@wabot-dev/framework 0.0.14 → 0.0.16

package/dist/src/node_modules/iconv-lite/encodings/dbcs-data.js

@@ -1,206 +0,0 @@
-import require$$0 from './tables/shiftjis.json.js';
-import require$$1 from './tables/eucjp.json.js';
-import require$$2 from './tables/cp936.json.js';
-import require$$3 from './tables/gbk-added.json.js';
-import require$$4 from './tables/gb18030-ranges.json.js';
-import require$$5 from './tables/cp949.json.js';
-import require$$6 from './tables/cp950.json.js';
-import require$$7 from './tables/big5-added.json.js';
-
-var dbcsData;
-var hasRequiredDbcsData;
-
-function requireDbcsData () {
-	if (hasRequiredDbcsData) return dbcsData;
-	hasRequiredDbcsData = 1;
-
-	// Description of supported double byte encodings and aliases.
-	// Tables are not require()-d until they are needed to speed up library load.
-	// require()-s are direct to support Browserify.
-
-	dbcsData = {
-	    
-	    // == Japanese/ShiftJIS ====================================================
-	    // All japanese encodings are based on JIS X set of standards:
-	    // JIS X 0201 - Single-byte encoding of ASCII + ¥ + Kana chars at 0xA1-0xDF.
-	    // JIS X 0208 - Main set of 6879 characters, placed in 94x94 plane, to be encoded by 2 bytes. 
-	    //              Has several variations in 1978, 1983, 1990 and 1997.
-	    // JIS X 0212 - Supplementary plane of 6067 chars in 94x94 plane. 1990. Effectively dead.
-	    // JIS X 0213 - Extension and modern replacement of 0208 and 0212. Total chars: 11233.
-	    //              2 planes, first is superset of 0208, second - revised 0212.
-	    //              Introduced in 2000, revised 2004. Some characters are in Unicode Plane 2 (0x2xxxx)
-
-	    // Byte encodings are:
-	    //  * Shift_JIS: Compatible with 0201, uses not defined chars in top half as lead bytes for double-byte
-	    //               encoding of 0208. Lead byte ranges: 0x81-0x9F, 0xE0-0xEF; Trail byte ranges: 0x40-0x7E, 0x80-0x9E, 0x9F-0xFC.
-	    //               Windows CP932 is a superset of Shift_JIS. Some companies added more chars, notably KDDI.
-	    //  * EUC-JP:    Up to 3 bytes per character. Used mostly on *nixes.
-	    //               0x00-0x7F       - lower part of 0201
-	    //               0x8E, 0xA1-0xDF - upper part of 0201
-	    //               (0xA1-0xFE)x2   - 0208 plane (94x94).
-	    //               0x8F, (0xA1-0xFE)x2 - 0212 plane (94x94).
-	    //  * JIS X 208: 7-bit, direct encoding of 0208. Byte ranges: 0x21-0x7E (94 values). Uncommon.
-	    //               Used as-is in ISO2022 family.
-	    //  * ISO2022-JP: Stateful encoding, with escape sequences to switch between ASCII, 
-	    //                0201-1976 Roman, 0208-1978, 0208-1983.
-	    //  * ISO2022-JP-1: Adds esc seq for 0212-1990.
-	    //  * ISO2022-JP-2: Adds esc seq for GB2313-1980, KSX1001-1992, ISO8859-1, ISO8859-7.
-	    //  * ISO2022-JP-3: Adds esc seq for 0201-1976 Kana set, 0213-2000 Planes 1, 2.
-	    //  * ISO2022-JP-2004: Adds 0213-2004 Plane 1.
-	    //
-	    // After JIS X 0213 appeared, Shift_JIS-2004, EUC-JISX0213 and ISO2022-JP-2004 followed, with just changing the planes.
-	    //
-	    // Overall, it seems that it's a mess :( http://www8.plala.or.jp/tkubota1/unicode-symbols-map2.html
-
-	    'shiftjis': {
-	        type: '_dbcs',
-	        table: function() { return require$$0 },
-	        encodeAdd: {'\u00a5': 0x5C, '\u203E': 0x7E},
-	        encodeSkipVals: [{from: 0xED40, to: 0xF940}],
-	    },
-	    'csshiftjis': 'shiftjis',
-	    'mskanji': 'shiftjis',
-	    'sjis': 'shiftjis',
-	    'windows31j': 'shiftjis',
-	    'ms31j': 'shiftjis',
-	    'xsjis': 'shiftjis',
-	    'windows932': 'shiftjis',
-	    'ms932': 'shiftjis',
-	    '932': 'shiftjis',
-	    'cp932': 'shiftjis',
-
-	    'eucjp': {
-	        type: '_dbcs',
-	        table: function() { return require$$1 },
-	        encodeAdd: {'\u00a5': 0x5C, '\u203E': 0x7E},
-	    },
-
-	    // TODO: KDDI extension to Shift_JIS
-	    // TODO: IBM CCSID 942 = CP932, but F0-F9 custom chars and other char changes.
-	    // TODO: IBM CCSID 943 = Shift_JIS = CP932 with original Shift_JIS lower 128 chars.
-
-
-	    // == Chinese/GBK ==========================================================
-	    // http://en.wikipedia.org/wiki/GBK
-	    // We mostly implement W3C recommendation: https://www.w3.org/TR/encoding/#gbk-encoder
-
-	    // Oldest GB2312 (1981, ~7600 chars) is a subset of CP936
-	    'gb2312': 'cp936',
-	    'gb231280': 'cp936',
-	    'gb23121980': 'cp936',
-	    'csgb2312': 'cp936',
-	    'csiso58gb231280': 'cp936',
-	    'euccn': 'cp936',
-
-	    // Microsoft's CP936 is a subset and approximation of GBK.
-	    'windows936': 'cp936',
-	    'ms936': 'cp936',
-	    '936': 'cp936',
-	    'cp936': {
-	        type: '_dbcs',
-	        table: function() { return require$$2 },
-	    },
-
-	    // GBK (~22000 chars) is an extension of CP936 that added user-mapped chars and some other.
-	    'gbk': {
-	        type: '_dbcs',
-	        table: function() { return require$$2.concat(require$$3) },
-	    },
-	    'xgbk': 'gbk',
-	    'isoir58': 'gbk',
-
-	    // GB18030 is an algorithmic extension of GBK.
-	    // Main source: https://www.w3.org/TR/encoding/#gbk-encoder
-	    // http://icu-project.org/docs/papers/gb18030.html
-	    // http://source.icu-project.org/repos/icu/data/trunk/charset/data/xml/gb-18030-2000.xml
-	    // http://www.khngai.com/chinese/charmap/tblgbk.php?page=0
-	    'gb18030': {
-	        type: '_dbcs',
-	        table: function() { return require$$2.concat(require$$3) },
-	        gb18030: function() { return require$$4 },
-	        encodeSkipVals: [0x80],
-	        encodeAdd: {'€': 0xA2E3},
-	    },
-
-	    'chinese': 'gb18030',
-
-
-	    // == Korean ===============================================================
-	    // EUC-KR, KS_C_5601 and KS X 1001 are exactly the same.
-	    'windows949': 'cp949',
-	    'ms949': 'cp949',
-	    '949': 'cp949',
-	    'cp949': {
-	        type: '_dbcs',
-	        table: function() { return require$$5 },
-	    },
-
-	    'cseuckr': 'cp949',
-	    'csksc56011987': 'cp949',
-	    'euckr': 'cp949',
-	    'isoir149': 'cp949',
-	    'korean': 'cp949',
-	    'ksc56011987': 'cp949',
-	    'ksc56011989': 'cp949',
-	    'ksc5601': 'cp949',
-
-
-	    // == Big5/Taiwan/Hong Kong ================================================
-	    // There are lots of tables for Big5 and cp950. Please see the following links for history:
-	    // http://moztw.org/docs/big5/  http://www.haible.de/bruno/charsets/conversion-tables/Big5.html
-	    // Variations, in roughly number of defined chars:
-	    //  * Windows CP 950: Microsoft variant of Big5. Canonical: http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP950.TXT
-	    //  * Windows CP 951: Microsoft variant of Big5-HKSCS-2001. Seems to be never public. http://me.abelcheung.org/articles/research/what-is-cp951/
-	    //  * Big5-2003 (Taiwan standard) almost superset of cp950.
-	    //  * Unicode-at-on (UAO) / Mozilla 1.8. Falling out of use on the Web. Not supported by other browsers.
-	    //  * Big5-HKSCS (-2001, -2004, -2008). Hong Kong standard. 
-	    //    many unicode code points moved from PUA to Supplementary plane (U+2XXXX) over the years.
-	    //    Plus, it has 4 combining sequences.
-	    //    Seems that Mozilla refused to support it for 10 yrs. https://bugzilla.mozilla.org/show_bug.cgi?id=162431 https://bugzilla.mozilla.org/show_bug.cgi?id=310299
-	    //    because big5-hkscs is the only encoding to include astral characters in non-algorithmic way.
-	    //    Implementations are not consistent within browsers; sometimes labeled as just big5.
-	    //    MS Internet Explorer switches from big5 to big5-hkscs when a patch applied.
-	    //    Great discussion & recap of what's going on https://bugzilla.mozilla.org/show_bug.cgi?id=912470#c31
-	    //    In the encoder, it might make sense to support encoding old PUA mappings to Big5 bytes seq-s.
-	    //    Official spec: http://www.ogcio.gov.hk/en/business/tech_promotion/ccli/terms/doc/2003cmp_2008.txt
-	    //                   http://www.ogcio.gov.hk/tc/business/tech_promotion/ccli/terms/doc/hkscs-2008-big5-iso.txt
-	    // 
-	    // Current understanding of how to deal with Big5(-HKSCS) is in the Encoding Standard, http://encoding.spec.whatwg.org/#big5-encoder
-	    // Unicode mapping (http://www.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/OTHER/BIG5.TXT) is said to be wrong.
-
-	    'windows950': 'cp950',
-	    'ms950': 'cp950',
-	    '950': 'cp950',
-	    'cp950': {
-	        type: '_dbcs',
-	        table: function() { return require$$6 },
-	    },
-
-	    // Big5 has many variations and is an extension of cp950. We use Encoding Standard's as a consensus.
-	    'big5': 'big5hkscs',
-	    'big5hkscs': {
-	        type: '_dbcs',
-	        table: function() { return require$$6.concat(require$$7) },
-	        encodeSkipVals: [
-	            // Although Encoding Standard says we should avoid encoding to HKSCS area (See Step 1 of
-	            // https://encoding.spec.whatwg.org/#index-big5-pointer), we still do it to increase compatibility with ICU.
-	            // But if a single unicode point can be encoded both as HKSCS and regular Big5, we prefer the latter.
-	            0x8e69, 0x8e6f, 0x8e7e, 0x8eab, 0x8eb4, 0x8ecd, 0x8ed0, 0x8f57, 0x8f69, 0x8f6e, 0x8fcb, 0x8ffe,
-	            0x906d, 0x907a, 0x90c4, 0x90dc, 0x90f1, 0x91bf, 0x92af, 0x92b0, 0x92b1, 0x92b2, 0x92d1, 0x9447, 0x94ca,
-	            0x95d9, 0x96fc, 0x9975, 0x9b76, 0x9b78, 0x9b7b, 0x9bc6, 0x9bde, 0x9bec, 0x9bf6, 0x9c42, 0x9c53, 0x9c62,
-	            0x9c68, 0x9c6b, 0x9c77, 0x9cbc, 0x9cbd, 0x9cd0, 0x9d57, 0x9d5a, 0x9dc4, 0x9def, 0x9dfb, 0x9ea9, 0x9eef,
-	            0x9efd, 0x9f60, 0x9fcb, 0xa077, 0xa0dc, 0xa0df, 0x8fcc, 0x92c8, 0x9644, 0x96ed,
-
-	            // Step 2 of https://encoding.spec.whatwg.org/#index-big5-pointer: Use last pointer for U+2550, U+255E, U+2561, U+256A, U+5341, or U+5345
-	            0xa2a4, 0xa2a5, 0xa2a7, 0xa2a6, 0xa2cc, 0xa2ce,
-	        ],
-	    },
-
-	    'cnbig5': 'big5hkscs',
-	    'csbig5': 'big5hkscs',
-	    'xxbig5': 'big5hkscs',
-	};
-	return dbcsData;
-}
-
-export { requireDbcsData as __require };

