@pdfme/pdf-lib 1.18.1 → 1.18.4

package/dist/pdf-lib.esm.js

@@ -16043,13 +16043,22 @@ class PDFContext {
         return PDFRawStream.of(this.obj(dict), typedArrayFor(contents));
     }
     flateStream(contents, dict = {}) {
-        return this.stream(pako_1$1.deflate(typedArrayFor(contents)), Object.assign(Object.assign({}, dict), { Filter: 'FlateDecode' }));
+        return this.stream(pako_1$1.deflate(typedArrayFor(contents)), {
+            ...dict,
+            Filter: 'FlateDecode',
+        });
     }
     contentStream(operators, dict = {}) {
         return PDFContentStream.of(this.obj(dict), operators);
     }
     formXObject(operators, dict = {}) {
-        return this.contentStream(operators, Object.assign(Object.assign({ BBox: this.obj([0, 0, 0, 0]), Matrix: this.obj([1, 0, 0, 1, 0, 0]) }, dict), { Type: 'XObject', Subtype: 'Form' }));
+        return this.contentStream(operators, {
+            BBox: this.obj([0, 0, 0, 0]),
+            Matrix: this.obj([1, 0, 0, 1, 0, 0]),
+            ...dict,
+            Type: 'XObject',
+            Subtype: 'Form',
+        });
     }
     /*
      * Reference to PDFContentStream that contains a single PDFOperator: `q`.
@@ -16384,43 +16393,6 @@ class PDFObjectCopier {
 }
 PDFObjectCopier.for = (src, dest) => new PDFObjectCopier(src, dest);
 
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
 /**
  * Entries should be added using the [[addEntry]] and [[addDeletedEntry]]
  * methods **in order of ascending object number**.
@@ -16666,52 +16638,50 @@ class PDFWriter {
         this.context = context;
         this.objectsPerTick = objectsPerTick;
     }
-    serializeToBuffer() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { size, header, indirectObjects, xref, trailerDict, trailer } = yield this.computeBufferSize();
-            let offset = 0;
-            const buffer = new Uint8Array(size);
-            offset += header.copyBytesInto(buffer, offset);
+    async serializeToBuffer() {
+        const { size, header, indirectObjects, xref, trailerDict, trailer } = await this.computeBufferSize();
+        let offset = 0;
+        const buffer = new Uint8Array(size);
+        offset += header.copyBytesInto(buffer, offset);
+        buffer[offset++] = CharCodes$1.Newline;
+        buffer[offset++] = CharCodes$1.Newline;
+        for (let idx = 0, len = indirectObjects.length; idx < len; idx++) {
+            const [ref, object] = indirectObjects[idx];
+            const objectNumber = String(ref.objectNumber);
+            offset += copyStringIntoBuffer(objectNumber, buffer, offset);
+            buffer[offset++] = CharCodes$1.Space;
+            const generationNumber = String(ref.generationNumber);
+            offset += copyStringIntoBuffer(generationNumber, buffer, offset);
+            buffer[offset++] = CharCodes$1.Space;
+            buffer[offset++] = CharCodes$1.o;
+            buffer[offset++] = CharCodes$1.b;
+            buffer[offset++] = CharCodes$1.j;
             buffer[offset++] = CharCodes$1.Newline;
+            offset += object.copyBytesInto(buffer, offset);
             buffer[offset++] = CharCodes$1.Newline;
-            for (let idx = 0, len = indirectObjects.length; idx < len; idx++) {
-                const [ref, object] = indirectObjects[idx];
-                const objectNumber = String(ref.objectNumber);
-                offset += copyStringIntoBuffer(objectNumber, buffer, offset);
-                buffer[offset++] = CharCodes$1.Space;
-                const generationNumber = String(ref.generationNumber);
-                offset += copyStringIntoBuffer(generationNumber, buffer, offset);
-                buffer[offset++] = CharCodes$1.Space;
-                buffer[offset++] = CharCodes$1.o;
-                buffer[offset++] = CharCodes$1.b;
-                buffer[offset++] = CharCodes$1.j;
-                buffer[offset++] = CharCodes$1.Newline;
-                offset += object.copyBytesInto(buffer, offset);
-                buffer[offset++] = CharCodes$1.Newline;
-                buffer[offset++] = CharCodes$1.e;
-                buffer[offset++] = CharCodes$1.n;
-                buffer[offset++] = CharCodes$1.d;
-                buffer[offset++] = CharCodes$1.o;
-                buffer[offset++] = CharCodes$1.b;
-                buffer[offset++] = CharCodes$1.j;
-                buffer[offset++] = CharCodes$1.Newline;
-                buffer[offset++] = CharCodes$1.Newline;
-                const n = object instanceof PDFObjectStream ? object.getObjectsCount() : 1;
-                if (this.shouldWaitForTick(n))
-                    yield waitForTick();
-            }
-            if (xref) {
-                offset += xref.copyBytesInto(buffer, offset);
-                buffer[offset++] = CharCodes$1.Newline;
-            }
-            if (trailerDict) {
-                offset += trailerDict.copyBytesInto(buffer, offset);
-                buffer[offset++] = CharCodes$1.Newline;
-                buffer[offset++] = CharCodes$1.Newline;
-            }
-            offset += trailer.copyBytesInto(buffer, offset);
-            return buffer;
-        });
+            buffer[offset++] = CharCodes$1.e;
+            buffer[offset++] = CharCodes$1.n;
+            buffer[offset++] = CharCodes$1.d;
+            buffer[offset++] = CharCodes$1.o;
+            buffer[offset++] = CharCodes$1.b;
+            buffer[offset++] = CharCodes$1.j;
+            buffer[offset++] = CharCodes$1.Newline;
+            buffer[offset++] = CharCodes$1.Newline;
+            const n = object instanceof PDFObjectStream ? object.getObjectsCount() : 1;
+            if (this.shouldWaitForTick(n))
+                await waitForTick();
+        }
+        if (xref) {
+            offset += xref.copyBytesInto(buffer, offset);
+            buffer[offset++] = CharCodes$1.Newline;
+        }
+        if (trailerDict) {
+            offset += trailerDict.copyBytesInto(buffer, offset);
+            buffer[offset++] = CharCodes$1.Newline;
+            buffer[offset++] = CharCodes$1.Newline;
+        }
+        offset += trailer.copyBytesInto(buffer, offset);
+        return buffer;
     }
     computeIndirectObjectSize([ref, object]) {
         const refSize = ref.sizeInBytes() + 3; // 'R' -> 'obj\n'
@@ -16727,28 +16697,26 @@ class PDFWriter {
             ID: this.context.trailerInfo.ID,
         });
     }
-    computeBufferSize() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const header = PDFHeader.forVersion(1, 7);
-            let size = header.sizeInBytes() + 2;
-            const xref = PDFCrossRefSection.create();
-            const indirectObjects = this.context.enumerateIndirectObjects();
-            for (let idx = 0, len = indirectObjects.length; idx < len; idx++) {
-                const indirectObject = indirectObjects[idx];
-                const [ref] = indirectObject;
-                xref.addEntry(ref, size);
-                size += this.computeIndirectObjectSize(indirectObject);
-                if (this.shouldWaitForTick(1))
-                    yield waitForTick();
-            }
-            const xrefOffset = size;
-            size += xref.sizeInBytes() + 1; // '\n'
-            const trailerDict = PDFTrailerDict.of(this.createTrailerDict());
-            size += trailerDict.sizeInBytes() + 2; // '\n\n'
-            const trailer = PDFTrailer.forLastCrossRefSectionOffset(xrefOffset);
-            size += trailer.sizeInBytes();
-            return { size, header, indirectObjects, xref, trailerDict, trailer };
-        });
+    async computeBufferSize() {
+        const header = PDFHeader.forVersion(1, 7);
+        let size = header.sizeInBytes() + 2;
+        const xref = PDFCrossRefSection.create();
+        const indirectObjects = this.context.enumerateIndirectObjects();
+        for (let idx = 0, len = indirectObjects.length; idx < len; idx++) {
+            const indirectObject = indirectObjects[idx];
+            const [ref] = indirectObject;
+            xref.addEntry(ref, size);
+            size += this.computeIndirectObjectSize(indirectObject);
+            if (this.shouldWaitForTick(1))
+                await waitForTick();
+        }
+        const xrefOffset = size;
+        size += xref.sizeInBytes() + 1; // '\n'
+        const trailerDict = PDFTrailerDict.of(this.createTrailerDict());
+        size += trailerDict.sizeInBytes() + 2; // '\n\n'
+        const trailer = PDFTrailer.forLastCrossRefSectionOffset(xrefOffset);
+        size += trailer.sizeInBytes();
+        return { size, header, indirectObjects, xref, trailerDict, trailer };
     }
 }
 PDFWriter.forContext = (context, objectsPerTick) => new PDFWriter(context, objectsPerTick);
@@ -16953,63 +16921,61 @@ class PDFStreamWriter extends PDFWriter {
         this.encodeStreams = encodeStreams;
         this.objectsPerStream = objectsPerStream;
     }
-    computeBufferSize() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let objectNumber = this.context.largestObjectNumber + 1;
-            const header = PDFHeader.forVersion(1, 7);
-            let size = header.sizeInBytes() + 2;
-            const xrefStream = PDFCrossRefStream.create(this.createTrailerDict(), this.encodeStreams);
-            const uncompressedObjects = [];
-            const compressedObjects = [];
-            const objectStreamRefs = [];
-            const indirectObjects = this.context.enumerateIndirectObjects();
-            for (let idx = 0, len = indirectObjects.length; idx < len; idx++) {
-                const indirectObject = indirectObjects[idx];
-                const [ref, object] = indirectObject;
-                const shouldNotCompress = ref === this.context.trailerInfo.Encrypt ||
-                    object instanceof PDFStream ||
-                    object instanceof PDFInvalidObject ||
-                    ref.generationNumber !== 0;
-                if (shouldNotCompress) {
-                    uncompressedObjects.push(indirectObject);
-                    xrefStream.addUncompressedEntry(ref, size);
-                    size += this.computeIndirectObjectSize(indirectObject);
-                    if (this.shouldWaitForTick(1))
-                        yield waitForTick();
-                }
-                else {
-                    let chunk = last(compressedObjects);
-                    let objectStreamRef = last(objectStreamRefs);
-                    if (!chunk || chunk.length % this.objectsPerStream === 0) {
-                        chunk = [];
-                        compressedObjects.push(chunk);
-                        objectStreamRef = PDFRef.of(objectNumber++);
-                        objectStreamRefs.push(objectStreamRef);
-                    }
-                    xrefStream.addCompressedEntry(ref, objectStreamRef, chunk.length);
-                    chunk.push(indirectObject);
-                }
-            }
-            for (let idx = 0, len = compressedObjects.length; idx < len; idx++) {
-                const chunk = compressedObjects[idx];
-                const ref = objectStreamRefs[idx];
-                const objectStream = PDFObjectStream.withContextAndObjects(this.context, chunk, this.encodeStreams);
+    async computeBufferSize() {
+        let objectNumber = this.context.largestObjectNumber + 1;
+        const header = PDFHeader.forVersion(1, 7);
+        let size = header.sizeInBytes() + 2;
+        const xrefStream = PDFCrossRefStream.create(this.createTrailerDict(), this.encodeStreams);
+        const uncompressedObjects = [];
+        const compressedObjects = [];
+        const objectStreamRefs = [];
+        const indirectObjects = this.context.enumerateIndirectObjects();
+        for (let idx = 0, len = indirectObjects.length; idx < len; idx++) {
+            const indirectObject = indirectObjects[idx];
+            const [ref, object] = indirectObject;
+            const shouldNotCompress = ref === this.context.trailerInfo.Encrypt ||
+                object instanceof PDFStream ||
+                object instanceof PDFInvalidObject ||
+                ref.generationNumber !== 0;
+            if (shouldNotCompress) {
+                uncompressedObjects.push(indirectObject);
                 xrefStream.addUncompressedEntry(ref, size);
-                size += this.computeIndirectObjectSize([ref, objectStream]);
-                uncompressedObjects.push([ref, objectStream]);
-                if (this.shouldWaitForTick(chunk.length))
-                    yield waitForTick();
-            }
-            const xrefStreamRef = PDFRef.of(objectNumber++);
-            xrefStream.dict.set(PDFName.of('Size'), PDFNumber.of(objectNumber));
-            xrefStream.addUncompressedEntry(xrefStreamRef, size);
-            const xrefOffset = size;
-            size += this.computeIndirectObjectSize([xrefStreamRef, xrefStream]);
-            uncompressedObjects.push([xrefStreamRef, xrefStream]);
-            const trailer = PDFTrailer.forLastCrossRefSectionOffset(xrefOffset);
-            size += trailer.sizeInBytes();
-            return { size, header, indirectObjects: uncompressedObjects, trailer };
-        });
+                size += this.computeIndirectObjectSize(indirectObject);
+                if (this.shouldWaitForTick(1))
+                    await waitForTick();
+            }
+            else {
+                let chunk = last(compressedObjects);
+                let objectStreamRef = last(objectStreamRefs);
+                if (!chunk || chunk.length % this.objectsPerStream === 0) {
+                    chunk = [];
+                    compressedObjects.push(chunk);
+                    objectStreamRef = PDFRef.of(objectNumber++);
+                    objectStreamRefs.push(objectStreamRef);
+                }
+                xrefStream.addCompressedEntry(ref, objectStreamRef, chunk.length);
+                chunk.push(indirectObject);
+            }
+        }
+        for (let idx = 0, len = compressedObjects.length; idx < len; idx++) {
+            const chunk = compressedObjects[idx];
+            const ref = objectStreamRefs[idx];
+            const objectStream = PDFObjectStream.withContextAndObjects(this.context, chunk, this.encodeStreams);
+            xrefStream.addUncompressedEntry(ref, size);
+            size += this.computeIndirectObjectSize([ref, objectStream]);
+            uncompressedObjects.push([ref, objectStream]);
+            if (this.shouldWaitForTick(chunk.length))
+                await waitForTick();
+        }
+        const xrefStreamRef = PDFRef.of(objectNumber++);
+        xrefStream.dict.set(PDFName.of('Size'), PDFNumber.of(objectNumber));
+        xrefStream.addUncompressedEntry(xrefStreamRef, size);
+        const xrefOffset = size;
+        size += this.computeIndirectObjectSize([xrefStreamRef, xrefStream]);
+        uncompressedObjects.push([xrefStreamRef, xrefStream]);
+        const trailer = PDFTrailer.forLastCrossRefSectionOffset(xrefOffset);
+        size += trailer.sizeInBytes();
+        return { size, header, indirectObjects: uncompressedObjects, trailer };
     }
 }
 PDFStreamWriter.forContext = (context, objectsPerTick, encodeStreams = true, objectsPerStream = 50) => new PDFStreamWriter(context, objectsPerTick, encodeStreams, objectsPerStream);
@@ -17380,11 +17346,9 @@ class CustomFontEmbedder {
         this.baseFontName = '';
         this.glyphCache = Cache.populatedBy(this.allGlyphsInFontSortedById);
     }
-    static for(fontkit, fontData, customName, fontFeatures) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const font = yield fontkit.create(fontData);
-            return new CustomFontEmbedder(font, fontData, customName, fontFeatures);
-        });
+    static async for(fontkit, fontData, customName, fontFeatures) {
+        const font = await fontkit.create(fontData);
+        return new CustomFontEmbedder(font, fontData, customName, fontFeatures);
     }
     /**
      * Encode the JavaScript string into this font. (JavaScript encodes strings in
@@ -17430,85 +17394,75 @@ class CustomFontEmbedder {
             this.customName || context.addRandomSuffix(this.fontName);
         return this.embedFontDict(context, ref);
     }
-    embedFontDict(context, ref) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const cidFontDictRef = yield this.embedCIDFontDict(context);
-            const unicodeCMapRef = this.embedUnicodeCmap(context);
-            const fontDict = context.obj({
-                Type: 'Font',
-                Subtype: 'Type0',
-                BaseFont: this.baseFontName,
-                Encoding: 'Identity-H',
-                DescendantFonts: [cidFontDictRef],
-                ToUnicode: unicodeCMapRef,
-            });
-            if (ref) {
-                context.assign(ref, fontDict);
-                return ref;
-            }
-            else {
-                return context.register(fontDict);
-            }
+    async embedFontDict(context, ref) {
+        const cidFontDictRef = await this.embedCIDFontDict(context);
+        const unicodeCMapRef = this.embedUnicodeCmap(context);
+        const fontDict = context.obj({
+            Type: 'Font',
+            Subtype: 'Type0',
+            BaseFont: this.baseFontName,
+            Encoding: 'Identity-H',
+            DescendantFonts: [cidFontDictRef],
+            ToUnicode: unicodeCMapRef,
         });
+        if (ref) {
+            context.assign(ref, fontDict);
+            return ref;
+        }
+        else {
+            return context.register(fontDict);
+        }
     }
     isCFF() {
         return this.font.cff;
     }
-    embedCIDFontDict(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fontDescriptorRef = yield this.embedFontDescriptor(context);
-            const 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 context.register(cidFontDict);
+    async embedCIDFontDict(context) {
+        const fontDescriptorRef = await this.embedFontDescriptor(context);
+        const 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(),
         });
-    }
-    embedFontDescriptor(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fontStreamRef = yield this.embedFontStream(context);
-            const { scale } = this;
-            const { italicAngle, ascent, descent, capHeight, xHeight } = this.font;
-            const { minX, minY, maxX, maxY } = this.font.bbox;
-            const fontDescriptor = context.obj({
-                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,
-                [this.isCFF() ? 'FontFile3' : 'FontFile2']: fontStreamRef,
-            });
-            return context.register(fontDescriptor);
+        return context.register(cidFontDict);
+    }
+    async embedFontDescriptor(context) {
+        const fontStreamRef = await this.embedFontStream(context);
+        const { scale } = this;
+        const { italicAngle, ascent, descent, capHeight, xHeight } = this.font;
+        const { minX, minY, maxX, maxY } = this.font.bbox;
+        const fontDescriptor = context.obj({
+            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,
+            [this.isCFF() ? 'FontFile3' : 'FontFile2']: fontStreamRef,
         });
+        return context.register(fontDescriptor);
     }
-    serializeFont() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.fontData;
-        });
+    async serializeFont() {
+        return this.fontData;
     }
-    embedFontStream(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fontStream = context.flateStream(yield this.serializeFont(), {
-                Subtype: this.isCFF() ? 'CIDFontType0C' : undefined,
-            });
-            return context.register(fontStream);
+    async embedFontStream(context) {
+        const fontStream = context.flateStream(await this.serializeFont(), {
+            Subtype: this.isCFF() ? 'CIDFontType0C' : undefined,
         });
+        return context.register(fontStream);
     }
     embedUnicodeCmap(context) {
         const cmap = createCmap(this.glyphCache.access(), this.glyphId.bind(this));
@@ -17555,11 +17509,9 @@ class CustomFontSubsetEmbedder extends CustomFontEmbedder {
         this.glyphCache = Cache.populatedBy(() => this.glyphs);
         this.glyphIdMap = new Map();
     }
-    static for(fontkit, fontData, customFontName, fontFeatures) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const font = yield fontkit.create(fontData);
-            return new CustomFontSubsetEmbedder(font, fontData, customFontName, fontFeatures);
-        });
+    static async for(fontkit, fontData, customFontName, fontFeatures) {
+        const font = await fontkit.create(fontData);
+        return new CustomFontSubsetEmbedder(font, fontData, customFontName, fontFeatures);
     }
     encodeText(text) {
         const { glyphs } = this.font.layout(text, this.fontFeatures);
@@ -17630,39 +17582,37 @@ class FileEmbedder {
     static for(bytes, fileName, options = {}) {
         return new FileEmbedder(bytes, fileName, options);
     }
-    embedIntoContext(context, ref) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { mimeType, description, creationDate, modificationDate, afRelationship, } = this.options;
-            const 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,
-                },
-            });
-            const embeddedFileStreamRef = context.register(embeddedFileStream);
-            const 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 ref;
-            }
-            else {
-                return context.register(fileSpecDict);
-            }
+    async embedIntoContext(context, ref) {
+        const { mimeType, description, creationDate, modificationDate, afRelationship, } = this.options;
+        const 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,
+            },
+        });
+        const embeddedFileStreamRef = context.register(embeddedFileStream);
+        const 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 ref;
+        }
+        else {
+            return context.register(fileSpecDict);
+        }
     }
 }
 
@@ -17698,67 +17648,63 @@ class JpegEmbedder {
         this.height = height;
         this.colorSpace = colorSpace;
     }
-    static for(imageData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const dataView = new DataView(imageData.buffer);
-            const soi = dataView.getUint16(0);
-            if (soi !== 0xffd8)
-                throw new Error('SOI not found in JPEG');
-            let pos = 2;
-            let marker;
-            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;
-            const bitsPerComponent = dataView.getUint8(pos++);
-            const height = dataView.getUint16(pos);
+    static async for(imageData) {
+        const dataView = new DataView(imageData.buffer);
+        const soi = dataView.getUint16(0);
+        if (soi !== 0xffd8)
+            throw new Error('SOI not found in JPEG');
+        let pos = 2;
+        let marker;
+        while (pos < dataView.byteLength) {
+            marker = dataView.getUint16(pos);
             pos += 2;
-            const width = dataView.getUint16(pos);
-            pos += 2;
-            const channelByte = dataView.getUint8(pos++);
-            const channelName = ChannelToColorSpace[channelByte];
-            if (!channelName)
-                throw new Error('Unknown JPEG channel.');
-            const colorSpace = channelName;
-            return new JpegEmbedder(imageData, bitsPerComponent, width, height, colorSpace);
-        });
-    }
-    embedIntoContext(context, ref) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const 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 ref;
-            }
-            else {
-                return context.register(xObject);
-            }
+            if (MARKERS.includes(marker))
+                break;
+            pos += dataView.getUint16(pos);
+        }
+        if (!MARKERS.includes(marker))
+            throw new Error('Invalid JPEG');
+        pos += 2;
+        const bitsPerComponent = dataView.getUint8(pos++);
+        const height = dataView.getUint16(pos);
+        pos += 2;
+        const width = dataView.getUint16(pos);
+        pos += 2;
+        const channelByte = dataView.getUint8(pos++);
+        const channelName = ChannelToColorSpace[channelByte];
+        if (!channelName)
+            throw new Error('Unknown JPEG channel.');
+        const colorSpace = channelName;
+        return new JpegEmbedder(imageData, bitsPerComponent, width, height, colorSpace);
+    }
+    async embedIntoContext(context, ref) {
+        const 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 ref;
+        }
+        else {
+            return context.register(xObject);
+        }
     }
 }
 
@@ -25644,32 +25590,28 @@ class PngEmbedder {
         this.height = png.height;
         this.colorSpace = 'DeviceRGB';
     }
-    static for(imageData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const png = PNG.load(imageData);
-            return new PngEmbedder(png);
-        });
+    static async for(imageData) {
+        const png = PNG.load(imageData);
+        return new PngEmbedder(png);
     }
-    embedIntoContext(context, ref) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const SMask = this.embedAlphaChannel(context);
-            const 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,
-            });
-            if (ref) {
-                context.assign(ref, xObject);
-                return ref;
-            }
-            else {
-                return context.register(xObject);
-            }
+    async embedIntoContext(context, ref) {
+        const SMask = this.embedAlphaChannel(context);
+        const 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,
         });
+        if (ref) {
+            context.assign(ref, xObject);
+            return ref;
+        }
+        else {
+            return context.register(xObject);
+        }
     }
     embedAlphaChannel(context) {
         if (!this.image.alphaChannel)
@@ -26657,34 +26599,30 @@ class PDFPageEmbedder {
         this.transformationMatrix =
             transformationMatrix !== null && transformationMatrix !== void 0 ? transformationMatrix : boundingBoxAdjustedMatrix(bb);
     }
-    static for(page, boundingBox, transformationMatrix) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new PDFPageEmbedder(page, boundingBox, transformationMatrix);
-        });
+    static async for(page, boundingBox, transformationMatrix) {
+        return new PDFPageEmbedder(page, boundingBox, transformationMatrix);
     }
-    embedIntoContext(context, ref) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { Contents, Resources } = this.page.normalizedEntries();
-            if (!Contents)
-                throw new MissingPageContentsEmbeddingError();
-            const decodedContents = this.decodeContents(Contents);
-            const { left, bottom, right, top } = this.boundingBox;
-            const xObject = context.flateStream(decodedContents, {
-                Type: 'XObject',
-                Subtype: 'Form',
-                FormType: 1,
-                BBox: [left, bottom, right, top],
-                Matrix: this.transformationMatrix,
-                Resources,
-            });
-            if (ref) {
-                context.assign(ref, xObject);
-                return ref;
-            }
-            else {
-                return context.register(xObject);
-            }
+    async embedIntoContext(context, ref) {
+        const { Contents, Resources } = this.page.normalizedEntries();
+        if (!Contents)
+            throw new MissingPageContentsEmbeddingError();
+        const decodedContents = this.decodeContents(Contents);
+        const { left, bottom, right, top } = this.boundingBox;
+        const xObject = context.flateStream(decodedContents, {
+            Type: 'XObject',
+            Subtype: 'Form',
+            FormType: 1,
+            BBox: [left, bottom, right, top],
+            Matrix: this.transformationMatrix,
+            Resources,
         });
+        if (ref) {
+            context.assign(ref, xObject);
+            return ref;
+        }
+        else {
+            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.
@@ -29136,23 +29074,21 @@ class PDFObjectStreamParser extends PDFObjectParser {
         this.firstOffset = dict.lookup(PDFName.of('First'), PDFNumber).asNumber();
         this.objectCount = dict.lookup(PDFName.of('N'), PDFNumber).asNumber();
     }
-    parseIntoContext() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.alreadyParsed) {
-                throw new ReparseError('PDFObjectStreamParser', 'parseIntoContext');
-            }
-            this.alreadyParsed = true;
-            const offsetsAndObjectNumbers = this.parseOffsetsAndObjectNumbers();
-            for (let idx = 0, len = offsetsAndObjectNumbers.length; idx < len; idx++) {
-                const { objectNumber, offset } = offsetsAndObjectNumbers[idx];
-                this.bytes.moveTo(this.firstOffset + offset);
-                const ref = PDFRef.of(objectNumber, 0);
-                const object = this.parseObject(ref);
-                this.context.assign(ref, object);
-                if (this.shouldWaitForTick())
-                    yield waitForTick();
-            }
-        });
+    async parseIntoContext() {
+        if (this.alreadyParsed) {
+            throw new ReparseError('PDFObjectStreamParser', 'parseIntoContext');
+        }
+        this.alreadyParsed = true;
+        const offsetsAndObjectNumbers = this.parseOffsetsAndObjectNumbers();
+        for (let idx = 0, len = offsetsAndObjectNumbers.length; idx < len; idx++) {
+            const { objectNumber, offset } = offsetsAndObjectNumbers[idx];
+            this.bytes.moveTo(this.firstOffset + offset);
+            const ref = PDFRef.of(objectNumber, 0);
+            const object = this.parseObject(ref);
+            this.context.assign(ref, object);
+            if (this.shouldWaitForTick())
+                await waitForTick();
+        }
     }
     parseOffsetsAndObjectNumbers() {
         const offsetsAndObjectNumbers = [];
@@ -29260,29 +29196,27 @@ class PDFParser extends PDFObjectParser {
         this.throwOnInvalidObject = throwOnInvalidObject;
         this.context.isDecrypted = !!(cryptoFactory === null || cryptoFactory === void 0 ? void 0 : cryptoFactory.encryptionKey);
     }
-    parseDocument() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.alreadyParsed) {
-                throw new ReparseError('PDFParser', 'parseDocument');
-            }
-            this.alreadyParsed = true;
-            this.context.header = this.parseHeader();
-            let prevOffset;
-            while (!this.bytes.done()) {
-                yield this.parseDocumentSection();
-                const offset = this.bytes.offset();
-                if (offset === prevOffset) {
-                    throw new StalledParserError(this.bytes.position());
-                }
-                prevOffset = offset;
-            }
-            this.maybeRecoverRoot();
-            if (this.context.lookup(PDFRef.of(0))) {
-                console.warn('Removing parsed object: 0 0 R');
-                this.context.delete(PDFRef.of(0));
+    async parseDocument() {
+        if (this.alreadyParsed) {
+            throw new ReparseError('PDFParser', 'parseDocument');
+        }
+        this.alreadyParsed = true;
+        this.context.header = this.parseHeader();
+        let prevOffset;
+        while (!this.bytes.done()) {
+            await this.parseDocumentSection();
+            const offset = this.bytes.offset();
+            if (offset === prevOffset) {
+                throw new StalledParserError(this.bytes.position());
             }
-            return this.context;
-        });
+            prevOffset = offset;
+        }
+        this.maybeRecoverRoot();
+        if (this.context.lookup(PDFRef.of(0))) {
+            console.warn('Removing parsed object: 0 0 R');
+            this.context.delete(PDFRef.of(0));
+        }
+        return this.context;
     }
     maybeRecoverRoot() {
         const isValidCatalog = (obj) => obj instanceof PDFDict &&
@@ -29334,30 +29268,28 @@ class PDFParser extends PDFObjectParser {
             return false;
         }
     }
-    parseIndirectObject() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ref = this.parseIndirectObjectHeader();
-            this.skipWhitespaceAndComments();
-            const object = this.parseObject(ref);
-            this.skipWhitespaceAndComments();
-            // if (!this.matchKeyword(Keywords.endobj)) {
-            // throw new MissingKeywordError(this.bytes.position(), Keywords.endobj);
-            // }
-            // TODO: Log a warning if this fails...
-            this.matchKeyword(Keywords.endobj);
-            if (object instanceof PDFRawStream &&
-                object.dict.lookup(PDFName.of('Type')) === PDFName.of('ObjStm')) {
-                yield PDFObjectStreamParser.forStream(object, this.shouldWaitForTick).parseIntoContext();
-            }
-            else if (object instanceof PDFRawStream &&
-                object.dict.lookup(PDFName.of('Type')) === PDFName.of('XRef')) {
-                PDFXRefStreamParser.forStream(object).parseIntoContext();
-            }
-            else {
-                this.context.assign(ref, object);
-            }
-            return ref;
-        });
+    async parseIndirectObject() {
+        const ref = this.parseIndirectObjectHeader();
+        this.skipWhitespaceAndComments();
+        const object = this.parseObject(ref);
+        this.skipWhitespaceAndComments();
+        // if (!this.matchKeyword(Keywords.endobj)) {
+        // throw new MissingKeywordError(this.bytes.position(), Keywords.endobj);
+        // }
+        // TODO: Log a warning if this fails...
+        this.matchKeyword(Keywords.endobj);
+        if (object instanceof PDFRawStream &&
+            object.dict.lookup(PDFName.of('Type')) === PDFName.of('ObjStm')) {
+            await PDFObjectStreamParser.forStream(object, this.shouldWaitForTick).parseIntoContext();
+        }
+        else if (object instanceof PDFRawStream &&
+            object.dict.lookup(PDFName.of('Type')) === PDFName.of('XRef')) {
+            PDFXRefStreamParser.forStream(object).parseIntoContext();
+        }
+        else {
+            this.context.assign(ref, object);
+        }
+        return ref;
     }
     // TODO: Improve and clean this up
     tryToParseInvalidIndirectObject() {
@@ -29386,26 +29318,24 @@ class PDFParser extends PDFObjectParser {
         this.context.assign(ref, object);
         return ref;
     }
-    parseIndirectObjects() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.skipWhitespaceAndComments();
-            while (!this.bytes.done() && IsDigit[this.bytes.peek()]) {
-                const initialOffset = this.bytes.offset();
-                try {
-                    yield this.parseIndirectObject();
-                }
-                catch (e) {
-                    // TODO: Add tracing/logging mechanism to track when this happens!
-                    this.bytes.moveTo(initialOffset);
-                    this.tryToParseInvalidIndirectObject();
-                }
-                this.skipWhitespaceAndComments();
-                // TODO: Can this be done only when needed, to avoid harming performance?
-                this.skipJibberish();
-                if (this.shouldWaitForTick())
-                    yield waitForTick();
+    async parseIndirectObjects() {
+        this.skipWhitespaceAndComments();
+        while (!this.bytes.done() && IsDigit[this.bytes.peek()]) {
+            const initialOffset = this.bytes.offset();
+            try {
+                await this.parseIndirectObject();
             }
-        });
+            catch (e) {
+                // TODO: Add tracing/logging mechanism to track when this happens!
+                this.bytes.moveTo(initialOffset);
+                this.tryToParseInvalidIndirectObject();
+            }
+            this.skipWhitespaceAndComments();
+            // TODO: Can this be done only when needed, to avoid harming performance?
+            this.skipJibberish();
+            if (this.shouldWaitForTick())
+                await waitForTick();
+        }
     }
     maybeParseCrossRefSection() {
         this.skipWhitespaceAndComments();
@@ -29465,15 +29395,13 @@ class PDFParser extends PDFObjectParser {
         this.skipWhitespaceAndComments();
         return PDFTrailer.forLastCrossRefSectionOffset(offset);
     }
-    parseDocumentSection() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.parseIndirectObjects();
-            this.maybeParseCrossRefSection();
-            this.maybeParseTrailerDict();
-            this.maybeParseTrailer();
-            // TODO: Can this be done only when needed, to avoid harming performance?
-            this.skipJibberish();
-        });
+    async parseDocumentSection() {
+        await this.parseIndirectObjects();
+        this.maybeParseCrossRefSection();
+        this.maybeParseTrailerDict();
+        this.maybeParseTrailer();
+        // TODO: Can this be done only when needed, to avoid harming performance?
+        this.skipJibberish();
     }
     /**
      * This operation is not necessary for valid PDF files. But some invalid PDFs
@@ -32196,6 +32124,16 @@ const segmentToBezier = (cx1, cy1, th0, th1, rx, ry, sinTh, cosTh) => {
 };
 const svgPathToOperators = (path) => apply(parse(path));
 
+const clipSpace = ({ topLeft, topRight, bottomRight, bottomLeft }) => [
+    moveTo(topLeft.x, topLeft.y),
+    lineTo(topRight.x, topRight.y),
+    lineTo(bottomRight.x, bottomRight.y),
+    lineTo(bottomLeft.x, bottomLeft.y),
+    closePath(),
+    clip(),
+    endPath(),
+];
+const clipSpaces = (spaces) => spaces.flatMap(clipSpace);
 const drawText = (line, options) => [
     pushGraphicsState(),
     options.graphicsState && setGraphicsState(options.graphicsState),
@@ -32211,6 +32149,8 @@ const drawLinesOfText = (lines, options) => {
     const operators = [
         pushGraphicsState(),
         options.graphicsState && setGraphicsState(options.graphicsState),
+        ...(options.clipSpaces ? clipSpaces(options.clipSpaces) : []),
+        options.matrix && concatTransformationMatrix(...options.matrix),
         beginText(),
         setFillingColor(options.color),
         setFontAndSize(options.font, options.size),
@@ -32226,6 +32166,8 @@ const drawLinesOfText = (lines, options) => {
 const drawImage = (name, options) => [
     pushGraphicsState(),
     options.graphicsState && setGraphicsState(options.graphicsState),
+    ...(options.clipSpaces ? clipSpaces(options.clipSpaces) : []),
+    options.matrix && concatTransformationMatrix(...options.matrix),
     translate(options.x, options.y),
     rotateRadians(toRadians(options.rotate)),
     scale(options.width, options.height),
@@ -32248,6 +32190,8 @@ const drawLine = (options) => {
     return [
         pushGraphicsState(),
         options.graphicsState && setGraphicsState(options.graphicsState),
+        ...(options.clipSpaces ? clipSpaces(options.clipSpaces) : []),
+        options.matrix && concatTransformationMatrix(...options.matrix),
         options.color && setStrokingColor(options.color),
         setLineWidth(options.thickness),
         setDashPattern((_a = options.dashArray) !== null && _a !== void 0 ? _a : [], (_b = options.dashPhase) !== null && _b !== void 0 ? _b : 0),
@@ -32261,6 +32205,36 @@ const drawLine = (options) => {
 };
 const drawRectangle = (options) => {
     var _a, _b;
+    let ops = [];
+    if (!options.radius || asNumber(options.radius) <= 0) {
+        ops = [
+            moveTo(0, 0),
+            lineTo(0, options.height),
+            lineTo(options.width, options.height),
+            lineTo(options.width, 0),
+            closePath(),
+        ];
+    }
+    else {
+        let radius = asNumber(options.radius);
+        const width = asNumber(options.width);
+        const height = asNumber(options.height);
+        if (radius > width / 2.0 || radius > height / 2.0) {
+            radius = Math.min(width / 2.0, height / 2.0);
+        }
+        const offset = KAPPA * radius;
+        ops = [
+            moveTo(0, radius),
+            appendBezierCurve(0, radius - offset, radius - offset, 0, radius, 0),
+            lineTo(width - radius, 0),
+            appendBezierCurve(width - radius + offset, 0, width, radius - offset, width, radius),
+            lineTo(width, height - radius),
+            appendBezierCurve(width, height - radius + offset, width - radius + offset, height, width - radius, height),
+            lineTo(radius, height),
+            appendBezierCurve(radius - offset, height, 0, height - radius + offset, 0, height - radius),
+            closePath(),
+        ];
+    }
     return [
         pushGraphicsState(),
         options.graphicsState && setGraphicsState(options.graphicsState),
@@ -32269,14 +32243,12 @@ const drawRectangle = (options) => {
         setLineWidth(options.borderWidth),
         options.borderLineCap && setLineCap(options.borderLineCap),
         setDashPattern((_a = options.borderDashArray) !== null && _a !== void 0 ? _a : [], (_b = options.borderDashPhase) !== null && _b !== void 0 ? _b : 0),
+        ...(options.clipSpaces ? clipSpaces(options.clipSpaces) : []),
+        options.matrix && concatTransformationMatrix(...options.matrix),
         translate(options.x, options.y),
         rotateRadians(toRadians(options.rotate)),
         skewRadians(toRadians(options.xSkew), toRadians(options.ySkew)),
-        moveTo(0, 0),
-        lineTo(0, options.height),
-        lineTo(options.width, options.height),
-        lineTo(options.width, 0),
-        closePath(),
+        ...ops,
         // prettier-ignore
         options.color && options.borderWidth ? fillAndStroke()
             : options.color ? fill()
@@ -32340,6 +32312,8 @@ const drawEllipse = (options) => {
         options.graphicsState && setGraphicsState(options.graphicsState),
         options.color && setFillingColor(options.color),
         options.borderColor && setStrokingColor(options.borderColor),
+        ...(options.clipSpaces ? clipSpaces(options.clipSpaces) : []),
+        options.matrix && concatTransformationMatrix(...options.matrix),
         setLineWidth(options.borderWidth),
         options.borderLineCap && setLineCap(options.borderLineCap),
         setDashPattern((_a = options.borderDashArray) !== null && _a !== void 0 ? _a : [], (_b = options.borderDashPhase) !== null && _b !== void 0 ? _b : 0),
@@ -32372,6 +32346,8 @@ const drawSvgPath = (path, options) => {
     return [
         pushGraphicsState(),
         options.graphicsState && setGraphicsState(options.graphicsState),
+        ...(options.clipSpaces ? clipSpaces(options.clipSpaces) : []),
+        options.matrix && concatTransformationMatrix(...options.matrix),
         translate(options.x, options.y),
         rotateRadians(toRadians((_a = options.rotate) !== null && _a !== void 0 ? _a : degrees(0))),
         options.scale && scale(options.scale, options.scale),
@@ -33033,7 +33009,7 @@ const defaultCheckBoxAppearanceProvider = (checkBox, widget) => {
     const borderWidth = (_a = bs === null || bs === void 0 ? void 0 : bs.getWidth()) !== null && _a !== void 0 ? _a : 0;
     const rotation = reduceRotation(ap === null || ap === void 0 ? void 0 : ap.getRotation());
     const { width, height } = adjustDimsForRotation(rectangle, rotation);
-    const rotate = rotateInPlace(Object.assign(Object.assign({}, rectangle), { rotation }));
+    const rotate = rotateInPlace({ ...rectangle, rotation });
     const black = rgb(0, 0, 0);
     const borderColor = (_b = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBorderColor())) !== null && _b !== void 0 ? _b : black;
     const normalBackgroundColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBackgroundColor());
@@ -33060,21 +33036,37 @@ const defaultCheckBoxAppearanceProvider = (checkBox, widget) => {
         normal: {
             on: [
                 ...rotate,
-                ...drawCheckBox(Object.assign(Object.assign({}, options), { color: normalBackgroundColor, filled: true })),
+                ...drawCheckBox({
+                    ...options,
+                    color: normalBackgroundColor,
+                    filled: true,
+                }),
             ],
             off: [
                 ...rotate,
-                ...drawCheckBox(Object.assign(Object.assign({}, options), { color: normalBackgroundColor, filled: false })),
+                ...drawCheckBox({
+                    ...options,
+                    color: normalBackgroundColor,
+                    filled: false,
+                }),
             ],
         },
         down: {
             on: [
                 ...rotate,
-                ...drawCheckBox(Object.assign(Object.assign({}, options), { color: downBackgroundColor, filled: true })),
+                ...drawCheckBox({
+                    ...options,
+                    color: downBackgroundColor,
+                    filled: true,
+                }),
             ],
             off: [
                 ...rotate,
-                ...drawCheckBox(Object.assign(Object.assign({}, options), { color: downBackgroundColor, filled: false })),
+                ...drawCheckBox({
+                    ...options,
+                    color: downBackgroundColor,
+                    filled: false,
+                }),
             ],
         },
     };
@@ -33090,7 +33082,7 @@ const defaultRadioGroupAppearanceProvider = (radioGroup, widget) => {
     const borderWidth = (_a = bs === null || bs === void 0 ? void 0 : bs.getWidth()) !== null && _a !== void 0 ? _a : 0;
     const rotation = reduceRotation(ap === null || ap === void 0 ? void 0 : ap.getRotation());
     const { width, height } = adjustDimsForRotation(rectangle, rotation);
-    const rotate = rotateInPlace(Object.assign(Object.assign({}, rectangle), { rotation }));
+    const rotate = rotateInPlace({ ...rectangle, rotation });
     const black = rgb(0, 0, 0);
     const borderColor = (_b = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBorderColor())) !== null && _b !== void 0 ? _b : black;
     const normalBackgroundColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBackgroundColor());
@@ -33116,21 +33108,37 @@ const defaultRadioGroupAppearanceProvider = (radioGroup, widget) => {
         normal: {
             on: [
                 ...rotate,
-                ...drawRadioButton(Object.assign(Object.assign({}, options), { color: normalBackgroundColor, filled: true })),
+                ...drawRadioButton({
+                    ...options,
+                    color: normalBackgroundColor,
+                    filled: true,
+                }),
             ],
             off: [
                 ...rotate,
-                ...drawRadioButton(Object.assign(Object.assign({}, options), { color: normalBackgroundColor, filled: false })),
+                ...drawRadioButton({
+                    ...options,
+                    color: normalBackgroundColor,
+                    filled: false,
+                }),
             ],
         },
         down: {
             on: [
                 ...rotate,
-                ...drawRadioButton(Object.assign(Object.assign({}, options), { color: downBackgroundColor, filled: true })),
+                ...drawRadioButton({
+                    ...options,
+                    color: downBackgroundColor,
+                    filled: true,
+                }),
             ],
             off: [
                 ...rotate,
-                ...drawRadioButton(Object.assign(Object.assign({}, options), { color: downBackgroundColor, filled: false })),
+                ...drawRadioButton({
+                    ...options,
+                    color: downBackgroundColor,
+                    filled: false,
+                }),
             ],
         },
     };
@@ -33151,7 +33159,7 @@ const defaultButtonAppearanceProvider = (button, widget, font) => {
     const borderWidth = (_d = bs === null || bs === void 0 ? void 0 : bs.getWidth()) !== null && _d !== void 0 ? _d : 0;
     const rotation = reduceRotation(ap === null || ap === void 0 ? void 0 : ap.getRotation());
     const { width, height } = adjustDimsForRotation(rectangle, rotation);
-    const rotate = rotateInPlace(Object.assign(Object.assign({}, rectangle), { rotation }));
+    const rotate = rotateInPlace({ ...rectangle, rotation });
     const black = rgb(0, 0, 0);
     const borderColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBorderColor());
     const normalBackgroundColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBackgroundColor());
@@ -33197,11 +33205,19 @@ const defaultButtonAppearanceProvider = (button, widget, font) => {
     return {
         normal: [
             ...rotate,
-            ...drawButton(Object.assign(Object.assign({}, options), { color: normalBackgroundColor, textLines: [normalLayout.line] })),
+            ...drawButton({
+                ...options,
+                color: normalBackgroundColor,
+                textLines: [normalLayout.line],
+            }),
         ],
         down: [
             ...rotate,
-            ...drawButton(Object.assign(Object.assign({}, options), { color: downBackgroundColor, textLines: [downLayout.line] })),
+            ...drawButton({
+                ...options,
+                color: downBackgroundColor,
+                textLines: [downLayout.line],
+            }),
         ],
     };
 };
@@ -33219,7 +33235,7 @@ const defaultTextFieldAppearanceProvider = (textField, widget, font) => {
     const borderWidth = (_b = bs === null || bs === void 0 ? void 0 : bs.getWidth()) !== null && _b !== void 0 ? _b : 0;
     const rotation = reduceRotation(ap === null || ap === void 0 ? void 0 : ap.getRotation());
     const { width, height } = adjustDimsForRotation(rectangle, rotation);
-    const rotate = rotateInPlace(Object.assign(Object.assign({}, rectangle), { rotation }));
+    const rotate = rotateInPlace({ ...rectangle, rotation });
     const black = rgb(0, 0, 0);
     const borderColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBorderColor());
     const normalBackgroundColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBackgroundColor());
@@ -33300,7 +33316,7 @@ const defaultDropdownAppearanceProvider = (dropdown, widget, font) => {
     const borderWidth = (_b = bs === null || bs === void 0 ? void 0 : bs.getWidth()) !== null && _b !== void 0 ? _b : 0;
     const rotation = reduceRotation(ap === null || ap === void 0 ? void 0 : ap.getRotation());
     const { width, height } = adjustDimsForRotation(rectangle, rotation);
-    const rotate = rotateInPlace(Object.assign(Object.assign({}, rectangle), { rotation }));
+    const rotate = rotateInPlace({ ...rectangle, rotation });
     const black = rgb(0, 0, 0);
     const borderColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBorderColor());
     const normalBackgroundColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBackgroundColor());
@@ -33354,7 +33370,7 @@ const defaultOptionListAppearanceProvider = (optionList, widget, font) => {
     const borderWidth = (_a = bs === null || bs === void 0 ? void 0 : bs.getWidth()) !== null && _a !== void 0 ? _a : 0;
     const rotation = reduceRotation(ap === null || ap === void 0 ? void 0 : ap.getRotation());
     const { width, height } = adjustDimsForRotation(rectangle, rotation);
-    const rotate = rotateInPlace(Object.assign(Object.assign({}, rectangle), { rotation }));
+    const rotate = rotateInPlace({ ...rectangle, rotation });
     const black = rgb(0, 0, 0);
     const borderColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBorderColor());
     const normalBackgroundColor = componentsToColor(ap === null || ap === void 0 ? void 0 : ap.getBackgroundColor());
@@ -33472,13 +33488,11 @@ class PDFEmbeddedPage {
      *
      * @returns Resolves when the embedding is complete.
      */
