@telorun/templating 0.5.0 → 0.7.0

package/README.md

@@ -55,8 +55,8 @@ metadata:
     A complete feedback collection REST API — no code, pure YAML.
     Persists entries to SQLite and serves them over HTTP.
 imports:
-  Http: std/http-server@0.8.0
-  Sql: std/sql@0.5.1
+  Http: std/http-server@0.9.0
+  Sql: std/sql@0.8.0
 targets:
   - Migrations
   - Server

package/dist/cel/catalog.d.ts

@@ -0,0 +1,47 @@
+/** Host-injected functions that need platform APIs the templating package must
+ *  not import directly (Node `crypto` / `Buffer`), keeping it browser-safe. The
+ *  kernel supplies real implementations; the analyzer omits them (the stubs
+ *  throw, since static analysis never executes these). */
+export interface CelHandlers {
+    sha256: (s: string) => string;
+    md5: (s: string) => string;
+    sha1: (s: string) => string;
+    sha512: (s: string) => string;
+    hmac: (algorithm: string, key: string, message: string) => string;
+    base64Encode: (s: string) => string;
+    base64Decode: (s: string) => string;
+    json: (value: unknown) => string;
+}
+export type CelFunctionCategory = "conversion" | "time" | "uuid" | "string" | "math" | "collection" | "json" | "encoding" | "hashing" | "null";
+/** One entry in the CEL standard library — the single source of truth that both
+ *  registers the function (`build`) and documents it (everything else). `telo
+ *  cel functions` and `celFunctionCatalog()` read the metadata; `buildCelEnvironment`
+ *  calls `build`. */
+export interface CelFunctionDoc {
+    /** Bare function name (`nowIso`, `uuidv4`). */
+    readonly name: string;
+    /** Human-facing signature for docs (`nowIso(tz?): string`). May use `?` for
+     *  optional args even though cel-js itself has no optional syntax. */
+    readonly signature: string;
+    /** Actual cel-js signatures to register — one per arity for an overloaded
+     *  function. When omitted, `deriveSignatures(signature)` is used: if the
+     *  signature contains `type?`-marked optional params (e.g. `fn(string?): T`),
+     *  it auto-expands to one registration per arity. Set `register` explicitly
+     *  only when the auto-derivation is insufficient. */
+    readonly register?: readonly string[];
+    readonly category: CelFunctionCategory;
+    readonly summary: string;
+    /** False → re-evaluates per call; in an `x-telo-eval: compile` field it bakes
+     *  once at load. */
+    readonly deterministic: boolean;
+    /** Needs a `CelHandlers` implementation (Node `crypto` / `Buffer`); the
+     *  analyzer's stub throws if such a function is actually evaluated. */
+    readonly hostBacked: boolean;
+    readonly build: (h: CelHandlers) => (...args: any[]) => unknown;
+}
+/** Public, build-free view of a catalog entry (for `--json` / docs). */
+export type CelFunctionInfo = Omit<CelFunctionDoc, "build">;
+export declare const CEL_FUNCTIONS: readonly CelFunctionDoc[];
+/** Build-free catalog for the CLI / docs (`telo cel functions`). */
+export declare function celFunctionCatalog(): CelFunctionInfo[];
+//# sourceMappingURL=catalog.d.ts.map

package/dist/cel/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../src/cel/catalog.ts"],"names":[],"mappings":"AAEA;;;0DAG0D;AAC1D,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9B,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC3B,IAAI,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC5B,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9B,IAAI,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IAClE,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IACpC,YAAY,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IACpC,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC;CAClC;AAED,MAAM,MAAM,mBAAmB,GAC3B,YAAY,GACZ,MAAM,GACN,MAAM,GACN,QAAQ,GACR,MAAM,GACN,YAAY,GACZ,MAAM,GACN,UAAU,GACV,SAAS,GACT,MAAM,CAAC;AAEX;;;qBAGqB;AACrB,MAAM,WAAW,cAAc;IAC7B,+CAA+C;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;0EACsE;IACtE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;yDAIqD;IACrD,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;wBACoB;IACpB,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC;2EACuE;IACvE,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,WAAW,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC;CACjE;AAED,wEAAwE;AACxE,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;AAyE5D,eAAO,MAAM,aAAa,EAAE,SAAS,cAAc,EAoZlD,CAAC;AAEF,oEAAoE;AACpE,wBAAgB,kBAAkB,IAAI,eAAe,EAAE,CAEtD"}

