@elaraai/east 1.0.84 → 1.0.85

package/dist/src/serialization/east.js

@@ -9,8 +9,9 @@ import { compareFor } from "../comparison.js";
 import { SortedMap } from "../containers/sortedmap.js";
 import { SortedSet } from "../containers/sortedset.js";
 import { isVariant, variant } from "../containers/variant.js";
-import { EastTypeValueType, toEastTypeValue } from "../type_of_type.js";
+import { EastTypeValueType, isTypeValueEqual, toEastTypeValue } from "../type_of_type.js";
 import { ref } from "../containers/ref.js";
+import { printEastString } from "./east_text.js";
 class ParseError extends Error {
     position;
     path;
@@ -55,65 +56,87 @@ function _encodeRelativeRef(currentPath, targetPath) {
     return `${upLevels}#${remainingStr}`;
 }
 /**
- * Decode a relative reference string and return the target path array.
- * Input like "2#.foo[0]" returns the target path array.
- * Input like "1#" returns the target path array.
+ * Resolve a relative reference string against the current path, to the
+ * punctuated path of its target: "2#.foo[0]" is the current path up two
+ * levels, then `.foo[0]`. The reference's components are taken as the printer
+ * wrote them, whole, so a quoted name or a Dict key's text holding a `.` or a
+ * `]` names what it named.
  */
 function _decodeRelativeRef(refStr, currentPath) {
     const hashIdx = refStr.indexOf('#');
     if (hashIdx === -1) {
         throw new Error(`Invalid relative reference: ${refStr}`);
     }
-    const upLevelStr = refStr.substring(0, hashIdx);
-    const remainingStr = refStr.substring(hashIdx + 1);
-    let upLevels;
-    try {
-        upLevels = parseInt(upLevelStr);
-    }
-    catch {
-        throw new Error(`Invalid relative reference: ${refStr}`);
-    }
-    if (upLevels < 0 || upLevels > currentPath.length) {
+    const upLevels = Number.parseInt(refStr.substring(0, hashIdx), 10);
+    if (Number.isNaN(upLevels) || upLevels > currentPath.length) {
         throw new Error(`Invalid relative reference: going up ${upLevels} levels from depth ${currentPath.length}`);
     }
-    // Build target path
-    const targetPath = currentPath.slice(0, currentPath.length - upLevels);
-    // Add remaining components if any
-    if (remainingStr.length > 0) {
-        // Parse the remaining punctuated path
-        // Format: .field[0][key] etc.
-        let pos = 0;
-        while (pos < remainingStr.length) {
-            if (remainingStr[pos] === '.') {
-                // Identifier follows
-                pos++;
-                let end = pos;
-                while (end < remainingStr.length && /[a-zA-Z0-9_]/.test(remainingStr[end])) {
-                    end++;
-                }
-                targetPath.push(`.${remainingStr.substring(pos, end)}`);
-                pos = end;
-            }
-            else if (remainingStr[pos] === '[') {
-                // Bracket expression
-                let end = pos + 1;
-                let depth = 1;
-                while (end < remainingStr.length && depth > 0) {
-                    if (remainingStr[end] === '[')
-                        depth++;
-                    else if (remainingStr[end] === ']')
-                        depth--;
-                    end++;
-                }
-                targetPath.push(remainingStr.substring(pos, end));
-                pos = end;
+    return _pathToPunctuated(currentPath.slice(0, currentPath.length - upLevels)) + refStr.substring(hashIdx + 1);
+}
+/**
+ * Find where a reference's path ends, from `pos`: the run of components a
+ * printer writes — `.` and a field or case name, bare or quoted in backticks,
+ * and a bracketed array index, Dict key or a Ref's `[]`. A quoted name, and a
+ * string or quoted name in a key, is taken whole, so a `.` or `]` in one does
+ * not end the path.
+ */
+function _scanReferencePath(input, pos) {
+    while (pos < input.length) {
+        const ch = input[pos];
+        if (ch === '.') {
+            pos += 1;
+            if (input[pos] === '`') {
+                pos = _skipQuoted(input, pos);
             }
             else {
-                pos++;
+                while (pos < input.length && /[a-zA-Z0-9_]/.test(input[pos])) {
+                    pos += 1;
+                }
             }
         }
+        else if (ch === '[') {
+            pos += 1;
+            let depth = 1;
+            while (pos < input.length && depth > 0) {
+                const c = input[pos];
+                if (c === '"' || c === '`') {
+                    pos = _skipQuoted(input, pos);
+                    continue;
+                }
+                if (c === '[')
+                    depth++;
+                else if (c === ']')
+                    depth--;
+                pos += 1;
+            }
+        }
+        else {
+            break;
+        }
+    }
+    return pos;
+}
+/**
+ * Find the position after the string or quoted name opening at `pos`: its
+ * closing quote is the first no `\` escapes, and with none it runs to the end
+ * of the input.
+ */
+function _skipQuoted(input, pos) {
+    const quote = input[pos];
+    pos += 1;
+    while (pos < input.length) {
+        const c = input[pos];
+        if (c === '\\') {
+            pos += 2;
+        }
+        else if (c === quote) {
+            return pos + 1;
+        }
+        else {
+            pos += 1;
+        }
     }
-    return targetPath;
+    return input.length;
 }
 export function encodeEastFor(type) {
     // Convert EastType to EastTypeValue if necessary
@@ -176,7 +199,9 @@ export function printFor(type, typeCtx = new Map()) {
         };
     }
     else if (type.type === "String") {
-        return (x, _ctx) => JSON.stringify(x);
+        // Only the escapes the grammar reads, `\\` and `\"`: every other
+        // character, a newline or a tab among them, is written as itself.
+        return (x, _ctx) => printEastString(x);
     }
     else if (type.type === "DateTime") {
         return (x, _ctx) => x.toISOString().substring(0, 23);
@@ -298,14 +323,18 @@ export function printFor(type, typeCtx = new Map()) {
     }
     else if (type.type === "Variant") {
         const case_printers = {};
+        // The path component a back-reference through each case names it by: the
+        // case's name as the text spells it, quoted when it is no plain identifier
+        const case_paths = new Map();
         const ret = (x, ctx = { refs: new Map(), currentPath: [] }) => {
             // Add variant case to path
-            ctx.currentPath.push(`.${x.type}`);
+            ctx.currentPath.push(case_paths.get(x.type));
             const result = case_printers[x.type](x.value, ctx);
             ctx.currentPath.pop();
             return result;
         };
         for (const { name: k, type: t } of type.value) {
+            case_paths.set(k, `.${printIdentifier(k)}`);
             if (t.type === "Null") {
                 const prefix = `.${printIdentifier(k)}`;
                 case_printers[k] = (_value, _ctx) => prefix;
@@ -449,13 +478,13 @@ const createParser = (type, frozen, typeCtx = new Map()) => {
         case "Blob":
             return parseBlob(frozen);
         case "Ref":
-            return createRefParser(type.value, frozen, typeCtx);
+            return createRefParser(type.value, frozen, typeCtx, type);
         case "Array":
-            return createArrayParser(type.value, frozen, typeCtx);
+            return createArrayParser(type.value, frozen, typeCtx, type);
         case "Set":
-            return createSetParser(type.value, frozen, typeCtx);
+            return createSetParser(type.value, frozen, typeCtx, type);
         case "Dict":
-            return createDictParser(type.value.key, type.value.value, frozen, typeCtx);
+            return createDictParser(type.value.key, type.value.value, frozen, typeCtx, type);
         case "Struct":
             return createStructParser(type.value, frozen, typeCtx);
         case "Variant":
@@ -591,9 +620,11 @@ const isTokenTerminator = (input, pos) => {
 /**
  * Parses a $.path reference and returns the referenced value.
  * Returns null if not at a reference (doesn't start with '$').
- * Throws ParseError if the reference is invalid or undefined.
+ * Throws ParseError if the reference is invalid or undefined, or names a
+ * container of another type than `type`, the one the text expects where the
+ * reference stands.
  */
-const parseReference = (input, pos, ctx) => {
+const parseReference = (input, pos, ctx, type) => {
     // Check if this looks like a reference: either "#..." or "N#..." where N is a digit
     let refStart = pos;
     let isRelative = false;
@@ -628,41 +659,14 @@ const parseReference = (input, pos, ctx) => {
     else {
         refStart = pos + 1; // Start after '#'
     }
-    let pathEnd = refStart;
-    while (pathEnd < input.length) {
-        const ch = input[pathEnd];
-        if (ch === '.') {
-            // Dot followed by identifier - keep going until we hit non-identifier char
-            pathEnd++;
-            while (pathEnd < input.length && /[a-zA-Z0-9_]/.test(input[pathEnd])) {
-                pathEnd++;
-            }
-        }
-        else if (ch === '[') {
-            // Bracket - find the matching close bracket
-            pathEnd++;
-            let depth = 1;
-            while (pathEnd < input.length && depth > 0) {
-                if (input[pathEnd] === '[')
-                    depth++;
-                else if (input[pathEnd] === ']')
-                    depth--;
-                pathEnd++;
-            }
-        }
-        else {
-            // Hit something that's not part of the path
-            break;
-        }
-    }
+    const pathEnd = _scanReferencePath(input, refStart);
     const refStr = input.substring(pos, pathEnd);
     // Resolve the target path
     let targetPathStr;
     try {
         if (isRelative) {
             // refStr is like "1#.a" - pass it directly to _decodeRelativeRef
-            const targetPath = _decodeRelativeRef(refStr, ctx.currentPath);
-            targetPathStr = _pathToPunctuated(targetPath);
+            targetPathStr = _decodeRelativeRef(refStr, ctx.currentPath);
         }
         else {
             // Absolute reference: just use the path part directly (without the leading #)
@@ -673,10 +677,16 @@ const parseReference = (input, pos, ctx) => {
         throw new ParseError(`invalid reference ${refStr}: ${e instanceof Error ? e.message : String(e)}`, pos);
     }
     // Look up in refs map
-    if (!ctx.refs.has(targetPathStr)) {
+    const target = ctx.refs.get(targetPathStr);
+    if (target === undefined) {
         throw new ParseError(`undefined reference ${refStr}`, pos);
     }
-    return { value: ctx.refs.get(targetPathStr), position: pathEnd };
+    // A container of the type the text expects here, as East's type equality
+    // has it: one of another type would be read as a value of the wrong type
+    if (!isTypeValueEqual(target.type, type)) {
+        throw new ParseError(`invalid reference ${refStr}: it names a value of another type`, pos);
+    }
+    return { value: target.value, position: pathEnd };
 };
 const parseBoolean = (input, pos, _ctx) => {
     pos = consumeWhitespace(input, pos);
@@ -720,7 +730,8 @@ const parseString = (input, pos, _ctx) => {
                     rangeStart = pos;
                 }
                 else {
-                    // TODO we need to (a) deal with escape sequences at least for unprintable characters and (b) safely handle LTR-RTL transition characters
+                    // The grammar has these two escapes and no others: a printer writes
+                    // every other character, a control character included, as itself.
                     throw new ParseError("unexpected escape sequence in string", pos);
                 }
             }
@@ -785,7 +796,7 @@ const parseBlob = (frozen) => (input, pos, _ctx) => {
     }
     return { value: bytes, position: pos };
 };
-const createRefParser = (value_type, frozen, typeCtx) => {
+const createRefParser = (value_type, frozen, typeCtx, self) => {
     let valueParser;
     const ret = (input, pos, ctx) => {
         pos = consumeWhitespace(input, pos);
@@ -795,7 +806,7 @@ const createRefParser = (value_type, frozen, typeCtx) => {
             ctx = { refs: new Map(), currentPath: [] };
         }
         // Check for reference first
-        const reference = parseReference(input, pos, ctx);
+        const reference = parseReference(input, pos, ctx, self);
         if (reference) {
             return reference;
         }
@@ -807,7 +818,7 @@ const createRefParser = (value_type, frozen, typeCtx) => {
         // Pre-register this ref if we have context
         if (ctx) {
             const pathStr = _pathToPunctuated(ctx.currentPath);
-            ctx.refs.set(pathStr, r);
+            ctx.refs.set(pathStr, { value: r, type: self });
         }
         if (ctx)
             ctx.currentPath.push(`[]`);
@@ -835,7 +846,7 @@ const createRefParser = (value_type, frozen, typeCtx) => {
     valueParser = createParser(value_type, frozen, typeCtx);
     return ret;
 };
-const createArrayParser = (value_type, frozen, typeCtx) => {
+const createArrayParser = (value_type, frozen, typeCtx, self) => {
     let valueParser;
     const ret = (input, pos, ctx) => {
         pos = consumeWhitespace(input, pos);
@@ -845,7 +856,7 @@ const createArrayParser = (value_type, frozen, typeCtx) => {
             ctx = { refs: new Map(), currentPath: [] };
         }
         // Check for reference first
-        const ref = parseReference(input, pos, ctx);
+        const ref = parseReference(input, pos, ctx, self);
         if (ref) {
             return ref;
         }
@@ -857,7 +868,7 @@ const createArrayParser = (value_type, frozen, typeCtx) => {
         // Pre-register this array if we have context
         if (ctx) {
             const pathStr = _pathToPunctuated(ctx.currentPath);
-            ctx.refs.set(pathStr, values);
+            ctx.refs.set(pathStr, { value: values, type: self });
         }
         // Handle empty array
         if (input[pos] === ']') {
@@ -902,7 +913,7 @@ const createArrayParser = (value_type, frozen, typeCtx) => {
     valueParser = createParser(value_type, frozen, typeCtx);
     return ret;
 };
-const createSetParser = (key_type, frozen, typeCtx) => {
+const createSetParser = (key_type, frozen, typeCtx, self) => {
     const keyParser = createParser(key_type, frozen, typeCtx);
     const keyCompare = compareFor(key_type);
     return (input, pos, ctx) => {
@@ -913,7 +924,7 @@ const createSetParser = (key_type, frozen, typeCtx) => {
             ctx = { refs: new Map(), currentPath: [] };
         }
         // Check for reference first
-        const ref = parseReference(input, pos, ctx);
+        const ref = parseReference(input, pos, ctx, self);
         if (ref) {
             return ref;
         }
@@ -925,7 +936,7 @@ const createSetParser = (key_type, frozen, typeCtx) => {
         // Pre-register this set if we have context
         if (ctx) {
             const pathStr = _pathToPunctuated(ctx.currentPath);
-            ctx.refs.set(pathStr, values);
+            ctx.refs.set(pathStr, { value: values, type: self });
         }
         // Handle empty set
         if (input[pos] === '}') {
@@ -962,7 +973,7 @@ const createSetParser = (key_type, frozen, typeCtx) => {
         }
     };
 };
-const createDictParser = (key_type, value_type, frozen, typeCtx) => {
+const createDictParser = (key_type, value_type, frozen, typeCtx, self) => {
     const keyParser = createParser(key_type, frozen, typeCtx);
     let valueParser;
     const keyCompare = compareFor(key_type);
@@ -975,7 +986,7 @@ const createDictParser = (key_type, value_type, frozen, typeCtx) => {
             ctx = { refs: new Map(), currentPath: [] };
         }
         // Check for reference first
-        const ref = parseReference(input, pos, ctx);
+        const ref = parseReference(input, pos, ctx, self);
         if (ref) {
             return ref;
         }
@@ -987,7 +998,7 @@ const createDictParser = (key_type, value_type, frozen, typeCtx) => {
         // Pre-register this dict if we have context
         if (ctx) {
             const pathStr = _pathToPunctuated(ctx.currentPath);
-            ctx.refs.set(pathStr, values);
+            ctx.refs.set(pathStr, { value: values, type: self });
         }
         // Handle empty dict
         if (input[pos] === ':') {
@@ -1073,7 +1084,9 @@ const parseQuotedIdentifier = (input, pos, _ctx) => {
     pos += 1;
     let rangeStart = pos;
     let result = "";
-    // search through for escape characters, copy string out in ranges
+    // search through for escape characters, copy string out in ranges; an
+    // escaped character is taken whole, so one right before the closing
+    // backtick never hides it
     while (pos < input.length) {
         const char = input[pos];
         if (char === '\\') {
@@ -1082,11 +1095,11 @@ const parseQuotedIdentifier = (input, pos, _ctx) => {
             if (pos < input.length) {
                 const char2 = input[pos];
                 if (char2 === '\\' || char2 === '`') {
-                    rangeStart = pos;
+                    result = result + char2;
                     pos += 1;
+                    rangeStart = pos;
                 }
                 else {
-                    // TODO we need to (a) deal with escape sequences at least for unprintable characters and (b) safely handle LTR-RTL transition characters
                     throw new ParseError("unexpected escape sequence in identifier", pos);
                 }
             }
@@ -1098,7 +1111,9 @@ const parseQuotedIdentifier = (input, pos, _ctx) => {
             result = result + input.substring(rangeStart, pos);
             return { value: result, position: pos + 1 };
         }
-        pos += 1;
+        else {
+            pos += 1;
+        }
     }
     throw new ParseError("unterminated identifier (missing closing `)", pos);
 };
@@ -1120,6 +1135,10 @@ const parseIdentifier = (input, pos, _ctx) => {
 };
 const createStructParser = (fields, frozen, typeCtx) => {
     const fieldNames = fields.map(f => f.name);
+    // The path component a back-reference through each field names it by, as
+    // the printer writes it: `.` and the field's name as the text spells it,
+    // quoted when it is no plain identifier
+    const fieldPaths = fieldNames.map(name => `.${printIdentifier(name)}`);
     const fieldParsers = [];
     const ret = (input, pos, ctx) => {
         pos = consumeWhitespace(input, pos);
@@ -1168,7 +1187,7 @@ const createStructParser = (fields, frozen, typeCtx) => {
             pos += 1;
             const parser = fieldParsers[fieldIndex];
             // Track path for struct fields
-            const fieldPath = /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(fieldName) ? `.${fieldName}` : `[${JSON.stringify(fieldName)}]`;
+            const fieldPath = fieldPaths[fieldIndex];
             if (ctx)
                 ctx.currentPath.push(fieldPath);
             try {
@@ -1240,6 +1259,9 @@ const createStructParser = (fields, frozen, typeCtx) => {
 const createVariantParser = (cases, frozen, typeCtx) => {
     const caseParsers = {};
     const caseNames = cases.map(c => c.name);
+    // The path component a back-reference through each case names it by, as the
+    // printer writes it
+    const casePaths = new Map(caseNames.map(name => [name, `.${printIdentifier(name)}`]));
     const ret = (input, pos, ctx) => {
         pos = consumeWhitespace(input, pos);
         // Create context if we don't have one (for top-level parsing with aliases)
@@ -1257,15 +1279,17 @@ const createVariantParser = (cases, frozen, typeCtx) => {
             throw new ParseError("whitespace not allowed between '.' and case identifier", pos);
         }
         const { value: caseName, position: casePos } = parseIdentifier(input, pos, ctx);
-        const valueParser = caseParsers[caseName];
-        if (valueParser === undefined) {
+        // One of the type's own cases, never a name an object inherits (`toString`)
+        const casePath = casePaths.get(caseName);
+        const valueParser = casePath === undefined ? undefined : caseParsers[caseName];
+        if (valueParser === undefined || casePath === undefined) {
             throw new ParseError(`unknown variant case .${printIdentifier(caseName)}, expected one of: ${caseNames.map(c => `.${printIdentifier(c)}`).join(', ')}`, pos);
         }
         // Create variant with undefined placeholder
         const v = variant(caseName, undefined);
         // Parse the value with case name in path
         if (ctx)
-            ctx.currentPath.push(`.${caseName}`);
+            ctx.currentPath.push(casePath);
         try {
             const { value: caseValue, position: valuePos } = valueParser(input, casePos, ctx);
             // Mutate the variant's value field
@@ -1277,7 +1301,7 @@ const createVariantParser = (cases, frozen, typeCtx) => {
         }
         catch (e) {
             if (e instanceof ParseError) {
-                const newPath = `.${caseName}` + (e.path ? e.path : '');
+                const newPath = casePath + (e.path ? e.path : '');
                 throw new ParseError(e.message, e.position, newPath);
             }
             throw e;
@@ -1886,7 +1910,7 @@ function parseInferredStruct(input, startPos, frozen) {
         }
         pos = consumeWhitespace(input, pos + 1);
         // Parse field value and infer type
-        const fieldPath = /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(fieldName) ? `.${fieldName}` : `[${JSON.stringify(fieldName)}]`;
+        const fieldPath = `.${printIdentifier(fieldName)}`;
         try {
             const fieldValue = parseInferredValue(input, pos, frozen);
             fields[fieldName] = fieldValue.type;
@@ -1953,7 +1977,7 @@ function parseInferredVariant(input, startPos, frozen) {
         }
         catch (e) {
             if (e instanceof ParseError) {
-                const newPath = `.${caseName}` + (e.path ? e.path : '');
+                const newPath = `.${printIdentifier(caseName)}` + (e.path ? e.path : '');
                 throw new ParseError(e.message, e.position, newPath);
             }
             throw e;