-    embed() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.alreadyEmbedded) {
-                yield this.embedder.embedIntoContext(this.doc.context, this.ref);
-                this.alreadyEmbedded = true;
-            }
-        });
+    async embed() {
+        if (!this.alreadyEmbedded) {
+            await this.embedder.embedIntoContext(this.doc.context, this.ref);
+            this.alreadyEmbedded = true;
+        }
     }
 }
 /**
@@ -33597,14 +33611,12 @@ class PDFFont {
      *
      * @returns Resolves when the embedding is complete.
      */
-    embed() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // TODO: Cleanup orphan embedded objects if a font is embedded multiple times...
-            if (this.modified) {
-                yield this.embedder.embedIntoContext(this.doc.context, this.ref);
-                this.modified = false;
-            }
-        });
+    async embed() {
+        // TODO: Cleanup orphan embedded objects if a font is embedded multiple times...
+        if (this.modified) {
+            await this.embedder.embedIntoContext(this.doc.context, this.ref);
+            this.modified = false;
+        }
     }
 }
 /**
@@ -33703,22 +33715,20 @@ class PDFImage {
      *
      * @returns Resolves when the embedding is complete.
      */
-    embed() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.embedder)
-                return;
-            // The image should only be embedded once. If there's a pending embed
-            // operation then wait on it. Otherwise we need to start the embed.
-            if (!this.embedTask) {
-                const { doc, ref } = this;
-                this.embedTask = this.embedder.embedIntoContext(doc.context, ref);
-            }
-            yield this.embedTask;
-            // We clear `this.embedder` so that the indirectly referenced image data
-            // can be garbage collected, thus avoiding a memory leak.
-            // See https://github.com/Hopding/pdf-lib/pull/1032/files.
-            this.embedder = undefined;
-        });
+    async embed() {
+        if (!this.embedder)
+            return;
+        // The image should only be embedded once. If there's a pending embed
+        // operation then wait on it. Otherwise we need to start the embed.
+        if (!this.embedTask) {
+            const { doc, ref } = this;
+            this.embedTask = this.embedder.embedIntoContext(doc.context, ref);
+        }
+        await this.embedTask;
+        // We clear `this.embedder` so that the indirectly referenced image data
+        // can be garbage collected, thus avoiding a memory leak.
+        // See https://github.com/Hopding/pdf-lib/pull/1032/files.
+        this.embedder = undefined;
     }
 }
 /**
@@ -34063,7 +34073,7 @@ class PDFField {
         const bs = widget.getBorderStyle();
         const borderWidth = (_a = bs === null || bs === void 0 ? void 0 : bs.getWidth()) !== null && _a !== void 0 ? _a : 0;
         const rotation = reduceRotation(ap === null || ap === void 0 ? void 0 : ap.getRotation());
-        const rotate = rotateInPlace(Object.assign(Object.assign({}, rectangle), { rotation }));
+        const rotate = rotateInPlace({ ...rectangle, rotation });
         const adj = adjustDimsForRotation(rectangle, rotation);
         const imageDims = image.scaleToFit(adj.width - borderWidth * 2, adj.height - borderWidth * 2);
         // Support borders on images and maybe other properties
@@ -36984,7 +36994,7 @@ class PDFForm {
                     const operators = [
                         pushGraphicsState(),
                         translate(rectangle.x, rectangle.y),
-                        ...rotateInPlace(Object.assign(Object.assign({}, rectangle), { rotation: 0 })),
+                        ...rotateInPlace({ ...rectangle, rotation: 0 }),
                         drawObject(xObjectKey),
                         popGraphicsState(),
                     ].filter(Boolean);
@@ -37329,39 +37339,37 @@ class PDFEmbeddedFile {
      *
      * @returns Resolves when the embedding is complete.
      */
