art-bd-ui 1.0.21 → 1.0.23

package/dist/esm/node_modules/pdf-lib/es/api/operators.js

@@ -0,0 +1,245 @@
+import { asPDFNumber, asPDFName, asNumber } from './objects.js';
+import { degreesToRadians } from './rotations.js';
+import '../core/errors.js';
+import '../core/syntax/CharCodes.js';
+import '../core/PDFContext.js';
+import '../core/PDFObjectCopier.js';
+import '../core/writers/PDFWriter.js';
+import '../core/writers/PDFStreamWriter.js';
+import '../core/document/PDFHeader.js';
+import '../core/document/PDFTrailer.js';
+import '../core/document/PDFTrailerDict.js';
+import '../core/document/PDFCrossRefSection.js';
+import '../core/embedders/StandardFontEmbedder.js';
+import '../core/embedders/CustomFontEmbedder.js';
+import '../core/embedders/CustomFontSubsetEmbedder.js';
+import '../core/embedders/FileEmbedder.js';
+import '../core/embedders/JpegEmbedder.js';
+import '../core/embedders/PngEmbedder.js';
+import '../core/embedders/PDFPageEmbedder.js';
+import '../core/interactive/ViewerPreferences.js';
+import '../core/objects/PDFObject.js';
+import '../core/objects/PDFBool.js';
+import '../core/objects/PDFNumber.js';
+import '../core/objects/PDFString.js';
+import '../core/objects/PDFHexString.js';
+import '../core/objects/PDFName.js';
+import '../core/objects/PDFNull.js';
+import '../core/objects/PDFArray.js';
+import '../core/objects/PDFDict.js';
+import '../core/objects/PDFRef.js';
+import '../core/objects/PDFInvalidObject.js';
+import '../core/objects/PDFStream.js';
+import '../core/objects/PDFRawStream.js';
+import '../core/structures/PDFCatalog.js';
+import '../core/structures/PDFContentStream.js';
+import '../core/structures/PDFCrossRefStream.js';
+import '../core/structures/PDFObjectStream.js';
+import '../core/structures/PDFPageTree.js';
+import '../core/structures/PDFPageLeaf.js';
+import '../core/structures/PDFFlateStream.js';
+import PDFOperator from '../core/operators/PDFOperator.js';
+import Ops from '../core/operators/PDFOperatorNames.js';
+import '../core/parser/PDFObjectParser.js';
+import '../core/parser/PDFObjectStreamParser.js';
+import '../core/parser/PDFParser.js';
+import '../core/parser/PDFXRefStreamParser.js';
+import '../core/streams/Ascii85Stream.js';
+import '../core/streams/AsciiHexStream.js';
+import '../core/streams/FlateStream.js';
+import '../core/streams/LZWStream.js';
+import '../core/streams/RunLengthStream.js';
+import '../core/streams/Stream.js';
+import '../core/annotation/PDFAnnotation.js';
+import '../core/annotation/PDFWidgetAnnotation.js';
+import '../core/annotation/AppearanceCharacteristics.js';
+import '../core/annotation/flags.js';
+import '../core/acroform/PDFAcroButton.js';
+import '../core/acroform/PDFAcroCheckBox.js';
+import '../core/acroform/PDFAcroChoice.js';
+import '../core/acroform/PDFAcroComboBox.js';
+import '../core/acroform/PDFAcroField.js';
+import '../core/acroform/PDFAcroForm.js';
+import '../core/acroform/PDFAcroListBox.js';
+import '../core/acroform/PDFAcroNonTerminal.js';
+import '../core/acroform/PDFAcroPushButton.js';
+import '../core/acroform/PDFAcroRadioButton.js';
+import '../core/acroform/PDFAcroSignature.js';
+import '../core/acroform/PDFAcroTerminal.js';
+import '../core/acroform/PDFAcroText.js';
+import '../core/acroform/flags.js';
+
+/* ==================== Clipping Path Operators ==================== */
+var clip = function () { return PDFOperator.of(Ops.ClipNonZero); };
+/* ==================== Graphics State Operators ==================== */
+var cos = Math.cos, sin = Math.sin, tan = Math.tan;
+var concatTransformationMatrix = function (a, b, c, d, e, f) {
+    return PDFOperator.of(Ops.ConcatTransformationMatrix, [
+        asPDFNumber(a),
+        asPDFNumber(b),
+        asPDFNumber(c),
+        asPDFNumber(d),
+        asPDFNumber(e),
+        asPDFNumber(f),
+    ]);
+};
+var translate = function (xPos, yPos) {
+    return concatTransformationMatrix(1, 0, 0, 1, xPos, yPos);
+};
+var scale = function (xPos, yPos) {
+    return concatTransformationMatrix(xPos, 0, 0, yPos, 0, 0);
+};
+var rotateRadians = function (angle) {
+    return concatTransformationMatrix(cos(asNumber(angle)), sin(asNumber(angle)), -sin(asNumber(angle)), cos(asNumber(angle)), 0, 0);
+};
+var rotateDegrees = function (angle) {
+    return rotateRadians(degreesToRadians(asNumber(angle)));
+};
+var skewRadians = function (xSkewAngle, ySkewAngle) {
+    return concatTransformationMatrix(1, tan(asNumber(xSkewAngle)), tan(asNumber(ySkewAngle)), 1, 0, 0);
+};
+var setDashPattern = function (dashArray, dashPhase) {
+    return PDFOperator.of(Ops.SetLineDashPattern, [
+        "[" + dashArray.map(asPDFNumber).join(' ') + "]",
+        asPDFNumber(dashPhase),
+    ]);
+};
+var LineCapStyle;
+(function (LineCapStyle) {
+    LineCapStyle[LineCapStyle["Butt"] = 0] = "Butt";
+    LineCapStyle[LineCapStyle["Round"] = 1] = "Round";
+    LineCapStyle[LineCapStyle["Projecting"] = 2] = "Projecting";
+})(LineCapStyle || (LineCapStyle = {}));
+var setLineCap = function (style) {
+    return PDFOperator.of(Ops.SetLineCapStyle, [asPDFNumber(style)]);
+};
+var LineJoinStyle;
+(function (LineJoinStyle) {
+    LineJoinStyle[LineJoinStyle["Miter"] = 0] = "Miter";
+    LineJoinStyle[LineJoinStyle["Round"] = 1] = "Round";
+    LineJoinStyle[LineJoinStyle["Bevel"] = 2] = "Bevel";
+})(LineJoinStyle || (LineJoinStyle = {}));
+var setGraphicsState = function (state) {
+    return PDFOperator.of(Ops.SetGraphicsStateParams, [asPDFName(state)]);
+};
+var pushGraphicsState = function () { return PDFOperator.of(Ops.PushGraphicsState); };
+var popGraphicsState = function () { return PDFOperator.of(Ops.PopGraphicsState); };
+var setLineWidth = function (width) {
+    return PDFOperator.of(Ops.SetLineWidth, [asPDFNumber(width)]);
+};
+/* ==================== Path Construction Operators ==================== */
+var appendBezierCurve = function (x1, y1, x2, y2, x3, y3) {
+    return PDFOperator.of(Ops.AppendBezierCurve, [
+        asPDFNumber(x1),
+        asPDFNumber(y1),
+        asPDFNumber(x2),
+        asPDFNumber(y2),
+        asPDFNumber(x3),
+        asPDFNumber(y3),
+    ]);
+};
+var appendQuadraticCurve = function (x1, y1, x2, y2) {
+    return PDFOperator.of(Ops.CurveToReplicateInitialPoint, [
+        asPDFNumber(x1),
+        asPDFNumber(y1),
+        asPDFNumber(x2),
+        asPDFNumber(y2),
+    ]);
+};
+var closePath = function () { return PDFOperator.of(Ops.ClosePath); };
+var moveTo = function (xPos, yPos) {
+    return PDFOperator.of(Ops.MoveTo, [asPDFNumber(xPos), asPDFNumber(yPos)]);
+};
+var lineTo = function (xPos, yPos) {
+    return PDFOperator.of(Ops.LineTo, [asPDFNumber(xPos), asPDFNumber(yPos)]);
+};
+/* ==================== Path Painting Operators ==================== */
+var stroke = function () { return PDFOperator.of(Ops.StrokePath); };
+var fill = function () { return PDFOperator.of(Ops.FillNonZero); };
+var fillAndStroke = function () { return PDFOperator.of(Ops.FillNonZeroAndStroke); };
+var endPath = function () { return PDFOperator.of(Ops.EndPath); };
+/* ==================== Text Positioning Operators ==================== */
+var nextLine = function () { return PDFOperator.of(Ops.NextLine); };
+/* ==================== Text Showing Operators ==================== */
+var showText = function (text) {
+    return PDFOperator.of(Ops.ShowText, [text]);
+};
+/* ==================== Text State Operators ==================== */
+var beginText = function () { return PDFOperator.of(Ops.BeginText); };
+var endText = function () { return PDFOperator.of(Ops.EndText); };
+var setFontAndSize = function (name, size) { return PDFOperator.of(Ops.SetFontAndSize, [asPDFName(name), asPDFNumber(size)]); };
+var setLineHeight = function (lineHeight) {
+    return PDFOperator.of(Ops.SetTextLineHeight, [asPDFNumber(lineHeight)]);
+};
+var TextRenderingMode;
+(function (TextRenderingMode) {
+    TextRenderingMode[TextRenderingMode["Fill"] = 0] = "Fill";
+    TextRenderingMode[TextRenderingMode["Outline"] = 1] = "Outline";
+    TextRenderingMode[TextRenderingMode["FillAndOutline"] = 2] = "FillAndOutline";
+    TextRenderingMode[TextRenderingMode["Invisible"] = 3] = "Invisible";
+    TextRenderingMode[TextRenderingMode["FillAndClip"] = 4] = "FillAndClip";
+    TextRenderingMode[TextRenderingMode["OutlineAndClip"] = 5] = "OutlineAndClip";
+    TextRenderingMode[TextRenderingMode["FillAndOutlineAndClip"] = 6] = "FillAndOutlineAndClip";
+    TextRenderingMode[TextRenderingMode["Clip"] = 7] = "Clip";
+})(TextRenderingMode || (TextRenderingMode = {}));
+var setTextMatrix = function (a, b, c, d, e, f) {
+    return PDFOperator.of(Ops.SetTextMatrix, [
+        asPDFNumber(a),
+        asPDFNumber(b),
+        asPDFNumber(c),
+        asPDFNumber(d),
+        asPDFNumber(e),
+        asPDFNumber(f),
+    ]);
+};
+var rotateAndSkewTextRadiansAndTranslate = function (rotationAngle, xSkewAngle, ySkewAngle, x, y) {
+    return setTextMatrix(cos(asNumber(rotationAngle)), sin(asNumber(rotationAngle)) + tan(asNumber(xSkewAngle)), -sin(asNumber(rotationAngle)) + tan(asNumber(ySkewAngle)), cos(asNumber(rotationAngle)), x, y);
+};
+/* ==================== XObject Operator ==================== */
+var drawObject = function (name) {
+    return PDFOperator.of(Ops.DrawObject, [asPDFName(name)]);
+};
+/* ==================== Color Operators ==================== */
+var setFillingGrayscaleColor = function (gray) {
+    return PDFOperator.of(Ops.NonStrokingColorGray, [asPDFNumber(gray)]);
+};
+var setStrokingGrayscaleColor = function (gray) {
+    return PDFOperator.of(Ops.StrokingColorGray, [asPDFNumber(gray)]);
+};
+var setFillingRgbColor = function (red, green, blue) {
+    return PDFOperator.of(Ops.NonStrokingColorRgb, [
+        asPDFNumber(red),
+        asPDFNumber(green),
+        asPDFNumber(blue),
+    ]);
+};
+var setStrokingRgbColor = function (red, green, blue) {
+    return PDFOperator.of(Ops.StrokingColorRgb, [
+        asPDFNumber(red),
+        asPDFNumber(green),
+        asPDFNumber(blue),
+    ]);
+};
+var setFillingCmykColor = function (cyan, magenta, yellow, key) {
+    return PDFOperator.of(Ops.NonStrokingColorCmyk, [
+        asPDFNumber(cyan),
+        asPDFNumber(magenta),
+        asPDFNumber(yellow),
+        asPDFNumber(key),
+    ]);
+};
+var setStrokingCmykColor = function (cyan, magenta, yellow, key) {
+    return PDFOperator.of(Ops.StrokingColorCmyk, [
+        asPDFNumber(cyan),
+        asPDFNumber(magenta),
+        asPDFNumber(yellow),
+        asPDFNumber(key),
+    ]);
+};
+/* ==================== Marked Content Operators ==================== */
+var beginMarkedContent = function (tag) {
+    return PDFOperator.of(Ops.BeginMarkedContent, [asPDFName(tag)]);
+};
+var endMarkedContent = function () { return PDFOperator.of(Ops.EndMarkedContent); };
+
+export { LineCapStyle, LineJoinStyle, TextRenderingMode, appendBezierCurve, appendQuadraticCurve, beginMarkedContent, beginText, clip, closePath, concatTransformationMatrix, drawObject, endMarkedContent, endPath, endText, fill, fillAndStroke, lineTo, moveTo, nextLine, popGraphicsState, pushGraphicsState, rotateAndSkewTextRadiansAndTranslate, rotateDegrees, rotateRadians, scale, setDashPattern, setFillingCmykColor, setFillingGrayscaleColor, setFillingRgbColor, setFontAndSize, setGraphicsState, setLineCap, setLineHeight, setLineWidth, setStrokingCmykColor, setStrokingGrayscaleColor, setStrokingRgbColor, setTextMatrix, showText, skewRadians, stroke, translate };

