@telorun/cel 0.107.0 → 0.109.0

package/dist/catalog-runtime.js

@@ -50,9 +50,9 @@ class CatalogRefusal extends Error {
 }
 /** The one place a refusal becomes a value. Anything else thrown is a defect here. */
 function refusing(run) {
-    return (args, ctx) => {
+    return (ctx, a, b, c, d) => {
         try {
-            return run(args, ctx);
+            return run(ctx, a, b, c, d);
         }
         catch (cause) {
             if (cause instanceof CatalogRefusal)
@@ -71,11 +71,13 @@ const own = (run) => () => refusing(run);
 const hosted = (name, build) => (handlers) => {
     const handler = handlers[name];
     if (handler === undefined) {
-        return (_args, ctx) => celError("unbound_function", `${name}() is supplied by the host, and this environment was given no implementation for it`, ctx.range);
+        return (ctx) => celError("unbound_function", `${name}() is supplied by the host, and this environment was given no implementation for it`, ctx.range);
     }
     return refusing(build(handler));
 };
 // --- reading arguments ------------------------------------------------------
+// `CelValue | undefined` because a parameter list is as wide as the widest overload; the
+// dispatcher has already resolved on this argument's type.
 const text = (value) => value;
 const bytes = (value) => value;
 /**
@@ -467,174 +469,173 @@ function compacted(value) {
 // --- the table -------------------------------------------------------------
 const IMPLEMENTATIONS = new Map([
     // collections
-    ["join(list<dyn>, string)", own((args) => list("join", args[0]).map((held) => textOf("join", held)).join(text(args[1])))],
-    ["keys(map<dyn, dyn>)", own((args) => mapEntries("keys", args[0]).map(([key]) => key))],
-    ["values(map<dyn, dyn>)", own((args) => mapEntries("values", args[0]).map(([, value]) => value))],
-    ["distinct(list<dyn>)", own((args) => distinct(list("distinct", args[0])))],
-    ["reverse(list<dyn>)", own((args) => [...list("reverse", args[0])].reverse())],
-    ["flatten(list<dyn>)", own((args) => list("flatten", args[0]).flat())],
-    ["sort(list<dyn>)", own((args) => sorted("sort", list("sort", args[0])))],
+    ["join(list<dyn>, string)", own((ctx, a, b) => list("join", a).map((held) => textOf("join", held)).join(text(b)))],
+    ["keys(map<dyn, dyn>)", own((ctx, a) => mapEntries("keys", a).map(([key]) => key))],
+    ["values(map<dyn, dyn>)", own((ctx, a) => mapEntries("values", a).map(([, value]) => value))],
+    ["distinct(list<dyn>)", own((ctx, a) => distinct(list("distinct", a)))],
+    ["reverse(list<dyn>)", own((ctx, a) => [...list("reverse", a)].reverse())],
+    ["flatten(list<dyn>)", own((ctx, a) => list("flatten", a).flat())],
+    ["sort(list<dyn>)", own((ctx, a) => sorted("sort", list("sort", a)))],
     [
         "range(int)",
-        own((args) => Array.from({ length: Math.max(0, Math.trunc(numberOf(args[0]))) }, (_unused, at) => BigInt(at))),
+        own((ctx, a) => Array.from({ length: Math.max(0, Math.trunc(numberOf(a))) }, (_unused, at) => BigInt(at))),
     ],
     [
         "enumerate(list<dyn>)",
-        own((args) => list("enumerate", args[0]).map((value, at) => {
+        own((ctx, a) => list("enumerate", a).map((value, at) => {
             const entry = Object.create(null);
             entry.index = BigInt(at);
             entry.value = value;
             return entry;
         })),
     ],
-    ["compact(list<dyn>)", own((args) => compacted(args[0]))],
-    ["compact(map<dyn, dyn>)", own((args) => compacted(args[0]))],
+    ["compact(list<dyn>)", own((ctx, a) => compacted(a))],
+    ["compact(map<dyn, dyn>)", own((ctx, a) => compacted(a))],
     [
         "merge(map<dyn, dyn>, map<dyn, dyn>)",
-        own((args) => mapOfEntries(args[0], [...mapEntries("merge", args[0]), ...mapEntries("merge", args[1])])),
+        own((ctx, a, b) => mapOfEntries(a, [...mapEntries("merge", a), ...mapEntries("merge", b)])),
     ],
     // One body over the three: the overloads exist so that a statically wrong receiver is a
     // type error, and at runtime a `dyn` receiver reaches whichever of them resolved first, so
     // the VALUE decides what is sliced.
-    ["slice(bytes, int, int)", own(sliced)],
-    ["slice(string, int, int)", own(sliced)],
-    ["slice(list<dyn>, int, int)", own(sliced)],
+    ["slice(bytes, int, int)", own((ctx, a, b, c) => sliced(a, b, c))],
+    ["slice(string, int, int)", own((ctx, a, b, c) => sliced(a, b, c))],
+    ["slice(list<dyn>, int, int)", own((ctx, a, b, c) => sliced(a, b, c))],
     // strings
-    ["lower(string)", own((args) => text(args[0]).toLowerCase())],
-    ["upper(string)", own((args) => text(args[0]).toUpperCase())],
-    ["trim(string)", own((args) => text(args[0]).trim())],
-    ["replace(string, string, string)", own((args) => text(args[0]).split(text(args[1])).join(text(args[2])))],
-    ["split(string, string)", own((args) => text(args[0]).split(text(args[1])))],
+    ["lower(string)", own((ctx, a) => text(a).toLowerCase())],
+    ["upper(string)", own((ctx, a) => text(a).toUpperCase())],
+    ["trim(string)", own((ctx, a) => text(a).trim())],
+    ["replace(string, string, string)", own((ctx, a, b, c) => text(a).split(text(b)).join(text(c)))],
+    ["split(string, string)", own((ctx, a, b) => text(a).split(text(b)))],
     [
         "trimPrefix(string, string)",
-        own((args) => {
-            const prefix = text(args[1]);
-            return text(args[0]).startsWith(prefix) ? text(args[0]).slice(prefix.length) : args[0];
+        own((ctx, a, b) => {
+            const prefix = text(b);
+            return text(a).startsWith(prefix) ? text(a).slice(prefix.length) : text(a);
         }),
     ],
     [
         "trimSuffix(string, string)",
-        own((args) => {
-            const suffix = text(args[1]);
-            const value = text(args[0]);
+        own((ctx, a, b) => {
+            const suffix = text(b);
+            const value = text(a);
             return suffix !== "" && value.endsWith(suffix) ? value.slice(0, value.length - suffix.length) : value;
         }),
     ],
     [
         "regexReplace(string, string, string)",
-        own((args) => pattern("regexReplace", args[1], undefined).matcher(text(args[0])).replaceAll(text(args[2]))),
+        own((ctx, a, b, c) => pattern("regexReplace", b, undefined).matcher(text(a)).replaceAll(text(c))),
     ],
     [
         "regexReplace(string, string, string, string)",
-        own((args) => pattern("regexReplace", args[1], args[3]).matcher(text(args[0])).replaceAll(text(args[2]))),
+        own((ctx, a, b, c, d) => pattern("regexReplace", b, d).matcher(text(a)).replaceAll(text(c))),
     ],
-    ["regexExtract(string, string)", own((args) => firstMatch("regexExtract", args, undefined))],
-    ["regexExtract(string, string, string)", own((args) => firstMatch("regexExtract", args, args[2]))],
-    ["regexExtractAll(string, string)", own((args) => everyMatch("regexExtractAll", args, undefined))],
-    ["regexExtractAll(string, string, string)", own((args) => everyMatch("regexExtractAll", args, args[2]))],
-    ["regexGroups(string, string)", own((args) => matchGroups("regexGroups", args, undefined))],
-    ["regexGroups(string, string, string)", own((args) => matchGroups("regexGroups", args, args[2]))],
+    ["regexExtract(string, string)", own((ctx, a, b) => firstMatch("regexExtract", a, b, undefined))],
+    ["regexExtract(string, string, string)", own((ctx, a, b, c) => firstMatch("regexExtract", a, b, c))],
+    ["regexExtractAll(string, string)", own((ctx, a, b) => everyMatch("regexExtractAll", a, b, undefined))],
+    ["regexExtractAll(string, string, string)", own((ctx, a, b, c) => everyMatch("regexExtractAll", a, b, c))],
+    ["regexGroups(string, string)", own((ctx, a, b) => matchGroups("regexGroups", a, b, undefined))],
+    ["regexGroups(string, string, string)", own((ctx, a, b, c) => matchGroups("regexGroups", a, b, c))],
     // math
-    ["abs(dyn)", own((args) => Math.abs(numberOf(args[0])))],
-    ["floor(dyn)", own((args) => Math.floor(numberOf(args[0])))],
-    ["ceil(dyn)", own((args) => Math.ceil(numberOf(args[0])))],
+    ["abs(dyn)", own((ctx, a) => Math.abs(numberOf(a)))],
+    ["floor(dyn)", own((ctx, a) => Math.floor(numberOf(a)))],
+    ["ceil(dyn)", own((ctx, a) => Math.ceil(numberOf(a)))],
     // Both arities go through `formattable`, so the 2^53 refusal does not depend on which
     // one the author wrote: guarding only the two-argument form left `round(x)` silently
     // answering with a neighbouring integer, reachable by writing one fewer argument.
-    ["round(double)", own((args) => Math.round(formattable("round", args[0])))],
-    ["round(int)", own((args) => Math.round(formattable("round", args[0])))],
-    ["round(double, int)", own((args) => roundedTo(args))],
-    ["round(int, int)", own((args) => roundedTo(args))],
-    ["min(list<dyn>)", own((args) => smallest(list("min", args[0]), true))],
-    ["max(list<dyn>)", own((args) => smallest(list("max", args[0]), false))],
+    ["round(double)", own((ctx, a) => Math.round(formattable("round", a)))],
+    ["round(int)", own((ctx, a) => Math.round(formattable("round", a)))],
+    ["round(double, int)", own((ctx, a, b) => roundedTo(a, b))],
+    ["round(int, int)", own((ctx, a, b) => roundedTo(a, b))],
+    ["min(list<dyn>)", own((ctx, a) => smallest(list("min", a), true))],
+    ["max(list<dyn>)", own((ctx, a) => smallest(list("max", a), false))],
     [
         "sum(list<dyn>)",
-        own((args) => list("sum", args[0]).reduce((total, held) => total + numberOf(held), 0)),
+        own((ctx, a) => list("sum", a).reduce((total, held) => total + numberOf(held), 0)),
     ],
     [
         "avg(list<dyn>)",
-        own((args) => {
-            const values = list("avg", args[0]);
+        own((ctx, a) => {
+            const values = list("avg", a);
             if (values.length === 0)
                 return null;
             return values.reduce((total, held) => total + numberOf(held), 0) / values.length;
         }),
     ],
     // JSON
-    ["json(dyn)", hosted("json", (handler) => (args) => handler(args[0]))],
-    ["parseJson(string)", own((args) => parseJsonText(text(args[0])))],
+    ["json(dyn)", hosted("json", (handler) => (ctx, a) => handler(a))],
+    ["parseJson(string)", own((ctx, a) => parseJsonText(text(a)))],
     // paths
     [
         "string.joinPath(string)",
-        hosted("joinPath", (handler) => (args) => handler(text(args[0]), text(args[1]))),
+        hosted("joinPath", (handler) => (ctx, a, b) => handler(text(a), text(b))),
     ],
     // encoding
-    ["base64Encode(string)", hosted("base64Encode", (handler) => (args) => handler(text(args[0])))],
-    ["base64Decode(string)", hosted("base64Decode", (handler) => (args) => handler(text(args[0])))],
-    ["bytesFromBase64(string)", own((args) => bytesFromBase64(text(args[0])))],
-    ["bytesToBase64(bytes)", own((args) => base64Text(bytes(args[0])))],
-    ["urlEncode(string)", own((args) => encodeURIComponent(text(args[0])))],
-    ["urlDecode(string)", own((args) => decodeURIComponent(text(args[0])))],
+    ["base64Encode(string)", hosted("base64Encode", (handler) => (ctx, a) => handler(text(a)))],
+    ["base64Decode(string)", hosted("base64Decode", (handler) => (ctx, a) => handler(text(a)))],
+    ["bytesFromBase64(string)", own((ctx, a) => bytesFromBase64(text(a)))],
+    ["bytesToBase64(bytes)", own((ctx, a) => base64Text(bytes(a)))],
+    ["urlEncode(string)", own((ctx, a) => encodeURIComponent(text(a)))],
+    ["urlDecode(string)", own((ctx, a) => decodeURIComponent(text(a)))],
     // hashing
-    ["sha256(string)", hosted("sha256", (handler) => (args) => handler(text(args[0])))],
-    ["md5(string)", hosted("md5", (handler) => (args) => handler(text(args[0])))],
-    ["sha1(string)", hosted("sha1", (handler) => (args) => handler(text(args[0])))],
-    ["sha512(string)", hosted("sha512", (handler) => (args) => handler(text(args[0])))],
+    ["sha256(string)", hosted("sha256", (handler) => (ctx, a) => handler(text(a)))],
+    ["md5(string)", hosted("md5", (handler) => (ctx, a) => handler(text(a)))],
+    ["sha1(string)", hosted("sha1", (handler) => (ctx, a) => handler(text(a)))],
+    ["sha512(string)", hosted("sha512", (handler) => (ctx, a) => handler(text(a)))],
     [
         "hmac(string, string, string)",
-        hosted("hmac", (handler) => (args) => handler(text(args[0]), text(args[1]), text(args[2]))),
+        hosted("hmac", (handler) => (ctx, a, b, c) => handler(text(a), text(b), text(c))),
     ],
     // null handling
-    ["default(dyn, dyn)", own((args) => (args[0] === null ? args[1] : args[0]))],
+    ["default(dyn, dyn)", own((ctx, a, b) => (a === null ? b : a))],
     [
         "coalesce(list<dyn>)",
-        own((args) => {
-            const found = list("coalesce", args[0]).find((held) => held !== null);
+        own((ctx, a) => {
+            const found = list("coalesce", a).find((held) => held !== null);
             return found === undefined ? null : found;
         }),
     ],
     // time
     ["now()", own(() => instantOfMillis("now", Date.now()))],
     ["nowIso()", own(() => isoTextIn(Date.now(), "UTC"))],
-    ["nowIso(string)", own((args) => isoTextIn(Date.now(), zoneArg("nowIso", args[0])))],
+    ["nowIso(string)", own((ctx, a) => isoTextIn(Date.now(), zoneArg("nowIso", a)))],
     ["today()", own(() => dateTextIn(Date.now(), "UTC"))],
-    ["today(string)", own((args) => dateTextIn(Date.now(), zoneArg("today", args[0])))],
+    ["today(string)", own((ctx, a) => dateTextIn(Date.now(), zoneArg("today", a)))],
     ["nowMillis()", own(() => BigInt(Date.now()))],
     ["nowSeconds()", own(() => BigInt(Math.floor(Date.now() / 1000)))],
-    ["dateIn(google.protobuf.Timestamp)", own((args) => dateIn(args, undefined))],
-    ["dateIn(google.protobuf.Timestamp, string)", own((args) => dateIn(args, args[1]))],
-    ["isoIn(google.protobuf.Timestamp)", own((args) => isoIn(args, undefined))],
-    ["isoIn(google.protobuf.Timestamp, string)", own((args) => isoIn(args, args[1]))],
-    ["startOfMonth(google.protobuf.Timestamp)", own((args) => startOfMonth(args, undefined))],
-    ["startOfMonth(google.protobuf.Timestamp, string)", own((args) => startOfMonth(args, args[1]))],
-    ["addMonths(google.protobuf.Timestamp, int)", own((args) => addMonths(args, undefined))],
-    ["addMonths(google.protobuf.Timestamp, int, string)", own((args) => addMonths(args, args[2]))],
+    ["dateIn(google.protobuf.Timestamp)", own((ctx, a) => dateIn(a, undefined))],
+    ["dateIn(google.protobuf.Timestamp, string)", own((ctx, a, b) => dateIn(a, b))],
+    ["isoIn(google.protobuf.Timestamp)", own((ctx, a) => isoIn(a, undefined))],
+    ["isoIn(google.protobuf.Timestamp, string)", own((ctx, a, b) => isoIn(a, b))],
+    ["startOfMonth(google.protobuf.Timestamp)", own((ctx, a) => startOfMonth(a, undefined))],
+    ["startOfMonth(google.protobuf.Timestamp, string)", own((ctx, a, b) => startOfMonth(a, b))],
+    ["addMonths(google.protobuf.Timestamp, int)", own((ctx, a, b) => addMonths(a, b, undefined))],
+    ["addMonths(google.protobuf.Timestamp, int, string)", own((ctx, a, b, c) => addMonths(a, b, c))],
     // formatting
-    ["format(double, string)", own((args) => formatter("format", args[1])(formattable("format", args[0])))],
-    ["format(int, string)", own((args) => formatter("format", args[1])(formattable("format", args[0])))],
-    ["fixed(double, int)", own((args) => fixedText(args))],
-    ["fixed(int, int)", own((args) => fixedText(args))],
-    ["formatDuration(double, int)", own((args) => durationText(args[0], args[1]))],
-    ["formatDuration(int, int)", own((args) => durationText(args[0], args[1]))],
+    ["format(double, string)", own((ctx, a, b) => formatter("format", b)(formattable("format", a)))],
+    ["format(int, string)", own((ctx, a, b) => formatter("format", b)(formattable("format", a)))],
+    ["fixed(double, int)", own((ctx, a, b) => fixedText(a, b))],
+    ["fixed(int, int)", own((ctx, a, b) => fixedText(a, b))],
+    ["formatDuration(double, int)", own((ctx, a, b) => durationText(a, b))],
+    ["formatDuration(int, int)", own((ctx, a, b) => durationText(a, b))],
     // uuid
     ["uuidv1()", own(() => v1())],
     ["uuidv4()", own(() => v4())],
     ["uuidv6()", own(() => v6())],
     ["uuidv7()", own(() => v7())],
-    ["uuidv3(string, string)", own((args) => v3(text(args[0]), text(args[1])))],
-    ["uuidv5(string, string)", own((args) => v5(text(args[0]), text(args[1])))],
-    ["uuidValidate(string)", own((args) => uuidValidate(text(args[0])))],
-    ["uuidVersion(string)", own((args) => BigInt(uuidVersion(text(args[0]))))],
+    ["uuidv3(string, string)", own((ctx, a, b) => v3(text(a), text(b)))],
+    ["uuidv5(string, string)", own((ctx, a, b) => v5(text(a), text(b)))],
+    ["uuidValidate(string)", own((ctx, a) => uuidValidate(text(a)))],
+    ["uuidVersion(string)", own((ctx, a) => BigInt(uuidVersion(text(a))))],
 ]);
 /**
  * The half-open range of a string, bytes or a list. Indices arrive as CEL ints (`bigint`),
  * which neither `String.slice` nor `TypedArray.subarray` accepts. `subarray` rather than
  * `slice` for bytes: a view costs no copy, and every consumer treats the result as read-only.
  */
-function sliced(args) {
-    const from = Number(args[1]);
-    const to = Number(args[2]);
-    const value = args[0];
+function sliced(value, start, end) {
+    const from = Number(start);
+    const to = Number(end);
     if (typeof value === "string")
         return value.slice(from, to);
     if (isCelBytes(value))
@@ -643,44 +644,44 @@ function sliced(args) {
         return value.slice(from, to);
     throw new CatalogRefusal(`slice: expected a string, bytes or a list, got ${celTypeNameOf(value) ?? "no CEL value"}`);
 }
-function roundedTo(args) {
-    return Number(formattable("round", args[0]).toFixed(digitCount("round", args[1])));
+function roundedTo(value, digits) {
+    return Number(formattable("round", value).toFixed(digitCount("round", digits)));
 }
-function fixedText(args) {
-    return formatter("fixed", `.${digitCount("fixed", args[1])}f`)(formattable("fixed", args[0]));
+function fixedText(value, digits) {
+    return formatter("fixed", `.${digitCount("fixed", digits)}f`)(formattable("fixed", value));
 }
-function firstMatch(what, args, flags) {
-    const matcher = pattern(what, args[1], flags).matcher(text(args[0]));
+function firstMatch(what, subject, source, flags) {
+    const matcher = pattern(what, source, flags).matcher(text(subject));
     return matcher.find() ? (matcher.group() ?? "") : "";
 }
-function everyMatch(what, args, flags) {
-    const matcher = pattern(what, args[1], flags).matcher(text(args[0]));
+function everyMatch(what, subject, source, flags) {
+    const matcher = pattern(what, source, flags).matcher(text(subject));
     const out = [];
     while (matcher.find())
         out.push(matcher.group() ?? "");
     return out;
 }
-function matchGroups(what, args, flags) {
-    const matcher = pattern(what, args[1], flags).matcher(text(args[0]));
+function matchGroups(what, subject, source, flags) {
+    const matcher = pattern(what, source, flags).matcher(text(subject));
     if (!matcher.find())
         return [];
     return Array.from({ length: matcher.groupCount() }, (_unused, at) => matcher.group(at + 1) ?? "");
 }
-function dateIn(args, zone) {
-    return dateTextIn(millisOf(instantArg("dateIn", args[0])), zoneArg("dateIn", zone));
+function dateIn(instant, zone) {
+    return dateTextIn(millisOf(instantArg("dateIn", instant)), zoneArg("dateIn", zone));
 }
-function isoIn(args, zone) {
-    return isoTextIn(millisOf(instantArg("isoIn", args[0])), zoneArg("isoIn", zone));
+function isoIn(instant, zone) {
+    return isoTextIn(millisOf(instantArg("isoIn", instant)), zoneArg("isoIn", zone));
 }
-function startOfMonth(args, zone) {
+function startOfMonth(instant, zone) {
     const named = zoneArg("startOfMonth", zone);
-    const fields = civilTimeIn(millisOf(instantArg("startOfMonth", args[0])), named);
+    const fields = civilTimeIn(millisOf(instantArg("startOfMonth", instant)), named);
     return instantOfMillis("startOfMonth", instantOfCivilTime({ ...fields, day: 1, hour: 0, minute: 0, second: 0 }, named));
 }
-function addMonths(args, zone) {
+function addMonths(instant, months, zone) {
     const named = zoneArg("addMonths", zone);
-    const fields = civilTimeIn(millisOf(instantArg("addMonths", args[0])), named);
-    const shifted = fields.year * 12 + (fields.month - 1) + Number(args[1]);
+    const fields = civilTimeIn(millisOf(instantArg("addMonths", instant)), named);
+    const shifted = fields.year * 12 + (fields.month - 1) + Number(months);
     // `%` takes the dividend's sign in JS, so a negative total would yield month 0.
     const year = Math.floor(shifted / 12);
     const month = (((shifted % 12) + 12) % 12) + 1;

package/dist/cel-map-value.d.ts

@@ -1,8 +1,8 @@
 /**
  * Building a CEL map, and the one identity a key has.
  *
- * A map's entries live in a `Map` keyed by the **canonical text** of each key, never by
- * a property name. Two consequences, both load-bearing:
+ * A map's entries live in a `Map` keyed by each key's **own typed value**, never by a
+ * property name. Three consequences, all load-bearing:
  *
  * - A map holds CEL's four key types (int, uint, bool, string) in one container, and an
  *   int key and a uint key of the same number are **one** key, because CEL equality
@@ -10,25 +10,38 @@
  * - Nothing a key spells can reach a prototype, a method or an inherited member. A map
  *   built from `{'__proto__': 1}` holds `__proto__` as data and reads it back as data;
  *   dropping such a key would be swallowing what the author wrote.
+ * - The types separate themselves. A `Map` compares its keys by type as well as value, so
+ *   a string `"1"` and an int `1` are distinct keys with nothing prefixed to say so — and a
+ *   second engine keys an entry by its own discriminant rather than reproducing this one's
+ *   text byte for byte.
  */
-import type { CelMap, CelMapValueEntry, CelValue } from "./cel-value.js";
+import type { CelMap, CelMapKey, CelMapValueEntry, CelValue } from "./cel-value.js";
 import { type CelError } from "./cel-value.js";
 import type { SourceRange } from "./syntax-tree.js";
 /**
- * The text that identifies a key. `n` covers the numeric types together: CEL equality
+ * What identifies a key. The `bigint` covers the numeric types together: CEL equality
  * makes `1`, `1u` and `1.0` one key, so a map carrying two of them is not a map and a
  * lookup by any of the three finds the entry — which is what
  * `{1u: 1.0, 2: 2.0, 3u: 3.0}[?3.0]` reads. A double that is not whole identifies
  * nothing, since no entry can hold it.
+ *
+ * A string and a bool identify themselves, and nothing is prefixed to keep the types
+ * apart: a `Map` key of one type never equals a key of another, so `"1"` and `1` are
+ * distinct keys and `"true"` is not `true`.
  */
-export declare function mapKeyIdentity(key: CelValue): string | undefined;
+export declare function mapKeyIdentity(key: CelValue): CelMapKey | undefined;
 /** An empty map, for a literal with no entries. */
-export declare function celMapOf(entries: ReadonlyMap<string, CelMapValueEntry>): CelMap;
+export declare function celMapOf(entries: ReadonlyMap<CelMapKey, CelMapValueEntry>): CelMap;
 /**
  * A map from its entries in written order, or the error that stops it: a key of a type
  * no map is keyed by, or two keys CEL equality makes one.
+ *
+ * The entries arrive **flat** — key, value, key, value — because a literal of n entries
+ * then costs one allocation rather than one per entry, and both backends write the same
+ * call. A duplicate is caught by the size not moving, which is the one hash lookup the
+ * insert already performs.
  */
-export declare function celMapFromEntries(pairs: readonly (readonly [CelValue, CelValue])[], range?: SourceRange): CelMap | CelError;
+export declare function celMapFromEntries(flat: readonly CelValue[], range?: SourceRange): CelMap | CelError;
 /** Every key of a map, in insertion order — what a comprehension ranges over. */
 export declare function celMapKeys(map: CelMap): CelValue[];
 //# sourceMappingURL=cel-map-value.d.ts.map

package/dist/cel-map-value.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cel-map-value.d.ts","sourceRoot":"","sources":["../src/cel-map-value.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAOhE;AAED,mDAAmD;AACnD,wBAAgB,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAAG,MAAM,CAE/E;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,SAAS,CAAC,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAE,EACjD,KAAK,CAAC,EAAE,WAAW,GAClB,MAAM,GAAG,QAAQ,CAsBnB;AAQD,iFAAiF;AACjF,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,EAAE,CAElD"}
+{"version":3,"file":"cel-map-value.d.ts","sourceRoot":"","sources":["../src/cel-map-value.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACpF,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,QAAQ,GAAG,SAAS,GAAG,SAAS,CAKnE;AAED,mDAAmD;AACnD,wBAAgB,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,SAAS,EAAE,gBAAgB,CAAC,GAAG,MAAM,CAElF;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,QAAQ,EAAE,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,MAAM,GAAG,QAAQ,CAyBnG;AAQD,iFAAiF;AACjF,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,EAAE,CAElD"}

package/dist/cel-map-value.js

@@ -1,8 +1,8 @@
 /**
  * Building a CEL map, and the one identity a key has.
  *
- * A map's entries live in a `Map` keyed by the **canonical text** of each key, never by
- * a property name. Two consequences, both load-bearing:
+ * A map's entries live in a `Map` keyed by each key's **own typed value**, never by a
+ * property name. Three consequences, all load-bearing:
  *
  * - A map holds CEL's four key types (int, uint, bool, string) in one container, and an
  *   int key and a uint key of the same number are **one** key, because CEL equality
@@ -10,27 +10,30 @@
  * - Nothing a key spells can reach a prototype, a method or an inherited member. A map
  *   built from `{'__proto__': 1}` holds `__proto__` as data and reads it back as data;
  *   dropping such a key would be swallowing what the author wrote.
+ * - The types separate themselves. A `Map` compares its keys by type as well as value, so
+ *   a string `"1"` and an int `1` are distinct keys with nothing prefixed to say so — and a
+ *   second engine keys an entry by its own discriminant rather than reproducing this one's
+ *   text byte for byte.
  */
 import { CEL_VALUE_TYPE, celError, isCelError, isCelUint, } from "./cel-value.js";
 /**
- * The text that identifies a key. `n` covers the numeric types together: CEL equality
+ * What identifies a key. The `bigint` covers the numeric types together: CEL equality
  * makes `1`, `1u` and `1.0` one key, so a map carrying two of them is not a map and a
  * lookup by any of the three finds the entry — which is what
  * `{1u: 1.0, 2: 2.0, 3u: 3.0}[?3.0]` reads. A double that is not whole identifies
  * nothing, since no entry can hold it.
+ *
+ * A string and a bool identify themselves, and nothing is prefixed to keep the types
+ * apart: a `Map` key of one type never equals a key of another, so `"1"` and `1` are
+ * distinct keys and `"true"` is not `true`.
  */
 export function mapKeyIdentity(key) {
-    if (typeof key === "string")
-        return `s${key}`;
-    if (typeof key === "boolean")
-        return `b${key}`;
-    if (typeof key === "bigint")
-        return `n${key}`;
-    if (isCelUint(key))
-        return `n${key.value}`;
-    if (typeof key === "number" && Number.isInteger(key))
-        return `n${BigInt(key)}`;
-    return undefined;
+    const held = typeof key;
+    if (held === "string" || held === "boolean" || held === "bigint")
+        return key;
+    if (held === "number")
+        return Number.isInteger(key) ? BigInt(key) : undefined;
+    return isCelUint(key) ? key.value : undefined;
 }
 /** An empty map, for a literal with no entries. */
 export function celMapOf(entries) {
@@ -39,10 +42,17 @@ export function celMapOf(entries) {
 /**
  * A map from its entries in written order, or the error that stops it: a key of a type
  * no map is keyed by, or two keys CEL equality makes one.
+ *
+ * The entries arrive **flat** — key, value, key, value — because a literal of n entries
+ * then costs one allocation rather than one per entry, and both backends write the same
+ * call. A duplicate is caught by the size not moving, which is the one hash lookup the
+ * insert already performs.
  */
-export function celMapFromEntries(pairs, range) {
+export function celMapFromEntries(flat, range) {
     const entries = new Map();
-    for (const [key, value] of pairs) {
+    for (let at = 0; at < flat.length; at += 2) {
+        const key = flat[at];
+        const value = flat[at + 1];
         if (isCelError(key))
             return key;
         if (isCelError(value))
@@ -54,10 +64,11 @@ export function celMapFromEntries(pairs, range) {
         if (identity === undefined) {
             return celError("unsupported_key_type", "a map is keyed by an int, a uint, a bool or a string", range);
         }
-        if (entries.has(identity)) {
+        const before = entries.size;
+        entries.set(identity, { key, value });
+        if (entries.size === before) {
             return celError("duplicate_map_key", `the key ${describeKey(key)} is written twice`, range);
         }
-        entries.set(identity, { key, value });
     }
     return celMapOf(entries);
 }

package/dist/cel-value.d.ts

@@ -62,12 +62,19 @@ export interface CelMapValueEntry {
     readonly value: CelValue;
 }
 /**
- * A map. Entries live in a `Map` keyed by the canonical text of each key, so the map
- * holds int, uint, bool and string keys alike and **no key is ever a property name**:
+ * What identifies a key inside a map's entries. A `Map` distinguishes its own keys **by
+ * type**, so the four CEL key types collapse onto three JS ones with no namespace to
+ * separate by hand: a string key is itself, a bool is itself, and an int, a uint and a
+ * whole double are all the `bigint` CEL equality makes them.
+ */
+export type CelMapKey = string | bigint | boolean;
+/**
+ * A map. Entries live in a `Map` keyed by each key's own `CelMapKey`, so the map holds
+ * int, uint, bool and string keys alike and **no key is ever a property name**:
  * `__proto__`, `constructor` and `prototype` are data here, as they are in any map.
  */
 export interface CelMap extends Branded<"map"> {
-    readonly entries: ReadonlyMap<string, CelMapValueEntry>;
+    readonly entries: ReadonlyMap<CelMapKey, CelMapValueEntry>;
 }
 /** Every evaluation failure this engine names. A code is never derived from a message. */
 export declare const CEL_EVALUATION_CODES: readonly ["no_such_key", "no_such_variable", "index_out_of_range", "no_matching_overload", "unsupported_container", "unsupported_key_type", "duplicate_map_key", "numeric_overflow", "division_by_zero", "modulo_by_zero", "invalid_conversion", "invalid_argument", "invalid_regular_expression", "optional_value_missing", "unbound_function", "async_value_unsupported"];

package/dist/cel-value.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cel-value.d.ts","sourceRoot":"","sources":["../src/cel-value.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEhE,eAAO,MAAM,cAAc,EAAE,OAAO,MAAqC,CAAC;AAE1E,gFAAgF;AAChF,eAAO,MAAM,cAAc,gHAQjB,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAE1D,UAAU,OAAO,CAAC,GAAG,SAAS,MAAM;IAClC,QAAQ,CAAC,CAAC,cAAc,CAAC,EAAE,GAAG,CAAC;CAChC;AAED,2EAA2E;AAC3E,MAAM,WAAW,OAAQ,SAAQ,OAAO,CAAC,MAAM,CAAC;IAC9C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAa,SAAQ,OAAO,CAAC,2BAA2B,CAAC;IACxE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,6EAA6E;AAC7E,MAAM,WAAW,WAAY,SAAQ,OAAO,CAAC,0BAA0B,CAAC;IACtE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,yEAAyE;AACzE,MAAM,WAAW,YAAa,SAAQ,OAAO,CAAC,MAAM,CAAC;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,8CAA8C;AAC9C,MAAM,WAAW,WAAY,SAAQ,OAAO,CAAC,UAAU,CAAC;IACtD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC;CAC1B;AAED,uFAAuF;AACvF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;CAC1B;AAED;;;;GAIG;AACH,MAAM,WAAW,MAAO,SAAQ,OAAO,CAAC,KAAK,CAAC;IAC5C,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;CACzD;AAED,0FAA0F;AAC1F,eAAO,MAAM,oBAAoB,6WA+BvB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEtE;;;;;;GAMG;AACH,MAAM,WAAW,QAAS,SAAQ,OAAO,CAAC,OAAO,CAAC;IAChD,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;CAC9B;AAED,sFAAsF;AACtF,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CACnC;AAED,kEAAkE;AAClE,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAC;CAClC;AAED,MAAM,MAAM,QAAQ,GAChB,IAAI,GACJ,OAAO,GACP,MAAM,GACN,MAAM,GACN,MAAM,GACN,UAAU,GACV,SAAS,QAAQ,EAAE,GACnB,OAAO,GACP,YAAY,GACZ,WAAW,GACX,YAAY,GACZ,WAAW,GACX,MAAM,GACN,QAAQ,GACR,YAAY,GACZ,SAAS,CAAC;AAId,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE9C;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAEvD;AAID,wBAAgB,OAAO,IAAI,WAAW,CAErC;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,WAAW,CAEnD;AAED,wBAAgB,QAAQ,CACtB,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,WAAW,GAClB,QAAQ,CAEV;AAUD,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAElE;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAE1D;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAEpE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAElE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAEpE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAM9D;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAK9D;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAwBhE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAMlD;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,QAAQ,GAAG,SAAS,CAO3F;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,UAAU,GAAG,QAAQ,CAiB1D"}
+{"version":3,"file":"cel-value.d.ts","sourceRoot":"","sources":["../src/cel-value.ts"],"names":[],"mappings":"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"}

package/dist/check-diagnostic.d.ts

@@ -36,9 +36,10 @@ export interface CelCheckDiagnostic {
  * refusal to compile a tree the front end already reported a syntax diagnostic for,
  * which is a question the caller should have asked before compiling, and
  * `emitted_module_rejected` is the refusal to run a loaded module whose integrity header
- * is not the one the emission asked for.
+ * is not the one the emission asked for, and `signature_too_wide` is a registration
+ * declaring more values than an implementation receives.
  */
-export type CelEngineErrorCode = "namespaces_mismatch" | "unreadable_expression" | "emitted_module_rejected";
+export type CelEngineErrorCode = "namespaces_mismatch" | "unreadable_expression" | "emitted_module_rejected" | "signature_too_wide";
 export declare class CelEngineError extends Error {
     readonly code: CelEngineErrorCode;
     constructor(code: CelEngineErrorCode, message: string);

package/dist/check-diagnostic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-diagnostic.d.ts","sourceRoot":"","sources":["../src/check-diagnostic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;GAIG;AACH,eAAO,MAAM,eAAe,4SAyBlB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5D,MAAM,WAAW,gBAAgB;IAC/B,uCAAuC;IACvC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,GAAG,CAAC,EAAE,gBAAgB,CAAC;CACjC;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,kBAAkB,GAC1B,qBAAqB,GACrB,uBAAuB,GACvB,yBAAyB,CAAC;AAE9B,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;gBAEtB,IAAI,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM;CAKtD;AAED,mFAAmF;AACnF,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA4B;IAEjD,GAAG,CAAC,UAAU,EAAE,kBAAkB,GAAG,IAAI;IAIzC,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,IAAI,SAAS,kBAAkB,EAAE;CAGtC"}
+{"version":3,"file":"check-diagnostic.d.ts","sourceRoot":"","sources":["../src/check-diagnostic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;GAIG;AACH,eAAO,MAAM,eAAe,4SAyBlB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5D,MAAM,WAAW,gBAAgB;IAC/B,uCAAuC;IACvC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,GAAG,CAAC,EAAE,gBAAgB,CAAC;CACjC;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GAC1B,qBAAqB,GACrB,uBAAuB,GACvB,yBAAyB,GACzB,oBAAoB,CAAC;AAEzB,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;gBAEtB,IAAI,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM;CAKtD;AAED,mFAAmF;AACnF,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA4B;IAEjD,GAAG,CAAC,UAAU,EAAE,kBAAkB,GAAG,IAAI;IAIzC,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,IAAI,SAAS,kBAAkB,EAAE;CAGtC"}

package/dist/checker.d.ts

@@ -38,6 +38,15 @@ export interface NamespaceFunction {
     readonly parameters?: readonly CelType[];
     /** How the declaration is written, for a listing; absent with the parameters. */
     readonly signature?: string;
+    /**
+     * Types the declaration named that nothing is registered under, in the order written.
+     *
+     * The declaration is accepted and reads `dyn` where one stands: a host's declaration is
+     * data out of someone's manifest, so a name its own registry does not carry is the host
+     * disagreeing with itself — reported at the call, where there is a range, rather than
+     * thrown at registration, where there is none. Same rule as an unjudged schema node.
+     */
+    readonly unregisteredTypes?: readonly string[];
     readonly deterministic?: boolean;
     readonly hostBacked?: boolean;
     readonly throws?: readonly string[];

package/dist/checker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checker.d.ts","sourceRoot":"","sources":["../src/checker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,OAAO,EAAc,MAAM,eAAe,CAAC;AAyBzD,OAAO,KAAK,EAAgB,kBAAkB,EAAoB,MAAM,uBAAuB,CAAC;AAGhG,OAAO,KAAK,EAAE,gBAAgB,EAAyC,MAAM,wBAAwB,CAAC;AAKtG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAYvD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,4FAA4F;IAC5F,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IACzC,iFAAiF;IACjF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,uBAAuB,EAAE,OAAO,CAAC;IAC1C,QAAQ,CAAC,4BAA4B,EAAE,OAAO,CAAC;IAC/C,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;CACvC;AAED,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS,CAAC;IACzD,QAAQ,CAAC,qBAAqB,EAAE,MAAM,SAAS,MAAM,EAAE,CAAC;IACxD,QAAQ,CAAC,iBAAiB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,iBAAiB,GAAG,SAAS,CAAC;IAC/F;;;;;;;OAOG;IACH,QAAQ,CAAC,eAAe,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;IACzD,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;CAClC;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,gCAAgC;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACpD,QAAQ,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,CAAC;CACzC;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,GAAG,WAAW,CAG/F"}
+{"version":3,"file":"checker.d.ts","sourceRoot":"","sources":["../src/checker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,OAAO,EAAc,MAAM,eAAe,CAAC;AAyBzD,OAAO,KAAK,EAAgB,kBAAkB,EAAoB,MAAM,uBAAuB,CAAC;AAGhG,OAAO,KAAK,EAAE,gBAAgB,EAAyC,MAAM,wBAAwB,CAAC;AAKtG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAYvD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,4FAA4F;IAC5F,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IACzC,iFAAiF;IACjF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;;;OAOG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/C,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,uBAAuB,EAAE,OAAO,CAAC;IAC1C,QAAQ,CAAC,4BAA4B,EAAE,OAAO,CAAC;IAC/C,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;CACvC;AAED,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS,CAAC;IACzD,QAAQ,CAAC,qBAAqB,EAAE,MAAM,SAAS,MAAM,EAAE,CAAC;IACxD,QAAQ,CAAC,iBAAiB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,iBAAiB,GAAG,SAAS,CAAC;IAC/F;;;;;;;OAOG;IACH,QAAQ,CAAC,eAAe,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;IACzD,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;CAClC;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,gCAAgC;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACpD,QAAQ,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,CAAC;CACzC;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,GAAG,WAAW,CAG/F"}