@nifrajs/web 2.1.0 → 2.3.0

package/dist/deferred.js

@@ -2,13 +2,13 @@
  * Deferred loader data (`defer()`). A loader may mark slow values as deferred: the critical data
  * renders in the shell, the deferred data streams in behind a `<Suspense>` (the adapter's `<Await>`
  * consumes it) and resolves on the client **without a re-fetch**. This module owns the agnostic
- * protocol — the marker, the resolved/deferred split, and the tiny client registry that streamed
+ * protocol - the marker, the resolved/deferred split, and the tiny client registry that streamed
  * resolution scripts settle. The per-adapter `<Await>` lives in `@nifrajs/web-{solid,react}/client`.
  */
 import { plainJsonCodec } from "@nifrajs/core/transport-codec";
 /**
- * Mark a loader value as deferred — it streams in after the shell instead of blocking it. Works
- * **anywhere** in the loader's returned data — a top-level key, or nested in objects/arrays:
+ * Mark a loader value as deferred - it streams in after the shell instead of blocking it. Works
+ * **anywhere** in the loader's returned data - a top-level key, or nested in objects/arrays:
  *
  *   return { user: await api.user.get(), feed: defer(api.user.feed()),
  *            panels: [{ chart: defer(api.metrics()) }] }
@@ -32,8 +32,8 @@ function isDeferred(value) {
 /**
  * Split a loader (or action) result into the **component-facing** data (deferred values carry their
  * assigned `id` + promise, for `<Await>`) and the **client-serializable** data (deferred values
- * replaced with a `{__nifra_deferred: id}` placeholder — promises don't serialize). Walks the tree
- * **recursively** — `defer()` works at any depth, inside nested objects and arrays — assigning ids in
+ * replaced with a `{__nifra_deferred: id}` placeholder - promises don't serialize). Walks the tree
+ * **recursively** - `defer()` works at any depth, inside nested objects and arrays - assigning ids in
  * walk order. `idOffset` continues the id space when a page splits two results (loader data **and**
  * action data) into one shared client registry, so their ids don't collide. `deferred` lists the
  * promises for callers that await them. Recurses plain objects + arrays only; the data is expected to
@@ -42,7 +42,7 @@ function isDeferred(value) {
 export function prepareDeferred(data, idOffset = 0) {
     const deferred = [];
     // Structural sharing: a subtree with no deferred value returns the ORIGINAL node for
-    // both sides (`fc`/`cl` identical to the input), so a deferred-free result — the common case — is
+    // both sides (`fc`/`cl` identical to the input), so a deferred-free result - the common case - is
     // returned by reference with no persisted clone, no downstream copy, and no throwaway clone
     // allocations. Only the path to a `defer()` marker is rebuilt; unchanged siblings are shared by
     // reference.
@@ -119,18 +119,18 @@ export function prepareDeferred(data, idOffset = 0) {
         : { forComponent: result.fc, forClient: result.cl, deferred };
 }
 /**
- * Stable, non-leaking payload streamed to the client when a deferred value rejects — never the raw
+ * Stable, non-leaking payload streamed to the client when a deferred value rejects - never the raw
  * error text. The real reason is logged server-side; `<Await>`'s `errorFallback` receives
  * this code. (A future typed `DeferredError` could opt into a public, intentional message.) Shared by
  * the NDJSON soft-nav transport and the full-document SSR path (`renderPage`'s `streamDocument`).
  */
 export const DEFERRED_ERROR_CODE = "deferred_error";
