@cedarjs/router 0.0.4

package/dist/cjs/useMatch.d.ts

@@ -0,0 +1,43 @@
+import type { FlattenSearchParams } from './util.js';
+type UseMatchOptions = {
+    routeParams?: Record<string, any>;
+    searchParams?: FlattenSearchParams;
+    matchSubPaths?: boolean;
+};
+/**
+ * Returns an object of { match: boolean; params: Record<string, unknown>; }
+ * If the path matches the current location `match` will be true.
+ * Params will be an object of the matched params, if there are any.
+ *
+ * Provide routeParams options to match specific route param values
+ * Provide searchParams options to match the current location.search
+ *
+ * This is useful for components that need to know "active" state, e.g.
+ * <NavLink>.
+ *
+ * Examples:
+ *
+ * Match search params key existence
+ * const match = useMatch('/about', { searchParams: ['category', 'page'] })
+ *
+ * Match search params key and value
+ * const match = useMatch('/items', { searchParams: [{page: 2}, {category: 'book'}] })
+ *
+ * Mix match
+ * const match = useMatch('/list', { searchParams: [{page: 2}, 'gtm'] })
+ *
+ * Match sub paths
+ * const match = useMatch('/product', { matchSubPaths: true })
+ *
+ * Match only specific route param values
+ * const match = useMatch('/product/{category}/{id}', { routeParams: { category: 'shirts' } })
+ */
+export declare const useMatch: (routePath: string, options?: UseMatchOptions) => {
+    match: boolean;
+    params?: undefined;
+} | {
+    match: boolean;
+    params: Record<string, unknown>;
+};
+export {};
+//# sourceMappingURL=useMatch.d.ts.map

package/dist/cjs/useMatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMatch.d.ts","sourceRoot":"","sources":["../../src/useMatch.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAA;AAEpD,KAAK,eAAe,GAAG;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACjC,YAAY,CAAC,EAAE,mBAAmB,CAAA;IAClC,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,QAAQ,cAAe,MAAM,YAAY,eAAe;;;;;;CAiDpE,CAAA"}

package/dist/cjs/useMatch.js

@@ -0,0 +1,72 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useMatch_exports = {};
+__export(useMatch_exports, {
+  useMatch: () => useMatch
+});
+module.exports = __toCommonJS(useMatch_exports);
+var import_location = require("./location.js");
+var import_util = require("./util.js");
+const useMatch = (routePath, options) => {
+  const location = (0, import_location.useLocation)();
+  if (!location) {
+    return { match: false };
+  }
+  if (options?.searchParams) {
+    const locationParams = new URLSearchParams(location.search);
+    const hasUnmatched = options.searchParams.some((param) => {
+      if (typeof param === "string") {
+        return !locationParams.has(param);
+      } else {
+        return Object.keys(param).some(
+          (key) => param[key] != locationParams.get(key)
+        );
+      }
+    });
+    if (hasUnmatched) {
+      return { match: false };
+    }
+  }
+  const matchInfo = (0, import_util.matchPath)(routePath, location.pathname, {
+    matchSubPaths: options?.matchSubPaths
+  });
+  if (!matchInfo.match) {
+    return { match: false };
+  }
+  const routeParams = Object.entries(options?.routeParams || {});
+  if (routeParams.length > 0) {
+    if (!isMatchWithParams(matchInfo) || !matchInfo.params) {
+      return { match: false };
+    }
+    const isParamMatch = routeParams.every(([key, value]) => {
+      return matchInfo.params[key] === value;
+    });
+    if (!isParamMatch) {
+      return { match: false };
+    }
+  }
+  return matchInfo;
+};
+function isMatchWithParams(match) {
+  return match !== null && typeof match === "object" && "params" in match;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useMatch
+});

package/dist/cjs/useRouteName.d.ts

@@ -0,0 +1,3 @@
+/** Gets the name of the current route (as defined in your Routes file) */
+export declare function useRouteName(): undefined;
+//# sourceMappingURL=useRouteName.d.ts.map

package/dist/cjs/useRouteName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRouteName.d.ts","sourceRoot":"","sources":["../../src/useRouteName.ts"],"names":[],"mappings":"AAOA,0EAA0E;AAC1E,wBAAgB,YAAY,cAS3B"}

package/dist/cjs/useRouteName.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useRouteName_exports = {};
+__export(useRouteName_exports, {
+  useRouteName: () => useRouteName
+});
+module.exports = __toCommonJS(useRouteName_exports);
+var import_router_context = require("./router-context.js");
+var import_index = require("./index.js");
+function useRouteName() {
+  const routerState = (0, import_router_context.useRouterState)();
+  const routeName = routerState.activeRouteName;
+  if (isAvailableRouteName(routeName)) {
+    return routeName;
+  }
+  return void 0;
+}
+function isAvailableRouteName(name) {
+  return typeof name === "string" && Object.keys(import_index.routes).includes(name);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useRouteName
+});

