{"version":3,"sources":["jsdelivr-header.js","/npm/svg-path-reverse@1.7.0/reverse.js"],"names":[],"mappings":"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","file":"/npm/svg-path-reverse@1.7.0/reverse.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.37.0.\n * Original file: /npm/svg-path-reverse@1.7.0/reverse.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/**\n * https://github.com/Pomax/svg-path-reverse\n *\n * This code is in the public domain, except in jurisdictions that do\n * not recognise the public domain, where this code is MIT licensed.\n */\n(function (root, factory) {\n    if (typeof define === \"function\" && define.amd) {\n        define(factory);\n    } else if (typeof exports === \"object\") {\n        module.exports = factory();\n    } else {\n        root.SVGPathEditor = factory();\n    }\n}(this, function () {\n\n  /**\n   * Normalise an SVG path to absolute coordinates\n   * and full commands, rather than relative coordinates\n   * and/or shortcut commands.\n   */\n  function normalizePath(d) {\n    // preprocess \"d\" so that we have spaces between values\n    d = d.replace(/,/g,' ')\n         .replace(/([^eE])-/g,'$1 -')\n         .replace(/\\s*([achlmqstvzACHLMQSTVZ])\\s*/g,\" $1 \")\n         .replace(/\\s+/g, ' ')\n         .replace(/(\\d*\\.\\d+([eE]-?\\d+)?)((\\.\\d+)+)/g, (_, g1, g2, g3) => g1 + g3.replaceAll(\".\", \" .\"));\n\n    // set up the variables used in this function\n    var instructions = d.replace(/([achlmqstvzACHLMQSTVZ])\\s?/g,\"|$1\").split(\"|\"),\n        instructionLength = instructions.length,\n        i,\n        instruction,\n        op,\n        lop,\n        prevop,\n        args = [],\n        oargs = [],\n        alen,\n        a,\n        sx = 0,\n        sy = 0,\n        x = 0,\n        y = 0,\n        cx = 0,\n        cy = 0,\n        cx2 = 0,\n        cy2 = 0,\n        rx = 0,\n        ry = 0,\n        xrot = 0,\n        lflag = 0,\n        sweep = 0,\n        normalized = \"\";\n\n    // we run through the instruction list starting at 1, not 0,\n    // because we split up \"|M x y ....\" so the first element will\n    // always be an empty string. By design.\n    for (i = 1; i < instructionLength; i++) {\n\n      // which instruction is this?\n      instruction = instructions[i];\n      op = instruction.substring(0,1);\n      lop = op.toLowerCase();\n\n      // what are the arguments? note that we need to convert\n      // all strings into numbers, or + will do silly things.\n      args = instruction.replace(op,'').trim().split(' ').filter(function(v) { return v !== ''; });\n      oargs = args;\n      args = args.map(parseFloat);\n      alen = args.length;\n\n      // we could use a switch, but elaborate code in a \"case\" with\n      // fallthrough is just horrid to read. So let's use ifthen\n      // statements instead.\n\n      // moveto command (plus possible lineto)\n      if(lop === \"m\") {\n        normalized += \"M \";\n        if (op === \"m\") {\n          x += args[0];\n          y += args[1];\n        } else {\n          x = args[0];\n          y = args[1];\n        }\n        // records start position, for dealing\n        // with the shape close operator ('Z')\n        sx = x;\n        sy = y;\n        normalized += x + \" \" + y + \" \";\n        if (alen > 2) {\n          for (a = 0; a < alen; a += 2) {\n            if (op === \"m\") {\n              x += args[a];\n              y += args[a+1];\n            } else {\n              x = args[a];\n              y = args[a+1];\n            }\n            normalized += \"L \" + x + \" \" + y + \" \";\n          }\n        }\n      }\n\n      // lineto commands\n      else if(lop === \"l\") {\n        for (a = 0; a < alen; a += 2) {\n          if (op === \"l\") {\n            x += args[a];\n            y += args[a+1];\n          } else {\n            x = args[a];\n            y = args[a+1];\n          }\n          normalized += \"L \" + x + \" \" + y + \" \";\n        }\n      }\n      else if(lop === \"h\") {\n        for (a = 0; a < alen; a++) {\n          if (op === \"h\") {\n            x += args[a];\n          } else {\n            x = args[a];\n          }\n          normalized += \"L \" + x + \" \" + y + \" \";\n        }\n      }\n      else if(lop === \"v\") {\n        for (a = 0; a < alen; a++) {\n          if (op === \"v\") {\n            y += args[a];\n          } else {\n            y = args[a];\n          }\n          normalized += \"L \" + x + \" \" + y + \" \";\n        }\n      }\n\n      // quadratic curveto commands\n      else if(lop === \"q\") {\n        for (a = 0; a < alen; a += 4) {\n          if (op === \"q\") {\n            cx = x + args[a];\n            cy = y + args[a+1];\n            x += args[a+2];\n            y += args[a+3];\n          } else {\n            cx = args[a];\n            cy = args[a+1];\n            x  = args[a+2];\n            y  = args[a+3];\n          }\n          normalized += \"Q \" + cx + \" \" + cy + \" \"  + x + \" \" + y + \" \";\n        }\n      }\n      else if(lop === \"t\") {\n        for (a = 0; a < alen; a += 2) {\n          if ([\"t\", \"q\"].indexOf(prevop) > -1) {\n            // reflect previous cx/cy over x/y\n            cx = x + (x-cx);\n            cy = y + (y-cy);\n          }\n          else {\n            cx = x;\n            cy = y;\n          }\n          // then get real end point\n          if (op === \"t\") {\n            x += args[a];\n            y += args[a+1];\n          } else {\n            x  = args[a];\n            y  = args[a+1];\n          }\n          normalized += \"Q \" + cx + \" \" + cy + \" \"  + x + \" \" + y + \" \";\n          prevop = lop;\n        }\n      }\n\n      // cubic curveto commands\n      else if(lop === \"c\") {\n        for (a = 0; a < alen; a += 6) {\n          if (op === \"c\") {\n            cx  = x + args[a];\n            cy  = y + args[a+1];\n            cx2 = x + args[a+2];\n            cy2 = y + args[a+3];\n            x  += args[a+4];\n            y  += args[a+5];\n          } else {\n            cx  = args[a];\n            cy  = args[a+1];\n            cx2 = args[a+2];\n            cy2 = args[a+3];\n            x   = args[a+4]\n            y   = args[a+5];\n          }\n          normalized += \"C \" + cx + \" \" + cy + \" \" + cx2 + \" \" + cy2 + \" \"  + x + \" \" + y + \" \";\n        }\n      }\n      else if(lop === \"s\") {\n        for (a = 0; a < alen; a += 4) {\n          cx = x;\n          cy = y;\n          if ([\"s\", \"c\"].indexOf(prevop) > -1) {\n            cx += (x-cx2);\n            cy += (y-cy2);\n          }\n          // then get real control and end point\n          if (op === \"s\") {\n            cx2 = x + args[a];\n            cy2 = y + args[a+1];\n            x  += args[a+2];\n            y  += args[a+3];\n          } else {\n            cx2 = args[a];\n            cy2 = args[a+1];\n            x   = args[a+2]\n            y   = args[a+3];\n          }\n          normalized += \"C \" + cx + \" \" + cy + \" \" + cx2 + \" \" + cy2 + \" \"  + x + \" \" + y + \" \";\n        }\n      }\n\n      //   rx ry x-axis-rotation large-arc-flag sweep-flag  x   y\n      // a 25,25             -30              0,         1 50,-25\n\n      // arc command\n      else if(lop === \"a\") {\n        for (a = 0; a < alen; a += 7) {\n          rx = args[a];\n          ry = args[a+1];\n          xrot = args[a+2];\n\n          lflag = oargs[a+3]; // we need the original string to deal with leading zeroes\n          let fixed = false;\n\n          if(lflag.length > 1) {\n            let b1 = parseInt(lflag[0]),\n                b2 = parseInt(lflag[1]),\n                rest = undefined;\n            if(lflag.length > 2) rest = parseFloat(lflag.substring(2));\n            args[a+3] = b1;\n            args.splice(a+4, 0, b2);\n            oargs.splice(a+4, 0, `+`);\n            if (rest!==undefined) args.splice(a+5, 0, rest);\n            fixed = true;\n          }\n          lflag = args[a+3];\n\n          sweep = fixed ? args[a+4] : oargs[a+4]; // we need the original string to deal with leading zeroes\n          if(!fixed && sweep.length > 1) {\n            args[a+4] = parseInt(sweep[0]);\n            args.splice(a+5, 0, parseFloat(sweep.substring(1)));\n          }\n          sweep = args[a+4];\n\n          if (op === \"a\") {\n            x += args[a+5];\n            y += args[a+6];\n          } else {\n            x = args[a+5];\n            y = args[a+6];\n          }\n\n          normalized += \"A \" + rx + \" \" + ry + \" \" + xrot + \" \" + lflag + \" \" + sweep + \" \" + x + \" \" + y + \" \";\n        }\n      }\n\n      else if(lop === \"z\") {\n        normalized += \"Z \";\n        // not unimportant: path closing changes the current x/y coordinate\n        x = sx;\n        y = sy;\n      }\n\n      prevop = lop;\n    }\n    return normalized.trim();\n  };\n\n  /**\n   * Reverse an SVG path.\n   * As long as the input path is normalised, this is actually really\n   * simple to do. As all pathing commands are symmetrical, meaning\n   * that they render the same when you reverse the coordinate order,\n   * the grand trick here is to reverse the path (making sure to keep\n   * coordinates ordered pairwise) and shift the operators left by\n   * one or two coordinate pairs depending on the operator:\n   *\n   *   - Z is removed (after noting it existed),\n   *   - L moves to 2 spots earlier (skipping one coordinate),\n   *   - Q moves to 2 spots earlier (skipping one coordinate),\n   *   - C moves to 4 spots earlier (skipping two coordinates)\n   *       and its arguments get reversed,\n   *   - the path start becomes M.\n   *   - the path end becomes Z iff it was there to begin with.\n   */\n  function reverseNormalizedPath(normalized) {\n    var terms = normalized.trim().split(' '),\n        term,\n        tlen = terms.length,\n        tlen1 = tlen-1,\n        t,\n        reversed = [],\n        x, y,\n        pair, pairs,\n        shift,\n        matcher = new RegExp('[QAZLCM]',''),\n        closed = terms.slice(-1)[0].toUpperCase() === 'Z';\n\n    for (t = 0; t < tlen; t++) {\n      term = terms[t];\n\n      // Is this an operator? If it is, run through its\n      // argument list, which we know is fixed length.\n      if (matcher.test(term)) {\n\n        // Arc processing relies on not-just-coordinates\n        if (term === \"A\") {\n          reversed.push(terms[t+5] === '0' ? '1' : '0');\n          reversed.push(terms[t+4]);\n          reversed.push(terms[t+3]);\n          reversed.push(terms[t+2]);\n          reversed.push(terms[t+1]);\n          reversed.push(term);\n          reversed.push(terms[t+7]);\n          reversed.push(terms[t+6]);\n          t += 7;\n          continue;\n        }\n\n        // how many coordinate pairs do we need to read,\n        // and by how many pairs should this operator be\n        // shifted left?\n        else if (term === \"C\") { pairs = 3; shift = 2; }\n        else if (term === \"Q\") { pairs = 2; shift = 1; }\n        else if (term === \"L\") { pairs = 1; shift = 1; }\n        else if (term === \"M\") { pairs = 1; shift = 0; }\n        else { continue; }\n\n        // do the argument reading and operator shifting\n        if (pairs === shift) {\n          reversed.push(term);\n        }\n        for (pair = 0; pair < pairs; pair++) {\n          if (pair === shift) {\n            reversed.push(term);\n          }\n          x = terms[++t];\n          y = terms[++t];\n          reversed.push(y);\n          reversed.push(x);\n        }\n      }\n      // the code has been set up so that every time we\n      // iterate because of the for() operation, the term\n      // we see is a pathing operator, not a number. As\n      // such, if we get to this \"else\" the path is malformed.\n      else {\n        var pre  = terms.slice(Math.max(t-3,0),3).join(\" \");\n            post = terms.slice(t+1,Math.min(t+4,tlen1)).join(\" \");\n            range = pre + \" [\" + term + \"] \" + post;\n        throw(\"Error while trying to reverse normalized SVG path, at position \"+t+\" (\"+range+\").\\n\" +\n               \"Either the path is not normalised, or it's malformed.\"); }\n    }\n\n    reversed.push('M');\n\n    // generating the reversed path string involves\n    // running through our transformed terms in reverse.\n    var revstring = \"\", rlen1 = reversed.length-1, r;\n    for (r = rlen1; r > 0; r--) {\n      revstring += reversed[r] + \" \";\n    }\n    if (closed) revstring += \"Z\";\n    revstring = revstring.replace(/M M/g,'Z M');\n\n    return revstring;\n  };\n\n  /**\n   * This is the function that you'll actually want to\n   * make use of, because it lets you reverse individual\n   * subpaths in some <path> \"d\" attribute.\n   */\n  function reverseSubPath(path, subpath) {\n    subpath = parseInt(subpath)==subpath ? subpath : false;\n    var path = normalizePath(path),\n        paths = path.replace(/M/g,'|M').split(\"|\"),\n        revpath;\n    paths.splice(0,1);\n    if (subpath !== false && subpath >= paths.length) {\n      return path;\n    }\n\n    if (subpath === false) {\n      paths = paths.map(function(spath) {\n        return reverseNormalizedPath(spath.trim());\n      });\n    } else {\n      var spath = paths[subpath];\n      if (spath) {\n        revpath = reverseNormalizedPath(spath.trim());\n        paths[subpath] = revpath;\n      }\n    }\n\n    return paths.reverse().join(\" \").replace(/ +/g,' ').trim();\n  };\n\n  /**\n   * Our return object\n   */\n  var SVGPathEditor = {\n    normalize: normalizePath,\n    reverseNormalized: reverseNormalizedPath,\n    reverse: reverseSubPath\n  };\n\n  return SVGPathEditor;\n}));\n"]}