@telorun/cel 0.0.0-stage → 0.108.0

package/dist/json-text-scan.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Where a text stops being a prefix of any RFC 8259 JSON text.
+ *
+ * It is the offset `parseJson`'s refusal names, and it is computed here so the wording
+ * is the catalog's own and never the host JSON parser's: the host's verdict decides
+ * WHETHER a text is JSON, and this scan decides only how the refusal reads. A text the
+ * host refused and this scan reads as JSON is a defect here, raised as one with the
+ * host's error as its cause (`catalog-runtime.ts`).
+ *
+ * Its agreement with RFC 8259 is a property of the scan, never asserted at runtime. What
+ * holds it here is the catalog's own conformance rows, which pin the offset of thirteen
+ * refusals — a mid-text one, an end-of-input one, a bad escape, a leading zero, a byte-order
+ * mark and a raw control character among them. What those rows cannot reach is a text no row
+ * writes: the scan's agreement over arbitrary input was measured by differential fuzzing
+ * against the host parser where it was first written, and that measurement travels with the
+ * suite that made it rather than with this copy.
+ */
+export interface JsonRefusal {
+    /** UTF-16 offset of the first offending code unit; the text's length when
+     *  every prefix is viable and the text is merely incomplete. */
+    readonly offset: number;
+    readonly endOfInput: boolean;
+}
+/** The refusal of `text`, or `undefined` when it is a JSON text. Iterative, so
+ *  nesting depth is bounded by memory rather than by the call stack. Neither
+ *  stricter nor laxer than RFC 8259. */
+export declare function scanJsonPrefix(text: string): JsonRefusal | undefined;
+//# sourceMappingURL=json-text-scan.d.ts.map

package/dist/json-text-scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-text-scan.d.ts","sourceRoot":"","sources":["../src/json-text-scan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,WAAW;IAC1B;oEACgE;IAChE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B;AAYD;;wCAEwC;AACxC,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CA6HpE"}

package/dist/json-text-scan.js

@@ -0,0 +1,159 @@
+const QUOTE = 0x22;
+const BACKSLASH = 0x5c;
+const SIMPLE_ESCAPES = '"\\/bfnrt';
+const isWhitespace = (c) => c === " " || c === "\t" || c === "\n" || c === "\r";
+const isDigit = (c) => c !== undefined && c >= "0" && c <= "9";
+const isHexDigit = (c) => isDigit(c) || (c >= "a" && c <= "f") || (c >= "A" && c <= "F");
+/** The refusal of `text`, or `undefined` when it is a JSON text. Iterative, so
+ *  nesting depth is bounded by memory rather than by the call stack. Neither
+ *  stricter nor laxer than RFC 8259. */
+export function scanJsonPrefix(text) {
+    const length = text.length;
+    let at = 0;
+    // Each token reader returns the offset it refuses, or `undefined` once `at`
+    // is past the token.
+    const readString = () => {
+        at++;
+        for (;;) {
+            if (at >= length)
+                return length;
+            const code = text.charCodeAt(at);
+            if (code === QUOTE) {
+                at++;
+                return undefined;
+            }
+            if (code < 0x20)
+                return at;
+            at++;
+            if (code !== BACKSLASH)
+                continue;
+            if (at >= length)
+                return length;
+            const escape = text[at];
+            if (escape === "u") {
+                at++;
+                for (let digit = 0; digit < 4; digit++, at++) {
+                    if (at >= length)
+                        return length;
+                    if (!isHexDigit(text[at]))
+                        return at;
+                }
+            }
+            else if (SIMPLE_ESCAPES.includes(escape))
+                at++;
+            else
+                return at;
+        }
+    };
+    const readDigits = () => {
+        if (!isDigit(text[at]))
+            return at;
+        while (isDigit(text[at]))
+            at++;
+        return undefined;
+    };
+    const readNumber = () => {
+        if (text[at] === "-")
+            at++;
+        if (text[at] === "0")
+            at++;
+        else {
+            const refused = readDigits();
+            if (refused !== undefined)
+                return refused;
+        }
+        if (text[at] === ".") {
+            at++;
+            const refused = readDigits();
+            if (refused !== undefined)
+                return refused;
+        }
+        if (text[at] === "e" || text[at] === "E") {
+            at++;
+            if (text[at] === "+" || text[at] === "-")
+                at++;
+            return readDigits();
+        }
+        return undefined;
+    };
+    const readLiteral = (literal) => {
+        for (const expected of literal) {
+            if (text[at] !== expected)
+                return at;
+            at++;
+        }
+        return undefined;
+    };
+    const refusedAt = (offset) => ({ offset, endOfInput: offset >= length });
+    const open = [];
+    let state = "value";
+    for (;;) {
+        while (isWhitespace(text[at]))
+            at++;
+        const c = text[at];
+        if (state === "after") {
+            const container = open[open.length - 1];
+            if (container === undefined)
+                return at === length ? undefined : refusedAt(at);
+            if (c === ",") {
+                at++;
+                state = container === "{" ? "key" : "value";
+            }
+            else if (c === (container === "{" ? "}" : "]")) {
+                at++;
+                open.pop();
+            }
+            else
+                return refusedAt(at);
+            continue;
+        }
+        if (state === "key" || state === "keyOrClose") {
+            if (state === "keyOrClose" && c === "}") {
+                at++;
+                open.pop();
+                state = "after";
+                continue;
+            }
+            if (c !== '"')
+                return refusedAt(at);
+            const refused = readString();
+            if (refused !== undefined)
+                return refusedAt(refused);
+            while (isWhitespace(text[at]))
+                at++;
+            if (text[at] !== ":")
+                return refusedAt(at);
+            at++;
+            state = "value";
+            continue;
+        }
+        if (state === "valueOrClose" && c === "]") {
+            at++;
+            open.pop();
+            state = "after";
+            continue;
+        }
+        if (c === "{" || c === "[") {
+            at++;
+            open.push(c);
+            state = c === "{" ? "keyOrClose" : "valueOrClose";
+            continue;
+        }
+        let refused;
+        if (c === '"')
+            refused = readString();
+        else if (c === "-" || isDigit(c))
+            refused = readNumber();
+        else if (c === "t")
+            refused = readLiteral("true");
+        else if (c === "f")
+            refused = readLiteral("false");
+        else if (c === "n")
+            refused = readLiteral("null");
+        else
+            refused = at;
+        if (refused !== undefined)
+            return refusedAt(refused);
+        state = "after";
+    }
+}