package/dist/cjs/useRoutePaths.d.ts

@@ -0,0 +1,4 @@
+import type { AvailableRoutes } from './index.js';
+export declare function useRoutePaths(): Record<string | number, string>;
+export declare function useRoutePath(routeName?: keyof AvailableRoutes): string | undefined;
+//# sourceMappingURL=useRoutePaths.d.ts.map

package/dist/cjs/useRoutePaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRoutePaths.d.ts","sourceRoot":"","sources":["../../src/useRoutePaths.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAGjD,wBAAgB,aAAa,oCAc5B;AAED,wBAAgB,YAAY,CAAC,SAAS,CAAC,EAAE,MAAM,eAAe,sBAW7D"}

package/dist/cjs/useRoutePaths.js

@@ -0,0 +1,50 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useRoutePaths_exports = {};
+__export(useRoutePaths_exports, {
+  useRoutePath: () => useRoutePath,
+  useRoutePaths: () => useRoutePaths
+});
+module.exports = __toCommonJS(useRoutePaths_exports);
+var import_router_context = require("./router-context.js");
+var import_useRouteName = require("./useRouteName.js");
+function useRoutePaths() {
+  const routerState = (0, import_router_context.useRouterState)();
+  const routePaths = Object.values(routerState.routes.pathRouteMap).reduce((routePathsAcc, currRoute) => {
+    if (currRoute.name) {
+      routePathsAcc[currRoute.name] = currRoute.path;
+    }
+    return routePathsAcc;
+  }, {});
+  return routePaths;
+}
+function useRoutePath(routeName) {
+  const currentRouteName = (0, import_useRouteName.useRouteName)();
+  const routePaths = useRoutePaths();
+  const name = routeName || currentRouteName;
+  if (!name) {
+    return void 0;
+  }
+  return routePaths[name];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useRoutePath,
+  useRoutePaths
+});

package/dist/cjs/util.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Get param name, type, and match for a route.
+ *
+ *  '/blog/{year}/{month}/{day:Int}/{filePath...}'
+ *   => [
+ *        ['year',     'String', '{year}'],
+ *        ['month',    'String', '{month}'],
+ *        ['day',      'Int',    '{day:Int}'],
+ *        ['filePath', 'Glob',   '{filePath...}']
+ *      ]
+ *
+ * Only exported to be able to test it
+ */
+export declare function paramsForRoute(route: string): string[][];
+export type TrailingSlashesTypes = 'never' | 'always' | 'preserve';
+export interface ParamType {
+    match?: RegExp;
+    parse?: (value: any) => unknown;
+}
+/**
+ * Determine if the given route is a match for the given pathname. If so,
+ * extract any named params and return them in an object.
+ *
+ * route         - The route path as specified in the <Route path={...} />
+ * pathname      - The pathname from the window.location.
+ * paramTypes    - The object containing all param type definitions.
+ * matchSubPaths - Also match sub routes
+ *
+ * Examples:
+ *
+ *  matchPath('/blog/{year}/{month}/{day}', '/blog/2019/12/07')
+ *  => { match: true, params: { year: '2019', month: '12', day: '07' }}
+ *
+ *  matchPath('/about', '/')
+ *  => { match: false }
+ *
+ *  matchPath('/post/{id:Int}', '/post/7')
+ *  => { match: true, params: { id: 7 }}
+ *
+ *  matchPath('/post/1', '/post/', { matchSubPaths: true })
+ *  => { match: true, params: {} }
+ */
+export declare function matchPath(routeDefinition: string, pathname: string, { userParamTypes, matchSubPaths, }?: {
+    userParamTypes?: Record<string, ParamType>;
+    matchSubPaths?: boolean;
+}): {
+    match: boolean;
+    params?: undefined;
+} | {
+    match: boolean;
+    params: Record<string, unknown>;
+};
+interface GetRouteRegexOptions {
+    matchSubPaths?: boolean;
+    allParamTypes?: Record<string, ParamType>;
+}
+/**
+ *  This function will return a regex for each route path i.e. /blog/{year}/{month}/{day}
+ *  will return a regex like /blog/([^/$1*]+)/([^/$1*]+)/([^/$1*]+)
+ *
+ * @returns
+ */
+export declare function getRouteRegexAndParams(route: string, { matchSubPaths, allParamTypes, }?: GetRouteRegexOptions | undefined): {
+    matchRegex: RegExp;
+    routeParams: string[][];
+    matchRegexString: string;
+};
+/**
+ * Parse the given search string into key/value pairs and return them in an
+ * object.
+ *
+ * Examples:
+ *
+ *  parseSearch('?key1=val1&key2=val2')
+ *  => { key1: 'val1', key2: 'val2' }
+ *
+ * @fixme
+ * This utility ignores keys with multiple values such as `?foo=1&foo=2`.
+ */
+export declare function parseSearch(search: string | string[][] | Record<string, string> | URLSearchParams | undefined): {};
+/**
+ * Validate a path to make sure it follows the router's rules. If any problems
+ * are found, a descriptive Error will be thrown, as problems with routes are
+ * critical enough to be considered fatal.
+ */
+export declare function validatePath(path: string, routeName: string): void;
+/**
+ * Take a given route path and replace any named parameters with those in the
+ * given args object. Any extra params not used in the path will be appended
+ * as key=value pairs in the search part.
+ *
+ * Examples:
+ *
+ *   replaceParams('/tags/{tag}', { tag: 'code', extra: 'foo' })
+ *   => '/tags/code?extra=foo
+ */
+export declare function replaceParams(route: string, args?: Record<string, unknown>): string;
+export type FlattenSearchParams = ReturnType<typeof flattenSearchParams>;
+/**
+ * Returns a flat array of search params
+ *
+ * `useMatch` hook options `searchParams` requires a flat array
+ *
+ * Example:
+ * ```
+ *   parseSearch('?key1=val1&key2=val2')
+ *   => { key1: 'val1', key2: 'val2' }
+ *
+ *   flattenSearchParams(parseSearch('?key1=val1&key2=val2'))
+ *   => [ { key1: 'val1' }, { key2: 'val2' } ]
+ * ```
+ */
+export declare function flattenSearchParams(queryString: string): Record<string, unknown>[];
+/**
+ * Detect if we're in an iframe.
+ *
+ * From https://stackoverflow.com/questions/326069/how-to-identify-if-a-webpage-is-being-loaded-inside-an-iframe-or-directly-into-t
+ */
+export declare function inIframe(): boolean;
+export {};
+//# sourceMappingURL=util.d.ts.map

