art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,205 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFArray from '../objects/PDFArray.js';
+import PDFDict from '../objects/PDFDict.js';
+import PDFName from '../objects/PDFName.js';
+import PDFNumber from '../objects/PDFNumber.js';
+import PDFStream from '../objects/PDFStream.js';
+
+var PDFPageLeaf = /** @class */ (function (_super) {
+    __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.Parent, PDFDict);
+    };
+    PDFPageLeaf.prototype.Contents = function () {
+        return this.lookup(PDFName.of('Contents'));
+    };
+    PDFPageLeaf.prototype.Annots = function () {
+        return this.lookupMaybe(PDFName.Annots, PDFArray);
+    };
+    PDFPageLeaf.prototype.BleedBox = function () {
+        return this.lookupMaybe(PDFName.BleedBox, PDFArray);
+    };
+    PDFPageLeaf.prototype.TrimBox = function () {
+        return this.lookupMaybe(PDFName.TrimBox, PDFArray);
+    };
+    PDFPageLeaf.prototype.ArtBox = function () {
+        return this.lookupMaybe(PDFName.ArtBox, PDFArray);
+    };
+    PDFPageLeaf.prototype.Resources = function () {
+        var dictOrRef = this.getInheritableAttribute(PDFName.Resources);
+        return this.context.lookupMaybe(dictOrRef, PDFDict);
+    };
+    PDFPageLeaf.prototype.MediaBox = function () {
+        var arrayOrRef = this.getInheritableAttribute(PDFName.MediaBox);
+        return this.context.lookup(arrayOrRef, PDFArray);
+    };
+    PDFPageLeaf.prototype.CropBox = function () {
+        var arrayOrRef = this.getInheritableAttribute(PDFName.CropBox);
+        return this.context.lookupMaybe(arrayOrRef, PDFArray);
+    };
+    PDFPageLeaf.prototype.Rotate = function () {
+        var numberOrRef = this.getInheritableAttribute(PDFName.Rotate);
+        return this.context.lookupMaybe(numberOrRef, PDFNumber);
+    };
+    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.Parent, parentRef);
+    };
+    PDFPageLeaf.prototype.addContentStream = function (contentStreamRef) {
+        var Contents = this.normalizedEntries().Contents || this.context.obj([]);
+        this.set(PDFName.Contents, Contents);
+        Contents.push(contentStreamRef);
+    };
+    PDFPageLeaf.prototype.wrapContentStreams = function (startStream, endStream) {
+        var Contents = this.Contents();
+        if (Contents instanceof PDFArray) {
+            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.Contents);
+        var contents = this.context.lookup(contentsRef);
+        if (contents instanceof PDFStream) {
+            this.set(PDFName.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.Resources);
+        var Resources = context.lookupMaybe(dictOrRef, PDFDict) || context.obj({});
+        this.set(PDFName.Resources, Resources);
+        // TODO: Clone `Font` if it is inherited
+        var Font = Resources.lookupMaybe(PDFName.Font, PDFDict) || context.obj({});
+        Resources.set(PDFName.Font, Font);
+        // TODO: Clone `XObject` if it is inherited
+        var XObject = Resources.lookupMaybe(PDFName.XObject, PDFDict) || context.obj({});
+        Resources.set(PDFName.XObject, XObject);
+        // TODO: Clone `ExtGState` if it is inherited
+        var ExtGState = Resources.lookupMaybe(PDFName.ExtGState, PDFDict) || context.obj({});
+        Resources.set(PDFName.ExtGState, ExtGState);
+        var Annots = this.Annots() || context.obj([]);
+        this.set(PDFName.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.Font, PDFDict),
+            XObject: Resources.lookup(PDFName.XObject, PDFDict),
+            ExtGState: Resources.lookup(PDFName.ExtGState, PDFDict),
+        };
+    };
+    PDFPageLeaf.InheritableEntries = [
+        'Resources',
+        'MediaBox',
+        'CropBox',
+        'Rotate',
+    ];
+    PDFPageLeaf.withContextAndParent = function (context, parent) {
+        var dict = new Map();
+        dict.set(PDFName.Type, PDFName.Page);
+        dict.set(PDFName.Parent, parent);
+        dict.set(PDFName.Resources, context.obj({}));
+        dict.set(PDFName.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));
+
+export { PDFPageLeaf as default };

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

