art-bd-ui 1.0.21 → 1.0.23

package/dist/cjs/node_modules/pdf-lib/es/core/structures/PDFPageLeaf.js

@@ -0,0 +1,209 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFArray = require('../objects/PDFArray.js');
+var PDFDict = require('../objects/PDFDict.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFNumber = require('../objects/PDFNumber.js');
+var PDFStream = require('../objects/PDFStream.js');
+
+var PDFPageLeaf = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFPageLeaf, _super);
+    function PDFPageLeaf(map, context, autoNormalizeCTM) {
+        if (autoNormalizeCTM === void 0) { autoNormalizeCTM = true; }
+        var _this = _super.call(this, map, context) || this;
+        _this.normalized = false;
+        _this.autoNormalizeCTM = autoNormalizeCTM;
+        return _this;
+    }
+    PDFPageLeaf.prototype.clone = function (context) {
+        var clone = PDFPageLeaf.fromMapWithContext(new Map(), context || this.context, this.autoNormalizeCTM);
+        var entries = this.entries();
+        for (var idx = 0, len = entries.length; idx < len; idx++) {
+            var _a = entries[idx], key = _a[0], value = _a[1];
+            clone.set(key, value);
+        }
+        return clone;
+    };
+    PDFPageLeaf.prototype.Parent = function () {
+        return this.lookupMaybe(PDFName.default.Parent, PDFDict.default);
+    };
+    PDFPageLeaf.prototype.Contents = function () {
+        return this.lookup(PDFName.default.of('Contents'));
+    };
+    PDFPageLeaf.prototype.Annots = function () {
+        return this.lookupMaybe(PDFName.default.Annots, PDFArray.default);
+    };
+    PDFPageLeaf.prototype.BleedBox = function () {
+        return this.lookupMaybe(PDFName.default.BleedBox, PDFArray.default);
+    };
+    PDFPageLeaf.prototype.TrimBox = function () {
+        return this.lookupMaybe(PDFName.default.TrimBox, PDFArray.default);
+    };
+    PDFPageLeaf.prototype.ArtBox = function () {
+        return this.lookupMaybe(PDFName.default.ArtBox, PDFArray.default);
+    };
+    PDFPageLeaf.prototype.Resources = function () {
+        var dictOrRef = this.getInheritableAttribute(PDFName.default.Resources);
+        return this.context.lookupMaybe(dictOrRef, PDFDict.default);
+    };
+    PDFPageLeaf.prototype.MediaBox = function () {
+        var arrayOrRef = this.getInheritableAttribute(PDFName.default.MediaBox);
+        return this.context.lookup(arrayOrRef, PDFArray.default);
+    };
+    PDFPageLeaf.prototype.CropBox = function () {
+        var arrayOrRef = this.getInheritableAttribute(PDFName.default.CropBox);
+        return this.context.lookupMaybe(arrayOrRef, PDFArray.default);
+    };
+    PDFPageLeaf.prototype.Rotate = function () {
+        var numberOrRef = this.getInheritableAttribute(PDFName.default.Rotate);
+        return this.context.lookupMaybe(numberOrRef, PDFNumber.default);
+    };
+    PDFPageLeaf.prototype.getInheritableAttribute = function (name) {
+        var attribute;
+        this.ascend(function (node) {
+            if (!attribute)
+                attribute = node.get(name);
+        });
+        return attribute;
+    };
+    PDFPageLeaf.prototype.setParent = function (parentRef) {
+        this.set(PDFName.default.Parent, parentRef);
+    };
+    PDFPageLeaf.prototype.addContentStream = function (contentStreamRef) {
+        var Contents = this.normalizedEntries().Contents || this.context.obj([]);
+        this.set(PDFName.default.Contents, Contents);
+        Contents.push(contentStreamRef);
+    };
+    PDFPageLeaf.prototype.wrapContentStreams = function (startStream, endStream) {
+        var Contents = this.Contents();
+        if (Contents instanceof PDFArray.default) {
+            Contents.insert(0, startStream);
+            Contents.push(endStream);
+            return true;
+        }
+        return false;
+    };
+    PDFPageLeaf.prototype.addAnnot = function (annotRef) {
+        var Annots = this.normalizedEntries().Annots;
+        Annots.push(annotRef);
+    };
+    PDFPageLeaf.prototype.removeAnnot = function (annotRef) {
+        var Annots = this.normalizedEntries().Annots;
+        var index = Annots.indexOf(annotRef);
+        if (index !== undefined) {
+            Annots.remove(index);
+        }
+    };
+    PDFPageLeaf.prototype.setFontDictionary = function (name, fontDictRef) {
+        var Font = this.normalizedEntries().Font;
+        Font.set(name, fontDictRef);
+    };
+    PDFPageLeaf.prototype.newFontDictionaryKey = function (tag) {
+        var Font = this.normalizedEntries().Font;
+        return Font.uniqueKey(tag);
+    };
+    PDFPageLeaf.prototype.newFontDictionary = function (tag, fontDictRef) {
+        var key = this.newFontDictionaryKey(tag);
+        this.setFontDictionary(key, fontDictRef);
+        return key;
+    };
+    PDFPageLeaf.prototype.setXObject = function (name, xObjectRef) {
+        var XObject = this.normalizedEntries().XObject;
+        XObject.set(name, xObjectRef);
+    };
+    PDFPageLeaf.prototype.newXObjectKey = function (tag) {
+        var XObject = this.normalizedEntries().XObject;
+        return XObject.uniqueKey(tag);
+    };
+    PDFPageLeaf.prototype.newXObject = function (tag, xObjectRef) {
+        var key = this.newXObjectKey(tag);
+        this.setXObject(key, xObjectRef);
+        return key;
+    };
+    PDFPageLeaf.prototype.setExtGState = function (name, extGStateRef) {
+        var ExtGState = this.normalizedEntries().ExtGState;
+        ExtGState.set(name, extGStateRef);
+    };
+    PDFPageLeaf.prototype.newExtGStateKey = function (tag) {
+        var ExtGState = this.normalizedEntries().ExtGState;
+        return ExtGState.uniqueKey(tag);
+    };
+    PDFPageLeaf.prototype.newExtGState = function (tag, extGStateRef) {
+        var key = this.newExtGStateKey(tag);
+        this.setExtGState(key, extGStateRef);
+        return key;
+    };
+    PDFPageLeaf.prototype.ascend = function (visitor) {
+        visitor(this);
+        var Parent = this.Parent();
+        if (Parent)
+            Parent.ascend(visitor);
+    };
+    PDFPageLeaf.prototype.normalize = function () {
+        if (this.normalized)
+            return;
+        var context = this.context;
+        var contentsRef = this.get(PDFName.default.Contents);
+        var contents = this.context.lookup(contentsRef);
+        if (contents instanceof PDFStream.default) {
+            this.set(PDFName.default.Contents, context.obj([contentsRef]));
+        }
+        if (this.autoNormalizeCTM) {
+            this.wrapContentStreams(this.context.getPushGraphicsStateContentStream(), this.context.getPopGraphicsStateContentStream());
+        }
+        // TODO: Clone `Resources` if it is inherited
+        var dictOrRef = this.getInheritableAttribute(PDFName.default.Resources);
+        var Resources = context.lookupMaybe(dictOrRef, PDFDict.default) || context.obj({});
+        this.set(PDFName.default.Resources, Resources);
+        // TODO: Clone `Font` if it is inherited
+        var Font = Resources.lookupMaybe(PDFName.default.Font, PDFDict.default) || context.obj({});
+        Resources.set(PDFName.default.Font, Font);
+        // TODO: Clone `XObject` if it is inherited
+        var XObject = Resources.lookupMaybe(PDFName.default.XObject, PDFDict.default) || context.obj({});
+        Resources.set(PDFName.default.XObject, XObject);
+        // TODO: Clone `ExtGState` if it is inherited
+        var ExtGState = Resources.lookupMaybe(PDFName.default.ExtGState, PDFDict.default) || context.obj({});
+        Resources.set(PDFName.default.ExtGState, ExtGState);
+        var Annots = this.Annots() || context.obj([]);
+        this.set(PDFName.default.Annots, Annots);
+        this.normalized = true;
+    };
+    PDFPageLeaf.prototype.normalizedEntries = function () {
+        this.normalize();
+        var Annots = this.Annots();
+        var Resources = this.Resources();
+        var Contents = this.Contents();
+        return {
+            Annots: Annots,
+            Resources: Resources,
+            Contents: Contents,
+            Font: Resources.lookup(PDFName.default.Font, PDFDict.default),
+            XObject: Resources.lookup(PDFName.default.XObject, PDFDict.default),
+            ExtGState: Resources.lookup(PDFName.default.ExtGState, PDFDict.default),
+        };
+    };
+    PDFPageLeaf.InheritableEntries = [
+        'Resources',
+        'MediaBox',
+        'CropBox',
+        'Rotate',
+    ];
+    PDFPageLeaf.withContextAndParent = function (context, parent) {
+        var dict = new Map();
+        dict.set(PDFName.default.Type, PDFName.default.Page);
+        dict.set(PDFName.default.Parent, parent);
+        dict.set(PDFName.default.Resources, context.obj({}));
+        dict.set(PDFName.default.MediaBox, context.obj([0, 0, 612, 792]));
+        return new PDFPageLeaf(dict, context, false);
+    };
+    PDFPageLeaf.fromMapWithContext = function (map, context, autoNormalizeCTM) {
+        if (autoNormalizeCTM === void 0) { autoNormalizeCTM = true; }
+        return new PDFPageLeaf(map, context, autoNormalizeCTM);
+    };
+    return PDFPageLeaf;
+}(PDFDict.default));
+
+exports.default = PDFPageLeaf;

