art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,244 @@
+import { __awaiter, __generator } from '../../../../tslib/tslib.es6.js';
+import { createCmap } from './CMap.js';
+import { deriveFontFlags } from './FontFlags.js';
+import PDFHexString from '../objects/PDFHexString.js';
+import PDFString from '../objects/PDFString.js';
+import { sortedUniq, byAscendingId } from '../../utils/arrays.js';
+import { toHexStringOfMinLength } from '../../utils/strings.js';
+import '../../utils/unicode.js';
+import '../../utils/base64.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import Cache from '../../utils/Cache.js';
+
+/**
+ * A note of thanks to the developers of https://github.com/foliojs/pdfkit, as
+ * this class borrows from:
+ *   https://github.com/devongovett/pdfkit/blob/e71edab0dd4657b5a767804ba86c94c58d01fbca/lib/image/jpeg.coffee
+ */
+var CustomFontEmbedder = /** @class */ (function () {
+    function CustomFontEmbedder(font, fontData, customName, fontFeatures) {
+        var _this = this;
+        this.allGlyphsInFontSortedById = function () {
+            var glyphs = new Array(_this.font.characterSet.length);
+            for (var idx = 0, len = glyphs.length; idx < len; idx++) {
+                var codePoint = _this.font.characterSet[idx];
+                glyphs[idx] = _this.font.glyphForCodePoint(codePoint);
+            }
+            return sortedUniq(glyphs.sort(byAscendingId), function (g) { return g.id; });
+        };
+        this.font = font;
+        this.scale = 1000 / this.font.unitsPerEm;
+        this.fontData = fontData;
+        this.fontName = this.font.postscriptName || 'Font';
+        this.customName = customName;
+        this.fontFeatures = fontFeatures;
+        this.baseFontName = '';
+        this.glyphCache = Cache.populatedBy(this.allGlyphsInFontSortedById);
+    }
+    CustomFontEmbedder.for = function (fontkit, fontData, customName, fontFeatures) {
+        return __awaiter(this, void 0, void 0, function () {
+            var font;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fontkit.create(fontData)];
+                    case 1:
+                        font = _a.sent();
+                        return [2 /*return*/, new CustomFontEmbedder(font, fontData, customName, fontFeatures)];
+                }
+            });
+        });
+    };
+    /**
+     * Encode the JavaScript string into this font. (JavaScript encodes strings in
+     * Unicode, but embedded fonts use their own custom encodings)
+     */
+    CustomFontEmbedder.prototype.encodeText = function (text) {
+        var glyphs = this.font.layout(text, this.fontFeatures).glyphs;
+        var hexCodes = new Array(glyphs.length);
+        for (var idx = 0, len = glyphs.length; idx < len; idx++) {
+            hexCodes[idx] = toHexStringOfMinLength(glyphs[idx].id, 4);
+        }
+        return PDFHexString.of(hexCodes.join(''));
+    };
+    // The advanceWidth takes into account kerning automatically, so we don't
+    // have to do that manually like we do for the standard fonts.
+    CustomFontEmbedder.prototype.widthOfTextAtSize = function (text, size) {
+        var glyphs = this.font.layout(text, this.fontFeatures).glyphs;
+        var totalWidth = 0;
+        for (var idx = 0, len = glyphs.length; idx < len; idx++) {
+            totalWidth += glyphs[idx].advanceWidth * this.scale;
+        }
+        var scale = size / 1000;
+        return totalWidth * scale;
+    };
+    CustomFontEmbedder.prototype.heightOfFontAtSize = function (size, options) {
+        if (options === void 0) { options = {}; }
+        var _a = options.descender, descender = _a === void 0 ? true : _a;
+        var _b = this.font, ascent = _b.ascent, descent = _b.descent, bbox = _b.bbox;
+        var yTop = (ascent || bbox.maxY) * this.scale;
+        var yBottom = (descent || bbox.minY) * this.scale;
+        var height = yTop - yBottom;
+        if (!descender)
+            height -= Math.abs(descent) || 0;
+        return (height / 1000) * size;
+    };
+    CustomFontEmbedder.prototype.sizeOfFontAtHeight = function (height) {
+        var _a = this.font, ascent = _a.ascent, descent = _a.descent, bbox = _a.bbox;
+        var yTop = (ascent || bbox.maxY) * this.scale;
+        var yBottom = (descent || bbox.minY) * this.scale;
+        return (1000 * height) / (yTop - yBottom);
+    };
+    CustomFontEmbedder.prototype.embedIntoContext = function (context, ref) {
+        this.baseFontName =
+            this.customName || context.addRandomSuffix(this.fontName);
+        return this.embedFontDict(context, ref);
+    };
+    CustomFontEmbedder.prototype.embedFontDict = function (context, ref) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cidFontDictRef, unicodeCMapRef, fontDict;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.embedCIDFontDict(context)];
+                    case 1:
+                        cidFontDictRef = _a.sent();
+                        unicodeCMapRef = this.embedUnicodeCmap(context);
+                        fontDict = context.obj({
+                            Type: 'Font',
+                            Subtype: 'Type0',
+                            BaseFont: this.baseFontName,
+                            Encoding: 'Identity-H',
+                            DescendantFonts: [cidFontDictRef],
+                            ToUnicode: unicodeCMapRef,
+                        });
+                        if (ref) {
+                            context.assign(ref, fontDict);
+                            return [2 /*return*/, ref];
+                        }
+                        else {
+                            return [2 /*return*/, context.register(fontDict)];
+                        }
+                }
+            });
+        });
+    };
+    CustomFontEmbedder.prototype.isCFF = function () {
+        return this.font.cff;
+    };
+    CustomFontEmbedder.prototype.embedCIDFontDict = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fontDescriptorRef, cidFontDict;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.embedFontDescriptor(context)];
+                    case 1:
+                        fontDescriptorRef = _a.sent();
+                        cidFontDict = context.obj({
+                            Type: 'Font',
+                            Subtype: this.isCFF() ? 'CIDFontType0' : 'CIDFontType2',
+                            CIDToGIDMap: 'Identity',
+                            BaseFont: this.baseFontName,
+                            CIDSystemInfo: {
+                                Registry: PDFString.of('Adobe'),
+                                Ordering: PDFString.of('Identity'),
+                                Supplement: 0,
+                            },
+                            FontDescriptor: fontDescriptorRef,
+                            W: this.computeWidths(),
+                        });
+                        return [2 /*return*/, context.register(cidFontDict)];
+                }
+            });
+        });
+    };
+    CustomFontEmbedder.prototype.embedFontDescriptor = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fontStreamRef, scale, _a, italicAngle, ascent, descent, capHeight, xHeight, _b, minX, minY, maxX, maxY, fontDescriptor;
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.embedFontStream(context)];
+                    case 1:
+                        fontStreamRef = _d.sent();
+                        scale = this.scale;
+                        _a = this.font, italicAngle = _a.italicAngle, ascent = _a.ascent, descent = _a.descent, capHeight = _a.capHeight, xHeight = _a.xHeight;
+                        _b = this.font.bbox, minX = _b.minX, minY = _b.minY, maxX = _b.maxX, maxY = _b.maxY;
+                        fontDescriptor = context.obj((_c = {
+                                Type: 'FontDescriptor',
+                                FontName: this.baseFontName,
+                                Flags: deriveFontFlags(this.font),
+                                FontBBox: [minX * scale, minY * scale, maxX * scale, maxY * scale],
+                                ItalicAngle: italicAngle,
+                                Ascent: ascent * scale,
+                                Descent: descent * scale,
+                                CapHeight: (capHeight || ascent) * scale,
+                                XHeight: (xHeight || 0) * scale,
+                                // Not sure how to compute/find this, nor is anybody else really:
+                                // https://stackoverflow.com/questions/35485179/stemv-value-of-the-truetype-font
+                                StemV: 0
+                            },
+                            _c[this.isCFF() ? 'FontFile3' : 'FontFile2'] = fontStreamRef,
+                            _c));
+                        return [2 /*return*/, context.register(fontDescriptor)];
+                }
+            });
+        });
+    };
+    CustomFontEmbedder.prototype.serializeFont = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fontData];
+            });
+        });
+    };
+    CustomFontEmbedder.prototype.embedFontStream = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fontStream, _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _b = (_a = context).flateStream;
+                        return [4 /*yield*/, this.serializeFont()];
+                    case 1:
+                        fontStream = _b.apply(_a, [_c.sent(), {
+                                Subtype: this.isCFF() ? 'CIDFontType0C' : undefined,
+                            }]);
+                        return [2 /*return*/, context.register(fontStream)];
+                }
+            });
+        });
+    };
+    CustomFontEmbedder.prototype.embedUnicodeCmap = function (context) {
+        var cmap = createCmap(this.glyphCache.access(), this.glyphId.bind(this));
+        var cmapStream = context.flateStream(cmap);
+        return context.register(cmapStream);
+    };
+    CustomFontEmbedder.prototype.glyphId = function (glyph) {
+        return glyph ? glyph.id : -1;
+    };
+    CustomFontEmbedder.prototype.computeWidths = function () {
+        var glyphs = this.glyphCache.access();
+        var widths = [];
+        var currSection = [];
+        for (var idx = 0, len = glyphs.length; idx < len; idx++) {
+            var currGlyph = glyphs[idx];
+            var prevGlyph = glyphs[idx - 1];
+            var currGlyphId = this.glyphId(currGlyph);
+            var prevGlyphId = this.glyphId(prevGlyph);
+            if (idx === 0) {
+                widths.push(currGlyphId);
+            }
+            else if (currGlyphId - prevGlyphId !== 1) {
+                widths.push(currSection);
+                widths.push(currGlyphId);
+                currSection = [];
+            }
+            currSection.push(currGlyph.advanceWidth * this.scale);
+        }
+        widths.push(currSection);
+        return widths;
+    };
+    return CustomFontEmbedder;
+}());
+
+export { CustomFontEmbedder as default };

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

