art-bd-ui 1.0.21 → 1.0.23

package/dist/esm/node_modules/pdf-lib/es/core/annotation/PDFWidgetAnnotation.js

@@ -0,0 +1,109 @@
+import { __extends } from '../../../../tslib/tslib.es6.js';
+import PDFDict from '../objects/PDFDict.js';
+import PDFName from '../objects/PDFName.js';
+import PDFRef from '../objects/PDFRef.js';
+import PDFString from '../objects/PDFString.js';
+import PDFHexString from '../objects/PDFHexString.js';
+import BorderStyle from './BorderStyle.js';
+import PDFAnnotation from './PDFAnnotation.js';
+import AppearanceCharacteristics from './AppearanceCharacteristics.js';
+
+var PDFWidgetAnnotation = /** @class */ (function (_super) {
+    __extends(PDFWidgetAnnotation, _super);
+    function PDFWidgetAnnotation() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PDFWidgetAnnotation.prototype.MK = function () {
+        var MK = this.dict.lookup(PDFName.of('MK'));
+        if (MK instanceof PDFDict)
+            return MK;
+        return undefined;
+    };
+    PDFWidgetAnnotation.prototype.BS = function () {
+        var BS = this.dict.lookup(PDFName.of('BS'));
+        if (BS instanceof PDFDict)
+            return BS;
+        return undefined;
+    };
+    PDFWidgetAnnotation.prototype.DA = function () {
+        var da = this.dict.lookup(PDFName.of('DA'));
+        if (da instanceof PDFString || da instanceof PDFHexString)
+            return da;
+        return undefined;
+    };
+    PDFWidgetAnnotation.prototype.P = function () {
+        var P = this.dict.get(PDFName.of('P'));
+        if (P instanceof PDFRef)
+            return P;
+        return undefined;
+    };
+    PDFWidgetAnnotation.prototype.setP = function (page) {
+        this.dict.set(PDFName.of('P'), page);
+    };
+    PDFWidgetAnnotation.prototype.setDefaultAppearance = function (appearance) {
+        this.dict.set(PDFName.of('DA'), PDFString.of(appearance));
+    };
+    PDFWidgetAnnotation.prototype.getDefaultAppearance = function () {
+        var DA = this.DA();
+        if (DA instanceof PDFHexString) {
+            return DA.decodeText();
+        }
+        return DA === null || DA === void 0 ? void 0 : DA.asString();
+    };
+    PDFWidgetAnnotation.prototype.getAppearanceCharacteristics = function () {
+        var MK = this.MK();
+        if (MK)
+            return AppearanceCharacteristics.fromDict(MK);
+        return undefined;
+    };
+    PDFWidgetAnnotation.prototype.getOrCreateAppearanceCharacteristics = function () {
+        var MK = this.MK();
+        if (MK)
+            return AppearanceCharacteristics.fromDict(MK);
+        var ac = AppearanceCharacteristics.fromDict(this.dict.context.obj({}));
+        this.dict.set(PDFName.of('MK'), ac.dict);
+        return ac;
+    };
+    PDFWidgetAnnotation.prototype.getBorderStyle = function () {
+        var BS = this.BS();
+        if (BS)
+            return BorderStyle.fromDict(BS);
+        return undefined;
+    };
+    PDFWidgetAnnotation.prototype.getOrCreateBorderStyle = function () {
+        var BS = this.BS();
+        if (BS)
+            return BorderStyle.fromDict(BS);
+        var bs = BorderStyle.fromDict(this.dict.context.obj({}));
+        this.dict.set(PDFName.of('BS'), bs.dict);
+        return bs;
+    };
+    PDFWidgetAnnotation.prototype.getOnValue = function () {
+        var _a;
+        var normal = (_a = this.getAppearances()) === null || _a === void 0 ? void 0 : _a.normal;
+        if (normal instanceof PDFDict) {
+            var keys = normal.keys();
+            for (var idx = 0, len = keys.length; idx < len; idx++) {
+                var key = keys[idx];
+                if (key !== PDFName.of('Off'))
+                    return key;
+            }
+        }
+        return undefined;
+    };
+    PDFWidgetAnnotation.fromDict = function (dict) {
+        return new PDFWidgetAnnotation(dict);
+    };
+    PDFWidgetAnnotation.create = function (context, parent) {
+        var dict = context.obj({
+            Type: 'Annot',
+            Subtype: 'Widget',
+            Rect: [0, 0, 0, 0],
+            Parent: parent,
+        });
+        return new PDFWidgetAnnotation(dict);
+    };
+    return PDFWidgetAnnotation;
+}(PDFAnnotation));
+
+export { PDFWidgetAnnotation as default };

