@amoa/casting 0.1.2 → 0.1.4

package/dist/node_modules/next/dist/compiled/path-to-regexp/index.js

@@ -0,0 +1,439 @@
+import { __module as pathToRegexp } from '../../../../../_virtual/index2.js';
+
+var hasRequiredPathToRegexp;
+
+function requirePathToRegexp () {
+	if (hasRequiredPathToRegexp) return pathToRegexp.exports;
+	hasRequiredPathToRegexp = 1;
+	(() => {
+
+	  if (typeof __nccwpck_require__ !== "undefined") __nccwpck_require__.ab = __dirname + "/";
+	  var e = {};
+	  (() => {
+	    var n = e;
+	    Object.defineProperty(n, "__esModule", {
+	      value: true
+	    });
+	    n.pathToRegexp = n.tokensToRegexp = n.regexpToFunction = n.match = n.tokensToFunction = n.compile = n.parse = void 0;
+	    function lexer(e) {
+	      var n = [];
+	      var r = 0;
+	      while (r < e.length) {
+	        var t = e[r];
+	        if (t === "*" || t === "+" || t === "?") {
+	          n.push({
+	            type: "MODIFIER",
+	            index: r,
+	            value: e[r++]
+	          });
+	          continue;
+	        }
+	        if (t === "\\") {
+	          n.push({
+	            type: "ESCAPED_CHAR",
+	            index: r++,
+	            value: e[r++]
+	          });
+	          continue;
+	        }
+	        if (t === "{") {
+	          n.push({
+	            type: "OPEN",
+	            index: r,
+	            value: e[r++]
+	          });
+	          continue;
+	        }
+	        if (t === "}") {
+	          n.push({
+	            type: "CLOSE",
+	            index: r,
+	            value: e[r++]
+	          });
+	          continue;
+	        }
+	        if (t === ":") {
+	          var a = "";
+	          var i = r + 1;
+	          while (i < e.length) {
+	            var o = e.charCodeAt(i);
+	            if (o >= 48 && o <= 57 || o >= 65 && o <= 90 || o >= 97 && o <= 122 || o === 95) {
+	              a += e[i++];
+	              continue;
+	            }
+	            break;
+	          }
+	          if (!a) throw new TypeError("Missing parameter name at ".concat(r));
+	          n.push({
+	            type: "NAME",
+	            index: r,
+	            value: a
+	          });
+	          r = i;
+	          continue;
+	        }
+	        if (t === "(") {
+	          var c = 1;
+	          var f = "";
+	          var i = r + 1;
+	          if (e[i] === "?") {
+	            throw new TypeError('Pattern cannot start with "?" at '.concat(i));
+	          }
+	          while (i < e.length) {
+	            if (e[i] === "\\") {
+	              f += e[i++] + e[i++];
+	              continue;
+	            }
+	            if (e[i] === ")") {
+	              c--;
+	              if (c === 0) {
+	                i++;
+	                break;
+	              }
+	            } else if (e[i] === "(") {
+	              c++;
+	              if (e[i + 1] !== "?") {
+	                throw new TypeError("Capturing groups are not allowed at ".concat(i));
+	              }
+	            }
+	            f += e[i++];
+	          }
+	          if (c) throw new TypeError("Unbalanced pattern at ".concat(r));
+	          if (!f) throw new TypeError("Missing pattern at ".concat(r));
+	          n.push({
+	            type: "PATTERN",
+	            index: r,
+	            value: f
+	          });
+	          r = i;
+	          continue;
+	        }
+	        n.push({
+	          type: "CHAR",
+	          index: r,
+	          value: e[r++]
+	        });
+	      }
+	      n.push({
+	        type: "END",
+	        index: r,
+	        value: ""
+	      });
+	      return n;
+	    }
+	    function parse(e, n) {
+	      if (n === void 0) {
+	        n = {};
+	      }
+	      var r = lexer(e);
+	      var t = n.prefixes,
+	        a = t === void 0 ? "./" : t,
+	        i = n.delimiter,
+	        o = i === void 0 ? "/#?" : i;
+	      var c = [];
+	      var f = 0;
+	      var u = 0;
+	      var p = "";
+	      var tryConsume = function (e) {
+	        if (u < r.length && r[u].type === e) return r[u++].value;
+	      };
+	      var mustConsume = function (e) {
+	        var n = tryConsume(e);
+	        if (n !== undefined) return n;
+	        var t = r[u],
+	          a = t.type,
+	          i = t.index;
+	        throw new TypeError("Unexpected ".concat(a, " at ").concat(i, ", expected ").concat(e));
+	      };
+	      var consumeText = function () {
+	        var e = "";
+	        var n;
+	        while (n = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) {
+	          e += n;
+	        }
+	        return e;
+	      };
+	      var isSafe = function (e) {
+	        for (var n = 0, r = o; n < r.length; n++) {
+	          var t = r[n];
+	          if (e.indexOf(t) > -1) return true;
+	        }
+	        return false;
+	      };
+	      var safePattern = function (e) {
+	        var n = c[c.length - 1];
+	        var r = e || (n && typeof n === "string" ? n : "");
+	        if (n && !r) {
+	          throw new TypeError('Must have text between two parameters, missing text after "'.concat(n.name, '"'));
+	        }
+	        if (!r || isSafe(r)) return "[^".concat(escapeString(o), "]+?");
+	        return "(?:(?!".concat(escapeString(r), ")[^").concat(escapeString(o), "])+?");
+	      };
+	      while (u < r.length) {
+	        var v = tryConsume("CHAR");
+	        var s = tryConsume("NAME");
+	        var d = tryConsume("PATTERN");
+	        if (s || d) {
+	          var g = v || "";
+	          if (a.indexOf(g) === -1) {
+	            p += g;
+	            g = "";
+	          }
+	          if (p) {
+	            c.push(p);
+	            p = "";
+	          }
+	          c.push({
+	            name: s || f++,
+	            prefix: g,
+	            suffix: "",
+	            pattern: d || safePattern(g),
+	            modifier: tryConsume("MODIFIER") || ""
+	          });
+	          continue;
+	        }
+	        var x = v || tryConsume("ESCAPED_CHAR");
+	        if (x) {
+	          p += x;
+	          continue;
+	        }
+	        if (p) {
+	          c.push(p);
+	          p = "";
+	        }
+	        var h = tryConsume("OPEN");
+	        if (h) {
+	          var g = consumeText();
+	          var l = tryConsume("NAME") || "";
+	          var m = tryConsume("PATTERN") || "";
+	          var T = consumeText();
+	          mustConsume("CLOSE");
+	          c.push({
+	            name: l || (m ? f++ : ""),
+	            pattern: l && !m ? safePattern(g) : m,
+	            prefix: g,
+	            suffix: T,
+	            modifier: tryConsume("MODIFIER") || ""
+	          });
+	          continue;
+	        }
+	        mustConsume("END");
+	      }
+	      return c;
+	    }
+	    n.parse = parse;
+	    function compile(e, n) {
+	      return tokensToFunction(parse(e, n), n);
+	    }
+	    n.compile = compile;
+	    function tokensToFunction(e, n) {
+	      if (n === void 0) {
+	        n = {};
+	      }
+	      var r = flags(n);
+	      var t = n.encode,
+	        a = t === void 0 ? function (e) {
+	          return e;
+	        } : t,
+	        i = n.validate,
+	        o = i === void 0 ? true : i;
+	      var c = e.map(function (e) {
+	        if (typeof e === "object") {
+	          return new RegExp("^(?:".concat(e.pattern, ")$"), r);
+	        }
+	      });
+	      return function (n) {
+	        var r = "";
+	        for (var t = 0; t < e.length; t++) {
+	          var i = e[t];
+	          if (typeof i === "string") {
+	            r += i;
+	            continue;
+	          }
+	          var f = n ? n[i.name] : undefined;
+	          var u = i.modifier === "?" || i.modifier === "*";
+	          var p = i.modifier === "*" || i.modifier === "+";
+	          if (Array.isArray(f)) {
+	            if (!p) {
+	              throw new TypeError('Expected "'.concat(i.name, '" to not repeat, but got an array'));
+	            }
+	            if (f.length === 0) {
+	              if (u) continue;
+	              throw new TypeError('Expected "'.concat(i.name, '" to not be empty'));
+	            }
+	            for (var v = 0; v < f.length; v++) {
+	              var s = a(f[v], i);
+	              if (o && !c[t].test(s)) {
+	                throw new TypeError('Expected all "'.concat(i.name, '" to match "').concat(i.pattern, '", but got "').concat(s, '"'));
+	              }
+	              r += i.prefix + s + i.suffix;
+	            }
+	            continue;
+	          }
+	          if (typeof f === "string" || typeof f === "number") {
+	            var s = a(String(f), i);
+	            if (o && !c[t].test(s)) {
+	              throw new TypeError('Expected "'.concat(i.name, '" to match "').concat(i.pattern, '", but got "').concat(s, '"'));
+	            }
+	            r += i.prefix + s + i.suffix;
+	            continue;
+	          }
+	          if (u) continue;
+	          var d = p ? "an array" : "a string";
+	          throw new TypeError('Expected "'.concat(i.name, '" to be ').concat(d));
+	        }
+	        return r;
+	      };
+	    }
+	    n.tokensToFunction = tokensToFunction;
+	    function match(e, n) {
+	      var r = [];
+	      var t = pathToRegexp(e, r, n);
+	      return regexpToFunction(t, r, n);
+	    }
+	    n.match = match;
+	    function regexpToFunction(e, n, r) {
+	      if (r === void 0) {
+	        r = {};
+	      }
+	      var t = r.decode,
+	        a = t === void 0 ? function (e) {
+	          return e;
+	        } : t;
+	      return function (r) {
+	        var t = e.exec(r);
+	        if (!t) return false;
+	        var i = t[0],
+	          o = t.index;
+	        var c = Object.create(null);
+	        var _loop_1 = function (e) {
+	          if (t[e] === undefined) return "continue";
+	          var r = n[e - 1];
+	          if (r.modifier === "*" || r.modifier === "+") {
+	            c[r.name] = t[e].split(r.prefix + r.suffix).map(function (e) {
+	              return a(e, r);
+	            });
+	          } else {
+	            c[r.name] = a(t[e], r);
+	          }
+	        };
+	        for (var f = 1; f < t.length; f++) {
+	          _loop_1(f);
+	        }
+	        return {
+	          path: i,
+	          index: o,
+	          params: c
+	        };
+	      };
+	    }
+	    n.regexpToFunction = regexpToFunction;
+	    function escapeString(e) {
+	      return e.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+	    }
+	    function flags(e) {
+	      return e && e.sensitive ? "" : "i";
+	    }
+	    function regexpToRegexp(e, n) {
+	      if (!n) return e;
+	      var r = /\((?:\?<(.*?)>)?(?!\?)/g;
+	      var t = 0;
+	      var a = r.exec(e.source);
+	      while (a) {
+	        n.push({
+	          name: a[1] || t++,
+	          prefix: "",
+	          suffix: "",
+	          modifier: "",
+	          pattern: ""
+	        });
+	        a = r.exec(e.source);
+	      }
+	      return e;
+	    }
+	    function arrayToRegexp(e, n, r) {
+	      var t = e.map(function (e) {
+	        return pathToRegexp(e, n, r).source;
+	      });
+	      return new RegExp("(?:".concat(t.join("|"), ")"), flags(r));
+	    }
+	    function stringToRegexp(e, n, r) {
+	      return tokensToRegexp(parse(e, r), n, r);
+	    }
+	    function tokensToRegexp(e, n, r) {
+	      if (r === void 0) {
+	        r = {};
+	      }
+	      var t = r.strict,
+	        a = t === void 0 ? false : t,
+	        i = r.start,
+	        o = i === void 0 ? true : i,
+	        c = r.end,
+	        f = c === void 0 ? true : c,
+	        u = r.encode,
+	        p = u === void 0 ? function (e) {
+	          return e;
+	        } : u,
+	        v = r.delimiter,
+	        s = v === void 0 ? "/#?" : v,
+	        d = r.endsWith,
+	        g = d === void 0 ? "" : d;
+	      var x = "[".concat(escapeString(g), "]|$");
+	      var h = "[".concat(escapeString(s), "]");
+	      var l = o ? "^" : "";
+	      for (var m = 0, T = e; m < T.length; m++) {
+	        var E = T[m];
+	        if (typeof E === "string") {
+	          l += escapeString(p(E));
+	        } else {
+	          var w = escapeString(p(E.prefix));
+	          var y = escapeString(p(E.suffix));
+	          if (E.pattern) {
+	            if (n) n.push(E);
+	            if (w || y) {
+	              if (E.modifier === "+" || E.modifier === "*") {
+	                var R = E.modifier === "*" ? "?" : "";
+	                l += "(?:".concat(w, "((?:").concat(E.pattern, ")(?:").concat(y).concat(w, "(?:").concat(E.pattern, "))*)").concat(y, ")").concat(R);
+	              } else {
+	                l += "(?:".concat(w, "(").concat(E.pattern, ")").concat(y, ")").concat(E.modifier);
+	              }
+	            } else {
+	              if (E.modifier === "+" || E.modifier === "*") {
+	                throw new TypeError('Can not repeat "'.concat(E.name, '" without a prefix and suffix'));
+	              }
+	              l += "(".concat(E.pattern, ")").concat(E.modifier);
+	            }
+	          } else {
+	            l += "(?:".concat(w).concat(y, ")").concat(E.modifier);
+	          }
+	        }
+	      }
+	      if (f) {
+	        if (!a) l += "".concat(h, "?");
+	        l += !r.endsWith ? "$" : "(?=".concat(x, ")");
+	      } else {
+	        var A = e[e.length - 1];
+	        var _ = typeof A === "string" ? h.indexOf(A[A.length - 1]) > -1 : A === undefined;
+	        if (!a) {
+	          l += "(?:".concat(h, "(?=").concat(x, "))?");
+	        }
+	        if (!_) {
+	          l += "(?=".concat(h, "|").concat(x, ")");
+	        }
+	      }
+	      return new RegExp(l, flags(r));
+	    }
+	    n.tokensToRegexp = tokensToRegexp;
+	    function pathToRegexp(e, n, r) {
+	      if (e instanceof RegExp) return regexpToRegexp(e, n);
+	      if (Array.isArray(e)) return arrayToRegexp(e, n, r);
+	      return stringToRegexp(e, n, r);
+	    }
+	    n.pathToRegexp = pathToRegexp;
+	  })();
+	  pathToRegexp.exports = e;
+	})();
+	return pathToRegexp.exports;
+}
+
+export { requirePathToRegexp as __require };