@@ -0,0 +1,73 @@
+import { __extends, __awaiter, __generator } from '../../../../tslib/tslib.es6.js';
+import CustomFontEmbedder from './CustomFontEmbedder.js';
+import PDFHexString from '../objects/PDFHexString.js';
+import { mergeUint8Arrays } from '../../utils/arrays.js';
+import { toHexStringOfMinLength } from '../../utils/strings.js';
+import '../../utils/unicode.js';
+import '../../utils/base64.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import Cache from '../../utils/Cache.js';
+
+/**
+ * A note of thanks to the developers of https://github.com/foliojs/pdfkit, as
+ * this class borrows from:
+ *   https://github.com/devongovett/pdfkit/blob/e71edab0dd4657b5a767804ba86c94c58d01fbca/lib/image/jpeg.coffee
+ */
+var CustomFontSubsetEmbedder = /** @class */ (function (_super) {
+    __extends(CustomFontSubsetEmbedder, _super);
+    function CustomFontSubsetEmbedder(font, fontData, customFontName, fontFeatures) {
+        var _this = _super.call(this, font, fontData, customFontName, fontFeatures) || this;
+        _this.subset = _this.font.createSubset();
+        _this.glyphs = [];
+        _this.glyphCache = Cache.populatedBy(function () { return _this.glyphs; });
+        _this.glyphIdMap = new Map();
+        return _this;
+    }
+    CustomFontSubsetEmbedder.for = function (fontkit, fontData, customFontName, fontFeatures) {
+        return __awaiter(this, void 0, void 0, function () {
+            var font;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fontkit.create(fontData)];
+                    case 1:
+                        font = _a.sent();
+                        return [2 /*return*/, new CustomFontSubsetEmbedder(font, fontData, customFontName, fontFeatures)];
+                }
+            });
+        });
+    };
+    CustomFontSubsetEmbedder.prototype.encodeText = function (text) {
+        var glyphs = this.font.layout(text, this.fontFeatures).glyphs;
+        var hexCodes = new Array(glyphs.length);
+        for (var idx = 0, len = glyphs.length; idx < len; idx++) {
+            var glyph = glyphs[idx];
+            var subsetGlyphId = this.subset.includeGlyph(glyph);
+            this.glyphs[subsetGlyphId - 1] = glyph;
+            this.glyphIdMap.set(glyph.id, subsetGlyphId);
+            hexCodes[idx] = toHexStringOfMinLength(subsetGlyphId, 4);
+        }
+        this.glyphCache.invalidate();
+        return PDFHexString.of(hexCodes.join(''));
+    };
+    CustomFontSubsetEmbedder.prototype.isCFF = function () {
+        return this.subset.cff;
+    };
+    CustomFontSubsetEmbedder.prototype.glyphId = function (glyph) {
+        return glyph ? this.glyphIdMap.get(glyph.id) : -1;
+    };
+    CustomFontSubsetEmbedder.prototype.serializeFont = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var parts = [];
+            _this.subset
+                .encodeStream()
+                .on('data', function (bytes) { return parts.push(bytes); })
+                .on('end', function () { return resolve(mergeUint8Arrays(parts)); })
+                .on('error', function (err) { return reject(err); });
+        });
+    };
+    return CustomFontSubsetEmbedder;
+}(CustomFontEmbedder));
+
+export { CustomFontSubsetEmbedder as default };

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

