yrv/build/lib/vendor.js

var strictUriEncode = str => encodeURIComponent(str).replace(/[!'()*]/g, x => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);

var token = '%[a-f0-9]{2}';
var singleMatcher = new RegExp(token, 'gi');
var multiMatcher = new RegExp('(' + token + ')+', 'gi');

function decodeComponents(components, split) {
	try {
		// Try to decode the entire string first
		return decodeURIComponent(components.join(''));
	} catch (err) {
		// Do nothing
	}

	if (components.length === 1) {
		return components;
	}

	split = split || 1;

	// Split the array in 2 parts
	var left = components.slice(0, split);
	var right = components.slice(split);

	return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
}

function decode(input) {
	try {
		return decodeURIComponent(input);
	} catch (err) {
		var tokens = input.match(singleMatcher);

		for (var i = 1; i < tokens.length; i++) {
			input = decodeComponents(tokens, i).join('');

			tokens = input.match(singleMatcher);
		}

		return input;
	}
}

function customDecodeURIComponent(input) {
	// Keep track of all the replacements and prefill the map with the `BOM`
	var replaceMap = {
		'%FE%FF': '\uFFFD\uFFFD',
		'%FF%FE': '\uFFFD\uFFFD'
	};

	var match = multiMatcher.exec(input);
	while (match) {
		try {
			// Decode as big chunks as possible
			replaceMap[match[0]] = decodeURIComponent(match[0]);
		} catch (err) {
			var result = decode(match[0]);

			if (result !== match[0]) {
				replaceMap[match[0]] = result;
			}
		}

		match = multiMatcher.exec(input);
	}

	// Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else
	replaceMap['%C2'] = '\uFFFD';

	var entries = Object.keys(replaceMap);

	for (var i = 0; i < entries.length; i++) {
		// Replace all decoded components
		var key = entries[i];
		input = input.replace(new RegExp(key, 'g'), replaceMap[key]);
	}

	return input;
}

var decodeUriComponent = function (encodedURI) {
	if (typeof encodedURI !== 'string') {
		throw new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');
	}

	try {
		encodedURI = encodedURI.replace(/\+/g, ' ');

		// Try the built in decoder first
		return decodeURIComponent(encodedURI);
	} catch (err) {
		// Fallback to a more advanced decoder
		return customDecodeURIComponent(encodedURI);
	}
};

var splitOnFirst = (string, separator) => {
	if (!(typeof string === 'string' && typeof separator === 'string')) {
		throw new TypeError('Expected the arguments to be of type `string`');
	}

	if (separator === '') {
		return [string];
	}

	const separatorIndex = string.indexOf(separator);

	if (separatorIndex === -1) {
		return [string];
	}

	return [
		string.slice(0, separatorIndex),
		string.slice(separatorIndex + separator.length)
	];
};

function encoderForArrayFormat(options) {
	switch (options.arrayFormat) {
		case 'index':
			return key => (result, value) => {
				const index = result.length;
				if (value === undefined) {
					return result;
				}

				if (value === null) {
					return [...result, [encode(key, options), '[', index, ']'].join('')];
				}

				return [
					...result,
					[encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join('')
				];
			};

		case 'bracket':
			return key => (result, value) => {
				if (value === undefined) {
					return result;
				}

				if (value === null) {
					return [...result, [encode(key, options), '[]'].join('')];
				}

				return [...result, [encode(key, options), '[]=', encode(value, options)].join('')];
			};

		case 'comma':
			return key => (result, value, index) => {
				if (value === null || value === undefined || value.length === 0) {
					return result;
				}

				if (index === 0) {
					return [[encode(key, options), '=', encode(value, options)].join('')];
				}

				return [[result, encode(value, options)].join(',')];
			};

		default:
			return key => (result, value) => {
				if (value === undefined) {
					return result;
				}

				if (value === null) {
					return [...result, encode(key, options)];
				}

				return [...result, [encode(key, options), '=', encode(value, options)].join('')];
			};
	}
}

function parserForArrayFormat(options) {
	let result;

	switch (options.arrayFormat) {
		case 'index':
			return (key, value, accumulator) => {
				result = /\[(\d*)\]$/.exec(key);

				key = key.replace(/\[\d*\]$/, '');

				if (!result) {
					accumulator[key] = value;
					return;
				}

				if (accumulator[key] === undefined) {
					accumulator[key] = {};
				}

				accumulator[key][result[1]] = value;
			};

		case 'bracket':
			return (key, value, accumulator) => {
				result = /(\[\])$/.exec(key);
				key = key.replace(/\[\]$/, '');

				if (!result) {
					accumulator[key] = value;
					return;
				}

				if (accumulator[key] === undefined) {
					accumulator[key] = [value];
					return;
				}

				accumulator[key] = [].concat(accumulator[key], value);
			};

		case 'comma':
			return (key, value, accumulator) => {
				const isArray = typeof value === 'string' && value.split('').indexOf(',') > -1;
				const newValue = isArray ? value.split(',') : value;
				accumulator[key] = newValue;
			};

		default:
			return (key, value, accumulator) => {
				if (accumulator[key] === undefined) {
					accumulator[key] = value;
					return;
				}

				accumulator[key] = [].concat(accumulator[key], value);
			};
	}
}

function encode(value, options) {
	if (options.encode) {
		return options.strict ? strictUriEncode(value) : encodeURIComponent(value);
	}

	return value;
}

function decode$1(value, options) {
	if (options.decode) {
		return decodeUriComponent(value);
	}

	return value;
}

function keysSorter(input) {
	if (Array.isArray(input)) {
		return input.sort();
	}

	if (typeof input === 'object') {
		return keysSorter(Object.keys(input))
			.sort((a, b) => Number(a) - Number(b))
			.map(key => input[key]);
	}

	return input;
}

function parseValue(value, options) {
	if (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === 'string' && value.trim() !== '')) {
		value = Number(value);
	} else if (options.parseBooleans && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {
		value = value.toLowerCase() === 'true';
	}

	return value;
}

function parse(input, options) {
	options = Object.assign({
		decode: true,
		sort: true,
		arrayFormat: 'none',
		parseNumbers: false,
		parseBooleans: false
	}, options);

	const formatter = parserForArrayFormat(options);

	// Create an object with no prototype
	const ret = Object.create(null);

	if (typeof input !== 'string') {
		return ret;
	}

	input = input.trim().replace(/^[?#&]/, '');

	if (!input) {
		return ret;
	}

	for (const param of input.split('&')) {
		let [key, value] = splitOnFirst(param.replace(/\+/g, ' '), '=');

		// Missing `=` should be `null`:
		// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
		value = value === undefined ? null : decode$1(value, options);
		formatter(decode$1(key, options), value, ret);
	}

	for (const key of Object.keys(ret)) {
		const value = ret[key];
		if (typeof value === 'object' && value !== null) {
			for (const k of Object.keys(value)) {
				value[k] = parseValue(value[k], options);
			}
		} else {
			ret[key] = parseValue(value, options);
		}
	}

	if (options.sort === false) {
		return ret;
	}

	return (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {
		const value = ret[key];
		if (Boolean(value) && typeof value === 'object' && !Array.isArray(value)) {
			// Sort object keys, not values
			result[key] = keysSorter(value);
		} else {
			result[key] = value;
		}

		return result;
	}, Object.create(null));
}
var parse_1 = parse;

var stringify = (object, options) => {
	if (!object) {
		return '';
	}

	options = Object.assign({
		encode: true,
		strict: true,
		arrayFormat: 'none'
	}, options);

	const formatter = encoderForArrayFormat(options);
	const keys = Object.keys(object);

	if (options.sort !== false) {
		keys.sort(options.sort);
	}

	return keys.map(key => {
		const value = object[key];

		if (value === undefined) {
			return '';
		}

		if (value === null) {
			return encode(key, options);
		}

		if (Array.isArray(value)) {
			return value
				.reduce(formatter(key), [])
				.join('&');
		}

		return encode(key, options) + '=' + encode(value, options);
	}).filter(x => x.length > 0).join('&');
};

var defaultExport = /*@__PURE__*/(function (Error) {
  function defaultExport(route, path) {
    var message = "Unreachable '" + (route !== '/' ? route.replace(/\/$/, '') : route) + "', segment '" + path + "' is not defined";
    Error.call(this, message);
    this.message = message;
    this.route = route;
    this.path = path;
  }

  if ( Error ) defaultExport.__proto__ = Error;
  defaultExport.prototype = Object.create( Error && Error.prototype );
  defaultExport.prototype.constructor = defaultExport;

  return defaultExport;
}(Error));

function buildMatcher(path, parent) {
  var regex;

  var _isSplat;

  var _priority = -100;

  var keys = [];
  regex = path.replace(/[-$.]/g, '\\$&').replace(/\(/g, '(?:').replace(/\)/g, ')?').replace(/([:*]\w+)(?:<([^<>]+?)>)?/g, function (_, key, expr) {
    keys.push(key.substr(1));

    if (key.charAt() === ':') {
      _priority += 100;
      return ("((?!#)" + (expr || '[^#/]+?') + ")");
    }

    _isSplat = true;
    _priority += 500;
    return ("((?!#)" + (expr || '[^#]+?') + ")");
  });

  try {
    regex = new RegExp(("^" + regex + "$"));
  } catch (e) {
    throw new TypeError(("Invalid route expression, given '" + parent + "'"));
  }

  var _hashed = path.includes('#') ? 0.5 : 1;

  var _depth = path.length * _priority * _hashed;

  return {
    keys: keys,
    regex: regex,
    _depth: _depth,
    _isSplat: _isSplat
  };
}
var PathMatcher = function PathMatcher(path, parent) {
  var ref = buildMatcher(path, parent);
  var keys = ref.keys;
  var regex = ref.regex;
  var _depth = ref._depth;
  var _isSplat = ref._isSplat;
  return {
    _isSplat: _isSplat,
    _depth: _depth,
    match: function (value) {
      var matches = value.match(regex);

      if (matches) {
        return keys.reduce(function (prev, cur, i) {
          prev[cur] = typeof matches[i + 1] === 'string' ? decodeURIComponent(matches[i + 1]) : null;
          return prev;
        }, {});
      }
    }
  };
};

PathMatcher.push = function push (key, prev, leaf, parent) {
  var root = prev[key] || (prev[key] = {});

  if (!root.pattern) {
    root.pattern = new PathMatcher(key, parent);
    root.route = (leaf || '').replace(/\/$/, '') || '/';
  }

  prev.keys = prev.keys || [];

  if (!prev.keys.includes(key)) {
    prev.keys.push(key);
    PathMatcher.sort(prev);
  }

  return root;
};

PathMatcher.sort = function sort (root) {
  root.keys.sort(function (a, b) {
    return root[a].pattern._depth - root[b].pattern._depth;
  });
};

function merge(path, parent) {
  return ("" + (parent && parent !== '/' ? parent : '') + (path || ''));
}
function walk(path, cb) {
  var matches = path.match(/<[^<>]*\/[^<>]*>/);

  if (matches) {
    throw new TypeError(("RegExp cannot contain slashes, given '" + matches + "'"));
  }

  var parts = path.split(/(?=\/|#)/);
  var root = [];

  if (parts[0] !== '/') {
    parts.unshift('/');
  }

  parts.some(function (x, i) {
    var parent = root.slice(1).concat(x).join('') || null;
    var segment = parts.slice(i + 1).join('') || null;
    var retval = cb(x, parent, segment ? ("" + (x !== '/' ? x : '') + segment) : null);
    root.push(x);
    return retval;
  });
}
function reduce(key, root, _seen) {
  var params = {};
  var out = [];
  var splat;
  walk(key, function (x, leaf, extra) {
    var found;

    if (!root.keys) {
      throw new defaultExport(key, x);
    }

    root.keys.some(function (k) {
      if (_seen.includes(k)) { return false; }
      var ref = root[k].pattern;
      var match = ref.match;
      var _isSplat = ref._isSplat;
      var matches = match(_isSplat ? extra || x : x);

      if (matches) {
        Object.assign(params, matches);

        if (root[k].route) {
          var routeInfo = Object.assign({}, root[k].info); // properly handle exact-routes!

          var hasMatch = false;

          if (routeInfo.exact) {
            hasMatch = extra === null;
          } else {
            hasMatch = !(x && leaf === null) || x === leaf || _isSplat || !extra;
          }

          routeInfo.matches = hasMatch;
          routeInfo.params = Object.assign({}, params);
          routeInfo.route = root[k].route;
          routeInfo.path = _isSplat && extra || leaf || x;
          out.push(routeInfo);
        }

        if (extra === null && !root[k].keys) {
          return true;
        }

        if (k !== '/') { _seen.push(k); }
        splat = _isSplat;
        root = root[k];
        found = true;
        return true;
      }

      return false;
    });

    if (!(found || root.keys.some(function (k) { return root[k].pattern.match(x); }))) {
      throw new defaultExport(key, x);
    }

    return splat || !found;
  });
  return out;
}
function find(path, routes, retries) {
  var get = reduce.bind(null, path, routes);
  var set = [];

  while (retries > 0) {
    retries -= 1;

    try {
      return get(set);
    } catch (e) {
      if (retries > 0) {
        return get(set);
      }

      throw e;
    }
  }
}
function add(path, routes, parent, routeInfo) {
  var fullpath = merge(path, parent);
  var root = routes;
  var key;

  if (routeInfo && routeInfo.nested !== true) {
    key = routeInfo.key;
    delete routeInfo.key;
  }

  walk(fullpath, function (x, leaf) {
    root = PathMatcher.push(x, root, leaf, fullpath);

    if (x !== '/') {
      root.info = root.info || Object.assign({}, routeInfo);
    }
  });
  root.info = root.info || Object.assign({}, routeInfo);

  if (key) {
    root.info.key = key;
  }

  return fullpath;
}
function rm(path, routes, parent) {
  var fullpath = merge(path, parent);
  var root = routes;
  var leaf = null;
  var key = null;
  walk(fullpath, function (x) {
    if (!root) {
      leaf = null;
      return true;
    }

    if (!root.keys) {
      throw new defaultExport(path, x);
    }

    key = x;
    leaf = root;
    root = root[key];
  });

  if (!(leaf && key)) {
    throw new defaultExport(path, key);
  }

  if (leaf === routes) {
    leaf = routes['/'];
  }

  if (leaf.route !== key) {
    var offset = leaf.keys.indexOf(key);

    if (offset === -1) {
      throw new defaultExport(path, key);
    }

    leaf.keys.splice(offset, 1);
    PathMatcher.sort(leaf);
    delete leaf[key];
  } // nested routes are upgradeable, so keep original info...


  if (root.route === leaf.route && (!root.info || root.info.key === leaf.info.key)) { delete leaf.info; }
}

var Router = function Router() {
  var routes = {};
  var stack = [];
  return {
    resolve: function (path, cb) {
      var url = path.split('?')[0];
      var seen = [];
      walk(url, function (x, leaf, extra) {
        try {
          cb(null, find(leaf, routes, 1).filter(function (r) {
            if (!seen.includes(r.path)) {
              seen.push(r.path);
              return true;
            }

            return false;
          }));
        } catch (e) {
          cb(e, []);
        }
      });
    },
    mount: function (path, cb) {
      if (path !== '/') {
        stack.push(path);
      }

      cb();
      stack.pop();
    },
    find: function (path, retries) { return find(path, routes, retries === true ? 2 : retries || 1); },
    add: function (path, routeInfo) { return add(path, routes, stack.join(''), routeInfo); },
    rm: function (path) { return rm(path, routes, stack.join('')); }
  };
};

Router.matches = function matches (uri, path) {
  return buildMatcher(uri, path).regex.test(path);
};

export { Router, parse_1 as parse, stringify };