-    embed() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.alreadyEmbedded) {
-                const ref = yield this.embedder.embedIntoContext(this.doc.context, this.ref);
-                if (!this.doc.catalog.has(PDFName.of('Names'))) {
-                    this.doc.catalog.set(PDFName.of('Names'), this.doc.context.obj({}));
-                }
-                const Names = this.doc.catalog.lookup(PDFName.of('Names'), PDFDict);
-                if (!Names.has(PDFName.of('EmbeddedFiles'))) {
-                    Names.set(PDFName.of('EmbeddedFiles'), this.doc.context.obj({}));
-                }
-                const EmbeddedFiles = Names.lookup(PDFName.of('EmbeddedFiles'), PDFDict);
-                if (!EmbeddedFiles.has(PDFName.of('Names'))) {
-                    EmbeddedFiles.set(PDFName.of('Names'), this.doc.context.obj([]));
-                }
-                const EFNames = EmbeddedFiles.lookup(PDFName.of('Names'), PDFArray);
-                EFNames.push(PDFHexString.fromText(this.embedder.fileName));
-                EFNames.push(ref);
-                /**
-                 * The AF-Tag is needed to achieve PDF-A3 compliance for embedded files
-                 *
-                 * The following document outlines the uses cases of the associated files (AF) tag.
-                 * See:
-                 * https://www.pdfa.org/wp-content/uploads/2018/10/PDF20_AN002-AF.pdf
-                 */
-                if (!this.doc.catalog.has(PDFName.of('AF'))) {
-                    this.doc.catalog.set(PDFName.of('AF'), this.doc.context.obj([]));
-                }
-                const AF = this.doc.catalog.lookup(PDFName.of('AF'), PDFArray);
-                AF.push(ref);
-                this.alreadyEmbedded = true;
+    async embed() {
+        if (!this.alreadyEmbedded) {
+            const ref = await this.embedder.embedIntoContext(this.doc.context, this.ref);
+            if (!this.doc.catalog.has(PDFName.of('Names'))) {
+                this.doc.catalog.set(PDFName.of('Names'), this.doc.context.obj({}));
             }
-        });
+            const Names = this.doc.catalog.lookup(PDFName.of('Names'), PDFDict);
+            if (!Names.has(PDFName.of('EmbeddedFiles'))) {
+                Names.set(PDFName.of('EmbeddedFiles'), this.doc.context.obj({}));
+            }
+            const EmbeddedFiles = Names.lookup(PDFName.of('EmbeddedFiles'), PDFDict);
+            if (!EmbeddedFiles.has(PDFName.of('Names'))) {
+                EmbeddedFiles.set(PDFName.of('Names'), this.doc.context.obj([]));
+            }
+            const EFNames = EmbeddedFiles.lookup(PDFName.of('Names'), PDFArray);
+            EFNames.push(PDFHexString.fromText(this.embedder.fileName));
+            EFNames.push(ref);
+            /**
+             * The AF-Tag is needed to achieve PDF-A3 compliance for embedded files
+             *
+             * The following document outlines the uses cases of the associated files (AF) tag.
+             * See:
+             * https://www.pdfa.org/wp-content/uploads/2018/10/PDF20_AN002-AF.pdf
+             */
+            if (!this.doc.catalog.has(PDFName.of('AF'))) {
+                this.doc.catalog.set(PDFName.of('AF'), this.doc.context.obj([]));
+            }
+            const AF = this.doc.catalog.lookup(PDFName.of('AF'), PDFArray);
+            AF.push(ref);
+            this.alreadyEmbedded = true;
+        }
     }
 }
 /**
@@ -37396,28 +37404,26 @@ class PDFJavaScript {
      *
      * @returns Resolves when the embedding is complete.
      */
-    embed() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.alreadyEmbedded) {
-                const { catalog, context } = this.doc;
-                const ref = yield this.embedder.embedIntoContext(this.doc.context, this.ref);
-                if (!catalog.has(PDFName.of('Names'))) {
-                    catalog.set(PDFName.of('Names'), context.obj({}));
-                }
-                const Names = catalog.lookup(PDFName.of('Names'), PDFDict);
-                if (!Names.has(PDFName.of('JavaScript'))) {
-                    Names.set(PDFName.of('JavaScript'), context.obj({}));
-                }
-                const Javascript = Names.lookup(PDFName.of('JavaScript'), PDFDict);
-                if (!Javascript.has(PDFName.of('Names'))) {
-                    Javascript.set(PDFName.of('Names'), context.obj([]));
-                }
-                const JSNames = Javascript.lookup(PDFName.of('Names'), PDFArray);
-                JSNames.push(PDFHexString.fromText(this.embedder.scriptName));
-                JSNames.push(ref);
-                this.alreadyEmbedded = true;
+    async embed() {
+        if (!this.alreadyEmbedded) {
+            const { catalog, context } = this.doc;
+            const ref = await this.embedder.embedIntoContext(this.doc.context, this.ref);
+            if (!catalog.has(PDFName.of('Names'))) {
+                catalog.set(PDFName.of('Names'), context.obj({}));
             }
-        });
+            const Names = catalog.lookup(PDFName.of('Names'), PDFDict);
+            if (!Names.has(PDFName.of('JavaScript'))) {
+                Names.set(PDFName.of('JavaScript'), context.obj({}));
+            }
+            const Javascript = Names.lookup(PDFName.of('JavaScript'), PDFDict);
+            if (!Javascript.has(PDFName.of('Names'))) {
+                Javascript.set(PDFName.of('Names'), context.obj([]));
+            }
+            const JSNames = Javascript.lookup(PDFName.of('Names'), PDFArray);
+            JSNames.push(PDFHexString.fromText(this.embedder.scriptName));
+            JSNames.push(ref);
+            this.alreadyEmbedded = true;
+        }
     }
 }
 /**
@@ -37441,21 +37447,19 @@ class JavaScriptEmbedder {
     static for(script, scriptName) {
         return new JavaScriptEmbedder(script, scriptName);
     }
-    embedIntoContext(context, ref) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const jsActionDict = context.obj({
-                Type: 'Action',
-                S: 'JavaScript',
-                JS: PDFHexString.fromText(this.script),
-            });
-            if (ref) {
-                context.assign(ref, jsActionDict);
-                return ref;
-            }
-            else {
-                return context.register(jsActionDict);
-            }
+    async embedIntoContext(context, ref) {
+        const jsActionDict = context.obj({
+            Type: 'Action',
+            S: 'JavaScript',
+            JS: PDFHexString.fromText(this.script),
         });
+        if (ref) {
+            context.assign(ref, jsActionDict);
+            return ref;
+        }
+        else {
+            return context.register(jsActionDict);
+        }
     }
 }
 
@@ -39189,42 +39193,38 @@ class PDFDocument {
      * @param options The options to be used when loading the document.
      * @returns Resolves with a document loaded from the input.
      */
-    static load(pdf, options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { ignoreEncryption = false, parseSpeed = ParseSpeeds.Slow, throwOnInvalidObject = false, updateMetadata = true, capNumbers = false, password, } = options;
-            assertIs(pdf, 'pdf', ['string', Uint8Array, ArrayBuffer]);
-            assertIs(ignoreEncryption, 'ignoreEncryption', ['boolean']);
-            assertIs(parseSpeed, 'parseSpeed', ['number']);
-            assertIs(throwOnInvalidObject, 'throwOnInvalidObject', ['boolean']);
-            assertIs(password, 'password', ['string', 'undefined']);
-            const bytes = toUint8Array(pdf);
-            const context = yield PDFParser.forBytesWithOptions(bytes, parseSpeed, throwOnInvalidObject, capNumbers).parseDocument();
-            if (!!context.lookup(context.trailerInfo.Encrypt) && password !== undefined) {
-                // Decrypt
-                const fileIds = context.lookup(context.trailerInfo.ID, PDFArray);
-                const encryptDict = context.lookup(context.trailerInfo.Encrypt, PDFDict);
-                const decryptedContext = yield PDFParser.forBytesWithOptions(bytes, parseSpeed, throwOnInvalidObject, capNumbers, new CipherTransformFactory(encryptDict, fileIds.get(0).asBytes(), password)).parseDocument();
-                return new PDFDocument(decryptedContext, true, updateMetadata);
-            }
-            else {
-                return new PDFDocument(context, ignoreEncryption, updateMetadata);
-            }
-        });
+    static async load(pdf, options = {}) {
+        const { ignoreEncryption = false, parseSpeed = ParseSpeeds.Slow, throwOnInvalidObject = false, updateMetadata = true, capNumbers = false, password, } = options;
+        assertIs(pdf, 'pdf', ['string', Uint8Array, ArrayBuffer]);
+        assertIs(ignoreEncryption, 'ignoreEncryption', ['boolean']);
+        assertIs(parseSpeed, 'parseSpeed', ['number']);
+        assertIs(throwOnInvalidObject, 'throwOnInvalidObject', ['boolean']);
+        assertIs(password, 'password', ['string', 'undefined']);
+        const bytes = toUint8Array(pdf);
+        const context = await PDFParser.forBytesWithOptions(bytes, parseSpeed, throwOnInvalidObject, capNumbers).parseDocument();
+        if (!!context.lookup(context.trailerInfo.Encrypt) && password !== undefined) {
+            // Decrypt
+            const fileIds = context.lookup(context.trailerInfo.ID, PDFArray);
+            const encryptDict = context.lookup(context.trailerInfo.Encrypt, PDFDict);
+            const decryptedContext = await PDFParser.forBytesWithOptions(bytes, parseSpeed, throwOnInvalidObject, capNumbers, new CipherTransformFactory(encryptDict, fileIds.get(0).asBytes(), password)).parseDocument();
+            return new PDFDocument(decryptedContext, true, updateMetadata);
+        }
+        else {
+            return new PDFDocument(context, ignoreEncryption, updateMetadata);
+        }
     }
     /**
      * Create a new [[PDFDocument]].
      * @returns Resolves with the newly created document.
      */
-    static create(options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { updateMetadata = true } = options;
-            const context = PDFContext.create();
-            const pageTree = PDFPageTree.withContext(context);
-            const pageTreeRef = context.register(pageTree);
-            const catalog = PDFCatalog.withContextAndPages(context, pageTreeRef);
-            context.trailerInfo.Root = context.register(catalog);
-            return new PDFDocument(context, false, updateMetadata);
-        });
+    static async create(options = {}) {
+        const { updateMetadata = true } = options;
+        const context = PDFContext.create();
+        const pageTree = PDFPageTree.withContext(context);
+        const pageTreeRef = context.register(pageTree);
+        const catalog = PDFCatalog.withContextAndPages(context, pageTreeRef);
+        context.trailerInfo.Root = context.register(catalog);
+        return new PDFDocument(context, false, updateMetadata);
     }
     /**
      * Register a fontkit instance. This must be done before custom fonts can
@@ -39708,22 +39708,20 @@ class PDFDocument {
      * @param indices The indices of the pages that should be copied.
      * @returns Resolves with an array of pages copied into this document.
      */
-    copyPages(srcDoc, indices) {
-        return __awaiter(this, void 0, void 0, function* () {
-            assertIs(srcDoc, 'srcDoc', [[PDFDocument, 'PDFDocument']]);
-            assertIs(indices, 'indices', [Array]);
-            yield srcDoc.flush();
-            const copier = PDFObjectCopier.for(srcDoc.context, this.context);
-            const srcPages = srcDoc.getPages();
-            const copiedPages = new Array(indices.length);
-            for (let idx = 0, len = indices.length; idx < len; idx++) {
-                const srcPage = srcPages[indices[idx]];
-                const copiedPage = copier.copy(srcPage.node);
-                const ref = this.context.register(copiedPage);
-                copiedPages[idx] = PDFPage.of(copiedPage, ref, this);
-            }
-            return copiedPages;
-        });
+    async copyPages(srcDoc, indices) {
+        assertIs(srcDoc, 'srcDoc', [[PDFDocument, 'PDFDocument']]);
+        assertIs(indices, 'indices', [Array]);
+        await srcDoc.flush();
+        const copier = PDFObjectCopier.for(srcDoc.context, this.context);
+        const srcPages = srcDoc.getPages();
+        const copiedPages = new Array(indices.length);
+        for (let idx = 0, len = indices.length; idx < len; idx++) {
+            const srcPage = srcPages[indices[idx]];
+            const copiedPage = copier.copy(srcPage.node);
+            const ref = this.context.register(copiedPage);
+            copiedPages[idx] = PDFPage.of(copiedPage, ref, this);
+        }
+        return copiedPages;
     }
     /**
      * Get a copy of this document.
@@ -39739,37 +39737,35 @@ class PDFDocument {
      *
      * @returns Resolves with a copy this document.
      */
-    copy() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pdfCopy = yield PDFDocument.create();
-            const contentPages = yield pdfCopy.copyPages(this, this.getPageIndices());
-            for (let idx = 0, len = contentPages.length; idx < len; idx++) {
-                pdfCopy.addPage(contentPages[idx]);
-            }
-            if (this.getAuthor() !== undefined) {
-                pdfCopy.setAuthor(this.getAuthor());
-            }
-            if (this.getCreationDate() !== undefined) {
-                pdfCopy.setCreationDate(this.getCreationDate());
-            }
-            if (this.getCreator() !== undefined) {
-                pdfCopy.setCreator(this.getCreator());
-            }
-            if (this.getModificationDate() !== undefined) {
-                pdfCopy.setModificationDate(this.getModificationDate());
-            }
-            if (this.getProducer() !== undefined) {
-                pdfCopy.setProducer(this.getProducer());
-            }
-            if (this.getSubject() !== undefined) {
-                pdfCopy.setSubject(this.getSubject());
-            }
-            if (this.getTitle() !== undefined) {
-                pdfCopy.setTitle(this.getTitle());
-            }
-            pdfCopy.defaultWordBreaks = this.defaultWordBreaks;
-            return pdfCopy;
-        });
+    async copy() {
+        const pdfCopy = await PDFDocument.create();
+        const contentPages = await pdfCopy.copyPages(this, this.getPageIndices());
+        for (let idx = 0, len = contentPages.length; idx < len; idx++) {
+            pdfCopy.addPage(contentPages[idx]);
+        }
+        if (this.getAuthor() !== undefined) {
+            pdfCopy.setAuthor(this.getAuthor());
+        }
+        if (this.getCreationDate() !== undefined) {
+            pdfCopy.setCreationDate(this.getCreationDate());
+        }
+        if (this.getCreator() !== undefined) {
+            pdfCopy.setCreator(this.getCreator());
+        }
+        if (this.getModificationDate() !== undefined) {
+            pdfCopy.setModificationDate(this.getModificationDate());
+        }
+        if (this.getProducer() !== undefined) {
+            pdfCopy.setProducer(this.getProducer());
+        }
+        if (this.getSubject() !== undefined) {
+            pdfCopy.setSubject(this.getSubject());
+        }
+        if (this.getTitle() !== undefined) {
+            pdfCopy.setTitle(this.getTitle());
+        }
+        pdfCopy.defaultWordBreaks = this.defaultWordBreaks;
+        return pdfCopy;
     }
     /**
      * Add JavaScript to this document. The supplied `script` is executed when the
@@ -39858,23 +39854,21 @@ class PDFDocument {
      * @param name The name of the file to be attached.
      * @returns Resolves when the attachment is complete.
      */