@@ -0,0 +1,72 @@
+import { __awaiter, __generator } from '../../../../tslib/tslib.es6.js';
+import PDFString from '../objects/PDFString.js';
+import PDFHexString from '../objects/PDFHexString.js';
+
+/**
+ * From the PDF-A3 specification, section **3.1. Requirements - General**.
+ * See:
+ * * https://www.pdfa.org/wp-content/uploads/2018/10/PDF20_AN002-AF.pdf
+ */
+var AFRelationship;
+(function (AFRelationship) {
+    AFRelationship["Source"] = "Source";
+    AFRelationship["Data"] = "Data";
+    AFRelationship["Alternative"] = "Alternative";
+    AFRelationship["Supplement"] = "Supplement";
+    AFRelationship["EncryptedPayload"] = "EncryptedPayload";
+    AFRelationship["FormData"] = "EncryptedPayload";
+    AFRelationship["Schema"] = "Schema";
+    AFRelationship["Unspecified"] = "Unspecified";
+})(AFRelationship || (AFRelationship = {}));
+var FileEmbedder = /** @class */ (function () {
+    function FileEmbedder(fileData, fileName, options) {
+        if (options === void 0) { options = {}; }
+        this.fileData = fileData;
+        this.fileName = fileName;
+        this.options = options;
+    }
+    FileEmbedder.for = function (bytes, fileName, options) {
+        if (options === void 0) { options = {}; }
+        return new FileEmbedder(bytes, fileName, options);
+    };
+    FileEmbedder.prototype.embedIntoContext = function (context, ref) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, mimeType, description, creationDate, modificationDate, afRelationship, embeddedFileStream, embeddedFileStreamRef, fileSpecDict;
+            return __generator(this, function (_b) {
+                _a = this.options, mimeType = _a.mimeType, description = _a.description, creationDate = _a.creationDate, modificationDate = _a.modificationDate, afRelationship = _a.afRelationship;
+                embeddedFileStream = context.flateStream(this.fileData, {
+                    Type: 'EmbeddedFile',
+                    Subtype: mimeType !== null && mimeType !== void 0 ? mimeType : undefined,
+                    Params: {
+                        Size: this.fileData.length,
+                        CreationDate: creationDate
+                            ? PDFString.fromDate(creationDate)
+                            : undefined,
+                        ModDate: modificationDate
+                            ? PDFString.fromDate(modificationDate)
+                            : undefined,
+                    },
+                });
+                embeddedFileStreamRef = context.register(embeddedFileStream);
+                fileSpecDict = context.obj({
+                    Type: 'Filespec',
+                    F: PDFString.of(this.fileName),
+                    UF: PDFHexString.fromText(this.fileName),
+                    EF: { F: embeddedFileStreamRef },
+                    Desc: description ? PDFHexString.fromText(description) : undefined,
+                    AFRelationship: afRelationship !== null && afRelationship !== void 0 ? afRelationship : undefined,
+                });
+                if (ref) {
+                    context.assign(ref, fileSpecDict);
+                    return [2 /*return*/, ref];
+                }
+                else {
+                    return [2 /*return*/, context.register(fileSpecDict)];
+                }
+            });
+        });
+    };
+    return FileEmbedder;
+}());
+
+export { AFRelationship, FileEmbedder as default };

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

