art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,77 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var CustomFontEmbedder = require('./CustomFontEmbedder.js');
+var PDFHexString = require('../objects/PDFHexString.js');
+var arrays = require('../../utils/arrays.js');
+var strings = require('../../utils/strings.js');
+require('../../utils/unicode.js');
+require('../../utils/base64.js');
+require('../../utils/objects.js');
+require('../../utils/pdfDocEncoding.js');
+var Cache = require('../../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) {
+    tslib_es6.__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.default.populatedBy(function () { return _this.glyphs; });
+        _this.glyphIdMap = new Map();
+        return _this;
+    }
+    CustomFontSubsetEmbedder.for = function (fontkit, fontData, customFontName, fontFeatures) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function () {
+            var font;
+            return tslib_es6.__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] = strings.toHexStringOfMinLength(subsetGlyphId, 4);
+        }
+        this.glyphCache.invalidate();
+        return PDFHexString.default.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(arrays.mergeUint8Arrays(parts)); })
+                .on('error', function (err) { return reject(err); });
+        });
+    };
+    return CustomFontSubsetEmbedder;
+}(CustomFontEmbedder.default));
+
+exports.default = CustomFontSubsetEmbedder;

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

@@ -0,0 +1,76 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFString = require('../objects/PDFString.js');
+var PDFHexString = require('../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
+ */
+exports.AFRelationship = void 0;
+(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";
+})(exports.AFRelationship || (exports.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 tslib_es6.__awaiter(this, void 0, void 0, function () {
+            var _a, mimeType, description, creationDate, modificationDate, afRelationship, embeddedFileStream, embeddedFileStreamRef, fileSpecDict;
+            return tslib_es6.__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.default.fromDate(creationDate)
+                            : undefined,
+                        ModDate: modificationDate
+                            ? PDFString.default.fromDate(modificationDate)
+                            : undefined,
+                    },
+                });
+                embeddedFileStreamRef = context.register(embeddedFileStream);
+                fileSpecDict = context.obj({
+                    Type: 'Filespec',
+                    F: PDFString.default.of(this.fileName),
+                    UF: PDFHexString.default.fromText(this.fileName),
+                    EF: { F: embeddedFileStreamRef },
+                    Desc: description ? PDFHexString.default.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;
+}());
+
+exports.default = FileEmbedder;

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

@@ -0,0 +1,38 @@
+'use strict';
+
+// 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;
+};
+
+exports.deriveFontFlags = deriveFontFlags;

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

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var PDFHexString = require('../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 tslib_es6.__awaiter(this, void 0, void 0, function () {
+            var jsActionDict;
+            return tslib_es6.__generator(this, function (_a) {
+                jsActionDict = context.obj({
+                    Type: 'Action',
+                    S: 'JavaScript',
+                    JS: PDFHexString.default.fromText(this.script),
+                });
+                if (ref) {
+                    context.assign(ref, jsActionDict);
+                    return [2 /*return*/, ref];
+                }
+                else {
+                    return [2 /*return*/, context.register(jsActionDict)];
+                }
+            });
+        });
+    };
+    return JavaScriptEmbedder;
+}());
+
+exports.default = JavaScriptEmbedder;

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