package/dist/cjs/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,cAyB3C;AAED,MAAM,MAAM,oBAAoB,GAAG,OAAO,GAAG,QAAQ,GAAG,UAAU,CAAA;AAElE,MAAM,WAAW,SAAS;IACxB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,OAAO,CAAA;CAChC;AAwBD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,SAAS,CACvB,eAAe,EAAE,MAAM,EACvB,QAAQ,EAAE,MAAM,EAChB,EACE,cAAc,EACd,aAAa,GACd,GAAE;IACD,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;IAC1C,aAAa,CAAC,EAAE,OAAO,CAAA;CAIxB;;;;;;EA2CF;AAED,UAAU,oBAAoB;IAC5B,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;CAC1C;AACD;;;;;GAKG;AAEH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,EACb,EACE,aAAqB,EACrB,aAA8B,GAC/B,GAAE,oBAAoB,GAAG,SAAc;;;;EA+BzC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CACzB,MAAM,EACF,MAAM,GACN,MAAM,EAAE,EAAE,GACV,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACtB,eAAe,GACf,SAAS,MAWd;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,QAyC3D;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,UAgCnC;AAED,MAAM,MAAM,mBAAmB,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAExE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,6BAQtD;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,YAMvB"}

package/dist/cjs/util.js

@@ -0,0 +1,214 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var util_exports = {};
+__export(util_exports, {
+  flattenSearchParams: () => flattenSearchParams,
+  getRouteRegexAndParams: () => getRouteRegexAndParams,
+  inIframe: () => inIframe,
+  matchPath: () => matchPath,
+  paramsForRoute: () => paramsForRoute,
+  parseSearch: () => parseSearch,
+  replaceParams: () => replaceParams,
+  validatePath: () => validatePath
+});
+module.exports = __toCommonJS(util_exports);
+function paramsForRoute(route) {
+  const params = [...route.matchAll(/\{([^}]+)\}/g)];
+  return params.map((match) => match[1]).map((match) => {
+    const parts = match.split(":");
+    let name = parts[0];
+    if (name.endsWith("...")) {
+      name = name.slice(0, -3);
+    }
+    let type = parts[1];
+    if (!type) {
+      type = match.endsWith("...") ? "Glob" : "String";
+    }
+    return [name, type, `{${match}}`];
+  });
+}
+const coreParamTypes = {
+  String: {
+    match: /[^/]+/
+  },
+  Int: {
+    match: /\d+/,
+    parse: Number
+  },
+  Float: {
+    match: /[-+]?(?:\d*\.?\d+|\d+\.?\d*)(?:[eE][-+]?\d+)?/,
+    parse: Number
+  },
+  Boolean: {
+    match: /true|false/,
+    parse: (boolAsString) => boolAsString === "true"
+  },
+  Glob: {
+    match: /.*/
+  }
+};
+function matchPath(routeDefinition, pathname, {
+  userParamTypes,
+  matchSubPaths
+} = {
+  userParamTypes: {},
+  matchSubPaths: false
+}) {
+  const allParamTypes = { ...coreParamTypes, ...userParamTypes };
+  const { matchRegex, routeParams: routeParamsDefinition } = getRouteRegexAndParams(routeDefinition, {
+    matchSubPaths,
+    allParamTypes
+  });
+  const matches = [...pathname.matchAll(matchRegex)];
+  if (matches.length === 0) {
+    return { match: false };
+  }
+  const providedParams = matches[0].slice(1);
+  if (routeParamsDefinition.length > 0) {
+    const params = providedParams.reduce(
+      (acc, value, index) => {
+        const [name, transformName] = routeParamsDefinition[index];
+        const typeInfo = allParamTypes[transformName];
+        let transformedValue = value;
+        if (typeof typeInfo?.parse === "function") {
+          transformedValue = typeInfo.parse(value);
+        }
+        return {
+          ...acc,
+          [name]: transformedValue
+        };
+      },
+      {}
+    );
+    return { match: true, params };
+  }
+  return { match: true };
+}
+function getRouteRegexAndParams(route, {
+  matchSubPaths = false,
+  allParamTypes = coreParamTypes
+} = {}) {
+  let typeMatchingRoute = route;
+  const routeParams = paramsForRoute(route);
+  for (const [_name, type, match] of routeParams) {
+    const matcher = allParamTypes[type]?.match;
+    const typeRegexp = matcher?.source || "[^/]+";
+    typeMatchingRoute = typeMatchingRoute.replace(match, `(${typeRegexp})`);
+  }
+  const matchRegex = matchSubPaths ? new RegExp(`^${typeMatchingRoute}(?:/.*)?$`, "g") : new RegExp(`^${typeMatchingRoute}$`, "g");
+  const matchRegexString = matchSubPaths ? `^${typeMatchingRoute}(?:/.*)?$` : `^${typeMatchingRoute}$`;
+  return {
+    matchRegex,
+    routeParams,
+    matchRegexString
+  };
+}
+function parseSearch(search) {
+  const searchParams = new URLSearchParams(search);
+  return [...searchParams.keys()].reduce(
+    (params, key) => ({
+      ...params,
+      [key]: searchParams.get(key)
+    }),
+    {}
+  );
+}
+function validatePath(path, routeName) {
+  if (!path.startsWith("/")) {
+    throw new Error(
+      `Route path for ${routeName} does not begin with a slash: "${path}"`
+    );
+  }
+  if (path.includes(" ")) {
+    throw new Error(`Route path for ${routeName} contains spaces: "${path}"`);
+  }
+  if (/{(?:ref|key)(?::|})/.test(path)) {
+    throw new Error(
+      [
+        `Route for ${routeName} contains ref or key as a path parameter: "${path}"`,
+        "`ref` and `key` shouldn't be used as path parameters because they're special React props.",
+        "You can fix this by renaming the path parameter."
+      ].join("\n")
+    );
+  }
+  if (path.length > 2e3) {
+    throw new Error(
+      `Route path for ${routeName} is too long to process at ${path.length} characters, limit is 2000 characters.`
+    );
+  }
+  const matches = path.matchAll(/\{([^}]+)\}/g);
+  const memo = {};
+  for (const match of matches) {
+    const param = match[1].split(":")[0];
+    if (memo[param]) {
+      throw new Error(`Route path contains duplicate parameter: "${path}"`);
+    } else {
+      memo[param] = true;
+    }
+  }
+}
+function replaceParams(route, args = {}) {
+  const params = paramsForRoute(route);
+  let path = route;
+  params.forEach((param) => {
+    const [name, _type, match] = param;
+    const value = args[name];
+    if (value !== void 0) {
+      path = path.replace(match, value);
+    } else {
+      throw new Error(
+        `Missing parameter '${name}' for route '${route}' when generating a navigation URL.`
+      );
+    }
+  });
+  const paramNames = params.map((param) => param[0]);
+  const extraArgKeys = Object.keys(args).filter((x) => !paramNames.includes(x)).filter((x) => args[x] !== void 0 && args[x] !== null);
+  if (extraArgKeys.length) {
+    const extraArgs = Object.fromEntries(
+      extraArgKeys.map((key) => [key, `${args[key]}`])
+    );
+    path += `?${new URLSearchParams(extraArgs).toString()}`;
+  }
+  return path;
+}
+function flattenSearchParams(queryString) {
+  const searchParams = [];
+  for (const [key, value] of Object.entries(parseSearch(queryString))) {
+    searchParams.push({ [key]: value });
+  }
+  return searchParams;
+}
+function inIframe() {
+  try {
+    return global?.self !== global?.top;
+  } catch {
+    return true;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  flattenSearchParams,
+  getRouteRegexAndParams,
+  inIframe,
+  matchPath,
+  paramsForRoute,
+  parseSearch,
+  replaceParams,
+  validatePath
+});