package/dist/esm/node_modules/pdf-lib/es/api/rotations.js

@@ -0,0 +1,72 @@
+import '../utils/base64.js';
+import '../utils/unicode.js';
+import { error } from '../utils/errors.js';
+import '../utils/objects.js';
+import { assertIs } from '../utils/validators.js';
+import '../utils/pdfDocEncoding.js';
+import '../utils/Cache.js';
+
+var RotationTypes;
+(function (RotationTypes) {
+    RotationTypes["Degrees"] = "degrees";
+    RotationTypes["Radians"] = "radians";
+})(RotationTypes || (RotationTypes = {}));
+var degrees = function (degreeAngle) {
+    assertIs(degreeAngle, 'degreeAngle', ['number']);
+    return { type: RotationTypes.Degrees, angle: degreeAngle };
+};
+var Radians = RotationTypes.Radians, Degrees = RotationTypes.Degrees;
+var degreesToRadians = function (degree) { return (degree * Math.PI) / 180; };
+var radiansToDegrees = function (radian) { return (radian * 180) / Math.PI; };
+// prettier-ignore
+var toRadians = function (rotation) {
+    return rotation.type === Radians ? rotation.angle
+        : rotation.type === Degrees ? degreesToRadians(rotation.angle)
+            : error("Invalid rotation: " + JSON.stringify(rotation));
+};
+// prettier-ignore
+var toDegrees = function (rotation) {
+    return rotation.type === Radians ? radiansToDegrees(rotation.angle)
+        : rotation.type === Degrees ? rotation.angle
+            : error("Invalid rotation: " + JSON.stringify(rotation));
+};
+var reduceRotation = function (degreeAngle) {
+    if (degreeAngle === void 0) { degreeAngle = 0; }
+    var quadrants = (degreeAngle / 90) % 4;
+    if (quadrants === 0)
+        return 0;
+    if (quadrants === 1)
+        return 90;
+    if (quadrants === 2)
+        return 180;
+    if (quadrants === 3)
+        return 270;
+    return 0; // `degreeAngle` is not a multiple of 90
+};
+var adjustDimsForRotation = function (dims, degreeAngle) {
+    if (degreeAngle === void 0) { degreeAngle = 0; }
+    var rotation = reduceRotation(degreeAngle);
+    return rotation === 90 || rotation === 270
+        ? { width: dims.height, height: dims.width }
+        : { width: dims.width, height: dims.height };
+};
+var rotateRectangle = function (rectangle, borderWidth, degreeAngle) {
+    if (borderWidth === void 0) { borderWidth = 0; }
+    if (degreeAngle === void 0) { degreeAngle = 0; }
+    var x = rectangle.x, y = rectangle.y, w = rectangle.width, h = rectangle.height;
+    var r = reduceRotation(degreeAngle);
+    var b = borderWidth / 2;
+    // prettier-ignore
+    if (r === 0)
+        return { x: x - b, y: y - b, width: w, height: h };
+    else if (r === 90)
+        return { x: x - h + b, y: y - b, width: h, height: w };
+    else if (r === 180)
+        return { x: x - w + b, y: y - h + b, width: w, height: h };
+    else if (r === 270)
+        return { x: x - b, y: y - w + b, width: h, height: w };
+    else
+        return { x: x - b, y: y - b, width: w, height: h };
+};
+
+export { RotationTypes, adjustDimsForRotation, degrees, degreesToRadians, radiansToDegrees, reduceRotation, rotateRectangle, toDegrees, toRadians };