@@ -0,0 +1,109 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../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 tslib_es6.__awaiter(this, void 0, void 0, function () {
+            var dataView, soi, pos, marker, bitsPerComponent, height, width, channelByte, channelName, colorSpace;
+            return tslib_es6.__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 tslib_es6.__awaiter(this, void 0, void 0, function () {
+            var xObject;
+            return tslib_es6.__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;
+}());
+
+exports.default = JpegEmbedder;

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

@@ -0,0 +1,98 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var errors = require('../errors.js');
+var PDFNumber = require('../objects/PDFNumber.js');
+var PDFRawStream = require('../objects/PDFRawStream.js');
+var PDFStream = require('../objects/PDFStream.js');
+var decode = require('../streams/decode.js');
+var PDFContentStream = require('../structures/PDFContentStream.js');
+var CharCodes = require('../syntax/CharCodes.js');
+var arrays = require('../../utils/arrays.js');
+require('../../utils/unicode.js');
+require('../../utils/base64.js');
+require('../../utils/objects.js');
+require('../../utils/pdfDocEncoding.js');
+require('../../utils/Cache.js');
+
+var fullPageBoundingBox = function (page) {
+    var mediaBox = page.MediaBox();
+    var width = mediaBox.lookup(2, PDFNumber.default).asNumber() -
+        mediaBox.lookup(0, PDFNumber.default).asNumber();
+    var height = mediaBox.lookup(3, PDFNumber.default).asNumber() -
+        mediaBox.lookup(1, PDFNumber.default).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 tslib_es6.__awaiter(this, void 0, void 0, function () {
+            return tslib_es6.__generator(this, function (_a) {
+                return [2 /*return*/, new PDFPageEmbedder(page, boundingBox, transformationMatrix)];
+            });
+        });
+    };
+    PDFPageEmbedder.prototype.embedIntoContext = function (context, ref) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function () {
+            var _a, Contents, Resources, decodedContents, _b, left, bottom, right, top, xObject;
+            return tslib_es6.__generator(this, function (_c) {
+                _a = this.page.normalizedEntries(), Contents = _a.Contents, Resources = _a.Resources;
+                if (!Contents)
+                    throw new errors.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.default.Newline);
+        var decodedContents = [];
+        for (var idx = 0, len = contents.size(); idx < len; idx++) {
+            var stream = contents.lookup(idx, PDFStream.default);
+            var content = void 0;
+            if (stream instanceof PDFRawStream.default) {
+                content = decode.decodePDFRawStream(stream).decode();
+            }
+            else if (stream instanceof PDFContentStream.default) {
+                content = stream.getUnencodedContents();
+            }
+            else {
+                throw new errors.UnrecognizedStreamTypeError(stream);
+            }
+            decodedContents.push(content, newline);
+        }
+        return arrays.mergeIntoTypedArray.apply(void 0, decodedContents);
+    };
+    return PDFPageEmbedder;
+}());
+
+exports.default = PDFPageEmbedder;

package/dist/cjs/node_modules/pdf-lib/es/core/embedders/PngEmbedder.js

@@ -0,0 +1,71 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../tslib/tslib.es6.js');
+var png = require('../../utils/png.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/png.coffee
+ */
+var PngEmbedder = /** @class */ (function () {
+    function PngEmbedder(png) {
+        this.image = png;
+        this.bitsPerComponent = png.bitsPerComponent;
+        this.width = png.width;
+        this.height = png.height;
+        this.colorSpace = 'DeviceRGB';
+    }
+    PngEmbedder.for = function (imageData) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function () {
+            var png$1;
+            return tslib_es6.__generator(this, function (_a) {
+                png$1 = png.PNG.load(imageData);
+                return [2 /*return*/, new PngEmbedder(png$1)];
+            });
+        });
+    };
+    PngEmbedder.prototype.embedIntoContext = function (context, ref) {
+        return tslib_es6.__awaiter(this, void 0, void 0, function () {
+            var SMask, xObject;
+            return tslib_es6.__generator(this, function (_a) {
+                SMask = this.embedAlphaChannel(context);
+                xObject = context.flateStream(this.image.rgbChannel, {
+                    Type: 'XObject',
+                    Subtype: 'Image',
+                    BitsPerComponent: this.image.bitsPerComponent,
+                    Width: this.image.width,
+                    Height: this.image.height,
+                    ColorSpace: this.colorSpace,
+                    SMask: SMask,
+                });
+                if (ref) {
+                    context.assign(ref, xObject);
+                    return [2 /*return*/, ref];
+                }
+                else {
+                    return [2 /*return*/, context.register(xObject)];
+                }
+            });
+        });
+    };
+    PngEmbedder.prototype.embedAlphaChannel = function (context) {
+        if (!this.image.alphaChannel)
+            return undefined;
+        var xObject = context.flateStream(this.image.alphaChannel, {
+            Type: 'XObject',
+            Subtype: 'Image',
+            Height: this.image.height,
+            Width: this.image.width,
+            BitsPerComponent: this.image.bitsPerComponent,
+            ColorSpace: 'DeviceGray',
+            Decode: [0, 1],
+        });
+        return context.register(xObject);
+    };
+    return PngEmbedder;
+}());
+
+exports.default = PngEmbedder;

package/dist/cjs/node_modules/pdf-lib/es/core/embedders/StandardFontEmbedder.js

