@tinkoff/router 0.2.7 → 0.2.8

package/lib/tree/tree.es.js

@@ -0,0 +1,148 @@
+import each from '@tinkoff/utils/array/each';
+import find from '@tinkoff/utils/array/find';
+import findIndex from '@tinkoff/utils/array/findIndex';
+import { getParts, parse } from './utils.es.js';
+import { HISTORY_FALLBACK_REGEXP } from './constants.es.js';
+
+const createTree = (route) => {
+    return {
+        route,
+        children: Object.create(null),
+        parameters: [],
+    };
+};
+const createNavigationRoute = (route, pathname, params) => {
+    return {
+        ...route,
+        actualPath: pathname,
+        params: params !== null && params !== void 0 ? params : {},
+    };
+};
+class RouteTree {
+    constructor(routes) {
+        this.tree = createTree();
+        each((route) => this.addRoute(route), routes);
+    }
+    // eslint-disable-next-line max-statements
+    addRoute(route) {
+        const parts = getParts(route.path);
+        let currentTree = this.tree;
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            const parsed = parse(part);
+            if (parsed.type === 1 /* PartType.historyFallback */) {
+                currentTree.historyFallbackRoute = route;
+                return;
+            }
+            if (parsed.type === 2 /* PartType.wildcard */) {
+                currentTree.wildcardRoute = route;
+                return;
+            }
+            if (parsed.type === 3 /* PartType.parameter */) {
+                const { paramName, regexp, optional } = parsed;
+                // prevent from creating new entries for same route
+                const found = find((par) => par.key === part, currentTree.parameters);
+                if (found) {
+                    currentTree = found.tree;
+                }
+                else {
+                    const parameter = {
+                        key: part,
+                        paramName,
+                        regexp,
+                        optional,
+                        tree: createTree(),
+                    };
+                    if (regexp && !optional) {
+                        // insert parameters with regexp before
+                        const index = findIndex((par) => !par.regexp, currentTree.parameters);
+                        currentTree.parameters.splice(index, 0, parameter);
+                    }
+                    else {
+                        currentTree.parameters.push(parameter);
+                    }
+                    currentTree = parameter.tree;
+                }
+            }
+            else {
+                if (!currentTree.children[part]) {
+                    currentTree.children[part] = createTree();
+                }
+                currentTree = currentTree.children[part];
+            }
+        }
+        currentTree.route = route;
+    }
+    getRoute(pathname) {
+        return this.findRoute(pathname, 'route');
+    }
+    getWildcard(pathname) {
+        return this.findRoute(pathname, 'wildcardRoute');
+    }
+    getHistoryFallback(pathname) {
+        const route = this.findRoute(pathname, 'historyFallbackRoute');
+        return (route && {
+            ...route,
+            // remove <history-fallback> from path
+            actualPath: route.path.replace(HISTORY_FALLBACK_REGEXP, '') || '/',
+        });
+    }
+    // eslint-disable-next-line max-statements
+    findRoute(pathname, propertyName) {
+        // we should use exact match only for classic route
+        // as special routes (for not-found and history-fallback) are defined for whole subtree
+        const exactMatch = propertyName === 'route';
+        const parts = getParts(pathname);
+        const queue = [
+            [this.tree, 0],
+        ];
+        while (queue.length) {
+            const [currentTree, index, params] = queue.pop();
+            const { children, parameters } = currentTree;
+            // this flag mean we can only check for optional parameters
+            // as we didn't find static route for this path, but still may find
+            // some inner route inside optional branch
+            // the value of parameter will be empty in this case ofc
+            let optionalOnly = false;
+            if (index >= parts.length) {
+                if (currentTree[propertyName]) {
+                    return createNavigationRoute(currentTree[propertyName], pathname, params);
+                }
+                // here we cant check any options except for optional parameters
+                optionalOnly = true;
+            }
+            // first add to queue special routes (not-found or history-fallback) to check it after other cases, as it will be processed last
+            if (!exactMatch && currentTree[propertyName]) {
+                queue.push([currentTree, parts.length, params]);
+            }
+            const part = parts[index];
+            const child = children[part];
+            // then add checks for only optional
+            for (const param of parameters) {
+                const { optional, tree } = param;
+                if (optional) {
+                    queue.push([tree, index, params]);
+                }
+            }
+            if (optionalOnly) {
+                continue;
+            }
+            // for non-optional cases
+            for (let i = parameters.length - 1; i >= 0; i--) {
+                const param = parameters[i];
+                const { paramName, tree, regexp } = param;
+                const match = regexp === null || regexp === void 0 ? void 0 : regexp.exec(part);
+                const paramValue = regexp ? match === null || match === void 0 ? void 0 : match[1] : part;
+                if (paramValue) {
+                    queue.push([tree, index + 1, { ...params, [paramName]: paramValue }]);
+                }
+            }
+            if (child) {
+                // add checks for static child subtree last as it will be processed first after queue.pop
+                queue.push([child, index + 1, params]);
+            }
+        }
+    }
+}
+
+export { RouteTree };