package/dist/esm/node_modules/pdf-lib/es/core/annotation/flags.js

@@ -0,0 +1,83 @@
+var flag = function (bitIndex) { return 1 << bitIndex; };
+/** From PDF spec table 165 */
+var AnnotationFlags;
+(function (AnnotationFlags) {
+    /**
+     * If set, do not display the annotation if it does not belong to one of the
+     * standard annotation types and no annotation handler is available. If clear,
+     * display such an unknown annotation using an appearance stream specified by
+     * its appearance dictionary, if any.
+     */
+    AnnotationFlags[AnnotationFlags["Invisible"] = flag(1 - 1)] = "Invisible";
+    /**
+     * If set, do not display or print the annotation or allow it to interact with
+     * the user, regardless of its annotation type or whether an annotation
+     * handler is available.
+     *
+     * In cases where screen space is limited, the ability to hide and show
+     * annotations selectively can be used in combination with appearance streams
+     * to display auxiliary pop-up information similar in function to online help
+     * systems.
+     */
+    AnnotationFlags[AnnotationFlags["Hidden"] = flag(2 - 1)] = "Hidden";
+    /**
+     * If set, print the annotation when the page is printed. If clear, never
+     * print the annotation, regardless of whether it is displayed on the screen.
+     *
+     * This can be useful for annotations representing interactive pushbuttons,
+     * which would serve no meaningful purpose on the printed page.
+     */
+    AnnotationFlags[AnnotationFlags["Print"] = flag(3 - 1)] = "Print";
+    /**
+     * If set, do not scale the annotation’s appearance to match the magnification
+     * of the page. The location of the annotation on the page (defined by the
+     * upper-left corner of its annotation rectangle) shall remain fixed,
+     * regardless of the page magnification.
+     */
+    AnnotationFlags[AnnotationFlags["NoZoom"] = flag(4 - 1)] = "NoZoom";
+    /**
+     * If set, do not rotate the annotation’s appearance to match the rotation of
+     * the page. The upper-left corner of the annotation rectangle shall remain in
+     * a fixed location on the page, regardless of the page rotation.
+     */
+    AnnotationFlags[AnnotationFlags["NoRotate"] = flag(5 - 1)] = "NoRotate";
+    /**
+     * If set, do not display the annotation on the screen or allow it to interact
+     * with the user. The annotation may be printed (depending on the setting of
+     * the Print flag) but should be considered hidden for purposes of on-screen
+     * display and user interaction.
+     */
+    AnnotationFlags[AnnotationFlags["NoView"] = flag(6 - 1)] = "NoView";
+    /**
+     * If set, do not allow the annotation to interact with the user. The
+     * annotation may be displayed or printed (depending on the settings of the
+     * NoView and Print flags) but should not respond to mouse clicks or change
+     * its appearance in response to mouse motions.
+     *
+     * This flag shall be ignored for widget annotations; its function is
+     * subsumed by the ReadOnly flag of the associated form field.
+     */
+    AnnotationFlags[AnnotationFlags["ReadOnly"] = flag(7 - 1)] = "ReadOnly";
+    /**
+     * If set, do not allow the annotation to be deleted or its properties
+     * (including position and size) to be modified by the user. However, this
+     * flag does not restrict changes to the annotation’s contents, such as the
+     * value of a form field.
+     */
+    AnnotationFlags[AnnotationFlags["Locked"] = flag(8 - 1)] = "Locked";
+    /**
+     * If set, invert the interpretation of the NoView flag for certain events.
+     *
+     * A typical use is to have an annotation that appears only when a mouse
+     * cursor is held over it.
+     */
+    AnnotationFlags[AnnotationFlags["ToggleNoView"] = flag(9 - 1)] = "ToggleNoView";
+    /**
+     * If set, do not allow the contents of the annotation to be modified by the
+     * user. This flag does not restrict deletion of the annotation or changes to
+     * other annotation properties, such as position and size.
+     */
+    AnnotationFlags[AnnotationFlags["LockedContents"] = flag(10 - 1)] = "LockedContents";
+})(AnnotationFlags || (AnnotationFlags = {}));
+
+export { AnnotationFlags };

package/dist/esm/node_modules/pdf-lib/es/core/document/PDFCrossRefSection.js

