is MappedRange.External -> {
          // Write the mapping.
          val mappingOffset: Int
          val mappedTo = range.mappedTo.utf8()
          val mappingIndex = mappingsBuffer.indexOf(mappedTo)
          if (mappingIndex == -1) {
            mappingOffset = mappingsBuffer.length
            mappingsBuffer.append(mappedTo)
          } else {
            mappingOffset = mappingIndex
          }

          // Write the range bytes.

        sourceCodePoint0.toInt(),
        sourceCodePoint1.toInt(),
        type,
        mappedTo.readByteString(),
      )
  }

  return SimpleIdnaMappingTable(result)
}

internal data class Mapping(
  val sourceCodePoint0: Int,
  val sourceCodePoint1: Int,
  val type: Int,
  val mappedTo: ByteString,
) {
  val section: Int
    get() = sourceCodePoint0 and 0x1fff80

 *    119 : Ignored.
 *    120 : Valid.
 *    121 : Disallowed
 *    122 : Mapped inline to the sequence: [b2].
 *    123 : Mapped inline to the sequence: [b2a].
 *    124 : Mapped inline to the sequence: [b2, b3].
 *    125 : Mapped inline to the sequence: [b2a, b3].
 *    126 : Mapped inline to the sequence: [b2, b3a].
 *    127 : Mapped inline to the sequence: [b2a, b3a].
 *
 * The range goes until the beginning of the next range.

/**
 * Represents a single character mapping rule that defines how input characters are mapped to output characters
 * for text analysis and search processing. This class is used in character mapping dictionaries to transform
 * text during indexing and search operations.
 *
 * <p>Each mapping item consists of one or more input character sequences that are mapped to a single output

    mapped = InetAddresses.forString(mappedStr);
    assertThat(mapped).isNotInstanceOf(Inet6Address.class);
    assertThat(mapped).isEqualTo(InetAddress.getByName("192.168.0.1"));

    mappedStr = "0:00:000:0000:0:ffff:1.2.3.4";
    assertTrue(InetAddresses.isMappedIPv4Address(mappedStr));
    mapped = InetAddresses.forString(mappedStr);
    assertThat(mapped).isNotInstanceOf(Inet6Address.class);

 *   <dd>{@code 00 00 00 00 00 00 00 00 00 00 00 00 c0 a8 00 01}
 *   <dt>An IPv6 "IPv4 mapped" address, {@code "::ffff:192.168.0.1"}.
 *   <dd>{@code 00 00 00 00 00 00 00 00 00 00 ff ff c0 a8 00 01}
 * </dl>
 *
 * <p>A few notes about IPv6 "IPv4 mapped" addresses and their observed use in Java.
 *
 * <p>"IPv4 mapped" addresses were originally a representation of IPv4 addresses for use on an IPv6

        assertEquals("2Domain Group", sambaHelper.getAccountId(createMockSID(2, "Domain Group")));

        // Test Alias SID (type 4, mapped to 2)
        assertEquals("2Local Group", sambaHelper.getAccountId(createMockSID(4, "Local Group")));

        // Test Well-Known Group SID (type 5, mapped to 1)
        assertEquals("1Everyone", sambaHelper.getAccountId(createMockSID(5, "Everyone")));
    }

    @Test

	return Map(unicode.ToLower, s)
}

// ToTitle treats s as UTF-8-encoded bytes and returns a copy with all the Unicode letters mapped to their title case.
func ToTitle(s []byte) []byte { return Map(unicode.ToTitle, s) }

// ToUpperSpecial treats s as UTF-8-encoded bytes and returns a copy with all the Unicode letters mapped to their
// upper case, giving priority to the special casing rules.
func ToUpperSpecial(c unicode.SpecialCase, s []byte) []byte {

     * combiner function to the corresponding values of the properties that are true.
     *
     * @param flags The map of boolean properties mapped to their values.
     * @param combiner The function to combine the values of the true properties.
     *
     * @return A provider of the reduced value. Non-present if no properties are true.
     */

   * long, long)} using the requested {@link MapMode}.
   *
   * <p>Files are mapped from offset 0 to {@code size}.
   *
   * <p>If the mode is {@link MapMode#READ_WRITE} and the file does not exist, it will be created
   * with the requested {@code size}. Thus this method is useful for creating memory mapped files
   * which do not yet exist.
   *
   * <p>This only works for files ≤ {@link Integer#MAX_VALUE} bytes.