package/dist/cjs/node_modules/pdf-lib/es/core/structures/PDFPageTree.js

@@ -0,0 +1,180 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFArray = require('../objects/PDFArray.js');
+var PDFDict = require('../objects/PDFDict.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFNumber = require('../objects/PDFNumber.js');
+var PDFPageLeaf = require('./PDFPageLeaf.js');
+var errors = require('../errors.js');
+
+var PDFPageTree = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFPageTree, _super);
+    function PDFPageTree() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFPageTree.prototype.Parent = function () {
+        return this.lookup(PDFName.default.of('Parent'));
+    };
+    PDFPageTree.prototype.Kids = function () {
+        return this.lookup(PDFName.default.of('Kids'), PDFArray.default);
+    };
+    PDFPageTree.prototype.Count = function () {
+        return this.lookup(PDFName.default.of('Count'), PDFNumber.default);
+    };
+    PDFPageTree.prototype.pushTreeNode = function (treeRef) {
+        var Kids = this.Kids();
+        Kids.push(treeRef);
+    };
+    PDFPageTree.prototype.pushLeafNode = function (leafRef) {
+        var Kids = this.Kids();
+        this.insertLeafKid(Kids.size(), leafRef);
+    };
+    /**
+     * Inserts the given ref as a leaf node of this page tree at the specified
+     * index (zero-based). Also increments the `Count` of each page tree in the
+     * hierarchy to accomodate the new page.
+     *
+     * Returns the ref of the PDFPageTree node into which `leafRef` was inserted,
+     * or `undefined` if it was inserted into the root node (the PDFPageTree upon
+     * which the method was first called).
+     */
+    PDFPageTree.prototype.insertLeafNode = function (leafRef, targetIndex) {
+        var Kids = this.Kids();
+        var Count = this.Count().asNumber();
+        if (targetIndex > Count) {
+            throw new errors.InvalidTargetIndexError(targetIndex, Count);
+        }
+        var leafsRemainingUntilTarget = targetIndex;
+        for (var idx = 0, len = Kids.size(); idx < len; idx++) {
+            if (leafsRemainingUntilTarget === 0) {
+                // Insert page and return
+                this.insertLeafKid(idx, leafRef);
+                return undefined;
+            }
+            var kidRef = Kids.get(idx);
+            var kid = this.context.lookup(kidRef);
+            if (kid instanceof PDFPageTree) {
+                if (kid.Count().asNumber() > leafsRemainingUntilTarget) {
+                    // Dig in
+                    return (kid.insertLeafNode(leafRef, leafsRemainingUntilTarget) || kidRef);
+                }
+                else {
+                    // Move on
+                    leafsRemainingUntilTarget -= kid.Count().asNumber();
+                }
+            }
+            if (kid instanceof PDFPageLeaf.default) {
+                // Move on
+                leafsRemainingUntilTarget -= 1;
+            }
+        }
+        if (leafsRemainingUntilTarget === 0) {
+            // Insert page at the end and return
+            this.insertLeafKid(Kids.size(), leafRef);
+            return undefined;
+        }
+        // Should never get here if `targetIndex` is valid
+        throw new errors.CorruptPageTreeError(targetIndex, 'insertLeafNode');
+    };
+    /**
+     * Removes the leaf node at the specified index (zero-based) from this page
+     * tree. Also decrements the `Count` of each page tree in the hierarchy to
+     * account for the removed page.
+     *
+     * If `prune` is true, then intermediate tree nodes will be removed from the
+     * tree if they contain 0 children after the leaf node is removed.
+     */
+    PDFPageTree.prototype.removeLeafNode = function (targetIndex, prune) {
+        if (prune === void 0) { prune = true; }
+        var Kids = this.Kids();
+        var Count = this.Count().asNumber();
+        if (targetIndex >= Count) {
+            throw new errors.InvalidTargetIndexError(targetIndex, Count);
+        }
+        var leafsRemainingUntilTarget = targetIndex;
+        for (var idx = 0, len = Kids.size(); idx < len; idx++) {
+            var kidRef = Kids.get(idx);
+            var kid = this.context.lookup(kidRef);
+            if (kid instanceof PDFPageTree) {
+                if (kid.Count().asNumber() > leafsRemainingUntilTarget) {
+                    // Dig in
+                    kid.removeLeafNode(leafsRemainingUntilTarget, prune);
+                    if (prune && kid.Kids().size() === 0)
+                        Kids.remove(idx);
+                    return;
+                }
+                else {
+                    // Move on
+                    leafsRemainingUntilTarget -= kid.Count().asNumber();
+                }
+            }
+            if (kid instanceof PDFPageLeaf.default) {
+                if (leafsRemainingUntilTarget === 0) {
+                    // Remove page and return
+                    this.removeKid(idx);
+                    return;
+                }
+                else {
+                    // Move on
+                    leafsRemainingUntilTarget -= 1;
+                }
+            }
+        }
+        // Should never get here if `targetIndex` is valid
+        throw new errors.CorruptPageTreeError(targetIndex, 'removeLeafNode');
+    };
+    PDFPageTree.prototype.ascend = function (visitor) {
+        visitor(this);
+        var Parent = this.Parent();
+        if (Parent)
+            Parent.ascend(visitor);
+    };
+    /** Performs a Post-Order traversal of this page tree */
+    PDFPageTree.prototype.traverse = function (visitor) {
+        var Kids = this.Kids();
+        for (var idx = 0, len = Kids.size(); idx < len; idx++) {
+            var kidRef = Kids.get(idx);
+            var kid = this.context.lookup(kidRef);
+            if (kid instanceof PDFPageTree)
+                kid.traverse(visitor);
+            visitor(kid, kidRef);
+        }
+    };
+    PDFPageTree.prototype.insertLeafKid = function (kidIdx, leafRef) {
+        var Kids = this.Kids();
+        this.ascend(function (node) {
+            var newCount = node.Count().asNumber() + 1;
+            node.set(PDFName.default.of('Count'), PDFNumber.default.of(newCount));
+        });
+        Kids.insert(kidIdx, leafRef);
+    };
+    PDFPageTree.prototype.removeKid = function (kidIdx) {
+        var Kids = this.Kids();
+        var kid = Kids.lookup(kidIdx);
+        if (kid instanceof PDFPageLeaf.default) {
+            this.ascend(function (node) {
+                var newCount = node.Count().asNumber() - 1;
+                node.set(PDFName.default.of('Count'), PDFNumber.default.of(newCount));
+            });
+        }
+        Kids.remove(kidIdx);
+    };
+    PDFPageTree.withContext = function (context, parent) {
+        var dict = new Map();
+        dict.set(PDFName.default.of('Type'), PDFName.default.of('Pages'));
+        dict.set(PDFName.default.of('Kids'), context.obj([]));
+        dict.set(PDFName.default.of('Count'), context.obj(0));
+        if (parent)
+            dict.set(PDFName.default.of('Parent'), parent);
+        return new PDFPageTree(dict, context);
+    };
+    PDFPageTree.fromMapWithContext = function (map, context) {
+        return new PDFPageTree(map, context);
+    };
+    return PDFPageTree;
+}(PDFDict.default));
+
+exports.default = PDFPageTree;

