@tokens-studio/tokenscript-interpreter 0.36.4 → 0.37.1

package/dist/lib/{chunk-2BDFE7U4.js → chunk-4L54VFWU.js}

@@ -1,5 +1,5 @@
-import { DictionarySymbol, serializeInterpreterResult, stringifyInterpreterResult, isSome, LexerError, isSpace, isNumber2, isAlpha, isAlphaNumeric, ParserError, isLanguageError, NullSymbol, isTokenscriptSymbol, StringSymbol, NumberWithUnitSymbol, NumberSymbol, InterpreterError, BooleanSymbol, isNull, jsValueToSymbolType, ListSymbol, ColorSymbol, parseHexWithAlpha, basicSymbolTypes, typeName, typeEquals, ProcessorError, isObject, TokenSymbol, isArray, isString, getKeyAlt, isNumber, isBoolean, safeParseInt, serializeError, ensureValidAlpha, formatHex8, isTransparent, getResultTypeName, LanguageError } from './chunk-S7WGJBSX.js';
-import { __name, SupportedFormats, ReservedKeyword, __export, UNINTERPRETED_KEYWORDS } from './chunk-AEOBCHBK.js';
+import { DictionarySymbol, serializeInterpreterResult, stringifyInterpreterResult, isSome, LexerError, isSpace, isNumber2, isAlpha, isAlphaNumeric, ParserError, isLanguageError, NullSymbol, isTokenscriptSymbol, StringSymbol, NumberWithUnitSymbol, NumberSymbol, InterpreterError, BooleanSymbol, isNull, jsValueToSymbolType, ListSymbol, ColorSymbol, parseHexWithAlpha, basicSymbolTypes, typeName, typeEquals, ProcessorError, isObject, TokenSymbol, isArray, isString, getKeyAlt, isNumber, isBoolean, safeParseInt, serializeError, ensureValidAlpha, formatHex8, isTransparent, getResultTypeName, LanguageError } from './chunk-24FMHL6W.js';
+import { __name, SupportedFormats, ReservedKeyword, __export, SCRIPT_ONLY_STATEMENT_KEYWORDS, UNINTERPRETED_KEYWORDS } from './chunk-SLITBMFB.js';
 import { z, Color, Fn, Token, Unit, Constants, ZodError } from '@tokens-studio/schema-validation';
 
 // src/interpreter/tolerant/partial-nodes.ts
@@ -504,6 +504,7 @@ var _Lexer = class _Lexer {
     this.text = text;
     this.currentChar = this.pos < this.text.length ? this.text[this.pos] : null;
     this.tolerant = options?.tolerant ?? false;
+    this.greedyStrings = options?.greedyStrings ?? false;
   }
   /**
    * Check if a FORMAT token (unit suffix) is valid at the given position.
@@ -608,8 +609,91 @@ var _Lexer = class _Lexer {
     const cp = char.codePointAt(0) ?? 0;
     return isAlphaNumeric(char) || cp === 45 /* HYPHEN */ || cp === 95 /* UNDERSCORE */ || cp > 127;
   }