package/dist/cel/catalog.js

@@ -0,0 +1,473 @@
+import { v1, v3, v4, v5, v6, v7, validate as uuidValidate, version as uuidVersion } from "uuid";
+const num = (x) => Number(x);
+const minMax = (list, isMin) => {
+    if (!Array.isArray(list) || list.length === 0)
+        return null;
+    let best = list[0];
+    let bestN = num(best);
+    for (const x of list) {
+        const n = num(x);
+        if (isMin ? n < bestN : n > bestN) {
+            best = x;
+            bestN = n;
+        }
+    }
+    return best;
+};
+const sortList = (list) => [...list].sort((a, b) => {
+    if (typeof a === "number" || typeof a === "bigint") {
+        const d = num(a) - num(b);
+        return d < 0 ? -1 : d > 0 ? 1 : 0;
+    }
+    return String(a) < String(b) ? -1 : String(a) > String(b) ? 1 : 0;
+});
+/** `Intl.DateTimeFormat` is an ECMA-402 global in Node (full ICU) and browsers,
+ *  so timezone handling needs no Node-only API and stays browser-safe. */
+const zoneParts = (date, tz, opts) => {
+    const parts = {};
+    for (const p of new Intl.DateTimeFormat("en-US", { timeZone: tz, ...opts }).formatToParts(date)) {
+        parts[p.type] = p.value;
+    }
+    return parts;
+};
+/** Current instant as ISO-8601 in `tz`: UTC `…Z` for "UTC", else the zone's
+ *  offset (e.g. `2026-06-06T18:30:00.000-05:00`). Uses only standard Intl
+ *  fields and derives the offset arithmetically, so it needs no newer Intl
+ *  type-lib features and stays portable. */
+const isoInZone = (tz) => {
+    const now = new Date();
+    if (tz === "UTC" || tz === "Z")
+        return now.toISOString();
+    const p = zoneParts(now, tz, {
+        hourCycle: "h23",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+    });
+    // Sub-second is timezone-independent; read it off the instant directly.
+    const ms = String(now.getUTCMilliseconds()).padStart(3, "0");
+    // Offset = the zone's wall-clock read as UTC, minus the real instant.
+    const asUtc = Date.UTC(+p.year, +p.month - 1, +p.day, +p.hour, +p.minute, +p.second);
+    const offsetMin = Math.round((asUtc - now.getTime()) / 60000);
+    const offset = offsetMin === 0
+        ? "Z"
+        : `${offsetMin > 0 ? "+" : "-"}${String(Math.floor(Math.abs(offsetMin) / 60)).padStart(2, "0")}:${String(Math.abs(offsetMin) % 60).padStart(2, "0")}`;
+    return `${p.year}-${p.month}-${p.day}T${p.hour}:${p.minute}:${p.second}.${ms}${offset}`;
+};
+/** Current calendar date (`YYYY-MM-DD`) in `tz`. */
+const dateInZone = (tz) => {
+    const now = new Date();
+    if (tz === "UTC" || tz === "Z")
+        return now.toISOString().slice(0, 10);
+    const p = zoneParts(now, tz, { year: "numeric", month: "2-digit", day: "2-digit" });
+    return `${p.year}-${p.month}-${p.day}`;
+};
+export const CEL_FUNCTIONS = [
+    // Collections
+    {
+        name: "join",
+        signature: "join(list, string): string",
+        category: "collection",
+        summary: "Join list elements into a string with a separator.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (list, sep) => list.map(String).join(sep),
+    },
+    {
+        name: "keys",
+        signature: "keys(map): list",
+        category: "collection",
+        summary: "List a map's keys.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (map) => map instanceof Map ? [...map.keys()] : Object.keys(map),
+    },
+    {
+        name: "values",
+        signature: "values(map): list",
+        category: "collection",
+        summary: "List a map's values.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (map) => map instanceof Map ? [...map.values()] : Object.values(map),
+    },
+    {
+        name: "distinct",
+        signature: "distinct(list): list",
+        category: "collection",
+        summary: "Remove duplicate elements, preserving order.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (list) => [...new Set(list)],
+    },
+    {
+        name: "reverse",
+        signature: "reverse(list): list",
+        category: "collection",
+        summary: "Reverse a list (copy; never mutates the input).",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (list) => [...list].reverse(),
+    },
+    {
+        name: "flatten",
+        signature: "flatten(list): list",
+        category: "collection",
+        summary: "Flatten one level of nested lists.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (list) => list.flat(),
+    },
+    {
+        name: "sort",
+        signature: "sort(list): list",
+        category: "collection",
+        summary: "Sort a list numerically (numbers) or lexicographically; copy.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (list) => sortList(list),
+    },
+    // Strings
+    {
+        name: "lower",
+        signature: "lower(string): string",
+        category: "string",
+        summary: "Lowercase a string.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (s) => s.toLowerCase(),
+    },
+    {
+        name: "upper",
+        signature: "upper(string): string",
+        category: "string",
+        summary: "Uppercase a string.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (s) => s.toUpperCase(),
+    },
+    {
+        name: "trim",
+        signature: "trim(string): string",
+        category: "string",
+        summary: "Strip leading/trailing whitespace.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (s) => s.trim(),
+    },
+    {
+        name: "replace",
+        signature: "replace(string, string, string): string",
+        category: "string",
+        summary: "Replace all occurrences of a substring.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (s, a, b) => s.split(a).join(b),
+    },
+    {
+        name: "split",
+        signature: "split(string, string): list",
+        category: "string",
+        summary: "Split a string on a separator into a list.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (s, sep) => s.split(sep),
+    },
+    // Math
+    {
+        name: "abs",
+        signature: "abs(dyn): double",
+        category: "math",
+        summary: "Absolute value.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (x) => Math.abs(num(x)),
+    },
+    {
+        name: "floor",
+        signature: "floor(dyn): double",
+        category: "math",
+        summary: "Round down to an integer.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (x) => Math.floor(num(x)),
+    },
+    {
+        name: "ceil",
+        signature: "ceil(dyn): double",
+        category: "math",
+        summary: "Round up to an integer.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (x) => Math.ceil(num(x)),
+    },
+    {
+        name: "round",
+        signature: "round(dyn): double",
+        category: "math",
+        summary: "Round to the nearest integer.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (x) => Math.round(num(x)),
+    },
+    {
+        name: "min",
+        signature: "min(list): dyn",
+        category: "math",
+        summary: "Smallest element (by numeric value); null for an empty list.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (list) => minMax(list, true),
+    },
+    {
+        name: "max",
+        signature: "max(list): dyn",
+        category: "math",
+        summary: "Largest element (by numeric value); null for an empty list.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (list) => minMax(list, false),
+    },
+    // JSON
+    {
+        name: "json",
+        signature: "json(dyn): string",
+        category: "json",
+        summary: "Serialize any value to a JSON string.",
+        deterministic: true,
+        hostBacked: true,
+        build: (h) => (value) => h.json(value),
+    },
+    {
+        name: "parseJson",
+        signature: "parseJson(string): dyn",
+        category: "json",
+        summary: "Parse a JSON string into a value (numbers come back as doubles).",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (s) => JSON.parse(s),
+    },
+    // Encoding
+    {
+        name: "base64Encode",
+        signature: "base64Encode(string): string",
+        category: "encoding",
+        summary: "Encode a UTF-8 string as base64.",
+        deterministic: true,
+        hostBacked: true,
+        build: (h) => (s) => h.base64Encode(s),
+    },
+    {
+        name: "base64Decode",
+        signature: "base64Decode(string): string",
+        category: "encoding",
+        summary: "Decode a base64 string to UTF-8.",
+        deterministic: true,
+        hostBacked: true,
+        build: (h) => (s) => h.base64Decode(s),
+    },
+    {
+        name: "urlEncode",
+        signature: "urlEncode(string): string",
+        category: "encoding",
+        summary: "Percent-encode a URI component.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (s) => encodeURIComponent(s),
+    },
+    {
+        name: "urlDecode",
+        signature: "urlDecode(string): string",
+        category: "encoding",
+        summary: "Decode a percent-encoded URI component.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (s) => decodeURIComponent(s),
+    },
+    // Hashing
+    {
+        name: "sha256",
+        signature: "sha256(string): string",
+        category: "hashing",
+        summary: "SHA-256 hash, hex-encoded.",
+        deterministic: true,
+        hostBacked: true,
+        build: (h) => (s) => h.sha256(s),
+    },
+    {
+        name: "md5",
+        signature: "md5(string): string",
+        category: "hashing",
+        summary: "MD5 hash, hex-encoded.",
+        deterministic: true,
+        hostBacked: true,
+        build: (h) => (s) => h.md5(s),
+    },
+    {
+        name: "sha1",
+        signature: "sha1(string): string",
+        category: "hashing",
+        summary: "SHA-1 hash, hex-encoded.",
+        deterministic: true,
+        hostBacked: true,
+        build: (h) => (s) => h.sha1(s),
+    },
+    {
+        name: "sha512",
+        signature: "sha512(string): string",
+        category: "hashing",
+        summary: "SHA-512 hash, hex-encoded.",
+        deterministic: true,
+        hostBacked: true,
+        build: (h) => (s) => h.sha512(s),
+    },
+    {
+        name: "hmac",
+        signature: "hmac(string, string, string): string",
+        category: "hashing",
+        summary: "HMAC of message under key for an algorithm (e.g. 'sha256'), hex.",
+        deterministic: true,
+        hostBacked: true,
+        build: (h) => (algo, key, msg) => h.hmac(algo, key, msg),
+    },
+    // Null handling
+    {
+        name: "default",
+        signature: "default(dyn, dyn): dyn",
+        category: "null",
+        summary: "Return the value, or the fallback when it is null.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (v, fallback) => v === null || v === undefined ? fallback : v,
+    },
+    {
+        name: "coalesce",
+        signature: "coalesce(list): dyn",
+        category: "null",
+        summary: "First non-null element of a list, or null.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (list) => {
+            const found = list.find((x) => x !== null && x !== undefined);
+            return found === undefined ? null : found;
+        },
+    },
+    // Time (non-deterministic). `nowIso`/`today` take an optional IANA timezone
+    // (default "UTC"); epoch values are absolute and take none.
+    {
+        name: "nowIso",
+        signature: "nowIso(string?): string",
+        category: "time",
+        summary: "Current time as ISO-8601; UTC by default, or in the given IANA timezone.",
+        deterministic: false,
+        hostBacked: false,
+        build: () => (tz) => isoInZone(tz ?? "UTC"),
+    },
+    {
+        name: "today",
+        signature: "today(string?): string",
+        category: "time",
+        summary: "Current calendar date (YYYY-MM-DD); UTC by default, or in the given IANA timezone.",
+        deterministic: false,
+        hostBacked: false,
+        build: () => (tz) => dateInZone(tz ?? "UTC"),
+    },
+    {
+        name: "nowMillis",
+        signature: "nowMillis(): int",
+        category: "time",
+        summary: "Current time as epoch milliseconds (absolute; timezone-independent).",
+        deterministic: false,
+        hostBacked: false,
+        build: () => () => BigInt(Date.now()),
+    },
+    {
+        name: "nowSeconds",
+        signature: "nowSeconds(): int",
+        category: "time",
+        summary: "Current time as epoch seconds (absolute; timezone-independent).",
+        deterministic: false,
+        hostBacked: false,
+        build: () => () => BigInt(Math.floor(Date.now() / 1000)),
+    },
+    // UUID
+    {
+        name: "uuidv1",
+        signature: "uuidv1(): string",
+        category: "uuid",
+        summary: "Time-based UUID (v1).",
+        deterministic: false,
+        hostBacked: false,
+        build: () => () => v1(),
+    },
+    {
+        name: "uuidv4",
+        signature: "uuidv4(): string",
+        category: "uuid",
+        summary: "Random UUID (v4).",
+        deterministic: false,
+        hostBacked: false,
+        build: () => () => v4(),
+    },
+    {
+        name: "uuidv6",
+        signature: "uuidv6(): string",
+        category: "uuid",
+        summary: "Time-ordered UUID (v6).",
+        deterministic: false,
+        hostBacked: false,
+        build: () => () => v6(),
+    },
+    {
+        name: "uuidv7",
+        signature: "uuidv7(): string",
+        category: "uuid",
+        summary: "Time-ordered UUID (v7).",
+        deterministic: false,
+        hostBacked: false,
+        build: () => () => v7(),
+    },
+    {
+        name: "uuidv3",
+        signature: "uuidv3(string, string): string",
+        category: "uuid",
+        summary: "Name-based UUID (v3, MD5) under a namespace UUID.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (name, ns) => v3(name, ns),
+    },
+    {
+        name: "uuidv5",
+        signature: "uuidv5(string, string): string",
+        category: "uuid",
+        summary: "Name-based UUID (v5, SHA-1) under a namespace UUID.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (name, ns) => v5(name, ns),
+    },
+    {
+        name: "uuidValidate",
+        signature: "uuidValidate(string): bool",
+        category: "uuid",
+        summary: "True if the string is a valid UUID.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (s) => uuidValidate(s),
+    },
+    {
+        name: "uuidVersion",
+        signature: "uuidVersion(string): int",
+        category: "uuid",
+        summary: "The version number of a UUID.",
+        deterministic: true,
+        hostBacked: false,
+        build: () => (s) => BigInt(uuidVersion(s)),
+    },
+];
+/** Build-free catalog for the CLI / docs (`telo cel functions`). */
+export function celFunctionCatalog() {
+    return CEL_FUNCTIONS.map(({ build: _build, ...info }) => info);
+}

