@slicemachine/init 0.1.1-dev-plugins.13 → 0.1.1-dev-plugins-validation.1

package/dist/__node_modules/spdx-license-ids/index.json.js

@@ -1,471 +0,0 @@
-const require$$1 = [
-  "0BSD",
-  "AAL",
-  "ADSL",
-  "AFL-1.1",
-  "AFL-1.2",
-  "AFL-2.0",
-  "AFL-2.1",
-  "AFL-3.0",
-  "AGPL-1.0-only",
-  "AGPL-1.0-or-later",
-  "AGPL-3.0-only",
-  "AGPL-3.0-or-later",
-  "AMDPLPA",
-  "AML",
-  "AMPAS",
-  "ANTLR-PD",
-  "ANTLR-PD-fallback",
-  "APAFML",
-  "APL-1.0",
-  "APSL-1.0",
-  "APSL-1.1",
-  "APSL-1.2",
-  "APSL-2.0",
-  "Abstyles",
-  "Adobe-2006",
-  "Adobe-Glyph",
-  "Afmparse",
-  "Aladdin",
-  "Apache-1.0",
-  "Apache-1.1",
-  "Apache-2.0",
-  "App-s2p",
-  "Arphic-1999",
-  "Artistic-1.0",
-  "Artistic-1.0-Perl",
-  "Artistic-1.0-cl8",
-  "Artistic-2.0",
-  "BSD-1-Clause",
-  "BSD-2-Clause",
-  "BSD-2-Clause-Patent",
-  "BSD-2-Clause-Views",
-  "BSD-3-Clause",
-  "BSD-3-Clause-Attribution",
-  "BSD-3-Clause-Clear",
-  "BSD-3-Clause-LBNL",
-  "BSD-3-Clause-Modification",
-  "BSD-3-Clause-No-Military-License",
-  "BSD-3-Clause-No-Nuclear-License",
-  "BSD-3-Clause-No-Nuclear-License-2014",
-  "BSD-3-Clause-No-Nuclear-Warranty",
-  "BSD-3-Clause-Open-MPI",
-  "BSD-4-Clause",
-  "BSD-4-Clause-Shortened",
-  "BSD-4-Clause-UC",
-  "BSD-Protection",
-  "BSD-Source-Code",
-  "BSL-1.0",
-  "BUSL-1.1",
-  "Baekmuk",
-  "Bahyph",
-  "Barr",
-  "Beerware",
-  "BitTorrent-1.0",
-  "BitTorrent-1.1",
-  "Bitstream-Vera",
-  "BlueOak-1.0.0",
-  "Borceux",
-  "C-UDA-1.0",
-  "CAL-1.0",
-  "CAL-1.0-Combined-Work-Exception",
-  "CATOSL-1.1",
-  "CC-BY-1.0",
-  "CC-BY-2.0",
-  "CC-BY-2.5",
-  "CC-BY-2.5-AU",
-  "CC-BY-3.0",
-  "CC-BY-3.0-AT",
-  "CC-BY-3.0-DE",
-  "CC-BY-3.0-IGO",
-  "CC-BY-3.0-NL",
-  "CC-BY-3.0-US",
-  "CC-BY-4.0",
-  "CC-BY-NC-1.0",
-  "CC-BY-NC-2.0",
-  "CC-BY-NC-2.5",
-  "CC-BY-NC-3.0",
-  "CC-BY-NC-3.0-DE",
-  "CC-BY-NC-4.0",
-  "CC-BY-NC-ND-1.0",
-  "CC-BY-NC-ND-2.0",
-  "CC-BY-NC-ND-2.5",
-  "CC-BY-NC-ND-3.0",
-  "CC-BY-NC-ND-3.0-DE",
-  "CC-BY-NC-ND-3.0-IGO",
-  "CC-BY-NC-ND-4.0",
-  "CC-BY-NC-SA-1.0",
-  "CC-BY-NC-SA-2.0",
-  "CC-BY-NC-SA-2.0-FR",
-  "CC-BY-NC-SA-2.0-UK",
-  "CC-BY-NC-SA-2.5",
-  "CC-BY-NC-SA-3.0",
-  "CC-BY-NC-SA-3.0-DE",
-  "CC-BY-NC-SA-3.0-IGO",
-  "CC-BY-NC-SA-4.0",
-  "CC-BY-ND-1.0",
-  "CC-BY-ND-2.0",
-  "CC-BY-ND-2.5",
-  "CC-BY-ND-3.0",
-  "CC-BY-ND-3.0-DE",
-  "CC-BY-ND-4.0",
-  "CC-BY-SA-1.0",
-  "CC-BY-SA-2.0",
-  "CC-BY-SA-2.0-UK",
-  "CC-BY-SA-2.1-JP",
-  "CC-BY-SA-2.5",
-  "CC-BY-SA-3.0",
-  "CC-BY-SA-3.0-AT",
-  "CC-BY-SA-3.0-DE",
-  "CC-BY-SA-4.0",
-  "CC-PDDC",
-  "CC0-1.0",
-  "CDDL-1.0",
-  "CDDL-1.1",
-  "CDL-1.0",
-  "CDLA-Permissive-1.0",
-  "CDLA-Permissive-2.0",
-  "CDLA-Sharing-1.0",
-  "CECILL-1.0",
-  "CECILL-1.1",
-  "CECILL-2.0",
-  "CECILL-2.1",
-  "CECILL-B",
-  "CECILL-C",
-  "CERN-OHL-1.1",
-  "CERN-OHL-1.2",
-  "CERN-OHL-P-2.0",
-  "CERN-OHL-S-2.0",
-  "CERN-OHL-W-2.0",
-  "CNRI-Jython",
-  "CNRI-Python",
-  "CNRI-Python-GPL-Compatible",
-  "COIL-1.0",
-  "CPAL-1.0",
-  "CPL-1.0",
-  "CPOL-1.02",
-  "CUA-OPL-1.0",
-  "Caldera",
-  "ClArtistic",
-  "Community-Spec-1.0",
-  "Condor-1.1",
-  "Crossword",
-  "CrystalStacker",
-  "Cube",
-  "D-FSL-1.0",
-  "DL-DE-BY-2.0",
-  "DOC",
-  "DRL-1.0",
-  "DSDP",
-  "Dotseqn",
-  "ECL-1.0",
-  "ECL-2.0",
-  "EFL-1.0",
-  "EFL-2.0",
-  "EPICS",
-  "EPL-1.0",
-  "EPL-2.0",
-  "EUDatagrid",
-  "EUPL-1.0",
-  "EUPL-1.1",
-  "EUPL-1.2",
-  "Elastic-2.0",
-  "Entessa",
-  "ErlPL-1.1",
-  "Eurosym",
-  "FDK-AAC",
-  "FSFAP",
-  "FSFUL",
-  "FSFULLR",
-  "FTL",
-  "Fair",
-  "Frameworx-1.0",
-  "FreeBSD-DOC",
-  "FreeImage",
-  "GD",
-  "GFDL-1.1-invariants-only",
-  "GFDL-1.1-invariants-or-later",
-  "GFDL-1.1-no-invariants-only",
-  "GFDL-1.1-no-invariants-or-later",
-  "GFDL-1.1-only",
-  "GFDL-1.1-or-later",
-  "GFDL-1.2-invariants-only",
-  "GFDL-1.2-invariants-or-later",
-  "GFDL-1.2-no-invariants-only",
-  "GFDL-1.2-no-invariants-or-later",
-  "GFDL-1.2-only",
-  "GFDL-1.2-or-later",
-  "GFDL-1.3-invariants-only",
-  "GFDL-1.3-invariants-or-later",
-  "GFDL-1.3-no-invariants-only",
-  "GFDL-1.3-no-invariants-or-later",
-  "GFDL-1.3-only",
-  "GFDL-1.3-or-later",
-  "GL2PS",
-  "GLWTPL",
-  "GPL-1.0-only",
-  "GPL-1.0-or-later",
-  "GPL-2.0-only",
-  "GPL-2.0-or-later",
-  "GPL-3.0-only",
-  "GPL-3.0-or-later",
-  "Giftware",
-  "Glide",
-  "Glulxe",
-  "HPND",
-  "HPND-sell-variant",
-  "HTMLTIDY",
-  "HaskellReport",
-  "Hippocratic-2.1",
-  "IBM-pibs",
-  "ICU",
-  "IJG",
-  "IPA",
-  "IPL-1.0",
-  "ISC",
-  "ImageMagick",
-  "Imlib2",
-  "Info-ZIP",
-  "Intel",
-  "Intel-ACPI",
-  "Interbase-1.0",
-  "JPNIC",
-  "JSON",
-  "Jam",
-  "JasPer-2.0",
-  "LAL-1.2",
-  "LAL-1.3",
-  "LGPL-2.0-only",
-  "LGPL-2.0-or-later",
-  "LGPL-2.1-only",
-  "LGPL-2.1-or-later",
-  "LGPL-3.0-only",
-  "LGPL-3.0-or-later",
-  "LGPLLR",
-  "LPL-1.0",
-  "LPL-1.02",
-  "LPPL-1.0",
-  "LPPL-1.1",
-  "LPPL-1.2",
-  "LPPL-1.3a",
-  "LPPL-1.3c",
-  "LZMA-SDK-9.11-to-9.20",
-  "LZMA-SDK-9.22",
-  "Latex2e",
-  "Leptonica",
-  "LiLiQ-P-1.1",
-  "LiLiQ-R-1.1",
-  "LiLiQ-Rplus-1.1",
-  "Libpng",
-  "Linux-OpenIB",
-  "Linux-man-pages-copyleft",
-  "MIT",
-  "MIT-0",
-  "MIT-CMU",
-  "MIT-Modern-Variant",
-  "MIT-advertising",
-  "MIT-enna",
-  "MIT-feh",
-  "MIT-open-group",
-  "MITNFA",
-  "MPL-1.0",
-  "MPL-1.1",
-  "MPL-2.0",
-  "MPL-2.0-no-copyleft-exception",
-  "MS-LPL",
-  "MS-PL",
-  "MS-RL",
-  "MTLL",
-  "MakeIndex",
-  "Minpack",
-  "MirOS",
-  "Motosoto",
-  "MulanPSL-1.0",
-  "MulanPSL-2.0",
-  "Multics",
-  "Mup",
-  "NAIST-2003",
-  "NASA-1.3",
-  "NBPL-1.0",
-  "NCGL-UK-2.0",
-  "NCSA",
-  "NGPL",
-  "NICTA-1.0",
-  "NIST-PD",
-  "NIST-PD-fallback",
-  "NLOD-1.0",
-  "NLOD-2.0",
-  "NLPL",
-  "NOSL",
-  "NPL-1.0",
-  "NPL-1.1",
-  "NPOSL-3.0",
-  "NRL",
-  "NTP",
-  "NTP-0",
-  "Naumen",
-  "Net-SNMP",
-  "NetCDF",
-  "Newsletr",
-  "Nokia",
-  "Noweb",
-  "O-UDA-1.0",
-  "OCCT-PL",
-  "OCLC-2.0",
-  "ODC-By-1.0",
-  "ODbL-1.0",
-  "OFL-1.0",
-  "OFL-1.0-RFN",
-  "OFL-1.0-no-RFN",
-  "OFL-1.1",
-  "OFL-1.1-RFN",
-  "OFL-1.1-no-RFN",
-  "OGC-1.0",
-  "OGDL-Taiwan-1.0",
-  "OGL-Canada-2.0",
-  "OGL-UK-1.0",
-  "OGL-UK-2.0",
-  "OGL-UK-3.0",
-  "OGTSL",
-  "OLDAP-1.1",
-  "OLDAP-1.2",
-  "OLDAP-1.3",
-  "OLDAP-1.4",
-  "OLDAP-2.0",
-  "OLDAP-2.0.1",
-  "OLDAP-2.1",
-  "OLDAP-2.2",
-  "OLDAP-2.2.1",
-  "OLDAP-2.2.2",
-  "OLDAP-2.3",
-  "OLDAP-2.4",
-  "OLDAP-2.5",
-  "OLDAP-2.6",
-  "OLDAP-2.7",
-  "OLDAP-2.8",
-  "OML",
-  "OPL-1.0",
-  "OPUBL-1.0",
-  "OSET-PL-2.1",
-  "OSL-1.0",
-  "OSL-1.1",
-  "OSL-2.0",
-  "OSL-2.1",
-  "OSL-3.0",
-  "OpenSSL",
-  "PDDL-1.0",
-  "PHP-3.0",
-  "PHP-3.01",
-  "PSF-2.0",
-  "Parity-6.0.0",
-  "Parity-7.0.0",
-  "Plexus",
-  "PolyForm-Noncommercial-1.0.0",
-  "PolyForm-Small-Business-1.0.0",
-  "PostgreSQL",
-  "Python-2.0",
-  "Python-2.0.1",
-  "QPL-1.0",
-  "Qhull",
-  "RHeCos-1.1",
-  "RPL-1.1",
-  "RPL-1.5",
-  "RPSL-1.0",
-  "RSA-MD",
-  "RSCPL",
-  "Rdisc",
-  "Ruby",
-  "SAX-PD",
-  "SCEA",
-  "SGI-B-1.0",
-  "SGI-B-1.1",
-  "SGI-B-2.0",
-  "SHL-0.5",
-  "SHL-0.51",
-  "SISSL",
-  "SISSL-1.2",
-  "SMLNJ",
-  "SMPPL",
-  "SNIA",
-  "SPL-1.0",
-  "SSH-OpenSSH",
-  "SSH-short",
-  "SSPL-1.0",
-  "SWL",
-  "Saxpath",
-  "SchemeReport",
-  "Sendmail",
-  "Sendmail-8.23",
-  "SimPL-2.0",
-  "Sleepycat",
-  "Spencer-86",
-  "Spencer-94",
-  "Spencer-99",
-  "SugarCRM-1.1.3",
-  "TAPR-OHL-1.0",
-  "TCL",
-  "TCP-wrappers",
-  "TMate",
-  "TORQUE-1.1",
-  "TOSL",
-  "TU-Berlin-1.0",
-  "TU-Berlin-2.0",
-  "UCL-1.0",
-  "UPL-1.0",
-  "Unicode-DFS-2015",
-  "Unicode-DFS-2016",
-  "Unicode-TOU",
-  "Unlicense",
-  "VOSTROM",
-  "VSL-1.0",
-  "Vim",
-  "W3C",
-  "W3C-19980720",
-  "W3C-20150513",
-  "WTFPL",
-  "Watcom-1.0",
-  "Wsuipa",
-  "X11",
-  "X11-distribute-modifications-variant",
-  "XFree86-1.1",
-  "XSkat",
-  "Xerox",
-  "Xnet",
-  "YPL-1.0",
-  "YPL-1.1",
-  "ZPL-1.1",
-  "ZPL-2.0",
-  "ZPL-2.1",
-  "Zed",
-  "Zend-2.0",
-  "Zimbra-1.3",
-  "Zimbra-1.4",
-  "Zlib",
-  "blessing",
-  "bzip2-1.0.6",
-  "copyleft-next-0.3.0",
-  "copyleft-next-0.3.1",
-  "curl",
-  "diffmark",
-  "dvipdfm",
-  "eGenix",
-  "etalab-2.0",
-  "gSOAP-1.3b",
-  "gnuplot",
-  "iMatix",
-  "libpng-2.0",
-  "libselinux-1.0",
-  "libtiff",
-  "mpi-permissive",
-  "mpich2",
-  "mplus",
-  "psfrag",
-  "psutils",
-  "xinetd",
-  "xpp",
-  "zlib-acknowledgement"
-];
-export {
-  require$$1 as default
-};
-//# sourceMappingURL=index.json.js.map

