@k67/kaitai-struct-ts 0.6.0 → 0.7.0

package/dist/cli.js

@@ -0,0 +1,2776 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/cli.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var import_util = require("util");
+
+// src/utils/errors.ts
+var KaitaiError = class _KaitaiError extends Error {
+  constructor(message, position) {
+    super(message);
+    this.position = position;
+    this.name = "KaitaiError";
+    Object.setPrototypeOf(this, _KaitaiError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends KaitaiError {
+  constructor(message, position) {
+    super(message, position);
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var ParseError = class _ParseError extends KaitaiError {
+  constructor(message, position) {
+    super(message, position);
+    this.name = "ParseError";
+    Object.setPrototypeOf(this, _ParseError.prototype);
+  }
+};
+var EOFError = class _EOFError extends KaitaiError {
+  constructor(message = "Unexpected end of stream", position) {
+    super(message, position);
+    this.name = "EOFError";
+    Object.setPrototypeOf(this, _EOFError.prototype);
+  }
+};
+var NotImplementedError = class _NotImplementedError extends KaitaiError {
+  constructor(feature) {
+    super(`Feature not yet implemented: ${feature}`);
+    this.name = "NotImplementedError";
+    Object.setPrototypeOf(this, _NotImplementedError.prototype);
+  }
+};
+
+// src/utils/encoding.ts
+function decodeString(bytes, encoding) {
+  const normalizedEncoding = encoding.toLowerCase().replace(/[-_]/g, "");
+  switch (normalizedEncoding) {
+    case "utf8":
+    case "utf-8":
+      return decodeUtf8(bytes);
+    case "ascii":
+    case "usascii":
+      return decodeAscii(bytes);
+    case "utf16":
+    case "utf16le":
+    case "utf-16le":
+      return decodeUtf16Le(bytes);
+    case "utf16be":
+    case "utf-16be":
+      return decodeUtf16Be(bytes);
+    case "latin1":
+    case "iso88591":
+    case "iso-8859-1":
+      return decodeLatin1(bytes);
+    default:
+      if (typeof TextDecoder !== "undefined") {
+        try {
+          return new TextDecoder(encoding).decode(bytes);
+        } catch {
+          throw new Error(`Unsupported encoding: ${encoding}`);
+        }
+      }
+      throw new Error(`Unsupported encoding: ${encoding}`);
+  }
+}
+function decodeUtf8(bytes) {
+  if (typeof TextDecoder !== "undefined") {
+    return new TextDecoder("utf-8").decode(bytes);
+  }
+  let result = "";
+  let i = 0;
+  while (i < bytes.length) {
+    const byte1 = bytes[i++];
+    if (byte1 < 128) {
+      result += String.fromCharCode(byte1);
+    } else if (byte1 < 224) {
+      const byte2 = bytes[i++];
+      result += String.fromCharCode((byte1 & 31) << 6 | byte2 & 63);
+    } else if (byte1 < 240) {
+      const byte2 = bytes[i++];
+      const byte3 = bytes[i++];
+      result += String.fromCharCode(
+        (byte1 & 15) << 12 | (byte2 & 63) << 6 | byte3 & 63
+      );
+    } else {
+      const byte2 = bytes[i++];
+      const byte3 = bytes[i++];
+      const byte4 = bytes[i++];
+      let codePoint = (byte1 & 7) << 18 | (byte2 & 63) << 12 | (byte3 & 63) << 6 | byte4 & 63;
+      codePoint -= 65536;
+      result += String.fromCharCode(
+        55296 + (codePoint >> 10),
+        56320 + (codePoint & 1023)
+      );
+    }
+  }
+  return result;
+}
+function decodeAscii(bytes) {
+  let result = "";
+  for (let i = 0; i < bytes.length; i++) {
+    result += String.fromCharCode(bytes[i] & 127);
+  }
+  return result;
+}
+function decodeLatin1(bytes) {
+  let result = "";
+  for (let i = 0; i < bytes.length; i++) {
+    result += String.fromCharCode(bytes[i]);
+  }
+  return result;
+}
+function decodeUtf16Le(bytes) {
+  if (typeof TextDecoder !== "undefined") {
+    return new TextDecoder("utf-16le").decode(bytes);
+  }
+  let result = "";
+  for (let i = 0; i < bytes.length; i += 2) {
+    const charCode = bytes[i] | bytes[i + 1] << 8;
+    result += String.fromCharCode(charCode);
+  }
+  return result;
+}
+function decodeUtf16Be(bytes) {
+  if (typeof TextDecoder !== "undefined") {
+    return new TextDecoder("utf-16be").decode(bytes);
+  }
+  let result = "";
+  for (let i = 0; i < bytes.length; i += 2) {
+    const charCode = bytes[i] << 8 | bytes[i + 1];
+    result += String.fromCharCode(charCode);
+  }
+  return result;
+}
+
+// src/stream/KaitaiStream.ts
+var KaitaiStream = class _KaitaiStream {
+  /**
+   * Create a new KaitaiStream from a buffer
+   * @param buffer - ArrayBuffer or Uint8Array containing the binary data
+   */
+  constructor(buffer) {
+    this._pos = 0;
+    this._bits = 0;
+    this._bitsLeft = 0;
+    if (buffer instanceof ArrayBuffer) {
+      this.buffer = new Uint8Array(buffer);
+      this.view = new DataView(buffer);
+    } else {
+      this.buffer = buffer;
+      this.view = new DataView(
+        buffer.buffer,
+        buffer.byteOffset,
+        buffer.byteLength
+      );
+    }
+  }
+  /**
+   * Current position in the stream
+   */
+  get pos() {
+    return this._pos;
+  }
+  set pos(value) {
+    this._pos = value;
+    this._bitsLeft = 0;
+  }
+  /**
+   * Total size of the stream in bytes
+   */
+  get size() {
+    return this.buffer.length;
+  }
+  /**
+   * Check if we've reached the end of the stream
+   */
+  isEof() {
+    return this._pos >= this.buffer.length;
+  }
+  /**
+   * Seek to a specific position in the stream
+   * @param pos - Position to seek to
+   */
+  seek(pos) {
+    if (pos < 0 || pos > this.buffer.length) {
+      throw new Error(`Invalid seek position: ${pos}`);
+    }
+    this.pos = pos;
+  }
+  /**
+   * Ensure we have enough bytes available
+   * @param count - Number of bytes needed
+   */
+  ensureBytes(count) {
+    if (this._pos + count > this.buffer.length) {
+      throw new EOFError(
+        `Requested ${count} bytes at position ${this._pos}, but only ${this.buffer.length - this._pos} bytes available`,
+        this._pos
+      );
+    }
+  }
+  // ==================== Unsigned Integers ====================
+  /**
+   * Read 1-byte unsigned integer (0 to 255)
+   */
+  readU1() {
+    this.ensureBytes(1);
+    return this.buffer[this._pos++];
+  }
+  /**
+   * Read 2-byte unsigned integer, little-endian
+   */
+  readU2le() {
+    this.ensureBytes(2);
+    const value = this.view.getUint16(this._pos, true);
+    this._pos += 2;
+    return value;
+  }
+  /**
+   * Read 2-byte unsigned integer, big-endian
+   */
+  readU2be() {
+    this.ensureBytes(2);
+    const value = this.view.getUint16(this._pos, false);
+    this._pos += 2;
+    return value;
+  }
+  /**
+   * Read 4-byte unsigned integer, little-endian
+   */
+  readU4le() {
+    this.ensureBytes(4);
+    const value = this.view.getUint32(this._pos, true);
+    this._pos += 4;
+    return value;
+  }
+  /**
+   * Read 4-byte unsigned integer, big-endian
+   */
+  readU4be() {
+    this.ensureBytes(4);
+    const value = this.view.getUint32(this._pos, false);
+    this._pos += 4;
+    return value;
+  }
+  /**
+   * Read 8-byte unsigned integer, little-endian
+   * Returns BigInt for values > Number.MAX_SAFE_INTEGER
+   */
+  readU8le() {
+    this.ensureBytes(8);
+    const value = this.view.getBigUint64(this._pos, true);
+    this._pos += 8;
+    return value;
+  }
+  /**
+   * Read 8-byte unsigned integer, big-endian
+   * Returns BigInt for values > Number.MAX_SAFE_INTEGER
+   */
+  readU8be() {
+    this.ensureBytes(8);
+    const value = this.view.getBigUint64(this._pos, false);
+    this._pos += 8;
+    return value;
+  }
+  // ==================== Signed Integers ====================
+  /**
+   * Read 1-byte signed integer (-128 to 127)
+   */
+  readS1() {
+    this.ensureBytes(1);
+    return this.view.getInt8(this._pos++);
+  }
+  /**
+   * Read 2-byte signed integer, little-endian
+   */
+  readS2le() {
+    this.ensureBytes(2);
+    const value = this.view.getInt16(this._pos, true);
+    this._pos += 2;
+    return value;
+  }
+  /**
+   * Read 2-byte signed integer, big-endian
+   */
+  readS2be() {
+    this.ensureBytes(2);
+    const value = this.view.getInt16(this._pos, false);
+    this._pos += 2;
+    return value;
+  }
+  /**
+   * Read 4-byte signed integer, little-endian
+   */
+  readS4le() {
+    this.ensureBytes(4);
+    const value = this.view.getInt32(this._pos, true);
+    this._pos += 4;
+    return value;
+  }
+  /**
+   * Read 4-byte signed integer, big-endian
+   */
+  readS4be() {
+    this.ensureBytes(4);
+    const value = this.view.getInt32(this._pos, false);
+    this._pos += 4;
+    return value;
+  }
+  /**
+   * Read 8-byte signed integer, little-endian
+   * Returns BigInt for values outside Number.MAX_SAFE_INTEGER range
+   */
+  readS8le() {
+    this.ensureBytes(8);
+    const value = this.view.getBigInt64(this._pos, true);
+    this._pos += 8;
+    return value;
+  }
+  /**
+   * Read 8-byte signed integer, big-endian
+   * Returns BigInt for values outside Number.MAX_SAFE_INTEGER range
+   */
+  readS8be() {
+    this.ensureBytes(8);
+    const value = this.view.getBigInt64(this._pos, false);
+    this._pos += 8;
+    return value;
+  }
+  // ==================== Floating Point ====================
+  /**
+   * Read 4-byte IEEE 754 single-precision float, little-endian
+   */
+  readF4le() {
+    this.ensureBytes(4);
+    const value = this.view.getFloat32(this._pos, true);
+    this._pos += 4;
+    return value;
+  }
+  /**
+   * Read 4-byte IEEE 754 single-precision float, big-endian
+   */
+  readF4be() {
+    this.ensureBytes(4);
+    const value = this.view.getFloat32(this._pos, false);
+    this._pos += 4;
+    return value;
+  }
+  /**
+   * Read 8-byte IEEE 754 double-precision float, little-endian
+   */
+  readF8le() {
+    this.ensureBytes(8);
+    const value = this.view.getFloat64(this._pos, true);
+    this._pos += 8;
+    return value;
+  }
+  /**
+   * Read 8-byte IEEE 754 double-precision float, big-endian
+   */
+  readF8be() {
+    this.ensureBytes(8);
+    const value = this.view.getFloat64(this._pos, false);
+    this._pos += 8;
+    return value;
+  }
+  // ==================== Byte Arrays ====================
+  /**
+   * Read a fixed number of bytes
+   * @param length - Number of bytes to read
+   */
+  readBytes(length) {
+    this.ensureBytes(length);
+    const bytes = this.buffer.slice(this._pos, this._pos + length);
+    this._pos += length;
+    return bytes;
+  }
+  /**
+   * Read all remaining bytes until end of stream
+   */
+  readBytesFull() {
+    const bytes = this.buffer.slice(this._pos);
+    this._pos = this.buffer.length;
+    return bytes;
+  }
+  /**
+   * Read bytes until a terminator byte is found
+   * @param term - Terminator byte value
+   * @param include - Include terminator in result
+   * @param consume - Consume terminator from stream
+   * @param eosError - Throw error if EOS reached before terminator
+   */
+  readBytesterm(term, include = false, consume = true, eosError = true) {
+    const start = this._pos;
+    let end = start;
+    while (end < this.buffer.length && this.buffer[end] !== term) {
+      end++;
+    }
+    const foundTerm = end < this.buffer.length;
+    if (!foundTerm && eosError) {
+      throw new EOFError(
+        `Terminator byte ${term} not found before end of stream`,
+        this._pos
+      );
+    }
+    const includeEnd = include && foundTerm ? end + 1 : end;
+    const bytes = this.buffer.slice(start, includeEnd);
+    if (foundTerm && consume) {
+      this._pos = end + 1;
+    } else {
+      this._pos = end;
+    }
+    return bytes;
+  }
+  // ==================== Strings ====================
+  /**
+   * Read a fixed-length string
+   * @param length - Number of bytes to read
+   * @param encoding - Character encoding (default: UTF-8)
+   */
+  readStr(length, encoding = "UTF-8") {
+    const bytes = this.readBytes(length);
+    return decodeString(bytes, encoding);
+  }
+  /**
+   * Read a null-terminated string
+   * @param encoding - Character encoding (default: UTF-8)
+   * @param term - Terminator byte (default: 0)
+   * @param include - Include terminator in result
+   * @param consume - Consume terminator from stream
+   * @param eosError - Throw error if EOS reached before terminator
+   */
+  readStrz(encoding = "UTF-8", term = 0, include = false, consume = true, eosError = true) {
+    const bytes = this.readBytesterm(term, include, consume, eosError);
+    return decodeString(bytes, encoding);
+  }
+  // ==================== Bit-level Reading ====================
+  /**
+   * Align bit reading to byte boundary
+   */
+  alignToByte() {
+    this._bitsLeft = 0;
+  }
+  /**
+   * Read specified number of bits as unsigned integer (big-endian)
+   * @param n - Number of bits to read (1-64)
+   */
+  readBitsIntBe(n) {
+    if (n < 1 || n > 64) {
+      throw new Error(`Invalid bit count: ${n}. Must be between 1 and 64`);
+    }
+    let result = 0n;
+    for (let bitsNeeded = n; bitsNeeded > 0; ) {
+      if (this._bitsLeft === 0) {
+        this._bits = this.readU1();
+        this._bitsLeft = 8;
+      }
+      const bitsToRead = Math.min(bitsNeeded, this._bitsLeft);
+      const mask = (1 << bitsToRead) - 1;
+      const shift = this._bitsLeft - bitsToRead;
+      result = result << BigInt(bitsToRead) | BigInt(this._bits >> shift & mask);
+      this._bitsLeft -= bitsToRead;
+      bitsNeeded -= bitsToRead;
+    }
+    return result;
+  }
+  /**
+   * Read specified number of bits as unsigned integer (little-endian)
+   * @param n - Number of bits to read (1-64)
+   */
+  readBitsIntLe(n) {
+    if (n < 1 || n > 64) {
+      throw new Error(`Invalid bit count: ${n}. Must be between 1 and 64`);
+    }
+    let result = 0n;
+    let bitPos = 0;
+    for (let bitsNeeded = n; bitsNeeded > 0; ) {
+      if (this._bitsLeft === 0) {
+        this._bits = this.readU1();
+        this._bitsLeft = 8;
+      }
+      const bitsToRead = Math.min(bitsNeeded, this._bitsLeft);
+      const mask = (1 << bitsToRead) - 1;
+      result |= BigInt(this._bits & mask) << BigInt(bitPos);
+      this._bits >>= bitsToRead;
+      this._bitsLeft -= bitsToRead;
+      bitsNeeded -= bitsToRead;
+      bitPos += bitsToRead;
+    }
+    return result;
+  }
+  // ==================== Utility Methods ====================
+  /**
+   * Get the underlying buffer
+   */
+  getBuffer() {
+    return this.buffer;
+  }
+  /**
+   * Create a substream from current position with specified size
+   * @param size - Size of the substream in bytes
+   */
+  substream(size) {
+    this.ensureBytes(size);
+    const subBuffer = this.buffer.slice(this._pos, this._pos + size);
+    this._pos += size;
+    return new _KaitaiStream(subBuffer);
+  }
+};
+
+// src/parser/schema.ts
+var BUILTIN_TYPES = [
+  // Unsigned integers
+  "u1",
+  "u2",
+  "u2le",
+  "u2be",
+  "u4",
+  "u4le",
+  "u4be",
+  "u8",
+  "u8le",
+  "u8be",
+  // Signed integers
+  "s1",
+  "s2",
+  "s2le",
+  "s2be",
+  "s4",
+  "s4le",
+  "s4be",
+  "s8",
+  "s8le",
+  "s8be",
+  // Floating point
+  "f4",
+  "f4le",
+  "f4be",
+  "f8",
+  "f8le",
+  "f8be",
+  // String
+  "str",
+  "strz"
+];
+function isBuiltinType(type) {
+  return BUILTIN_TYPES.includes(type);
+}
+function getTypeEndianness(type) {
+  if (type.endsWith("le")) return "le";
+  if (type.endsWith("be")) return "be";
+  return void 0;
+}
+function getBaseType(type) {
+  if (type.endsWith("le") || type.endsWith("be")) {
+    return type.slice(0, -2);
+  }
+  return type;
+}
+function isIntegerType(type) {
+  const base = getBaseType(type);
+  return /^[us][1248]$/.test(base);
+}
+function isFloatType(type) {
+  const base = getBaseType(type);
+  return /^f[48]$/.test(base);
+}
+function isStringType(type) {
+  return type === "str" || type === "strz";
+}
+
+// src/parser/KsyParser.ts
+var import_yaml = require("yaml");
+var KsyParser = class {
+  /**
+   * Parse a .ksy YAML string into a typed schema object.
+   *
+   * @param yaml - YAML string containing the .ksy definition
+   * @param options - Parsing options
+   * @returns Parsed and validated schema
+   * @throws {ParseError} If YAML parsing fails
+   * @throws {ValidationError} If schema validation fails
+   */
+  parse(yaml, options = {}) {
+    const { validate = true, strict = false } = options;
+    let parsed;
+    try {
+      parsed = (0, import_yaml.parse)(yaml);
+    } catch (error) {
+      throw new ParseError(
+        `Failed to parse YAML: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new ParseError("KSY file must contain an object");
+    }
+    const schema = parsed;
+    if (validate) {
+      const result = this.validate(schema, { strict });
+      if (!result.valid) {
+        const errorMessages = result.errors.map((e) => e.message).join("; ");
+        throw new ValidationError(
+          `Schema validation failed: ${errorMessages}`
+        );
+      }
+      if (result.warnings.length > 0 && !strict) {
+        console.warn(
+          "Schema validation warnings:",
+          result.warnings.map((w) => w.message)
+        );
+      }
+    }
+    return schema;
+  }
+  /**
+   * Validate a schema object.
+   *
+   * @param schema - Schema to validate
+   * @param options - Validation options
+   * @returns Validation result with errors and warnings
+   */
+  validate(schema, options = {}) {
+    const { strict = false, isNested = false } = options;
+    const errors = [];
+    const warnings = [];
+    if (!schema.meta && !isNested) {
+      errors.push({
+        message: 'Missing required "meta" section',
+        path: [],
+        code: "MISSING_META"
+      });
+    } else if (schema.meta) {
+      if (!schema.meta.id) {
+        errors.push({
+          message: 'Missing required "meta.id" field',
+          path: ["meta"],
+          code: "MISSING_META_ID"
+        });
+      } else if (typeof schema.meta.id !== "string") {
+        errors.push({
+          message: '"meta.id" must be a string',
+          path: ["meta", "id"],
+          code: "INVALID_META_ID_TYPE"
+        });
+      } else if (!/^[a-z][a-z0-9_]*$/.test(schema.meta.id)) {
+        warnings.push({
+          message: '"meta.id" should follow snake_case naming convention',
+          path: ["meta", "id"],
+          code: "META_ID_NAMING"
+        });
+      }
+      if (schema.meta.endian) {
+        if (typeof schema.meta.endian === "string" && schema.meta.endian !== "le" && schema.meta.endian !== "be") {
+          errors.push({
+            message: '"meta.endian" must be "le" or "be"',
+            path: ["meta", "endian"],
+            code: "INVALID_ENDIAN"
+          });
+        }
+      }
+    }
+    if (schema.seq) {
+      if (!Array.isArray(schema.seq)) {
+        errors.push({
+          message: '"seq" must be an array',
+          path: ["seq"],
+          code: "INVALID_SEQ_TYPE"
+        });
+      } else {
+        schema.seq.forEach((attr, index) => {
+          this.validateAttribute(
+            attr,
+            ["seq", String(index)],
+            errors,
+            warnings,
+            strict
+          );
+        });
+      }
+    }
+    if (schema.instances) {
+      if (typeof schema.instances !== "object") {
+        errors.push({
+          message: '"instances" must be an object',
+          path: ["instances"],
+          code: "INVALID_INSTANCES_TYPE"
+        });
+      } else {
+        Object.entries(schema.instances).forEach(([key, instance]) => {
+          this.validateAttribute(
+            instance,
+            ["instances", key],
+            errors,
+            warnings,
+            strict
+          );
+        });
+      }
+    }
+    if (schema.types) {
+      if (typeof schema.types !== "object") {
+        errors.push({
+          message: '"types" must be an object',
+          path: ["types"],
+          code: "INVALID_TYPES_TYPE"
+        });
+      } else {
+        Object.entries(schema.types).forEach(([key, type]) => {
+          const typeResult = this.validate(type, { ...options, isNested: true });
+          errors.push(
+            ...typeResult.errors.map((e) => ({
+              ...e,
+              path: ["types", key, ...e.path]
+            }))
+          );
+          warnings.push(
+            ...typeResult.warnings.map((w) => ({
+              ...w,
+              path: ["types", key, ...w.path]
+            }))
+          );
+        });
+      }
+    }
+    if (schema.enums) {
+      if (typeof schema.enums !== "object") {
+        errors.push({
+          message: '"enums" must be an object',
+          path: ["enums"],
+          code: "INVALID_ENUMS_TYPE"
+        });
+      }
+    }
+    return {
+      valid: errors.length === 0 && (strict ? warnings.length === 0 : true),
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Validate an attribute specification.
+   *
+   * @param attr - Attribute to validate
+   * @param path - Path to this attribute in the schema
+   * @param errors - Array to collect errors
+   * @param warnings - Array to collect warnings
+   * @param strict - Whether to be strict about warnings
+   * @private
+   */
+  validateAttribute(attr, path, errors, warnings, _strict) {
+    if (attr.id && typeof attr.id === "string") {
+      if (!/^[a-z][a-z0-9_]*$/.test(attr.id)) {
+        warnings.push({
+          message: `Field "${attr.id}" should follow snake_case naming convention`,
+          path: [...path, "id"],
+          code: "FIELD_ID_NAMING"
+        });
+      }
+    }
+    if (attr.repeat) {
+      if (attr.repeat !== "expr" && attr.repeat !== "eos" && attr.repeat !== "until") {
+        errors.push({
+          message: '"repeat" must be "expr", "eos", or "until"',
+          path: [...path, "repeat"],
+          code: "INVALID_REPEAT"
+        });
+      }
+      if (attr.repeat === "expr" && !attr["repeat-expr"]) {
+        errors.push({
+          message: '"repeat-expr" is required when repeat is "expr"',
+          path: [...path, "repeat-expr"],
+          code: "MISSING_REPEAT_EXPR"
+        });
+      }
+      if (attr.repeat === "until" && !attr["repeat-until"]) {
+        errors.push({
+          message: '"repeat-until" is required when repeat is "until"',
+          path: [...path, "repeat-until"],
+          code: "MISSING_REPEAT_UNTIL"
+        });
+      }
+    }
+    if (attr["size-eos"] && attr.size) {
+      warnings.push({
+        message: '"size-eos" and "size" are mutually exclusive',
+        path: [...path],
+        code: "SIZE_EOS_WITH_SIZE"
+      });
+    }
+    if (attr.contents) {
+      if (!Array.isArray(attr.contents) && typeof attr.contents !== "string") {
+        errors.push({
+          message: '"contents" must be an array or string',
+          path: [...path, "contents"],
+          code: "INVALID_CONTENTS_TYPE"
+        });
+      }
+    }
+  }
+  /**
+   * Parse multiple .ksy files and resolve imports.
+   *
+   * @param mainYaml - Main .ksy file content
+   * @param imports - Map of import names to their YAML content
+   * @param options - Parsing options
+   * @returns Parsed schema with resolved imports
+   */
+  parseWithImports(mainYaml, _imports, options = {}) {
+    const mainSchema = this.parse(mainYaml, options);
+    return mainSchema;
+  }
+};
+
+// src/interpreter/Context.ts
+var Context = class _Context {
+  /**
+   * Create a new execution context.
+   *
+   * @param _io - Binary stream being read
+   * @param _root - Root object of the parse tree
+   * @param _parent - Parent object (optional)
+   * @param enums - Enum definitions from schema (optional)
+   */
+  constructor(_io, _root = null, _parent = null, enums) {
+    this._io = _io;
+    this._root = _root;
+    /** Stack of parent objects */
+    this.parentStack = [];
+    /** Current object being parsed */
+    this._current = {};
+    /** Enum definitions from schema */
+    this._enums = {};
+    if (_parent !== null) {
+      this.parentStack.push(_parent);
+    }
+    if (enums) {
+      this._enums = enums;
+    }
+  }
+  /**
+   * Get the current I/O stream.
+   * Accessible in expressions as `_io`.
+   *
+   * @returns Current stream
+   */
+  get io() {
+    return this._io;
+  }
+  /**
+   * Get the root object.
+   * Accessible in expressions as `_root`.
+   *
+   * @returns Root object
+   */
+  get root() {
+    return this._root;
+  }
+  /**
+   * Get the parent object.
+   * Accessible in expressions as `_parent`.
+   *
+   * @returns Parent object or null if at root
+   */
+  get parent() {
+    return this.parentStack.length > 0 ? this.parentStack[this.parentStack.length - 1] : null;
+  }
+  /**
+   * Get the current object being parsed.
+   * Used to access fields defined earlier in the sequence.
+   *
+   * @returns Current object
+   */
+  get current() {
+    return this._current;
+  }
+  /**
+   * Set the current object.
+   *
+   * @param obj - Object to set as current
+   */
+  set current(obj) {
+    this._current = obj;
+  }
+  /**
+   * Push a new parent onto the stack.
+   * Used when entering a nested type.
+   *
+   * @param parent - Parent object to push
+   */
+  pushParent(parent) {
+    this.parentStack.push(parent);
+  }
+  /**
+   * Pop the current parent from the stack.
+   * Used when exiting a nested type.
+   *
+   * @returns The popped parent object
+   */
+  popParent() {
+    return this.parentStack.pop();
+  }
+  /**
+   * Get a value from the context by path.
+   * Supports special names: _io, _root, _parent, _index.
+   *
+   * @param name - Name or path to resolve
+   * @returns Resolved value
+   */
+  resolve(name) {
+    switch (name) {
+      case "_io":
+        return this._io;
+      case "_root":
+        return this._root;
+      case "_parent":
+        return this.parent;
+      case "_index":
+        return this._current["_index"];
+      default:
+        if (name in this._current) {
+          return this._current[name];
+        }
+        return void 0;
+    }
+  }
+  /**
+   * Set a value in the current object.
+   *
+   * @param name - Field name
+   * @param value - Value to set
+   */
+  set(name, value) {
+    this._current[name] = value;
+  }
+  /**
+   * Get enum value by name.
+   * Used for enum access in expressions (EnumName::value).
+   *
+   * @param enumName - Name of the enum
+   * @param valueName - Name of the enum value
+   * @returns Enum value (number) or undefined
+   */
+  getEnumValue(enumName, valueName) {
+    const enumDef = this._enums[enumName];
+    if (!enumDef) {
+      return void 0;
+    }
+    for (const [key, value] of Object.entries(enumDef)) {
+      if (value === valueName) {
+        const numKey = Number(key);
+        return isNaN(numKey) ? key : numKey;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Check if an enum exists.
+   *
+   * @param enumName - Name of the enum
+   * @returns True if enum exists
+   */
+  hasEnum(enumName) {
+    return enumName in this._enums;
+  }
+  /**
+   * Create a child context for nested parsing.
+   * The current object becomes the parent in the child context.
+   *
+   * @param stream - Stream for the child context (defaults to current stream)
+   * @returns New child context
+   */
+  createChild(stream) {
+    const childContext = new _Context(
+      stream || this._io,
+      this._root || this._current,
+      this._current,
+      this._enums
+    );
+    return childContext;
+  }
+  /**
+   * Clone this context.
+   * Creates a shallow copy with the same stream, root, and parent.
+   *
+   * @returns Cloned context
+   */
+  clone() {
+    const cloned = new _Context(this._io, this._root, this.parent, this._enums);
+    cloned._current = { ...this._current };
+    cloned.parentStack = [...this.parentStack];
+    return cloned;
+  }
+};
+
+// src/expression/Token.ts
+function createToken(type, value = null, position = 0) {
+  return { type, value, position };
+}
+
+// src/expression/Lexer.ts
+var Lexer = class {
+  /**
+   * Create a new lexer.
+   *
+   * @param input - Expression string to tokenize
+   */
+  constructor(input) {
+    this.position = 0;
+    this.current = null;
+    this.input = input;
+    this.current = input.length > 0 ? input[0] : null;
+  }
+  /**
+   * Tokenize the entire input string.
+   *
+   * @returns Array of tokens
+   * @throws {ParseError} If invalid syntax is encountered
+   */
+  tokenize() {
+    const tokens = [];
+    while (this.current !== null) {
+      if (this.isWhitespace(this.current)) {
+        this.skipWhitespace();
+        continue;
+      }
+      if (this.isDigit(this.current)) {
+        tokens.push(this.readNumber());
+        continue;
+      }
+      if (this.isIdentifierStart(this.current)) {
+        tokens.push(this.readIdentifierOrKeyword());
+        continue;
+      }
+      if (this.current === '"' || this.current === "'") {
+        tokens.push(this.readString());
+        continue;
+      }
+      const token = this.readOperator();
+      if (token) {
+        tokens.push(token);
+        continue;
+      }
+      throw new ParseError(
+        `Unexpected character: ${this.current}`,
+        this.position
+      );
+    }
+    tokens.push(createToken("EOF" /* EOF */, null, this.position));
+    return tokens;
+  }
+  /**
+   * Advance to the next character.
+   * @private
+   */
+  advance() {
+    this.position++;
+    this.current = this.position < this.input.length ? this.input[this.position] : null;
+  }
+  /**
+   * Peek at the next character without advancing.
+   * @private
+   */
+  peek(offset = 1) {
+    const pos = this.position + offset;
+    return pos < this.input.length ? this.input[pos] : null;
+  }
+  /**
+   * Check if character is whitespace.
+   * @private
+   */
+  isWhitespace(char) {
+    return /\s/.test(char);
+  }
+  /**
+   * Check if character is a digit.
+   * @private
+   */
+  isDigit(char) {
+    return /[0-9]/.test(char);
+  }
+  /**
+   * Check if character can start an identifier.
+   * @private
+   */
+  isIdentifierStart(char) {
+    return /[a-zA-Z_]/.test(char);
+  }
+  /**
+   * Check if character can be part of an identifier.
+   * @private
+   */
+  isIdentifierPart(char) {
+    return /[a-zA-Z0-9_]/.test(char);
+  }
+  /**
+   * Skip whitespace characters.
+   * @private
+   */
+  skipWhitespace() {
+    while (this.current !== null && this.isWhitespace(this.current)) {
+      this.advance();
+    }
+  }
+  /**
+   * Read a number token.
+   * @private
+   */
+  readNumber() {
+    const start = this.position;
+    let value = "";
+    if (this.current === "0" && this.peek() === "x") {
+      value += this.current;
+      this.advance();
+      value += this.current;
+      this.advance();
+      while (this.current !== null && /[0-9a-fA-F]/.test(this.current)) {
+        value += this.current;
+        this.advance();
+      }
+      return createToken("NUMBER" /* NUMBER */, parseInt(value, 16), start);
+    }
+    while (this.current !== null && this.isDigit(this.current)) {
+      value += this.current;
+      this.advance();
+    }
+    if (this.current === "." && this.peek() && this.isDigit(this.peek())) {
+      value += this.current;
+      this.advance();
+      while (this.current !== null && this.isDigit(this.current)) {
+        value += this.current;
+        this.advance();
+      }
+      return createToken("NUMBER" /* NUMBER */, parseFloat(value), start);
+    }
+    return createToken("NUMBER" /* NUMBER */, parseInt(value, 10), start);
+  }
+  /**
+   * Read an identifier or keyword token.
+   * @private
+   */
+  readIdentifierOrKeyword() {
+    const start = this.position;
+    let value = "";
+    while (this.current !== null && this.isIdentifierPart(this.current)) {
+      value += this.current;
+      this.advance();
+    }
+    switch (value) {
+      case "true":
+        return createToken("BOOLEAN" /* BOOLEAN */, true, start);
+      case "false":
+        return createToken("BOOLEAN" /* BOOLEAN */, false, start);
+      case "and":
+        return createToken("AND" /* AND */, value, start);
+      case "or":
+        return createToken("OR" /* OR */, value, start);
+      case "not":
+        return createToken("NOT" /* NOT */, value, start);
+      default:
+        return createToken("IDENTIFIER" /* IDENTIFIER */, value, start);
+    }
+  }
+  /**
+   * Read a string token.
+   * @private
+   */
+  readString() {
+    const start = this.position;
+    const quote = this.current;
+    let value = "";
+    this.advance();
+    while (this.current !== null && this.current !== quote) {
+      if (this.current === "\\") {
+        this.advance();
+        if (this.current === null) {
+          throw new ParseError("Unterminated string", start);
+        }
+        const ch = this.current;
+        if (ch === "n") {
+          value += "\n";
+        } else if (ch === "t") {
+          value += "	";
+        } else if (ch === "r") {
+          value += "\r";
+        } else if (ch === "\\") {
+          value += "\\";
+        } else if (ch === '"') {
+          value += '"';
+        } else if (ch === "'") {
+          value += "'";
+        } else {
+          value += ch;
+        }
+      } else {
+        value += this.current;
+      }
+      this.advance();
+    }
+    if (this.current === null) {
+      throw new ParseError("Unterminated string", start);
+    }
+    this.advance();
+    return createToken("STRING" /* STRING */, value, start);
+  }
+  /**
+   * Read an operator or punctuation token.
+   * @private
+   */
+  readOperator() {
+    const start = this.position;
+    const char = this.current;
+    switch (char) {
+      case "+":
+        this.advance();
+        return createToken("PLUS" /* PLUS */, char, start);
+      case "-":
+        this.advance();
+        return createToken("MINUS" /* MINUS */, char, start);
+      case "*":
+        this.advance();
+        return createToken("STAR" /* STAR */, char, start);
+      case "/":
+        this.advance();
+        return createToken("SLASH" /* SLASH */, char, start);
+      case "%":
+        this.advance();
+        return createToken("PERCENT" /* PERCENT */, char, start);
+      case "<":
+        this.advance();
+        if (this.current === "=") {
+          this.advance();
+          return createToken("LE" /* LE */, "<=", start);
+        } else if (this.current === "<") {
+          this.advance();
+          return createToken("LSHIFT" /* LSHIFT */, "<<", start);
+        }
+        return createToken("LT" /* LT */, "<", start);
+      case ">":
+        this.advance();
+        if (this.current === "=") {
+          this.advance();
+          return createToken("GE" /* GE */, ">=", start);
+        } else if (this.current === ">") {
+          this.advance();
+          return createToken("RSHIFT" /* RSHIFT */, ">>", start);
+        }
+        return createToken("GT" /* GT */, ">", start);
+      case "=":
+        this.advance();
+        if (this.current === "=") {
+          this.advance();
+          return createToken("EQ" /* EQ */, "==", start);
+        }
+        throw new ParseError("Expected == for equality", start);
+      case "!":
+        this.advance();
+        if (this.current === "=") {
+          this.advance();
+          return createToken("NE" /* NE */, "!=", start);
+        }
+        throw new ParseError("Expected != for inequality", start);
+      case "&":
+        this.advance();
+        return createToken("AMPERSAND" /* AMPERSAND */, char, start);
+      case "|":
+        this.advance();
+        return createToken("PIPE" /* PIPE */, char, start);
+      case "^":
+        this.advance();
+        return createToken("CARET" /* CARET */, char, start);
+      case "?":
+        this.advance();
+        return createToken("QUESTION" /* QUESTION */, char, start);
+      case ":":
+        this.advance();
+        if (this.current === ":") {
+          this.advance();
+          return createToken("DOUBLE_COLON" /* DOUBLE_COLON */, "::", start);
+        }
+        return createToken("COLON" /* COLON */, char, start);
+      case "(":
+        this.advance();
+        return createToken("LPAREN" /* LPAREN */, char, start);
+      case ")":
+        this.advance();
+        return createToken("RPAREN" /* RPAREN */, char, start);
+      case "[":
+        this.advance();
+        return createToken("LBRACKET" /* LBRACKET */, char, start);
+      case "]":
+        this.advance();
+        return createToken("RBRACKET" /* RBRACKET */, char, start);
+      case ".":
+        this.advance();
+        return createToken("DOT" /* DOT */, char, start);
+      case ",":
+        this.advance();
+        return createToken("COMMA" /* COMMA */, char, start);
+      default:
+        return null;
+    }
+  }
+};
+
+// src/expression/AST.ts
+function createLiteral(value) {
+  return { kind: "Literal", value };
+}
+function createIdentifier(name) {
+  return { kind: "Identifier", name };
+}
+function createBinaryOp(operator, left, right) {
+  return { kind: "BinaryOp", operator, left, right };
+}
+function createUnaryOp(operator, operand) {
+  return { kind: "UnaryOp", operator, operand };
+}
+function createTernary(condition, ifTrue, ifFalse) {
+  return { kind: "Ternary", condition, ifTrue, ifFalse };
+}
+function createMemberAccess(object, property) {
+  return { kind: "MemberAccess", object, property };
+}
+function createIndexAccess(object, index) {
+  return { kind: "IndexAccess", object, index };
+}
+function createMethodCall(object, method, args) {
+  return { kind: "MethodCall", object, method, args };
+}
+function createEnumAccess(enumName, value) {
+  return { kind: "EnumAccess", enumName, value };
+}
+
+// src/expression/Parser.ts
+var ExpressionParser = class {
+  /**
+   * Create a new expression parser.
+   *
+   * @param tokens - Array of tokens to parse
+   */
+  constructor(tokens) {
+    this.position = 0;
+    this.tokens = tokens;
+  }
+  /**
+   * Parse the tokens into an AST.
+   *
+   * @returns Root AST node
+   * @throws {ParseError} If invalid syntax is encountered
+   */
+  parse() {
+    const expr = this.parseTernary();
+    if (!this.isAtEnd()) {
+      throw new ParseError(
+        `Unexpected token: ${this.current().type}`,
+        this.current().position
+      );
+    }
+    return expr;
+  }
+  /**
+   * Get the current token.
+   * @private
+   */
+  current() {
+    return this.tokens[this.position];
+  }
+  /**
+   * Check if we're at the end of tokens.
+   * @private
+   */
+  isAtEnd() {
+    return this.current().type === "EOF" /* EOF */;
+  }
+  /**
+   * Advance to the next token.
+   * @private
+   */
+  advance() {
+    if (!this.isAtEnd()) {
+      this.position++;
+    }
+    return this.tokens[this.position - 1];
+  }
+  /**
+   * Check if current token matches any of the given types.
+   * @private
+   */
+  match(...types) {
+    for (const type of types) {
+      if (this.current().type === type) {
+        this.advance();
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Expect a specific token type and advance.
+   * @private
+   */
+  expect(type, message) {
+    if (this.current().type !== type) {
+      throw new ParseError(message, this.current().position);
+    }
+    return this.advance();
+  }
+  /**
+   * Parse ternary conditional (lowest precedence).
+   * condition ? ifTrue : ifFalse
+   * @private
+   */
+  parseTernary() {
+    let expr = this.parseLogicalOr();
+    if (this.match("QUESTION" /* QUESTION */)) {
+      const ifTrue = this.parseTernary();
+      this.expect("COLON" /* COLON */, "Expected : in ternary expression");
+      const ifFalse = this.parseTernary();
+      return createTernary(expr, ifTrue, ifFalse);
+    }
+    return expr;
+  }
+  /**
+   * Parse logical OR.
+   * @private
+   */
+  parseLogicalOr() {
+    let left = this.parseLogicalAnd();
+    while (this.match("OR" /* OR */)) {
+      const operator = "or";
+      const right = this.parseLogicalAnd();
+      left = createBinaryOp(operator, left, right);
+    }
+    return left;
+  }
+  /**
+   * Parse logical AND.
+   * @private
+   */
+  parseLogicalAnd() {
+    let left = this.parseBitwiseOr();
+    while (this.match("AND" /* AND */)) {
+      const operator = "and";
+      const right = this.parseBitwiseOr();
+      left = createBinaryOp(operator, left, right);
+    }
+    return left;
+  }
+  /**
+   * Parse bitwise OR.
+   * @private
+   */
+  parseBitwiseOr() {
+    let left = this.parseBitwiseXor();
+    while (this.match("PIPE" /* PIPE */)) {
+      const operator = "|";
+      const right = this.parseBitwiseXor();
+      left = createBinaryOp(operator, left, right);
+    }
+    return left;
+  }
+  /**
+   * Parse bitwise XOR.
+   * @private
+   */
+  parseBitwiseXor() {
+    let left = this.parseBitwiseAnd();
+    while (this.match("CARET" /* CARET */)) {
+      const operator = "^";
+      const right = this.parseBitwiseAnd();
+      left = createBinaryOp(operator, left, right);
+    }
+    return left;
+  }
+  /**
+   * Parse bitwise AND.
+   * @private
+   */
+  parseBitwiseAnd() {
+    let left = this.parseEquality();
+    while (this.match("AMPERSAND" /* AMPERSAND */)) {
+      const operator = "&";
+      const right = this.parseEquality();
+      left = createBinaryOp(operator, left, right);
+    }
+    return left;
+  }
+  /**
+   * Parse equality operators (==, !=).
+   * @private
+   */
+  parseEquality() {
+    let left = this.parseRelational();
+    while (this.match("EQ" /* EQ */, "NE" /* NE */)) {
+      const operator = this.tokens[this.position - 1].value;
+      const right = this.parseRelational();
+      left = createBinaryOp(operator, left, right);
+    }
+    return left;
+  }
+  /**
+   * Parse relational operators (<, <=, >, >=).
+   * @private
+   */
+  parseRelational() {
+    let left = this.parseBitShift();
+    while (this.match("LT" /* LT */, "LE" /* LE */, "GT" /* GT */, "GE" /* GE */)) {
+      const operator = this.tokens[this.position - 1].value;
+      const right = this.parseBitShift();
+      left = createBinaryOp(operator, left, right);
+    }
+    return left;
+  }
+  /**
+   * Parse bit shift operators (<<, >>).
+   * @private
+   */
+  parseBitShift() {
+    let left = this.parseAdditive();
+    while (this.match("LSHIFT" /* LSHIFT */, "RSHIFT" /* RSHIFT */)) {
+      const operator = this.tokens[this.position - 1].value;
+      const right = this.parseAdditive();
+      left = createBinaryOp(operator, left, right);
+    }
+    return left;
+  }
+  /**
+   * Parse additive operators (+, -).
+   * @private
+   */
+  parseAdditive() {
+    let left = this.parseMultiplicative();
+    while (this.match("PLUS" /* PLUS */, "MINUS" /* MINUS */)) {
+      const operator = this.tokens[this.position - 1].value;
+      const right = this.parseMultiplicative();
+      left = createBinaryOp(operator, left, right);
+    }
+    return left;
+  }
+  /**
+   * Parse multiplicative operators (*, /, %).
+   * @private
+   */
+  parseMultiplicative() {
+    let left = this.parseUnary();
+    while (this.match("STAR" /* STAR */, "SLASH" /* SLASH */, "PERCENT" /* PERCENT */)) {
+      const operator = this.tokens[this.position - 1].value;
+      const right = this.parseUnary();
+      left = createBinaryOp(operator, left, right);
+    }
+    return left;
+  }
+  /**
+   * Parse unary operators (-, not).
+   * @private
+   */
+  parseUnary() {
+    if (this.match("MINUS" /* MINUS */, "NOT" /* NOT */)) {
+      const operator = this.tokens[this.position - 1].value;
+      const operand = this.parseUnary();
+      return createUnaryOp(operator, operand);
+    }
+    return this.parsePostfix();
+  }
+  /**
+   * Parse postfix operators (., [], ()).
+   * @private
+   */
+  parsePostfix() {
+    let expr = this.parsePrimary();
+    while (true) {
+      if (this.match("DOT" /* DOT */)) {
+        const property = this.expect(
+          "IDENTIFIER" /* IDENTIFIER */,
+          "Expected property name after ."
+        );
+        expr = createMemberAccess(expr, property.value);
+      } else if (this.match("LBRACKET" /* LBRACKET */)) {
+        const index = this.parseTernary();
+        this.expect("RBRACKET" /* RBRACKET */, "Expected ] after array index");
+        expr = createIndexAccess(expr, index);
+      } else if (this.current().type === "LPAREN" /* LPAREN */) {
+        if (expr.kind === "MemberAccess") {
+          this.advance();
+          const args = [];
+          if (this.current().type !== "RPAREN" /* RPAREN */) {
+            args.push(this.parseTernary());
+            while (this.match("COMMA" /* COMMA */)) {
+              args.push(this.parseTernary());
+            }
+          }
+          this.expect("RPAREN" /* RPAREN */, "Expected ) after arguments");
+          const memberExpr = expr;
+          expr = createMethodCall(memberExpr.object, memberExpr.property, args);
+        } else {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    return expr;
+  }
+  /**
+   * Parse primary expressions (literals, identifiers, grouping).
+   * @private
+   */
+  parsePrimary() {
+    if (this.match("NUMBER" /* NUMBER */, "STRING" /* STRING */, "BOOLEAN" /* BOOLEAN */)) {
+      const token = this.tokens[this.position - 1];
+      return createLiteral(token.value);
+    }
+    if (this.match("IDENTIFIER" /* IDENTIFIER */)) {
+      const name = this.tokens[this.position - 1].value;
+      if (this.match("DOUBLE_COLON" /* DOUBLE_COLON */)) {
+        const value = this.expect(
+          "IDENTIFIER" /* IDENTIFIER */,
+          "Expected enum value after ::"
+        );
+        return createEnumAccess(name, value.value);
+      }
+      return createIdentifier(name);
+    }
+    if (this.match("LPAREN" /* LPAREN */)) {
+      const expr = this.parseTernary();
+      this.expect("RPAREN" /* RPAREN */, "Expected ) after expression");
+      return expr;
+    }
+    throw new ParseError(
+      `Unexpected token: ${this.current().type}`,
+      this.current().position
+    );
+  }
+};
+
+// src/expression/Evaluator.ts
+var Evaluator = class {
+  /**
+   * Evaluate an AST node in the given context.
+   *
+   * @param node - AST node to evaluate
+   * @param context - Execution context
+   * @returns Evaluated value
+   * @throws {ParseError} If evaluation fails
+   */
+  evaluate(node, context) {
+    const n = node;
+    switch (node.kind) {
+      case "Literal":
+        return n.value;
+      case "Identifier":
+        return this.evaluateIdentifier(n.name, context);
+      case "BinaryOp":
+        return this.evaluateBinaryOp(n.operator, n.left, n.right, context);
+      case "UnaryOp":
+        return this.evaluateUnaryOp(n.operator, n.operand, context);
+      case "Ternary":
+        return this.evaluateTernary(n.condition, n.ifTrue, n.ifFalse, context);
+      case "MemberAccess":
+        return this.evaluateMemberAccess(n.object, n.property, context);
+      case "IndexAccess":
+        return this.evaluateIndexAccess(n.object, n.index, context);
+      case "MethodCall":
+        return this.evaluateMethodCall(n.object, n.method, n.args, context);
+      case "EnumAccess":
+        return this.evaluateEnumAccess(n.enumName, n.value, context);
+      default:
+        throw new ParseError(`Unknown AST node kind: ${node.kind}`);
+    }
+  }
+  /**
+   * Evaluate an identifier.
+   * @private
+   */
+  evaluateIdentifier(name, context) {
+    return context.resolve(name);
+  }
+  /**
+   * Evaluate a binary operation.
+   * @private
+   */
+  evaluateBinaryOp(operator, left, right, context) {
+    const leftVal = this.evaluate(left, context);
+    const rightVal = this.evaluate(right, context);
+    switch (operator) {
+      // Arithmetic
+      case "+":
+        return this.add(leftVal, rightVal);
+      case "-":
+        return this.toNumber(leftVal) - this.toNumber(rightVal);
+      case "*":
+        return this.toNumber(leftVal) * this.toNumber(rightVal);
+      case "/":
+        return this.toNumber(leftVal) / this.toNumber(rightVal);
+      case "%":
+        return this.modulo(this.toNumber(leftVal), this.toNumber(rightVal));
+      // Comparison
+      case "<":
+        return this.compare(leftVal, rightVal) < 0;
+      case "<=":
+        return this.compare(leftVal, rightVal) <= 0;
+      case ">":
+        return this.compare(leftVal, rightVal) > 0;
+      case ">=":
+        return this.compare(leftVal, rightVal) >= 0;
+      case "==":
+        return this.equals(leftVal, rightVal);
+      case "!=":
+        return !this.equals(leftVal, rightVal);
+      // Bitwise
+      case "<<":
+        return this.toInt(leftVal) << this.toInt(rightVal);
+      case ">>":
+        return this.toInt(leftVal) >> this.toInt(rightVal);
+      case "&":
+        return this.toInt(leftVal) & this.toInt(rightVal);
+      case "|":
+        return this.toInt(leftVal) | this.toInt(rightVal);
+      case "^":
+        return this.toInt(leftVal) ^ this.toInt(rightVal);
+      // Logical
+      case "and":
+        return this.toBoolean(leftVal) && this.toBoolean(rightVal);
+      case "or":
+        return this.toBoolean(leftVal) || this.toBoolean(rightVal);
+      default:
+        throw new ParseError(`Unknown binary operator: ${operator}`);
+    }
+  }
+  /**
+   * Evaluate a unary operation.
+   * @private
+   */
+  evaluateUnaryOp(operator, operand, context) {
+    const value = this.evaluate(operand, context);
+    switch (operator) {
+      case "-":
+        return -this.toNumber(value);
+      case "not":
+        return !this.toBoolean(value);
+      default:
+        throw new ParseError(`Unknown unary operator: ${operator}`);
+    }
+  }
+  /**
+   * Evaluate a ternary conditional.
+   * @private
+   */
+  evaluateTernary(condition, ifTrue, ifFalse, context) {
+    const condValue = this.evaluate(condition, context);
+    return this.toBoolean(condValue) ? this.evaluate(ifTrue, context) : this.evaluate(ifFalse, context);
+  }
+  /**
+   * Evaluate member access (object.property).
+   * @private
+   */
+  evaluateMemberAccess(object, property, context) {
+    const obj = this.evaluate(object, context);
+    if (obj === null || obj === void 0) {
+      throw new ParseError(
+        `Cannot access property ${property} of null/undefined`
+      );
+    }
+    if (typeof obj === "object") {
+      return obj[property];
+    }
+    throw new ParseError(`Cannot access property ${property} of non-object`);
+  }
+  /**
+   * Evaluate index access (array[index]).
+   * @private
+   */
+  evaluateIndexAccess(object, index, context) {
+    const obj = this.evaluate(object, context);
+    const idx = this.evaluate(index, context);
+    if (Array.isArray(obj)) {
+      const numIdx = this.toInt(idx);
+      return obj[numIdx];
+    }
+    if (obj instanceof Uint8Array) {
+      const numIdx = this.toInt(idx);
+      return obj[numIdx];
+    }
+    throw new ParseError("Index access requires an array");
+  }
+  /**
+   * Evaluate method call (object.method()).
+   * @private
+   */
+  evaluateMethodCall(object, method, _args, context) {
+    const obj = this.evaluate(object, context);
+    if (method === "length" || method === "size") {
+      if (Array.isArray(obj)) return obj.length;
+      if (obj instanceof Uint8Array) return obj.length;
+      if (typeof obj === "string") return obj.length;
+      throw new ParseError(`Object does not have a ${method} property`);
+    }
+    if (method === "to_i") {
+      return this.toInt(obj);
+    }
+    if (method === "to_s") {
+      return String(obj);
+    }
+    throw new ParseError(`Unknown method: ${method}`);
+  }
+  /**
+   * Evaluate enum access (EnumName::value).
+   * @private
+   */
+  evaluateEnumAccess(enumName, valueName, context) {
+    const value = context.getEnumValue(enumName, valueName);
+    if (value === void 0) {
+      throw new ParseError(`Enum value "${enumName}::${valueName}" not found`);
+    }
+    return value;
+  }
+  /**
+   * Helper: Add two values (handles strings and numbers).
+   * @private
+   */
+  add(left, right) {
+    if (typeof left === "string" || typeof right === "string") {
+      return String(left) + String(right);
+    }
+    return this.toNumber(left) + this.toNumber(right);
+  }
+  /**
+   * Helper: Modulo operation (Kaitai-style, not remainder).
+   * @private
+   */
+  modulo(a, b) {
+    const result = a % b;
+    return result < 0 ? result + b : result;
+  }
+  /**
+   * Helper: Compare two values.
+   * @private
+   */
+  compare(left, right) {
+    if (typeof left === "string" && typeof right === "string") {
+      return left < right ? -1 : left > right ? 1 : 0;
+    }
+    const leftNum = this.toNumber(left);
+    const rightNum = this.toNumber(right);
+    return leftNum < rightNum ? -1 : leftNum > rightNum ? 1 : 0;
+  }
+  /**
+   * Helper: Check equality.
+   * @private
+   */
+  equals(left, right) {
+    if (typeof left === "bigint" || typeof right === "bigint") {
+      return BigInt(left) === BigInt(right);
+    }
+    return left === right;
+  }
+  /**
+   * Helper: Convert to number.
+   * @private
+   */
+  toNumber(value) {
+    if (typeof value === "number") return value;
+    if (typeof value === "bigint") return Number(value);
+    if (typeof value === "boolean") return value ? 1 : 0;
+    if (typeof value === "string") return parseFloat(value);
+    throw new ParseError(`Cannot convert ${typeof value} to number`);
+  }
+  /**
+   * Helper: Convert to integer.
+   * @private
+   */
+  toInt(value) {
+    return Math.floor(this.toNumber(value));
+  }
+  /**
+   * Helper: Convert to boolean.
+   * @private
+   */
+  toBoolean(value) {
+    if (typeof value === "boolean") return value;
+    if (typeof value === "number") return value !== 0;
+    if (typeof value === "bigint") return value !== 0n;
+    if (typeof value === "string") return value.length > 0;
+    if (value === null || value === void 0) return false;
+    return true;
+  }
+};
+
+// src/expression/index.ts
+function evaluateExpression(expression, context) {
+  const lexer = new Lexer(expression);
+  const tokens = lexer.tokenize();
+  const parser = new ExpressionParser(tokens);
+  const ast = parser.parse();
+  const evaluator = new Evaluator();
+  return evaluator.evaluate(ast, context);
+}
+
+// src/interpreter/TypeInterpreter.ts
+var TypeInterpreter = class _TypeInterpreter {
+  /**
+   * Create a new type interpreter.
+   *
+   * @param schema - Kaitai Struct schema to interpret
+   * @param parentMeta - Parent schema's meta (for nested types)
+   */
+  constructor(schema, parentMeta) {
+    this.schema = schema;
+    this.parentMeta = parentMeta;
+    if (!schema.meta && !parentMeta) {
+      throw new ParseError("Schema must have meta section");
+    }
+    if (schema.meta && !schema.meta.id && !parentMeta) {
+      throw new ParseError("Root schema must have meta.id");
+    }
+  }
+  /**
+   * Parse binary data according to the schema.
+   *
+   * @param stream - Binary stream to parse
+   * @param parent - Parent object (for nested types)
+   * @param typeArgs - Arguments for parametric types
+   * @returns Parsed object
+   */
+  parse(stream, parent, typeArgs) {
+    const result = {};
+    const context = new Context(stream, result, parent, this.schema.enums);
+    context.current = result;
+    if (typeArgs && this.schema.params) {
+      for (let i = 0; i < this.schema.params.length && i < typeArgs.length; i++) {
+        const param = this.schema.params[i];
+        const argValue = typeArgs[i];
+        const evaluatedArg = typeof argValue === "string" ? this.evaluateValue(argValue, context) : argValue;
+        context.set(param.id, evaluatedArg);
+      }
+    }
+    if (this.schema.seq) {
+      for (const attr of this.schema.seq) {
+        const value = this.parseAttribute(attr, context);
+        if (attr.id) {
+          result[attr.id] = value;
+        }
+      }
+    }
+    if (this.schema.instances) {
+      this.setupInstances(result, stream, context);
+    }
+    return result;
+  }
+  /**
+   * Set up lazy-evaluated instance getters.
+   * Instances are computed on first access and cached.
+   *
+   * @param result - Result object to add getters to
+   * @param stream - Stream for parsing
+   * @param context - Execution context
+   * @private
+   */
+  setupInstances(result, stream, context) {
+    if (!this.schema.instances) return;
+    for (const [name, instance] of Object.entries(this.schema.instances)) {
+      let cached = void 0;
+      let evaluated = false;
+      Object.defineProperty(result, name, {
+        get: () => {
+          if (!evaluated) {
+            cached = this.parseInstance(
+              instance,
+              stream,
+              context
+            );
+            evaluated = true;
+          }
+          return cached;
+        },
+        enumerable: true,
+        configurable: true
+      });
+    }
+  }
+  /**
+   * Parse an instance (lazy-evaluated field).
+   *
+   * @param instance - Instance specification
+   * @param stream - Stream to read from
+   * @param context - Execution context
+   * @returns Parsed or calculated value
+   * @private
+   */
+  parseInstance(instance, stream, context) {
+    if ("value" in instance) {
+      return this.evaluateValue(
+        instance.value,
+        context
+      );
+    }
+    const savedPos = stream.pos;
+    try {
+      if (instance.pos !== void 0) {
+        const pos = this.evaluateValue(
+          instance.pos,
+          context
+        );
+        if (typeof pos === "number") {
+          stream.seek(pos);
+        } else if (typeof pos === "bigint") {
+          stream.seek(Number(pos));
+        } else {
+          throw new ParseError(
+            `pos must evaluate to a number, got ${typeof pos}`
+          );
+        }
+      }
+      const value = this.parseAttribute(instance, context);
+      return value;
+    } finally {
+      if (instance.pos !== void 0) {
+        stream.seek(savedPos);
+      }
+    }
+  }
+  /**
+   * Parse a single attribute according to its specification.
+   *
+   * @param attr - Attribute specification
+   * @param context - Execution context
+   * @returns Parsed value
+   * @private
+   */
+  parseAttribute(attr, context) {
+    const stream = context.io;
+    if (attr.if) {
+      const condition = this.evaluateValue(attr.if, context);
+      if (!condition) {
+        return void 0;
+      }
+    }
+    if (attr.pos !== void 0) {
+      const pos = this.evaluateValue(attr.pos, context);
+      if (typeof pos === "number") {
+        stream.seek(pos);
+      } else if (typeof pos === "bigint") {
+        stream.seek(Number(pos));
+      } else {
+        throw new ParseError(`pos must evaluate to a number, got ${typeof pos}`);
+      }
+    }
+    if (attr.io) {
+      throw new NotImplementedError("Custom I/O streams");
+    }
+    if (attr.repeat) {
+      return this.parseRepeated(attr, context);
+    }
+    if (attr.contents) {
+      return this.parseContents(attr, context);
+    }
+    const value = this.parseValue(attr, context);
+    return value;
+  }
+  /**
+   * Parse a repeated attribute.
+   *
+   * @param attr - Attribute specification with repeat
+   * @param context - Execution context
+   * @returns Array of parsed values
+   * @private
+   */
+  parseRepeated(attr, context) {
+    const stream = context.io;
+    const result = [];
+    switch (attr.repeat) {
+      case "expr": {
+        const countValue = this.evaluateValue(attr["repeat-expr"], context);
+        const count = typeof countValue === "number" ? countValue : typeof countValue === "bigint" ? Number(countValue) : 0;
+        if (count < 0) {
+          throw new ParseError(`repeat-expr must be non-negative, got ${count}`);
+        }
+        for (let i = 0; i < count; i++) {
+          context.set("_index", i);
+          const value = this.parseAttribute(
+            { ...attr, repeat: void 0, "repeat-expr": void 0 },
+            context
+          );
+          result.push(value);
+        }
+        break;
+      }
+      case "eos": {
+        while (!stream.isEof()) {
+          context.set("_index", result.length);
+          result.push(this.parseValue(attr, context));
+        }
+        break;
+      }
+      case "until": {
+        if (!attr["repeat-until"]) {
+          throw new ParseError("repeat-until expression is required");
+        }
+        let index = 0;
+        while (true) {
+          context.set("_index", index);
+          const value = this.parseAttribute(
+            { ...attr, repeat: void 0, "repeat-until": void 0 },
+            context
+          );
+          result.push(value);
+          context.set("_", value);
+          const condition = this.evaluateValue(attr["repeat-until"], context);
+          if (condition) {
+            break;
+          }
+          if (stream.isEof()) {
+            break;
+          }
+          index++;
+        }
+        break;
+      }
+      default:
+        throw new ParseError(`Unknown repeat type: ${attr.repeat}`);
+    }
+    return result;
+  }
+  /**
+   * Parse and validate contents.
+   *
+   * @param attr - Attribute specification with contents
+   * @param context - Execution context
+   * @returns The validated contents
+   * @private
+   */
+  parseContents(attr, context) {
+    const stream = context.io;
+    const expected = attr.contents;
+    if (Array.isArray(expected)) {
+      const bytes = stream.readBytes(expected.length);
+      for (let i = 0; i < expected.length; i++) {
+        if (bytes[i] !== expected[i]) {
+          throw new ValidationError(
+            `Contents mismatch at byte ${i}: expected ${expected[i]}, got ${bytes[i]}`,
+            stream.pos - expected.length + i
+          );
+        }
+      }
+      return bytes;
+    } else {
+      const encoding = attr.encoding || this.schema.meta.encoding || "UTF-8";
+      const str = stream.readStr(expected.length, encoding);
+      if (str !== expected) {
+        throw new ValidationError(
+          `Contents mismatch: expected "${expected}", got "${str}"`,
+          stream.pos - expected.length
+        );
+      }
+      return str;
+    }
+  }
+  /**
+   * Parse a single value according to its type.
+   *
+   * @param attr - Attribute specification
+   * @param context - Execution context
+   * @returns Parsed value
+   * @private
+   */
+  parseValue(attr, context) {
+    const stream = context.io;
+    const type = attr.type;
+    if (attr.size !== void 0) {
+      const sizeValue = this.evaluateValue(attr.size, context);
+      const size = typeof sizeValue === "number" ? sizeValue : typeof sizeValue === "bigint" ? Number(sizeValue) : 0;
+      if (size < 0) {
+        throw new ParseError(`size must be non-negative, got ${size}`);
+      }
+      if (type === "str" || !type) {
+        const encoding = attr.encoding || this.schema.meta.encoding || "UTF-8";
+        let data;
+        if (type === "str") {
+          data = stream.readBytes(size);
+          if (attr.process) {
+            data = this.applyProcessing(data, attr.process);
+          }
+          return new TextDecoder(encoding).decode(data);
+        } else {
+          data = stream.readBytes(size);
+          if (attr.process) {
+            data = this.applyProcessing(data, attr.process);
+          }
+          return data;
+        }
+      } else {
+        let data = stream.readBytes(size);
+        if (attr.process) {
+          data = this.applyProcessing(data, attr.process);
+        }
+        const substream = new KaitaiStream(data);
+        return this.parseType(type, substream, context, attr["type-args"]);
+      }
+    }
+    if (attr["size-eos"]) {
+      if (type === "str") {
+        const encoding = attr.encoding || this.schema.meta.encoding || "UTF-8";
+        const bytes = stream.readBytesFull();
+        return new TextDecoder(encoding).decode(bytes);
+      } else {
+        return stream.readBytesFull();
+      }
+    }
+    if (!type) {
+      throw new ParseError("Attribute must have either type, size, or contents");
+    }
+    return this.parseType(type, stream, context, attr["type-args"]);
+  }
+  /**
+   * Parse a value of a specific type.
+   *
+   * @param type - Type name or switch specification
+   * @param stream - Stream to read from
+   * @param context - Execution context
+   * @param typeArgs - Arguments for parametric types
+   * @returns Parsed value
+   * @private
+   */
+  parseType(type, stream, context, typeArgs) {
+    if (typeof type === "object") {
+      return this.parseSwitchType(
+        type,
+        stream,
+        context
+      );
+    }
+    if (isBuiltinType(type)) {
+      return this.parseBuiltinType(type, stream, context);
+    }
+    if (this.schema.types && type in this.schema.types) {
+      const typeSchema = this.schema.types[type];
+      const meta = this.schema.meta || this.parentMeta;
+      if (this.schema.enums && !typeSchema.enums) {
+        typeSchema.enums = this.schema.enums;
+      }
+      if (this.schema.types && !typeSchema.types) {
+        typeSchema.types = this.schema.types;
+      }
+      const interpreter = new _TypeInterpreter(typeSchema, meta);
+      return interpreter.parse(stream, context.current, typeArgs);
+    }
+    throw new ParseError(`Unknown type: ${type}`);
+  }
+  /**
+   * Parse a switch type (type selection based on expression).
+   *
+   * @param switchType - Switch type specification
+   * @param stream - Stream to read from
+   * @param context - Execution context
+   * @returns Parsed value
+   * @private
+   */
+  parseSwitchType(switchType, stream, context) {
+    const switchOn = switchType["switch-on"];
+    const cases = switchType["cases"];
+    const defaultType = switchType["default"];
+    if (!switchOn || typeof switchOn !== "string") {
+      throw new ParseError("switch-on expression is required for switch types");
+    }
+    if (!cases) {
+      throw new ParseError("cases are required for switch types");
+    }
+    const switchValue = this.evaluateValue(switchOn, context);
+    const switchKey = String(switchValue);
+    let selectedType = cases[switchKey];
+    if (selectedType === void 0 && defaultType) {
+      selectedType = defaultType;
+    }
+    if (selectedType === void 0) {
+      throw new ParseError(
+        `No matching case for switch value "${switchKey}" and no default type specified`
+      );
+    }
+    return this.parseType(selectedType, stream, context);
+  }
+  /**
+   * Parse a built-in type.
+   *
+   * @param type - Built-in type name
+   * @param stream - Stream to read from
+   * @param context - Execution context
+   * @returns Parsed value
+   * @private
+   */
+  parseBuiltinType(type, stream, _context) {
+    const base = getBaseType(type);
+    const typeEndian = getTypeEndianness(type);
+    const meta = this.schema.meta || this.parentMeta;
+    const metaEndian = meta?.endian;
+    const endian = typeEndian || (typeof metaEndian === "string" ? metaEndian : "le");
+    if (isIntegerType(type)) {
+      return this.readInteger(base, endian, stream);
+    }
+    if (isFloatType(type)) {
+      return this.readFloat(base, endian, stream);
+    }
+    if (isStringType(type)) {
+      throw new ParseError("String types require size, size-eos, or terminator");
+    }
+    throw new ParseError(`Unknown built-in type: ${type}`);
+  }
+  /**
+   * Read an integer value.
+   *
+   * @param type - Integer type (u1, u2, u4, u8, s1, s2, s4, s8)
+   * @param endian - Endianness
+   * @param stream - Stream to read from
+   * @returns Integer value
+   * @private
+   */
+  readInteger(type, endian, stream) {
+    switch (type) {
+      case "u1":
+        return stream.readU1();
+      case "u2":
+        return endian === "le" ? stream.readU2le() : stream.readU2be();
+      case "u4":
+        return endian === "le" ? stream.readU4le() : stream.readU4be();
+      case "u8":
+        return endian === "le" ? stream.readU8le() : stream.readU8be();
+      case "s1":
+        return stream.readS1();
+      case "s2":
+        return endian === "le" ? stream.readS2le() : stream.readS2be();
+      case "s4":
+        return endian === "le" ? stream.readS4le() : stream.readS4be();
+      case "s8":
+        return endian === "le" ? stream.readS8le() : stream.readS8be();
+      default:
+        throw new ParseError(`Unknown integer type: ${type}`);
+    }
+  }
+  /**
+   * Read a floating point value.
+   *
+   * @param type - Float type (f4, f8)
+   * @param endian - Endianness
+   * @param stream - Stream to read from
+   * @returns Float value
+   * @private
+   */
+  readFloat(type, endian, stream) {
+    switch (type) {
+      case "f4":
+        return endian === "le" ? stream.readF4le() : stream.readF4be();
+      case "f8":
+        return endian === "le" ? stream.readF8le() : stream.readF8be();
+      default:
+        throw new ParseError(`Unknown float type: ${type}`);
+    }
+  }
+  /**
+   * Apply processing transformation to data.
+   * Supports basic transformations like zlib decompression.
+   *
+   * @param data - Data to process
+   * @param process - Processing specification
+   * @returns Processed data
+   * @private
+   */
+  applyProcessing(data, process2) {
+    const processType = typeof process2 === "string" ? process2 : process2.algorithm;
+    if (processType) {
+      throw new NotImplementedError(
+        `Processing type "${processType}" is not yet implemented. Supported in future versions with zlib, encryption, etc.`
+      );
+    }
+    return data;
+  }
+  /**
+   * Evaluate a value that can be an expression or literal.
+   *
+   * @param value - Value to evaluate (expression string, number, or boolean)
+   * @param context - Execution context
+   * @returns Evaluated result
+   * @private
+   */
+  evaluateValue(value, context) {
+    if (value === void 0) {
+      return void 0;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+      return value;
+    }
+    if (typeof value === "string") {
+      try {
+        return evaluateExpression(value, context);
+      } catch (error) {
+        throw new ParseError(
+          `Failed to evaluate expression "${value}": ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    return value;
+  }
+};
+
+// src/index.ts
+function parse(ksyYaml, buffer, options = {}) {
+  const { validate = true, strict = false } = options;
+  const parser = new KsyParser();
+  const schema = parser.parse(ksyYaml, { validate, strict });
+  const stream = new KaitaiStream(buffer);
+  const interpreter = new TypeInterpreter(schema);
+  return interpreter.parse(stream);
+}
+
+// src/cli.ts
+var VERSION = "0.6.0";
+var HELP_TEXT = `
+kaitai - Parse binary files using Kaitai Struct definitions
+
+USAGE:
+  kaitai <ksy-file> <binary-file> [options]
+  pnpx kaitai <ksy-file> <binary-file> [options]
+
+ARGUMENTS:
+  <ksy-file>      Path to .ksy definition file (YAML format)
+  <binary-file>   Path to binary file to parse
+
+OPTIONS:
+  -o, --output <file>     Write output to file instead of stdout
+  -p, --pretty            Pretty-print JSON output (default: true for stdout)
+  -f, --format <format>   Output format: json or yaml (default: json)
+  --field <path>          Extract specific field (dot notation: e.g., "header.version")
+  --no-validate           Skip schema validation
+  --strict                Treat schema warnings as errors
+  -q, --quiet             Suppress non-error output
+  -h, --help              Show this help message
+  -v, --version           Show version number
+
+EXAMPLES:
+  # Parse a binary file and output JSON
+  kaitai format.ksy data.bin
+
+  # Parse and save to file
+  kaitai format.ksy data.bin -o output.json
+
+  # Parse with pretty printing disabled
+  kaitai format.ksy data.bin --no-pretty
+
+  # Extract specific field
+  kaitai format.ksy data.bin --field header.magic
+
+  # Strict validation
+  kaitai format.ksy data.bin --strict
+
+  # Output as YAML
+  kaitai format.ksy data.bin --format yaml
+
+EXIT CODES:
+  0   Success
+  1   General error (file not found, parse error, etc.)
+  2   Invalid arguments or usage
+  3   Schema validation error
+
+For more information, visit: https://github.com/fabianopinto/kaitai-struct-ts
+`;
+function showHelp() {
+  console.log(HELP_TEXT);
+}
+function showVersion() {
+  console.log(`kaitai v${VERSION}`);
+}
+function parseCliArgs() {
+  try {
+    const { values, positionals } = (0, import_util.parseArgs)({
+      args: process.argv.slice(2),
+      options: {
+        output: { type: "string", short: "o" },
+        pretty: { type: "boolean", short: "p", default: void 0 },
+        "no-pretty": { type: "boolean", default: false },
+        format: { type: "string", short: "f", default: "json" },
+        field: { type: "string" },
+        validate: { type: "boolean", default: true },
+        "no-validate": { type: "boolean", default: false },
+        strict: { type: "boolean", default: false },
+        quiet: { type: "boolean", short: "q", default: false },
+        help: { type: "boolean", short: "h", default: false },
+        version: { type: "boolean", short: "v", default: false }
+      },
+      allowPositionals: true
+    });
+    const pretty = values.pretty !== void 0 ? values.pretty : values["no-pretty"] ? false : void 0;
+    const validate = values["no-validate"] ? false : values.validate;
+    const options = {
+      output: values.output,
+      pretty,
+      format: values.format || "json",
+      field: values.field,
+      validate,
+      strict: values.strict,
+      quiet: values.quiet,
+      help: values.help,
+      version: values.version
+    };
+    return { options, positional: positionals };
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Error parsing arguments: ${error.message}`);
+    }
+    process.exit(2);
+  }
+}
+function readFile(filePath, description) {
+  const resolvedPath = (0, import_path.resolve)(filePath);
+  if (!(0, import_fs.existsSync)(resolvedPath)) {
+    console.error(`Error: ${description} not found: ${filePath}`);
+    process.exit(1);
+  }
+  try {
+    return (0, import_fs.readFileSync)(resolvedPath);
+  } catch (error) {
+    console.error(
+      `Error reading ${description}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    process.exit(1);
+  }
+}
+function extractField(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      throw new Error(`Cannot access property '${part}' of ${typeof current}`);
+    }
+    current = current[part];
+  }
+  return current;
+}
+function formatOutput(data, format, pretty) {
+  if (format === "yaml") {
+    return JSON.stringify(data, null, 2).replace(/^{$/gm, "").replace(/^}$/gm, "").replace(/^\s*"([^"]+)":\s*/gm, "$1: ").replace(/,$/gm, "");
+  }
+  return pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+}
+function main() {
+  const { options, positional } = parseCliArgs();
+  if (options.help) {
+    showHelp();
+    process.exit(0);
+  }
+  if (options.version) {
+    showVersion();
+    process.exit(0);
+  }
+  if (positional.length < 2) {
+    console.error("Error: Missing required arguments");
+    console.error("Usage: kaitai <ksy-file> <binary-file> [options]");
+    console.error('Run "kaitai --help" for more information');
+    process.exit(2);
+  }
+  if (positional.length > 2) {
+    console.error("Error: Too many arguments");
+    console.error("Usage: kaitai <ksy-file> <binary-file> [options]");
+    process.exit(2);
+  }
+  const [ksyFile, binaryFile] = positional;
+  if (options.format && !["json", "yaml"].includes(options.format)) {
+    console.error(
+      `Error: Invalid format '${options.format}'. Must be 'json' or 'yaml'`
+    );
+    process.exit(2);
+  }
+  if (!options.quiet) {
+    console.error(`Reading KSY definition: ${ksyFile}`);
+    console.error(`Reading binary file: ${binaryFile}`);
+  }
+  const ksyContent = readFile(ksyFile, "KSY definition file").toString("utf-8");
+  const binaryData = readFile(binaryFile, "Binary file");
+  const parseOptions = {
+    validate: options.validate,
+    strict: options.strict
+  };
+  if (!options.quiet) {
+    console.error("Parsing...");
+  }
+  let result;
+  try {
+    result = parse(ksyContent, binaryData, parseOptions);
+  } catch (error) {
+    console.error(
+      `Parse error: ${error instanceof Error ? error.message : String(error)}`
+    );
+    if (error instanceof Error && error.name === "ValidationError") {
+      process.exit(3);
+    }
+    process.exit(1);
+  }
+  let output = result;
+  if (options.field) {
+    try {
+      output = extractField(result, options.field);
+      if (!options.quiet) {
+        console.error(`Extracted field: ${options.field}`);
+      }
+    } catch (error) {
+      console.error(
+        `Error extracting field '${options.field}': ${error instanceof Error ? error.message : String(error)}`
+      );
+      process.exit(1);
+    }
+  }
+  const shouldPretty = options.pretty !== void 0 ? options.pretty : !options.output;
+  const formatted = formatOutput(output, options.format || "json", shouldPretty);
+  if (options.output) {
+    try {
+      (0, import_fs.writeFileSync)(options.output, formatted + "\n", "utf-8");
+      if (!options.quiet) {
+        console.error(`Output written to: ${options.output}`);
+      }
+    } catch (error) {
+      console.error(
+        `Error writing output file: ${error instanceof Error ? error.message : String(error)}`
+      );
+      process.exit(1);
+    }
+  } else {
+    console.log(formatted);
+  }
+  if (!options.quiet) {
+    console.error("Done!");
+  }
+}
+main();
+/**
+ * @fileoverview Custom error classes for Kaitai Struct parsing and validation
+ * @module utils/errors
+ * @author Fabiano Pinto
+ * @license MIT
+ */
+/**
+ * @fileoverview String encoding and decoding utilities for binary data
+ * @module utils/encoding
+ * @author Fabiano Pinto
+ * @license MIT
+ */
+/**
+ * @fileoverview Binary stream reader for Kaitai Struct
+ * @module stream/KaitaiStream
+ * @author Fabiano Pinto
+ * @license MIT
+ */
+/**
+ * @fileoverview Binary stream reading functionality
+ * @module stream
+ * @author Fabiano Pinto
+ * @license MIT
+ */
+/**
+ * @fileoverview Type definitions for Kaitai Struct YAML schema (.ksy files)
+ * @module parser/schema
+ * @author Fabiano Pinto
+ * @license MIT
+ */
+/**
+ * @fileoverview Parser for Kaitai Struct YAML (.ksy) files
+ * @module parser/KsyParser
+ * @author Fabiano Pinto
+ * @license MIT
+ */
+/**
+ * @fileoverview Parser module for Kaitai Struct YAML files
+ * @module parser
+ * @author Fabiano Pinto
+ * @license MIT
+ */
+/**
+ * @fileoverview Execution context for Kaitai Struct parsing
+ * @module interpreter/Context
+ * @author Fabiano Pinto
+ * @license MIT
+ */
+/**
+ * @fileoverview Token types for Kaitai Struct expression language
+ * @module expression/Token
+ * @author Fabiano Pinto
+ * @license MIT
+ */
+/**
+ * @fileoverview Lexer for Kaitai Struct expression language
+ * @module expression/Lexer
+ * @author Fabiano Pinto
+ * @license MIT
+ */
+/**
+ * @fileoverview Abstract Syntax Tree nodes for expression language
+ * @module expression/AST
+ * @author Fabiano Pinto
+ * @license MIT
+ */
+/**
+ * @fileoverview Parser for Kaitai Struct expression language
+ * @module expression/Parser
+ * @author Fabiano Pinto
+ * @license MIT
+ */
+/**
+ * @fileoverview Evaluator for Kaitai Struct expression AST
+ * @module expression/Evaluator
+ * @author Fabiano Pinto
+ * @license MIT
+ */
+/**
+ * @fileoverview Expression evaluation module
+ * @module expression
+ * @author Fabiano Pinto
+ * @license MIT
+ */
+/**
+ * @fileoverview Type interpreter for executing Kaitai Struct schemas
+ * @module interpreter/TypeInterpreter
+ * @author Fabiano Pinto
+ * @license MIT
+ */
+/**
+ * @fileoverview Interpreter module for executing Kaitai Struct schemas
+ * @module interpreter
+ * @author Fabiano Pinto
+ * @license MIT
+ */
+/**
+ * @fileoverview Main entry point for kaitai-struct-ts library
+ * @module kaitai-struct-ts
+ * @author Fabiano Pinto
+ * @license MIT
+ * @version 0.2.0
+ *
+ * @description
+ * A runtime interpreter for Kaitai Struct binary format definitions in TypeScript.
+ * Parse any binary data format by providing a .ksy (Kaitai Struct YAML) definition file.
+ *
+ * @example
+ * ```typescript
+ * import { parse } from 'kaitai-struct-ts'
+ *
+ * const ksyDefinition = `
+ * meta:
+ *   id: my_format
+ *   endian: le
+ * seq:
+ *   - id: magic
+ *     contents: [0x4D, 0x5A]
+ *   - id: version
+ *     type: u2
+ * `
+ *
+ * const buffer = new Uint8Array([0x4D, 0x5A, 0x01, 0x00])
+ * const result = parse(ksyDefinition, buffer)
+ * console.log(result.version) // 1
+ * ```
+ */
+/**
+ * @fileoverview CLI utility for parsing binary files with Kaitai Struct definitions
+ * @module kaitai-struct-ts/cli
+ * @author Fabiano Pinto
+ * @license MIT
+ */