@fluixi/router 0.1.2-alpha.3 → 0.1.2-alpha.4

package/dist/lib/match.cjs

@@ -0,0 +1,122 @@
+"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);
+
+// src/lib/match.ts
+var match_exports = {};
+__export(match_exports, {
+  matchPath: () => matchPath,
+  matchRoutes: () => matchRoutes,
+  rankRoutes: () => rankRoutes,
+  scoreRoute: () => scoreRoute
+});
+module.exports = __toCommonJS(match_exports);
+function normalizePath(p) {
+  return p.startsWith("//") ? p.replace(/^\/+/, "/") : p;
+}
+function matchPath(pattern, path, exact = false) {
+  const keys = [];
+  if (pattern === path) return { params: {}, path };
+  if (!exact && pattern === "/" && path.startsWith("/"))
+    return { params: {}, path: "/" };
+  let regexStr = pattern.replace(/:([a-zA-Z0-9_]+)/g, (_, key) => {
+    keys.push(key);
+    return "([^/]+)";
+  }).replace(/\*([a-zA-Z0-9_]*)/g, (_, name) => {
+    if (name) keys.push(name);
+    return "(.*)";
+  });
+  if (!regexStr.startsWith("/")) regexStr = "/" + regexStr;
+  if (regexStr === "") regexStr = "/";
+  const regex = new RegExp(`^${regexStr}${exact ? "$" : "(?=/|$)"}`);
+  const match = path.match(regex);
+  if (!match) return null;
+  const params = {};
+  keys.forEach((key, i) => {
+    params[key] = match[i + 1];
+  });
+  return { params, path: match[0] };
+}
+function scoreRoute(def) {
+  const segments = def.path.split("/").filter(Boolean);
+  if (segments.length === 0) return 5;
+  let score = 0;
+  for (const seg of segments) {
+    if (seg.startsWith("*")) score += 1;
+    else if (seg.startsWith(":")) score += 10;
+    else score += 100;
+  }
+  return score;
+}
+function rankRoutes(defs) {
+  return [...defs].sort((a, b) => scoreRoute(b) - scoreRoute(a));
+}
+function matchRoutes(routes, pathname) {
+  const path = pathname.length > 1 ? pathname.replace(/\/+$/, "") || "/" : pathname;
+  const result = matchInto(routes, path);
+  if (!result) return null;
+  const matched = [];
+  let cumulative = "";
+  const params = {};
+  for (const layer of result.layers) {
+    cumulative = normalizePath(joinMatched(cumulative, layer.consumed));
+    const layerParams = {};
+    for (const [k, v] of Object.entries(layer.params)) {
+      if (!(k in params)) layerParams[k] = v;
+      params[k] = v;
+    }
+    matched.push({
+      route: layer.route,
+      component: layer.route.component,
+      params: layerParams,
+      pathname: cumulative || "/"
+    });
+  }
+  return { matched, params, pathname };
+}
+function matchInto(defs, currentPath) {
+  if (!defs || defs.length === 0) return null;
+  const ranked = rankRoutes(defs);
+  for (const def of ranked) {
+    const hasChildren = !!def.children && def.children.length > 0;
+    const seg = matchPath(def.path, currentPath, !hasChildren);
+    if (!seg) continue;
+    if (hasChildren) {
+      const childMatch = matchInto(def.children, currentPath);
+      if (childMatch) {
+        return {
+          layers: [
+            { route: def, params: seg.params, consumed: seg.path },
+            ...childMatch.layers
+          ]
+        };
+      }
+      continue;
+    }
+    return { layers: [{ route: def, params: seg.params, consumed: seg.path }] };
+  }
+  return null;
+}
+function joinMatched(cumulative, consumed) {
+  if (!cumulative) return consumed;
+  if (consumed === cumulative) return cumulative;
+  if (consumed.startsWith(cumulative)) return consumed;
+  const a = cumulative.replace(/\/$/, "");
+  const b = consumed.replace(/^\//, "");
+  return `${a}/${b}`;
+}

package/dist/lib/match.mjs

@@ -0,0 +1,101 @@
+// src/lib/match.ts
+function normalizePath(p) {
+  return p.startsWith("//") ? p.replace(/^\/+/, "/") : p;
+}
+function matchPath(pattern, path, exact = false) {
+  const keys = [];
+  if (pattern === path) return { params: {}, path };
+  if (!exact && pattern === "/" && path.startsWith("/"))
+    return { params: {}, path: "/" };
+  let regexStr = pattern.replace(/:([a-zA-Z0-9_]+)/g, (_, key) => {
+    keys.push(key);
+    return "([^/]+)";
+  }).replace(/\*([a-zA-Z0-9_]*)/g, (_, name) => {
+    if (name) keys.push(name);
+    return "(.*)";
+  });
+  if (!regexStr.startsWith("/")) regexStr = "/" + regexStr;
+  if (regexStr === "") regexStr = "/";
+  const regex = new RegExp(`^${regexStr}${exact ? "$" : "(?=/|$)"}`);
+  const match = path.match(regex);
+  if (!match) return null;
+  const params = {};
+  keys.forEach((key, i) => {
+    params[key] = match[i + 1];
+  });
+  return { params, path: match[0] };
+}
+function scoreRoute(def) {
+  const segments = def.path.split("/").filter(Boolean);
+  if (segments.length === 0) return 5;
+  let score = 0;
+  for (const seg of segments) {
+    if (seg.startsWith("*")) score += 1;
+    else if (seg.startsWith(":")) score += 10;
+    else score += 100;
+  }
+  return score;
+}
+function rankRoutes(defs) {
+  return [...defs].sort((a, b) => scoreRoute(b) - scoreRoute(a));
+}
+function matchRoutes(routes, pathname) {
+  const path = pathname.length > 1 ? pathname.replace(/\/+$/, "") || "/" : pathname;
+  const result = matchInto(routes, path);
+  if (!result) return null;
+  const matched = [];
+  let cumulative = "";
+  const params = {};
+  for (const layer of result.layers) {
+    cumulative = normalizePath(joinMatched(cumulative, layer.consumed));
+    const layerParams = {};
+    for (const [k, v] of Object.entries(layer.params)) {
+      if (!(k in params)) layerParams[k] = v;
+      params[k] = v;
+    }
+    matched.push({
+      route: layer.route,
+      component: layer.route.component,
+      params: layerParams,
+      pathname: cumulative || "/"
+    });
+  }
+  return { matched, params, pathname };
+}
+function matchInto(defs, currentPath) {
+  if (!defs || defs.length === 0) return null;
+  const ranked = rankRoutes(defs);
+  for (const def of ranked) {
+    const hasChildren = !!def.children && def.children.length > 0;
+    const seg = matchPath(def.path, currentPath, !hasChildren);
+    if (!seg) continue;
+    if (hasChildren) {
+      const childMatch = matchInto(def.children, currentPath);
+      if (childMatch) {
+        return {
+          layers: [
+            { route: def, params: seg.params, consumed: seg.path },
+            ...childMatch.layers
+          ]
+        };
+      }
+      continue;
+    }
+    return { layers: [{ route: def, params: seg.params, consumed: seg.path }] };
+  }
+  return null;
+}
+function joinMatched(cumulative, consumed) {
+  if (!cumulative) return consumed;
+  if (consumed === cumulative) return cumulative;
+  if (consumed.startsWith(cumulative)) return consumed;
+  const a = cumulative.replace(/\/$/, "");
+  const b = consumed.replace(/^\//, "");
+  return `${a}/${b}`;
+}
+export {
+  matchPath,
+  matchRoutes,
+  rankRoutes,
+  scoreRoute
+};

package/dist/lib/router.cjs

@@ -0,0 +1,211 @@
+"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);
+
+// src/lib/router.ts
+var router_exports = {};
+__export(router_exports, {
+  createRouter: () => createRouter,
+  splitPath: () => splitPath
+});
+module.exports = __toCommonJS(router_exports);
+
+// src/lib/match.ts
+function normalizePath(p) {
+  return p.startsWith("//") ? p.replace(/^\/+/, "/") : p;
+}
+function matchPath(pattern, path, exact = false) {
+  const keys = [];
+  if (pattern === path) return { params: {}, path };
+  if (!exact && pattern === "/" && path.startsWith("/"))
+    return { params: {}, path: "/" };
+  let regexStr = pattern.replace(/:([a-zA-Z0-9_]+)/g, (_, key) => {
+    keys.push(key);
+    return "([^/]+)";
+  }).replace(/\*([a-zA-Z0-9_]*)/g, (_, name) => {
+    if (name) keys.push(name);
+    return "(.*)";
+  });
+  if (!regexStr.startsWith("/")) regexStr = "/" + regexStr;
+  if (regexStr === "") regexStr = "/";
+  const regex = new RegExp(`^${regexStr}${exact ? "$" : "(?=/|$)"}`);
+  const match = path.match(regex);
+  if (!match) return null;
+  const params = {};
+  keys.forEach((key, i) => {
+    params[key] = match[i + 1];
+  });
+  return { params, path: match[0] };
+}
+function scoreRoute(def) {
+  const segments = def.path.split("/").filter(Boolean);
+  if (segments.length === 0) return 5;
+  let score = 0;
+  for (const seg of segments) {
+    if (seg.startsWith("*")) score += 1;
+    else if (seg.startsWith(":")) score += 10;
+    else score += 100;
+  }
+  return score;
+}
+function rankRoutes(defs) {
+  return [...defs].sort((a, b) => scoreRoute(b) - scoreRoute(a));
+}
+function matchRoutes(routes, pathname) {
+  const path = pathname.length > 1 ? pathname.replace(/\/+$/, "") || "/" : pathname;
+  const result = matchInto(routes, path);
+  if (!result) return null;
+  const matched = [];
+  let cumulative = "";
+  const params = {};
+  for (const layer of result.layers) {
+    cumulative = normalizePath(joinMatched(cumulative, layer.consumed));
+    const layerParams = {};
+    for (const [k, v] of Object.entries(layer.params)) {
+      if (!(k in params)) layerParams[k] = v;
+      params[k] = v;
+    }
+    matched.push({
+      route: layer.route,
+      component: layer.route.component,
+      params: layerParams,
+      pathname: cumulative || "/"
+    });
+  }
+  return { matched, params, pathname };
+}
+function matchInto(defs, currentPath) {
+  if (!defs || defs.length === 0) return null;
+  const ranked = rankRoutes(defs);
+  for (const def of ranked) {
+    const hasChildren = !!def.children && def.children.length > 0;
+    const seg = matchPath(def.path, currentPath, !hasChildren);
+    if (!seg) continue;
+    if (hasChildren) {
+      const childMatch = matchInto(def.children, currentPath);
+      if (childMatch) {
+        return {
+          layers: [
+            { route: def, params: seg.params, consumed: seg.path },
+            ...childMatch.layers
+          ]
+        };
+      }
+      continue;
+    }
+    return { layers: [{ route: def, params: seg.params, consumed: seg.path }] };
+  }
+  return null;
+}
+function joinMatched(cumulative, consumed) {
+  if (!cumulative) return consumed;
+  if (consumed === cumulative) return cumulative;
+  if (consumed.startsWith(cumulative)) return consumed;
+  const a = cumulative.replace(/\/$/, "");
+  const b = consumed.replace(/^\//, "");
+  return `${a}/${b}`;
+}
+
+// src/lib/history.ts
+function splitPath(to) {
+  let rest = to;
+  let hash = "";
+  const hashIdx = rest.indexOf("#");
+  if (hashIdx !== -1) {
+    hash = rest.slice(hashIdx);
+    rest = rest.slice(0, hashIdx);
+  }
+  let search = "";
+  const qIdx = rest.indexOf("?");
+  if (qIdx !== -1) {
+    search = rest.slice(qIdx);
+    rest = rest.slice(0, qIdx);
+  }
+  return { pathname: rest || "/", search, hash };
+}
+
+// src/lib/router.ts
+function parseQuery(search) {
+  const q = {};
+  if (search) {
+    const usp = new URLSearchParams(
+      search.startsWith("?") ? search.slice(1) : search
+    );
+    usp.forEach((v, k) => q[k] = v);
+  }
+  return q;
+}
+function stripBase(pathname, base) {
+  if (!base) return pathname || "/";
+  const b = base.replace(/\/$/, "");
+  if (pathname === b) return "/";
+  if (pathname.startsWith(b + "/")) return pathname.slice(b.length) || "/";
+  return pathname || "/";
+}
+function withBase(to, base) {
+  if (!base) return to;
+  if (/^https?:\/\//.test(to)) return to;
+  const b = base.replace(/\/$/, "");
+  return `${b}${to.startsWith("/") ? to : "/" + to}`;
+}
+function createRouter(config) {
+  const { routes, history, base } = config;
+  const listeners = /* @__PURE__ */ new Set();
+  const readLocation = () => {
+    const raw = history.get();
+    return {
+      pathname: raw.pathname,
+      search: raw.search,
+      hash: raw.hash,
+      state: raw.state,
+      query: parseQuery(raw.search)
+    };
+  };
+  const computeMatch = (pathname) => matchRoutes(routes, stripBase(pathname, base));
+  let current = (() => {
+    const location = readLocation();
+    return { location, match: computeMatch(location.pathname) };
+  })();
+  const recompute = () => {
+    const location = readLocation();
+    current = { location, match: computeMatch(location.pathname) };
+    listeners.forEach((l) => l(current));
+  };
+  const unsubscribeHistory = history.subscribe(recompute);
+  return {
+    state() {
+      return current;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    navigate(to, options = {}) {
+      const target = withBase(to, base);
+      if (options.replace) history.replace(target, options.state ?? null);
+      else history.push(target, options.state ?? null);
+    },
+    match(pathname) {
+      return computeMatch(pathname);
+    },
+    destroy() {
+      unsubscribeHistory();
+      listeners.clear();
+    }
+  };
+}

package/dist/lib/router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/lib/router.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,EACV,MAAM,EACN,YAAY,EAKb,MAAM,YAAY,CAAC;AA8BpB,wBAAgB,YAAY,CAAC,CAAC,GAAG,OAAO,EACtC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,GACtB,MAAM,CAAC,CAAC,CAAC,CAuDX;AAED,0DAA0D;AAC1D,OAAO,EAAE,SAAS,EAAE,CAAC"}
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/lib/router.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,EACV,MAAM,EACN,YAAY,EAKb,MAAM,YAAY,CAAC;AAiCpB,wBAAgB,YAAY,CAAC,CAAC,GAAG,OAAO,EACtC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,GACtB,MAAM,CAAC,CAAC,CAAC,CAuDX;AAED,0DAA0D;AAC1D,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/lib/router.js

@@ -10,10 +10,12 @@ import { splitPath } from './history.js';
 /** Parse a `?a=1&b=2` search string into an object. */
 function parseQuery(search) {
     const q = {};
-    if (!search)
-        return q;
-    const usp = new URLSearchParams(search.startsWith('?') ? search.slice(1) : search);
-    usp.forEach((v, k) => (q[k] = v));
+    // Guarded rather than an early return: `search` is typed as a string but reaches
+    // here from a location object, so a missing one must give `{}` and not throw.
+    if (search) {
+        const usp = new URLSearchParams(search.startsWith('?') ? search.slice(1) : search);
+        usp.forEach((v, k) => (q[k] = v));
+    }
     return q;
 }
 /** Strip a base prefix from a pathname (so matching is base-relative). */

package/dist/lib/router.mjs

@@ -0,0 +1,188 @@
+// src/lib/match.ts
+function normalizePath(p) {
+  return p.startsWith("//") ? p.replace(/^\/+/, "/") : p;
+}
+function matchPath(pattern, path, exact = false) {
+  const keys = [];
+  if (pattern === path) return { params: {}, path };
+  if (!exact && pattern === "/" && path.startsWith("/"))
+    return { params: {}, path: "/" };
+  let regexStr = pattern.replace(/:([a-zA-Z0-9_]+)/g, (_, key) => {
+    keys.push(key);
+    return "([^/]+)";
+  }).replace(/\*([a-zA-Z0-9_]*)/g, (_, name) => {
+    if (name) keys.push(name);
+    return "(.*)";
+  });
+  if (!regexStr.startsWith("/")) regexStr = "/" + regexStr;
+  if (regexStr === "") regexStr = "/";
+  const regex = new RegExp(`^${regexStr}${exact ? "$" : "(?=/|$)"}`);
+  const match = path.match(regex);
+  if (!match) return null;
+  const params = {};
+  keys.forEach((key, i) => {
+    params[key] = match[i + 1];
+  });
+  return { params, path: match[0] };
+}
+function scoreRoute(def) {
+  const segments = def.path.split("/").filter(Boolean);
+  if (segments.length === 0) return 5;
+  let score = 0;
+  for (const seg of segments) {
+    if (seg.startsWith("*")) score += 1;
+    else if (seg.startsWith(":")) score += 10;
+    else score += 100;
+  }
+  return score;
+}
+function rankRoutes(defs) {
+  return [...defs].sort((a, b) => scoreRoute(b) - scoreRoute(a));
+}
+function matchRoutes(routes, pathname) {
+  const path = pathname.length > 1 ? pathname.replace(/\/+$/, "") || "/" : pathname;
+  const result = matchInto(routes, path);
+  if (!result) return null;
+  const matched = [];
+  let cumulative = "";
+  const params = {};
+  for (const layer of result.layers) {
+    cumulative = normalizePath(joinMatched(cumulative, layer.consumed));
+    const layerParams = {};
+    for (const [k, v] of Object.entries(layer.params)) {
+      if (!(k in params)) layerParams[k] = v;
+      params[k] = v;
+    }
+    matched.push({
+      route: layer.route,
+      component: layer.route.component,
+      params: layerParams,
+      pathname: cumulative || "/"
+    });
+  }
+  return { matched, params, pathname };
+}
+function matchInto(defs, currentPath) {
+  if (!defs || defs.length === 0) return null;
+  const ranked = rankRoutes(defs);
+  for (const def of ranked) {
+    const hasChildren = !!def.children && def.children.length > 0;
+    const seg = matchPath(def.path, currentPath, !hasChildren);
+    if (!seg) continue;
+    if (hasChildren) {
+      const childMatch = matchInto(def.children, currentPath);
+      if (childMatch) {
+        return {
+          layers: [
+            { route: def, params: seg.params, consumed: seg.path },
+            ...childMatch.layers
+          ]
+        };
+      }
+      continue;
+    }
+    return { layers: [{ route: def, params: seg.params, consumed: seg.path }] };
+  }
+  return null;
+}
+function joinMatched(cumulative, consumed) {
+  if (!cumulative) return consumed;
+  if (consumed === cumulative) return cumulative;
+  if (consumed.startsWith(cumulative)) return consumed;
+  const a = cumulative.replace(/\/$/, "");
+  const b = consumed.replace(/^\//, "");
+  return `${a}/${b}`;
+}
+
+// src/lib/history.ts
+function splitPath(to) {
+  let rest = to;
+  let hash = "";
+  const hashIdx = rest.indexOf("#");
+  if (hashIdx !== -1) {
+    hash = rest.slice(hashIdx);
+    rest = rest.slice(0, hashIdx);
+  }
+  let search = "";
+  const qIdx = rest.indexOf("?");
+  if (qIdx !== -1) {
+    search = rest.slice(qIdx);
+    rest = rest.slice(0, qIdx);
+  }
+  return { pathname: rest || "/", search, hash };
+}
+
+// src/lib/router.ts
+function parseQuery(search) {
+  const q = {};
+  if (search) {
+    const usp = new URLSearchParams(
+      search.startsWith("?") ? search.slice(1) : search
+    );
+    usp.forEach((v, k) => q[k] = v);
+  }
+  return q;
+}
+function stripBase(pathname, base) {
+  if (!base) return pathname || "/";
+  const b = base.replace(/\/$/, "");
+  if (pathname === b) return "/";
+  if (pathname.startsWith(b + "/")) return pathname.slice(b.length) || "/";
+  return pathname || "/";
+}
+function withBase(to, base) {
+  if (!base) return to;
+  if (/^https?:\/\//.test(to)) return to;
+  const b = base.replace(/\/$/, "");
+  return `${b}${to.startsWith("/") ? to : "/" + to}`;
+}
+function createRouter(config) {
+  const { routes, history, base } = config;
+  const listeners = /* @__PURE__ */ new Set();
+  const readLocation = () => {
+    const raw = history.get();
+    return {
+      pathname: raw.pathname,
+      search: raw.search,
+      hash: raw.hash,
+      state: raw.state,
+      query: parseQuery(raw.search)
+    };
+  };
+  const computeMatch = (pathname) => matchRoutes(routes, stripBase(pathname, base));
+  let current = (() => {
+    const location = readLocation();
+    return { location, match: computeMatch(location.pathname) };
+  })();
+  const recompute = () => {
+    const location = readLocation();
+    current = { location, match: computeMatch(location.pathname) };
+    listeners.forEach((l) => l(current));
+  };
+  const unsubscribeHistory = history.subscribe(recompute);
+  return {
+    state() {
+      return current;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    navigate(to, options = {}) {
+      const target = withBase(to, base);
+      if (options.replace) history.replace(target, options.state ?? null);
+      else history.push(target, options.state ?? null);
+    },
+    match(pathname) {
+      return computeMatch(pathname);
+    },
+    destroy() {
+      unsubscribeHistory();
+      listeners.clear();
+    }
+  };
+}
+export {
+  createRouter,
+  splitPath
+};

package/dist/lib/types.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+
+// src/lib/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);