func (x xlMetaInlineData) entries() int {
	if len(x) == 0 || !x.versionOK() {
		return 0
	}
	sz, _, _ := msgp.ReadMapHeaderBytes(x.afterVersion())
	return int(sz)
}

// replace will add or replace a key/value pair.
func (x *xlMetaInlineData) replace(key string, value []byte) {
	in := x.afterVersion()
	sz, buf, _ := msgp.ReadMapHeaderBytes(in)
	keys := make([][]byte, 0, sz+1)
	vals := make([][]byte, 0, sz+1)

     * @param credentials The credentials.
     * @param value The value to replace.
     * @return The value with credentials replaced.
     */
    protected String replaceCredentials(final Credentials credentials, final String value) {
        if (StringUtil.isNotBlank(value)) {
            return value.replace(USERNAME, credentials.getUserPrincipal().getName()).replace(PASSWORD, credentials.getPassword());
        }

        public boolean remove(Object key, Object value) {
            throw uoe();
        }

        @Override
        public boolean replace(K key, V oldValue, V newValue) {
            throw uoe();
        }

        @Override
        public V replace(K key, V value) {
            throw uoe();
        }

        @Override

  ReaderInputStream(Reader reader, Charset charset, int bufferSize) {
    this(
        reader,
        charset
            .newEncoder()
            .onMalformedInput(CodingErrorAction.REPLACE)
            .onUnmappableCharacter(CodingErrorAction.REPLACE),
        bufferSize);
  }

  /**
   * Creates a new input stream that will encode the characters from {@code reader} into bytes using
   * the given character set encoder.
   *

            engine.createTemplate(template).make(bindings).writeTo(writer);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }

        return writer.toString().replace("\\r", "");
    }

  val req = Request.Builder().url(url).build()

  client.newCall(req).execute().use {
    println(url)
    println("""Content-Encoding: ${it.networkResponse?.header("Content-Encoding")}""")
    println("| ${it.body.string().replace("\n", "\n| ")}")
  }

      |data: +2
      |data: 10
      |
      |
      """.trimMargin().replace("\n", "\r"),
    )
    assertThat(callbacks.remove()).isEqualTo(Event(null, null, "YHOO\n+2\n10"))
  }

  @Test
  fun multilineCrLf() {
    consumeEvents(
      """
      |data: YHOO
      |data: +2
      |data: 10
      |
      |
      """.trimMargin().replace("\n", "\r\n"),
    )

    }

    public void setVersionNo(final Long version) {
        asDocMeta().version(version);
    }

    public String convert(final String url) {
        final String targetStr = getDuplicateHostName().replace(".", "\\.");
        return url.replaceFirst("://" + targetStr + "$", "://" + getRegularName())
                .replaceFirst("://" + targetStr + "([:/])", "://" + getRegularName() + "$1");
    }

    @Override

        return value.replaceAll("<%(?![@-])([\\s\\S]*?)%>", "&lt;%$1%&gt;")
                .replaceAll("<%=([\\s\\S]*?)%>", "&lt;%=$1%&gt;")
                .replace(TRY_STATEMENT, "<% try{ %>")
                .replace(CACHE_AND_SESSION_INVALIDATE_STATEMENT, "<% }catch(Exception e){session.invalidate();} %>");
    }

    /**
     * Encode the JSP content.
     * @param value The value.

import com.fasterxml.jackson.databind.node.ObjectNode;
import org.elasticsearch.gradle.internal.test.rest.transform.ReplaceByKey;
import org.gradle.api.tasks.Internal;

/**
 * A transformation to replace the value of a match. For example, change from "match":{"_type": "foo"} to "match":{"_type": "bar"}
 */
public class ReplaceValueInMatch extends ReplaceByKey {