art-bd-ui 1.0.21 → 1.0.23

package/dist/cjs/node_modules/pdf-lib/es/core/interactive/ViewerPreferences.js

@@ -0,0 +1,517 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var PDFArray = require('../objects/PDFArray.js');
+var PDFBool = require('../objects/PDFBool.js');
+var PDFName = require('../objects/PDFName.js');
+var PDFNumber = require('../objects/PDFNumber.js');
+require('../../utils/base64.js');
+require('../../utils/unicode.js');
+require('../../utils/objects.js');
+var validators = require('../../utils/validators.js');
+require('../../utils/pdfDocEncoding.js');
+require('../../utils/Cache.js');
+
+var asEnum = function (rawValue, enumType) {
+    if (rawValue === undefined)
+        return undefined;
+    return enumType[rawValue];
+};
+exports.NonFullScreenPageMode = void 0;
+(function (NonFullScreenPageMode) {
+    /**
+     * After exiting FullScreen mode, neither the document outline nor thumbnail
+     * images should be visible.
+     */
+    NonFullScreenPageMode["UseNone"] = "UseNone";
+    /** After exiting FullScreen mode, the document outline should be visible. */
+    NonFullScreenPageMode["UseOutlines"] = "UseOutlines";
+    /** After exiting FullScreen mode, thumbnail images should be visible. */
+    NonFullScreenPageMode["UseThumbs"] = "UseThumbs";
+    /**
+     * After exiting FullScreen mode, the optional content group panel should be
+     * visible.
+     */
+    NonFullScreenPageMode["UseOC"] = "UseOC";
+})(exports.NonFullScreenPageMode || (exports.NonFullScreenPageMode = {}));
+exports.ReadingDirection = void 0;
+(function (ReadingDirection) {
+    /** The predominant reading order is Left to Right. */
+    ReadingDirection["L2R"] = "L2R";
+    /**
+     * The predominant reading order is Right to left (including vertical writing
+     * systems, such as Chinese, Japanese and Korean).
+     */
+    ReadingDirection["R2L"] = "R2L";
+})(exports.ReadingDirection || (exports.ReadingDirection = {}));
+exports.PrintScaling = void 0;
+(function (PrintScaling) {
+    /** No page scaling. */
+    PrintScaling["None"] = "None";
+    /* Use the PDF reader's default print scaling. */
+    PrintScaling["AppDefault"] = "AppDefault";
+})(exports.PrintScaling || (exports.PrintScaling = {}));
+exports.Duplex = void 0;
+(function (Duplex) {
+    /** The PDF reader should print single-sided. */
+    Duplex["Simplex"] = "Simplex";
+    /**
+     * The PDF reader should print double sided and flip on the short edge of the
+     * sheet.
+     */
+    Duplex["DuplexFlipShortEdge"] = "DuplexFlipShortEdge";
+    /**
+     * The PDF reader should print double sided and flip on the long edge of the
+     * sheet.
+     */
+    Duplex["DuplexFlipLongEdge"] = "DuplexFlipLongEdge";
+})(exports.Duplex || (exports.Duplex = {}));
+var ViewerPreferences = /** @class */ (function () {
+    /** @ignore */
+    function ViewerPreferences(dict) {
+        this.dict = dict;
+    }
+    ViewerPreferences.prototype.lookupBool = function (key) {
+        var returnObj = this.dict.lookup(PDFName.default.of(key));
+        if (returnObj instanceof PDFBool.default)
+            return returnObj;
+        return undefined;
+    };
+    ViewerPreferences.prototype.lookupName = function (key) {
+        var returnObj = this.dict.lookup(PDFName.default.of(key));
+        if (returnObj instanceof PDFName.default)
+            return returnObj;
+        return undefined;
+    };
+    /** @ignore */
+    ViewerPreferences.prototype.HideToolbar = function () {
+        return this.lookupBool('HideToolbar');
+    };
+    /** @ignore */
+    ViewerPreferences.prototype.HideMenubar = function () {
+        return this.lookupBool('HideMenubar');
+    };
+    /** @ignore */
+    ViewerPreferences.prototype.HideWindowUI = function () {
+        return this.lookupBool('HideWindowUI');
+    };
+    /** @ignore */
+    ViewerPreferences.prototype.FitWindow = function () {
+        return this.lookupBool('FitWindow');
+    };
+    /** @ignore */
+    ViewerPreferences.prototype.CenterWindow = function () {
+        return this.lookupBool('CenterWindow');
+    };
+    /** @ignore */
+    ViewerPreferences.prototype.DisplayDocTitle = function () {
+        return this.lookupBool('DisplayDocTitle');
+    };
+    /** @ignore */
+    ViewerPreferences.prototype.NonFullScreenPageMode = function () {
+        return this.lookupName('NonFullScreenPageMode');
+    };
+    /** @ignore */
+    ViewerPreferences.prototype.Direction = function () {
+        return this.lookupName('Direction');
+    };
+    /** @ignore */
+    ViewerPreferences.prototype.PrintScaling = function () {
+        return this.lookupName('PrintScaling');
+    };
+    /** @ignore */
+    ViewerPreferences.prototype.Duplex = function () {
+        return this.lookupName('Duplex');
+    };
+    /** @ignore */
+    ViewerPreferences.prototype.PickTrayByPDFSize = function () {
+        return this.lookupBool('PickTrayByPDFSize');
+    };
+    /** @ignore */
+    ViewerPreferences.prototype.PrintPageRange = function () {
+        var PrintPageRange = this.dict.lookup(PDFName.default.of('PrintPageRange'));
+        if (PrintPageRange instanceof PDFArray.default)
+            return PrintPageRange;
+        return undefined;
+    };
+    /** @ignore */
+    ViewerPreferences.prototype.NumCopies = function () {
+        var NumCopies = this.dict.lookup(PDFName.default.of('NumCopies'));
+        if (NumCopies instanceof PDFNumber.default)
+            return NumCopies;
+        return undefined;
+    };
+    /**
+     * Returns `true` if PDF readers should hide the toolbar menus when displaying
+     * this document.
+     * @returns Whether or not toolbars should be hidden.
+     */
+    ViewerPreferences.prototype.getHideToolbar = function () {
+        var _a, _b;
+        return (_b = (_a = this.HideToolbar()) === null || _a === void 0 ? void 0 : _a.asBoolean()) !== null && _b !== void 0 ? _b : false;
+    };
+    /**
+     * Returns `true` if PDF readers should hide the menu bar when displaying this
+     * document.
+     * @returns Whether or not the menu bar should be hidden.
+     */
+    ViewerPreferences.prototype.getHideMenubar = function () {
+        var _a, _b;
+        return (_b = (_a = this.HideMenubar()) === null || _a === void 0 ? void 0 : _a.asBoolean()) !== null && _b !== void 0 ? _b : false;
+    };
+    /**
+     * Returns `true` if PDF readers should hide the user interface elements in
+     * the document's window (such as scroll bars and navigation controls),
+     * leaving only the document's contents displayed.
+     * @returns Whether or not user interface elements should be hidden.
+     */
+    ViewerPreferences.prototype.getHideWindowUI = function () {
+        var _a, _b;
+        return (_b = (_a = this.HideWindowUI()) === null || _a === void 0 ? void 0 : _a.asBoolean()) !== null && _b !== void 0 ? _b : false;
+    };
+    /**
+     * Returns `true` if PDF readers should resize the document's window to fit
+     * the size of the first displayed page.
+     * @returns Whether or not the window should be resized to fit.
+     */
+    ViewerPreferences.prototype.getFitWindow = function () {
+        var _a, _b;
+        return (_b = (_a = this.FitWindow()) === null || _a === void 0 ? void 0 : _a.asBoolean()) !== null && _b !== void 0 ? _b : false;
+    };
+    /**
+     * Returns `true` if PDF readers should position the document's window in the
+     * center of the screen.
+     * @returns Whether or not to center the document window.
+     */
+    ViewerPreferences.prototype.getCenterWindow = function () {
+        var _a, _b;
+        return (_b = (_a = this.CenterWindow()) === null || _a === void 0 ? void 0 : _a.asBoolean()) !== null && _b !== void 0 ? _b : false;
+    };
+    /**
+     * Returns `true` if the window's title bar should display the document
+     * `Title`, taken from the document metadata (see [[PDFDocument.getTitle]]).
+     * Returns `false` if the title bar should instead display the filename of the
+     * PDF file.
+     * @returns Whether to display the document title.
+     */
+    ViewerPreferences.prototype.getDisplayDocTitle = function () {
+        var _a, _b;
+        return (_b = (_a = this.DisplayDocTitle()) === null || _a === void 0 ? void 0 : _a.asBoolean()) !== null && _b !== void 0 ? _b : false;
+    };
+    /**
+     * Returns the page mode, which tells the PDF reader how to display the
+     * document after exiting full-screen mode.
+     * @returns The page mode after exiting full-screen mode.
+     */
+    ViewerPreferences.prototype.getNonFullScreenPageMode = function () {
+        var _a, _b;
+        var mode = (_a = this.NonFullScreenPageMode()) === null || _a === void 0 ? void 0 : _a.decodeText();
+        return (_b = asEnum(mode, exports.NonFullScreenPageMode)) !== null && _b !== void 0 ? _b : exports.NonFullScreenPageMode.UseNone;
+    };
+    /**
+     * Returns the predominant reading order for text.
+     * @returns The text reading order.
+     */
+    ViewerPreferences.prototype.getReadingDirection = function () {
+        var _a, _b;
+        var direction = (_a = this.Direction()) === null || _a === void 0 ? void 0 : _a.decodeText();
+        return (_b = asEnum(direction, exports.ReadingDirection)) !== null && _b !== void 0 ? _b : exports.ReadingDirection.L2R;
+    };
+    /**
+     * Returns the page scaling option that the PDF reader should select when the
+     * print dialog is displayed.
+     * @returns The page scaling option.
+     */
+    ViewerPreferences.prototype.getPrintScaling = function () {
+        var _a, _b;
+        var scaling = (_a = this.PrintScaling()) === null || _a === void 0 ? void 0 : _a.decodeText();
+        return (_b = asEnum(scaling, exports.PrintScaling)) !== null && _b !== void 0 ? _b : exports.PrintScaling.AppDefault;
+    };
+    /**
+     * Returns the paper handling option that should be used when printing the
+     * file from the print dialog.
+     * @returns The paper handling option.
+     */
+    ViewerPreferences.prototype.getDuplex = function () {
+        var _a;
+        var duplex = (_a = this.Duplex()) === null || _a === void 0 ? void 0 : _a.decodeText();
+        return asEnum(duplex, exports.Duplex);
+    };
+    /**
+     * Returns `true` if the PDF page size should be used to select the input
+     * paper tray.
+     * @returns Whether or not the PDF page size should be used to select the
+     *          input paper tray.
+     */
+    ViewerPreferences.prototype.getPickTrayByPDFSize = function () {
+        var _a;
+        return (_a = this.PickTrayByPDFSize()) === null || _a === void 0 ? void 0 : _a.asBoolean();
+    };
+    /**
+     * Returns an array of page number ranges, which are the values used to
+     * initialize the print dialog box when the file is printed. Each range
+     * specifies the first (`start`) and last (`end`) pages in a sub-range of
+     * pages to be printed. The first page of the PDF file is denoted by 0.
+     * For example:
+     * ```js
+     * const viewerPrefs = pdfDoc.catalog.getOrCreateViewerPreferences()
+     * const includesPage3 = viewerPrefs
+     *   .getPrintRanges()
+     *   .some(pr => pr.start =< 2 && pr.end >= 2)
+     * if (includesPage3) console.log('printRange includes page 3')
+     * ```
+     * @returns An array of objects, each with the properties `start` and `end`,
+     *          denoting page indices. If not, specified an empty array is
+     *          returned.
+     */
+    ViewerPreferences.prototype.getPrintPageRange = function () {
+        var rng = this.PrintPageRange();
+        if (!rng)
+            return [];
+        var pageRanges = [];
+        for (var i = 0; i < rng.size(); i += 2) {
+            // Despite the spec clearly stating that "The first page of the PDF file
+            // shall be donoted by 1", several test PDFs (spec 1.7) created in
+            // Acrobat XI 11.0 and also read with Reader DC 2020.013 indicate this is
+            // actually a 0 based index.
+            var start = rng.lookup(i, PDFNumber.default).asNumber();
+            var end = rng.lookup(i + 1, PDFNumber.default).asNumber();
+            pageRanges.push({ start: start, end: end });
+        }
+        return pageRanges;
+    };
+    /**
+     * Returns the number of copies to be printed when the print dialog is opened
+     * for this document.
+     * @returns The default number of copies to be printed.
+     */
+    ViewerPreferences.prototype.getNumCopies = function () {
+        var _a, _b;
+        return (_b = (_a = this.NumCopies()) === null || _a === void 0 ? void 0 : _a.asNumber()) !== null && _b !== void 0 ? _b : 1;
+    };
+    /**
+     * Choose whether the PDF reader's toolbars should be hidden while the
+     * document is active.
+     * @param hideToolbar `true` if the toolbar should be hidden.
+     */
+    ViewerPreferences.prototype.setHideToolbar = function (hideToolbar) {
+        var HideToolbar = this.dict.context.obj(hideToolbar);
+        this.dict.set(PDFName.default.of('HideToolbar'), HideToolbar);
+    };
+    /**
+     * Choose whether the PDF reader's menu bar should be hidden while the
+     * document is active.
+     * @param hideMenubar `true` if the menu bar should be hidden.
+     */
+    ViewerPreferences.prototype.setHideMenubar = function (hideMenubar) {
+        var HideMenubar = this.dict.context.obj(hideMenubar);
+        this.dict.set(PDFName.default.of('HideMenubar'), HideMenubar);
+    };
+    /**
+     * Choose whether the PDF reader should hide user interface elements in the
+     * document's window (such as scroll bars and navigation controls), leaving
+     * only the document's contents displayed.
+     * @param hideWindowUI `true` if the user interface elements should be hidden.
+     */
+    ViewerPreferences.prototype.setHideWindowUI = function (hideWindowUI) {
+        var HideWindowUI = this.dict.context.obj(hideWindowUI);
+        this.dict.set(PDFName.default.of('HideWindowUI'), HideWindowUI);
+    };
+    /**
+     * Choose whether the PDF reader should resize the document's window to fit
+     * the size of the first displayed page.
+     * @param fitWindow `true` if the window should be resized.
+     */
+    ViewerPreferences.prototype.setFitWindow = function (fitWindow) {
+        var FitWindow = this.dict.context.obj(fitWindow);
+        this.dict.set(PDFName.default.of('FitWindow'), FitWindow);
+    };
+    /**
+     * Choose whether the PDF reader should position the document's window in the
+     * center of the screen.
+     * @param centerWindow `true` if the window should be centered.
+     */
+    ViewerPreferences.prototype.setCenterWindow = function (centerWindow) {
+        var CenterWindow = this.dict.context.obj(centerWindow);
+        this.dict.set(PDFName.default.of('CenterWindow'), CenterWindow);
+    };
+    /**
+     * Choose whether the window's title bar should display the document `Title`
+     * taken from the document metadata (see [[PDFDocument.setTitle]]). If
+     * `false`, the title bar should instead display the PDF filename.
+     * @param displayTitle `true` if the document title should be displayed.
+     */
+    ViewerPreferences.prototype.setDisplayDocTitle = function (displayTitle) {
+        var DisplayDocTitle = this.dict.context.obj(displayTitle);
+        this.dict.set(PDFName.default.of('DisplayDocTitle'), DisplayDocTitle);
+    };
+    /**
+     * Choose how the PDF reader should display the document upon exiting
+     * full-screen mode. This entry is meaningful only if the value of the
+     * `PageMode` entry in the document's [[PDFCatalog]] is `FullScreen`.
+     *
+     * For example:
+     * ```js
+     * import { PDFDocument, NonFullScreenPageMode, PDFName } from 'pdf-lib'
+     *
+     * const pdfDoc = await PDFDocument.create()
+     *
+     * // Set the PageMode
+     * pdfDoc.catalog.set(PDFName.of('PageMode'),PDFName.of('FullScreen'))
+     *
+     * // Set what happens when full-screen is closed
+     * const viewerPrefs = pdfDoc.catalog.getOrCreateViewerPreferences()
+     * viewerPrefs.setNonFullScreenPageMode(NonFullScreenPageMode.UseOutlines)
+     * ```
+     *
+     * @param nonFullScreenPageMode How the document should be displayed upon
+     *                              exiting full screen mode.
+     */
+    ViewerPreferences.prototype.setNonFullScreenPageMode = function (nonFullScreenPageMode) {
+        validators.assertIsOneOf(nonFullScreenPageMode, 'nonFullScreenPageMode', exports.NonFullScreenPageMode);
+        var mode = PDFName.default.of(nonFullScreenPageMode);
+        this.dict.set(PDFName.default.of('NonFullScreenPageMode'), mode);
+    };
+    /**
+     * Choose the predominant reading order for text.
+     *
+     * This entry has no direct effect on the document's contents or page
+     * numbering, but may be used to determine the relative positioning of pages
+     * when displayed side by side or printed n-up.
+     *
+     * For example:
+     * ```js
+     * import { PDFDocument, ReadingDirection } from 'pdf-lib'
+     *
+     * const pdfDoc = await PDFDocument.create()
+     * const viewerPrefs = pdfDoc.catalog.getOrCreateViewerPreferences()
+     * viewerPrefs.setReadingDirection(ReadingDirection.R2L)
+     * ```
+     *
+     * @param readingDirection The reading order for text.
+     */
+    ViewerPreferences.prototype.setReadingDirection = function (readingDirection) {
+        validators.assertIsOneOf(readingDirection, 'readingDirection', exports.ReadingDirection);
+        var direction = PDFName.default.of(readingDirection);
+        this.dict.set(PDFName.default.of('Direction'), direction);
+    };
+    /**
+     * Choose the page scaling option that should be selected when a print dialog
+     * is displayed for this document.
+     *
+     * For example:
+     * ```js
+     * import { PDFDocument, PrintScaling } from 'pdf-lib'
+     *
+     * const pdfDoc = await PDFDocument.create()
+     * const viewerPrefs = pdfDoc.catalog.getOrCreateViewerPreferences()
+     * viewerPrefs.setPrintScaling(PrintScaling.None)
+     * ```
+     *
+     * @param printScaling The print scaling option.
+     */
+    ViewerPreferences.prototype.setPrintScaling = function (printScaling) {
+        validators.assertIsOneOf(printScaling, 'printScaling', exports.PrintScaling);
+        var scaling = PDFName.default.of(printScaling);
+        this.dict.set(PDFName.default.of('PrintScaling'), scaling);
+    };
+    /**
+     * Choose the paper handling option that should be selected by default in the
+     * print dialog.
+     *
+     * For example:
+     * ```js
+     * import { PDFDocument, Duplex } from 'pdf-lib'
+     *
+     * const pdfDoc = await PDFDocument.create()
+     * const viewerPrefs = pdfDoc.catalog.getOrCreateViewerPreferences()
+     * viewerPrefs.setDuplex(Duplex.DuplexFlipShortEdge)
+     * ```
+     *
+     * @param duplex The double or single sided printing option.
+     */
+    ViewerPreferences.prototype.setDuplex = function (duplex) {
+        validators.assertIsOneOf(duplex, 'duplex', exports.Duplex);
+        var dup = PDFName.default.of(duplex);
+        this.dict.set(PDFName.default.of('Duplex'), dup);
+    };
+    /**
+     * Choose whether the PDF document's page size should be used to select the
+     * input paper tray when printing. This setting influences only the preset
+     * values used to populate the print dialog presented by a PDF reader.
+     *
+     * If PickTrayByPDFSize is true, the check box in the print dialog associated
+     * with input paper tray should be checked. This setting has no effect on
+     * operating systems that do not provide the ability to pick the input tray
+     * by size.
+     *
+     * @param pickTrayByPDFSize `true` if the document's page size should be used
+     *                          to select the input paper tray.
+     */
+    ViewerPreferences.prototype.setPickTrayByPDFSize = function (pickTrayByPDFSize) {
+        var PickTrayByPDFSize = this.dict.context.obj(pickTrayByPDFSize);
+        this.dict.set(PDFName.default.of('PickTrayByPDFSize'), PickTrayByPDFSize);
+    };
+    /**
+     * Choose the page numbers used to initialize the print dialog box when the
+     * file is printed. The first page of the PDF file is denoted by 0.
+     *
+     * For example:
+     * ```js
+     * import { PDFDocument } from 'pdf-lib'
+     *
+     * const pdfDoc = await PDFDocument.create()
+     * const viewerPrefs = pdfDoc.catalog.getOrCreateViewerPreferences()
+     *
+     * // We can set the default print range to only the first page
+     * viewerPrefs.setPrintPageRange({ start: 0, end: 0 })
+     *
+     * // Or we can supply noncontiguous ranges (e.g. pages 1, 3, and 5-7)
+     * viewerPrefs.setPrintPageRange([
+     *   { start: 0, end: 0 },
+     *   { start: 2, end: 2 },
+     *   { start: 4, end: 6 },
+     * ])
+     * ```
+     *
+     * @param printPageRange An object or array of objects, each with the
+     *                       properties `start` and `end`, denoting a range of
+     *                       page indices.
+     */
+    ViewerPreferences.prototype.setPrintPageRange = function (printPageRange) {
+        if (!Array.isArray(printPageRange))
+            printPageRange = [printPageRange];
+        var flatRange = [];
+        for (var idx = 0, len = printPageRange.length; idx < len; idx++) {
+            flatRange.push(printPageRange[idx].start);
+            flatRange.push(printPageRange[idx].end);
+        }
+        validators.assertEachIs(flatRange, 'printPageRange', ['number']);
+        var pageRanges = this.dict.context.obj(flatRange);
+        this.dict.set(PDFName.default.of('PrintPageRange'), pageRanges);
+    };
+    /**
+     * Choose the default number of copies to be printed when the print dialog is
+     * opened for this file.
+     * @param numCopies The default number of copies.
+     */
+    ViewerPreferences.prototype.setNumCopies = function (numCopies) {
+        validators.assertRange(numCopies, 'numCopies', 1, Number.MAX_VALUE);
+        validators.assertInteger(numCopies, 'numCopies');
+        var NumCopies = this.dict.context.obj(numCopies);
+        this.dict.set(PDFName.default.of('NumCopies'), NumCopies);
+    };
+    /** @ignore */
+    ViewerPreferences.fromDict = function (dict) {
+        return new ViewerPreferences(dict);
+    };
+    /** @ignore */
+    ViewerPreferences.create = function (context) {
+        var dict = context.obj({});
+        return new ViewerPreferences(dict);
+    };
+    return ViewerPreferences;
+}());
+
+exports.default = ViewerPreferences;

