@cedarjs/router 0.0.4

package/dist/useBlocker.js

@@ -0,0 +1,41 @@
+import { useEffect, useCallback, useState, useId } from "react";
+import { block, unblock } from "./history.js";
+function useBlocker({ when }) {
+  const [blockerState, setBlockerState] = useState("IDLE");
+  const [pendingNavigation, setPendingNavigation] = useState(null);
+  const blockerId = useId();
+  const blocker = useCallback(
+    ({ retry }) => {
+      if (when) {
+        setBlockerState("BLOCKED");
+        setPendingNavigation(() => retry);
+      } else {
+        retry();
+      }
+    },
+    [when]
+  );
+  useEffect(() => {
+    if (when) {
+      block(blockerId, blocker);
+    } else {
+      unblock(blockerId);
+    }
+    return () => unblock(blockerId);
+  }, [when, blocker, blockerId]);
+  const confirm = useCallback(() => {
+    setBlockerState("IDLE");
+    if (pendingNavigation) {
+      pendingNavigation();
+      setPendingNavigation(null);
+    }
+  }, [pendingNavigation]);
+  const abort = useCallback(() => {
+    setBlockerState("IDLE");
+    setPendingNavigation(null);
+  }, []);
+  return { state: blockerState, confirm, abort };
+}
+export {
+  useBlocker
+};

package/dist/useIsMounted.d.ts

@@ -0,0 +1,2 @@
+export declare const useIsMounted: () => () => boolean;
+//# sourceMappingURL=useIsMounted.d.ts.map

package/dist/useIsMounted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsMounted.d.ts","sourceRoot":"","sources":["../src/useIsMounted.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,qBAUxB,CAAA"}

package/dist/useIsMounted.js

@@ -0,0 +1,13 @@
+import { useRef, useEffect, useCallback } from "react";
+const useIsMounted = () => {
+  const isMounted = useRef(true);
+  useEffect(() => {
+    return () => {
+      isMounted.current = false;
+    };
+  }, []);
+  return useCallback(() => isMounted.current, []);
+};
+export {
+  useIsMounted
+};

package/dist/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/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/useMatch.js

@@ -0,0 +1,48 @@
+import { useLocation } from "./location.js";
+import { matchPath } from "./util.js";
+const useMatch = (routePath, options) => {
+  const 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 = 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;
+}
+export {
+  useMatch
+};

package/dist/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/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/useRouteName.js

@@ -0,0 +1,16 @@
+import { useRouterState } from "./router-context.js";
+import { routes } from "./index.js";
+function useRouteName() {
+  const routerState = useRouterState();
+  const routeName = routerState.activeRouteName;
+  if (isAvailableRouteName(routeName)) {
+    return routeName;
+  }
+  return void 0;
+}
+function isAvailableRouteName(name) {
+  return typeof name === "string" && Object.keys(routes).includes(name);
+}
+export {
+  useRouteName
+};

package/dist/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/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/useRoutePaths.js

@@ -0,0 +1,25 @@
+import { useRouterState } from "./router-context.js";
+import { useRouteName } from "./useRouteName.js";
+function useRoutePaths() {
+  const routerState = 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 = useRouteName();
+  const routePaths = useRoutePaths();
+  const name = routeName || currentRouteName;
+  if (!name) {
+    return void 0;
+  }
+  return routePaths[name];
+}
+export {
+  useRoutePath,
+  useRoutePaths
+};

package/dist/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/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/util.js

@@ -0,0 +1,183 @@
+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;
+  }
+}
+export {
+  flattenSearchParams,
+  getRouteRegexAndParams,
+  inIframe,
+  matchPath,
+  paramsForRoute,
+  parseSearch,
+  replaceParams,
+  validatePath
+};

package/package.json

@@ -0,0 +1,127 @@
+{
+  "name": "@cedarjs/router",
+  "version": "0.0.4",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cedarjs/cedar.git",
+    "directory": "packages/router"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    },
+    "./Route": {
+      "import": "./dist/Route.js",
+      "require": "./dist/cjs/Route.js"
+    },
+    "./Set": {
+      "import": "./dist/Set.js",
+      "require": "./dist/cjs/Set.js"
+    },
+    "./Link": {
+      "import": "./dist/link.js",
+      "require": "./dist/cjs/link.js"
+    },
+    "./NavLink": {
+      "import": "./dist/navLink.js",
+      "require": "./dist/cjs/navLink.js"
+    },
+    "./location": {
+      "import": "./dist/location.js",
+      "require": "./dist/cjs/location.js"
+    },
+    "./namedRoutes": {
+      "import": "./dist/namedRoutes.js",
+      "require": "./dist/cjs/namedRoutes.js"
+    },
+    "./util": {
+      "import": "./dist/util.js",
+      "require": "./dist/cjs/util.js"
+    },
+    "./react-util": {
+      "import": "./dist/react-util.js",
+      "require": "./dist/cjs/react-util.js"
+    },
+    "./rscCss": {
+      "require": "./dist/cjs/rsc/rscCss.js",
+      "import": "./dist/rsc/rscCss.js"
+    },
+    "./serverRouter": {
+      "import": "./dist/rsc/ServerRouter.js",
+      "require": "./dist/cjs/rsc/ServerRouter.js"
+    },
+    "./RscRouter": {
+      "react-server": "./dist/rsc/ServerRouter.js",
+      "require": "./dist/cjs/rsc/ClientRouter.js",
+      "import": "./dist/rsc/ClientRouter.js"
+    },
+    "./SsrRouter": {
+      "react-server": "./dist/rsc/ServerRouter.js",
+      "require": "./dist/cjs/rsc/SsrRouter.js",
+      "import": "./dist/rsc/SsrRouter.js"
+    },
+    "./dist/*": {
+      "require": "./dist/cjs/*.js",
+      "import": "./dist/*.js"
+    }
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "skip-nav.css"
+  ],
+  "scripts": {
+    "build": "tsx ./build.ts",
+    "build:pack": "yarn pack -o cedar-router.tgz",
+    "build:types": "tsc --build --verbose tsconfig.build.json",
+    "build:types-cjs": "tsc --build --verbose tsconfig.cjs.json",
+    "build:watch": "nodemon --watch src --ext \"js,jsx,ts,tsx\" --ignore dist --exec \"yarn build\"",
+    "check:attw": "tsx ./attw.ts",
+    "check:package": "concurrently npm:check:attw yarn publint",
+    "prepublishOnly": "NODE_ENV=production yarn build",
+    "test": "vitest run",
+    "test:types": "tstyche",
+    "test:watch": "vitest watch"
+  },
+  "dependencies": {
+    "@babel/runtime-corejs3": "7.26.10",
+    "@cedarjs/auth": "0.0.4",
+    "@cedarjs/server-store": "0.0.4",
+    "core-js": "3.42.0",
+    "react": "18.3.1",
+    "react-dom": "18.3.1"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "0.16.4",
+    "@babel/cli": "7.26.4",
+    "@babel/core": "^7.26.10",
+    "@cedarjs/framework-tools": "0.0.4",
+    "@testing-library/jest-dom": "6.5.0",
+    "@types/react": "^18.2.55",
+    "@types/react-dom": "^18.2.19",
+    "concurrently": "8.2.2",
+    "publint": "0.3.11",
+    "tstyche": "3.0.0",
+    "tsx": "4.19.3",
+    "typescript": "5.6.2",
+    "vitest": "2.1.9"
+  },
+  "peerDependencies": {
+    "react": "18.3.1",
+    "react-dom": "18.3.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "5b4f77f985bd86ee31ee7338312627accf0cb85b"
+}