@@ -0,0 +1,106 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Font = require('../../../../@pdf-lib/standard-fonts/es/Font.js');
+var Encoding = require('../../../../@pdf-lib/standard-fonts/es/Encoding.js');
+var PDFHexString = require('../objects/PDFHexString.js');
+require('../../utils/base64.js');
+var strings = require('../../utils/strings.js');
+require('../../utils/unicode.js');
+require('../../utils/objects.js');
+require('../../utils/pdfDocEncoding.js');
+require('../../utils/Cache.js');
+
+/**
+ * A note of thanks to the developers of https://github.com/foliojs/pdfkit, as
+ * this class borrows from:
+ *   https://github.com/foliojs/pdfkit/blob/f91bdd61c164a72ea06be1a43dc0a412afc3925f/lib/font/afm.coffee
+ */
+var StandardFontEmbedder = /** @class */ (function () {
+    function StandardFontEmbedder(fontName, customName) {
+        // prettier-ignore
+        this.encoding = (fontName === Font.FontNames.ZapfDingbats ? Encoding.Encodings.ZapfDingbats
+            : fontName === Font.FontNames.Symbol ? Encoding.Encodings.Symbol
+                : Encoding.Encodings.WinAnsi);
+        this.font = Font.Font.load(fontName);
+        this.fontName = this.font.FontName;
+        this.customName = customName;
+    }
+    /**
+     * Encode the JavaScript string into this font. (JavaScript encodes strings in
+     * Unicode, but standard fonts use either WinAnsi, ZapfDingbats, or Symbol
+     * encodings)
+     */
+    StandardFontEmbedder.prototype.encodeText = function (text) {
+        var glyphs = this.encodeTextAsGlyphs(text);
+        var hexCodes = new Array(glyphs.length);
+        for (var idx = 0, len = glyphs.length; idx < len; idx++) {
+            hexCodes[idx] = strings.toHexString(glyphs[idx].code);
+        }
+        return PDFHexString.default.of(hexCodes.join(''));
+    };
+    StandardFontEmbedder.prototype.widthOfTextAtSize = function (text, size) {
+        var glyphs = this.encodeTextAsGlyphs(text);
+        var totalWidth = 0;
+        for (var idx = 0, len = glyphs.length; idx < len; idx++) {
+            var left = glyphs[idx].name;
+            var right = (glyphs[idx + 1] || {}).name;
+            var kernAmount = this.font.getXAxisKerningForPair(left, right) || 0;
+            totalWidth += this.widthOfGlyph(left) + kernAmount;
+        }
+        var scale = size / 1000;
+        return totalWidth * scale;
+    };
+    StandardFontEmbedder.prototype.heightOfFontAtSize = function (size, options) {
+        if (options === void 0) { options = {}; }
+        var _a = options.descender, descender = _a === void 0 ? true : _a;
+        var _b = this.font, Ascender = _b.Ascender, Descender = _b.Descender, FontBBox = _b.FontBBox;
+        var yTop = Ascender || FontBBox[3];
+        var yBottom = Descender || FontBBox[1];
+        var height = yTop - yBottom;
+        if (!descender)
+            height += Descender || 0;
+        return (height / 1000) * size;
+    };
+    StandardFontEmbedder.prototype.sizeOfFontAtHeight = function (height) {
+        var _a = this.font, Ascender = _a.Ascender, Descender = _a.Descender, FontBBox = _a.FontBBox;
+        var yTop = Ascender || FontBBox[3];
+        var yBottom = Descender || FontBBox[1];
+        return (1000 * height) / (yTop - yBottom);
+    };
+    StandardFontEmbedder.prototype.embedIntoContext = function (context, ref) {
+        var fontDict = context.obj({
+            Type: 'Font',
+            Subtype: 'Type1',
+            BaseFont: this.customName || this.fontName,
+            Encoding: this.encoding === Encoding.Encodings.WinAnsi ? 'WinAnsiEncoding' : undefined,
+        });
+        if (ref) {
+            context.assign(ref, fontDict);
+            return ref;
+        }
+        else {
+            return context.register(fontDict);
+        }
+    };
+    StandardFontEmbedder.prototype.widthOfGlyph = function (glyphName) {
+        // Default to 250 if font doesn't specify a width
+        return this.font.getWidthOfGlyph(glyphName) || 250;
+    };
+    StandardFontEmbedder.prototype.encodeTextAsGlyphs = function (text) {
+        var codePoints = Array.from(text);
+        var glyphs = new Array(codePoints.length);
+        for (var idx = 0, len = codePoints.length; idx < len; idx++) {
+            var codePoint = strings.toCodePoint(codePoints[idx]);
+            glyphs[idx] = this.encoding.encodeUnicodeCodePoint(codePoint);
+        }
+        return glyphs;
+    };
+    StandardFontEmbedder.for = function (fontName, customName) {
+        return new StandardFontEmbedder(fontName, customName);
+    };
+    return StandardFontEmbedder;
+}());
+
+exports.default = StandardFontEmbedder;