art-bd-ui 1.0.21 → 1.0.23

package/dist/cjs/node_modules/pdf-lib/es/utils/pdfDocEncoding.js

@@ -0,0 +1,70 @@
+'use strict';
+
+var strings = require('./strings.js');
+
+// Mapping from PDFDocEncoding to Unicode code point
+var pdfDocEncodingToUnicode = new Uint16Array(256);
+// Initialize the code points which are the same
+for (var idx = 0; idx < 256; idx++) {
+    pdfDocEncodingToUnicode[idx] = idx;
+}
+// Set differences (see "Table D.2 – PDFDocEncoding Character Set" of the PDF spec)
+pdfDocEncodingToUnicode[0x16] = strings.toCharCode('\u0017'); // SYNCRONOUS IDLE
+pdfDocEncodingToUnicode[0x18] = strings.toCharCode('\u02D8'); // BREVE
+pdfDocEncodingToUnicode[0x19] = strings.toCharCode('\u02C7'); // CARON
+pdfDocEncodingToUnicode[0x1a] = strings.toCharCode('\u02C6'); // MODIFIER LETTER CIRCUMFLEX ACCENT
+pdfDocEncodingToUnicode[0x1b] = strings.toCharCode('\u02D9'); // DOT ABOVE
+pdfDocEncodingToUnicode[0x1c] = strings.toCharCode('\u02DD'); // DOUBLE ACUTE ACCENT
+pdfDocEncodingToUnicode[0x1d] = strings.toCharCode('\u02DB'); // OGONEK
+pdfDocEncodingToUnicode[0x1e] = strings.toCharCode('\u02DA'); // RING ABOVE
+pdfDocEncodingToUnicode[0x1f] = strings.toCharCode('\u02DC'); // SMALL TILDE
+pdfDocEncodingToUnicode[0x7f] = strings.toCharCode('\uFFFD'); // REPLACEMENT CHARACTER (box with questionmark)
+pdfDocEncodingToUnicode[0x80] = strings.toCharCode('\u2022'); // BULLET
+pdfDocEncodingToUnicode[0x81] = strings.toCharCode('\u2020'); // DAGGER
+pdfDocEncodingToUnicode[0x82] = strings.toCharCode('\u2021'); // DOUBLE DAGGER
+pdfDocEncodingToUnicode[0x83] = strings.toCharCode('\u2026'); // HORIZONTAL ELLIPSIS
+pdfDocEncodingToUnicode[0x84] = strings.toCharCode('\u2014'); // EM DASH
+pdfDocEncodingToUnicode[0x85] = strings.toCharCode('\u2013'); // EN DASH
+pdfDocEncodingToUnicode[0x86] = strings.toCharCode('\u0192'); // LATIN SMALL LETTER SCRIPT F
+pdfDocEncodingToUnicode[0x87] = strings.toCharCode('\u2044'); // FRACTION SLASH (solidus)
+pdfDocEncodingToUnicode[0x88] = strings.toCharCode('\u2039'); // SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+pdfDocEncodingToUnicode[0x89] = strings.toCharCode('\u203A'); // SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+pdfDocEncodingToUnicode[0x8a] = strings.toCharCode('\u2212'); // MINUS SIGN
+pdfDocEncodingToUnicode[0x8b] = strings.toCharCode('\u2030'); // PER MILLE SIGN
+pdfDocEncodingToUnicode[0x8c] = strings.toCharCode('\u201E'); // DOUBLE LOW-9 QUOTATION MARK (quotedblbase)
+pdfDocEncodingToUnicode[0x8d] = strings.toCharCode('\u201C'); // LEFT DOUBLE QUOTATION MARK (quotedblleft)
+pdfDocEncodingToUnicode[0x8e] = strings.toCharCode('\u201D'); // RIGHT DOUBLE QUOTATION MARK (quotedblright)
+pdfDocEncodingToUnicode[0x8f] = strings.toCharCode('\u2018'); // LEFT SINGLE QUOTATION MARK (quoteleft)
+pdfDocEncodingToUnicode[0x90] = strings.toCharCode('\u2019'); // RIGHT SINGLE QUOTATION MARK (quoteright)
+pdfDocEncodingToUnicode[0x91] = strings.toCharCode('\u201A'); // SINGLE LOW-9 QUOTATION MARK (quotesinglbase)
+pdfDocEncodingToUnicode[0x92] = strings.toCharCode('\u2122'); // TRADE MARK SIGN
+pdfDocEncodingToUnicode[0x93] = strings.toCharCode('\uFB01'); // LATIN SMALL LIGATURE FI
+pdfDocEncodingToUnicode[0x94] = strings.toCharCode('\uFB02'); // LATIN SMALL LIGATURE FL
+pdfDocEncodingToUnicode[0x95] = strings.toCharCode('\u0141'); // LATIN CAPITAL LETTER L WITH STROKE
+pdfDocEncodingToUnicode[0x96] = strings.toCharCode('\u0152'); // LATIN CAPITAL LIGATURE OE
+pdfDocEncodingToUnicode[0x97] = strings.toCharCode('\u0160'); // LATIN CAPITAL LETTER S WITH CARON
+pdfDocEncodingToUnicode[0x98] = strings.toCharCode('\u0178'); // LATIN CAPITAL LETTER Y WITH DIAERESIS
+pdfDocEncodingToUnicode[0x99] = strings.toCharCode('\u017D'); // LATIN CAPITAL LETTER Z WITH CARON
+pdfDocEncodingToUnicode[0x9a] = strings.toCharCode('\u0131'); // LATIN SMALL LETTER DOTLESS I
+pdfDocEncodingToUnicode[0x9b] = strings.toCharCode('\u0142'); // LATIN SMALL LETTER L WITH STROKE
+pdfDocEncodingToUnicode[0x9c] = strings.toCharCode('\u0153'); // LATIN SMALL LIGATURE OE
+pdfDocEncodingToUnicode[0x9d] = strings.toCharCode('\u0161'); // LATIN SMALL LETTER S WITH CARON
+pdfDocEncodingToUnicode[0x9e] = strings.toCharCode('\u017E'); // LATIN SMALL LETTER Z WITH CARON
+pdfDocEncodingToUnicode[0x9f] = strings.toCharCode('\uFFFD'); // REPLACEMENT CHARACTER (box with questionmark)
+pdfDocEncodingToUnicode[0xa0] = strings.toCharCode('\u20AC'); // EURO SIGN
+pdfDocEncodingToUnicode[0xad] = strings.toCharCode('\uFFFD'); // REPLACEMENT CHARACTER (box with questionmark)
+/**
+ * Decode a byte array into a string using PDFDocEncoding.
+ *
+ * @param bytes a byte array (decimal representation) containing a string
+ *              encoded with PDFDocEncoding.
+ */
+var pdfDocEncodingDecode = function (bytes) {
+    var codePoints = new Array(bytes.length);
+    for (var idx = 0, len = bytes.length; idx < len; idx++) {
+        codePoints[idx] = pdfDocEncodingToUnicode[bytes[idx]];
+    }
+    return String.fromCodePoint.apply(String, codePoints);
+};
+
+exports.pdfDocEncodingDecode = pdfDocEncodingDecode;

