art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,381 @@
+'use strict';
+
+var operators = require('./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 operators.moveTo(cx, cy);
+    },
+    m: function (a) {
+        cx += a[0];
+        cy += a[1];
+        px = py = null;
+        sx = cx;
+        sy = cy;
+        return operators.moveTo(cx, cy);
+    },
+    C: function (a) {
+        cx = a[4];
+        cy = a[5];
+        px = a[2];
+        py = a[3];
+        return operators.appendBezierCurve(a[0], a[1], a[2], a[3], a[4], a[5]);
+    },
+    c: function (a) {
+        var cmd = operators.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 = operators.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 = operators.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 operators.appendQuadraticCurve(a[0], a[1], cx, cy);
+    },
+    q: function (a) {
+        var cmd = operators.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 = operators.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 = operators.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 operators.lineTo(cx, cy);
+    },
+    l: function (a) {
+        cx += a[0];
+        cy += a[1];
+        px = py = null;
+        return operators.lineTo(cx, cy);
+    },
+    H: function (a) {
+        cx = a[0];
+        px = py = null;
+        return operators.lineTo(cx, cy);
+    },
+    h: function (a) {
+        cx += a[0];
+        px = py = null;
+        return operators.lineTo(cx, cy);
+    },
+    V: function (a) {
+        cy = a[0];
+        px = py = null;
+        return operators.lineTo(cx, cy);
+    },
+    v: function (a) {
+        cy += a[0];
+        px = py = null;
+        return operators.lineTo(cx, cy);
+    },
+    Z: function () {
+        var cmd = operators.closePath();
+        cx = sx;
+        cy = sy;
+        return cmd;
+    },
+    z: function () {
+        var cmd = operators.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(operators.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)); };
+
+exports.svgPathToOperators = svgPathToOperators;

package/dist/cjs/node_modules/pdf-lib/es/api/text/alignment.js

@@ -0,0 +1,8 @@
+'use strict';
+
+exports.TextAlignment = void 0;
+(function (TextAlignment) {
+    TextAlignment[TextAlignment["Left"] = 0] = "Left";
+    TextAlignment[TextAlignment["Center"] = 1] = "Center";
+    TextAlignment[TextAlignment["Right"] = 2] = "Right";
+})(exports.TextAlignment || (exports.TextAlignment = {}));

package/dist/cjs/node_modules/pdf-lib/es/api/text/layout.js

