编码

1. 前言

UTF-8 编码是交换 Unicode（通用编码字符集）最合适的编码。因此，对于新协议和格式，以及在新环境中部署的现有格式，本规范要求（并定义）使用 UTF-8 编码。

其他（旧）编码在过去某种程度上已经被定义。然而，用户代理并未始终以相同的方式实现它们，也未始终使用相同的标签，并且在处理编码的未定义和以前的专有区域时经常有所不同。本规范解决了这些差距，使得新的用户代理无需逆向工程编码实现，而现有的用户代理可以趋于一致。

特别是，本规范定义了所有这些编码、从字节到标量值及其返回的算法、它们的规范名称和识别标签。本规范还定义了一个 API，用于向 JavaScript 暴露部分编码算法。

用户代理在标签方面也显著偏离了 IANA 字符集注册表中列出的内容。为了阻止进一步传播旧编码，本规范对上述细节进行了详尽的定义，因此不需要注册表。特别是，本规范不提供扩展编码任何方面的机制。

2. 安全背景

当生产者和消费者对使用的编码或对给定编码的实现方式未达成一致时，会出现一系列编码安全问题。例如，2011 年报告了一次攻击，其中 Shift_JIS 的前导字节 0x82 被用来“掩盖” JSON 资源中某字段的尾随字节 0x22，该字段由攻击者控制。生产者未发现问题，尽管这是一个非法字节组合。消费者将其解码为单个 U+FFFD（�），因此改变了整体解释，因为 U+0022（"）是一个重要的分隔符。现在，使用多个字节表示标量值的编码的解码器要求，在非法字节组合的情况下，范围 U+0000 到 U+007F（含）的标量值不能被“掩盖”。对于上述序列，输出将是 U+FFFD U+0022。（作为一个不幸的例外，gb18030 解码器将在 队列末尾最多“掩盖”一个这样的字节。）

对于将任何 ASCII 字节映射到非 ASCII 代码点的编码（当没有前导字节存在时），这是一个更大的问题。这些是“ASCII 不兼容”编码，除了由于已部署内容而必须支持的 ISO-2022-JP 和 UTF-16BE/LE，它们不被支持。（正在 调查是否可以将更多此类编码的标签映射到 替代编码，而不是未知编码回退。）一个示例攻击是向资源注入精心设计的内容，然后鼓励用户覆盖编码，从而导致例如脚本执行。

HTML 和 HTML 表单功能中使用的 URL 编码器在使用无法表示所有标量值的编码时也可能导致轻微的信息丢失。例如，当资源使用 windows-1252 编码时，服务器将无法区分最终用户在表单中输入“💩”和“💩”。

当仅使用 UTF-8 时，这里概述的问题将消失，这也是现在所有事物必须使用 UTF-8 编码的众多原因之一。

另请参阅 浏览器 UI章节。

3. 术语

本规范依赖于 Infra 标准。[INFRA]

十六进制数字以 "0x" 为前缀。

在公式中，所有数字均为整数，加法用 "+" 表示，减法用 "−" 表示，乘法用 "×" 表示，整数除法用 "/" 表示（返回商），取模用 "%" 表示（返回整数除法的余数），逻辑左移用 "<<" 表示，逻辑右移用 ">>" 表示，按位与用 "&" 表示，按位或用 "|" 表示。

对于逻辑右移，操作数必须至少具有 21 位精度。

I/O 队列 是一种 列表，其 项具有特定类型（例如 字节或 标量值）。队列末尾 是一种特殊的 项，可以存在于任何类型的 I/O 队列中，表示队列中没有更多的 项。

如果向 I/O 队列 « 0x92 0xA9, 队列结尾 » 插入字节 « 0xF0, 0x9F »， 则结果为 I/O 队列 « 0xF0, 0x9F, 0x92 0xA9, 队列结尾 »。下一个要读取的项是 0xF0。

Infra 标准预计将定义一些关于类型转换的基础设施。详见 whatwg/infra issue #319。[INFRA]

I/O 队列被定义为列表，而非队列，因为它们包含 恢复操作。然而，这一恢复操作仅是本规范算法的内部细节，不应被其他标准使用。实现可以采用其他方式来实现此类算法，细节见实现注意事项。

4. 编码

编码定义了从标量值序列到字节序列（及其反向）的映射。每个编码都有一个名称，以及一个或多个标签。

本规范定义了三个与 Unicode 标准中定义的编码方案同名的编码：UTF-8、UTF-16LE和UTF-16BE。这些编码与编码方案的不同之处在于字节顺序标记（也称为 BOM）的处理不是编码本身的一部分，而是本规范中包装算法的一部分，而字节顺序标记处理是 Unicode 标准中编码方案定义的一部分。UTF-8与UTF-8 解码算法一起使用时，与同名的编码方案匹配。本规范不提供与UTF-16LE和UTF-16BE结合以匹配类似名称的编码方案的包装算法。[UNICODE]

4.1. 编码器和解码器

每个编码都有一个关联的解码器，并且大多数都有一个关联的编码器。解码器和编码器的实例具有一个处理器算法，并可能具有状态。处理器算法接受一个输入I/O 队列和一个项，并返回完成、一个或多个项、错误（可选地带有一个代码点），或继续。

替代和UTF-16BE/LE编码没有编码器。

错误模式在以下使用中，对于解码器是"replacement"或"fatal"，对于编码器是"fatal"或"html"。

XML 处理器会将错误模式设置为"fatal"。[XML]

由于 HTML 表单需要一个非终止的旧编码器，"html"作为错误模式存在。"html"错误模式会导致发出一个无法与合法输入区分的序列，因此可能导致静默的数据丢失。强烈建议开发人员使用UTF-8编码以防止这种情况发生。[HTML]

4.2. 名称和标签

下表列出了所有编码及其标签，用户代理必须支持这些编码和标签。用户代理不得支持任何其他编码或标签。

对于每个编码，对其ASCII 小写化的名称会生成其一个标签。

作者必须使用UTF-8编码，并且必须使用其（ASCII 大小写不敏感）"utf-8"标签来标识它。

新协议和格式，以及在新环境中部署的现有格式，必须仅使用UTF-8编码。如果这些协议和格式需要公开编码的名称或标签，它们必须将其公开为"utf-8"。

这是一个比Unicode 技术标准第 22 号第 1.4 节规定的更基本和更严格的将标签映射到编码的算法，因为这是与已部署内容兼容所必需的。

所有编码及其标签也可以作为非规范性的encodings.json资源获取。

支持的编码集主要基于本标准开发开始时主要浏览器引擎支持的编码集的交集，同时移除了那些很少被合法使用但可能被用于攻击的编码。从现有 Web 内容的使用水平的零散证据来看，某些编码的包含是值得怀疑的。也就是说，虽然这些编码被浏览器广泛支持，但尚不清楚它们是否被 Web 内容广泛使用。然而，并未积极移除那些被浏览器广泛支持或属于 ISO 8859 系列的单字节编码。特别是，IBM866、macintosh、x-mac-cyrillic、ISO-8859-3、ISO-8859-10、ISO-8859-14和ISO-8859-16的必要性对于支持现有内容来说是值得怀疑的，但目前没有移除这些编码的计划。