package/lib/tree/tree.js

@@ -0,0 +1,158 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var each = require('@tinkoff/utils/array/each');
+var find = require('@tinkoff/utils/array/find');
+var findIndex = require('@tinkoff/utils/array/findIndex');
+var utils = require('./utils.js');
+var constants = require('./constants.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var each__default = /*#__PURE__*/_interopDefaultLegacy(each);
+var find__default = /*#__PURE__*/_interopDefaultLegacy(find);
+var findIndex__default = /*#__PURE__*/_interopDefaultLegacy(findIndex);
+
+const createTree = (route) => {
+    return {
+        route,
+        children: Object.create(null),
+        parameters: [],
+    };
+};
+const createNavigationRoute = (route, pathname, params) => {
+    return {
+        ...route,
+        actualPath: pathname,
+        params: params !== null && params !== void 0 ? params : {},
+    };
+};
+class RouteTree {
+    constructor(routes) {
+        this.tree = createTree();
+        each__default["default"]((route) => this.addRoute(route), routes);
+    }
+    // eslint-disable-next-line max-statements
+    addRoute(route) {
+        const parts = utils.getParts(route.path);
+        let currentTree = this.tree;
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            const parsed = utils.parse(part);
+            if (parsed.type === 1 /* PartType.historyFallback */) {
+                currentTree.historyFallbackRoute = route;
+                return;
+            }
+            if (parsed.type === 2 /* PartType.wildcard */) {
+                currentTree.wildcardRoute = route;
+                return;
+            }
+            if (parsed.type === 3 /* PartType.parameter */) {
+                const { paramName, regexp, optional } = parsed;
+                // prevent from creating new entries for same route
+                const found = find__default["default"]((par) => par.key === part, currentTree.parameters);
+                if (found) {
+                    currentTree = found.tree;
+                }
+                else {
+                    const parameter = {
+                        key: part,
+                        paramName,
+                        regexp,
+                        optional,
+                        tree: createTree(),
+                    };
+                    if (regexp && !optional) {
+                        // insert parameters with regexp before
+                        const index = findIndex__default["default"]((par) => !par.regexp, currentTree.parameters);
+                        currentTree.parameters.splice(index, 0, parameter);
+                    }
+                    else {
+                        currentTree.parameters.push(parameter);
+                    }
+                    currentTree = parameter.tree;
+                }
+            }
+            else {
+                if (!currentTree.children[part]) {
+                    currentTree.children[part] = createTree();
+                }
+                currentTree = currentTree.children[part];
+            }
+        }
+        currentTree.route = route;
+    }
+    getRoute(pathname) {
+        return this.findRoute(pathname, 'route');
+    }
+    getWildcard(pathname) {
+        return this.findRoute(pathname, 'wildcardRoute');
+    }
+    getHistoryFallback(pathname) {
+        const route = this.findRoute(pathname, 'historyFallbackRoute');
+        return (route && {
+            ...route,
+            // remove <history-fallback> from path
+            actualPath: route.path.replace(constants.HISTORY_FALLBACK_REGEXP, '') || '/',
+        });
+    }
+    // eslint-disable-next-line max-statements
+    findRoute(pathname, propertyName) {
+        // we should use exact match only for classic route
+        // as special routes (for not-found and history-fallback) are defined for whole subtree
+        const exactMatch = propertyName === 'route';
+        const parts = utils.getParts(pathname);
+        const queue = [
+            [this.tree, 0],
+        ];
+        while (queue.length) {
+            const [currentTree, index, params] = queue.pop();
+            const { children, parameters } = currentTree;
+            // this flag mean we can only check for optional parameters
+            // as we didn't find static route for this path, but still may find
+            // some inner route inside optional branch
+            // the value of parameter will be empty in this case ofc
+            let optionalOnly = false;
+            if (index >= parts.length) {
+                if (currentTree[propertyName]) {
+                    return createNavigationRoute(currentTree[propertyName], pathname, params);
+                }
+                // here we cant check any options except for optional parameters
+                optionalOnly = true;
+            }
+            // first add to queue special routes (not-found or history-fallback) to check it after other cases, as it will be processed last
+            if (!exactMatch && currentTree[propertyName]) {
+                queue.push([currentTree, parts.length, params]);
+            }
+            const part = parts[index];
+            const child = children[part];
+            // then add checks for only optional
+            for (const param of parameters) {
+                const { optional, tree } = param;
+                if (optional) {
+                    queue.push([tree, index, params]);
+                }
+            }
+            if (optionalOnly) {
+                continue;
+            }
+            // for non-optional cases
+            for (let i = parameters.length - 1; i >= 0; i--) {
+                const param = parameters[i];
+                const { paramName, tree, regexp } = param;
+                const match = regexp === null || regexp === void 0 ? void 0 : regexp.exec(part);
+                const paramValue = regexp ? match === null || match === void 0 ? void 0 : match[1] : part;
+                if (paramValue) {
+                    queue.push([tree, index + 1, { ...params, [paramName]: paramValue }]);
+                }
+            }
+            if (child) {
+                // add checks for static child subtree last as it will be processed first after queue.pop
+                queue.push([child, index + 1, params]);
+            }
+        }
+    }
+}
+
+exports.RouteTree = RouteTree;