package/dist/cjs/node_modules/pdf-lib/es/core/syntax/CharCodes.js

@@ -0,0 +1,68 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var CharCodes;
+(function (CharCodes) {
+    CharCodes[CharCodes["Null"] = 0] = "Null";
+    CharCodes[CharCodes["Backspace"] = 8] = "Backspace";
+    CharCodes[CharCodes["Tab"] = 9] = "Tab";
+    CharCodes[CharCodes["Newline"] = 10] = "Newline";
+    CharCodes[CharCodes["FormFeed"] = 12] = "FormFeed";
+    CharCodes[CharCodes["CarriageReturn"] = 13] = "CarriageReturn";
+    CharCodes[CharCodes["Space"] = 32] = "Space";
+    CharCodes[CharCodes["ExclamationPoint"] = 33] = "ExclamationPoint";
+    CharCodes[CharCodes["Hash"] = 35] = "Hash";
+    CharCodes[CharCodes["Percent"] = 37] = "Percent";
+    CharCodes[CharCodes["LeftParen"] = 40] = "LeftParen";
+    CharCodes[CharCodes["RightParen"] = 41] = "RightParen";
+    CharCodes[CharCodes["Plus"] = 43] = "Plus";
+    CharCodes[CharCodes["Minus"] = 45] = "Minus";
+    CharCodes[CharCodes["Dash"] = 45] = "Dash";
+    CharCodes[CharCodes["Period"] = 46] = "Period";
+    CharCodes[CharCodes["ForwardSlash"] = 47] = "ForwardSlash";
+    CharCodes[CharCodes["Zero"] = 48] = "Zero";
+    CharCodes[CharCodes["One"] = 49] = "One";
+    CharCodes[CharCodes["Two"] = 50] = "Two";
+    CharCodes[CharCodes["Three"] = 51] = "Three";
+    CharCodes[CharCodes["Four"] = 52] = "Four";
+    CharCodes[CharCodes["Five"] = 53] = "Five";
+    CharCodes[CharCodes["Six"] = 54] = "Six";
+    CharCodes[CharCodes["Seven"] = 55] = "Seven";
+    CharCodes[CharCodes["Eight"] = 56] = "Eight";
+    CharCodes[CharCodes["Nine"] = 57] = "Nine";
+    CharCodes[CharCodes["LessThan"] = 60] = "LessThan";
+    CharCodes[CharCodes["GreaterThan"] = 62] = "GreaterThan";
+    CharCodes[CharCodes["A"] = 65] = "A";
+    CharCodes[CharCodes["D"] = 68] = "D";
+    CharCodes[CharCodes["E"] = 69] = "E";
+    CharCodes[CharCodes["F"] = 70] = "F";
+    CharCodes[CharCodes["O"] = 79] = "O";
+    CharCodes[CharCodes["P"] = 80] = "P";
+    CharCodes[CharCodes["R"] = 82] = "R";
+    CharCodes[CharCodes["LeftSquareBracket"] = 91] = "LeftSquareBracket";
+    CharCodes[CharCodes["BackSlash"] = 92] = "BackSlash";
+    CharCodes[CharCodes["RightSquareBracket"] = 93] = "RightSquareBracket";
+    CharCodes[CharCodes["a"] = 97] = "a";
+    CharCodes[CharCodes["b"] = 98] = "b";
+    CharCodes[CharCodes["d"] = 100] = "d";
+    CharCodes[CharCodes["e"] = 101] = "e";
+    CharCodes[CharCodes["f"] = 102] = "f";
+    CharCodes[CharCodes["i"] = 105] = "i";
+    CharCodes[CharCodes["j"] = 106] = "j";
+    CharCodes[CharCodes["l"] = 108] = "l";
+    CharCodes[CharCodes["m"] = 109] = "m";
+    CharCodes[CharCodes["n"] = 110] = "n";
+    CharCodes[CharCodes["o"] = 111] = "o";
+    CharCodes[CharCodes["r"] = 114] = "r";
+    CharCodes[CharCodes["s"] = 115] = "s";
+    CharCodes[CharCodes["t"] = 116] = "t";
+    CharCodes[CharCodes["u"] = 117] = "u";
+    CharCodes[CharCodes["x"] = 120] = "x";
+    CharCodes[CharCodes["LeftCurly"] = 123] = "LeftCurly";
+    CharCodes[CharCodes["RightCurly"] = 125] = "RightCurly";
+    CharCodes[CharCodes["Tilde"] = 126] = "Tilde";
+})(CharCodes || (CharCodes = {}));
+var CharCodes$1 = CharCodes;
+
+exports.default = CharCodes$1;

