discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/internal-test-helpers/lib/test-cases/query-param.js

@@ -1,124 +0,0 @@
-import Controller from '@ember/controller';
-import { NoneLocation } from 'ember-routing';
-import { run } from '@ember/runloop';
-
-import ApplicationTestCase from './application';
-
-export default class QueryParamTestCase extends ApplicationTestCase {
-  constructor() {
-    super(...arguments);
-
-    let testCase = this;
-    testCase.expectedPushURL = null;
-    testCase.expectedReplaceURL = null;
-    this.add(
-      'location:test',
-      NoneLocation.extend({
-        setURL(path) {
-          if (testCase.expectedReplaceURL) {
-            testCase.assert.ok(false, 'pushState occurred but a replaceState was expected');
-          }
-
-          if (testCase.expectedPushURL) {
-            testCase.assert.equal(path, testCase.expectedPushURL, 'an expected pushState occurred');
-            testCase.expectedPushURL = null;
-          }
-
-          this.set('path', path);
-        },
-
-        replaceURL(path) {
-          if (testCase.expectedPushURL) {
-            testCase.assert.ok(false, 'replaceState occurred but a pushState was expected');
-          }
-
-          if (testCase.expectedReplaceURL) {
-            testCase.assert.equal(
-              path,
-              testCase.expectedReplaceURL,
-              'an expected replaceState occurred'
-            );
-            testCase.expectedReplaceURL = null;
-          }
-
-          this.set('path', path);
-        },
-      })
-    );
-  }
-
-  visitAndAssert(path) {
-    return this.visit(...arguments).then(() => {
-      this.assertCurrentPath(path);
-    });
-  }
-
-  getController(name) {
-    return this.applicationInstance.lookup(`controller:${name}`);
-  }
-
-  getRoute(name) {
-    return this.applicationInstance.lookup(`route:${name}`);
-  }
-
-  get routerOptions() {
-    return {
-      location: 'test',
-    };
-  }
-
-  setAndFlush(obj, prop, value) {
-    return run(obj, 'set', prop, value);
-  }
-
-  assertCurrentPath(path, message = `current path equals '${path}'`) {
-    this.assert.equal(this.appRouter.get('location.path'), path, message);
-  }
-
-  /**
-    Sets up a Controller for a given route with a single query param and default
-    value. Can optionally extend the controller with an object.
-
-    @public
-    @method setSingleQPController
-  */
-  setSingleQPController(routeName, param = 'foo', defaultValue = 'bar', options = {}) {
-    this.add(
-      `controller:${routeName}`,
-      Controller.extend(
-        {
-          queryParams: [param],
-          [param]: defaultValue,
-        },
-        options
-      )
-    );
-  }
-
-  /**
-    Sets up a Controller for a given route with a custom property/url key mapping.
-
-    @public
-    @method setMappedQPController
-  */
-  setMappedQPController(
-    routeName,
-    prop = 'page',
-    urlKey = 'parentPage',
-    defaultValue = 1,
-    options = {}
-  ) {
-    this.add(
-      `controller:${routeName}`,
-      Controller.extend(
-        {
-          queryParams: {
-            [prop]: urlKey,
-          },
-          [prop]: defaultValue,
-        },
-        options
-      )
-    );
-  }
-}

data/dist/es/internal-test-helpers/lib/test-cases/rendering.js

@@ -1,14 +0,0 @@
-import AbstractRenderingTestCase from './abstract-rendering';
-import { privatize as P } from 'container';
-
-export default class RenderingTestCase extends AbstractRenderingTestCase {
-  constructor() {
-    super(...arguments);
-    let { owner } = this;
-
-    this.env = owner.lookup('service:-glimmer-environment');
-    this.templateOptions = owner.lookup(P`template-compiler:main`);
-    this.compileTimeLookup = this.templateOptions.resolver;
-    this.runtimeResolver = this.compileTimeLookup.resolver;
-  }
-}

data/dist/es/internal-test-helpers/lib/test-cases/router.js

