{"version":3,"sources":["jsdelivr-header.js","/npm/@luncheon/simplify-svg-path@0.2.0/index.iife.js"],"names":[],"mappings":"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","file":"/npm/@luncheon/simplify-svg-path@0.2.0/index.iife.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/@luncheon/simplify-svg-path@0.2.0/index.iife.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","var simplifySvgPath=(()=>{/*\n * simplify-svg-path\n *\n * The logic is a copy of Paper.js v0.12.11.\n */\n/*\n * Paper.js - The Swiss Army Knife of Vector Graphics Scripting.\n * http://paperjs.org/\n *\n * Copyright (c) 2011 - 2020, Jürg Lehni & Jonathan Puckey\n * http://juerglehni.com/ & https://puckey.studio/\n *\n * Distributed under the MIT license. See LICENSE file for details.\n *\n * All rights reserved.\n */\n// An Algorithm for Automatically Fitting Digitized Curves\n// by Philip J. Schneider\n// from \"Graphics Gems\", Academic Press, 1990\n// Modifications and optimizations of original algorithm by Jürg Lehni.\nconst EPSILON = 1e-12;\nconst MACHINE_EPSILON = 1.12e-16;\nconst isMachineZero = (val) => val >= -MACHINE_EPSILON && val <= MACHINE_EPSILON;\n// `Math.sqrt(x * x + y * y)` seems to be faster than `Math.hypot(x, y)`\nconst hypot = (x, y) => Math.sqrt(x * x + y * y);\nconst point = (x, y) => ({ x, y });\nconst pointLength = (p) => hypot(p.x, p.y);\nconst pointNegate = (p) => point(-p.x, -p.y);\nconst pointAdd = (p1, p2) => point(p1.x + p2.x, p1.y + p2.y);\nconst pointSubtract = (p1, p2) => point(p1.x - p2.x, p1.y - p2.y);\nconst pointMultiplyScalar = (p, n) => point(p.x * n, p.y * n);\nconst pointDot = (p1, p2) => p1.x * p2.x + p1.y * p2.y;\nconst pointDistance = (p1, p2) => hypot(p1.x - p2.x, p1.y - p2.y);\nconst pointNormalize = (p, length = 1) => pointMultiplyScalar(p, length / (pointLength(p) || Infinity));\nconst createSegment = (p, i) => ({ p, i });\nconst fit = (points, closed, error) => {\n    // We need to duplicate the first and last segment when simplifying a\n    // closed path.\n    if (closed) {\n        points.unshift(points[points.length - 1]);\n        points.push(points[1]); // The point previously at index 0 is now 1.\n    }\n    const length = points.length;\n    if (length === 0) {\n        return [];\n    }\n    // To support reducing paths with multiple points in the same place\n    // to one segment:\n    const segments = [createSegment(points[0])];\n    fitCubic(points, segments, error, 0, length - 1, \n    // Left Tangent\n    pointSubtract(points[1], points[0]), \n    // Right Tangent\n    pointSubtract(points[length - 2], points[length - 1]));\n    // Remove the duplicated segments for closed paths again.\n    if (closed) {\n        segments.shift();\n        segments.pop();\n    }\n    return segments;\n};\n// Fit a Bezier curve to a (sub)set of digitized points\nconst fitCubic = (points, segments, error, first, last, tan1, tan2) => {\n    //  Use heuristic if region only has two points in it\n    if (last - first === 1) {\n        const pt1 = points[first], pt2 = points[last], dist = pointDistance(pt1, pt2) / 3;\n        addCurve(segments, [pt1, pointAdd(pt1, pointNormalize(tan1, dist)), pointAdd(pt2, pointNormalize(tan2, dist)), pt2]);\n        return;\n    }\n    // Parameterize points, and attempt to fit curve\n    const uPrime = chordLengthParameterize(points, first, last);\n    let maxError = Math.max(error, error * error), split, parametersInOrder = true;\n    // Try not 4 but 5 iterations\n    for (let i = 0; i <= 4; i++) {\n        const curve = generateBezier(points, first, last, uPrime, tan1, tan2);\n        //  Find max deviation of points to fitted curve\n        const max = findMaxError(points, first, last, curve, uPrime);\n        if (max.error < error && parametersInOrder) {\n            addCurve(segments, curve);\n            return;\n        }\n        split = max.index;\n        // If error not too large, try reparameterization and iteration\n        if (max.error >= maxError)\n            break;\n        parametersInOrder = reparameterize(points, first, last, uPrime, curve);\n        maxError = max.error;\n    }\n    // Fitting failed -- split at max error point and fit recursively\n    const tanCenter = pointSubtract(points[split - 1], points[split + 1]);\n    fitCubic(points, segments, error, first, split, tan1, tanCenter);\n    fitCubic(points, segments, error, split, last, pointNegate(tanCenter), tan2);\n};\nconst addCurve = (segments, curve) => {\n    const prev = segments[segments.length - 1];\n    prev.o = pointSubtract(curve[1], curve[0]);\n    segments.push(createSegment(curve[3], pointSubtract(curve[2], curve[3])));\n};\n// Use least-squares method to find Bezier control points for region.\nconst generateBezier = (points, first, last, uPrime, tan1, tan2) => {\n    const epsilon = /*#=*/ EPSILON, abs = Math.abs, pt1 = points[first], pt2 = points[last], \n    // Create the C and X matrices\n    C = [\n        [0, 0],\n        [0, 0],\n    ], X = [0, 0];\n    for (let i = 0, l = last - first + 1; i < l; i++) {\n        const u = uPrime[i], t = 1 - u, b = 3 * u * t, b0 = t * t * t, b1 = b * t, b2 = b * u, b3 = u * u * u, a1 = pointNormalize(tan1, b1), a2 = pointNormalize(tan2, b2), tmp = pointSubtract(pointSubtract(points[first + i], pointMultiplyScalar(pt1, b0 + b1)), pointMultiplyScalar(pt2, b2 + b3));\n        C[0][0] += pointDot(a1, a1);\n        C[0][1] += pointDot(a1, a2);\n        // C[1][0] += a1.dot(a2);\n        C[1][0] = C[0][1];\n        C[1][1] += pointDot(a2, a2);\n        X[0] += pointDot(a1, tmp);\n        X[1] += pointDot(a2, tmp);\n    }\n    // Compute the determinants of C and X\n    const detC0C1 = C[0][0] * C[1][1] - C[1][0] * C[0][1];\n    let alpha1;\n    let alpha2;\n    if (abs(detC0C1) > epsilon) {\n        // Kramer's rule\n        const detC0X = C[0][0] * X[1] - C[1][0] * X[0], detXC1 = X[0] * C[1][1] - X[1] * C[0][1];\n        // Derive alpha values\n        alpha1 = detXC1 / detC0C1;\n        alpha2 = detC0X / detC0C1;\n    }\n    else {\n        // Matrix is under-determined, try assuming alpha1 == alpha2\n        const c0 = C[0][0] + C[0][1], c1 = C[1][0] + C[1][1];\n        alpha1 = alpha2 = abs(c0) > epsilon ? X[0] / c0 : abs(c1) > epsilon ? X[1] / c1 : 0;\n    }\n    // If alpha negative, use the Wu/Barsky heuristic (see text)\n    // (if alpha is 0, you get coincident control points that lead to\n    // divide by zero in any subsequent NewtonRaphsonRootFind() call.\n    const segLength = pointDistance(pt2, pt1), eps = epsilon * segLength;\n    let handle1, handle2;\n    if (alpha1 < eps || alpha2 < eps) {\n        // fall back on standard (probably inaccurate) formula,\n        // and subdivide further if needed.\n        alpha1 = alpha2 = segLength / 3;\n    }\n    else {\n        // Check if the found control points are in the right order when\n        // projected onto the line through pt1 and pt2.\n        const line = pointSubtract(pt2, pt1);\n        // Control points 1 and 2 are positioned an alpha distance out\n        // on the tangent vectors, left and right, respectively\n        handle1 = pointNormalize(tan1, alpha1);\n        handle2 = pointNormalize(tan2, alpha2);\n        if (pointDot(handle1, line) - pointDot(handle2, line) > segLength * segLength) {\n            // Fall back to the Wu/Barsky heuristic above.\n            alpha1 = alpha2 = segLength / 3;\n            handle1 = handle2 = null; // Force recalculation\n        }\n    }\n    // First and last control points of the Bezier curve are\n    // positioned exactly at the first and last data points\n    return [pt1, pointAdd(pt1, handle1 || pointNormalize(tan1, alpha1)), pointAdd(pt2, handle2 || pointNormalize(tan2, alpha2)), pt2];\n};\n// Given set of points and their parameterization, try to find\n// a better parameterization.\nconst reparameterize = (points, first, last, u, curve) => {\n    for (let i = first; i <= last; i++) {\n        u[i - first] = findRoot(curve, points[i], u[i - first]);\n    }\n    // Detect if the new parameterization has reordered the points.\n    // In that case, we would fit the points of the path in the wrong order.\n    for (let i = 1, l = u.length; i < l; i++) {\n        if (u[i] <= u[i - 1])\n            return false;\n    }\n    return true;\n};\n// Use Newton-Raphson iteration to find better root.\nconst findRoot = (curve, point, u) => {\n    const curve1 = [], curve2 = [];\n    // Generate control vertices for Q'\n    for (let i = 0; i <= 2; i++) {\n        curve1[i] = pointMultiplyScalar(pointSubtract(curve[i + 1], curve[i]), 3);\n    }\n    // Generate control vertices for Q''\n    for (let i = 0; i <= 1; i++) {\n        curve2[i] = pointMultiplyScalar(pointSubtract(curve1[i + 1], curve1[i]), 2);\n    }\n    // Compute Q(u), Q'(u) and Q''(u)\n    const pt = evaluate(3, curve, u), pt1 = evaluate(2, curve1, u), pt2 = evaluate(1, curve2, u), diff = pointSubtract(pt, point), df = pointDot(pt1, pt1) + pointDot(diff, pt2);\n    // u = u - f(u) / f'(u)\n    return isMachineZero(df) ? u : u - pointDot(diff, pt1) / df;\n};\n// Evaluate a bezier curve at a particular parameter value\nconst evaluate = (degree, curve, t) => {\n    // Copy array\n    const tmp = curve.slice();\n    // Triangle computation\n    for (let i = 1; i <= degree; i++) {\n        for (let j = 0; j <= degree - i; j++) {\n            tmp[j] = pointAdd(pointMultiplyScalar(tmp[j], 1 - t), pointMultiplyScalar(tmp[j + 1], t));\n        }\n    }\n    return tmp[0];\n};\n// Assign parameter values to digitized points\n// using relative distances between points.\nconst chordLengthParameterize = (points, first, last) => {\n    const u = [0];\n    for (let i = first + 1; i <= last; i++) {\n        u[i - first] = u[i - first - 1] + pointDistance(points[i], points[i - 1]);\n    }\n    for (let i = 1, m = last - first; i <= m; i++) {\n        u[i] /= u[m];\n    }\n    return u;\n};\n// Find the maximum squared distance of digitized points to fitted curve.\nconst findMaxError = (points, first, last, curve, u) => {\n    let index = Math.floor((last - first + 1) / 2), maxDist = 0;\n    for (let i = first + 1; i < last; i++) {\n        const P = evaluate(3, curve, u[i - first]);\n        const v = pointSubtract(P, points[i]);\n        const dist = v.x * v.x + v.y * v.y; // squared\n        if (dist >= maxDist) {\n            maxDist = dist;\n            index = i;\n        }\n    }\n    return {\n        error: maxDist,\n        index: index,\n    };\n};\nconst getSegmentsPathData = (segments, closed, precision) => {\n    const length = segments.length;\n    const precisionMultiplier = 10 ** precision;\n    const round = precision < 16 ? (n) => Math.round(n * precisionMultiplier) / precisionMultiplier : (n) => n;\n    const formatPair = (x, y) => round(x) + ',' + round(y);\n    let first = true;\n    let prevX, prevY, outX, outY;\n    const parts = [];\n    const addSegment = (segment, skipLine) => {\n        const curX = segment.p.x;\n        const curY = segment.p.y;\n        if (first) {\n            parts.push('M' + formatPair(curX, curY));\n            first = false;\n        }\n        else {\n            const inX = curX + (segment.i?.x ?? 0);\n            const inY = curY + (segment.i?.y ?? 0);\n            if (inX === curX && inY === curY && outX === prevX && outY === prevY) {\n                // l = relative lineto:\n                if (!skipLine) {\n                    const dx = curX - prevX;\n                    const dy = curY - prevY;\n                    parts.push(dx === 0 ? 'v' + round(dy) : dy === 0 ? 'h' + round(dx) : 'l' + formatPair(dx, dy));\n                }\n            }\n            else {\n                // c = relative curveto:\n                parts.push('c' +\n                    formatPair(outX - prevX, outY - prevY) +\n                    ' ' +\n                    formatPair(inX - prevX, inY - prevY) +\n                    ' ' +\n                    formatPair(curX - prevX, curY - prevY));\n            }\n        }\n        prevX = curX;\n        prevY = curY;\n        outX = curX + (segment.o?.x ?? 0);\n        outY = curY + (segment.o?.y ?? 0);\n    };\n    if (!length)\n        return '';\n    for (let i = 0; i < length; i++)\n        addSegment(segments[i]);\n    // Close path by drawing first segment again\n    if (closed && length > 0) {\n        addSegment(segments[0], true);\n        parts.push('z');\n    }\n    return parts.join('');\n};\nconst simplifySvgPath = (points, options = {}) => {\n    if (points.length === 0) {\n        return '';\n    }\n    return getSegmentsPathData(fit(points.map(typeof points[0].x === 'number' ? (p) => point(p.x, p.y) : (p) => point(p[0], p[1])), options.closed, options.tolerance ?? 2.5), options.closed, options.precision ?? 5);\n};\nreturn simplifySvgPath;\n})()"]}