-    attach(attachment, name, options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            assertIs(attachment, 'attachment', ['string', Uint8Array, ArrayBuffer]);
-            assertIs(name, 'name', ['string']);
-            assertOrUndefined(options.mimeType, 'mimeType', ['string']);
-            assertOrUndefined(options.description, 'description', ['string']);
-            assertOrUndefined(options.creationDate, 'options.creationDate', [Date]);
-            assertOrUndefined(options.modificationDate, 'options.modificationDate', [
-                Date,
-            ]);
-            assertIsOneOfOrUndefined(options.afRelationship, 'options.afRelationship', AFRelationship);
-            const bytes = toUint8Array(attachment);
-            const embedder = FileEmbedder.for(bytes, name, options);
-            const ref = this.context.nextRef();
-            const embeddedFile = PDFEmbeddedFile.of(ref, this, embedder);
-            this.embeddedFiles.push(embeddedFile);
-        });
+    async attach(attachment, name, options = {}) {
+        assertIs(attachment, 'attachment', ['string', Uint8Array, ArrayBuffer]);
+        assertIs(name, 'name', ['string']);
+        assertOrUndefined(options.mimeType, 'mimeType', ['string']);
+        assertOrUndefined(options.description, 'description', ['string']);
+        assertOrUndefined(options.creationDate, 'options.creationDate', [Date]);
+        assertOrUndefined(options.modificationDate, 'options.modificationDate', [
+            Date,
+        ]);
+        assertIsOneOfOrUndefined(options.afRelationship, 'options.afRelationship', AFRelationship);
+        const bytes = toUint8Array(attachment);
+        const embedder = FileEmbedder.for(bytes, name, options);
+        const ref = this.context.nextRef();
+        const embeddedFile = PDFEmbeddedFile.of(ref, this, embedder);
+        this.embeddedFiles.push(embeddedFile);
     }
     /**
      * Embed a font into this document. The input data can be provided in multiple
@@ -39911,30 +39905,28 @@ class PDFDocument {
      * @param options The options to be used when embedding the font.
      * @returns Resolves with the embedded font.
      */
-    embedFont(font, options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { subset = false, customName, features } = options;
-            assertIs(font, 'font', ['string', Uint8Array, ArrayBuffer]);
-            assertIs(subset, 'subset', ['boolean']);
-            let embedder;
-            if (isStandardFont(font)) {
-                embedder = StandardFontEmbedder.for(font, customName);
-            }
-            else if (canBeConvertedToUint8Array(font)) {
-                const bytes = toUint8Array(font);
-                const fontkit = this.assertFontkit();
-                embedder = subset
-                    ? yield CustomFontSubsetEmbedder.for(fontkit, bytes, customName, features)
-                    : yield CustomFontEmbedder.for(fontkit, bytes, customName, features);
-            }
-            else {
-                throw new TypeError('`font` must be one of `StandardFonts | string | Uint8Array | ArrayBuffer`');
-            }
-            const ref = this.context.nextRef();
-            const pdfFont = PDFFont.of(ref, this, embedder);
-            this.fonts.push(pdfFont);
-            return pdfFont;
-        });
+    async embedFont(font, options = {}) {
+        const { subset = false, customName, features } = options;
+        assertIs(font, 'font', ['string', Uint8Array, ArrayBuffer]);
+        assertIs(subset, 'subset', ['boolean']);
+        let embedder;
+        if (isStandardFont(font)) {
+            embedder = StandardFontEmbedder.for(font, customName);
+        }
+        else if (canBeConvertedToUint8Array(font)) {
+            const bytes = toUint8Array(font);
+            const fontkit = this.assertFontkit();
+            embedder = subset
+                ? await CustomFontSubsetEmbedder.for(fontkit, bytes, customName, features)
+                : await CustomFontEmbedder.for(fontkit, bytes, customName, features);
+        }
+        else {
+            throw new TypeError('`font` must be one of `StandardFonts | string | Uint8Array | ArrayBuffer`');
+        }
+        const ref = this.context.nextRef();
+        const pdfFont = PDFFont.of(ref, this, embedder);
+        this.fonts.push(pdfFont);
+        return pdfFont;
     }
     /**
      * Embed a standard font into this document.
@@ -39988,16 +39980,14 @@ class PDFDocument {
      * @param jpg The input data for a JPEG image.
      * @returns Resolves with the embedded image.
      */
-    embedJpg(jpg) {
-        return __awaiter(this, void 0, void 0, function* () {
-            assertIs(jpg, 'jpg', ['string', Uint8Array, ArrayBuffer]);
-            const bytes = toUint8Array(jpg);
-            const embedder = yield JpegEmbedder.for(bytes);
-            const ref = this.context.nextRef();
-            const pdfImage = PDFImage.of(ref, this, embedder);
-            this.images.push(pdfImage);
-            return pdfImage;
-        });
+    async embedJpg(jpg) {
+        assertIs(jpg, 'jpg', ['string', Uint8Array, ArrayBuffer]);
+        const bytes = toUint8Array(jpg);
+        const embedder = await JpegEmbedder.for(bytes);
+        const ref = this.context.nextRef();
+        const pdfImage = PDFImage.of(ref, this, embedder);
+        this.images.push(pdfImage);
+        return pdfImage;
     }
     /**
      * Embed a PNG image into this document. The input data can be provided in
@@ -40029,16 +40019,14 @@ class PDFDocument {
      * @param png The input data for a PNG image.
      * @returns Resolves with the embedded image.
      */
-    embedPng(png) {
-        return __awaiter(this, void 0, void 0, function* () {
-            assertIs(png, 'png', ['string', Uint8Array, ArrayBuffer]);
-            const bytes = toUint8Array(png);
-            const embedder = yield PngEmbedder.for(bytes);
-            const ref = this.context.nextRef();
-            const pdfImage = PDFImage.of(ref, this, embedder);
-            this.images.push(pdfImage);
-            return pdfImage;
-        });
+    async embedPng(png) {
+        assertIs(png, 'png', ['string', Uint8Array, ArrayBuffer]);
+        const bytes = toUint8Array(png);
+        const embedder = await PngEmbedder.for(bytes);
+        const ref = this.context.nextRef();
+        const pdfImage = PDFImage.of(ref, this, embedder);
+        this.images.push(pdfImage);
+        return pdfImage;
     }
     /**
      * Embed one or more PDF pages into this document.
@@ -40060,19 +40048,17 @@ class PDFDocument {
      * @param indices The indices of the pages that should be embedded.
      * @returns Resolves with an array of the embedded pages.
      */
-    embedPdf(pdf, indices = [0]) {
-        return __awaiter(this, void 0, void 0, function* () {
-            assertIs(pdf, 'pdf', [
-                'string',
-                Uint8Array,
-                ArrayBuffer,
-                [PDFDocument, 'PDFDocument'],
-            ]);
-            assertIs(indices, 'indices', [Array]);
-            const srcDoc = pdf instanceof PDFDocument ? pdf : yield PDFDocument.load(pdf);
-            const srcPages = pluckIndices(srcDoc.getPages(), indices);
-            return this.embedPages(srcPages);
-        });
+    async embedPdf(pdf, indices = [0]) {
+        assertIs(pdf, 'pdf', [
+            'string',
+            Uint8Array,
+            ArrayBuffer,
+            [PDFDocument, 'PDFDocument'],
+        ]);
+        assertIs(indices, 'indices', [Array]);
+        const srcDoc = pdf instanceof PDFDocument ? pdf : await PDFDocument.load(pdf);
+        const srcPages = pluckIndices(srcDoc.getPages(), indices);
+        return this.embedPages(srcPages);
     }
     /**
      * Embed a single PDF page into this document.
@@ -40106,12 +40092,10 @@ class PDFDocument {
      * page anywhere it is drawn.
      * @returns Resolves with the embedded pdf page.
      */
-    embedPage(page, boundingBox, transformationMatrix) {
-        return __awaiter(this, void 0, void 0, function* () {
-            assertIs(page, 'page', [[PDFPage, 'PDFPage']]);
-            const [embeddedPage] = yield this.embedPages([page], [boundingBox], [transformationMatrix]);
-            return embeddedPage;
-        });
+    async embedPage(page, boundingBox, transformationMatrix) {
+        assertIs(page, 'page', [[PDFPage, 'PDFPage']]);
+        const [embeddedPage] = await this.embedPages([page], [boundingBox], [transformationMatrix]);
+        return embeddedPage;
     }
     /**
      * Embed one or more PDF pages into this document.
@@ -40141,34 +40125,32 @@ class PDFDocument {
      * (each page's transformation will apply anywhere it is drawn).
      * @returns Resolves with an array of the embedded pdf pages.
      */
-    embedPages(pages, boundingBoxes = [], transformationMatrices = []) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (pages.length === 0)
-                return [];
-            // Assert all pages have the same context
-            for (let idx = 0, len = pages.length - 1; idx < len; idx++) {
-                const currPage = pages[idx];
-                const nextPage = pages[idx + 1];
-                if (currPage.node.context !== nextPage.node.context) {
-                    throw new PageEmbeddingMismatchedContextError();
-                }
-            }
-            const context = pages[0].node.context;
-            const maybeCopyPage = context === this.context
-                ? (p) => p
-                : PDFObjectCopier.for(context, this.context).copy;
-            const embeddedPages = new Array(pages.length);
-            for (let idx = 0, len = pages.length; idx < len; idx++) {
-                const page = maybeCopyPage(pages[idx].node);
-                const box = boundingBoxes[idx];
-                const matrix = transformationMatrices[idx];
-                const embedder = yield PDFPageEmbedder.for(page, box, matrix);
-                const ref = this.context.nextRef();
-                embeddedPages[idx] = PDFEmbeddedPage.of(ref, this, embedder);
-            }
-            this.embeddedPages.push(...embeddedPages);
-            return embeddedPages;
-        });
+    async embedPages(pages, boundingBoxes = [], transformationMatrices = []) {
+        if (pages.length === 0)
+            return [];
+        // Assert all pages have the same context
+        for (let idx = 0, len = pages.length - 1; idx < len; idx++) {
+            const currPage = pages[idx];
+            const nextPage = pages[idx + 1];
+            if (currPage.node.context !== nextPage.node.context) {
+                throw new PageEmbeddingMismatchedContextError();
+            }
+        }
+        const context = pages[0].node.context;
+        const maybeCopyPage = context === this.context
+            ? (p) => p
+            : PDFObjectCopier.for(context, this.context).copy;
+        const embeddedPages = new Array(pages.length);
+        for (let idx = 0, len = pages.length; idx < len; idx++) {
+            const page = maybeCopyPage(pages[idx].node);
+            const box = boundingBoxes[idx];
+            const matrix = transformationMatrices[idx];
+            const embedder = await PDFPageEmbedder.for(page, box, matrix);
+            const ref = this.context.nextRef();
+            embeddedPages[idx] = PDFEmbeddedPage.of(ref, this, embedder);
+        }
+        this.embeddedPages.push(...embeddedPages);
+        return embeddedPages;
     }
     /**
      * > **NOTE:** You shouldn't need to call this method directly. The [[save]]
@@ -40180,14 +40162,12 @@ class PDFDocument {
      *
      * @returns Resolves when the flush is complete.
      */
-    flush() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.embedAll(this.fonts);
-            yield this.embedAll(this.images);
-            yield this.embedAll(this.embeddedPages);
-            yield this.embedAll(this.embeddedFiles);
-            yield this.embedAll(this.javaScripts);
-        });
+    async flush() {
+        await this.embedAll(this.fonts);
+        await this.embedAll(this.images);
+        await this.embedAll(this.embeddedPages);
+        await this.embedAll(this.embeddedFiles);
+        await this.embedAll(this.javaScripts);
     }
     /**
      * Serialize this document to an array of bytes making up a PDF file.
@@ -40205,24 +40185,22 @@ class PDFDocument {
      * @param options The options to be used when saving the document.
      * @returns Resolves with the bytes of the serialized document.
      */
-    save(options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { useObjectStreams = true, addDefaultPage = true, objectsPerTick = 50, updateFieldAppearances = true, } = options;
-            assertIs(useObjectStreams, 'useObjectStreams', ['boolean']);
-            assertIs(addDefaultPage, 'addDefaultPage', ['boolean']);
-            assertIs(objectsPerTick, 'objectsPerTick', ['number']);
-            assertIs(updateFieldAppearances, 'updateFieldAppearances', ['boolean']);
-            if (addDefaultPage && this.getPageCount() === 0)
-                this.addPage();
-            if (updateFieldAppearances) {
-                const form = this.formCache.getValue();
-                if (form)
-                    form.updateFieldAppearances();
-            }
-            yield this.flush();
-            const Writer = useObjectStreams ? PDFStreamWriter : PDFWriter;
-            return Writer.forContext(this.context, objectsPerTick).serializeToBuffer();
-        });
+    async save(options = {}) {
+        const { useObjectStreams = true, addDefaultPage = true, objectsPerTick = 50, updateFieldAppearances = true, } = options;
+        assertIs(useObjectStreams, 'useObjectStreams', ['boolean']);
+        assertIs(addDefaultPage, 'addDefaultPage', ['boolean']);
+        assertIs(objectsPerTick, 'objectsPerTick', ['number']);
+        assertIs(updateFieldAppearances, 'updateFieldAppearances', ['boolean']);
+        if (addDefaultPage && this.getPageCount() === 0)
+            this.addPage();
+        if (updateFieldAppearances) {
+            const form = this.formCache.getValue();
+            if (form)
+                form.updateFieldAppearances();
+        }
+        await this.flush();
+        const Writer = useObjectStreams ? PDFStreamWriter : PDFWriter;
+        return Writer.forContext(this.context, objectsPerTick).serializeToBuffer();
     }
     /**
      * Serialize this document to a base64 encoded string or data URI making up a
@@ -40239,14 +40217,12 @@ class PDFDocument {
      * @returns Resolves with a base64 encoded string or data URI of the
      *          serialized document.
      */
-    saveAsBase64(options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { dataUri = false } = options, otherOptions = __rest(options, ["dataUri"]);
-            assertIs(dataUri, 'dataUri', ['boolean']);
-            const bytes = yield this.save(otherOptions);
-            const base64 = encodeToBase64(bytes);
-            return dataUri ? `data:application/pdf;base64,${base64}` : base64;
-        });
+    async saveAsBase64(options = {}) {
+        const { dataUri = false, ...otherOptions } = options;
+        assertIs(dataUri, 'dataUri', ['boolean']);
+        const bytes = await this.save(otherOptions);
+        const base64 = encodeToBase64(bytes);
+        return dataUri ? `data:application/pdf;base64,${base64}` : base64;
     }
     findPageForAnnotationRef(ref) {
         const pages = this.getPages();
@@ -40259,12 +40235,10 @@ class PDFDocument {
         }
         return undefined;
     }