@@ -0,0 +1,36 @@
+// prettier-ignore
+var makeFontFlags = function (options) {
+    var flags = 0;
+    var flipBit = function (bit) { flags |= (1 << (bit - 1)); };
+    if (options.fixedPitch)
+        flipBit(1);
+    if (options.serif)
+        flipBit(2);
+    flipBit(3);
+    if (options.script)
+        flipBit(4);
+    if (options.nonsymbolic)
+        flipBit(6);
+    if (options.italic)
+        flipBit(7);
+    if (options.allCap)
+        flipBit(17);
+    if (options.smallCap)
+        flipBit(18);
+    if (options.forceBold)
+        flipBit(19);
+    return flags;
+};
+// From: https://github.com/foliojs/pdfkit/blob/83f5f7243172a017adcf6a7faa5547c55982c57b/lib/font/embedded.js#L123-L129
+var deriveFontFlags = function (font) {
+    var familyClass = font['OS/2'] ? font['OS/2'].sFamilyClass : 0;
+    var flags = makeFontFlags({
+        fixedPitch: font.post.isFixedPitch,
+        serif: 1 <= familyClass && familyClass <= 7,
+        script: familyClass === 10,
+        italic: font.head.macStyle.italic,
+    });
+    return flags;
+};
+
+export { deriveFontFlags };

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

