@angular-wave/angular.ts 0.9.4 → 0.9.6

package/src/router/url/url-config.js

@@ -1,155 +0,0 @@
-import { ParamTypes } from "../params/param-types";
-import { isDefined, isString } from "../../shared/utils.js";
-/**
- * An API to customize the URL behavior and retrieve URL configuration
- *
- * This API is used to customize the behavior of the URL.
- * This includes optional trailing slashes ([[strictMode]]), case sensitivity ([[caseInsensitive]]),
- * and custom parameter encoding (custom [[type]]).
- *
- * It also has information about the location (url) configuration such as [[port]] and [[baseHref]].
- * This information can be used to build absolute URLs, such as
- * `https://example.com:443/basepath/state/substate?param1=a#hashvalue`;
- *
- * This API is found at `router.urlService.config` (see: [[UIRouter.urlService]], [[URLService.config]])
- */
-export class UrlConfigProvider {
-  constructor() {
-    /** @type {ParamTypes} */
-    this.paramTypes = new ParamTypes();
-    /** @type {boolean} */
-    this._isCaseInsensitive = false;
-    /** @type {boolean} */
-    this._isStrictMode = true;
-    /** @type {boolean} */
-    this._defaultSquashPolicy = false;
-    /**
-     * Applys ng1-specific path parameter encoding
-     *
-     * The Angular 1 `$location` service is a bit weird.
-     * It doesn't allow slashes to be encoded/decoded bi-directionally.
-     *
-     * See the writeup at https://github.com/angular-ui/ui-router/issues/2598
-     *
-     * This code patches the `path` parameter type so it encoded/decodes slashes as ~2F
-     *
-     */
-    const pathType = this.type("path");
-    pathType.encode = (x) =>
-      x != null
-        ? x.toString().replace(/([~/])/g, (m) => ({ "~": "~~", "/": "~2F" })[m])
-        : x;
-    pathType.decode = (x) =>
-      x != null
-        ? x
-            .toString()
-            .replace(/(~~|~2F)/g, (m) => ({ "~~": "~", "~2F": "/" })[m])
-        : x;
-    this.paramTypes.enqueue = false;
-    this.paramTypes._flushTypeQueue();
-  }
-
-  $get = [
-    function () {
-      return this;
-    },
-  ];
-
-  /**
-   * Defines whether URL matching should be case sensitive (the default behavior), or not.
-   *
-   * #### Example:
-   * ```js
-   * // Allow case insensitive url matches
-   * urlService.config.caseInsensitive(true);
-   * ```
-   *
-   * @param value `false` to match URL in a case sensitive manner; otherwise `true`;
-   * @returns the current value of caseInsensitive
-   */
-  caseInsensitive(value) {
-    return (this._isCaseInsensitive = isDefined(value)
-      ? value
-      : this._isCaseInsensitive);
-  }
-  /**
-   * Sets the default behavior when generating or matching URLs with default parameter values.
-   *
-   * #### Example:
-   * ```js
-   * // Remove default parameter values from the url
-   * urlService.config.defaultSquashPolicy(true);
-   * ```
-   *
-   * @param value A string that defines the default parameter URL squashing behavior.
-   *    - `nosquash`: When generating an href with a default parameter value, do not squash the parameter value from the URL
-   *    - `slash`: When generating an href with a default parameter value, squash (remove) the parameter value, and, if the
-   *      parameter is surrounded by slashes, squash (remove) one slash from the URL
-   *    - any other string, e.g. "~": When generating an href with a default parameter value, squash (remove)
-   *      the parameter value from the URL and replace it with this string.
-   * @returns the current value of defaultSquashPolicy
-   */
-  defaultSquashPolicy(value) {
-    if (
-      isDefined(value) &&
-      value !== true &&
-      value !== false &&
-      !isString(value)
-    )
-      throw new Error(
-        `Invalid squash policy: ${value}. Valid policies: false, true, arbitrary-string`,
-      );
-    return (this._defaultSquashPolicy = isDefined(value)
-      ? value
-      : this._defaultSquashPolicy);
-  }
-  /**
-   * Defines whether URLs should match trailing slashes, or not (the default behavior).
-   *
-   * #### Example:
-   * ```js
-   * // Allow optional trailing slashes
-   * urlService.config.strictMode(false);
-   * ```
-   *
-   * @param value `false` to match trailing slashes in URLs, otherwise `true`.
-   * @returns the current value of strictMode
-   */
-  strictMode(value) {
-    return (this._isStrictMode = isDefined(value) ? value : this._isStrictMode);
-  }
-  /**
-   * Creates and registers a custom [[ParamType]] object
-   *
-   * A custom parameter type can be used to generate URLs with typed parameters or custom encoding/decoding.
-   *
-   * #### Note: Register custom types *before using them* in a state definition.
-   *
-   * #### Example:
-   * ```js
-   * // Encode object parameter as JSON string
-   * urlService.config.type('myjson', {
-   *   encode: (obj) => JSON.stringify(obj),
-   *   decode: (str) => JSON.parse(str),
-   *   is: (val) => typeof(val) === 'object',
-   *   pattern: /[^/]+/,
-   *   equals: (a, b) => _.isEqual(a, b),
-   * });
-   * ```
-   *
-   * See [[ParamTypeDefinition]] for more examples
-   *
-   * @param name The type name.
-   * @param definition The type definition. See [[ParamTypeDefinition]] for information on the values accepted.
-   * @param definitionFn A function that is injected before the app runtime starts.
-   *        The result of this function should be a [[ParamTypeDefinition]].
-   *        The result is merged into the existing `definition`.
-   *        See [[ParamType]] for information on the values accepted.
-   *
-   * @returns if only the `name` parameter was specified: the currently registered [[ParamType]] object, or undefined
-   */
-  type(name, definition, definitionFn) {
-    const type = this.paramTypes.type(name, definition, definitionFn);
-    return !isDefined(definition) ? type : this;
-  }
-}