package/dist/cjs/node_modules/pdf-lib/es/utils/png.js

@@ -0,0 +1,62 @@
+'use strict';
+
+var UPNG = require('../../../@pdf-lib/upng/UPNG.js');
+
+var getImageType = function (ctype) {
+    if (ctype === 0)
+        return exports.PngType.Greyscale;
+    if (ctype === 2)
+        return exports.PngType.Truecolour;
+    if (ctype === 3)
+        return exports.PngType.IndexedColour;
+    if (ctype === 4)
+        return exports.PngType.GreyscaleWithAlpha;
+    if (ctype === 6)
+        return exports.PngType.TruecolourWithAlpha;
+    throw new Error("Unknown color type: " + ctype);
+};
+var splitAlphaChannel = function (rgbaChannel) {
+    var pixelCount = Math.floor(rgbaChannel.length / 4);
+    var rgbChannel = new Uint8Array(pixelCount * 3);
+    var alphaChannel = new Uint8Array(pixelCount * 1);
+    var rgbaOffset = 0;
+    var rgbOffset = 0;
+    var alphaOffset = 0;
+    while (rgbaOffset < rgbaChannel.length) {
+        rgbChannel[rgbOffset++] = rgbaChannel[rgbaOffset++];
+        rgbChannel[rgbOffset++] = rgbaChannel[rgbaOffset++];
+        rgbChannel[rgbOffset++] = rgbaChannel[rgbaOffset++];
+        alphaChannel[alphaOffset++] = rgbaChannel[rgbaOffset++];
+    }
+    return { rgbChannel: rgbChannel, alphaChannel: alphaChannel };
+};
+exports.PngType = void 0;
+(function (PngType) {
+    PngType["Greyscale"] = "Greyscale";
+    PngType["Truecolour"] = "Truecolour";
+    PngType["IndexedColour"] = "IndexedColour";
+    PngType["GreyscaleWithAlpha"] = "GreyscaleWithAlpha";
+    PngType["TruecolourWithAlpha"] = "TruecolourWithAlpha";
+})(exports.PngType || (exports.PngType = {}));
+var PNG = /** @class */ (function () {
+    function PNG(pngData) {
+        var upng = UPNG.default.decode(pngData);
+        var frames = UPNG.default.toRGBA8(upng);
+        if (frames.length > 1)
+            throw new Error("Animated PNGs are not supported");
+        var frame = new Uint8Array(frames[0]);
+        var _a = splitAlphaChannel(frame), rgbChannel = _a.rgbChannel, alphaChannel = _a.alphaChannel;
+        this.rgbChannel = rgbChannel;
+        var hasAlphaValues = alphaChannel.some(function (a) { return a < 255; });
+        if (hasAlphaValues)
+            this.alphaChannel = alphaChannel;
+        this.type = getImageType(upng.ctype);
+        this.width = upng.width;
+        this.height = upng.height;
+        this.bitsPerComponent = 8;
+    }
+    PNG.load = function (pngData) { return new PNG(pngData); };
+    return PNG;
+}());
+
+exports.PNG = PNG;

