@loaders.gl/polyfills 3.4.0-alpha.2 → 3.4.0-alpha.3

package/dist/es5/lib/encoding.js

@@ -8,74 +8,49 @@ exports.TextDecoder = TextDecoder;
 exports.TextEncoder = TextEncoder;
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 var _encodingIndexes = _interopRequireDefault(require("./encoding-indexes"));
-
 global['encoding-indexes'] = _encodingIndexes.default || {};
-
 function inRange(a, min, max) {
   return min <= a && a <= max;
 }
-
 function includes(array, item) {
   return array.indexOf(item) !== -1;
 }
 var floor = Math.floor;
-
 function ToDictionary(o) {
   if (o === undefined) return {};
   if (o === Object(o)) return o;
   throw TypeError('Could not convert argument to dictionary');
 }
-
 function stringToCodePoints(string) {
-
   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) {
+    } else if (0xdc00 <= c && c <= 0xdfff) {
       u.push(0xfffd);
-    }
-
-    else if (0xd800 <= c && c <= 0xdbff) {
+    } else if (0xd800 <= c && c <= 0xdbff) {
       if (i === n - 1) {
         u.push(0xfffd);
-      }
-      else {
+      } 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 {
+        } else {
           u.push(0xfffd);
         }
       }
     }
-
     i += 1;
   }
-
   return u;
 }
-
 function codePointsToString(code_points) {
   var s = '';
   for (var i = 0; i < code_points.length; ++i) {
@@ -89,15 +64,11 @@ function codePointsToString(code_points) {
   }
   return s;
 }
-
 function isASCIIByte(a) {
   return 0x00 <= a && a <= 0x7f;
 }
-
 var isASCIICodePoint = isASCIIByte;
-
 var end_of_stream = -1;
-
 function Stream(tokens) {
   this.tokens = [].slice.call(tokens);
   this.tokens.reverse();
@@ -113,9 +84,7 @@ Stream.prototype = {
   prepend: function prepend(token) {
     if (Array.isArray(token)) {
       var tokens = token;
-      while (tokens.length) {
-        this.tokens.push(tokens.pop());
-      }
+      while (tokens.length) this.tokens.push(tokens.pop());
     } else {
       this.tokens.push(token);
     }
@@ -123,45 +92,35 @@ Stream.prototype = {
   push: function push(token) {
     if (Array.isArray(token)) {
       var tokens = token;
-      while (tokens.length) {
-        this.tokens.unshift(tokens.shift());
-      }
+      while (tokens.length) this.tokens.unshift(tokens.shift());
     } else {
       this.tokens.unshift(token);
     }
   }
 };
-
 var finished = -1;
-
 function decoderError(fatal, opt_code_point) {
   if (fatal) throw TypeError('Decoder error');
   return opt_code_point || 0xfffd;
 }
-
 function encoderError(code_point) {
   throw TypeError('The code point ' + code_point + ' could not be encoded.');
 }
-
 function Decoder() {}
 Decoder.prototype = {
   handler: function handler(stream, bite) {}
 };
-
 function Encoder() {}
 Encoder.prototype = {
   handler: function handler(stream, code_point) {}
 };
-
 function getEncoding(label) {
   label = String(label).trim().toLowerCase();
-
   if (Object.prototype.hasOwnProperty.call(label_to_encoding, label)) {
     return label_to_encoding[label];
   }
   return null;
 }
-
 var encodings = [{
   encodings: [{
     labels: ['unicode-1-1-utf-8', 'utf-8', 'utf8'],
@@ -304,7 +263,6 @@ var encodings = [{
   }],
   heading: 'Legacy miscellaneous encodings'
 }];
-
 var label_to_encoding = {};
 encodings.forEach(function (category) {
   category.encodings.forEach(function (encoding) {
@@ -313,32 +271,25 @@ encodings.forEach(function (category) {
     });
   });
 });
-
 var encoders = {};
 var decoders = {};
-
 function indexCodePointFor(pointer, index) {
   if (!index) return null;
   return index[pointer] || null;
 }
-
 function indexPointerFor(code_point, index) {
   var pointer = index.indexOf(code_point);
   return pointer === -1 ? null : pointer;
 }
-
 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];
 }
-
 function indexGB18030RangesCodePointFor(pointer) {
   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');
@@ -352,13 +303,10 @@ function indexGB18030RangesCodePointFor(pointer) {
       break;
     }
   }
-
   return code_point_offset + pointer - offset;
 }
-
 function indexGB18030RangesPointerFor(code_point) {
   if (code_point === 0xe7c7) return 7457;
-
   var offset = 0;
   var pointer_offset = 0;
   var idx = index('gb18030-ranges');
@@ -372,69 +320,52 @@ function indexGB18030RangesPointerFor(code_point) {
       break;
     }
   }
-
   return pointer_offset + code_point - offset;
 }
-
 function indexShiftJISPointerFor(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;
-
 function indexBig5PointerFor(code_point) {
   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;
-
 var DEFAULT_ENCODING = 'utf-8';
-
 function TextDecoder(label, options) {
   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;
 }
 if (Object.defineProperty) {
@@ -443,20 +374,17 @@ if (Object.defineProperty) {
       return this._encoding.name.toLowerCase();
     }
   });
-
   Object.defineProperty(TextDecoder.prototype, 'fatal', {
     get: function get() {
       return this._error_mode === 'fatal';
     }
   });
-
   Object.defineProperty(TextDecoder.prototype, 'ignoreBOM', {
     get: function get() {
       return this._ignoreBOM;
     }
   });
 }
-
 TextDecoder.prototype.decode = function decode(input, options) {
   var bytes;
   if ((0, _typeof2.default)(input) === 'object' && input instanceof ArrayBuffer) {
@@ -467,34 +395,24 @@ TextDecoder.prototype.decode = function decode(input, options) {
     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);
     }
-
   }
   if (!this._do_not_flush) {
     do {
@@ -505,35 +423,27 @@ TextDecoder.prototype.decode = function decode(input, options) {
     } 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 {
-      }
+      } else {}
     }
     return codePointsToString(stream);
   }
   return serializeStream.call(this, output);
 };