package/src/router/url/url-matcher.js

@@ -1,532 +0,0 @@
-import {
-  map,
-  inherit,
-  unnest,
-  tail,
-  find,
-  allTrueR,
-  unnestR,
-  arrayTuples,
-  defaults,
-} from "../../shared/common.js";
-import { propEq } from "../../shared/hof.js";
-import { hasOwn, isDefined, isString } from "../../shared/utils.js";
-import { Param, DefType } from "../params/param.js";
-import { joinNeighborsR, splitOnDelim } from "../../shared/strings.js";
-
-function quoteRegExp(str, param) {
-  let surroundPattern = ["", ""];
-  let result = str.replace(/[\\[\]^$*+?.()|{}]/g, "\\$&");
-  if (!param) return result;
-  switch (param.squash) {
-    case false:
-      surroundPattern = ["(", ")" + (param.isOptional ? "?" : "")];
-      break;
-    case true:
-      result = result.replace(/\/$/, "");
-      surroundPattern = ["(?:/(", ")|/)?"];
-      break;
-    default:
-      surroundPattern = [`(${param.squash}|`, ")?"];
-      break;
-  }
-  return (
-    result + surroundPattern[0] + param.type.pattern.source + surroundPattern[1]
-  );
-}
-const memoizeTo = (obj, _prop, fn) => (obj[_prop] = obj[_prop] || fn());
-const splitOnSlash = splitOnDelim("/");
-const defaultConfig = {
-  state: { params: {} },
-  strict: true,
-  caseInsensitive: true,
-};
-/**
- * Matches URLs against patterns.
- *
- * Matches URLs against patterns and extracts named parameters from the path or the search
- * part of the URL.
- *
- * A URL pattern consists of a path pattern, optionally followed by '?' and a list of search (query)
- * parameters. Multiple search parameter names are separated by '&'. Search parameters
- * do not influence whether or not a URL is matched, but their values are passed through into
- * the matched parameters returned by [[UrlMatcher.exec]].
- *
- * - *Path parameters* are defined using curly brace placeholders (`/somepath/{param}`)
- * or colon placeholders (`/somePath/:param`).
- *
- * - *A parameter RegExp* may be defined for a param after a colon
- * (`/somePath/{param:[a-zA-Z0-9]+}`) in a curly brace placeholder.
- * The regexp must match for the url to be matched.
- * Should the regexp itself contain curly braces, they must be in matched pairs or escaped with a backslash.
- *
- * Note: a RegExp parameter will encode its value using either [[ParamTypes.path]] or [[ParamTypes.query]].
- *
- * - *Custom parameter types* may also be specified after a colon (`/somePath/{param:int}`) in curly brace parameters.
- *   See [[UrlMatcherFactory.type]] for more information.
- *
- * - *Catch-all parameters* are defined using an asterisk placeholder (`/somepath/*catchallparam`).
- *   A catch-all * parameter value will contain the remainder of the URL.
- *
- * ---
- *
- * Parameter names may contain only word characters (latin letters, digits, and underscore) and
- * must be unique within the pattern (across both path and search parameters).
- * A path parameter matches any number of characters other than '/'. For catch-all
- * placeholders the path parameter matches any number of characters.
- *
- * Examples:
- *
- * * `'/hello/'` - Matches only if the path is exactly '/hello/'. There is no special treatment for
- *   trailing slashes, and patterns have to match the entire path, not just a prefix.
- * * `'/user/:id'` - Matches '/user/bob' or '/user/1234!!!' or even '/user/' but not '/user' or
- *   '/user/bob/details'. The second path segment will be captured as the parameter 'id'.
- * * `'/user/{id}'` - Same as the previous example, but using curly brace syntax.
- * * `'/user/{id:[^/]*}'` - Same as the previous example.
- * * `'/user/{id:[0-9a-fA-F]{1,8}}'` - Similar to the previous example, but only matches if the id
- *   parameter consists of 1 to 8 hex digits.
- * * `'/files/{path:.*}'` - Matches any URL starting with '/files/' and captures the rest of the
- *   path into the parameter 'path'.
- * * `'/files/*path'` - ditto.
- * * `'/calendar/{start:date}'` - Matches "/calendar/2014-11-12" (because the pattern defined
- *   in the built-in  `date` ParamType matches `2014-11-12`) and provides a Date object in $stateParams.start
- *
- */
-export class UrlMatcher {
-  /** @internal Given a matcher, return an array with the matcher's path segments and path params, in order */
-  static pathSegmentsAndParams(matcher) {
-    const staticSegments = matcher._segments;
-    const pathParams = matcher._params.filter(
-      (p) => p.location === DefType.PATH,
-    );
-    return arrayTuples(staticSegments, pathParams.concat(undefined))
-      .reduce(unnestR, [])
-      .filter((x) => x !== "" && isDefined(x));
-  }
-  /** @internal Given a matcher, return an array with the matcher's query params */
-  static queryParams(matcher) {
-    return matcher._params.filter((p) => p.location === DefType.SEARCH);
-  }
-  /**
-   * Compare two UrlMatchers
-   *
-   * This comparison function converts a UrlMatcher into static and dynamic path segments.
-   * Each static path segment is a static string between a path separator (slash character).
-   * Each dynamic segment is a path parameter.
-   *
-   * The comparison function sorts static segments before dynamic ones.
-   */
-  static compare(a, b) {
-    /**
-     * Turn a UrlMatcher and all its parent matchers into an array
-     * of slash literals '/', string literals, and Param objects
-     *
-     * This example matcher matches strings like "/foo/:param/tail":
-     * var matcher = $umf.compile("/foo").append($umf.compile("/:param")).append($umf.compile("/")).append($umf.compile("tail"));
-     * var result = segments(matcher); // [ '/', 'foo', '/', Param, '/', 'tail' ]
-     *
-     * Caches the result as `matcher._cache.segments`
-     */
-    const segments = (matcher) =>
-      (matcher._cache.segments =
-        matcher._cache.segments ||
-        matcher._cache.path
-          .map(UrlMatcher.pathSegmentsAndParams)
-          .reduce(unnestR, [])
-          .reduce(joinNeighborsR, [])
-          .map((x) => (isString(x) ? splitOnSlash(x) : x))
-          .reduce(unnestR, []));
-    /**
-     * Gets the sort weight for each segment of a UrlMatcher
-     *
-     * Caches the result as `matcher._cache.weights`
-     */
-    const weights = (matcher) =>
-      (matcher._cache.weights =
-        matcher._cache.weights ||
-        segments(matcher).map((segment) => {
-          // Sort slashes first, then static strings, the Params
-          if (segment === "/") return 1;
-          if (isString(segment)) return 2;
-          if (segment instanceof Param) return 3;
-        }));
-    /**
-     * Pads shorter array in-place (mutates)
-     */
-    const padArrays = (l, r, padVal) => {
-      const len = Math.max(l.length, r.length);
-      while (l.length < len) l.push(padVal);
-      while (r.length < len) r.push(padVal);
-    };
-    const weightsA = weights(a),
-      weightsB = weights(b);
-    padArrays(weightsA, weightsB, 0);
-    const _pairs = arrayTuples(weightsA, weightsB);
-    let cmp, i;
-    for (i = 0; i < _pairs.length; i++) {
-      cmp = _pairs[i][0] - _pairs[i][1];
-      if (cmp !== 0) return cmp;
-    }
-    return 0;
-  }
-  /**
-   * @param pattern The pattern to compile into a matcher.
-   * @param paramTypes The [[ParamTypes]] registry
-   * @param paramFactory A [[ParamFactory]] object
-   * @param config  A [[UrlMatcherCompileConfig]] configuration object
-   */
-  constructor(pattern, paramTypes, paramFactory, config) {
-    this._cache = { path: [/** @type {UrlMatcher} */ (this)] };
-
-    this._children = [];
-
-    this._params = [];
-
-    this._segments = [];
-
-    this._compiled = [];
-    this.config = config = defaults(config, defaultConfig);
-    this.pattern = pattern;
-    // Find all placeholders and create a compiled pattern, using either classic or curly syntax:
-    //   '*' name
-    //   ':' name
-    //   '{' name '}'
-    //   '{' name ':' regexp '}'
-    // The regular expression is somewhat complicated due to the need to allow curly braces
-    // inside the regular expression. The placeholder regexp breaks down as follows:
-    //    ([:*])([\w\[\]]+)              - classic placeholder ($1 / $2) (search version has - for snake-case)
-    //    \{([\w\[\]]+)(?:\:\s*( ... ))?\}  - curly brace placeholder ($3) with optional regexp/type ... ($4) (search version has - for snake-case
-    //    (?: ... | ... | ... )+         - the regexp consists of any number of atoms, an atom being either
-    //    [^{}\\]+                       - anything other than curly braces or backslash
-    //    \\.                            - a backslash escape
-    //    \{(?:[^{}\\]+|\\.)*\}          - a matched set of curly braces containing other atoms
-    const placeholder =
-      /([:*])([\w[\]]+)|\{([\w[\]]+)(?::\s*((?:[^{}\\]+|\\.|\{(?:[^{}\\]+|\\.)*\})+))?\}/g;
-    const searchPlaceholder =
-      /([:]?)([\w[\].-]+)|\{([\w[\].-]+)(?::\s*((?:[^{\\}]+|\\.|{(?:[^{\\}]+|\\.)*})+))?\}/g;
-    const patterns = [];
-    let last = 0;
-    let matchArray;
-    const checkParamErrors = (id) => {
-      if (!UrlMatcher.nameValidator.test(id))
-        throw new Error(
-          `Invalid parameter name '${id}' in pattern '${pattern}'`,
-        );
-      if (find(this._params, propEq("id", id)))
-        throw new Error(
-          `Duplicate parameter name '${id}' in pattern '${pattern}'`,
-        );
-    };
-    // Split into static segments separated by path parameter placeholders.
-    // The number of segments is always 1 more than the number of parameters.
-    const matchDetails = (m, isSearch) => {
-      // IE[78] returns '' for unmatched groups instead of null
-      const id = m[2] || m[3];
-      const regexp = isSearch
-        ? m[4]
-        : m[4] || (m[1] === "*" ? "[\\s\\S]*" : null);
-      const makeRegexpType = (str) =>
-        inherit(paramTypes.type(isSearch ? "query" : "path"), {
-          pattern: new RegExp(
-            str,
-            this.config.caseInsensitive ? "i" : undefined,
-          ),
-        });
-      return {
-        id,
-        regexp,
-        segment: pattern.substring(last, m.index),
-        type: !regexp
-          ? null
-          : paramTypes.type(regexp) || makeRegexpType(regexp),
-      };
-    };
-    let details;
-    let segment;
-    while ((matchArray = placeholder.exec(pattern))) {
-      details = matchDetails(matchArray, false);
-      if (details.segment.indexOf("?") >= 0) break; // we're into the search part
-      checkParamErrors(details.id);
-      this._params.push(
-        paramFactory.fromPath(details.id, details.type, config.state),
-      );
-      this._segments.push(details.segment);
-      patterns.push([details.segment, tail(this._params)]);
-      last = placeholder.lastIndex;
-    }
-    segment = pattern.substring(last);
-    // Find any search parameter names and remove them from the last segment
-    const i = segment.indexOf("?");
-    if (i >= 0) {
-      const search = segment.substring(i);
-      segment = segment.substring(0, i);
-      if (search.length > 0) {
-        last = 0;
-        while ((matchArray = searchPlaceholder.exec(search))) {
-          details = matchDetails(matchArray, true);
-          checkParamErrors(details.id);
-          this._params.push(
-            paramFactory.fromSearch(details.id, details.type, config.state),
-          );
-          last = placeholder.lastIndex;
-          // check if ?&
-        }
-      }
-    }
-    this._segments.push(segment);
-    this._compiled = patterns
-      .map((_pattern) => quoteRegExp.apply(null, _pattern))
-      .concat(quoteRegExp(segment));
-  }
-  /**
-   * Creates a new concatenated UrlMatcher
-   *
-   * Builds a new UrlMatcher by appending another UrlMatcher to this one.
-   *
-   * @param url A `UrlMatcher` instance to append as a child of the current `UrlMatcher`.
-   */
-  append(url) {
-    this._children.push(url);
-    url._cache = {
-      path: this._cache.path.concat(url),
-      parent: this,
-      pattern: null,
-    };
-    return url;
-  }
-
-  isRoot() {
-    return this._cache.path[0] === this;
-  }
-  /** Returns the input pattern string */
-  toString() {
-    return this.pattern;
-  }
-  _getDecodedParamValue(value, param) {
-    return param.value(value);
-  }
-  /**
-   * Tests the specified url/path against this matcher.
-   *
-   * Tests if the given url matches this matcher's pattern, and returns an object containing the captured
-   * parameter values.  Returns null if the path does not match.
-   *
-   * The returned object contains the values
-   * of any search parameters that are mentioned in the pattern, but their value may be null if
-   * they are not present in `search`. This means that search parameters are always treated
-   * as optional.
-   *
-   * #### Example:
-   * ```js
-   * new UrlMatcher('/user/{id}?q&r').exec('/user/bob', {
-   *   x: '1', q: 'hello'
-   * });
-   * // returns { id: 'bob', q: 'hello', r: null }
-   * ```
-   *
-   * @param path    The URL path to match, e.g. `$location.getPath()`.
-   * @param search  URL search parameters, e.g. `$location.getSearch()`.
-   * @param hash    URL hash e.g. `$location.getHash()`.
-   *
-   * @returns The captured parameter values.
-   */
-  exec(path, search = {}, hash) {
-    const match = memoizeTo(this._cache, "pattern", () => {
-      return new RegExp(
-        [
-          "^",
-          unnest(this._cache.path.map((x) => x._compiled)).join(""),
-          this.config.strict === false ? "/?" : "",
-          "$",
-        ].join(""),
-        this.config.caseInsensitive ? "i" : undefined,
-      );
-    }).exec(path);
-    if (!match) return null;
-    // options = defaults(options, { isolate: false });
-    const allParams = this.parameters(),
-      pathParams = allParams.filter((param) => !param.isSearch()),
-      searchParams = allParams.filter((param) => param.isSearch()),
-      nPathSegments = this._cache.path
-        .map((urlm) => urlm._segments.length - 1)
-        .reduce((a, x) => a + x),
-      values = {};
-    if (nPathSegments !== match.length - 1)
-      throw new Error(`Unbalanced capture group in route '${this.pattern}'`);
-    function decodePathArray(paramVal) {
-      const reverseString = (str) => str.split("").reverse().join("");
-      const unquoteDashes = (str) => str.replace(/\\-/g, "-");
-      const split = reverseString(paramVal).split(/-(?!\\)/);
-      const allReversed = map(split, reverseString);
-      return map(allReversed, unquoteDashes).reverse();
-    }
-    for (let i = 0; i < nPathSegments; i++) {
-      const param = pathParams[i];
-      let value = match[i + 1];
-      // if the param value matches a pre-replace pair, replace the value before decoding.
-      for (let j = 0; j < param.replace.length; j++) {
-        if (param.replace[j].from === value) value = param.replace[j].to;
-      }
-      if (value && param.array === true) value = decodePathArray(value);
-      values[param.id] = this._getDecodedParamValue(value, param);
-    }
-    searchParams.forEach((param) => {
-      let value = search[param.id];
-      for (let j = 0; j < param.replace.length; j++) {
-        if (param.replace[j].from === value) value = param.replace[j].to;
-      }
-      values[param.id] = this._getDecodedParamValue(value, param);
-    });
-    if (hash) values["#"] = hash;
-    return values;
-  }
-  /**
-   * @internal
-   * Returns all the [[Param]] objects of all path and search parameters of this pattern in order of appearance.
-   *
-   * @returns {Array.<Param>}  An array of [[Param]] objects. Must be treated as read-only. If the
-   *    pattern has no parameters, an empty array is returned.
-   */
-  parameters(opts = {}) {
-    if (opts.inherit === false) return this._params;
-    return unnest(this._cache.path.map((matcher) => matcher._params));
-  }
-  /**
-   * @internal
-   * Returns a single parameter from this UrlMatcher by id
-   *
-   * @param id
-   * @param opts
-   * @returns {Param|any|boolean|UrlMatcher|null}
-   */
-  parameter(id, opts = {}) {
-    const findParam = () => {
-      for (const param of this._params) {
-        if (param.id === id) return param;
-      }
-    };
-    const parent = this._cache.parent;
-    return (
-      findParam() ||
-      (opts.inherit !== false && parent && parent.parameter(id, opts)) ||
-      null
-    );
-  }
-  /**
-   * Validates the input parameter values against this UrlMatcher
-   *
-   * Checks an object hash of parameters to validate their correctness according to the parameter
-   * types of this `UrlMatcher`.
-   *
-   * @param params The object hash of parameters to validate.
-   * @returns Returns `true` if `params` validates, otherwise `false`.
-   */
-  validates(params) {
-    const validParamVal = (param, val) => !param || param.validates(val);
-    params = params || {};
-    // I'm not sure why this checks only the param keys passed in, and not all the params known to the matcher
-    const paramSchema = this.parameters().filter((paramDef) =>
-      hasOwn(params, paramDef.id),
-    );
-    return paramSchema
-      .map((paramDef) => validParamVal(paramDef, params[paramDef.id]))
-      .reduce(allTrueR, true);
-  }
-  /**
-   * Given a set of parameter values, creates a URL from this UrlMatcher.
-   *
-   * Creates a URL that matches this pattern by substituting the specified values
-   * for the path and search parameters.
-   *
-   * #### Example:
-   * ```js
-   * new UrlMatcher('/user/{id}?q').format({ id:'bob', q:'yes' });
-   * // returns '/user/bob?q=yes'
-   * ```
-   *
-   * @param values  the values to substitute for the parameters in this pattern.
-   * @returns the formatted URL (path and optionally search part).
-   */
-  format(values = {}) {
-    // Build the full path of UrlMatchers (including all parent UrlMatchers)
-    const urlMatchers = this._cache.path;
-    // Extract all the static segments and Params (processed as ParamDetails)
-    // into an ordered array
-    const pathSegmentsAndParams = urlMatchers
-      .map(UrlMatcher.pathSegmentsAndParams)
-      .reduce(unnestR, [])
-      .map((x) => (isString(x) ? x : getDetails(x)));
-    // Extract the query params into a separate array
-    const queryParams = urlMatchers
-      .map(UrlMatcher.queryParams)
-      .reduce(unnestR, [])
-      .map(getDetails);
-    const isInvalid = (param) => param.isValid === false;
-    if (pathSegmentsAndParams.concat(queryParams).filter(isInvalid).length) {
-      return null;
-    }
-    /**
-     * Given a Param, applies the parameter value, then returns detailed information about it
-     */
-    function getDetails(param) {
-      // Normalize to typed value
-      const value = param.value(values[param.id]);
-      const isValid = param.validates(value);
-      const isDefaultValue = param.isDefaultValue(value);
-      // Check if we're in squash mode for the parameter
-      const squash = isDefaultValue ? param.squash : false;
-      // Allow the Parameter's Type to encode the value
-      const encoded = param.type.encode(value);
-      return { param, value, isValid, isDefaultValue, squash, encoded };
-    }
-    // Build up the path-portion from the list of static segments and parameters
-    const pathString = pathSegmentsAndParams.reduce((acc, x) => {
-      // The element is a static segment (a raw string); just append it
-      if (isString(x)) return acc + x;
-      // Otherwise, it's a ParamDetails.
-      const { squash, encoded, param } = x;
-      // If squash is === true, try to remove a slash from the path
-      if (squash === true) return acc.match(/\/$/) ? acc.slice(0, -1) : acc;
-      // If squash is a string, use the string for the param value
-      if (isString(squash)) return acc + squash;
-      if (squash !== false) return acc; // ?
-      if (encoded == null) return acc;
-      // If this parameter value is an array, encode the value using encodeDashes
-      if (Array.isArray(encoded))
-        return acc + map(encoded, encodeDashes).join("-");
-      // If the parameter type is "raw", then do not encodeURIComponent
-      if (param.raw) return acc + encoded;
-      // Encode the value
-      return acc + encodeURIComponent(encoded);
-    }, "");
-    // Build the query string by applying parameter values (array or regular)
-    // then mapping to key=value, then flattening and joining using "&"
-    const queryString = queryParams
-      .map((paramDetails) => {
-        let { param, squash, encoded, isDefaultValue } = paramDetails;
-        if (encoded == null || (isDefaultValue && squash !== false)) return;
-        if (!Array.isArray(encoded)) encoded = [encoded];
-        if (encoded.length === 0) return;
-        if (!param.raw) encoded = map(encoded, encodeURIComponent);
-        return encoded.map((val) => `${param.id}=${val}`);
-      })
-      .reduce(unnestR, [])
-      .join("&");
-    // Concat the pathstring with the queryString (if exists) and the hashString (if exists)
-    return (
-      pathString +
-      (queryString ? `?${queryString}` : "") +
-      (values["#"] ? "#" + values["#"] : "")
-    );
-  }
-}
-
-UrlMatcher.nameValidator = /^\w+([-.]+\w+)*(?:\[\])?$/;
-
-function encodeDashes(str) {
-  // Replace dashes with encoded "\-"
-  return encodeURIComponent(str).replace(
-    /-/g,
-    (c) => `%5C%${c.charCodeAt(0).toString(16).toUpperCase()}`,
-  );
-}