-    embedAll(embeddables) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let idx = 0, len = embeddables.length; idx < len; idx++) {
-                yield embeddables[idx].embed();
-            }
-        });
+    async embedAll(embeddables) {
+        for (let idx = 0, len = embeddables.length; idx < len; idx++) {
+            await embeddables[idx].embed();
+        }
     }
     updateInfoDict() {
         const pdfLib = `pdf-lib (https://github.com/Hopding/pdf-lib)`;
@@ -41628,772 +41602,70 @@ exports.isBlock = isBlock;
 
 var index = /*@__PURE__*/unwrapExports(dist);
 
-/** This value represents the precision we accept for float values */
-const FLOAT_APPROXIMATION = 0.000001;
-/** Calculates the distance between 2 points */
-const distance = (A, B) => norm(vector(A, B));
-const distanceCoords = (A, B) => norm(minus(B, A));
-/** Calculates the distance denoted by a vector */
-const norm = (vect) => Math.sqrt(vect.x * vect.x + vect.y * vect.y);
-/** Calculates the orthogonal vector of provided vector */
-const orthogonal = ({ x, y }) => ({
-    x: -y,
-    y: x,
-});
-/** Check if 2 vectors are proportional */
-const isColinear = ({ x: ux, y: uy }, { x: vx, y: vy }) => isEqual(ux * vy, uy * vx);
-/** Check if 2 floating values can be considered equals */
-const isEqual = (a, b) => Math.round(Math.abs(a - b) / FLOAT_APPROXIMATION) === 0;
-/** Calculate the scalar product between 2 vectors */
-const scalar = ({ x: ux, y: uy }, { x: vx, y: vy }) => ux * vx + uy * vy;
-/** Calculate the sum of 2 vectors */
-const plus = ({ x: ux, y: uy }, { x: vx, y: vy }) => ({ x: ux + vx, y: uy + vy });
-/** Calculate the vector multiplied by a scalar */
-const times = ({ x, y }, k = 1) => ({
-    x: k * x,
-    y: k * y,
-});
-/** Calculate the difference of 2 vectors */
-const minus = (u, v) => plus(u, times(v, -1));
-/** Returns the vector between 2 points. */
-const vector = (A, B) => minus(B.toCoords(), A.toCoords());
-/**
- * Returns the angle between the vector and the horizontal axis (Ox).
- * The return value is between -PI and PI.
- * @returns {number} angle in radian between -Pi and Pi
- */
-const orientation = ({ x, y }) => {
-    const alpha = Math.acos(x / Math.sqrt(x * x + y * y));
-    return y > 0 ? alpha : -alpha;
-};
-/** Returns the unit vector associated to the provided vector,
- * or the Null vector (0, 0) if the vector is null
- */
-const unitVector = (u) => {
-    const l = norm(u);
-    return l > 0 ? times(u, 1 / l) : u;
-};
-/** Returns the angle from u to v in radian */
-const angle = (u, v, previousAngle = 0) => {
-    let sweep = orientation(v) - orientation(u);
-    // If the angle has the same sign as the arc orientation, we return the angle as is
-    // Otherwise, we need to correct the value, adding or removing 2π
-    while (Math.abs(previousAngle - sweep) > Math.PI) {
-        sweep += Math.sign(previousAngle - sweep) * 2 * Math.PI;
-    }
-    return sweep;
-};
-/** Returns the angle between the lines (BA) and (BC) in radian
- * @returns {number} the angle in radian, between -Pi and Pi
- */
-const angleABC = (A, B, C, previousAngle = 0) => angle(vector(B, A), vector(B, C), previousAngle);
-/** Rotate the vector by an angle in radian */
-const rotate = (vect, teta) => {
-    const { x, y } = vect;
-    const nx = x * Math.cos(teta) - y * Math.sin(teta);
-    const ny = y * Math.cos(teta) + x * Math.sin(teta);
-    return { x: nx, y: ny };
-};
-
-class GraphElement {
-    distance(P) {
-        const H = this.orthoProjection(P);
-        return distance(H, P);
-    }
-}
-
-class Point extends GraphElement {
-    constructor(coords = { x: 0, y: 0 }) {
-        super();
-        this.x = coords.x;
-        this.y = coords.y;
-    }
-    toCoords() {
-        return { x: this.x, y: this.y };
-    }
-    isEqual(element) {
-        if (!(element instanceof Point))
-            return false;
-        const A = this.toCoords();
-        const B = element.toCoords();
-        return isEqual(A.x, B.x) && isEqual(A.y, B.y);
-    }
-    orthoProjection() {
-        return new Point(this.toCoords());
-    }
-    plus(vect) {
-        const P = new Point(plus(this.toCoords(), vect));
-        return P;
-    }
-}
-Point.type = 'PointFixed';
-
-class Circle extends GraphElement {
-    constructor(O = new Point(), r = 1) {
-        super();
-        this.O = O;
-        this.r = r;
-    }
-    ray() {
-        return this.r;
-    }
-    center() {
-        return this.O;
-    }
-    /** This is used to standardize type Circle | Arc */
-    getCircle() {
-        return this;
-    }
-    isEqual(element) {
-        return (element instanceof Circle &&
-            this.center().isEqual(element.center()) &&
-            isEqual(this.ray(), element.ray()));
-    }
-    includes(P) {
-        return isEqual(distance(this.center(), P), this.ray());
-    }
-    orthoProjection(P) {
-        const center = this.center().toCoords();
-        const coords = P.toCoords();
-        if (distanceCoords(coords, center) < this.ray())
-            return P;
-        const vect = times(unitVector(minus(coords, center)), this.ray());
-        return new Point(plus(center, vect));
-    }
-}
+const identityMatrix = [1, 0, 0, 1, 0, 0];
 
-class Arc extends GraphElement {
-    constructor(O = new Point(), A = new Point(), B = new Point(), lastSweep = 0) {
-        super();
-        this.O = O;
-        this.A = A;
-        this.B = B;
-        this.lastSweep = lastSweep;
-    }
-    center() {
-        return this.O;
-    }
-    origin() {
-        return this.A;
-    }
-    destination() {
-        return this.getCircle().orthoProjection(this.B);
-    }
-    sweep() {
-        this.lastSweep = angleABC(this.origin(), this.center(), this.destination(), this.lastSweep);
-        return this.lastSweep;
-    }
-    ray() {
-        return distance(this.center(), this.origin());
-    }
-    isEqual(element) {
-        if (!(element instanceof Arc))
-            return false;
-        const dest = this.destination();
-        const o = this.origin();
-        const eDest = element.destination();
-        const eO = element.origin();
-        return (this.getCircle().isEqual(element.getCircle()) &&
-            ((dest.isEqual(eDest) && o.isEqual(eO)) ||
-                (dest.isEqual(eO) && o.isEqual(eDest))));
-    }
-    getCircle() {
-        const circle = new Circle(this.center(), this.ray());
-        return circle;
-    }
-    originVect() {
-        return vector(this.center(), this.origin());
-    }
-    middle() {
-        const halfSweep = this.sweep() / 2;
-        const mid = this.center().plus(rotate(vector(this.center(), this.origin()), halfSweep));
-        return mid;
-    }
-    includes(P) {
-        // As angles are returned between -π and π, we need the middle of the arc
-        return (this.getCircle().includes(P) &&
-            Math.abs(angleABC(this.middle(), this.center(), P)) <=
-                Math.abs(this.sweep() / 2));
-    }
-    orthoProjection(P) {
-        const H = this.getCircle().orthoProjection(P);
-        if (this.includes(H))
-            return H;
-        else {
-            const origin = this.origin().toCoords();
-            const destination = this.destination().toCoords();
-            // Returns the closest between origin and destination
-            const coords = distanceCoords(H.toCoords(), origin) <
-                distanceCoords(H.toCoords(), destination)
-                ? origin
-                : destination;
-            return new Point(coords);
+const combineMatrix = ([a, b, c, d, e, f], [a2, b2, c2, d2, e2, f2]) => [
+    a * a2 + c * b2,
+    b * a2 + d * b2,
+    a * c2 + c * d2,
+    b * c2 + d * d2,
+    a * e2 + c * f2 + e,
+    b * e2 + d * f2 + f,
+];
+const applyTransformation = ([a, b, c, d, e, f], { x, y }) => ({
+    x: a * x + c * y + e,
+    y: b * x + d * y + f
+});
+const transformationToMatrix = (name, args) => {
+    switch (name) {
+        case 'scale':
+        case 'scaleX':
+        case 'scaleY': {
+            // [sx 0 0 sy 0 0]
+            const [sx, sy = sx] = args;
+            return [name === 'scaleY' ? 1 : sx, 0, 0, name === 'scaleX' ? 1 : sy, 0, 0];
         }
-    }
-}
-
-class Plot extends GraphElement {
-    constructor(points = []) {
-        super();
-        this.points = points;
-    }
-    getPoints() {
-        return [...this.points];
-    }
-    translate(translationVector) {
-        this.points = this.points.map((point) => plus(point, translationVector));
-    }
-    isEqual(element) {
-        if (!(element instanceof Plot))
-            return false;
-        const points = this.getPoints().map((coord) => new Point(coord));
-        const points2 = element.getPoints().map((coord) => new Point(coord));
-        return (points.every((point, i) => point.isEqual(points2[i])) ||
-            points.reverse().every((point, i) => point.isEqual(points2[i])));
-    }
-    orthoProjection(P) {
-        const points = this.getPoints();
-        const orthos = points
-            .slice(0, -1)
-            .map((pt, i) => new Segment(new Point(pt), new Point(points[i + 1])))
-            .map((seg) => seg.orthoProjection(P));
-        let min = Number.POSITIVE_INFINITY;
-        let closest = new Point(points[0]);
-        orthos.forEach((ortho) => {
-            const d = ortho.distance(P);
-            if (d < min) {
-                min = d;
-                closest = ortho;
-            }
-        });
-        return closest;
-    }
-}
-
-class Rectangle extends GraphElement {
-    constructor(start = new Point(), end = new Point()) {
-        super();
-        this.start = start;
-        this.end = end;
-    }
-    getSize() {
-        const start = this.start.toCoords();
-        const end = this.end.toCoords();
-        return {
-            width: Math.abs(start.x - end.x),
-            height: Math.abs(start.y - end.y),
-        };
-    }
-    getCoords() {
-        const start = this.start.toCoords();
-        const end = this.end.toCoords();
-        return {
-            x: Math.min(start.x, end.x),
-            y: Math.max(start.y, end.y),
-        };
-    }
-    getStart() {
-        const start = new Point(this.getCoords());
-        return start;
-    }
-    getEnd() {
-        const { width, height } = this.getSize();
-        const end = new Point(this.getStart()).plus({ x: width, y: -height });
-        return end;
-    }
-    center() {
-        const center = new Segment(this.getStart(), this.getEnd()).middle();
-        return center;
-    }
-    isEqual(element) {
-        return (element instanceof Rectangle &&
-            this.getStart().isEqual(element.getStart()) &&
-            this.getEnd().isEqual(element.getEnd()));
-    }
-    orthoProjection(P) {
-        const { x, y } = this.getCoords();
-        const end = this.getEnd().toCoords();
-        const { x: Px, y: Py } = P.toCoords();
-        const Hx = Px < x ? x : Px > end.x ? end.x : Px;
-        const Hy = Py > y ? y : Py < end.y ? end.y : Py;
-        return new Point({ x: Hx, y: Hy });
-    }
-}
-Rectangle.type = 'Rectangle';
-
-function intersections(A, B) {
-    if (A instanceof Point || B instanceof Point)
-        return [];
-    else if (A instanceof Text || B instanceof Text)
-        return [];
-    else if (A instanceof Image || B instanceof Image)
-        return [];
-    // TODO: calculate the coords of the intersection: https://www.emathzone.com/tutorials/geometry/intersection-of-line-and-ellipse.html
-    else if (A instanceof Line)
-        return intersectionsLine(A, B);
-    else if (A instanceof Segment) {
-        return intersectionsLine(A.getLine(), B).filter((P) => A.includes(new Point(P)));
-    }
-    else if (A instanceof Circle)
-        return intersectionsCircle(A, B);
-    else if (A instanceof Arc) {
-        return intersectionsCircle(A.getCircle(), B).filter((P) => A.includes(new Point(P)));
-    }
-    else if (A instanceof Plot)
-        return intersectionsPlot(A, B);
-    else if (A instanceof Rectangle)
-        return intersectionsRectangle(A, B);
-    else if (A instanceof Ellipse)
-        return intersectionsEllipse(A, B);
-    return A;
-}
-function intersectionsLine(A, B) {
-    if (B instanceof Line)
-        return intersectionLine(A, B);
-    else if (B instanceof Segment) {
-        return intersectionLine(A, B.getLine()).filter((P) => B.includes(new Point(P)));
-    }
-    else if (B instanceof Circle)
-        return intersectionCircleLine(B, A);
-    else if (B instanceof Arc) {
-        return intersectionsCircle(B.getCircle(), A).filter((P) => B.includes(new Point(P)));
-    }
-    else if (B instanceof Plot)
-        return intersectionsPlot(B, A);
-    else if (B instanceof Rectangle)
-        return intersectionsRectangle(B, A);
-    else if (B instanceof Ellipse)
-        return intersectionsEllipse(B, A);
-    return B;
-}
-function intersectionsEllipse(A, B) {
-    if (B instanceof Line)
-        return intersectionsLineAndEllipse(A, B);
-    else if (B instanceof Segment) {
-        return intersectionsEllipse(A, B.getLine()).filter((P) => B.includes(new Point(P)));
-    }
-    // TODO:
-    // else if (B instanceof Circle) return intersectionEllipseCircle(B, A)
-    else if (B instanceof Circle)
-        return [];
-    // TODO:
-    // else if (B instanceof Ellipse) return intersectionEllipseEllipse(B, A)
-    else if (B instanceof Ellipse)
-        return [];
-    else if (B instanceof Arc) {
-        return intersectionsEllipse(A, B.getCircle()).filter((P) => B.includes(new Point(P)));
-    }
-    else if (B instanceof Plot)
-        return intersectionsPlot(B, A);
-    else if (B instanceof Rectangle)
-        return intersectionsRectangle(B, A);
-    return B;
-}
-function intersectionsLineAndEllipse(A, B) {
-    const center = A.center().toCoords();
-    const a = A.a();
-    const b = A.b();
-    const rotation = A.rotation();
-    const isLineParallel2YAxis = isEqual(B.dirVect().x, 0);
-    // this is a dummy value to represent a point on the line
-    const p1Y = isLineParallel2YAxis ? 1 : B.y(1);
-    const p1X = isLineParallel2YAxis ? B.origin().toCoords().x : 1;
-    const p1 = { x: p1X, y: p1Y };
-    // this is a dummy value to represent a point on the line
-    const p2Y = isLineParallel2YAxis ? 2 : B.y(2);
-    const p2X = isLineParallel2YAxis ? B.origin().toCoords().x : 2;
-    const p2 = { x: p2X, y: p2Y };
-    const p1Normalized = rotate({ x: p1.x - center.x, y: p1.y - center.y }, -rotation);
-    const p2Normalized = rotate({ x: p2.x - center.x, y: p2.y - center.y }, -rotation);
-    const angular = (p1Normalized.y - p2Normalized.y) / (p1Normalized.x - p2Normalized.x);
-    const linear = p1Normalized.y - angular * p1Normalized.x;
-    const lineY = (x) => angular * x + linear;
-    const denormalize = (coord) => {
-        const rotated = rotate(coord, rotation);
-        return {
-            x: rotated.x + center.x,
-            y: rotated.y + center.y,
-        };
-    };
-    // Intersection with vertical line
-    if (isEqual(p1Normalized.x - p2Normalized.x, 0)) {
-        const x = p1Normalized.x;
-        const delta = b ** 2 - (x ** 2 * b ** 2) / a ** 2;
-        if (delta < 0)
-            return [];
-        else if (delta === 0) {
-            return [{ x, y: 0 }].map(denormalize);
+        case 'translate':
+        case 'translateX':
+        case 'translateY': {
+            // [1 0 0 1 tx ty]
+            const [tx, ty = tx] = args;
+            // -ty is necessary because the pdf's y axis is inverted
+            return [1, 0, 0, 1, name === 'translateY' ? 0 : tx, name === 'translateX' ? 0 : -ty];
         }
-        else {
-            const y1 = Math.sqrt((b ** 2 * (a ** 2 - x ** 2)) / a ** 2);
-            const y2 = -y1;
-            return [
-                { x, y: y1 },
-                { x, y: y2 },
-            ].map(denormalize);
-        }
-    }
-    // Intersection with any line
-    // the quadratic equation is:
-    // alpha * x ** 2 + beta * x + gamma = 0
-    const alpha = a ** 2 * angular ** 2 + b ** 2;
-    const beta = 2 * a ** 2 * (angular * linear);
-    const gamma = a ** 2 * (linear ** 2 - b ** 2);
-    const delta = beta ** 2 - 4 * alpha * gamma;
-    if (delta < 0)
-        return [];
-    else if (delta === 0) {
-        const x = -(beta ** 2) / (2 * alpha);
-        const y = lineY(x);
-        return [{ x, y }].map(denormalize);
-    }
-    else {
-        const x1 = (-beta + Math.sqrt(delta)) / (2 * alpha);
-        const y1 = lineY(x1);
-        const x2 = (-beta - Math.sqrt(delta)) / (2 * alpha);
-        const y2 = lineY(x2);
-        return [
-            { x: x1, y: y1 },
-            { x: x2, y: y2 },
-        ].map(denormalize);
-    }
-}
-function intersectionLine(A, B) {
-    if (isColinear(A.dirVect(), B.dirVect()))
-        return [];
-    else {
-        const { x: ux, y: uy } = A.dirVect();
-        const { x: vx, y: vy } = B.dirVect();
-        const { x: xA, y: yA } = A.origin().toCoords();
-        const { x: xB, y: yB } = B.origin().toCoords();
-        const x = (ux * (vx * (yA - yB) + vy * xB) - uy * vx * xA) / (ux * vy - uy * vx);
-        const y = (uy * (vy * (xA - xB) + vx * yB) - ux * vy * yA) / (uy * vx - ux * vy);
-        return [{ x, y }];
-    }
-}
-function intersectionsPlot(A, B) {
-    const points = A.getPoints().map((pt) => new Point(pt));
-    const head = points.pop();
-    const segments = points.map((pt, i) => new Segment(pt, points[i + 1] || head));
-    // @ts-ignore
-    const inters = segments.map((s) => intersections(s, B)).flat();
-    return inters;
-}
-function intersectionsRectangle(A, B) {
-    const P1 = A.getCoords();
-    const P3 = A.getEnd();
-    const P2 = { x: P1.x, y: P3.y };
-    const P4 = { x: P3.x, y: P1.y };
-    return intersections(new Plot([P1, P2, P3, P4, P1]), B);
-}
-function intersectionCircleLine(A, B) {
-    const rA = A.ray();
-    const O = A.center();
-    const H = B.orthoProjection(O);
-    const OH = distance(O, H);
-    // The line is tangeant
-    if (isEqual(OH, rA))
-        return [H];
-    // The line is too far from the circle
-    else if (OH > A.ray())
-        return [];
-    // The line cut the circle in 2 points
-    else {
-        // Pythagore
-        const HP = Math.sqrt(rA * rA - OH * OH);
-        const vect = unitVector(B.dirVect());
-        return [H.plus(times(vect, HP)), H.plus(times(vect, -HP))];
-    }
-}
-function intersectionCircle(A, B) {
-    const oA = A.center();
-    const oB = B.center();
-    const rA = A.ray();
-    const rB = B.ray();
-    const axis = vector(oA, oB);
-    const CC = norm(axis);
-    // The circles are tangeant
-    if (isEqual(CC, rA + rB))
-        return [A.orthoProjection(oB).toCoords()];
-    // The circles are too far from eachother
-    else if (CC > rA + rB)
-        return [];
-    // The intersections belong to an orthogonal axis
-    else {
-        const ratio = 1 / 2 + (rA * rA - rB * rB) / (CC * CC) / 2;
-        const H = oA.plus(times(axis, ratio));
-        return intersectionCircleLine(A, new Line(H, H.plus(orthogonal(axis))));
-    }
-}
-function intersectionsCircle(A, B) {
-    if (B instanceof Circle)
-        return intersectionCircle(A, B);
-    else if (B instanceof Line)
-        return intersectionCircleLine(A, B);
-    else if (B instanceof Segment) {
-        return intersectionCircleLine(A, B.getLine()).filter((P) => B.includes(new Point(P)));
-    }
-    else if (B instanceof Arc) {
-        return intersectionCircle(A, B.getCircle()).filter((P) => B.includes(new Point(P)));
-    }
-    else if (B instanceof Plot)
-        return intersectionsPlot(B, A);
-    else if (B instanceof Rectangle)
-        return intersectionsRectangle(B, A);
-    else if (B instanceof Ellipse)
-        return intersectionsEllipse(B, A);
-    return B;
-}
-function getIntersections(elements) {
-    const checked = [];
-    const inters = [];
-    elements.forEach((elt) => {
-        checked.forEach((e) => inters.push(...intersections(e, elt)));
-        checked.push(elt);
-    });
-    return inters;
-}
-
-class Line extends GraphElement {
-    constructor(A = new Point(), B = new Point()) {
-        super();
-        this.A = A;
-        this.B = B;
-    }
-    origin() {
-        return this.A;
-    }
-    dirVect() {
-        return vector(this.A, this.B);
-    }
-    /** Line equation */
-    y(x) {
-        const a = this.a();
-        const b = this.b();
-        return a * x + b;
-    }
-    /** The slope */
-    a() {
-        const dirVect = this.dirVect();
-        return dirVect.y / dirVect.x;
-    }
-    /** Origin y coordinate */
-    b() {
-        const O = this.origin().toCoords();
-        const a = this.a();
-        return O.y - a * O.x;
-    }
-    isEqual(element) {
-        const vect = this.dirVect();
-        return (element instanceof Line &&
-            isColinear(vect, element.dirVect()) &&
-            (isEqual(vect.x, 0)
-                ? // We need to take care of the case of the vertical line
-                    isEqual(this.origin().toCoords().x, element.origin().toCoords().x)
-                : isEqual(this.b(), element.b())));
-    }
-    /** Reversed line equation */
-    x(y) {
-        const dirVect = this.dirVect();
-        return ((y - this.b()) * dirVect.x) / dirVect.y;
-    }
-    includes(P) {
-        const { x, y } = P.toCoords();
-        const vect = this.dirVect();
-        return isEqual(vect.x, 0)
-            ? isEqual(this.origin().toCoords().x, x)
-            : isEqual(this.y(x), y);
-    }
-    /** This is used to standarsize type Segment | HalfLine | Line */
-    getLine() {
-        const line = new Line(this.origin(), this.B);
-        return line;
-    }
-    orthoProjection(P) {
-        const vectOrtho = orthogonal(this.dirVect());
-        const A = new Point(P.toCoords());
-        const ortho = new Line(A, A.plus(vectOrtho));
-        const H = intersectionLine(this, ortho)[0];
-        return new Point(H);
-    }
-}
-
-class Segment extends GraphElement {
-    constructor(A = new Point(), B = new Point()) {
-        super();
-        this.A = A;
-        this.B = B;
-    }
-    origin() {
-        return this.A;
-    }
-    destination() {
-        return this.B;
-    }
-    dirVect() {
-        return vector(this.origin(), this.destination());
-    }
-    length() {
-        return distance(this.destination(), this.origin());
-    }
-    isEqual(element) {
-        if (!(element instanceof Segment))
-            return false;
-        const o = this.origin();
-        const dest = this.destination();
-        const oE = element.origin();
-        const destE = element.destination();
-        return (element instanceof Segment &&
-            ((o.isEqual(oE) && dest.isEqual(destE)) ||
-                (o.isEqual(destE) && dest.isEqual(oE))));
-    }
-    /** Returns an equivalent line object */
-    getLine() {
-        const line = new Line(this.origin(), this.destination());
-        return line;
-    }
-    includes(P) {
-        const vect = this.dirVect();
-        const otherVect = vector(this.origin(), P);
-        // The vectors are not even colinear
-        if (!isColinear(vect, otherVect))
-            return false;
-        // The point is behind the origin
-        else if (scalar(vect, otherVect) < 0)
-            return false;
-        // The point is after the destination
-        else if (norm(vect) < norm(otherVect))
-            return false;
-        else
-            return true;
-    }
-    middle() {
-        const mid = new Point(plus(this.origin().toCoords(), times(this.dirVect(), 0.5)));
-        return mid;
-    }
-    orthoProjection(P) {
-        const H = this.getLine().orthoProjection(P);
-        const vect = this.dirVect();
-        const origin = this.origin().toCoords();
-        const destination = this.destination().toCoords();
-        const otherVect = vector(this.origin(), H);
-        // The point is before the origin
-        if (scalar(vect, otherVect) < 0)
-            return new Point(origin);
-        // The point is after the destination
-        else if (norm(vect) < norm(otherVect))
-            return new Point(destination);
-        // The point is within the segment
-        else
-            return H;
-    }
-}
-Segment.type = 'Segment';
-
-class Ellipse extends GraphElement {
-    constructor(A = new Point(), B = new Point(), C = new Point()) {
-        super();
-        this.A = A;
-        this.B = B;
-        this.C = C;
-    }
-    center() {
-        const center = this.axis().middle();
-        return center;
-    }
-    axis() {
-        const axis = new Segment(this.A, this.B);
-        return axis;
-    }
-    a() {
-        const axis = this.axis();
-        return Math.max(axis.length() / 2, axis.distance(this.C));
-    }
-    b() {
-        const axis = this.axis();
-        return Math.min(axis.length() / 2, axis.distance(this.C));
-    }
-    rotation() {
-        const axis = this.axis();
-        return axis.length() / 2 > axis.distance(this.C)
-            ? orientation(axis.dirVect())
-            : orientation(orthogonal(axis.dirVect()));
-    }
-    getSize() {
-        return { width: 2 * this.a(), height: 2 * this.b() };
-    }
-    isEqual(element) {
-        if (!(element instanceof Ellipse))
-            return false;
-        const a = this.a();
-        const b = this.b();
-        const rotation = this.rotation();
-        const eltA = element.a();
-        const eltB = element.b();
-        const eltRotation = element.rotation();
-        // If the main axis is the same on both ellipse
-        if (eltA < eltB === a < b) {
-            // The rotation is equivalent module PI as the element is symetrical
-            return (isEqual(eltA, a) &&
-                isEqual(eltB, b) &&
-                isEqual(rotation + (Math.PI % Math.PI), eltRotation + (Math.PI % Math.PI)));
-        }
-        // If the small axis is different
-        else {
-            // We add a rotation of PI / 2 to emulate the fact that the main axis are actually orthogonal
-            return (isEqual(eltA, b) &&
-                isEqual(eltB, a) &&
-                isEqual(rotation + (Math.PI % Math.PI), eltRotation + (((3 * Math.PI) / 2) % Math.PI)));
-        }
-    }
-    includes(P) {
-        const { x, y } = P.toCoords();
-        const { x: cx, y: cy } = this.center().toCoords();
-        const teta = this.rotation();
-        return isEqual(Math.pow(((x - cx) * Math.cos(teta) + (y - cy) * Math.sin(teta)) / this.a(), 2) +
-            Math.pow(((x - cx) * Math.sin(teta) - (y - cy) * Math.cos(teta)) / this.b(), 2), 1);
-    }
-    orthoProjection(P) {
-        // We will consider that the parametric projection is a correct approximation of the distance for the current case, even if it is not orthogonal
-        const C = this.center();
-        const axis = this.axis();
-        const CP = vector(C, P);
-        const teta = angle(axis.dirVect(), vector(C, P));
-        const ray = this.polarRay(teta);
-        if (distance(P, this.center()) < ray)
-            return P;
-        const vect = times(unitVector(CP), ray);
-        return new Point(this.center().plus(vect).toCoords());
-    }
-    polarRay(teta) {
-        const a = this.a();
-        const b = this.b();
-        const excentricity = Math.sqrt(Math.abs(a * a - b * b)) / Math.max(a, b);
-        return (Math.min(a, b) / Math.sqrt(1 - Math.pow(excentricity * Math.cos(teta), 2)));
-    }
-}
-
-/**
- * take an array of T and turn it into an 2D-array where each sub array has n elements
- * ex: [1,2,3,4] -> [[1,2], [3, 4]]
- * @param arr the array of elements
- * @param n the size of each sub array
- */
-const groupBy = (arr, n) => {
-    if (arr.length <= n)
-        return [arr];
-    return arr === null || arr === void 0 ? void 0 : arr.reduce((acc, curr, i) => {
-        const index = Math.floor(i / n);
-        if (i % n) {
-            acc[index].push(curr);
+        case 'rotate': {
+            // [cos(a) sin(a) -sin(a) cos(a) 0 0]
+            const [a, x = 0, y = 0] = args;
+            const t1 = transformationToMatrix('translate', [x, y]);
+            const t2 = transformationToMatrix('translate', [-x, -y]);
+            // -args[0] -> the '-' operator is necessary because the pdf rotation system is inverted
+            const aRadians = degreesToRadians(-a);
+            const r = [Math.cos(aRadians), Math.sin(aRadians), -Math.sin(aRadians), Math.cos(aRadians), 0, 0];
+            // rotation around a point is the combination of: translate * rotate * (-translate)
+            return combineMatrix(combineMatrix(t1, r), t2);
+        }
+        case 'skewY':
+        case 'skewX': {
+            // [1 tan(a) 0 1 0 0]
+            // [1 0 tan(a) 1 0 0]
+            // -args[0] -> the '-' operator is necessary because the pdf rotation system is inverted
+            const a = degreesToRadians(-args[0]);
+            const skew = Math.tan(a);
+            const skewX = name === 'skewX' ? skew : 0;
+            const skewY = name === 'skewY' ? skew : 0;
+            return [1, skewY, skewX, 1, 0, 0];
         }
-        else {
-            acc.push([curr]);
+        case 'matrix': {
+            const [a, b, c, d, e, f] = args;
+            const r = transformationToMatrix('scale', [1, -1]);
+            const m = [a, b, c, d, e, f];
+            return combineMatrix(combineMatrix(r, m), r);
         }
-        return acc;
-    }, []);
+        default:
+            return identityMatrix;
+    }
 };
-const isCoordinateInsideTheRect = (dot, rect) => isEqual(0, distance(dot, rect.orthoProjection(dot)));
+const combineTransformation = (matrix, name, args) => combineMatrix(matrix, transformationToMatrix(name, args));
 const StrokeLineCapMap = {
     butt: LineCapStyle.Butt,
     round: LineCapStyle.Round,
@@ -42408,662 +41680,144 @@ const StrokeLineJoinMap = {
     miter: LineJoinStyle.Miter,
     round: LineJoinStyle.Round,
 };
-const getInnerSegment = (start, end, rect) => {
-    const isStartInside = isCoordinateInsideTheRect(start, rect);
-    const isEndInside = isCoordinateInsideTheRect(end, rect);
-    let resultLineStart = start;
-    let resultLineEnd = end;
-    // it means that the segment is already inside the rect
-    if (isEndInside && isStartInside)
-        return new Segment(start, end);
-    const line = new Segment(start, end);
-    const intersection = getIntersections([rect, line]);
-    // if there's no intersection it means that the line doesn't intersects the svgRect and isn't visible
-    if (intersection.length === 0)
-        return;
-    if (!isStartInside) {
-        // replace the line start point by the nearest intersection
-        const nearestPoint = intersection.sort((p1, p2) => distanceCoords(start, p1) - distanceCoords(start, p2))[0];
-        resultLineStart = new Point(nearestPoint);
-    }
-    if (!isEndInside) {
-        // replace the line start point by the nearest intersection
-        const nearestPoint = intersection.sort((p1, p2) => distanceCoords(end, p1) - distanceCoords(end, p2))[0];
-        resultLineEnd = new Point(nearestPoint);
-    }
-    return new Segment(resultLineStart, resultLineEnd);
-};
-const cropSvgElement = (svgRect, element) => {
-    var _a, _b;
-    switch (element.tagName) {
-        case 'text': {
-            const fontSize = element.svgAttributes.fontSize || 12;
-            // TODO: compute the right font boundaries to know which characters should be drawn
-            // this is an workaround to draw text that are just a little outside the viewbox boundaries
-            const start = new Point({
-                x: element.svgAttributes.x || 0,
-                y: element.svgAttributes.y || 0,
-            });
-            const paddingRect = new Rectangle(new Point({
-                x: svgRect.start.x - fontSize,
-                y: svgRect.start.y + fontSize,
-            }), new Point({ x: svgRect.end.x + fontSize, y: svgRect.end.y - fontSize }));
-            if (!isCoordinateInsideTheRect(start, paddingRect)) {
-                element.set_content('');
-            }
-            break;
-        }
-        case 'line': {
-            const start = new Point({
-                x: element.svgAttributes.x1,
-                y: element.svgAttributes.y1,
-            });
-            const end = new Point({
-                x: element.svgAttributes.x2,
-                y: element.svgAttributes.y2,
-            });
-            const line = getInnerSegment(start, end, svgRect);
-            element.svgAttributes.x1 = line ? line.A.x : 0;
-            element.svgAttributes.x2 = line ? line.B.x : 0;
-            element.svgAttributes.y1 = line ? line.A.y : 0;
-            element.svgAttributes.y2 = line ? line.B.y : 0;
-            break;
-        }
-        case 'path': {
-            // the path origin coordinate
-            const basePoint = new Point({
-                x: element.svgAttributes.x || 0,
-                y: element.svgAttributes.y || 0,
-            });
-            const normalizePoint = (p) => new Point({ x: p.x - basePoint.x, y: p.y - basePoint.y });
-            /**
-             *
-             * @param origin is the origin of the current drawing in the page coordinate system
-             * @param command the path instruction
-             * @param params the instruction params
-             * @returns the point where the next instruction starts and the new instruction text
-             */
-            const handlePath = (origin, command, params) => {
-                switch (command) {
-                    case 'm':
-                    case 'M': {
-                        const isLocalInstruction = command === command.toLocaleLowerCase();
-                        const nextPoint = new Point({
-                            x: (isLocalInstruction ? origin.x : basePoint.x) + params[0],
-                            y: (isLocalInstruction ? origin.y : basePoint.y) + params[1],
-                        });
-                        return {
-                            point: nextPoint,
-                            command: `${command}${params[0]},${params[1]}`,
-                        };
-                    }
-                    case 'v':
-                    case 'V':
-                    case 'h':
-                    case 'H':
-                    case 'l':
-                    case 'L': {
-                        const isLocalInstruction = ['l', 'v', 'h'].includes(command);
-                        const getNextPoint = () => {
-                            switch (command.toLocaleLowerCase()) {
-                                case 'l':
-                                    return new Point({
-                                        x: (isLocalInstruction ? origin.x : basePoint.x) + params[0],
-                                        y: (isLocalInstruction ? origin.y : basePoint.y) + params[1],
-                                    });
-                                case 'v':
-                                    return new Point({
-                                        x: origin.x,
-                                        y: (isLocalInstruction ? origin.y : basePoint.y) + params[0],
-                                    });
-                                case 'h':
-                                    return new Point({
-                                        x: (isLocalInstruction ? origin.x : basePoint.x) + params[0],
-                                        y: origin.y,
-                                    });
-                                default:
-                                    return new Point({
-                                        x: 0,
-                                        y: 0,
-                                    });
-                            }
-                        };
-                        const nextPoint = getNextPoint();
-                        const normalizedNext = normalizePoint(nextPoint);
-                        let endPoint = new Point({ x: nextPoint.x, y: nextPoint.y });
-                        let startPoint = new Point({ x: origin.x, y: origin.y });
-                        const result = getInnerSegment(startPoint, endPoint, svgRect);
-                        if (!result) {
-                            return {
-                                point: nextPoint,
-                                command: `M${normalizedNext.x},${normalizedNext.y}`,
-                            };
-                        }
-                        // if the point wasn't moved it means that it's inside the rect
-                        const isStartInside = result.A.isEqual(startPoint);
-                        const isEndInside = result.B.isEqual(endPoint);
-                        // the intersection points are referencing the pdf coordinates, it's necessary to convert these points to the path's origin point
-                        endPoint = normalizePoint(new Point(result.B.toCoords()));
-                        startPoint = normalizePoint(new Point(result.A.toCoords()));
-                        const startInstruction = isStartInside
-                            ? ''
-                            : `M${startPoint.x},${startPoint.y}`;
-                        const endInstruction = isEndInside
-                            ? ''
-                            : `M${normalizedNext.x},${normalizedNext.y}`;
-                        return {
-                            point: nextPoint,
-                            command: `${startInstruction} L${endPoint.x},${endPoint.y} ${endInstruction} `,
-                        };
-                    }
-                    case 'a':
-                    case 'A': {
-                        const isLocalInstruction = command === 'a';
-                        const [, , , , , x, y] = params;
-                        const nextPoint = new Point({
-                            x: (isLocalInstruction ? origin.x : basePoint.x) + x,
-                            y: (isLocalInstruction ? origin.y : basePoint.y) + y,
-                        });
-                        // TODO: implement the code to fit the Elliptical Arc Curve instructions into the viewbox
-                        return {
-                            point: nextPoint,
-                            command: `${command} ${params.map((p) => `${p}`).join()}`,
-                        };
-                    }
-                    case 'c':
-                    case 'C': {
-                        const isLocalInstruction = command === 'c';
-                        let x = 0;
-                        let y = 0;
-                        for (let pendingParams = params; pendingParams.length > 0; pendingParams = pendingParams.slice(6)) {
-                            const [, , , , pendingX, pendingY] = pendingParams;
-                            if (isLocalInstruction) {
-                                x += pendingX;
-                                y += pendingY;
-                            }
-                            else {
-                                x = pendingX;
-                                y = pendingY;
-                            }
-                        }
-                        const nextPoint = new Point({
-                            x: (isLocalInstruction ? origin.x : basePoint.x) + x,
-                            y: (isLocalInstruction ? origin.y : basePoint.y) + y,
-                        });
-                        // TODO: implement the code to fit the Cubic Bézier Curve instructions into the viewbox
-                        return {
-                            point: nextPoint,
-                            command: `${command} ${params.map((p) => `${p}`).join()}`,
-                        };
-                    }
-                    case 's':
-                    case 'S':
-                        const isLocalInstruction = command === 's';
-                        let x = 0;
-                        let y = 0;
-                        for (let pendingParams = params; pendingParams.length > 0; pendingParams = pendingParams.slice(4)) {
-                            const [, , pendingX, pendingY] = pendingParams;
-                            x += pendingX;
-                            y += pendingY;
-                        }
-                        const nextPoint = new Point({
-                            x: (isLocalInstruction ? origin.x : basePoint.x) + x,
-                            y: (isLocalInstruction ? origin.y : basePoint.y) + y,
-                        });
-                        return {
-                            point: nextPoint,
-                            command: `${command} ${params.map((p) => `${p}`).join()}`,
-                        };
-                    case 'q':
-                    case 'Q': {
-                        const isLocalInstruction = command === 'q';
-                        const [, , x, y] = params;
-                        const nextPoint = new Point({
-                            x: (isLocalInstruction ? origin.x : basePoint.x) + x,
-                            y: (isLocalInstruction ? origin.y : basePoint.y) + y,
-                        });
-                        // TODO: implement the code to fit the Quadratic Bézier Curve instructions into the viewbox
-                        return {
-                            point: nextPoint,
-                            command: `${command} ${params.map((p) => `${p}`).join()}`,
-                        };
-                    }
-                    // TODO: Handle the remaining svg instructions: t,q
-                    default:
-                        return {
-                            point: origin,
-                            command: `${command} ${params.map((p) => `${p}`).join()}`,
-                        };
-                }
-            };
-            const commands = (_a = element.svgAttributes.d) === null || _a === void 0 ? void 0 : _a.match(/(v|h|a|l|t|m|q|c|s|z)([0-9,e\s.-]*)/gi);
-            let currentPoint = new Point({ x: basePoint.x, y: basePoint.y });
-            const newPath = commands === null || commands === void 0 ? void 0 : commands.map((command) => {
-                var _a, _b;
-                const letter = (_a = command.match(/[a-z]/i)) === null || _a === void 0 ? void 0 : _a[0];
-                const params = (_b = command
-                    .match(/(-?[0-9]+\.[0-9]+(e[+-]?[0-9]+)?)|(-?\.[0-9]+(e[+-]?[0-9]+)?)|(-?[0-9]+)/gi)) === null || _b === void 0 ? void 0 : _b.filter((m) => m !== '').map((v) => parseFloat(v));
-                if (letter && params) {
-                    const result = handlePath(currentPoint, letter, params);
-                    if (result) {
-                        currentPoint = result.point;
-                        return result.command;
-                    }
-                }
-                return command;
-            }).join(' ');
-            element.svgAttributes.d = newPath;
-            break;
-        }
-        case 'ellipse':
-        case 'circle': {
-            if (element.svgAttributes.cx === undefined ||
-                element.svgAttributes.cy === undefined ||
-                element.svgAttributes.rx === undefined ||
-                element.svgAttributes.ry === undefined) {
-                break;
-            }
-            const { cx = 0, cy = 0, rx = 0, ry = 0 } = element.svgAttributes;
-            const center = new Point({
-                x: cx,
-                y: cy,
-            });
-            const rotation = ((_b = element.svgAttributes.rotation) === null || _b === void 0 ? void 0 : _b.angle) || 0;
-            // these points are relative to the ellipse's center
-            const a = new Point(rotate({ x: -rx, y: 0 }, degreesToRadians(rotation)));
-            const b = new Point(rotate({ x: rx, y: 0 }, degreesToRadians(rotation)));
-            const c = new Point(rotate({ x: 0, y: ry }, degreesToRadians(rotation)));
-            // these points are relative to the real coordinate system
-            const A = center.plus(a);
-            const B = center.plus(b);
-            const C = center.plus(c);
-            const ellipse = new Ellipse(A, B, C);
-            const intersections = getIntersections([svgRect, ellipse]);
-            const isCenterInsideRect = isCoordinateInsideTheRect(center, svgRect);
-            /**
-             * if there are less than 2 intersection, there are two possibilities:
-             * - the ellipse is outside the viewbox and therefore isn't visible
-             * - the ellipse is inside the viewbox and don't need to be cropped
-             */
-            if (intersections.length < 2) {
-                !isCenterInsideRect && element.setAttribute('rx', '0');
-                !isCenterInsideRect && (element.svgAttributes.rx = 0);
-                !isCenterInsideRect && element.setAttribute('ry', '0');
-                !isCenterInsideRect && (element.svgAttributes.ry = 0);
-                break;
-            }
-            // viewbox rectangle coordinates
-            const P1 = new Point(svgRect.getCoords());
-            const P3 = new Point(svgRect.getEnd());
-            const P2 = new Point({ x: P3.x, y: P1.y });
-            const P4 = new Point({ x: P1.x, y: P3.y });
-            const top = new Segment(P1, P2);
-            const right = new Segment(P2, P3);
-            const bottom = new Segment(P3, P4);
-            const left = new Segment(P4, P1);
-            // Warning: keep the order of the segments, it's important when building the path that will represent the ellipse
-            const rectSegments = [top, right, bottom, left];
-            const isPointInsideEllipse = (P) => (P.x - cx) ** 2 / rx ** 2 + (P.y - cy) ** 2 / ry ** 2 <= 1;
-            // check if the rect boundaries are inside the circle
-            const isRectInsideEllipse = isPointInsideEllipse(P1) &&
-                isPointInsideEllipse(P2) &&
-                isPointInsideEllipse(P3) &&
-                isPointInsideEllipse(P4);
-            // the segments that are intersecting the circle. And, therefore, are lines that are cropping the drawing
-            const circleSegments = isRectInsideEllipse
-                ? rectSegments
-                : rectSegments.map((segment, i) => {
-                    const [p1, p2] = getIntersections([segment, ellipse])
-                        // it's important to sort the segment's point because it impacts the angle of the arc, the points are sorted on clockwise direction
-                        .sort((p1, p2) => {
-                        // top
-                        if (i === 0) {
-                            return p1.x - p2.x;
-                            // right
-                        }
-                        else if (i === 1) {
-                            return p2.y - p1.y;
-                            // bottom
-                        }
-                        else if (i === 2) {
-                            return p2.x - p1.x;
-                            // left
-                        }
-                        else {
-                            return p1.y - p2.y;
-                        }
-                    });
-                    if (p1 && p2) {
-                        return new Segment(new Point(p1), new Point(p2));
-                        // if the other point isn't inside the circle it means that the circle isn't cropped by the segment
-                    }
-                    else if (p1 &&
-                        (isPointInsideEllipse(segment.A) ||
-                            isPointInsideEllipse(segment.B))) {
-                        const intersectionPoint = new Point(p1);
-                        const innerPoint = isPointInsideEllipse(segment.A)
-                            ? segment.A
-                            : segment.B;
-                        // ensures that the segment is always following the clockwise direction
-                        const start = innerPoint.isEqual(segment.A)
-                            ? innerPoint
-                            : intersectionPoint;
-                        const end = innerPoint.isEqual(segment.A)
-                            ? intersectionPoint
-                            : innerPoint;
-                        return new Segment(start, end);
-                        // if there's no intersection and the segment's points are inside the Ellipse it means that the segment should be drawn as part of the ellipse
-                    }
-                    else if (!(p1 && p2) &&
-                        isPointInsideEllipse(segment.A) &&
-                        isPointInsideEllipse(segment.B)) {
-                        return segment;
-                    }
-                    return;
-                });
-            const inverseAngle = (angle) => (360 - angle) % 360;
-            const pointsAngle = (p1, p2, direction = 'clockwise') => {
-                const startAngle = radiansToDegrees(Math.atan2(p1.y - center.y, p1.x - center.x));
-                const endAngle = radiansToDegrees(Math.atan2(p2.y - center.y, p2.x - center.x));
-                const arcAngle = (endAngle + (360 - startAngle)) % 360;
-                return direction === 'clockwise' ? arcAngle : inverseAngle(arcAngle);
-            };
-            /**
-             * - draw a line for each segment
-             * - if two segments aren't connected draw an arc connecting them
-             */
-            let startPoint;
-            // the point where the pen is located
-            let currentPoint;
-            let lastSegment;
-            let path = circleSegments.reduce((path, segment) => {
-                if (!segment)
-                    return path;
-                if (!startPoint) {
-                    startPoint = segment.A;
-                    path = `M ${segment.A.x},${segment.A.y}`;
-                }
-                // if the current segment isn't connected to the last one, connect both with an arc
-                if (lastSegment && !lastSegment.B.isEqual(segment.A)) {
-                    const arcAngle = pointsAngle(segment.A, lastSegment.B);
-                    // angles greater than 180 degrees are marked as large-arc-flag = 1
-                    path += `A ${rx},${ry} ${rotation} ${arcAngle > 180 ? 1 : 0},0 ${segment.A.x}, ${segment.A.y}`;
-                }
-                path += ` L ${segment.B.x},${segment.B.y}`;
-                currentPoint = segment.B;
-                lastSegment = segment;
-                return path;
-            }, '');
-            // if the path isn't closed, close it by drawing an arc
-            if (startPoint && currentPoint && !startPoint.isEqual(currentPoint)) {
-                const arcAngle = pointsAngle(currentPoint, startPoint, 'counter-clockwise');
-                // angles greater than 180 degrees are marked as large-arc-flag = 1
-                path += `A ${rx},${ry} ${rotation} ${arcAngle > 180 ? 1 : 0},0 ${startPoint.x}, ${startPoint.y}`;
-            }
-            // create a new element that will represent the cropped ellipse
-            const newElement = index.parse(`<path d="${path}" fill="red"/>`).firstChild;
-            const svgAttributes = Object.assign(Object.assign({}, element.svgAttributes), { 
-                // the x and y values are 0 because all the path coordinates are global
-                x: 0, y: 0, 
-                // the path coordinates are already rotated
-                rotate: undefined, d: path });
-            Object.assign(newElement, { svgAttributes });
-            return newElement;
-        }
-        case 'rect': {
-            const { x = 0, y = 0, width = 0, height = 0, rotate: rawRotation, } = element.svgAttributes;
-            const rotation = (rawRotation === null || rawRotation === void 0 ? void 0 : rawRotation.angle) || 0;
-            if (!(width && height))
-                return element;
-            // bottomLeft point
-            const origin = new Point({ x, y });
-            const rotateAroundOrigin = (p) => new Point(rotate(normalize(p), degreesToRadians(rotation))).plus(origin);
-            const normalize = (p) => p.plus({ x: -origin.x, y: -origin.y });
-            const topLeft = rotateAroundOrigin(origin.plus({ x: 0, y: -height }));
-            const topRight = rotateAroundOrigin(origin.plus({ x: width, y: -height }));
-            const bottomRight = rotateAroundOrigin(origin.plus({ x: width, y: 0 }));
-            const pointToString = (p) => [p.x, p.y].join();
-            const d = `M${pointToString(topLeft)} L${pointToString(topRight)} L${pointToString(bottomRight)} L${pointToString(origin)}  L${pointToString(topLeft)}`;
-            const el = index.parse(`<path d="${d}"/>`).firstChild;
-            const newAttributes = Object.assign(Object.assign({}, element.svgAttributes), { d, x: 0, y: 0 });
-            // @ts-ignore
-            delete newAttributes.width;
-            // @ts-ignore
-            delete newAttributes.height;
-            delete newAttributes.rotate;
-            delete newAttributes.rotation;
-            Object.assign(el, {
-                svgAttributes: newAttributes,
-            });
-            return cropSvgElement(svgRect, el);
-        }
-        // TODO: implement the crop for the following elements
-        case 'image':
-        default:
-            return element;
-    }
-    return element;
-};
 // TODO: Improve type system to require the correct props for each tagName.
 /** methods to draw SVGElements onto a PDFPage */
 const runnersToPage = (page, options) => ({
-    text(element) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const anchor = element.svgAttributes.textAnchor;
-            const dominantBaseline = element.svgAttributes.dominantBaseline;
-            const text = element.text.trim().replace(/\s/g, ' ');
-            const fontSize = element.svgAttributes.fontSize || 12;
-            /** This will find the best font for the provided style in the list */
-            function getBestFont(style, fonts) {
-                const family = style.fontFamily;
-                if (!family)
-                    return undefined;
-                const isBold = style.fontWeight === 'bold' || Number(style.fontWeight) >= 700;
-                const isItalic = style.fontStyle === 'italic';
-                const getFont = (bold, italic, family) => fonts[family + (bold ? '_bold' : '') + (italic ? '_italic' : '')];
-                return (getFont(isBold, isItalic, family) ||
-                    getFont(isBold, false, family) ||
-                    getFont(false, isItalic, family) ||
-                    getFont(false, false, family) ||
-                    Object.keys(fonts).find((fontFamily) => fontFamily.startsWith(family)));
-            }
-            const font = options.fonts && getBestFont(element.svgAttributes, options.fonts);
-            const textWidth = (font || page.getFont()[0]).widthOfTextAtSize(text, fontSize);
-            const textHeight = (font || page.getFont()[0]).heightAtSize(fontSize);
-            const offsetX = anchor === 'middle' ? textWidth / 2 : anchor === 'end' ? textWidth : 0;
-            const offsetY = dominantBaseline === 'text-before-edge'
-                ? textHeight
-                : dominantBaseline === 'text-after-edge'
-                    ? -textHeight
-                    : dominantBaseline === 'middle'
-                        ? textHeight / 2
-                        : 0;
-            const point = new Point({
-                x: (element.svgAttributes.x || 0) - offsetX,
-                y: (element.svgAttributes.y || 0) - offsetY,
-            });
-            // TODO: compute the right font boundaries to know which characters should be drawed
-            // this is an workaround to draw text that are just a little outside the viewbox boundaries
-            page.drawText(text, {
-                x: point.x,
-                y: point.y,
-                font,
-                size: fontSize,
-                color: element.svgAttributes.fill,
-                opacity: element.svgAttributes.fillOpacity,
-                rotate: element.svgAttributes.rotate,
-            });
+    async text(element) {
+        const anchor = element.svgAttributes.textAnchor;
+        const dominantBaseline = element.svgAttributes.dominantBaseline;
+        const text = element.text.trim().replace(/\s/g, ' ');
+        const fontSize = element.svgAttributes.fontSize || 12;
+        /** This will find the best font for the provided style in the list */
+        function getBestFont(style, fonts) {
+            const family = style.fontFamily;
+            if (!family)
+                return undefined;
+            const isBold = style.fontWeight === 'bold' || Number(style.fontWeight) >= 700;
+            const isItalic = style.fontStyle === 'italic';
+            const getFont = (bold, italic, family) => fonts[family + (bold ? '_bold' : '') + (italic ? '_italic' : '')];
+            return (getFont(isBold, isItalic, family) ||
+                getFont(isBold, false, family) ||
+                getFont(false, isItalic, family) ||
+                getFont(false, false, family) ||
+                Object.keys(fonts).find((fontFamily) => fontFamily.startsWith(family)));
+        }
+        const font = options.fonts && getBestFont(element.svgAttributes, options.fonts);
+        const textWidth = (font || page.getFont()[0]).widthOfTextAtSize(text, fontSize);
+        const textHeight = (font || page.getFont()[0]).heightAtSize(fontSize);
+        const offsetX = anchor === 'middle' ? textWidth / 2 : anchor === 'end' ? textWidth : 0;
+        const offsetY = dominantBaseline === 'text-before-edge'
+            ? textHeight
+            : dominantBaseline === 'text-after-edge'
+                ? -textHeight
+                : dominantBaseline === 'middle'
+                    ? textHeight / 2
+                    : 0;
+        page.drawText(text, {
+            x: -offsetX,
+            y: -offsetY,
+            font,
+            // TODO: the font size should be correctly scaled too
+            size: fontSize,
+            color: element.svgAttributes.fill,
+            opacity: element.svgAttributes.fillOpacity,
+            matrix: element.svgAttributes.matrix,
+            clipSpaces: element.svgAttributes.clipSpaces,
         });
     },
-    line(element) {
-        return __awaiter(this, void 0, void 0, function* () {
-            page.drawLine({
-                start: {
-                    x: element.svgAttributes.x1,
-                    y: element.svgAttributes.y1,
-                },
-                end: {
-                    x: element.svgAttributes.x2,
-                    y: element.svgAttributes.y2,
-                },
-                thickness: element.svgAttributes.strokeWidth,
-                color: element.svgAttributes.stroke,
-                opacity: element.svgAttributes.strokeOpacity,
-                lineCap: element.svgAttributes.strokeLineCap,
-            });
+    async line(element) {
+        page.drawLine({
+            start: {
+                x: element.svgAttributes.x1 || 0,
+                y: -element.svgAttributes.y1 || 0,
+            },
+            end: {
+                x: element.svgAttributes.x2 || 0,
+                y: -element.svgAttributes.y2 || 0,
+            },
+            thickness: element.svgAttributes.strokeWidth,
+            color: element.svgAttributes.stroke,
+            opacity: element.svgAttributes.strokeOpacity,
+            lineCap: element.svgAttributes.strokeLineCap,
+            matrix: element.svgAttributes.matrix,
+            clipSpaces: element.svgAttributes.clipSpaces,
         });
     },
-    path(element) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!element.svgAttributes.d)
-                return;
-            // See https://jsbin.com/kawifomupa/edit?html,output and
-            page.drawSvgPath(element.svgAttributes.d, {
-                x: element.svgAttributes.x || 0,
-                y: element.svgAttributes.y || 0,
-                borderColor: element.svgAttributes.stroke,
-                borderWidth: element.svgAttributes.strokeWidth,
-                borderOpacity: element.svgAttributes.strokeOpacity,
-                borderLineCap: element.svgAttributes.strokeLineCap,
-                color: element.svgAttributes.fill,
-                opacity: element.svgAttributes.fillOpacity,
-                scale: element.svgAttributes.scale,
-                rotate: element.svgAttributes.rotate,
-                fillRule: element.svgAttributes.fillRule,
-            });
+    async path(element) {
+        if (!element.svgAttributes.d)
+            return;
+        // See https://jsbin.com/kawifomupa/edit?html,output and
+        page.drawSvgPath(element.svgAttributes.d, {
+            x: 0,
+            y: 0,
+            borderColor: element.svgAttributes.stroke,
+            borderWidth: element.svgAttributes.strokeWidth,
+            borderOpacity: element.svgAttributes.strokeOpacity,
+            borderLineCap: element.svgAttributes.strokeLineCap,
+            color: element.svgAttributes.fill,
+            opacity: element.svgAttributes.fillOpacity,
+            fillRule: element.svgAttributes.fillRule,
+            matrix: element.svgAttributes.matrix,
+            clipSpaces: element.svgAttributes.clipSpaces,
         });
     },
-    image(element) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { src } = element.svgAttributes;
-            if (!src)
-                return;
-            const isPng = src.match(/\.png(\?|$)|^data:image\/png;base64/gim);
-            const img = isPng
-                ? yield page.doc.embedPng(src)
-                : yield page.doc.embedJpg(src);
-            const { x, y, width, height } = getFittingRectangle(img.width, img.height, element.svgAttributes.width || img.width, element.svgAttributes.height || img.height, element.svgAttributes.preserveAspectRatio);
-            page.drawImage(img, {
-                x: (element.svgAttributes.x || 0) + x,
-                y: (element.svgAttributes.y || 0) - y - height,
-                width,
-                height,
-                opacity: element.svgAttributes.fillOpacity,
-                xSkew: element.svgAttributes.skewX,
-                ySkew: element.svgAttributes.skewY,
-                rotate: element.svgAttributes.rotate,
-            });
+    async image(element) {
+        const { src } = element.svgAttributes;
+        if (!src)
+            return;
+        const isPng = src.match(/\.png(\?|$)|^data:image\/png;base64/gim);
+        const img = isPng
+            ? await page.doc.embedPng(src)
+            : await page.doc.embedJpg(src);
+        const { x, y, width, height } = getFittingRectangle(img.width, img.height, element.svgAttributes.width || img.width, element.svgAttributes.height || img.height, element.svgAttributes.preserveAspectRatio);
+        page.drawImage(img, {
+            x,
+            y: -y - height,
+            width,
+            height,
+            opacity: element.svgAttributes.fillOpacity,
+            matrix: element.svgAttributes.matrix,
+            clipSpaces: element.svgAttributes.clipSpaces,
         });
     },
-    rect(element) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!element.svgAttributes.fill && !element.svgAttributes.stroke)
-                return;
-            page.drawRectangle({
-                x: element.svgAttributes.x,
-                y: element.svgAttributes.y || 0,
-                width: element.svgAttributes.width,
-                height: element.svgAttributes.height * -1,
-                borderColor: element.svgAttributes.stroke,
-                borderWidth: element.svgAttributes.strokeWidth,
-                borderOpacity: element.svgAttributes.strokeOpacity,
-                borderLineCap: element.svgAttributes.strokeLineCap,
-                color: element.svgAttributes.fill,
-                opacity: element.svgAttributes.fillOpacity,
-                xSkew: element.svgAttributes.skewX,
-                ySkew: element.svgAttributes.skewY,
-                rotate: element.svgAttributes.rotate,
-            });
+    async rect(element) {
+        if (!element.svgAttributes.fill && !element.svgAttributes.stroke)
+            return;
+        page.drawRectangle({
+            x: 0,
+            y: 0,
+            width: element.svgAttributes.width,
+            height: element.svgAttributes.height * -1,
+            borderColor: element.svgAttributes.stroke,
+            borderWidth: element.svgAttributes.strokeWidth,
+            borderOpacity: element.svgAttributes.strokeOpacity,
+            borderLineCap: element.svgAttributes.strokeLineCap,
+            color: element.svgAttributes.fill,
+            opacity: element.svgAttributes.fillOpacity,
+            matrix: element.svgAttributes.matrix,
+            clipSpaces: element.svgAttributes.clipSpaces,
         });
     },
-    ellipse(element) {
-        return __awaiter(this, void 0, void 0, function* () {
-            page.drawEllipse({
-                x: element.svgAttributes.cx,
-                y: element.svgAttributes.cy,
-                xScale: element.svgAttributes.rx,
-                yScale: element.svgAttributes.ry,
-                borderColor: element.svgAttributes.stroke,
-                borderWidth: element.svgAttributes.strokeWidth,
-                borderOpacity: element.svgAttributes.strokeOpacity,
-                borderLineCap: element.svgAttributes.strokeLineCap,
-                color: element.svgAttributes.fill,
-                opacity: element.svgAttributes.fillOpacity,
-                rotate: element.svgAttributes.rotate,
-            });
+    async ellipse(element) {
+        page.drawEllipse({
+            x: element.svgAttributes.cx || 0,
+            y: -(element.svgAttributes.cy || 0),
+            xScale: element.svgAttributes.rx,
+            yScale: element.svgAttributes.ry,
+            borderColor: element.svgAttributes.stroke,
+            borderWidth: element.svgAttributes.strokeWidth,
+            borderOpacity: element.svgAttributes.strokeOpacity,
+            borderLineCap: element.svgAttributes.strokeLineCap,
+            color: element.svgAttributes.fill,
+            opacity: element.svgAttributes.fillOpacity,
+            matrix: element.svgAttributes.matrix,
+            clipSpaces: element.svgAttributes.clipSpaces,
         });
     },
-    circle(element) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return runnersToPage(page, options).ellipse(element);
-        });
+    async circle(element) {
+        return runnersToPage(page, options).ellipse(element);
     },
 });
-const transform = (converter, name, args) => {
-    switch (name) {
-        case 'scaleX':
-            return transform(converter, 'scale', [args[0], 0]);
-        case 'scaleY':
-            return transform(converter, 'scale', [0, args[0]]);
-        case 'scale':
-            const [xScale, yScale = xScale] = args;
-            return {
-                point: (x, y) => converter.point(x * xScale, y * yScale),
-                size: (w, h) => converter.size(w * xScale, h * yScale),
-            };
-        case 'translateX':
-            return transform(converter, 'translate', [args[0], 0]);
-        case 'translateY':
-            return transform(converter, 'translate', [0, args[0]]);
-        case 'translate':
-            const [dx, dy = dx] = args;
-            return {
-                point: (x, y) => converter.point(x + dx, y + dy),
-                size: converter.size,
-            };
-        case 'rotate': {
-            if (args.length > 1) {
-                const [a, x, y = x] = args;
-                let tempResult = transform(converter, 'translate', [x, y]);
-                tempResult = transform(tempResult, 'rotate', [a]);
-                return transform(tempResult, 'translate', [-x, -y]);
-            }
-            else {
-                const [a] = args;
-                const angle = degreesToRadians(a);
-                return {
-                    point: (x, y) => converter.point(x * Math.cos(angle) - y * Math.sin(angle), y * Math.cos(angle) + x * Math.sin(angle)),
-                    size: converter.size,
-                };
-            }
-        }
-        case 'matrix': {
-            const [scaleX, skewY, skewX, scaleY, translateX, translateY] = args;
-            return {
-                point: (x, y) => converter.point(x * scaleX + y * skewX + translateX, x * skewY + y * scaleY + translateY),
-                size: (w, h) => converter.size(w * scaleX, h * scaleY),
-            };
-        }
-        case 'skewX': {
-            const angle = degreesToRadians(args[0]);
-            return {
-                point: (x, y) => converter.point((1 + x) * Math.tan(angle), y),
-                size: converter.size,
-            };
-        }
-        case 'skewY': {
-            const angle = degreesToRadians(args[0]);
-            return {
-                point: (x, y) => converter.point(x, (1 + y) * Math.tan(angle)),
-                size: converter.size,
-            };
-        }
-        default: {
-            console.log('transformation unsupported:', name);
-            return converter;
-        }
-    }
-};
 const styleOrAttribute = (attributes, style, attribute, def) => {
     const value = style[attribute] || attributes[attribute];
     if (!value && typeof def !== 'undefined')
@@ -43093,8 +41847,8 @@ const parseColor = (color, inherited) => {
         alpha: parsedColor.alpha ? parsedColor.alpha + '' : undefined,
     };
 };
-const parseAttributes = (element, inherited, converter) => {
-    var _a, _b, _c, _d, _e, _f, _g;
+const parseAttributes = (element, inherited, matrix) => {
+    var _a, _b, _c, _d;
     const attributes = element.attributes;
     const style = parseStyles(attributes.style);
     const widthRaw = styleOrAttribute(attributes, style, 'width', '');
@@ -43150,7 +41904,6 @@ const parseAttributes = (element, inherited, converter) => {
         dominantBaseline: attributes['dominant-baseline'],
         preserveAspectRatio: attributes.preserveAspectRatio,
     };
-    let newConverter = converter;
     let transformList = attributes.transform || '';
     // Handle transformations set as direct attributes
     [
@@ -43169,28 +41922,11 @@ const parseAttributes = (element, inherited, converter) => {
             transformList = attributes[name] + ' ' + transformList;
         }
     });
-    // skewX, skewY, rotate and scale are handled by the pdf-lib
-    ['skewX', 'skewY', 'rotate'].forEach((name) => {
-        var _a;
-        if (attributes[name]) {
-            const d = (_a = attributes[name].match(/-?(\d+\.?|\.)\d*/)) === null || _a === void 0 ? void 0 : _a[0];
-            if (d !== undefined) {
-                svgAttributes[name] = {
-                    angle: parseInt(d, 10),
-                    type: RotationTypes.Degrees,
-                };
-            }
-        }
-    });
-    if (attributes.scale) {
-        const d = (_e = attributes.scale.match(/-?(\d+\.?|\.)\d*/)) === null || _e === void 0 ? void 0 : _e[0];
-        if (d !== undefined)
-            svgAttributes.scale = parseInt(d, 10);
-    }
     // Convert x/y as if it was a translation
     if (x || y) {
         transformList = transformList + `translate(${x || 0} ${y || 0}) `;
     }
+    let newMatrix = matrix;
     // Apply the transformations
     if (transformList) {
         const regexTransform = /(\w+)\((.+?)\)/g;
@@ -43201,295 +41937,38 @@ const parseAttributes = (element, inherited, converter) => {
                 .split(/\s*,\s*|\s+/)
                 .filter((value) => value.length > 0)
                 .map((value) => parseFloat(value));
-            const currentConverter = newConverter;
-            newConverter = transform(newConverter, name, args);
-            const xAxisVector = minus(currentConverter.point(0, 0), currentConverter.point(1, 0));
-            const xAxisVectorPostTransform = minus(newConverter.point(0, 0), newConverter.point(1, 0));
-            // matrix transform may also represent rotations: https://www.w3.org/TR/SVGTiny12/coords.html
-            if (name === 'rotate' || name === 'matrix') {
-                // transformations over x and y axis might change the page coord direction
-                const { width: xDirection, height: yDirection } = currentConverter.size(1, 1);
-                const rotationAdded = name === 'rotate' ? args[0] : radiansToDegrees(angle(xAxisVectorPostTransform, xAxisVector));
-                // the page Y coord is inverted so the angle rotation is inverted too
-                const pageYDirection = -1;
-                newInherited.rotation = degrees(pageYDirection * rotationAdded * Math.sign(xDirection * yDirection) +
-                    (((_f = inherited.rotation) === null || _f === void 0 ? void 0 : _f.angle) || 0));
-                svgAttributes.rotate = newInherited.rotation;
-            }
+            newMatrix = combineTransformation(newMatrix, name, args);
             parsed = regexTransform.exec(transformList);
         }
     }
-    // x and y were already transformed into a translation. The new reference point is now 0,0
-    const { x: newX, y: newY } = newConverter.point(0, 0);
-    svgAttributes.x = newX;
-    svgAttributes.y = newY;
+    svgAttributes.x = x;
+    svgAttributes.y = y;
     if (attributes.cx || attributes.cy) {
-        const { x: newCX, y: newCY } = newConverter.point(cx || 0, cy || 0);
-        svgAttributes.cx = newCX;
-        svgAttributes.cy = newCY;
+        svgAttributes.cx = cx;
+        svgAttributes.cy = cy;
     }
     if (attributes.rx || attributes.ry || attributes.r) {
-        const { width: newRX, height: newRY } = newConverter.size(rx || 0, ry || 0);
-        svgAttributes.rx = newRX;
-        svgAttributes.ry = newRY;
+        svgAttributes.rx = rx;
+        svgAttributes.ry = ry;
     }
     if (attributes.x1 || attributes.y1) {
-        const { x: newX1, y: newY1 } = newConverter.point(x1 || 0, y1 || 0);
-        svgAttributes.x1 = newX1;
-        svgAttributes.y1 = newY1;
+        svgAttributes.x1 = x1;
+        svgAttributes.y1 = y1;
     }
     if (attributes.x2 || attributes.y2) {
-        const { x: newX2, y: newY2 } = newConverter.point(x2 || 0, y2 || 0);
-        svgAttributes.x2 = newX2;
-        svgAttributes.y2 = newY2;
+        svgAttributes.x2 = x2;
+        svgAttributes.y2 = y2;
     }
     if (attributes.width || attributes.height) {
-        const size = newConverter.size(width !== null && width !== void 0 ? width : inherited.width, height !== null && height !== void 0 ? height : inherited.height);
-        svgAttributes.width = size.width;
-        svgAttributes.height = size.height;
+        svgAttributes.width = width !== null && width !== void 0 ? width : inherited.width;
+        svgAttributes.height = height !== null && height !== void 0 ? height : inherited.height;
     }
-    // We convert all the points from the path
     if (attributes.d) {
-        const { x: xOrigin, y: yOrigin } = newConverter.point(0, 0);
-        // these are the x and y coordinates relative to the svg space, therefore these values weren't parsed by any converter. Each instruction will left the cursor on new position
-        let currentX = 0;
-        let currentY = 0;
-        svgAttributes.d = (_g = attributes.d) === null || _g === void 0 ? void 0 : _g.replace(/(l|m|s|t|q|c|z|a|v|h)([0-9,e\s.-]*)/gi, (command) => {
-            var _a, _b;
-            const letter = (_a = command.match(/[a-z]/i)) === null || _a === void 0 ? void 0 : _a[0];
-            if ((letter === null || letter === void 0 ? void 0 : letter.toLocaleLowerCase()) === 'z')
-                return letter;
-            // const params = command.match(/([0-9e.-]+)/ig)?.filter(m => m !== '')//.map(v => parseFloat(v))
-            const params = (_b = command
-                .match(/(-?[0-9]+\.[0-9]+(e[+-]?[0-9]+)?)|(-?\.[0-9]+(e[+-]?[0-9]+)?)|(-?[0-9]+)/gi)) === null || _b === void 0 ? void 0 : _b.filter((m) => m !== ''); // .map(v => parseFloat(v))
-            if (!params)
-                return letter || '';
-            switch (letter === null || letter === void 0 ? void 0 : letter.toLocaleLowerCase()) {
-                case 'm':
-                case 'l': {
-                    const groupedParams = groupBy(params, 2);
-                    return groupedParams
-                        .map((pair, pairIndex) => {
-                        const [x, y] = pair;
-                        const xReal = parseFloatValue(x, inherited.width) || 0;
-                        const yReal = parseFloatValue(y, innerHeight) || 0;
-                        if (letter === letter.toLowerCase()) {
-                            currentX += xReal;
-                            currentY += yReal;
-                        }
-                        else {
-                            currentX = xReal;
-                            currentY = yReal;
-                        }
-                        const point = newConverter.point(currentX, currentY);
-                        return ((pairIndex > 0 || letter.toUpperCase() === 'L' ? 'L' : 'M') +
-                            [point.x - xOrigin, point.y - yOrigin].join(','));
-                    })
-                        .join(' ');
-                }
-                case 'v': {
-                    return params
-                        .map((value) => {
-                        const coord = parseFloatValue(value) || 0;
-                        if (letter === letter.toLowerCase()) {
-                            currentY += coord;
-                        }
-                        else {
-                            currentY = coord;
-                        }
-                        const point = newConverter.point(currentX, currentY);
-                        // we can't use 'v' as the final command because rotations might require a different command after the path parsing
-                        // for instance, a 90 degree rotation would turn a 'v' into an 'h' command
-                        return `L${point.x - xOrigin} ${point.y - yOrigin}`;
-                    })
-                        .join(' ');
-                }
-                case 'h': {
-                    return params
-                        .map((value) => {
-                        const coord = parseFloatValue(value) || 0;
-                        if (letter === letter.toLowerCase()) {
-                            currentX += coord;
-                        }
-                        else {
-                            currentX = coord;
-                        }
-                        const point = newConverter.point(currentX, currentY);
-                        // we can't use 'h' as the final command because rotations might require a different command after the path parsing
-                        // for instance, a 90 degree rotation would turn a 'h' into an 'v' command
-                        return `L${point.x - xOrigin} ${point.y - yOrigin}`;
-                    })
-                        .join(' ');
-                }
-                case 'a': {
-                    const groupedParams = groupBy(params, 7);
-                    return groupedParams
-                        .map((p) => {
-                        const [rxPixel, ryPixel, xAxisRotation = '0', largeArc = '0', sweepFlag = '0', xPixel, yPixel,] = p;
-                        const realRx = parseFloatValue(rxPixel, inherited.width) || 0;
-                        const realRy = parseFloatValue(ryPixel, inherited.height) || 0;
-                        const realX = parseFloatValue(xPixel, inherited.width) || 0;
-                        const realY = parseFloatValue(yPixel, inherited.height) || 0;
-                        const { width: newRx, height: newRy } = newConverter.size(realRx, realRy);
-                        let point;
-                        if (letter === letter.toLowerCase()) {
-                            currentX += realX;
-                            currentY += realY;
-                        }
-                        else {
-                            currentX = realX;
-                            currentY = realY;
-                        }
-                        point = newConverter.point(currentX, currentY);
-                        // transformations over x and y axis might change the page coord direction
-                        const { width: xDirection, height: yDirection } = newConverter.size(1, 1);
-                        // -1 is the default direction
-                        const pageYDirection = -1 * Math.sign(xDirection * yDirection);
-                        const oppositeSweepFlag = sweepFlag === '0' ? '1' : '0';
-                        return [
-                            letter.toUpperCase(),
-                            newRx,
-                            newRy,
-                            xAxisRotation,
-                            largeArc,
-                            pageYDirection === -1 ? oppositeSweepFlag : sweepFlag,
-                            point.x - xOrigin,
-                            point.y - yOrigin,
-                        ].join(' ');
-                    })
-                        .join(' ');
-                }
-                case 'c': {
-                    const groupedParams = groupBy(params, 6);
-                    const result = groupedParams
-                        .map(([c1X, c1Y, c2X, c2Y, xString, yString]) => [
-                        parseFloatValue(c1X, inherited.width) || 0,
-                        parseFloatValue(c1Y, inherited.height) || 0,
-                        parseFloatValue(c2X, inherited.width) || 0,
-                        parseFloatValue(c2Y, inherited.height) || 0,
-                        parseFloatValue(xString, inherited.width) || 0,
-                        parseFloatValue(yString, inherited.height) || 0,
-                    ])
-                        .map(([c1X, c1Y, c2X, c2Y, xReal, yReal]) => {
-                        let controlPoint1X;
-                        let controlPoint1Y;
-                        let controlPoint2X;
-                        let controlPoint2Y;
-                        if (letter === letter.toLowerCase()) {
-                            controlPoint1X = currentX + c1X;
-                            controlPoint1Y = currentY + c1Y;
-                            controlPoint2X = currentX + c2X;
-                            controlPoint2Y = currentY + c2Y;
-                            currentX += xReal;
-                            currentY += yReal;
-                        }
-                        else {
-                            controlPoint1X = c1X;
-                            controlPoint1Y = c1Y;
-                            controlPoint2X = c2X;
-                            controlPoint2Y = c2Y;
-                            currentX = xReal;
-                            currentY = yReal;
-                        }
-                        const controlPoint1 = newConverter.point(controlPoint1X, controlPoint1Y);
-                        const controlPoint2 = newConverter.point(controlPoint2X, controlPoint2Y);
-                        const point = newConverter.point(currentX, currentY);
-                        return [
-                            controlPoint1.x - xOrigin,
-                            controlPoint1.y - yOrigin,
-                            controlPoint2.x - xOrigin,
-                            controlPoint2.y - yOrigin,
-                            point.x - xOrigin,
-                            point.y - yOrigin,
-                        ].join(',');
-                    })
-                        .join(' ');
-                    return (letter === null || letter === void 0 ? void 0 : letter.toUpperCase()) + '' + result;
-                }
-                case 's': {
-                    const groupedParams = groupBy(params, 4);
-                    const result = groupedParams
-                        // the control point 1 is omitted because it's the reflection of c2
-                        .map(([c2X, c2Y, xString, yString]) => [
-                        parseFloatValue(c2X, inherited.width) || 0,
-                        parseFloatValue(c2Y, inherited.height) || 0,
-                        parseFloatValue(xString, inherited.width) || 0,
-                        parseFloatValue(yString, inherited.height) || 0,
-                    ])
-                        .map(([c2X, c2Y, xReal, yReal]) => {
-                        let controlPoint2X;
-                        let controlPoint2Y;
-                        if (letter === letter.toLowerCase()) {
-                            controlPoint2X = currentX + c2X;
-                            controlPoint2Y = currentY + c2Y;
-                            currentX += xReal;
-                            currentY += yReal;
-                        }
-                        else {
-                            controlPoint2X = c2X;
-                            controlPoint2Y = c2Y;
-                            currentX = xReal;
-                            currentY = yReal;
-                        }
-                        const controlPoint2 = newConverter.point(controlPoint2X, controlPoint2Y);
-                        const point = newConverter.point(currentX, currentY);
-                        return [
-                            controlPoint2.x - xOrigin,
-                            controlPoint2.y - yOrigin,
-                            point.x - xOrigin,
-                            point.y - yOrigin,
-                        ].join(',');
-                    })
-                        .join(' ');
-                    return (letter === null || letter === void 0 ? void 0 : letter.toUpperCase()) + '' + result;
-                }
-                default: {
-                    const groupedParams = groupBy(params, 2);
-                    const result = groupedParams
-                        .map(([xString, yString]) => [
-                        parseFloatValue(xString, inherited.width) || 0,
-                        parseFloatValue(yString, inherited.height) || 0,
-                    ])
-                        .map(([xReal, yReal]) => {
-                        if (letter === letter.toLowerCase()) {
-                            currentX += xReal;
-                            currentY += yReal;
-                        }
-                        else {
-                            currentX = xReal;
-                            currentY = yReal;
-                        }
-                        const point = newConverter.point(currentX, currentY);
-                        return [point.x - xOrigin, point.y - yOrigin].join(',');
-                    })
-                        .join(' ');
-                    return (letter === null || letter === void 0 ? void 0 : letter.toUpperCase()) + '' + result;
-                }
-            }
-        });
-    }
-    if (attributes.viewBox) {
-        const viewBox = parseViewBox(attributes.viewBox);
-        const size = {
-            width: width || inherited.viewBox.width,
-            height: height || inherited.viewBox.height,
-        };
-        const localConverter = getConverterWithAspectRatio(size, viewBox, attributes.preserveAspectRatio);
-        const oldConverter = newConverter;
-        newConverter = {
-            point: (px, py) => {
-                const { x: localX, y: localY } = localConverter.point(px, py);
-                return oldConverter.point(localX, localY);
-            },
-            size: (w, h) => {
-                const { width: localWidth, height: localHeight } = localConverter.size(w, h);
-                return oldConverter.size(localWidth, localHeight);
-            },
-        };
+        newMatrix = combineTransformation(newMatrix, 'scale', [1, -1]);
+        svgAttributes.d = attributes.d;
     }
-    // apply the converter only when there's a local fontSize instruction
     if (fontSizeRaw && newInherited.fontSize) {
-        newInherited.fontSize = newConverter.size(1, newInherited.fontSize).height;
+        newInherited.fontSize = newInherited.fontSize;
     }
     if (newInherited.fontFamily) {
         // Handle complex fontFamily like `"Linux Libertine O", serif`
@@ -43498,43 +41977,13 @@ const parseAttributes = (element, inherited, converter) => {
             newInherited.fontFamily = inner[1] || inner[2];
     }
     if (newInherited.strokeWidth) {
-        const result = newConverter.size(newInherited.strokeWidth, newInherited.strokeWidth);
-        svgAttributes.strokeWidth = Math.max(Math.min(Math.abs(result.width), Math.abs(result.height)), 1);
+        svgAttributes.strokeWidth = newInherited.strokeWidth;
     }
     return {
         inherited: newInherited,
         svgAttributes,
-        converter: newConverter,
         tagName: element.tagName,
-    };
-};
-const getConverter = (box, viewBox) => {
-    const { width, height } = box;
-    const { x: xMin, y: yMin, width: viewWidth, height: viewHeight } = viewBox;
-    const converter = {
-        point: (xReal, yReal) => ({
-            x: ((xReal - xMin) / viewWidth) * (width || 0),
-            y: ((yReal - yMin) / viewHeight) * (height || 0),
-        }),
-        size: (wReal, hReal) => ({
-            width: (wReal / viewWidth) * (width || 0),
-            height: (hReal / viewHeight) * (height || 0),
-        }),
-    };
-    return converter;
-};
-const getConverterWithAspectRatio = (size, viewBox, preserveAspectRatio) => {
-    // explanation about how the svg attributes applies transformations to the child elements
-    // https://www.w3.org/TR/SVG/coords.html#ComputingAViewportsTransform
-    const { x, y, width, height } = getFittingRectangle(viewBox.width, viewBox.height, size.width, size.height, preserveAspectRatio);
-    const ratioConverter = getConverter({ width, height }, viewBox);
-    // We translate the drawing in the page when the aspect ratio is different, according to the preserveAspectRatio instructions.
-    return {
-        point: (xReal, yReal) => {
-            const P = ratioConverter.point(xReal, yReal);
-            return { x: P.x + x, y: P.y + y };
-        },
-        size: ratioConverter.size,
+        matrix: newMatrix,
     };
 };
 const getFittingRectangle = (originalWidth, originalHeight, targetWidth, targetHeight, preserveAspectRatio) => {
@@ -43572,16 +42021,62 @@ const getFittingRectangle = (originalWidth, originalHeight, targetWidth, targetH
     })();
     return { x, y, width, height };
 };
-const parseHTMLNode = (node, inherited, converter) => {
+const getAspectRatioTransformation = (matrix, originalWidth, originalHeight, targetWidth, targetHeight, preserveAspectRatio) => {
+    const scaleX = targetWidth / originalWidth;
+    const scaleY = targetHeight / originalHeight;
+    const boxScale = combineTransformation(matrix, 'scale', [
+        scaleX,
+        scaleY
+    ]);
+    if (preserveAspectRatio === 'none') {
+        return {
+            clipBox: boxScale,
+            content: boxScale
+        };
+    }
+    // TODO: the following code works for the 'meet' param but not for the 'slice'
+    const scale = targetWidth > targetHeight ? scaleY : scaleX;
+    const dx = targetWidth - (originalWidth * scale);
+    const dy = targetHeight - (originalHeight * scale);
+    const [x, y] = (() => {
+        switch (preserveAspectRatio) {
+            case 'xMinYMin':
+                return [0, 0];
+            case 'xMidYMin':
+                return [dx / 2, 0];
+            case 'xMaxYMin':
+                return [dx, dy / 2];
+            case 'xMinYMid':
+                return [0, dy];
+            case 'xMaxYMid':
+                return [dx, dy / 2];
+            case 'xMinYMax':
+                return [0, dy];
+            case 'xMidYMax':
+                return [dx / 2, dy];
+            case 'xMaxYMax':
+                return [dx, dy];
+            case 'xMidYMid':
+            default:
+                return [dx / 2, dy / 2];
+        }
+    })();
+    const contentTransform = combineTransformation(combineTransformation(matrix, 'translate', [x, y]), 'scale', [scale]);
+    return {
+        clipBox: boxScale,
+        content: contentTransform
+    };
+};
+const parseHTMLNode = (node, inherited, matrix, clipSpaces) => {
     if (node.nodeType === index.NodeType.COMMENT_NODE)
         return [];
     else if (node.nodeType === index.NodeType.TEXT_NODE)
         return [];
     else if (node.tagName === 'g') {
-        return parseGroupNode(node, inherited, converter);
+        return parseGroupNode(node, inherited, matrix, clipSpaces);
     }
     else if (node.tagName === 'svg') {
-        return parseSvgNode(node, inherited, converter);
+        return parseSvgNode(node, inherited, matrix, clipSpaces);
     }
     else {
         if (node.tagName === 'polygon') {
@@ -43589,36 +42084,69 @@ const parseHTMLNode = (node, inherited, converter) => {
             node.attributes.d = `M${node.attributes.points}Z`;
             delete node.attributes.points;
         }
-        const attributes = parseAttributes(node, inherited, converter);
-        const svgAttributes = Object.assign(Object.assign({}, attributes.inherited), attributes.svgAttributes);
+        const attributes = parseAttributes(node, inherited, matrix);
+        const svgAttributes = {
+            ...attributes.inherited,
+            ...attributes.svgAttributes,
+            matrix: attributes.matrix,
+            clipSpaces
+        };
         Object.assign(node, { svgAttributes });
         return [node];
     }
 };
-const parseSvgNode = (node, inherited, converter) => {
+const parseSvgNode = (node, inherited, matrix, clipSpaces) => {
     var _a, _b;
     // if the width/height aren't set, the svg will have the same dimension as the current drawing space
     (_a = node.attributes.width) !== null && _a !== void 0 ? _a : node.setAttribute('width', inherited.viewBox.width + '');
     (_b = node.attributes.height) !== null && _b !== void 0 ? _b : node.setAttribute('height', inherited.viewBox.height + '');
-    const attributes = parseAttributes(node, inherited, converter);
+    const attributes = parseAttributes(node, inherited, matrix);
     const result = [];
     const viewBox = node.attributes.viewBox
         ? parseViewBox(node.attributes.viewBox)
         : node.attributes.width && node.attributes.height
             ? parseViewBox(`0 0 ${node.attributes.width} ${node.attributes.height}`)
             : inherited.viewBox;
-    const svgRect = new Rectangle(new Point(attributes.converter.point(viewBox.x, viewBox.y)), new Point(attributes.converter.point(viewBox.x + viewBox.width, viewBox.y + viewBox.height)));
+    const x = parseFloat(node.attributes.x) || 0;
+    const y = parseFloat(node.attributes.y) || 0;
+    let newMatrix = combineTransformation(matrix, 'translate', [x, y]);
+    const { clipBox: clipBoxTransform, content: contentTransform } = getAspectRatioTransformation(newMatrix, viewBox.width, viewBox.height, parseFloat(node.attributes.width), parseFloat(node.attributes.height), node.attributes.preserveAspectRatio || 'xMidYMid');
+    const topLeft = applyTransformation(clipBoxTransform, {
+        x: 0,
+        y: 0,
+    });
+    const topRight = applyTransformation(clipBoxTransform, {
+        x: viewBox.width,
+        y: 0,
+    });
+    const bottomRight = applyTransformation(clipBoxTransform, {
+        x: viewBox.width,
+        y: -viewBox.height,
+    });
+    const bottomLeft = applyTransformation(clipBoxTransform, {
+        x: 0,
+        y: -viewBox.height,
+    });
+    const baseClipSpace = {
+        topLeft,
+        topRight,
+        bottomRight,
+        bottomLeft
+    };
+    // TODO: maybe this is the correct transformation
+    // newMatrix = combineTransformation(newMatrix, 'translate', [-baseClipSpace.xMin, -baseClipSpace.yMin])
+    newMatrix = combineTransformation(contentTransform, 'translate', [-viewBox.x, -viewBox.y]);
     node.childNodes.forEach((child) => {
-        const parsedNodes = parseHTMLNode(child, Object.assign(Object.assign({}, attributes.inherited), { viewBox }), attributes.converter).map((el) => cropSvgElement(svgRect, el));
+        const parsedNodes = parseHTMLNode(child, { ...attributes.inherited, viewBox }, newMatrix, [...clipSpaces, baseClipSpace]);
         result.push(...parsedNodes);
     });
     return result;
 };
-const parseGroupNode = (node, inherited, converter) => {
-    const attributes = parseAttributes(node, inherited, converter);
+const parseGroupNode = (node, inherited, matrix, clipSpaces) => {
+    const attributes = parseAttributes(node, inherited, matrix);
     const result = [];
     node.childNodes.forEach((child) => {
-        result.push(...parseHTMLNode(child, attributes.inherited, attributes.converter));
+        result.push(...parseHTMLNode(child, attributes.inherited, attributes.matrix, clipSpaces));
     });
     return result;
 };
@@ -43645,22 +42173,21 @@ const parseViewBox = (viewBox) => {
         height: heightViewBox,
     };
 };
-const parse$1 = (svg, { width, height, x, y, fontSize }, size, converter) => {
+const parse$1 = (svg, { width, height, fontSize }, size, matrix) => {
     const htmlElement = index.parse(svg).firstChild;
     if (width)
         htmlElement.setAttribute('width', width + '');
     if (height)
         htmlElement.setAttribute('height', height + '');
-    if (x !== undefined)
-        htmlElement.setAttribute('x', x + '');
-    if (y !== undefined)
-        htmlElement.setAttribute('y', size.height - y + '');
     if (fontSize)
         htmlElement.setAttribute('font-size', fontSize + '');
     // TODO: what should be the default viewBox?
-    return parseHTMLNode(htmlElement, Object.assign(Object.assign({}, size), { viewBox: parseViewBox(htmlElement.attributes.viewBox || '0 0 1 1') }), converter);
+    return parseHTMLNode(htmlElement, {
+        ...size,
+        viewBox: parseViewBox(htmlElement.attributes.viewBox || '0 0 1 1'),
+    }, matrix, []);
 };
-const drawSvg = (page, svg, options) => __awaiter(void 0, void 0, void 0, function* () {
+const drawSvg = async (page, svg, options) => {
     if (!svg)
         return;
     const size = page.getSize();
@@ -43685,19 +42212,42 @@ const drawSvg = (page, svg, options) => __awaiter(void 0, void 0, void 0, functi
             .map(([key, val]) => `${key}:${val};`)
             .join(''));
     }
-    // The y axis of the page is reverted
-    const defaultConverter = {
-        point: (xP, yP) => ({ x: xP, y: size.height - yP }),
-        size: (w, h) => ({ width: w, height: h }),
-    };
+    const baseTransformation = [1, 0, 0, 1, options.x || 0, options.y || 0];
     const runners = runnersToPage(page, options);
-    const elements = parse$1(firstChild.outerHTML, options, size, defaultConverter);
-    yield elements.reduce((prev, elt) => __awaiter(void 0, void 0, void 0, function* () {
+    const elements = parse$1(firstChild.outerHTML, options, size, baseTransformation);
+    await elements.reduce(async (prev, elt) => {
         var _a;
-        yield prev;
+        await prev;
+        // uncomment these lines to draw the clipSpaces
+        // elt.svgAttributes.clipSpaces.forEach(space => {
+        //   page.drawLine({
+        //     start: space.topLeft,
+        //     end: space.topRight,
+        //     color: parseColor('#000000')?.rgb,
+        //     thickness: 1
+        //   })
+        //   page.drawLine({
+        //     start: space.topRight,
+        //     end: space.bottomRight,
+        //     color: parseColor('#000000')?.rgb,
+        //     thickness: 1
+        //   })
+        //   page.drawLine({
+        //     start: space.bottomRight,
+        //     end: space.bottomLeft,
+        //     color: parseColor('#000000')?.rgb,
+        //     thickness: 1
+        //   })
+        //   page.drawLine({
+        //     start: space.bottomLeft,
+        //     end: space.topLeft,
+        //     color: parseColor('#000000')?.rgb,
+        //     thickness: 1
+        //   })
+        // })
         return (_a = runners[elt.tagName]) === null || _a === void 0 ? void 0 : _a.call(runners, elt);
-    }), Promise.resolve());
-});
+    }, Promise.resolve());
+};
 
 /**
  * Represents a single page of a [[PDFDocument]].
@@ -44554,6 +43104,8 @@ class PDFPage {
             y: (_f = options.y) !== null && _f !== void 0 ? _f : this.y,
             lineHeight: (_g = options.lineHeight) !== null && _g !== void 0 ? _g : this.lineHeight,
             graphicsState: graphicsStateKey,
+            matrix: options.matrix,
+            clipSpaces: options.clipSpaces
         }));
         if (options.font) {
             if (oldFont)
@@ -44615,6 +43167,8 @@ class PDFPage {
             xSkew: (_f = options.xSkew) !== null && _f !== void 0 ? _f : degrees(0),
             ySkew: (_g = options.ySkew) !== null && _g !== void 0 ? _g : degrees(0),
             graphicsState: graphicsStateKey,
+            matrix: options.matrix,
+            clipSpaces: options.clipSpaces
         }));
     }
     /**
@@ -44773,6 +43327,8 @@ class PDFPage {
             borderLineCap: (_j = options.borderLineCap) !== null && _j !== void 0 ? _j : undefined,
             graphicsState: graphicsStateKey,
             fillRule: options.fillRule,
+            matrix: options.matrix,
+            clipSpaces: options.clipSpaces
         }));
     }
     /**
@@ -44826,6 +43382,8 @@ class PDFPage {
             dashPhase: (_d = options.dashPhase) !== null && _d !== void 0 ? _d : undefined,
             lineCap: (_e = options.lineCap) !== null && _e !== void 0 ? _e : undefined,
             graphicsState: graphicsStateKey,
+            matrix: options.matrix,
+            clipSpaces: options.clipSpaces,
         }));
     }
     /**
@@ -44844,12 +43402,13 @@ class PDFPage {
      *   color: rgb(0.75, 0.2, 0.2),
      *   opacity: 0.5,
      *   borderOpacity: 0.75,
+     *   radius: 0.1,
      * })
      * ```
      * @param options The options to be used when drawing the rectangle.
      */
     drawRectangle(options = {}) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
         assertOrUndefined(options.x, 'options.x', ['number']);
         assertOrUndefined(options.y, 'options.y', ['number']);
         assertOrUndefined(options.width, 'options.width', ['number']);
@@ -44872,6 +43431,7 @@ class PDFPage {
         assertIsOneOfOrUndefined(options.borderLineCap, 'options.borderLineCap', LineCapStyle);
         assertRangeOrUndefined(options.borderOpacity, 'options.borderOpacity', 0, 1);
         assertIsOneOfOrUndefined(options.blendMode, 'options.blendMode', BlendMode);
+        assertOrUndefined(options.radius, 'options.radius', ['number']);
         const graphicsStateKey = this.maybeEmbedGraphicsState({
             opacity: options.opacity,
             borderOpacity: options.borderOpacity,
@@ -44896,6 +43456,9 @@ class PDFPage {
             borderDashPhase: (_m = options.borderDashPhase) !== null && _m !== void 0 ? _m : undefined,
             graphicsState: graphicsStateKey,
             borderLineCap: (_o = options.borderLineCap) !== null && _o !== void 0 ? _o : undefined,
+            matrix: options.matrix,
+            clipSpaces: options.clipSpaces,
+            radius: (_p = options.radius) !== null && _p !== void 0 ? _p : 0,
         }));
     }
     /**
@@ -44920,7 +43483,7 @@ class PDFPage {
     drawSquare(options = {}) {
         const { size } = options;
         assertOrUndefined(size, 'size', ['number']);
-        this.drawRectangle(Object.assign(Object.assign({}, options), { width: size, height: size }));
+        this.drawRectangle({ ...options, width: size, height: size });
     }
     /**
      * Draw an ellipse on this page. For example:
@@ -44985,6 +43548,8 @@ class PDFPage {
             borderDashPhase: (_k = options.borderDashPhase) !== null && _k !== void 0 ? _k : undefined,
             borderLineCap: (_l = options.borderLineCap) !== null && _l !== void 0 ? _l : undefined,
             graphicsState: graphicsStateKey,
+            matrix: options.matrix,
+            clipSpaces: options.clipSpaces,
         }));
     }
     /**
@@ -45008,7 +43573,7 @@ class PDFPage {
     drawCircle(options = {}) {
         const { size = 100 } = options;
         assertOrUndefined(size, 'size', ['number']);
-        this.drawEllipse(Object.assign(Object.assign({}, options), { xScale: size, yScale: size }));
+        this.drawEllipse({ ...options, xScale: size, yScale: size });
     }
     setOrEmbedFont(font) {
         const oldFont = this.font;
@@ -45032,21 +43597,19 @@ class PDFPage {
      * @param svg The SVG to be drawn.
      * @param options The options to be used when drawing the SVG.
      */
-    drawSvg(svg, options = {}) {
+    async drawSvg(svg, options = {}) {
         var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            assertIs(svg, 'svg', ['string']);
-            assertOrUndefined(options.x, 'options.x', ['number']);
-            assertOrUndefined(options.y, 'options.y', ['number']);
-            assertOrUndefined(options.width, 'options.width', ['number']);
-            assertOrUndefined(options.height, 'options.height', ['number']);
-            yield drawSvg(this, svg, {
-                x: (_a = options.x) !== null && _a !== void 0 ? _a : this.x,
-                y: (_b = options.y) !== null && _b !== void 0 ? _b : this.y,
-                fonts: options.fonts,
-                width: options.width,
-                height: options.height,
-            });
+        assertIs(svg, 'svg', ['string']);
+        assertOrUndefined(options.x, 'options.x', ['number']);
+        assertOrUndefined(options.y, 'options.y', ['number']);
+        assertOrUndefined(options.width, 'options.width', ['number']);
+        assertOrUndefined(options.height, 'options.height', ['number']);
+        await drawSvg(this, svg, {
+            x: (_a = options.x) !== null && _a !== void 0 ? _a : this.x,
+            y: (_b = options.y) !== null && _b !== void 0 ? _b : this.y,
+            fonts: options.fonts,
+            width: options.width,
+            height: options.height,
         });
     }
     getFont() {