-// Shared, stateless — allocated once at module load, not per stream.
+// Shared, stateless - allocated once at module load, not per stream.
 const NDJSON_ENCODER = new TextEncoder();
 /**
  * Stream a loader result as NDJSON for a client (soft) navigation: line 1 is the critical data with
  * `{__nifra_deferred: id}` placeholders (`forClient`), then one line per deferred as its promise
- * settles — `{"i": id, "v": value}` on resolve, `{"i": id, "e": "deferred_error"}` on reject (a
+ * settles - `{"i": id, "v": value}` on resolve, `{"i": id, "e": "deferred_error"}` on reject (a
  * rejection is data, not a stream error; the opaque code never leaks the raw reason). Closes when all
  * settle. The client (`defaultFetchData`) returns the
  * data after line 1 and settles `<Await>`'s markers as the resolution lines arrive. `JSON.stringify`
@@ -180,7 +180,7 @@ export const DEFERRED_RUNTIME = `(() => {
     return e;
   };
   window.__nifraDeferred = (id) => get(id).p;
-  // Tag the promise (status/value/reason) — React's use() reads them and returns SYNCHRONOUSLY at
+  // Tag the promise (status/value/reason) - React's use() reads them and returns SYNCHRONOUSLY at
   // hydration, so it renders the resolved content directly into the <Suspense> boundary the server
   // streamed (no re-suspend, no fallback flash). r/j also wake awaiters (Solid uses its own _$HY).
   window.__nifraResolve = (id, v) => { const e = get(id); e.p.status = "fulfilled"; e.p.value = v; e.r(v); };
@@ -188,7 +188,7 @@ export const DEFERRED_RUNTIME = `(() => {
 })();`;
 /**
  * Source emitted into the generated client entry: maps serialized `{__nifra_deferred: id}` placeholders
- * (at any depth — nested objects/arrays) to the registry's promises, so the component receives real
+ * (at any depth - nested objects/arrays) to the registry's promises, so the component receives real
  * promises to `<Await>`. A no-op for data without placeholders (so non-deferred pages are unchanged).
  */
 export const MAP_DEFERRED_SOURCE = `const mapDeferred = (d) => {
@@ -199,18 +199,18 @@ export const MAP_DEFERRED_SOURCE = `const mapDeferred = (d) => {
   for (const k in d) out[k] = mapDeferred(d[k])
   return out
 }`;
-/** Replace `{__nifra_deferred: <number>}` placeholders (at any depth — nested objects/arrays) with
+/** Replace `{__nifra_deferred: <number>}` placeholders (at any depth - nested objects/arrays) with
  * `Deferred` markers whose promises are held open in `pending` (settled later by
  * {@link parseNdjsonData}'s drain). Mirrors `prepareDeferred`'s recursive walk. */
 function markersFromPlaceholders(data, pending) {
-    // Markers already created in THIS parse, keyed by id — so a repeated id aliases the first marker.
+    // Markers already created in THIS parse, keyed by id - so a repeated id aliases the first marker.
     const byId = new Map();
     const walk = (value) => {
         const id = value?.__nifra_deferred;
         if (value !== null && typeof value === "object" && typeof id === "number") {
             // The NDJSON stream is a trust boundary; the server assigns unique ids, but a corrupt/crafted
             // line-1 could repeat one. Alias a duplicate id to the first marker (same promise) instead of
-            // overwriting its resolver in `pending` — otherwise the first marker would never settle (a
+            // overwriting its resolver in `pending` - otherwise the first marker would never settle (a
             // permanently-pending promise that leaks on abort). One resolve line then settles both.
             const seen = byId.get(id);
             if (seen !== undefined)
@@ -246,7 +246,7 @@ function markersFromPlaceholders(data, pending) {
  * the NDJSON body into a data object whose deferred markers settle as resolution lines arrive.
  * Returns after **line 1** so the router can apply the critical data + render immediately; the
  * markers' promises settle/reject in the background. If the stream ends (or `signal` aborts) with
- * markers unsettled, they reject — so `<Await>` never hangs.
+ * markers unsettled, they reject - so `<Await>` never hangs.
  */
 export async function parseNdjsonData(stream, signal, codec = plainJsonCodec) {
     const reader = stream.getReader();
@@ -297,7 +297,7 @@ export async function parseNdjsonData(stream, signal, codec = plainJsonCodec) {
             }
         }
         catch {
-            // stream errored — leftovers are rejected below (unless this was an abort)
+            // stream errored - leftovers are rejected below (unless this was an abort)
         }
         finally {
             signal?.removeEventListener("abort", onAbort); // no-op if it already fired ({ once: true })

package/dist/dev-error.d.ts

@@ -1,7 +1,7 @@
 /**
  * Dev-only error overlay. When a loader/action/render throws during `@nifrajs/web/vite` dev, this
- * renders a readable full-page overlay — the message, the source-mapped stack (Vite's
- * `ssrFixStacktrace` runs first), and the request line — instead of the bare `err.stack` text dump.
+ * renders a readable full-page overlay - the message, the source-mapped stack (Vite's
+ * `ssrFixStacktrace` runs first), and the request line - instead of the bare `err.stack` text dump.
  * Dev-only by construction: it's called solely from the Vite middleware's catch, never in
  * production (production maps errors to the `_error` route boundary).
  */

package/dist/dev-error.js

@@ -1,7 +1,7 @@
 /**
  * Dev-only error overlay. When a loader/action/render throws during `@nifrajs/web/vite` dev, this
- * renders a readable full-page overlay — the message, the source-mapped stack (Vite's
- * `ssrFixStacktrace` runs first), and the request line — instead of the bare `err.stack` text dump.
+ * renders a readable full-page overlay - the message, the source-mapped stack (Vite's
+ * `ssrFixStacktrace` runs first), and the request line - instead of the bare `err.stack` text dump.
  * Dev-only by construction: it's called solely from the Vite middleware's catch, never in
  * production (production maps errors to the `_error` route boundary).
  */
@@ -31,7 +31,7 @@ export function renderDevErrorOverlay(err, req) {
     const framesHtml = frames.length > 0
         ? `<ol class="frames">${frames.map((f) => `<li>${esc(f)}</li>`).join("")}</ol>`
         : `<p class="no-frames">No stack frames.</p>`;
-    return `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>${name} — nifra dev</title>
+    return `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>${name} - nifra dev</title>
 <style>
   :root { color-scheme: dark }
   body { margin: 0; background: #0b0d10; color: #e6e6e6; font: 14px/1.6 ui-monospace, SFMono-Regular, Menlo, monospace; }

package/dist/dev-port.d.ts

@@ -0,0 +1,36 @@
+/**
+ * `@nifrajs/web/dev-port` - what a dev server says when it cannot bind.
+ *
+ * Both pipelines need this and neither should own it: the Vite server binds through Node's `http`
+ * (asynchronous `error` event), the Bun server binds through `Bun.serve` (synchronous throw). Two very
+ * different failure mechanics, one thing the developer has to be told.
+ *
+ * That message is worth this much care because the visible symptom is not the real one. When the port is
+ * taken, the EARLIER dev server is still answering on it, still serving the build it started with. Every
+ * subsequent edit appears to do nothing. What reaches the developer is "my changes stopped reaching SSR",
+ * which reads as broken HMR or a stale module graph and sends them into the module graph - not to the one
+ * process that never started. Naming the cause here is the entire fix.
+ *
+ * This module deliberately imports nothing: it is shared by a Node-http path and a Bun path, and the
+ * structural `ListenTarget` keeps it free of either runtime's types.
+ */
+/** The `EADDRINUSE` explanation. Exported so tests pin the exact text a user will read. */
+export declare function portInUseMessage(port: number): string;
+/** True when an unknown thrown value carries the "address already in use" errno. */
+export declare const isAddressInUse: (err: unknown) => boolean;
+/** Map a bind failure to the port-collision explanation, leaving every other failure as itself. */
+export declare const explainBindFailure: (err: unknown, port: number) => Error;
+/** The bits of a Node server {@link listenOrExplain} touches - structural, so a test can fake it. */
+export interface ListenTarget {
+    listen(port: number, cb: () => void): void;
+    once(event: "error", cb: (err: unknown) => void): void;
+    removeListener(event: "error", cb: (err: unknown) => void): void;
+}
+/**
+ * `listen`, but a bind failure becomes a readable nifra error instead of Node's raw internal throw.
+ *
+ * Without an `error` listener attached, Node throws from deep inside `node:events`, the new process dies
+ * in the background, and nothing connects that death to the stale page in front of you.
+ */
+export declare function listenOrExplain(server: ListenTarget, port: number): Promise<void>;
+//# sourceMappingURL=dev-port.d.ts.map

package/dist/dev-port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-port.d.ts","sourceRoot":"","sources":["../src/dev-port.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,2FAA2F;AAC3F,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQrD;AAED,oFAAoF;AACpF,eAAO,MAAM,cAAc,GAAI,KAAK,OAAO,KAAG,OACa,CAAA;AAI3D,mGAAmG;AACnG,eAAO,MAAM,kBAAkB,GAAI,KAAK,OAAO,EAAE,MAAM,MAAM,KAAG,KACQ,CAAA;AAExE,qGAAqG;AACrG,MAAM,WAAW,YAAY;IAC3B,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;IAC1C,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI,CAAA;IACtD,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI,CAAA;CACjE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAWjF"}

package/dist/dev-port.js

@@ -0,0 +1,48 @@
+/**
+ * `@nifrajs/web/dev-port` - what a dev server says when it cannot bind.
+ *
+ * Both pipelines need this and neither should own it: the Vite server binds through Node's `http`
+ * (asynchronous `error` event), the Bun server binds through `Bun.serve` (synchronous throw). Two very
+ * different failure mechanics, one thing the developer has to be told.
+ *
+ * That message is worth this much care because the visible symptom is not the real one. When the port is
+ * taken, the EARLIER dev server is still answering on it, still serving the build it started with. Every
+ * subsequent edit appears to do nothing. What reaches the developer is "my changes stopped reaching SSR",
+ * which reads as broken HMR or a stale module graph and sends them into the module graph - not to the one
+ * process that never started. Naming the cause here is the entire fix.
+ *
+ * This module deliberately imports nothing: it is shared by a Node-http path and a Bun path, and the
+ * structural `ListenTarget` keeps it free of either runtime's types.
+ */
+/** The `EADDRINUSE` explanation. Exported so tests pin the exact text a user will read. */
+export function portInUseMessage(port) {
+    return (`[nifra] dev server can't start: port ${port} is already in use.\n` +
+        `  Most likely an earlier \`nifra dev\` is still running. It keeps serving the PREVIOUS build, so ` +
+        `every edit will look like it stops reaching SSR while the browser shows stale output.\n` +
+        `  Free the port:  lsof -ti:${port} | xargs kill\n` +
+        `  Or use another: nifra dev --port ${port + 1}`);
+}
+/** True when an unknown thrown value carries the "address already in use" errno. */
+export const isAddressInUse = (err) => err?.code === "EADDRINUSE";
+const asError = (err) => (err instanceof Error ? err : new Error(String(err)));
+/** Map a bind failure to the port-collision explanation, leaving every other failure as itself. */
+export const explainBindFailure = (err, port) => isAddressInUse(err) ? new Error(portInUseMessage(port)) : asError(err);
+/**
+ * `listen`, but a bind failure becomes a readable nifra error instead of Node's raw internal throw.
+ *
+ * Without an `error` listener attached, Node throws from deep inside `node:events`, the new process dies
+ * in the background, and nothing connects that death to the stale page in front of you.
+ */
+export function listenOrExplain(server, port) {
+    return new Promise((resolve, reject) => {
+        const onError = (err) => reject(explainBindFailure(err, port));
+        server.once("error", onError);
+        server.listen(port, () => {
+            // Drop the guard once we're listening: leaving it attached would funnel a LATER server error into
+            // an already-settled promise, silently swallowing it instead of surfacing it.
+            server.removeListener("error", onError);
+            resolve();
+        });
+    });
+}
+//# sourceMappingURL=dev-port.js.map