package/dist/cjs/node_modules/pdf-lib/es/core/objects/PDFArray.js

@@ -0,0 +1,120 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFNumber = require('./PDFNumber.js');
+var PDFObject = require('./PDFObject.js');
+var CharCodes = require('../syntax/CharCodes.js');
+var errors = require('../errors.js');
+
+var PDFArray = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFArray, _super);
+    function PDFArray(context) {
+        var _this = _super.call(this) || this;
+        _this.array = [];
+        _this.context = context;
+        return _this;
+    }
+    PDFArray.prototype.size = function () {
+        return this.array.length;
+    };
+    PDFArray.prototype.push = function (object) {
+        this.array.push(object);
+    };
+    PDFArray.prototype.insert = function (index, object) {
+        this.array.splice(index, 0, object);
+    };
+    PDFArray.prototype.indexOf = function (object) {
+        var index = this.array.indexOf(object);
+        return index === -1 ? undefined : index;
+    };
+    PDFArray.prototype.remove = function (index) {
+        this.array.splice(index, 1);
+    };
+    PDFArray.prototype.set = function (idx, object) {
+        this.array[idx] = object;
+    };
+    PDFArray.prototype.get = function (index) {
+        return this.array[index];
+    };
+    PDFArray.prototype.lookupMaybe = function (index) {
+        var _a;
+        var types = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            types[_i - 1] = arguments[_i];
+        }
+        return (_a = this.context).lookupMaybe.apply(_a, tslib_es6.__spreadArrays([this.get(index)], types));
+    };
+    PDFArray.prototype.lookup = function (index) {
+        var _a;
+        var types = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            types[_i - 1] = arguments[_i];
+        }
+        return (_a = this.context).lookup.apply(_a, tslib_es6.__spreadArrays([this.get(index)], types));
+    };
+    PDFArray.prototype.asRectangle = function () {
+        if (this.size() !== 4)
+            throw new errors.PDFArrayIsNotRectangleError(this.size());
+        var lowerLeftX = this.lookup(0, PDFNumber.default).asNumber();
+        var lowerLeftY = this.lookup(1, PDFNumber.default).asNumber();
+        var upperRightX = this.lookup(2, PDFNumber.default).asNumber();
+        var upperRightY = this.lookup(3, PDFNumber.default).asNumber();
+        var x = lowerLeftX;
+        var y = lowerLeftY;
+        var width = upperRightX - lowerLeftX;
+        var height = upperRightY - lowerLeftY;
+        return { x: x, y: y, width: width, height: height };
+    };
+    PDFArray.prototype.asArray = function () {
+        return this.array.slice();
+    };
+    PDFArray.prototype.clone = function (context) {
+        var clone = PDFArray.withContext(context || this.context);
+        for (var idx = 0, len = this.size(); idx < len; idx++) {
+            clone.push(this.array[idx]);
+        }
+        return clone;
+    };
+    PDFArray.prototype.toString = function () {
+        var arrayString = '[ ';
+        for (var idx = 0, len = this.size(); idx < len; idx++) {
+            arrayString += this.get(idx).toString();
+            arrayString += ' ';
+        }
+        arrayString += ']';
+        return arrayString;
+    };
+    PDFArray.prototype.sizeInBytes = function () {
+        var size = 3;
+        for (var idx = 0, len = this.size(); idx < len; idx++) {
+            size += this.get(idx).sizeInBytes() + 1;
+        }
+        return size;
+    };
+    PDFArray.prototype.copyBytesInto = function (buffer, offset) {
+        var initialOffset = offset;
+        buffer[offset++] = CharCodes.default.LeftSquareBracket;
+        buffer[offset++] = CharCodes.default.Space;
+        for (var idx = 0, len = this.size(); idx < len; idx++) {
+            offset += this.get(idx).copyBytesInto(buffer, offset);
+            buffer[offset++] = CharCodes.default.Space;
+        }
+        buffer[offset++] = CharCodes.default.RightSquareBracket;
+        return offset - initialOffset;
+    };
+    PDFArray.prototype.scalePDFNumbers = function (x, y) {
+        for (var idx = 0, len = this.size(); idx < len; idx++) {
+            var el = this.lookup(idx);
+            if (el instanceof PDFNumber.default) {
+                var factor = idx % 2 === 0 ? x : y;
+                this.set(idx, PDFNumber.default.of(el.asNumber() * factor));
+            }
+        }
+    };
+    PDFArray.withContext = function (context) { return new PDFArray(context); };
+    return PDFArray;
+}(PDFObject.default));
+
+exports.default = PDFArray;