package/dist/src/node_modules/iconv-lite/encodings/index.js

@@ -1,44 +0,0 @@
-import { __exports as encodings } from '../../../_virtual/index29.js';
-import { __require as requireInternal } from './internal.js';
-import { __require as requireUtf32 } from './utf32.js';
-import { __require as requireUtf16 } from './utf16.js';
-import { __require as requireUtf7 } from './utf7.js';
-import { __require as requireSbcsCodec } from './sbcs-codec.js';
-import { __require as requireSbcsData } from './sbcs-data.js';
-import { __require as requireSbcsDataGenerated } from './sbcs-data-generated.js';
-import { __require as requireDbcsCodec } from './dbcs-codec.js';
-import { __require as requireDbcsData } from './dbcs-data.js';
-
-var hasRequiredEncodings;
-
-function requireEncodings () {
-	if (hasRequiredEncodings) return encodings;
-	hasRequiredEncodings = 1;
-	(function (exports) {
-
-		// Update this array if you add/rename/remove files in this directory.
-		// We support Browserify by skipping automatic module discovery and requiring modules directly.
-		var modules = [
-		    requireInternal(),
-		    requireUtf32(),
-		    requireUtf16(),
-		    requireUtf7(),
-		    requireSbcsCodec(),
-		    requireSbcsData(),
-		    requireSbcsDataGenerated(),
-		    requireDbcsCodec(),
-		    requireDbcsData(),
-		];
-
-		// Put all encoding/alias/codec definitions to single object and export it.
-		for (var i = 0; i < modules.length; i++) {
-		    var module = modules[i];
-		    for (var enc in module)
-		        if (Object.prototype.hasOwnProperty.call(module, enc))
-		            exports[enc] = module[enc];
-		} 
-	} (encodings));
-	return encodings;
-}
-
-export { requireEncodings as __require };

