@holoscript/core 1.0.0-alpha.1 → 2.0.0

package/src/parser/HoloScriptPlusParser.ts

@@ -0,0 +1,1089 @@
+/**
+ * HoloScript+ Parser
+ *
+ * Parses HoloScript+ source code into an AST with support for:
+ * - Standard HoloScript syntax (backward compatible)
+ * - @ directive parsing for VR traits, state, control flow
+ * - Expression interpolation with ${...}
+ * - TypeScript companion imports
+ *
+ * @version 1.0.0
+ */
+
+import type {
+  HSPlusAST,
+  HSPlusNode,
+  HSPlusDirective,
+  HSPlusCompileResult,
+  HSPlusParserOptions,
+  VRTraitName,
+} from '../types/AdvancedTypeSystem';
+
+// =============================================================================
+// TOKEN TYPES
+// =============================================================================
+
+type TokenType =
+  | 'IDENTIFIER'
+  | 'STRING'
+  | 'NUMBER'
+  | 'BOOLEAN'
+  | 'NULL'
+  | 'LBRACE'
+  | 'RBRACE'
+  | 'LBRACKET'
+  | 'RBRACKET'
+  | 'LPAREN'
+  | 'RPAREN'
+  | 'COLON'
+  | 'COMMA'
+  | 'AT'
+  | 'HASH'
+  | 'DOT'
+  | 'EQUALS'
+  | 'ARROW'
+  | 'PIPE'
+  | 'EXPRESSION'
+  | 'COMMENT'
+  | 'NEWLINE'
+  | 'INDENT'
+  | 'DEDENT'
+  | 'EOF';
+
+interface Token {
+  type: TokenType;
+  value: string;
+  line: number;
+  column: number;
+}
+
+// =============================================================================
+// VR TRAITS
+// =============================================================================
+
+const VR_TRAITS: VRTraitName[] = [
+  'grabbable',
+  'throwable',
+  'pointable',
+  'hoverable',
+  'scalable',
+  'rotatable',
+  'stackable',
+  'snappable',
+  'breakable',
+];
+
+// =============================================================================
+// LIFECYCLE HOOKS
+// =============================================================================
+
+type HookName = string;
+
+const LIFECYCLE_HOOKS: HookName[] = [
+  // Standard lifecycle
+  'on_mount',
+  'on_unmount',
+  'on_update',
+  'on_data_update',
+  // VR lifecycle
+  'on_grab',
+  'on_release',
+  'on_hover_enter',
+  'on_hover_exit',
+  'on_point_enter',
+  'on_point_exit',
+  'on_collision',
+  'on_trigger_enter',
+  'on_trigger_exit',
+  'on_click',
+  'on_double_click',
+  // Controller hooks
+  'on_controller_button',
+  'on_trigger_hold',
+  'on_trigger_release',
+  'on_grip_hold',
+  'on_grip_release',
+];
+
+// =============================================================================
+// LEXER
+// =============================================================================
+
+class Lexer {
+  private source: string;
+  private pos: number = 0;
+  private line: number = 1;
+  private column: number = 1;
+  private indentStack: number[] = [0];
+  private tokens: Token[] = [];
+  private pendingDedents: number = 0;
+
+  constructor(source: string) {
+    this.source = source;
+  }
+
+  tokenize(): Token[] {
+    while (this.pos < this.source.length) {
+      // Handle pending dedents
+      while (this.pendingDedents > 0) {
+        this.tokens.push(this.createToken('DEDENT', ''));
+        this.pendingDedents--;
+      }
+
+      const char = this.source[this.pos];
+
+      // Skip whitespace (but track indentation at line start)
+      if (char === ' ' || char === '\t') {
+        if (this.column === 1) {
+          this.handleIndentation();
+        } else {
+          this.advance();
+        }
+        continue;
+      }
+
+      // Comments
+      if (char === '/' && this.peek(1) === '/') {
+        this.skipLineComment();
+        continue;
+      }
+      if (char === '/' && this.peek(1) === '*') {
+        this.skipBlockComment();
+        continue;
+      }
+      if (char === '#' && this.peek(1) !== '#') {
+        if (this.peek(1) === '#') {
+          this.skipLineComment();
+          continue;
+        }
+      }
+
+      // Newlines
+      if (char === '\n') {
+        this.tokens.push(this.createToken('NEWLINE', '\n'));
+        this.advance();
+        this.line++;
+        this.column = 1;
+        continue;
+      }
+      if (char === '\r') {
+        this.advance();
+        if (this.peek() === '\n') {
+          this.advance();
+        }
+        this.tokens.push(this.createToken('NEWLINE', '\n'));
+        this.line++;
+        this.column = 1;
+        continue;
+      }
+
+      // Symbols
+      if (char === '{') {
+        this.tokens.push(this.createToken('LBRACE', '{'));
+        this.advance();
+        continue;
+      }
+      if (char === '}') {
+        this.tokens.push(this.createToken('RBRACE', '}'));
+        this.advance();
+        continue;
+      }
+      if (char === '[') {
+        this.tokens.push(this.createToken('LBRACKET', '['));
+        this.advance();
+        continue;
+      }
+      if (char === ']') {
+        this.tokens.push(this.createToken('RBRACKET', ']'));
+        this.advance();
+        continue;
+      }
+      if (char === '(') {
+        this.tokens.push(this.createToken('LPAREN', '('));
+        this.advance();
+        continue;
+      }
+      if (char === ')') {
+        this.tokens.push(this.createToken('RPAREN', ')'));
+        this.advance();
+        continue;
+      }
+      if (char === ':') {
+        this.tokens.push(this.createToken('COLON', ':'));
+        this.advance();
+        continue;
+      }
+      if (char === ',') {
+        this.tokens.push(this.createToken('COMMA', ','));
+        this.advance();
+        continue;
+      }
+      if (char === '@') {
+        this.tokens.push(this.createToken('AT', '@'));
+        this.advance();
+        continue;
+      }
+      if (char === '#') {
+        this.tokens.push(this.createToken('HASH', '#'));
+        this.advance();
+        continue;
+      }
+      if (char === '.') {
+        this.tokens.push(this.createToken('DOT', '.'));
+        this.advance();
+        continue;
+      }
+      if (char === '=') {
+        if (this.peek(1) === '>') {
+          this.tokens.push(this.createToken('ARROW', '=>'));
+          this.advance();
+          this.advance();
+          continue;
+        }
+        this.tokens.push(this.createToken('EQUALS', '='));
+        this.advance();
+        continue;
+      }
+      if (char === '|') {
+        this.tokens.push(this.createToken('PIPE', '|'));
+        this.advance();
+        continue;
+      }
+
+      // Strings
+      if (char === '"' || char === "'") {
+        this.tokens.push(this.readString(char));
+        continue;
+      }
+
+      // Numbers
+      if (this.isDigit(char) || (char === '-' && this.isDigit(this.peek(1)))) {
+        this.tokens.push(this.readNumber());
+        continue;
+      }
+
+      // Expression interpolation ${...}
+      if (char === '$' && this.peek(1) === '{') {
+        this.tokens.push(this.readExpression());
+        continue;
+      }
+
+      // Identifiers and keywords
+      if (this.isIdentifierStart(char)) {
+        this.tokens.push(this.readIdentifier());
+        continue;
+      }
+
+      // Unknown character - skip
+      this.advance();
+    }
+
+    // Handle remaining dedents
+    while (this.indentStack.length > 1) {
+      this.tokens.push(this.createToken('DEDENT', ''));
+      this.indentStack.pop();
+    }
+
+    this.tokens.push(this.createToken('EOF', ''));
+    return this.tokens;
+  }
+
+  private advance(): string {
+    const char = this.source[this.pos];
+    this.pos++;
+    this.column++;
+    return char;
+  }
+
+  private peek(offset: number = 0): string {
+    const pos = this.pos + offset;
+    return pos < this.source.length ? this.source[pos] : '';
+  }
+
+  private createToken(type: TokenType, value: string): Token {
+    return {
+      type,
+      value,
+      line: this.line,
+      column: this.column - value.length,
+    };
+  }
+
+  private handleIndentation(): void {
+    let indent = 0;
+    while (this.peek() === ' ' || this.peek() === '\t') {
+      indent += this.peek() === '\t' ? 4 : 1;
+      this.advance();
+    }
+
+    if (this.peek() === '\n' || this.peek() === '\r') {
+      return;
+    }
+
+    const currentIndent = this.indentStack[this.indentStack.length - 1];
+
+    if (indent > currentIndent) {
+      this.indentStack.push(indent);
+      this.tokens.push(this.createToken('INDENT', ''));
+    } else if (indent < currentIndent) {
+      while (
+        this.indentStack.length > 1 &&
+        indent < this.indentStack[this.indentStack.length - 1]
+      ) {
+        this.indentStack.pop();
+        this.pendingDedents++;
+      }
+    }
+  }
+
+  private skipLineComment(): void {
+    while (this.peek() !== '\n' && this.pos < this.source.length) {
+      this.advance();
+    }
+  }
+
+  private skipBlockComment(): void {
+    this.advance(); // /
+    this.advance(); // *
+    while (this.pos < this.source.length) {
+      if (this.peek() === '*' && this.peek(1) === '/') {
+        this.advance();
+        this.advance();
+        break;
+      }
+      if (this.peek() === '\n') {
+        this.line++;
+        this.column = 0;
+      }
+      this.advance();
+    }
+  }
+
+  private readString(quote: string): Token {
+    const startLine = this.line;
+    const startColumn = this.column;
+    this.advance(); // Opening quote
+    let value = '';
+
+    while (this.peek() !== quote && this.pos < this.source.length) {
+      if (this.peek() === '\\') {
+        this.advance();
+        const escaped = this.advance();
+        switch (escaped) {
+          case 'n':
+            value += '\n';
+            break;
+          case 't':
+            value += '\t';
+            break;
+          case 'r':
+            value += '\r';
+            break;
+          case '\\':
+            value += '\\';
+            break;
+          case '"':
+            value += '"';
+            break;
+          case "'":
+            value += "'";
+            break;
+          default:
+            value += escaped;
+        }
+      } else if (this.peek() === '\n') {
+        this.line++;
+        this.column = 0;
+        value += this.advance();
+      } else {
+        value += this.advance();
+      }
+    }
+
+    this.advance(); // Closing quote
+    return {
+      type: 'STRING',
+      value,
+      line: startLine,
+      column: startColumn,
+    };
+  }
+
+  private readNumber(): Token {
+    const startColumn = this.column;
+    let value = '';
+
+    if (this.peek() === '-') {
+      value += this.advance();
+    }
+
+    while (this.isDigit(this.peek())) {
+      value += this.advance();
+    }
+
+    if (this.peek() === '.' && this.isDigit(this.peek(1))) {
+      value += this.advance(); // .
+      while (this.isDigit(this.peek())) {
+        value += this.advance();
+      }
+    }
+
+    // Scientific notation
+    if (this.peek() === 'e' || this.peek() === 'E') {
+      value += this.advance();
+      if (this.peek() === '+' || this.peek() === '-') {
+        value += this.advance();
+      }
+      while (this.isDigit(this.peek())) {
+        value += this.advance();
+      }
+    }
+
+    // Unit suffix
+    while (this.isAlpha(this.peek()) || this.peek() === '%') {
+      value += this.advance();
+    }
+
+    return {
+      type: 'NUMBER',
+      value,
+      line: this.line,
+      column: startColumn,
+    };
+  }
+
+  private readExpression(): Token {
+    const startLine = this.line;
+    const startColumn = this.column;
+    this.advance(); // $
+    this.advance(); // {
+
+    let value = '';
+    let braceDepth = 1;
+
+    while (braceDepth > 0 && this.pos < this.source.length) {
+      if (this.peek() === '{') {
+        braceDepth++;
+      } else if (this.peek() === '}') {
+        braceDepth--;
+        if (braceDepth === 0) {
+          break;
+        }
+      }
+      if (this.peek() === '\n') {
+        this.line++;
+        this.column = 0;
+      }
+      value += this.advance();
+    }
+
+    this.advance(); // Closing }
+
+    return {
+      type: 'EXPRESSION',
+      value: value.trim(),
+      line: startLine,
+      column: startColumn,
+    };
+  }
+
+  private readIdentifier(): Token {
+    const startColumn = this.column;
+    let value = '';
+
+    while (this.isIdentifierPart(this.peek())) {
+      value += this.advance();
+    }
+
+    if (value === 'true' || value === 'false') {
+      return {
+        type: 'BOOLEAN',
+        value,
+        line: this.line,
+        column: startColumn,
+      };
+    }
+    if (value === 'null' || value === 'none') {
+      return {
+        type: 'NULL',
+        value,
+        line: this.line,
+        column: startColumn,
+      };
+    }
+
+    return {
+      type: 'IDENTIFIER',
+      value,
+      line: this.line,
+      column: startColumn,
+    };
+  }
+
+  private isDigit(char: string): boolean {
+    return char >= '0' && char <= '9';
+  }
+
+  private isAlpha(char: string): boolean {
+    return (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z');
+  }
+
+  private isIdentifierStart(char: string): boolean {
+    return this.isAlpha(char) || char === '_';
+  }
+
+  private isIdentifierPart(char: string): boolean {
+    return this.isIdentifierStart(char) || this.isDigit(char) || char === '-';
+  }
+}
+
+// =============================================================================
+// PARSER
+// =============================================================================
+
+export class HoloScriptPlusParser {
+  private tokens: Token[] = [];
+  private pos: number = 0;
+  private options: HSPlusParserOptions;
+  private errors: Array<{ message: string; line: number; column: number }> = [];
+  private warnings: Array<{ message: string; line: number; column: number }> = [];
+  private imports: Array<{ path: string; alias: string }> = [];
+  private hasState: boolean = false;
+  private hasVRTraits: boolean = false;
+  private hasControlFlow: boolean = false;
+  private compiledExpressions: Map<string, string> = new Map();
+
+  constructor(options: HSPlusParserOptions = {}) {
+    this.options = {
+      enableVRTraits: true,
+      enableTypeScriptImports: true,
+      strict: false,
+      ...options,
+    };
+  }
+
+  parse(source: string): HSPlusCompileResult {
+    // Reset state
+    this.errors = [];
+    this.warnings = [];
+    this.imports = [];
+    this.hasState = false;
+    this.hasVRTraits = false;
+    this.hasControlFlow = false;
+    this.compiledExpressions = new Map();
+    this.pos = 0;
+
+    // Tokenize
+    const lexer = new Lexer(source);
+    this.tokens = lexer.tokenize();
+
+    // Parse root node
+    const root = this.parseDocument();
+
+    // Build AST
+    const ast: HSPlusAST = {
+      type: 'Program',
+      body: root.directives || [],
+      version: '1.0',
+      root,
+      imports: this.imports,
+      hasState: this.hasState,
+      hasVRTraits: this.hasVRTraits,
+      hasControlFlow: this.hasControlFlow,
+    };
+
+    return {
+      success: true,
+      ast,
+      compiledExpressions: this.compiledExpressions,
+      requiredCompanions: this.imports.map((i) => i.path),
+      features: {
+        state: this.hasState,
+        vrTraits: this.hasVRTraits,
+        loops: this.hasControlFlow,
+        conditionals: this.hasControlFlow,
+        lifecycleHooks: root.directives.some((d: any) => d.type === 'lifecycle'),
+      },
+      warnings: this.warnings,
+      errors: this.errors,
+    };
+  }
+
+  private parseDocument(): HSPlusNode {
+    this.skipNewlines();
+
+    const directives: HSPlusDirective[] = [];
+    while (this.check('AT')) {
+      const directive = this.parseDirective();
+      if (directive) {
+        directives.push(directive);
+      }
+      this.skipNewlines();
+    }
+
+    const root = this.parseNode();
+    root.directives = [...directives, ...root.directives];
+
+    return root;
+  }
+
+  private parseNode(): HSPlusNode {
+    const startToken = this.current();
+
+    const type = this.expect('IDENTIFIER', 'Expected element type').value;
+
+    let id: string | undefined;
+    if (this.check('HASH')) {
+      this.advance();
+      id = this.expect('IDENTIFIER', 'Expected ID after #').value;
+    }
+
+    const properties: Record<string, unknown> = {};
+    const directives: HSPlusDirective[] = [];
+    const traits = new Map<VRTraitName, unknown>();
+
+    while (!this.check('LBRACE') && !this.check('NEWLINE') && !this.check('EOF')) {
+      if (this.check('AT')) {
+        const directive = this.parseDirective();
+        if (directive) {
+          if (directive.type === 'trait') {
+            traits.set(directive.name as VRTraitName, (directive as any).config);
+            this.hasVRTraits = true;
+          } else {
+            directives.push(directive);
+          }
+        }
+      } else if (this.check('IDENTIFIER')) {
+        const key = this.advance().value;
+        if (this.check('COLON') || this.check('EQUALS')) {
+          this.advance();
+          properties[key] = this.parseValue();
+        } else {
+          properties[key] = true;
+        }
+      } else {
+        break;
+      }
+    }
+
+    const children: HSPlusNode[] = [];
+    if (this.check('LBRACE')) {
+      this.advance();
+      this.skipNewlines();
+
+      while (!this.check('RBRACE') && !this.check('EOF')) {
+        if (this.check('AT')) {
+          const directive = this.parseDirective();
+          if (directive) {
+            if (directive.type === 'trait') {
+              traits.set(directive.name as VRTraitName, (directive as any).config);
+              this.hasVRTraits = true;
+            } else {
+              directives.push(directive);
+            }
+          }
+        } else if (this.check('IDENTIFIER')) {
+          const saved = this.pos;
+          const name = this.advance().value;
+
+          if (this.check('COLON') || this.check('EQUALS')) {
+            this.advance();
+            properties[name] = this.parseValue();
+          } else {
+            this.pos = saved;
+            children.push(this.parseNode());
+          }
+        } else {
+          this.skipNewlines();
+          if (this.check('RBRACE') || this.check('EOF')) break;
+          this.advance();
+        }
+        this.skipNewlines();
+      }
+
+      this.expect('RBRACE', 'Expected }');
+    }
+
+    return {
+      type: type as any,
+      id,
+      properties,
+      directives,
+      children,
+      traits,
+      loc: {
+        start: { line: startToken.line, column: startToken.column },
+        end: { line: this.current().line, column: this.current().column },
+      },
+    };
+  }
+
+  private parseDirective(): HSPlusDirective | null {
+    this.expect('AT', 'Expected @');
+    const name = this.expect('IDENTIFIER', 'Expected directive name').value;
+
+    if (VR_TRAITS.includes(name as VRTraitName)) {
+      if (!this.options.enableVRTraits) {
+        this.warn(`VR trait @${name} is disabled`);
+        return null;
+      }
+      const config = this.parseTraitConfig();
+      return { type: 'trait' as const, name: name as VRTraitName, config } as any;
+    }
+
+    if (LIFECYCLE_HOOKS.includes(name)) {
+      const params: string[] = [];
+      if (this.check('LPAREN')) {
+        this.advance();
+        while (!this.check('RPAREN') && !this.check('EOF')) {
+          params.push(this.expect('IDENTIFIER', 'Expected parameter name').value);
+          if (this.check('COMMA')) this.advance();
+        }
+        this.expect('RPAREN', 'Expected )');
+      }
+
+      let body = '';
+      if (this.check('ARROW')) {
+        this.advance();
+        body = this.parseInlineExpression();
+      } else if (this.check('LBRACE')) {
+        body = this.parseCodeBlock();
+      }
+
+      return {
+        type: 'lifecycle' as const,
+        hook: name,
+        params,
+        body,
+      } as any;
+    }
+
+    if (name === 'state') {
+      this.hasState = true;
+      const body = this.parseStateBlock();
+      return { type: 'state' as const, body } as any;
+    }
+
+    if (name === 'for') {
+      this.hasControlFlow = true;
+      const variable = this.expect('IDENTIFIER', 'Expected variable name').value;
+      this.expect('IDENTIFIER', 'Expected "in"');
+      const iterable = this.parseInlineExpression();
+      const body = this.parseControlFlowBody();
+      return { type: 'for' as const, variable, iterable, body } as any;
+    }
+
+    if (name === 'if') {
+      this.hasControlFlow = true;
+      const condition = this.parseInlineExpression();
+      const body = this.parseControlFlowBody();
+      let elseBody: HSPlusNode[] | undefined;
+
+      this.skipNewlines();
+      if (this.check('AT')) {
+        const saved = this.pos;
+        this.advance();
+        if (this.check('IDENTIFIER') && this.current().value === 'else') {
+          this.advance();
+          elseBody = this.parseControlFlowBody();
+        } else {
+          this.pos = saved;
+        }
+      }
+
+      return { type: 'if' as const, condition, body, else: elseBody } as any;
+    }
+
+    if (name === 'import') {
+      if (!this.options.enableTypeScriptImports) {
+        this.warn('@import is disabled');
+        return null;
+      }
+      const path = this.expect('STRING', 'Expected import path').value;
+      let alias = path.split('/').pop()?.replace(/\.[^.]+$/, '') || 'import';
+      if (this.check('IDENTIFIER') && this.current().value === 'as') {
+        this.advance();
+        alias = this.expect('IDENTIFIER', 'Expected alias').value;
+      }
+      this.imports.push({ path, alias });
+      return { type: 'import' as const, path, alias } as any;
+    }
+
+    if (this.options.strict) {
+      this.error(`Unknown directive @${name}`);
+    } else {
+      this.warn(`Unknown directive @${name}`);
+    }
+    return null;
+  }
+
+  private parseTraitConfig(): Record<string, unknown> {
+    const config: Record<string, unknown> = {};
+
+    if (this.check('LPAREN')) {
+      this.advance();
+      while (!this.check('RPAREN') && !this.check('EOF')) {
+        const key = this.expect('IDENTIFIER', 'Expected property name').value;
+        if (this.check('COLON') || this.check('EQUALS')) {
+          this.advance();
+          config[key] = this.parseValue();
+        } else {
+          config[key] = true;
+        }
+        if (this.check('COMMA')) this.advance();
+      }
+      this.expect('RPAREN', 'Expected )');
+    }
+
+    return config;
+  }
+
+  private parseStateBlock(): Record<string, any> {
+    const state: Record<string, any> = {};
+
+    if (this.check('LBRACE')) {
+      this.advance();
+      this.skipNewlines();
+
+      while (!this.check('RBRACE') && !this.check('EOF')) {
+        const key = this.expect('IDENTIFIER', 'Expected state variable name').value;
+        if (this.check('COLON') || this.check('EQUALS')) {
+          this.advance();
+          state[key] = this.parseValue();
+        } else {
+          state[key] = null;
+        }
+        this.skipNewlines();
+      }
+
+      this.expect('RBRACE', 'Expected }');
+    }
+
+    return state;
+  }
+
+  private parseControlFlowBody(): HSPlusNode[] {
+    const nodes: HSPlusNode[] = [];
+
+    if (this.check('LBRACE')) {
+      this.advance();
+      this.skipNewlines();
+
+      while (!this.check('RBRACE') && !this.check('EOF')) {
+        if (this.check('AT')) {
+          const directive = this.parseDirective();
+          if (directive && directive.type === 'for') {
+            nodes.push({
+              type: 'fragment',
+              properties: {},
+              directives: [directive],
+              children: [],
+              traits: new Map(),
+            });
+          }
+        } else if (this.check('IDENTIFIER')) {
+          nodes.push(this.parseNode());
+        }
+        this.skipNewlines();
+      }
+
+      this.expect('RBRACE', 'Expected }');
+    }
+
+    return nodes;
+  }
+
+  private parseCodeBlock(): string {
+    let code = '';
+    let braceDepth = 0;
+
+    if (this.check('LBRACE')) {
+      this.advance();
+      braceDepth = 1;
+
+      while (braceDepth > 0 && !this.check('EOF')) {
+        const token = this.advance();
+        if (token.type === 'LBRACE') {
+          braceDepth++;
+          code += '{';
+        } else if (token.type === 'RBRACE') {
+          braceDepth--;
+          if (braceDepth > 0) {
+            code += '}';
+          }
+        } else {
+          code += token.value;
+          if (token.type === 'NEWLINE') {
+            code += '\n';
+          } else {
+            code += ' ';
+          }
+        }
+      }
+    }
+
+    return code.trim();
+  }
+
+  private parseInlineExpression(): string {
+    let expr = '';
+
+    while (
+      !this.check('NEWLINE') &&
+      !this.check('LBRACE') &&
+      !this.check('EOF')
+    ) {
+      const token = this.advance();
+      expr += token.value + ' ';
+    }
+
+    return expr.trim();
+  }
+
+  private parseValue(): unknown {
+    const token = this.current();
+
+    if (token.type === 'STRING') {
+      this.advance();
+      return token.value;
+    }
+
+    if (token.type === 'NUMBER') {
+      this.advance();
+      const match = token.value.match(/^(-?\d+(?:\.\d+)?(?:e[+-]?\d+)?)(.*)?$/i);
+      if (match) {
+        const num = parseFloat(match[1]);
+        const unit = match[2];
+        if (unit) {
+          return `${num}${unit}`;
+        }
+        return num;
+      }
+      return parseFloat(token.value);
+    }
+
+    if (token.type === 'BOOLEAN') {
+      this.advance();
+      return token.value === 'true';
+    }
+
+    if (token.type === 'NULL') {
+      this.advance();
+      return null;
+    }
+
+    if (token.type === 'EXPRESSION') {
+      this.advance();
+      const exprId = `expr_${this.compiledExpressions.size}`;
+      this.compiledExpressions.set(exprId, token.value);
+      return { __expr: exprId, __raw: token.value };
+    }
+
+    if (token.type === 'LBRACKET') {
+      return this.parseArray();
+    }
+
+    if (token.type === 'LBRACE') {
+      return this.parseObject();
+    }
+
+    if (token.type === 'IDENTIFIER') {
+      this.advance();
+      return { __ref: token.value };
+    }
+
+    return null;
+  }
+
+  private parseArray(): unknown[] {
+    const arr: unknown[] = [];
+    this.expect('LBRACKET', 'Expected [');
+
+    while (!this.check('RBRACKET') && !this.check('EOF')) {
+      arr.push(this.parseValue());
+      if (this.check('COMMA')) this.advance();
+      this.skipNewlines();
+    }
+
+    this.expect('RBRACKET', 'Expected ]');
+    return arr;
+  }
+
+  private parseObject(): Record<string, unknown> {
+    const obj: Record<string, unknown> = {};
+    this.expect('LBRACE', 'Expected {');
+    this.skipNewlines();
+
+    while (!this.check('RBRACE') && !this.check('EOF')) {
+      const key = this.expect('IDENTIFIER', 'Expected property name').value;
+      if (this.check('COLON') || this.check('EQUALS')) {
+        this.advance();
+        obj[key] = this.parseValue();
+      } else {
+        obj[key] = true;
+      }
+      if (this.check('COMMA')) this.advance();
+      this.skipNewlines();
+    }
+
+    this.expect('RBRACE', 'Expected }');
+    return obj;
+  }
+
+  private current(): Token {
+    return this.tokens[this.pos] || { type: 'EOF', value: '', line: 0, column: 0 };
+  }
+
+  private check(type: TokenType): boolean {
+    return this.current().type === type;
+  }
+
+  private advance(): Token {
+    const token = this.current();
+    if (this.pos < this.tokens.length) {
+      this.pos++;
+    }
+    return token;
+  }
+
+  private expect(type: TokenType, message: string): Token {
+    if (!this.check(type)) {
+      this.error(`${message}. Got ${this.current().type} "${this.current().value}"`);
+      return { type, value: '', line: this.current().line, column: this.current().column };
+    }
+    return this.advance();
+  }
+
+  private skipNewlines(): void {
+    while (this.check('NEWLINE') || this.check('INDENT') || this.check('DEDENT')) {
+      this.advance();
+    }
+  }
+
+  private error(message: string): void {
+    const token = this.current();
+    this.errors.push({
+      message,
+      line: token.line,
+      column: token.column,
+    });
+  }
+
+  private warn(message: string): void {
+    const token = this.current();
+    this.warnings.push({
+      message,
+      line: token.line,
+      column: token.column,
+    });
+  }
+}
+
+export function createParser(options?: HSPlusParserOptions): HoloScriptPlusParser {
+  return new HoloScriptPlusParser(options);
+}
+
+export function parse(source: string, options?: HSPlusParserOptions): HSPlusCompileResult {
+  const parser = createParser(options);
+  return parser.parse(source);
+}