package/dist/createNamedContext.d.ts

@@ -0,0 +1,3 @@
+/** Create a React Context with the given name. */
+export declare function createNamedContext<T>(name: string, defaultValue?: T): import("react").Context<T | undefined>;
+//# sourceMappingURL=createNamedContext.d.ts.map

package/dist/createNamedContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNamedContext.d.ts","sourceRoot":"","sources":["../src/createNamedContext.ts"],"names":[],"mappings":"AAEA,kDAAkD;AAClD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC,0CAInE"}

package/dist/createNamedContext.js

@@ -0,0 +1,9 @@
+import { createContext } from "react";
+function createNamedContext(name, defaultValue) {
+  const Ctx = createContext(defaultValue);
+  Ctx.displayName = name;
+  return Ctx;
+}
+export {
+  createNamedContext
+};

package/dist/dummyComponent.d.ts

@@ -0,0 +1,3 @@
+declare const _default: () => null;
+export default _default;
+//# sourceMappingURL=dummyComponent.d.ts.map

package/dist/dummyComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dummyComponent.d.ts","sourceRoot":"","sources":["../src/dummyComponent.ts"],"names":[],"mappings":";AAEA,wBAAyB"}

package/dist/dummyComponent.js

@@ -0,0 +1,4 @@
+var dummyComponent_default = () => null;
+export {
+  dummyComponent_default as default
+};