package/dist/src/node_modules/iconv-lite/encodings/internal.js

@@ -1,210 +0,0 @@
-import { __require as requireSafer } from '../../safer-buffer/safer.js';
-import require$$1 from 'string_decoder';
-
-var internal;
-var hasRequiredInternal;
-
-function requireInternal () {
-	if (hasRequiredInternal) return internal;
-	hasRequiredInternal = 1;
-	var Buffer = requireSafer().Buffer;
-
-	// Export Node.js internal encodings.
-
-	internal = {
-	    // Encodings
-	    utf8:   { type: "_internal", bomAware: true},
-	    cesu8:  { type: "_internal", bomAware: true},
-	    unicode11utf8: "utf8",
-
-	    ucs2:   { type: "_internal", bomAware: true},
-	    utf16le: "ucs2",
-
-	    binary: { type: "_internal" },
-	    base64: { type: "_internal" },
-	    hex:    { type: "_internal" },
-
-	    // Codec.
-	    _internal: InternalCodec,
-	};
-
-	//------------------------------------------------------------------------------
-
-	function InternalCodec(codecOptions, iconv) {
-	    this.enc = codecOptions.encodingName;
-	    this.bomAware = codecOptions.bomAware;
-
-	    if (this.enc === "base64")
-	        this.encoder = InternalEncoderBase64;
-	    else if (this.enc === "cesu8") {
-	        this.enc = "utf8"; // Use utf8 for decoding.
-	        this.encoder = InternalEncoderCesu8;
-
-	        // Add decoder for versions of Node not supporting CESU-8
-	        if (Buffer.from('eda0bdedb2a9', 'hex').toString() !== '💩') {
-	            this.decoder = InternalDecoderCesu8;
-	            this.defaultCharUnicode = iconv.defaultCharUnicode;
-	        }
-	    }
-	}
-
-	InternalCodec.prototype.encoder = InternalEncoder;
-	InternalCodec.prototype.decoder = InternalDecoder;
-
-	//------------------------------------------------------------------------------
-
-	// We use node.js internal decoder. Its signature is the same as ours.
-	var StringDecoder = require$$1.StringDecoder;
-
-	if (!StringDecoder.prototype.end) // Node v0.8 doesn't have this method.
-	    StringDecoder.prototype.end = function() {};
-
-
-	function InternalDecoder(options, codec) {
-	    this.decoder = new StringDecoder(codec.enc);
-	}
-
-	InternalDecoder.prototype.write = function(buf) {
-	    if (!Buffer.isBuffer(buf)) {
-	        buf = Buffer.from(buf);
-	    }
-
-	    return this.decoder.write(buf);
-	};
-
-	InternalDecoder.prototype.end = function() {
-	    return this.decoder.end();
-	};
-
-
-	//------------------------------------------------------------------------------
-	// Encoder is mostly trivial
-
-	function InternalEncoder(options, codec) {
-	    this.enc = codec.enc;
-	}
-
-	InternalEncoder.prototype.write = function(str) {
-	    return Buffer.from(str, this.enc);
-	};
-
-	InternalEncoder.prototype.end = function() {
-	};
-
-
-	//------------------------------------------------------------------------------
-	// Except base64 encoder, which must keep its state.
-
-	function InternalEncoderBase64(options, codec) {
-	    this.prevStr = '';
-	}
-
-	InternalEncoderBase64.prototype.write = function(str) {
-	    str = this.prevStr + str;
-	    var completeQuads = str.length - (str.length % 4);
-	    this.prevStr = str.slice(completeQuads);
-	    str = str.slice(0, completeQuads);
-
-	    return Buffer.from(str, "base64");
-	};
-
-	InternalEncoderBase64.prototype.end = function() {
-	    return Buffer.from(this.prevStr, "base64");
-	};
-
-
-	//------------------------------------------------------------------------------
-	// CESU-8 encoder is also special.
-
-	function InternalEncoderCesu8(options, codec) {
-	}
-
-	InternalEncoderCesu8.prototype.write = function(str) {
-	    var buf = Buffer.alloc(str.length * 3), bufIdx = 0;
-	    for (var i = 0; i < str.length; i++) {
-	        var charCode = str.charCodeAt(i);
-	        // Naive implementation, but it works because CESU-8 is especially easy
-	        // to convert from UTF-16 (which all JS strings are encoded in).
-	        if (charCode < 0x80)
-	            buf[bufIdx++] = charCode;
-	        else if (charCode < 0x800) {
-	            buf[bufIdx++] = 0xC0 + (charCode >>> 6);
-	            buf[bufIdx++] = 0x80 + (charCode & 0x3f);
-	        }
-	        else { // charCode will always be < 0x10000 in javascript.
-	            buf[bufIdx++] = 0xE0 + (charCode >>> 12);
-	            buf[bufIdx++] = 0x80 + ((charCode >>> 6) & 0x3f);
-	            buf[bufIdx++] = 0x80 + (charCode & 0x3f);
-	        }
-	    }
-	    return buf.slice(0, bufIdx);
-	};
-
-	InternalEncoderCesu8.prototype.end = function() {
-	};
-
-	//------------------------------------------------------------------------------
-	// CESU-8 decoder is not implemented in Node v4.0+
-
-	function InternalDecoderCesu8(options, codec) {
-	    this.acc = 0;
-	    this.contBytes = 0;
-	    this.accBytes = 0;
-	    this.defaultCharUnicode = codec.defaultCharUnicode;
-	}
-
-	InternalDecoderCesu8.prototype.write = function(buf) {
-	    var acc = this.acc, contBytes = this.contBytes, accBytes = this.accBytes, 
-	        res = '';
-	    for (var i = 0; i < buf.length; i++) {
-	        var curByte = buf[i];
-	        if ((curByte & 0xC0) !== 0x80) { // Leading byte
-	            if (contBytes > 0) { // Previous code is invalid
-	                res += this.defaultCharUnicode;
-	                contBytes = 0;
-	            }
-
-	            if (curByte < 0x80) { // Single-byte code
-	                res += String.fromCharCode(curByte);
-	            } else if (curByte < 0xE0) { // Two-byte code
-	                acc = curByte & 0x1F;
-	                contBytes = 1; accBytes = 1;
-	            } else if (curByte < 0xF0) { // Three-byte code
-	                acc = curByte & 0x0F;
-	                contBytes = 2; accBytes = 1;
-	            } else { // Four or more are not supported for CESU-8.
-	                res += this.defaultCharUnicode;
-	            }
-	        } else { // Continuation byte
-	            if (contBytes > 0) { // We're waiting for it.
-	                acc = (acc << 6) | (curByte & 0x3f);
-	                contBytes--; accBytes++;
-	                if (contBytes === 0) {
-	                    // Check for overlong encoding, but support Modified UTF-8 (encoding NULL as C0 80)
-	                    if (accBytes === 2 && acc < 0x80 && acc > 0)
-	                        res += this.defaultCharUnicode;
-	                    else if (accBytes === 3 && acc < 0x800)
-	                        res += this.defaultCharUnicode;
-	                    else
-	                        // Actually add character.
-	                        res += String.fromCharCode(acc);
-	                }
-	            } else { // Unexpected continuation byte
-	                res += this.defaultCharUnicode;
-	            }
-	        }
-	    }
-	    this.acc = acc; this.contBytes = contBytes; this.accBytes = accBytes;
-	    return res;
-	};
-
-	InternalDecoderCesu8.prototype.end = function() {
-	    var res = 0;
-	    if (this.contBytes > 0)
-	        res += this.defaultCharUnicode;
-	    return res;
-	};
-	return internal;
-}
-
-export { requireInternal as __require };

