art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,60 @@
+import UPNG from '../../../@pdf-lib/upng/UPNG.js';
+
+var getImageType = function (ctype) {
+    if (ctype === 0)
+        return PngType.Greyscale;
+    if (ctype === 2)
+        return PngType.Truecolour;
+    if (ctype === 3)
+        return PngType.IndexedColour;
+    if (ctype === 4)
+        return PngType.GreyscaleWithAlpha;
+    if (ctype === 6)
+        return 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 };
+};
+var PngType;
+(function (PngType) {
+    PngType["Greyscale"] = "Greyscale";
+    PngType["Truecolour"] = "Truecolour";
+    PngType["IndexedColour"] = "IndexedColour";
+    PngType["GreyscaleWithAlpha"] = "GreyscaleWithAlpha";
+    PngType["TruecolourWithAlpha"] = "TruecolourWithAlpha";
+})(PngType || (PngType = {}));
+var PNG = /** @class */ (function () {
+    function PNG(pngData) {
+        var upng = UPNG.decode(pngData);
+        var frames = UPNG.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;
+}());
+
+export { PNG, PngType };

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

@@ -0,0 +1,20 @@
+/**
+ * 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;
+}());
+
+export { SimpleRNG };

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

@@ -0,0 +1,134 @@
+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 };
+};
+
+export { breakTextIntoLines, charAtIndex, charFromCode, charFromHexCode, charSplit, cleanText, copyStringIntoBuffer, escapeRegExp, escapedNewlineChars, findLastMatch, isNewlineChar, lineSplit, mergeLines, padStart, parseDate, toCharCode, toCodePoint, toHexString, toHexStringOfMinLength };

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

@@ -0,0 +1,239 @@
+import { toHexString } from './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" + 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);
+};
+
+export { hasSurrogates, hasUtf16BOM, highSurrogate, isWithinBMP, lowSurrogate, utf16Decode, utf16Encode };

package/dist/esm/node_modules/pdf-lib/es/utils/validators.js

@@ -0,0 +1,182 @@
+import { values } from './objects.js';
+
+/* tslint:disable:ban-types */
+var backtick = function (val) { return "`" + val + "`"; };
+var singleQuote = function (val) { return "'" + val + "'"; };
+// prettier-ignore
+var formatValue = function (value) {
+    var type = typeof value;
+    if (type === 'string')
+        return singleQuote(value);
+    else if (type === 'undefined')
+        return backtick(value);
+    else
+        return value;
+};
+var createValueErrorMsg = function (value, valueName, values) {
+    var allowedValues = new Array(values.length);
+    for (var idx = 0, len = values.length; idx < len; idx++) {
+        var v = values[idx];
+        allowedValues[idx] = formatValue(v);
+    }
+    var joinedValues = allowedValues.join(' or ');
+    // prettier-ignore
+    return backtick(valueName) + " must be one of " + joinedValues + ", but was actually " + formatValue(value);
+};
+var assertIsOneOf = function (value, valueName, allowedValues) {
+    if (!Array.isArray(allowedValues)) {
+        allowedValues = values(allowedValues);
+    }
+    for (var idx = 0, len = allowedValues.length; idx < len; idx++) {
+        if (value === allowedValues[idx])
+            return;
+    }
+    throw new TypeError(createValueErrorMsg(value, valueName, allowedValues));
+};
+var assertIsOneOfOrUndefined = function (value, valueName, allowedValues) {
+    if (!Array.isArray(allowedValues)) {
+        allowedValues = values(allowedValues);
+    }
+    assertIsOneOf(value, valueName, allowedValues.concat(undefined));
+};
+var assertIsSubset = function (values$1, valueName, allowedValues) {
+    if (!Array.isArray(allowedValues)) {
+        allowedValues = values(allowedValues);
+    }
+    for (var idx = 0, len = values$1.length; idx < len; idx++) {
+        assertIsOneOf(values$1[idx], valueName, allowedValues);
+    }
+};
+var getType = function (val) {
+    if (val === null)
+        return 'null';
+    if (val === undefined)
+        return 'undefined';
+    if (typeof val === 'string')
+        return 'string';
+    if (isNaN(val))
+        return 'NaN';
+    if (typeof val === 'number')
+        return 'number';
+    if (typeof val === 'boolean')
+        return 'boolean';
+    if (typeof val === 'symbol')
+        return 'symbol';
+    if (typeof val === 'bigint')
+        return 'bigint';
+    if (val.constructor && val.constructor.name)
+        return val.constructor.name;
+    if (val.name)
+        return val.name;
+    if (val.constructor)
+        return String(val.constructor);
+    return String(val);
+};
+var isType = function (value, type) {
+    if (type === 'null')
+        return value === null;
+    if (type === 'undefined')
+        return value === undefined;
+    if (type === 'string')
+        return typeof value === 'string';
+    if (type === 'number')
+        return typeof value === 'number' && !isNaN(value);
+    if (type === 'boolean')
+        return typeof value === 'boolean';
+    if (type === 'symbol')
+        return typeof value === 'symbol';
+    if (type === 'bigint')
+        return typeof value === 'bigint';
+    if (type === Date)
+        return value instanceof Date;
+    if (type === Array)
+        return value instanceof Array;
+    if (type === Uint8Array)
+        return value instanceof Uint8Array;
+    if (type === ArrayBuffer)
+        return value instanceof ArrayBuffer;
+    if (type === Function)
+        return value instanceof Function;
+    return value instanceof type[0];
+};
+var createTypeErrorMsg = function (value, valueName, types) {
+    var allowedTypes = new Array(types.length);
+    for (var idx = 0, len = types.length; idx < len; idx++) {
+        var type = types[idx];
+        if (type === 'null')
+            allowedTypes[idx] = backtick('null');
+        if (type === 'undefined')
+            allowedTypes[idx] = backtick('undefined');
+        if (type === 'string')
+            allowedTypes[idx] = backtick('string');
+        else if (type === 'number')
+            allowedTypes[idx] = backtick('number');
+        else if (type === 'boolean')
+            allowedTypes[idx] = backtick('boolean');
+        else if (type === 'symbol')
+            allowedTypes[idx] = backtick('symbol');
+        else if (type === 'bigint')
+            allowedTypes[idx] = backtick('bigint');
+        else if (type === Array)
+            allowedTypes[idx] = backtick('Array');
+        else if (type === Uint8Array)
+            allowedTypes[idx] = backtick('Uint8Array');
+        else if (type === ArrayBuffer)
+            allowedTypes[idx] = backtick('ArrayBuffer');
+        else
+            allowedTypes[idx] = backtick(type[1]);
+    }
+    var joinedTypes = allowedTypes.join(' or ');
+    // prettier-ignore
+    return backtick(valueName) + " must be of type " + joinedTypes + ", but was actually of type " + backtick(getType(value));
+};
+var assertIs = function (value, valueName, types) {
+    for (var idx = 0, len = types.length; idx < len; idx++) {
+        if (isType(value, types[idx]))
+            return;
+    }
+    throw new TypeError(createTypeErrorMsg(value, valueName, types));
+};
+var assertOrUndefined = function (value, valueName, types) {
+    assertIs(value, valueName, types.concat('undefined'));
+};
+var assertEachIs = function (values, valueName, types) {
+    for (var idx = 0, len = values.length; idx < len; idx++) {
+        assertIs(values[idx], valueName, types);
+    }
+};
+var assertRange = function (value, valueName, min, max) {
+    assertIs(value, valueName, ['number']);
+    assertIs(min, 'min', ['number']);
+    assertIs(max, 'max', ['number']);
+    max = Math.max(min, max);
+    if (value < min || value > max) {
+        // prettier-ignore
+        throw new Error(backtick(valueName) + " must be at least " + min + " and at most " + max + ", but was actually " + value);
+    }
+};
+var assertRangeOrUndefined = function (value, valueName, min, max) {
+    assertIs(value, valueName, ['number', 'undefined']);
+    if (typeof value === 'number')
+        assertRange(value, valueName, min, max);
+};
+var assertMultiple = function (value, valueName, multiplier) {
+    assertIs(value, valueName, ['number']);
+    if (value % multiplier !== 0) {
+        // prettier-ignore
+        throw new Error(backtick(valueName) + " must be a multiple of " + multiplier + ", but was actually " + value);
+    }
+};
+var assertInteger = function (value, valueName) {
+    if (!Number.isInteger(value)) {
+        throw new Error(backtick(valueName) + " must be an integer, but was actually " + value);
+    }
+};
+var assertPositive = function (value, valueName) {
+    if (![1, 0].includes(Math.sign(value))) {
+        // prettier-ignore
+        throw new Error(backtick(valueName) + " must be a positive number or 0, but was actually " + value);
+    }
+};
+
+export { assertEachIs, assertInteger, assertIs, assertIsOneOf, assertIsOneOfOrUndefined, assertIsSubset, assertMultiple, assertOrUndefined, assertPositive, assertRange, assertRangeOrUndefined, backtick, createTypeErrorMsg, createValueErrorMsg, getType, isType, singleQuote };