if (map.isEmpty()) {
      return EMPTY_REPLACEMENT_ARRAY;
    }
    char max = Collections.max(map.keySet());
    char[][] replacements = new char[max + 1][];
    for (Character c : map.keySet()) {
      replacements[c] = map.get(c).toCharArray();
    }
    return replacements;
  }

  // Immutable empty array for when there are no replacements.

  /**
   * Creates a new ArrayBasedUnicodeEscaper instance with the given replacement map and specified
   * safe range. If {@code safeMax < safeMin} then no code points are considered safe. This
   * initializer is useful when explicit instances of ArrayBasedEscaperMap are used to allow the
   * sharing of large replacement mappings.
   *
   * <p>If a code point has no mapped replacement then it is checked against the safe range. If it

  /**
   * Creates a new ArrayBasedCharEscaper instance with the given replacement map and specified safe
   * range. If {@code safeMax < safeMin} then no characters are considered safe. This initializer is
   * useful when explicit instances of ArrayBasedEscaperMap are used to allow the sharing of large
   * replacement mappings.
   *
   * <p>If a character has no mapped replacement then it is checked against the safe range. If it

  /**
   * Simple decorator that turns an array of replacement char[]s into a CharEscaper, this results in
   * a very fast escape method.
   */
  private static class CharArrayDecorator extends CharEscaper {
    private final char[] @Nullable [] replacements;
    private final int replaceLength;

    CharArrayDecorator(char[] @Nullable [] replacements) {
      this.replacements = replacements;
      this.replaceLength = replacements.length;

        this.regex = value;
    }

    public String getReplacement() {
        checkSpecifiedProperty("replacement");
        return convertEmptyToNull(replacement);
    }

    public void setReplacement(String value) {
        registerModifiedProperty("replacement");
        this.replacement = value;
    }

    public Integer getSortOrder() {
        checkSpecifiedProperty("sortOrder");

     */
    public void manageArtifact(Artifact artifact, Artifact replacement) {
        String msg = indent + artifact;
        msg += " (";
        if (replacement.getVersion() != null) {
            msg += "applying version: " + replacement.getVersion() + ";";
        }
        if (replacement.getScope() != null) {
            msg += "applying artifactScope: " + replacement.getScope();
        }
        msg += ")";

    public void setReplacement_Equal(String replacement) {
        setReplacement_Term(replacement, null);
    }

    public void setReplacement_Equal(String replacement, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setReplacement_Term(replacement, opLambda);
    }

    public void setReplacement_Term(String replacement) {
        setReplacement_Term(replacement, null);
    }

     * @throws NullPointerException if {@code replacement} is null
     */
    @CanIgnoreReturnValue
    public Builder addEscape(char c, String replacement) {
      checkNotNull(replacement);
      // This can replace an existing character (the builder is re-usable).
      replacementMap.put(c, replacement);
      return this;
    }

    /** Returns a new escaper based on the current state of the builder. */
    public Escaper build() {

      if (matches(c)) {
        if (c == replacement && (i == len - 1 || !matches(sequence.charAt(i + 1)))) {
          // a no-op replacement
          i++;
        } else {
          StringBuilder builder = new StringBuilder(len).append(sequence, 0, i).append(replacement);
          return finishCollapseFrom(sequence, i + 1, len, replacement, builder, true);
        }
      }
    }

        <constraint name="__context__" within="" contains="" />
        <constraint name="src" within="" contains="" />