package/dist/__node_modules/spdx-license-ids/index.json.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/__node_modules/to-regex-range/index.cjs

@@ -1,215 +0,0 @@
-"use strict";
-const index = require("../is-number/index.cjs");
-/*!
- * to-regex-range <https://github.com/micromatch/to-regex-range>
- *
- * Copyright (c) 2015-present, Jon Schlinkert.
- * Released under the MIT License.
- */
-const isNumber = index;
-const toRegexRange = (min, max, options) => {
-  if (isNumber(min) === false) {
-    throw new TypeError("toRegexRange: expected the first argument to be a number");
-  }
-  if (max === void 0 || min === max) {
-    return String(min);
-  }
-  if (isNumber(max) === false) {
-    throw new TypeError("toRegexRange: expected the second argument to be a number.");
-  }
-  let opts = { relaxZeros: true, ...options };
-  if (typeof opts.strictZeros === "boolean") {
-    opts.relaxZeros = opts.strictZeros === false;
-  }
-  let relax = String(opts.relaxZeros);
-  let shorthand = String(opts.shorthand);
-  let capture = String(opts.capture);
-  let wrap = String(opts.wrap);
-  let cacheKey = min + ":" + max + "=" + relax + shorthand + capture + wrap;
-  if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
-    return toRegexRange.cache[cacheKey].result;
-  }
-  let a = Math.min(min, max);
-  let b = Math.max(min, max);
-  if (Math.abs(a - b) === 1) {
-    let result = min + "|" + max;
-    if (opts.capture) {
-      return `(${result})`;
-    }
-    if (opts.wrap === false) {
-      return result;
-    }
-    return `(?:${result})`;
-  }
-  let isPadded = hasPadding(min) || hasPadding(max);
-  let state = { min, max, a, b };
-  let positives = [];
-  let negatives = [];
-  if (isPadded) {
-    state.isPadded = isPadded;
-    state.maxLen = String(state.max).length;
-  }
-  if (a < 0) {
-    let newMin = b < 0 ? Math.abs(b) : 1;
-    negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
-    a = state.a = 0;
-  }
-  if (b >= 0) {
-    positives = splitToPatterns(a, b, state, opts);
-  }
-  state.negatives = negatives;
-  state.positives = positives;
-  state.result = collatePatterns(negatives, positives);
-  if (opts.capture === true) {
-    state.result = `(${state.result})`;
-  } else if (opts.wrap !== false && positives.length + negatives.length > 1) {
-    state.result = `(?:${state.result})`;
-  }
-  toRegexRange.cache[cacheKey] = state;
-  return state.result;
-};
-function collatePatterns(neg, pos, options) {
-  let onlyNegative = filterPatterns(neg, pos, "-", false) || [];
-  let onlyPositive = filterPatterns(pos, neg, "", false) || [];
-  let intersected = filterPatterns(neg, pos, "-?", true) || [];
-  let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
-  return subpatterns.join("|");
-}
-function splitToRanges(min, max) {
-  let nines = 1;
-  let zeros = 1;
-  let stop = countNines(min, nines);
-  let stops = /* @__PURE__ */ new Set([max]);
-  while (min <= stop && stop <= max) {
-    stops.add(stop);
-    nines += 1;
-    stop = countNines(min, nines);
-  }
-  stop = countZeros(max + 1, zeros) - 1;
-  while (min < stop && stop <= max) {
-    stops.add(stop);
-    zeros += 1;
-    stop = countZeros(max + 1, zeros) - 1;
-  }
-  stops = [...stops];
-  stops.sort(compare);
-  return stops;
-}
-function rangeToPattern(start, stop, options) {
-  if (start === stop) {
-    return { pattern: start, count: [], digits: 0 };
-  }
-  let zipped = zip(start, stop);
-  let digits = zipped.length;
-  let pattern = "";
-  let count = 0;
-  for (let i = 0; i < digits; i++) {
-    let [startDigit, stopDigit] = zipped[i];
-    if (startDigit === stopDigit) {
-      pattern += startDigit;
-    } else if (startDigit !== "0" || stopDigit !== "9") {
-      pattern += toCharacterClass(startDigit, stopDigit);
-    } else {
-      count++;
-    }
-  }
-  if (count) {
-    pattern += options.shorthand === true ? "\\d" : "[0-9]";
-  }
-  return { pattern, count: [count], digits };
-}
-function splitToPatterns(min, max, tok, options) {
-  let ranges = splitToRanges(min, max);
-  let tokens = [];
-  let start = min;
-  let prev;
-  for (let i = 0; i < ranges.length; i++) {
-    let max2 = ranges[i];
-    let obj = rangeToPattern(String(start), String(max2), options);
-    let zeros = "";
-    if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
-      if (prev.count.length > 1) {
-        prev.count.pop();
-      }
-      prev.count.push(obj.count[0]);
-      prev.string = prev.pattern + toQuantifier(prev.count);
-      start = max2 + 1;
-      continue;
-    }
-    if (tok.isPadded) {
-      zeros = padZeros(max2, tok, options);
-    }
-    obj.string = zeros + obj.pattern + toQuantifier(obj.count);
-    tokens.push(obj);
-    start = max2 + 1;
-    prev = obj;
-  }
-  return tokens;
-}
-function filterPatterns(arr, comparison, prefix, intersection, options) {
-  let result = [];
-  for (let ele of arr) {
-    let { string } = ele;
-    if (!intersection && !contains(comparison, "string", string)) {
-      result.push(prefix + string);
-    }
-    if (intersection && contains(comparison, "string", string)) {
-      result.push(prefix + string);
-    }
-  }
-  return result;
-}
-function zip(a, b) {
-  let arr = [];
-  for (let i = 0; i < a.length; i++)
-    arr.push([a[i], b[i]]);
-  return arr;
-}
-function compare(a, b) {
-  return a > b ? 1 : b > a ? -1 : 0;
-}
-function contains(arr, key, val) {
-  return arr.some((ele) => ele[key] === val);
-}
-function countNines(min, len) {
-  return Number(String(min).slice(0, -len) + "9".repeat(len));
-}
-function countZeros(integer, zeros) {
-  return integer - integer % Math.pow(10, zeros);
-}
-function toQuantifier(digits) {
-  let [start = 0, stop = ""] = digits;
-  if (stop || start > 1) {
-    return `{${start + (stop ? "," + stop : "")}}`;
-  }
-  return "";
-}
-function toCharacterClass(a, b, options) {
-  return `[${a}${b - a === 1 ? "" : "-"}${b}]`;
-}
-function hasPadding(str) {
-  return /^-?(0+)\d/.test(str);
-}
-function padZeros(value, tok, options) {
-  if (!tok.isPadded) {
-    return value;
-  }
-  let diff = Math.abs(tok.maxLen - String(value).length);
-  let relax = options.relaxZeros !== false;
-  switch (diff) {
-    case 0:
-      return "";
-    case 1:
-      return relax ? "0?" : "0";
-    case 2:
-      return relax ? "0{0,2}" : "00";
-    default: {
-      return relax ? `0{0,${diff}}` : `0{${diff}}`;
-    }
-  }
-}
-toRegexRange.cache = {};
-toRegexRange.clearCache = () => toRegexRange.cache = {};
-var toRegexRange_1 = toRegexRange;
-module.exports = toRegexRange_1;
-//# sourceMappingURL=index.cjs.map