package/lib/tree/utils.browser.js

@@ -0,0 +1,77 @@
+import map from '@tinkoff/utils/array/map';
+import { HISTORY_FALLBACK_REGEXP, WILDCARD_REGEXP, PARAMETER_DELIMITER, PARAM_PARSER_REGEXP } from './constants.browser.js';
+import { normalizeTrailingSlash } from '../utils.browser.js';
+
+const getParts = (pathname) => pathname
+    .split('/')
+    .slice(pathname.startsWith('/') ? 1 : 0, pathname.endsWith('/') ? -1 : Infinity);
+const isHistoryFallback = (part) => {
+    return HISTORY_FALLBACK_REGEXP.test(part);
+};
+const isWildcard = (part) => {
+    return WILDCARD_REGEXP.test(part);
+};
+const isParameterized = (part) => {
+    return part.includes(PARAMETER_DELIMITER);
+};
+const parseParameter = (part) => {
+    const [prefix = '', param, postfix = ''] = part.split(PARAMETER_DELIMITER);
+    const match = PARAM_PARSER_REGEXP.exec(param);
+    if (!match) {
+        throw new Error('parameters should satisfy pattern "prefix:paramName(regexp)\\?:postfix"');
+    }
+    const [, paramName, regexp, optional] = match;
+    const useRegexp = prefix || postfix || regexp;
+    return {
+        type: 3 /* PartType.parameter */,
+        paramName,
+        regexp: useRegexp
+            ? new RegExp(`^${prefix}(${regexp || '.+'})${optional ? '?' : ''}${postfix}$`)
+            : undefined,
+        optional: !!optional && !prefix && !postfix,
+    };
+};
+const parse = (part) => {
+    if (isHistoryFallback(part)) {
+        return { type: 1 /* PartType.historyFallback */ };
+    }
+    if (isWildcard(part)) {
+        return { type: 2 /* PartType.wildcard */ };
+    }
+    if (isParameterized(part)) {
+        return parseParameter(part);
+    }
+    return { type: 0 /* PartType.literal */, value: part };
+};
+const makePath = (pathname, params) => {
+    const parts = getParts(pathname);
+    const result = map((part) => {
+        var _a;
+        if (isHistoryFallback(part) || isWildcard(part)) {
+            throw new Error(`Pathname should be only a string with dynamic parameters, not a special string, got ${pathname}`);
+        }
+        if (isParameterized(part)) {
+            const [prefix = '', param = '', postfix = ''] = part.split(PARAMETER_DELIMITER);
+            const match = PARAM_PARSER_REGEXP.exec(param);
+            if (!match) {
+                throw new Error('parameters should satisfy pattern "prefix:paramName(regexp)\\?:postfix"');
+            }
+            const [, paramName, regexp, optional] = match;
+            const value = (_a = params[paramName]) === null || _a === void 0 ? void 0 : _a.toString();
+            if (optional && !value) {
+                return '';
+            }
+            if (!value) {
+                throw new Error(`value for parameter for ${paramName} should be defined in params`);
+            }
+            if (regexp && !new RegExp(regexp).test(value)) {
+                throw new Error(`passed parameter for ${paramName} should satisfy regxep: ${regexp}, got: ${value}`);
+            }
+            return prefix + value + postfix || part;
+        }
+        return part;
+    }, parts).join('/');
+    return normalizeTrailingSlash(`/${result}`, pathname.endsWith('/'));
+};
+
+export { getParts, isHistoryFallback, isParameterized, isWildcard, makePath, parse };