package/dist/lexer.d.ts

@@ -0,0 +1,103 @@
+/**
+ * CEL's tokens.
+ *
+ * The lexer decodes literals as it reads them — a string token carries its text
+ * with every escape resolved, a bytes token its bytes, an integer its magnitude as
+ * a `bigint` — so nothing downstream re-reads source text to learn a value.
+ *
+ * It stops at the first thing it cannot read, reporting one diagnostic and ending
+ * the token stream there. The parser then builds whatever the tokens before it
+ * support, which is what leaves a half-typed expression usable.
+ *
+ * Three readings are deliberate, each pinned by the conformance vectors:
+ *
+ * - **Only a single-letter prefix** introduces a string: `r`, `R`, `b`, `B`. `br'x'`
+ *   is the identifier `br` followed by a string, which no expression admits.
+ * - **A raw string still lets a backslash take the next character with it**, keeping
+ *   both as written, so `r'\''` is a backslash and a quote rather than an unclosed
+ *   string.
+ * - **A bytes literal holds the UTF-8 of its text.** `b'ÿ'` is `0xC3 0xBF`, two bytes,
+ *   and an escape (`\xff`, `\303`) is the one byte it names. cel-spec's own answer, and
+ *   the only reading under which `b'ÿ' == b'\303\277'` — a row — holds.
+ *
+ * A number never begins with `.`: `.5` is a dot and a number, and no expression
+ * admits that either.
+ */
+import { FirstSyntaxDiagnostic } from "./syntax-diagnostic.js";
+export declare const MAX_INT = 9223372036854775807n;
+export declare const MIN_INT = -9223372036854775808n;
+export declare const MAX_UINT = 18446744073709551615n;
+export type TokenType = 
+/** A name, and a word read as a literal (`true`, `false`, `null`). */
+"ident"
+/** A member name written between backticks, whatever it spells. */
+ | "quotedIdent"
+/** A reserved word with no other reading: refused wherever a name is read. */
+ | "reserved"
+/** An operator written as a word (`in`). */
+ | "keyword" | "int" | "uint" | "double" | "string" | "bytes" | "punct" | "eof";
+export interface Token {
+    readonly type: TokenType;
+    readonly start: number;
+    readonly end: number;
+    /** The lexeme, for `punct`; the name, for `ident` and `reserved`. */
+    readonly text: string;
+    readonly int?: bigint;
+    readonly double?: number;
+    readonly string?: string;
+    readonly bytes?: Uint8Array;
+    /**
+     * An integer magnitude of exactly 2^63 — legal only directly under a unary
+     * minus, which is how the int64 minimum is written.
+     */
+    readonly atIntBoundary?: boolean;
+}
+export declare class Lexer {
+    private readonly source;
+    private readonly diagnostics;
+    private at;
+    constructor(source: string, diagnostics: FirstSyntaxDiagnostic);
+    /** Every token up to the end of the source, or up to the first unreadable text. */
+    tokenize(): Token[];
+    private eof;
+    private skipIgnored;
+    private next;
+    private readPunctuation;
+    /**
+     * A member name between backticks. cel-spec's `ESCAPED_IDENTIFIER` takes no escapes
+     * and cannot hold a backtick, so the text between them is the name as written.
+     */
+    private readQuotedIdentifier;
+    /** An identifier, a literal word, or the prefix of a string literal. */
+    private readWord;
+    private readNumber;
+    private invalidNumber;
+    /**
+     * A string or bytes literal. `start` is the literal's own start (its prefix, when
+     * it has one) and `quoteAt` the opening quote.
+     */
+    private readQuoted;
+    private unterminated;
+    /** A raw literal: a backslash takes the next character with it, both kept as written. */
+    private scanRaw;
+    /**
+     * One character of a literal's text, as the literal holds it: a code unit in a string,
+     * the character's UTF-8 bytes in a bytes literal. Answers how many code units it read,
+     * since a character outside the basic plane is written as a surrogate pair.
+     */
+    private literalCharacter;
+    private scanEscaped;
+    /** Decodes one escape sequence onto `units`, answering where it ends. */
+    private readEscape;
+    private readHexEscape;
+    private readOctalEscape;
+    private readUnicodeEscape;
+    /** A leading surrogate stands only beside the trailing one that completes it. */
+    private readSurrogatePair;
+}
+/** Every token of the source, with at most one diagnostic for where it stopped. */
+export declare function tokenize(source: string): {
+    tokens: Token[];
+    diagnostics: FirstSyntaxDiagnostic;
+};
+//# sourceMappingURL=lexer.d.ts.map