+  /**
+   * Greedy variant of isValidStringElement.
+   * Consumes everything except whitespace and structural delimiters.
+   * Used in inline mode to allow values like `http://foo.bar` as a single string.
+   */
+  isValidStringElementGreedy(char) {
+    if (char === null) return false;
+    if (isSpace(char)) return false;
+    const cp = char.codePointAt(0) ?? 0;
+    switch (cp) {
+      case 123:
+      // {
+      case 125:
+      // }
+      case 40:
+      // (
+      case 41:
+      // )
+      case 91:
+      // [
+      case 93:
+      // ]
+      case 44:
+      // ,
+      case 34:
+      // "
+      case 39:
+      // '
+      case 59:
+        return false;
+    }
+    return true;
+  }
   stringElement() {
     const startPos = this.pos;
+    const isGreedy = this.greedyStrings;
+    if (isGreedy && this.isValidFormatPosition(startPos)) {
+      return this.stringElementNonGreedy(startPos);
+    }
+    let result = "";
+    let isSimpleIdentifier = true;
+    const check = isGreedy ? (c) => this.isValidStringElementGreedy(c) : (c) => this.isValidStringElement(c);
+    while (check(this.currentChar)) {
+      if (isSimpleIdentifier && !isAlphaNumeric(this.currentChar) && this.currentChar !== "-" && this.currentChar !== "_") {
+        isSimpleIdentifier = false;
+      }
+      result += this.currentChar;
+      this.advance();
+    }
+    if (isSimpleIdentifier) {
+      const normalizedResult = result.toLowerCase();
+      const keyword = RESERVED_KEYWORD_STRINGS[normalizedResult];
+      if (keyword) {
+        return {
+          type: "RESERVED_KEYWORD" /* RESERVED_KEYWORD */,
+          value: keyword,
+          line: this.line,
+          pos: startPos,
+          endPos: this.pos
+        };
+      }
+      const format = SUPPORTED_FORMAT_STRINGS[normalizedResult];
+      if (format && this.isValidFormatPosition(startPos)) {
+        return {
+          type: "FORMAT" /* FORMAT */,
+          value: format,
+          line: this.line,
+          pos: startPos,
+          endPos: this.pos
+        };
+      }
+    }
+    return {
+      type: "STRING" /* STRING */,
+      value: result,
+      line: this.line,
+      pos: startPos,
+      endPos: this.pos
+    };
+  }
+  /**
+   * Non-greedy string element parsing, used when in format-adjacent position
+   * so that unit suffixes are correctly extracted even in greedy mode.
+   */
+  stringElementNonGreedy(startPos) {
     let result = "";
     while (this.isValidStringElement(this.currentChar)) {
       result += this.currentChar;
@@ -1944,7 +2028,20 @@ ${contextText}`;
       this.error("PARSER_TOLERANT_REQUIRES_INLINE" /* TOLERANT_REQUIRES_INLINE */);
     }
     if (this.currentToken.type === "EOF" /* EOF */) return null;
-    if (inlineMode) return this.listExpr();
+    if (inlineMode) {
+      if (this.currentToken.type === "RESERVED_KEYWORD" /* RESERVED_KEYWORD */ && SCRIPT_ONLY_STATEMENT_KEYWORDS.has(this.currentToken.value)) {
+        this.error("PARSER_UNALLOWED_INLINE_SYNTAX" /* UNALLOWED_INLINE_SYNTAX */, {
+          originalError: `Unexpected token: ${this.currentToken.value}`
+        });
+      }
+      const node2 = this.listExpr();
+      if (!this.tolerant && this.currentToken.type !== "EOF" /* EOF */) {
+        this.error("PARSER_UNEXPECTED_TOKEN" /* UNEXPECTED_TOKEN */, {
+          token: String(this.currentToken.value)
+        });
+      }
+      return node2;
+    }
     const node = this.statementsList();
     if (this.currentToken.type !== "EOF" /* EOF */) {
       this.error("PARSER_INVALID_SYNTAX" /* INVALID_SYNTAX */, {
@@ -1956,10 +2053,16 @@ ${contextText}`;
 };
 __name(_Parser, "Parser");
 var Parser = _Parser;
-function parseExpression(text) {
-  const lexer = new Lexer(text);
+function lexerOptionsForMode(mode, overrides) {
+  const base = mode === "inline" ? { greedyStrings: true } : {};
+  return { ...base, ...overrides };
+}
+__name(lexerOptionsForMode, "lexerOptionsForMode");
+function parseExpression(text, options) {
+  const mode = options?.mode ?? "script";
+  const lexer = new Lexer(text, lexerOptionsForMode(mode, options?.lexerOverrides));
   const parser = new Parser(lexer);
-  const ast = parser.parse();
+  const ast = parser.parse(mode === "inline");
   return {
     lexer,
     parser,
@@ -3803,6 +3906,22 @@ var _PrefixResolver = class _PrefixResolver {
     this.earlyResolved.push(tokenName);
   }
   tryParseExpression(refPath, value) {
+    try {
+      return parseExpression(value, { mode: "inline" });
+    } catch (error) {
+      const isStatementSyntax = error instanceof ParserError && (error.code === "PARSER_UNALLOWED_INLINE_SYNTAX" /* UNALLOWED_INLINE_SYNTAX */ || error.code === "PARSER_UNEXPECTED_TOKEN" /* UNEXPECTED_TOKEN */ && SCRIPT_ONLY_STATEMENT_KEYWORDS.has(error.data?.token));
+      if (isStatementSyntax) ; else if (isLanguageError(error)) {
+        return this.resolveError(refPath, error, value);
+      } else {
+        return this.resolveError(
+          refPath,
+          new ProcessorError("PROC_UNKNOWN_PARSING_ERROR" /* UNKNOWN_PARSING_ERROR */, {
+            data: { error: error instanceof Error ? error.message : String(error) }
+          }),
+          value
+        );
+      }
+    }
     try {
       return parseExpression(value);
     } catch (error) {
@@ -7193,12 +7312,10 @@ Constants.specName;
 
 // src/lib/eval.ts
 function evaluateExpression(expression, options = {}) {
-  const { references = {}, config, allowStatements = false } = options;
+  const { references = {}, config, mode = "script" } = options;
   const startTime = performance.now();
   try {
-    const lexer = new Lexer(expression);
-    const parser = new Parser(lexer);
-    const ast = parser.parse(allowStatements);
+    const { ast } = parseExpression(expression, { mode });
     if (!ast) {
       return {
         success: true,
@@ -7229,7 +7346,7 @@ __name(evaluateExpression, "evaluateExpression");
 
 // src/interpreter/tolerant/index.ts
 function parseTolerantly(text) {
-  const lexer = new Lexer(text, { tolerant: true });
+  const lexer = new Lexer(text, lexerOptionsForMode("inline", { tolerant: true }));
   try {
     const parser = new Parser(lexer, { tolerant: true });
     const ast = parser.parse(true);
@@ -7252,7 +7369,7 @@ function parseTolerantly(text) {
 }
 __name(parseTolerantly, "parseTolerantly");
 function tokenizeTolerantly(text) {
-  const lexer = new Lexer(text, { tolerant: true });
+  const lexer = new Lexer(text, lexerOptionsForMode("inline", { tolerant: true }));
   return lexer.tokenizeAll();
 }
 __name(tokenizeTolerantly, "tokenizeTolerantly");
@@ -7299,6 +7416,6 @@ var ASTNodes = {
   UnaryOpNode
 };
 
-export { ASTNodes, ColorManager, ColorSpecificationSchema, Config, ConstantsSpecificationSchema, DEFAULT_LANGUAGE_OPTIONS, FunctionSpecificationSchema, FunctionsManager, IncompleteType, Interpreter, Lexer, ParseState, Parser, PartialBinOpNode, PartialFunctionCallNode, PartialParenNode, PartialReferenceNode, PartialStringNode, PartialUnaryOpNode, TokenResolver, UnitManager, UnitSpecificationSchema, ValidationSeverity, buildTokens, builders_exports, collectAllReferences, collectReferenceNodes, errorClasses, errorHelpers, evaluateExpression, fetchAndRegisterSchemas, fetchTokenScriptSchema, filterAST, flattenChildrenMap, flattenChildrenObject, getAffectedTokens, getBrokenReferences, getModifiedDependants, getRenamedReferences, hasPartialNodes, parseExpression, parseTolerantly, processTokenSets, processTokens, renameReferences, tokenizeTolerantly, validateTokenName, validateTokenPath, walkAST };
-//# sourceMappingURL=chunk-2BDFE7U4.js.map
-//# sourceMappingURL=chunk-2BDFE7U4.js.map
+export { ASTNodes, ColorManager, ColorSpecificationSchema, Config, ConstantsSpecificationSchema, DEFAULT_LANGUAGE_OPTIONS, FunctionSpecificationSchema, FunctionsManager, IncompleteType, Interpreter, Lexer, ParseState, Parser, PartialBinOpNode, PartialFunctionCallNode, PartialParenNode, PartialReferenceNode, PartialStringNode, PartialUnaryOpNode, TokenResolver, UnitManager, UnitSpecificationSchema, ValidationSeverity, buildTokens, builders_exports, collectAllReferences, collectReferenceNodes, errorClasses, errorHelpers, evaluateExpression, fetchAndRegisterSchemas, fetchTokenScriptSchema, filterAST, flattenChildrenMap, flattenChildrenObject, getAffectedTokens, getBrokenReferences, getModifiedDependants, getRenamedReferences, hasPartialNodes, lexerOptionsForMode, parseExpression, parseTolerantly, processTokenSets, processTokens, renameReferences, tokenizeTolerantly, validateTokenName, validateTokenPath, walkAST };
+//# sourceMappingURL=chunk-4L54VFWU.js.map
+//# sourceMappingURL=chunk-4L54VFWU.js.map