package/dist/src/node_modules/iconv-lite/encodings/sbcs-codec.js

@@ -1,83 +0,0 @@
-import { __exports as sbcsCodec } from '../../../_virtual/sbcs-codec.js';
-import { __require as requireSafer } from '../../safer-buffer/safer.js';
-
-var hasRequiredSbcsCodec;
-
-function requireSbcsCodec () {
-	if (hasRequiredSbcsCodec) return sbcsCodec;
-	hasRequiredSbcsCodec = 1;
-	var Buffer = requireSafer().Buffer;
-
-	// Single-byte codec. Needs a 'chars' string parameter that contains 256 or 128 chars that
-	// correspond to encoded bytes (if 128 - then lower half is ASCII). 
-
-	sbcsCodec._sbcs = SBCSCodec;
-	function SBCSCodec(codecOptions, iconv) {
-	    if (!codecOptions)
-	        throw new Error("SBCS codec is called without the data.")
-	    
-	    // Prepare char buffer for decoding.
-	    if (!codecOptions.chars || (codecOptions.chars.length !== 128 && codecOptions.chars.length !== 256))
-	        throw new Error("Encoding '"+codecOptions.type+"' has incorrect 'chars' (must be of len 128 or 256)");
-	    
-	    if (codecOptions.chars.length === 128) {
-	        var asciiString = "";
-	        for (var i = 0; i < 128; i++)
-	            asciiString += String.fromCharCode(i);
-	        codecOptions.chars = asciiString + codecOptions.chars;
-	    }
-
-	    this.decodeBuf = Buffer.from(codecOptions.chars, 'ucs2');
-	    
-	    // Encoding buffer.
-	    var encodeBuf = Buffer.alloc(65536, iconv.defaultCharSingleByte.charCodeAt(0));
-
-	    for (var i = 0; i < codecOptions.chars.length; i++)
-	        encodeBuf[codecOptions.chars.charCodeAt(i)] = i;
-
-	    this.encodeBuf = encodeBuf;
-	}
-
-	SBCSCodec.prototype.encoder = SBCSEncoder;
-	SBCSCodec.prototype.decoder = SBCSDecoder;
-
-
-	function SBCSEncoder(options, codec) {
-	    this.encodeBuf = codec.encodeBuf;
-	}
-
-	SBCSEncoder.prototype.write = function(str) {
-	    var buf = Buffer.alloc(str.length);
-	    for (var i = 0; i < str.length; i++)
-	        buf[i] = this.encodeBuf[str.charCodeAt(i)];
-	    
-	    return buf;
-	};
-
-	SBCSEncoder.prototype.end = function() {
-	};
-
-
-	function SBCSDecoder(options, codec) {
-	    this.decodeBuf = codec.decodeBuf;
-	}
-
-	SBCSDecoder.prototype.write = function(buf) {
-	    // Strings are immutable in JS -> we use ucs2 buffer to speed up computations.
-	    var decodeBuf = this.decodeBuf;
-	    var newBuf = Buffer.alloc(buf.length*2);
-	    var idx1 = 0, idx2 = 0;
-	    for (var i = 0; i < buf.length; i++) {
-	        idx1 = buf[i]*2; idx2 = i*2;
-	        newBuf[idx2] = decodeBuf[idx1];
-	        newBuf[idx2+1] = decodeBuf[idx1+1];
-	    }
-	    return newBuf.toString('ucs2');
-	};
-
-	SBCSDecoder.prototype.end = function() {
-	};
-	return sbcsCodec;
-}
-
-export { requireSbcsCodec as __require };