return result
}

/** Returns a copy of [mappings] with adjacent ranges merged wherever possible. */
internal fun mergeAdjacentRanges(mappings: List<Mapping>): List<Mapping> {
  var index = 0
  val result = mutableListOf<Mapping>()

  while (index < mappings.size) {
    val mapping = mappings[index]
    val type = canonicalizeType(mapping.type)
    val mappedTo = mapping.mappedTo

    var unionWith: Mapping = mapping

        /*
         * Initialize mapping from lifecycle phase to bound mojos. The key set of this map denotes the phases the caller
         * is interested in, i.e. all phases up to and including the specified phase.
         */

        Map<String, Map<Integer, List<MojoExecution>>> mappings = new LinkedHashMap<>();

        for (String phase : lifecycle.getPhases()) {

      |
      """.trimMargin(),
    )

    val mappings = buffer.readCodePointMappings()
    assertEquals(
      mapOf(
        // Map to nothing.
        0x180c to "",
        // Case map.
        'A'.code to "a",
        // Case map.
        'ΐ'.code to "\u03B9\u0308\u0301",
      ),
      mappings.mappings,
    )
  }

 * permissive and permits the `_` character.
 *
 * [mapping table]: https://www.unicode.org/reports/tr46/#IDNA_Mapping_Table
 * [mapping step]: https://www.unicode.org/reports/tr46/#ProcessingStepMap
 */
class SimpleIdnaMappingTable internal constructor(
  internal val mappings: List<Mapping>,
) {
  /**

    }
  return buildIdnaMappingTableData(table)
}

/**
 * Generate a file containing the mapping table's string literals, like this:
 *
 * ```
 * internal val IDNA_MAPPING_TABLE: IdnaMappingTable = IdnaMappingTable(
 *   sections = "...",
 *   ranges = "...",
 *   mappings = "",
 * )
 * ```
 */
fun generateMappingTableFile(data: IdnaMappingTableData): FileSpec {

    val unassigned = readCodePointSet(base / "rfc3454.A.1.txt")
    val mapping =
      MappingListCodePointMapping(
        mutableMapOf<Int, String>()
          .apply {
            putAll(readCodePointMapping(base / "rfc3454.B.1.txt").mappings)
            putAll(readCodePointMapping(base / "rfc3454.B.2.txt").mappings)
          },
      )
    val prohibitSet =
      RangeListCodePointSet(
        ranges =

  }

  /**
   * Constructs a new bimap with the same mappings as the specified map. If the specified map is an
   * {@code EnumHashBiMap} or an {@link EnumBiMap}, the new bimap has the same key type as the input
   * bimap. Otherwise, the specified map must contain at least one mapping, in order to determine
   * the key type.
   *
   * @param map the map whose mappings are to be placed in this map

    }
  }

  // Replacement mappings.
  private final Map<Character, String> map;

  // The highest index we've seen so far.
  private int max = -1;

  /** Construct a new sparse array builder. */
  public CharEscaperBuilder() {
    this.map = new HashMap<>();
  }

  /** Add a new mapping from an index to an object to the escaping. */
  @CanIgnoreReturnValue

  @Test fun compareConstructedAndGeneratedCompactTables() {
    assertThat(IDNA_MAPPING_TABLE.sections).isEqualTo(compactTable.sections)
    assertThat(IDNA_MAPPING_TABLE.ranges).isEqualTo(compactTable.ranges)
    assertThat(IDNA_MAPPING_TABLE.mappings).isEqualTo(compactTable.mappings)
  }

  private fun String.map(): String {
    val buffer = Buffer()
    for (codePoint in codePoints()) {

{
  "fess_config.path_mapping" : {
    "aliases" : { },
    "mappings" : {
      "path_mapping" : {
        "properties" : {
          "createdBy" : {
            "type" : "keyword"
          },
          "createdTime" : {
            "type" : "long"
          },
          "processType" : {
            "type" : "keyword"
          },
          "regex" : {
            "type" : "keyword"
          },
          "replacement" : {