package/dist/cjs/node_modules/pdf-lib/es/utils/rng.js

@@ -0,0 +1,22 @@
+'use strict';
+
+/**
+ * Generates a pseudo random number. Although it is not cryptographically secure
+ * and uniformly distributed, it is not a concern for the intended use-case,
+ * which is to generate distinct numbers.
+ *
+ * Credit: https://stackoverflow.com/a/19303725/10254049
+ */
+var SimpleRNG = /** @class */ (function () {
+    function SimpleRNG(seed) {
+        this.seed = seed;
+    }
+    SimpleRNG.prototype.nextInt = function () {
+        var x = Math.sin(this.seed++) * 10000;
+        return x - Math.floor(x);
+    };
+    SimpleRNG.withSeed = function (seed) { return new SimpleRNG(seed); };
+    return SimpleRNG;
+}());
+
+exports.SimpleRNG = SimpleRNG;

package/dist/cjs/node_modules/pdf-lib/es/utils/strings.js

@@ -0,0 +1,154 @@
+'use strict';
+
+var toCharCode = function (character) { return character.charCodeAt(0); };
+var toCodePoint = function (character) { return character.codePointAt(0); };
+var toHexStringOfMinLength = function (num, minLength) {
+    return padStart(num.toString(16), minLength, '0').toUpperCase();
+};
+var toHexString = function (num) { return toHexStringOfMinLength(num, 2); };
+var charFromCode = function (code) { return String.fromCharCode(code); };
+var charFromHexCode = function (hex) { return charFromCode(parseInt(hex, 16)); };
+var padStart = function (value, length, padChar) {
+    var padding = '';
+    for (var idx = 0, len = length - value.length; idx < len; idx++) {
+        padding += padChar;
+    }
+    return padding + value;
+};
+var copyStringIntoBuffer = function (str, buffer, offset) {
+    var length = str.length;
+    for (var idx = 0; idx < length; idx++) {
+        buffer[offset++] = str.charCodeAt(idx);
+    }
+    return length;
+};
+var escapeRegExp = function (str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+};
+var cleanText = function (text) {
+    return text.replace(/\t|\u0085|\u2028|\u2029/g, '    ').replace(/[\b\v]/g, '');
+};
+var escapedNewlineChars = ['\\n', '\\f', '\\r', '\\u000B'];
+var isNewlineChar = function (text) { return /^[\n\f\r\u000B]$/.test(text); };
+var lineSplit = function (text) { return text.split(/[\n\f\r\u000B]/); };
+var mergeLines = function (text) {
+    return text.replace(/[\n\f\r\u000B]/g, ' ');
+};
+// JavaScript's String.charAt() method doesn work on strings containing UTF-16
+// characters (with high and low surrogate pairs), such as 💩 (poo emoji). This
+// `charAtIndex()` function does.
+//
+// Credit: https://github.com/mathiasbynens/String.prototype.at/blob/master/at.js#L14-L48
+var charAtIndex = function (text, index) {
+    // Get the first code unit and code unit value
+    var cuFirst = text.charCodeAt(index);
+    var cuSecond;
+    var nextIndex = index + 1;
+    var length = 1;
+    if (
+    // Check if it's the start of a surrogate pair.
+    cuFirst >= 0xd800 &&
+        cuFirst <= 0xdbff && // high surrogate
+        text.length > nextIndex // there is a next code unit
+    ) {
+        cuSecond = text.charCodeAt(nextIndex);
+        if (cuSecond >= 0xdc00 && cuSecond <= 0xdfff)
+            length = 2; // low surrogate
+    }
+    return [text.slice(index, index + length), length];
+};
+var charSplit = function (text) {
+    var chars = [];
+    for (var idx = 0, len = text.length; idx < len;) {
+        var _a = charAtIndex(text, idx), c = _a[0], cLen = _a[1];
+        chars.push(c);
+        idx += cLen;
+    }
+    return chars;
+};
+var buildWordBreakRegex = function (wordBreaks) {
+    var newlineCharUnion = escapedNewlineChars.join('|');
+    var escapedRules = ['$'];
+    for (var idx = 0, len = wordBreaks.length; idx < len; idx++) {
+        var wordBreak = wordBreaks[idx];
+        if (isNewlineChar(wordBreak)) {
+            throw new TypeError("`wordBreak` must not include " + newlineCharUnion);
+        }
+        escapedRules.push(wordBreak === '' ? '.' : escapeRegExp(wordBreak));
+    }
+    var breakRules = escapedRules.join('|');
+    return new RegExp("(" + newlineCharUnion + ")|((.*?)(" + breakRules + "))", 'gm');
+};
+var breakTextIntoLines = function (text, wordBreaks, maxWidth, computeWidthOfText) {
+    var regex = buildWordBreakRegex(wordBreaks);
+    var words = cleanText(text).match(regex);
+    var currLine = '';
+    var currWidth = 0;
+    var lines = [];
+    var pushCurrLine = function () {
+        if (currLine !== '')
+            lines.push(currLine);
+        currLine = '';
+        currWidth = 0;
+    };
+    for (var idx = 0, len = words.length; idx < len; idx++) {
+        var word = words[idx];
+        if (isNewlineChar(word)) {
+            pushCurrLine();
+        }
+        else {
+            var width = computeWidthOfText(word);
+            if (currWidth + width > maxWidth)
+                pushCurrLine();
+            currLine += word;
+            currWidth += width;
+        }
+    }
+    pushCurrLine();
+    return lines;
+};
+// See section "7.9.4 Dates" of the PDF specification
+var dateRegex = /^D:(\d\d\d\d)(\d\d)?(\d\d)?(\d\d)?(\d\d)?(\d\d)?([+\-Z])?(\d\d)?'?(\d\d)?'?$/;
+var parseDate = function (dateStr) {
+    var match = dateStr.match(dateRegex);
+    if (!match)
+        return undefined;
+    var year = match[1], _a = match[2], month = _a === void 0 ? '01' : _a, _b = match[3], day = _b === void 0 ? '01' : _b, _c = match[4], hours = _c === void 0 ? '00' : _c, _d = match[5], mins = _d === void 0 ? '00' : _d, _e = match[6], secs = _e === void 0 ? '00' : _e, _f = match[7], offsetSign = _f === void 0 ? 'Z' : _f, _g = match[8], offsetHours = _g === void 0 ? '00' : _g, _h = match[9], offsetMins = _h === void 0 ? '00' : _h;
+    // http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15
+    var tzOffset = offsetSign === 'Z' ? 'Z' : "" + offsetSign + offsetHours + ":" + offsetMins;
+    var date = new Date(year + "-" + month + "-" + day + "T" + hours + ":" + mins + ":" + secs + tzOffset);
+    return date;
+};
+var findLastMatch = function (value, regex) {
+    var _a;
+    var position = 0;
+    var lastMatch;
+    while (position < value.length) {
+        var match = value.substring(position).match(regex);
+        if (!match)
+            return { match: lastMatch, pos: position };
+        lastMatch = match;
+        position += ((_a = match.index) !== null && _a !== void 0 ? _a : 0) + match[0].length;
+    }
+    return { match: lastMatch, pos: position };
+};
+
+exports.breakTextIntoLines = breakTextIntoLines;
+exports.charAtIndex = charAtIndex;
+exports.charFromCode = charFromCode;
+exports.charFromHexCode = charFromHexCode;
+exports.charSplit = charSplit;
+exports.cleanText = cleanText;
+exports.copyStringIntoBuffer = copyStringIntoBuffer;
+exports.escapeRegExp = escapeRegExp;
+exports.escapedNewlineChars = escapedNewlineChars;
+exports.findLastMatch = findLastMatch;
+exports.isNewlineChar = isNewlineChar;
+exports.lineSplit = lineSplit;
+exports.mergeLines = mergeLines;
+exports.padStart = padStart;
+exports.parseDate = parseDate;
+exports.toCharCode = toCharCode;
+exports.toCodePoint = toCodePoint;
+exports.toHexString = toHexString;
+exports.toHexStringOfMinLength = toHexStringOfMinLength;