-
 function TextEncoder(label, options) {
   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);
@@ -548,9 +458,7 @@ function TextEncoder(label, options) {
       console.warn('TextEncoder constructor called with encoding label, ' + 'which is ignored.');
     }
   }
-
   if (!Object.defineProperty) this.encoding = enc._encoding.name.toLowerCase();
-
   return enc;
 }
 if (Object.defineProperty) {
@@ -560,20 +468,15 @@ if (Object.defineProperty) {
     }
   });
 }
-
 TextEncoder.prototype.encode = function encode(opt_string, options) {
   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();
@@ -592,151 +495,105 @@ TextEncoder.prototype.encode = function encode(opt_string, options) {
   }
   return new Uint8Array(output);
 };
-
 function UTF8Decoder(options) {
   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)) {
+      } else if (inRange(bite, 0xc2, 0xdf)) {
         utf8_bytes_needed = 1;
-
         utf8_code_point = bite & 0x1f;
-      }
-
-      else if (inRange(bite, 0xe0, 0xef)) {
+      } 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)) {
+      } 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 {
+      } else {
         return decoderError(fatal);
       }
-
       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;
   };
 }
-
 function UTF8Encoder(options) {
   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)) {
+    } else if (inRange(code_point, 0x0800, 0xffff)) {
       count = 2;
       offset = 0xe0;
-    }
-    else if (inRange(code_point, 0x10000, 0x10ffff)) {
+    } 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;
   };
 }
-
 encoders['UTF-8'] = function (options) {
   return new UTF8Encoder(options);
 };
 decoders['UTF-8'] = function (options) {
   return new UTF8Decoder(options);
 };
-
 function SingleByteDecoder(index, options) {
   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;
   };
 }
-
 function SingleByteEncoder(index, options) {
   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;
   };
 }
@@ -756,15 +613,12 @@ function SingleByteEncoder(index, options) {
     });
   });
 })();
-
 decoders['GBK'] = function (options) {
   return new GB18030Decoder(options);
 };
-
 encoders['GBK'] = function (options) {
   return new GB18030Encoder(options, true);
 };