@@ -0,0 +1,127 @@
+import PDFRef from '../objects/PDFRef.js';
+import CharCodes from '../syntax/CharCodes.js';
+import '../../utils/base64.js';
+import { padStart, copyStringIntoBuffer } from '../../utils/strings.js';
+import '../../utils/unicode.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import '../../utils/Cache.js';
+
+/**
+ * Entries should be added using the [[addEntry]] and [[addDeletedEntry]]
+ * methods **in order of ascending object number**.
+ */
+var PDFCrossRefSection = /** @class */ (function () {
+    function PDFCrossRefSection(firstEntry) {
+        this.subsections = firstEntry ? [[firstEntry]] : [];
+        this.chunkIdx = 0;
+        this.chunkLength = firstEntry ? 1 : 0;
+    }
+    PDFCrossRefSection.prototype.addEntry = function (ref, offset) {
+        this.append({ ref: ref, offset: offset, deleted: false });
+    };
+    PDFCrossRefSection.prototype.addDeletedEntry = function (ref, nextFreeObjectNumber) {
+        this.append({ ref: ref, offset: nextFreeObjectNumber, deleted: true });
+    };
+    PDFCrossRefSection.prototype.toString = function () {
+        var section = "xref\n";
+        for (var rangeIdx = 0, rangeLen = this.subsections.length; rangeIdx < rangeLen; rangeIdx++) {
+            var range = this.subsections[rangeIdx];
+            section += range[0].ref.objectNumber + " " + range.length + "\n";
+            for (var entryIdx = 0, entryLen = range.length; entryIdx < entryLen; entryIdx++) {
+                var entry = range[entryIdx];
+                section += padStart(String(entry.offset), 10, '0');
+                section += ' ';
+                section += padStart(String(entry.ref.generationNumber), 5, '0');
+                section += ' ';
+                section += entry.deleted ? 'f' : 'n';
+                section += ' \n';
+            }
+        }
+        return section;
+    };
+    PDFCrossRefSection.prototype.sizeInBytes = function () {
+        var size = 5;
+        for (var idx = 0, len = this.subsections.length; idx < len; idx++) {
+            var subsection = this.subsections[idx];
+            var subsectionLength = subsection.length;
+            var firstEntry = subsection[0];
+            size += 2;
+            size += String(firstEntry.ref.objectNumber).length;
+            size += String(subsectionLength).length;
+            size += 20 * subsectionLength;
+        }
+        return size;
+    };
+    PDFCrossRefSection.prototype.copyBytesInto = function (buffer, offset) {
+        var initialOffset = offset;
+        buffer[offset++] = CharCodes.x;
+        buffer[offset++] = CharCodes.r;
+        buffer[offset++] = CharCodes.e;
+        buffer[offset++] = CharCodes.f;
+        buffer[offset++] = CharCodes.Newline;
+        offset += this.copySubsectionsIntoBuffer(this.subsections, buffer, offset);
+        return offset - initialOffset;
+    };
+    PDFCrossRefSection.prototype.copySubsectionsIntoBuffer = function (subsections, buffer, offset) {
+        var initialOffset = offset;
+        var length = subsections.length;
+        for (var idx = 0; idx < length; idx++) {
+            var subsection = this.subsections[idx];
+            var firstObjectNumber = String(subsection[0].ref.objectNumber);
+            offset += copyStringIntoBuffer(firstObjectNumber, buffer, offset);
+            buffer[offset++] = CharCodes.Space;
+            var rangeLength = String(subsection.length);
+            offset += copyStringIntoBuffer(rangeLength, buffer, offset);
+            buffer[offset++] = CharCodes.Newline;
+            offset += this.copyEntriesIntoBuffer(subsection, buffer, offset);
+        }
+        return offset - initialOffset;
+    };
+    PDFCrossRefSection.prototype.copyEntriesIntoBuffer = function (entries, buffer, offset) {
+        var length = entries.length;
+        for (var idx = 0; idx < length; idx++) {
+            var entry = entries[idx];
+            var entryOffset = padStart(String(entry.offset), 10, '0');
+            offset += copyStringIntoBuffer(entryOffset, buffer, offset);
+            buffer[offset++] = CharCodes.Space;
+            var entryGen = padStart(String(entry.ref.generationNumber), 5, '0');
+            offset += copyStringIntoBuffer(entryGen, buffer, offset);
+            buffer[offset++] = CharCodes.Space;
+            buffer[offset++] = entry.deleted ? CharCodes.f : CharCodes.n;
+            buffer[offset++] = CharCodes.Space;
+            buffer[offset++] = CharCodes.Newline;
+        }
+        return 20 * length;
+    };
+    PDFCrossRefSection.prototype.append = function (currEntry) {
+        if (this.chunkLength === 0) {
+            this.subsections.push([currEntry]);
+            this.chunkIdx = 0;
+            this.chunkLength = 1;
+            return;
+        }
+        var chunk = this.subsections[this.chunkIdx];
+        var prevEntry = chunk[this.chunkLength - 1];
+        if (currEntry.ref.objectNumber - prevEntry.ref.objectNumber > 1) {
+            this.subsections.push([currEntry]);
+            this.chunkIdx += 1;
+            this.chunkLength = 1;
+        }
+        else {
+            chunk.push(currEntry);
+            this.chunkLength += 1;
+        }
+    };
+    PDFCrossRefSection.create = function () {
+        return new PDFCrossRefSection({
+            ref: PDFRef.of(0, 65535),
+            offset: 0,
+            deleted: true,
+        });
+    };
+    PDFCrossRefSection.createEmpty = function () { return new PDFCrossRefSection(); };
+    return PDFCrossRefSection;
+}());
+
+export { PDFCrossRefSection as default };

