@xmachines/play-router 2.1.0 → 2.2.0

package/dist/base-path.js

@@ -0,0 +1,418 @@
+/**
+ * The base-path support — it mounts the routes of a machine under a URL prefix.
+ *
+ * A host application often owns a part of its own URL space, and it wants a machine
+ * to own the rest of that space, inside the SAME router. A URL such as
+ * `/:machineId/play/dashboard` has two halves: `/:machineId/play` belongs to the
+ * host, which resolves `:machineId` in a loader, and `/dashboard` belongs to the
+ * `meta.route` tree of the machine.
+ *
+ * This module is the boundary between those two halves:
+ * - {@link resolveBasePath} makes the concrete prefix that the browser URL carries,
+ *   from a base-path pattern and its params.
+ * - {@link stripBasePath} removes that prefix from an inbound location of the router,
+ *   and it reports a location OUTSIDE the prefix as foreign, so that the bridge stays
+ *   out of it.
+ * - {@link joinBasePath} adds the prefix again to an outbound path of the machine.
+ *
+ * The prefix lives on the BRIDGE, and not on the `RouteMap`. A route map is static,
+ * it is shared, and it holds an LRU cache inside, while a mount point is dynamic. One
+ * route map therefore serves every `machineId` without a rebuild.
+ *
+ * @internal The package exports these primitives for an adapter and for a host, but
+ * a consumer normally uses the `basePath` option of a bridge instead.
+ */
+import { InvalidBasePathError, MissingBasePathParamError } from "./errors.js";
+/**
+ * The base path of a bridge that has no `basePath` option.
+ *
+ * The object is FROZEN, and both levels of it: {@link resolveBasePath} returns this
+ * exact instance for every bridge with no mount, and
+ * `RouterBridgeBase.basePathParams` hands its `params` to the caller.
+ * `Readonly<Record<string, string>>` is gone at run time, so without the freeze one
+ * write in consumer code would leak that key into every other unmounted bridge in
+ * the process.
+ */
+export const NO_BASE_PATH = Object.freeze({
+    path: "",
+    params: Object.freeze({}),
+});
+/**
+ * Normalizes a base path, and it substitutes no `:param` segment of that path.
+ *
+ * Use this function when you want the form of the pattern, for example to declare
+ * the routes of a machine in a route config of a host that substitutes each param
+ * itself. {@link resolveBasePath} gives the form that a bridge needs.
+ *
+ * @param basePath - The prefix, as a pattern or as a concrete path. An absent value,
+ *   `""`, and `"/"` all give `""`.
+ * @returns The normalized prefix. It starts with `/`, and it carries no trailing `/`.
+ * @throws {InvalidBasePathError} For a wildcard segment, for an optional `:param?`
+ *   segment, for a `$param` segment, for a query string or a hash fragment, for a URL
+ *   scheme, for a dot segment (`.`, `..`, and their percent-encoded forms), and for any
+ *   segment that a browser rewrites — one that holds whitespace, a backslash, or a
+ *   character that a URL percent-encodes.
+ *
+ * @example
+ * ```typescript
+ * normalizeBasePath("/:machineId/play/");  // "/:machineId/play"
+ * normalizeBasePath("admin");              // "/admin"
+ * normalizeBasePath("/");                  // ""
+ * ```
+ */
+export function normalizeBasePath(basePath) {
+    if (basePath === undefined || basePath === null || basePath === "")
+        return "";
+    // A base path is a PATHNAME, so refuse a whole URL before the slash collapse hides
+    // the mistake. "https://host/admin" collapses to "/https:/host/admin", whose every
+    // segment passes the segment guards below. The bridge would take that mount, then
+    // strip no real router location under it: the machine would go permanently silent,
+    // exactly as it does for a query or a hash.
+    assertNoScheme(basePath);
+    // Collapse each duplicate slash, add the leading slash, and drop the trailing one.
+    // The result therefore concatenates cleanly with a machine path, which always
+    // starts with "/", and it compares cleanly with a sanitized router location, which
+    // sanitizePathname() has already collapsed.
+    const collapsed = `/${basePath}`.replace(/\/+/g, "/").replace(/\/$/, "");
+    if (collapsed === "")
+        return "";
+    for (const segment of collapsed.slice(1).split("/")) {
+        assertBasePathSegment(segment, basePath);
+    }
+    return collapsed;
+}
+/**
+ * Resolves a base path and its params to the concrete prefix that a browser URL
+ * carries.
+ *
+ * A bridge calls this function one time, and again on each `setBasePath()` call. The
+ * result is always concrete. {@link stripBasePath} therefore compares a literal
+ * prefix, and no URLPattern match runs on the hot path of a navigation.
+ *
+ * @param basePath - The prefix, as a pattern or as a concrete path.
+ * @param params - The values of the `:param` segments of `basePath`.
+ * @returns The concrete prefix, and the values of each param for a `play.route` event.
+ * @throws {InvalidBasePathError} For a wildcard segment, for an optional `:param?`
+ *   segment, for a `$param` segment, for a query string or a hash fragment, for a URL
+ *   scheme, for a dot segment (`.`, `..`, and their percent-encoded forms), and for any
+ *   segment that a browser rewrites — one that holds whitespace, a backslash, or a
+ *   character that a URL percent-encodes.
+ * @throws {MissingBasePathParamError} When a `:param` of the prefix has no value.
+ *
+ * @example
+ * ```typescript
+ * resolveBasePath("/:machineId/play", { machineId: "abc123" });
+ * // → { path: "/abc123/play", params: { machineId: "abc123" } }
+ *
+ * resolveBasePath("/admin");
+ * // → { path: "/admin", params: {} }
+ * ```
+ */
+export function resolveBasePath(basePath, params) {
+    const normalized = normalizeBasePath(basePath);
+    if (normalized === "")
+        return NO_BASE_PATH;
+    if (!normalized.includes(":")) {
+        return Object.freeze({
+            path: normalized,
+            params: Object.freeze({}),
+        });
+    }
+    // A null prototype, for both directions of the lookup. A plain `{}` accumulator
+    // turns `resolvedParams["__proto__"] = value` into a write of the PROTOTYPE, so a
+    // param of that name would vanish from the result.
+    const resolvedParams = Object.create(null);
+    const segments = normalized
+        .slice(1)
+        .split("/")
+        .map((segment) => {
+        if (!segment.startsWith(":"))
+            return segment;
+        const name = segment.slice(1);
+        // `Object.hasOwn`, and not a bare read: `params[name]` walks the prototype
+        // chain, so ":constructor" with no value of its own found
+        // `Object.prototype.constructor` and resolved the prefix to the source text of
+        // a function. `stripBasePath` then read EVERY location as foreign, and the
+        // machine went silent for ever instead of failing loudly here.
+        const value = params !== undefined && Object.hasOwn(params, name)
+            ? params[name] // nosemgrep: gitlab.eslint.detect-object-injection
+            : undefined;
+        if (value === undefined || value === null || value === "") {
+            throw new MissingBasePathParamError(name, basePath ?? "");
+        }
+        const text = String(value);
+        const encoded = encodeBasePathValue(text);
+        // The guards of `assertBasePathSegment` run on the PATTERN, before this
+        // substitution, so they see ":id" and never the value that replaces it. A value
+        // of "." or ".." therefore passed every one of them and resolved away in the
+        // browser: "/m/../play" comes back as "/play", `stripBasePath` reads every
+        // location as foreign, and the machine goes permanently silent with no error —
+        // the exact failure the dot-segment guard exists to prevent. Test the RESOLVED
+        // segment here.
+        if (!isStableSegment(encoded)) {
+            throw new InvalidBasePathError(basePath ?? "", `the value "${text}" of ":${name}" resolves to the segment "${encoded}", which a browser rewrites, so the prefix that comes back is not the prefix that went out.`);
+        }
+        resolvedParams[name] = text; // nosemgrep: gitlab.eslint.detect-object-injection
+        return encoded;
+    });
+    // FROZEN, both levels, for the same reason NO_BASE_PATH is: `RouterBridgeBase`
+    // returns `this.mount.params` BY REFERENCE from its accessor, and
+    // `Readonly<Record<string, string>>` is gone at run time. One write in consumer code
+    // would change what the bridge reports for the rest of its life, while `basePath`
+    // still holds the real prefix — the staleness the accessor promises cannot happen.
+    // Spread, and not the null-prototype record itself: a spread creates OWN properties,
+    // so a param named "__proto__" stays a key AND the value keeps a normal prototype.
+    // Handing the bare record out made `bridge.basePathParams.hasOwnProperty(…)` throw,
+    // on a value the docs describe as a `Readonly<Record<string, string>>`.
+    return Object.freeze({
+        path: `/${segments.join("/")}`,
+        params: Object.freeze({ ...resolvedParams }),
+    });
+}
+/**
+ * Removes the base path from an inbound location of the router.
+ *
+ * The return value separates the two cases that make a shared router work:
+ * - A string is the MACHINE half of the location, for example `"/dashboard"` of
+ *   `"/abc123/play/dashboard"`. The bridge matches it against the route map.
+ * - `null` means that the location is FOREIGN: it lies outside the mount, so it
+ *   belongs to the host. The bridge sends no `play.route` event, AND it runs no
+ *   corrective navigation. A correction here would drag the user off a page of the
+ *   host.
+ *
+ * The match is exact, and it respects each segment boundary. `"/abc/playground"` is
+ * therefore foreign to the mount `"/abc/play"`.
+ *
+ * @param pathname - A sanitized pathname of the router, with no query and no duplicate slash.
+ * @param basePath - The concrete prefix of {@link resolveBasePath}. `""` removes nothing.
+ * @returns The machine half of the path, or `null` when the location is foreign.
+ *
+ * @example
+ * ```typescript
+ * stripBasePath("/abc123/play/dashboard", "/abc123/play");  // "/dashboard"
+ * stripBasePath("/abc123/play", "/abc123/play");            // "/"
+ * stripBasePath("/settings", "/abc123/play");               // null — the host owns it
+ * ```
+ */
+export function stripBasePath(pathname, basePath) {
+    if (basePath === "")
+        return pathname;
+    if (pathname === basePath)
+        return "/";
+    if (pathname.startsWith(`${basePath}/`))
+        return pathname.slice(basePath.length);
+    return null;
+}
+/**
+ * Adds the base path to an outbound path of the machine.
+ *
+ * The function joins the PATHNAME only. A query string and a hash fragment of the
+ * path of the machine stay at the end, because the prefix belongs in front of the
+ * path.
+ *
+ * @param basePath - The concrete prefix of {@link resolveBasePath}. `""` adds nothing.
+ * @param path - The path of the machine, for example `"/dashboard"` or `"/dates?trip=one-way"`.
+ * @returns The location for the router of the host.
+ *
+ * @example
+ * ```typescript
+ * joinBasePath("/abc123/play", "/dashboard");         // "/abc123/play/dashboard"
+ * joinBasePath("/abc123/play", "/");                  // "/abc123/play"
+ * joinBasePath("/abc123/play", "/x?tab=a");           // "/abc123/play/x?tab=a"
+ * joinBasePath("", "/dashboard");                     // "/dashboard"
+ * ```
+ */
+export function joinBasePath(basePath, path) {
+    if (basePath === "")
+        return path;
+    const mark = firstMarkIndex(path);
+    const pathname = mark === -1 ? path : path.slice(0, mark);
+    const suffix = mark === -1 ? "" : path.slice(mark);
+    // The root of the machine IS the mount point: "/" must not append a trailing slash,
+    // because the router callback reports "/abc123/play" and a mismatch there would
+    // defeat the echo suppression of the bridge.
+    const joined = pathname === "" || pathname === "/"
+        ? basePath
+        : `${basePath}${pathname.startsWith("/") ? "" : "/"}${pathname}`;
+    return `${joined}${suffix}`;
+}
+/**
+ * Gives the index of the first query mark or fragment mark of a path, or `-1`.
+ *
+ * The names say `At`, because both values are an INDEX. A name such as `hash` reads
+ * as a digest to a reader and to a scanner both: `gitlab.eslint.detect-possible-timing-attacks`
+ * fires on a `===` test against an identifier of that name, and it cannot see that
+ * the operands here are two numbers.
+ *
+ * @internal `RouterBridgeBase` splits a location on the same boundary, to read the
+ *   pathname half of an actor route. One function, so the two sides cannot disagree
+ *   about where a pathname ends.
+ */
+export function firstMarkIndex(path) {
+    const queryAt = path.indexOf("?");
+    const fragmentAt = path.indexOf("#");
+    if (queryAt === -1)
+        return fragmentAt;
+    if (fragmentAt === -1)
+        return queryAt;
+    return Math.min(queryAt, fragmentAt);
+}
+/**
+ * Refuses each segment of a base path that resolves to ONE concrete prefix never.
+ *
+ * A bridge writes a real browser URL from its prefix. A wildcard and an optional
+ * segment each describe a SET of prefixes, so neither of them holds a value to write,
+ * and a silent pass would put a literal `*` or `:section?` into the address bar.
+ */
+function assertBasePathSegment(segment, basePath) {
+    if (segment.includes("*")) {
+        throw new InvalidBasePathError(basePath, 'a wildcard segment cannot resolve to one concrete prefix. Drop the splat segment: mount on the prefix itself, for example "/:machineId/play" for the route "/$machineId/play/$".');
+    }
+    if (segment.startsWith("$")) {
+        throw new InvalidBasePathError(basePath, `"${segment}" looks like a route param of TanStack Router. A base path declares a param as ":${segment.slice(1)}", and its value goes in basePathParams.`);
+    }
+    if (segment.startsWith(":") && segment.endsWith("?")) {
+        throw new InvalidBasePathError(basePath, `the optional segment "${segment}" cannot resolve to one concrete prefix. Give a required ":${segment.slice(1, -1)}" param, or mount on the shorter prefix.`);
+    }
+    if (segment === ":") {
+        throw new InvalidBasePathError(basePath, "a param segment needs a name.");
+    }
+    // A browser resolves "." and ".." out of a location, so the prefix that
+    // `navigateRouter` writes is not the prefix that comes back: "/../admin/about"
+    // becomes "/admin/about", which no longer starts with the mount. Every later location
+    // would read as foreign and the machine would go permanently silent.
+    //
+    // The PERCENT-ENCODED forms resolve away exactly the same. The WHATWG URL standard
+    // reads "%2e" as a single-dot segment and ".%2e", "%2e." and "%2e%2e" as double-dot
+    // segments, each test case-insensitive, so "/a/%2e%2e/admin" also comes back as
+    // "/admin". A guard on the two literal forms alone let that mount through.
+    if (isDotSegment(segment)) {
+        throw new InvalidBasePathError(basePath, `the segment "${segment}" resolves away in a browser, so the prefix that comes back is not the prefix that went out. Give the path that it resolves to.`);
+    }
+    // A browser percent-encodes a space, a tab and a newline of a pathname, so the prefix
+    // that comes back is not the prefix that went out — the same failure as a dot segment,
+    // and the same silence. `assertNoScheme` also reads the RAW value, and a leading space
+    // hid a whole URL from it: " https://host/admin" collapsed to "/ https:/host/admin".
+    if (/\s/.test(segment)) {
+        throw new InvalidBasePathError(basePath, `the segment "${segment}" holds whitespace, which a browser percent-encodes, so the prefix that comes back is not the prefix that went out. Give the path with no whitespace in it.`);
+    }
+    // A base path is a PATHNAME. A query or a hash in it would survive normalization,
+    // then never match a router location — `sanitizePathname` has already removed both
+    // by the time `stripBasePath` compares — so every location would read as foreign
+    // and the machine would go permanently silent. Refuse it here instead.
+    if (segment.includes("?") || segment.includes("#")) {
+        throw new InvalidBasePathError(basePath, "a base path is a pathname only: it can carry no query string and no hash fragment. Put a query on the machine's own route instead.");
+    }
+    // The general form of the three guards above, and the one that catches the rest. A
+    // browser reads a "\" as a "/", so "/adm\in" arrives as two segments and "/a\..\x"
+    // arrives as "/x"; it percent-encodes a non-ASCII character and the characters '"',
+    // '<', '>', '{', '}', '^' and '`', so "/café" arrives as "/caf%C3%A9". Each one gives
+    // the same silence as a dot segment: no location matches the mount, and no error says
+    // so. The guards above stay, because each one names the mistake it found.
+    if (!isStableSegment(segment)) {
+        throw new InvalidBasePathError(basePath, `a browser rewrites the segment "${segment}", so the prefix that comes back is not the prefix that went out. Give the segment in the form that a URL carries, for example "caf%C3%A9" for "café".`);
+    }
+}
+/** The origin of the probe of {@link isStableSegment}. It reaches no network. */
+const PROBE_ORIGIN = "http://probe.invalid";
+/**
+ * Tells you whether a browser writes a path segment back exactly as it went out.
+ *
+ * The WHATWG URL parser rewrites a segment in several ways: it resolves "." and ".."
+ * away, it reads a "\" as a "/", and it percent-encodes whitespace, a non-ASCII
+ * character, and the characters '"', '<', '>', '{', '}', '^' and '`'. Every one of them
+ * gives one failure: the prefix that `navigateRouter` writes is not the prefix that
+ * comes back, so `stripBasePath` reads every location as foreign and the machine goes
+ * permanently silent, with no error raised.
+ *
+ * The function asks the URL parser, and it lists no character, because that list
+ * belongs to the standard and not to this file.
+ */
+function isStableSegment(segment) {
+    try {
+        return new URL(`/${segment}`, PROBE_ORIGIN).pathname === `/${segment}`;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Tells you whether a segment is a single-dot or a double-dot path segment.
+ *
+ * The WHATWG URL standard names six forms, and a browser resolves every one of them out
+ * of a location: "." and "%2e" for the single dot, and "..", ".%2e", "%2e." and "%2e%2e"
+ * for the double dot. Each percent test is case-insensitive.
+ */
+function isDotSegment(segment) {
+    const decoded = segment.toLowerCase().replaceAll("%2e", ".");
+    return decoded === "." || decoded === "..";
+}
+/**
+ * Refuses a base path that carries a URL scheme.
+ *
+ * The test runs on the RAW value, because the slash collapse of
+ * {@link normalizeBasePath} turns the form into a path that looks legal. It also runs
+ * on the TRIMMED value, because a browser drops the leading whitespace of a URL: a
+ * scheme behind a space is still a scheme. And it runs at every segment boundary,
+ * because a scheme that a caller joined behind a prefix of its own is still a scheme.
+ *
+ * A protocol-relative `//host/path` is NOT refused: it is indistinguishable from a
+ * sloppy `//a//b`, which the collapse deliberately forgives.
+ *
+ * @throws {InvalidBasePathError} For `scheme://host/path`.
+ */
+function assertNoScheme(basePath) {
+    // RFC 3986: a scheme starts with a letter, then holds letters, digits, "+", "-"
+    // and ".". A leading "//" with no scheme is the protocol-relative form.
+    // The test runs at EVERY segment boundary, and not at the start alone. A caller that
+    // joins a prefix onto a base writes "/https://app.example.com/admin", and also
+    // "/tenant/https://app.example.com/admin": the collapse then makes
+    // "/tenant/https:/app.example.com/admin", whose every segment is legal, so the bridge
+    // mounts where no real location starts and the machine goes permanently silent. A
+    // guard that stripped the LEADING slashes alone caught the first form and missed the
+    // second.
+    if (/(?:^|\/)[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(basePath.trim())) {
+        throw new InvalidBasePathError(basePath, 'a base path is a pathname only: it can carry no scheme and no host. Give the path part alone, for example "/admin" for "https://app.example.com/admin".');
+    }
+}
+/**
+ * Escapes the value of a base-path param for a URL segment.
+ *
+ * `encodeURIComponent` leaves a `*` alone, and that is correct here: a `*` is a legal
+ * path character, and a browser reports it literally. An escape to `%2A` resolved a
+ * mount that no real location matches, so `stripBasePath` read every location as
+ * foreign and the machine went permanently silent, with no error raised.
+ *
+ * The `*` of "a pattern of no navigation" never reaches this value.
+ * `resolveNavigationPath` tests the MACHINE half of the route, and `joinBasePath` adds
+ * the prefix after that test — see the one `navigateRouter` call in
+ * `pushResolvedRoute`.
+ */
+function encodeBasePathValue(value) {
+    // `encodeURIComponent` encodes for a QUERY component, so it escapes eight characters
+    // that RFC 3986 lets a path segment hold raw: the sub-delims "$&+,;=" and ":" and
+    // "@". Every router reports those raw in a pathname, so an escape resolves a mount
+    // that no real location matches — `stripBasePath` reads every location as foreign and
+    // the machine goes permanently silent, with no error raised.
+    //
+    // Escape for a segment instead: put those characters back, and keep the escape of
+    // everything that would change the SHAPE of the path — "/", "?", "#" and "%" among
+    // them — because a value must forge no path and no query.
+    return encodeURIComponent(value).replace(/%(?:24|26|2B|2C|3A|3B|3D|40)/g, (escaped) => PATH_SEGMENT_SAFE.get(escaped) ?? escaped);
+}
+/**
+ * The escapes that {@link encodeBasePathValue} undoes: the characters a path segment
+ * holds raw, which `encodeURIComponent` escapes because it encodes for a query.
+ */
+/** A Map, and not an object: a dynamic key reaches no prototype through one. */
+const PATH_SEGMENT_SAFE = new Map([
+    ["%24", "$"],
+    ["%26", "&"],
+    ["%2B", "+"],
+    ["%2C", ","],
+    ["%3A", ":"],
+    ["%3B", ";"],
+    ["%3D", "="],
+    ["%40", "@"],
+]);
+//# sourceMappingURL=base-path.js.map

package/dist/base-path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-path.js","sourceRoot":"","sources":["../src/base-path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAkE9E;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,YAAY,GAAqB,MAAM,CAAC,MAAM,CAAC;IAC3D,IAAI,EAAE,EAAE;IACR,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;CACzB,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAA6B;IAC9D,IAAI,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,IAAI,IAAI,QAAQ,KAAK,EAAE;QAAE,OAAO,EAAE,CAAC;IAE9E,mFAAmF;IACnF,mFAAmF;IACnF,kFAAkF;IAClF,mFAAmF;IACnF,4CAA4C;IAC5C,cAAc,CAAC,QAAQ,CAAC,CAAC;IAEzB,mFAAmF;IACnF,8EAA8E;IAC9E,mFAAmF;IACnF,4CAA4C;IAC5C,MAAM,SAAS,GAAG,IAAI,QAAQ,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACzE,IAAI,SAAS,KAAK,EAAE;QAAE,OAAO,EAAE,CAAC;IAEhC,KAAK,MAAM,OAAO,IAAI,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QACrD,qBAAqB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC1C,CAAC;IACD,OAAO,SAAS,CAAC;AAClB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,eAAe,CAC9B,QAA6B,EAC7B,MAAoD;IAEpD,MAAM,UAAU,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC;IAC/C,IAAI,UAAU,KAAK,EAAE;QAAE,OAAO,YAAY,CAAC;IAC3C,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QAC/B,OAAO,MAAM,CAAC,MAAM,CAAC;YACpB,IAAI,EAAE,UAAU;YAChB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;SACzB,CAAC,CAAC;IACJ,CAAC;IAED,gFAAgF;IAChF,kFAAkF;IAClF,mDAAmD;IACnD,MAAM,cAAc,GAA2B,MAAM,CAAC,MAAM,CAAC,IAAI,CAA2B,CAAC;IAC7F,MAAM,QAAQ,GAAG,UAAU;SACzB,KAAK,CAAC,CAAC,CAAC;SACR,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;QAChB,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC;YAAE,OAAO,OAAO,CAAC;QAE7C,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC9B,2EAA2E;QAC3E,0DAA0D;QAC1D,+EAA+E;QAC/E,2EAA2E;QAC3E,+DAA+D;QAC/D,MAAM,KAAK,GACV,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC;YAClD,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,mDAAmD;YAClE,CAAC,CAAC,SAAS,CAAC;QACd,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;YAC3D,MAAM,IAAI,yBAAyB,CAAC,IAAI,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAC;QAC3D,CAAC;QAED,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC3B,MAAM,OAAO,GAAG,mBAAmB,CAAC,IAAI,CAAC,CAAC;QAC1C,wEAAwE;QACxE,gFAAgF;QAChF,6EAA6E;QAC7E,2EAA2E;QAC3E,+EAA+E;QAC/E,+EAA+E;QAC/E,gBAAgB;QAChB,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,EAAE,CAAC;YAC/B,MAAM,IAAI,oBAAoB,CAC7B,QAAQ,IAAI,EAAE,EACd,cAAc,IAAI,UAAU,IAAI,8BAA8B,OAAO,6FAA6F,CAClK,CAAC;QACH,CAAC;QACD,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,mDAAmD;QAChF,OAAO,OAAO,CAAC;IAChB,CAAC,CAAC,CAAC;IAEJ,+EAA+E;IAC/E,kEAAkE;IAClE,qFAAqF;IACrF,kFAAkF;IAClF,mFAAmF;IACnF,qFAAqF;IACrF,mFAAmF;IACnF,oFAAoF;IACpF,wEAAwE;IACxE,OAAO,MAAM,CAAC,MAAM,CAAC;QACpB,IAAI,EAAE,IAAI,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;QAC9B,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,cAAc,EAAE,CAAC;KAC5C,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,aAAa,CAAC,QAAgB,EAAE,QAAgB;IAC/D,IAAI,QAAQ,KAAK,EAAE;QAAE,OAAO,QAAQ,CAAC;IACrC,IAAI,QAAQ,KAAK,QAAQ;QAAE,OAAO,GAAG,CAAC;IACtC,IAAI,QAAQ,CAAC,UAAU,CAAC,GAAG,QAAQ,GAAG,CAAC;QAAE,OAAO,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IAChF,OAAO,IAAI,CAAC;AACb,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,YAAY,CAAC,QAAgB,EAAE,IAAY;IAC1D,IAAI,QAAQ,KAAK,EAAE;QAAE,OAAO,IAAI,CAAC;IAEjC,MAAM,IAAI,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;IAClC,MAAM,QAAQ,GAAG,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;IAC1D,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAEnD,oFAAoF;IACpF,gFAAgF;IAChF,6CAA6C;IAC7C,MAAM,MAAM,GACX,QAAQ,KAAK,EAAE,IAAI,QAAQ,KAAK,GAAG;QAClC,CAAC,CAAC,QAAQ;QACV,CAAC,CAAC,GAAG,QAAQ,GAAG,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,QAAQ,EAAE,CAAC;IAEnE,OAAO,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;AAC7B,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,cAAc,CAAC,IAAY;IAC1C,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAClC,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACrC,IAAI,OAAO,KAAK,CAAC,CAAC;QAAE,OAAO,UAAU,CAAC;IACtC,IAAI,UAAU,KAAK,CAAC,CAAC;QAAE,OAAO,OAAO,CAAC;IACtC,OAAO,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;GAMG;AACH,SAAS,qBAAqB,CAAC,OAAe,EAAE,QAAgB;IAC/D,IAAI,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,oBAAoB,CAC7B,QAAQ,EACR,kLAAkL,CAClL,CAAC;IACH,CAAC;IACD,IAAI,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,oBAAoB,CAC7B,QAAQ,EACR,IAAI,OAAO,oFAAoF,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,0CAA0C,CACzJ,CAAC;IACH,CAAC;IACD,IAAI,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACtD,MAAM,IAAI,oBAAoB,CAC7B,QAAQ,EACR,yBAAyB,OAAO,8DAA8D,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,0CAA0C,CAC5J,CAAC;IACH,CAAC;IACD,IAAI,OAAO,KAAK,GAAG,EAAE,CAAC;QACrB,MAAM,IAAI,oBAAoB,CAAC,QAAQ,EAAE,+BAA+B,CAAC,CAAC;IAC3E,CAAC;IACD,wEAAwE;IACxE,+EAA+E;IAC/E,sFAAsF;IACtF,qEAAqE;IACrE,EAAE;IACF,mFAAmF;IACnF,oFAAoF;IACpF,gFAAgF;IAChF,2EAA2E;IAC3E,IAAI,YAAY,CAAC,OAAO,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,oBAAoB,CAC7B,QAAQ,EACR,gBAAgB,OAAO,iIAAiI,CACxJ,CAAC;IACH,CAAC;IACD,sFAAsF;IACtF,uFAAuF;IACvF,uFAAuF;IACvF,qFAAqF;IACrF,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,oBAAoB,CAC7B,QAAQ,EACR,gBAAgB,OAAO,6JAA6J,CACpL,CAAC;IACH,CAAC;IACD,kFAAkF;IAClF,mFAAmF;IACnF,iFAAiF;IACjF,uEAAuE;IACvE,IAAI,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACpD,MAAM,IAAI,oBAAoB,CAC7B,QAAQ,EACR,oIAAoI,CACpI,CAAC;IACH,CAAC;IACD,mFAAmF;IACnF,mFAAmF;IACnF,oFAAoF;IACpF,sFAAsF;IACtF,sFAAsF;IACtF,0EAA0E;IAC1E,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,EAAE,CAAC;QAC/B,MAAM,IAAI,oBAAoB,CAC7B,QAAQ,EACR,mCAAmC,OAAO,wJAAwJ,CAClM,CAAC;IACH,CAAC;AACF,CAAC;AAED,iFAAiF;AACjF,MAAM,YAAY,GAAG,sBAAsB,CAAC;AAE5C;;;;;;;;;;;;GAYG;AACH,SAAS,eAAe,CAAC,OAAe;IACvC,IAAI,CAAC;QACJ,OAAO,IAAI,GAAG,CAAC,IAAI,OAAO,EAAE,EAAE,YAAY,CAAC,CAAC,QAAQ,KAAK,IAAI,OAAO,EAAE,CAAC;IACxE,CAAC;IAAC,MAAM,CAAC;QACR,OAAO,KAAK,CAAC;IACd,CAAC;AACF,CAAC;AAED;;;;;;GAMG;AACH,SAAS,YAAY,CAAC,OAAe;IACpC,MAAM,OAAO,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IAC7D,OAAO,OAAO,KAAK,GAAG,IAAI,OAAO,KAAK,IAAI,CAAC;AAC5C,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAS,cAAc,CAAC,QAAgB;IACvC,gFAAgF;IAChF,wEAAwE;IACxE,qFAAqF;IACrF,+EAA+E;IAC/E,mEAAmE;IACnE,sFAAsF;IACtF,kFAAkF;IAClF,qFAAqF;IACrF,UAAU;IACV,IAAI,sCAAsC,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;QAClE,MAAM,IAAI,oBAAoB,CAC7B,QAAQ,EACR,yJAAyJ,CACzJ,CAAC;IACH,CAAC;AACF,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAS,mBAAmB,CAAC,KAAa;IACzC,qFAAqF;IACrF,kFAAkF;IAClF,mFAAmF;IACnF,sFAAsF;IACtF,6DAA6D;IAC7D,EAAE;IACF,kFAAkF;IAClF,mFAAmF;IACnF,0DAA0D;IAC1D,OAAO,kBAAkB,CAAC,KAAK,CAAC,CAAC,OAAO,CACvC,+BAA+B,EAC/B,CAAC,OAAO,EAAE,EAAE,CAAC,iBAAiB,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,OAAO,CACtD,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,gFAAgF;AAChF,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAiB;IACjD,CAAC,KAAK,EAAE,GAAG,CAAC;IACZ,CAAC,KAAK,EAAE,GAAG,CAAC;IACZ,CAAC,KAAK,EAAE,GAAG,CAAC;IACZ,CAAC,KAAK,EAAE,GAAG,CAAC;IACZ,CAAC,KAAK,EAAE,GAAG,CAAC;IACZ,CAAC,KAAK,EAAE,GAAG,CAAC;IACZ,CAAC,KAAK,EAAE,GAAG,CAAC;IACZ,CAAC,KAAK,EAAE,GAAG,CAAC;CACZ,CAAC,CAAC"}

package/dist/base-route-map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base-route-map.d.ts","sourceRoot":"","sources":["../src/base-route-map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AA0BH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,YAAY;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uGAAuG;IACvG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,qBAAa,QAAQ;IACpB,8EAA8E;IAC9E,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,cAAc,CAGpB;IACF,OAAO,CAAC,cAAc,CAAkC;IAExD;;;;;;;;;;;;;;;;;OAiBG;gBACS,QAAQ,EAAE,YAAY,EAAE,EAAE,EAAE,SAAe,EAAE,GAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAO;IAoCtF;;;;;;;;;;;;;;;OAeG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAuB7C;;;;;;;;;;;;;;;;OAgBG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;CAGhD"}
+{"version":3,"file":"base-route-map.d.ts","sourceRoot":"","sources":["../src/base-route-map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AA0BH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,YAAY;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uGAAuG;IACvG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,qBAAa,QAAQ;IACpB,8EAA8E;IAC9E,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,cAAc,CAGpB;IACF,OAAO,CAAC,cAAc,CAAkC;IAExD;;;;;;;;;;;;;;;;;OAiBG;gBACS,QAAQ,EAAE,YAAY,EAAE,EAAE,EAAE,SAAe,EAAE,GAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAO;IAwCtF;;;;;;;;;;;;;;;OAeG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAuB7C;;;;;;;;;;;;;;;;OAgBG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;CAGhD"}

package/dist/base-route-map.js

@@ -119,6 +119,11 @@ export class RouteMap {
                     });
                 }
                 catch (err) {
+                    // `getCompiledPattern` reports an invalid pattern itself, and with the REASON
+                    // when it knows one. A second wrap here replaced that message with the
+                    // generic one, so the explanation reached the caller never.
+                    if (err instanceof InvalidRoutePatternError)
+                        throw err;
                     throw new InvalidRoutePatternError(path, { cause: err });
                 }
                 this.patternBuckets.set(bucketKey, bucket);

package/dist/base-route-map.js.map

@@ -1 +1 @@
-{"version":3,"file":"base-route-map.js","sourceRoot":"","sources":["../src/base-route-map.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"base-route-map.js","sourceRoot":"","sources":["../src/base-route-map.ts"],"names":[],"mappings":"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"}

package/dist/errors.d.ts

@@ -123,13 +123,20 @@ export declare class UnknownStateTypeError extends PlayError {
     constructor(stateType: string, nodeId: string, validTypes: string[]);
 }
 /**
- * The `RouteMap` constructor throws this error when `URLPattern` cannot compile the
- * string of a route pattern. The `pattern` field holds the string in question, and
- * `cause` holds the original error of the `URLPattern` constructor.
+ * The library throws this error when `URLPattern` cannot compile the string of a route
+ * pattern. The `pattern` field holds the string in question, and `cause` holds the
+ * original error of the `URLPattern` constructor.
+ *
+ * Every compilation reports through this error, so `extractRouteParams` raises it for a
+ * pattern that no `RouteMap` ever held, and not a bare `TypeError`.
  *
  * The common causes:
  * - A parenthesis or a bracket without its pair in the string of the pattern
  * - A character that a URL pathname pattern does not permit
+ * - Two params of one pattern that land on the same URLPattern group. A name with a
+ *   hyphen compiles with an underscore, so `:cat-id` and `:cat_id` are one group. The
+ *   message names the two params and the group, and `cause` is absent: the library
+ *   refuses the pattern before URLPattern sees it.
  *
  * **Error code:** `PLAY_ROUTE_MAP_INVALID_PATTERN`
  *
@@ -149,6 +156,82 @@ export declare class UnknownStateTypeError extends PlayError {
 export declare class InvalidRoutePatternError extends PlayError {
     /** The string of the route pattern. URLPattern could not compile it. */
     readonly pattern: string;
-    constructor(pattern: string, options?: ErrorOptions);
+    /**
+     * @param pattern - The route pattern that URLPattern could not compile.
+     * @param options - The standard `cause`, and an optional `reason` that says WHY. Give
+     *   a reason whenever the library knows it: the pattern alone shows a caller nothing
+     *   when the fault is a rewrite that the library made, and not the text they wrote.
+     */
+    constructor(pattern: string, options?: ErrorOptions & {
+        reason?: string;
+    });
+}
+/**
+ * Thrown when a `basePath` option resolves to one concrete URL prefix never.
+ *
+ * A bridge writes a real browser URL from its prefix, so every segment must hold
+ * exactly one value. A wildcard segment (`*`), an optional segment (`:section?`), a
+ * nameless `:` segment, a query string, and a hash fragment each describe a SET of
+ * prefixes instead, or no prefix at all. A `$param` segment is the route-param
+ * syntax of TanStack Router: a base path writes a param as `:param`, and it takes
+ * the value of that param from `basePathParams`.
+ *
+ * **How to fix it:** mount on the prefix itself, and let the machine own the rest.
+ * For the splat route `/$machineId/play/$` of TanStack, the base path is
+ * `"/:machineId/play"` with `basePathParams: { machineId }`.
+ *
+ * **Error code:** `PLAY_ROUTER_INVALID_BASE_PATH`
+ *
+ * @example
+ * ```typescript
+ * import { InvalidBasePathError } from "@xmachines/play-router/errors";
+ *
+ * try {
+ *   bridge.setBasePath("/:machineId/play/*");
+ * } catch (err) {
+ *   if (err instanceof InvalidBasePathError) {
+ *     console.error(`Bad base path: "${err.basePath}"`, err.message);
+ *   }
+ * }
+ * ```
+ */
+export declare class InvalidBasePathError extends PlayError {
+    /** The `basePath` option of the refusal, exactly as the caller gave it. */
+    readonly basePath: string;
+    constructor(basePath: string, reason: string);
+}
+/**
+ * Thrown when a `:param` segment of a `basePath` has no value in `basePathParams`.
+ *
+ * A base path can be a pattern, so a host keeps one string that mirrors its own
+ * route config. The bridge must still resolve that pattern to a concrete prefix,
+ * because it writes a real browser URL, and it removes a literal prefix from every
+ * inbound location. Every `:param` therefore needs a value.
+ *
+ * **How to fix it:** give the value that the host resolved already — a loader of
+ * TanStack, or a `useParams()` call, holds it — as `basePathParams: { machineId }`.
+ * An empty string counts as an absent value, because it would collapse the segment.
+ *
+ * **Error code:** `PLAY_ROUTER_MISSING_BASE_PATH_PARAM`
+ *
+ * @example
+ * ```typescript
+ * import { MissingBasePathParamError } from "@xmachines/play-router/errors";
+ *
+ * try {
+ *   connectRouter({ actor, router, routeMap, basePath: "/:machineId/play" });
+ * } catch (err) {
+ *   if (err instanceof MissingBasePathParamError) {
+ *     console.error(`basePath needs a value for :${err.param}`);
+ *   }
+ * }
+ * ```
+ */
+export declare class MissingBasePathParamError extends PlayError {
+    /** The name of the `:param` segment without a value, and without its `:`. */
+    readonly param: string;
+    /** The `basePath` option that declares the param. */
+    readonly basePath: string;
+    constructor(param: string, basePath: string);
 }
 //# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,eAAgB,SAAQ,SAAS;gBACjC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAInD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;;CAUlD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,0BAA2B,SAAQ,SAAS;;CASxD;AAED;;;;;GAKG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;IACjD,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEb,OAAO,EAAE,MAAM;CAS3B;AAED;;;;;GAKG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;IACjD,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEb,OAAO,EAAE,MAAM;CAS3B;AAED;;;;;GAKG;AACH,qBAAa,uBAAwB,SAAQ,SAAS;IACrD,sFAAsF;IACtF,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,CAAC;gBAElB,UAAU,EAAE,MAAM,EAAE;CAWhC;AAED;;;;;GAKG;AACH,qBAAa,qBAAsB,SAAQ,SAAS;IACnD,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,sDAAsD;IACtD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE;CAWnE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,wBAAyB,SAAQ,SAAS;IACtD,wEAAwE;IACxE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEb,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAUnD"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,eAAgB,SAAQ,SAAS;gBACjC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAInD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;;CAUlD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,0BAA2B,SAAQ,SAAS;;CASxD;AAED;;;;;GAKG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;IACjD,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEb,OAAO,EAAE,MAAM;CAS3B;AAED;;;;;GAKG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;IACjD,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEb,OAAO,EAAE,MAAM;CAS3B;AAED;;;;;GAKG;AACH,qBAAa,uBAAwB,SAAQ,SAAS;IACrD,sFAAsF;IACtF,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,CAAC;gBAElB,UAAU,EAAE,MAAM,EAAE;CAWhC;AAED;;;;;GAKG;AACH,qBAAa,qBAAsB,SAAQ,SAAS;IACnD,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,sDAAsD;IACtD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE;CAWnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,wBAAyB,SAAQ,SAAS;IACtD,wEAAwE;IACxE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB;;;;;OAKG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;CAazE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IAClD,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAS5C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,yBAA0B,SAAQ,SAAS;IACvD,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,qDAAqD;IACrD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAU3C"}