package/dist/cjs/node_modules/pdf-lib/es/core/syntax/Delimiters.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var CharCodes = require('./CharCodes.js');
+
+var IsDelimiter = new Uint8Array(256);
+IsDelimiter[CharCodes.default.LeftParen] = 1;
+IsDelimiter[CharCodes.default.RightParen] = 1;
+IsDelimiter[CharCodes.default.LessThan] = 1;
+IsDelimiter[CharCodes.default.GreaterThan] = 1;
+IsDelimiter[CharCodes.default.LeftSquareBracket] = 1;
+IsDelimiter[CharCodes.default.RightSquareBracket] = 1;
+IsDelimiter[CharCodes.default.LeftCurly] = 1;
+IsDelimiter[CharCodes.default.RightCurly] = 1;
+IsDelimiter[CharCodes.default.ForwardSlash] = 1;
+IsDelimiter[CharCodes.default.Percent] = 1;
+
+exports.IsDelimiter = IsDelimiter;

package/dist/cjs/node_modules/pdf-lib/es/core/syntax/Irregular.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var CharCodes = require('./CharCodes.js');
+var Delimiters = require('./Delimiters.js');
+var Whitespace = require('./Whitespace.js');
+
+var IsIrregular = new Uint8Array(256);
+for (var idx = 0, len = 256; idx < len; idx++) {
+    IsIrregular[idx] = Whitespace.IsWhitespace[idx] || Delimiters.IsDelimiter[idx] ? 1 : 0;
+}
+IsIrregular[CharCodes.default.Hash] = 1;
+
+exports.IsIrregular = IsIrregular;