@@ -0,0 +1,220 @@
+'use strict';
+
+var errors = require('../errors.js');
+var alignment = require('./alignment.js');
+require('../../utils/base64.js');
+var strings = require('../../utils/strings.js');
+require('../../utils/unicode.js');
+require('../../utils/objects.js');
+require('../../utils/pdfDocEncoding.js');
+require('../../utils/Cache.js');
+
+var MIN_FONT_SIZE = 4;
+var MAX_FONT_SIZE = 500;
+var computeFontSize = function (lines, font, bounds, multiline) {
+    if (multiline === void 0) { multiline = false; }
+    var fontSize = MIN_FONT_SIZE;
+    while (fontSize < MAX_FONT_SIZE) {
+        var linesUsed = 0;
+        for (var lineIdx = 0, lineLen = lines.length; lineIdx < lineLen; lineIdx++) {
+            linesUsed += 1;
+            var line = lines[lineIdx];
+            var words = line.split(' ');
+            // Layout the words using the current `fontSize`, line wrapping
+            // whenever we reach the end of the current line.
+            var spaceInLineRemaining = bounds.width;
+            for (var idx = 0, len = words.length; idx < len; idx++) {
+                var isLastWord = idx === len - 1;
+                var word = isLastWord ? words[idx] : words[idx] + ' ';
+                var widthOfWord = font.widthOfTextAtSize(word, fontSize);
+                spaceInLineRemaining -= widthOfWord;
+                if (spaceInLineRemaining <= 0) {
+                    linesUsed += 1;
+                    spaceInLineRemaining = bounds.width - widthOfWord;
+                }
+            }
+        }
+        // Return if we exceeded the allowed width
+        if (!multiline && linesUsed > lines.length)
+            return fontSize - 1;
+        var height = font.heightAtSize(fontSize);
+        var lineHeight = height + height * 0.2;
+        var totalHeight = lineHeight * linesUsed;
+        // Return if we exceeded the allowed height
+        if (totalHeight > Math.abs(bounds.height))
+            return fontSize - 1;
+        fontSize += 1;
+    }
+    return fontSize;
+};
+var computeCombedFontSize = function (line, font, bounds, cellCount) {
+    var cellWidth = bounds.width / cellCount;
+    var cellHeight = bounds.height;
+    var fontSize = MIN_FONT_SIZE;
+    var chars = strings.charSplit(line);
+    while (fontSize < MAX_FONT_SIZE) {
+        for (var idx = 0, len = chars.length; idx < len; idx++) {
+            var c = chars[idx];
+            var tooLong = font.widthOfTextAtSize(c, fontSize) > cellWidth * 0.75;
+            if (tooLong)
+                return fontSize - 1;
+        }
+        var height = font.heightAtSize(fontSize, { descender: false });
+        if (height > cellHeight)
+            return fontSize - 1;
+        fontSize += 1;
+    }
+    return fontSize;
+};
+var lastIndexOfWhitespace = function (line) {
+    for (var idx = line.length; idx > 0; idx--) {
+        if (/\s/.test(line[idx]))
+            return idx;
+    }
+    return undefined;
+};
+var splitOutLines = function (input, maxWidth, font, fontSize) {
+    var _a;
+    var lastWhitespaceIdx = input.length;
+    while (lastWhitespaceIdx > 0) {
+        var line = input.substring(0, lastWhitespaceIdx);
+        var encoded = font.encodeText(line);
+        var width = font.widthOfTextAtSize(line, fontSize);
+        if (width < maxWidth) {
+            var remainder = input.substring(lastWhitespaceIdx) || undefined;
+            return { line: line, encoded: encoded, width: width, remainder: remainder };
+        }
+        lastWhitespaceIdx = (_a = lastIndexOfWhitespace(line)) !== null && _a !== void 0 ? _a : 0;
+    }
+    // We were unable to split the input enough to get a chunk that would fit
+    // within the specified `maxWidth` so we'll just return everything
+    return {
+        line: input,
+        encoded: font.encodeText(input),
+        width: font.widthOfTextAtSize(input, fontSize),
+        remainder: undefined,
+    };
+};
+var layoutMultilineText = function (text, _a) {
+    var alignment$1 = _a.alignment, fontSize = _a.fontSize, font = _a.font, bounds = _a.bounds;
+    var lines = strings.lineSplit(strings.cleanText(text));
+    if (fontSize === undefined || fontSize === 0) {
+        fontSize = computeFontSize(lines, font, bounds, true);
+    }
+    var height = font.heightAtSize(fontSize);
+    var lineHeight = height + height * 0.2;
+    var textLines = [];
+    var minX = bounds.x;
+    var minY = bounds.y;
+    var maxX = bounds.x + bounds.width;
+    var maxY = bounds.y + bounds.height;
+    var y = bounds.y + bounds.height;
+    for (var idx = 0, len = lines.length; idx < len; idx++) {
+        var prevRemainder = lines[idx];
+        while (prevRemainder !== undefined) {
+            var _b = splitOutLines(prevRemainder, bounds.width, font, fontSize), line = _b.line, encoded = _b.encoded, width = _b.width, remainder = _b.remainder;
+            // prettier-ignore
+            var x = (alignment$1 === alignment.TextAlignment.Left ? bounds.x
+                : alignment$1 === alignment.TextAlignment.Center ? bounds.x + (bounds.width / 2) - (width / 2)
+                    : alignment$1 === alignment.TextAlignment.Right ? bounds.x + bounds.width - width
+                        : bounds.x);
+            y -= lineHeight;
+            if (x < minX)
+                minX = x;
+            if (y < minY)
+                minY = y;
+            if (x + width > maxX)
+                maxX = x + width;
+            if (y + height > maxY)
+                maxY = y + height;
+            textLines.push({ text: line, encoded: encoded, width: width, height: height, x: x, y: y });
+            // Only trim lines that we had to split ourselves. So we won't trim lines
+            // that the user provided themselves with whitespace.
+            prevRemainder = remainder === null || remainder === void 0 ? void 0 : remainder.trim();
+        }
+    }
+    return {
+        fontSize: fontSize,
+        lineHeight: lineHeight,
+        lines: textLines,
+        bounds: {
+            x: minX,
+            y: minY,
+            width: maxX - minX,
+            height: maxY - minY,
+        },
+    };
+};
+var layoutCombedText = function (text, _a) {
+    var fontSize = _a.fontSize, font = _a.font, bounds = _a.bounds, cellCount = _a.cellCount;
+    var line = strings.mergeLines(strings.cleanText(text));
+    if (line.length > cellCount) {
+        throw new errors.CombedTextLayoutError(line.length, cellCount);
+    }
+    if (fontSize === undefined || fontSize === 0) {
+        fontSize = computeCombedFontSize(line, font, bounds, cellCount);
+    }
+    var cellWidth = bounds.width / cellCount;
+    var height = font.heightAtSize(fontSize, { descender: false });
+    var y = bounds.y + (bounds.height / 2 - height / 2);
+    var cells = [];
+    var minX = bounds.x;
+    var minY = bounds.y;
+    var maxX = bounds.x + bounds.width;
+    var maxY = bounds.y + bounds.height;
+    var cellOffset = 0;
+    var charOffset = 0;
+    while (cellOffset < cellCount) {
+        var _b = strings.charAtIndex(line, charOffset), char = _b[0], charLength = _b[1];
+        var encoded = font.encodeText(char);
+        var width = font.widthOfTextAtSize(char, fontSize);
+        var cellCenter = bounds.x + (cellWidth * cellOffset + cellWidth / 2);
+        var x = cellCenter - width / 2;
+        if (x < minX)
+            minX = x;
+        if (y < minY)
+            minY = y;
+        if (x + width > maxX)
+            maxX = x + width;
+        if (y + height > maxY)
+            maxY = y + height;
+        cells.push({ text: line, encoded: encoded, width: width, height: height, x: x, y: y });
+        cellOffset += 1;
+        charOffset += charLength;
+    }
+    return {
+        fontSize: fontSize,
+        cells: cells,
+        bounds: {
+            x: minX,
+            y: minY,
+            width: maxX - minX,
+            height: maxY - minY,
+        },
+    };
+};
+var layoutSinglelineText = function (text, _a) {
+    var alignment$1 = _a.alignment, fontSize = _a.fontSize, font = _a.font, bounds = _a.bounds;
+    var line = strings.mergeLines(strings.cleanText(text));
+    if (fontSize === undefined || fontSize === 0) {
+        fontSize = computeFontSize([line], font, bounds);
+    }
+    var encoded = font.encodeText(line);
+    var width = font.widthOfTextAtSize(line, fontSize);
+    var height = font.heightAtSize(fontSize, { descender: false });
+    // prettier-ignore
+    var x = (alignment$1 === alignment.TextAlignment.Left ? bounds.x
+        : alignment$1 === alignment.TextAlignment.Center ? bounds.x + (bounds.width / 2) - (width / 2)
+            : alignment$1 === alignment.TextAlignment.Right ? bounds.x + bounds.width - width
+                : bounds.x);
+    var y = bounds.y + (bounds.height / 2 - height / 2);
+    return {
+        fontSize: fontSize,
+        line: { text: line, encoded: encoded, width: width, height: height, x: x, y: y },
+        bounds: { x: x, y: y, width: width, height: height },
+    };
+};
+
+exports.layoutCombedText = layoutCombedText;
+exports.layoutMultilineText = layoutMultilineText;
+exports.layoutSinglelineText = layoutSinglelineText;