4.3. 输出编码

要从编码encoding获取输出编码，请执行以下步骤：

1. 如果encoding是替代或UTF-16BE/LE，则返回UTF-8。

2. 返回encoding。

获取输出编码算法对于 URL 解析和 HTML 表单提交非常有用，因为两者都需要完全符合此算法。

5. 索引

大多数旧的编码都使用索引。一个索引是一个有序的条目列表，每个条目由一个指针和一个对应的代码点组成。在一个索引中，指针是唯一的，而代码点可以重复。

一个高效的实现可能为每个编码提供两个索引。一个针对其解码器优化，另一个针对其编码器优化。

要在一个索引中找到指针及其对应的代码点，请执行以下步骤：令lines为将资源内容按 U+000A LF 分割的结果。然后移除lines中为空字符串或以 U+0023 (#) 开头的每一项。然后通过将lines中的每一项按 U+0009 TAB 分割来找到指针及其对应的代码点。第一个子项是指针（作为十进制数），第二个是对应的代码点（作为十六进制数）。其他子项不相关。

为了表示变化，一个索引包括一个标识符和一个日期。如果标识符发生变化，则索引也发生变化。

索引代码点是index中pointer对应的代码点，如果pointer不在index中，则为 null。

索引指针是index中codePoint对应的第一个指针，如果codePoint不在index中，则为 null。

以下是本规范定义的索引，不包括单字节索引，后者有自己的表格：

所有索引也可以作为非规范性的indexes.json资源获取。（GB18030 范围索引在此处采用稍有不同的格式，以便表示范围。）

6. 为标准提供的挂钩

6.1. 为标准提供的旧版挂钩

7. API

本节使用 Web IDL 的术语。浏览器用户代理必须支持此 API。JavaScript 实现应支持此 API。鼓励其他用户代理或编程语言使用适合其需求的 API，可能不是这一个。[WEBIDL]

function encodeArrayOfStrings(strings) {
          var encoder, encoded, len, bytes, view, offset;
        
          encoder = new TextEncoder();
          encoded = [];
        
          len = Uint32Array.BYTES_PER_ELEMENT;
          for (var i = 0; i < strings.length; i++) {
            len += Uint32Array.BYTES_PER_ELEMENT;
            encoded[i] = encoder.encode(strings[i]);
            len += encoded[i].byteLength;
          }
        
          bytes = new Uint8Array(len);
          view = new DataView(bytes.buffer);
          offset = 0;
        
          view.setUint32(offset, strings.length);
          offset += Uint32Array.BYTES_PER_ELEMENT;
          for (var i = 0; i < encoded.length; i += 1) {
            len = encoded[i].byteLength;
            view.setUint32(offset, len);
            offset += Uint32Array.BYTES_PER_ELEMENT;
            bytes.set(encoded[i], offset);
            offset += len;
          }
          return bytes.buffer;
        }

function decodeArrayOfStrings(buffer, encoding) {
          var decoder, view, offset, num_strings, strings, len;
        
          decoder = new TextDecoder(encoding);
          view = new DataView(buffer);
          offset = 0;
          strings = [];
        
          num_strings = view.getUint32(offset);
          offset += Uint32Array.BYTES_PER_ELEMENT;
          for (var i = 0; i < num_strings; i++) {
            len = view.getUint32(offset);
            offset += Uint32Array.BYTES_PER_ELEMENT;
            strings[i] = decoder.decode(
              new DataView(view.buffer, offset, len));
            offset += len;
          }
          return strings;
        }

7.1. 接口混入 TextDecoderCommon

interface mixin TextDecoderCommon {
          readonly attribute DOMString encoding;
          readonly attribute boolean fatal;
          readonly attribute boolean ignoreBOM;
        };
        

TextDecoderCommon 接口混入定义了 TextDecoder 和 TextDecoderStream 对象共享的通用 getter。这些对象有关联的：

编码

一个编码。

解码器

一个解码器实例。

I/O 队列

一个字节的I/O 队列。

忽略 BOM

一个布尔值，初始为 false。

已见 BOM

一个布尔值，初始为 false。

错误模式

一个错误模式，初始为 "replacement"。

7.2. 接口 TextDecoder

dictionary TextDecoderOptions {
  boolean fatal = false;
  boolean ignoreBOM = false;
};

dictionary TextDecodeOptions {
  boolean stream = false;
};

[Exposed=*]
interface TextDecoder {
  constructor(optional DOMString label = "utf-8", optional TextDecoderOptions options = {});

  USVString decode(optional AllowSharedBufferSource input, optional TextDecodeOptions options = {});
};
TextDecoder includes TextDecoderCommon;

一个 TextDecoder 对象拥有一个关联的不刷新标志（do not flush flag），它是一个布尔值， 初始为 false。

decoder = new TextDecoder([label = "utf-8" [, options]])

返回一个新的 TextDecoder 对象。

如果 label 不是一个有效的标签，或者是用于 replacement 的标签，则抛出一个 RangeError。

decoder . encoding

返回编码的名称，小写形式。

decoder . fatal

如果错误模式是 "fatal"，则返回 true；否则返回 false。

decoder . ignoreBOM

返回忽略 BOM 标志的值。

decoder . decode([input [, options]])

返回运行编码的解码器的结果。 该方法可以被多次调用，并将 options 的 stream 属性设置为 true，然后最后一次调用时不再设置 options 的 stream（或设为 false），以处理分段的输入。如果最后一次调用（`stream` 未设置或为 false）时没有 input，最清晰的做法是省略这两个参数。

var string = "", decoder = new TextDecoder(encoding), buffer;
while(buffer = next_chunk()) {
  string += decoder.decode(buffer, {stream:true});
}
string += decoder.decode(); // 队列末尾

如果错误模式是 "fatal" 且编码的解码器返回错误， 则抛出一个 TypeError。

7.3. 接口混入 TextEncoderCommon

interface mixin TextEncoderCommon {
  readonly attribute DOMString encoding;
};

TextEncoderCommon 接口混入定义了 TextEncoder 和 TextEncoderStream 对象共享的通用 getter。

7.4. 接口 TextEncoder

dictionary TextEncoderEncodeIntoResult {
  unsigned long long read;
  unsigned long long written;
};

[Exposed=*]
interface TextEncoder {
  constructor();

  [NewObject] Uint8Array encode(optional USVString input = "");
  TextEncoderEncodeIntoResult encodeInto(USVString source, [AllowShared] Uint8Array destination);
};
TextEncoder includes TextEncoderCommon;

一个 TextEncoder 对象不提供 label 参数，因为它只支持 UTF-8。它也不提供 stream 选项，因为没有编码器需要缓冲标量值。

encoder = new TextEncoder()

返回一个新的 TextEncoder 对象。

encoder . encoding

返回 "utf-8"。

encoder . encode([input = ""])

返回运行 UTF-8 编码器的结果。

encoder . encodeInto(source, destination)

在 source 上运行UTF-8 编码器，将该操作的结果存入 destination，并以一个对象的形式返回进度，其中 read 是 source 中已转换的代码单元数，而 written 是 destination 中已修改的字节数。

function convertString(buffer, input, callback) {
  let bufferSize = 256,
      bufferStart = malloc(buffer, bufferSize),
      writeOffset = 0,
      readOffset = 0;
  while (true) {
    const view = new Uint8Array(buffer, bufferStart + writeOffset, bufferSize - writeOffset),
          {read, written} = cachedEncoder.encodeInto(input.substring(readOffset), view);
    readOffset += read;
    writeOffset += written;
    if (readOffset === input.length) {
      callback(bufferStart, writeOffset);
      free(buffer, bufferStart);
      return;
    }
    bufferSize *= 2;
    bufferStart = realloc(buffer, bufferStart, bufferSize);
  }
}

7.5. 接口 TextDecoderStream

[Exposed=*]
interface TextDecoderStream {
  constructor(optional DOMString label = "utf-8", optional TextDecoderOptions options = {});
};
TextDecoderStream includes TextDecoderCommon;
TextDecoderStream includes GenericTransformStream;

decoder = new TextDecoderStream([label = "utf-8" [, options]])

返回一个新的 TextDecoderStream 对象。

如果 label 不是一个有效的标签，或者是用于replacement的标签，则抛出一个 RangeError。

decoder . encoding

返回编码的名称，小写形式。

decoder . fatal

如果错误模式是 "fatal"，则返回 true，否则返回 false。

decoder . ignoreBOM

返回忽略 BOM 标志的值。

decoder . readable

返回一个可读流，其块是通过在写入到 writable的块上运行编码的解码器而产生的字符串。

decoder . writable

返回一个可写流，它接受 AllowSharedBufferSource 块，并通过编码的解码器运行它们，然后才使它们对readable可用。

通常这将通过在一个 ReadableStream 源上使用 pipeThrough() 方法来完成。

var decoder = new TextDecoderStream(encoding);
byteReadable
  .pipeThrough(decoder)
  .pipeTo(textWritable);

如果错误模式是 "fatal" 并且编码的解码器返回错误，那么 readable 和 writable 都将因一个 TypeError 而出错。

7.6. 接口 TextEncoderStream

[Exposed=*]
interface TextEncoderStream {
  constructor();
};
TextEncoderStream includes TextEncoderCommon;
TextEncoderStream includes GenericTransformStream;

一个 TextEncoderStream 对象拥有一个关联的：

编码器（encoder）

一个编码器实例。

前导代理项（leading surrogate）

null 或一个前导代理项，初始为 null。

一个 TextEncoderStream 对象不提供 label 参数，因为它只支持 UTF-8。

encoder = new TextEncoderStream()

返回一个新的 TextEncoderStream 对象。

encoder . encoding

返回 "utf-8"。

encoder . readable

返回一个可读流，其块是通过在写入到 writable 的块上运行 UTF-8 的编码器而产生的 Uint8Array。

encoder . writable

返回一个可写流，它接受字符串块，并通过 UTF-8 的编码器运行它们，然后才使它们对 readable 可用。

通常这将通过在一个 ReadableStream 源上使用 pipeThrough() 方法来完成。

textReadable
  .pipeThrough(new TextEncoderStream())
  .pipeTo(byteWritable);

8. 编码

8.1. UTF-8

8.1.1. UTF-8 解码器

字节顺序标记（BOM）的优先级高于标签，因为在已部署的内容中发现它更为准确。因此，它不属于 UTF-8 解码器算法的一部分，而是属于 decode 和 UTF-8 decode 算法。

UTF-8 的解码器拥有一个关联的：

UTF-8 码点

已见 UTF-8 字节数

所需 UTF-8 字节数

均为数字，初始为 0。

UTF-8 下界

一个字节，初始为 0x80。

UTF-8 上界

一个字节，初始为 0xBF。

UTF-8 解码器的处理程序，给定 ioQueue 和 byte，运行以下步骤：

1. 如果 byte 是队列末尾且所需 UTF-8 字节数不为 0，则将 所需 UTF-8 字节数设为 0 并返回错误。

2. 如果 byte 是队列末尾，则返回完成。

3. 如果所需 UTF-8 字节数为 0，则根据 byte：

   0x00 到 0x7F

   返回一个码点，其值为 byte。

   0xC2 到 0xDF

   1. 将所需 UTF-8 字节数设为 1。

   2. 将UTF-8 码点设为 byte & 0x1F。

      byte 的最低五位。

   0xE0 到 0xEF

   1. 如果 byte 是 0xE0，则将UTF-8 下界设为 0xA0。

   2. 如果 byte 是 0xED，则将UTF-8 上界设为 0x9F。

   3. 将所需 UTF-8 字节数设为 2。

   4. 将UTF-8 码点设为 byte & 0xF。

      byte 的最低四位。

   0xF0 到 0xF4

   1. 如果 byte 是 0xF0，则将UTF-8 下界设为 0x90。

   2. 如果 byte 是 0xF4，则将UTF-8 上界设为 0x8F。

   3. 将所需 UTF-8 字节数设为 3。

   4. 将UTF-8 码点设为 byte & 0x7。

      byte 的最低三位。

   其他情况

   返回错误。

   返回继续。

4. 如果 byte 不在UTF-8 下界到 UTF-8 上界（含）的范围内：

   1. 将UTF-8 码点、 所需 UTF-8 字节数和已见 UTF-8 字节数设为 0， 将UTF-8 下界设为 0x80，并将 UTF-8 上界设为 0xBF。

   2. 将 byte 恢复到 ioQueue。

   3. 返回错误。

5. 将UTF-8 下界设为 0x80，并将 UTF-8 上界设为 0xBF。

6. 将UTF-8 码点设为 (UTF-8 码点 << 6) | (byte & 0x3F)

   将UTF-8 码点的现有位左移六位，并将新空出的最低六位设置为 byte 的最低六位。

7. 将已见 UTF-8 字节数增加一。

8. 如果已见 UTF-8 字节数不等于所需 UTF-8 字节数，则返回 继续。

9. 令 codePoint 为UTF-8 码点。

10. 将UTF-8 码点、 所需 UTF-8 字节数和已见 UTF-8 字节数设为 0。

11. 返回一个码点，其值为 codePoint。

上述UTF-8 解码器中的约束与 Unicode 标准中的“使用 U+FFFD 的最佳实践”相匹配。根据编码标准，不允许有其他行为（实现相同结果的其他算法是允许的，甚至是被鼓励的）。 [UNICODE]

8.1.2. UTF-8 编码器

UTF-8 的编码器的处理程序，给定 unused 和 codePoint，执行以下步骤：

1. 如果 codePoint 是队列末尾，则返回完成。

2. 如果 codePoint 是一个ASCII 码点，则返回一个值为 codePoint 的字节。

3. 根据 codePoint 所在的范围设置 count 和 offset：

   U+0080 到 U+07FF（含）

   1 和 0xC0

   U+0800 到 U+FFFF（含）

   2 和 0xE0

   U+10000 到 U+10FFFF（含）

   3 和 0xF0

4. 令 bytes 为一个字节序列，其第一个字节是 (codePoint >> (6 × count)) + offset。

5. 当 count 大于 0 时：

   1. 将 temp 设置为 codePoint >> (6 × (count − 1))。

   2. 向 bytes 追加 0x80 | (temp & 0x3F)。

   3. 将 count 减一。

6. 按顺序返回字节序列 bytes。

该算法的结果与 Unicode 标准中描述的算法相同。 此处包含它是为了完整性。[UNICODE]

9. 旧式单字节编码

一个编码，其中每个字节要么是一个单独的码点，要么什么都不是，这就是单字节编码。 单字节编码共享 解码器和编码器。单字节索引，由单字节解码器和 单字节编码器引用，由下表定义，并取决于所使用的单字节编码。除了两种 单字节编码外，所有单字节编码都有一个唯一的索引。

ISO-8859-8 和ISO-8859-8-I是 不同的编码名称，因为 ISO-8859-8 会影响布局方向。尽管 历史上ISO-8859-6和 “ISO-8859-6-I”也可能存在这种情况，但现在已不再如此。

9.1. 单字节解码器

单字节编码的解码器的处理程序，给定 unused 和 byte，执行以下步骤：

1. 如果 byte 是队列末尾，则返回完成。

2. 如果 byte 是一个ASCII 字节，则返回一个值为 byte 的码点。

3. 令 codePoint 为单字节索引中 byte − 0x80 对应的索引码点。

4. 如果 codePoint 为 null，则返回错误。

5. 返回一个值为 codePoint 的码点。

9.2. 单字节编码器

单字节编码的编码器的处理程序，给定 unused 和 codePoint，执行以下步骤：

1. 如果 codePoint 是队列末尾，则返回完成。

2. 如果 codePoint 是一个ASCII 码点，则返回一个值为 codePoint 的字节。

3. 令 pointer 为单字节索引中 codePoint 对应的索引指针。

4. 如果 pointer 为 null，则返回带 codePoint 的错误。

5. 返回一个值为 pointer + 0x80 的字节。

10. 旧式多字节简体中文编码

10.1. GBK

10.1.1. GBK 解码器

GBK 的解码器是 gb18030 的解码器。

10.1.2. GBK 编码器

GBK 的编码器是 gb18030 的编码器，并将其 is GBK 标志设置为 true。

不将 GBK 与 gb18030 完全别名化是一种保守的做法，旨在减少破坏使用 GBK 编码器生成的旧式服务器和其他内容消费者的可能性。

10.2. gb18030

10.2.1. gb18030 解码器

gb18030 的解码器拥有一个关联的：

gb18030 第一个字节

gb18030 第二个字节

gb18030 第三个字节

均为字节，初始值为 0x00。

gb18030 的解码器的处理程序，给定 ioQueue 和 byte，执行以下步骤：

1. 如果 byte 是队列末尾，并且gb18030 第一个字节、gb18030 第二个字节和 gb18030 第三个字节均为 0x00，则返回完成。

2. 如果 byte 是队列末尾，并且gb18030 第一个字节、gb18030 第二个字节或 gb18030 第三个字节不为 0x00，则将gb18030 第一个字节、gb18030 第二个字节和 gb18030 第三个字节设为 0x00，并返回错误。

3. 如果gb18030 第三个字节不为 0x00：

   1. 如果 byte 不在 0x30 到 0x39（含）的范围内：

      1. 将 « gb18030 第二个字节, gb18030 第三个字节, byte » 恢复到 ioQueue。

      2. 将gb18030 第一个字节、gb18030 第二个字节和gb18030 第三个字节设为 0x00。

      3. 返回错误。

   2. 令 codePoint 为 ((gb18030 第一个字节 − 0x81) × (10 × 126 × 10)) + ((gb18030 第二个字节 − 0x30) × (10 × 126)) + ((gb18030 第三个字节 − 0x81) × 10) + byte − 0x30 对应的gb18030 范围索引码点。

   3. 将gb18030 第一个字节、gb18030 第二个字节和gb18030 第三个字节设为 0x00。

   4. 如果 codePoint 为 null，则返回错误。

   5. 返回一个值为 codePoint 的码点。

4. 如果gb18030 第二个字节不为 0x00：

   1. 如果 byte 在 0x81 到 0xFE（含）的范围内，则将gb18030 第三个字节设为 byte 并返回继续。

   2. 将 « gb18030 第二个字节, byte » 恢复到 ioQueue，将 gb18030 第一个字节和gb18030 第二个字节设为 0x00，并返回错误。

5. 如果gb18030 第一个字节不为 0x00：

   1. 如果 byte 在 0x30 到 0x39（含）的范围内，则将gb18030 第二个字节设为 byte 并返回继续。

   2. 令 leading 为gb18030 第一个字节。

   3. 将gb18030 第一个字节设为 0x00。

   4. 令 pointer 为 null。

   5. 如果 byte 小于 0x7F，则令 offset 为 0x40；否则为 0x41。

   6. 如果 byte 在 0x40 到 0x7E（含）或 0x80 到 0xFE（含）的范围内， 则将 pointer 设为 (leading − 0x81) × 190 + (byte − offset)。

   7. 如果 pointer 为 null，则令 codePoint 为 null；否则为gb18030 索引中 pointer 对应的 索引码点。

   8. 如果 codePoint 不为 null，则返回一个值为 codePoint 的码点。

   9. 如果 byte 是一个ASCII 字节，则将 byte 恢复到 ioQueue。

   10. 返回错误。

6. 如果 byte 是一个ASCII 字节，则返回一个值为 byte 的码点。

7. 如果 byte 是 0x80，则返回码点 U+20AC (€)。

8. 如果 byte 在 0x81 到 0xFE（含）的范围内，则将gb18030 第一个字节设为 byte 并返回继续。

9. 返回错误。

10.2.2. gb18030 编码器

gb18030 的编码器有一个关联的 is GBK 标志，它是一个布尔值， 初始为 false。

gb18030 的编码器的处理程序，给定 unused 和 codePoint，执行以下步骤：

1. 如果 codePoint 是队列末尾，则返回完成。

2. 如果 codePoint 是一个ASCII 码点，则返回一个值为 codePoint 的字节。

3. 如果 codePoint 是 U+E5E5，则返回带 codePoint 的错误。

   gb18030 索引将 0xA3 0xA0 映射到 U+3000 表意空格，而不是 U+E5E5， 以兼容已部署的内容。因此它不能往返。

4. 如果is GBK为 true 且 codePoint 是 U+20AC (€)，则返回字节 0x80。

5. 如果下表中有某行的第一列是 codePoint，则返回该行第二列中列出的两个字节：

   码点	字节
   U+E78D	0xA6 0xD9
   U+E78E	0xA6 0xDA
   U+E78F	0xA6 0xDB
   U+E790	0xA6 0xDC
   U+E791	0xA6 0xDD
   U+E792	0xA6 0xDE
   U+E793	0xA6 0xDF
   U+E794	0xA6 0xEC
   U+E795	0xA6 0xED
   U+E796	0xA6 0xF3
   U+E81E	0xFE 0x59
   U+E826	0xFE 0x61
   U+E82B	0xFE 0x66
   U+E82C	0xFE 0x67
   U+E832	0xFE 0x6D
   U+E843	0xFE 0x7E
   U+E854	0xFE 0x90
   U+E864	0xFE 0xA0

   这个不对称的编码器表保留了与 GB18030-2005 标准的兼容性。另请参见gb18030 范围索引处的解释。

6. 令 pointer 为gb18030 索引中 codePoint 对应的索引指针。

7. 如果 pointer 不为 null：

   1. 令 leading 为 pointer / 190 + 0x81。

   2. 令 trailing 为 pointer % 190。

   3. 如果 trailing 小于 0x3F，则令 offset 为 0x40， 否则为 0x41。

   4. 返回两个字节，其值分别为 leading 和 trailing + offset。

8. 如果is GBK为 true，则返回带 codePoint 的错误。

9. 将 pointer 设为 codePoint 对应的gb18030 范围索引指针。

10. 令 byte1 为 pointer / (10 × 126 × 10)。

11. 将 pointer 设为 pointer % (10 × 126 × 10)。

12. 令 byte2 为 pointer / (10 × 126)。

13. 将 pointer 设为 pointer % (10 × 126)。

14. 令 byte3 为 pointer / 10。

15. 令 byte4 为 pointer % 10。

16. 返回四个字节，其值分别为 byte1 + 0x81、 byte2 + 0x30、byte3 + 0x81、 byte4 + 0x30。

11. 旧式多字节繁体中文编码

11.1. Big5

11.1.1. Big5 解码器

Big5 的解码器有一个关联的 Big5 前导字节，它是一个字节，初始值为 0x00。

Big5 的解码器的处理程序，给定 ioQueue 和 byte，执行以下步骤：

1. 如果 byte 是队列末尾且Big5 前导字节不为 0x00，则将 Big5 前导字节设为 0x00 并返回错误。

2. 如果 byte 是队列末尾且Big5 前导字节为 0x00，则返回 完成。

3. 如果Big5 前导字节不为 0x00：

   1. 令 leading 为Big5 前导字节。

   2. 将Big5 前导字节设为 0x00。

   3. 令 pointer 为 null。

   4. 如果 byte 小于 0x7F，则令 offset 为 0x40；否则为 0x62。

   5. 如果 byte 在 0x40 到 0x7E（含）或 0xA1 到 0xFE（含）的范围内， 则将 pointer 设为 (leading − 0x81) × 157 + (byte − offset)。

   6. 如果下表中存在第一列为 pointer 的行，则返回其第二列中列出的两个码点（第三列无关）：

      指针	码点	备注
      1133	U+00CA U+0304	Ê̄ (带扬抑符和长音符的拉丁大写字母 E)
      1135	U+00CA U+030C	Ê̌ (带扬抑符和抑扬符的拉丁大写字母 E)
      1164	U+00EA U+0304	ê̄ (带扬抑符和长音符的拉丁小写字母 e)
      1166	U+00EA U+030C	ê̌ (带扬抑符和抑扬符的拉丁小写字母 e)

      由于索引仅限于 单个码点，因此对这些指针使用此表。

   7. 如果 pointer 为 null，则令 codePoint 为 null；否则为Big5 索引中 pointer 对应的 索引码点。

   8. 如果 codePoint 不为 null，则返回一个值为 codePoint 的码点。

   9. 如果 byte 是一个ASCII 字节，则将 byte 恢复到 ioQueue。

   10. 返回错误。

4. 如果 byte 是一个ASCII 字节，则返回一个值为 byte 的码点。

5. 如果 byte 在 0x81 到 0xFE（含）的范围内，则将 Big5 前导字节设为 byte 并返回继续。

6. 返回错误。

11.1.2. Big5 编码器

Big5 的编码器的处理程序，给定 unused 和 codePoint，执行以下步骤：

1. 如果 codePoint 是队列末尾，则返回完成。

2. 如果 codePoint 是一个ASCII 码点，则返回一个值为 codePoint 的字节。

3. 令 pointer 为 codePoint 对应的Big5 索引指针。

4. 如果 pointer 为 null，则返回带 codePoint 的错误。

5. 令 leading 为 pointer / 157 + 0x81。

6. 令 trailing 为 pointer % 157。

7. 如果 trailing 小于 0x3F，则令 offset 为 0x40， 否则为 0x62。

8. 返回两个字节，其值分别为 leading 和 trailing + offset。

12. 旧式多字节日文编码

12.1. EUC-JP

12.1.1. EUC-JP 解码器

EUC-JP 的解码器有一个关联的：

EUC-JP jis0212

一个布尔值，初始为 false。

EUC-JP 前导字节

一个字节，初始为 0x00。

EUC-JP 的解码器的处理程序，给定 ioQueue 和 byte，执行以下步骤：

1. 如果 byte 是队列末尾且EUC-JP 前导字节不为 0x00，则将 EUC-JP 前导字节设为 0x00 并返回错误。

2. 如果 byte 是队列末尾且EUC-JP 前导字节为 0x00，则返回 完成。

3. 如果EUC-JP 前导字节为 0x8E 且 byte 在 0xA1 到 0xDF（含）的范围内，则将EUC-JP 前导字节设为 0x00 并返回一个值为 0xFF61 − 0xA1 + byte 的码点。

4. 如果EUC-JP 前导字节为 0x8F 且 byte 在 0xA1 到 0xFE（含）的范围内，则将EUC-JP jis0212 设为 true，将EUC-JP 前导字节设为 byte， 并返回继续。

5. 如果EUC-JP 前导字节不为 0x00：

   1. 令 leading 为EUC-JP 前导字节。

   2. 将EUC-JP 前导字节设为 0x00。

   3. 令 codePoint 为 null。

   4. 如果 leading 和 byte 都在 0xA1 到 0xFE（含）的范围内，则 如果EUC-JP jis0212为 false，则将 codePoint 设为jis0208 索引中 (leading − 0xA1) × 94 + byte − 0xA1 对应的索引码点；否则设为jis0212 索引中对应的码点。

   5. 将EUC-JP jis0212 设为 false。

   6. 如果 codePoint 不为 null，则返回一个值为 codePoint 的码点。

   7. 如果 byte 是一个ASCII 字节，则将 byte 恢复到 ioQueue。

   8. 返回错误。

6. 如果 byte 是一个ASCII 字节，则返回一个值为 byte 的码点。

7. 如果 byte 是 0x8E、0x8F 或在 0xA1 到 0xFE（含）的范围内，则将 EUC-JP 前导字节设为 byte 并返回继续。

8. 返回错误。

12.1.2. EUC-JP 编码器

EUC-JP 的编码器的处理程序，给定 unused 和 codePoint，执行以下步骤：

1. 如果 codePoint 是队列末尾，则返回完成。

2. 如果 codePoint 是一个ASCII 码点，则返回一个值为 codePoint 的字节。

3. 如果 codePoint 是 U+00A5 (¥)，则返回字节 0x5C。

4. 如果 codePoint 是 U+203E (‾)，则返回字节 0x7E。

5. 如果 codePoint 在 U+FF61 (｡) 到 U+FF9F (ﾟ)（含）的范围内，则返回两个 字节，其值分别为 0x8E 和 codePoint − 0xFF61 + 0xA1。

6. 如果 codePoint 是 U+2212 (−)，则将其设为 U+FF0D (－)。

7. 令 pointer 为jis0208 索引中 codePoint 对应的索引指针。

   如果 pointer 不为 null，则由于 jis0208 索引和 索引指针 操作的性质，它将小于 8836。

8. 如果 pointer 为 null，则返回带 codePoint 的错误。

9. 令 leading 为 pointer / 94 + 0xA1。

10. 令 trailing 为 pointer % 94 + 0xA1。

11. 返回两个字节，其值分别为 leading 和 trailing。

12.2. ISO-2022-JP

12.2.1. ISO-2022-JP 解码器

ISO-2022-JP 的解码器有一个关联的：

ISO-2022-JP 解码器状态

一个状态，初始为ASCII。

ISO-2022-JP 解码器输出状态

一个状态，初始为ASCII。

ISO-2022-JP 前导字节

一个字节，初始为 0x00。

ISO-2022-JP 输出标志

一个布尔值，初始为 false。

ISO-2022-JP 的解码器的处理程序，给定 ioQueue 和 byte，根据 ISO-2022-JP 解码器状态执行以下步骤：

ASCII

根据 byte：

0x1B

将ISO-2022-JP 解码器状态设为 转义开始并返回 继续。

0x00 到 0x7F，不包括 0x0E、0x0F 和 0x1B

将ISO-2022-JP 输出标志设为 false 并返回一个值为 byte 的码点。

队列末尾

返回完成。

其他情况

将ISO-2022-JP 输出标志设为 false 并返回错误。

罗马字

根据 byte：

0x1B

将ISO-2022-JP 解码器状态设为 转义开始并返回 继续。

0x5C

将ISO-2022-JP 输出标志设为 false 并返回码点 U+00A5 (¥)。

0x7E

将ISO-2022-JP 输出标志设为 false 并返回码点 U+203E (‾)。

0x00 到 0x7F，不包括 0x0E、0x0F、0x1B、0x5C 和 0x7E

将ISO-2022-JP 输出标志设为 false 并返回一个值为 byte 的码点。

队列末尾

返回完成。

其他情况

将ISO-2022-JP 输出标志设为 false 并返回错误。

片假名

根据 byte：

0x1B

将ISO-2022-JP 解码器状态设为 转义开始并返回 继续。

0x21 到 0x5F

将ISO-2022-JP 输出标志设为 false 并返回一个值为 0xFF61 − 0x21 + byte 的码点。

队列末尾

返回完成。

其他情况

将ISO-2022-JP 输出标志设为 false 并返回错误。

前导字节

根据 byte：

0x1B

将ISO-2022-JP 解码器状态设为 转义开始并返回 继续。

0x21 到 0x7E

将ISO-2022-JP 输出标志设为 false，将ISO-2022-JP 前导字节设为 byte， 将ISO-2022-JP 解码器状态设为尾随字节， 并返回继续。

队列末尾

返回完成。

其他情况

将ISO-2022-JP 输出标志设为 false 并返回错误。

尾随字节

根据 byte：

0x1B

将ISO-2022-JP 解码器状态设为 转义开始并返回错误。

0x21 到 0x7E

1. 将ISO-2022-JP 解码器状态设为 前导字节。

2. 令 pointer 为 (ISO-2022-JP 前导字节 − 0x21) × 94 + byte − 0x21。

3. 令 codePoint 为jis0208 索引中 pointer 对应的 索引码点。

4. 如果 codePoint 为 null，则返回错误。

5. 返回一个值为 codePoint 的码点。

队列末尾

将ISO-2022-JP 解码器状态设为 前导字节并返回错误。

其他情况

将ISO-2022-JP 解码器状态设为 前导字节并返回 错误。

转义开始

1. 如果 byte 是 0x24 或 0x28，则将 ISO-2022-JP 前导字节设为 byte，将ISO-2022-JP 解码器状态设为 转义，并返回继续。

2. 如果 byte 不是队列末尾，则将 byte 恢复到 ioQueue。

3. 将ISO-2022-JP 输出标志设为 false，将ISO-2022-JP 解码器状态设为 ISO-2022-JP 解码器输出状态，并返回错误。

转义

1. 令 leading 为ISO-2022-JP 前导字节并设 ISO-2022-JP 前导字节为 0x00。

2. 令 state 为 null。

3. 如果 leading 是 0x28 且 byte 是 0x42，则将 state 设为ASCII。

4. 如果 leading 是 0x28 且 byte 是 0x4A，则将 state 设为罗马字。

5. 如果 leading 是 0x28 且 byte 是 0x49，则将 state 设为片假名。

6. 如果 leading 是 0x24 且 byte 是 0x40 或 0x42， 则将 state 设为前导字节。

7. 如果 state 不为 null：

   1. 将ISO-2022-JP 解码器状态和 ISO-2022-JP 解码器输出状态设为 state。

   2. 令 output 为ISO-2022-JP 输出标志的值。

   3. 将ISO-2022-JP 输出标志设为 true。

   4. 如果 output 为 false，则返回继续； 否则返回错误。

8. 如果 byte 是队列末尾，则将 leading 恢复到 ioQueue；否则，将 « leading, byte » 恢复到 ioQueue。

9. 将ISO-2022-JP 输出标志设为 false， 将ISO-2022-JP 解码器状态设为ISO-2022-JP 解码器输出状态 并返回错误。

12.2.2. ISO-2022-JP 编码器

ISO-2022-JP 的编码器有一个关联的 ISO-2022-JP 编码器状态，可以是ASCII、 罗马字或 jis0208，初始为 ASCII。

ISO-2022-JP 的编码器的处理程序，给定 ioQueue 和 codePoint，执行以下步骤：

1. 如果 codePoint 是队列末尾且ISO-2022-JP 编码器状态不为 ASCII，则将ISO-2022-JP 编码器状态设为 ASCII 并返回三个字节 0x1B 0x28 0x42。

2. 如果 codePoint 是队列末尾且ISO-2022-JP 编码器状态为 ASCII，则返回完成。

3. 如果ISO-2022-JP 编码器状态为ASCII或 罗马字，且 codePoint 为 U+000E、U+000F 或 U+001B，则返回带 U+FFFD () 的错误。

   这里返回 U+FFFD () 而不是 codePoint 是为了防止攻击。

4. 如果ISO-2022-JP 编码器状态为ASCII且 codePoint 是一个ASCII 码点，则返回一个值为 codePoint 的字节。

5. 如果ISO-2022-JP 编码器状态为罗马字且 codePoint 是一个ASCII 码点（不包括 U+005C (\) 和 U+007E (~)），或者是 U+00A5 (¥) 或 U+203E (‾)：

   1. 如果 codePoint 是一个ASCII 码点，则返回一个值为 codePoint 的字节。

   2. 如果 codePoint 是 U+00A5 (¥)，则返回字节 0x5C。

   3. 如果 codePoint 是 U+203E (‾)，则返回字节 0x7E。

6. 如果 codePoint 是一个ASCII 码点，且ISO-2022-JP 编码器状态不为ASCII，则将 codePoint 恢复到 ioQueue，将ISO-2022-JP 编码器状态设为 ASCII，并返回三个字节 0x1B 0x28 0x42。

7. 如果 codePoint 是 U+00A5 (¥) 或 U+203E (‾)，且 ISO-2022-JP 编码器状态不为罗马字，则将 codePoint 恢复到 ioQueue， 将ISO-2022-JP 编码器状态设为 罗马字，并返回三个字节 0x1B 0x28 0x4A。

8. 如果 codePoint 是 U+2212 (−)，则将其设为 U+FF0D (－)。

9. 如果 codePoint 在 U+FF61 (｡) 到 U+FF9F (ﾟ)（含）的范围内，则将其设为 ISO-2022-JP 片假名索引中 codePoint − 0xFF61 对应的索引码点。

10. 令 pointer 为jis0208 索引中 codePoint 对应的索引指针。

    如果 pointer 不为 null，则由于 jis0208 索引和 索引指针 操作的性质，它将小于 8836。

11. 如果 pointer 为 null：

    1. 如果ISO-2022-JP 编码器状态为jis0208， 则将 codePoint 恢复到 ioQueue，将 ISO-2022-JP 编码器状态设为ASCII，并返回三个 字节 0x1B 0x28 0x42。

    2. 返回带 codePoint 的错误。

12. 如果ISO-2022-JP 编码器状态不为jis0208， 则将 codePoint 恢复到 ioQueue， 将 ISO-2022-JP 编码器状态设为jis0208，并返回 三个字节 0x1B 0x24 0x42。

13. 令 leading 为 pointer / 94 + 0x21。

14. 令 trailing 为 pointer % 94 + 0x21。

15. 返回两个字节，其值分别为 leading 和 trailing。

12.3. Shift_JIS

12.3.1. Shift_JIS 解码器

Shift_JIS 的解码器有一个关联的 Shift_JIS 前导字节，它是一个字节，初始值为 0x00。

Shift_JIS 的解码器的处理程序，给定 ioQueue 和 byte，执行以下步骤：

1. 如果 byte 是队列末尾且Shift_JIS 前导字节不为 0x00，则将 Shift_JIS 前导字节设为 0x00 并返回错误。

2. 如果 byte 是队列末尾且Shift_JIS 前导字节为 0x00，则返回 完成。

3. 如果Shift_JIS 前导字节不为 0x00：

   1. 令 leading 为Shift_JIS 前导字节。

   2. 将Shift_JIS 前导字节设为 0x00。

   3. 令 pointer 为 null。

   4. 如果 byte 小于 0x7F，则令 offset 为 0x40；否则为 0x41。

   5. 如果 leading 小于 0xA0，则令 leadingOffset 为 0x81；否则为 0xC1。

   6. 如果 byte 在 0x40 到 0x7E（含）或 0x80 到 0xFC（含）的范围内， 则将 pointer 设为 (leading − leadingOffset) × 188 + byte − offset。

   7. 如果 pointer 在 8836 到 10715（含）的范围内，则返回一个值为 0xE000 − 8836 + pointer 的码点。

      这是来自 Windows 的可互操作的旧式传统，称为 EUDC。

   8. 如果 pointer 为 null，则令 codePoint 为 null；否则为jis0208 索引中 pointer 对应的 索引码点。

   9. 如果 codePoint 不为 null，则返回一个值为 codePoint 的码点。

   10. 如果 byte 是一个ASCII 字节，则将 byte 恢复到 ioQueue。

   11. 返回错误。

4. 如果 byte 是一个ASCII 字节或 0x80，则返回一个值为 byte 的码点。

5. 如果 byte 在 0xA1 到 0xDF（含）的范围内，则返回一个值为 0xFF61 − 0xA1 + byte 的码点。

6. 如果 byte 在 0x81 到 0x9F（含）或 0xE0 到 0xFC（含）的范围内，则 将Shift_JIS 前导字节设为 byte 并返回继续。

7. 返回错误。

12.3.2. Shift_JIS 编码器

Shift_JIS 的编码器的处理程序，给定 unused 和 codePoint，执行以下步骤：

1. 如果 codePoint 是队列末尾，则返回完成。

2. 如果 codePoint 是一个ASCII 码点或 U+0080，则返回一个值为 codePoint 的字节。

3. 如果 codePoint 是 U+00A5 (¥)，则返回字节 0x5C。

4. 如果 codePoint 是 U+203E (‾)，则返回字节 0x7E。

5. 如果 codePoint 在 U+FF61 (｡) 到 U+FF9F (ﾟ)（含）的范围内，则返回一个 值为 codePoint − 0xFF61 + 0xA1 的字节。

6. 如果 codePoint 是 U+2212 (−)，则将其设为 U+FF0D (－)。

7. 令 pointer 为 codePoint 对应的Shift_JIS 索引指针。

8. 如果 pointer 为 null，则返回带 codePoint 的错误。

9. 令 leading 为 pointer / 188。

10. 如果 leading 小于 0x1F，则令 leadingOffset 为 0x81；否则为 0xC1。

11. 令 trailing 为 pointer % 188。

12. 如果 trailing 小于 0x3F，则令 offset 为 0x40；否则为 0x41。

13. 返回两个字节，其值分别为 leading + leadingOffset 和 trailing + offset。

13. 旧版多字节韩文编码

13.1. EUC-KR

13.1.1. EUC-KR 解码器

EUC-KR 的解码器有一个关联的 EUC-KR 前导字节，它是一个字节，初始值为 0x00。

EUC-KR 的解码器的处理程序，给定 ioQueue 和 byte，执行以下步骤：

1. 如果 byte 是队列末尾且EUC-KR 前导字节不为 0x00，则将 EUC-KR 前导字节设为 0x00 并返回错误。

2. 如果 byte 是队列末尾且EUC-KR 前导字节为 0x00，则返回 完成。

3. 如果EUC-KR 前导字节不为 0x00：

   1. 令 leading 为EUC-KR 前导字节。

   2. 将EUC-KR 前导字节设为 0x00。

   3. 令 pointer 为 null。

   4. 如果 byte 在 0x41 到 0xFE（含）的范围内，则将 pointer 设为 (leading − 0x81) × 190 + (byte − 0x41)。

   5. 如果 pointer 为 null，则令 codePoint 为 null；否则为EUC-KR 索引中 pointer 对应的 索引码点。

   6. 如果 codePoint 不为 null，则返回一个值为 codePoint 的码点。

   7. 如果 byte 是一个ASCII 字节，则将 byte 恢复到 ioQueue。

   8. 返回错误。

4. 如果 byte 是一个ASCII 字节，则返回一个值为 byte 的码点。

5. 如果 byte 在 0x81 到 0xFE（含）的范围内，则将EUC-KR 前导字节设为 byte 并返回继续。

6. 返回错误。

13.1.2. EUC-KR 编码器

EUC-KR 的编码器的处理程序，给定 unused 和 codePoint，执行以下步骤：

1. 如果 codePoint 是队列末尾，则返回完成。

2. 如果 codePoint 是一个ASCII 码点，则返回一个值为 codePoint 的字节。

3. 令 pointer 为EUC-KR 索引中 codePoint 对应的索引指针。

4. 如果 pointer 为 null，则返回带 codePoint 的错误。

5. 令 leading 为 pointer / 190 + 0x81。

6. 令 trailing 为 pointer % 190 + 0x41。

7. 返回两个字节，其值分别为 leading 和 trailing。

14. 旧式杂项编码

14.1. replacement

replacement 编码的存在是为了防止滥用服务器与客户端支持的 编码不一致造成的某些攻击。

14.1.1. replacement 解码器

replacement 的解码器有一个关联的 replacement error returned，它是一个布尔值，初始为 false。

replacement 的解码器的处理程序，给定 unused 和 byte，执行以下步骤：

1. 如果 byte 是队列末尾，则返回完成。

2. 如果 replacement error returned 为 false，则将 replacement error returned 设为 true，并返回错误。

3. 返回完成。

14.2. UTF-16BE/LE 的通用基础设施

UTF-16BE/LE 是 UTF-16BE 或 UTF-16LE。

14.2.1. 共享 UTF-16 解码器

字节顺序标记优先于标签，因为在实际内容中它被发现更为准确。因此它不是共享 UTF-16 解码器算法的一部分，而属于解码算法。

共享 UTF-16 解码器有一个关联的：

UTF-16 前导字节

为空或一个字节，初始为 null。

UTF-16 前导代理项

为空或前导代理项，初始为 null。

是否 UTF-16BE 解码器

布尔值，初始为 false。

共享 UTF-16 解码器的处理程序，给定 ioQueue 和 byte，执行以下步骤：

1. 如果 byte 是队列末尾，且 UTF-16 前导字节 或 UTF-16 前导代理项非空，则将 UTF-16 前导字节和 UTF-16 前导代理项设为 null，并返回错误。

2. 如果 byte 是队列末尾，且UTF-16 前导字节和 UTF-16 前导代理项均为空，则返回完成。

3. 如果UTF-16 前导字节为空，则将UTF-16 前导字节设为 byte，并返回继续。

4. 令 codeUnit 为以下结果之一：

   是否 UTF-16BE 解码器为 true

   (UTF-16 前导字节 << 8) + byte。

   是否 UTF-16BE 解码器为 false

   (byte << 8) + UTF-16 前导字节。

5. 将UTF-16 前导字节设为 null。

6. 如果UTF-16 前导代理项非空：

   1. 令 leadingSurrogate 为UTF-16 前导代理项。

   2. 将UTF-16 前导代理项设为 null。

   3. 如果 codeUnit 是尾随代理项，则返回由代理项组成的标量值，参数为 leadingSurrogate 和 codeUnit。

   4. 令 byte1 为 codeUnit >> 8。

   5. 令 byte2 为 codeUnit & 0x00FF。

   6. 若是否 UTF-16BE 解码器为 true，则 bytes 为 [byte1, byte2]，否则为 [byte2, byte1]。

   7. 恢复 bytes 到 ioQueue 并返回错误。

7. 如果 codeUnit 是前导代理项，则将UTF-16 前导代理项设为 codeUnit 并返回继续。

8. 如果 codeUnit 是尾随代理项，则返回错误。

9. 返回码点 codeUnit。

14.3. UTF-16BE

14.3.1. UTF-16BE 解码器

UTF-16BE 的解码器是共享 UTF-16 解码器，其 是否 UTF-16BE 解码器 设为 true。

14.4. UTF-16LE

"utf-16" 是 UTF-16LE 的标签，用于兼容已部署的内容。

14.4.1. UTF-16LE 解码器

UTF-16LE 的解码器是共享 UTF-16 解码器。

14.5. x-user-defined

虽然技术上这是单字节编码，但它被单独定义，因为它可以算法化实现。

14.5.1. x-user-defined 解码器

x-user-defined 的解码器的处理程序，给定 unused 和 byte，执行以下步骤：

1. 如果 byte 是队列末尾，则返回完成。

2. 如果 byte 是一个ASCII 字节，则返回一个值为 byte 的码点。

3. 返回一个值为 0xF780 + byte − 0x80 的码点。

14.5.2. x-user-defined 编码器

x-user-defined 的编码器的处理程序，给定 unused 和 codePoint，执行以下步骤：

1. 如果 codePoint 是队列末尾，则返回完成。

2. 如果 codePoint 是一个ASCII 码点，则返回一个值为 codePoint 的字节。

3. 如果 codePoint 在 U+F780 到 U+F7FF（含）的范围内，则返回一个值为 codePoint − 0xF780 + 0x80 的字节。

4. 返回带 codePoint 的错误。

15. 浏览器 UI

建议浏览器不要启用覆盖资源编码的选项。如果此功能仍然存在，浏览器不应将 UTF-16BE/LE 作为选项提供，因为上述安全问题。若资源已用 UTF-16BE/LE 解码，浏览器也应该禁用该功能。

实现注意事项

对于本标准中的编码，其解码器可以用如下方式实现，无需支持具有任意I/O 队列和任意恢复：

1. 能够反读当前字节。

2. 为 gb18030（一个 ASCII 字节）和 ISO-2022-JP（0x24 或 0x28）提供单字节缓冲区。

   对于 gb18030，当 gb18030 third 不为 0x00 时遇到非法字节，可以将 gb18030 second 移入单字节缓冲区，作为下一个字节返回，并将 gb18030 third 作为新的 gb18030 first，在单字节缓冲区被返回并清空后检查其是否不为 0x00。因为 gb18030 的第一个字节和第三个字节的取值范围是相同的，所以这是可行的。

ISO-2022-JP 编码器需要 ISO-2022-JP 编码器状态 作为额外状态，但除此之外，本标准中其他编码的编码器不需要额外状态或缓冲区。

致谢