@@ -0,0 +1,176 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFArray from '../objects/PDFArray.js';
+import PDFDict from '../objects/PDFDict.js';
+import PDFName from '../objects/PDFName.js';
+import PDFNumber from '../objects/PDFNumber.js';
+import PDFPageLeaf from './PDFPageLeaf.js';
+import { InvalidTargetIndexError, CorruptPageTreeError } from '../errors.js';
+
+var PDFPageTree = /** @class */ (function (_super) {
+    __extends(PDFPageTree, _super);
+    function PDFPageTree() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFPageTree.prototype.Parent = function () {
+        return this.lookup(PDFName.of('Parent'));
+    };
+    PDFPageTree.prototype.Kids = function () {
+        return this.lookup(PDFName.of('Kids'), PDFArray);
+    };
+    PDFPageTree.prototype.Count = function () {
+        return this.lookup(PDFName.of('Count'), PDFNumber);
+    };
+    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 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) {
+                // 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 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 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) {
+                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 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.of('Count'), PDFNumber.of(newCount));
+        });
+        Kids.insert(kidIdx, leafRef);
+    };
+    PDFPageTree.prototype.removeKid = function (kidIdx) {
+        var Kids = this.Kids();
+        var kid = Kids.lookup(kidIdx);
+        if (kid instanceof PDFPageLeaf) {
+            this.ascend(function (node) {
+                var newCount = node.Count().asNumber() - 1;
+                node.set(PDFName.of('Count'), PDFNumber.of(newCount));
+            });
+        }
+        Kids.remove(kidIdx);
+    };
+    PDFPageTree.withContext = function (context, parent) {
+        var dict = new Map();
+        dict.set(PDFName.of('Type'), PDFName.of('Pages'));
+        dict.set(PDFName.of('Kids'), context.obj([]));
+        dict.set(PDFName.of('Count'), context.obj(0));
+        if (parent)
+            dict.set(PDFName.of('Parent'), parent);
+        return new PDFPageTree(dict, context);
+    };
+    PDFPageTree.fromMapWithContext = function (map, context) {
+        return new PDFPageTree(map, context);
+    };
+    return PDFPageTree;
+}(PDFDict));
+
+export { PDFPageTree as default };

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

@@ -0,0 +1,64 @@
+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;
+
+export { CharCodes$1 as default };

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

@@ -0,0 +1,15 @@
+import CharCodes from './CharCodes.js';
+
+var IsDelimiter = new Uint8Array(256);
+IsDelimiter[CharCodes.LeftParen] = 1;
+IsDelimiter[CharCodes.RightParen] = 1;
+IsDelimiter[CharCodes.LessThan] = 1;
+IsDelimiter[CharCodes.GreaterThan] = 1;
+IsDelimiter[CharCodes.LeftSquareBracket] = 1;
+IsDelimiter[CharCodes.RightSquareBracket] = 1;
+IsDelimiter[CharCodes.LeftCurly] = 1;
+IsDelimiter[CharCodes.RightCurly] = 1;
+IsDelimiter[CharCodes.ForwardSlash] = 1;
+IsDelimiter[CharCodes.Percent] = 1;
+
+export { IsDelimiter };

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

@@ -0,0 +1,11 @@
+import CharCodes from './CharCodes.js';
+import { IsDelimiter } from './Delimiters.js';
+import { IsWhitespace } from './Whitespace.js';
+
+var IsIrregular = new Uint8Array(256);
+for (var idx = 0, len = 256; idx < len; idx++) {
+    IsIrregular[idx] = IsWhitespace[idx] || IsDelimiter[idx] ? 1 : 0;
+}
+IsIrregular[CharCodes.Hash] = 1;
+
+export { IsIrregular };

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

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

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

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

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

@@ -0,0 +1,11 @@
+import CharCodes from './CharCodes.js';
+
+var IsWhitespace = new Uint8Array(256);
+IsWhitespace[CharCodes.Null] = 1;
+IsWhitespace[CharCodes.Tab] = 1;
+IsWhitespace[CharCodes.Newline] = 1;
+IsWhitespace[CharCodes.FormFeed] = 1;
+IsWhitespace[CharCodes.CarriageReturn] = 1;
+IsWhitespace[CharCodes.Space] = 1;
+
+export { IsWhitespace };