package/dist/dev-port.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-port.js","sourceRoot":"","sources":["../src/dev-port.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,2FAA2F;AAC3F,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,OAAO,CACL,wCAAwC,IAAI,uBAAuB;QACnE,mGAAmG;QACnG,yFAAyF;QACzF,8BAA8B,IAAI,iBAAiB;QACnD,sCAAsC,IAAI,GAAG,CAAC,EAAE,CACjD,CAAA;AACH,CAAC;AAED,oFAAoF;AACpF,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,GAAY,EAAW,EAAE,CACrD,GAAiC,EAAE,IAAI,KAAK,YAAY,CAAA;AAE3D,MAAM,OAAO,GAAG,CAAC,GAAY,EAAS,EAAE,CAAC,CAAC,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;AAE9F,mGAAmG;AACnG,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,GAAY,EAAE,IAAY,EAAS,EAAE,CACtE,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;AASxE;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,MAAoB,EAAE,IAAY;IAChE,OAAO,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QAC3C,MAAM,OAAO,GAAG,CAAC,GAAY,EAAQ,EAAE,CAAC,MAAM,CAAC,kBAAkB,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAA;QAC7E,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;QAC7B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE;YACvB,kGAAkG;YAClG,8EAA8E;YAC9E,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;YACvC,OAAO,EAAE,CAAA;QACX,CAAC,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;AACJ,CAAC"}

