Creationshop/cannaiq
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
eedc027ff6d1b6e9804bbd6c3223b49667ac361b
cannaiq/backend/node_modules/@zxing/text-encoding/umd/encoding.js
Kelly 5757a8e9bd Initial commit - Dutchie dispensary scraper
2025-11-28 19:45:44 -07:00

2928 lines
122 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(global = global || self, factory(global.TextEncoding = {}));
}(this, (function (exports) { 'use strict';
/** @const */ var DEFAULT_ENCODING = 'utf-8';
/**
* @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 (opt_code_point === void 0) { opt_code_point = undefined; }
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.");
}
// 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.
var keyLabel = 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 (keyLabel in label_to_encoding) {
return label_to_encoding[keyLabel];
}
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",
"cp1252",
"cp819",
"ibm819",
"iso-ir-100",
"windows-1252",
"x-cp1252",
],
name: "windows-1252",
},
{
labels: [
"ascii",
"us-ascii",
"iso-8859-1",
"iso8859-1",
"iso88591",
"iso_8859-1",
"iso_8859-1:1987",
"l1",
"latin1",
"csisolatin1",
],
name: "iso-8859-1",
},
{
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 label_to_encoding = {};
encodings.forEach(function (category) {
category.encodings.forEach(function (encoding) {
encoding.labels.forEach(function (label) {
label_to_encoding[label] = encoding;
});
});
});
// 5.1 Encoders and decoders
/** @const */
var finished = -1;
function getArrayVal(idxVal) {
return Array.isArray(idxVal) ? idxVal : [idxVal];
}
/**
* @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.
*/
function inRange(a, min, 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;
}
/**
* @param {*} o
* @return {Object}
*/
function ToDictionary(o) {
if (o === undefined || o === null)
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.
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);
}
}
}
// 3. Set i to i+1.
i += 1;
}
// 6. Return U.
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);
}
}
return s;
}
function getGlobalScope() {
if (typeof global !== 'undefined')
return global;
if (typeof window !== 'undefined')
return window;
if (typeof self !== 'undefined')
return self;
return;
}
var _encodingIndexes;
function checkForEncodingIndexes() {
if (typeof TextEncodingIndexes !== 'undefined')
return TextEncodingIndexes.encodingIndexes;
var glo = getGlobalScope();
if (!glo)
return null;
if ('TextEncodingIndexes' in glo)
return global['TextEncodingIndexes']['encodingIndexes'];
if ('encoding-indexes' in glo)
return global['encodingIndexes'];
return null;
}
function getEncodingIndexes() {
if (_encodingIndexes) {
return _encodingIndexes;
}
var indexes = checkForEncodingIndexes();
if (!indexes) {
return null;
}
_encodingIndexes = indexes;
return 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;
}
/**
* @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;
}
/**
* @param {string} name Name of the index.
* @return {(!Array.<number>|!Array.<Array.<number>>)}
* */
function index(name) {
var encodingIndexes = getEncodingIndexes();
if (!encodingIndexes) {
throw Error("Indexes missing." +
" Did you forget to include encoding-indexes.js first?");
}
return encodingIndexes[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');
for (var i = 0; i < idx.length; ++i) {
/** @type {!Array.<number>} */
var entry = getArrayVal(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;
}
/**
* @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');
for (var i = 0; i < idx.length; ++i) {
var idxVal = idx[i];
/** @type {!Array.<number>} */
var entry = getArrayVal(idxVal);
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;
}
/**
* @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);
}
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_);
}
var big5_index_no_hkscs;
//
// 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;
}
/**
* 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;
/**
* @constructor
* @implements {Decoder}
* @param {{fatal: boolean}} options
*/
var Big5Decoder = /** @class */ (function () {
function Big5Decoder(options) {
this.fatal = options.fatal;
// Big5's decoder has an associated Big5 lead (initially 0x00).
/** @type {number} */ this.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.
*/
Big5Decoder.prototype.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 && this.Big5_lead !== 0x00) {
this.Big5_lead = 0x00;
return decoderError(this.fatal);
}
// 2. If byte is end-of-stream and Big5 lead is 0x00, return
// finished.
if (bite === end_of_stream && this.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 (this.Big5_lead !== 0x00) {
var lead = this.Big5_lead;
var pointer = null;
this.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(this.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)) {
this.Big5_lead = bite;
return null;
}
// 6. Return error.
return decoderError(this.fatal);
};
return Big5Decoder;
}());
/**
* @constructor
* @implements {Encoder}
* @param {{fatal: boolean}} options
*/
var Big5Encoder = /** @class */ (function () {
function Big5Encoder(options) {
this.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.
*/
Big5Encoder.prototype.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 Math.floor(pointer / 157) + 0x81.
var lead = Math.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];
};
return Big5Encoder;
}());
/**
* @constructor
* @implements {Decoder}
* @param {{fatal: boolean}} options
*/
var EUCJPDecoder = /** @class */ (function () {
function EUCJPDecoder(options) {
this.fatal = options.fatal;
// euc-jp's decoder has an associated euc-jp jis0212 flag
// (initially unset) and euc-jp lead (initially 0x00).
/** @type {boolean} */ this.eucjp_jis0212_flag = false,
/** @type {number} */ this.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.
*/
EUCJPDecoder.prototype.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 && this.eucjp_lead !== 0x00) {
this.eucjp_lead = 0x00;
return decoderError(this.fatal);
}
// 2. If byte is end-of-stream and euc-jp lead is 0x00, return
// finished.
if (bite === end_of_stream && this.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 (this.eucjp_lead === 0x8E && inRange(bite, 0xA1, 0xDF)) {
this.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 (this.eucjp_lead === 0x8F && inRange(bite, 0xA1, 0xFE)) {
this.eucjp_jis0212_flag = true;
this.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 (this.eucjp_lead !== 0x00) {
var lead = this.eucjp_lead;
this.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(!this.eucjp_jis0212_flag ? 'jis0208' : 'jis0212'));
}
// 3. Unset the euc-jp jis0212 flag.
this.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(this.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)) {
this.eucjp_lead = bite;
return null;
}
// 8. Return error.
return decoderError(this.fatal);
};
return EUCJPDecoder;
}());
/**
* @constructor
* @implements {Encoder}
* @param {{fatal: boolean}} options
*/
var EUCJPEncoder = /** @class */ (function () {
function EUCJPEncoder(options) {
this.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.
*/
EUCJPEncoder.prototype.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 Math.floor(pointer / 94) + 0xA1.
var lead = Math.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];
};
return EUCJPEncoder;
}());
/**
* @constructor
* @implements {Decoder}
* @param {{fatal: boolean}} options
*/
var EUCKRDecoder = /** @class */ (function () {
function EUCKRDecoder(options) {
this.fatal = options.fatal;
// euc-kr's decoder has an associated euc-kr lead (initially 0x00).
/** @type {number} */ this.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.
*/
EUCKRDecoder.prototype.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 && this.euckr_lead !== 0) {
this.euckr_lead = 0x00;
return decoderError(this.fatal);
}
// 2. If byte is end-of-stream and euc-kr lead is 0x00, return
// finished.
if (bite === end_of_stream && this.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 (this.euckr_lead !== 0x00) {
var lead = this.euckr_lead;
var pointer = null;
this.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(this.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)) {
this.euckr_lead = bite;
return null;
}
// 6. Return error.
return decoderError(this.fatal);
};
return EUCKRDecoder;
}());
/**
* @constructor
* @implements {Encoder}
* @param {{fatal: boolean}} options
*/
var EUCKREncoder = /** @class */ (function () {
function EUCKREncoder(options) {
this.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.
*/
EUCKREncoder.prototype.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 Math.floor(pointer / 190) + 0x81.
var lead = Math.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];
};
return EUCKREncoder;
}());
/**
* @constructor
* @implements {Decoder}
* @param {{fatal: boolean}} options
*/
var GB18030Decoder = /** @class */ (function () {
function GB18030Decoder(options) {
this.fatal = options.fatal;
// gb18030's decoder has an associated gb18030 first, gb18030
// second, and gb18030 third (all initially 0x00).
/** @type {number} */ this.gb18030_first = 0x00,
/** @type {number} */ this.gb18030_second = 0x00,
/** @type {number} */ this.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.
*/
GB18030Decoder.prototype.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 && this.gb18030_first === 0x00 &&
this.gb18030_second === 0x00 && this.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 &&
(this.gb18030_first !== 0x00 || this.gb18030_second !== 0x00 ||
this.gb18030_third !== 0x00)) {
this.gb18030_first = 0x00;
this.gb18030_second = 0x00;
this.gb18030_third = 0x00;
decoderError(this.fatal);
}
var code_point;
// 3. If gb18030 third is not 0x00, run these substeps:
if (this.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((((this.gb18030_first - 0x81) * 10 + this.gb18030_second - 0x30) * 126 +
this.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 = [this.gb18030_second, this.gb18030_third, bite];
// 4. Set gb18030 first, gb18030 second, and gb18030 third to
// 0x00.
this.gb18030_first = 0x00;
this.gb18030_second = 0x00;
this.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(this.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 (this.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)) {
this.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([this.gb18030_second, bite]);
this.gb18030_first = 0x00;
this.gb18030_second = 0x00;
return decoderError(this.fatal);
}
// 5. If gb18030 first is not 0x00, run these substeps:
if (this.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)) {
this.gb18030_second = bite;
return null;
}
// 2. Let lead be gb18030 first, let pointer be null, and set
// gb18030 first to 0x00.
var lead = this.gb18030_first;
var pointer = null;
this.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(this.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)) {
this.gb18030_first = bite;
return null;
}
// 9. Return error.
return decoderError(this.fatal);
};
return GB18030Decoder;
}());
/**
* @constructor
* @implements {Encoder}
* @param {{fatal: boolean}} options
* @param {boolean=} gbk_flag
*/
var GB18030Encoder = /** @class */ (function () {
function GB18030Encoder(options, gbk_flag) {
if (gbk_flag === void 0) { gbk_flag = undefined; }
this.gbk_flag = gbk_flag;
this.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.
*/
GB18030Encoder.prototype.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 (this.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 Math.floor(pointer / 190) + 0x81.
var lead = Math.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 (this.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 Math.floor(pointer / 10 / 126 / 10).
var byte1 = Math.floor(pointer / 10 / 126 / 10);
// 10. Set pointer to pointer − byte1 × 10 × 126 × 10.
pointer = pointer - byte1 * 10 * 126 * 10;
// 11. Let byte2 be Math.floor(pointer / 10 / 126).
var byte2 = Math.floor(pointer / 10 / 126);
// 12. Set pointer to pointer − byte2 × 10 × 126.
pointer = pointer - byte2 * 10 * 126;
// 13. Let byte3 be Math.floor(pointer / 10).
var byte3 = Math.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];
};
return GB18030Encoder;
}());
var states;
(function (states) {
states[states["ASCII"] = 0] = "ASCII";
states[states["Roman"] = 1] = "Roman";
states[states["Katakana"] = 2] = "Katakana";
states[states["LeadByte"] = 3] = "LeadByte";
states[states["TrailByte"] = 4] = "TrailByte";
states[states["EscapeStart"] = 5] = "EscapeStart";
states[states["Escape"] = 6] = "Escape";
})(states || (states = {}));
var ISO2022JPDecoder = /** @class */ (function () {
/**
* @constructor
* @implements {Decoder}
* @param {{fatal: boolean}} options
*/
function ISO2022JPDecoder(options) {
this.fatal = options.fatal;
// 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).
/** @type {number} */ this.iso2022jp_decoder_state = states.ASCII,
/** @type {number} */ this.iso2022jp_decoder_output_state = states.ASCII,
/** @type {number} */ this.iso2022jp_lead = 0x00,
/** @type {boolean} */ this.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.
*/
ISO2022JPDecoder.prototype.handler = function (stream, bite) {
// switching on iso-2022-jp decoder state:
switch (this.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.
this.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.
this.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.
this.iso2022jp_output_flag = false;
return decoderError(this.fatal);
case states.Roman:
// Roman
// Based on byte:
// 0x1B
if (bite === 0x1B) {
// Set iso-2022-jp decoder state to escape start and return
// continue.
this.iso2022jp_decoder_state = states.EscapeStart;
return null;
}
// 0x5C
if (bite === 0x5C) {
// Unset the iso-2022-jp output flag and return code point
// U+00A5.
this.iso2022jp_output_flag = false;
return 0x00A5;
}
// 0x7E
if (bite === 0x7E) {
// Unset the iso-2022-jp output flag and return code point
// U+203E.
this.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.
this.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.
this.iso2022jp_output_flag = false;
return decoderError(this.fatal);
case states.Katakana:
// Katakana
// Based on byte:
// 0x1B
if (bite === 0x1B) {
// Set iso-2022-jp decoder state to escape start and return
// continue.
this.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.
this.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.
this.iso2022jp_output_flag = false;
return decoderError(this.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.
this.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.
this.iso2022jp_output_flag = false;
this.iso2022jp_lead = bite;
this.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.
this.iso2022jp_output_flag = false;
return decoderError(this.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.
this.iso2022jp_decoder_state = states.EscapeStart;
return decoderError(this.fatal);
}
// 0x21 to 0x7E
if (inRange(bite, 0x21, 0x7E)) {
// 1. Set the iso-2022-jp decoder state to lead byte.
this.iso2022jp_decoder_state = states.LeadByte;
// 2. Let pointer be (iso-2022-jp lead − 0x21) × 94 + byte − 0x21.
var pointer = (this.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(this.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.
this.iso2022jp_decoder_state = states.LeadByte;
stream.prepend(bite);
return decoderError(this.fatal);
}
// Otherwise
// Set iso-2022-jp decoder state to lead byte and return
// error.
this.iso2022jp_decoder_state = states.LeadByte;
return decoderError(this.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) {
this.iso2022jp_lead = bite;
this.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.
this.iso2022jp_output_flag = false;
this.iso2022jp_decoder_state = this.iso2022jp_decoder_output_state;
return decoderError(this.fatal);
case states.Escape:
// Escape
// 1. Let lead be iso-2022-jp lead and set iso-2022-jp lead to
// 0x00.
var lead = this.iso2022jp_lead;
this.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.
this.iso2022jp_decoder_state = this.iso2022jp_decoder_state = state;
// 2. Let output flag be the iso-2022-jp output flag.
var output_flag = this.iso2022jp_output_flag;
// 3. Set the iso-2022-jp output flag.
this.iso2022jp_output_flag = true;
// 4. Return continue, if output flag is unset, and error
// otherwise.
return !output_flag ? null : decoderError(this.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.
this.iso2022jp_output_flag = false;
this.iso2022jp_decoder_state = this.iso2022jp_decoder_output_state;
return decoderError(this.fatal);
}
};
return ISO2022JPDecoder;
}());
var states$1;
(function (states) {
states[states["ASCII"] = 0] = "ASCII";
states[states["Roman"] = 1] = "Roman";
states[states["jis0208"] = 2] = "jis0208";
})(states$1 || (states$1 = {}));
/**
* @constructor
* @implements {Encoder}
* @param {{fatal: boolean}} options
*/
var ISO2022JPEncoder = /** @class */ (function () {
function ISO2022JPEncoder(options) {
this.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).
/** @type {number} */ this.iso2022jp_state = states$1.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.
*/
ISO2022JPEncoder.prototype.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 &&
this.iso2022jp_state !== states$1.ASCII) {
stream.prepend(code_point);
this.iso2022jp_state = states$1.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 && this.iso2022jp_state === states$1.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 ((this.iso2022jp_state === states$1.ASCII ||
this.iso2022jp_state === states$1.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 (this.iso2022jp_state === states$1.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 (this.iso2022jp_state === states$1.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) &&
this.iso2022jp_state !== states$1.ASCII) {
stream.prepend(code_point);
this.iso2022jp_state = states$1.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) &&
this.iso2022jp_state !== states$1.Roman) {
stream.prepend(code_point);
this.iso2022jp_state = states$1.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 (this.iso2022jp_state !== states$1.jis0208) {
stream.prepend(code_point);
this.iso2022jp_state = states$1.jis0208;
return [0x1B, 0x24, 0x42];
}
// 12. Let lead be Math.floor(pointer / 94) + 0x21.
var lead = Math.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];
};
return ISO2022JPEncoder;
}());
/**
* @constructor
* @implements {Decoder}
* @param {{fatal: boolean}} options
*/
var ShiftJISDecoder = /** @class */ (function () {
function ShiftJISDecoder(options) {
this.fatal = options.fatal;
// Shift_JIS's decoder has an associated Shift_JIS lead (initially
// 0x00).
/** @type {number} */ this.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.
*/
ShiftJISDecoder.prototype.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 && this.Shift_JIS_lead !== 0x00) {
this.Shift_JIS_lead = 0x00;
return decoderError(this.fatal);
}
// 2. If byte is end-of-stream and Shift_JIS lead is 0x00,
// return finished.
if (bite === end_of_stream && this.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 (this.Shift_JIS_lead !== 0x00) {
var lead = this.Shift_JIS_lead;
var pointer = null;
this.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(this.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)) {
this.Shift_JIS_lead = bite;
return null;
}
// 7. Return error.
return decoderError(this.fatal);
};
return ShiftJISDecoder;
}());
/**
* @constructor
* @implements {Encoder}
* @param {{fatal: boolean}} options
*/
var ShiftJISEncoder = /** @class */ (function () {
function ShiftJISEncoder(options) {
this.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.
*/
ShiftJISEncoder.prototype.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 Math.floor(pointer / 188).
var lead = Math.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];
};
return ShiftJISEncoder;
}());
/**
* @constructor
* @implements {Decoder}
* @param {!Array.<number>} index The encoding index.
* @param {{fatal: boolean}} options
*/
var SingleByteDecoder = /** @class */ (function () {
function SingleByteDecoder(index, options) {
this.index = index;
this.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.
*/
SingleByteDecoder.prototype.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 = this.index[bite - 0x80];
// 4. If code point is null, return error.
if (!code_point)
return decoderError(this.fatal);
// 5. Return a code point whose value is code point.
return code_point;
};
return SingleByteDecoder;
}());
/**
* @constructor
* @implements {Encoder}
* @param {!Array.<?number>} index The encoding index.
* @param {{fatal: boolean}} options
*/
var SingleByteEncoder = /** @class */ (function () {
function SingleByteEncoder(index, options) {
this.index = index;
this.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.
*/
SingleByteEncoder.prototype.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, this.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;
};
return SingleByteEncoder;
}());
/**
* @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];
}
/**
* @constructor
* @implements {Decoder}
* @param {boolean} utf16_be True if big-endian, false if little-endian.
* @param {{fatal: boolean}} options
*/
var UTF16Decoder = /** @class */ (function () {
function UTF16Decoder(utf16_be, options) {
this.utf16_be = utf16_be;
this.fatal = options.fatal;
/** @type {?number} */ this.utf16_lead_byte = null;
/** @type {?number} */ this.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.
*/
UTF16Decoder.prototype.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 && (this.utf16_lead_byte !== null ||
this.utf16_lead_surrogate !== null)) {
return decoderError(this.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 && this.utf16_lead_byte === null &&
this.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 (this.utf16_lead_byte === null) {
this.utf16_lead_byte = bite;
return null;
}
// 4. Let code unit be the result of:
var code_unit;
if (this.utf16_be) {
// utf-16be decoder flag is set
// (utf-16 lead byte << 8) + byte.
code_unit = (this.utf16_lead_byte << 8) + bite;
}
else {
// utf-16be decoder flag is unset
// (byte << 8) + utf-16 lead byte.
code_unit = (bite << 8) + this.utf16_lead_byte;
}
// Then set utf-16 lead byte to null.
this.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 (this.utf16_lead_surrogate !== null) {
var lead_surrogate = this.utf16_lead_surrogate;
this.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, this.utf16_be));
return decoderError(this.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)) {
this.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(this.fatal);
// 8. Return code point code unit.
return code_unit;
};
return UTF16Decoder;
}());
/**
* @constructor
* @implements {Encoder}
* @param {boolean} utf16_be True if big-endian, false if little-endian.
* @param {{fatal: boolean}} options
*/
var UTF16Encoder = /** @class */ (function () {
function UTF16Encoder(utf16_be, options) {
this.utf16_be = utf16_be;
this.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.
*/
UTF16Encoder.prototype.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, this.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, this.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, this.utf16_be);
// 5. Return a byte sequence of lead followed by trail.
return lead.concat(trail);
};
return UTF16Encoder;
}());
/**
* @constructor
* @implements {Decoder}
* @param {{fatal: boolean}} options
*/
var UTF8Decoder = /** @class */ (function () {
function UTF8Decoder(options) {
this.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).
/** @type {number} */ this.utf8_code_point = 0,
/** @type {number} */ this.utf8_bytes_seen = 0,
/** @type {number} */ this.utf8_bytes_needed = 0,
/** @type {number} */ this.utf8_lower_boundary = 0x80,
/** @type {number} */ this.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.
*/
UTF8Decoder.prototype.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 && this.utf8_bytes_needed !== 0) {
this.utf8_bytes_needed = 0;
return decoderError(this.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 (this.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.
this.utf8_bytes_needed = 1;
// 2. Set UTF-8 code point to byte & 0x1F.
this.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)
this.utf8_lower_boundary = 0xA0;
// 2. If byte is 0xED, set utf-8 upper boundary to 0x9F.
if (bite === 0xED)
this.utf8_upper_boundary = 0x9F;
// 3. Set utf-8 bytes needed to 2.
this.utf8_bytes_needed = 2;
// 4. Set UTF-8 code point to byte & 0xF.
this.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)
this.utf8_lower_boundary = 0x90;
// 2. If byte is 0xF4, set utf-8 upper boundary to 0x8F.
if (bite === 0xF4)
this.utf8_upper_boundary = 0x8F;
// 3. Set utf-8 bytes needed to 3.
this.utf8_bytes_needed = 3;
// 4. Set UTF-8 code point to byte & 0x7.
this.utf8_code_point = bite & 0x7;
}
// Otherwise
else {
// Return error.
return decoderError(this.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, this.utf8_lower_boundary, this.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.
this.utf8_code_point = this.utf8_bytes_needed = this.utf8_bytes_seen = 0;
this.utf8_lower_boundary = 0x80;
this.utf8_upper_boundary = 0xBF;
// 2. Prepend byte to stream.
stream.prepend(bite);
// 3. Return error.
return decoderError(this.fatal);
}
// 5. Set utf-8 lower boundary to 0x80 and utf-8 upper boundary
// to 0xBF.
this.utf8_lower_boundary = 0x80;
this.utf8_upper_boundary = 0xBF;
// 6. Set UTF-8 code point to (UTF-8 code point << 6) | (byte &
// 0x3F)
this.utf8_code_point = (this.utf8_code_point << 6) | (bite & 0x3F);
// 7. Increase utf-8 bytes seen by one.
this.utf8_bytes_seen += 1;
// 8. If utf-8 bytes seen is not equal to utf-8 bytes needed,
// continue.
if (this.utf8_bytes_seen !== this.utf8_bytes_needed)
return null;
// 9. Let code point be utf-8 code point.
var code_point = this.utf8_code_point;
// 10. Set utf-8 code point, utf-8 bytes needed, and utf-8 bytes
// seen to 0.
this.utf8_code_point = this.utf8_bytes_needed = this.utf8_bytes_seen = 0;
// 11. Return a code point whose value is code point.
return code_point;
};
return UTF8Decoder;
}());
/**
* @constructor
* @implements {Encoder}
* @param {{fatal: boolean}} options
*/
var UTF8Encoder = /** @class */ (function () {
function UTF8Encoder(options) {
this.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.
*/
UTF8Encoder.prototype.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;
};
return UTF8Encoder;
}());
/**
* @constructor
* @implements {Decoder}
* @param {{fatal: boolean}} options
*/
var XUserDefinedDecoder = /** @class */ (function () {
function XUserDefinedDecoder(options) {
this.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.
*/
XUserDefinedDecoder.prototype.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;
};
return XUserDefinedDecoder;
}());
/**
* @constructor
* @implements {Encoder}
* @param {{fatal: boolean}} options
*/
var XUserDefinedEncoder = /** @class */ (function () {
function XUserDefinedEncoder(options) {
this.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.
*/
XUserDefinedEncoder.prototype.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);
};
return XUserDefinedEncoder;
}());
// This is free and unencumbered software released into the public domain.
//
// Utilities
//
// import './encoding/utilities';
//
// Implementation of Encoding specification
// https://encoding.spec.whatwg.org/
//
//
// 4. Terminology
//
// import './encoding/terminology';
//
// 5. Encodings
//
// import "./encoding/encodings";
//
// 6. Indexes
//
// import './encoding/indexes';
var encodingIndexes = getEncodingIndexes();
// Registry of of encoder/decoder factories, by encoding name.
/** @type {Object.<string, function({fatal:boolean}): Encoder>} */
// const encoders: Encoders = {};
/** @type {Object.<string, function({fatal:boolean}): Decoder>} */
// const decoders: Decoders = {};
//
// 10. Legacy single-byte encodings
//
// 10.1 single-byte decoder
// 10.2 single-byte encoder
var encoders = {
// 9.1 utf-8
// 9.1.1 utf-8 decoder
// 9.1.2 utf-8 encoder
/** @param {{fatal: boolean}} options */
'UTF-8': function (options) { return new UTF8Encoder(options); },
//
// 11. Legacy multi-byte Chinese (simplified) encodings
//
// 11.1 gbk
// 11.1.1 gbk decoder
// gbk's decoder is gb18030's decoder.
// 11.1.2 gbk encoder
// gbk's encoder is gb18030's encoder with its gbk flag set.
/** @param {{fatal: boolean}} options */
'GBK': function (options) { return new GB18030Encoder(options, true); },
// 11.2 gb18030
// 11.2.1 gb18030 decoder
// 11.2.2 gb18030 encoder
/** @param {{fatal: boolean}} options */
'gb18030': function (options) { return new GB18030Encoder(options); },
//
// 12. Legacy multi-byte Chinese (traditional) encodings
//
// 12.1 Big5
// 12.1.1 Big5 decoder
// 12.1.2 Big5 encoder
/** @param {{fatal: boolean}} options */
'Big5': function (options) { return new Big5Encoder(options); },
//
// 13. Legacy multi-byte Japanese encodings
//
// 13.1 euc-jp
// 13.1.1 euc-jp decoder
// 13.1.2 euc-jp encoder
/** @param {{fatal: boolean}} options */
'EUC-JP': function (options) { return new EUCJPEncoder(options); },
// 13.2 iso-2022-jp
// 13.2.1 iso-2022-jp decoder
// 13.2.2 iso-2022-jp encoder
/** @param {{fatal: boolean}} options */
'ISO-2022-JP': function (options) { return new ISO2022JPEncoder(options); },
// 13.3 Shift_JIS
// 13.3.1 Shift_JIS decoder
// 13.3.2 Shift_JIS encoder
/** @param {{fatal: boolean}} options */
'Shift_JIS': function (options) { return new ShiftJISEncoder(options); },
//
// 14. Legacy multi-byte Korean encodings
//
// 14.1 euc-kr
// 14.1.1 euc-kr decoder
// 14.1.2 euc-kr encoder
/** @param {{fatal: boolean}} options */
'EUC-KR': function (options) { return new EUCKREncoder(options); },
//
// 15. Legacy miscellaneous encodings
//
// 15.1 replacement
// Not needed - API throws RangeError
// 15.2 Common infrastructure for utf-16be and utf-16le
// 15.2.1 shared utf-16 decoder
// 15.2.2 shared utf-16 encoder
// 15.3 utf-16be
// 15.3.1 utf-16be decoder
/** @param {{fatal: boolean}} options */
'UTF-16BE': function (options) { return new UTF16Encoder(true, options); },
// 15.3.2 utf-16be encoder
// 15.4 utf-16le
// 15.4.1 utf-16le decoder
/** @param {{fatal: boolean}} options */
'UTF-16LE': function (options) { return new UTF16Encoder(false, options); },
// 15.4.2 utf-16le encoder
// 15.5 x-user-defined
// 15.5.1 x-user-defined decoder
// 15.5.2 x-user-defined encoder
/** @param {{fatal: boolean}} options */
'x-user-defined': function (options) { return new XUserDefinedEncoder(options); },
};
var decoders = {
/** @param {{fatal: boolean}} options */
'UTF-8': function (options) { return new UTF8Decoder(options); },
/** @param {{fatal: boolean}} options */
'GBK': function (options) { return new GB18030Decoder(options); },
/** @param {{fatal: boolean}} options */
'gb18030': function (options) { return new GB18030Decoder(options); },
/** @param {{fatal: boolean}} options */
'Big5': function (options) { return new Big5Decoder(options); },
/** @param {{fatal: boolean}} options */
'EUC-JP': function (options) { return new EUCJPDecoder(options); },
/** @param {{fatal: boolean}} options */
'ISO-2022-JP': function (options) { return new ISO2022JPDecoder(options); },
/** @param {{fatal: boolean}} options */
'Shift_JIS': function (options) { return new ShiftJISDecoder(options); },
/** @param {{fatal: boolean}} options */
'EUC-KR': function (options) { return new EUCKRDecoder(options); },
/** @param {{fatal: boolean}} options */
'UTF-16BE': function (options) { return new UTF16Decoder(true, options); },
/** @param {{fatal: boolean}} options */
'UTF-16LE': function (options) { return new UTF16Decoder(false, options); },
/** @param {{fatal: boolean}} options */
'x-user-defined': function (options) { return new XUserDefinedDecoder(options); },
};
if (encodingIndexes) {
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);
};
});
});
}
/**
* A stream represents an ordered sequence of tokens.
*/
var Stream = /** @class */ (function () {
/**
*
* @constructor
* @param {!(Array.<number>|Uint8Array)} tokens Array of tokens that provide
* the stream.
*/
function Stream(tokens) {
/** @type {!Array.<number>} */
this.tokens = Array.from(tokens);
// Reversed as push/pop is more efficient than shift/unshift.
this.tokens.reverse();
}
/**
* @return {boolean} True if end-of-stream has been hit.
*/
Stream.prototype.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.
*/
Stream.prototype.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.
*/
Stream.prototype.prepend = function (token) {
if (Array.isArray(token)) {
var tokens = (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.
*/
Stream.prototype.push = function (token) {
if (Array.isArray(token)) {
var tokens = (token);
while (tokens.length)
this.tokens.unshift(tokens.shift());
}
else {
this.tokens.unshift(token);
}
};
return Stream;
}());
/**
* @constructor
* @param {string=} label The label of the encoding;
* defaults to 'utf-8'.
* @param {Object=} options
*/
var TextDecoder = /** @class */ (function () {
function TextDecoder(label, options) {
label = label !== undefined ? String(label) : DEFAULT_ENCODING;
var optionsMap = 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.
// const dec = this;
// no need to do this as this is a proper class
// now and TSC will handle transpilation to older platforms
// 4. Set dec's encoding to encoding.
this._encoding = encoding;
// 5. If options's fatal member is true, set dec's error mode to
// fatal.
if (Boolean(optionsMap['fatal']))
this._error_mode = 'fatal';
// 6. If options's ignoreBOM member is true, set dec's ignore BOM
// flag.
if (Boolean(optionsMap['ignoreBOM']))
this._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;
}
Object.defineProperty(TextDecoder.prototype, "encoding", {
// 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(); }
// });
get: function () {
return this._encoding.name.toLowerCase();
},
enumerable: true,
configurable: true
});
Object.defineProperty(TextDecoder.prototype, "fatal", {
// 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'; }
// });
get: function () {
return this._error_mode === 'fatal';
},
enumerable: true,
configurable: true
});
Object.defineProperty(TextDecoder.prototype, "ignoreBOM", {
// 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; }
// });
get: function () {
return this._ignoreBOM;
},
enumerable: true,
configurable: true
});
// }
/**
* @param {BufferSource=} input The buffer of bytes to decode.
* @param {Object=} options
* @return {string} The decoded string.
*/
TextDecoder.prototype.decode = function (input, options) {
var bytes = getBytesFromInput(input);
var optionsMap = 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;
}
// 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(optionsMap['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)
continue;
if (Array.isArray(result))
output.push.apply(output, /**@type {!Array.<number>}*/ (result));
else
output.push(result);
} while (!input_stream.endOfStream());
this._decoder = null;
}
return this.serializeStream(output);
};
// A TextDecoder object also has an associated serialize stream
// algorithm...
/**
* @param {!Array.<number>} stream
* @return {string}
* @this {TextDecoder}
*/
TextDecoder.prototype.serializeStream = function (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;
}
}
// 4. Otherwise, return output.
return codePointsToString(stream);
};
return TextDecoder;
}());
function isBufferInstance(input) {
try {
return input instanceof ArrayBuffer;
}
catch (e) {
console.error(e);
return false;
}
}
function getBytesFromInput(input) {
if (typeof input !== 'object')
return new Uint8Array(0);
if (isBufferInstance(input)) {
return new Uint8Array(input);
}
if ('buffer' in input && isBufferInstance(input.buffer)) {
return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
}
return new Uint8Array(0);
}
/**
* @constructor
* @param {string=} label The label of the encoding. NONSTANDARD.
* @param {Object=} options NONSTANDARD.
*/
var TextEncoder = /** @class */ (function () {
function TextEncoder(label, options) {
var optionsMap = 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(optionsMap['fatal']) ? 'fatal' : 'replacement';
// 1. Let enc be a new TextEncoder object.
// const enc = this;
// no need to do this as this is a proper class
// now and TSC will handle transpilation to older platforms
// 2. Set enc's encoding to UTF-8's encoder.
if (Boolean(optionsMap['NONSTANDARD_allowLegacyEncoding'])) {
// NONSTANDARD behavior.
label = !!label ? 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?');
}
this._encoding = encoding;
// EXPERIMENTAL_CODE
// } else if (["iso-8859-1", "ISO-8859-1", "latin-1", "latin1", "LATIN-1", "LATIN1"].indexOf(label) !== -1) {
// this._encoding = getEncoding('iso-8859-1');
}
else {
// Standard behavior.
this._encoding = getEncoding('utf-8');
var glo = getGlobalScope() || {};
if (label !== undefined && 'console' in glo) {
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;
}
Object.defineProperty(TextEncoder.prototype, "encoding", {
// 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(); }
// });
// }
get: function () {
return this._encoding.name.toLowerCase();
},
enumerable: true,
configurable: true
});
/**
* @param {string=} opt_string The string to encode.
* @param {Object=} options
* @return {!Uint8Array} Encoded bytes, as a Uint8Array.
*/
TextEncoder.prototype.encode = function (opt_string, options) {
opt_string = opt_string === undefined ? '' : String(opt_string);
var optionsMap = 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(optionsMap['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:
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;
}
// 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);
};
return TextEncoder;
}());
// Polyfills browser
if (typeof window !== 'undefined') {
var checkUndefined = function (key) { return !(key in window)
|| typeof window[key] === 'undefined'
|| window[key] === null; };
if (checkUndefined('TextDecoder'))
window['TextDecoder'] = TextDecoder;
if (checkUndefined('TextEncoder'))
window['TextEncoder'] = TextEncoder;
}
exports.TextDecoder = TextDecoder;
exports.TextEncoder = TextEncoder;
Object.defineProperty(exports, '__esModule', { value: true });
})));
//# sourceMappingURL=encoding.js.map
Reference in New Issue View Git Blame Copy Permalink