-
 function GB18030Decoder(options) {
   var fatal = options.fatal;
   var gb18030_first = 0x00,
@@ -786,140 +640,96 @@ function GB18030Decoder(options) {
       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);
   };
 }
-
 function GB18030Encoder(options, gbk_flag) {
   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];
   };
 }
-
 encoders['gb18030'] = function (options) {
   return new GB18030Encoder(options);
 };
 decoders['gb18030'] = function (options) {
   return new GB18030Decoder(options);
 };
-
 function Big5Decoder(options) {
   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];
@@ -930,146 +740,100 @@ function Big5Decoder(options) {
         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);
   };
 }
-
 function Big5Encoder(options) {
   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];
   };
 }
-
 encoders['Big5'] = function (options) {
   return new Big5Encoder(options);
 };
 decoders['Big5'] = function (options) {
   return new Big5Decoder(options);
 };
-
 function EUCJPDecoder(options) {
   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);
   };
 }
-
 function EUCJPEncoder(options) {
   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];
   };
 }
-
 encoders['EUC-JP'] = function (options) {
   return new EUCJPEncoder(options);
 };
 decoders['EUC-JP'] = function (options) {
   return new EUCJPDecoder(options);
 };
-
 function ISO2022JPDecoder(options) {
   var fatal = options.fatal;
   var states = {
@@ -1089,163 +853,121 @@ function ISO2022JPDecoder(options) {
     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);
     }
   };
 }
-
 function ISO2022JPEncoder(options) {
   var fatal = options.fatal;
   var states = {
@@ -1260,62 +982,45 @@ function ISO2022JPEncoder(options) {
       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];
   };
 }
-
 encoders['ISO-2022-JP'] = function (options) {
   return new ISO2022JPEncoder(options);
 };
 decoders['ISO-2022-JP'] = function (options) {
   return new ISO2022JPDecoder(options);
 };
-
 function ShiftJISDecoder(options) {
   var fatal = options.fatal;
   var Shift_JIS_lead = 0x00;
@@ -1324,156 +1029,104 @@ function ShiftJISDecoder(options) {
       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);
   };
 }
-
 function ShiftJISEncoder(options) {
   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];
   };
 }
-
 encoders['Shift_JIS'] = function (options) {
   return new ShiftJISEncoder(options);
 };
 decoders['Shift_JIS'] = function (options) {
   return new ShiftJISDecoder(options);
 };
-
 function EUCKRDecoder(options) {
   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);
   };
 }
-
 function EUCKREncoder(options) {
   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];
   };
 }
-
 encoders['EUC-KR'] = function (options) {
   return new EUCKREncoder(options);
 };
 decoders['EUC-KR'] = function (options) {
   return new EUCKRDecoder(options);
 };
-
 function convertCodeUnitToBytes(code_unit, utf16be) {
   var byte1 = code_unit >> 8;
-
   var byte2 = code_unit & 0x00ff;
-
   if (utf16be) return [byte1, byte2];
   return [byte2, byte1];
 }
-
 function UTF16Decoder(utf16_be, options) {
   var fatal = options.fatal;
   var utf16_lead_byte = null,
@@ -1482,16 +1135,13 @@ function UTF16Decoder(utf16_be, options) {
     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;
@@ -1499,83 +1149,62 @@ function UTF16Decoder(utf16_be, options) {
       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;
   };
 }
-
 function UTF16Encoder(utf16_be, options) {
   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);
   };
 }
-
 encoders['UTF-16BE'] = function (options) {
   return new UTF16Encoder(true, options);
 };
 decoders['UTF-16BE'] = function (options) {
   return new UTF16Decoder(true, options);
 };
-
 encoders['UTF-16LE'] = function (options) {
   return new UTF16Encoder(false, options);
 };
 decoders['UTF-16LE'] = function (options) {
   return new UTF16Decoder(false, options);
 };
-
 function XUserDefinedDecoder(options) {
   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;
   };
 }
-
 function XUserDefinedEncoder(options) {
   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);
   };
 }
-
 encoders['x-user-defined'] = function (options) {
   return new XUserDefinedEncoder(options);
 };