package/dist/dev.d.ts

@@ -1,25 +1,82 @@
 import { type BuildClientOptions } from "./build.js";
-/** Minimal app surface the dev server needs — `createWebApp(...)` satisfies it. */
+/** Minimal app surface the dev server needs - `createWebApp(...)` satisfies it. */
 interface FetchApp {
     fetch(request: Request): Response | Promise<Response>;
 }
 export interface DevServerOptions extends Omit<BuildClientOptions, "minify"> {
     /**
-     * Build the nifra app for the freshly-built client entry. `importQuery` changes on every
-     * rebuild — pass it to `discoverRoutes(routesDir, { importQuery })` so SSR re-imports edited
-     * route modules instead of Bun's cached copies.
+     * Build the nifra app for the current client entry. `importQuery` changes on every reload - pass it to
+     * `discoverRoutes(routesDir, { importQuery })` so SSR re-imports edited route modules instead of Bun's
+     * cached copies.
      */
     readonly createApp: (clientEntry: string, importQuery: string) => FetchApp | Promise<FetchApp>;
     /** Directories to watch (default: `[routesDir]`). */
     readonly watch?: readonly string[];
     /** Port to listen on (default {@link DEFAULT_DEV_PORT}). */
     readonly port?: number;
+    /** Directory of user-authored static files served at the root (default `"public"`). The SAME
+     * option the production build copies and serves, so dev and prod cannot drift. */
+    readonly publicDir?: string | false;
+    /**
+     * Run the client-leak guards on each change (default `true`).
+     *
+     * `buildClient` is what runs them - server-only code reaching the browser, `node:` builtins in client
+     * code - and Bun's dev server does its own bundling, so nothing would run them otherwise. They are
+     * security guards; a dev loop that stops enforcing them is how a leak reaches a deploy unnoticed. The
+     * pass runs in the background off the hot path, so HMR is never waiting on it, and only reports.
+     */
+    readonly guardLeaks?: boolean;
 }
 export interface DevServer {
     readonly port: number;
+    /**
+     * The URL pages point their client entry at - always {@link CLIENT_ENTRY_PATH}, never Bun's hashed
+     * chunk. Deliberately not the underlying chunk URL: that one moves on every rebuild, and anything
+     * holding onto it is holding onto a URL that will stop working.
+     */
+    readonly clientEntry: string;
     stop(): void;
 }
