@fc-components/monaco-editor 0.2.1 → 0.3.1

package/dist/monaco-editor.cjs.development.js

@@ -3888,6 +3888,1927 @@ function SqlEditor(props) {
   })));
 }
 
+var languageConfiguration$3 = {
+  wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+  comments: {
+    lineComment: '//',
+    blockComment: ['/*', '*/']
+  },
+  brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+  autoClosingPairs: [{
+    open: '{',
+    close: '}'
+  }, {
+    open: '[',
+    close: ']'
+  }, {
+    open: '(',
+    close: ')'
+  }, {
+    open: '"',
+    close: '"'
+  }, {
+    open: "'",
+    close: "'"
+  }, {
+    open: '`',
+    close: '`'
+  }],
+  surroundingPairs: [{
+    open: '{',
+    close: '}'
+  }, {
+    open: '[',
+    close: ']'
+  }, {
+    open: '(',
+    close: ')'
+  }, {
+    open: '"',
+    close: '"'
+  }, {
+    open: "'",
+    close: "'"
+  }, {
+    open: '`',
+    close: '`'
+  }],
+  folding: {
+    offSide: false
+  }
+};
+// Expr-lang keywords
+var keywords$3 = ['let', 'true', 'false', 'nil', 'in', 'not', 'and', 'or', 'if', 'else'];
+// Expr-lang built-in functions
+var stringFunctions = ['trim', 'trimPrefix', 'trimSuffix', 'upper', 'lower', 'split', 'splitAfter', 'replace', 'repeat', 'indexOf', 'lastIndexOf', 'hasPrefix', 'hasSuffix', 'contains', 'startsWith', 'endsWith'];
+var dateFunctions = ['now', 'duration', 'date', 'timezone'];
+var numberFunctions = ['max', 'min', 'abs', 'ceil', 'floor', 'round'];
+var arrayFunctions = ['all', 'any', 'one', 'none', 'map', 'filter', 'find', 'findIndex', 'findLast', 'findLastIndex', 'groupBy', 'count', 'concat', 'flatten', 'uniq', 'join', 'reduce', 'sum', 'mean', 'median', 'first', 'last', 'take', 'reverse', 'sort', 'sortBy'];
+var mapFunctions = ['keys', 'values'];
+var typeConversionFunctions = ['type', 'int', 'float', 'string', 'toJSON', 'fromJSON', 'toBase64', 'fromBase64', 'toPairs', 'fromPairs'];
+var miscFunctions = ['len', 'get'];
+var bitwiseFunctions = ['bitand', 'bitor', 'bitxor', 'bitnand', 'bitnot', 'bitshl', 'bitshr', 'bitushr'];
+var builtinFunctions = /*#__PURE__*/[].concat(stringFunctions, dateFunctions, numberFunctions, arrayFunctions, mapFunctions, typeConversionFunctions, miscFunctions, bitwiseFunctions);
+var language$3 = {
+  defaultToken: '',
+  tokenPostfix: '.expr',
+  brackets: [{
+    open: '(',
+    close: ')',
+    token: 'delimiter.parenthesis'
+  }, {
+    open: '{',
+    close: '}',
+    token: 'delimiter.curly'
+  }, {
+    open: '[',
+    close: ']',
+    token: 'delimiter.square'
+  }],
+  keywords: keywords$3,
+  builtinFunctions: builtinFunctions,
+  operators: ['+', '-', '*', '/', '%', '^', '**', '==', '!=', '<', '>', '<=', '>=', '!', '&&', '||', '?:', '??', '.', '?.', 'in', 'matches', '..', '|'],
+  escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,2}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  digits: /\d+(_+\d+)*/,
+  hexdigits: /[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+  octdigits: /[0-7]+(_+[0-7]+)*/,
+  bindigits: /[01]+(_+[01]+)*/,
+  tokenizer: {
+    root: [{
+      include: '@whitespace'
+    }, {
+      include: '@comments'
+    }, {
+      include: '@numbers'
+    }, {
+      include: '@strings'
+    }, {
+      include: '@bytes'
+    },
+    // Function calls: identifier followed by '('
+    [/[a-zA-Z_]\w*(?=\s*\()/, {
+      cases: {
+        '@builtinFunctions': 'keyword.function',
+        '@default': 'identifier.function'
+      }
+    }],
+    // Keywords and identifiers
+    [/[a-zA-Z_]\w*/, {
+      cases: {
+        '@keywords': 'keyword',
+        '@default': 'identifier'
+      }
+    }],
+    // Operators
+    [/[?][?:]/, 'operator'], [/[?][.]/, 'operator'], [/[.]{2}/, 'operator'], [/[*]{2}/, 'operator'], [/[|]/, 'operator'], [/[+\-*/%^]/, 'operator'], [/==|!=|<=|>=|<|>/, 'operator'], [/!|&&|\|\|/, 'operator'], [/[=]/, 'operator'], [/[.~]/, 'operator'],
+    // Delimiters
+    [/[,;]/, 'delimiter'], [/[{}()\[\]]/, '@brackets']],
+    whitespace: [[/[ \t\r\n]+/, 'white']],
+    comments: [[/\/\/.*$/, 'comment'], [/\/\*/, {
+      token: 'comment.quote',
+      next: '@comment'
+    }]],
+    comment: [[/[^*/]+/, 'comment'], [/\*\//, {
+      token: 'comment.quote',
+      next: '@pop'
+    }], [/./, 'comment']],
+    numbers: [[/0[xX]@hexdigits/, 'number.hex'], [/0[oO]@octdigits/, 'number.octal'], [/0[bB]@bindigits/, 'number.binary'], [/(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?/, 'number']],
+    strings: [[/"/, {
+      token: 'string.double',
+      next: '@string_double'
+    }], [/'/, {
+      token: 'string',
+      next: '@string_single'
+    }], [/`/, {
+      token: 'string.backtick',
+      next: '@string_backtick'
+    }]],
+    string_double: [[/[^"\\]+/, 'string.double'], [/@escapes/, 'string.escape'], [/\\./, 'string.escape.invalid'], [/"/, {
+      token: 'string.double',
+      next: '@pop'
+    }]],
+    string_single: [[/[^'\\]+/, 'string'], [/@escapes/, 'string.escape'], [/\\./, 'string.escape.invalid'], [/'/, {
+      token: 'string',
+      next: '@pop'
+    }]],
+    string_backtick: [[/[^`]+/, 'string.backtick'], [/`/, {
+      token: 'string.backtick',
+      next: '@pop'
+    }]],
+    bytes: [[/[bB]"/, {
+      token: 'string.bytes',
+      next: '@bytes_double'
+    }], [/[bB]'/, {
+      token: 'string.bytes',
+      next: '@bytes_single'
+    }]],
+    bytes_double: [[/[^"\\]+/, 'string.bytes'], [/\\(?:[abfnrtv\\"]|x[0-9A-Fa-f]{2}|[0-7]{3})/, 'string.escape'], [/\\./, 'string.escape.invalid'], [/"/, {
+      token: 'string.bytes',
+      next: '@pop'
+    }]],
+    bytes_single: [[/[^'\\]+/, 'string.bytes'], [/\\(?:[abfnrtv\\']|x[0-9A-Fa-f]{2}|[0-7]{3})/, 'string.escape'], [/\\./, 'string.escape.invalid'], [/'/, {
+      token: 'string.bytes',
+      next: '@pop'
+    }]]
+  }
+};
+
+var EXPR_KEYWORDS = ['let', 'true', 'false', 'nil', 'in', 'not', 'and', 'or', 'if', 'else'];
+var EXPR_FUNCTIONS = [
+// String functions
+{
+  name: 'trim',
+  signature: 'trim(str[, chars])',
+  description: 'Removes white spaces from both ends of a string',
+  category: 'string'
+}, {
+  name: 'trimPrefix',
+  signature: 'trimPrefix(str, prefix)',
+  description: 'Removes the specified prefix from the string',
+  category: 'string'
+}, {
+  name: 'trimSuffix',
+  signature: 'trimSuffix(str, suffix)',
+  description: 'Removes the specified suffix from the string',
+  category: 'string'
+}, {
+  name: 'upper',
+  signature: 'upper(str)',
+  description: 'Converts all characters to uppercase',
+  category: 'string'
+}, {
+  name: 'lower',
+  signature: 'lower(str)',
+  description: 'Converts all characters to lowercase',
+  category: 'string'
+}, {
+  name: 'split',
+  signature: 'split(str, delimiter[, n])',
+  description: 'Splits a string at each instance of the delimiter',
+  category: 'string'
+}, {
+  name: 'splitAfter',
+  signature: 'splitAfter(str, delimiter[, n])',
+  description: 'Splits a string after each instance of the delimiter',
+  category: 'string'
+}, {
+  name: 'replace',
+  signature: 'replace(str, old, new)',
+  description: 'Replaces all occurrences of old with new',
+  category: 'string'
+}, {
+  name: 'repeat',
+  signature: 'repeat(str, n)',
+  description: 'Repeats a string n times',
+  category: 'string'
+}, {
+  name: 'indexOf',
+  signature: 'indexOf(str, substring)',
+  description: 'Returns the index of the first occurrence of substring',
+  category: 'string'
+}, {
+  name: 'lastIndexOf',
+  signature: 'lastIndexOf(str, substring)',
+  description: 'Returns the index of the last occurrence of substring',
+  category: 'string'
+}, {
+  name: 'hasPrefix',
+  signature: 'hasPrefix(str, prefix)',
+  description: 'Returns true if string starts with the given prefix',
+  category: 'string'
+}, {
+  name: 'hasSuffix',
+  signature: 'hasSuffix(str, suffix)',
+  description: 'Returns true if string ends with the given suffix',
+  category: 'string'
+}, {
+  name: 'contains',
+  signature: 'contains(str, substr)',
+  description: 'Returns true if string contains the given substring',
+  category: 'string'
+}, {
+  name: 'startsWith',
+  signature: 'startsWith(str, prefix)',
+  description: 'Returns true if string starts with the given prefix',
+  category: 'string'
+}, {
+  name: 'endsWith',
+  signature: 'endsWith(str, suffix)',
+  description: 'Returns true if string ends with the given suffix',
+  category: 'string'
+},
+// Date functions
+{
+  name: 'now',
+  signature: 'now()',
+  description: 'Returns the current date as a time.Time value',
+  category: 'date'
+}, {
+  name: 'duration',
+  signature: 'duration(str)',
+  description: 'Returns time.Duration value of the given string',
+  category: 'date'
+}, {
+  name: 'date',
+  signature: 'date(str[, format[, timezone]])',
+  description: 'Converts the given string into a date representation',
+  category: 'date'
+}, {
+  name: 'timezone',
+  signature: 'timezone(str)',
+  description: 'Returns the timezone of the given string',
+  category: 'date'
+},
+// Number functions
+{
+  name: 'max',
+  signature: 'max(n1, n2)',
+  description: 'Returns the maximum of two numbers',
+  category: 'number'
+}, {
+  name: 'min',
+  signature: 'min(n1, n2)',
+  description: 'Returns the minimum of two numbers',
+  category: 'number'
+}, {
+  name: 'abs',
+  signature: 'abs(n)',
+  description: 'Returns the absolute value of a number',
+  category: 'number'
+}, {
+  name: 'ceil',
+  signature: 'ceil(n)',
+  description: 'Returns the least integer value greater than or equal to x',
+  category: 'number'
+}, {
+  name: 'floor',
+  signature: 'floor(n)',
+  description: 'Returns the greatest integer value less than or equal to x',
+  category: 'number'
+}, {
+  name: 'round',
+  signature: 'round(n)',
+  description: 'Returns the nearest integer, rounding half away from zero',
+  category: 'number'
+},
+// Array functions
+{
+  name: 'all',
+  signature: 'all(array, predicate)',
+  description: 'Returns true if all elements satisfy the predicate',
+  category: 'array'
+}, {
+  name: 'any',
+  signature: 'any(array, predicate)',
+  description: 'Returns true if any elements satisfy the predicate',
+  category: 'array'
+}, {
+  name: 'one',
+  signature: 'one(array, predicate)',
+  description: 'Returns true if exactly one element satisfies the predicate',
+  category: 'array'
+}, {
+  name: 'none',
+  signature: 'none(array, predicate)',
+  description: 'Returns true if no elements satisfy the predicate',
+  category: 'array'
+}, {
+  name: 'map',
+  signature: 'map(array, predicate)',
+  description: 'Returns new array by applying the predicate to each element',
+  category: 'array'
+}, {
+  name: 'filter',
+  signature: 'filter(array, predicate)',
+  description: 'Returns new array by filtering elements by predicate',
+  category: 'array'
+}, {
+  name: 'find',
+  signature: 'find(array, predicate)',
+  description: 'Finds the first element satisfying the predicate',
+  category: 'array'
+}, {
+  name: 'findIndex',
+  signature: 'findIndex(array, predicate)',
+  description: 'Finds the index of the first element satisfying the predicate',
+  category: 'array'
+}, {
+  name: 'findLast',
+  signature: 'findLast(array, predicate)',
+  description: 'Finds the last element satisfying the predicate',
+  category: 'array'
+}, {
+  name: 'findLastIndex',
+  signature: 'findLastIndex(array, predicate)',
+  description: 'Finds the index of the last element satisfying the predicate',
+  category: 'array'
+}, {
+  name: 'groupBy',
+  signature: 'groupBy(array, predicate)',
+  description: 'Groups elements by the result of the predicate',
+  category: 'array'
+}, {
+  name: 'count',
+  signature: 'count(array[, predicate])',
+  description: 'Returns the number of elements satisfying the predicate',
+  category: 'array'
+}, {
+  name: 'concat',
+  signature: 'concat(array1, array2[, ...])',
+  description: 'Concatenates two or more arrays',
+  category: 'array'
+}, {
+  name: 'flatten',
+  signature: 'flatten(array)',
+  description: 'Flattens an array into one-dimensional array',
+  category: 'array'
+}, {
+  name: 'uniq',
+  signature: 'uniq(array)',
+  description: 'Removes duplicates from an array',
+  category: 'array'
+}, {
+  name: 'join',
+  signature: 'join(array[, delimiter])',
+  description: 'Joins an array of strings into a single string',
+  category: 'array'
+}, {
+  name: 'reduce',
+  signature: 'reduce(array, predicate[, initial])',
+  description: 'Reduces an array to a single value',
+  category: 'array'
+}, {
+  name: 'sum',
+  signature: 'sum(array[, predicate])',
+  description: 'Returns the sum of all numbers in an array',
+  category: 'array'
+}, {
+  name: 'mean',
+  signature: 'mean(array)',
+  description: 'Returns the average of all numbers in an array',
+  category: 'array'
+}, {
+  name: 'median',
+  signature: 'median(array)',
+  description: 'Returns the median of all numbers in an array',
+  category: 'array'
+}, {
+  name: 'first',
+  signature: 'first(array)',
+  description: 'Returns the first element from an array',
+  category: 'array'
+}, {
+  name: 'last',
+  signature: 'last(array)',
+  description: 'Returns the last element from an array',
+  category: 'array'
+}, {
+  name: 'take',
+  signature: 'take(array, n)',
+  description: 'Returns the first n elements from an array',
+  category: 'array'
+}, {
+  name: 'reverse',
+  signature: 'reverse(array)',
+  description: 'Returns a new reversed copy of the array',
+  category: 'array'
+}, {
+  name: 'sort',
+  signature: 'sort(array[, order])',
+  description: 'Sorts an array in ascending or descending order',
+  category: 'array'
+}, {
+  name: 'sortBy',
+  signature: 'sortBy(array[, predicate, order])',
+  description: 'Sorts an array by the result of the predicate',
+  category: 'array'
+},
+// Map functions
+{
+  name: 'keys',
+  signature: 'keys(map)',
+  description: 'Returns an array containing the keys of the map',
+  category: 'map'
+}, {
+  name: 'values',
+  signature: 'values(map)',
+  description: 'Returns an array containing the values of the map',
+  category: 'map'
+},
+// Type conversion functions
+{
+  name: 'type',
+  signature: 'type(v)',
+  description: 'Returns the type of the given value',
+  category: 'conversion'
+}, {
+  name: 'int',
+  signature: 'int(v)',
+  description: 'Returns the integer value of a number or string',
+  category: 'conversion'
+}, {
+  name: 'float',
+  signature: 'float(v)',
+  description: 'Returns the float value of a number or string',
+  category: 'conversion'
+}, {
+  name: 'string',
+  signature: 'string(v)',
+  description: 'Converts a value to its string representation',
+  category: 'conversion'
+}, {
+  name: 'toJSON',
+  signature: 'toJSON(v)',
+  description: 'Converts a value to JSON string representation',
+  category: 'conversion'
+}, {
+  name: 'fromJSON',
+  signature: 'fromJSON(v)',
+  description: 'Parses a JSON string to a value',
+  category: 'conversion'
+}, {
+  name: 'toBase64',
+  signature: 'toBase64(v)',
+  description: 'Encodes a string into Base64 format',
+  category: 'conversion'
+}, {
+  name: 'fromBase64',
+  signature: 'fromBase64(v)',
+  description: 'Decodes a Base64 encoded string',
+  category: 'conversion'
+}, {
+  name: 'toPairs',
+  signature: 'toPairs(map)',
+  description: 'Converts a map to an array of key-value pairs',
+  category: 'conversion'
+}, {
+  name: 'fromPairs',
+  signature: 'fromPairs(array)',
+  description: 'Converts an array of key-value pairs to a map',
+  category: 'conversion'
+},
+// Miscellaneous functions
+{
+  name: 'len',
+  signature: 'len(v)',
+  description: 'Returns the length of an array, map, or string',
+  category: 'misc'
+}, {
+  name: 'get',
+  signature: 'get(v, index)',
+  description: 'Retrieves element at the specified index from an array or map',
+  category: 'misc'
+},
+// Bitwise functions
+{
+  name: 'bitand',
+  signature: 'bitand(int, int)',
+  description: 'Returns the bitwise AND of two integers',
+  category: 'bitwise'
+}, {
+  name: 'bitor',
+  signature: 'bitor(int, int)',
+  description: 'Returns the bitwise OR of two integers',
+  category: 'bitwise'
+}, {
+  name: 'bitxor',
+  signature: 'bitxor(int, int)',
+  description: 'Returns the bitwise XOR of two integers',
+  category: 'bitwise'
+}, {
+  name: 'bitnand',
+  signature: 'bitnand(int, int)',
+  description: 'Returns the bitwise AND NOT of two integers',
+  category: 'bitwise'
+}, {
+  name: 'bitnot',
+  signature: 'bitnot(int)',
+  description: 'Returns the bitwise NOT of an integer',
+  category: 'bitwise'
+}, {
+  name: 'bitshl',
+  signature: 'bitshl(int, int)',
+  description: 'Returns the Left Shift of an integer',
+  category: 'bitwise'
+}, {
+  name: 'bitshr',
+  signature: 'bitshr(int, int)',
+  description: 'Returns the Right Shift of an integer',
+  category: 'bitwise'
+}, {
+  name: 'bitushr',
+  signature: 'bitushr(int, int)',
+  description: 'Returns the unsigned Right Shift of an integer',
+  category: 'bitwise'
+}];
+var getExprCompletionProvider = function getExprCompletionProvider() {
+  return {
+    provideCompletionItems: function provideCompletionItems(model, position, _context, _token) {
+      var word = model.getWordUntilPosition(position);
+      var range = new monaco.Range(position.lineNumber, word.startColumn, position.lineNumber, word.endColumn);
+      var suggestions = [].concat(EXPR_KEYWORDS.map(function (keyword) {
+        return {
+          label: keyword,
+          kind: monaco.languages.CompletionItemKind.Keyword,
+          insertText: keyword,
+          range: range,
+          sortText: '1' + keyword
+        };
+      }), EXPR_FUNCTIONS.map(function (func) {
+        return {
+          label: func.name,
+          kind: monaco.languages.CompletionItemKind.Function,
+          insertText: func.name,
+          detail: func.signature,
+          documentation: func.description + (" (" + func.category + ")"),
+          range: range,
+          sortText: '2' + func.name,
+          insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet
+        };
+      }));
+      return {
+        suggestions: suggestions
+      };
+    }
+  };
+};
+
+/**
+ * Expr-lang token types and AST definitions
+ */
+var TokenKind;
+(function (TokenKind) {
+  TokenKind["Identifier"] = "Identifier";
+  TokenKind["Number"] = "Number";
+  TokenKind["String"] = "String";
+  TokenKind["Operator"] = "Operator";
+  TokenKind["Bracket"] = "Bracket";
+  TokenKind["EOF"] = "EOF";
+})(TokenKind || (TokenKind = {}));
+var EOF_TOKEN = {
+  kind: TokenKind.EOF,
+  value: '',
+  start: 0,
+  end: 0,
+  line: 0,
+  column: 0
+};
+// Operator precedence (higher = binds tighter)
+var OPERATOR_PRECEDENCE = {
+  '??': 1,
+  '||': 2,
+  or: 2,
+  '&&': 3,
+  and: 3,
+  '==': 4,
+  '!=': 4,
+  '<': 5,
+  '>': 5,
+  '<=': 5,
+  '>=': 5,
+  "in": 5,
+  matches: 5,
+  contains: 5,
+  startsWith: 5,
+  endsWith: 5,
+  '+': 6,
+  '-': 6,
+  '*': 7,
+  '/': 7,
+  '%': 7,
+  '^': 8,
+  '**': 8
+};
+// Unary operators
+var UNARY_OPERATORS = /*#__PURE__*/new Set(['!', 'not', '-']);
+// Comparison operators (for chained comparisons)
+var COMPARISON_OPERATORS = /*#__PURE__*/new Set(['<', '>', '<=', '>=', '==', '!=']);
+
+// Tokens that should be treated as Operators even if they look like identifiers
+var OPERATOR_TOKENS = /*#__PURE__*/new Set(['let', 'if', 'else', 'not', 'and', 'or', 'in', 'matches', 'contains', 'startsWith', 'endsWith', 'hasPrefix', 'hasSuffix']);
+var Lexer = /*#__PURE__*/function () {
+  function Lexer() {
+    this.input = '';
+    this.pos = 0;
+    this.line = 1;
+    this.column = 1;
+    this.startLine = 1;
+    this.startColumn = 1;
+  }
+  var _proto = Lexer.prototype;
+  _proto.reset = function reset(input) {
+    this.input = input;
+    this.pos = 0;
+    this.line = 1;
+    this.column = 1;
+    this.startLine = 1;
+    this.startColumn = 1;
+  };
+  _proto.next = function next() {
+    this.skipWhitespace();
+    this.skipComments();
+    if (this.pos >= this.input.length) {
+      return _extends({}, EOF_TOKEN, {
+        start: this.pos,
+        end: this.pos,
+        line: this.line,
+        column: this.column
+      });
+    }
+    this.startLine = this.line;
+    this.startColumn = this.column;
+    var ch = this.input[this.pos];
+    // String literals
+    if (ch === '"' || ch === "'") {
+      return this.readString(ch);
+    }
+    if (ch === '`') {
+      return this.readBacktickString();
+    }
+    // Byte literals: b"..." or b'...' or B"..." or B'...'
+    if ((ch === 'b' || ch === 'B') && this.pos + 1 < this.input.length) {
+      var _next = this.input[this.pos + 1];
+      if (_next === '"' || _next === "'") {
+        return this.readByteLiteral();
+      }
+    }
+    // Numbers
+    if (this.isDigit(ch) || ch === '.' && this.pos + 1 < this.input.length && this.isDigit(this.input[this.pos + 1])) {
+      return this.readNumber();
+    }
+    // Identifiers and keywords
+    if (this.isIdentStart(ch)) {
+      var token = this.readIdentOrKeyword();
+      return token;
+    }
+    // Operators and brackets
+    return this.readOperatorOrBracket();
+  };
+  _proto.skipWhitespace = function skipWhitespace() {
+    while (this.pos < this.input.length) {
+      var ch = this.input[this.pos];
+      if (ch === ' ' || ch === '\t' || ch === '\r') {
+        this.pos++;
+        this.column++;
+      } else if (ch === '\n') {
+        this.pos++;
+        this.line++;
+        this.column = 1;
+      } else {
+        break;
+      }
+    }
+  };
+  _proto.skipComments = function skipComments() {
+    while (this.pos < this.input.length) {
+      // Line comment //
+      if (this.input[this.pos] === '/' && this.pos + 1 < this.input.length && this.input[this.pos + 1] === '/') {
+        this.pos += 2;
+        this.column += 2;
+        while (this.pos < this.input.length && this.input[this.pos] !== '\n') {
+          this.pos++;
+          this.column++;
+        }
+        this.skipWhitespace();
+        continue;
+      }
+      // Block comment /* */
+      if (this.input[this.pos] === '/' && this.pos + 1 < this.input.length && this.input[this.pos + 1] === '*') {
+        this.pos += 2;
+        this.column += 2;
+        while (this.pos < this.input.length) {
+          if (this.input[this.pos] === '*' && this.pos + 1 < this.input.length && this.input[this.pos + 1] === '/') {
+            this.pos += 2;
+            this.column += 2;
+            break;
+          }
+          if (this.input[this.pos] === '\n') {
+            this.line++;
+            this.column = 1;
+          } else {
+            this.column++;
+          }
+          this.pos++;
+        }
+        this.skipWhitespace();
+        continue;
+      }
+      break;
+    }
+  };
+  _proto.readString = function readString(quote) {
+    var start = this.pos;
+    this.pos++; // skip opening quote
+    this.column++;
+    var value = '';
+    while (this.pos < this.input.length) {
+      var ch = this.input[this.pos];
+      if (ch === '\\') {
+        if (this.pos + 1 >= this.input.length) break;
+        var next = this.input[this.pos + 1];
+        switch (next) {
+          case 'n':
+            value += '\n';
+            break;
+          case 't':
+            value += '\t';
+            break;
+          case 'r':
+            value += '\r';
+            break;
+          case '\\':
+            value += '\\';
+            break;
+          case quote:
+            value += quote;
+            break;
+          case 'x':
+            {
+              var hex = this.input.substr(this.pos + 2, 2);
+              value += String.fromCharCode(parseInt(hex, 16));
+              this.pos += 2;
+              this.column += 2;
+              break;
+            }
+          case 'u':
+            {
+              var unicode = this.input.substr(this.pos + 2, 4);
+              value += String.fromCharCode(parseInt(unicode, 16));
+              this.pos += 2;
+              this.column += 2;
+              break;
+            }
+          default:
+            value += next;
+        }
+        this.pos += 2;
+        this.column += 2;
+      } else if (ch === quote) {
+        this.pos++; // skip closing quote
+        this.column++;
+        return this.makeToken(TokenKind.String, value, start);
+      } else {
+        value += ch;
+        this.pos++;
+        this.column++;
+        if (ch === '\n') {
+          this.line++;
+          this.column = 1;
+        }
+      }
+    }
+    return this.makeToken(TokenKind.String, value, start);
+  };
+  _proto.readBacktickString = function readBacktickString() {
+    var start = this.pos;
+    this.pos++; // skip opening backtick
+    this.column++;
+    var value = '';
+    while (this.pos < this.input.length) {
+      var ch = this.input[this.pos];
+      if (ch === '`') {
+        this.pos++;
+        this.column++;
+        return this.makeToken(TokenKind.String, value, start);
+      }
+      value += ch;
+      this.pos++;
+      if (ch === '\n') {
+        this.line++;
+        this.column = 1;
+      } else {
+        this.column++;
+      }
+    }
+    return this.makeToken(TokenKind.String, value, start);
+  };
+  _proto.readByteLiteral = function readByteLiteral() {
+    // b"..." or b'...' or B"..." or B'...'
+    var start = this.pos;
+    this.pos++; // skip 'b' or 'B'
+    this.column++;
+    var quote = this.input[this.pos];
+    this.pos++; // skip quote
+    this.column++;
+    var value = '';
+    while (this.pos < this.input.length) {
+      var ch = this.input[this.pos];
+      if (ch === '\\') {
+        if (this.pos + 1 >= this.input.length) break;
+        var next = this.input[this.pos + 1];
+        switch (next) {
+          case 'n':
+            value += '\n';
+            break;
+          case 't':
+            value += '\t';
+            break;
+          case 'r':
+            value += '\r';
+            break;
+          case '\\':
+            value += '\\';
+            break;
+          case quote:
+            value += quote;
+            break;
+          case 'x':
+            {
+              var hex = this.input.substr(this.pos + 2, 2);
+              value += String.fromCharCode(parseInt(hex, 16));
+              this.pos += 2;
+              this.column += 2;
+              break;
+            }
+          default:
+            // octal escape \NNN
+            if (this.isDigit(next)) {
+              var octal = this.input.substr(this.pos + 1, 3);
+              value += String.fromCharCode(parseInt(octal, 8));
+              this.pos += 2;
+              this.column += 2;
+              break;
+            }
+            value += next;
+        }
+        this.pos += 2;
+        this.column += 2;
+      } else if (ch === quote) {
+        this.pos++;
+        this.column++;
+        return this.makeToken(TokenKind.String, value, start);
+      } else {
+        value += ch;
+        this.pos++;
+        this.column++;
+      }
+    }
+    return this.makeToken(TokenKind.String, value, start);
+  };
+  _proto.readNumber = function readNumber() {
+    var start = this.pos;
+    var value = '';
+    while (this.pos < this.input.length) {
+      var ch = this.input[this.pos];
+      if (this.isDigit(ch) || ch === '.' || ch === 'e' || ch === 'E' || ch === '+' || ch === '-' || ch === '_' || ch === 'x' || ch === 'X' || ch === 'o' || ch === 'O' || ch === 'b' || ch === 'B' || ch >= 'a' && ch <= 'f' || ch >= 'A' && ch <= 'F') {
+        value += ch;
+        this.pos++;
+        this.column++;
+      } else {
+        break;
+      }
+    }
+    return this.makeToken(TokenKind.Number, value, start);
+  };
+  _proto.readIdentOrKeyword = function readIdentOrKeyword() {
+    var start = this.pos;
+    var value = '';
+    while (this.pos < this.input.length) {
+      var ch = this.input[this.pos];
+      if (this.isIdentPart(ch)) {
+        value += ch;
+        this.pos++;
+        this.column++;
+      } else {
+        break;
+      }
+    }
+    // Keywords that are operators
+    if (OPERATOR_TOKENS.has(value)) {
+      return this.makeToken(TokenKind.Operator, value, start);
+    }
+    return this.makeToken(TokenKind.Identifier, value, start);
+  };
+  _proto.readOperatorOrBracket = function readOperatorOrBracket() {
+    var start = this.pos;
+    var ch = this.input[this.pos];
+    // Brackets
+    if ('()[]{}'.includes(ch)) {
+      this.pos++;
+      this.column++;
+      return this.makeToken(TokenKind.Bracket, ch, start);
+    }
+    // Multi-character operators
+    var twoChar = this.input.substr(this.pos, 2);
+    var threeChar = this.input.substr(this.pos, 3);
+    // 3-character operators: **=
+    // 2-character operators
+    var twoCharOps = ['==', '!=', '<=', '>=', '&&', '||', '??', '?.', '..', '**', '//', '::', '->'];
+    var threeCharOps = ['...', '<<=', '>>='];
+    if (threeCharOps.includes(threeChar)) {
+      this.pos += 3;
+      this.column += 3;
+      return this.makeToken(TokenKind.Operator, threeChar, start);
+    }
+    if (twoCharOps.includes(twoChar)) {
+      this.pos += 2;
+      this.column += 2;
+      return this.makeToken(TokenKind.Operator, twoChar, start);
+    }
+    // Single-character operators and separators
+    var singleCharOps = '+-*/%^=<>!&|?.,;:#@$~';
+    if (singleCharOps.includes(ch)) {
+      this.pos++;
+      this.column++;
+      return this.makeToken(TokenKind.Operator, ch, start);
+    }
+    // Unrecognized character
+    this.pos++;
+    this.column++;
+    return this.makeToken(TokenKind.Operator, ch, start);
+  };
+  _proto.isDigit = function isDigit(ch) {
+    return ch >= '0' && ch <= '9';
+  };
+  _proto.isIdentStart = function isIdentStart(ch) {
+    return ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z' || ch === '_' || ch === '$';
+  };
+  _proto.isIdentPart = function isIdentPart(ch) {
+    return this.isIdentStart(ch) || this.isDigit(ch);
+  };
+  _proto.makeToken = function makeToken(kind, value, start) {
+    return {
+      kind: kind,
+      value: value,
+      start: start,
+      end: this.pos,
+      line: this.startLine,
+      column: this.startColumn
+    };
+  };
+  return Lexer;
+}();
+
+var ExprParser = /*#__PURE__*/function () {
+  function ExprParser() {
+    this.current = _extends({}, EOF_TOKEN);
+    this.errors = [];
+    this.lexer = new Lexer();
+  }
+  /**
+   * Parse an expr-lang expression and return any syntax errors.
+   * Returns empty array if the expression is valid.
+   */
+  var _proto = ExprParser.prototype;
+  _proto.parse = function parse(input) {
+    this.errors = [];
+    this.lexer.reset(input);
+    this.advance();
+    if (input.trim().length === 0) {
+      return [];
+    }
+    this.parseSequenceExpression();
+    // Check for unexpected tokens at the end
+    if (this.curKind() !== TokenKind.EOF && this.errors.length === 0) {
+      this.error("unexpected token \"" + this.curVal() + "\"");
+    }
+    return this.errors;
+  };
+  _proto.advance = function advance() {
+    this.current = this.lexer.next();
+  };
+  _proto.curKind = function curKind() {
+    return this.current.kind;
+  };
+  _proto.curVal = function curVal() {
+    return this.current.value;
+  };
+  _proto.expect = function expect(kind, value) {
+    if (this.curKind() === kind && (value === undefined || this.curVal() === value)) {
+      this.advance();
+      return true;
+    }
+    if (value) {
+      this.error("expected \"" + value + "\" but got \"" + this.curVal() + "\"");
+    } else {
+      this.error("unexpected token \"" + this.curVal() + "\"");
+    }
+    return false;
+  };
+  _proto.error = function error(message) {
+    if (this.errors.length === 0) {
+      // Calculate end position — approximate
+      var endLine = this.current.line;
+      var endColumn = this.current.column + this.curVal().length;
+      this.errors.push({
+        message: message,
+        startLine: this.current.line,
+        startColumn: this.current.column,
+        endLine: endLine,
+        endColumn: endColumn
+      });
+    }
+  };
+  _proto.errorAt = function errorAt(token, message) {
+    if (this.errors.length === 0) {
+      var endColumn = token.column + token.value.length;
+      this.errors.push({
+        message: message,
+        startLine: token.line,
+        startColumn: token.column,
+        endLine: token.line,
+        endColumn: endColumn
+      });
+    }
+  }
+  // ========== Parsing Functions ==========
+  /**
+   * parseSequenceExpression parses multiple expressions separated by semicolons.
+   */;
+  _proto.parseSequenceExpression = function parseSequenceExpression() {
+    if (this.errors.length > 0) return;
+    this.parseExpression(0);
+    while (this.curVal() === ';' && this.errors.length === 0) {
+      this.advance();
+      if (this.curKind() === TokenKind.EOF) break;
+      this.parseExpression(0);
+    }
+  }
+  /**
+   * parseExpression uses precedence climbing to parse binary expressions.
+   */;
+  _proto.parseExpression = function parseExpression(precedence) {
+    if (this.errors.length > 0) return;
+    // Handle "let" at precedence 0
+    if (precedence === 0 && this.curVal() === 'let') {
+      this.parseVariableDeclaration();
+      return;
+    }
+    // Handle "if" at precedence 0
+    if (precedence === 0 && this.curVal() === 'if') {
+      this.parseConditionalIf();
+      return;
+    }
+    // Handle unary operators
+    if (UNARY_OPERATORS.has(this.curVal()) && this.curKind() === TokenKind.Operator) {
+      var unaryToken = this.current;
+      this.advance();
+      if (this.curKind() === TokenKind.EOF) {
+        this.errorAt(unaryToken, 'unexpected token EOF');
+        return;
+      }
+      if (this.errors.length > 0) return;
+      this.parsePrimary();
+      if (this.errors.length > 0) return;
+      this.parsePostfixExpression();
+      return;
+    }
+    this.parsePrimary();
+    if (this.errors.length > 0) return;
+    this.parsePostfixExpression();
+    if (this.errors.length > 0) return;
+    // Handle binary operators with precedence climbing
+    while (this.curKind() === TokenKind.Operator && this.errors.length === 0) {
+      var op = this.curVal();
+      var opToken = this.current;
+      // Handle pipe operator |
+      if (op === '|') {
+        this.advance(); // skip |
+        if (this.curKind() === TokenKind.EOF) {
+          this.errorAt(opToken, 'unexpected token EOF');
+          return;
+        }
+        if (this.curKind() === TokenKind.Identifier) {
+          this.advance(); // skip identifier
+          this.parseArguments();
+          if (this.curVal() === ';') break;
+          continue;
+        }
+        this.error("expected identifier after pipe \"|\" but got \"" + this.curVal() + "\"");
+        return;
+      }
+      // Handle semicolon — end of this expression
+      if (op === ';') break;
+      // Check precedence
+      var opPrec = OPERATOR_PRECEDENCE[op];
+      if (opPrec === undefined || opPrec < precedence) break;
+      // Handle "not" prefix for "not in", "not contains", etc.
+      if (op === 'not') {
+        this.advance();
+        var nextOp = this.curVal();
+        var negatedPrec = OPERATOR_PRECEDENCE[nextOp];
+        if (negatedPrec !== undefined && negatedPrec >= precedence) {
+          this.advance();
+          this.parseExpression(negatedPrec + 1);
+          continue;
+        }
+        this.error("unexpected token \"" + nextOp + "\" after \"not\"");
+        return;
+      }
+      // Handle chained comparisons: a < b < c => (a < b) && (b < c)
+      if (COMPARISON_OPERATORS.has(op)) {
+        this.advance();
+        if (this.curKind() === TokenKind.EOF) {
+          this.errorAt(opToken, 'unexpected token EOF');
+          return;
+        }
+        this.parseExpression(opPrec + 1);
+        // Keep parsing chained comparisons
+        while (this.curKind() === TokenKind.Operator && COMPARISON_OPERATORS.has(this.curVal()) && this.errors.length === 0) {
+          var chainOpToken = this.current;
+          this.advance();
+          if (this.curKind() === TokenKind.EOF) {
+            this.errorAt(chainOpToken, 'unexpected token EOF');
+            return;
+          }
+          this.parseExpression((OPERATOR_PRECEDENCE[this.curVal()] || 0) + 1);
+        }
+        continue;
+      }
+      this.advance();
+      if (this.curKind() === TokenKind.EOF) {
+        this.errorAt(opToken, 'unexpected token EOF');
+        return;
+      }
+      // Right-associative operators bind to the right
+      // For simplicity, parse with same precedence for right-assoc
+      this.parseExpression(opPrec + 1);
+      // Handle ternary ? :
+      if (precedence === 0 && this.curVal() === '?') {
+        this.parseConditional();
+      }
+    }
+    // Handle ternary ? : at precedence 0
+    if (precedence === 0 && this.curVal() === '?') {
+      this.parseConditional();
+    }
+  }
+  /**
+   * parsePrimary handles unary operators, parentheses, and the #/. pointer prefix.
+   */;
+  _proto.parsePrimary = function parsePrimary() {
+    if (this.errors.length > 0) return;
+    // Unary operators are handled in parseExpression
+    // Parenthesized expression
+    if (this.curKind() === TokenKind.Bracket && this.curVal() === '(') {
+      this.advance(); // skip (
+      this.parseSequenceExpression();
+      if (!this.expect(TokenKind.Bracket, ')')) {
+        return;
+      }
+      return;
+    }
+    // Handle # or . prefix (in predicates)
+    if ((this.curVal() === '#' || this.curVal() === '.') && this.curKind() === TokenKind.Operator) {
+      this.advance();
+      if (this.curKind() === TokenKind.Identifier) {
+        this.advance();
+      }
+      this.parsePostfixExpression();
+      return;
+    }
+    this.parseSecondary();
+  }
+  /**
+   * parseSecondary handles identifiers, literals, arrays, and maps.
+   */;
+  _proto.parseSecondary = function parseSecondary() {
+    if (this.errors.length > 0) return;
+    var token = this.current;
+    switch (token.kind) {
+      case TokenKind.Identifier:
+        {
+          this.advance();
+          // Check for function call
+          if (this.curKind() === TokenKind.Bracket && this.curVal() === '(') {
+            this.parseArguments();
+          }
+          break;
+        }
+      case TokenKind.Number:
+        {
+          this.advance();
+          break;
+        }
+      case TokenKind.String:
+        {
+          this.advance();
+          break;
+        }
+      case TokenKind.Bracket:
+        {
+          if (token.value === '[') {
+            this.parseArrayExpression();
+          } else if (token.value === '{') {
+            this.parseMapExpression();
+          } else {
+            this.error("unexpected token \"" + token.value + "\"");
+          }
+          break;
+        }
+      default:
+        this.error("unexpected token \"" + token.value + "\"");
+        break;
+    }
+  }
+  /**
+   * parsePostfixExpression handles .member, ?.member, [index], [from:to], and calls after the primary.
+   */;
+  _proto.parsePostfixExpression = function parsePostfixExpression() {
+    while (this.errors.length === 0) {
+      var token = this.current;
+      // .member or ?.member
+      if (token.kind === TokenKind.Operator && (token.value === '.' || token.value === '?.')) {
+        this.advance();
+        // After . or ?., expect an identifier (or operator like "not" that can be a method name)
+        if (this.curKind() === TokenKind.Identifier || this.curKind() === TokenKind.Operator) {
+          this.advance();
+          // Check for method call: obj.method()
+          if (this.curKind() === TokenKind.Bracket && this.curVal() === '(') {
+            this.parseArguments();
+          }
+        } else if (this.curKind() === TokenKind.Bracket && this.curVal() === '[' && token.value === '?.') {
+          // obj?[index] — handle bracket after ?.
+          this.advance();
+          this.parseExpression(0);
+          this.expect(TokenKind.Bracket, ']');
+        } else {
+          this.error("expected property name after \"" + token.value + "\" but got \"" + this.curVal() + "\"");
+          return;
+        }
+        continue;
+      }
+      // [index] or [from:to]
+      if (token.kind === TokenKind.Bracket && token.value === '[') {
+        this.advance();
+        // Check for slice: [:] or [:to]
+        if (this.curKind() === TokenKind.Operator && this.curVal() === ':') {
+          this.advance();
+          if (this.curKind() !== TokenKind.Bracket || this.curVal() !== ']') {
+            this.parseExpression(0);
+          }
+          this.expect(TokenKind.Bracket, ']');
+        } else {
+          // Index expression
+          this.parseExpression(0);
+          // Check for slice: [from:]
+          if (this.curKind() === TokenKind.Operator && this.curVal() === ':') {
+            this.advance();
+            if (this.curKind() !== TokenKind.Bracket || this.curVal() !== ']') {
+              this.parseExpression(0);
+            }
+          }
+          this.expect(TokenKind.Bracket, ']');
+        }
+        continue;
+      }
+      // Function call after member access
+      if (token.kind === TokenKind.Bracket && token.value === '(') {
+        this.parseArguments();
+        continue;
+      }
+      break;
+    }
+  }
+  /**
+   * parseVariableDeclaration parses "let name = value; rest"
+   */;
+  _proto.parseVariableDeclaration = function parseVariableDeclaration() {
+    this.expect(TokenKind.Operator, 'let');
+    if (this.errors.length > 0) return;
+    if (this.curKind() !== TokenKind.Identifier) {
+      this.error("expected variable name after \"let\" but got \"" + this.curVal() + "\"");
+      return;
+    }
+    this.advance(); // skip variable name
+    if (!this.expect(TokenKind.Operator, '=')) return;
+    this.parseExpression(0);
+    if (this.errors.length > 0) return;
+    // Optional semicolon after value
+    if (this.curVal() === ';') {
+      this.advance();
+      if (this.curKind() !== TokenKind.EOF) {
+        this.parseSequenceExpression();
+      }
+    }
+  }
+  /**
+   * parseConditionalIf parses "if expr { expr1 } else { expr2 }" or "if expr { expr1 } else if ..."
+   */;
+  _proto.parseConditionalIf = function parseConditionalIf() {
+    this.advance(); // skip 'if'
+    if (this.errors.length > 0) return;
+    this.parseExpression(0);
+    if (this.errors.length > 0) return;
+    if (!this.expect(TokenKind.Bracket, '{')) return;
+    this.parseSequenceExpression();
+    if (this.errors.length > 0) return;
+    if (!this.expect(TokenKind.Bracket, '}')) return;
+    if (!this.expect(TokenKind.Operator, 'else')) return;
+    // Nested if
+    if (this.curVal() === 'if') {
+      this.parseConditionalIf();
+      return;
+    }
+    if (!this.expect(TokenKind.Bracket, '{')) return;
+    this.parseSequenceExpression();
+    if (this.errors.length > 0) return;
+    this.expect(TokenKind.Bracket, '}');
+  }
+  /**
+   * parseConditional parses "expr ? expr1 : expr2" or "expr ?: expr2"
+   */;
+  _proto.parseConditional = function parseConditional() {
+    if (this.curVal() !== '?') return;
+    this.advance(); // skip ?
+    // Elvis operator ?:
+    if (this.curVal() === ':') {
+      this.advance();
+      this.parseExpression(0);
+      return;
+    }
+    this.parseExpression(0);
+    if (this.errors.length > 0) return;
+    if (!this.expect(TokenKind.Operator, ':')) return;
+    this.parseExpression(0);
+  }
+  /**
+   * parseArguments parses function call arguments: (arg1, arg2, ...)
+   */;
+  _proto.parseArguments = function parseArguments() {
+    if (!this.expect(TokenKind.Bracket, '(')) return;
+    while (this.curKind() !== TokenKind.Bracket || this.curVal() !== ')') {
+      if (this.curKind() === TokenKind.EOF) {
+        this.error('unexpected end of expression, expected ")"');
+        return;
+      }
+      if (this.curVal() === ',') {
+        this.advance();
+        continue;
+      }
+      // Check for predicate { ... } argument
+      if (this.curKind() === TokenKind.Bracket && this.curVal() === '{') {
+        this.advance();
+        this.parseSequenceExpression();
+        this.expect(TokenKind.Bracket, '}');
+      } else {
+        this.parseExpression(0);
+      }
+      if (this.errors.length > 0) return;
+      if (this.curVal() === ',') {
+        this.advance();
+        // Allow trailing comma
+        if (this.curKind() === TokenKind.Bracket && this.curVal() === ')') {
+          break;
+        }
+      }
+    }
+    this.expect(TokenKind.Bracket, ')');
+  }
+  /**
+   * parseArrayExpression parses "[elem1, elem2, ...]"
+   */;
+  _proto.parseArrayExpression = function parseArrayExpression() {
+    this.expect(TokenKind.Bracket, '[');
+    if (this.errors.length > 0) return;
+    if (this.curKind() === TokenKind.Bracket && this.curVal() === ']') {
+      this.advance();
+      return;
+    }
+    while (this.errors.length === 0) {
+      this.parseExpression(0);
+      if (this.errors.length > 0) return;
+      if (this.curKind() === TokenKind.Bracket && this.curVal() === ']') {
+        break;
+      }
+      if (this.curVal() === ',') {
+        this.advance();
+        // Allow trailing comma
+        if (this.curKind() === TokenKind.Bracket && this.curVal() === ']') {
+          break;
+        }
+        continue;
+      }
+      this.error("expected \",\" or \"]\" but got \"" + this.curVal() + "\"");
+      return;
+    }
+    this.expect(TokenKind.Bracket, ']');
+  }
+  /**
+   * parseMapExpression parses "{key: value, ...}"
+   */;
+  _proto.parseMapExpression = function parseMapExpression() {
+    this.expect(TokenKind.Bracket, '{');
+    if (this.errors.length > 0) return;
+    if (this.curKind() === TokenKind.Bracket && this.curVal() === '}') {
+      this.advance();
+      return;
+    }
+    while (this.errors.length === 0) {
+      // Key: identifier, string, number, or parenthesized expression
+      if (this.curKind() === TokenKind.Identifier || this.curKind() === TokenKind.String || this.curKind() === TokenKind.Number) {
+        this.advance();
+      } else if (this.curKind() === TokenKind.Bracket && this.curVal() === '(') {
+        this.advance();
+        this.parseExpression(0);
+        this.expect(TokenKind.Bracket, ')');
+      } else {
+        this.error("map key must be a string, number, identifier, or parenthesized expression, got \"" + this.curVal() + "\"");
+        return;
+      }
+      if (!this.expect(TokenKind.Operator, ':')) return;
+      this.parseExpression(0);
+      if (this.errors.length > 0) return;
+      if (this.curKind() === TokenKind.Bracket && this.curVal() === '}') {
+        break;
+      }
+      if (this.curVal() === ',') {
+        this.advance();
+        if (this.curKind() === TokenKind.Bracket && this.curVal() === '}') {
+          break;
+        }
+        continue;
+      }
+      this.error("expected \",\" or \"}\" but got \"" + this.curVal() + "\"");
+      return;
+    }
+    this.expect(TokenKind.Bracket, '}');
+  };
+  return ExprParser;
+}();
+
+var EXPR_LANG_ID = 'expr';
+var parser = /*#__PURE__*/new ExprParser();
+/**
+ * Validate an expr-lang expression and return Monaco editor markers.
+ * Uses the recursive descent parser for syntax errors,
+ * plus regex-based checks for structural issues like unbalanced quotes/brackets.
+ */
+var validateExpr = function validateExpr(expr) {
+  var markers = [];
+  if (!expr || expr.trim().length === 0) {
+    return markers;
+  }
+  // 1. Parser-based syntax validation
+  var parseErrors = parser.parse(expr);
+  for (var _iterator = _createForOfIteratorHelperLoose(parseErrors), _step; !(_step = _iterator()).done;) {
+    var err = _step.value;
+    markers.push({
+      severity: monaco.MarkerSeverity.Error,
+      startLineNumber: err.startLine,
+      startColumn: err.startColumn,
+      endLineNumber: err.endLine,
+      endColumn: err.endColumn,
+      message: err.message
+    });
+  }
+  // 2. Line-level structural checks (fallback for issues the parser might miss)
+  var structuralMarkers = validateLineLevel(expr);
+  markers.push.apply(markers, structuralMarkers);
+  return markers;
+};
+/**
+ * Basic line-level validation for quotes and bracket balancing.
+ */
+function validateLineLevel(expr) {
+  var markers = [];
+  var lines = expr.split('\n');
+  var inBlockComment = false;
+  lines.forEach(function (line, index) {
+    var lineNumber = index + 1;
+    // Track block comment state
+    if (!inBlockComment) {
+      var blockCommentStart = line.indexOf('/*');
+      if (blockCommentStart !== -1) {
+        var blockCommentEnd = line.indexOf('*/', blockCommentStart + 2);
+        if (blockCommentEnd === -1) {
+          inBlockComment = true;
+        }
+      }
+    } else {
+      var _blockCommentEnd = line.indexOf('*/');
+      if (_blockCommentEnd !== -1) {
+        inBlockComment = false;
+      }
+      if (inBlockComment || line.trim().startsWith('/*')) {
+        return;
+      }
+    }
+    var trimmedLine = line.trim();
+    if (trimmedLine.startsWith('//') || trimmedLine.startsWith('/*')) {
+      return;
+    }
+    // Check for unclosed quotes
+    var singleQuotes = countQuotesOutsideBlockComments(line);
+    if (singleQuotes % 2 !== 0) {
+      markers.push({
+        severity: monaco.MarkerSeverity.Warning,
+        startLineNumber: lineNumber,
+        startColumn: 1,
+        endLineNumber: lineNumber,
+        endColumn: line.length + 1,
+        message: "Unclosed single quote '",
+        source: EXPR_LANG_ID
+      });
+    }
+    var doubleQuotes = countDoubleQuotesOutsideBlockComments(line);
+    if (doubleQuotes % 2 !== 0) {
+      markers.push({
+        severity: monaco.MarkerSeverity.Warning,
+        startLineNumber: lineNumber,
+        startColumn: 1,
+        endLineNumber: lineNumber,
+        endColumn: line.length + 1,
+        message: 'Unclosed double quote "',
+        source: EXPR_LANG_ID
+      });
+    }
+    var backticks = (line.match(/`/g) || []).length;
+    if (backticks % 2 !== 0) {
+      markers.push({
+        severity: monaco.MarkerSeverity.Warning,
+        startLineNumber: lineNumber,
+        startColumn: 1,
+        endLineNumber: lineNumber,
+        endColumn: line.length + 1,
+        message: 'Unclosed backtick `',
+        source: EXPR_LANG_ID
+      });
+    }
+    // Check for unbalanced brackets
+    var openParens = (line.match(/\(/g) || []).length;
+    var closeParens = (line.match(/\)/g) || []).length;
+    if (openParens > closeParens) {
+      markers.push({
+        severity: monaco.MarkerSeverity.Warning,
+        startLineNumber: lineNumber,
+        startColumn: 1,
+        endLineNumber: lineNumber,
+        endColumn: line.length + 1,
+        message: 'Unmatched opening parenthesis',
+        source: EXPR_LANG_ID
+      });
+    } else if (closeParens > openParens) {
+      markers.push({
+        severity: monaco.MarkerSeverity.Warning,
+        startLineNumber: lineNumber,
+        startColumn: 1,
+        endLineNumber: lineNumber,
+        endColumn: line.length + 1,
+        message: 'Unmatched closing parenthesis',
+        source: EXPR_LANG_ID
+      });
+    }
+    var openBrackets = (line.match(/\[/g) || []).length;
+    var closeBrackets = (line.match(/\]/g) || []).length;
+    if (openBrackets > closeBrackets) {
+      markers.push({
+        severity: monaco.MarkerSeverity.Warning,
+        startLineNumber: lineNumber,
+        startColumn: 1,
+        endLineNumber: lineNumber,
+        endColumn: line.length + 1,
+        message: 'Unmatched opening bracket',
+        source: EXPR_LANG_ID
+      });
+    } else if (closeBrackets > openBrackets) {
+      markers.push({
+        severity: monaco.MarkerSeverity.Warning,
+        startLineNumber: lineNumber,
+        startColumn: 1,
+        endLineNumber: lineNumber,
+        endColumn: line.length + 1,
+        message: 'Unmatched closing bracket',
+        source: EXPR_LANG_ID
+      });
+    }
+    var openBraces = (line.match(/\{/g) || []).length;
+    var closeBraces = (line.match(/\}/g) || []).length;
+    if (openBraces > closeBraces) {
+      markers.push({
+        severity: monaco.MarkerSeverity.Warning,
+        startLineNumber: lineNumber,
+        startColumn: 1,
+        endLineNumber: lineNumber,
+        endColumn: line.length + 1,
+        message: 'Unmatched opening curly brace',
+        source: EXPR_LANG_ID
+      });
+    } else if (closeBraces > openBraces) {
+      markers.push({
+        severity: monaco.MarkerSeverity.Warning,
+        startLineNumber: lineNumber,
+        startColumn: 1,
+        endLineNumber: lineNumber,
+        endColumn: line.length + 1,
+        message: 'Unmatched closing curly brace',
+        source: EXPR_LANG_ID
+      });
+    }
+  });
+  return markers;
+}
+function countQuotesOutsideBlockComments(line) {
+  var withoutBlockComments = line.replace(/\/\*[\s\S]*?\*\//g, '');
+  return (withoutBlockComments.match(/'/g) || []).length;
+}
+function countDoubleQuotesOutsideBlockComments(line) {
+  var withoutBlockComments = line.replace(/\/\*[\s\S]*?\*\//g, '');
+  return (withoutBlockComments.match(/"/g) || []).length;
+}
+
+var _templateObject$3, _templateObject2$3;
+var EXPR_LANG_ID$1 = 'expr';
+var SIZE_MAP$3 = {
+  small: {
+    className: 'ant-input-sm',
+    top: 1,
+    bottom: 1,
+    minHeight: 24
+  },
+  middle: {
+    className: 'ant-input-md',
+    top: 1,
+    bottom: 1,
+    minHeight: 32
+  },
+  large: {
+    className: 'ant-input-lg',
+    top: 3,
+    bottom: 2,
+    minHeight: 40
+  }
+};
+var themeMap$3 = {
+  light: 'expr-light',
+  dark: 'expr-dark'
+};
+var containerDisabledClassName$3 = /*#__PURE__*/css.css(_templateObject$3 || (_templateObject$3 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  .monaco-editor {\n    user-select: none;\n    pointer-events: none;\n  }\n"])));
+var containerReadOnlyClassName$3 = /*#__PURE__*/css.css(_templateObject2$3 || (_templateObject2$3 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  .monaco-editor .cursors-layer > .cursor {\n    opacity: 0 !important;\n  }\n"])));
+function ExprEditor(props) {
+  var id = uuid.v4();
+  var className = props.className,
+    maxHeight = props.maxHeight,
+    fontSize = props.fontSize,
+    _props$size = props.size,
+    size = _props$size === void 0 ? 'middle' : _props$size,
+    _props$theme = props.theme,
+    theme = _props$theme === void 0 ? 'light' : _props$theme,
+    _props$value = props.value,
+    value = _props$value === void 0 ? '' : _props$value,
+    placeholder = props.placeholder,
+    _props$enableAutocomp = props.enableAutocomplete,
+    enableAutocomplete = _props$enableAutocomp === void 0 ? true : _props$enableAutocomp,
+    _props$readOnly = props.readOnly,
+    readOnly = _props$readOnly === void 0 ? false : _props$readOnly,
+    _props$disabled = props.disabled,
+    disabled = _props$disabled === void 0 ? false : _props$disabled,
+    onChange = props.onChange,
+    onEnter = props.onEnter,
+    onBlur = props.onBlur,
+    onFocus = props.onFocus,
+    editorDidMount = props.editorDidMount;
+  var containerRef = React.useRef(null);
+  var editorRef = React.useRef(null);
+  var modelRef = React.useRef(null);
+  var disposablesRef = React.useRef([]);
+  React.useEffect(function () {
+    // Register language
+    if (!monaco.languages.getLanguages().some(function (lang) {
+      return lang.id === EXPR_LANG_ID$1;
+    })) {
+      monaco.languages.register({
+        id: EXPR_LANG_ID$1
+      });
+      monaco.languages.setMonarchTokensProvider(EXPR_LANG_ID$1, language$3);
+      monaco.languages.setLanguageConfiguration(EXPR_LANG_ID$1, languageConfiguration$3);
+    }
+    // Register completion provider
+    if (enableAutocomplete) {
+      var disposable = monaco.languages.registerCompletionItemProvider(EXPR_LANG_ID$1, getExprCompletionProvider());
+      disposablesRef.current.push(disposable);
+    }
+    return function () {
+      disposablesRef.current.forEach(function (disposable) {
+        return disposable.dispose();
+      });
+      disposablesRef.current = [];
+    };
+  }, [enableAutocomplete]);
+  var handleEditorMount = function handleEditorMount(editor) {
+    editorRef.current = editor;
+    modelRef.current = editor.getModel();
+    monaco.editor.defineTheme('expr-light', {
+      base: 'vs',
+      inherit: true,
+      rules: [],
+      colors: {
+        'editor.background': '#00000000',
+        focusBorder: '#00000000'
+      }
+    });
+    monaco.editor.defineTheme('expr-dark', {
+      base: 'vs-dark',
+      inherit: true,
+      rules: [],
+      colors: {
+        'editor.background': '#00000000',
+        focusBorder: '#00000000'
+      }
+    });
+    var isEditorFocused = editor.createContextKey('isEditorFocused' + id, false);
+    editor.onDidBlurEditorWidget(function () {
+      isEditorFocused.set(false);
+      onBlur == null || onBlur(editor.getValue());
+      var position = editor.getPosition();
+      if (position) {
+        var newSelection = new monaco.Selection(position.lineNumber, position.column, position.lineNumber, position.column);
+        editor.setSelection(newSelection);
+      }
+    });
+    editor.onDidFocusEditorText(function () {
+      isEditorFocused.set(true);
+      onFocus == null || onFocus(editor.getValue());
+    });
+    // Auto-height
+    var updateElementHeight = function updateElementHeight() {
+      var containerDiv = containerRef.current;
+      if (containerDiv !== null) {
+        var pixelHeight = editor.getContentHeight();
+        containerDiv.style.minHeight = pixelHeight + "px";
+        containerDiv.style.width = '100%';
+        var pixelWidth = containerDiv.clientWidth;
+        editor.layout({
+          width: pixelWidth,
+          height: pixelHeight
+        });
+      }
+    };
+    editor.onDidContentSizeChange(updateElementHeight);
+    updateElementHeight();
+    // Disable search box
+    monaco.editor.addKeybindingRule({
+      keybinding: monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyF,
+      command: null
+    });
+    // Shift+Enter for newline
+    editor.addCommand(monaco.KeyMod.Shift | monaco.KeyCode.Enter, function () {
+      var position = editor.getPosition();
+      if (position) {
+        editor.executeEdits('shift-enter', [{
+          range: new monaco.Range(position.lineNumber, position.column, position.lineNumber, position.column),
+          text: '\n'
+        }]);
+        editor.setPosition({
+          lineNumber: position.lineNumber + 1,
+          column: 1
+        });
+      }
+    }, 'isEditorFocused' + id);
+    // Prevent default Enter
+    monaco.editor.addKeybindingRule({
+      keybinding: monaco.KeyCode.Enter,
+      command: '-',
+      when: '!suggestWidgetVisible'
+    });
+    // Custom Enter handler
+    editor.addCommand(monaco.KeyCode.Enter, function () {
+      onEnter == null || onEnter(editor.getValue());
+    }, '!suggestWidgetVisible && isEditorFocused' + id);
+    // Setup validation on content change using decorations (no marker hover clutter)
+    var model = editor.getModel();
+    var errorDecorations = [];
+    if (model) {
+      var updateDecorations = function updateDecorations() {
+        var exprValue = model.getValue();
+        var markers = validateExpr(exprValue);
+        var newDecorations = markers.map(function (m) {
+          return {
+            range: new monaco.Range(m.startLineNumber, m.startColumn, m.endLineNumber, m.endColumn),
+            options: {
+              className: 'expr-error-squiggly',
+              hoverMessage: {
+                value: m.message
+              },
+              minimap: {
+                color: '#e51400',
+                position: 1
+              },
+              overviewRuler: {
+                color: '#e51400',
+                position: monaco.editor.OverviewRulerLane.Right
+              }
+            }
+          };
+        });
+        errorDecorations = model.deltaDecorations(errorDecorations, newDecorations);
+      };
+      var validateDisposable = model.onDidChangeContent(updateDecorations);
+      disposablesRef.current.push(validateDisposable);
+      // Run initial validation
+      updateDecorations();
+    }
+    // Inject CSS for the red squiggly underline
+    var styleEl = document.createElement('style');
+    styleEl.textContent = "\n      .expr-error-squiggly {\n        background: url(\"data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 6 3' preserveAspectRatio='none'%3E%3Cpath d='M0,2.5 L1.5,1 L3,2.5 L4.5,1 L6,2.5' stroke='%23e51400' stroke-width='0.6' fill='none'/%3E%3C/svg%3E\") repeat-x left bottom;\n        background-size: 6px 3px;\n        padding-bottom: 3px;\n      }\n    ";
+    document.head.appendChild(styleEl);
+    disposablesRef.current.push({
+      dispose: function dispose() {
+        return styleEl.remove();
+      }
+    });
+    editorDidMount == null || editorDidMount(editor);
+  };
+  var handleChange = function handleChange(newValue, _e) {
+    onChange == null || onChange(newValue);
+  };
+  var themeValue = themeMap$3[theme];
+  return React__default.createElement("div", {
+    className: 'ant-input' + (size ? " " + SIZE_MAP$3[size].className : '') + (disabled ? " ant-input-disabled " + containerDisabledClassName$3 : '') + (readOnly ? " " + containerReadOnlyClassName$3 : '') + (className ? " " + className : ''),
+    style: {
+      display: 'block',
+      resize: 'vertical',
+      overflow: 'auto',
+      minHeight: SIZE_MAP$3[size].minHeight,
+      maxHeight: maxHeight
+    }
+  }, React__default.createElement("div", {
+    ref: containerRef,
+    style: {
+      height: '100%'
+    }
+  }, React__default.createElement(MonacoEditor, {
+    language: EXPR_LANG_ID$1,
+    theme: themeValue,
+    value: value,
+    onChange: handleChange,
+    options: {
+      placeholder: placeholder,
+      selectOnLineNumbers: true,
+      fontSize: fontSize || 12,
+      roundedSelection: false,
+      scrollBeyondLastLine: false,
+      readOnly: readOnly || disabled,
+      minimap: {
+        enabled: false
+      },
+      lineNumbers: 'off',
+      lineNumbersMinChars: 0,
+      glyphMargin: false,
+      folding: false,
+      lineDecorationsWidth: 0,
+      overviewRulerLanes: 0,
+      overviewRulerBorder: false,
+      hideCursorInOverviewRuler: true,
+      hover: {
+        enabled: true,
+        delay: 200
+      },
+      fixedOverflowWidgets: true,
+      renderLineHighlight: 'none',
+      renderValidationDecorations: 'on',
+      scrollbar: {
+        vertical: 'hidden',
+        horizontal: 'auto'
+      },
+      automaticLayout: true,
+      wordWrap: 'on'
+    },
+    editorDidMount: handleEditorMount
+  })));
+}
+
+exports.ExprMonacoEditor = ExprEditor;
 exports.PromQLMonacoEditor = PromQLEditor;
 exports.SqlMonacoEditor = SqlEditor;
 exports.YamlMonacoEditor = YamlEditor;