package/dist/esm/node_modules/pdf-lib/es/core/document/PDFHeader.js

@@ -0,0 +1,45 @@
+import CharCodes from '../syntax/CharCodes.js';
+import '../../utils/base64.js';
+import { copyStringIntoBuffer, charFromCode } from '../../utils/strings.js';
+import '../../utils/unicode.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import '../../utils/Cache.js';
+
+var PDFHeader = /** @class */ (function () {
+    function PDFHeader(major, minor) {
+        this.major = String(major);
+        this.minor = String(minor);
+    }
+    PDFHeader.prototype.toString = function () {
+        var bc = charFromCode(129);
+        return "%PDF-" + this.major + "." + this.minor + "\n%" + bc + bc + bc + bc;
+    };
+    PDFHeader.prototype.sizeInBytes = function () {
+        return 12 + this.major.length + this.minor.length;
+    };
+    PDFHeader.prototype.copyBytesInto = function (buffer, offset) {
+        var initialOffset = offset;
+        buffer[offset++] = CharCodes.Percent;
+        buffer[offset++] = CharCodes.P;
+        buffer[offset++] = CharCodes.D;
+        buffer[offset++] = CharCodes.F;
+        buffer[offset++] = CharCodes.Dash;
+        offset += copyStringIntoBuffer(this.major, buffer, offset);
+        buffer[offset++] = CharCodes.Period;
+        offset += copyStringIntoBuffer(this.minor, buffer, offset);
+        buffer[offset++] = CharCodes.Newline;
+        buffer[offset++] = CharCodes.Percent;
+        buffer[offset++] = 129;
+        buffer[offset++] = 129;
+        buffer[offset++] = 129;
+        buffer[offset++] = 129;
+        return offset - initialOffset;
+    };
+    PDFHeader.forVersion = function (major, minor) {
+        return new PDFHeader(major, minor);
+    };
+    return PDFHeader;
+}());
+
+export { PDFHeader as default };

package/dist/esm/node_modules/pdf-lib/es/core/document/PDFTrailer.js

@@ -0,0 +1,46 @@
+import CharCodes from '../syntax/CharCodes.js';
+import '../../utils/base64.js';
+import { copyStringIntoBuffer } from '../../utils/strings.js';
+import '../../utils/unicode.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import '../../utils/Cache.js';
+
+var PDFTrailer = /** @class */ (function () {
+    function PDFTrailer(lastXRefOffset) {
+        this.lastXRefOffset = String(lastXRefOffset);
+    }
+    PDFTrailer.prototype.toString = function () {
+        return "startxref\n" + this.lastXRefOffset + "\n%%EOF";
+    };
+    PDFTrailer.prototype.sizeInBytes = function () {
+        return 16 + this.lastXRefOffset.length;
+    };
+    PDFTrailer.prototype.copyBytesInto = function (buffer, offset) {
+        var initialOffset = offset;
+        buffer[offset++] = CharCodes.s;
+        buffer[offset++] = CharCodes.t;
+        buffer[offset++] = CharCodes.a;
+        buffer[offset++] = CharCodes.r;
+        buffer[offset++] = CharCodes.t;
+        buffer[offset++] = CharCodes.x;
+        buffer[offset++] = CharCodes.r;
+        buffer[offset++] = CharCodes.e;
+        buffer[offset++] = CharCodes.f;
+        buffer[offset++] = CharCodes.Newline;
+        offset += copyStringIntoBuffer(this.lastXRefOffset, buffer, offset);
+        buffer[offset++] = CharCodes.Newline;
+        buffer[offset++] = CharCodes.Percent;
+        buffer[offset++] = CharCodes.Percent;
+        buffer[offset++] = CharCodes.E;
+        buffer[offset++] = CharCodes.O;
+        buffer[offset++] = CharCodes.F;
+        return offset - initialOffset;
+    };
+    PDFTrailer.forLastCrossRefSectionOffset = function (offset) {
+        return new PDFTrailer(offset);
+    };
+    return PDFTrailer;
+}());
+
+export { PDFTrailer as default };