package/dist/cjs/node_modules/pdf-lib/es/core/objects/PDFBool.js

@@ -0,0 +1,55 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var errors = require('../errors.js');
+var PDFObject = require('./PDFObject.js');
+var CharCodes = require('../syntax/CharCodes.js');
+
+var ENFORCER = {};
+var PDFBool = /** @class */ (function (_super) {
+    tslib_es6.__extends(PDFBool, _super);
+    function PDFBool(enforcer, value) {
+        var _this = this;
+        if (enforcer !== ENFORCER)
+            throw new errors.PrivateConstructorError('PDFBool');
+        _this = _super.call(this) || this;
+        _this.value = value;
+        return _this;
+    }
+    PDFBool.prototype.asBoolean = function () {
+        return this.value;
+    };
+    PDFBool.prototype.clone = function () {
+        return this;
+    };
+    PDFBool.prototype.toString = function () {
+        return String(this.value);
+    };
+    PDFBool.prototype.sizeInBytes = function () {
+        return this.value ? 4 : 5;
+    };
+    PDFBool.prototype.copyBytesInto = function (buffer, offset) {
+        if (this.value) {
+            buffer[offset++] = CharCodes.default.t;
+            buffer[offset++] = CharCodes.default.r;
+            buffer[offset++] = CharCodes.default.u;
+            buffer[offset++] = CharCodes.default.e;
+            return 4;
+        }
+        else {
+            buffer[offset++] = CharCodes.default.f;
+            buffer[offset++] = CharCodes.default.a;
+            buffer[offset++] = CharCodes.default.l;
+            buffer[offset++] = CharCodes.default.s;
+            buffer[offset++] = CharCodes.default.e;
+            return 5;
+        }
+    };
+    PDFBool.True = new PDFBool(ENFORCER, true);
+    PDFBool.False = new PDFBool(ENFORCER, false);
+    return PDFBool;
+}(PDFObject.default));
+
+exports.default = PDFBool;