@@ -0,0 +1,34 @@
+import { __awaiter, __generator } from '../../../../tslib/tslib.es6.js';
+import PDFHexString from '../objects/PDFHexString.js';
+
+var JavaScriptEmbedder = /** @class */ (function () {
+    function JavaScriptEmbedder(script, scriptName) {
+        this.script = script;
+        this.scriptName = scriptName;
+    }
+    JavaScriptEmbedder.for = function (script, scriptName) {
+        return new JavaScriptEmbedder(script, scriptName);
+    };
+    JavaScriptEmbedder.prototype.embedIntoContext = function (context, ref) {
+        return __awaiter(this, void 0, void 0, function () {
+            var jsActionDict;
+            return __generator(this, function (_a) {
+                jsActionDict = context.obj({
+                    Type: 'Action',
+                    S: 'JavaScript',
+                    JS: PDFHexString.fromText(this.script),
+                });
+                if (ref) {
+                    context.assign(ref, jsActionDict);
+                    return [2 /*return*/, ref];
+                }
+                else {
+                    return [2 /*return*/, context.register(jsActionDict)];
+                }
+            });
+        });
+    };
+    return JavaScriptEmbedder;
+}());
+
+export { JavaScriptEmbedder as default };

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

@@ -0,0 +1,105 @@
+import { __awaiter, __generator } from '../../../../tslib/tslib.es6.js';
+
+// prettier-ignore
+var MARKERS = [
+    0xffc0, 0xffc1, 0xffc2,
+    0xffc3, 0xffc5, 0xffc6,
+    0xffc7, 0xffc8, 0xffc9,
+    0xffca, 0xffcb, 0xffcc,
+    0xffcd, 0xffce, 0xffcf,
+];
+var ColorSpace;
+(function (ColorSpace) {
+    ColorSpace["DeviceGray"] = "DeviceGray";
+    ColorSpace["DeviceRGB"] = "DeviceRGB";
+    ColorSpace["DeviceCMYK"] = "DeviceCMYK";
+})(ColorSpace || (ColorSpace = {}));
+var ChannelToColorSpace = {
+    1: ColorSpace.DeviceGray,
+    3: ColorSpace.DeviceRGB,
+    4: ColorSpace.DeviceCMYK,
+};
+/**
+ * A note of thanks to the developers of https://github.com/foliojs/pdfkit, as
+ * this class borrows from:
+ *   https://github.com/foliojs/pdfkit/blob/a6af76467ce06bd6a2af4aa7271ccac9ff152a7d/lib/image/jpeg.js
+ */
+var JpegEmbedder = /** @class */ (function () {
+    function JpegEmbedder(imageData, bitsPerComponent, width, height, colorSpace) {
+        this.imageData = imageData;
+        this.bitsPerComponent = bitsPerComponent;
+        this.width = width;
+        this.height = height;
+        this.colorSpace = colorSpace;
+    }
+    JpegEmbedder.for = function (imageData) {
+        return __awaiter(this, void 0, void 0, function () {
+            var dataView, soi, pos, marker, bitsPerComponent, height, width, channelByte, channelName, colorSpace;
+            return __generator(this, function (_a) {
+                dataView = new DataView(imageData.buffer);
+                soi = dataView.getUint16(0);
+                if (soi !== 0xffd8)
+                    throw new Error('SOI not found in JPEG');
+                pos = 2;
+                while (pos < dataView.byteLength) {
+                    marker = dataView.getUint16(pos);
+                    pos += 2;
+                    if (MARKERS.includes(marker))
+                        break;
+                    pos += dataView.getUint16(pos);
+                }
+                if (!MARKERS.includes(marker))
+                    throw new Error('Invalid JPEG');
+                pos += 2;
+                bitsPerComponent = dataView.getUint8(pos++);
+                height = dataView.getUint16(pos);
+                pos += 2;
+                width = dataView.getUint16(pos);
+                pos += 2;
+                channelByte = dataView.getUint8(pos++);
+                channelName = ChannelToColorSpace[channelByte];
+                if (!channelName)
+                    throw new Error('Unknown JPEG channel.');
+                colorSpace = channelName;
+                return [2 /*return*/, new JpegEmbedder(imageData, bitsPerComponent, width, height, colorSpace)];
+            });
+        });
+    };
+    JpegEmbedder.prototype.embedIntoContext = function (context, ref) {
+        return __awaiter(this, void 0, void 0, function () {
+            var xObject;
+            return __generator(this, function (_a) {
+                xObject = context.stream(this.imageData, {
+                    Type: 'XObject',
+                    Subtype: 'Image',
+                    BitsPerComponent: this.bitsPerComponent,
+                    Width: this.width,
+                    Height: this.height,
+                    ColorSpace: this.colorSpace,
+                    Filter: 'DCTDecode',
+                    // CMYK JPEG streams in PDF are typically stored complemented,
+                    // with 1 as 'off' and 0 as 'on' (PDF 32000-1:2008, 8.6.4.4).
+                    //
+                    // Standalone CMYK JPEG (usually exported by Photoshop) are
+                    // stored inverse, with 0 as 'off' and 1 as 'on', like RGB.
+                    //
+                    // Applying a swap here as a hedge that most bytes passing
+                    // through this method will benefit from it.
+                    Decode: this.colorSpace === ColorSpace.DeviceCMYK
+                        ? [1, 0, 1, 0, 1, 0, 1, 0]
+                        : undefined,
+                });
+                if (ref) {
+                    context.assign(ref, xObject);
+                    return [2 /*return*/, ref];
+                }
+                else {
+                    return [2 /*return*/, context.register(xObject)];
+                }
+            });
+        });
+    };
+    return JpegEmbedder;
+}());
+
+export { JpegEmbedder as default };

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