package/dist/__node_modules/to-regex-range/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","sources":["../../../../../node_modules/to-regex-range/index.js"],"sourcesContent":["/*!\n * to-regex-range <https://github.com/micromatch/to-regex-range>\n *\n * Copyright (c) 2015-present, Jon Schlinkert.\n * Released under the MIT License.\n */\n\n'use strict';\n\nconst isNumber = require('is-number');\n\nconst toRegexRange = (min, max, options) => {\n  if (isNumber(min) === false) {\n    throw new TypeError('toRegexRange: expected the first argument to be a number');\n  }\n\n  if (max === void 0 || min === max) {\n    return String(min);\n  }\n\n  if (isNumber(max) === false) {\n    throw new TypeError('toRegexRange: expected the second argument to be a number.');\n  }\n\n  let opts = { relaxZeros: true, ...options };\n  if (typeof opts.strictZeros === 'boolean') {\n    opts.relaxZeros = opts.strictZeros === false;\n  }\n\n  let relax = String(opts.relaxZeros);\n  let shorthand = String(opts.shorthand);\n  let capture = String(opts.capture);\n  let wrap = String(opts.wrap);\n  let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;\n\n  if (toRegexRange.cache.hasOwnProperty(cacheKey)) {\n    return toRegexRange.cache[cacheKey].result;\n  }\n\n  let a = Math.min(min, max);\n  let b = Math.max(min, max);\n\n  if (Math.abs(a - b) === 1) {\n    let result = min + '|' + max;\n    if (opts.capture) {\n      return `(${result})`;\n    }\n    if (opts.wrap === false) {\n      return result;\n    }\n    return `(?:${result})`;\n  }\n\n  let isPadded = hasPadding(min) || hasPadding(max);\n  let state = { min, max, a, b };\n  let positives = [];\n  let negatives = [];\n\n  if (isPadded) {\n    state.isPadded = isPadded;\n    state.maxLen = String(state.max).length;\n  }\n\n  if (a < 0) {\n    let newMin = b < 0 ? Math.abs(b) : 1;\n    negatives = splitToPatterns(newMin, Math.abs(a), state, opts);\n    a = state.a = 0;\n  }\n\n  if (b >= 0) {\n    positives = splitToPatterns(a, b, state, opts);\n  }\n\n  state.negatives = negatives;\n  state.positives = positives;\n  state.result = collatePatterns(negatives, positives, opts);\n\n  if (opts.capture === true) {\n    state.result = `(${state.result})`;\n  } else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {\n    state.result = `(?:${state.result})`;\n  }\n\n  toRegexRange.cache[cacheKey] = state;\n  return state.result;\n};\n\nfunction collatePatterns(neg, pos, options) {\n  let onlyNegative = filterPatterns(neg, pos, '-', false, options) || [];\n  let onlyPositive = filterPatterns(pos, neg, '', false, options) || [];\n  let intersected = filterPatterns(neg, pos, '-?', true, options) || [];\n  let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);\n  return subpatterns.join('|');\n}\n\nfunction splitToRanges(min, max) {\n  let nines = 1;\n  let zeros = 1;\n\n  let stop = countNines(min, nines);\n  let stops = new Set([max]);\n\n  while (min <= stop && stop <= max) {\n    stops.add(stop);\n    nines += 1;\n    stop = countNines(min, nines);\n  }\n\n  stop = countZeros(max + 1, zeros) - 1;\n\n  while (min < stop && stop <= max) {\n    stops.add(stop);\n    zeros += 1;\n    stop = countZeros(max + 1, zeros) - 1;\n  }\n\n  stops = [...stops];\n  stops.sort(compare);\n  return stops;\n}\n\n/**\n * Convert a range to a regex pattern\n * @param {Number} `start`\n * @param {Number} `stop`\n * @return {String}\n */\n\nfunction rangeToPattern(start, stop, options) {\n  if (start === stop) {\n    return { pattern: start, count: [], digits: 0 };\n  }\n\n  let zipped = zip(start, stop);\n  let digits = zipped.length;\n  let pattern = '';\n  let count = 0;\n\n  for (let i = 0; i < digits; i++) {\n    let [startDigit, stopDigit] = zipped[i];\n\n    if (startDigit === stopDigit) {\n      pattern += startDigit;\n\n    } else if (startDigit !== '0' || stopDigit !== '9') {\n      pattern += toCharacterClass(startDigit, stopDigit, options);\n\n    } else {\n      count++;\n    }\n  }\n\n  if (count) {\n    pattern += options.shorthand === true ? '\\\\d' : '[0-9]';\n  }\n\n  return { pattern, count: [count], digits };\n}\n\nfunction splitToPatterns(min, max, tok, options) {\n  let ranges = splitToRanges(min, max);\n  let tokens = [];\n  let start = min;\n  let prev;\n\n  for (let i = 0; i < ranges.length; i++) {\n    let max = ranges[i];\n    let obj = rangeToPattern(String(start), String(max), options);\n    let zeros = '';\n\n    if (!tok.isPadded && prev && prev.pattern === obj.pattern) {\n      if (prev.count.length > 1) {\n        prev.count.pop();\n      }\n\n      prev.count.push(obj.count[0]);\n      prev.string = prev.pattern + toQuantifier(prev.count);\n      start = max + 1;\n      continue;\n    }\n\n    if (tok.isPadded) {\n      zeros = padZeros(max, tok, options);\n    }\n\n    obj.string = zeros + obj.pattern + toQuantifier(obj.count);\n    tokens.push(obj);\n    start = max + 1;\n    prev = obj;\n  }\n\n  return tokens;\n}\n\nfunction filterPatterns(arr, comparison, prefix, intersection, options) {\n  let result = [];\n\n  for (let ele of arr) {\n    let { string } = ele;\n\n    // only push if _both_ are negative...\n    if (!intersection && !contains(comparison, 'string', string)) {\n      result.push(prefix + string);\n    }\n\n    // or _both_ are positive\n    if (intersection && contains(comparison, 'string', string)) {\n      result.push(prefix + string);\n    }\n  }\n  return result;\n}\n\n/**\n * Zip strings\n */\n\nfunction zip(a, b) {\n  let arr = [];\n  for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);\n  return arr;\n}\n\nfunction compare(a, b) {\n  return a > b ? 1 : b > a ? -1 : 0;\n}\n\nfunction contains(arr, key, val) {\n  return arr.some(ele => ele[key] === val);\n}\n\nfunction countNines(min, len) {\n  return Number(String(min).slice(0, -len) + '9'.repeat(len));\n}\n\nfunction countZeros(integer, zeros) {\n  return integer - (integer % Math.pow(10, zeros));\n}\n\nfunction toQuantifier(digits) {\n  let [start = 0, stop = ''] = digits;\n  if (stop || start > 1) {\n    return `{${start + (stop ? ',' + stop : '')}}`;\n  }\n  return '';\n}\n\nfunction toCharacterClass(a, b, options) {\n  return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;\n}\n\nfunction hasPadding(str) {\n  return /^-?(0+)\\d/.test(str);\n}\n\nfunction padZeros(value, tok, options) {\n  if (!tok.isPadded) {\n    return value;\n  }\n\n  let diff = Math.abs(tok.maxLen - String(value).length);\n  let relax = options.relaxZeros !== false;\n\n  switch (diff) {\n    case 0:\n      return '';\n    case 1:\n      return relax ? '0?' : '0';\n    case 2:\n      return relax ? '0{0,2}' : '00';\n    default: {\n      return relax ? `0{0,${diff}}` : `0{${diff}}`;\n    }\n  }\n}\n\n/**\n * Cache\n */\n\ntoRegexRange.cache = {};\ntoRegexRange.clearCache = () => (toRegexRange.cache = {});\n\n/**\n * Expose `toRegexRange`\n */\n\nmodule.exports = toRegexRange;\n"],"names":["require$$0","max"],"mappings":"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"}