package/dist/cel/environment.d.ts

@@ -1,12 +1,13 @@
 import { Environment } from "@marcbachmann/cel-js";
-export interface CelHandlers {
-    sha256: (s: string) => string;
-    json: (value: unknown) => string;
-}
-/** Build a CEL `Environment` with Telo's stdlib of functions. Always registers the
- *  same function signatures (so `env.check()` succeeds for type-inference) — the
- *  handlers govern what the function does when called at runtime. Analyzer-only
- *  callers can omit handlers; runtime callers (kernel) must supply real ones.
+import { type CelHandlers } from "./catalog.js";
+export type { CelHandlers } from "./catalog.js";
+/** Build a CEL `Environment` with Telo's stdlib. Every function comes from the
+ *  single-source catalog (`CEL_FUNCTIONS`), so registration and the documented
+ *  surface (`telo cel functions`) can never drift. Always registers the same
+ *  signatures (so `env.check()` succeeds for type-inference); the host-injected
+ *  handlers govern what `hostBacked` functions do at runtime. Analyzer-only
+ *  callers can omit handlers (the stubs throw if such a function is evaluated);
+ *  runtime callers (kernel) supply real ones.
  *
  *  Also registers the `Stream` object type, backed by the `Stream` class from
  *  `@telorun/sdk`. CEL's type-checker rejects values whose constructor isn't
@@ -16,5 +17,12 @@ export interface CelHandlers {
  *  no fields, so terminal access (passing the value through CEL) succeeds but
  *  member access raises a CEL error at runtime — matching the analyzer's
  *  static check on `x-telo-stream`-marked properties. */
-export declare function buildCelEnvironment(handlers?: CelHandlers): Environment;
+/** Expand a documented signature that may contain `type?`-marked optional
+ *  parameters into one cel-js registration signature per arity. For example,
+ *  `"nowIso(string?): string"` produces `["nowIso(): string",
+ *  "nowIso(string): string"]`. Required parameters must precede optional ones.
+ *  Returns `[signature]` unchanged when no `?` is present or the signature
+ *  cannot be parsed. */
+export declare function deriveSignatures(signature: string): string[];
+export declare function buildCelEnvironment(handlers?: Partial<CelHandlers>): Environment;
 //# sourceMappingURL=environment.d.ts.map

package/dist/cel/environment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../src/cel/environment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAGnD,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC9B,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC;CAClC;AAcD;;;;;;;;;;;;yDAYyD;AACzD,wBAAgB,mBAAmB,CAAC,QAAQ,GAAE,WAA2B,GAAG,WAAW,CAgBtF"}
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../src/cel/environment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,EAAiB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAE/D,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAoBhD;;;;;;;;;;;;;;;yDAeyD;AACzD;;;;;wBAKwB;AACxB,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAyB5D;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,GAAE,OAAO,CAAC,WAAW,CAAM,GAAG,WAAW,CAcpF"}