-/** Start the dev server: build → serve → watch → rebuild + reload on change. */
+/**
+ * The stable URL every SSR'd page points its client entry at.
+ *
+ * It has to be stable, and Bun's own URL is not: that one is a content hash over the entire client graph,
+ * so it changes whenever anything the entry imports changes. This path redirects to whichever hashed
+ * chunk Bun is serving at the moment the browser asks, which is the only formulation that stays correct
+ * across a rebuild.
+ */
+export declare const CLIENT_ENTRY_PATH = "/__nifra/client.js";
+/**
+ * The throwaway HTML document. Its only job is to make Bun bundle the entry and assign it a URL - it is
+ * never shown to a user, so it carries no app markup. The `<div id="root">` is there purely so the
+ * document stands on its own if someone opens the probe path directly while debugging.
+ */
+export declare function devHtml(entryHref: string): string;
+interface WriteDevFilesOptions {
+    readonly routesDir: string;
+    readonly clientModule: string;
+    readonly entryPath: string;
+    readonly htmlPath: string;
+}
+/**
+ * Generate the client entry + the HTML route that carries it.
+ *
+ * Route specifiers are written **relative to the entry file**, not root-relative as the Vite path writes
+ * them: Vite resolves `/routes/x.tsx` against its configured root, while Bun's bundler resolves an import
+ * the way the runtime does, so a leading slash there would mean the filesystem root.
+ */
+export declare function writeDevFiles(options: WriteDevFilesOptions): void;
+/** `<link rel="stylesheet">` tags for Bun's extracted CSS, injected into each SSR'd page's `<head>`. */
+export declare function styleTags(styles: readonly string[]): string;
+/**
+ * Inject Bun's stylesheet links into an SSR'd document.
+ *
+ * Prefers `</head>`; falls back to prepending when a document has no head (a bare fragment from a custom
+ * renderer). Never appends blindly at the end - a stylesheet after `</body>` still applies but arrives
+ * after first paint, so the page flashes unstyled and dev stops resembling production.
+ */
+export declare function injectStyles(html: string, styles: readonly string[]): string;
+/** Start the Bun dev server: generate → bundle → serve → watch → hot-reload on change. */
 export declare function createDevServer(options: DevServerOptions): Promise<DevServer>;
 export {};
 //# sourceMappingURL=dev.d.ts.map