package/dist/esm/node_modules/pdf-lib/es/core/document/PDFTrailerDict.js

@@ -0,0 +1,30 @@
+import CharCodes from '../syntax/CharCodes.js';
+
+var PDFTrailerDict = /** @class */ (function () {
+    function PDFTrailerDict(dict) {
+        this.dict = dict;
+    }
+    PDFTrailerDict.prototype.toString = function () {
+        return "trailer\n" + this.dict.toString();
+    };
+    PDFTrailerDict.prototype.sizeInBytes = function () {
+        return 8 + this.dict.sizeInBytes();
+    };
+    PDFTrailerDict.prototype.copyBytesInto = function (buffer, offset) {
+        var initialOffset = offset;
+        buffer[offset++] = CharCodes.t;
+        buffer[offset++] = CharCodes.r;
+        buffer[offset++] = CharCodes.a;
+        buffer[offset++] = CharCodes.i;
+        buffer[offset++] = CharCodes.l;
+        buffer[offset++] = CharCodes.e;
+        buffer[offset++] = CharCodes.r;
+        buffer[offset++] = CharCodes.Newline;
+        offset += this.dict.copyBytesInto(buffer, offset);
+        return offset - initialOffset;
+    };
+    PDFTrailerDict.of = function (dict) { return new PDFTrailerDict(dict); };
+    return PDFTrailerDict;
+}());
+
+export { PDFTrailerDict as default };

package/dist/esm/node_modules/pdf-lib/es/core/embedders/CMap.js

@@ -0,0 +1,46 @@
+import '../../utils/base64.js';
+import { toHexStringOfMinLength, toHexString } from '../../utils/strings.js';
+import { isWithinBMP, hasSurrogates, highSurrogate, lowSurrogate } from '../../utils/unicode.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import '../../utils/Cache.js';
+
+/** `glyphs` should be an array of unique glyphs */
+var createCmap = function (glyphs, glyphId) {
+    var bfChars = new Array(glyphs.length);
+    for (var idx = 0, len = glyphs.length; idx < len; idx++) {
+        var glyph = glyphs[idx];
+        var id = cmapHexFormat(cmapHexString(glyphId(glyph)));
+        var unicode = cmapHexFormat.apply(void 0, glyph.codePoints.map(cmapCodePointFormat));
+        bfChars[idx] = [id, unicode];
+    }
+    return fillCmapTemplate(bfChars);
+};
+/* =============================== Templates ================================ */
+var fillCmapTemplate = function (bfChars) { return "/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap\n/CIDSystemInfo <<\n  /Registry (Adobe)\n  /Ordering (UCS)\n  /Supplement 0\n>> def\n/CMapName /Adobe-Identity-UCS def\n/CMapType 2 def\n1 begincodespacerange\n<0000><ffff>\nendcodespacerange\n" + bfChars.length + " beginbfchar\n" + bfChars.map(function (_a) {
+    var glyphId = _a[0], codePoint = _a[1];
+    return glyphId + " " + codePoint;
+}).join('\n') + "\nendbfchar\nendcmap\nCMapName currentdict /CMap defineresource pop\nend\nend"; };
+/* =============================== Utilities ================================ */
+var cmapHexFormat = function () {
+    var values = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        values[_i] = arguments[_i];
+    }
+    return "<" + values.join('') + ">";
+};
+var cmapHexString = function (value) { return toHexStringOfMinLength(value, 4); };
+var cmapCodePointFormat = function (codePoint) {
+    if (isWithinBMP(codePoint))
+        return cmapHexString(codePoint);
+    if (hasSurrogates(codePoint)) {
+        var hs = highSurrogate(codePoint);
+        var ls = lowSurrogate(codePoint);
+        return "" + cmapHexString(hs) + cmapHexString(ls);
+    }
+    var hex = toHexString(codePoint);
+    var msg = "0x" + hex + " is not a valid UTF-8 or UTF-16 codepoint.";
+    throw new Error(msg);
+};
+
+export { createCmap };