package/dist/cjs/node_modules/pdf-lib/es/core/syntax/Keywords.js

@@ -0,0 +1,85 @@
+'use strict';
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var CharCodes = require('./CharCodes.js');
+
+var Space = CharCodes.default.Space, CarriageReturn = CharCodes.default.CarriageReturn, Newline = CharCodes.default.Newline;
+var stream = [
+    CharCodes.default.s,
+    CharCodes.default.t,
+    CharCodes.default.r,
+    CharCodes.default.e,
+    CharCodes.default.a,
+    CharCodes.default.m,
+];
+var endstream = [
+    CharCodes.default.e,
+    CharCodes.default.n,
+    CharCodes.default.d,
+    CharCodes.default.s,
+    CharCodes.default.t,
+    CharCodes.default.r,
+    CharCodes.default.e,
+    CharCodes.default.a,
+    CharCodes.default.m,
+];
+var Keywords = {
+    header: [
+        CharCodes.default.Percent,
+        CharCodes.default.P,
+        CharCodes.default.D,
+        CharCodes.default.F,
+        CharCodes.default.Dash,
+    ],
+    eof: [
+        CharCodes.default.Percent,
+        CharCodes.default.Percent,
+        CharCodes.default.E,
+        CharCodes.default.O,
+        CharCodes.default.F,
+    ],
+    obj: [CharCodes.default.o, CharCodes.default.b, CharCodes.default.j],
+    endobj: [
+        CharCodes.default.e,
+        CharCodes.default.n,
+        CharCodes.default.d,
+        CharCodes.default.o,
+        CharCodes.default.b,
+        CharCodes.default.j,
+    ],
+    xref: [CharCodes.default.x, CharCodes.default.r, CharCodes.default.e, CharCodes.default.f],
+    trailer: [
+        CharCodes.default.t,
+        CharCodes.default.r,
+        CharCodes.default.a,
+        CharCodes.default.i,
+        CharCodes.default.l,
+        CharCodes.default.e,
+        CharCodes.default.r,
+    ],
+    startxref: [
+        CharCodes.default.s,
+        CharCodes.default.t,
+        CharCodes.default.a,
+        CharCodes.default.r,
+        CharCodes.default.t,
+        CharCodes.default.x,
+        CharCodes.default.r,
+        CharCodes.default.e,
+        CharCodes.default.f,
+    ],
+    true: [CharCodes.default.t, CharCodes.default.r, CharCodes.default.u, CharCodes.default.e],
+    false: [CharCodes.default.f, CharCodes.default.a, CharCodes.default.l, CharCodes.default.s, CharCodes.default.e],
+    null: [CharCodes.default.n, CharCodes.default.u, CharCodes.default.l, CharCodes.default.l],
+    stream: stream,
+    streamEOF1: tslib_es6.__spreadArrays(stream, [Space, CarriageReturn, Newline]),
+    streamEOF2: tslib_es6.__spreadArrays(stream, [CarriageReturn, Newline]),
+    streamEOF3: tslib_es6.__spreadArrays(stream, [CarriageReturn]),
+    streamEOF4: tslib_es6.__spreadArrays(stream, [Newline]),
+    endstream: endstream,
+    EOF1endstream: tslib_es6.__spreadArrays([CarriageReturn, Newline], endstream),
+    EOF2endstream: tslib_es6.__spreadArrays([CarriageReturn], endstream),
+    EOF3endstream: tslib_es6.__spreadArrays([Newline], endstream),
+};
+
+exports.Keywords = Keywords;