package/dist/dev.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../src/dev.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,kBAAkB,EAAe,MAAM,YAAY,CAAA;AAGjE,mFAAmF;AACnF,UAAU,QAAQ;IAChB,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;CACtD;AAED,MAAM,WAAW,gBAAiB,SAAQ,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC;IAC1E;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;IAC9F,qDAAqD;IACrD,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAClC,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,IAAI,IAAI,IAAI,CAAA;CACb;AAOD,gFAAgF;AAChF,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,SAAS,CAAC,CAoEnF"}
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../src/dev.ts"],"names":[],"mappings":"AAsDA,OAAO,EAAE,KAAK,kBAAkB,EAAe,MAAM,YAAY,CAAA;AAQjE,mFAAmF;AACnF,UAAU,QAAQ;IAChB,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;CACtD;AAED,MAAM,WAAW,gBAAiB,SAAQ,IAAI,CAAC,kBAAkB,EAAE,QAAQ,CAAC;IAC1E;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;IAC9F,qDAAqD;IACrD,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAClC,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB;sFACkF;IAClF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,KAAK,CAAA;IACnC;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAC9B;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,IAAI,IAAI,IAAI,CAAA;CACb;AAaD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,uBAAuB,CAAA;AAuCrD;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAMjD;AAED,UAAU,oBAAoB;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI,CAsBjE;AAED,wGAAwG;AACxG,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAQ3D;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAM5E;AAED,0FAA0F;AAC1F,wBAAsB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,SAAS,CAAC,CAwOnF"}