@loaders.gl/polyfills 3.1.3 → 4.0.0-alpha.5

package/dist/lib/encoding.js

@@ -1,2779 +1,1450 @@
-"use strict";
-// @ts-nocheck
-/* eslint-disable */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TextDecoder = exports.TextEncoder = void 0;
-// Copied from https://github.com/inexorabletash/text-encoding/blob/b4e5bc26e26e51f56e3daa9f13138c79f49d3c34/lib/encoding.js
-// This is free and unencumbered software released into the public domain.
-// See LICENSE.md for more information.
-const encoding_indexes_1 = __importDefault(require("./encoding-indexes"));
-// Note: Aaian character indices add half a megabyte to bundle. Ignore, since we really only want the built-in UTF8...
-// import indexes from './encoding-indexes-asian';
-global['encoding-indexes'] = encoding_indexes_1.default || {};
-//
-// Utilities
-//
-/**
- * @param {number} a The number to test.
- * @param {number} min The minimum value in the range, inclusive.
- * @param {number} max The maximum value in the range, inclusive.
- * @return {boolean} True if a >= min and a <= max.
- */
+import indexes from './encoding-indexes';
+global['encoding-indexes'] = indexes || {};
+
 function inRange(a, min, max) {
-    return min <= a && a <= max;
+  return min <= a && a <= max;
 }
-/**
- * @param {!Array.<*>} array The array to check.
- * @param {*} item The item to look for in the array.
- * @return {boolean} True if the item appears in the array.
- */
+
 function includes(array, item) {
-    return array.indexOf(item) !== -1;
+  return array.indexOf(item) !== -1;
 }
+
 var floor = Math.floor;
-/**
- * @param {*} o
- * @return {Object}
- */
+
 function ToDictionary(o) {
-    if (o === undefined)
-        return {};
-    if (o === Object(o))
-        return o;
-    throw TypeError('Could not convert argument to dictionary');
+  if (o === undefined) return {};
+  if (o === Object(o)) return o;
+  throw TypeError('Could not convert argument to dictionary');
 }