package/dist/history.d.ts

@@ -0,0 +1,24 @@
+export interface NavigateOptions {
+    replace?: boolean;
+    scroll?: boolean;
+}
+export type Listener = (ev?: PopStateEvent, options?: NavigateOptions) => any;
+export type BeforeUnloadListener = (ev: BeforeUnloadEvent) => any;
+export type BlockerCallback = (tx: {
+    retry: () => void;
+}) => void;
+export type Blocker = {
+    id: string;
+    callback: BlockerCallback;
+};
+declare const gHistory: {
+    listen: (listener: Listener) => string;
+    navigate: (to: string, options?: NavigateOptions) => void;
+    back: () => void;
+    remove: (listenerId: string) => void;
+    block: (id: string, callback: BlockerCallback) => void;
+    unblock: (id: string) => void;
+};
+declare const navigate: (to: string, options?: NavigateOptions) => void, back: () => void, block: (id: string, callback: BlockerCallback) => void, unblock: (id: string) => void;
+export { gHistory, navigate, back, block, unblock };
+//# sourceMappingURL=history.d.ts.map

package/dist/history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../src/history.tsx"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,EAAE,CAAC,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,eAAe,KAAK,GAAG,CAAA;AAC7E,MAAM,MAAM,oBAAoB,GAAG,CAAC,EAAE,EAAE,iBAAiB,KAAK,GAAG,CAAA;AACjE,MAAM,MAAM,eAAe,GAAG,CAAC,EAAE,EAAE;IAAE,KAAK,EAAE,MAAM,IAAI,CAAA;CAAE,KAAK,IAAI,CAAA;AACjE,MAAM,MAAM,OAAO,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,CAAA;AAgI/D,QAAA,MAAM,QAAQ;uBAxHS,QAAQ;mBAOrB,MAAM,YACD,eAAe;;yBA8CL,MAAM;gBAWf,MAAM,YAAY,eAAe;kBAa/B,MAAM;CA0CQ,CAAA;AAEhC,QAAA,MAAQ,QAAQ,OAnHN,MAAM,YACD,eAAe,WAkHZ,IAAI,cAAE,KAAK,OAzDb,MAAM,YAAY,eAAe,WAyDlB,OAAO,OA5CpB,MAAM,SA4C2B,CAAA;AAEnD,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,CAAA"}