package/dist/lexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexer.d.ts","sourceRoot":"","sources":["../src/lexer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,eAAO,MAAM,OAAO,uBAAuB,CAAC;AAC5C,eAAO,MAAM,OAAO,wBAAwB,CAAC;AAC7C,eAAO,MAAM,QAAQ,wBAAwB,CAAC;AAE9C,MAAM,MAAM,SAAS;AACnB,sEAAsE;AACpE,OAAO;AACT,mEAAmE;GACjE,aAAa;AACf,8EAA8E;GAC5E,UAAU;AACZ,4CAA4C;GAC1C,SAAS,GACT,KAAK,GACL,MAAM,GACN,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,OAAO,GACP,KAAK,CAAC;AAEV,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,qEAAqE;IACrE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;CAClC;AAgED,qBAAa,KAAK;IAId,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAJ9B,OAAO,CAAC,EAAE,CAAK;gBAGI,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,qBAAqB;IAGrD,mFAAmF;IACnF,QAAQ,IAAI,KAAK,EAAE;IAiBnB,OAAO,CAAC,GAAG;IAIX,OAAO,CAAC,WAAW;IAenB,OAAO,CAAC,IAAI;IAYZ,OAAO,CAAC,eAAe;IAoBvB;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAe5B,wEAAwE;IACxE,OAAO,CAAC,QAAQ;IAchB,OAAO,CAAC,UAAU;IA0ElB,OAAO,CAAC,aAAa;IAYrB;;;OAGG;IACH,OAAO,CAAC,UAAU;IAgBlB,OAAO,CAAC,YAAY;IAKpB,yFAAyF;IACzF,OAAO,CAAC,OAAO;IAuBf;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAUxB,OAAO,CAAC,WAAW;IAwBnB,yEAAyE;IACzE,OAAO,CAAC,UAAU;IAmClB,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,iBAAiB;IA8BzB,iFAAiF;IACjF,OAAO,CAAC,iBAAiB;CAgB1B;AAkCD,mFAAmF;AACnF,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAAC,WAAW,EAAE,qBAAqB,CAAA;CAAE,CAIhG"}