@@ -1,26 +0,0 @@
-import ApplicationTestCase from './application';
-
-export default class RouterTestCase extends ApplicationTestCase {
-  constructor() {
-    super(...arguments);
-
-    this.router.map(function() {
-      this.route('parent', { path: '/' }, function() {
-        this.route('child');
-        this.route('sister');
-        this.route('brother');
-      });
-      this.route('dynamic', { path: '/dynamic/:dynamic_id' });
-    });
-  }
-
-  get routerService() {
-    return this.applicationInstance.lookup('service:router');
-  }
-
-  buildQueryParams(queryParams) {
-    return {
-      queryParams,
-    };
-  }
-}

data/dist/es/internal-test-helpers/lib/test-cases/test-resolver-application.js

@@ -1,40 +0,0 @@
-import AbstractApplicationTestCase from './abstract-application';
-import { ModuleBasedResolver } from '../test-resolver';
-import { Component } from 'ember-glimmer';
-import { assign } from '@ember/polyfills';
-
-export default class TestResolverApplicationTestCase extends AbstractApplicationTestCase {
-  get applicationOptions() {
-    return assign(super.applicationOptions, {
-      Resolver: ModuleBasedResolver,
-    });
-  }
-
-  add(specifier, factory) {
-    this.resolver.add(specifier, factory);
-  }
-
-  addTemplate(templateName, templateString) {
-    this.resolver.add(
-      `template:${templateName}`,
-      this.compile(templateString, {
-        moduleName: `my-app/templates/${templateName}.hbs`,
-      })
-    );
-  }
-
-  addComponent(name, { ComponentClass = Component, template = null }) {
-    if (ComponentClass) {
-      this.resolver.add(`component:${name}`, ComponentClass);
-    }
-
-    if (typeof template === 'string') {
-      this.resolver.add(
-        `template:components/${name}`,
-        this.compile(template, {
-          moduleName: `my-app/templates/components/${name}.hbs`,
-        })
-      );
-    }
-  }
-}

data/dist/es/internal-test-helpers/lib/test-resolver.js

@@ -1,86 +0,0 @@
-import { compile } from 'ember-template-compiler';
-
-const DELIMITER = '%';
-
-function serializeKey(specifier, source, namespace) {
-  let [type, name] = specifier.split(':');
-  return `${type}://${[
-    name,
-    namespace ? '[source invalid due to namespace]' : source,
-    namespace,
-  ].join(DELIMITER)}`;
-}
-
-class Resolver {
-  constructor() {
-    this._registered = {};
-  }
-  resolve(specifier) {
-    return this._registered[specifier] || this._registered[serializeKey(specifier)];
-  }
-  expandLocalLookup(specifier, source, namespace) {
-    if (specifier.indexOf('://') !== -1) {
-      return specifier; // an already expanded specifier
-    }
-
-    if (source || namespace) {
-      let key = serializeKey(specifier, source, namespace);
-      if (this._registered[key]) {
-        return key; // like local lookup
-      }
-
-      key = serializeKey(specifier);
-      if (this._registered[key]) {
-        return specifier; // top level resolution despite source/namespace
-      }
-    }
-
-    return specifier; // didn't know how to expand it
-  }
-  add(lookup, factory) {
-    let key;
-    switch (typeof lookup) {
-      case 'string':
-        if (lookup.indexOf(':') === -1) {
-          throw new Error('Specifiers added to the resolver must be in the format of type:name');
-        }
-        key = serializeKey(lookup);
-        break;
-      case 'object':
-        key = serializeKey(lookup.specifier, lookup.source, lookup.namespace);
-        break;
-      default:
-        throw new Error('Specifier string has an unknown type');
-    }
-
-    return (this._registered[key] = factory);
-  }
-  addTemplate(templateName, template) {
-    let templateType = typeof template;
-    if (templateType !== 'string') {
-      throw new Error(
-        `You called addTemplate for "${templateName}" with a template argument of type of '${templateType}'. addTemplate expects an argument of an uncompiled template as a string.`
-      );
-    }
-    return (this._registered[serializeKey(`template:${templateName}`)] = compile(template, {
-      moduleName: `my-app/templates/${templateName}.hbs`,
-    }));
-  }
-  static create() {
-    return new this();
-  }
-}
-
-export default Resolver;
-
-/*
- * A resolver with moduleBasedResolver = true handles error and loading
- * substates differently than a standard resolver.
- */
-class ModuleBasedResolver extends Resolver {
-  get moduleBasedResolver() {
-    return true;
-  }
-}
-
-export { ModuleBasedResolver };