package/dist/cjs/node_modules/pdf-lib/es/utils/unicode.js

@@ -0,0 +1,247 @@
+'use strict';
+
+var strings = require('./strings.js');
+
+/**
+ * Encodes a string to UTF-16.
+ *
+ * @param input The string to be encoded.
+ * @param byteOrderMark Whether or not a byte order marker (BOM) should be added
+ *                      to the start of the encoding. (default `true`)
+ * @returns A Uint16Array containing the UTF-16 encoding of the input string.
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * JavaScript strings are composed of Unicode code points. Code points are
+ * integers in the range 0 to 1,114,111 (0x10FFFF). When serializing a string,
+ * it must be encoded as a sequence of words. A word is typically 8, 16, or 32
+ * bytes in size. As such, Unicode defines three encoding forms: UTF-8, UTF-16,
+ * and UTF-32. These encoding forms are described in the Unicode standard [1].
+ * This function implements the UTF-16 encoding form.
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * In UTF-16, each code point is mapped to one or two 16-bit integers. The
+ * UTF-16 mapping logic is as follows [2]:
+ *
+ * • If a code point is in the range U+0000..U+FFFF, then map the code point to
+ *   a 16-bit integer with the most significant byte first.
+ *
+ * • If a code point is in the range U+10000..U+10000, then map the code point
+ *   to two 16-bit integers. The first integer should contain the high surrogate
+ *   and the second integer should contain the low surrogate. Both surrogates
+ *   should be written with the most significant byte first.
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * It is important to note, when iterating through the code points of a string
+ * in JavaScript, that if a character is encoded as a surrogate pair it will
+ * increase the string's length by 2 instead of 1 [4]. For example:
+ *
+ * ```
+ * > 'a'.length
+ * 1
+ * > '💩'.length
+ * 2
+ * > '語'.length
+ * 1
+ * > 'a💩語'.length
+ * 4
+ * ```
+ *
+ * The results of the above example are explained by the fact that the
+ * characters 'a' and '語' are not represented by surrogate pairs, but '💩' is.
+ *
+ * Because of this idiosyncrasy in JavaScript's string implementation and APIs,
+ * we must "jump" an extra index after encoding a character as a surrogate
+ * pair. In practice, this means we must increment the index of our for loop by
+ * 2 if we encode a surrogate pair, and 1 in all other cases.
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * References:
+ *   - [1] https://www.unicode.org/versions/Unicode12.0.0/UnicodeStandard-12.0.pdf
+ *         3.9  Unicode Encoding Forms - UTF-8
+ *   - [2] http://www.herongyang.com/Unicode/UTF-16-UTF-16-Encoding.html
+ *   - [3] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length#Description
+ *
+ */
+var utf16Encode = function (input, byteOrderMark) {
+    if (byteOrderMark === void 0) { byteOrderMark = true; }
+    var encoded = [];
+    if (byteOrderMark)
+        encoded.push(0xfeff);
+    for (var idx = 0, len = input.length; idx < len;) {
+        var codePoint = input.codePointAt(idx);
+        // Two byte encoding
+        if (codePoint < 0x010000) {
+            encoded.push(codePoint);
+            idx += 1;
+        }
+        // Four byte encoding (surrogate pair)
+        else if (codePoint < 0x110000) {
+            encoded.push(highSurrogate(codePoint), lowSurrogate(codePoint));
+            idx += 2;
+        }
+        // Should never reach this case
+        else
+            throw new Error("Invalid code point: 0x" + strings.toHexString(codePoint));
+    }
+    return new Uint16Array(encoded);
+};
+/**
+ * Returns `true` if the `codePoint` is within the
+ * Basic Multilingual Plane (BMP). Code points inside the BMP are not encoded
+ * with surrogate pairs.
+ * @param codePoint The code point to be evaluated.
+ *
+ * Reference: https://en.wikipedia.org/wiki/UTF-16#Description
+ */
+var isWithinBMP = function (codePoint) {
+    return codePoint >= 0 && codePoint <= 0xffff;
+};
+/**
+ * Returns `true` if the given `codePoint` is valid and must be represented
+ * with a surrogate pair when encoded.
+ * @param codePoint The code point to be evaluated.
+ *
+ * Reference: https://en.wikipedia.org/wiki/UTF-16#Description
+ */
+var hasSurrogates = function (codePoint) {
+    return codePoint >= 0x010000 && codePoint <= 0x10ffff;
+};
+// From Unicode 3.0 spec, section 3.7:
+//   http://unicode.org/versions/Unicode3.0.0/ch03.pdf
+var highSurrogate = function (codePoint) {
+    return Math.floor((codePoint - 0x10000) / 0x400) + 0xd800;
+};
+// From Unicode 3.0 spec, section 3.7:
+//   http://unicode.org/versions/Unicode3.0.0/ch03.pdf
+var lowSurrogate = function (codePoint) {
+    return ((codePoint - 0x10000) % 0x400) + 0xdc00;
+};
+var ByteOrder;
+(function (ByteOrder) {
+    ByteOrder["BigEndian"] = "BigEndian";
+    ByteOrder["LittleEndian"] = "LittleEndian";
+})(ByteOrder || (ByteOrder = {}));
+var REPLACEMENT = '�'.codePointAt(0);
+/**
+ * Decodes a Uint8Array of data to a string using UTF-16.
+ *
+ * Note that this function attempts to recover from erronous input by
+ * inserting the replacement character (�) to mark invalid code points
+ * and surrogate pairs.
+ *
+ * @param input A Uint8Array containing UTF-16 encoded data
+ * @param byteOrderMark Whether or not a byte order marker (BOM) should be read
+ *                      at the start of the encoding. (default `true`)
+ * @returns The decoded string.
+ */
+var utf16Decode = function (input, byteOrderMark) {
+    if (byteOrderMark === void 0) { byteOrderMark = true; }
+    // Need at least 2 bytes of data in UTF-16 encodings
+    if (input.length <= 1)
+        return String.fromCodePoint(REPLACEMENT);
+    var byteOrder = byteOrderMark ? readBOM(input) : ByteOrder.BigEndian;
+    // Skip byte order mark if needed
+    var idx = byteOrderMark ? 2 : 0;
+    var codePoints = [];
+    while (input.length - idx >= 2) {
+        var first = decodeValues(input[idx++], input[idx++], byteOrder);
+        if (isHighSurrogate(first)) {
+            if (input.length - idx < 2) {
+                // Need at least 2 bytes left for the low surrogate that is required
+                codePoints.push(REPLACEMENT);
+            }
+            else {
+                var second = decodeValues(input[idx++], input[idx++], byteOrder);
+                if (isLowSurrogate(second)) {
+                    codePoints.push(first, second);
+                }
+                else {
+                    // Low surrogates should always follow high surrogates
+                    codePoints.push(REPLACEMENT);
+                }
+            }
+        }
+        else if (isLowSurrogate(first)) {
+            // High surrogates should always come first since `decodeValues()`
+            // accounts for the byte ordering
+            idx += 2;
+            codePoints.push(REPLACEMENT);
+        }
+        else {
+            codePoints.push(first);
+        }
+    }
+    // There shouldn't be extra byte(s) left over
+    if (idx < input.length)
+        codePoints.push(REPLACEMENT);
+    return String.fromCodePoint.apply(String, codePoints);
+};
+/**
+ * Returns `true` if the given `codePoint` is a high surrogate.
+ * @param codePoint The code point to be evaluated.
+ *
+ * Reference: https://en.wikipedia.org/wiki/UTF-16#Description
+ */
+var isHighSurrogate = function (codePoint) {
+    return codePoint >= 0xd800 && codePoint <= 0xdbff;
+};
+/**
+ * Returns `true` if the given `codePoint` is a low surrogate.
+ * @param codePoint The code point to be evaluated.
+ *
+ * Reference: https://en.wikipedia.org/wiki/UTF-16#Description
+ */
+var isLowSurrogate = function (codePoint) {
+    return codePoint >= 0xdc00 && codePoint <= 0xdfff;
+};
+/**
+ * Decodes the given utf-16 values first and second using the specified
+ * byte order.
+ * @param first The first byte of the encoding.
+ * @param second The second byte of the encoding.
+ * @param byteOrder The byte order of the encoding.
+ * Reference: https://en.wikipedia.org/wiki/UTF-16#Examples
+ */
+var decodeValues = function (first, second, byteOrder) {
+    // Append the binary representation of the preceding byte by shifting the
+    // first one 8 to the left and than applying a bitwise or-operator to append
+    // the second one.
+    if (byteOrder === ByteOrder.LittleEndian)
+        return (second << 8) | first;
+    if (byteOrder === ByteOrder.BigEndian)
+        return (first << 8) | second;
+    throw new Error("Invalid byteOrder: " + byteOrder);
+};
+/**
+ * Returns whether the given array contains a byte order mark for the
+ * UTF-16BE or UTF-16LE encoding. If it has neither, BigEndian is assumed.
+ *
+ * Reference: https://en.wikipedia.org/wiki/Byte_order_mark#UTF-16
+ *
+ * @param bytes The byte array to be evaluated.
+ */
+// prettier-ignore
+var readBOM = function (bytes) { return (hasUtf16BigEndianBOM(bytes) ? ByteOrder.BigEndian
+    : hasUtf16LittleEndianBOM(bytes) ? ByteOrder.LittleEndian
+        : ByteOrder.BigEndian); };
+var hasUtf16BigEndianBOM = function (bytes) {
+    return bytes[0] === 0xfe && bytes[1] === 0xff;
+};
+var hasUtf16LittleEndianBOM = function (bytes) {
+    return bytes[0] === 0xff && bytes[1] === 0xfe;
+};
+var hasUtf16BOM = function (bytes) {
+    return hasUtf16BigEndianBOM(bytes) || hasUtf16LittleEndianBOM(bytes);
+};
+
+exports.hasSurrogates = hasSurrogates;
+exports.hasUtf16BOM = hasUtf16BOM;
+exports.highSurrogate = highSurrogate;
+exports.isWithinBMP = isWithinBMP;
+exports.lowSurrogate = lowSurrogate;
+exports.utf16Decode = utf16Decode;
+exports.utf16Encode = utf16Encode;