@@ -0,0 +1,94 @@
+import { __awaiter, __generator } from '../../../../tslib/tslib.es6.js';
+import { MissingPageContentsEmbeddingError, UnrecognizedStreamTypeError } from '../errors.js';
+import PDFNumber from '../objects/PDFNumber.js';
+import PDFRawStream from '../objects/PDFRawStream.js';
+import PDFStream from '../objects/PDFStream.js';
+import { decodePDFRawStream } from '../streams/decode.js';
+import PDFContentStream from '../structures/PDFContentStream.js';
+import CharCodes from '../syntax/CharCodes.js';
+import { mergeIntoTypedArray } from '../../utils/arrays.js';
+import '../../utils/unicode.js';
+import '../../utils/base64.js';
+import '../../utils/objects.js';
+import '../../utils/pdfDocEncoding.js';
+import '../../utils/Cache.js';
+
+var fullPageBoundingBox = function (page) {
+    var mediaBox = page.MediaBox();
+    var width = mediaBox.lookup(2, PDFNumber).asNumber() -
+        mediaBox.lookup(0, PDFNumber).asNumber();
+    var height = mediaBox.lookup(3, PDFNumber).asNumber() -
+        mediaBox.lookup(1, PDFNumber).asNumber();
+    return { left: 0, bottom: 0, right: width, top: height };
+};
+// Returns the identity matrix, modified to position the content of the given
+// bounding box at (0, 0).
+var boundingBoxAdjustedMatrix = function (bb) { return [1, 0, 0, 1, -bb.left, -bb.bottom]; };
+var PDFPageEmbedder = /** @class */ (function () {
+    function PDFPageEmbedder(page, boundingBox, transformationMatrix) {
+        this.page = page;
+        var bb = boundingBox !== null && boundingBox !== void 0 ? boundingBox : fullPageBoundingBox(page);
+        this.width = bb.right - bb.left;
+        this.height = bb.top - bb.bottom;
+        this.boundingBox = bb;
+        this.transformationMatrix = transformationMatrix !== null && transformationMatrix !== void 0 ? transformationMatrix : boundingBoxAdjustedMatrix(bb);
+    }
+    PDFPageEmbedder.for = function (page, boundingBox, transformationMatrix) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new PDFPageEmbedder(page, boundingBox, transformationMatrix)];
+            });
+        });
+    };
+    PDFPageEmbedder.prototype.embedIntoContext = function (context, ref) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, Contents, Resources, decodedContents, _b, left, bottom, right, top, xObject;
+            return __generator(this, function (_c) {
+                _a = this.page.normalizedEntries(), Contents = _a.Contents, Resources = _a.Resources;
+                if (!Contents)
+                    throw new MissingPageContentsEmbeddingError();
+                decodedContents = this.decodeContents(Contents);
+                _b = this.boundingBox, left = _b.left, bottom = _b.bottom, right = _b.right, top = _b.top;
+                xObject = context.flateStream(decodedContents, {
+                    Type: 'XObject',
+                    Subtype: 'Form',
+                    FormType: 1,
+                    BBox: [left, bottom, right, top],
+                    Matrix: this.transformationMatrix,
+                    Resources: Resources,
+                });
+                if (ref) {
+                    context.assign(ref, xObject);
+                    return [2 /*return*/, ref];
+                }
+                else {
+                    return [2 /*return*/, context.register(xObject)];
+                }
+            });
+        });
+    };
+    // `contents` is an array of streams which are merged to include them in the XObject.
+    // This methods extracts each stream and joins them with a newline character.
+    PDFPageEmbedder.prototype.decodeContents = function (contents) {
+        var newline = Uint8Array.of(CharCodes.Newline);
+        var decodedContents = [];
+        for (var idx = 0, len = contents.size(); idx < len; idx++) {
+            var stream = contents.lookup(idx, PDFStream);
+            var content = void 0;
+            if (stream instanceof PDFRawStream) {
+                content = decodePDFRawStream(stream).decode();
+            }
+            else if (stream instanceof PDFContentStream) {
+                content = stream.getUnencodedContents();
+            }
+            else {
+                throw new UnrecognizedStreamTypeError(stream);
+            }
+            decodedContents.push(content, newline);
+        }
+        return mergeIntoTypedArray.apply(void 0, decodedContents);
+    };
+    return PDFPageEmbedder;
+}());
+
+export { PDFPageEmbedder as default };