@tsed/platform-serverless 6.88.1 → 6.89.0

package/lib/index-eeb85309.js

@@ -1,2354 +0,0 @@
-var assert = require('assert');
-var http = require('http');
-var index$1 = require('./index-a7574150.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
-var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
-
-var UTF8_ACCEPT = 12;
-var UTF8_REJECT = 0;
-var UTF8_DATA = [// The first part of the table maps bytes to character to a transition.
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 7, 7, 10, 9, 9, 9, 11, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, // The second part of the table maps a state to a new state when adding a
-// transition.
-0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 24, 36, 48, 60, 72, 84, 96, 0, 12, 12, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 24, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 48, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // The third part maps the current transition to a mask that needs to apply
-// to the byte.
-0x7F, 0x3F, 0x3F, 0x3F, 0x00, 0x1F, 0x0F, 0x0F, 0x0F, 0x07, 0x07, 0x07];
-
-function decodeURIComponent(uri) {
-  var percentPosition = uri.indexOf('%');
-  if (percentPosition === -1) return uri;
-  var length = uri.length;
-  var decoded = '';
-  var last = 0;
-  var codepoint = 0;
-  var startOfOctets = percentPosition;
-  var state = UTF8_ACCEPT;
-
-  while (percentPosition > -1 && percentPosition < length) {
-    var high = hexCodeToInt(uri[percentPosition + 1], 4);
-    var low = hexCodeToInt(uri[percentPosition + 2], 0);
-    var byte = high | low;
-    var type = UTF8_DATA[byte];
-    state = UTF8_DATA[256 + state + type];
-    codepoint = codepoint << 6 | byte & UTF8_DATA[364 + type];
-
-    if (state === UTF8_ACCEPT) {
-      decoded += uri.slice(last, startOfOctets);
-      decoded += codepoint <= 0xFFFF ? String.fromCharCode(codepoint) : String.fromCharCode(0xD7C0 + (codepoint >> 10), 0xDC00 + (codepoint & 0x3FF));
-      codepoint = 0;
-      last = percentPosition + 3;
-      percentPosition = startOfOctets = uri.indexOf('%', last);
-    } else if (state === UTF8_REJECT) {
-      return null;
-    } else {
-      percentPosition += 3;
-      if (percentPosition < length && uri.charCodeAt(percentPosition) === 37) continue;
-      return null;
-    }
-  }
-
-  return decoded + uri.slice(last);
-}
-
-var HEX = {
-  '0': 0,
-  '1': 1,
-  '2': 2,
-  '3': 3,
-  '4': 4,
-  '5': 5,
-  '6': 6,
-  '7': 7,
-  '8': 8,
-  '9': 9,
-  'a': 10,
-  'A': 10,
-  'b': 11,
-  'B': 11,
-  'c': 12,
-  'C': 12,
-  'd': 13,
-  'D': 13,
-  'e': 14,
-  'E': 14,
-  'f': 15,
-  'F': 15
-};
-
-function hexCodeToInt(c, shift) {
-  var i = HEX[c];
-  return i === undefined ? 255 : i << shift;
-}
-
-var fastDecodeUriComponent = decodeURIComponent;
-
-function createCommonjsModule(fn) {
-  var module = { exports: {} };
-	return fn(module, module.exports), module.exports;
-}
-
-var types$2 = {
-  ROOT: 0,
-  GROUP: 1,
-  POSITION: 2,
-  SET: 3,
-  RANGE: 4,
-  REPETITION: 5,
-  REFERENCE: 6,
-  CHAR: 7
-};
-
-const INTS = () => [{
-  type: types$2.RANGE,
-  from: 48,
-  to: 57
-}];
-
-const WORDS = () => {
-  return [{
-    type: types$2.CHAR,
-    value: 95
-  }, {
-    type: types$2.RANGE,
-    from: 97,
-    to: 122
-  }, {
-    type: types$2.RANGE,
-    from: 65,
-    to: 90
-  }].concat(INTS());
-};
-
-const WHITESPACE = () => {
-  return [{
-    type: types$2.CHAR,
-    value: 9
-  }, {
-    type: types$2.CHAR,
-    value: 10
-  }, {
-    type: types$2.CHAR,
-    value: 11
-  }, {
-    type: types$2.CHAR,
-    value: 12
-  }, {
-    type: types$2.CHAR,
-    value: 13
-  }, {
-    type: types$2.CHAR,
-    value: 32
-  }, {
-    type: types$2.CHAR,
-    value: 160
-  }, {
-    type: types$2.CHAR,
-    value: 5760
-  }, {
-    type: types$2.RANGE,
-    from: 8192,
-    to: 8202
-  }, {
-    type: types$2.CHAR,
-    value: 8232
-  }, {
-    type: types$2.CHAR,
-    value: 8233
-  }, {
-    type: types$2.CHAR,
-    value: 8239
-  }, {
-    type: types$2.CHAR,
-    value: 8287
-  }, {
-    type: types$2.CHAR,
-    value: 12288
-  }, {
-    type: types$2.CHAR,
-    value: 65279
-  }];
-};
-
-const NOTANYCHAR = () => {
-  return [{
-    type: types$2.CHAR,
-    value: 10
-  }, {
-    type: types$2.CHAR,
-    value: 13
-  }, {
-    type: types$2.CHAR,
-    value: 8232
-  }, {
-    type: types$2.CHAR,
-    value: 8233
-  }];
-}; // Predefined class objects.
-
-
-var words = () => ({
-  type: types$2.SET,
-  set: WORDS(),
-  not: false
-});
-
-var notWords = () => ({
-  type: types$2.SET,
-  set: WORDS(),
-  not: true
-});
-
-var ints = () => ({
-  type: types$2.SET,
-  set: INTS(),
-  not: false
-});
-
-var notInts = () => ({
-  type: types$2.SET,
-  set: INTS(),
-  not: true
-});
-
-var whitespace = () => ({
-  type: types$2.SET,
-  set: WHITESPACE(),
-  not: false
-});
-
-var notWhitespace = () => ({
-  type: types$2.SET,
-  set: WHITESPACE(),
-  not: true
-});
-
-var anyChar = () => ({
-  type: types$2.SET,
-  set: NOTANYCHAR(),
-  not: true
-});
-
-var sets = {
-  words: words,
-  notWords: notWords,
-  ints: ints,
-  notInts: notInts,
-  whitespace: whitespace,
-  notWhitespace: notWhitespace,
-  anyChar: anyChar
-};
-
-var util = createCommonjsModule(function (module, exports) {
-  const CTRL = '@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^ ?';
-  const SLSH = {
-    '0': 0,
-    't': 9,
-    'n': 10,
-    'v': 11,
-    'f': 12,
-    'r': 13
-  };
-  /**
-   * Finds character representations in str and convert all to
-   * their respective characters
-   *
-   * @param {String} str
-   * @return {String}
-   */
-
-  exports.strToChars = function (str) {
-    /* jshint maxlen: false */
-    var chars_regex = /(\[\\b\])|(\\)?\\(?:u([A-F0-9]{4})|x([A-F0-9]{2})|(0?[0-7]{2})|c([@A-Z[\\\]^?])|([0tnvfr]))/g;
-    str = str.replace(chars_regex, function (s, b, lbs, a16, b16, c8, dctrl, eslsh) {
-      if (lbs) {
-        return s;
-      }
-
-      var code = b ? 8 : a16 ? parseInt(a16, 16) : b16 ? parseInt(b16, 16) : c8 ? parseInt(c8, 8) : dctrl ? CTRL.indexOf(dctrl) : SLSH[eslsh];
-      var c = String.fromCharCode(code); // Escape special regex characters.
-
-      if (/[[\]{}^$.|?*+()]/.test(c)) {
-        c = '\\' + c;
-      }
-
-      return c;
-    });
-    return str;
-  };
-  /**
-   * turns class into tokens
-   * reads str until it encounters a ] not preceeded by a \
-   *
-   * @param {String} str
-   * @param {String} regexpStr
-   * @return {Array.<Array.<Object>, Number>}
-   */
-
-
-  exports.tokenizeClass = (str, regexpStr) => {
-    /* jshint maxlen: false */
-    var tokens = [];
-    var regexp = /\\(?:(w)|(d)|(s)|(W)|(D)|(S))|((?:(?:\\)(.)|([^\]\\]))-(?:\\)?([^\]]))|(\])|(?:\\)?([^])/g;
-    var rs, c;
-
-    while ((rs = regexp.exec(str)) != null) {
-      if (rs[1]) {
-        tokens.push(sets.words());
-      } else if (rs[2]) {
-        tokens.push(sets.ints());
-      } else if (rs[3]) {
-        tokens.push(sets.whitespace());
-      } else if (rs[4]) {
-        tokens.push(sets.notWords());
-      } else if (rs[5]) {
-        tokens.push(sets.notInts());
-      } else if (rs[6]) {
-        tokens.push(sets.notWhitespace());
-      } else if (rs[7]) {
-        tokens.push({
-          type: types$2.RANGE,
-          from: (rs[8] || rs[9]).charCodeAt(0),
-          to: rs[10].charCodeAt(0)
-        });
-      } else if (c = rs[12]) {
-        tokens.push({
-          type: types$2.CHAR,
-          value: c.charCodeAt(0)
-        });
-      } else {
-        return [tokens, regexp.lastIndex];
-      }
-    }
-
-    exports.error(regexpStr, 'Unterminated character class');
-  };
-  /**
-   * Shortcut to throw errors.
-   *
-   * @param {String} regexp
-   * @param {String} msg
-   */
-
-
-  exports.error = (regexp, msg) => {
-    throw new SyntaxError('Invalid regular expression: /' + regexp + '/: ' + msg);
-  };
-});
-
-var wordBoundary = () => ({
-  type: types$2.POSITION,
-  value: 'b'
-});
-
-var nonWordBoundary = () => ({
-  type: types$2.POSITION,
-  value: 'B'
-});
-
-var begin = () => ({
-  type: types$2.POSITION,
-  value: '^'
-});
-
-var end = () => ({
-  type: types$2.POSITION,
-  value: '$'
-});
-
-var positions = {
-  wordBoundary: wordBoundary,
-  nonWordBoundary: nonWordBoundary,
-  begin: begin,
-  end: end
-};
-
-var lib = regexpStr => {
-  var i = 0,
-      l,
-      c,
-      start = {
-    type: types$2.ROOT,
-    stack: []
-  },
-      // Keep track of last clause/group and stack.
-  lastGroup = start,
-      last = start.stack,
-      groupStack = [];
-
-  var repeatErr = i => {
-    util.error(regexpStr, `Nothing to repeat at column ${i - 1}`);
-  }; // Decode a few escaped characters.
-
-
-  var str = util.strToChars(regexpStr);
-  l = str.length; // Iterate through each character in string.
-
-  while (i < l) {
-    c = str[i++];
-
-    switch (c) {
-      // Handle escaped characters, inclues a few sets.
-      case '\\':
-        c = str[i++];
-
-        switch (c) {
-          case 'b':
-            last.push(positions.wordBoundary());
-            break;
-
-          case 'B':
-            last.push(positions.nonWordBoundary());
-            break;
-
-          case 'w':
-            last.push(sets.words());
-            break;
-
-          case 'W':
-            last.push(sets.notWords());
-            break;
-
-          case 'd':
-            last.push(sets.ints());
-            break;
-
-          case 'D':
-            last.push(sets.notInts());
-            break;
-
-          case 's':
-            last.push(sets.whitespace());
-            break;
-
-          case 'S':
-            last.push(sets.notWhitespace());
-            break;
-
-          default:
-            // Check if c is integer.
-            // In which case it's a reference.
-            if (/\d/.test(c)) {
-              last.push({
-                type: types$2.REFERENCE,
-                value: parseInt(c, 10)
-              }); // Escaped character.
-            } else {
-              last.push({
-                type: types$2.CHAR,
-                value: c.charCodeAt(0)
-              });
-            }
-
-        }
-
-        break;
-      // Positionals.
-
-      case '^':
-        last.push(positions.begin());
-        break;
-
-      case '$':
-        last.push(positions.end());
-        break;
-      // Handle custom sets.
-
-      case '[':
-        // Check if this class is 'anti' i.e. [^abc].
-        var not;
-
-        if (str[i] === '^') {
-          not = true;
-          i++;
-        } else {
-          not = false;
-        } // Get all the characters in class.
-
-
-        var classTokens = util.tokenizeClass(str.slice(i), regexpStr); // Increase index by length of class.
-
-        i += classTokens[1];
-        last.push({
-          type: types$2.SET,
-          set: classTokens[0],
-          not
-        });
-        break;
-      // Class of any character except \n.
-
-      case '.':
-        last.push(sets.anyChar());
-        break;
-      // Push group onto stack.
-
-      case '(':
-        // Create group.
-        var group = {
-          type: types$2.GROUP,
-          stack: [],
-          remember: true
-        };
-        c = str[i]; // If if this is a special kind of group.
-
-        if (c === '?') {
-          c = str[i + 1];
-          i += 2; // Match if followed by.
-
-          if (c === '=') {
-            group.followedBy = true; // Match if not followed by.
-          } else if (c === '!') {
-            group.notFollowedBy = true;
-          } else if (c !== ':') {
-            util.error(regexpStr, `Invalid group, character '${c}'` + ` after '?' at column ${i - 1}`);
-          }
-
-          group.remember = false;
-        } // Insert subgroup into current group stack.
-
-
-        last.push(group); // Remember the current group for when the group closes.
-
-        groupStack.push(lastGroup); // Make this new group the current group.
-
-        lastGroup = group;
-        last = group.stack;
-        break;
-      // Pop group out of stack.
-
-      case ')':
-        if (groupStack.length === 0) {
-          util.error(regexpStr, `Unmatched ) at column ${i - 1}`);
-        }
-
-        lastGroup = groupStack.pop(); // Check if this group has a PIPE.
-        // To get back the correct last stack.
-
-        last = lastGroup.options ? lastGroup.options[lastGroup.options.length - 1] : lastGroup.stack;
-        break;
-      // Use pipe character to give more choices.
-
-      case '|':
-        // Create array where options are if this is the first PIPE
-        // in this clause.
-        if (!lastGroup.options) {
-          lastGroup.options = [lastGroup.stack];
-          delete lastGroup.stack;
-        } // Create a new stack and add to options for rest of clause.
-
-
-        var stack = [];
-        lastGroup.options.push(stack);
-        last = stack;
-        break;
-      // Repetition.
-      // For every repetition, remove last element from last stack
-      // then insert back a RANGE object.
-      // This design is chosen because there could be more than
-      // one repetition symbols in a regex i.e. `a?+{2,3}`.
-
-      case '{':
-        var rs = /^(\d+)(,(\d+)?)?\}/.exec(str.slice(i)),
-            min,
-            max;
-
-        if (rs !== null) {
-          if (last.length === 0) {
-            repeatErr(i);
-          }
-
-          min = parseInt(rs[1], 10);
-          max = rs[2] ? rs[3] ? parseInt(rs[3], 10) : Infinity : min;
-          i += rs[0].length;
-          last.push({
-            type: types$2.REPETITION,
-            min,
-            max,
-            value: last.pop()
-          });
-        } else {
-          last.push({
-            type: types$2.CHAR,
-            value: 123
-          });
-        }
-
-        break;
-
-      case '?':
-        if (last.length === 0) {
-          repeatErr(i);
-        }
-
-        last.push({
-          type: types$2.REPETITION,
-          min: 0,
-          max: 1,
-          value: last.pop()
-        });
-        break;
-
-      case '+':
-        if (last.length === 0) {
-          repeatErr(i);
-        }
-
-        last.push({
-          type: types$2.REPETITION,
-          min: 1,
-          max: Infinity,
-          value: last.pop()
-        });
-        break;
-
-      case '*':
-        if (last.length === 0) {
-          repeatErr(i);
-        }
-
-        last.push({
-          type: types$2.REPETITION,
-          min: 0,
-          max: Infinity,
-          value: last.pop()
-        });
-        break;
-      // Default is a character that is not `\[](){}?+*^$`.
-
-      default:
-        last.push({
-          type: types$2.CHAR,
-          value: c.charCodeAt(0)
-        });
-    }
-  } // Check if any groups have not been closed.
-
-
-  if (groupStack.length !== 0) {
-    util.error(regexpStr, 'Unterminated group');
-  }
-
-  return start;
-};
-
-var types_1 = types$2;
-lib.types = types_1;
-
-var types$1 = lib.types;
-
-var safeRegex2 = function (re, opts) {
-  if (!opts) opts = {};
-  var replimit = opts.limit === undefined ? 25 : opts.limit;
-  if (isRegExp(re)) re = re.source;else if (typeof re !== 'string') re = String(re);
-
-  try {
-    re = lib(re);
-  } catch (err) {
-    return false;
-  }
-
-  var reps = 0;
-  return function walk(node, starHeight) {
-    var i;
-    var ok;
-    var len;
-
-    if (node.type === types$1.REPETITION) {
-      starHeight++;
-      reps++;
-      if (starHeight > 1) return false;
-      if (reps > replimit) return false;
-    }
-
-    if (node.options) {
-      for (i = 0, len = node.options.length; i < len; i++) {
-        ok = walk({
-          stack: node.options[i]
-        }, starHeight);
-        if (!ok) return false;
-      }
-    }
-
-    var stack = node.stack || node.value && node.value.stack;
-    if (!stack) return true;
-
-    for (i = 0; i < stack.length; i++) {
-      ok = walk(stack[i], starHeight);
-      if (!ok) return false;
-    }
-
-    return true;
-  }(re, 0);
-};
-
-function isRegExp(x) {
-  return {}.toString.call(x) === '[object RegExp]';
-}
-
-const indent = '    ';
-const branchIndent = '│   ';
-const midBranchIndent = '├── ';
-const endBranchIndent = '└── ';
-const wildcardDelimiter = '*';
-const pathDelimiter = '/';
-const pathRegExp = /(?=\/)/;
-/* eslint-enable */
-
-function prettyPrintRoutesArray$1(routeArray) {
-  const mergedRouteArray = [];
-  let tree = '';
-  routeArray.sort((a, b) => {
-    if (!a.path || !b.path) return 0;
-    return a.path.localeCompare(b.path);
-  }); // merge alike paths
-
-  for (let i = 0; i < routeArray.length; i++) {
-    const route = routeArray[i];
-    const pathExists = mergedRouteArray.find(r => route.path === r.path);
-
-    if (pathExists) {
-      // path already declared, add new method and break out of loop
-      pathExists.handlers.push({
-        method: route.method,
-        opts: route.opts.constraints || undefined
-      });
-      continue;
-    }
-
-    const routeHandler = {
-      method: route.method,
-      opts: route.opts.constraints || undefined
-    };
-    mergedRouteArray.push({
-      path: route.path,
-      methods: [route.method],
-      opts: [route.opts],
-      handlers: [routeHandler],
-      parents: [],
-      branchLevel: 1
-    });
-  } // insert root level path if none defined
-
-
-  if (!mergedRouteArray.filter(r => r.path === pathDelimiter).length) {
-    const rootPath = {
-      path: pathDelimiter,
-      truncatedPath: '',
-      methods: [],
-      opts: [],
-      handlers: [{}],
-      parents: [pathDelimiter]
-    }; // if wildcard route exists, insert root level after wildcard
-
-    if (mergedRouteArray.filter(r => r.path === wildcardDelimiter).length) {
-      mergedRouteArray.splice(1, 0, rootPath);
-    } else {
-      mergedRouteArray.unshift(rootPath);
-    }
-  } // build tree
-
-
-  const routeTree = buildRouteTree(mergedRouteArray); // draw tree
-
-  routeTree.forEach((rootBranch, idx) => {
-    tree += drawBranch(rootBranch, null, idx === routeTree.length - 1, false, true);
-    tree += '\n'; // newline characters inserted at beginning of drawing function to allow for nested paths
-  });
-  return tree;
-}
-
-function buildRouteTree(mergedRouteArray, rootPath) {
-  const result = [];
-  const temp = {
-    result
-  };
-  mergedRouteArray.forEach((route, idx) => {
-    let splitPath = route.path.split(pathRegExp); // add preceding slash for proper nesting
-
-    if (splitPath[0] !== pathDelimiter) {
-      // handle wildcard route
-      if (splitPath[0] !== wildcardDelimiter) splitPath = [pathDelimiter, splitPath[0].slice(1), ...splitPath.slice(1)];
-    } // build tree
-
-
-    splitPath.reduce((acc, path, pidx) => {
-      if (!acc[path]) {
-        acc[path] = {
-          result: []
-        };
-        const pathSeg = {
-          path,
-          children: acc[path].result
-        };
-        if (pidx === splitPath.length - 1) pathSeg.handlers = route.handlers;
-        acc.result.push(pathSeg);
-      }
-
-      return acc[path];
-    }, temp);
-  }); // unfold root object from array
-
-  return result;
-}
-
-function drawBranch(pathSeg, prefix, endBranch, noPrefix, rootBranch) {
-  let branch = '';
-  if (!noPrefix && !rootBranch) branch += '\n';
-  if (!noPrefix) branch += `${prefix || ''}${endBranch ? endBranchIndent : midBranchIndent}`;
-  branch += `${pathSeg.path}`;
-
-  if (pathSeg.handlers) {
-    const flatHandlers = pathSeg.handlers.reduce((acc, curr) => {
-      const match = acc.findIndex(h => JSON.stringify(h.opts) === JSON.stringify(curr.opts));
-
-      if (match !== -1) {
-        acc[match].method = [acc[match].method, curr.method].join(', ');
-      } else {
-        acc.push(curr);
-      }
-
-      return acc;
-    }, []);
-    flatHandlers.forEach((handler, idx) => {
-      if (idx > 0) branch += `${noPrefix ? '' : prefix}${endBranch ? indent : branchIndent}${pathSeg.path}`;
-      branch += ` (${handler.method || '-'})`;
-      if (handler.opts && JSON.stringify(handler.opts) !== '{}') branch += ` ${JSON.stringify(handler.opts)}`;
-      if (flatHandlers.length > 1 && idx !== flatHandlers.length - 1) branch += '\n';
-    });
-  }
-
-  if (!noPrefix) prefix = `${prefix || ''}${endBranch ? indent : branchIndent}`;
-  pathSeg.children.forEach((child, idx) => {
-    const endBranch = idx === pathSeg.children.length - 1;
-    const skipPrefix = !pathSeg.handlers && pathSeg.children.length === 1;
-    branch += drawBranch(child, prefix, endBranch, skipPrefix);
-  });
-  return branch;
-}
-
-function prettyPrintFlattenedNode$1(flattenedNode, prefix, tail) {
-  let paramName = '';
-  const printHandlers = [];
-
-  for (const node of flattenedNode.nodes) {
-    for (const handler of node.handlers) {
-      printHandlers.push(index$1._extends({
-        method: node.method
-      }, handler));
-    }
-  }
-
-  if (printHandlers.length) {
-    printHandlers.forEach((handler, index) => {
-      let suffix = `(${handler.method || '-'})`;
-
-      if (Object.keys(handler.constraints).length > 0) {
-        suffix += ' ' + JSON.stringify(handler.constraints);
-      }
-
-      let name = ''; // find locations of parameters in prefix
-
-      const paramIndices = flattenedNode.prefix.split('').map((ch, idx) => ch === ':' ? idx : null).filter(idx => idx !== null);
-
-      if (paramIndices.length) {
-        let prevLoc = 0;
-        paramIndices.forEach((loc, idx) => {
-          // find parameter in prefix
-          name += flattenedNode.prefix.slice(prevLoc, loc + 1); // insert parameters
-
-          name += handler.params[handler.params.length - paramIndices.length + idx];
-          if (idx === paramIndices.length - 1) name += flattenedNode.prefix.slice(loc + 1);
-          prevLoc = loc + 1;
-        });
-      } else {
-        // there are no parameters, return full object
-        name = flattenedNode.prefix;
-      }
-
-      if (index === 0) {
-        paramName += `${name} ${suffix}`;
-        return;
-      } else {
-        paramName += '\n';
-      }
-
-      paramName += `${prefix}${tail ? indent : branchIndent}${name} ${suffix}`;
-    });
-  } else {
-    paramName = flattenedNode.prefix;
-  }
-
-  let tree = `${prefix}${tail ? endBranchIndent : midBranchIndent}${paramName}\n`;
-  prefix = `${prefix}${tail ? indent : branchIndent}`;
-  const labels = Object.keys(flattenedNode.children);
-
-  for (let i = 0; i < labels.length; i++) {
-    const child = flattenedNode.children[labels[i]];
-    tree += prettyPrintFlattenedNode$1(child, prefix, i === labels.length - 1);
-  }
-
-  return tree;
-}
-
-function flattenNode$1(flattened, node) {
-  if (node.handlers.length > 0) {
-    flattened.nodes.push(node);
-  }
-
-  if (node.children) {
-    for (const child of Object.values(node.children)) {
-      // split on the slash separator but use a regex to lookahead and not actually match it, preserving it in the returned string segments
-      const childPrefixSegments = child.prefix.split(pathRegExp);
-      let cursor = flattened;
-      let parent;
-
-      for (const segment of childPrefixSegments) {
-        parent = cursor;
-        cursor = cursor.children[segment];
-
-        if (!cursor) {
-          cursor = {
-            prefix: segment,
-            nodes: [],
-            children: {}
-          };
-          parent.children[segment] = cursor;
-        }
-      }
-
-      flattenNode$1(cursor, child);
-    }
-  }
-}
-
-function compressFlattenedNode$1(flattenedNode) {
-  const childKeys = Object.keys(flattenedNode.children);
-
-  if (flattenedNode.nodes.length === 0 && childKeys.length === 1) {
-    const child = flattenedNode.children[childKeys[0]];
-
-    if (child.nodes.length <= 1) {
-      compressFlattenedNode$1(child);
-      flattenedNode.nodes = child.nodes;
-      flattenedNode.prefix += child.prefix;
-      flattenedNode.children = child.children;
-      return flattenedNode;
-    }
-  }
-
-  for (const key of Object.keys(flattenedNode.children)) {
-    compressFlattenedNode$1(flattenedNode.children[key]);
-  }
-
-  return flattenedNode;
-}
-
-var prettyPrint = {
-  flattenNode: flattenNode$1,
-  compressFlattenedNode: compressFlattenedNode$1,
-  prettyPrintFlattenedNode: prettyPrintFlattenedNode$1,
-  prettyPrintRoutesArray: prettyPrintRoutesArray$1
-};
-
-var fastDeepEqual = function equal(a, b) {
-  if (a === b) return true;
-
-  if (a && b && typeof a == 'object' && typeof b == 'object') {
-    if (a.constructor !== b.constructor) return false;
-    var length, i, keys;
-
-    if (Array.isArray(a)) {
-      length = a.length;
-      if (length != b.length) return false;
-
-      for (i = length; i-- !== 0;) if (!equal(a[i], b[i])) return false;
-
-      return true;
-    }
-
-    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
-    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
-    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
-    keys = Object.keys(a);
-    length = keys.length;
-    if (length !== Object.keys(b).length) return false;
-
-    for (i = length; i-- !== 0;) if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
-
-    for (i = length; i-- !== 0;) {
-      var key = keys[i];
-      if (!equal(a[key], b[key])) return false;
-    }
-
-    return true;
-  } // true if both NaN, false otherwise
-
-
-  return a !== a && b !== b;
-};
-
-const types = {
-  STATIC: 0,
-  PARAM: 1,
-  MATCH_ALL: 2,
-  REGEX: 3,
-  // It's used for a parameter, that is followed by another parameter in the same part
-  MULTI_PARAM: 4
-};
-
-function Node$1(options) {
-  options = options || {};
-  this.prefix = options.prefix || '/';
-  this.label = this.prefix[0];
-  this.method = options.method; // not used for logic, just for debugging and pretty printing
-
-  this.handlers = options.handlers || []; // unoptimized list of handler objects for which the fast matcher function will be compiled
-
-  this.unconstrainedHandler = options.unconstrainedHandler || null; // optimized reference to the handler that will match most of the time
-
-  this.children = options.children || {};
-  this.numberOfChildren = Object.keys(this.children).length;
-  this.kind = options.kind || this.types.STATIC;
-  this.regex = options.regex || null;
-  this.wildcardChild = null;
-  this.parametricBrother = null;
-  this.constrainer = options.constrainer;
-  this.hasConstraints = options.hasConstraints;
-  this.constrainedHandlerStores = null;
-}
-
-Object.defineProperty(Node$1.prototype, 'types', {
-  value: types
-});
-
-Node$1.prototype.getLabel = function () {
-  return this.prefix[0];
-};
-
-Node$1.prototype.addChild = function (node) {
-  var label = '';
-
-  switch (node.kind) {
-    case this.types.STATIC:
-      label = node.getLabel();
-      break;
-
-    case this.types.PARAM:
-    case this.types.REGEX:
-    case this.types.MULTI_PARAM:
-      label = ':';
-      break;
-
-    case this.types.MATCH_ALL:
-      this.wildcardChild = node;
-      label = '*';
-      break;
-
-    default:
-      throw new Error(`Unknown node kind: ${node.kind}`);
-  }
-
-  assert__default['default'](this.children[label] === undefined, `There is already a child with label '${label}'`);
-  this.children[label] = node;
-  this.numberOfChildren = Object.keys(this.children).length;
-  const labels = Object.keys(this.children);
-  var parametricBrother = this.parametricBrother;
-
-  for (var i = 0; i < labels.length; i++) {
-    const child = this.children[labels[i]];
-
-    if (child.label === ':') {
-      parametricBrother = child;
-      break;
-    }
-  } // Save the parametric brother inside static children
-
-
-  const iterate = node => {
-    if (!node) {
-      return;
-    }
-
-    if (node.kind !== this.types.STATIC) {
-      return;
-    }
-
-    if (node !== this) {
-      node.parametricBrother = parametricBrother || node.parametricBrother;
-    }
-
-    const labels = Object.keys(node.children);
-
-    for (var i = 0; i < labels.length; i++) {
-      iterate(node.children[labels[i]]);
-    }
-  };
-
-  iterate(this);
-  return this;
-};
-
-Node$1.prototype.reset = function (prefix) {
-  this.prefix = prefix;
-  this.children = {};
-  this.handlers = [];
-  this.unconstrainedHandler = null;
-  this.kind = this.types.STATIC;
-  this.numberOfChildren = 0;
-  this.regex = null;
-  this.wildcardChild = null;
-  this.hasConstraints = false;
-
-  this._decompileGetHandlerMatchingConstraints();
-
-  return this;
-};
-
-Node$1.prototype.split = function (length) {
-  const newChild = new Node$1({
-    prefix: this.prefix.slice(length),
-    children: this.children,
-    kind: this.kind,
-    method: this.method,
-    handlers: this.handlers.slice(0),
-    regex: this.regex,
-    constrainer: this.constrainer,
-    hasConstraints: this.hasConstraints,
-    unconstrainedHandler: this.unconstrainedHandler
-  });
-
-  if (this.wildcardChild !== null) {
-    newChild.wildcardChild = this.wildcardChild;
-  }
-
-  this.reset(this.prefix.slice(0, length));
-  this.addChild(newChild);
-  return newChild;
-};
-
-Node$1.prototype.findByLabel = function (path) {
-  return this.children[path[0]];
-};
-
-Node$1.prototype.findMatchingChild = function (derivedConstraints, path) {
-  var child = this.children[path[0]];
-
-  if (child !== undefined && (child.numberOfChildren > 0 || child.getMatchingHandler(derivedConstraints) !== null)) {
-    if (path.slice(0, child.prefix.length) === child.prefix) {
-      return child;
-    }
-  }
-
-  child = this.children[':'];
-
-  if (child !== undefined && (child.numberOfChildren > 0 || child.getMatchingHandler(derivedConstraints) !== null)) {
-    return child;
-  }
-
-  child = this.children['*'];
-
-  if (child !== undefined && (child.numberOfChildren > 0 || child.getMatchingHandler(derivedConstraints) !== null)) {
-    return child;
-  }
-
-  return null;
-};
-
-Node$1.prototype.addHandler = function (handler, params, store, constraints) {
-  if (!handler) return;
-  assert__default['default'](!this.getHandler(constraints), `There is already a handler with constraints '${JSON.stringify(constraints)}' and method '${this.method}'`);
-  const handlerObject = {
-    handler: handler,
-    params: params,
-    constraints: constraints,
-    store: store || null,
-    paramsLength: params.length
-  };
-  this.handlers.push(handlerObject); // Sort the most constrained handlers to the front of the list of handlers so they are tested first.
-
-  this.handlers.sort((a, b) => Object.keys(a.constraints).length - Object.keys(b.constraints).length);
-
-  if (Object.keys(constraints).length > 0) {
-    this.hasConstraints = true;
-  } else {
-    this.unconstrainedHandler = handlerObject;
-  }
-
-  if (this.hasConstraints && this.handlers.length > 32) {
-    throw new Error('find-my-way supports a maximum of 32 route handlers per node when there are constraints, limit reached');
-  } // Note that the fancy constraint handler matcher needs to be recompiled now that the list of handlers has changed
-  // This lazy compilation means we don't do the compile until the first time the route match is tried, which doesn't waste time re-compiling every time a new handler is added
-
-
-  this._decompileGetHandlerMatchingConstraints();
-};
-
-Node$1.prototype.getHandler = function (constraints) {
-  return this.handlers.filter(handler => fastDeepEqual(constraints, handler.constraints))[0];
-}; // We compile the handler matcher the first time this node is matched. We need to recompile it if new handlers are added, so when a new handler is added, we reset the handler matching function to this base one that will recompile it.
-
-
-function compileThenGetHandlerMatchingConstraints(derivedConstraints) {
-  this._compileGetHandlerMatchingConstraints();
-
-  return this._getHandlerMatchingConstraints(derivedConstraints);
-} // This is the hot path for node handler finding -- change with care!
-
-
-Node$1.prototype.getMatchingHandler = function (derivedConstraints) {
-  if (this.hasConstraints) {
-    // This node is constrained, use the performant precompiled constraint matcher
-    return this._getHandlerMatchingConstraints(derivedConstraints);
-  } else {
-    // This node doesn't have any handlers that are constrained, so it's handlers probably match. Some requests have constraint values that *must* match however, like version, so check for those before returning it.
-    if (derivedConstraints && derivedConstraints.__hasMustMatchValues) {
-      return null;
-    } else {
-      return this.unconstrainedHandler;
-    }
-  }
-}; // Slot for the compiled constraint matching function
-
-
-Node$1.prototype._getHandlerMatchingConstraints = compileThenGetHandlerMatchingConstraints;
-
-Node$1.prototype._decompileGetHandlerMatchingConstraints = function () {
-  this._getHandlerMatchingConstraints = compileThenGetHandlerMatchingConstraints;
-  return null;
-}; // Builds a store object that maps from constraint values to a bitmap of handler indexes which pass the constraint for a value
-// So for a host constraint, this might look like { "fastify.io": 0b0010, "google.ca": 0b0101 }, meaning the 3rd handler is constrainted to fastify.io, and the 2nd and 4th handlers are constrained to google.ca.
-// The store's implementation comes from the strategies provided to the Router.
-
-
-Node$1.prototype._buildConstraintStore = function (constraint) {
-  const store = this.constrainer.newStoreForConstraint(constraint);
-
-  for (let i = 0; i < this.handlers.length; i++) {
-    const handler = this.handlers[i];
-    const mustMatchValue = handler.constraints[constraint];
-
-    if (typeof mustMatchValue !== 'undefined') {
-      let indexes = store.get(mustMatchValue);
-
-      if (!indexes) {
-        indexes = 0;
-      }
-
-      indexes |= 1 << i; // set the i-th bit for the mask because this handler is constrained by this value https://stackoverflow.com/questions/1436438/how-do-you-set-clear-and-toggle-a-single-bit-in-javascrip
-
-      store.set(mustMatchValue, indexes);
-    }
-  }
-
-  return store;
-}; // Builds a bitmask for a given constraint that has a bit for each handler index that is 0 when that handler *is* constrained and 1 when the handler *isnt* constrainted. This is opposite to what might be obvious, but is just for convienience when doing the bitwise operations.
-
-
-Node$1.prototype._constrainedIndexBitmask = function (constraint) {
-  let mask = 0b0;
-
-  for (let i = 0; i < this.handlers.length; i++) {
-    const handler = this.handlers[i];
-
-    if (handler.constraints && constraint in handler.constraints) {
-      mask |= 1 << i;
-    }
-  }
-
-  return ~mask;
-}; // Compile a fast function to match the handlers for this node
-// The function implements a general case multi-constraint matching algorithm.
-// The general idea is this: we have a bunch of handlers, each with a potentially different set of constraints, and sometimes none at all. We're given a list of constraint values and we have to use the constraint-value-comparison strategies to see which handlers match the constraint values passed in.
-// We do this by asking each constraint store which handler indexes match the given constraint value for each store. Trickily, the handlers that a store says match are the handlers constrained by that store, but handlers that aren't constrained at all by that store could still match just fine. So, each constraint store can only describe matches for it, and it won't have any bearing on the handlers it doesn't care about. For this reason, we have to ask each stores which handlers match and track which have been matched (or not cared about) by all of them.
-// We use bitmaps to represent these lists of matches so we can use bitwise operations to implement this efficiently. Bitmaps are cheap to allocate, let us implement this masking behaviour in one CPU instruction, and are quite compact in memory. We start with a bitmap set to all 1s representing every handler that is a match candidate, and then for each constraint, see which handlers match using the store, and then mask the result by the mask of handlers that that store applies to, and bitwise AND with the candidate list. Phew.
-// We consider all this compiling function complexity to be worth it, because the naive implementation that just loops over the handlers asking which stores match is quite a bit slower.
-
-
-Node$1.prototype._compileGetHandlerMatchingConstraints = function () {
-  this.constrainedHandlerStores = {};
-  let constraints = new Set();
-
-  for (const handler of this.handlers) {
-    for (const key of Object.keys(handler.constraints)) {
-      constraints.add(key);
-    }
-  }
-
-  constraints = Array.from(constraints);
-  const lines = []; // always check the version constraint first as it is the most selective
-
-  constraints.sort((a, b) => a === 'version' ? 1 : 0);
-
-  for (const constraint of constraints) {
-    this.constrainedHandlerStores[constraint] = this._buildConstraintStore(constraint);
-  }
-
-  lines.push(`
-  let candidates = 0b${'1'.repeat(this.handlers.length)}
-  let mask, matches
-  `);
-
-  for (const constraint of constraints) {
-    // Setup the mask for indexes this constraint applies to. The mask bits are set to 1 for each position if the constraint applies.
-    lines.push(`
-    mask = ${this._constrainedIndexBitmask(constraint)}
-    value = derivedConstraints.${constraint}
-    `); // If there's no constraint value, none of the handlers constrained by this constraint can match. Remove them from the candidates.
-    // If there is a constraint value, get the matching indexes bitmap from the store, and mask it down to only the indexes this constraint applies to, and then bitwise and with the candidates list to leave only matching candidates left.
-
-    lines.push(`
-    if (typeof value === "undefined") {
-      candidates &= mask
-    } else {
-      matches = this.constrainedHandlerStores.${constraint}.get(value) || 0
-      candidates &= (matches | mask)
-    }
-    if (candidates === 0) return null;
-    `);
-  } // Return the first handler who's bit is set in the candidates https://stackoverflow.com/questions/18134985/how-to-find-index-of-first-set-bit
-
-
-  lines.push(`
-  return this.handlers[Math.floor(Math.log2(candidates))]
-  `);
-  this._getHandlerMatchingConstraints = new Function('derivedConstraints', lines.join('\n')); // eslint-disable-line
-};
-
-var node = Node$1;
-
-function SemVerStore() {
-  if (!(this instanceof SemVerStore)) {
-    return new SemVerStore();
-  }
-
-  this.tree = new Node();
-}
-
-SemVerStore.prototype.set = function (version, store) {
-  if (typeof version !== 'string') {
-    throw new TypeError('Version should be a string');
-  }
-
-  var currentNode = this.tree;
-  version = version.split('.');
-
-  while (version.length) {
-    currentNode = currentNode.addChild(new Node(version.shift()));
-  }
-
-  currentNode.setStore(store);
-  return this;
-};
-
-SemVerStore.prototype.get = function (version) {
-  if (typeof version !== 'string') return null;
-  if (version === '*') version = 'x.x.x';
-  var node = this.tree;
-  var firstDot = version.indexOf('.');
-  var secondDot = version.indexOf('.', firstDot + 1);
-  var major = version.slice(0, firstDot);
-  var minor = secondDot === -1 ? version.slice(firstDot + 1) : version.slice(firstDot + 1, secondDot);
-  var patch = secondDot === -1 ? 'x' : version.slice(secondDot + 1);
-  node = node.getChild(major);
-  if (node === null) return null;
-  node = node.getChild(minor);
-  if (node === null) return null;
-  node = node.getChild(patch);
-  if (node === null) return null;
-  return node.store;
-};
-
-SemVerStore.prototype.del = function (version) {
-  if (typeof version !== 'string') {
-    throw new TypeError('Version should be a string');
-  }
-
-  var firstDot = version.indexOf('.');
-  var secondDot = version.indexOf('.', firstDot + 1);
-  var major = version.slice(0, firstDot);
-  var minor = secondDot === -1 ? version.slice(firstDot + 1) : version.slice(firstDot + 1, secondDot);
-  var patch = secondDot === -1 ? 'x' : version.slice(secondDot + 1); // check existence of major node
-
-  var majorNode = this.tree.children[major];
-  if (majorNode == null) return this; // if minor is the wildcard, then remove the full major node
-
-  if (minor === 'x') {
-    this.tree.removeChild(major);
-    return this;
-  } // check existence of minor node
-
-
-  var minorNode = majorNode.children[minor];
-  if (minorNode == null) return this; // if patch is the wildcard, then remove the full minor node
-  // and also the major if there are no more children
-
-  if (patch === 'x') {
-    this.tree.children[major].removeChild(minor);
-
-    if (this.tree.children[major].length === 0) {
-      this.tree.removeChild(major);
-    }
-
-    return this;
-  } // check existence of patch node
-
-
-  var patchNode = minorNode.children[patch];
-  if (patchNode == null) return this; // Specific delete
-
-  this.tree.children[major].children[minor].removeChild(patch); // check if the minor node has no more children, if so removes it
-  // same for the major node
-
-  if (this.tree.children[major].children[minor].length === 0) {
-    this.tree.children[major].removeChild(minor);
-
-    if (this.tree.children[major].length === 0) {
-      this.tree.removeChild(major);
-    }
-  }
-
-  return this;
-};
-
-SemVerStore.prototype.empty = function () {
-  this.tree = new Node();
-  return this;
-};
-
-function getMax(arr) {
-  var l = arr.length;
-  var max = arr[0];
-
-  for (var i = 1; i < l; i++) {
-    if (arr[i] > max) {
-      max = arr[i];
-    }
-  }
-
-  return max;
-}
-
-function Node(prefix, children, store) {
-  this.prefix = Number(prefix) || 0;
-  this.children = children || null;
-  this.childrenPrefixes = children ? Object.keys(children) : [];
-  this.store = store || null;
-}
-
-Node.prototype.getChild = function (prefix) {
-  if (this.children === null) return null;
-
-  if (prefix === 'x') {
-    var max = getMax(this.childrenPrefixes);
-    return this.children[max];
-  }
-
-  return this.children[prefix] || null;
-};
-
-Node.prototype.addChild = function (node) {
-  this.children = this.children || {};
-  var child = this.getChild(node.prefix);
-
-  if (child === null) {
-    this.children[node.prefix] = node;
-    this.childrenPrefixes.push(node.prefix);
-  }
-
-  return child || node;
-};
-
-Node.prototype.removeChild = function (prefix) {
-  if (prefix === 'x') {
-    this.children = null;
-    this.childrenPrefixes = [];
-    return this;
-  }
-
-  if (this.children[prefix] !== undefined) {
-    prefix = Number(prefix);
-    delete this.children[prefix];
-    this.childrenPrefixes.splice(this.childrenPrefixes.indexOf(prefix), 1);
-  }
-
-  return this;
-};
-
-Node.prototype.setStore = function (store) {
-  this.store = store;
-  return this;
-};
-
-Object.defineProperty(Node.prototype, 'length', {
-  get: function () {
-    return this.childrenPrefixes.length;
-  }
-});
-var semverStore = SemVerStore;
-
-var acceptVersion = {
-  name: 'version',
-  mustMatchWhenDerived: true,
-  storage: semverStore,
-
-  validate(value) {
-    assert__default['default'](typeof value === 'string', 'Version should be a string');
-  }
-
-};
-
-function HostStorage() {
-  var hosts = {};
-  var regexHosts = [];
-  return {
-    get: host => {
-      var exact = hosts[host];
-
-      if (exact) {
-        return exact;
-      }
-
-      var item;
-
-      for (var i = 0; i < regexHosts.length; i++) {
-        item = regexHosts[i];
-
-        if (item.host.test(host)) {
-          return item.value;
-        }
-      }
-    },
-    set: (host, value) => {
-      if (host instanceof RegExp) {
-        regexHosts.push({
-          host,
-          value
-        });
-      } else {
-        hosts[host] = value;
-      }
-    },
-    del: host => {
-      delete hosts[host];
-      regexHosts = regexHosts.filter(obj => String(obj.host) !== String(host));
-    },
-    empty: () => {
-      hosts = {};
-      regexHosts = [];
-    }
-  };
-}
-
-var acceptHost = {
-  name: 'host',
-  mustMatchWhenDerived: false,
-  storage: HostStorage,
-
-  validate(value) {
-    assert__default['default'](typeof value === 'string' || Object.prototype.toString.call(value) === '[object RegExp]', 'Host should be a string or a RegExp');
-  }
-
-};
-
-class Constrainer {
-  constructor(customStrategies) {
-    this.strategies = {
-      version: acceptVersion,
-      host: acceptHost
-    };
-    this.strategiesInUse = new Set(); // validate and optimize prototypes of given custom strategies
-
-    if (customStrategies) {
-      var kCustomStrategies = Object.keys(customStrategies);
-      var strategy;
-
-      for (var i = 0; i < kCustomStrategies.length; i++) {
-        strategy = customStrategies[kCustomStrategies[i]];
-        assert__default['default'](typeof strategy.name === 'string' && strategy.name !== '', 'strategy.name is required.');
-        assert__default['default'](strategy.storage && typeof strategy.storage === 'function', 'strategy.storage function is required.');
-        assert__default['default'](strategy.deriveConstraint && typeof strategy.deriveConstraint === 'function', 'strategy.deriveConstraint function is required.');
-        strategy.isCustom = true;
-        this.strategies[strategy.name] = strategy;
-      }
-    }
-  }
-
-  deriveConstraints(req, ctx) {
-    return undefined;
-  } // When new constraints start getting used, we need to rebuild the deriver to derive them. Do so if we see novel constraints used.
-
-
-  noteUsage(constraints) {
-    if (constraints) {
-      const beforeSize = this.strategiesInUse.size;
-
-      for (const key in constraints) {
-        this.strategiesInUse.add(key);
-      }
-
-      if (beforeSize !== this.strategiesInUse.size) {
-        this._buildDeriveConstraints();
-      }
-    }
-  }
-
-  newStoreForConstraint(constraint) {
-    if (!this.strategies[constraint]) {
-      throw new Error(`No strategy registered for constraint key ${constraint}`);
-    }
-
-    return this.strategies[constraint].storage();
-  }
-
-  validateConstraints(constraints) {
-    for (const key in constraints) {
-      const value = constraints[key];
-
-      if (typeof value === 'undefined') {
-        throw new Error('Can\'t pass an undefined constraint value, must pass null or no key at all');
-      }
-
-      const strategy = this.strategies[key];
-
-      if (!strategy) {
-        throw new Error(`No strategy registered for constraint key ${key}`);
-      }
-
-      if (strategy.validate) {
-        strategy.validate(value);
-      }
-    }
-  } // Optimization: build a fast function for deriving the constraints for all the strategies at once. We inline the definitions of the version constraint and the host constraint for performance.
-  // If no constraining strategies are in use (no routes constrain on host, or version, or any custom strategies) then we don't need to derive constraints for each route match, so don't do anything special, and just return undefined
-  // This allows us to not allocate an object to hold constraint values if no constraints are defined.
-
-
-  _buildDeriveConstraints() {
-    if (this.strategiesInUse.size === 0) return;
-    const lines = [`
-      const derivedConstraints = {
-        __hasMustMatchValues: false,
-    `];
-    const mustMatchKeys = [];
-
-    for (const key of this.strategiesInUse) {
-      const strategy = this.strategies[key]; // Optimization: inline the derivation for the common built in constraints
-
-      if (!strategy.isCustom) {
-        if (key === 'version') {
-          lines.push('   version: req.headers[\'accept-version\'],');
-        } else if (key === 'host') {
-          lines.push('   host: req.headers.host,');
-        } else {
-          throw new Error('unknown non-custom strategy for compiling constraint derivation function');
-        }
-      } else {
-        lines.push(`  ${strategy.name}: this.strategies.${key}.deriveConstraint(req, ctx),`);
-      }
-
-      if (strategy.mustMatchWhenDerived) {
-        mustMatchKeys.push(key);
-      }
-    }
-
-    lines.push('}'); // There are some constraints that can be derived and marked as "must match", where if they are derived, they only match routes that actually have a constraint on the value, like the SemVer version constraint.
-    // An example: a request comes in for version 1.x, and this node has a handler that maches the path, but there's no version constraint. For SemVer, the find-my-way semantics do not match this handler to that request.
-    // This function is used by Nodes with handlers to match when they don't have any constrained routes to exclude request that do have must match derived constraints present.
-
-    if (mustMatchKeys.length > 0) {
-      lines.push(`derivedConstraints.__hasMustMatchValues = !!(${mustMatchKeys.map(key => `derivedConstraints.${key}`).join(' || ')})`);
-    }
-
-    lines.push('return derivedConstraints');
-    this.deriveConstraints = new Function('req', 'ctx', lines.join('\n')).bind(this); // eslint-disable-line
-  }
-
-}
-
-var constrainer = Constrainer;
-
-/*
-  Char codes:
-    '#': 35
-    '*': 42
-    '-': 45
-    '/': 47
-    ':': 58
-    ';': 59
-    '?': 63
-*/
-
-
-const {
-  flattenNode,
-  compressFlattenedNode,
-  prettyPrintFlattenedNode,
-  prettyPrintRoutesArray
-} = prettyPrint;
-const NODE_TYPES = node.prototype.types;
-const httpMethods = http__default['default'].METHODS;
-const FULL_PATH_REGEXP = /^https?:\/\/.*?\//;
-
-if (!safeRegex2(FULL_PATH_REGEXP)) {
-  throw new Error('the FULL_PATH_REGEXP is not safe, update this module');
-}
-
-function Router(opts) {
-  if (!(this instanceof Router)) {
-    return new Router(opts);
-  }
-
-  opts = opts || {};
-
-  if (opts.defaultRoute) {
-    assert__default['default'](typeof opts.defaultRoute === 'function', 'The default route must be a function');
-    this.defaultRoute = opts.defaultRoute;
-  } else {
-    this.defaultRoute = null;
-  }
-
-  if (opts.onBadUrl) {
-    assert__default['default'](typeof opts.onBadUrl === 'function', 'The bad url handler must be a function');
-    this.onBadUrl = opts.onBadUrl;
-  } else {
-    this.onBadUrl = null;
-  }
-
-  this.caseSensitive = opts.caseSensitive === undefined ? true : opts.caseSensitive;
-  this.ignoreTrailingSlash = opts.ignoreTrailingSlash || false;
-  this.maxParamLength = opts.maxParamLength || 100;
-  this.allowUnsafeRegex = opts.allowUnsafeRegex || false;
-  this.constrainer = new constrainer(opts.constraints);
-  this.trees = {};
-  this.routes = [];
-}
-
-Router.prototype.on = function on(method, path, opts, handler, store) {
-  if (typeof opts === 'function') {
-    if (handler !== undefined) {
-      store = handler;
-    }
-
-    handler = opts;
-    opts = {};
-  } // path validation
-
-
-  assert__default['default'](typeof path === 'string', 'Path should be a string');
-  assert__default['default'](path.length > 0, 'The path could not be empty');
-  assert__default['default'](path[0] === '/' || path[0] === '*', 'The first character of a path should be `/` or `*`'); // handler validation
-
-  assert__default['default'](typeof handler === 'function', 'Handler should be a function');
-
-  this._on(method, path, opts, handler, store);
-
-  if (this.ignoreTrailingSlash && path !== '/' && !path.endsWith('*')) {
-    if (path.endsWith('/')) {
-      this._on(method, path.slice(0, -1), opts, handler, store);
-    } else {
-      this._on(method, path + '/', opts, handler, store);
-    }
-  }
-};
-
-Router.prototype._on = function _on(method, path, opts, handler, store) {
-  if (Array.isArray(method)) {
-    for (var k = 0; k < method.length; k++) {
-      this._on(method[k], path, opts, handler, store);
-    }
-
-    return;
-  }
-
-  assert__default['default'](typeof method === 'string', 'Method should be a string');
-  assert__default['default'](httpMethods.indexOf(method) !== -1, `Method '${method}' is not an http method.`);
-  let constraints = {};
-
-  if (opts.constraints !== undefined) {
-    assert__default['default'](typeof opts.constraints === 'object' && opts.constraints !== null, 'Constraints should be an object');
-
-    if (Object.keys(opts.constraints).length !== 0) {
-      constraints = opts.constraints;
-    }
-  }
-
-  this.constrainer.validateConstraints(constraints); // Let the constrainer know if any constraints are being used now
-
-  this.constrainer.noteUsage(constraints);
-  const params = [];
-  var j = 0;
-  this.routes.push({
-    method: method,
-    path: path,
-    opts: opts,
-    handler: handler,
-    store: store
-  });
-
-  for (var i = 0, len = path.length; i < len; i++) {
-    // search for parametric or wildcard routes
-    // parametric route
-    if (path.charCodeAt(i) === 58) {
-      if (i !== len - 1 && path.charCodeAt(i + 1) === 58) {
-        // It's a double colon. Let's just replace it with a single colon and go ahead
-        path = path.slice(0, i) + path.slice(i + 1);
-        len = path.length;
-        continue;
-      }
-
-      var nodeType = NODE_TYPES.PARAM;
-      j = i + 1;
-      var staticPart = path.slice(0, i);
-
-      if (this.caseSensitive === false) {
-        staticPart = staticPart.toLowerCase();
-      } // add the static part of the route to the tree
-
-
-      this._insert(method, staticPart, NODE_TYPES.STATIC, null, null, null, null, constraints); // isolate the parameter name
-
-
-      var isRegex = false;
-
-      while (i < len && path.charCodeAt(i) !== 47) {
-        isRegex = isRegex || path[i] === '(';
-
-        if (isRegex) {
-          i = getClosingParenthensePosition(path, i) + 1;
-          break;
-        } else if (path.charCodeAt(i) !== 45) {
-          i++;
-        } else {
-          break;
-        }
-      }
-
-      if (isRegex && (i === len || path.charCodeAt(i) === 47)) {
-        nodeType = NODE_TYPES.REGEX;
-      } else if (i < len && path.charCodeAt(i) !== 47) {
-        nodeType = NODE_TYPES.MULTI_PARAM;
-      }
-
-      var parameter = path.slice(j, i);
-      var regex = isRegex ? parameter.slice(parameter.indexOf('('), i) : null;
-
-      if (isRegex) {
-        regex = new RegExp(regex);
-
-        if (!this.allowUnsafeRegex) {
-          assert__default['default'](safeRegex2(regex), `The regex '${regex.toString()}' is not safe!`);
-        }
-      }
-
-      params.push(parameter.slice(0, isRegex ? parameter.indexOf('(') : i));
-      path = path.slice(0, j) + path.slice(i);
-      i = j;
-      len = path.length; // if the path is ended
-
-      if (i === len) {
-        var completedPath = path.slice(0, i);
-
-        if (this.caseSensitive === false) {
-          completedPath = completedPath.toLowerCase();
-        }
-
-        return this._insert(method, completedPath, nodeType, params, handler, store, regex, constraints);
-      } // add the parameter and continue with the search
-
-
-      staticPart = path.slice(0, i);
-
-      if (this.caseSensitive === false) {
-        staticPart = staticPart.toLowerCase();
-      }
-
-      this._insert(method, staticPart, nodeType, params, null, null, regex, constraints);
-
-      i--; // wildcard route
-    } else if (path.charCodeAt(i) === 42) {
-      this._insert(method, path.slice(0, i), NODE_TYPES.STATIC, null, null, null, null, constraints); // add the wildcard parameter
-
-
-      params.push('*');
-      return this._insert(method, path.slice(0, len), NODE_TYPES.MATCH_ALL, params, handler, store, null, constraints);
-    }
-  }
-
-  if (this.caseSensitive === false) {
-    path = path.toLowerCase();
-  } // static route
-
-
-  this._insert(method, path, NODE_TYPES.STATIC, params, handler, store, null, constraints);
-};
-
-Router.prototype._insert = function _insert(method, path, kind, params, handler, store, regex, constraints) {
-  const route = path;
-  var prefix = '';
-  var pathLen = 0;
-  var prefixLen = 0;
-  var len = 0;
-  var max = 0;
-  var node$1 = null; // Boot the tree for this method if it doesn't exist yet
-
-  var currentNode = this.trees[method];
-
-  if (typeof currentNode === 'undefined') {
-    currentNode = new node({
-      method: method,
-      constrainer: this.constrainer
-    });
-    this.trees[method] = currentNode;
-  }
-
-  while (true) {
-    prefix = currentNode.prefix;
-    prefixLen = prefix.length;
-    pathLen = path.length;
-    len = 0; // search for the longest common prefix
-
-    max = pathLen < prefixLen ? pathLen : prefixLen;
-
-    while (len < max && path[len] === prefix[len]) len++; // the longest common prefix is smaller than the current prefix
-    // let's split the node and add a new child
-
-
-    if (len < prefixLen) {
-      node$1 = currentNode.split(len); // if the longest common prefix has the same length of the current path
-      // the handler should be added to the current node, to a child otherwise
-
-      if (len === pathLen) {
-        assert__default['default'](!currentNode.getHandler(constraints), `Method '${method}' already declared for route '${route}' with constraints '${JSON.stringify(constraints)}'`);
-        currentNode.addHandler(handler, params, store, constraints);
-        currentNode.kind = kind;
-      } else {
-        node$1 = new node({
-          method: method,
-          prefix: path.slice(len),
-          kind: kind,
-          handlers: null,
-          regex: regex,
-          constrainer: this.constrainer
-        });
-        node$1.addHandler(handler, params, store, constraints);
-        currentNode.addChild(node$1);
-      } // the longest common prefix is smaller than the path length,
-      // but is higher than the prefix
-
-    } else if (len < pathLen) {
-      // remove the prefix
-      path = path.slice(len); // check if there is a child with the label extracted from the new path
-
-      node$1 = currentNode.findByLabel(path); // there is a child within the given label, we must go deepen in the tree
-
-      if (node$1) {
-        currentNode = node$1;
-        continue;
-      } // there are not children within the given label, let's create a new one!
-
-
-      node$1 = new node({
-        method: method,
-        prefix: path,
-        kind: kind,
-        handlers: null,
-        regex: regex,
-        constrainer: this.constrainer
-      });
-      node$1.addHandler(handler, params, store, constraints);
-      currentNode.addChild(node$1); // the node already exist
-    } else if (handler) {
-      assert__default['default'](!currentNode.getHandler(constraints), `Method '${method}' already declared for route '${route}' with constraints '${JSON.stringify(constraints)}'`);
-      currentNode.addHandler(handler, params, store, constraints);
-    }
-
-    return;
-  }
-};
-
-Router.prototype.reset = function reset() {
-  this.trees = {};
-  this.routes = [];
-};
-
-Router.prototype.off = function off(method, path) {
-  var self = this;
-
-  if (Array.isArray(method)) {
-    return method.map(function (method) {
-      return self.off(method, path);
-    });
-  } // method validation
-
-
-  assert__default['default'](typeof method === 'string', 'Method should be a string');
-  assert__default['default'](httpMethods.indexOf(method) !== -1, `Method '${method}' is not an http method.`); // path validation
-
-  assert__default['default'](typeof path === 'string', 'Path should be a string');
-  assert__default['default'](path.length > 0, 'The path could not be empty');
-  assert__default['default'](path[0] === '/' || path[0] === '*', 'The first character of a path should be `/` or `*`'); // Rebuild tree without the specific route
-
-  const ignoreTrailingSlash = this.ignoreTrailingSlash;
-  var newRoutes = self.routes.filter(function (route) {
-    if (!ignoreTrailingSlash) {
-      return !(method === route.method && path === route.path);
-    }
-
-    if (path.endsWith('/')) {
-      const routeMatches = path === route.path || path.slice(0, -1) === route.path;
-      return !(method === route.method && routeMatches);
-    }
-
-    const routeMatches = path === route.path || path + '/' === route.path;
-    return !(method === route.method && routeMatches);
-  });
-
-  if (ignoreTrailingSlash) {
-    newRoutes = newRoutes.filter(function (route, i, ar) {
-      if (route.path.endsWith('/') && i < ar.length - 1) {
-        return route.path.slice(0, -1) !== ar[i + 1].path;
-      } else if (route.path.endsWith('/') === false && i < ar.length - 1) {
-        return route.path + '/' !== ar[i + 1].path;
-      }
-
-      return true;
-    });
-  }
-
-  self.reset();
-  newRoutes.forEach(function (route) {
-    self.on(route.method, route.path, route.opts, route.handler, route.store);
-  });
-};
-
-Router.prototype.lookup = function lookup(req, res, ctx) {
-  var handle = this.find(req.method, sanitizeUrl(req.url), this.constrainer.deriveConstraints(req, ctx));
-  if (handle === null) return this._defaultRoute(req, res, ctx);
-  return ctx === undefined ? handle.handler(req, res, handle.params, handle.store) : handle.handler.call(ctx, req, res, handle.params, handle.store);
-};
-
-Router.prototype.find = function find(method, path, derivedConstraints) {
-  var currentNode = this.trees[method];
-  if (currentNode === undefined) return null;
-
-  if (path.charCodeAt(0) !== 47) {
-    // 47 is '/'
-    path = path.replace(FULL_PATH_REGEXP, '/');
-  }
-
-  var originalPath = path;
-  var originalPathLength = path.length;
-
-  if (this.caseSensitive === false) {
-    path = path.toLowerCase();
-  }
-
-  var maxParamLength = this.maxParamLength;
-  var wildcardNode = null;
-  var pathLenWildcard = 0;
-  var decoded = null;
-  var pindex = 0;
-  var params = null;
-  var i = 0;
-  var idxInOriginalPath = 0;
-
-  while (true) {
-    var pathLen = path.length;
-    var prefix = currentNode.prefix; // found the route
-
-    if (pathLen === 0 || path === prefix) {
-      var handle = derivedConstraints !== undefined ? currentNode.getMatchingHandler(derivedConstraints) : currentNode.unconstrainedHandler;
-
-      if (handle !== null && handle !== undefined) {
-        var paramsObj = {};
-
-        if (handle.paramsLength > 0) {
-          var paramNames = handle.params;
-
-          for (i = 0; i < handle.paramsLength; i++) {
-            paramsObj[paramNames[i]] = params[i];
-          }
-        }
-
-        return {
-          handler: handle.handler,
-          params: paramsObj,
-          store: handle.store
-        };
-      }
-    }
-
-    var prefixLen = prefix.length;
-    var len = 0;
-    var previousPath = path; // search for the longest common prefix
-
-    i = pathLen < prefixLen ? pathLen : prefixLen;
-
-    while (len < i && path.charCodeAt(len) === prefix.charCodeAt(len)) len++;
-
-    if (len === prefixLen) {
-      path = path.slice(len);
-      pathLen = path.length;
-      idxInOriginalPath += len;
-    }
-
-    var node = currentNode.findMatchingChild(derivedConstraints, path);
-
-    if (node === null) {
-      node = currentNode.parametricBrother;
-
-      if (node === null) {
-        return this._getWildcardNode(wildcardNode, originalPath, pathLenWildcard);
-      }
-
-      var goBack = previousPath.charCodeAt(0) === 47 ? previousPath : '/' + previousPath;
-
-      if (originalPath.indexOf(goBack) === -1) {
-        // we need to know the outstanding path so far from the originalPath since the last encountered "/" and assign it to previousPath.
-        // e.g originalPath: /aa/bbb/cc, path: bb/cc
-        // outstanding path: /bbb/cc
-        var pathDiff = originalPath.slice(0, originalPathLength - pathLen);
-        previousPath = pathDiff.slice(pathDiff.lastIndexOf('/') + 1, pathDiff.length) + path;
-      }
-
-      idxInOriginalPath = idxInOriginalPath - (previousPath.length - path.length);
-      path = previousPath;
-      pathLen = previousPath.length;
-      len = prefixLen;
-    }
-
-    var kind = node.kind; // static route
-
-    if (kind === NODE_TYPES.STATIC) {
-      // if exist, save the wildcard child
-      if (currentNode.wildcardChild !== null) {
-        wildcardNode = currentNode.wildcardChild;
-        pathLenWildcard = pathLen;
-      }
-
-      currentNode = node;
-      continue;
-    }
-
-    if (len !== prefixLen) {
-      return this._getWildcardNode(wildcardNode, originalPath, pathLenWildcard);
-    } // if exist, save the wildcard child
-
-
-    if (currentNode.wildcardChild !== null) {
-      wildcardNode = currentNode.wildcardChild;
-      pathLenWildcard = pathLen;
-    } // parametric route
-
-
-    if (kind === NODE_TYPES.PARAM) {
-      currentNode = node;
-      i = path.indexOf('/');
-      if (i === -1) i = pathLen;
-      if (i > maxParamLength) return null;
-      decoded = fastDecodeUriComponent(originalPath.slice(idxInOriginalPath, idxInOriginalPath + i));
-
-      if (decoded === null) {
-        return this.onBadUrl !== null ? this._onBadUrl(originalPath.slice(idxInOriginalPath, idxInOriginalPath + i)) : null;
-      }
-
-      params || (params = []);
-      params[pindex++] = decoded;
-      path = path.slice(i);
-      idxInOriginalPath += i;
-      continue;
-    } // wildcard route
-
-
-    if (kind === NODE_TYPES.MATCH_ALL) {
-      decoded = fastDecodeUriComponent(originalPath.slice(idxInOriginalPath));
-
-      if (decoded === null) {
-        return this.onBadUrl !== null ? this._onBadUrl(originalPath.slice(idxInOriginalPath)) : null;
-      }
-
-      params || (params = []);
-      params[pindex] = decoded;
-      currentNode = node;
-      path = '';
-      continue;
-    } // parametric(regex) route
-
-
-    if (kind === NODE_TYPES.REGEX) {
-      currentNode = node;
-      i = path.indexOf('/');
-      if (i === -1) i = pathLen;
-      if (i > maxParamLength) return null;
-      decoded = fastDecodeUriComponent(originalPath.slice(idxInOriginalPath, idxInOriginalPath + i));
-
-      if (decoded === null) {
-        return this.onBadUrl !== null ? this._onBadUrl(originalPath.slice(idxInOriginalPath, idxInOriginalPath + i)) : null;
-      }
-
-      if (!node.regex.test(decoded)) return null;
-      params || (params = []);
-      params[pindex++] = decoded;
-      path = path.slice(i);
-      idxInOriginalPath += i;
-      continue;
-    } // multiparametric route
-
-
-    if (kind === NODE_TYPES.MULTI_PARAM) {
-      currentNode = node;
-      i = 0;
-
-      if (node.regex !== null) {
-        var matchedParameter = path.match(node.regex);
-        if (matchedParameter === null) return null;
-        i = matchedParameter[1].length;
-      } else {
-        while (i < pathLen && path.charCodeAt(i) !== 47 && path.charCodeAt(i) !== 45) i++;
-
-        if (i > maxParamLength) return null;
-      }
-
-      decoded = fastDecodeUriComponent(originalPath.slice(idxInOriginalPath, idxInOriginalPath + i));
-
-      if (decoded === null) {
-        return this.onBadUrl !== null ? this._onBadUrl(originalPath.slice(idxInOriginalPath, idxInOriginalPath + i)) : null;
-      }
-
-      params || (params = []);
-      params[pindex++] = decoded;
-      path = path.slice(i);
-      idxInOriginalPath += i;
-      continue;
-    }
-
-    wildcardNode = null;
-  }
-};
-
-Router.prototype._getWildcardNode = function (node, path, len) {
-  if (node === null) return null;
-  var decoded = fastDecodeUriComponent(path.slice(-len));
-
-  if (decoded === null) {
-    return this.onBadUrl !== null ? this._onBadUrl(path.slice(-len)) : null;
-  }
-
-  var handle = node.handlers[0];
-
-  if (handle !== null && handle !== undefined) {
-    return {
-      handler: handle.handler,
-      params: {
-        '*': decoded
-      },
-      store: handle.store
-    };
-  }
-
-  return null;
-};
-
-Router.prototype._defaultRoute = function (req, res, ctx) {
-  if (this.defaultRoute !== null) {
-    return ctx === undefined ? this.defaultRoute(req, res) : this.defaultRoute.call(ctx, req, res);
-  } else {
-    res.statusCode = 404;
-    res.end();
-  }
-};
-
-Router.prototype._onBadUrl = function (path) {
-  const onBadUrl = this.onBadUrl;
-  return {
-    handler: (req, res, ctx) => onBadUrl(path, req, res),
-    params: {},
-    store: null
-  };
-};
-
-Router.prototype.prettyPrint = function (opts = {}) {
-  opts.commonPrefix = opts.commonPrefix === undefined ? true : opts.commonPrefix; // default to original behaviour
-
-  if (!opts.commonPrefix) return prettyPrintRoutesArray(this.routes);
-  const root = {
-    prefix: '/',
-    nodes: [],
-    children: {}
-  };
-
-  for (const node of Object.values(this.trees)) {
-    if (node) {
-      flattenNode(root, node);
-    }
-  }
-
-  compressFlattenedNode(root);
-  return prettyPrintFlattenedNode(root, '', true);
-};
-
-for (var i in http__default['default'].METHODS) {
-  /* eslint no-prototype-builtins: "off" */
-  if (!http__default['default'].METHODS.hasOwnProperty(i)) continue;
-  const m = http__default['default'].METHODS[i];
-  const methodName = m.toLowerCase();
-  if (Router.prototype[methodName]) throw new Error('Method already exists: ' + methodName);
-
-  Router.prototype[methodName] = function (path, handler, store) {
-    return this.on(m, path, handler, store);
-  };
-}
-
-Router.prototype.all = function (path, handler, store) {
-  this.on(httpMethods, path, handler, store);
-};
-
-var findMyWay = Router;
-
-function sanitizeUrl(url) {
-  for (var i = 0, len = url.length; i < len; i++) {
-    var charCode = url.charCodeAt(i); // Some systems do not follow RFC and separate the path and query
-    // string with a `;` character (code 59), e.g. `/foo;jsessionid=123456`.
-    // Thus, we need to split on `;` as well as `?` and `#`.
-
-    if (charCode === 63 || charCode === 59 || charCode === 35) {
-      return url.slice(0, i);
-    }
-  }
-
-  return url;
-}
-
-function getClosingParenthensePosition(path, idx) {
-  // `path.indexOf()` will always return the first position of the closing parenthese,
-  // but it's inefficient for grouped or wrong regexp expressions.
-  // see issues #62 and #63 for more info
-  var parentheses = 1;
-
-  while (idx < path.length) {
-    idx++; // ignore skipped chars
-
-    if (path[idx] === '\\') {
-      idx++;
-      continue;
-    }
-
-    if (path[idx] === ')') {
-      parentheses--;
-    } else if (path[idx] === '(') {
-      parentheses++;
-    }
-
-    if (!parentheses) return idx;
-  }
-
-  throw new TypeError('Invalid regexp expression in "' + path + '"');
-}
-
-var index = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(null), findMyWay, {
-  'default': findMyWay
-});
-
-exports.index = index;
-//# sourceMappingURL=index-eeb85309.js.map