@hadi77ir/pdfme-svg 0.1.0

package/dist/jspdf-shim.js

@@ -0,0 +1,744 @@
+import { rgb, PDFOperator, pushGraphicsState, popGraphicsState, concatTransformationMatrix, setLineWidth, setStrokingRgbColor, setFillingRgbColor, moveTo, lineTo, appendBezierCurve, closePath, stroke, fill, fillEvenOdd, fillAndStroke, endPath, clip, clipEvenOdd, LineCapStyle, LineJoinStyle, setLineCap, setLineJoin, setDashPattern, setGraphicsState, drawObject, PDFName, PDFContentStream, StandardFonts, PDFNumber, PDFRawStream } from '@pdfme/pdf-lib';
+export class Matrix {
+    constructor(a, b, c, d, e, f) {
+        this.a = a;
+        this.b = b;
+        this.c = c;
+        this.d = d;
+        this.e = e;
+        this.f = f;
+    }
+    get sx() { return this.a; }
+    set sx(v) { this.a = v; }
+    get sy() { return this.d; }
+    set sy(v) { this.d = v; }
+    get tx() { return this.e; }
+    set tx(v) { this.e = v; }
+    get ty() { return this.f; }
+    set ty(v) { this.f = v; }
+    inversed() {
+        const { a, b, c, d, e, f } = this;
+        const det = a * d - b * c;
+        if (!det) {
+            return new Matrix(1, 0, 0, 1, 0, 0);
+        }
+        const invDet = 1 / det;
+        return new Matrix(d * invDet, -b * invDet, -c * invDet, a * invDet, (c * f - d * e) * invDet, (b * e - a * f) * invDet);
+    }
+    applyToPoint(point) {
+        return {
+            x: point.x * this.a + point.y * this.c + this.e,
+            y: point.x * this.b + point.y * this.d + this.f
+        };
+    }
+}
+export const unitMatrix = new Matrix(1, 0, 0, 1, 0, 0);
+export function matrixMult(m1, m2) {
+    return new Matrix(m1.a * m2.a + m1.b * m2.c, m1.a * m2.b + m1.b * m2.d, m1.c * m2.a + m1.d * m2.c, m1.c * m2.b + m1.d * m2.d, m1.e * m2.a + m1.f * m2.c + m2.e, m1.e * m2.b + m1.f * m2.d + m2.f);
+}
+export class GState {
+    constructor(options = {}) {
+        Object.assign(this, options);
+    }
+}
+export class TilingPattern {
+    constructor(boundingBox, xStep, yStep, gState, matrix) {
+        this.boundingBox = boundingBox;
+        this.xStep = xStep;
+        this.yStep = yStep;
+        this.gState = gState;
+        this.matrix = matrix;
+    }
+}
+export class ShadingPattern {
+    constructor(type, coords, colors, gState, matrix) {
+        this.type = type;
+        this.coords = coords;
+        this.colors = colors;
+        this.gState = gState;
+        this.matrix = matrix;
+    }
+}
+export class jsPDF {
+    convertMatrixWithHeight(m, height) {
+        const { a, b, c, d, e, f } = m;
+        return new Matrix(a, -b, -c, d, c * height + e, height * (1 - d) - f);
+    }
+    convertMatrix(m) {
+        return this.convertMatrixWithHeight(m, this.internal.pageSize.getHeight());
+    }
+    convertMatrixForPattern(m) {
+        const h = this.internal.pageSize.getHeight();
+        return new Matrix(m.a, -m.b, m.c, -m.d, m.e, h - m.f);
+    }
+    normalizeReferenceKey(value) {
+        const trimmed = value.trim();
+        const urlMatch = /^url\(\s*['"]?(.*?)['"]?\s*\)$/i.exec(trimmed);
+        const raw = urlMatch ? urlMatch[1] : trimmed;
+        return raw.startsWith('#') ? raw.slice(1) : raw;
+    }
+    constructor(page, doc) {
+        this.unitMatrix = unitMatrix;
+        this.Matrix = (a, b, c, d, e, f) => new Matrix(a, b, c, d, e, f);
+        this.matrixMult = matrixMult;
+        this.currentMatrix = unitMatrix;
+        this.graphicsStateStack = [];
+        this.formObjects = {};
+        this.activeFormObject = null;
+        this.savedPage = null;
+        this.shadingPatterns = {};
+        this.tilingPatterns = {};
+        this.formObjectCounter = 0;
+        this.patternCounter = 0;
+        this.fontSize = 12;
+        this.currentFont = null;
+        this.currentTextColor = rgb(0, 0, 0);
+        this.page = page;
+        this.doc = doc;
+        this.internal = {
+            pageSize: {
+                getWidth: () => this.page.getWidth(),
+                getHeight: () => this.page.getHeight(),
+            },
+            scaleFactor: 1,
+        };
+    }
+    advancedAPI() { }
+    compatAPI() { }
+    getStringUnitWidth(text) {
+        if (!this.currentFont)
+            return 0;
+        return this.currentFont.widthOfTextAtSize(text, 1);
+    }
+    saveGraphicsState() {
+        this.page.pushOperators(pushGraphicsState());
+        this.graphicsStateStack.push({
+            matrix: this.currentMatrix,
+            font: this.currentFont,
+            fontSize: this.fontSize,
+            textColor: this.currentTextColor
+        });
+    }
+    restoreGraphicsState() {
+        this.page.pushOperators(popGraphicsState());
+        const state = this.graphicsStateStack.pop();
+        if (!state)
+            return;
+        this.currentMatrix = state.matrix;
+        this.currentFont = state.font;
+        this.fontSize = state.fontSize;
+        this.currentTextColor = state.textColor;
+        if (state.font && typeof this.page.setFont === 'function') {
+            this.page.setFont(state.font);
+        }
+        if (typeof this.page.setFontSize === 'function') {
+            this.page.setFontSize(state.fontSize);
+        }
+        if (state.textColor && typeof this.page.setFontColor === 'function') {
+            this.page.setFontColor(state.textColor);
+        }
+    }
+    setCurrentTransformationMatrix(matrix) {
+        const inv = this.currentMatrix.inversed();
+        const rel = matrixMult(matrix, inv);
+        const converted = this.convertMatrix(rel);
+        this.page.pushOperators(concatTransformationMatrix(converted.a, converted.b, converted.c, converted.d, converted.e, converted.f));
+        this.currentMatrix = matrix;
+    }
+    setLineWidth(width) {
+        this.page.pushOperators(setLineWidth(width));
+    }
+    setDrawColor(r, g, b) {
+        this.page.pushOperators(setStrokingRgbColor(r / 255, g / 255, b / 255));
+    }
+    setFillColor(r, g, b) {
+        this.page.pushOperators(setFillingRgbColor(r / 255, g / 255, b / 255));
+    }
+    setTextColor(r, g, b) {
+        const color = rgb(r / 255, g / 255, b / 255);
+        this.currentTextColor = color;
+        if (typeof this.page.setFontColor === 'function') {
+            this.page.setFontColor(color);
+        }
+        this.page.pushOperators(setFillingRgbColor(r / 255, g / 255, b / 255));
+    }
+    setLineCap(cap) {
+        let style = LineCapStyle.Butt;
+        if (cap === 'round' || cap === 1)
+            style = LineCapStyle.Round;
+        if (cap === 'projecting' || cap === 2)
+            style = LineCapStyle.Projecting;
+        this.page.pushOperators(setLineCap(style));
+    }
+    setLineJoin(join) {
+        let style = LineJoinStyle.Miter;
+        if (join === 'round' || join === 1)
+            style = LineJoinStyle.Round;
+        if (join === 'bevel' || join === 2)
+            style = LineJoinStyle.Bevel;
+        this.page.pushOperators(setLineJoin(style));
+    }
+    setLineDashPattern(dash, offset) {
+        this.page.pushOperators(setDashPattern(dash, offset));
+    }
+    setLineMiterLimit(limit) {
+        // @ts-ignore
+        this.page.pushOperators(PDFOperator.of('M', [this.doc.context.obj(limit)]));
+    }
+    setGState(gstate) {
+        const options = {};
+        if (gstate.opacity !== undefined) {
+            options.ca = gstate.opacity;
+        }
+        if (gstate['stroke-opacity'] !== undefined) {
+            options.CA = gstate['stroke-opacity'];
+        }
+        if (Object.keys(options).length > 0) {
+            const gs = this.doc.context.obj({
+                Type: 'ExtGState',
+                ...options
+            });
+            const key = this.page.node.newExtGState('GS', gs);
+            this.page.pushOperators(setGraphicsState(key));
+        }
+    }
+    setFontSize(size) {
+        this.fontSize = size;
+        this.page.setFontSize(size);
+    }
+    getFontSize() {
+        return this.fontSize;
+    }
+    setFont(fontName, fontStyle) {
+        let standardFont = StandardFonts.Helvetica;
+        const lowerName = fontName.toLowerCase();
+        if (lowerName.includes('times'))
+            standardFont = StandardFonts.TimesRoman;
+        if (lowerName.includes('courier'))
+            standardFont = StandardFonts.Courier;
+        if (fontStyle) {
+            const isBold = fontStyle.includes('bold');
+            const isItalic = fontStyle.includes('italic') || fontStyle.includes('oblique');
+            if (standardFont === StandardFonts.Helvetica) {
+                if (isBold && isItalic)
+                    standardFont = StandardFonts.HelveticaBoldOblique;
+                else if (isBold)
+                    standardFont = StandardFonts.HelveticaBold;
+                else if (isItalic)
+                    standardFont = StandardFonts.HelveticaOblique;
+            }
+            else if (standardFont === StandardFonts.TimesRoman) {
+                if (isBold && isItalic)
+                    standardFont = StandardFonts.TimesRomanBoldItalic;
+                else if (isBold)
+                    standardFont = StandardFonts.TimesRomanBold;
+                else if (isItalic)
+                    standardFont = StandardFonts.TimesRomanItalic;
+            }
+            else if (standardFont === StandardFonts.Courier) {
+                if (isBold && isItalic)
+                    standardFont = StandardFonts.CourierBoldOblique;
+                else if (isBold)
+                    standardFont = StandardFonts.CourierBold;
+                else if (isItalic)
+                    standardFont = StandardFonts.CourierOblique;
+            }
+        }
+        try {
+            const font = this.doc.embedStandardFont(standardFont);
+            this.page.setFont(font);
+            this.currentFont = font;
+        }
+        catch (e) {
+            // ignore
+        }
+    }
+    getFontList() {
+        return {
+            'helvetica': ['normal', 'bold', 'italic', 'bolditalic'],
+            'times': ['normal', 'bold', 'italic', 'bolditalic'],
+            'courier': ['normal', 'bold', 'italic', 'bolditalic']
+        };
+    }
+    moveTo(x, y) {
+        this.page.pushOperators(moveTo(x, this.internal.pageSize.getHeight() - y));
+    }
+    lineTo(x, y) {
+        this.page.pushOperators(lineTo(x, this.internal.pageSize.getHeight() - y));
+    }
+    curveTo(x1, y1, x2, y2, x, y) {
+        const h = this.internal.pageSize.getHeight();
+        this.page.pushOperators(appendBezierCurve(x1, h - y1, x2, h - y2, x, h - y));
+    }
+    close() {
+        this.page.pushOperators(closePath());
+    }
+    registerPattern(id, patternRef) {
+        const resources = this.page.node.Resources();
+        let patterns = resources.get(PDFName.of('Pattern'));
+        if (!patterns) {
+            patterns = this.doc.context.obj({});
+            resources.set(PDFName.of('Pattern'), patterns);
+        }
+        patterns.set(PDFName.of(id), patternRef);
+    }
+    beginFormObject(x, y, w, h, matrix) {
+        this.savedPage = this.page;
+        const stream = PDFContentStream.of(this.doc.context.obj({}), []);
+        this.activeFormObject = { key: '', stream, bBox: [x, y, w, h], matrix, savedMatrix: this.currentMatrix };
+        this.currentMatrix = unitMatrix;
+        const mockPage = {
+            pushOperators: (...ops) => stream.push(...ops),
+            getHeight: () => h,
+            getWidth: () => w,
+            setFontSize: (size) => {
+                this.fontSize = size;
+                if (this.savedPage && typeof this.savedPage.setFontSize === 'function') {
+                    ;
+                    this.savedPage.setFontSize(size);
+                }
+            },
+            setFont: (font) => {
+                if (this.savedPage && typeof this.savedPage.setFont === 'function') {
+                    ;
+                    this.savedPage.setFont(font);
+                }
+            },
+            drawText: (text, options) => {
+                if (!this.currentFont)
+                    return;
+                const size = options.size || this.fontSize;
+                const encoded = this.currentFont.encodeText(text);
+                stream.push(pushGraphicsState());
+                if (options.angle instanceof Matrix) {
+                    const m = options.angle;
+                    const converted = this.convertMatrix(m);
+                    stream.push(concatTransformationMatrix(converted.a, converted.b, converted.c, converted.d, converted.e, converted.f));
+                }
+                stream.push(PDFOperator.of('BT'));
+                stream.push(PDFOperator.of('Tf', [this.currentFont.name, PDFNumber.of(size)]));
+                const tx = options.x || 0;
+                const ty = h - (options.y || 0);
+                stream.push(PDFOperator.of('Td', [PDFNumber.of(tx), PDFNumber.of(ty)]));
+                stream.push(PDFOperator.of('Tj', [encoded]));
+                stream.push(PDFOperator.of('ET'));
+                stream.push(popGraphicsState());
+            },
+            node: {
+                newExtGState: (name, gs) => this.savedPage.node.newExtGState(name, gs),
+                newXObject: (name, ref) => this.savedPage.node.newXObject(name, ref),
+                Resources: () => this.savedPage.node.Resources()
+            }
+        };
+        this.page = mockPage;
+    }
+    endFormObject(key) {
+        if (!this.activeFormObject)
+            return;
+        const { stream, bBox, matrix, savedMatrix } = this.activeFormObject;
+        const normalizedKey = this.normalizeReferenceKey(key);
+        const formDict = stream.dict;
+        formDict.set(PDFName.of('Type'), PDFName.of('XObject'));
+        formDict.set(PDFName.of('Subtype'), PDFName.of('Form'));
+        formDict.set(PDFName.of('BBox'), this.doc.context.obj([bBox[0], -bBox[1], bBox[0] + bBox[2], bBox[3] - bBox[1]]));
+        const formHeight = bBox[3];
+        const pageHeight = this.savedPage ? this.savedPage.getHeight() : this.internal.pageSize.getHeight();
+        const convertedMatrix = this.convertMatrixWithHeight(matrix, formHeight);
+        const correction = new Matrix(1, 0, 0, 1, 0, pageHeight - formHeight);
+        const formMatrix = matrixMult(correction, convertedMatrix);
+        formDict.set(PDFName.of('Matrix'), this.doc.context.obj([
+            formMatrix.a,
+            formMatrix.b,
+            formMatrix.c,
+            formMatrix.d,
+            formMatrix.e,
+            formMatrix.f
+        ]));
+        formDict.set(PDFName.of('Resources'), this.savedPage.node.Resources());
+        const formRef = this.doc.context.register(stream);
+        this.formObjects[normalizedKey] = { ref: formRef, bBox };
+        this.page = this.savedPage;
+        this.currentMatrix = savedMatrix;
+        this.internal.pageSize.getWidth = () => this.page.getWidth();
+        this.internal.pageSize.getHeight = () => this.page.getHeight();
+        this.activeFormObject = null;
+        this.savedPage = null;
+    }
+    doFormObject(key, matrix) {
+        const normalizedKey = this.normalizeReferenceKey(key);
+        const form = this.formObjects[normalizedKey];
+        if (!form)
+            return;
+        const nameStr = `Xo${++this.formObjectCounter}`;
+        const name = this.page.node.newXObject(nameStr, form.ref);
+        this.page.pushOperators(pushGraphicsState());
+        const converted = this.convertMatrix(matrix);
+        this.page.pushOperators(concatTransformationMatrix(converted.a, converted.b, converted.c, converted.d, converted.e, converted.f));
+        this.page.pushOperators(drawObject(name));
+        this.page.pushOperators(popGraphicsState());
+    }
+    registerShading(name, shadingRef) {
+        const resources = this.page.node.Resources();
+        let shadings = resources.get(PDFName.of('Shading'));
+        if (!shadings) {
+            shadings = this.doc.context.obj({});
+            resources.set(PDFName.of('Shading'), shadings);
+        }
+        ;
+        shadings.set(PDFName.of(name), shadingRef);
+    }
+    buildSampledFunction(colors, numberSamples = 21) {
+        const count = Math.max(2, numberSamples);
+        const samples = this.interpolateSampledColors(colors, count);
+        const funcDict = this.doc.context.obj({
+            FunctionType: 0,
+            Domain: [0, 1],
+            Size: [count],
+            BitsPerSample: 8,
+            Range: [0, 1, 0, 1, 0, 1],
+            Decode: [0, 1, 0, 1, 0, 1]
+        });
+        const funcStream = PDFRawStream.of(funcDict, samples);
+        return this.doc.context.register(funcStream);
+    }
+    interpolateSampledColors(colors, numberSamples) {
+        const count = Math.max(2, numberSamples);
+        const stops = colors.map(stop => ({
+            offset: Number(stop.offset) || 0,
+            color: Array.isArray(stop.color) ? stop.color : [0, 0, 0]
+        }));
+        if (stops.length === 0) {
+            return new Uint8Array(count * 3);
+        }
+        if (stops[0].offset !== 0) {
+            stops.unshift({ ...stops[0], offset: 0 });
+        }
+        if (stops[stops.length - 1].offset !== 1) {
+            stops.push({ ...stops[stops.length - 1], offset: 1 });
+        }
+        const samples = new Uint8Array(count * 3);
+        let index = 0;
+        for (let i = 0; i < count; i++) {
+            const t = i / (count - 1);
+            while (index < stops.length - 2 && t > stops[index + 1].offset) {
+                index++;
+            }
+            const a = stops[index];
+            const b = stops[index + 1];
+            const denom = b.offset - a.offset;
+            const d = denom !== 0 ? (t - a.offset) / denom : 0;
+            for (let c = 0; c < 3; c++) {
+                const aColor = Number(a.color[c]) || 0;
+                const bColor = Number(b.color[c]) || 0;
+                const value = Math.round((1 - d) * aColor + d * bColor);
+                samples[i * 3 + c] = Math.max(0, Math.min(255, value));
+            }
+        }
+        return samples;
+    }
+    addShadingPattern(id, pattern) {
+        const key = this.normalizeReferenceKey(id);
+        if (this.shadingPatterns[key])
+            return;
+        const shadingType = pattern.type === 'axial' ? 2 : 3;
+        const funcRef = this.buildSampledFunction(pattern.colors);
+        const coords = shadingType === 2
+            ? [pattern.coords[0], pattern.coords[1], pattern.coords[2], pattern.coords[3]]
+            : [
+                pattern.coords[0],
+                pattern.coords[1],
+                pattern.coords[2],
+                pattern.coords[3],
+                pattern.coords[4],
+                pattern.coords[5]
+            ];
+        const shadingDict = this.doc.context.obj({
+            ShadingType: shadingType,
+            ColorSpace: 'DeviceRGB',
+            Coords: coords,
+            Function: funcRef,
+            Extend: [true, true]
+        });
+        if (pattern.matrix) {
+            const converted = this.convertMatrixForPattern(pattern.matrix);
+            shadingDict.set(PDFName.of('Matrix'), this.doc.context.obj([
+                converted.a,
+                converted.b,
+                converted.c,
+                converted.d,
+                converted.e,
+                converted.f
+            ]));
+        }
+        const shadingRef = this.doc.context.register(shadingDict);
+        const name = `Sh${++this.patternCounter}`;
+        this.shadingPatterns[key] = { name, pattern, ref: shadingRef };
+    }
+    applyShadingPattern(key, data, evenOdd, strokePath) {
+        const shading = this.shadingPatterns[key];
+        if (!shading)
+            return false;
+        this.registerShading(shading.name, shading.ref);
+        this.page.pushOperators(pushGraphicsState());
+        if (evenOdd) {
+            this.page.pushOperators(clipEvenOdd());
+        }
+        else {
+            this.page.pushOperators(clip());
+        }
+        if (strokePath) {
+            this.page.pushOperators(stroke());
+        }
+        else {
+            this.page.pushOperators(endPath());
+        }
+        if (shading.pattern.gState) {
+            this.setGState(shading.pattern.gState);
+        }
+        const matrix = data.matrix || unitMatrix;
+        const converted = this.convertMatrixForPattern(matrix);
+        this.page.pushOperators(concatTransformationMatrix(converted.a, converted.b, converted.c, converted.d, converted.e, converted.f), PDFOperator.of('sh', [PDFName.of(shading.name)]));
+        this.page.pushOperators(popGraphicsState());
+        return true;
+    }
+    applyTilingPattern(key, data, operator) {
+        const base = this.tilingPatterns[key];
+        if (!base)
+            return false;
+        const dict = this.doc.context.obj({});
+        const boundingBox = data.boundingBox || base.pattern.boundingBox;
+        const xStep = data.xStep || base.pattern.xStep;
+        const yStep = data.yStep || base.pattern.yStep;
+        dict.set(PDFName.of('Type'), PDFName.of('Pattern'));
+        dict.set(PDFName.of('PatternType'), PDFNumber.of(1));
+        dict.set(PDFName.of('PaintType'), PDFNumber.of(1));
+        dict.set(PDFName.of('TilingType'), PDFNumber.of(1));
+        dict.set(PDFName.of('BBox'), this.doc.context.obj(boundingBox));
+        dict.set(PDFName.of('XStep'), PDFNumber.of(xStep));
+        dict.set(PDFName.of('YStep'), PDFNumber.of(yStep));
+        const baseResources = base.stream.dict.get(PDFName.of('Resources'));
+        dict.set(PDFName.of('Resources'), baseResources || this.page.node.Resources());
+        const matrix = data.matrix || unitMatrix;
+        const converted = this.convertMatrix(matrix);
+        dict.set(PDFName.of('Matrix'), this.doc.context.obj([converted.a, converted.b, converted.c, converted.d, converted.e, converted.f]));
+        const patternStream = PDFRawStream.of(dict, base.stream.getUnencodedContents());
+        const patternRef = this.doc.context.register(patternStream);
+        const patternName = `P${++this.patternCounter}`;
+        this.registerPattern(patternName, patternRef);
+        this.page.pushOperators(pushGraphicsState());
+        this.page.pushOperators(PDFOperator.of('cs', [PDFName.of('Pattern')]), PDFOperator.of('scn', [PDFName.of(patternName)]));
+        if (base.pattern.gState) {
+            this.setGState(base.pattern.gState);
+        }
+        this.page.pushOperators(operator);
+        this.page.pushOperators(popGraphicsState());
+        return true;
+    }
+    applyPatternFill(data, operator, evenOdd, strokePath) {
+        if (!data || typeof data !== 'object' || !data.key)
+            return false;
+        const key = this.normalizeReferenceKey(data.key);
+        if (this.shadingPatterns[key]) {
+            return this.applyShadingPattern(key, data, evenOdd, strokePath);
+        }
+        if (this.tilingPatterns[key]) {
+            return this.applyTilingPattern(key, data, operator);
+        }
+        return false;
+    }
+    fill(data) {
+        if (this.applyPatternFill(data, fill(), false, false))
+            return;
+        if (data && typeof data === 'string' && data.startsWith('PT')) {
+            this.page.pushOperators(PDFOperator.of('scn', [PDFName.of(data)]));
+        }
+        this.page.pushOperators(fill());
+    }
+    fillEvenOdd(data) {
+        if (this.applyPatternFill(data, fillEvenOdd(), true, false))
+            return;
+        this.page.pushOperators(fillEvenOdd());
+    }
+    stroke(data) {
+        this.page.pushOperators(stroke());
+    }
+    fillStroke(data) {
+        if (this.applyPatternFill(data, fillAndStroke(), false, true))
+            return;
+        this.page.pushOperators(fillAndStroke());
+    }
+    fillStrokeEvenOdd(data) {
+        const operator = PDFOperator.of('B*');
+        if (this.applyPatternFill(data, operator, true, true))
+            return;
+        // @ts-ignore
+        this.page.pushOperators(operator);
+    }
+    discardPath() {
+        this.page.pushOperators(endPath());
+    }
+    clip(rule) {
+        if (rule === 'evenodd') {
+            this.page.pushOperators(clipEvenOdd());
+        }
+        else {
+            this.page.pushOperators(clip());
+        }
+        return this;
+    }
+    rect(x, y, w, h) {
+        const ph = this.internal.pageSize.getHeight();
+        this.page.pushOperators(moveTo(x, ph - y), lineTo(x + w, ph - y), lineTo(x + w, ph - (y + h)), lineTo(x, ph - (y + h)), closePath());
+        return this;
+    }
+    text(text, x, y, options) {
+        this.saveGraphicsState();
+        const ph = this.internal.pageSize.getHeight();
+        const drawOptions = {
+            x,
+            y: ph - y,
+            size: this.getFontSize(),
+            ...options
+        };
+        if (options && options.angle instanceof Matrix) {
+            this.setCurrentTransformationMatrix(options.angle);
+            delete drawOptions.angle;
+        }
+        if (options && options.charSpace !== undefined) {
+            // @ts-ignore
+            this.page.pushOperators(PDFOperator.of('Tc', [this.doc.context.obj(options.charSpace)]));
+        }
+        if (options && options.renderingMode !== undefined) {
+            const modeMap = {
+                fill: 0,
+                stroke: 1,
+                fillThenStroke: 2,
+                invisible: 3,
+                fillStroke: 2
+            };
+            const mode = modeMap[options.renderingMode] !== undefined ? modeMap[options.renderingMode] : 0;
+            // @ts-ignore
+            this.page.pushOperators(PDFOperator.of('Tr', [this.doc.context.obj(mode)]));
+        }
+        this.page.drawText(text, drawOptions);
+        if (options && options.charSpace !== undefined) {
+            // @ts-ignore
+            this.page.pushOperators(PDFOperator.of('Tc', [this.doc.context.obj(0)]));
+        }
+        this.restoreGraphicsState();
+    }
+    async addImage(img, type, x, y, w, h) {
+        try {
+            const image = await (img.startsWith('data:image/png')
+                ? this.doc.embedPng(img)
+                : this.doc.embedJpg(img));
+            this.page.drawImage(image, {
+                x,
+                y: this.internal.pageSize.getHeight() - y - h,
+                width: w,
+                height: h
+            });
+        }
+        catch (e) {
+            console.warn('Failed to add image to PDF', e);
+        }
+    }
+    link(x, y, w, h, options) {
+        try {
+            const ph = this.internal.pageSize.getHeight();
+            const rect = [x, ph - y - h, x + w, ph - y];
+            const annot = this.doc.context.obj({
+                Type: 'Annot',
+                Subtype: 'Link',
+                Rect: rect,
+                Border: [0, 0, 0],
+                A: {
+                    Type: 'Action',
+                    S: 'URI',
+                    URI: options.url
+                }
+            });
+            const annotRef = this.doc.context.register(annot);
+            const annots = this.page.node.Annots() || this.doc.context.obj([]);
+            annots.push(annotRef);
+            this.page.node.set(PDFName.of('Annots'), annots);
+        }
+        catch (e) {
+            console.warn('Failed to add link to PDF', e);
+        }
+    }
+    beginTilingPattern(pattern) {
+        this.savedPage = this.page;
+        const stream = PDFContentStream.of(this.doc.context.obj({}), []);
+        this.activeFormObject = { key: '', stream, bBox: pattern.boundingBox, matrix: unitMatrix, savedMatrix: this.currentMatrix };
+        this.currentMatrix = unitMatrix;
+        const h = pattern.boundingBox[3];
+        const mockPage = {
+            pushOperators: (...ops) => stream.push(...ops),
+            getHeight: () => pattern.boundingBox[3],
+            getWidth: () => pattern.boundingBox[2],
+            setFontSize: (size) => this.savedPage.setFontSize(size),
+            setFont: (font) => this.savedPage.setFont(font),
+            drawText: (text, options) => {
+                if (!this.currentFont)
+                    return;
+                const size = options.size || this.fontSize;
+                const encoded = this.currentFont.encodeText(text);
+                stream.push(pushGraphicsState());
+                if (options.angle instanceof Matrix) {
+                    const m = options.angle;
+                    const converted = this.convertMatrix(m);
+                    stream.push(concatTransformationMatrix(converted.a, converted.b, converted.c, converted.d, converted.e, converted.f));
+                }
+                stream.push(PDFOperator.of('BT'));
+                stream.push(PDFOperator.of('Tf', [this.currentFont.name, PDFNumber.of(size)]));
+                const tx = options.x || 0;
+                const ty = h - (options.y || 0);
+                stream.push(PDFOperator.of('Td', [PDFNumber.of(tx), PDFNumber.of(ty)]));
+                stream.push(PDFOperator.of('Tj', [encoded]));
+                stream.push(PDFOperator.of('ET'));
+                stream.push(popGraphicsState());
+            },
+            node: {
+                newExtGState: (name, gs) => this.savedPage.node.newExtGState(name, gs),
+                newXObject: (name, ref) => this.savedPage.node.newXObject(name, ref),
+                Resources: () => this.savedPage.node.Resources()
+            }
+        };
+        this.page = mockPage;
+    }
+    endTilingPattern(id, pattern) {
+        if (!this.activeFormObject)
+            return;
+        const { stream, bBox, savedMatrix } = this.activeFormObject;
+        const normalizedKey = this.normalizeReferenceKey(id);
+        const patternDict = stream.dict;
+        patternDict.set(PDFName.of('Type'), PDFName.of('Pattern'));
+        patternDict.set(PDFName.of('PatternType'), PDFNumber.of(1));
+        patternDict.set(PDFName.of('PaintType'), PDFNumber.of(1));
+        patternDict.set(PDFName.of('TilingType'), PDFNumber.of(1));
+        patternDict.set(PDFName.of('BBox'), this.doc.context.obj([bBox[0], -bBox[1], bBox[0] + bBox[2], bBox[3] - bBox[1]]));
+        patternDict.set(PDFName.of('XStep'), PDFNumber.of(pattern.xStep));
+        patternDict.set(PDFName.of('YStep'), PDFNumber.of(pattern.yStep));
+        patternDict.set(PDFName.of('Resources'), this.savedPage.node.Resources());
+        if (pattern.matrix) {
+            const converted = this.convertMatrixForPattern(pattern.matrix);
+            patternDict.set(PDFName.of('Matrix'), this.doc.context.obj([
+                converted.a,
+                converted.b,
+                converted.c,
+                converted.d,
+                converted.e,
+                converted.f
+            ]));
+        }
+        this.tilingPatterns[normalizedKey] = { pattern, stream, cloneIndex: 0 };
+        this.page = this.savedPage;
+        this.currentMatrix = savedMatrix;
+        this.activeFormObject = null;
+        this.savedPage = null;
+    }
+}
+jsPDF.version = '2.5.1';
+jsPDF.API = {};
+//# sourceMappingURL=jspdf-shim.js.map