@bpmnkit/feel 0.0.21 → 1.0.0

package/dist/lexer.js

@@ -36,6 +36,7 @@ const DOT = 0x2e;
 const GT = 0x3e;
 const LT = 0x3c;
 const BANG = 0x21;
+const PLUS = 0x2b;
 const MINUS = 0x2d;
 const EQ = 0x3d;
 const UNDERSCORE = 0x5f;
@@ -43,13 +44,32 @@ function isDigit(c) {
     return c >= 0x30 && c <= 0x39;
 }
 function isLetter(c) {
-    return (c >= 0x61 && c <= 0x7a) || (c >= 0x41 && c <= 0x5a);
+    if ((c >= 0x61 && c <= 0x7a) || (c >= 0x41 && c <= 0x5a))
+        return true;
+    // FEEL names are not limited to ASCII: anything above the ASCII range is
+    // a name character, which covers accented letters and emoji alike.
+    return c > 0x7f;
 }
 function isWhitespace(c) {
     return c === SPACE || c === TAB || c === LF || c === CR;
 }
 const SINGLE_OPS = new Set("+-*/=<>?".split("").map((c) => c.charCodeAt(0)));
 const PUNCT = new Set("()[]{},:".split("").map((c) => c.charCodeAt(0)));
+/** End of an exponent starting at `i` ("e4", "e+4", "e-4"), or `i` if none. */
+function readExponent(input, i) {
+    const c = input.charCodeAt(i);
+    if (c !== 0x65 && c !== 0x45)
+        return i;
+    let j = i + 1;
+    const sign = input.charCodeAt(j);
+    if (sign === PLUS || sign === MINUS)
+        j++;
+    if (!isDigit(input.charCodeAt(j)))
+        return i;
+    while (j < input.length && isDigit(input.charCodeAt(j)))
+        j++;
+    return j;
+}
 export function tokenize(input) {
     const tokens = [];
     let i = 0;
@@ -150,14 +170,15 @@ export function tokenize(input) {
             i++;
             continue;
         }
-        // Dot (not ..)
-        if (c === DOT) {
+        // Dot (not ".." and not the start of a number like ".872")
+        if (c === DOT && !isDigit(next)) {
             tokens.push({ kind: "punct", value: ".", start, end: i + 1 });
             i++;
             continue;
         }
-        // Number (only consume one decimal point, and only if followed by a digit)
-        if (isDigit(c)) {
+        // Number: digits, an optional fraction, an optional exponent. A leading
+        // "." is allowed (".872"), and ".." is never part of a number.
+        if (isDigit(c) || (c === DOT && isDigit(next))) {
             while (i < len && isDigit(input.charCodeAt(i)))
                 i++;
             // Consume decimal fraction only if next char is '.' followed by a digit (not '..')
@@ -166,6 +187,9 @@ export function tokenize(input) {
                 while (i < len && isDigit(input.charCodeAt(i)))
                     i++;
             }
+            const exponent = readExponent(input, i);
+            if (exponent > i)
+                i = exponent;
             tokens.push({ kind: "number", value: input.slice(start, i), start, end: i });
             continue;
         }
@@ -189,4 +213,67 @@ export function tokenize(input) {
     }
     return tokens;
 }
+const SIMPLE_ESCAPES = {
+    "'": "'",
+    '"': '"',
+    "\\": "\\",
+    n: "\n",
+    r: "\r",
+    t: "\t",
+};
+/** Decodes a \u/\U escape at `i`, or returns null when it is not a valid one. */
+function readCodePoint(body, i) {
+    const kind = body[i + 1];
+    const maxDigits = kind === "u" ? 4 : 6;
+    const digits = /^[0-9a-fA-F]+/.exec(body.slice(i + 2, i + 2 + maxDigits))?.[0] ?? "";
+    // \u takes exactly four digits; \U takes as many as still form a code point,
+    // so "\U101EF0" is \U101EF followed by a literal "0".
+    const minLength = kind === "u" ? 4 : 1;
+    for (let len = digits.length; len >= minLength; len--) {
+        if (kind === "u" && len !== 4)
+            break;
+        const code = Number.parseInt(digits.slice(0, len), 16);
+        if (code <= 0x10ffff)
+            return { text: String.fromCodePoint(code), length: 2 + len };
+    }
+    return null;
+}
+/**
+ * Decodes the escape sequences of a FEEL string literal body (the text between
+ * the quotes). Recognizes \' \" \\ \n \r \t, \uXXXX and the extended
+ * \UXXXXXX form; an unrecognized sequence is left as written, since dropping
+ * the backslash would silently alter the author's data.
+ */
+export function unescapeString(body) {
+    if (!body.includes("\\"))
+        return body;
+    let out = "";
+    let i = 0;
+    while (i < body.length) {
+        const c = body[i];
+        if (c !== "\\" || i + 1 >= body.length) {
+            out += c;
+            i++;
+            continue;
+        }
+        const simple = SIMPLE_ESCAPES[body[i + 1]];
+        if (simple !== undefined) {
+            out += simple;
+            i += 2;
+            continue;
+        }
+        const next = body[i + 1];
+        if (next === "u" || next === "U") {
+            const decoded = readCodePoint(body, i);
+            if (decoded) {
+                out += decoded.text;
+                i += decoded.length;
+                continue;
+            }
+        }
+        out += c;
+        i++;
+    }
+    return out;
+}
 //# sourceMappingURL=lexer.js.map

package/dist/parser.d.ts

@@ -8,6 +8,15 @@ export interface ParseResult {
     ast: FeelNode | null;
     errors: ParseError[];
 }
-export declare function parseExpression(input: string): ParseResult;
-export declare function parseUnaryTests(input: string): ParseResult;
+export interface ParseOptions {
+    /**
+     * Names that are in scope where the expression is evaluated. FEEL names may
+     * contain spaces, so `a b + 1` can only be read as a reference to `a b`
+     * when the parser is told that `a b` exists. Without this, only multi-word
+     * built-in names are recognized.
+     */
+    names?: Iterable<string>;
+}
+export declare function parseExpression(input: string, options?: ParseOptions): ParseResult;
+export declare function parseUnaryTests(input: string, options?: ParseOptions): ParseResult;
 //# sourceMappingURL=parser.d.ts.map