-/**
- * @param {string} string Input string of UTF-16 code units.
- * @return {!Array.<number>} Code points.
- */
+
 function stringToCodePoints(string) {
-    // https://heycam.github.io/webidl/#dfn-obtain-unicode
-    // 1. Let S be the DOMString value.
-    var s = String(string);
-    // 2. Let n be the length of S.
-    var n = s.length;
-    // 3. Initialize i to 0.
-    var i = 0;
-    // 4. Initialize U to be an empty sequence of Unicode characters.
-    var u = [];
-    // 5. While i < n:
-    while (i < n) {
-        // 1. Let c be the code unit in S at index i.
-        var c = s.charCodeAt(i);
-        // 2. Depending on the value of c:
-        // c < 0xD800 or c > 0xDFFF
-        if (c < 0xd800 || c > 0xdfff) {
-            // Append to U the Unicode character with code point c.
-            u.push(c);
-        }
-        // 0xDC00 ≤ c ≤ 0xDFFF
-        else if (0xdc00 <= c && c <= 0xdfff) {
-            // Append to U a U+FFFD REPLACEMENT CHARACTER.
+  var s = String(string);
+  var n = s.length;
+  var i = 0;
+  var u = [];
+
+  while (i < n) {
+    var c = s.charCodeAt(i);
+
+    if (c < 0xd800 || c > 0xdfff) {
+      u.push(c);
+    } else if (0xdc00 <= c && c <= 0xdfff) {
+        u.push(0xfffd);
+      } else if (0xd800 <= c && c <= 0xdbff) {
+          if (i === n - 1) {
             u.push(0xfffd);
-        }
-        // 0xD800 ≤ c ≤ 0xDBFF
-        else if (0xd800 <= c && c <= 0xdbff) {
-            // 1. If i = n−1, then append to U a U+FFFD REPLACEMENT
-            // CHARACTER.
-            if (i === n - 1) {
-                u.push(0xfffd);
-            }
-            // 2. Otherwise, i < n−1:
-            else {
-                // 1. Let d be the code unit in S at index i+1.
-                var d = s.charCodeAt(i + 1);
-                // 2. If 0xDC00 ≤ d ≤ 0xDFFF, then:
-                if (0xdc00 <= d && d <= 0xdfff) {
-                    // 1. Let a be c & 0x3FF.
-                    var a = c & 0x3ff;
-                    // 2. Let b be d & 0x3FF.
-                    var b = d & 0x3ff;
-                    // 3. Append to U the Unicode character with code point
-                    // 2^16+2^10*a+b.
-                    u.push(0x10000 + (a << 10) + b);
-                    // 4. Set i to i+1.
-                    i += 1;
-                }
-                // 3. Otherwise, d < 0xDC00 or d > 0xDFFF. Append to U a
-                // U+FFFD REPLACEMENT CHARACTER.
-                else {
-                    u.push(0xfffd);
+          } else {
+              var d = s.charCodeAt(i + 1);
+
+              if (0xdc00 <= d && d <= 0xdfff) {
+                var a = c & 0x3ff;
+                var b = d & 0x3ff;
+                u.push(0x10000 + (a << 10) + b);
+                i += 1;
+              } else {
+                  u.push(0xfffd);
                 }
             }
         }
-        // 3. Set i to i+1.
-        i += 1;
-    }
-    // 6. Return U.
-    return u;
+
+    i += 1;
+  }
+
+  return u;
 }
-/**
- * @param {!Array.<number>} code_points Array of code points.
- * @return {string} string String of UTF-16 code units.
- */
+
 function codePointsToString(code_points) {
-    var s = '';
-    for (var i = 0; i < code_points.length; ++i) {
-        var cp = code_points[i];
-        if (cp <= 0xffff) {
-            s += String.fromCharCode(cp);
-        }
-        else {
-            cp -= 0x10000;
-            s += String.fromCharCode((cp >> 10) + 0xd800, (cp & 0x3ff) + 0xdc00);
-        }
+  var s = '';
+
+  for (var i = 0; i < code_points.length; ++i) {
+    var cp = code_points[i];
+
+    if (cp <= 0xffff) {
+      s += String.fromCharCode(cp);
+    } else {
+      cp -= 0x10000;
+      s += String.fromCharCode((cp >> 10) + 0xd800, (cp & 0x3ff) + 0xdc00);
     }
-    return s;
+  }
+
+  return s;
 }
-//
-// Implementation of Encoding specification
-// https://encoding.spec.whatwg.org/
-//
-//
-// 4. Terminology
-//
-/**
- * An ASCII byte is a byte in the range 0x00 to 0x7F, inclusive.
- * @param {number} a The number to test.
- * @return {boolean} True if a is in the range 0x00 to 0x7F, inclusive.
- */
+
 function isASCIIByte(a) {
-    return 0x00 <= a && a <= 0x7f;
+  return 0x00 <= a && a <= 0x7f;
 }
-/**
- * An ASCII code point is a code point in the range U+0000 to
- * U+007F, inclusive.
- */
+
 var isASCIICodePoint = isASCIIByte;
-/**
- * End-of-stream is a special token that signifies no more tokens
- * are in the stream.
- * @const
- */ var end_of_stream = -1;
-/**
- * A stream represents an ordered sequence of tokens.
- *
- * @constructor
- * @param {!(Array.<number>|Uint8Array)} tokens Array of tokens that provide
- * the stream.
- */
+var end_of_stream = -1;
+
 function Stream(tokens) {
-    /** @type {!Array.<number>} */
-    this.tokens = [].slice.call(tokens);
-    // Reversed as push/pop is more efficient than shift/unshift.
-    this.tokens.reverse();
+  this.tokens = [].slice.call(tokens);
+  this.tokens.reverse();
 }
+
 Stream.prototype = {
-    /**
-     * @return {boolean} True if end-of-stream has been hit.
-     */
-    endOfStream: function () {
-        return !this.tokens.length;
-    },
-    /**
-     * When a token is read from a stream, the first token in the
-     * stream must be returned and subsequently removed, and
-     * end-of-stream must be returned otherwise.
-     *
-     * @return {number} Get the next token from the stream, or
-     * end_of_stream.
-     */
-    read: function () {
-        if (!this.tokens.length)
-            return end_of_stream;
-        return this.tokens.pop();
-    },
-    /**
-     * When one or more tokens are prepended to a stream, those tokens
-     * must be inserted, in given order, before the first token in the
-     * stream.
-     *
-     * @param {(number|!Array.<number>)} token The token(s) to prepend to the
-     * stream.
-     */
-    prepend: function (token) {
-        if (Array.isArray(token)) {
-            var tokens = /**@type {!Array.<number>}*/ token;
-            while (tokens.length)
-                this.tokens.push(tokens.pop());
-        }
-        else {
-            this.tokens.push(token);
-        }
-    },
-    /**
-     * When one or more tokens are pushed to a stream, those tokens
-     * must be inserted, in given order, after the last token in the
-     * stream.
-     *
-     * @param {(number|!Array.<number>)} token The tokens(s) to push to the
-     * stream.
-     */
-    push: function (token) {
-        if (Array.isArray(token)) {
-            var tokens = /**@type {!Array.<number>}*/ token;
-            while (tokens.length)
-                this.tokens.unshift(tokens.shift());
-        }
-        else {
-            this.tokens.unshift(token);
-        }
+  endOfStream: function () {
+    return !this.tokens.length;
+  },
+  read: function () {
+    if (!this.tokens.length) return end_of_stream;
+    return this.tokens.pop();
+  },
+  prepend: function (token) {
+    if (Array.isArray(token)) {
+      var tokens = token;
+
+      while (tokens.length) this.tokens.push(tokens.pop());
+    } else {
+      this.tokens.push(token);
+    }
+  },
+  push: function (token) {
+    if (Array.isArray(token)) {
+      var tokens = token;
+
+      while (tokens.length) this.tokens.unshift(tokens.shift());
+    } else {
+      this.tokens.unshift(token);
     }
+  }
 };
-//
-// 5. Encodings
-//
-// 5.1 Encoders and decoders
-/** @const */
 var finished = -1;
-/**
- * @param {boolean} fatal If true, decoding errors raise an exception.
- * @param {number=} opt_code_point Override the standard fallback code point.
- * @return {number} The code point to insert on a decoding error.
- */
+
 function decoderError(fatal, opt_code_point) {
-    if (fatal)
-        throw TypeError('Decoder error');
-    return opt_code_point || 0xfffd;
+  if (fatal) throw TypeError('Decoder error');
+  return opt_code_point || 0xfffd;
 }
-/**
- * @param {number} code_point The code point that could not be encoded.
- * @return {number} Always throws, no value is actually returned.
- */
+
 function encoderError(code_point) {
-    throw TypeError('The code point ' + code_point + ' could not be encoded.');
+  throw TypeError('The code point ' + code_point + ' could not be encoded.');
 }
-/** @interface */
-function Decoder() { }
+
+function Decoder() {}
+
 Decoder.prototype = {
-    /**
-     * @param {Stream} stream The stream of bytes being decoded.
-     * @param {number} bite The next byte read from the stream.
-     * @return {?(number|!Array.<number>)} The next code point(s)
-     *     decoded, or null if not enough data exists in the input
-     *     stream to decode a complete code point, or |finished|.
-     */
-    handler: function (stream, bite) { }
+  handler: function (stream, bite) {}
 };
-/** @interface */
-function Encoder() { }
+
+function Encoder() {}
+
 Encoder.prototype = {
-    /**
-     * @param {Stream} stream The stream of code points being encoded.
-     * @param {number} code_point Next code point read from the stream.
-     * @return {(number|!Array.<number>)} Byte(s) to emit, or |finished|.
-     */
-    handler: function (stream, code_point) { }
+  handler: function (stream, code_point) {}
 };
-// 5.2 Names and labels
-// TODO: Define @typedef for Encoding: {name:string,labels:Array.<string>}
-// https://github.com/google/closure-compiler/issues/247
-/**
- * @param {string} label The encoding label.
- * @return {?{name:string,labels:Array.<string>}}
- */
+
 function getEncoding(label) {
-    // 1. Remove any leading and trailing ASCII whitespace from label.
-    label = String(label).trim().toLowerCase();
-    // 2. If label is an ASCII case-insensitive match for any of the
-    // labels listed in the table below, return the corresponding
-    // encoding, and failure otherwise.
-    if (Object.prototype.hasOwnProperty.call(label_to_encoding, label)) {
-        return label_to_encoding[label];
-    }
-    return null;
+  label = String(label).trim().toLowerCase();
+
+  if (Object.prototype.hasOwnProperty.call(label_to_encoding, label)) {
+    return label_to_encoding[label];
+  }
+
+  return null;
 }
-/**
- * Encodings table: https://encoding.spec.whatwg.org/encodings.json
- * @const
- * @type {!Array.<{
- *          heading: string,
- *          encodings: Array.<{name:string,labels:Array.<string>}>
- *        }>}
- */
-var encodings = [
-    {
-        encodings: [
-            {
-                labels: ['unicode-1-1-utf-8', 'utf-8', 'utf8'],
-                name: 'UTF-8'
-            }
-        ],
-        heading: 'The Encoding'
-    },
-    {
-        encodings: [
-            {
-                labels: ['866', 'cp866', 'csibm866', 'ibm866'],
-                name: 'IBM866'
-            },
-            {
-                labels: [
-                    'csisolatin2',
-                    'iso-8859-2',
-                    'iso-ir-101',
-                    'iso8859-2',
-                    'iso88592',
-                    'iso_8859-2',
-                    'iso_8859-2:1987',
-                    'l2',
-                    'latin2'
-                ],
-                name: 'ISO-8859-2'
-            },
-            {
-                labels: [
-                    'csisolatin3',
-                    'iso-8859-3',
-                    'iso-ir-109',
-                    'iso8859-3',
-                    'iso88593',
-                    'iso_8859-3',
-                    'iso_8859-3:1988',
-                    'l3',
-                    'latin3'
-                ],
-                name: 'ISO-8859-3'
-            },
-            {
-                labels: [
-                    'csisolatin4',
-                    'iso-8859-4',
-                    'iso-ir-110',
-                    'iso8859-4',
-                    'iso88594',
-                    'iso_8859-4',
-                    'iso_8859-4:1988',
-                    'l4',
-                    'latin4'
-                ],
-                name: 'ISO-8859-4'
-            },
-            {
-                labels: [
-                    'csisolatincyrillic',
-                    'cyrillic',
-                    'iso-8859-5',
-                    'iso-ir-144',
-                    'iso8859-5',
-                    'iso88595',
-                    'iso_8859-5',
-                    'iso_8859-5:1988'
-                ],
-                name: 'ISO-8859-5'
-            },
-            {
-                labels: [
-                    'arabic',
-                    'asmo-708',
-                    'csiso88596e',
-                    'csiso88596i',
-                    'csisolatinarabic',
-                    'ecma-114',
-                    'iso-8859-6',
-                    'iso-8859-6-e',
-                    'iso-8859-6-i',
-                    'iso-ir-127',
-                    'iso8859-6',
-                    'iso88596',
-                    'iso_8859-6',
-                    'iso_8859-6:1987'
-                ],
-                name: 'ISO-8859-6'
-            },
-            {
-                labels: [
-                    'csisolatingreek',
-                    'ecma-118',
-                    'elot_928',
-                    'greek',
-                    'greek8',
-                    'iso-8859-7',
-                    'iso-ir-126',
-                    'iso8859-7',
-                    'iso88597',
-                    'iso_8859-7',
-                    'iso_8859-7:1987',
-                    'sun_eu_greek'
-                ],
-                name: 'ISO-8859-7'
-            },
-            {
-                labels: [
-                    'csiso88598e',
-                    'csisolatinhebrew',
-                    'hebrew',
-                    'iso-8859-8',
-                    'iso-8859-8-e',
-                    'iso-ir-138',
-                    'iso8859-8',
-                    'iso88598',
-                    'iso_8859-8',
-                    'iso_8859-8:1988',
-                    'visual'
-                ],
-                name: 'ISO-8859-8'
-            },
-            {
-                labels: ['csiso88598i', 'iso-8859-8-i', 'logical'],
-                name: 'ISO-8859-8-I'
-            },
-            {
-                labels: [
-                    'csisolatin6',
-                    'iso-8859-10',
-                    'iso-ir-157',
-                    'iso8859-10',
-                    'iso885910',
-                    'l6',
-                    'latin6'
-                ],
-                name: 'ISO-8859-10'
-            },
-            {
-                labels: ['iso-8859-13', 'iso8859-13', 'iso885913'],
-                name: 'ISO-8859-13'
-            },
-            {
-                labels: ['iso-8859-14', 'iso8859-14', 'iso885914'],
-                name: 'ISO-8859-14'
-            },
-            {
-                labels: ['csisolatin9', 'iso-8859-15', 'iso8859-15', 'iso885915', 'iso_8859-15', 'l9'],
-                name: 'ISO-8859-15'
-            },
-            {
-                labels: ['iso-8859-16'],
-                name: 'ISO-8859-16'
-            },
-            {
-                labels: ['cskoi8r', 'koi', 'koi8', 'koi8-r', 'koi8_r'],
-                name: 'KOI8-R'
-            },
-            {
-                labels: ['koi8-ru', 'koi8-u'],
-                name: 'KOI8-U'
-            },
-            {
-                labels: ['csmacintosh', 'mac', 'macintosh', 'x-mac-roman'],
-                name: 'macintosh'
-            },
-            {
-                labels: ['dos-874', 'iso-8859-11', 'iso8859-11', 'iso885911', 'tis-620', 'windows-874'],
-                name: 'windows-874'
-            },
-            {
-                labels: ['cp1250', 'windows-1250', 'x-cp1250'],
-                name: 'windows-1250'
-            },
-            {
-                labels: ['cp1251', 'windows-1251', 'x-cp1251'],
-                name: 'windows-1251'
-            },
-            {
-                labels: [
-                    'ansi_x3.4-1968',
-                    'ascii',
-                    'cp1252',
-                    'cp819',
-                    'csisolatin1',
-                    'ibm819',
-                    'iso-8859-1',
-                    'iso-ir-100',
-                    'iso8859-1',
-                    'iso88591',
-                    'iso_8859-1',
-                    'iso_8859-1:1987',
-                    'l1',
-                    'latin1',
-                    'us-ascii',
-                    'windows-1252',
-                    'x-cp1252'
-                ],
-                name: 'windows-1252'
-            },
-            {
-                labels: ['cp1253', 'windows-1253', 'x-cp1253'],
-                name: 'windows-1253'
-            },
-            {
-                labels: [
-                    'cp1254',
-                    'csisolatin5',
-                    'iso-8859-9',
-                    'iso-ir-148',
-                    'iso8859-9',
-                    'iso88599',
-                    'iso_8859-9',
-                    'iso_8859-9:1989',
-                    'l5',
-                    'latin5',
-                    'windows-1254',
-                    'x-cp1254'
-                ],
-                name: 'windows-1254'
-            },
-            {
-                labels: ['cp1255', 'windows-1255', 'x-cp1255'],
-                name: 'windows-1255'
-            },
-            {
-                labels: ['cp1256', 'windows-1256', 'x-cp1256'],
-                name: 'windows-1256'
-            },
-            {
-                labels: ['cp1257', 'windows-1257', 'x-cp1257'],
-                name: 'windows-1257'
-            },
-            {
-                labels: ['cp1258', 'windows-1258', 'x-cp1258'],
-                name: 'windows-1258'
-            },
-            {
-                labels: ['x-mac-cyrillic', 'x-mac-ukrainian'],
-                name: 'x-mac-cyrillic'
-            }
-        ],
-        heading: 'Legacy single-byte encodings'
-    },
-    {
-        encodings: [
-            {
-                labels: [
-                    'chinese',
-                    'csgb2312',
-                    'csiso58gb231280',
-                    'gb2312',
-                    'gb_2312',
-                    'gb_2312-80',
-                    'gbk',
-                    'iso-ir-58',
-                    'x-gbk'
-                ],
-                name: 'GBK'
-            },
-            {
-                labels: ['gb18030'],
-                name: 'gb18030'
-            }
-        ],
-        heading: 'Legacy multi-byte Chinese (simplified) encodings'
-    },
-    {
-        encodings: [
-            {
-                labels: ['big5', 'big5-hkscs', 'cn-big5', 'csbig5', 'x-x-big5'],
-                name: 'Big5'
-            }
-        ],
-        heading: 'Legacy multi-byte Chinese (traditional) encodings'
-    },
-    {
-        encodings: [
-            {
-                labels: ['cseucpkdfmtjapanese', 'euc-jp', 'x-euc-jp'],
-                name: 'EUC-JP'
-            },
-            {
-                labels: ['csiso2022jp', 'iso-2022-jp'],
-                name: 'ISO-2022-JP'
-            },
-            {
-                labels: [
-                    'csshiftjis',
-                    'ms932',
-                    'ms_kanji',
-                    'shift-jis',
-                    'shift_jis',
-                    'sjis',
-                    'windows-31j',
-                    'x-sjis'
-                ],
-                name: 'Shift_JIS'
-            }
-        ],
-        heading: 'Legacy multi-byte Japanese encodings'
-    },
-    {
-        encodings: [
-            {
-                labels: [
-                    'cseuckr',
-                    'csksc56011987',
-                    'euc-kr',
-                    'iso-ir-149',
-                    'korean',
-                    'ks_c_5601-1987',
-                    'ks_c_5601-1989',
-                    'ksc5601',
-                    'ksc_5601',
-                    'windows-949'
-                ],
-                name: 'EUC-KR'
-            }
-        ],
-        heading: 'Legacy multi-byte Korean encodings'
-    },
-    {
-        encodings: [
-            {
-                labels: ['csiso2022kr', 'hz-gb-2312', 'iso-2022-cn', 'iso-2022-cn-ext', 'iso-2022-kr'],
-                name: 'replacement'
-            },
-            {
-                labels: ['utf-16be'],
-                name: 'UTF-16BE'
-            },
-            {
-                labels: ['utf-16', 'utf-16le'],
-                name: 'UTF-16LE'
-            },
-            {
-                labels: ['x-user-defined'],
-                name: 'x-user-defined'
-            }
-        ],
-        heading: 'Legacy miscellaneous encodings'
-    }
-];
-// Label to encoding registry.
-/** @type {Object.<string,{name:string,labels:Array.<string>}>} */
+
+var encodings = [{
+  encodings: [{
+    labels: ['unicode-1-1-utf-8', 'utf-8', 'utf8'],
+    name: 'UTF-8'
+  }],
+  heading: 'The Encoding'
+}, {
+  encodings: [{
+    labels: ['866', 'cp866', 'csibm866', 'ibm866'],
+    name: 'IBM866'
+  }, {
+    labels: ['csisolatin2', 'iso-8859-2', 'iso-ir-101', 'iso8859-2', 'iso88592', 'iso_8859-2', 'iso_8859-2:1987', 'l2', 'latin2'],
+    name: 'ISO-8859-2'
+  }, {
+    labels: ['csisolatin3', 'iso-8859-3', 'iso-ir-109', 'iso8859-3', 'iso88593', 'iso_8859-3', 'iso_8859-3:1988', 'l3', 'latin3'],
+    name: 'ISO-8859-3'
+  }, {
+    labels: ['csisolatin4', 'iso-8859-4', 'iso-ir-110', 'iso8859-4', 'iso88594', 'iso_8859-4', 'iso_8859-4:1988', 'l4', 'latin4'],
+    name: 'ISO-8859-4'
+  }, {
+    labels: ['csisolatincyrillic', 'cyrillic', 'iso-8859-5', 'iso-ir-144', 'iso8859-5', 'iso88595', 'iso_8859-5', 'iso_8859-5:1988'],
+    name: 'ISO-8859-5'
+  }, {
+    labels: ['arabic', 'asmo-708', 'csiso88596e', 'csiso88596i', 'csisolatinarabic', 'ecma-114', 'iso-8859-6', 'iso-8859-6-e', 'iso-8859-6-i', 'iso-ir-127', 'iso8859-6', 'iso88596', 'iso_8859-6', 'iso_8859-6:1987'],
+    name: 'ISO-8859-6'
+  }, {
+    labels: ['csisolatingreek', 'ecma-118', 'elot_928', 'greek', 'greek8', 'iso-8859-7', 'iso-ir-126', 'iso8859-7', 'iso88597', 'iso_8859-7', 'iso_8859-7:1987', 'sun_eu_greek'],
+    name: 'ISO-8859-7'
+  }, {
+    labels: ['csiso88598e', 'csisolatinhebrew', 'hebrew', 'iso-8859-8', 'iso-8859-8-e', 'iso-ir-138', 'iso8859-8', 'iso88598', 'iso_8859-8', 'iso_8859-8:1988', 'visual'],
+    name: 'ISO-8859-8'
+  }, {
+    labels: ['csiso88598i', 'iso-8859-8-i', 'logical'],
+    name: 'ISO-8859-8-I'
+  }, {
+    labels: ['csisolatin6', 'iso-8859-10', 'iso-ir-157', 'iso8859-10', 'iso885910', 'l6', 'latin6'],
+    name: 'ISO-8859-10'
+  }, {
+    labels: ['iso-8859-13', 'iso8859-13', 'iso885913'],
+    name: 'ISO-8859-13'
+  }, {
+    labels: ['iso-8859-14', 'iso8859-14', 'iso885914'],
+    name: 'ISO-8859-14'
+  }, {
+    labels: ['csisolatin9', 'iso-8859-15', 'iso8859-15', 'iso885915', 'iso_8859-15', 'l9'],
+    name: 'ISO-8859-15'
+  }, {
+    labels: ['iso-8859-16'],
+    name: 'ISO-8859-16'
+  }, {
+    labels: ['cskoi8r', 'koi', 'koi8', 'koi8-r', 'koi8_r'],
+    name: 'KOI8-R'
+  }, {
+    labels: ['koi8-ru', 'koi8-u'],
+    name: 'KOI8-U'
+  }, {
+    labels: ['csmacintosh', 'mac', 'macintosh', 'x-mac-roman'],
+    name: 'macintosh'
+  }, {
+    labels: ['dos-874', 'iso-8859-11', 'iso8859-11', 'iso885911', 'tis-620', 'windows-874'],
+    name: 'windows-874'
+  }, {
+    labels: ['cp1250', 'windows-1250', 'x-cp1250'],
+    name: 'windows-1250'
+  }, {
+    labels: ['cp1251', 'windows-1251', 'x-cp1251'],
+    name: 'windows-1251'
+  }, {
+    labels: ['ansi_x3.4-1968', 'ascii', 'cp1252', 'cp819', 'csisolatin1', 'ibm819', 'iso-8859-1', 'iso-ir-100', 'iso8859-1', 'iso88591', 'iso_8859-1', 'iso_8859-1:1987', 'l1', 'latin1', 'us-ascii', 'windows-1252', 'x-cp1252'],
+    name: 'windows-1252'
+  }, {
+    labels: ['cp1253', 'windows-1253', 'x-cp1253'],
+    name: 'windows-1253'
+  }, {
+    labels: ['cp1254', 'csisolatin5', 'iso-8859-9', 'iso-ir-148', 'iso8859-9', 'iso88599', 'iso_8859-9', 'iso_8859-9:1989', 'l5', 'latin5', 'windows-1254', 'x-cp1254'],
+    name: 'windows-1254'
+  }, {
+    labels: ['cp1255', 'windows-1255', 'x-cp1255'],
+    name: 'windows-1255'
+  }, {
+    labels: ['cp1256', 'windows-1256', 'x-cp1256'],
+    name: 'windows-1256'
+  }, {
+    labels: ['cp1257', 'windows-1257', 'x-cp1257'],
+    name: 'windows-1257'
+  }, {
+    labels: ['cp1258', 'windows-1258', 'x-cp1258'],
+    name: 'windows-1258'
+  }, {
+    labels: ['x-mac-cyrillic', 'x-mac-ukrainian'],
+    name: 'x-mac-cyrillic'
+  }],
+  heading: 'Legacy single-byte encodings'
+}, {
+  encodings: [{
+    labels: ['chinese', 'csgb2312', 'csiso58gb231280', 'gb2312', 'gb_2312', 'gb_2312-80', 'gbk', 'iso-ir-58', 'x-gbk'],
+    name: 'GBK'
+  }, {
+    labels: ['gb18030'],
+    name: 'gb18030'
+  }],
+  heading: 'Legacy multi-byte Chinese (simplified) encodings'
+}, {
+  encodings: [{
+    labels: ['big5', 'big5-hkscs', 'cn-big5', 'csbig5', 'x-x-big5'],
+    name: 'Big5'
+  }],
+  heading: 'Legacy multi-byte Chinese (traditional) encodings'
+}, {
+  encodings: [{
+    labels: ['cseucpkdfmtjapanese', 'euc-jp', 'x-euc-jp'],
+    name: 'EUC-JP'
+  }, {
+    labels: ['csiso2022jp', 'iso-2022-jp'],
+    name: 'ISO-2022-JP'
+  }, {
+    labels: ['csshiftjis', 'ms932', 'ms_kanji', 'shift-jis', 'shift_jis', 'sjis', 'windows-31j', 'x-sjis'],
+    name: 'Shift_JIS'
+  }],
+  heading: 'Legacy multi-byte Japanese encodings'
+}, {
+  encodings: [{
+    labels: ['cseuckr', 'csksc56011987', 'euc-kr', 'iso-ir-149', 'korean', 'ks_c_5601-1987', 'ks_c_5601-1989', 'ksc5601', 'ksc_5601', 'windows-949'],
+    name: 'EUC-KR'
+  }],
+  heading: 'Legacy multi-byte Korean encodings'
+}, {
+  encodings: [{
+    labels: ['csiso2022kr', 'hz-gb-2312', 'iso-2022-cn', 'iso-2022-cn-ext', 'iso-2022-kr'],
+    name: 'replacement'
+  }, {
+    labels: ['utf-16be'],
+    name: 'UTF-16BE'
+  }, {
+    labels: ['utf-16', 'utf-16le'],
+    name: 'UTF-16LE'
+  }, {
+    labels: ['x-user-defined'],
+    name: 'x-user-defined'
+  }],
+  heading: 'Legacy miscellaneous encodings'
+}];
 var label_to_encoding = {};
 encodings.forEach(function (category) {
-    category.encodings.forEach(function (encoding) {
-        encoding.labels.forEach(function (label) {
-            label_to_encoding[label] = encoding;
-        });
+  category.encodings.forEach(function (encoding) {
+    encoding.labels.forEach(function (label) {
+      label_to_encoding[label] = encoding;
     });
+  });
 });
-// Registry of of encoder/decoder factories, by encoding name.
-/** @type {Object.<string, function({fatal:boolean}): Encoder>} */
 var encoders = {};
-/** @type {Object.<string, function({fatal:boolean}): Decoder>} */
 var decoders = {};
-//
-// 6. Indexes
-//
-/**
- * @param {number} pointer The |pointer| to search for.
- * @param {(!Array.<?number>|undefined)} index The |index| to search within.
- * @return {?number} The code point corresponding to |pointer| in |index|,
- *     or null if |code point| is not in |index|.
- */
+
 function indexCodePointFor(pointer, index) {
-    if (!index)
-        return null;
-    return index[pointer] || null;
+  if (!index) return null;
+  return index[pointer] || null;
 }
-/**
- * @param {number} code_point The |code point| to search for.
- * @param {!Array.<?number>} index The |index| to search within.
- * @return {?number} The first pointer corresponding to |code point| in
- *     |index|, or null if |code point| is not in |index|.
- */
+
 function indexPointerFor(code_point, index) {
-    var pointer = index.indexOf(code_point);
-    return pointer === -1 ? null : pointer;
+  var pointer = index.indexOf(code_point);
+  return pointer === -1 ? null : pointer;
 }
-/**
- * @param {string} name Name of the index.
- * @return {(!Array.<number>|!Array.<Array.<number>>)}
- *  */
+
 function index(name) {
-    if (!('encoding-indexes' in global)) {
-        throw Error('Indexes missing.' + ' Did you forget to include encoding-indexes.js first?');
-    }
-    return global['encoding-indexes'][name];
+  if (!('encoding-indexes' in global)) {
+    throw Error('Indexes missing.' + ' Did you forget to include encoding-indexes.js first?');
+  }
+
+  return global['encoding-indexes'][name];
 }
-/**
- * @param {number} pointer The |pointer| to search for in the gb18030 index.
- * @return {?number} The code point corresponding to |pointer| in |index|,
- *     or null if |code point| is not in the gb18030 index.
- */
+
 function indexGB18030RangesCodePointFor(pointer) {
-    // 1. If pointer is greater than 39419 and less than 189000, or
-    // pointer is greater than 1237575, return null.
-    if ((pointer > 39419 && pointer < 189000) || pointer > 1237575)
-        return null;
-    // 2. If pointer is 7457, return code point U+E7C7.
-    if (pointer === 7457)
-        return 0xe7c7;
-    // 3. Let offset be the last pointer in index gb18030 ranges that
-    // is equal to or less than pointer and let code point offset be
-    // its corresponding code point.
-    var offset = 0;
-    var code_point_offset = 0;
-    var idx = index('gb18030-ranges');
-    var i;
-    for (i = 0; i < idx.length; ++i) {
-        /** @type {!Array.<number>} */
-        var entry = idx[i];
-        if (entry[0] <= pointer) {
-            offset = entry[0];
-            code_point_offset = entry[1];
-        }
-        else {
-            break;
-        }
+  if (pointer > 39419 && pointer < 189000 || pointer > 1237575) return null;
+  if (pointer === 7457) return 0xe7c7;
+  var offset = 0;
+  var code_point_offset = 0;
+  var idx = index('gb18030-ranges');
+  var i;
+
+  for (i = 0; i < idx.length; ++i) {
+    var entry = idx[i];
+
+    if (entry[0] <= pointer) {
+      offset = entry[0];
+      code_point_offset = entry[1];
+    } else {
+      break;
     }
-    // 4. Return a code point whose value is code point offset +
-    // pointer − offset.
-    return code_point_offset + pointer - offset;
+  }
+
+  return code_point_offset + pointer - offset;
 }
-/**
- * @param {number} code_point The |code point| to locate in the gb18030 index.
- * @return {number} The first pointer corresponding to |code point| in the
- *     gb18030 index.
- */
+
 function indexGB18030RangesPointerFor(code_point) {
-    // 1. If code point is U+E7C7, return pointer 7457.
-    if (code_point === 0xe7c7)
-        return 7457;
-    // 2. Let offset be the last code point in index gb18030 ranges
-    // that is equal to or less than code point and let pointer offset
-    // be its corresponding pointer.
-    var offset = 0;
-    var pointer_offset = 0;
-    var idx = index('gb18030-ranges');
-    var i;
-    for (i = 0; i < idx.length; ++i) {
-        /** @type {!Array.<number>} */
-        var entry = idx[i];
-        if (entry[1] <= code_point) {
-            offset = entry[1];
-            pointer_offset = entry[0];
-        }
-        else {
-            break;
-        }
+  if (code_point === 0xe7c7) return 7457;
+  var offset = 0;
+  var pointer_offset = 0;
+  var idx = index('gb18030-ranges');
+  var i;
+
+  for (i = 0; i < idx.length; ++i) {
+    var entry = idx[i];
+
+    if (entry[1] <= code_point) {
+      offset = entry[1];
+      pointer_offset = entry[0];
+    } else {
+      break;
     }
-    // 3. Return a pointer whose value is pointer offset + code point
-    // − offset.
-    return pointer_offset + code_point - offset;
+  }
+
+  return pointer_offset + code_point - offset;
 }
-/**
- * @param {number} code_point The |code_point| to search for in the Shift_JIS
- *     index.
- * @return {?number} The code point corresponding to |pointer| in |index|,
- *     or null if |code point| is not in the Shift_JIS index.
- */
+
 function indexShiftJISPointerFor(code_point) {
-    // 1. Let index be index jis0208 excluding all entries whose
-    // pointer is in the range 8272 to 8835, inclusive.
-    shift_jis_index =
-        shift_jis_index ||
-            index('jis0208').map(function (code_point, pointer) {
-                return inRange(pointer, 8272, 8835) ? null : code_point;
-            });
-    var index_ = shift_jis_index;
-    // 2. Return the index pointer for code point in index.
-    return index_.indexOf(code_point);
+  shift_jis_index = shift_jis_index || index('jis0208').map(function (code_point, pointer) {
+    return inRange(pointer, 8272, 8835) ? null : code_point;
+  });
+  var index_ = shift_jis_index;
+  return index_.indexOf(code_point);
 }
+
 var shift_jis_index;
-/**
- * @param {number} code_point The |code_point| to search for in the big5
- *     index.
- * @return {?number} The code point corresponding to |pointer| in |index|,
- *     or null if |code point| is not in the big5 index.
- */
+
 function indexBig5PointerFor(code_point) {
-    // 1. Let index be index Big5 excluding all entries whose pointer
-    big5_index_no_hkscs =
-        big5_index_no_hkscs ||
-            index('big5').map(function (code_point, pointer) {
-                return pointer < (0xa1 - 0x81) * 157 ? null : code_point;
-            });
-    var index_ = big5_index_no_hkscs;
-    // 2. If code point is U+2550, U+255E, U+2561, U+256A, U+5341, or
-    // U+5345, return the last pointer corresponding to code point in
-    // index.
-    if (code_point === 0x2550 ||
-        code_point === 0x255e ||
-        code_point === 0x2561 ||
-        code_point === 0x256a ||
-        code_point === 0x5341 ||
-        code_point === 0x5345) {
-        return index_.lastIndexOf(code_point);
-    }
-    // 3. Return the index pointer for code point in index.
-    return indexPointerFor(code_point, index_);
+  big5_index_no_hkscs = big5_index_no_hkscs || index('big5').map(function (code_point, pointer) {
+    return pointer < (0xa1 - 0x81) * 157 ? null : code_point;
+  });
+  var index_ = big5_index_no_hkscs;
+
+  if (code_point === 0x2550 || code_point === 0x255e || code_point === 0x2561 || code_point === 0x256a || code_point === 0x5341 || code_point === 0x5345) {
+    return index_.lastIndexOf(code_point);
+  }
+
+  return indexPointerFor(code_point, index_);
 }
+
 var big5_index_no_hkscs;
-//
-// 8. API
-//
-/** @const */ var DEFAULT_ENCODING = 'utf-8';
-// 8.1 Interface TextDecoder
-/**
- * @constructor
- * @param {string=} label The label of the encoding;
- *     defaults to 'utf-8'.
- * @param {Object=} options
- */
+var DEFAULT_ENCODING = 'utf-8';
+
 function TextDecoder(label, options) {
-    // Web IDL conventions
-    if (!(this instanceof TextDecoder))
-        throw TypeError("Called as a function. Did you forget 'new'?");
-    label = label !== undefined ? String(label) : DEFAULT_ENCODING;
-    options = ToDictionary(options);
-    // A TextDecoder object has an associated encoding, decoder,
-    // stream, ignore BOM flag (initially unset), BOM seen flag
-    // (initially unset), error mode (initially replacement), and do
-    // not flush flag (initially unset).
-    /** @private */
-    this._encoding = null;
-    /** @private @type {?Decoder} */
-    this._decoder = null;
-    /** @private @type {boolean} */
-    this._ignoreBOM = false;
-    /** @private @type {boolean} */
-    this._BOMseen = false;
-    /** @private @type {string} */
-    this._error_mode = 'replacement';
-    /** @private @type {boolean} */
-    this._do_not_flush = false;
-    // 1. Let encoding be the result of getting an encoding from
-    // label.
-    var encoding = getEncoding(label);
-    // 2. If encoding is failure or replacement, throw a RangeError.
-    if (encoding === null || encoding.name === 'replacement')
-        throw RangeError('Unknown encoding: ' + label);
-    if (!decoders[encoding.name]) {
-        throw Error('Decoder not present.' + ' Did you forget to include encoding-indexes.js first?');
-    }
-    // 3. Let dec be a new TextDecoder object.
-    var dec = this;
-    // 4. Set dec's encoding to encoding.
-    dec._encoding = encoding;
-    // 5. If options's fatal member is true, set dec's error mode to
-    // fatal.
-    if (Boolean(options['fatal']))
-        dec._error_mode = 'fatal';
-    // 6. If options's ignoreBOM member is true, set dec's ignore BOM
-    // flag.
-    if (Boolean(options['ignoreBOM']))
-        dec._ignoreBOM = true;
-    // For pre-ES5 runtimes:
-    if (!Object.defineProperty) {
-        this.encoding = dec._encoding.name.toLowerCase();
-        this.fatal = dec._error_mode === 'fatal';
-        this.ignoreBOM = dec._ignoreBOM;
-    }
-    // 7. Return dec.
-    return dec;
+  if (!(this instanceof TextDecoder)) throw TypeError("Called as a function. Did you forget 'new'?");
+  label = label !== undefined ? String(label) : DEFAULT_ENCODING;
+  options = ToDictionary(options);
+  this._encoding = null;
+  this._decoder = null;
+  this._ignoreBOM = false;
+  this._BOMseen = false;
+  this._error_mode = 'replacement';
+  this._do_not_flush = false;
+  var encoding = getEncoding(label);
+  if (encoding === null || encoding.name === 'replacement') throw RangeError('Unknown encoding: ' + label);
+
+  if (!decoders[encoding.name]) {
+    throw Error('Decoder not present.' + ' Did you forget to include encoding-indexes.js first?');
+  }
+
+  var dec = this;
+  dec._encoding = encoding;
+  if (Boolean(options['fatal'])) dec._error_mode = 'fatal';
+  if (Boolean(options['ignoreBOM'])) dec._ignoreBOM = true;
+
+  if (!Object.defineProperty) {
+    this.encoding = dec._encoding.name.toLowerCase();
+    this.fatal = dec._error_mode === 'fatal';
+    this.ignoreBOM = dec._ignoreBOM;
+  }
+
+  return dec;
 }
-exports.TextDecoder = TextDecoder;
+
 if (Object.defineProperty) {
-    // The encoding attribute's getter must return encoding's name.
-    Object.defineProperty(TextDecoder.prototype, 'encoding', {
-        /** @this {TextDecoder} */
-        get: function () {
-            return this._encoding.name.toLowerCase();
-        }
-    });
-    // The fatal attribute's getter must return true if error mode
-    // is fatal, and false otherwise.
-    Object.defineProperty(TextDecoder.prototype, 'fatal', {
-        /** @this {TextDecoder} */
-        get: function () {
-            return this._error_mode === 'fatal';
-        }
-    });
-    // The ignoreBOM attribute's getter must return true if ignore
-    // BOM flag is set, and false otherwise.
-    Object.defineProperty(TextDecoder.prototype, 'ignoreBOM', {
-        /** @this {TextDecoder} */
-        get: function () {
-            return this._ignoreBOM;
-        }
-    });
-}
-/**
- * @param {BufferSource=} input The buffer of bytes to decode.
- * @param {Object=} options
- * @return {string} The decoded string.
- */
-TextDecoder.prototype.decode = function decode(input, options) {
-    var bytes;
-    if (typeof input === 'object' && input instanceof ArrayBuffer) {
-        bytes = new Uint8Array(input);
-    }
-    else if (typeof input === 'object' &&
-        'buffer' in input &&
-        input.buffer instanceof ArrayBuffer) {
-        bytes = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  Object.defineProperty(TextDecoder.prototype, 'encoding', {
+    get: function () {
+      return this._encoding.name.toLowerCase();
     }
-    else {
-        bytes = new Uint8Array(0);
+  });
+  Object.defineProperty(TextDecoder.prototype, 'fatal', {
+    get: function () {
+      return this._error_mode === 'fatal';
     }
-    options = ToDictionary(options);
-    // 1. If the do not flush flag is unset, set decoder to a new
-    // encoding's decoder, set stream to a new stream, and unset the
-    // BOM seen flag.
-    if (!this._do_not_flush) {
-        this._decoder = decoders[this._encoding.name]({
-            fatal: this._error_mode === 'fatal'
-        });
-        this._BOMseen = false;
+  });
+  Object.defineProperty(TextDecoder.prototype, 'ignoreBOM', {
+    get: function () {
+      return this._ignoreBOM;
     }
-    // 2. If options's stream is true, set the do not flush flag, and
-    // unset the do not flush flag otherwise.
-    this._do_not_flush = Boolean(options['stream']);
-    // 3. If input is given, push a copy of input to stream.
-    // TODO: Align with spec algorithm - maintain stream on instance.
-    var input_stream = new Stream(bytes);
-    // 4. Let output be a new stream.
-    var output = [];
-    /** @type {?(number|!Array.<number>)} */
-    var result;
-    // 5. While true:
-    while (true) {
-        // 1. Let token be the result of reading from stream.
-        var token = input_stream.read();
-        // 2. If token is end-of-stream and the do not flush flag is
-        // set, return output, serialized.
-        // TODO: Align with spec algorithm.
-        if (token === end_of_stream)
-            break;
-        // 3. Otherwise, run these subsubsteps:
-        // 1. Let result be the result of processing token for decoder,
-        // stream, output, and error mode.
-        result = this._decoder.handler(input_stream, token);
-        // 2. If result is finished, return output, serialized.
-        if (result === finished)
-            break;
-        if (result !== null) {
-            if (Array.isArray(result))
-                output.push.apply(output, /**@type {!Array.<number>}*/ result);
-            else
-                output.push(result);
-        }
-        // 3. Otherwise, if result is error, throw a TypeError.
-        // (Thrown in handler)
-        // 4. Otherwise, do nothing.
-    }
-    // TODO: Align with spec algorithm.
-    if (!this._do_not_flush) {
-        do {
-            result = this._decoder.handler(input_stream, input_stream.read());
-            if (result === finished)
-                break;
-            if (result === null)
-                continue;
-            if (Array.isArray(result))
-                output.push.apply(output, /**@type {!Array.<number>}*/ result);
-            else
-                output.push(result);
-        } while (!input_stream.endOfStream());
-        this._decoder = null;
+  });
+}
+
+TextDecoder.prototype.decode = function decode(input, options) {
+  var bytes;
+
+  if (typeof input === 'object' && input instanceof ArrayBuffer) {
+    bytes = new Uint8Array(input);
+  } else if (typeof input === 'object' && 'buffer' in input && input.buffer instanceof ArrayBuffer) {
+    bytes = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  } else {
+    bytes = new Uint8Array(0);
+  }
+
+  options = ToDictionary(options);
+
+  if (!this._do_not_flush) {
+    this._decoder = decoders[this._encoding.name]({
+      fatal: this._error_mode === 'fatal'
+    });
+    this._BOMseen = false;
+  }
+
+  this._do_not_flush = Boolean(options['stream']);
+  var input_stream = new Stream(bytes);
+  var output = [];
+  var result;
+
+  while (true) {
+    var token = input_stream.read();
+    if (token === end_of_stream) break;
+    result = this._decoder.handler(input_stream, token);
+    if (result === finished) break;
+
+    if (result !== null) {
+      if (Array.isArray(result)) output.push.apply(output, result);else output.push(result);
     }
-    // A TextDecoder object also has an associated serialize stream
-    // algorithm...
-    /**
-     * @param {!Array.<number>} stream
-     * @return {string}
-     * @this {TextDecoder}
-     */
-    function serializeStream(stream) {
-        // 1. Let token be the result of reading from stream.
-        // (Done in-place on array, rather than as a stream)
-        // 2. If encoding is UTF-8, UTF-16BE, or UTF-16LE, and ignore
-        // BOM flag and BOM seen flag are unset, run these subsubsteps:
-        if (includes(['UTF-8', 'UTF-16LE', 'UTF-16BE'], this._encoding.name) &&
-            !this._ignoreBOM &&
-            !this._BOMseen) {
-            if (stream.length > 0 && stream[0] === 0xfeff) {
-                // 1. If token is U+FEFF, set BOM seen flag.
-                this._BOMseen = true;
-                stream.shift();
-            }
-            else if (stream.length > 0) {
-                // 2. Otherwise, if token is not end-of-stream, set BOM seen
-                // flag and append token to stream.
-                this._BOMseen = true;
-            }
-            else {
-                // 3. Otherwise, if token is not end-of-stream, append token
-                // to output.
-                // (no-op)
-            }
-        }
-        // 4. Otherwise, return output.
-        return codePointsToString(stream);
+  }
+
+  if (!this._do_not_flush) {
+    do {
+      result = this._decoder.handler(input_stream, input_stream.read());
+      if (result === finished) break;
+      if (result === null) continue;
+      if (Array.isArray(result)) output.push.apply(output, result);else output.push(result);
+    } while (!input_stream.endOfStream());
+
+    this._decoder = null;
+  }
+
+  function serializeStream(stream) {
+    if (includes(['UTF-8', 'UTF-16LE', 'UTF-16BE'], this._encoding.name) && !this._ignoreBOM && !this._BOMseen) {
+      if (stream.length > 0 && stream[0] === 0xfeff) {
+        this._BOMseen = true;
+        stream.shift();
+      } else if (stream.length > 0) {
+        this._BOMseen = true;
+      } else {}
     }
-    return serializeStream.call(this, output);
+
+    return codePointsToString(stream);
+  }
+
+  return serializeStream.call(this, output);
 };
-// 8.2 Interface TextEncoder
-/**
- * @constructor
- * @param {string=} label The label of the encoding. NONSTANDARD.
- * @param {Object=} options NONSTANDARD.
- */
+
 function TextEncoder(label, options) {
-    // Web IDL conventions
-    if (!(this instanceof TextEncoder))
-        throw TypeError("Called as a function. Did you forget 'new'?");
-    options = ToDictionary(options);
-    // A TextEncoder object has an associated encoding and encoder.
-    /** @private */
-    this._encoding = null;
-    /** @private @type {?Encoder} */
-    this._encoder = null;
-    // Non-standard
-    /** @private @type {boolean} */
-    this._do_not_flush = false;
-    /** @private @type {string} */
-    this._fatal = Boolean(options['fatal']) ? 'fatal' : 'replacement';
-    // 1. Let enc be a new TextEncoder object.
-    var enc = this;
-    // 2. Set enc's encoding to UTF-8's encoder.
-    if (Boolean(options['NONSTANDARD_allowLegacyEncoding'])) {
-        // NONSTANDARD behavior.
-        label = label !== undefined ? String(label) : DEFAULT_ENCODING;
-        var encoding = getEncoding(label);
-        if (encoding === null || encoding.name === 'replacement')
-            throw RangeError('Unknown encoding: ' + label);
-        if (!encoders[encoding.name]) {
-            throw Error('Encoder not present.' + ' Did you forget to include encoding-indexes.js first?');
-        }
-        enc._encoding = encoding;
+  if (!(this instanceof TextEncoder)) throw TypeError("Called as a function. Did you forget 'new'?");
+  options = ToDictionary(options);
+  this._encoding = null;
+  this._encoder = null;
+  this._do_not_flush = false;
+  this._fatal = Boolean(options['fatal']) ? 'fatal' : 'replacement';
+  var enc = this;
+
+  if (Boolean(options['NONSTANDARD_allowLegacyEncoding'])) {
+    label = label !== undefined ? String(label) : DEFAULT_ENCODING;
+    var encoding = getEncoding(label);
+    if (encoding === null || encoding.name === 'replacement') throw RangeError('Unknown encoding: ' + label);
+
+    if (!encoders[encoding.name]) {
+      throw Error('Encoder not present.' + ' Did you forget to include encoding-indexes.js first?');
     }
-    else {
-        // Standard behavior.
-        enc._encoding = getEncoding('utf-8');
-        if (label !== undefined && 'console' in global) {
-            console.warn('TextEncoder constructor called with encoding label, ' + 'which is ignored.');
-        }
+
+    enc._encoding = encoding;
+  } else {
+    enc._encoding = getEncoding('utf-8');
+
+    if (label !== undefined && 'console' in global) {
+      console.warn('TextEncoder constructor called with encoding label, ' + 'which is ignored.');
     }
-    // For pre-ES5 runtimes:
-    if (!Object.defineProperty)
-        this.encoding = enc._encoding.name.toLowerCase();
-    // 3. Return enc.
-    return enc;
+  }
+
+  if (!Object.defineProperty) this.encoding = enc._encoding.name.toLowerCase();
+  return enc;
 }
-exports.TextEncoder = TextEncoder;
+
 if (Object.defineProperty) {
-    // The encoding attribute's getter must return encoding's name.
-    Object.defineProperty(TextEncoder.prototype, 'encoding', {
-        /** @this {TextEncoder} */
-        get: function () {
-            return this._encoding.name.toLowerCase();
-        }
-    });
+  Object.defineProperty(TextEncoder.prototype, 'encoding', {
+    get: function () {
+      return this._encoding.name.toLowerCase();
+    }
+  });
 }
-/**
- * @param {string=} opt_string The string to encode.
- * @param {Object=} options
- * @return {!Uint8Array} Encoded bytes, as a Uint8Array.
- */
+
 TextEncoder.prototype.encode = function encode(opt_string, options) {
-    opt_string = opt_string === undefined ? '' : String(opt_string);
-    options = ToDictionary(options);
-    // NOTE: This option is nonstandard. None of the encodings
-    // permitted for encoding (i.e. UTF-8, UTF-16) are stateful when
-    // the input is a USVString so streaming is not necessary.
-    if (!this._do_not_flush)
-        this._encoder = encoders[this._encoding.name]({
-            fatal: this._fatal === 'fatal'
-        });
-    this._do_not_flush = Boolean(options['stream']);
-    // 1. Convert input to a stream.
-    var input = new Stream(stringToCodePoints(opt_string));
-    // 2. Let output be a new stream
-    var output = [];
-    /** @type {?(number|!Array.<number>)} */
-    var result;
-    // 3. While true, run these substeps:
+  opt_string = opt_string === undefined ? '' : String(opt_string);
+  options = ToDictionary(options);
+  if (!this._do_not_flush) this._encoder = encoders[this._encoding.name]({
+    fatal: this._fatal === 'fatal'
+  });
+  this._do_not_flush = Boolean(options['stream']);
+  var input = new Stream(stringToCodePoints(opt_string));
+  var output = [];
+  var result;
+
+  while (true) {
+    var token = input.read();
+    if (token === end_of_stream) break;
+    result = this._encoder.handler(input, token);
+    if (result === finished) break;
+    if (Array.isArray(result)) output.push.apply(output, result);else output.push(result);
+  }
+
+  if (!this._do_not_flush) {
     while (true) {
-        // 1. Let token be the result of reading from input.
-        var token = input.read();
-        if (token === end_of_stream)
-            break;
-        // 2. Let result be the result of processing token for encoder,
-        // input, output.
-        result = this._encoder.handler(input, token);
-        if (result === finished)
-            break;
-        if (Array.isArray(result))
-            output.push.apply(output, /**@type {!Array.<number>}*/ result);
-        else
-            output.push(result);
-    }
-    // TODO: Align with spec algorithm.
-    if (!this._do_not_flush) {
-        while (true) {
-            result = this._encoder.handler(input, input.read());
-            if (result === finished)
-                break;
-            if (Array.isArray(result))
-                output.push.apply(output, /**@type {!Array.<number>}*/ result);
-            else
-                output.push(result);
-        }
-        this._encoder = null;
+      result = this._encoder.handler(input, input.read());
+      if (result === finished) break;
+      if (Array.isArray(result)) output.push.apply(output, result);else output.push(result);
     }
-    // 3. If result is finished, convert output into a byte sequence,
-    // and then return a Uint8Array object wrapping an ArrayBuffer
-    // containing output.
-    return new Uint8Array(output);
+
+    this._encoder = null;
+  }
+
+  return new Uint8Array(output);
 };
-//
-// 9. The encoding
-//
-// 9.1 utf-8
-// 9.1.1 utf-8 decoder
-/**
- * @constructor
- * @implements {Decoder}
- * @param {{fatal: boolean}} options
- */
+
 function UTF8Decoder(options) {
-    var fatal = options.fatal;
-    // utf-8's decoder's has an associated utf-8 code point, utf-8
-    // bytes seen, and utf-8 bytes needed (all initially 0), a utf-8
-    // lower boundary (initially 0x80), and a utf-8 upper boundary
-    // (initially 0xBF).
-    var /** @type {number} */ utf8_code_point = 0, 
-    /** @type {number} */ utf8_bytes_seen = 0, 
-    /** @type {number} */ utf8_bytes_needed = 0, 
-    /** @type {number} */ utf8_lower_boundary = 0x80, 
-    /** @type {number} */ utf8_upper_boundary = 0xbf;
-    /**
-     * @param {Stream} stream The stream of bytes being decoded.
-     * @param {number} bite The next byte read from the stream.
-     * @return {?(number|!Array.<number>)} The next code point(s)
-     *     decoded, or null if not enough data exists in the input
-     *     stream to decode a complete code point.
-     */
-    this.handler = function (stream, bite) {
-        // 1. If byte is end-of-stream and utf-8 bytes needed is not 0,
-        // set utf-8 bytes needed to 0 and return error.
-        if (bite === end_of_stream && utf8_bytes_needed !== 0) {
-            utf8_bytes_needed = 0;
-            return decoderError(fatal);
-        }
-        // 2. If byte is end-of-stream, return finished.
-        if (bite === end_of_stream)
-            return finished;
-        // 3. If utf-8 bytes needed is 0, based on byte:
-        if (utf8_bytes_needed === 0) {
-            // 0x00 to 0x7F
-            if (inRange(bite, 0x00, 0x7f)) {
-                // Return a code point whose value is byte.
-                return bite;
-            }
-            // 0xC2 to 0xDF
-            else if (inRange(bite, 0xc2, 0xdf)) {
-                // 1. Set utf-8 bytes needed to 1.
-                utf8_bytes_needed = 1;
-                // 2. Set UTF-8 code point to byte & 0x1F.
-                utf8_code_point = bite & 0x1f;
-            }
-            // 0xE0 to 0xEF
-            else if (inRange(bite, 0xe0, 0xef)) {
-                // 1. If byte is 0xE0, set utf-8 lower boundary to 0xA0.
-                if (bite === 0xe0)
-                    utf8_lower_boundary = 0xa0;
-                // 2. If byte is 0xED, set utf-8 upper boundary to 0x9F.
-                if (bite === 0xed)
-                    utf8_upper_boundary = 0x9f;
-                // 3. Set utf-8 bytes needed to 2.
-                utf8_bytes_needed = 2;
-                // 4. Set UTF-8 code point to byte & 0xF.
-                utf8_code_point = bite & 0xf;
-            }
-            // 0xF0 to 0xF4
-            else if (inRange(bite, 0xf0, 0xf4)) {
-                // 1. If byte is 0xF0, set utf-8 lower boundary to 0x90.
-                if (bite === 0xf0)
-                    utf8_lower_boundary = 0x90;
-                // 2. If byte is 0xF4, set utf-8 upper boundary to 0x8F.
-                if (bite === 0xf4)
-                    utf8_upper_boundary = 0x8f;
-                // 3. Set utf-8 bytes needed to 3.
-                utf8_bytes_needed = 3;
-                // 4. Set UTF-8 code point to byte & 0x7.
-                utf8_code_point = bite & 0x7;
-            }
-            // Otherwise
-            else {
-                // Return error.
+  var fatal = options.fatal;
+  var utf8_code_point = 0,
+      utf8_bytes_seen = 0,
+      utf8_bytes_needed = 0,
+      utf8_lower_boundary = 0x80,
+      utf8_upper_boundary = 0xbf;
+
+  this.handler = function (stream, bite) {
+    if (bite === end_of_stream && utf8_bytes_needed !== 0) {
+      utf8_bytes_needed = 0;
+      return decoderError(fatal);
+    }
+
+    if (bite === end_of_stream) return finished;
+
+    if (utf8_bytes_needed === 0) {
+      if (inRange(bite, 0x00, 0x7f)) {
+        return bite;
+      } else if (inRange(bite, 0xc2, 0xdf)) {
+          utf8_bytes_needed = 1;
+          utf8_code_point = bite & 0x1f;
+        } else if (inRange(bite, 0xe0, 0xef)) {
+            if (bite === 0xe0) utf8_lower_boundary = 0xa0;
+            if (bite === 0xed) utf8_upper_boundary = 0x9f;
+            utf8_bytes_needed = 2;
+            utf8_code_point = bite & 0xf;
+          } else if (inRange(bite, 0xf0, 0xf4)) {
+              if (bite === 0xf0) utf8_lower_boundary = 0x90;
+              if (bite === 0xf4) utf8_upper_boundary = 0x8f;
+              utf8_bytes_needed = 3;
+              utf8_code_point = bite & 0x7;
+            } else {
                 return decoderError(fatal);
-            }
-            // Return continue.
-            return null;
-        }
-        // 4. If byte is not in the range utf-8 lower boundary to utf-8
-        // upper boundary, inclusive, run these substeps:
-        if (!inRange(bite, utf8_lower_boundary, utf8_upper_boundary)) {
-            // 1. Set utf-8 code point, utf-8 bytes needed, and utf-8
-            // bytes seen to 0, set utf-8 lower boundary to 0x80, and set
-            // utf-8 upper boundary to 0xBF.
-            utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;
-            utf8_lower_boundary = 0x80;
-            utf8_upper_boundary = 0xbf;
-            // 2. Prepend byte to stream.
-            stream.prepend(bite);
-            // 3. Return error.
-            return decoderError(fatal);
-        }
-        // 5. Set utf-8 lower boundary to 0x80 and utf-8 upper boundary
-        // to 0xBF.
-        utf8_lower_boundary = 0x80;
-        utf8_upper_boundary = 0xbf;
-        // 6. Set UTF-8 code point to (UTF-8 code point << 6) | (byte &
-        // 0x3F)
-        utf8_code_point = (utf8_code_point << 6) | (bite & 0x3f);
-        // 7. Increase utf-8 bytes seen by one.
-        utf8_bytes_seen += 1;
-        // 8. If utf-8 bytes seen is not equal to utf-8 bytes needed,
-        // continue.
-        if (utf8_bytes_seen !== utf8_bytes_needed)
-            return null;
-        // 9. Let code point be utf-8 code point.
-        var code_point = utf8_code_point;
-        // 10. Set utf-8 code point, utf-8 bytes needed, and utf-8 bytes
-        // seen to 0.
-        utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;
-        // 11. Return a code point whose value is code point.
-        return code_point;
-    };
+              }
+
+      return null;
+    }
+
+    if (!inRange(bite, utf8_lower_boundary, utf8_upper_boundary)) {
+      utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;
+      utf8_lower_boundary = 0x80;
+      utf8_upper_boundary = 0xbf;
+      stream.prepend(bite);
+      return decoderError(fatal);
+    }
+
+    utf8_lower_boundary = 0x80;
+    utf8_upper_boundary = 0xbf;
+    utf8_code_point = utf8_code_point << 6 | bite & 0x3f;
+    utf8_bytes_seen += 1;
+    if (utf8_bytes_seen !== utf8_bytes_needed) return null;
+    var code_point = utf8_code_point;
+    utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;
+    return code_point;
+  };
 }
-// 9.1.2 utf-8 encoder
-/**
- * @constructor
- * @implements {Encoder}
- * @param {{fatal: boolean}} options
- */
+
 function UTF8Encoder(options) {
-    var fatal = options.fatal;
-    /**
-     * @param {Stream} stream Input stream.
-     * @param {number} code_point Next code point read from the stream.
-     * @return {(number|!Array.<number>)} Byte(s) to emit.
-     */
-    this.handler = function (stream, code_point) {
-        // 1. If code point is end-of-stream, return finished.
-        if (code_point === end_of_stream)
-            return finished;
-        // 2. If code point is an ASCII code point, return a byte whose
-        // value is code point.
-        if (isASCIICodePoint(code_point))
-            return code_point;
-        // 3. Set count and offset based on the range code point is in:
-        var count, offset;
-        // U+0080 to U+07FF, inclusive:
-        if (inRange(code_point, 0x0080, 0x07ff)) {
-            // 1 and 0xC0
-            count = 1;
-            offset = 0xc0;
-        }
-        // U+0800 to U+FFFF, inclusive:
-        else if (inRange(code_point, 0x0800, 0xffff)) {
-            // 2 and 0xE0
-            count = 2;
-            offset = 0xe0;
-        }
-        // U+10000 to U+10FFFF, inclusive:
-        else if (inRange(code_point, 0x10000, 0x10ffff)) {
-            // 3 and 0xF0
-            count = 3;
-            offset = 0xf0;
-        }
-        // 4. Let bytes be a byte sequence whose first byte is (code
-        // point >> (6 × count)) + offset.
-        var bytes = [(code_point >> (6 * count)) + offset];
-        // 5. Run these substeps while count is greater than 0:
-        while (count > 0) {
-            // 1. Set temp to code point >> (6 × (count − 1)).
-            var temp = code_point >> (6 * (count - 1));
-            // 2. Append to bytes 0x80 | (temp & 0x3F).
-            bytes.push(0x80 | (temp & 0x3f));
-            // 3. Decrease count by one.
-            count -= 1;
-        }
-        // 6. Return bytes bytes, in order.
-        return bytes;
-    };
+  var fatal = options.fatal;
+
+  this.handler = function (stream, code_point) {
+    if (code_point === end_of_stream) return finished;
+    if (isASCIICodePoint(code_point)) return code_point;
+    var count, offset;
+
+    if (inRange(code_point, 0x0080, 0x07ff)) {
+      count = 1;
+      offset = 0xc0;
+    } else if (inRange(code_point, 0x0800, 0xffff)) {
+        count = 2;
+        offset = 0xe0;
+      } else if (inRange(code_point, 0x10000, 0x10ffff)) {
+          count = 3;
+          offset = 0xf0;
+        }
+
+    var bytes = [(code_point >> 6 * count) + offset];
+
+    while (count > 0) {
+      var temp = code_point >> 6 * (count - 1);
+      bytes.push(0x80 | temp & 0x3f);
+      count -= 1;
+    }
+
+    return bytes;
+  };
 }
-/** @param {{fatal: boolean}} options */
+
 encoders['UTF-8'] = function (options) {
-    return new UTF8Encoder(options);
+  return new UTF8Encoder(options);
 };
-/** @param {{fatal: boolean}} options */
+
 decoders['UTF-8'] = function (options) {
-    return new UTF8Decoder(options);
+  return new UTF8Decoder(options);
 };
-//
-// 10. Legacy single-byte encodings
-//
-// 10.1 single-byte decoder
-/**
- * @constructor
- * @implements {Decoder}
- * @param {!Array.<number>} index The encoding index.
- * @param {{fatal: boolean}} options
- */
+
 function SingleByteDecoder(index, options) {
-    var fatal = options.fatal;
-    /**
-     * @param {Stream} stream The stream of bytes being decoded.
-     * @param {number} bite The next byte read from the stream.
-     * @return {?(number|!Array.<number>)} The next code point(s)
-     *     decoded, or null if not enough data exists in the input
-     *     stream to decode a complete code point.
-     */
-    this.handler = function (stream, bite) {
-        // 1. If byte is end-of-stream, return finished.
-        if (bite === end_of_stream)
-            return finished;
-        // 2. If byte is an ASCII byte, return a code point whose value
-        // is byte.
-        if (isASCIIByte(bite))
-            return bite;
-        // 3. Let code point be the index code point for byte − 0x80 in
-        // index single-byte.
-        var code_point = index[bite - 0x80];
-        // 4. If code point is null, return error.
-        if (code_point === null)
-            return decoderError(fatal);
-        // 5. Return a code point whose value is code point.
-        return code_point;
-    };
+  var fatal = options.fatal;
+
+  this.handler = function (stream, bite) {
+    if (bite === end_of_stream) return finished;
+    if (isASCIIByte(bite)) return bite;
+    var code_point = index[bite - 0x80];
+    if (code_point === null) return decoderError(fatal);
+    return code_point;
+  };
 }
-// 10.2 single-byte encoder
-/**
- * @constructor
- * @implements {Encoder}
- * @param {!Array.<?number>} index The encoding index.
- * @param {{fatal: boolean}} options
- */
+
 function SingleByteEncoder(index, options) {
-    var fatal = options.fatal;
-    /**
-     * @param {Stream} stream Input stream.
-     * @param {number} code_point Next code point read from the stream.
-     * @return {(number|!Array.<number>)} Byte(s) to emit.
-     */
-    this.handler = function (stream, code_point) {
-        // 1. If code point is end-of-stream, return finished.
-        if (code_point === end_of_stream)
-            return finished;
-        // 2. If code point is an ASCII code point, return a byte whose
-        // value is code point.
-        if (isASCIICodePoint(code_point))
-            return code_point;
-        // 3. Let pointer be the index pointer for code point in index
-        // single-byte.
-        var pointer = indexPointerFor(code_point, index);
-        // 4. If pointer is null, return error with code point.
-        if (pointer === null)
-            encoderError(code_point);
-        // 5. Return a byte whose value is pointer + 0x80.
-        return pointer + 0x80;
-    };
+  var fatal = options.fatal;
+
+  this.handler = function (stream, code_point) {
+    if (code_point === end_of_stream) return finished;
+    if (isASCIICodePoint(code_point)) return code_point;
+    var pointer = indexPointerFor(code_point, index);
+    if (pointer === null) encoderError(code_point);
+    return pointer + 0x80;
+  };
 }
+
 (function () {
-    if (!('encoding-indexes' in global))
-        return;
-    encodings.forEach(function (category) {
-        if (category.heading !== 'Legacy single-byte encodings')
-            return;
-        category.encodings.forEach(function (encoding) {
-            var name = encoding.name;
-            var idx = index(name.toLowerCase());
-            /** @param {{fatal: boolean}} options */
-            decoders[name] = function (options) {
-                return new SingleByteDecoder(idx, options);
-            };
-            /** @param {{fatal: boolean}} options */
-            encoders[name] = function (options) {
-                return new SingleByteEncoder(idx, options);
-            };
-        });
+  if (!('encoding-indexes' in global)) return;
+  encodings.forEach(function (category) {
+    if (category.heading !== 'Legacy single-byte encodings') return;
+    category.encodings.forEach(function (encoding) {
+      var name = encoding.name;
+      var idx = index(name.toLowerCase());
+
+      decoders[name] = function (options) {
+        return new SingleByteDecoder(idx, options);
+      };
+
+      encoders[name] = function (options) {
+        return new SingleByteEncoder(idx, options);
+      };
     });
+  });
 })();
-//
-// 11. Legacy multi-byte Chinese (simplified) encodings
-//
-// 11.1 gbk
-// 11.1.1 gbk decoder
-// gbk's decoder is gb18030's decoder.
-/** @param {{fatal: boolean}} options */
+
 decoders['GBK'] = function (options) {
-    return new GB18030Decoder(options);
+  return new GB18030Decoder(options);
 };
-// 11.1.2 gbk encoder
-// gbk's encoder is gb18030's encoder with its gbk flag set.
-/** @param {{fatal: boolean}} options */
+
 encoders['GBK'] = function (options) {
-    return new GB18030Encoder(options, true);
+  return new GB18030Encoder(options, true);
 };
-// 11.2 gb18030
-// 11.2.1 gb18030 decoder
-/**
- * @constructor
- * @implements {Decoder}
- * @param {{fatal: boolean}} options
- */
+
 function GB18030Decoder(options) {
-    var fatal = options.fatal;
-    // gb18030's decoder has an associated gb18030 first, gb18030
-    // second, and gb18030 third (all initially 0x00).
-    var /** @type {number} */ gb18030_first = 0x00, 
-    /** @type {number} */ gb18030_second = 0x00, 
-    /** @type {number} */ gb18030_third = 0x00;
-    /**
-     * @param {Stream} stream The stream of bytes being decoded.
-     * @param {number} bite The next byte read from the stream.
-     * @return {?(number|!Array.<number>)} The next code point(s)
-     *     decoded, or null if not enough data exists in the input
-     *     stream to decode a complete code point.
-     */
-    this.handler = function (stream, bite) {
-        // 1. If byte is end-of-stream and gb18030 first, gb18030
-        // second, and gb18030 third are 0x00, return finished.
-        if (bite === end_of_stream &&
-            gb18030_first === 0x00 &&
-            gb18030_second === 0x00 &&
-            gb18030_third === 0x00) {
-            return finished;
-        }
-        // 2. If byte is end-of-stream, and gb18030 first, gb18030
-        // second, or gb18030 third is not 0x00, set gb18030 first,
-        // gb18030 second, and gb18030 third to 0x00, and return error.
-        if (bite === end_of_stream &&
-            (gb18030_first !== 0x00 || gb18030_second !== 0x00 || gb18030_third !== 0x00)) {
-            gb18030_first = 0x00;
-            gb18030_second = 0x00;
-            gb18030_third = 0x00;
-            decoderError(fatal);
-        }
-        var code_point;
-        // 3. If gb18030 third is not 0x00, run these substeps:
-        if (gb18030_third !== 0x00) {
-            // 1. Let code point be null.
-            code_point = null;
-            // 2. If byte is in the range 0x30 to 0x39, inclusive, set
-            // code point to the index gb18030 ranges code point for
-            // (((gb18030 first − 0x81) × 10 + gb18030 second − 0x30) ×
-            // 126 + gb18030 third − 0x81) × 10 + byte − 0x30.
-            if (inRange(bite, 0x30, 0x39)) {
-                code_point = indexGB18030RangesCodePointFor((((gb18030_first - 0x81) * 10 + gb18030_second - 0x30) * 126 + gb18030_third - 0x81) *
-                    10 +
-                    bite -
-                    0x30);
-            }
-            // 3. Let buffer be a byte sequence consisting of gb18030
-            // second, gb18030 third, and byte, in order.
-            var buffer = [gb18030_second, gb18030_third, bite];
-            // 4. Set gb18030 first, gb18030 second, and gb18030 third to
-            // 0x00.
-            gb18030_first = 0x00;
-            gb18030_second = 0x00;
-            gb18030_third = 0x00;
-            // 5. If code point is null, prepend buffer to stream and
-            // return error.
-            if (code_point === null) {
-                stream.prepend(buffer);
-                return decoderError(fatal);
-            }
-            // 6. Return a code point whose value is code point.
-            return code_point;
-        }
-        // 4. If gb18030 second is not 0x00, run these substeps:
-        if (gb18030_second !== 0x00) {
-            // 1. If byte is in the range 0x81 to 0xFE, inclusive, set
-            // gb18030 third to byte and return continue.
-            if (inRange(bite, 0x81, 0xfe)) {
-                gb18030_third = bite;
-                return null;
-            }
-            // 2. Prepend gb18030 second followed by byte to stream, set
-            // gb18030 first and gb18030 second to 0x00, and return error.
-            stream.prepend([gb18030_second, bite]);
-            gb18030_first = 0x00;
-            gb18030_second = 0x00;
-            return decoderError(fatal);
-        }
-        // 5. If gb18030 first is not 0x00, run these substeps:
-        if (gb18030_first !== 0x00) {
-            // 1. If byte is in the range 0x30 to 0x39, inclusive, set
-            // gb18030 second to byte and return continue.
-            if (inRange(bite, 0x30, 0x39)) {
-                gb18030_second = bite;
-                return null;
-            }
-            // 2. Let lead be gb18030 first, let pointer be null, and set
-            // gb18030 first to 0x00.
-            var lead = gb18030_first;
-            var pointer = null;
-            gb18030_first = 0x00;
-            // 3. Let offset be 0x40 if byte is less than 0x7F and 0x41
-            // otherwise.
-            var offset = bite < 0x7f ? 0x40 : 0x41;
-            // 4. If byte is in the range 0x40 to 0x7E, inclusive, or 0x80
-            // to 0xFE, inclusive, set pointer to (lead − 0x81) × 190 +
-            // (byte − offset).
-            if (inRange(bite, 0x40, 0x7e) || inRange(bite, 0x80, 0xfe))
-                pointer = (lead - 0x81) * 190 + (bite - offset);
-            // 5. Let code point be null if pointer is null and the index
-            // code point for pointer in index gb18030 otherwise.
-            code_point = pointer === null ? null : indexCodePointFor(pointer, index('gb18030'));
-            // 6. If code point is null and byte is an ASCII byte, prepend
-            // byte to stream.
-            if (code_point === null && isASCIIByte(bite))
-                stream.prepend(bite);
-            // 7. If code point is null, return error.
-            if (code_point === null)
-                return decoderError(fatal);
-            // 8. Return a code point whose value is code point.
-            return code_point;
-        }
-        // 6. If byte is an ASCII byte, return a code point whose value
-        // is byte.
-        if (isASCIIByte(bite))
-            return bite;
-        // 7. If byte is 0x80, return code point U+20AC.
-        if (bite === 0x80)
-            return 0x20ac;
-        // 8. If byte is in the range 0x81 to 0xFE, inclusive, set
-        // gb18030 first to byte and return continue.
-        if (inRange(bite, 0x81, 0xfe)) {
-            gb18030_first = bite;
-            return null;
-        }
-        // 9. Return error.
+  var fatal = options.fatal;
+  var gb18030_first = 0x00,
+      gb18030_second = 0x00,
+      gb18030_third = 0x00;
+
+  this.handler = function (stream, bite) {
+    if (bite === end_of_stream && gb18030_first === 0x00 && gb18030_second === 0x00 && gb18030_third === 0x00) {
+      return finished;
+    }
+
+    if (bite === end_of_stream && (gb18030_first !== 0x00 || gb18030_second !== 0x00 || gb18030_third !== 0x00)) {
+      gb18030_first = 0x00;
+      gb18030_second = 0x00;
+      gb18030_third = 0x00;
+      decoderError(fatal);
+    }
+
+    var code_point;
+
+    if (gb18030_third !== 0x00) {
+      code_point = null;
+
+      if (inRange(bite, 0x30, 0x39)) {
+        code_point = indexGB18030RangesCodePointFor((((gb18030_first - 0x81) * 10 + gb18030_second - 0x30) * 126 + gb18030_third - 0x81) * 10 + bite - 0x30);
+      }
+
+      var buffer = [gb18030_second, gb18030_third, bite];
+      gb18030_first = 0x00;
+      gb18030_second = 0x00;
+      gb18030_third = 0x00;
+
+      if (code_point === null) {
+        stream.prepend(buffer);
         return decoderError(fatal);
-    };
+      }
+
+      return code_point;
+    }
+
+    if (gb18030_second !== 0x00) {
+      if (inRange(bite, 0x81, 0xfe)) {
+        gb18030_third = bite;
+        return null;
+      }
+
+      stream.prepend([gb18030_second, bite]);
+      gb18030_first = 0x00;
+      gb18030_second = 0x00;
+      return decoderError(fatal);
+    }
+
+    if (gb18030_first !== 0x00) {
+      if (inRange(bite, 0x30, 0x39)) {
+        gb18030_second = bite;
+        return null;
+      }
+
+      var lead = gb18030_first;
+      var pointer = null;
+      gb18030_first = 0x00;
+      var offset = bite < 0x7f ? 0x40 : 0x41;
+      if (inRange(bite, 0x40, 0x7e) || inRange(bite, 0x80, 0xfe)) pointer = (lead - 0x81) * 190 + (bite - offset);
+      code_point = pointer === null ? null : indexCodePointFor(pointer, index('gb18030'));
+      if (code_point === null && isASCIIByte(bite)) stream.prepend(bite);
+      if (code_point === null) return decoderError(fatal);
+      return code_point;
+    }
+
+    if (isASCIIByte(bite)) return bite;
+    if (bite === 0x80) return 0x20ac;
+
+    if (inRange(bite, 0x81, 0xfe)) {
+      gb18030_first = bite;
+      return null;
+    }
+
+    return decoderError(fatal);
+  };
 }
-// 11.2.2 gb18030 encoder
-/**
- * @constructor
- * @implements {Encoder}
- * @param {{fatal: boolean}} options
- * @param {boolean=} gbk_flag
- */
+
 function GB18030Encoder(options, gbk_flag) {
-    var fatal = options.fatal;
-    // gb18030's decoder has an associated gbk flag (initially unset).
-    /**
-     * @param {Stream} stream Input stream.
-     * @param {number} code_point Next code point read from the stream.
-     * @return {(number|!Array.<number>)} Byte(s) to emit.
-     */
-    this.handler = function (stream, code_point) {
-        // 1. If code point is end-of-stream, return finished.
-        if (code_point === end_of_stream)
-            return finished;
-        // 2. If code point is an ASCII code point, return a byte whose
-        // value is code point.
-        if (isASCIICodePoint(code_point))
-            return code_point;
-        // 3. If code point is U+E5E5, return error with code point.
-        if (code_point === 0xe5e5)
-            return encoderError(code_point);
-        // 4. If the gbk flag is set and code point is U+20AC, return
-        // byte 0x80.
-        if (gbk_flag && code_point === 0x20ac)
-            return 0x80;
-        // 5. Let pointer be the index pointer for code point in index
-        // gb18030.
-        var pointer = indexPointerFor(code_point, index('gb18030'));
-        // 6. If pointer is not null, run these substeps:
-        if (pointer !== null) {
-            // 1. Let lead be floor(pointer / 190) + 0x81.
-            var lead = floor(pointer / 190) + 0x81;
-            // 2. Let trail be pointer % 190.
-            var trail = pointer % 190;
-            // 3. Let offset be 0x40 if trail is less than 0x3F and 0x41 otherwise.
-            var offset = trail < 0x3f ? 0x40 : 0x41;
-            // 4. Return two bytes whose values are lead and trail + offset.
-            return [lead, trail + offset];
-        }
-        // 7. If gbk flag is set, return error with code point.
-        if (gbk_flag)
-            return encoderError(code_point);
-        // 8. Set pointer to the index gb18030 ranges pointer for code
-        // point.
-        pointer = indexGB18030RangesPointerFor(code_point);
-        // 9. Let byte1 be floor(pointer / 10 / 126 / 10).
-        var byte1 = floor(pointer / 10 / 126 / 10);
-        // 10. Set pointer to pointer − byte1 × 10 × 126 × 10.
-        pointer = pointer - byte1 * 10 * 126 * 10;
-        // 11. Let byte2 be floor(pointer / 10 / 126).
-        var byte2 = floor(pointer / 10 / 126);
-        // 12. Set pointer to pointer − byte2 × 10 × 126.
-        pointer = pointer - byte2 * 10 * 126;
-        // 13. Let byte3 be floor(pointer / 10).
-        var byte3 = floor(pointer / 10);
-        // 14. Let byte4 be pointer − byte3 × 10.
-        var byte4 = pointer - byte3 * 10;
-        // 15. Return four bytes whose values are byte1 + 0x81, byte2 +
-        // 0x30, byte3 + 0x81, byte4 + 0x30.
-        return [byte1 + 0x81, byte2 + 0x30, byte3 + 0x81, byte4 + 0x30];
-    };
+  var fatal = options.fatal;
+
+  this.handler = function (stream, code_point) {
+    if (code_point === end_of_stream) return finished;
+    if (isASCIICodePoint(code_point)) return code_point;
+    if (code_point === 0xe5e5) return encoderError(code_point);
+    if (gbk_flag && code_point === 0x20ac) return 0x80;
+    var pointer = indexPointerFor(code_point, index('gb18030'));
+
+    if (pointer !== null) {
+      var lead = floor(pointer / 190) + 0x81;
+      var trail = pointer % 190;
+      var offset = trail < 0x3f ? 0x40 : 0x41;
+      return [lead, trail + offset];
+    }
+
+    if (gbk_flag) return encoderError(code_point);
+    pointer = indexGB18030RangesPointerFor(code_point);
+    var byte1 = floor(pointer / 10 / 126 / 10);
+    pointer = pointer - byte1 * 10 * 126 * 10;
+    var byte2 = floor(pointer / 10 / 126);
+    pointer = pointer - byte2 * 10 * 126;
+    var byte3 = floor(pointer / 10);
+    var byte4 = pointer - byte3 * 10;
+    return [byte1 + 0x81, byte2 + 0x30, byte3 + 0x81, byte4 + 0x30];
+  };
 }
-/** @param {{fatal: boolean}} options */
+
 encoders['gb18030'] = function (options) {
-    return new GB18030Encoder(options);
+  return new GB18030Encoder(options);
 };
-/** @param {{fatal: boolean}} options */
+
 decoders['gb18030'] = function (options) {
-    return new GB18030Decoder(options);
+  return new GB18030Decoder(options);
 };
-//
-// 12. Legacy multi-byte Chinese (traditional) encodings
-//
-// 12.1 Big5
-// 12.1.1 Big5 decoder
-/**
- * @constructor
- * @implements {Decoder}
- * @param {{fatal: boolean}} options
- */
+
 function Big5Decoder(options) {
-    var fatal = options.fatal;
-    // Big5's decoder has an associated Big5 lead (initially 0x00).
-    var /** @type {number} */ Big5_lead = 0x00;
-    /**
-     * @param {Stream} stream The stream of bytes being decoded.
-     * @param {number} bite The next byte read from the stream.
-     * @return {?(number|!Array.<number>)} The next code point(s)
-     *     decoded, or null if not enough data exists in the input
-     *     stream to decode a complete code point.
-     */
-    this.handler = function (stream, bite) {
-        // 1. If byte is end-of-stream and Big5 lead is not 0x00, set
-        // Big5 lead to 0x00 and return error.
-        if (bite === end_of_stream && Big5_lead !== 0x00) {
-            Big5_lead = 0x00;
-            return decoderError(fatal);
-        }
-        // 2. If byte is end-of-stream and Big5 lead is 0x00, return
-        // finished.
-        if (bite === end_of_stream && Big5_lead === 0x00)
-            return finished;
-        // 3. If Big5 lead is not 0x00, let lead be Big5 lead, let
-        // pointer be null, set Big5 lead to 0x00, and then run these
-        // substeps:
-        if (Big5_lead !== 0x00) {
-            var lead = Big5_lead;
-            var pointer = null;
-            Big5_lead = 0x00;
-            // 1. Let offset be 0x40 if byte is less than 0x7F and 0x62
-            // otherwise.
-            var offset = bite < 0x7f ? 0x40 : 0x62;
-            // 2. If byte is in the range 0x40 to 0x7E, inclusive, or 0xA1
-            // to 0xFE, inclusive, set pointer to (lead − 0x81) × 157 +
-            // (byte − offset).
-            if (inRange(bite, 0x40, 0x7e) || inRange(bite, 0xa1, 0xfe))
-                pointer = (lead - 0x81) * 157 + (bite - offset);
-            // 3. If there is a row in the table below whose first column
-            // is pointer, return the two code points listed in its second
-            // column
-            // Pointer | Code points
-            // --------+--------------
-            // 1133    | U+00CA U+0304
-            // 1135    | U+00CA U+030C
-            // 1164    | U+00EA U+0304
-            // 1166    | U+00EA U+030C
-            switch (pointer) {
-                case 1133:
-                    return [0x00ca, 0x0304];
-                case 1135:
-                    return [0x00ca, 0x030c];
-                case 1164:
-                    return [0x00ea, 0x0304];
-                case 1166:
-                    return [0x00ea, 0x030c];
-            }
-            // 4. Let code point be null if pointer is null and the index
-            // code point for pointer in index Big5 otherwise.
-            var code_point = pointer === null ? null : indexCodePointFor(pointer, index('big5'));
-            // 5. If code point is null and byte is an ASCII byte, prepend
-            // byte to stream.
-            if (code_point === null && isASCIIByte(bite))
-                stream.prepend(bite);
-            // 6. If code point is null, return error.
-            if (code_point === null)
-                return decoderError(fatal);
-            // 7. Return a code point whose value is code point.
-            return code_point;
-        }
-        // 4. If byte is an ASCII byte, return a code point whose value
-        // is byte.
-        if (isASCIIByte(bite))
-            return bite;
-        // 5. If byte is in the range 0x81 to 0xFE, inclusive, set Big5
-        // lead to byte and return continue.
-        if (inRange(bite, 0x81, 0xfe)) {
-            Big5_lead = bite;
-            return null;
-        }
-        // 6. Return error.
-        return decoderError(fatal);
-    };
+  var fatal = options.fatal;
+  var Big5_lead = 0x00;
+
+  this.handler = function (stream, bite) {
+    if (bite === end_of_stream && Big5_lead !== 0x00) {
+      Big5_lead = 0x00;
+      return decoderError(fatal);
+    }
+
+    if (bite === end_of_stream && Big5_lead === 0x00) return finished;
+
+    if (Big5_lead !== 0x00) {
+      var lead = Big5_lead;
+      var pointer = null;
+      Big5_lead = 0x00;
+      var offset = bite < 0x7f ? 0x40 : 0x62;
+      if (inRange(bite, 0x40, 0x7e) || inRange(bite, 0xa1, 0xfe)) pointer = (lead - 0x81) * 157 + (bite - offset);
+
+      switch (pointer) {
+        case 1133:
+          return [0x00ca, 0x0304];
+
+        case 1135:
+          return [0x00ca, 0x030c];
+
+        case 1164:
+          return [0x00ea, 0x0304];
+
+        case 1166:
+          return [0x00ea, 0x030c];
+      }
+
+      var code_point = pointer === null ? null : indexCodePointFor(pointer, index('big5'));
+      if (code_point === null && isASCIIByte(bite)) stream.prepend(bite);
+      if (code_point === null) return decoderError(fatal);
+      return code_point;
+    }
+
+    if (isASCIIByte(bite)) return bite;
+
+    if (inRange(bite, 0x81, 0xfe)) {
+      Big5_lead = bite;
+      return null;
+    }
+
+    return decoderError(fatal);
+  };
 }
-// 12.1.2 Big5 encoder
-/**
- * @constructor
- * @implements {Encoder}
- * @param {{fatal: boolean}} options
- */
+
 function Big5Encoder(options) {
-    var fatal = options.fatal;
-    /**
-     * @param {Stream} stream Input stream.
-     * @param {number} code_point Next code point read from the stream.
-     * @return {(number|!Array.<number>)} Byte(s) to emit.
-     */
-    this.handler = function (stream, code_point) {
-        // 1. If code point is end-of-stream, return finished.
-        if (code_point === end_of_stream)
-            return finished;
-        // 2. If code point is an ASCII code point, return a byte whose
-        // value is code point.
-        if (isASCIICodePoint(code_point))
-            return code_point;
-        // 3. Let pointer be the index Big5 pointer for code point.
-        var pointer = indexBig5PointerFor(code_point);
-        // 4. If pointer is null, return error with code point.
-        if (pointer === null)
-            return encoderError(code_point);
-        // 5. Let lead be floor(pointer / 157) + 0x81.
-        var lead = floor(pointer / 157) + 0x81;
-        // 6. If lead is less than 0xA1, return error with code point.
-        if (lead < 0xa1)
-            return encoderError(code_point);
-        // 7. Let trail be pointer % 157.
-        var trail = pointer % 157;
-        // 8. Let offset be 0x40 if trail is less than 0x3F and 0x62
-        // otherwise.
-        var offset = trail < 0x3f ? 0x40 : 0x62;
-        // Return two bytes whose values are lead and trail + offset.
-        return [lead, trail + offset];
-    };
+  var fatal = options.fatal;
+
+  this.handler = function (stream, code_point) {
+    if (code_point === end_of_stream) return finished;
+    if (isASCIICodePoint(code_point)) return code_point;
+    var pointer = indexBig5PointerFor(code_point);
+    if (pointer === null) return encoderError(code_point);
+    var lead = floor(pointer / 157) + 0x81;
+    if (lead < 0xa1) return encoderError(code_point);
+    var trail = pointer % 157;
+    var offset = trail < 0x3f ? 0x40 : 0x62;
+    return [lead, trail + offset];
+  };
 }
-/** @param {{fatal: boolean}} options */
+
 encoders['Big5'] = function (options) {
-    return new Big5Encoder(options);
+  return new Big5Encoder(options);
 };
-/** @param {{fatal: boolean}} options */
+
 decoders['Big5'] = function (options) {
-    return new Big5Decoder(options);
+  return new Big5Decoder(options);
 };
-//
-// 13. Legacy multi-byte Japanese encodings
-//
-// 13.1 euc-jp
-// 13.1.1 euc-jp decoder
-/**
- * @constructor
- * @implements {Decoder}
- * @param {{fatal: boolean}} options
- */
+
 function EUCJPDecoder(options) {
-    var fatal = options.fatal;
-    // euc-jp's decoder has an associated euc-jp jis0212 flag
-    // (initially unset) and euc-jp lead (initially 0x00).
-    var /** @type {boolean} */ eucjp_jis0212_flag = false, 
-    /** @type {number} */ eucjp_lead = 0x00;
-    /**
-     * @param {Stream} stream The stream of bytes being decoded.
-     * @param {number} bite The next byte read from the stream.
-     * @return {?(number|!Array.<number>)} The next code point(s)
-     *     decoded, or null if not enough data exists in the input
-     *     stream to decode a complete code point.
-     */
-    this.handler = function (stream, bite) {
-        // 1. If byte is end-of-stream and euc-jp lead is not 0x00, set
-        // euc-jp lead to 0x00, and return error.
-        if (bite === end_of_stream && eucjp_lead !== 0x00) {
-            eucjp_lead = 0x00;
-            return decoderError(fatal);
-        }
-        // 2. If byte is end-of-stream and euc-jp lead is 0x00, return
-        // finished.
-        if (bite === end_of_stream && eucjp_lead === 0x00)
-            return finished;
-        // 3. If euc-jp lead is 0x8E and byte is in the range 0xA1 to
-        // 0xDF, inclusive, set euc-jp lead to 0x00 and return a code
-        // point whose value is 0xFF61 − 0xA1 + byte.
-        if (eucjp_lead === 0x8e && inRange(bite, 0xa1, 0xdf)) {
-            eucjp_lead = 0x00;
-            return 0xff61 - 0xa1 + bite;
-        }
-        // 4. If euc-jp lead is 0x8F and byte is in the range 0xA1 to
-        // 0xFE, inclusive, set the euc-jp jis0212 flag, set euc-jp lead
-        // to byte, and return continue.
-        if (eucjp_lead === 0x8f && inRange(bite, 0xa1, 0xfe)) {
-            eucjp_jis0212_flag = true;
-            eucjp_lead = bite;
-            return null;
-        }
-        // 5. If euc-jp lead is not 0x00, let lead be euc-jp lead, set
-        // euc-jp lead to 0x00, and run these substeps:
-        if (eucjp_lead !== 0x00) {
-            var lead = eucjp_lead;
-            eucjp_lead = 0x00;
-            // 1. Let code point be null.
-            var code_point = null;
-            // 2. If lead and byte are both in the range 0xA1 to 0xFE,
-            // inclusive, set code point to the index code point for (lead
-            // − 0xA1) × 94 + byte − 0xA1 in index jis0208 if the euc-jp
-            // jis0212 flag is unset and in index jis0212 otherwise.
-            if (inRange(lead, 0xa1, 0xfe) && inRange(bite, 0xa1, 0xfe)) {
-                code_point = indexCodePointFor((lead - 0xa1) * 94 + (bite - 0xa1), index(!eucjp_jis0212_flag ? 'jis0208' : 'jis0212'));
-            }
-            // 3. Unset the euc-jp jis0212 flag.
-            eucjp_jis0212_flag = false;
-            // 4. If byte is not in the range 0xA1 to 0xFE, inclusive,
-            // prepend byte to stream.
-            if (!inRange(bite, 0xa1, 0xfe))
-                stream.prepend(bite);
-            // 5. If code point is null, return error.
-            if (code_point === null)
-                return decoderError(fatal);
-            // 6. Return a code point whose value is code point.
-            return code_point;
-        }
-        // 6. If byte is an ASCII byte, return a code point whose value
-        // is byte.
-        if (isASCIIByte(bite))
-            return bite;
-        // 7. If byte is 0x8E, 0x8F, or in the range 0xA1 to 0xFE,
-        // inclusive, set euc-jp lead to byte and return continue.
-        if (bite === 0x8e || bite === 0x8f || inRange(bite, 0xa1, 0xfe)) {
-            eucjp_lead = bite;
-            return null;
-        }
-        // 8. Return error.
-        return decoderError(fatal);
-    };
+  var fatal = options.fatal;
+  var eucjp_jis0212_flag = false,
+      eucjp_lead = 0x00;
+
+  this.handler = function (stream, bite) {
+    if (bite === end_of_stream && eucjp_lead !== 0x00) {
+      eucjp_lead = 0x00;
+      return decoderError(fatal);
+    }
+
+    if (bite === end_of_stream && eucjp_lead === 0x00) return finished;
+
+    if (eucjp_lead === 0x8e && inRange(bite, 0xa1, 0xdf)) {
+      eucjp_lead = 0x00;
+      return 0xff61 - 0xa1 + bite;
+    }
+
+    if (eucjp_lead === 0x8f && inRange(bite, 0xa1, 0xfe)) {
+      eucjp_jis0212_flag = true;
+      eucjp_lead = bite;
+      return null;
+    }
+
+    if (eucjp_lead !== 0x00) {
+      var lead = eucjp_lead;
+      eucjp_lead = 0x00;
+      var code_point = null;
+
+      if (inRange(lead, 0xa1, 0xfe) && inRange(bite, 0xa1, 0xfe)) {
+        code_point = indexCodePointFor((lead - 0xa1) * 94 + (bite - 0xa1), index(!eucjp_jis0212_flag ? 'jis0208' : 'jis0212'));
+      }
+
+      eucjp_jis0212_flag = false;
+      if (!inRange(bite, 0xa1, 0xfe)) stream.prepend(bite);
+      if (code_point === null) return decoderError(fatal);
+      return code_point;
+    }
+
+    if (isASCIIByte(bite)) return bite;
+
+    if (bite === 0x8e || bite === 0x8f || inRange(bite, 0xa1, 0xfe)) {
+      eucjp_lead = bite;
+      return null;
+    }
+
+    return decoderError(fatal);
+  };
 }
-// 13.1.2 euc-jp encoder
-/**
- * @constructor
- * @implements {Encoder}
- * @param {{fatal: boolean}} options
- */
+
 function EUCJPEncoder(options) {
-    var fatal = options.fatal;
-    /**
-     * @param {Stream} stream Input stream.
-     * @param {number} code_point Next code point read from the stream.
-     * @return {(number|!Array.<number>)} Byte(s) to emit.
-     */
-    this.handler = function (stream, code_point) {
-        // 1. If code point is end-of-stream, return finished.
-        if (code_point === end_of_stream)
-            return finished;
-        // 2. If code point is an ASCII code point, return a byte whose
-        // value is code point.
-        if (isASCIICodePoint(code_point))
-            return code_point;
-        // 3. If code point is U+00A5, return byte 0x5C.
-        if (code_point === 0x00a5)
-            return 0x5c;
-        // 4. If code point is U+203E, return byte 0x7E.
-        if (code_point === 0x203e)
-            return 0x7e;
-        // 5. If code point is in the range U+FF61 to U+FF9F, inclusive,
-        // return two bytes whose values are 0x8E and code point −
-        // 0xFF61 + 0xA1.
-        if (inRange(code_point, 0xff61, 0xff9f))
-            return [0x8e, code_point - 0xff61 + 0xa1];
-        // 6. If code point is U+2212, set it to U+FF0D.
-        if (code_point === 0x2212)
-            code_point = 0xff0d;
-        // 7. Let pointer be the index pointer for code point in index
-        // jis0208.
-        var pointer = indexPointerFor(code_point, index('jis0208'));
-        // 8. If pointer is null, return error with code point.
-        if (pointer === null)
-            return encoderError(code_point);
-        // 9. Let lead be floor(pointer / 94) + 0xA1.
-        var lead = floor(pointer / 94) + 0xa1;
-        // 10. Let trail be pointer % 94 + 0xA1.
-        var trail = (pointer % 94) + 0xa1;
-        // 11. Return two bytes whose values are lead and trail.
-        return [lead, trail];
-    };
+  var fatal = options.fatal;
+
+  this.handler = function (stream, code_point) {
+    if (code_point === end_of_stream) return finished;
+    if (isASCIICodePoint(code_point)) return code_point;
+    if (code_point === 0x00a5) return 0x5c;
+    if (code_point === 0x203e) return 0x7e;
+    if (inRange(code_point, 0xff61, 0xff9f)) return [0x8e, code_point - 0xff61 + 0xa1];
+    if (code_point === 0x2212) code_point = 0xff0d;
+    var pointer = indexPointerFor(code_point, index('jis0208'));
+    if (pointer === null) return encoderError(code_point);
+    var lead = floor(pointer / 94) + 0xa1;
+    var trail = pointer % 94 + 0xa1;
+    return [lead, trail];
+  };
 }
-/** @param {{fatal: boolean}} options */
+
 encoders['EUC-JP'] = function (options) {
-    return new EUCJPEncoder(options);
+  return new EUCJPEncoder(options);
 };
-/** @param {{fatal: boolean}} options */
+
 decoders['EUC-JP'] = function (options) {
-    return new EUCJPDecoder(options);
+  return new EUCJPDecoder(options);
 };
-// 13.2 iso-2022-jp
-// 13.2.1 iso-2022-jp decoder
-/**
- * @constructor
- * @implements {Decoder}
- * @param {{fatal: boolean}} options
- */
+
 function ISO2022JPDecoder(options) {
-    var fatal = options.fatal;
-    /** @enum */
-    var states = {
-        ASCII: 0,
-        Roman: 1,
-        Katakana: 2,
-        LeadByte: 3,
-        TrailByte: 4,
-        EscapeStart: 5,
-        Escape: 6
-    };
-    // iso-2022-jp's decoder has an associated iso-2022-jp decoder
-    // state (initially ASCII), iso-2022-jp decoder output state
-    // (initially ASCII), iso-2022-jp lead (initially 0x00), and
-    // iso-2022-jp output flag (initially unset).
-    var /** @type {number} */ iso2022jp_decoder_state = states.ASCII, 
-    /** @type {number} */ iso2022jp_decoder_output_state = states.ASCII, 
-    /** @type {number} */ iso2022jp_lead = 0x00, 
-    /** @type {boolean} */ iso2022jp_output_flag = false;
-    /**
-     * @param {Stream} stream The stream of bytes being decoded.
-     * @param {number} bite The next byte read from the stream.
-     * @return {?(number|!Array.<number>)} The next code point(s)
-     *     decoded, or null if not enough data exists in the input
-     *     stream to decode a complete code point.
-     */
-    this.handler = function (stream, bite) {
-        // switching on iso-2022-jp decoder state:
-        switch (iso2022jp_decoder_state) {
-            default:
-            case states.ASCII:
-                // ASCII
-                // Based on byte:
-                // 0x1B
-                if (bite === 0x1b) {
-                    // Set iso-2022-jp decoder state to escape start and return
-                    // continue.
-                    iso2022jp_decoder_state = states.EscapeStart;
-                    return null;
-                }
-                // 0x00 to 0x7F, excluding 0x0E, 0x0F, and 0x1B
-                if (inRange(bite, 0x00, 0x7f) && bite !== 0x0e && bite !== 0x0f && bite !== 0x1b) {
-                    // Unset the iso-2022-jp output flag and return a code point
-                    // whose value is byte.
-                    iso2022jp_output_flag = false;
-                    return bite;
-                }
-                // end-of-stream
-                if (bite === end_of_stream) {
-                    // Return finished.
-                    return finished;
-                }
-                // Otherwise
-                // Unset the iso-2022-jp output flag and return error.
-                iso2022jp_output_flag = false;
-                return decoderError(fatal);
-            case states.Roman:
-                // Roman
-                // Based on byte:
-                // 0x1B
-                if (bite === 0x1b) {
-                    // Set iso-2022-jp decoder state to escape start and return
-                    // continue.
-                    iso2022jp_decoder_state = states.EscapeStart;
-                    return null;
-                }
-                // 0x5C
-                if (bite === 0x5c) {
-                    // Unset the iso-2022-jp output flag and return code point
-                    // U+00A5.
-                    iso2022jp_output_flag = false;
-                    return 0x00a5;
-                }
-                // 0x7E
-                if (bite === 0x7e) {
-                    // Unset the iso-2022-jp output flag and return code point
-                    // U+203E.
-                    iso2022jp_output_flag = false;
-                    return 0x203e;
-                }
-                // 0x00 to 0x7F, excluding 0x0E, 0x0F, 0x1B, 0x5C, and 0x7E
-                if (inRange(bite, 0x00, 0x7f) &&
-                    bite !== 0x0e &&
-                    bite !== 0x0f &&
-                    bite !== 0x1b &&
-                    bite !== 0x5c &&
-                    bite !== 0x7e) {
-                    // Unset the iso-2022-jp output flag and return a code point
-                    // whose value is byte.
-                    iso2022jp_output_flag = false;
-                    return bite;
-                }
-                // end-of-stream
-                if (bite === end_of_stream) {
-                    // Return finished.
-                    return finished;
-                }
-                // Otherwise
-                // Unset the iso-2022-jp output flag and return error.
-                iso2022jp_output_flag = false;
-                return decoderError(fatal);
-            case states.Katakana:
-                // Katakana
-                // Based on byte:
-                // 0x1B
-                if (bite === 0x1b) {
-                    // Set iso-2022-jp decoder state to escape start and return
-                    // continue.
-                    iso2022jp_decoder_state = states.EscapeStart;
-                    return null;
-                }
-                // 0x21 to 0x5F
-                if (inRange(bite, 0x21, 0x5f)) {
-                    // Unset the iso-2022-jp output flag and return a code point
-                    // whose value is 0xFF61 − 0x21 + byte.
-                    iso2022jp_output_flag = false;
-                    return 0xff61 - 0x21 + bite;
-                }
-                // end-of-stream
-                if (bite === end_of_stream) {
-                    // Return finished.
-                    return finished;
-                }
-                // Otherwise
-                // Unset the iso-2022-jp output flag and return error.
-                iso2022jp_output_flag = false;
-                return decoderError(fatal);
-            case states.LeadByte:
-                // Lead byte
-                // Based on byte:
-                // 0x1B
-                if (bite === 0x1b) {
-                    // Set iso-2022-jp decoder state to escape start and return
-                    // continue.
-                    iso2022jp_decoder_state = states.EscapeStart;
-                    return null;
-                }
-                // 0x21 to 0x7E
-                if (inRange(bite, 0x21, 0x7e)) {
-                    // Unset the iso-2022-jp output flag, set iso-2022-jp lead
-                    // to byte, iso-2022-jp decoder state to trail byte, and
-                    // return continue.
-                    iso2022jp_output_flag = false;
-                    iso2022jp_lead = bite;
-                    iso2022jp_decoder_state = states.TrailByte;
-                    return null;
-                }
-                // end-of-stream
-                if (bite === end_of_stream) {
-                    // Return finished.
-                    return finished;
-                }
-                // Otherwise
-                // Unset the iso-2022-jp output flag and return error.
-                iso2022jp_output_flag = false;
-                return decoderError(fatal);
-            case states.TrailByte:
-                // Trail byte
-                // Based on byte:
-                // 0x1B
-                if (bite === 0x1b) {
-                    // Set iso-2022-jp decoder state to escape start and return
-                    // continue.
-                    iso2022jp_decoder_state = states.EscapeStart;
-                    return decoderError(fatal);
-                }
-                // 0x21 to 0x7E
-                if (inRange(bite, 0x21, 0x7e)) {
-                    // 1. Set the iso-2022-jp decoder state to lead byte.
-                    iso2022jp_decoder_state = states.LeadByte;
-                    // 2. Let pointer be (iso-2022-jp lead − 0x21) × 94 + byte − 0x21.
-                    var pointer = (iso2022jp_lead - 0x21) * 94 + bite - 0x21;
-                    // 3. Let code point be the index code point for pointer in
-                    // index jis0208.
-                    var code_point = indexCodePointFor(pointer, index('jis0208'));
-                    // 4. If code point is null, return error.
-                    if (code_point === null)
-                        return decoderError(fatal);
-                    // 5. Return a code point whose value is code point.
-                    return code_point;
-                }
-                // end-of-stream
-                if (bite === end_of_stream) {
-                    // Set the iso-2022-jp decoder state to lead byte, prepend
-                    // byte to stream, and return error.
-                    iso2022jp_decoder_state = states.LeadByte;
-                    stream.prepend(bite);
-                    return decoderError(fatal);
-                }
-                // Otherwise
-                // Set iso-2022-jp decoder state to lead byte and return
-                // error.
-                iso2022jp_decoder_state = states.LeadByte;
-                return decoderError(fatal);
-            case states.EscapeStart:
-                // Escape start
-                // 1. If byte is either 0x24 or 0x28, set iso-2022-jp lead to
-                // byte, iso-2022-jp decoder state to escape, and return
-                // continue.
-                if (bite === 0x24 || bite === 0x28) {
-                    iso2022jp_lead = bite;
-                    iso2022jp_decoder_state = states.Escape;
-                    return null;
-                }
-                // 2. Prepend byte to stream.
-                stream.prepend(bite);
-                // 3. Unset the iso-2022-jp output flag, set iso-2022-jp
-                // decoder state to iso-2022-jp decoder output state, and
-                // return error.
-                iso2022jp_output_flag = false;
-                iso2022jp_decoder_state = iso2022jp_decoder_output_state;
-                return decoderError(fatal);
-            case states.Escape:
-                // Escape
-                // 1. Let lead be iso-2022-jp lead and set iso-2022-jp lead to
-                // 0x00.
-                var lead = iso2022jp_lead;
-                iso2022jp_lead = 0x00;
-                // 2. Let state be null.
-                var state = null;
-                // 3. If lead is 0x28 and byte is 0x42, set state to ASCII.
-                if (lead === 0x28 && bite === 0x42)
-                    state = states.ASCII;
-                // 4. If lead is 0x28 and byte is 0x4A, set state to Roman.
-                if (lead === 0x28 && bite === 0x4a)
-                    state = states.Roman;
-                // 5. If lead is 0x28 and byte is 0x49, set state to Katakana.
-                if (lead === 0x28 && bite === 0x49)
-                    state = states.Katakana;
-                // 6. If lead is 0x24 and byte is either 0x40 or 0x42, set
-                // state to lead byte.
-                if (lead === 0x24 && (bite === 0x40 || bite === 0x42))
-                    state = states.LeadByte;
-                // 7. If state is non-null, run these substeps:
-                if (state !== null) {
-                    // 1. Set iso-2022-jp decoder state and iso-2022-jp decoder
-                    // output state to states.
-                    iso2022jp_decoder_state = iso2022jp_decoder_state = state;
-                    // 2. Let output flag be the iso-2022-jp output flag.
-                    var output_flag = iso2022jp_output_flag;
-                    // 3. Set the iso-2022-jp output flag.
-                    iso2022jp_output_flag = true;
-                    // 4. Return continue, if output flag is unset, and error
-                    // otherwise.
-                    return !output_flag ? null : decoderError(fatal);
-                }
-                // 8. Prepend lead and byte to stream.
-                stream.prepend([lead, bite]);
-                // 9. Unset the iso-2022-jp output flag, set iso-2022-jp
-                // decoder state to iso-2022-jp decoder output state and
-                // return error.
-                iso2022jp_output_flag = false;
-                iso2022jp_decoder_state = iso2022jp_decoder_output_state;
-                return decoderError(fatal);
-        }
-    };
+  var fatal = options.fatal;
+  var states = {
+    ASCII: 0,
+    Roman: 1,
+    Katakana: 2,
+    LeadByte: 3,
+    TrailByte: 4,
+    EscapeStart: 5,
+    Escape: 6
+  };
+  var iso2022jp_decoder_state = states.ASCII,
+      iso2022jp_decoder_output_state = states.ASCII,
+      iso2022jp_lead = 0x00,
+      iso2022jp_output_flag = false;
+
+  this.handler = function (stream, bite) {
+    switch (iso2022jp_decoder_state) {
+      default:
+      case states.ASCII:
+        if (bite === 0x1b) {
+          iso2022jp_decoder_state = states.EscapeStart;
+          return null;
+        }
+
+        if (inRange(bite, 0x00, 0x7f) && bite !== 0x0e && bite !== 0x0f && bite !== 0x1b) {
+          iso2022jp_output_flag = false;
+          return bite;
+        }
+
+        if (bite === end_of_stream) {
+          return finished;
+        }
+
+        iso2022jp_output_flag = false;
+        return decoderError(fatal);
+
+      case states.Roman:
+        if (bite === 0x1b) {
+          iso2022jp_decoder_state = states.EscapeStart;
+          return null;
+        }
+
+        if (bite === 0x5c) {
+          iso2022jp_output_flag = false;
+          return 0x00a5;
+        }
+
+        if (bite === 0x7e) {
+          iso2022jp_output_flag = false;
+          return 0x203e;
+        }
+
+        if (inRange(bite, 0x00, 0x7f) && bite !== 0x0e && bite !== 0x0f && bite !== 0x1b && bite !== 0x5c && bite !== 0x7e) {
+          iso2022jp_output_flag = false;
+          return bite;
+        }
+
+        if (bite === end_of_stream) {
+          return finished;
+        }
+
+        iso2022jp_output_flag = false;
+        return decoderError(fatal);
+
+      case states.Katakana:
+        if (bite === 0x1b) {
+          iso2022jp_decoder_state = states.EscapeStart;
+          return null;
+        }
+
+        if (inRange(bite, 0x21, 0x5f)) {
+          iso2022jp_output_flag = false;
+          return 0xff61 - 0x21 + bite;
+        }
+
+        if (bite === end_of_stream) {
+          return finished;
+        }
+
+        iso2022jp_output_flag = false;
+        return decoderError(fatal);
+
+      case states.LeadByte:
+        if (bite === 0x1b) {
+          iso2022jp_decoder_state = states.EscapeStart;
+          return null;
+        }
+
+        if (inRange(bite, 0x21, 0x7e)) {
+          iso2022jp_output_flag = false;
+          iso2022jp_lead = bite;
+          iso2022jp_decoder_state = states.TrailByte;
+          return null;
+        }
+
+        if (bite === end_of_stream) {
+          return finished;
+        }
+
+        iso2022jp_output_flag = false;
+        return decoderError(fatal);
+
+      case states.TrailByte:
+        if (bite === 0x1b) {
+          iso2022jp_decoder_state = states.EscapeStart;
+          return decoderError(fatal);
+        }
+
+        if (inRange(bite, 0x21, 0x7e)) {
+          iso2022jp_decoder_state = states.LeadByte;
+          var pointer = (iso2022jp_lead - 0x21) * 94 + bite - 0x21;
+          var code_point = indexCodePointFor(pointer, index('jis0208'));
+          if (code_point === null) return decoderError(fatal);
+          return code_point;
+        }
+
+        if (bite === end_of_stream) {
+          iso2022jp_decoder_state = states.LeadByte;
+          stream.prepend(bite);
+          return decoderError(fatal);
+        }
+
+        iso2022jp_decoder_state = states.LeadByte;
+        return decoderError(fatal);
+
+      case states.EscapeStart:
+        if (bite === 0x24 || bite === 0x28) {
+          iso2022jp_lead = bite;
+          iso2022jp_decoder_state = states.Escape;
+          return null;
+        }
+
+        stream.prepend(bite);
+        iso2022jp_output_flag = false;
+        iso2022jp_decoder_state = iso2022jp_decoder_output_state;
+        return decoderError(fatal);
+
+      case states.Escape:
+        var lead = iso2022jp_lead;
+        iso2022jp_lead = 0x00;
+        var state = null;
+        if (lead === 0x28 && bite === 0x42) state = states.ASCII;
+        if (lead === 0x28 && bite === 0x4a) state = states.Roman;
+        if (lead === 0x28 && bite === 0x49) state = states.Katakana;
+        if (lead === 0x24 && (bite === 0x40 || bite === 0x42)) state = states.LeadByte;
+
+        if (state !== null) {
+          iso2022jp_decoder_state = iso2022jp_decoder_state = state;
+          var output_flag = iso2022jp_output_flag;
+          iso2022jp_output_flag = true;
+          return !output_flag ? null : decoderError(fatal);
+        }
+
+        stream.prepend([lead, bite]);
+        iso2022jp_output_flag = false;
+        iso2022jp_decoder_state = iso2022jp_decoder_output_state;
+        return decoderError(fatal);
+    }
+  };
 }
-// 13.2.2 iso-2022-jp encoder
-/**
- * @constructor
- * @implements {Encoder}
- * @param {{fatal: boolean}} options
- */
+
 function ISO2022JPEncoder(options) {
-    var fatal = options.fatal;
-    // iso-2022-jp's encoder has an associated iso-2022-jp encoder
-    // state which is one of ASCII, Roman, and jis0208 (initially
-    // ASCII).
-    /** @enum */
-    var states = {
-        ASCII: 0,
-        Roman: 1,
-        jis0208: 2
-    };
-    var /** @type {number} */ iso2022jp_state = states.ASCII;
-    /**
-     * @param {Stream} stream Input stream.
-     * @param {number} code_point Next code point read from the stream.
-     * @return {(number|!Array.<number>)} Byte(s) to emit.
-     */
-    this.handler = function (stream, code_point) {
-        // 1. If code point is end-of-stream and iso-2022-jp encoder
-        // state is not ASCII, prepend code point to stream, set
-        // iso-2022-jp encoder state to ASCII, and return three bytes
-        // 0x1B 0x28 0x42.
-        if (code_point === end_of_stream && iso2022jp_state !== states.ASCII) {
-            stream.prepend(code_point);
-            iso2022jp_state = states.ASCII;
-            return [0x1b, 0x28, 0x42];
-        }
-        // 2. If code point is end-of-stream and iso-2022-jp encoder
-        // state is ASCII, return finished.
-        if (code_point === end_of_stream && iso2022jp_state === states.ASCII)
-            return finished;
-        // 3. If ISO-2022-JP encoder state is ASCII or Roman, and code
-        // point is U+000E, U+000F, or U+001B, return error with U+FFFD.
-        if ((iso2022jp_state === states.ASCII || iso2022jp_state === states.Roman) &&
-            (code_point === 0x000e || code_point === 0x000f || code_point === 0x001b)) {
-            return encoderError(0xfffd);
-        }
-        // 4. If iso-2022-jp encoder state is ASCII and code point is an
-        // ASCII code point, return a byte whose value is code point.
-        if (iso2022jp_state === states.ASCII && isASCIICodePoint(code_point))
-            return code_point;
-        // 5. If iso-2022-jp encoder state is Roman and code point is an
-        // ASCII code point, excluding U+005C and U+007E, or is U+00A5
-        // or U+203E, run these substeps:
-        if (iso2022jp_state === states.Roman &&
-            ((isASCIICodePoint(code_point) && code_point !== 0x005c && code_point !== 0x007e) ||
-                code_point == 0x00a5 ||
-                code_point == 0x203e)) {
-            // 1. If code point is an ASCII code point, return a byte
-            // whose value is code point.
-            if (isASCIICodePoint(code_point))
-                return code_point;
-            // 2. If code point is U+00A5, return byte 0x5C.
-            if (code_point === 0x00a5)
-                return 0x5c;
-            // 3. If code point is U+203E, return byte 0x7E.
-            if (code_point === 0x203e)
-                return 0x7e;
-        }
-        // 6. If code point is an ASCII code point, and iso-2022-jp
-        // encoder state is not ASCII, prepend code point to stream, set
-        // iso-2022-jp encoder state to ASCII, and return three bytes
-        // 0x1B 0x28 0x42.
-        if (isASCIICodePoint(code_point) && iso2022jp_state !== states.ASCII) {
-            stream.prepend(code_point);
-            iso2022jp_state = states.ASCII;
-            return [0x1b, 0x28, 0x42];
-        }
-        // 7. If code point is either U+00A5 or U+203E, and iso-2022-jp
-        // encoder state is not Roman, prepend code point to stream, set
-        // iso-2022-jp encoder state to Roman, and return three bytes
-        // 0x1B 0x28 0x4A.
-        if ((code_point === 0x00a5 || code_point === 0x203e) && iso2022jp_state !== states.Roman) {
-            stream.prepend(code_point);
-            iso2022jp_state = states.Roman;
-            return [0x1b, 0x28, 0x4a];
-        }
-        // 8. If code point is U+2212, set it to U+FF0D.
-        if (code_point === 0x2212)
-            code_point = 0xff0d;
-        // 9. Let pointer be the index pointer for code point in index
-        // jis0208.
-        var pointer = indexPointerFor(code_point, index('jis0208'));
-        // 10. If pointer is null, return error with code point.
-        if (pointer === null)
-            return encoderError(code_point);
-        // 11. If iso-2022-jp encoder state is not jis0208, prepend code
-        // point to stream, set iso-2022-jp encoder state to jis0208,
-        // and return three bytes 0x1B 0x24 0x42.
-        if (iso2022jp_state !== states.jis0208) {
-            stream.prepend(code_point);
-            iso2022jp_state = states.jis0208;
-            return [0x1b, 0x24, 0x42];
-        }
-        // 12. Let lead be floor(pointer / 94) + 0x21.
-        var lead = floor(pointer / 94) + 0x21;
-        // 13. Let trail be pointer % 94 + 0x21.
-        var trail = (pointer % 94) + 0x21;
-        // 14. Return two bytes whose values are lead and trail.
-        return [lead, trail];
-    };
+  var fatal = options.fatal;
+  var states = {
+    ASCII: 0,
+    Roman: 1,
+    jis0208: 2
+  };
+  var iso2022jp_state = states.ASCII;
+
+  this.handler = function (stream, code_point) {
+    if (code_point === end_of_stream && iso2022jp_state !== states.ASCII) {
+      stream.prepend(code_point);
+      iso2022jp_state = states.ASCII;
+      return [0x1b, 0x28, 0x42];
+    }
+
+    if (code_point === end_of_stream && iso2022jp_state === states.ASCII) return finished;
+
+    if ((iso2022jp_state === states.ASCII || iso2022jp_state === states.Roman) && (code_point === 0x000e || code_point === 0x000f || code_point === 0x001b)) {
+      return encoderError(0xfffd);
+    }
+
+    if (iso2022jp_state === states.ASCII && isASCIICodePoint(code_point)) return code_point;
+
+    if (iso2022jp_state === states.Roman && (isASCIICodePoint(code_point) && code_point !== 0x005c && code_point !== 0x007e || code_point == 0x00a5 || code_point == 0x203e)) {
+      if (isASCIICodePoint(code_point)) return code_point;
+      if (code_point === 0x00a5) return 0x5c;
+      if (code_point === 0x203e) return 0x7e;
+    }
+
+    if (isASCIICodePoint(code_point) && iso2022jp_state !== states.ASCII) {
+      stream.prepend(code_point);
+      iso2022jp_state = states.ASCII;
+      return [0x1b, 0x28, 0x42];
+    }
+
+    if ((code_point === 0x00a5 || code_point === 0x203e) && iso2022jp_state !== states.Roman) {
+      stream.prepend(code_point);
+      iso2022jp_state = states.Roman;
+      return [0x1b, 0x28, 0x4a];
+    }
+
+    if (code_point === 0x2212) code_point = 0xff0d;
+    var pointer = indexPointerFor(code_point, index('jis0208'));
+    if (pointer === null) return encoderError(code_point);
+
+    if (iso2022jp_state !== states.jis0208) {
+      stream.prepend(code_point);
+      iso2022jp_state = states.jis0208;
+      return [0x1b, 0x24, 0x42];
+    }
+
+    var lead = floor(pointer / 94) + 0x21;
+    var trail = pointer % 94 + 0x21;
+    return [lead, trail];
+  };
 }
-/** @param {{fatal: boolean}} options */
+
 encoders['ISO-2022-JP'] = function (options) {
-    return new ISO2022JPEncoder(options);
+  return new ISO2022JPEncoder(options);
 };
-/** @param {{fatal: boolean}} options */
+
 decoders['ISO-2022-JP'] = function (options) {
-    return new ISO2022JPDecoder(options);
+  return new ISO2022JPDecoder(options);
 };
-// 13.3 Shift_JIS
-// 13.3.1 Shift_JIS decoder
-/**
- * @constructor
- * @implements {Decoder}
- * @param {{fatal: boolean}} options
- */
+
 function ShiftJISDecoder(options) {
-    var fatal = options.fatal;
-    // Shift_JIS's decoder has an associated Shift_JIS lead (initially
-    // 0x00).
-    var /** @type {number} */ Shift_JIS_lead = 0x00;
-    /**
-     * @param {Stream} stream The stream of bytes being decoded.
-     * @param {number} bite The next byte read from the stream.
-     * @return {?(number|!Array.<number>)} The next code point(s)
-     *     decoded, or null if not enough data exists in the input
-     *     stream to decode a complete code point.
-     */
-    this.handler = function (stream, bite) {
-        // 1. If byte is end-of-stream and Shift_JIS lead is not 0x00,
-        // set Shift_JIS lead to 0x00 and return error.
-        if (bite === end_of_stream && Shift_JIS_lead !== 0x00) {
-            Shift_JIS_lead = 0x00;
-            return decoderError(fatal);
-        }
-        // 2. If byte is end-of-stream and Shift_JIS lead is 0x00,
-        // return finished.
-        if (bite === end_of_stream && Shift_JIS_lead === 0x00)
-            return finished;
-        // 3. If Shift_JIS lead is not 0x00, let lead be Shift_JIS lead,
-        // let pointer be null, set Shift_JIS lead to 0x00, and then run
-        // these substeps:
-        if (Shift_JIS_lead !== 0x00) {
-            var lead = Shift_JIS_lead;
-            var pointer = null;
-            Shift_JIS_lead = 0x00;
-            // 1. Let offset be 0x40, if byte is less than 0x7F, and 0x41
-            // otherwise.
-            var offset = bite < 0x7f ? 0x40 : 0x41;
-            // 2. Let lead offset be 0x81, if lead is less than 0xA0, and
-            // 0xC1 otherwise.
-            var lead_offset = lead < 0xa0 ? 0x81 : 0xc1;
-            // 3. If byte is in the range 0x40 to 0x7E, inclusive, or 0x80
-            // to 0xFC, inclusive, set pointer to (lead − lead offset) ×
-            // 188 + byte − offset.
-            if (inRange(bite, 0x40, 0x7e) || inRange(bite, 0x80, 0xfc))
-                pointer = (lead - lead_offset) * 188 + bite - offset;
-            // 4. If pointer is in the range 8836 to 10715, inclusive,
-            // return a code point whose value is 0xE000 − 8836 + pointer.
-            if (inRange(pointer, 8836, 10715))
-                return 0xe000 - 8836 + pointer;
-            // 5. Let code point be null, if pointer is null, and the
-            // index code point for pointer in index jis0208 otherwise.
-            var code_point = pointer === null ? null : indexCodePointFor(pointer, index('jis0208'));
-            // 6. If code point is null and byte is an ASCII byte, prepend
-            // byte to stream.
-            if (code_point === null && isASCIIByte(bite))
-                stream.prepend(bite);
-            // 7. If code point is null, return error.
-            if (code_point === null)
-                return decoderError(fatal);
-            // 8. Return a code point whose value is code point.
-            return code_point;
-        }
-        // 4. If byte is an ASCII byte or 0x80, return a code point
-        // whose value is byte.
-        if (isASCIIByte(bite) || bite === 0x80)
-            return bite;
-        // 5. If byte is in the range 0xA1 to 0xDF, inclusive, return a
-        // code point whose value is 0xFF61 − 0xA1 + byte.
-        if (inRange(bite, 0xa1, 0xdf))
-            return 0xff61 - 0xa1 + bite;
-        // 6. If byte is in the range 0x81 to 0x9F, inclusive, or 0xE0
-        // to 0xFC, inclusive, set Shift_JIS lead to byte and return
-        // continue.
-        if (inRange(bite, 0x81, 0x9f) || inRange(bite, 0xe0, 0xfc)) {
-            Shift_JIS_lead = bite;
-            return null;
-        }
-        // 7. Return error.
-        return decoderError(fatal);
-    };
+  var fatal = options.fatal;
+  var Shift_JIS_lead = 0x00;
+
+  this.handler = function (stream, bite) {
+    if (bite === end_of_stream && Shift_JIS_lead !== 0x00) {
+      Shift_JIS_lead = 0x00;
+      return decoderError(fatal);
+    }
+
+    if (bite === end_of_stream && Shift_JIS_lead === 0x00) return finished;
+
+    if (Shift_JIS_lead !== 0x00) {
+      var lead = Shift_JIS_lead;
+      var pointer = null;
+      Shift_JIS_lead = 0x00;
+      var offset = bite < 0x7f ? 0x40 : 0x41;
+      var lead_offset = lead < 0xa0 ? 0x81 : 0xc1;
+      if (inRange(bite, 0x40, 0x7e) || inRange(bite, 0x80, 0xfc)) pointer = (lead - lead_offset) * 188 + bite - offset;
+      if (inRange(pointer, 8836, 10715)) return 0xe000 - 8836 + pointer;
+      var code_point = pointer === null ? null : indexCodePointFor(pointer, index('jis0208'));
+      if (code_point === null && isASCIIByte(bite)) stream.prepend(bite);
+      if (code_point === null) return decoderError(fatal);
+      return code_point;
+    }
+
+    if (isASCIIByte(bite) || bite === 0x80) return bite;
+    if (inRange(bite, 0xa1, 0xdf)) return 0xff61 - 0xa1 + bite;
+
+    if (inRange(bite, 0x81, 0x9f) || inRange(bite, 0xe0, 0xfc)) {
+      Shift_JIS_lead = bite;
+      return null;
+    }
+
+    return decoderError(fatal);
+  };
 }
-// 13.3.2 Shift_JIS encoder
-/**
- * @constructor
- * @implements {Encoder}
- * @param {{fatal: boolean}} options
- */
+
 function ShiftJISEncoder(options) {
-    var fatal = options.fatal;
-    /**
-     * @param {Stream} stream Input stream.
-     * @param {number} code_point Next code point read from the stream.
-     * @return {(number|!Array.<number>)} Byte(s) to emit.
-     */
-    this.handler = function (stream, code_point) {
-        // 1. If code point is end-of-stream, return finished.
-        if (code_point === end_of_stream)
-            return finished;
-        // 2. If code point is an ASCII code point or U+0080, return a
-        // byte whose value is code point.
-        if (isASCIICodePoint(code_point) || code_point === 0x0080)
-            return code_point;
-        // 3. If code point is U+00A5, return byte 0x5C.
-        if (code_point === 0x00a5)
-            return 0x5c;
-        // 4. If code point is U+203E, return byte 0x7E.
-        if (code_point === 0x203e)
-            return 0x7e;
-        // 5. If code point is in the range U+FF61 to U+FF9F, inclusive,
-        // return a byte whose value is code point − 0xFF61 + 0xA1.
-        if (inRange(code_point, 0xff61, 0xff9f))
-            return code_point - 0xff61 + 0xa1;
-        // 6. If code point is U+2212, set it to U+FF0D.
-        if (code_point === 0x2212)
-            code_point = 0xff0d;
-        // 7. Let pointer be the index Shift_JIS pointer for code point.
-        var pointer = indexShiftJISPointerFor(code_point);
-        // 8. If pointer is null, return error with code point.
-        if (pointer === null)
-            return encoderError(code_point);
-        // 9. Let lead be floor(pointer / 188).
-        var lead = floor(pointer / 188);
-        // 10. Let lead offset be 0x81, if lead is less than 0x1F, and
-        // 0xC1 otherwise.
-        var lead_offset = lead < 0x1f ? 0x81 : 0xc1;
-        // 11. Let trail be pointer % 188.
-        var trail = pointer % 188;
-        // 12. Let offset be 0x40, if trail is less than 0x3F, and 0x41
-        // otherwise.
-        var offset = trail < 0x3f ? 0x40 : 0x41;
-        // 13. Return two bytes whose values are lead + lead offset and
-        // trail + offset.
-        return [lead + lead_offset, trail + offset];
-    };
+  var fatal = options.fatal;
+
+  this.handler = function (stream, code_point) {
+    if (code_point === end_of_stream) return finished;
+    if (isASCIICodePoint(code_point) || code_point === 0x0080) return code_point;
+    if (code_point === 0x00a5) return 0x5c;
+    if (code_point === 0x203e) return 0x7e;
+    if (inRange(code_point, 0xff61, 0xff9f)) return code_point - 0xff61 + 0xa1;
+    if (code_point === 0x2212) code_point = 0xff0d;
+    var pointer = indexShiftJISPointerFor(code_point);
+    if (pointer === null) return encoderError(code_point);
+    var lead = floor(pointer / 188);
+    var lead_offset = lead < 0x1f ? 0x81 : 0xc1;
+    var trail = pointer % 188;
+    var offset = trail < 0x3f ? 0x40 : 0x41;
+    return [lead + lead_offset, trail + offset];
+  };
 }
-/** @param {{fatal: boolean}} options */
+
 encoders['Shift_JIS'] = function (options) {
-    return new ShiftJISEncoder(options);
+  return new ShiftJISEncoder(options);
 };
-/** @param {{fatal: boolean}} options */
+
 decoders['Shift_JIS'] = function (options) {
-    return new ShiftJISDecoder(options);
+  return new ShiftJISDecoder(options);
 };
-//
-// 14. Legacy multi-byte Korean encodings
-//
-// 14.1 euc-kr
-// 14.1.1 euc-kr decoder
-/**
- * @constructor
- * @implements {Decoder}
- * @param {{fatal: boolean}} options
- */
+
 function EUCKRDecoder(options) {
-    var fatal = options.fatal;
-    // euc-kr's decoder has an associated euc-kr lead (initially 0x00).
-    var /** @type {number} */ euckr_lead = 0x00;
-    /**
-     * @param {Stream} stream The stream of bytes being decoded.
-     * @param {number} bite The next byte read from the stream.
-     * @return {?(number|!Array.<number>)} The next code point(s)
-     *     decoded, or null if not enough data exists in the input
-     *     stream to decode a complete code point.
-     */
-    this.handler = function (stream, bite) {
-        // 1. If byte is end-of-stream and euc-kr lead is not 0x00, set
-        // euc-kr lead to 0x00 and return error.
-        if (bite === end_of_stream && euckr_lead !== 0) {
-            euckr_lead = 0x00;
-            return decoderError(fatal);
-        }
-        // 2. If byte is end-of-stream and euc-kr lead is 0x00, return
-        // finished.
-        if (bite === end_of_stream && euckr_lead === 0)
-            return finished;
-        // 3. If euc-kr lead is not 0x00, let lead be euc-kr lead, let
-        // pointer be null, set euc-kr lead to 0x00, and then run these
-        // substeps:
-        if (euckr_lead !== 0x00) {
-            var lead = euckr_lead;
-            var pointer = null;
-            euckr_lead = 0x00;
-            // 1. If byte is in the range 0x41 to 0xFE, inclusive, set
-            // pointer to (lead − 0x81) × 190 + (byte − 0x41).
-            if (inRange(bite, 0x41, 0xfe))
-                pointer = (lead - 0x81) * 190 + (bite - 0x41);
-            // 2. Let code point be null, if pointer is null, and the
-            // index code point for pointer in index euc-kr otherwise.
-            var code_point = pointer === null ? null : indexCodePointFor(pointer, index('euc-kr'));
-            // 3. If code point is null and byte is an ASCII byte, prepend
-            // byte to stream.
-            if (pointer === null && isASCIIByte(bite))
-                stream.prepend(bite);
-            // 4. If code point is null, return error.
-            if (code_point === null)
-                return decoderError(fatal);
-            // 5. Return a code point whose value is code point.
-            return code_point;
-        }
-        // 4. If byte is an ASCII byte, return a code point whose value
-        // is byte.
-        if (isASCIIByte(bite))
-            return bite;
-        // 5. If byte is in the range 0x81 to 0xFE, inclusive, set
-        // euc-kr lead to byte and return continue.
-        if (inRange(bite, 0x81, 0xfe)) {
-            euckr_lead = bite;
-            return null;
-        }
-        // 6. Return error.
-        return decoderError(fatal);
-    };
+  var fatal = options.fatal;
+  var euckr_lead = 0x00;
+
+  this.handler = function (stream, bite) {
+    if (bite === end_of_stream && euckr_lead !== 0) {
+      euckr_lead = 0x00;
+      return decoderError(fatal);
+    }
+
+    if (bite === end_of_stream && euckr_lead === 0) return finished;
+
+    if (euckr_lead !== 0x00) {
+      var lead = euckr_lead;
+      var pointer = null;
+      euckr_lead = 0x00;
+      if (inRange(bite, 0x41, 0xfe)) pointer = (lead - 0x81) * 190 + (bite - 0x41);
+      var code_point = pointer === null ? null : indexCodePointFor(pointer, index('euc-kr'));
+      if (pointer === null && isASCIIByte(bite)) stream.prepend(bite);
+      if (code_point === null) return decoderError(fatal);
+      return code_point;
+    }
+
+    if (isASCIIByte(bite)) return bite;
+
+    if (inRange(bite, 0x81, 0xfe)) {
+      euckr_lead = bite;
+      return null;
+    }
+
+    return decoderError(fatal);
+  };
 }
-// 14.1.2 euc-kr encoder
-/**
- * @constructor
- * @implements {Encoder}
- * @param {{fatal: boolean}} options
- */
+
 function EUCKREncoder(options) {
-    var fatal = options.fatal;
-    /**
-     * @param {Stream} stream Input stream.
-     * @param {number} code_point Next code point read from the stream.
-     * @return {(number|!Array.<number>)} Byte(s) to emit.
-     */
-    this.handler = function (stream, code_point) {
-        // 1. If code point is end-of-stream, return finished.
-        if (code_point === end_of_stream)
-            return finished;
-        // 2. If code point is an ASCII code point, return a byte whose
-        // value is code point.
-        if (isASCIICodePoint(code_point))
-            return code_point;
-        // 3. Let pointer be the index pointer for code point in index
-        // euc-kr.
-        var pointer = indexPointerFor(code_point, index('euc-kr'));
-        // 4. If pointer is null, return error with code point.
-        if (pointer === null)
-            return encoderError(code_point);
-        // 5. Let lead be floor(pointer / 190) + 0x81.
-        var lead = floor(pointer / 190) + 0x81;
-        // 6. Let trail be pointer % 190 + 0x41.
-        var trail = (pointer % 190) + 0x41;
-        // 7. Return two bytes whose values are lead and trail.
-        return [lead, trail];
-    };
+  var fatal = options.fatal;
+
+  this.handler = function (stream, code_point) {
+    if (code_point === end_of_stream) return finished;
+    if (isASCIICodePoint(code_point)) return code_point;
+    var pointer = indexPointerFor(code_point, index('euc-kr'));
+    if (pointer === null) return encoderError(code_point);
+    var lead = floor(pointer / 190) + 0x81;
+    var trail = pointer % 190 + 0x41;
+    return [lead, trail];
+  };
 }
-/** @param {{fatal: boolean}} options */
+
 encoders['EUC-KR'] = function (options) {
-    return new EUCKREncoder(options);
+  return new EUCKREncoder(options);
 };
-/** @param {{fatal: boolean}} options */
+
 decoders['EUC-KR'] = function (options) {
-    return new EUCKRDecoder(options);
+  return new EUCKRDecoder(options);
 };
-//
-// 15. Legacy miscellaneous encodings
-//
-// 15.1 replacement
-// Not needed - API throws RangeError
-// 15.2 Common infrastructure for utf-16be and utf-16le
-/**
- * @param {number} code_unit
- * @param {boolean} utf16be
- * @return {!Array.<number>} bytes
- */
+
 function convertCodeUnitToBytes(code_unit, utf16be) {
-    // 1. Let byte1 be code unit >> 8.
-    var byte1 = code_unit >> 8;
-    // 2. Let byte2 be code unit & 0x00FF.
-    var byte2 = code_unit & 0x00ff;
-    // 3. Then return the bytes in order:
-    // utf-16be flag is set: byte1, then byte2.
-    if (utf16be)
-        return [byte1, byte2];
-    // utf-16be flag is unset: byte2, then byte1.
-    return [byte2, byte1];
+  var byte1 = code_unit >> 8;
+  var byte2 = code_unit & 0x00ff;
+  if (utf16be) return [byte1, byte2];
+  return [byte2, byte1];
 }
-// 15.2.1 shared utf-16 decoder
-/**
- * @constructor
- * @implements {Decoder}
- * @param {boolean} utf16_be True if big-endian, false if little-endian.
- * @param {{fatal: boolean}} options
- */
+
 function UTF16Decoder(utf16_be, options) {
-    var fatal = options.fatal;
-    var /** @type {?number} */ utf16_lead_byte = null, 
-    /** @type {?number} */ utf16_lead_surrogate = null;
-    /**
-     * @param {Stream} stream The stream of bytes being decoded.
-     * @param {number} bite The next byte read from the stream.
-     * @return {?(number|!Array.<number>)} The next code point(s)
-     *     decoded, or null if not enough data exists in the input
-     *     stream to decode a complete code point.
-     */
-    this.handler = function (stream, bite) {
-        // 1. If byte is end-of-stream and either utf-16 lead byte or
-        // utf-16 lead surrogate is not null, set utf-16 lead byte and
-        // utf-16 lead surrogate to null, and return error.
-        if (bite === end_of_stream && (utf16_lead_byte !== null || utf16_lead_surrogate !== null)) {
-            return decoderError(fatal);
-        }
-        // 2. If byte is end-of-stream and utf-16 lead byte and utf-16
-        // lead surrogate are null, return finished.
-        if (bite === end_of_stream && utf16_lead_byte === null && utf16_lead_surrogate === null) {
-            return finished;
-        }
-        // 3. If utf-16 lead byte is null, set utf-16 lead byte to byte
-        // and return continue.
-        if (utf16_lead_byte === null) {
-            utf16_lead_byte = bite;
-            return null;
-        }
-        // 4. Let code unit be the result of:
-        var code_unit;
-        if (utf16_be) {
-            // utf-16be decoder flag is set
-            //   (utf-16 lead byte << 8) + byte.
-            code_unit = (utf16_lead_byte << 8) + bite;
-        }
-        else {
-            // utf-16be decoder flag is unset
-            //   (byte << 8) + utf-16 lead byte.
-            code_unit = (bite << 8) + utf16_lead_byte;
-        }
-        // Then set utf-16 lead byte to null.
-        utf16_lead_byte = null;
-        // 5. If utf-16 lead surrogate is not null, let lead surrogate
-        // be utf-16 lead surrogate, set utf-16 lead surrogate to null,
-        // and then run these substeps:
-        if (utf16_lead_surrogate !== null) {
-            var lead_surrogate = utf16_lead_surrogate;
-            utf16_lead_surrogate = null;
-            // 1. If code unit is in the range U+DC00 to U+DFFF,
-            // inclusive, return a code point whose value is 0x10000 +
-            // ((lead surrogate − 0xD800) << 10) + (code unit − 0xDC00).
-            if (inRange(code_unit, 0xdc00, 0xdfff)) {
-                return 0x10000 + (lead_surrogate - 0xd800) * 0x400 + (code_unit - 0xdc00);
-            }
-            // 2. Prepend the sequence resulting of converting code unit
-            // to bytes using utf-16be decoder flag to stream and return
-            // error.
-            stream.prepend(convertCodeUnitToBytes(code_unit, utf16_be));
-            return decoderError(fatal);
-        }
-        // 6. If code unit is in the range U+D800 to U+DBFF, inclusive,
-        // set utf-16 lead surrogate to code unit and return continue.
-        if (inRange(code_unit, 0xd800, 0xdbff)) {
-            utf16_lead_surrogate = code_unit;
-            return null;
-        }
-        // 7. If code unit is in the range U+DC00 to U+DFFF, inclusive,
-        // return error.
-        if (inRange(code_unit, 0xdc00, 0xdfff))
-            return decoderError(fatal);
-        // 8. Return code point code unit.
-        return code_unit;
-    };
+  var fatal = options.fatal;
+  var utf16_lead_byte = null,
+      utf16_lead_surrogate = null;
+
+  this.handler = function (stream, bite) {
+    if (bite === end_of_stream && (utf16_lead_byte !== null || utf16_lead_surrogate !== null)) {
+      return decoderError(fatal);
+    }
+
+    if (bite === end_of_stream && utf16_lead_byte === null && utf16_lead_surrogate === null) {
+      return finished;
+    }
+
+    if (utf16_lead_byte === null) {
+      utf16_lead_byte = bite;
+      return null;
+    }
+
+    var code_unit;
+
+    if (utf16_be) {
+      code_unit = (utf16_lead_byte << 8) + bite;
+    } else {
+      code_unit = (bite << 8) + utf16_lead_byte;
+    }
+
+    utf16_lead_byte = null;
+
+    if (utf16_lead_surrogate !== null) {
+      var lead_surrogate = utf16_lead_surrogate;
+      utf16_lead_surrogate = null;
+
+      if (inRange(code_unit, 0xdc00, 0xdfff)) {
+        return 0x10000 + (lead_surrogate - 0xd800) * 0x400 + (code_unit - 0xdc00);
+      }
+
+      stream.prepend(convertCodeUnitToBytes(code_unit, utf16_be));
+      return decoderError(fatal);
+    }
+
+    if (inRange(code_unit, 0xd800, 0xdbff)) {
+      utf16_lead_surrogate = code_unit;
+      return null;
+    }
+
+    if (inRange(code_unit, 0xdc00, 0xdfff)) return decoderError(fatal);
+    return code_unit;
+  };
 }
-// 15.2.2 shared utf-16 encoder
-/**
- * @constructor
- * @implements {Encoder}
- * @param {boolean} utf16_be True if big-endian, false if little-endian.
- * @param {{fatal: boolean}} options
- */
+
 function UTF16Encoder(utf16_be, options) {
-    var fatal = options.fatal;
-    /**
-     * @param {Stream} stream Input stream.
-     * @param {number} code_point Next code point read from the stream.
-     * @return {(number|!Array.<number>)} Byte(s) to emit.
-     */
-    this.handler = function (stream, code_point) {
-        // 1. If code point is end-of-stream, return finished.
-        if (code_point === end_of_stream)
-            return finished;
-        // 2. If code point is in the range U+0000 to U+FFFF, inclusive,
-        // return the sequence resulting of converting code point to
-        // bytes using utf-16be encoder flag.
-        if (inRange(code_point, 0x0000, 0xffff))
-            return convertCodeUnitToBytes(code_point, utf16_be);
-        // 3. Let lead be ((code point − 0x10000) >> 10) + 0xD800,
-        // converted to bytes using utf-16be encoder flag.
-        var lead = convertCodeUnitToBytes(((code_point - 0x10000) >> 10) + 0xd800, utf16_be);
-        // 4. Let trail be ((code point − 0x10000) & 0x3FF) + 0xDC00,
-        // converted to bytes using utf-16be encoder flag.
-        var trail = convertCodeUnitToBytes(((code_point - 0x10000) & 0x3ff) + 0xdc00, utf16_be);
-        // 5. Return a byte sequence of lead followed by trail.
-        return lead.concat(trail);
-    };
+  var fatal = options.fatal;
+
+  this.handler = function (stream, code_point) {
+    if (code_point === end_of_stream) return finished;
+    if (inRange(code_point, 0x0000, 0xffff)) return convertCodeUnitToBytes(code_point, utf16_be);
+    var lead = convertCodeUnitToBytes((code_point - 0x10000 >> 10) + 0xd800, utf16_be);
+    var trail = convertCodeUnitToBytes((code_point - 0x10000 & 0x3ff) + 0xdc00, utf16_be);
+    return lead.concat(trail);
+  };
 }
-// 15.3 utf-16be
-// 15.3.1 utf-16be decoder
-/** @param {{fatal: boolean}} options */
+
 encoders['UTF-16BE'] = function (options) {
-    return new UTF16Encoder(true, options);
+  return new UTF16Encoder(true, options);
 };
-// 15.3.2 utf-16be encoder
-/** @param {{fatal: boolean}} options */
+
 decoders['UTF-16BE'] = function (options) {
-    return new UTF16Decoder(true, options);
+  return new UTF16Decoder(true, options);
 };
-// 15.4 utf-16le
-// 15.4.1 utf-16le decoder
-/** @param {{fatal: boolean}} options */
+
 encoders['UTF-16LE'] = function (options) {
-    return new UTF16Encoder(false, options);
+  return new UTF16Encoder(false, options);
 };
-// 15.4.2 utf-16le encoder
-/** @param {{fatal: boolean}} options */
+
 decoders['UTF-16LE'] = function (options) {
-    return new UTF16Decoder(false, options);
+  return new UTF16Decoder(false, options);
 };
-// 15.5 x-user-defined
-// 15.5.1 x-user-defined decoder
-/**
- * @constructor
- * @implements {Decoder}
- * @param {{fatal: boolean}} options
- */
+
 function XUserDefinedDecoder(options) {
-    var fatal = options.fatal;
-    /**
-     * @param {Stream} stream The stream of bytes being decoded.
-     * @param {number} bite The next byte read from the stream.
-     * @return {?(number|!Array.<number>)} The next code point(s)
-     *     decoded, or null if not enough data exists in the input
-     *     stream to decode a complete code point.
-     */
-    this.handler = function (stream, bite) {
-        // 1. If byte is end-of-stream, return finished.
-        if (bite === end_of_stream)
-            return finished;
-        // 2. If byte is an ASCII byte, return a code point whose value
-        // is byte.
-        if (isASCIIByte(bite))
-            return bite;
-        // 3. Return a code point whose value is 0xF780 + byte − 0x80.
-        return 0xf780 + bite - 0x80;
-    };
+  var fatal = options.fatal;
+
+  this.handler = function (stream, bite) {
+    if (bite === end_of_stream) return finished;
+    if (isASCIIByte(bite)) return bite;
+    return 0xf780 + bite - 0x80;
+  };
 }
-// 15.5.2 x-user-defined encoder
-/**
- * @constructor
- * @implements {Encoder}
- * @param {{fatal: boolean}} options
- */
+
 function XUserDefinedEncoder(options) {
-    var fatal = options.fatal;
-    /**
-     * @param {Stream} stream Input stream.
-     * @param {number} code_point Next code point read from the stream.
-     * @return {(number|!Array.<number>)} Byte(s) to emit.
-     */
-    this.handler = function (stream, code_point) {
-        // 1.If code point is end-of-stream, return finished.
-        if (code_point === end_of_stream)
-            return finished;
-        // 2. If code point is an ASCII code point, return a byte whose
-        // value is code point.
-        if (isASCIICodePoint(code_point))
-            return code_point;
-        // 3. If code point is in the range U+F780 to U+F7FF, inclusive,
-        // return a byte whose value is code point − 0xF780 + 0x80.
-        if (inRange(code_point, 0xf780, 0xf7ff))
-            return code_point - 0xf780 + 0x80;
-        // 4. Return error with code point.
-        return encoderError(code_point);
-    };
+  var fatal = options.fatal;
+
+  this.handler = function (stream, code_point) {
+    if (code_point === end_of_stream) return finished;
+    if (isASCIICodePoint(code_point)) return code_point;
+    if (inRange(code_point, 0xf780, 0xf7ff)) return code_point - 0xf780 + 0x80;
+    return encoderError(code_point);
+  };
 }
-/** @param {{fatal: boolean}} options */
+
 encoders['x-user-defined'] = function (options) {
-    return new XUserDefinedEncoder(options);
+  return new XUserDefinedEncoder(options);
 };
-/** @param {{fatal: boolean}} options */
+
 decoders['x-user-defined'] = function (options) {
-    return new XUserDefinedDecoder(options);
+  return new XUserDefinedDecoder(options);
 };
+
+export { TextEncoder, TextDecoder };
+//# sourceMappingURL=encoding.js.map