2017-06-12 15:25:53 +00:00
|
|
|
'use strict';
|
|
|
|
|
|
|
|
// An implementation of the WHATWG Encoding Standard
|
|
|
|
// https://encoding.spec.whatwg.org
|
|
|
|
|
2019-11-22 17:04:46 +00:00
|
|
|
const {
|
2022-11-12 21:31:44 +00:00
|
|
|
Boolean,
|
2019-11-22 17:04:46 +00:00
|
|
|
ObjectDefineProperties,
|
|
|
|
ObjectGetOwnPropertyDescriptors,
|
2022-06-03 08:23:58 +00:00
|
|
|
ObjectSetPrototypeOf,
|
|
|
|
ObjectValues,
|
2020-12-11 14:34:02 +00:00
|
|
|
SafeMap,
|
|
|
|
StringPrototypeSlice,
|
2019-11-30 15:55:29 +00:00
|
|
|
Symbol,
|
2019-12-11 20:08:38 +00:00
|
|
|
SymbolToStringTag,
|
2020-09-28 14:56:54 +00:00
|
|
|
Uint8Array,
|
2019-11-22 17:04:46 +00:00
|
|
|
} = primordials;
|
2019-04-09 07:55:53 +00:00
|
|
|
|
2018-03-04 21:16:24 +00:00
|
|
|
const {
|
|
|
|
ERR_ENCODING_NOT_SUPPORTED,
|
|
|
|
ERR_INVALID_ARG_TYPE,
|
|
|
|
ERR_INVALID_THIS,
|
2023-02-26 10:34:02 +00:00
|
|
|
ERR_NO_ICU,
|
2018-03-04 21:16:24 +00:00
|
|
|
} = require('internal/errors').codes;
|
2017-06-12 15:25:53 +00:00
|
|
|
const kHandle = Symbol('handle');
|
|
|
|
const kFlags = Symbol('flags');
|
|
|
|
const kEncoding = Symbol('encoding');
|
|
|
|
const kDecoder = Symbol('decoder');
|
|
|
|
const kEncoder = Symbol('encoder');
|
2022-12-15 23:11:07 +00:00
|
|
|
const kFatal = Symbol('kFatal');
|
2022-11-12 21:31:44 +00:00
|
|
|
const kUTF8FastPath = Symbol('kUTF8FastPath');
|
|
|
|
const kIgnoreBOM = Symbol('kIgnoreBOM');
|
2017-06-12 15:25:53 +00:00
|
|
|
|
|
|
|
const {
|
|
|
|
getConstructorOf,
|
2022-02-11 17:30:47 +00:00
|
|
|
customInspectSymbol: inspect,
|
2022-05-21 09:59:38 +00:00
|
|
|
kEmptyObject,
|
2022-02-11 17:30:47 +00:00
|
|
|
kEnumerableProperty,
|
2017-06-12 15:25:53 +00:00
|
|
|
} = require('internal/util');
|
|
|
|
|
|
|
|
const {
|
2020-03-11 16:01:14 +00:00
|
|
|
isAnyArrayBuffer,
|
2019-09-10 23:13:01 +00:00
|
|
|
isArrayBufferView,
|
2023-02-26 10:34:02 +00:00
|
|
|
isUint8Array,
|
2018-12-20 16:35:40 +00:00
|
|
|
} = require('internal/util/types');
|
2017-06-12 15:25:53 +00:00
|
|
|
|
2021-07-31 10:50:19 +00:00
|
|
|
const {
|
|
|
|
validateString,
|
|
|
|
validateObject,
|
2024-01-04 11:37:44 +00:00
|
|
|
kValidateObjectAllowObjectsAndNull,
|
2021-07-31 10:50:19 +00:00
|
|
|
} = require('internal/validators');
|
2023-02-11 18:25:00 +00:00
|
|
|
const binding = internalBinding('encoding_binding');
|
2017-06-12 15:25:53 +00:00
|
|
|
const {
|
2019-09-10 23:13:01 +00:00
|
|
|
encodeInto,
|
2023-04-20 03:28:35 +00:00
|
|
|
encodeIntoResults,
|
2022-11-12 21:31:44 +00:00
|
|
|
encodeUtf8String,
|
|
|
|
decodeUTF8,
|
2023-02-11 18:25:00 +00:00
|
|
|
} = binding;
|
2017-06-12 15:25:53 +00:00
|
|
|
|
2022-12-12 15:17:53 +00:00
|
|
|
const { Buffer } = require('buffer');
|
2017-06-12 15:25:53 +00:00
|
|
|
|
2018-01-28 18:25:56 +00:00
|
|
|
function validateEncoder(obj) {
|
|
|
|
if (obj == null || obj[kEncoder] !== true)
|
2018-03-04 21:16:24 +00:00
|
|
|
throw new ERR_INVALID_THIS('TextEncoder');
|
2018-01-28 18:25:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function validateDecoder(obj) {
|
|
|
|
if (obj == null || obj[kDecoder] !== true)
|
2018-03-04 21:16:24 +00:00
|
|
|
throw new ERR_INVALID_THIS('TextDecoder');
|
2018-01-28 18:25:56 +00:00
|
|
|
}
|
|
|
|
|
2017-06-12 15:25:53 +00:00
|
|
|
const CONVERTER_FLAGS_FLUSH = 0x1;
|
|
|
|
const CONVERTER_FLAGS_FATAL = 0x2;
|
|
|
|
const CONVERTER_FLAGS_IGNORE_BOM = 0x4;
|
|
|
|
|
|
|
|
const empty = new Uint8Array(0);
|
|
|
|
|
2020-12-11 14:34:02 +00:00
|
|
|
const encodings = new SafeMap([
|
2017-06-12 15:25:53 +00:00
|
|
|
['unicode-1-1-utf-8', 'utf-8'],
|
2023-09-23 12:20:39 +00:00
|
|
|
['unicode11utf8', 'utf-8'],
|
|
|
|
['unicode20utf8', 'utf-8'],
|
2017-06-12 15:25:53 +00:00
|
|
|
['utf8', 'utf-8'],
|
|
|
|
['utf-8', 'utf-8'],
|
2023-09-23 12:20:39 +00:00
|
|
|
['x-unicode20utf8', 'utf-8'],
|
2017-06-12 15:25:53 +00:00
|
|
|
['866', 'ibm866'],
|
|
|
|
['cp866', 'ibm866'],
|
|
|
|
['csibm866', 'ibm866'],
|
|
|
|
['ibm866', 'ibm866'],
|
|
|
|
['csisolatin2', 'iso-8859-2'],
|
|
|
|
['iso-8859-2', 'iso-8859-2'],
|
|
|
|
['iso-ir-101', 'iso-8859-2'],
|
|
|
|
['iso8859-2', 'iso-8859-2'],
|
|
|
|
['iso88592', 'iso-8859-2'],
|
|
|
|
['iso_8859-2', 'iso-8859-2'],
|
|
|
|
['iso_8859-2:1987', 'iso-8859-2'],
|
|
|
|
['l2', 'iso-8859-2'],
|
|
|
|
['latin2', 'iso-8859-2'],
|
|
|
|
['csisolatin3', 'iso-8859-3'],
|
|
|
|
['iso-8859-3', 'iso-8859-3'],
|
|
|
|
['iso-ir-109', 'iso-8859-3'],
|
|
|
|
['iso8859-3', 'iso-8859-3'],
|
|
|
|
['iso88593', 'iso-8859-3'],
|
|
|
|
['iso_8859-3', 'iso-8859-3'],
|
|
|
|
['iso_8859-3:1988', 'iso-8859-3'],
|
|
|
|
['l3', 'iso-8859-3'],
|
|
|
|
['latin3', 'iso-8859-3'],
|
|
|
|
['csisolatin4', 'iso-8859-4'],
|
|
|
|
['iso-8859-4', 'iso-8859-4'],
|
|
|
|
['iso-ir-110', 'iso-8859-4'],
|
|
|
|
['iso8859-4', 'iso-8859-4'],
|
|
|
|
['iso88594', 'iso-8859-4'],
|
|
|
|
['iso_8859-4', 'iso-8859-4'],
|
|
|
|
['iso_8859-4:1988', 'iso-8859-4'],
|
|
|
|
['l4', 'iso-8859-4'],
|
|
|
|
['latin4', 'iso-8859-4'],
|
|
|
|
['csisolatincyrillic', 'iso-8859-5'],
|
|
|
|
['cyrillic', 'iso-8859-5'],
|
|
|
|
['iso-8859-5', 'iso-8859-5'],
|
|
|
|
['iso-ir-144', 'iso-8859-5'],
|
|
|
|
['iso8859-5', 'iso-8859-5'],
|
|
|
|
['iso88595', 'iso-8859-5'],
|
|
|
|
['iso_8859-5', 'iso-8859-5'],
|
|
|
|
['iso_8859-5:1988', 'iso-8859-5'],
|
|
|
|
['arabic', 'iso-8859-6'],
|
|
|
|
['asmo-708', 'iso-8859-6'],
|
|
|
|
['csiso88596e', 'iso-8859-6'],
|
|
|
|
['csiso88596i', 'iso-8859-6'],
|
|
|
|
['csisolatinarabic', 'iso-8859-6'],
|
|
|
|
['ecma-114', 'iso-8859-6'],
|
|
|
|
['iso-8859-6', 'iso-8859-6'],
|
|
|
|
['iso-8859-6-e', 'iso-8859-6'],
|
|
|
|
['iso-8859-6-i', 'iso-8859-6'],
|
|
|
|
['iso-ir-127', 'iso-8859-6'],
|
|
|
|
['iso8859-6', 'iso-8859-6'],
|
|
|
|
['iso88596', 'iso-8859-6'],
|
|
|
|
['iso_8859-6', 'iso-8859-6'],
|
|
|
|
['iso_8859-6:1987', 'iso-8859-6'],
|
|
|
|
['csisolatingreek', 'iso-8859-7'],
|
|
|
|
['ecma-118', 'iso-8859-7'],
|
|
|
|
['elot_928', 'iso-8859-7'],
|
|
|
|
['greek', 'iso-8859-7'],
|
|
|
|
['greek8', 'iso-8859-7'],
|
|
|
|
['iso-8859-7', 'iso-8859-7'],
|
|
|
|
['iso-ir-126', 'iso-8859-7'],
|
|
|
|
['iso8859-7', 'iso-8859-7'],
|
|
|
|
['iso88597', 'iso-8859-7'],
|
|
|
|
['iso_8859-7', 'iso-8859-7'],
|
|
|
|
['iso_8859-7:1987', 'iso-8859-7'],
|
|
|
|
['sun_eu_greek', 'iso-8859-7'],
|
|
|
|
['csiso88598e', 'iso-8859-8'],
|
|
|
|
['csisolatinhebrew', 'iso-8859-8'],
|
|
|
|
['hebrew', 'iso-8859-8'],
|
|
|
|
['iso-8859-8', 'iso-8859-8'],
|
|
|
|
['iso-8859-8-e', 'iso-8859-8'],
|
|
|
|
['iso-ir-138', 'iso-8859-8'],
|
|
|
|
['iso8859-8', 'iso-8859-8'],
|
|
|
|
['iso88598', 'iso-8859-8'],
|
|
|
|
['iso_8859-8', 'iso-8859-8'],
|
|
|
|
['iso_8859-8:1988', 'iso-8859-8'],
|
|
|
|
['visual', 'iso-8859-8'],
|
|
|
|
['csiso88598i', 'iso-8859-8-i'],
|
|
|
|
['iso-8859-8-i', 'iso-8859-8-i'],
|
|
|
|
['logical', 'iso-8859-8-i'],
|
|
|
|
['csisolatin6', 'iso-8859-10'],
|
|
|
|
['iso-8859-10', 'iso-8859-10'],
|
|
|
|
['iso-ir-157', 'iso-8859-10'],
|
|
|
|
['iso8859-10', 'iso-8859-10'],
|
|
|
|
['iso885910', 'iso-8859-10'],
|
|
|
|
['l6', 'iso-8859-10'],
|
|
|
|
['latin6', 'iso-8859-10'],
|
|
|
|
['iso-8859-13', 'iso-8859-13'],
|
|
|
|
['iso8859-13', 'iso-8859-13'],
|
|
|
|
['iso885913', 'iso-8859-13'],
|
|
|
|
['iso-8859-14', 'iso-8859-14'],
|
|
|
|
['iso8859-14', 'iso-8859-14'],
|
|
|
|
['iso885914', 'iso-8859-14'],
|
|
|
|
['csisolatin9', 'iso-8859-15'],
|
|
|
|
['iso-8859-15', 'iso-8859-15'],
|
|
|
|
['iso8859-15', 'iso-8859-15'],
|
|
|
|
['iso885915', 'iso-8859-15'],
|
|
|
|
['iso_8859-15', 'iso-8859-15'],
|
|
|
|
['l9', 'iso-8859-15'],
|
2023-09-23 12:20:39 +00:00
|
|
|
['iso-8859-16', 'iso-8859-16'],
|
2017-06-12 15:25:53 +00:00
|
|
|
['cskoi8r', 'koi8-r'],
|
|
|
|
['koi', 'koi8-r'],
|
|
|
|
['koi8', 'koi8-r'],
|
|
|
|
['koi8-r', 'koi8-r'],
|
|
|
|
['koi8_r', 'koi8-r'],
|
|
|
|
['koi8-ru', 'koi8-u'],
|
|
|
|
['koi8-u', 'koi8-u'],
|
|
|
|
['csmacintosh', 'macintosh'],
|
|
|
|
['mac', 'macintosh'],
|
|
|
|
['macintosh', 'macintosh'],
|
|
|
|
['x-mac-roman', 'macintosh'],
|
|
|
|
['dos-874', 'windows-874'],
|
|
|
|
['iso-8859-11', 'windows-874'],
|
|
|
|
['iso8859-11', 'windows-874'],
|
|
|
|
['iso885911', 'windows-874'],
|
|
|
|
['tis-620', 'windows-874'],
|
|
|
|
['windows-874', 'windows-874'],
|
|
|
|
['cp1250', 'windows-1250'],
|
|
|
|
['windows-1250', 'windows-1250'],
|
|
|
|
['x-cp1250', 'windows-1250'],
|
|
|
|
['cp1251', 'windows-1251'],
|
|
|
|
['windows-1251', 'windows-1251'],
|
|
|
|
['x-cp1251', 'windows-1251'],
|
|
|
|
['ansi_x3.4-1968', 'windows-1252'],
|
|
|
|
['ascii', 'windows-1252'],
|
|
|
|
['cp1252', 'windows-1252'],
|
|
|
|
['cp819', 'windows-1252'],
|
|
|
|
['csisolatin1', 'windows-1252'],
|
|
|
|
['ibm819', 'windows-1252'],
|
|
|
|
['iso-8859-1', 'windows-1252'],
|
|
|
|
['iso-ir-100', 'windows-1252'],
|
|
|
|
['iso8859-1', 'windows-1252'],
|
|
|
|
['iso88591', 'windows-1252'],
|
|
|
|
['iso_8859-1', 'windows-1252'],
|
|
|
|
['iso_8859-1:1987', 'windows-1252'],
|
|
|
|
['l1', 'windows-1252'],
|
|
|
|
['latin1', 'windows-1252'],
|
|
|
|
['us-ascii', 'windows-1252'],
|
|
|
|
['windows-1252', 'windows-1252'],
|
|
|
|
['x-cp1252', 'windows-1252'],
|
|
|
|
['cp1253', 'windows-1253'],
|
|
|
|
['windows-1253', 'windows-1253'],
|
|
|
|
['x-cp1253', 'windows-1253'],
|
|
|
|
['cp1254', 'windows-1254'],
|
|
|
|
['csisolatin5', 'windows-1254'],
|
|
|
|
['iso-8859-9', 'windows-1254'],
|
|
|
|
['iso-ir-148', 'windows-1254'],
|
|
|
|
['iso8859-9', 'windows-1254'],
|
|
|
|
['iso88599', 'windows-1254'],
|
|
|
|
['iso_8859-9', 'windows-1254'],
|
|
|
|
['iso_8859-9:1989', 'windows-1254'],
|
|
|
|
['l5', 'windows-1254'],
|
|
|
|
['latin5', 'windows-1254'],
|
|
|
|
['windows-1254', 'windows-1254'],
|
|
|
|
['x-cp1254', 'windows-1254'],
|
|
|
|
['cp1255', 'windows-1255'],
|
|
|
|
['windows-1255', 'windows-1255'],
|
|
|
|
['x-cp1255', 'windows-1255'],
|
|
|
|
['cp1256', 'windows-1256'],
|
|
|
|
['windows-1256', 'windows-1256'],
|
|
|
|
['x-cp1256', 'windows-1256'],
|
|
|
|
['cp1257', 'windows-1257'],
|
|
|
|
['windows-1257', 'windows-1257'],
|
|
|
|
['x-cp1257', 'windows-1257'],
|
|
|
|
['cp1258', 'windows-1258'],
|
|
|
|
['windows-1258', 'windows-1258'],
|
|
|
|
['x-cp1258', 'windows-1258'],
|
|
|
|
['x-mac-cyrillic', 'x-mac-cyrillic'],
|
|
|
|
['x-mac-ukrainian', 'x-mac-cyrillic'],
|
|
|
|
['chinese', 'gbk'],
|
|
|
|
['csgb2312', 'gbk'],
|
|
|
|
['csiso58gb231280', 'gbk'],
|
|
|
|
['gb2312', 'gbk'],
|
|
|
|
['gb_2312', 'gbk'],
|
|
|
|
['gb_2312-80', 'gbk'],
|
|
|
|
['gbk', 'gbk'],
|
|
|
|
['iso-ir-58', 'gbk'],
|
|
|
|
['x-gbk', 'gbk'],
|
|
|
|
['gb18030', 'gb18030'],
|
|
|
|
['big5', 'big5'],
|
|
|
|
['big5-hkscs', 'big5'],
|
|
|
|
['cn-big5', 'big5'],
|
|
|
|
['csbig5', 'big5'],
|
|
|
|
['x-x-big5', 'big5'],
|
|
|
|
['cseucpkdfmtjapanese', 'euc-jp'],
|
|
|
|
['euc-jp', 'euc-jp'],
|
|
|
|
['x-euc-jp', 'euc-jp'],
|
|
|
|
['csiso2022jp', 'iso-2022-jp'],
|
|
|
|
['iso-2022-jp', 'iso-2022-jp'],
|
|
|
|
['csshiftjis', 'shift_jis'],
|
|
|
|
['ms932', 'shift_jis'],
|
|
|
|
['ms_kanji', 'shift_jis'],
|
|
|
|
['shift-jis', 'shift_jis'],
|
|
|
|
['shift_jis', 'shift_jis'],
|
|
|
|
['sjis', 'shift_jis'],
|
|
|
|
['windows-31j', 'shift_jis'],
|
|
|
|
['x-sjis', 'shift_jis'],
|
|
|
|
['cseuckr', 'euc-kr'],
|
|
|
|
['csksc56011987', 'euc-kr'],
|
|
|
|
['euc-kr', 'euc-kr'],
|
|
|
|
['iso-ir-149', 'euc-kr'],
|
|
|
|
['korean', 'euc-kr'],
|
|
|
|
['ks_c_5601-1987', 'euc-kr'],
|
|
|
|
['ks_c_5601-1989', 'euc-kr'],
|
|
|
|
['ksc5601', 'euc-kr'],
|
|
|
|
['ksc_5601', 'euc-kr'],
|
|
|
|
['windows-949', 'euc-kr'],
|
2023-09-23 12:20:39 +00:00
|
|
|
['csiso2022kr', 'replacement'],
|
|
|
|
['hz-gb-2312', 'replacement'],
|
|
|
|
['iso-2022-cn', 'replacement'],
|
|
|
|
['iso-2022-cn-ext', 'replacement'],
|
|
|
|
['iso-2022-kr', 'replacement'],
|
|
|
|
['replacement', 'replacement'],
|
|
|
|
['unicodefffe', 'utf-16be'],
|
2017-06-12 15:25:53 +00:00
|
|
|
['utf-16be', 'utf-16be'],
|
2023-09-23 12:20:39 +00:00
|
|
|
['csunicode', 'utf-16le'],
|
|
|
|
['iso-10646-ucs-2', 'utf-16le'],
|
|
|
|
['ucs-2', 'utf-16le'],
|
|
|
|
['unicode', 'utf-16le'],
|
|
|
|
['unicodefeff', 'utf-16le'],
|
2017-06-12 15:25:53 +00:00
|
|
|
['utf-16le', 'utf-16le'],
|
2021-02-06 13:36:58 +00:00
|
|
|
['utf-16', 'utf-16le'],
|
2023-09-23 12:20:39 +00:00
|
|
|
['x-user-defined', 'x-user-defined'],
|
2017-06-12 15:25:53 +00:00
|
|
|
]);
|
|
|
|
|
|
|
|
// Unfortunately, String.prototype.trim also removes non-ascii whitespace,
|
|
|
|
// so we have to do this manually
|
|
|
|
function trimAsciiWhitespace(label) {
|
2019-11-12 15:08:20 +00:00
|
|
|
let s = 0;
|
|
|
|
let e = label.length;
|
2017-06-12 15:25:53 +00:00
|
|
|
while (s < e && (
|
|
|
|
label[s] === '\u0009' ||
|
|
|
|
label[s] === '\u000a' ||
|
|
|
|
label[s] === '\u000c' ||
|
|
|
|
label[s] === '\u000d' ||
|
|
|
|
label[s] === '\u0020')) {
|
|
|
|
s++;
|
|
|
|
}
|
|
|
|
while (e > s && (
|
|
|
|
label[e - 1] === '\u0009' ||
|
|
|
|
label[e - 1] === '\u000a' ||
|
|
|
|
label[e - 1] === '\u000c' ||
|
|
|
|
label[e - 1] === '\u000d' ||
|
|
|
|
label[e - 1] === '\u0020')) {
|
|
|
|
e--;
|
|
|
|
}
|
2020-12-11 14:34:02 +00:00
|
|
|
return StringPrototypeSlice(label, s, e);
|
2017-06-12 15:25:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function getEncodingFromLabel(label) {
|
|
|
|
const enc = encodings.get(label);
|
|
|
|
if (enc !== undefined) return enc;
|
|
|
|
return encodings.get(trimAsciiWhitespace(label.toLowerCase()));
|
|
|
|
}
|
|
|
|
|
|
|
|
class TextEncoder {
|
|
|
|
constructor() {
|
2017-07-30 10:09:13 +00:00
|
|
|
this[kEncoder] = true;
|
2017-06-12 15:25:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
get encoding() {
|
2018-01-28 18:25:56 +00:00
|
|
|
validateEncoder(this);
|
2017-06-12 15:25:53 +00:00
|
|
|
return 'utf-8';
|
|
|
|
}
|
|
|
|
|
|
|
|
encode(input = '') {
|
2018-01-28 18:25:56 +00:00
|
|
|
validateEncoder(this);
|
2017-06-12 15:25:53 +00:00
|
|
|
return encodeUtf8String(`${input}`);
|
|
|
|
}
|
|
|
|
|
2019-09-10 23:13:01 +00:00
|
|
|
encodeInto(src, dest) {
|
|
|
|
validateEncoder(this);
|
|
|
|
validateString(src, 'src');
|
|
|
|
if (!dest || !isUint8Array(dest))
|
|
|
|
throw new ERR_INVALID_ARG_TYPE('dest', 'Uint8Array', dest);
|
2023-02-11 18:25:00 +00:00
|
|
|
|
|
|
|
encodeInto(src, dest);
|
|
|
|
// We need to read from the binding here since the buffer gets refreshed
|
|
|
|
// from the snapshot.
|
2023-04-20 03:28:35 +00:00
|
|
|
const { 0: read, 1: written } = encodeIntoResults;
|
2023-02-11 18:25:00 +00:00
|
|
|
return { read, written };
|
2019-09-10 23:13:01 +00:00
|
|
|
}
|
|
|
|
|
2017-06-12 15:25:53 +00:00
|
|
|
[inspect](depth, opts) {
|
2018-01-28 18:25:56 +00:00
|
|
|
validateEncoder(this);
|
2017-06-12 15:25:53 +00:00
|
|
|
if (typeof depth === 'number' && depth < 0)
|
2018-12-11 21:42:34 +00:00
|
|
|
return this;
|
2019-03-26 04:21:27 +00:00
|
|
|
const ctor = getConstructorOf(this);
|
2023-01-10 05:38:36 +00:00
|
|
|
const obj = { __proto__: {
|
2023-02-26 10:34:02 +00:00
|
|
|
constructor: ctor === null ? TextEncoder : ctor,
|
2023-01-10 05:38:36 +00:00
|
|
|
} };
|
2017-06-12 15:25:53 +00:00
|
|
|
obj.encoding = this.encoding;
|
|
|
|
// Lazy to avoid circular dependency
|
2019-03-19 14:04:38 +00:00
|
|
|
return require('internal/util/inspect').inspect(obj, opts);
|
2017-06-12 15:25:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-22 17:04:46 +00:00
|
|
|
ObjectDefineProperties(
|
2017-06-12 15:25:53 +00:00
|
|
|
TextEncoder.prototype, {
|
2022-02-11 17:30:47 +00:00
|
|
|
'encode': kEnumerableProperty,
|
|
|
|
'encodeInto': kEnumerableProperty,
|
|
|
|
'encoding': kEnumerableProperty,
|
2022-06-03 08:23:58 +00:00
|
|
|
[SymbolToStringTag]: { __proto__: null, configurable: true, value: 'TextEncoder' },
|
2021-01-23 19:46:29 +00:00
|
|
|
});
|
2017-06-12 15:25:53 +00:00
|
|
|
|
2018-10-12 18:32:55 +00:00
|
|
|
const TextDecoder =
|
2018-10-08 23:10:07 +00:00
|
|
|
internalBinding('config').hasIntl ?
|
2017-07-30 10:09:13 +00:00
|
|
|
makeTextDecoderICU() :
|
|
|
|
makeTextDecoderJS();
|
|
|
|
|
|
|
|
function makeTextDecoderICU() {
|
|
|
|
const {
|
|
|
|
decode: _decode,
|
|
|
|
getConverter,
|
2018-10-03 02:30:07 +00:00
|
|
|
} = internalBinding('icu');
|
2017-07-30 10:09:13 +00:00
|
|
|
|
|
|
|
class TextDecoder {
|
2022-05-21 09:59:38 +00:00
|
|
|
constructor(encoding = 'utf-8', options = kEmptyObject) {
|
2017-07-30 10:09:13 +00:00
|
|
|
encoding = `${encoding}`;
|
2023-10-02 12:56:39 +00:00
|
|
|
validateObject(options, 'options', kValidateObjectAllowObjectsAndNull);
|
2017-07-30 10:09:13 +00:00
|
|
|
|
|
|
|
const enc = getEncodingFromLabel(encoding);
|
|
|
|
if (enc === undefined)
|
2018-03-04 21:16:24 +00:00
|
|
|
throw new ERR_ENCODING_NOT_SUPPORTED(encoding);
|
2017-07-30 10:09:13 +00:00
|
|
|
|
2019-11-12 15:08:20 +00:00
|
|
|
let flags = 0;
|
2017-07-30 10:09:13 +00:00
|
|
|
if (options !== null) {
|
|
|
|
flags |= options.fatal ? CONVERTER_FLAGS_FATAL : 0;
|
|
|
|
flags |= options.ignoreBOM ? CONVERTER_FLAGS_IGNORE_BOM : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
this[kDecoder] = true;
|
|
|
|
this[kFlags] = flags;
|
|
|
|
this[kEncoding] = enc;
|
2022-11-12 21:31:44 +00:00
|
|
|
this[kIgnoreBOM] = Boolean(options?.ignoreBOM);
|
2022-12-15 23:11:07 +00:00
|
|
|
this[kFatal] = Boolean(options?.fatal);
|
|
|
|
// Only support fast path for UTF-8.
|
|
|
|
this[kUTF8FastPath] = enc === 'utf-8';
|
2022-11-12 21:31:44 +00:00
|
|
|
this[kHandle] = undefined;
|
|
|
|
|
2022-12-15 23:11:07 +00:00
|
|
|
if (!this[kUTF8FastPath]) {
|
2022-11-12 21:31:44 +00:00
|
|
|
this.#prepareConverter();
|
|
|
|
}
|
2017-07-30 10:09:13 +00:00
|
|
|
}
|
|
|
|
|
2022-11-12 21:31:44 +00:00
|
|
|
#prepareConverter() {
|
|
|
|
if (this[kHandle] !== undefined) return;
|
|
|
|
const handle = getConverter(this[kEncoding], this[kFlags]);
|
|
|
|
if (handle === undefined)
|
|
|
|
throw new ERR_ENCODING_NOT_SUPPORTED(this[kEncoding]);
|
|
|
|
this[kHandle] = handle;
|
|
|
|
}
|
2017-07-30 10:09:13 +00:00
|
|
|
|
2022-05-21 09:59:38 +00:00
|
|
|
decode(input = empty, options = kEmptyObject) {
|
2018-01-28 18:25:56 +00:00
|
|
|
validateDecoder(this);
|
2022-11-12 21:31:44 +00:00
|
|
|
|
|
|
|
this[kUTF8FastPath] &&= !(options?.stream);
|
|
|
|
|
|
|
|
if (this[kUTF8FastPath]) {
|
2022-12-15 23:11:07 +00:00
|
|
|
return decodeUTF8(input, this[kIgnoreBOM], this[kFatal]);
|
2022-11-12 21:31:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
this.#prepareConverter();
|
|
|
|
|
2023-10-02 12:56:39 +00:00
|
|
|
validateObject(options, 'options', kValidateObjectAllowObjectsAndNull);
|
2017-07-30 10:09:13 +00:00
|
|
|
|
2019-11-12 15:08:20 +00:00
|
|
|
let flags = 0;
|
2017-07-30 10:09:13 +00:00
|
|
|
if (options !== null)
|
|
|
|
flags |= options.stream ? 0 : CONVERTER_FLAGS_FLUSH;
|
|
|
|
|
2022-11-09 14:18:42 +00:00
|
|
|
return _decode(this[kHandle], input, flags, this.encoding);
|
2017-07-30 10:09:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-12 18:32:55 +00:00
|
|
|
return TextDecoder;
|
2017-07-30 10:09:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function makeTextDecoderJS() {
|
2019-11-12 15:08:20 +00:00
|
|
|
let StringDecoder;
|
2017-07-30 10:09:13 +00:00
|
|
|
function lazyStringDecoder() {
|
|
|
|
if (StringDecoder === undefined)
|
|
|
|
({ StringDecoder } = require('string_decoder'));
|
|
|
|
return StringDecoder;
|
|
|
|
}
|
|
|
|
|
|
|
|
const kBOMSeen = Symbol('BOM seen');
|
|
|
|
|
|
|
|
function hasConverter(encoding) {
|
|
|
|
return encoding === 'utf-8' || encoding === 'utf-16le';
|
|
|
|
}
|
|
|
|
|
|
|
|
class TextDecoder {
|
2022-05-21 09:59:38 +00:00
|
|
|
constructor(encoding = 'utf-8', options = kEmptyObject) {
|
2017-07-30 10:09:13 +00:00
|
|
|
encoding = `${encoding}`;
|
2023-10-02 12:56:39 +00:00
|
|
|
validateObject(options, 'options', kValidateObjectAllowObjectsAndNull);
|
2017-07-30 10:09:13 +00:00
|
|
|
|
|
|
|
const enc = getEncodingFromLabel(encoding);
|
|
|
|
if (enc === undefined || !hasConverter(enc))
|
2018-03-04 21:16:24 +00:00
|
|
|
throw new ERR_ENCODING_NOT_SUPPORTED(encoding);
|
2017-07-30 10:09:13 +00:00
|
|
|
|
2019-11-12 15:08:20 +00:00
|
|
|
let flags = 0;
|
2017-07-30 10:09:13 +00:00
|
|
|
if (options !== null) {
|
|
|
|
if (options.fatal) {
|
2018-03-04 21:16:24 +00:00
|
|
|
throw new ERR_NO_ICU('"fatal" option');
|
2017-07-30 10:09:13 +00:00
|
|
|
}
|
|
|
|
flags |= options.ignoreBOM ? CONVERTER_FLAGS_IGNORE_BOM : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
this[kDecoder] = true;
|
|
|
|
// StringDecoder will normalize WHATWG encoding to Node.js encoding.
|
|
|
|
this[kHandle] = new (lazyStringDecoder())(enc);
|
|
|
|
this[kFlags] = flags;
|
|
|
|
this[kEncoding] = enc;
|
|
|
|
this[kBOMSeen] = false;
|
|
|
|
}
|
|
|
|
|
2022-05-21 09:59:38 +00:00
|
|
|
decode(input = empty, options = kEmptyObject) {
|
2018-01-28 18:25:56 +00:00
|
|
|
validateDecoder(this);
|
2020-03-11 16:01:14 +00:00
|
|
|
if (isAnyArrayBuffer(input)) {
|
2022-11-01 23:59:26 +00:00
|
|
|
try {
|
2022-12-12 15:17:53 +00:00
|
|
|
input = Buffer.from(input);
|
2022-11-01 23:59:26 +00:00
|
|
|
} catch {
|
|
|
|
input = empty;
|
|
|
|
}
|
2017-09-28 07:16:41 +00:00
|
|
|
} else if (isArrayBufferView(input)) {
|
2022-11-01 23:59:26 +00:00
|
|
|
try {
|
2022-12-12 15:17:53 +00:00
|
|
|
input = Buffer.from(input.buffer, input.byteOffset,
|
|
|
|
input.byteLength);
|
2022-11-01 23:59:26 +00:00
|
|
|
} catch {
|
|
|
|
input = empty;
|
|
|
|
}
|
2017-07-30 10:09:13 +00:00
|
|
|
} else {
|
2018-03-04 21:16:24 +00:00
|
|
|
throw new ERR_INVALID_ARG_TYPE('input',
|
2018-03-19 12:33:46 +00:00
|
|
|
['ArrayBuffer', 'ArrayBufferView'],
|
|
|
|
input);
|
2017-07-30 10:09:13 +00:00
|
|
|
}
|
2023-10-02 12:56:39 +00:00
|
|
|
validateObject(options, 'options', kValidateObjectAllowObjectsAndNull);
|
2017-07-30 10:09:13 +00:00
|
|
|
|
|
|
|
if (this[kFlags] & CONVERTER_FLAGS_FLUSH) {
|
|
|
|
this[kBOMSeen] = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (options !== null && options.stream) {
|
|
|
|
this[kFlags] &= ~CONVERTER_FLAGS_FLUSH;
|
|
|
|
} else {
|
|
|
|
this[kFlags] |= CONVERTER_FLAGS_FLUSH;
|
|
|
|
}
|
|
|
|
|
2019-10-26 14:27:51 +00:00
|
|
|
let result = this[kFlags] & CONVERTER_FLAGS_FLUSH ?
|
|
|
|
this[kHandle].end(input) :
|
|
|
|
this[kHandle].write(input);
|
|
|
|
|
|
|
|
if (result.length > 0 &&
|
|
|
|
!this[kBOMSeen] &&
|
|
|
|
!(this[kFlags] & CONVERTER_FLAGS_IGNORE_BOM)) {
|
|
|
|
// If the very first result in the stream is a BOM, and we are not
|
|
|
|
// explicitly told to ignore it, then we discard it.
|
|
|
|
if (result[0] === '\ufeff') {
|
2020-12-11 14:34:02 +00:00
|
|
|
result = StringPrototypeSlice(result, 1);
|
2017-07-30 10:09:13 +00:00
|
|
|
}
|
|
|
|
this[kBOMSeen] = true;
|
|
|
|
}
|
|
|
|
|
2019-10-26 14:27:51 +00:00
|
|
|
return result;
|
2017-07-30 10:09:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-12 18:32:55 +00:00
|
|
|
return TextDecoder;
|
2017-07-30 10:09:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Mix in some shared properties.
|
2022-06-03 08:23:58 +00:00
|
|
|
const sharedProperties = ObjectGetOwnPropertyDescriptors({
|
|
|
|
get encoding() {
|
|
|
|
validateDecoder(this);
|
|
|
|
return this[kEncoding];
|
|
|
|
},
|
|
|
|
|
|
|
|
get fatal() {
|
|
|
|
validateDecoder(this);
|
|
|
|
return (this[kFlags] & CONVERTER_FLAGS_FATAL) === CONVERTER_FLAGS_FATAL;
|
|
|
|
},
|
|
|
|
|
|
|
|
get ignoreBOM() {
|
|
|
|
validateDecoder(this);
|
|
|
|
return (this[kFlags] & CONVERTER_FLAGS_IGNORE_BOM) ===
|
2020-05-17 17:07:04 +00:00
|
|
|
CONVERTER_FLAGS_IGNORE_BOM;
|
2022-06-03 08:23:58 +00:00
|
|
|
},
|
2020-05-17 17:07:04 +00:00
|
|
|
|
2022-06-03 08:23:58 +00:00
|
|
|
[inspect](depth, opts) {
|
|
|
|
validateDecoder(this);
|
|
|
|
if (typeof depth === 'number' && depth < 0)
|
|
|
|
return this;
|
|
|
|
const constructor = getConstructorOf(this) || TextDecoder;
|
2023-01-10 05:38:36 +00:00
|
|
|
const obj = { __proto__: { constructor } };
|
2022-06-03 08:23:58 +00:00
|
|
|
obj.encoding = this.encoding;
|
|
|
|
obj.fatal = this.fatal;
|
|
|
|
obj.ignoreBOM = this.ignoreBOM;
|
|
|
|
if (opts.showHidden) {
|
|
|
|
obj[kFlags] = this[kFlags];
|
|
|
|
obj[kHandle] = this[kHandle];
|
2017-07-30 10:09:13 +00:00
|
|
|
}
|
2022-06-03 08:23:58 +00:00
|
|
|
// Lazy to avoid circular dependency
|
|
|
|
const { inspect } = require('internal/util/inspect');
|
|
|
|
return `${constructor.name} ${inspect(obj)}`;
|
2023-02-26 10:34:02 +00:00
|
|
|
},
|
2022-06-03 08:23:58 +00:00
|
|
|
});
|
|
|
|
const propertiesValues = ObjectValues(sharedProperties);
|
|
|
|
for (let i = 0; i < propertiesValues.length; i++) {
|
|
|
|
// We want to use null-prototype objects to not rely on globally mutable
|
|
|
|
// %Object.prototype%.
|
|
|
|
ObjectSetPrototypeOf(propertiesValues[i], null);
|
|
|
|
}
|
|
|
|
sharedProperties[inspect].enumerable = false;
|
2020-05-17 17:07:04 +00:00
|
|
|
|
|
|
|
ObjectDefineProperties(TextDecoder.prototype, {
|
2022-02-11 17:30:47 +00:00
|
|
|
decode: kEnumerableProperty,
|
2022-06-03 08:23:58 +00:00
|
|
|
...sharedProperties,
|
2020-05-17 17:07:04 +00:00
|
|
|
[SymbolToStringTag]: {
|
2022-06-03 08:23:58 +00:00
|
|
|
__proto__: null,
|
2020-05-17 17:07:04 +00:00
|
|
|
configurable: true,
|
2023-02-26 10:34:02 +00:00
|
|
|
value: 'TextDecoder',
|
|
|
|
},
|
2020-05-17 17:07:04 +00:00
|
|
|
});
|
2017-07-30 10:09:13 +00:00
|
|
|
|
2017-06-12 15:25:53 +00:00
|
|
|
module.exports = {
|
|
|
|
getEncodingFromLabel,
|
|
|
|
TextDecoder,
|
2023-02-26 10:34:02 +00:00
|
|
|
TextEncoder,
|
2017-06-12 15:25:53 +00:00
|
|
|
};
|