package/dist/esm/node_modules/pdf-lib/es/api/sizes.js

@@ -0,0 +1,4 @@
+var PageSizes = {
+    A4: [595.28, 841.89]};
+
+export { PageSizes };

package/dist/esm/node_modules/pdf-lib/es/api/svgPath.js

@@ -0,0 +1,379 @@
+import { closePath, lineTo, appendQuadraticCurve, appendBezierCurve, moveTo } from './operators.js';
+
+// Originated from pdfkit Copyright (c) 2014 Devon Govett
+// https://github.com/foliojs/pdfkit/blob/1e62e6ffe24b378eb890df507a47610f4c4a7b24/lib/path.js
+// MIT LICENSE
+// Updated for pdf-lib & TypeScript by Jeremy Messenger
+var cx = 0;
+var cy = 0;
+var px = 0;
+var py = 0;
+var sx = 0;
+var sy = 0;
+var parameters = new Map([
+    ['A', 7],
+    ['a', 7],
+    ['C', 6],
+    ['c', 6],
+    ['H', 1],
+    ['h', 1],
+    ['L', 2],
+    ['l', 2],
+    ['M', 2],
+    ['m', 2],
+    ['Q', 4],
+    ['q', 4],
+    ['S', 4],
+    ['s', 4],
+    ['T', 2],
+    ['t', 2],
+    ['V', 1],
+    ['v', 1],
+    ['Z', 0],
+    ['z', 0],
+]);
+var parse = function (path) {
+    var cmd;
+    var ret = [];
+    var args = [];
+    var curArg = '';
+    var foundDecimal = false;
+    var params = 0;
+    for (var _i = 0, path_1 = path; _i < path_1.length; _i++) {
+        var c = path_1[_i];
+        if (parameters.has(c)) {
+            params = parameters.get(c);
+            if (cmd) {
+                // save existing command
+                if (curArg.length > 0) {
+                    args[args.length] = +curArg;
+                }
+                ret[ret.length] = { cmd: cmd, args: args };
+                args = [];
+                curArg = '';
+                foundDecimal = false;
+            }
+            cmd = c;
+        }
+        else if ([' ', ','].includes(c) ||
+            (c === '-' && curArg.length > 0 && curArg[curArg.length - 1] !== 'e') ||
+            (c === '.' && foundDecimal)) {
+            if (curArg.length === 0) {
+                continue;
+            }
+            if (args.length === params) {
+                // handle reused commands
+                ret[ret.length] = { cmd: cmd, args: args };
+                args = [+curArg];
+                // handle assumed commands
+                if (cmd === 'M') {
+                    cmd = 'L';
+                }
+                if (cmd === 'm') {
+                    cmd = 'l';
+                }
+            }
+            else {
+                args[args.length] = +curArg;
+            }
+            foundDecimal = c === '.';
+            // fix for negative numbers or repeated decimals with no delimeter between commands
+            curArg = ['-', '.'].includes(c) ? c : '';
+        }
+        else {
+            curArg += c;
+            if (c === '.') {
+                foundDecimal = true;
+            }
+        }
+    }
+    // add the last command
+    if (curArg.length > 0) {
+        if (args.length === params) {
+            // handle reused commands
+            ret[ret.length] = { cmd: cmd, args: args };
+            args = [+curArg];
+            // handle assumed commands
+            if (cmd === 'M') {
+                cmd = 'L';
+            }
+            if (cmd === 'm') {
+                cmd = 'l';
+            }
+        }
+        else {
+            args[args.length] = +curArg;
+        }
+    }
+    ret[ret.length] = { cmd: cmd, args: args };
+    return ret;
+};
+var apply = function (commands) {
+    // current point, control point, and subpath starting point
+    cx = cy = px = py = sx = sy = 0;
+    // run the commands
+    var cmds = [];
+    for (var i = 0; i < commands.length; i++) {
+        var c = commands[i];
+        if (c.cmd && typeof runners[c.cmd] === 'function') {
+            var cmd = runners[c.cmd](c.args);
+            if (Array.isArray(cmd)) {
+                cmds = cmds.concat(cmd);
+            }
+            else {
+                cmds.push(cmd);
+            }
+        }
+    }
+    return cmds;
+};
+var runners = {
+    M: function (a) {
+        cx = a[0];
+        cy = a[1];
+        px = py = null;
+        sx = cx;
+        sy = cy;
+        return moveTo(cx, cy);
+    },
+    m: function (a) {
+        cx += a[0];
+        cy += a[1];
+        px = py = null;
+        sx = cx;
+        sy = cy;
+        return moveTo(cx, cy);
+    },
+    C: function (a) {
+        cx = a[4];
+        cy = a[5];
+        px = a[2];
+        py = a[3];
+        return appendBezierCurve(a[0], a[1], a[2], a[3], a[4], a[5]);
+    },
+    c: function (a) {
+        var cmd = appendBezierCurve(a[0] + cx, a[1] + cy, a[2] + cx, a[3] + cy, a[4] + cx, a[5] + cy);
+        px = cx + a[2];
+        py = cy + a[3];
+        cx += a[4];
+        cy += a[5];
+        return cmd;
+    },
+    S: function (a) {
+        if (px === null || py === null) {
+            px = cx;
+            py = cy;
+        }
+        var cmd = appendBezierCurve(cx - (px - cx), cy - (py - cy), a[0], a[1], a[2], a[3]);
+        px = a[0];
+        py = a[1];
+        cx = a[2];
+        cy = a[3];
+        return cmd;
+    },
+    s: function (a) {
+        if (px === null || py === null) {
+            px = cx;
+            py = cy;
+        }
+        var cmd = appendBezierCurve(cx - (px - cx), cy - (py - cy), cx + a[0], cy + a[1], cx + a[2], cy + a[3]);
+        px = cx + a[0];
+        py = cy + a[1];
+        cx += a[2];
+        cy += a[3];
+        return cmd;
+    },
+    Q: function (a) {
+        px = a[0];
+        py = a[1];
+        cx = a[2];
+        cy = a[3];
+        return appendQuadraticCurve(a[0], a[1], cx, cy);
+    },
+    q: function (a) {
+        var cmd = appendQuadraticCurve(a[0] + cx, a[1] + cy, a[2] + cx, a[3] + cy);
+        px = cx + a[0];
+        py = cy + a[1];
+        cx += a[2];
+        cy += a[3];
+        return cmd;
+    },
+    T: function (a) {
+        if (px === null || py === null) {
+            px = cx;
+            py = cy;
+        }
+        else {
+            px = cx - (px - cx);
+            py = cy - (py - cy);
+        }
+        var cmd = appendQuadraticCurve(px, py, a[0], a[1]);
+        px = cx - (px - cx);
+        py = cy - (py - cy);
+        cx = a[0];
+        cy = a[1];
+        return cmd;
+    },
+    t: function (a) {
+        if (px === null || py === null) {
+            px = cx;
+            py = cy;
+        }
+        else {
+            px = cx - (px - cx);
+            py = cy - (py - cy);
+        }
+        var cmd = appendQuadraticCurve(px, py, cx + a[0], cy + a[1]);
+        cx += a[0];
+        cy += a[1];
+        return cmd;
+    },
+    A: function (a) {
+        var cmds = solveArc(cx, cy, a);
+        cx = a[5];
+        cy = a[6];
+        return cmds;
+    },
+    a: function (a) {
+        a[5] += cx;
+        a[6] += cy;
+        var cmds = solveArc(cx, cy, a);
+        cx = a[5];
+        cy = a[6];
+        return cmds;
+    },
+    L: function (a) {
+        cx = a[0];
+        cy = a[1];
+        px = py = null;
+        return lineTo(cx, cy);
+    },
+    l: function (a) {
+        cx += a[0];
+        cy += a[1];
+        px = py = null;
+        return lineTo(cx, cy);
+    },
+    H: function (a) {
+        cx = a[0];
+        px = py = null;
+        return lineTo(cx, cy);
+    },
+    h: function (a) {
+        cx += a[0];
+        px = py = null;
+        return lineTo(cx, cy);
+    },
+    V: function (a) {
+        cy = a[0];
+        px = py = null;
+        return lineTo(cx, cy);
+    },
+    v: function (a) {
+        cy += a[0];
+        px = py = null;
+        return lineTo(cx, cy);
+    },
+    Z: function () {
+        var cmd = closePath();
+        cx = sx;
+        cy = sy;
+        return cmd;
+    },
+    z: function () {
+        var cmd = closePath();
+        cx = sx;
+        cy = sy;
+        return cmd;
+    },
+};
+var solveArc = function (x, y, coords) {
+    var rx = coords[0], ry = coords[1], rot = coords[2], large = coords[3], sweep = coords[4], ex = coords[5], ey = coords[6];
+    var segs = arcToSegments(ex, ey, rx, ry, large, sweep, rot, x, y);
+    var cmds = [];
+    for (var _i = 0, segs_1 = segs; _i < segs_1.length; _i++) {
+        var seg = segs_1[_i];
+        var bez = segmentToBezier.apply(void 0, seg);
+        cmds.push(appendBezierCurve.apply(void 0, bez));
+    }
+    return cmds;
+};
+// from Inkscape svgtopdf, thanks!
+var arcToSegments = function (x, y, rx, ry, large, sweep, rotateX, ox, oy) {
+    var th = rotateX * (Math.PI / 180);
+    var sinTh = Math.sin(th);
+    var cosTh = Math.cos(th);
+    rx = Math.abs(rx);
+    ry = Math.abs(ry);
+    px = cosTh * (ox - x) * 0.5 + sinTh * (oy - y) * 0.5;
+    py = cosTh * (oy - y) * 0.5 - sinTh * (ox - x) * 0.5;
+    var pl = (px * px) / (rx * rx) + (py * py) / (ry * ry);
+    if (pl > 1) {
+        pl = Math.sqrt(pl);
+        rx *= pl;
+        ry *= pl;
+    }
+    var a00 = cosTh / rx;
+    var a01 = sinTh / rx;
+    var a10 = -sinTh / ry;
+    var a11 = cosTh / ry;
+    var x0 = a00 * ox + a01 * oy;
+    var y0 = a10 * ox + a11 * oy;
+    var x1 = a00 * x + a01 * y;
+    var y1 = a10 * x + a11 * y;
+    var d = (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0);
+    var sfactorSq = 1 / d - 0.25;
+    if (sfactorSq < 0) {
+        sfactorSq = 0;
+    }
+    var sfactor = Math.sqrt(sfactorSq);
+    if (sweep === large) {
+        sfactor = -sfactor;
+    }
+    var xc = 0.5 * (x0 + x1) - sfactor * (y1 - y0);
+    var yc = 0.5 * (y0 + y1) + sfactor * (x1 - x0);
+    var th0 = Math.atan2(y0 - yc, x0 - xc);
+    var th1 = Math.atan2(y1 - yc, x1 - xc);
+    var thArc = th1 - th0;
+    if (thArc < 0 && sweep === 1) {
+        thArc += 2 * Math.PI;
+    }
+    else if (thArc > 0 && sweep === 0) {
+        thArc -= 2 * Math.PI;
+    }
+    var segments = Math.ceil(Math.abs(thArc / (Math.PI * 0.5 + 0.001)));
+    var result = [];
+    for (var i = 0; i < segments; i++) {
+        var th2 = th0 + (i * thArc) / segments;
+        var th3 = th0 + ((i + 1) * thArc) / segments;
+        result[i] = [xc, yc, th2, th3, rx, ry, sinTh, cosTh];
+    }
+    return result;
+};
+var segmentToBezier = function (cx1, cy1, th0, th1, rx, ry, sinTh, cosTh) {
+    var a00 = cosTh * rx;
+    var a01 = -sinTh * ry;
+    var a10 = sinTh * rx;
+    var a11 = cosTh * ry;
+    var thHalf = 0.5 * (th1 - th0);
+    var t = ((8 / 3) * Math.sin(thHalf * 0.5) * Math.sin(thHalf * 0.5)) /
+        Math.sin(thHalf);
+    var x1 = cx1 + Math.cos(th0) - t * Math.sin(th0);
+    var y1 = cy1 + Math.sin(th0) + t * Math.cos(th0);
+    var x3 = cx1 + Math.cos(th1);
+    var y3 = cy1 + Math.sin(th1);
+    var x2 = x3 + t * Math.sin(th1);
+    var y2 = y3 - t * Math.cos(th1);
+    var result = [
+        a00 * x1 + a01 * y1,
+        a10 * x1 + a11 * y1,
+        a00 * x2 + a01 * y2,
+        a10 * x2 + a11 * y2,
+        a00 * x3 + a01 * y3,
+        a10 * x3 + a11 * y3,
+    ];
+    return result;
+};
+var svgPathToOperators = function (path) { return apply(parse(path)); };
+
+export { svgPathToOperators };