package/dist/cjs/node_modules/pdf-lib/es/core/syntax/Numeric.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var CharCodes = require('./CharCodes.js');
+
+var IsDigit = new Uint8Array(256);
+IsDigit[CharCodes.default.Zero] = 1;
+IsDigit[CharCodes.default.One] = 1;
+IsDigit[CharCodes.default.Two] = 1;
+IsDigit[CharCodes.default.Three] = 1;
+IsDigit[CharCodes.default.Four] = 1;
+IsDigit[CharCodes.default.Five] = 1;
+IsDigit[CharCodes.default.Six] = 1;
+IsDigit[CharCodes.default.Seven] = 1;
+IsDigit[CharCodes.default.Eight] = 1;
+IsDigit[CharCodes.default.Nine] = 1;
+var IsNumericPrefix = new Uint8Array(256);
+IsNumericPrefix[CharCodes.default.Period] = 1;
+IsNumericPrefix[CharCodes.default.Plus] = 1;
+IsNumericPrefix[CharCodes.default.Minus] = 1;
+var IsNumeric = new Uint8Array(256);
+for (var idx = 0, len = 256; idx < len; idx++) {
+    IsNumeric[idx] = IsDigit[idx] || IsNumericPrefix[idx] ? 1 : 0;
+}
+
+exports.IsDigit = IsDigit;
+exports.IsNumeric = IsNumeric;
+exports.IsNumericPrefix = IsNumericPrefix;

package/dist/cjs/node_modules/pdf-lib/es/core/syntax/Whitespace.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var CharCodes = require('./CharCodes.js');
+
+var IsWhitespace = new Uint8Array(256);
+IsWhitespace[CharCodes.default.Null] = 1;
+IsWhitespace[CharCodes.default.Tab] = 1;
+IsWhitespace[CharCodes.default.Newline] = 1;
+IsWhitespace[CharCodes.default.FormFeed] = 1;
+IsWhitespace[CharCodes.default.CarriageReturn] = 1;
+IsWhitespace[CharCodes.default.Space] = 1;
+
+exports.IsWhitespace = IsWhitespace;