data/dist/es/internal-test-helpers/tests/index-test.js

@@ -1,10 +0,0 @@
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'internal-test-helpers',
-  class extends AbstractTestCase {
-    ['@test module present'](assert) {
-      assert.ok(true, 'each package needs at least one test to be able to run through `npm test`');
-    }
-  }
-);

data/dist/es/route-recognizer.js

@@ -1,685 +0,0 @@
-var createObject = Object.create;
-function createMap() {
-    var map = createObject(null);
-    map["__"] = undefined;
-    delete map["__"];
-    return map;
-}
-
-var Target = function Target(path, matcher, delegate) {
-    this.path = path;
-    this.matcher = matcher;
-    this.delegate = delegate;
-};
-Target.prototype.to = function to (target, callback) {
-    var delegate = this.delegate;
-    if (delegate && delegate.willAddRoute) {
-        target = delegate.willAddRoute(this.matcher.target, target);
-    }
-    this.matcher.add(this.path, target);
-    if (callback) {
-        if (callback.length === 0) {
-            throw new Error("You must have an argument in the function passed to `to`");
-        }
-        this.matcher.addChild(this.path, target, callback, this.delegate);
-    }
-};
-var Matcher = function Matcher(target) {
-    this.routes = createMap();
-    this.children = createMap();
-    this.target = target;
-};
-Matcher.prototype.add = function add (path, target) {
-    this.routes[path] = target;
-};
-Matcher.prototype.addChild = function addChild (path, target, callback, delegate) {
-    var matcher = new Matcher(target);
-    this.children[path] = matcher;
-    var match = generateMatch(path, matcher, delegate);
-    if (delegate && delegate.contextEntered) {
-        delegate.contextEntered(target, match);
-    }
-    callback(match);
-};
-function generateMatch(startingPath, matcher, delegate) {
-    function match(path, callback) {
-        var fullPath = startingPath + path;
-        if (callback) {
-            callback(generateMatch(fullPath, matcher, delegate));
-        }
-        else {
-            return new Target(fullPath, matcher, delegate);
-        }
-    }
-    
-    return match;
-}
-function addRoute(routeArray, path, handler) {
-    var len = 0;
-    for (var i = 0; i < routeArray.length; i++) {
-        len += routeArray[i].path.length;
-    }
-    path = path.substr(len);
-    var route = { path: path, handler: handler };
-    routeArray.push(route);
-}
-function eachRoute(baseRoute, matcher, callback, binding) {
-    var routes = matcher.routes;
-    var paths = Object.keys(routes);
-    for (var i = 0; i < paths.length; i++) {
-        var path = paths[i];
-        var routeArray = baseRoute.slice();
-        addRoute(routeArray, path, routes[path]);
-        var nested = matcher.children[path];
-        if (nested) {
-            eachRoute(routeArray, nested, callback, binding);
-        }
-        else {
-            callback.call(binding, routeArray);
-        }
-    }
-}
-var map = function (callback, addRouteCallback) {
-    var matcher = new Matcher();
-    callback(generateMatch("", matcher, this.delegate));
-    eachRoute([], matcher, function (routes) {
-        if (addRouteCallback) {
-            addRouteCallback(this, routes);
-        }
-        else {
-            this.add(routes);
-        }
-    }, this);
-};
-
-// Normalizes percent-encoded values in `path` to upper-case and decodes percent-encoded
-// values that are not reserved (i.e., unicode characters, emoji, etc). The reserved
-// chars are "/" and "%".
-// Safe to call multiple times on the same path.
-// Normalizes percent-encoded values in `path` to upper-case and decodes percent-encoded
-function normalizePath(path) {
-    return path.split("/")
-        .map(normalizeSegment)
-        .join("/");
-}
-// We want to ensure the characters "%" and "/" remain in percent-encoded
-// form when normalizing paths, so replace them with their encoded form after
-// decoding the rest of the path
-var SEGMENT_RESERVED_CHARS = /%|\//g;
-function normalizeSegment(segment) {
-    if (segment.length < 3 || segment.indexOf("%") === -1)
-        { return segment; }
-    return decodeURIComponent(segment).replace(SEGMENT_RESERVED_CHARS, encodeURIComponent);
-}
-// We do not want to encode these characters when generating dynamic path segments
-// See https://tools.ietf.org/html/rfc3986#section-3.3
-// sub-delims: "!", "$", "&", "'", "(", ")", "*", "+", ",", ";", "="
-// others allowed by RFC 3986: ":", "@"
-//
-// First encode the entire path segment, then decode any of the encoded special chars.
-//
-// The chars "!", "'", "(", ")", "*" do not get changed by `encodeURIComponent`,
-// so the possible encoded chars are:
-// ['%24', '%26', '%2B', '%2C', '%3B', '%3D', '%3A', '%40'].
-var PATH_SEGMENT_ENCODINGS = /%(?:2(?:4|6|B|C)|3(?:B|D|A)|40)/g;
-function encodePathSegment(str) {
-    return encodeURIComponent(str).replace(PATH_SEGMENT_ENCODINGS, decodeURIComponent);
-}
-
-var escapeRegex = /(\/|\.|\*|\+|\?|\||\(|\)|\[|\]|\{|\}|\\)/g;
-var isArray = Array.isArray;
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-function getParam(params, key) {
-    if (typeof params !== "object" || params === null) {
-        throw new Error("You must pass an object as the second argument to `generate`.");
-    }
-    if (!hasOwnProperty.call(params, key)) {
-        throw new Error("You must provide param `" + key + "` to `generate`.");
-    }
-    var value = params[key];
-    var str = typeof value === "string" ? value : "" + value;
-    if (str.length === 0) {
-        throw new Error("You must provide a param `" + key + "`.");
-    }
-    return str;
-}
-var eachChar = [];
-eachChar[0 /* Static */] = function (segment, currentState) {
-    var state = currentState;
-    var value = segment.value;
-    for (var i = 0; i < value.length; i++) {
-        var ch = value.charCodeAt(i);
-        state = state.put(ch, false, false);
-    }
-    return state;
-};
-eachChar[1 /* Dynamic */] = function (_, currentState) {
-    return currentState.put(47 /* SLASH */, true, true);
-};
-eachChar[2 /* Star */] = function (_, currentState) {
-    return currentState.put(-1 /* ANY */, false, true);
-};
-eachChar[4 /* Epsilon */] = function (_, currentState) {
-    return currentState;
-};
-var regex = [];
-regex[0 /* Static */] = function (segment) {
-    return segment.value.replace(escapeRegex, "\\$1");
-};
-regex[1 /* Dynamic */] = function () {
-    return "([^/]+)";
-};
-regex[2 /* Star */] = function () {
-    return "(.+)";
-};
-regex[4 /* Epsilon */] = function () {
-    return "";
-};
-var generate = [];
-generate[0 /* Static */] = function (segment) {
-    return segment.value;
-};
-generate[1 /* Dynamic */] = function (segment, params) {
-    var value = getParam(params, segment.value);
-    if (RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS) {
-        return encodePathSegment(value);
-    }
-    else {
-        return value;
-    }
-};
-generate[2 /* Star */] = function (segment, params) {
-    return getParam(params, segment.value);
-};
-generate[4 /* Epsilon */] = function () {
-    return "";
-};
-var EmptyObject = Object.freeze({});
-var EmptyArray = Object.freeze([]);
-// The `names` will be populated with the paramter name for each dynamic/star
-// segment. `shouldDecodes` will be populated with a boolean for each dyanamic/star
-// segment, indicating whether it should be decoded during recognition.
-function parse(segments, route, types) {
-    // normalize route as not starting with a "/". Recognition will
-    // also normalize.
-    if (route.length > 0 && route.charCodeAt(0) === 47 /* SLASH */) {
-        route = route.substr(1);
-    }
-    var parts = route.split("/");
-    var names = undefined;
-    var shouldDecodes = undefined;
-    for (var i = 0; i < parts.length; i++) {
-        var part = parts[i];
-        var flags = 0;
-        var type = 0;
-        if (part === "") {
-            type = 4 /* Epsilon */;
-        }
-        else if (part.charCodeAt(0) === 58 /* COLON */) {
-            type = 1 /* Dynamic */;
-        }
-        else if (part.charCodeAt(0) === 42 /* STAR */) {
-            type = 2 /* Star */;
-        }
-        else {
-            type = 0 /* Static */;
-        }
-        flags = 2 << type;
-        if (flags & 12 /* Named */) {
-            part = part.slice(1);
-            names = names || [];
-            names.push(part);
-            shouldDecodes = shouldDecodes || [];
-            shouldDecodes.push((flags & 4 /* Decoded */) !== 0);
-        }
-        if (flags & 14 /* Counted */) {
-            types[type]++;
-        }
-        segments.push({
-            type: type,
-            value: normalizeSegment(part)
-        });
-    }
-    return {
-        names: names || EmptyArray,
-        shouldDecodes: shouldDecodes || EmptyArray,
-    };
-}
-function isEqualCharSpec(spec, char, negate) {
-    return spec.char === char && spec.negate === negate;
-}
-// A State has a character specification and (`charSpec`) and a list of possible
-// subsequent states (`nextStates`).
-//
-// If a State is an accepting state, it will also have several additional
-// properties:
-//
-// * `regex`: A regular expression that is used to extract parameters from paths
-//   that reached this accepting state.
-// * `handlers`: Information on how to convert the list of captures into calls
-//   to registered handlers with the specified parameters
-// * `types`: How many static, dynamic or star segments in this route. Used to
-//   decide which route to use if multiple registered routes match a path.
-//
-// Currently, State is implemented naively by looping over `nextStates` and
-// comparing a character specification against a character. A more efficient
-// implementation would use a hash of keys pointing at one or more next states.
-var State = function State(states, id, char, negate, repeat) {
-    this.states = states;
-    this.id = id;
-    this.char = char;
-    this.negate = negate;
-    this.nextStates = repeat ? id : null;
-    this.pattern = "";
-    this._regex = undefined;
-    this.handlers = undefined;
-    this.types = undefined;
-};
-State.prototype.regex = function regex$1 () {
-    if (!this._regex) {
-        this._regex = new RegExp(this.pattern);
-    }
-    return this._regex;
-};
-State.prototype.get = function get (char, negate) {
-        var this$1 = this;
-
-    var nextStates = this.nextStates;
-    if (nextStates === null)
-        { return; }
-    if (isArray(nextStates)) {
-        for (var i = 0; i < nextStates.length; i++) {
-            var child = this$1.states[nextStates[i]];
-            if (isEqualCharSpec(child, char, negate)) {
-                return child;
-            }
-        }
-    }
-    else {
-        var child$1 = this.states[nextStates];
-        if (isEqualCharSpec(child$1, char, negate)) {
-            return child$1;
-        }
-    }
-};
-State.prototype.put = function put (char, negate, repeat) {
-    var state;
-    // If the character specification already exists in a child of the current
-    // state, just return that state.
-    if (state = this.get(char, negate)) {
-        return state;
-    }
-    // Make a new state for the character spec
-    var states = this.states;
-    state = new State(states, states.length, char, negate, repeat);
-    states[states.length] = state;
-    // Insert the new state as a child of the current state
-    if (this.nextStates == null) {
-        this.nextStates = state.id;
-    }
-    else if (isArray(this.nextStates)) {
-        this.nextStates.push(state.id);
-    }
-    else {
-        this.nextStates = [this.nextStates, state.id];
-    }
-    // Return the new state
-    return state;
-};
-// Find a list of child states matching the next character
-State.prototype.match = function match (ch) {
-        var this$1 = this;
-
-    var nextStates = this.nextStates;
-    if (!nextStates)
-        { return []; }
-    var returned = [];
-    if (isArray(nextStates)) {
-        for (var i = 0; i < nextStates.length; i++) {
-            var child = this$1.states[nextStates[i]];
-            if (isMatch(child, ch)) {
-                returned.push(child);
-            }
-        }
-    }
-    else {
-        var child$1 = this.states[nextStates];
-        if (isMatch(child$1, ch)) {
-            returned.push(child$1);
-        }
-    }
-    return returned;
-};
-function isMatch(spec, char) {
-    return spec.negate ? spec.char !== char && spec.char !== -1 /* ANY */ : spec.char === char || spec.char === -1 /* ANY */;
-}
-// This is a somewhat naive strategy, but should work in a lot of cases
-// A better strategy would properly resolve /posts/:id/new and /posts/edit/:id.
-//
-// This strategy generally prefers more static and less dynamic matching.
-// Specifically, it
-//
-//  * prefers fewer stars to more, then
-//  * prefers using stars for less of the match to more, then
-//  * prefers fewer dynamic segments to more, then
-//  * prefers more static segments to more
-function sortSolutions(states) {
-    return states.sort(function (a, b) {
-        var ref = a.types || [0, 0, 0];
-        var astatics = ref[0];
-        var adynamics = ref[1];
-        var astars = ref[2];
-        var ref$1 = b.types || [0, 0, 0];
-        var bstatics = ref$1[0];
-        var bdynamics = ref$1[1];
-        var bstars = ref$1[2];
-        if (astars !== bstars) {
-            return astars - bstars;
-        }
-        if (astars) {
-            if (astatics !== bstatics) {
-                return bstatics - astatics;
-            }
-            if (adynamics !== bdynamics) {
-                return bdynamics - adynamics;
-            }
-        }
-        if (adynamics !== bdynamics) {
-            return adynamics - bdynamics;
-        }
-        if (astatics !== bstatics) {
-            return bstatics - astatics;
-        }
-        return 0;
-    });
-}
-function recognizeChar(states, ch) {
-    var nextStates = [];
-    for (var i = 0, l = states.length; i < l; i++) {
-        var state = states[i];
-        nextStates = nextStates.concat(state.match(ch));
-    }
-    return nextStates;
-}
-var RecognizeResults = function RecognizeResults(queryParams) {
-    this.length = 0;
-    this.queryParams = queryParams || {};
-};
-
-RecognizeResults.prototype.splice = Array.prototype.splice;
-RecognizeResults.prototype.slice = Array.prototype.slice;
-RecognizeResults.prototype.push = Array.prototype.push;
-function findHandler(state, originalPath, queryParams) {
-    var handlers = state.handlers;
-    var regex = state.regex();
-    if (!regex || !handlers)
-        { throw new Error("state not initialized"); }
-    var captures = originalPath.match(regex);
-    var currentCapture = 1;
-    var result = new RecognizeResults(queryParams);
-    result.length = handlers.length;
-    for (var i = 0; i < handlers.length; i++) {
-        var handler = handlers[i];
-        var names = handler.names;
-        var shouldDecodes = handler.shouldDecodes;
-        var params = EmptyObject;
-        var isDynamic = false;
-        if (names !== EmptyArray && shouldDecodes !== EmptyArray) {
-            for (var j = 0; j < names.length; j++) {
-                isDynamic = true;
-                var name = names[j];
-                var capture = captures && captures[currentCapture++];
-                if (params === EmptyObject) {
-                    params = {};
-                }
-                if (RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS && shouldDecodes[j]) {
-                    params[name] = capture && decodeURIComponent(capture);
-                }
-                else {
-                    params[name] = capture;
-                }
-            }
-        }
-        result[i] = {
-            handler: handler.handler,
-            params: params,
-            isDynamic: isDynamic
-        };
-    }
-    return result;
-}
-function decodeQueryParamPart(part) {
-    // http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4.1
-    part = part.replace(/\+/gm, "%20");
-    var result;
-    try {
-        result = decodeURIComponent(part);
-    }
-    catch (error) {
-        result = "";
-    }
-    return result;
-}
-var RouteRecognizer = function RouteRecognizer() {
-    this.names = createMap();
-    var states = [];
-    var state = new State(states, 0, -1 /* ANY */, true, false);
-    states[0] = state;
-    this.states = states;
-    this.rootState = state;
-};
-RouteRecognizer.prototype.add = function add (routes, options) {
-    var currentState = this.rootState;
-    var pattern = "^";
-    var types = [0, 0, 0];
-    var handlers = new Array(routes.length);
-    var allSegments = [];
-    var isEmpty = true;
-    var j = 0;
-    for (var i = 0; i < routes.length; i++) {
-        var route = routes[i];
-        var ref = parse(allSegments, route.path, types);
-            var names = ref.names;
-            var shouldDecodes = ref.shouldDecodes;
-        // preserve j so it points to the start of newly added segments
-        for (; j < allSegments.length; j++) {
-            var segment = allSegments[j];
-            if (segment.type === 4 /* Epsilon */) {
-                continue;
-            }
-            isEmpty = false;
-            // Add a "/" for the new segment
-            currentState = currentState.put(47 /* SLASH */, false, false);
-            pattern += "/";
-            // Add a representation of the segment to the NFA and regex
-            currentState = eachChar[segment.type](segment, currentState);
-            pattern += regex[segment.type](segment);
-        }
-        handlers[i] = {
-            handler: route.handler,
-            names: names,
-            shouldDecodes: shouldDecodes
-        };
-    }
-    if (isEmpty) {
-        currentState = currentState.put(47 /* SLASH */, false, false);
-        pattern += "/";
-    }
-    currentState.handlers = handlers;
-    currentState.pattern = pattern + "$";
-    currentState.types = types;
-    var name;
-    if (typeof options === "object" && options !== null && options.as) {
-        name = options.as;
-    }
-    if (name) {
-        // if (this.names[name]) {
-        //   throw new Error("You may not add a duplicate route named `" + name + "`.");
-        // }
-        this.names[name] = {
-            segments: allSegments,
-            handlers: handlers
-        };
-    }
-};
-RouteRecognizer.prototype.handlersFor = function handlersFor (name) {
-    var route = this.names[name];
-    if (!route) {
-        throw new Error("There is no route named " + name);
-    }
-    var result = new Array(route.handlers.length);
-    for (var i = 0; i < route.handlers.length; i++) {
-        var handler = route.handlers[i];
-        result[i] = handler;
-    }
-    return result;
-};
-RouteRecognizer.prototype.hasRoute = function hasRoute (name) {
-    return !!this.names[name];
-};
-RouteRecognizer.prototype.generate = function generate$1 (name, params) {
-    var route = this.names[name];
-    var output = "";
-    if (!route) {
-        throw new Error("There is no route named " + name);
-    }
-    var segments = route.segments;
-    for (var i = 0; i < segments.length; i++) {
-        var segment = segments[i];
-        if (segment.type === 4 /* Epsilon */) {
-            continue;
-        }
-        output += "/";
-        output += generate[segment.type](segment, params);
-    }
-    if (output.charAt(0) !== "/") {
-        output = "/" + output;
-    }
-    if (params && params.queryParams) {
-        output += this.generateQueryString(params.queryParams);
-    }
-    return output;
-};
-RouteRecognizer.prototype.generateQueryString = function generateQueryString (params) {
-    var pairs = [];
-    var keys = Object.keys(params);
-    keys.sort();
-    for (var i = 0; i < keys.length; i++) {
-        var key = keys[i];
-        var value = params[key];
-        if (value == null) {
-            continue;
-        }
-        var pair = encodeURIComponent(key);
-        if (isArray(value)) {
-            for (var j = 0; j < value.length; j++) {
-                var arrayPair = key + "[]" + "=" + encodeURIComponent(value[j]);
-                pairs.push(arrayPair);
-            }
-        }
-        else {
-            pair += "=" + encodeURIComponent(value);
-            pairs.push(pair);
-        }
-    }
-    if (pairs.length === 0) {
-        return "";
-    }
-    return "?" + pairs.join("&");
-};
-RouteRecognizer.prototype.parseQueryString = function parseQueryString (queryString) {
-    var pairs = queryString.split("&");
-    var queryParams = {};
-    for (var i = 0; i < pairs.length; i++) {
-        var pair = pairs[i].split("="), key = decodeQueryParamPart(pair[0]), keyLength = key.length, isArray = false, value = (void 0);
-        if (pair.length === 1) {
-            value = "true";
-        }
-        else {
-            // Handle arrays
-            if (keyLength > 2 && key.slice(keyLength - 2) === "[]") {
-                isArray = true;
-                key = key.slice(0, keyLength - 2);
-                if (!queryParams[key]) {
-                    queryParams[key] = [];
-                }
-            }
-            value = pair[1] ? decodeQueryParamPart(pair[1]) : "";
-        }
-        if (isArray) {
-            queryParams[key].push(value);
-        }
-        else {
-            queryParams[key] = value;
-        }
-    }
-    return queryParams;
-};
-RouteRecognizer.prototype.recognize = function recognize (path) {
-    var results;
-    var states = [this.rootState];
-    var queryParams = {};
-    var isSlashDropped = false;
-    var hashStart = path.indexOf("#");
-    if (hashStart !== -1) {
-        path = path.substr(0, hashStart);
-    }
-    var queryStart = path.indexOf("?");
-    if (queryStart !== -1) {
-        var queryString = path.substr(queryStart + 1, path.length);
-        path = path.substr(0, queryStart);
-        queryParams = this.parseQueryString(queryString);
-    }
-    if (path.charAt(0) !== "/") {
-        path = "/" + path;
-    }
-    var originalPath = path;
-    if (RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS) {
-        path = normalizePath(path);
-    }
-    else {
-        path = decodeURI(path);
-        originalPath = decodeURI(originalPath);
-    }
-    var pathLen = path.length;
-    if (pathLen > 1 && path.charAt(pathLen - 1) === "/") {
-        path = path.substr(0, pathLen - 1);
-        originalPath = originalPath.substr(0, originalPath.length - 1);
-        isSlashDropped = true;
-    }
-    for (var i = 0; i < path.length; i++) {
-        states = recognizeChar(states, path.charCodeAt(i));
-        if (!states.length) {
-            break;
-        }
-    }
-    var solutions = [];
-    for (var i$1 = 0; i$1 < states.length; i$1++) {
-        if (states[i$1].handlers) {
-            solutions.push(states[i$1]);
-        }
-    }
-    states = sortSolutions(solutions);
-    var state = solutions[0];
-    if (state && state.handlers) {
-        // if a trailing slash was dropped and a star segment is the last segment
-        // specified, put the trailing slash back
-        if (isSlashDropped && state.pattern && state.pattern.slice(-5) === "(.+)$") {
-            originalPath = originalPath + "/";
-        }
-        results = findHandler(state, originalPath, queryParams);
-    }
-    return results;
-};
-RouteRecognizer.VERSION = "0.3.3";
-// Set to false to opt-out of encoding and decoding path segments.
-// See https://github.com/tildeio/route-recognizer/pull/55
-RouteRecognizer.ENCODE_AND_DECODE_PATH_SEGMENTS = true;
-RouteRecognizer.Normalizer = {
-    normalizeSegment: normalizeSegment, normalizePath: normalizePath, encodePathSegment: encodePathSegment
-};
-RouteRecognizer.prototype.map = map;
-
-export default RouteRecognizer;
-
-//# sourceMappingURL=route-recognizer.es.js.map