package/lib/tree/utils.es.js

@@ -0,0 +1,77 @@
+import map from '@tinkoff/utils/array/map';
+import { HISTORY_FALLBACK_REGEXP, WILDCARD_REGEXP, PARAMETER_DELIMITER, PARAM_PARSER_REGEXP } from './constants.es.js';
+import { normalizeTrailingSlash } from '../utils.es.js';
+
+const getParts = (pathname) => pathname
+    .split('/')
+    .slice(pathname.startsWith('/') ? 1 : 0, pathname.endsWith('/') ? -1 : Infinity);
+const isHistoryFallback = (part) => {
+    return HISTORY_FALLBACK_REGEXP.test(part);
+};
+const isWildcard = (part) => {
+    return WILDCARD_REGEXP.test(part);
+};
+const isParameterized = (part) => {
+    return part.includes(PARAMETER_DELIMITER);
+};
+const parseParameter = (part) => {
+    const [prefix = '', param, postfix = ''] = part.split(PARAMETER_DELIMITER);
+    const match = PARAM_PARSER_REGEXP.exec(param);
+    if (!match) {
+        throw new Error('parameters should satisfy pattern "prefix:paramName(regexp)\\?:postfix"');
+    }
+    const [, paramName, regexp, optional] = match;
+    const useRegexp = prefix || postfix || regexp;
+    return {
+        type: 3 /* PartType.parameter */,
+        paramName,
+        regexp: useRegexp
+            ? new RegExp(`^${prefix}(${regexp || '.+'})${optional ? '?' : ''}${postfix}$`)
+            : undefined,
+        optional: !!optional && !prefix && !postfix,
+    };
+};
+const parse = (part) => {
+    if (isHistoryFallback(part)) {
+        return { type: 1 /* PartType.historyFallback */ };
+    }
+    if (isWildcard(part)) {
+        return { type: 2 /* PartType.wildcard */ };
+    }
+    if (isParameterized(part)) {
+        return parseParameter(part);
+    }
+    return { type: 0 /* PartType.literal */, value: part };
+};
+const makePath = (pathname, params) => {
+    const parts = getParts(pathname);
+    const result = map((part) => {
+        var _a;
+        if (isHistoryFallback(part) || isWildcard(part)) {
+            throw new Error(`Pathname should be only a string with dynamic parameters, not a special string, got ${pathname}`);
+        }
+        if (isParameterized(part)) {
+            const [prefix = '', param = '', postfix = ''] = part.split(PARAMETER_DELIMITER);
+            const match = PARAM_PARSER_REGEXP.exec(param);
+            if (!match) {
+                throw new Error('parameters should satisfy pattern "prefix:paramName(regexp)\\?:postfix"');
+            }
+            const [, paramName, regexp, optional] = match;
+            const value = (_a = params[paramName]) === null || _a === void 0 ? void 0 : _a.toString();
+            if (optional && !value) {
+                return '';
+            }
+            if (!value) {
+                throw new Error(`value for parameter for ${paramName} should be defined in params`);
+            }
+            if (regexp && !new RegExp(regexp).test(value)) {
+                throw new Error(`passed parameter for ${paramName} should satisfy regxep: ${regexp}, got: ${value}`);
+            }
+            return prefix + value + postfix || part;
+        }
+        return part;
+    }, parts).join('/');
+    return normalizeTrailingSlash(`/${result}`, pathname.endsWith('/'));
+};
+
+export { getParts, isHistoryFallback, isParameterized, isWildcard, makePath, parse };

package/lib/tree/utils.js

@@ -0,0 +1,90 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var map = require('@tinkoff/utils/array/map');
+var constants = require('./constants.js');
+var utils = require('../utils.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var map__default = /*#__PURE__*/_interopDefaultLegacy(map);
+
+const getParts = (pathname) => pathname
+    .split('/')
+    .slice(pathname.startsWith('/') ? 1 : 0, pathname.endsWith('/') ? -1 : Infinity);
+const isHistoryFallback = (part) => {
+    return constants.HISTORY_FALLBACK_REGEXP.test(part);
+};
+const isWildcard = (part) => {
+    return constants.WILDCARD_REGEXP.test(part);
+};
+const isParameterized = (part) => {
+    return part.includes(constants.PARAMETER_DELIMITER);
+};
+const parseParameter = (part) => {
+    const [prefix = '', param, postfix = ''] = part.split(constants.PARAMETER_DELIMITER);
+    const match = constants.PARAM_PARSER_REGEXP.exec(param);
+    if (!match) {
+        throw new Error('parameters should satisfy pattern "prefix:paramName(regexp)\\?:postfix"');
+    }
+    const [, paramName, regexp, optional] = match;
+    const useRegexp = prefix || postfix || regexp;
+    return {
+        type: 3 /* PartType.parameter */,
+        paramName,
+        regexp: useRegexp
+            ? new RegExp(`^${prefix}(${regexp || '.+'})${optional ? '?' : ''}${postfix}$`)
+            : undefined,
+        optional: !!optional && !prefix && !postfix,
+    };
+};
+const parse = (part) => {
+    if (isHistoryFallback(part)) {
+        return { type: 1 /* PartType.historyFallback */ };
+    }
+    if (isWildcard(part)) {
+        return { type: 2 /* PartType.wildcard */ };
+    }
+    if (isParameterized(part)) {
+        return parseParameter(part);
+    }
+    return { type: 0 /* PartType.literal */, value: part };
+};
+const makePath = (pathname, params) => {
+    const parts = getParts(pathname);
+    const result = map__default["default"]((part) => {
+        var _a;
+        if (isHistoryFallback(part) || isWildcard(part)) {
+            throw new Error(`Pathname should be only a string with dynamic parameters, not a special string, got ${pathname}`);
+        }
+        if (isParameterized(part)) {
+            const [prefix = '', param = '', postfix = ''] = part.split(constants.PARAMETER_DELIMITER);
+            const match = constants.PARAM_PARSER_REGEXP.exec(param);
+            if (!match) {
+                throw new Error('parameters should satisfy pattern "prefix:paramName(regexp)\\?:postfix"');
+            }
+            const [, paramName, regexp, optional] = match;
+            const value = (_a = params[paramName]) === null || _a === void 0 ? void 0 : _a.toString();
+            if (optional && !value) {
+                return '';
+            }
+            if (!value) {
+                throw new Error(`value for parameter for ${paramName} should be defined in params`);
+            }
+            if (regexp && !new RegExp(regexp).test(value)) {
+                throw new Error(`passed parameter for ${paramName} should satisfy regxep: ${regexp}, got: ${value}`);
+            }
+            return prefix + value + postfix || part;
+        }
+        return part;
+    }, parts).join('/');
+    return utils.normalizeTrailingSlash(`/${result}`, pathname.endsWith('/'));
+};
+
+exports.getParts = getParts;
+exports.isHistoryFallback = isHistoryFallback;
+exports.isParameterized = isParameterized;
+exports.isWildcard = isWildcard;
+exports.makePath = makePath;
+exports.parse = parse;

package/lib/utils.browser.js

@@ -0,0 +1,35 @@
+import T from '@tinkoff/utils/function/T';
+
+const isFilePath = (pathname) => {
+    return /\/.+\.[^/]+$/.test(pathname);
+};
+const normalizeTrailingSlash = (pathname, trailingSlash = false) => {
+    const hasTrailingSlash = pathname.endsWith('/');
+    if (trailingSlash) {
+        return hasTrailingSlash || isFilePath(pathname) ? pathname : `${pathname}/`;
+    }
+    return pathname.length > 1 && hasTrailingSlash ? pathname.slice(0, -1) : pathname;
+};
+const normalizeManySlashes = (hrefOrPath) => {
+    const [href, ...search] = hrefOrPath.split('?');
+    return [href.replace(/\/+/g, '/').replace(/^(\w+):\//, '$1://'), ...search].join('?');
+};
+const isSameHost = typeof window === 'undefined'
+    ? T
+    : (url) => {
+        return !url.host || url.host === window.location.host;
+    };
+const makeNavigateOptions = (options) => {
+    if (typeof options === 'string') {
+        return { url: options };
+    }
+    return options;
+};
+const registerHook = (hooksSet, hook) => {
+    hooksSet.add(hook);
+    return () => {
+        hooksSet.delete(hook);
+    };
+};
+
+export { isFilePath, isSameHost, makeNavigateOptions, normalizeManySlashes, normalizeTrailingSlash, registerHook };

package/lib/utils.es.js

@@ -0,0 +1,35 @@
+import T from '@tinkoff/utils/function/T';
+
+const isFilePath = (pathname) => {
+    return /\/.+\.[^/]+$/.test(pathname);
+};
+const normalizeTrailingSlash = (pathname, trailingSlash = false) => {
+    const hasTrailingSlash = pathname.endsWith('/');
+    if (trailingSlash) {
+        return hasTrailingSlash || isFilePath(pathname) ? pathname : `${pathname}/`;
+    }
+    return pathname.length > 1 && hasTrailingSlash ? pathname.slice(0, -1) : pathname;
+};
+const normalizeManySlashes = (hrefOrPath) => {
+    const [href, ...search] = hrefOrPath.split('?');
+    return [href.replace(/\/+/g, '/').replace(/^(\w+):\//, '$1://'), ...search].join('?');
+};
+const isSameHost = typeof window === 'undefined'
+    ? T
+    : (url) => {
+        return !url.host || url.host === window.location.host;
+    };
+const makeNavigateOptions = (options) => {
+    if (typeof options === 'string') {
+        return { url: options };
+    }
+    return options;
+};
+const registerHook = (hooksSet, hook) => {
+    hooksSet.add(hook);
+    return () => {
+        hooksSet.delete(hook);
+    };
+};
+
+export { isFilePath, isSameHost, makeNavigateOptions, normalizeManySlashes, normalizeTrailingSlash, registerHook };

package/lib/utils.js

@@ -0,0 +1,48 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var T = require('@tinkoff/utils/function/T');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var T__default = /*#__PURE__*/_interopDefaultLegacy(T);
+
+const isFilePath = (pathname) => {
+    return /\/.+\.[^/]+$/.test(pathname);
+};
+const normalizeTrailingSlash = (pathname, trailingSlash = false) => {
+    const hasTrailingSlash = pathname.endsWith('/');
+    if (trailingSlash) {
+        return hasTrailingSlash || isFilePath(pathname) ? pathname : `${pathname}/`;
+    }
+    return pathname.length > 1 && hasTrailingSlash ? pathname.slice(0, -1) : pathname;
+};
+const normalizeManySlashes = (hrefOrPath) => {
+    const [href, ...search] = hrefOrPath.split('?');
+    return [href.replace(/\/+/g, '/').replace(/^(\w+):\//, '$1://'), ...search].join('?');
+};
+const isSameHost = typeof window === 'undefined'
+    ? T__default["default"]
+    : (url) => {
+        return !url.host || url.host === window.location.host;
+    };
+const makeNavigateOptions = (options) => {
+    if (typeof options === 'string') {
+        return { url: options };
+    }
+    return options;
+};
+const registerHook = (hooksSet, hook) => {
+    hooksSet.add(hook);
+    return () => {
+        hooksSet.delete(hook);
+    };
+};
+
+exports.isFilePath = isFilePath;
+exports.isSameHost = isSameHost;
+exports.makeNavigateOptions = makeNavigateOptions;
+exports.normalizeManySlashes = normalizeManySlashes;
+exports.normalizeTrailingSlash = normalizeTrailingSlash;
+exports.registerHook = registerHook;