@k67/kaitai-struct-ts 0.8.0 → 0.10.0

package/dist/cli.js

@@ -5,1003 +5,1111 @@
 var import_fs = require("fs");
 var import_path = require("path");
 var import_util = require("util");
+var import_yaml2 = require("yaml");
+
+// 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) {
+  if (BUILTIN_TYPES.includes(type)) return true;
+  if (/^b\d+$/.test(type)) return true;
+  return false;
+}
+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");
 
 // src/utils/errors.ts
 var KaitaiError = class _KaitaiError extends Error {
-  constructor(message, position) {
-    super(message);
+  constructor(message, position, context) {
+    super(_KaitaiError.formatMessage(message, position, context));
     this.position = position;
+    this.context = context;
     this.name = "KaitaiError";
     Object.setPrototypeOf(this, _KaitaiError.prototype);
   }
+  /**
+   * Format error message with position and context.
+   * @private
+   */
+  static formatMessage(message, position, context) {
+    let formatted = message;
+    if (position !== void 0) {
+      formatted += ` (at byte offset 0x${position.toString(16).toUpperCase()})`;
+    }
+    if (context && context.length > 0) {
+      const hexContext = _KaitaiError.formatHexContext(context, position);
+      formatted += `
+${hexContext}`;
+    }
+    return formatted;
+  }
+  /**
+   * Format hex dump context around error position.
+   * @private
+   */
+  static formatHexContext(data, position) {
+    const contextSize = 16;
+    const start = Math.max(0, (position ?? 0) - contextSize);
+    const end = Math.min(data.length, (position ?? 0) + contextSize);
+    const chunk = data.slice(start, end);
+    const lines = ["Context:"];
+    let offset = start;
+    for (let i = 0; i < chunk.length; i += 16) {
+      const lineBytes = chunk.slice(i, i + 16);
+      const hex = Array.from(lineBytes).map((b) => b.toString(16).padStart(2, "0")).join(" ");
+      const ascii = Array.from(lineBytes).map((b) => b >= 32 && b <= 126 ? String.fromCharCode(b) : ".").join("");
+      const offsetStr = `  ${(offset + i).toString(16).padStart(8, "0")}`;
+      const marker = position !== void 0 && position >= offset + i && position < offset + i + lineBytes.length ? " <--" : "";
+      lines.push(`${offsetStr}: ${hex.padEnd(48, " ")} | ${ascii}${marker}`);
+    }
+    return lines.join("\n");
+  }
 };
 var ValidationError = class _ValidationError extends KaitaiError {
-  constructor(message, position) {
-    super(message, position);
+  constructor(message, position, context) {
+    super(message, position, context);
     this.name = "ValidationError";
     Object.setPrototypeOf(this, _ValidationError.prototype);
   }
 };
 var ParseError = class _ParseError extends KaitaiError {
-  constructor(message, position) {
-    super(message, position);
+  constructor(message, position, context) {
+    super(message, position, context);
     this.name = "ParseError";
     Object.setPrototypeOf(this, _ParseError.prototype);
   }
 };
 var EOFError = class _EOFError extends KaitaiError {
-  constructor(message = "Unexpected end of stream", position) {
-    super(message, position);
+  constructor(message = "Unexpected end of stream", position, context) {
+    super(message, position, context);
     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 {
+// src/parser/KsyParser.ts
+var KsyParser = class {
   /**
-   * Create a new KaitaiStream from a buffer
-   * @param buffer - ArrayBuffer or Uint8Array containing the binary data
+   * 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
    */
-  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
+  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;
   }
   /**
-   * 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
+   * Validate a schema object.
+   *
+   * @param schema - Schema to validate
+   * @param options - Validation options
+   * @returns Validation result with errors and warnings
    */
-  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}`);
+  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"
+          });
+        }
+      }
     }
-    this.pos = pos;
+    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
+    };
   }
   /**
-   * Ensure we have enough bytes available
-   * @param count - Number of bytes needed
+   * 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
    */
-  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
-      );
+  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"
+        });
+      }
     }
   }
-  // ==================== Unsigned Integers ====================
   /**
-   * Read 1-byte unsigned integer (0 to 255)
-   */
-  readU1() {
-    this.ensureBytes(1);
-    return this.buffer[this._pos++];
+   * 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
+   * @throws {ParseError} If import resolution fails
+   * @example
+   * ```typescript
+   * const parser = new KsyParser()
+   * const imports = new Map([
+   *   ['/common/riff', riffYamlContent]
+   * ])
+   * const schema = parser.parseWithImports(wavYaml, imports)
+   * ```
+   */
+  parseWithImports(mainYaml, imports, options = {}) {
+    const mainSchema = this.parse(mainYaml, options);
+    if (!mainSchema.meta.imports || mainSchema.meta.imports.length === 0) {
+      return mainSchema;
+    }
+    const resolvedTypes = {};
+    for (const importPath of mainSchema.meta.imports) {
+      if (!imports.has(importPath)) {
+        throw new ParseError(
+          `Import not found: ${importPath}. Available imports: ${Array.from(imports.keys()).join(", ")}`
+        );
+      }
+      const importYaml = imports.get(importPath);
+      const importedSchema = this.parse(importYaml, {
+        ...options,
+        validate: false
+        // Skip validation for imported schemas
+      });
+      const namespace = this.extractNamespace(importPath);
+      if (importedSchema.types) {
+        for (const [typeName, typeSchema] of Object.entries(
+          importedSchema.types
+        )) {
+          const qualifiedName = `${namespace}::${typeName}`;
+          resolvedTypes[qualifiedName] = typeSchema;
+        }
+      }
+      resolvedTypes[namespace] = {
+        meta: importedSchema.meta,
+        seq: importedSchema.seq,
+        instances: importedSchema.instances,
+        types: importedSchema.types,
+        enums: importedSchema.enums
+      };
+      if (importedSchema.enums) {
+        if (!mainSchema.enums) {
+          mainSchema.enums = {};
+        }
+        for (const [enumName, enumSpec] of Object.entries(
+          importedSchema.enums
+        )) {
+          const qualifiedEnumName = `${namespace}::${enumName}`;
+          mainSchema.enums[qualifiedEnumName] = enumSpec;
+        }
+      }
+    }
+    if (Object.keys(resolvedTypes).length > 0) {
+      mainSchema.types = {
+        ...resolvedTypes,
+        ...mainSchema.types
+      };
+    }
+    return mainSchema;
   }
   /**
-   * Read 2-byte unsigned integer, little-endian
+   * Extract namespace from import path.
+   * Converts paths like '/common/riff' or 'common/riff' to 'riff'.
+   *
+   * @param importPath - Import path from meta.imports
+   * @returns Namespace identifier
+   * @private
    */
-  readU2le() {
-    this.ensureBytes(2);
-    const value = this.view.getUint16(this._pos, true);
-    this._pos += 2;
-    return value;
+  extractNamespace(importPath) {
+    const normalized = importPath.startsWith("/") ? importPath.slice(1) : importPath;
+    const segments = normalized.split("/");
+    return segments[segments.length - 1];
   }
+};
+
+// src/interpreter/Context.ts
+var Context = class _Context {
   /**
-   * Read 2-byte unsigned integer, big-endian
+   * 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)
    */
-  readU2be() {
-    this.ensureBytes(2);
-    const value = this.view.getUint16(this._pos, false);
-    this._pos += 2;
-    return value;
+  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;
+    }
   }
   /**
-   * 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
+   * Get the current I/O stream.
+   * Accessible in expressions as `_io`.
+   *
+   * @returns Current stream
    */
-  readU4be() {
-    this.ensureBytes(4);
-    const value = this.view.getUint32(this._pos, false);
-    this._pos += 4;
-    return value;
+  get io() {
+    return this._io;
   }
   /**
-   * Read 8-byte unsigned integer, little-endian
-   * Returns BigInt for values > Number.MAX_SAFE_INTEGER
+   * Get the root object.
+   * Accessible in expressions as `_root`.
+   *
+   * @returns Root object
    */
-  readU8le() {
-    this.ensureBytes(8);
-    const value = this.view.getBigUint64(this._pos, true);
-    this._pos += 8;
-    return value;
+  get root() {
+    return this._root;
   }
   /**
-   * Read 8-byte unsigned integer, big-endian
-   * Returns BigInt for values > Number.MAX_SAFE_INTEGER
+   * Get the parent object.
+   * Accessible in expressions as `_parent`.
+   *
+   * @returns Parent object or null if at root
    */
-  readU8be() {
-    this.ensureBytes(8);
-    const value = this.view.getBigUint64(this._pos, false);
-    this._pos += 8;
-    return value;
+  get parent() {
+    return this.parentStack.length > 0 ? this.parentStack[this.parentStack.length - 1] : null;
   }
-  // ==================== Signed Integers ====================
   /**
-   * Read 1-byte signed integer (-128 to 127)
+   * Get the current object being parsed.
+   * Used to access fields defined earlier in the sequence.
+   *
+   * @returns Current object
    */
-  readS1() {
-    this.ensureBytes(1);
-    return this.view.getInt8(this._pos++);
+  get current() {
+    return this._current;
   }
   /**
-   * Read 2-byte signed integer, little-endian
+   * Set the current object.
+   *
+   * @param obj - Object to set as current
    */
-  readS2le() {
-    this.ensureBytes(2);
-    const value = this.view.getInt16(this._pos, true);
-    this._pos += 2;
-    return value;
+  set current(obj) {
+    this._current = obj;
   }
   /**
-   * Read 2-byte signed integer, big-endian
+   * Push a new parent onto the stack.
+   * Used when entering a nested type.
+   *
+   * @param parent - Parent object to push
    */
-  readS2be() {
-    this.ensureBytes(2);
-    const value = this.view.getInt16(this._pos, false);
-    this._pos += 2;
-    return value;
+  pushParent(parent) {
+    this.parentStack.push(parent);
   }
   /**
-   * Read 4-byte signed integer, little-endian
+   * Pop the current parent from the stack.
+   * Used when exiting a nested type.
+   *
+   * @returns The popped parent object
    */
-  readS4le() {
-    this.ensureBytes(4);
-    const value = this.view.getInt32(this._pos, true);
-    this._pos += 4;
-    return value;
+  popParent() {
+    return this.parentStack.pop();
   }
   /**
-   * Read 4-byte signed integer, big-endian
+   * 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
    */
-  readS4be() {
-    this.ensureBytes(4);
-    const value = this.view.getInt32(this._pos, false);
-    this._pos += 4;
-    return 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;
+    }
   }
   /**
-   * Read 8-byte signed integer, little-endian
-   * Returns BigInt for values outside Number.MAX_SAFE_INTEGER range
+   * Set a value in the current object.
+   *
+   * @param name - Field name
+   * @param value - Value to set
    */
-  readS8le() {
-    this.ensureBytes(8);
-    const value = this.view.getBigInt64(this._pos, true);
-    this._pos += 8;
-    return value;
+  set(name, value) {
+    this._current[name] = value;
   }
   /**
-   * Read 8-byte signed integer, big-endian
-   * Returns BigInt for values outside Number.MAX_SAFE_INTEGER range
+   * 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
    */
-  readS8be() {
-    this.ensureBytes(8);
-    const value = this.view.getBigInt64(this._pos, false);
-    this._pos += 8;
-    return value;
+  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;
   }
-  // ==================== Floating Point ====================
   /**
-   * Read 4-byte IEEE 754 single-precision float, little-endian
+   * Check if an enum exists.
+   *
+   * @param enumName - Name of the enum
+   * @returns True if enum exists
    */
-  readF4le() {
-    this.ensureBytes(4);
-    const value = this.view.getFloat32(this._pos, true);
-    this._pos += 4;
-    return value;
+  hasEnum(enumName) {
+    return enumName in this._enums;
   }
   /**
-   * Read 4-byte IEEE 754 single-precision float, big-endian
+   * 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
    */
-  readF4be() {
-    this.ensureBytes(4);
-    const value = this.view.getFloat32(this._pos, false);
-    this._pos += 4;
-    return value;
+  createChild(stream) {
+    const childContext = new _Context(
+      stream || this._io,
+      this._root || this._current,
+      this._current,
+      this._enums
+    );
+    return childContext;
   }
   /**
-   * Read 8-byte IEEE 754 double-precision float, little-endian
+   * Clone this context.
+   * Creates a shallow copy with the same stream, root, and parent.
+   *
+   * @returns Cloned context
    */
-  readF8le() {
-    this.ensureBytes(8);
-    const value = this.view.getFloat64(this._pos, true);
-    this._pos += 8;
-    return value;
+  clone() {
+    const cloned = new _Context(this._io, this._root, this.parent, this._enums);
+    cloned._current = { ...this._current };
+    cloned.parentStack = [...this.parentStack];
+    return cloned;
   }
-  /**
-   * 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;
+};
+
+// 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}`);
   }
-  // ==================== 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;
+}
+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 {
   /**
-   * Read all remaining bytes until end of stream
+   * Create a new KaitaiStream from a buffer
+   * @param buffer - ArrayBuffer or Uint8Array containing the binary data
    */
-  readBytesFull() {
-    const bytes = this.buffer.slice(this._pos);
-    this._pos = this.buffer.length;
-    return bytes;
+  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
+      );
+    }
   }
   /**
-   * 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
+   * Current position in the stream
    */
-  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++;
+  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}`);
     }
-    const foundTerm = end < this.buffer.length;
-    if (!foundTerm && eosError) {
+    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(
-        `Terminator byte ${term} not found before end of stream`,
+        `Requested ${count} bytes at position ${this._pos}, but only ${this.buffer.length - this._pos} bytes available`,
         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 ====================
+  // ==================== Unsigned Integers ====================
   /**
-   * Read a fixed-length string
-   * @param length - Number of bytes to read
-   * @param encoding - Character encoding (default: UTF-8)
+   * Read 1-byte unsigned integer (0 to 255)
    */
-  readStr(length, encoding = "UTF-8") {
-    const bytes = this.readBytes(length);
-    return decodeString(bytes, encoding);
+  readU1() {
+    this.ensureBytes(1);
+    return this.buffer[this._pos++];
   }
   /**
-   * 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
+   * Read 2-byte unsigned integer, little-endian
    */
-  readStrz(encoding = "UTF-8", term = 0, include = false, consume = true, eosError = true) {
-    const bytes = this.readBytesterm(term, include, consume, eosError);
-    return decodeString(bytes, encoding);
+  readU2le() {
+    this.ensureBytes(2);
+    const value = this.view.getUint16(this._pos, true);
+    this._pos += 2;
+    return value;
   }
-  // ==================== Bit-level Reading ====================
   /**
-   * Align bit reading to byte boundary
+   * Read 2-byte unsigned integer, big-endian
    */
-  alignToByte() {
-    this._bitsLeft = 0;
+  readU2be() {
+    this.ensureBytes(2);
+    const value = this.view.getUint16(this._pos, false);
+    this._pos += 2;
+    return value;
   }
   /**
-   * Read specified number of bits as unsigned integer (big-endian)
-   * @param n - Number of bits to read (1-64)
+   * Read 4-byte unsigned integer, little-endian
    */
-  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;
+  readU4le() {
+    this.ensureBytes(4);
+    const value = this.view.getUint32(this._pos, true);
+    this._pos += 4;
+    return value;
   }
   /**
-   * Read specified number of bits as unsigned integer (little-endian)
-   * @param n - Number of bits to read (1-64)
+   * Read 4-byte unsigned integer, big-endian
    */
-  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;
+  readU4be() {
+    this.ensureBytes(4);
+    const value = this.view.getUint32(this._pos, false);
+    this._pos += 4;
+    return value;
   }
-  // ==================== Utility Methods ====================
   /**
-   * Get the underlying buffer
+   * Read 8-byte unsigned integer, little-endian
+   * Returns BigInt for values > Number.MAX_SAFE_INTEGER
    */
-  getBuffer() {
-    return this.buffer;
+  readU8le() {
+    this.ensureBytes(8);
+    const value = this.view.getBigUint64(this._pos, true);
+    this._pos += 8;
+    return value;
   }
   /**
-   * Create a substream from current position with specified size
-   * @param size - Size of the substream in bytes
+   * Read 8-byte unsigned integer, big-endian
+   * Returns BigInt for values > Number.MAX_SAFE_INTEGER
    */
-  substream(size) {
-    this.ensureBytes(size);
-    const subBuffer = this.buffer.slice(this._pos, this._pos + size);
-    this._pos += size;
-    return new _KaitaiStream(subBuffer);
+  readU8be() {
+    this.ensureBytes(8);
+    const value = this.view.getBigUint64(this._pos, false);
+    this._pos += 8;
+    return value;
   }
-};
-
-// 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);
+  // ==================== Signed Integers ====================
+  /**
+   * Read 1-byte signed integer (-128 to 127)
+   */
+  readS1() {
+    this.ensureBytes(1);
+    return this.view.getInt8(this._pos++);
   }
-  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
+   * Read 2-byte signed integer, little-endian
    */
-  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;
+  readS2le() {
+    this.ensureBytes(2);
+    const value = this.view.getInt16(this._pos, true);
+    this._pos += 2;
+    return value;
   }
   /**
-   * Validate a schema object.
-   *
-   * @param schema - Schema to validate
-   * @param options - Validation options
-   * @returns Validation result with errors and warnings
+   * Read 2-byte signed integer, big-endian
    */
-  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
-    };
+  readS2be() {
+    this.ensureBytes(2);
+    const value = this.view.getInt16(this._pos, false);
+    this._pos += 2;
+    return value;
   }
   /**
-   * 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
+   * Read 4-byte signed integer, little-endian
    */
-  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"
-        });
-      }
-    }
+  readS4le() {
+    this.ensureBytes(4);
+    const value = this.view.getInt32(this._pos, true);
+    this._pos += 4;
+    return value;
   }
   /**
-   * 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
+   * Read 4-byte signed integer, big-endian
    */
-  parseWithImports(mainYaml, _imports, options = {}) {
-    const mainSchema = this.parse(mainYaml, options);
-    return mainSchema;
+  readS4be() {
+    this.ensureBytes(4);
+    const value = this.view.getInt32(this._pos, false);
+    this._pos += 4;
+    return value;
   }
-};
-
-// 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)
+   * 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
    */
-  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;
-    }
+  readF4le() {
+    this.ensureBytes(4);
+    const value = this.view.getFloat32(this._pos, true);
+    this._pos += 4;
+    return value;
   }
   /**
-   * Get the current I/O stream.
-   * Accessible in expressions as `_io`.
-   *
-   * @returns Current stream
+   * Read 4-byte IEEE 754 single-precision float, big-endian
    */
-  get io() {
-    return this._io;
+  readF4be() {
+    this.ensureBytes(4);
+    const value = this.view.getFloat32(this._pos, false);
+    this._pos += 4;
+    return value;
   }
   /**
-   * Get the root object.
-   * Accessible in expressions as `_root`.
-   *
-   * @returns Root object
+   * Read 8-byte IEEE 754 double-precision float, little-endian
    */
-  get root() {
-    return this._root;
+  readF8le() {
+    this.ensureBytes(8);
+    const value = this.view.getFloat64(this._pos, true);
+    this._pos += 8;
+    return value;
   }
   /**
-   * Get the parent object.
-   * Accessible in expressions as `_parent`.
-   *
-   * @returns Parent object or null if at root
+   * Read 8-byte IEEE 754 double-precision float, big-endian
    */
-  get parent() {
-    return this.parentStack.length > 0 ? this.parentStack[this.parentStack.length - 1] : null;
+  readF8be() {
+    this.ensureBytes(8);
+    const value = this.view.getFloat64(this._pos, false);
+    this._pos += 8;
+    return value;
   }
+  // ==================== Byte Arrays ====================
   /**
-   * Get the current object being parsed.
-   * Used to access fields defined earlier in the sequence.
-   *
-   * @returns Current object
+   * Read a fixed number of bytes
+   * @param length - Number of bytes to read
    */
-  get current() {
-    return this._current;
+  readBytes(length) {
+    this.ensureBytes(length);
+    const bytes = this.buffer.slice(this._pos, this._pos + length);
+    this._pos += length;
+    return bytes;
   }
   /**
-   * Set the current object.
-   *
-   * @param obj - Object to set as current
+   * Read all remaining bytes until end of stream
    */
-  set current(obj) {
-    this._current = obj;
+  readBytesFull() {
+    const bytes = this.buffer.slice(this._pos);
+    this._pos = this.buffer.length;
+    return bytes;
   }
   /**
-   * Push a new parent onto the stack.
-   * Used when entering a nested type.
-   *
-   * @param parent - Parent object to push
+   * 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
    */
-  pushParent(parent) {
-    this.parentStack.push(parent);
+  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 ====================
   /**
-   * Pop the current parent from the stack.
-   * Used when exiting a nested type.
-   *
-   * @returns The popped parent object
+   * Read a fixed-length string
+   * @param length - Number of bytes to read
+   * @param encoding - Character encoding (default: UTF-8)
    */
-  popParent() {
-    return this.parentStack.pop();
+  readStr(length, encoding = "UTF-8") {
+    const bytes = this.readBytes(length);
+    return decodeString(bytes, encoding);
   }
   /**
-   * 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
+   * 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
    */
-  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;
-    }
+  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 ====================
   /**
-   * Set a value in the current object.
-   *
-   * @param name - Field name
-   * @param value - Value to set
+   * Align bit reading to byte boundary
    */
-  set(name, value) {
-    this._current[name] = value;
+  alignToByte() {
+    this._bitsLeft = 0;
   }
   /**
-   * 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
+   * Read specified number of bits as unsigned integer (big-endian)
+   * @param n - Number of bits to read (1-64)
    */
-  getEnumValue(enumName, valueName) {
-    const enumDef = this._enums[enumName];
-    if (!enumDef) {
-      return void 0;
+  readBitsIntBe(n) {
+    if (n < 1 || n > 64) {
+      throw new Error(`Invalid bit count: ${n}. Must be between 1 and 64`);
     }
-    for (const [key, value] of Object.entries(enumDef)) {
-      if (value === valueName) {
-        const numKey = Number(key);
-        return isNaN(numKey) ? key : numKey;
+    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 void 0;
+    return result;
   }
   /**
-   * Check if an enum exists.
-   *
-   * @param enumName - Name of the enum
-   * @returns True if enum exists
+   * Read specified number of bits as unsigned integer (little-endian)
+   * @param n - Number of bits to read (1-64)
    */
-  hasEnum(enumName) {
-    return enumName in this._enums;
+  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 ====================
   /**
-   * 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
+   * Get the underlying buffer
    */
-  createChild(stream) {
-    const childContext = new _Context(
-      stream || this._io,
-      this._root || this._current,
-      this._current,
-      this._enums
-    );
-    return childContext;
+  getBuffer() {
+    return this.buffer;
   }
-  /**
-   * Clone this context.
-   * Creates a shallow copy with the same stream, root, and parent.
-   *
-   * @returns Cloned context
+  /**
+   * Create a substream from current position with specified size
+   * @param size - Size of the substream in bytes
    */
-  clone() {
-    const cloned = new _Context(this._io, this._root, this.parent, this._enums);
-    cloned._current = { ...this._current };
-    cloned.parentStack = [...this.parentStack];
-    return cloned;
+  substream(size) {
+    this.ensureBytes(size);
+    const subBuffer = this.buffer.slice(this._pos, this._pos + size);
+    this._pos += size;
+    return new _KaitaiStream(subBuffer);
   }
 };
 
@@ -1132,6 +1240,17 @@ var Lexer = class {
       }
       return createToken("NUMBER" /* NUMBER */, parseInt(value, 16), start);
     }
+    if (this.current === "0" && this.peek() === "b") {
+      value += this.current;
+      this.advance();
+      value += this.current;
+      this.advance();
+      while (this.current !== null && /[01]/.test(this.current)) {
+        value += this.current;
+        this.advance();
+      }
+      return createToken("NUMBER" /* NUMBER */, parseInt(value, 2), start);
+    }
     while (this.current !== null && this.isDigit(this.current)) {
       value += this.current;
       this.advance();
@@ -1343,6 +1462,9 @@ function createMethodCall(object, method, args) {
 function createEnumAccess(enumName, value) {
   return { kind: "EnumAccess", enumName, value };
 }
+function createArrayLiteral(elements) {
+  return { kind: "ArrayLiteral", elements };
+}
 
 // src/expression/Parser.ts
 var ExpressionParser = class {
@@ -1639,6 +1761,17 @@ var ExpressionParser = class {
       this.expect("RPAREN" /* RPAREN */, "Expected ) after expression");
       return expr;
     }
+    if (this.match("LBRACKET" /* LBRACKET */)) {
+      const elements = [];
+      if (this.current().type !== "RBRACKET" /* RBRACKET */) {
+        elements.push(this.parseTernary());
+        while (this.match("COMMA" /* COMMA */)) {
+          elements.push(this.parseTernary());
+        }
+      }
+      this.expect("RBRACKET" /* RBRACKET */, "Expected ] after array literal");
+      return createArrayLiteral(elements);
+    }
     throw new ParseError(
       `Unexpected token: ${this.current().type}`,
       this.current().position
@@ -1677,6 +1810,8 @@ var Evaluator = class {
         return this.evaluateMethodCall(n.object, n.method, n.args, context);
       case "EnumAccess":
         return this.evaluateEnumAccess(n.enumName, n.value, context);
+      case "ArrayLiteral":
+        return this.evaluateArrayLiteral(n.elements, context);
       default:
         throw new ParseError(`Unknown AST node kind: ${node.kind}`);
     }
@@ -1722,15 +1857,15 @@ var Evaluator = class {
         return !this.equals(leftVal, rightVal);
       // Bitwise
       case "<<":
-        return this.toInt(leftVal) << this.toInt(rightVal);
+        return this.bitwiseOp(leftVal, rightVal, (a, b) => a << b);
       case ">>":
-        return this.toInt(leftVal) >> this.toInt(rightVal);
+        return this.bitwiseOp(leftVal, rightVal, (a, b) => a >> b);
       case "&":
-        return this.toInt(leftVal) & this.toInt(rightVal);
+        return this.bitwiseOp(leftVal, rightVal, (a, b) => a & b);
       case "|":
-        return this.toInt(leftVal) | this.toInt(rightVal);
+        return this.bitwiseOp(leftVal, rightVal, (a, b) => a | b);
       case "^":
-        return this.toInt(leftVal) ^ this.toInt(rightVal);
+        return this.bitwiseOp(leftVal, rightVal, (a, b) => a ^ b);
       // Logical
       case "and":
         return this.toBoolean(leftVal) && this.toBoolean(rightVal);
@@ -1774,6 +1909,16 @@ var Evaluator = class {
         `Cannot access property ${property} of null/undefined`
       );
     }
+    if (property === "to_i") {
+      if (typeof obj === "number") return Math.floor(obj);
+      if (typeof obj === "bigint") return Number(obj);
+      if (typeof obj === "string") return parseInt(obj, 10);
+      if (typeof obj === "boolean") return obj ? 1 : 0;
+      return this.toInt(obj);
+    }
+    if (property === "to_s") {
+      return String(obj);
+    }
     if (typeof obj === "object") {
       return obj[property];
     }
@@ -1800,8 +1945,9 @@ var Evaluator = class {
    * Evaluate method call (object.method()).
    * @private
    */
-  evaluateMethodCall(object, method, _args, context) {
+  evaluateMethodCall(object, method, args, context) {
     const obj = this.evaluate(object, context);
+    const evalArgs = args.map((arg) => this.evaluate(arg, context));
     if (method === "length" || method === "size") {
       if (Array.isArray(obj)) return obj.length;
       if (obj instanceof Uint8Array) return obj.length;
@@ -1809,13 +1955,182 @@ var Evaluator = class {
       throw new ParseError(`Object does not have a ${method} property`);
     }
     if (method === "to_i") {
+      const base = evalArgs.length > 0 ? this.toInt(evalArgs[0]) : 10;
+      if (typeof obj === "string") {
+        return parseInt(obj, base);
+      }
       return this.toInt(obj);
     }
     if (method === "to_s") {
       return String(obj);
     }
+    if (typeof obj === "string") {
+      return this.evaluateStringMethod(obj, method, evalArgs);
+    }
+    if (Array.isArray(obj) || obj instanceof Uint8Array) {
+      return this.evaluateArrayMethod(obj, method, evalArgs);
+    }
     throw new ParseError(`Unknown method: ${method}`);
   }
+  /**
+   * Evaluate string methods.
+   * @private
+   */
+  evaluateStringMethod(str, method, args) {
+    switch (method) {
+      case "substring": {
+        const start = args.length > 0 ? this.toInt(args[0]) : 0;
+        const end = args.length > 1 ? this.toInt(args[1]) : void 0;
+        return str.substring(start, end);
+      }
+      case "substr": {
+        const start = args.length > 0 ? this.toInt(args[0]) : 0;
+        const length = args.length > 1 ? this.toInt(args[1]) : void 0;
+        return str.substr(start, length);
+      }
+      case "reverse":
+        return str.split("").reverse().join("");
+      case "to_i": {
+        const base = args.length > 0 ? this.toInt(args[0]) : 10;
+        return parseInt(str, base);
+      }
+      case "length":
+      case "size":
+        return str.length;
+      // Ruby-style string methods used in Kaitai
+      case "upcase":
+      case "to_upper":
+        return str.toUpperCase();
+      case "downcase":
+      case "to_lower":
+        return str.toLowerCase();
+      case "capitalize":
+        return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+      case "strip":
+      case "trim":
+        return str.trim();
+      case "lstrip":
+      case "trim_start":
+        return str.trimStart();
+      case "rstrip":
+      case "trim_end":
+        return str.trimEnd();
+      case "starts_with":
+      case "startsWith": {
+        if (args.length === 0) {
+          throw new ParseError("starts_with requires 1 argument");
+        }
+        return str.startsWith(String(args[0]));
+      }
+      case "ends_with":
+      case "endsWith": {
+        if (args.length === 0) {
+          throw new ParseError("ends_with requires 1 argument");
+        }
+        return str.endsWith(String(args[0]));
+      }
+      case "includes":
+      case "contains": {
+        if (args.length === 0) {
+          throw new ParseError("includes requires 1 argument");
+        }
+        return str.includes(String(args[0]));
+      }
+      case "index_of":
+      case "indexOf": {
+        if (args.length === 0) {
+          throw new ParseError("index_of requires 1 argument");
+        }
+        return str.indexOf(String(args[0]));
+      }
+      case "split": {
+        if (args.length === 0) {
+          throw new ParseError("split requires 1 argument");
+        }
+        return str.split(String(args[0]));
+      }
+      case "replace": {
+        if (args.length < 2) {
+          throw new ParseError("replace requires 2 arguments");
+        }
+        return str.replace(String(args[0]), String(args[1]));
+      }
+      case "replace_all":
+      case "replaceAll": {
+        if (args.length < 2) {
+          throw new ParseError("replace_all requires 2 arguments");
+        }
+        const search = String(args[0]);
+        const replace = String(args[1]);
+        return str.split(search).join(replace);
+      }
+      case "pad_left":
+      case "padStart": {
+        if (args.length === 0) {
+          throw new ParseError("pad_left requires at least 1 argument");
+        }
+        const length = this.toInt(args[0]);
+        const fillString = args.length > 1 ? String(args[1]) : " ";
+        return str.padStart(length, fillString);
+      }
+      case "pad_right":
+      case "padEnd": {
+        if (args.length === 0) {
+          throw new ParseError("pad_right requires at least 1 argument");
+        }
+        const length = this.toInt(args[0]);
+        const fillString = args.length > 1 ? String(args[1]) : " ";
+        return str.padEnd(length, fillString);
+      }
+      default:
+        throw new ParseError(`Unknown string method: ${method}`);
+    }
+  }
+  /**
+   * Evaluate array methods.
+   * @private
+   */
+  evaluateArrayMethod(arr, method, args) {
+    const array = Array.isArray(arr) ? arr : Array.from(arr);
+    switch (method) {
+      case "length":
+      case "size":
+        return array.length;
+      case "first":
+        return array[0];
+      case "last":
+        return array[array.length - 1];
+      case "min":
+        return Math.min(...array.map((v) => this.toNumber(v)));
+      case "max":
+        return Math.max(...array.map((v) => this.toNumber(v)));
+      case "reverse":
+        return [...array].reverse();
+      case "sort":
+        return [...array].sort((a, b) => this.compare(a, b));
+      case "includes":
+      case "contains": {
+        if (args.length === 0) {
+          throw new ParseError("includes requires 1 argument");
+        }
+        return array.some((item) => this.equals(item, args[0]));
+      }
+      case "index_of":
+      case "indexOf": {
+        if (args.length === 0) {
+          throw new ParseError("index_of requires 1 argument");
+        }
+        return array.findIndex((item) => this.equals(item, args[0]));
+      }
+      case "slice": {
+        const start = args.length > 0 ? this.toInt(args[0]) : 0;
+        const end = args.length > 1 ? this.toInt(args[1]) : void 0;
+        return array.slice(start, end);
+      }
+      default:
+        throw new ParseError(`Unknown array method: ${method}`);
+    }
+  }
   /**
    * Evaluate enum access (EnumName::value).
    * @private
@@ -1845,6 +2160,38 @@ var Evaluator = class {
     const result = a % b;
     return result < 0 ? result + b : result;
   }
+  /**
+   * Helper: Bitwise operation with BigInt support.
+   * JavaScript bitwise operators work on 32-bit integers, but Kaitai
+   * may use 64-bit values. For values that fit in 32 bits, use native ops.
+   * For larger values, convert to BigInt (with limitations).
+   * @private
+   */
+  bitwiseOp(left, right, op) {
+    if (typeof left === "bigint" || typeof right === "bigint") {
+      const leftBig = typeof left === "bigint" ? left : BigInt(left);
+      const rightBig = typeof right === "bigint" ? right : BigInt(right);
+      if (op.toString().includes("<<")) {
+        return leftBig << BigInt(Number(rightBig));
+      }
+      if (op.toString().includes(">>")) {
+        return leftBig >> BigInt(Number(rightBig));
+      }
+      if (op.toString().includes("&")) {
+        return leftBig & rightBig;
+      }
+      if (op.toString().includes("|")) {
+        return leftBig | rightBig;
+      }
+      if (op.toString().includes("^")) {
+        return leftBig ^ rightBig;
+      }
+    }
+    if (left === void 0 || left === null || right === void 0 || right === null) {
+      throw new ParseError("Cannot perform bitwise operation on null/undefined");
+    }
+    return op(this.toInt(left), this.toInt(right));
+  }
   /**
    * Helper: Compare two values.
    * @private
@@ -1865,8 +2212,30 @@ var Evaluator = class {
     if (typeof left === "bigint" || typeof right === "bigint") {
       return BigInt(left) === BigInt(right);
     }
+    const toArray = (v) => {
+      if (Array.isArray(v))
+        return v.map((x) => typeof x === "bigint" ? Number(x) : x);
+      if (v instanceof Uint8Array) return Array.from(v);
+      return null;
+    };
+    const leftArr = toArray(left);
+    const rightArr = toArray(right);
+    if (leftArr && rightArr) {
+      if (leftArr.length !== rightArr.length) return false;
+      for (let i = 0; i < leftArr.length; i++) {
+        if (leftArr[i] !== rightArr[i]) return false;
+      }
+      return true;
+    }
     return left === right;
   }
+  /**
+   * Evaluate an array literal.
+   * @private
+   */
+  evaluateArrayLiteral(elements, context) {
+    return elements.map((e) => this.evaluate(e, context));
+  }
   /**
    * Helper: Convert to number.
    * @private
@@ -1901,7 +2270,8 @@ var Evaluator = class {
 
 // src/expression/index.ts
 function evaluateExpression(expression, context) {
-  const lexer = new Lexer(expression);
+  const preprocessed = expression.replace(/\.as<[^>]+>/g, "");
+  const lexer = new Lexer(preprocessed);
   const tokens = lexer.tokenize();
   const parser = new ExpressionParser(tokens);
   const ast = parser.parse();
@@ -1909,6 +2279,112 @@ function evaluateExpression(expression, context) {
   return evaluator.evaluate(ast, context);
 }
 
+// src/utils/process.ts
+var import_pako = require("pako");
+function applyProcess(data, process2) {
+  const spec = typeof process2 === "string" ? { algorithm: process2 } : process2;
+  const algorithm = spec.algorithm;
+  if (!algorithm) {
+    throw new ParseError("Process specification missing algorithm");
+  }
+  switch (algorithm) {
+    case "zlib":
+      return processZlib(data);
+    case "xor":
+      return processXor(data, spec.key);
+    case "rol":
+      return processRol(data, spec.amount, spec.group);
+    case "ror":
+      return processRor(data, spec.amount, spec.group);
+    case "bswap2":
+      return processByteswap(data, 2);
+    case "bswap4":
+      return processByteswap(data, 4);
+    case "bswap8":
+      return processByteswap(data, 8);
+    case "bswap16":
+      return processByteswap(data, 16);
+    default:
+      throw new ParseError(
+        `Unknown process algorithm: ${algorithm}. Supported: zlib, xor, rol, ror, bswap2, bswap4, bswap8, bswap16`
+      );
+  }
+}
+function processZlib(data) {
+  try {
+    return (0, import_pako.inflate)(data);
+  } catch (error) {
+    throw new ParseError(
+      `Zlib decompression failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function processXor(data, key) {
+  if (key === void 0) {
+    throw new ParseError("XOR process requires a key parameter");
+  }
+  const result = new Uint8Array(data.length);
+  const keyBytes = Array.isArray(key) ? key : [key];
+  if (keyBytes.length === 0) {
+    throw new ParseError("XOR key cannot be empty");
+  }
+  for (let i = 0; i < data.length; i++) {
+    result[i] = data[i] ^ keyBytes[i % keyBytes.length];
+  }
+  return result;
+}
+function processRol(data, amount, group) {
+  const bits = amount ?? 1;
+  const groupSize = group ?? 1;
+  if (bits < 0 || bits > 7) {
+    throw new ParseError("ROL amount must be between 0 and 7");
+  }
+  if (groupSize !== 1) {
+    throw new ParseError("ROL with group size > 1 not yet supported");
+  }
+  const result = new Uint8Array(data.length);
+  for (let i = 0; i < data.length; i++) {
+    const byte = data[i];
+    result[i] = (byte << bits | byte >> 8 - bits) & 255;
+  }
+  return result;
+}
+function processRor(data, amount, group) {
+  const bits = amount ?? 1;
+  const groupSize = group ?? 1;
+  if (bits < 0 || bits > 7) {
+    throw new ParseError("ROR amount must be between 0 and 7");
+  }
+  if (groupSize !== 1) {
+    throw new ParseError("ROR with group size > 1 not yet supported");
+  }
+  const result = new Uint8Array(data.length);
+  for (let i = 0; i < data.length; i++) {
+    const byte = data[i];
+    result[i] = (byte >> bits | byte << 8 - bits) & 255;
+  }
+  return result;
+}
+function processByteswap(data, groupSize) {
+  if (![2, 4, 8, 16].includes(groupSize)) {
+    throw new ParseError(
+      `Invalid byteswap group size: ${groupSize}. Must be 2, 4, 8, or 16`
+    );
+  }
+  if (data.length % groupSize !== 0) {
+    throw new ParseError(
+      `Data length ${data.length} is not aligned to group size ${groupSize}`
+    );
+  }
+  const result = new Uint8Array(data.length);
+  for (let i = 0; i < data.length; i += groupSize) {
+    for (let j = 0; j < groupSize; j++) {
+      result[i + j] = data[i + groupSize - 1 - j];
+    }
+  }
+  return result;
+}
+
 // src/interpreter/TypeInterpreter.ts
 var TypeInterpreter = class _TypeInterpreter {
   /**
@@ -1927,18 +2403,38 @@ var TypeInterpreter = class _TypeInterpreter {
       throw new ParseError("Root schema must have meta.id");
     }
   }
+  /**
+   * Safely extract a KaitaiStream from an object that may expose `_io`.
+   * Avoids using `any` casts to satisfy linting.
+   */
+  static getKaitaiIO(val) {
+    if (val && typeof val === "object") {
+      const rec = val;
+      const maybe = rec["_io"];
+      if (maybe instanceof KaitaiStream) return maybe;
+    }
+    return null;
+  }
   /**
    * 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
+   * @param root - Root object of the parse tree (for nested types)
    * @returns Parsed object
    */
-  parse(stream, parent, typeArgs) {
+  parse(stream, parent, typeArgs, root) {
     const result = {};
-    const context = new Context(stream, result, parent, this.schema.enums);
+    const actualRoot = root || result;
+    const context = new Context(stream, actualRoot, parent, this.schema.enums);
     context.current = result;
+    const startPos = stream.pos;
+    result["_io"] = stream;
+    if (root) {
+      ;
+      result["_root"] = root;
+    }
     if (typeArgs && this.schema.params) {
       for (let i = 0; i < this.schema.params.length && i < typeArgs.length; i++) {
         const param = this.schema.params[i];
@@ -1947,6 +2443,9 @@ var TypeInterpreter = class _TypeInterpreter {
         context.set(param.id, evaluatedArg);
       }
     }
+    if (this.schema.instances) {
+      this.setupInstances(result, stream, context);
+    }
     if (this.schema.seq) {
       for (const attr of this.schema.seq) {
         const value = this.parseAttribute(attr, context);
@@ -1955,9 +2454,8 @@ var TypeInterpreter = class _TypeInterpreter {
         }
       }
     }
-    if (this.schema.instances) {
-      this.setupInstances(result, stream, context);
-    }
+    const endPos = stream.pos;
+    result["_sizeof"] = endPos - startPos;
     return result;
   }
   /**
@@ -2041,7 +2539,22 @@ var TypeInterpreter = class _TypeInterpreter {
    * @private
    */
   parseAttribute(attr, context) {
-    const stream = context.io;
+    let stream = context.io;
+    if (attr.io !== void 0) {
+      const ioVal = this.evaluateValue(attr.io, context);
+      if (ioVal instanceof KaitaiStream) {
+        stream = ioVal;
+      } else {
+        const kio = _TypeInterpreter.getKaitaiIO(ioVal);
+        if (kio) {
+          stream = kio;
+        } else {
+          throw new ParseError(
+            "io must evaluate to a KaitaiStream or an object with _io"
+          );
+        }
+      }
+    }
     if (attr.if) {
       const condition = this.evaluateValue(attr.if, context);
       if (!condition) {
@@ -2058,9 +2571,6 @@ var TypeInterpreter = class _TypeInterpreter {
         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);
     }
@@ -2157,7 +2667,7 @@ var TypeInterpreter = class _TypeInterpreter {
       }
       return bytes;
     } else {
-      const encoding = attr.encoding || this.schema.meta.encoding || "UTF-8";
+      const encoding = attr.encoding || this.schema.meta?.encoding || this.parentMeta?.encoding || "UTF-8";
       const str = stream.readStr(expected.length, encoding);
       if (str !== expected) {
         throw new ValidationError(
@@ -2186,7 +2696,7 @@ var TypeInterpreter = class _TypeInterpreter {
         throw new ParseError(`size must be non-negative, got ${size}`);
       }
       if (type === "str" || !type) {
-        const encoding = attr.encoding || this.schema.meta.encoding || "UTF-8";
+        const encoding = attr.encoding || this.schema.meta?.encoding || this.parentMeta?.encoding || "UTF-8";
         let data;
         if (type === "str") {
           data = stream.readBytes(size);
@@ -2212,11 +2722,19 @@ var TypeInterpreter = class _TypeInterpreter {
     }
     if (attr["size-eos"]) {
       if (type === "str") {
-        const encoding = attr.encoding || this.schema.meta.encoding || "UTF-8";
+        const encoding = attr.encoding || this.schema.meta?.encoding || this.parentMeta?.encoding || "UTF-8";
         const bytes = stream.readBytesFull();
         return new TextDecoder(encoding).decode(bytes);
       } else {
-        return stream.readBytesFull();
+        let bytes = stream.readBytesFull();
+        if (attr.process) {
+          bytes = this.applyProcessing(bytes, attr.process);
+        }
+        if (type) {
+          const sub = new KaitaiStream(bytes);
+          return this.parseType(type, sub, context, attr["type-args"]);
+        }
+        return bytes;
       }
     }
     if (!type) {
@@ -2242,11 +2760,13 @@ var TypeInterpreter = class _TypeInterpreter {
         context
       );
     }
-    if (isBuiltinType(type)) {
-      return this.parseBuiltinType(type, stream, context);
+    const { typeName, args } = this.parseParameterizedType(type, context);
+    const effectiveArgs = args.length > 0 ? args : typeArgs;
+    if (isBuiltinType(typeName)) {
+      return this.parseBuiltinType(typeName, stream, context);
     }
-    if (this.schema.types && type in this.schema.types) {
-      const typeSchema = this.schema.types[type];
+    if (this.schema.types && typeName in this.schema.types) {
+      const typeSchema = this.schema.types[typeName];
       const meta = this.schema.meta || this.parentMeta;
       if (this.schema.enums && !typeSchema.enums) {
         typeSchema.enums = this.schema.enums;
@@ -2255,9 +2775,100 @@ var TypeInterpreter = class _TypeInterpreter {
         typeSchema.types = this.schema.types;
       }
       const interpreter = new _TypeInterpreter(typeSchema, meta);
-      return interpreter.parse(stream, context.current, typeArgs);
+      return interpreter.parse(
+        stream,
+        context.current,
+        effectiveArgs,
+        context.root
+      );
+    }
+    throw new ParseError(`Unknown type: ${typeName}`);
+  }
+  /**
+   * Parse parameterized type syntax and extract type name and arguments.
+   * Supports: type_name(arg1, arg2, ...) or just type_name
+   *
+   * @param typeSpec - Type specification string
+   * @param context - Execution context for evaluating argument expressions
+   * @returns Object with typeName and evaluated args
+   * @private
+   */
+  parseParameterizedType(typeSpec, context) {
+    const match = typeSpec.match(/^([a-z_][a-z0-9_]*)\((.*)\)$/i);
+    if (!match) {
+      return { typeName: typeSpec, args: [] };
+    }
+    const typeName = match[1];
+    const argsString = match[2].trim();
+    if (!argsString) {
+      return { typeName, args: [] };
+    }
+    const args = [];
+    let current = "";
+    let inString = false;
+    let stringChar = "";
+    let parenDepth = 0;
+    for (let i = 0; i < argsString.length; i++) {
+      const char = argsString[i];
+      if (inString) {
+        current += char;
+        if (char === stringChar && argsString[i - 1] !== "\\") {
+          inString = false;
+        }
+      } else if (char === '"' || char === "'") {
+        inString = true;
+        stringChar = char;
+        current += char;
+      } else if (char === "(") {
+        parenDepth++;
+        current += char;
+      } else if (char === ")") {
+        parenDepth--;
+        current += char;
+      } else if (char === "," && parenDepth === 0) {
+        args.push(this.parseArgument(current.trim(), context));
+        current = "";
+      } else {
+        current += char;
+      }
+    }
+    if (current.trim()) {
+      args.push(this.parseArgument(current.trim(), context));
+    }
+    return { typeName, args };
+  }
+  /**
+   * Parse and evaluate a single type argument.
+   *
+   * @param arg - Argument string
+   * @param context - Execution context
+   * @returns Evaluated argument value
+   * @private
+   */
+  parseArgument(arg, context) {
+    if (arg === "true") return true;
+    if (arg === "false") return false;
+    if (arg.startsWith('"') && arg.endsWith('"') || arg.startsWith("'") && arg.endsWith("'")) {
+      return arg.slice(1, -1);
+    }
+    if (/^-?\d+$/.test(arg)) {
+      return parseInt(arg, 10);
+    }
+    if (/^-?\d+\.\d+$/.test(arg)) {
+      return parseFloat(arg);
+    }
+    if (/^0x[0-9a-f]+$/i.test(arg)) {
+      return parseInt(arg, 16);
+    }
+    try {
+      const result = this.evaluateValue(arg, context);
+      if (typeof result === "string" || typeof result === "number" || typeof result === "boolean") {
+        return result;
+      }
+      return Number(result);
+    } catch {
+      return arg;
     }
-    throw new ParseError(`Unknown type: ${type}`);
   }
   /**
    * Parse a switch type (type selection based on expression).
@@ -2300,18 +2911,33 @@ var TypeInterpreter = class _TypeInterpreter {
    * @returns Parsed value
    * @private
    */
-  parseBuiltinType(type, stream, _context) {
+  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");
+    let endian;
+    if (typeEndian) {
+      endian = typeEndian;
+    } else if (typeof metaEndian === "string") {
+      endian = metaEndian;
+    } else if (metaEndian && typeof metaEndian === "object") {
+      endian = this.evaluateEndianExpression(metaEndian, context);
+    } else {
+      endian = "le";
+    }
     if (isIntegerType(type)) {
       return this.readInteger(base, endian, stream);
     }
     if (isFloatType(type)) {
       return this.readFloat(base, endian, stream);
     }
+    if (/^b\d+$/.test(type)) {
+      const n = parseInt(type.slice(1), 10);
+      const val = stream.readBitsIntBe(n);
+      const maxSafe = BigInt(Number.MAX_SAFE_INTEGER);
+      return val <= maxSafe ? Number(val) : val;
+    }
     if (isStringType(type)) {
       const encoding = this.schema.meta?.encoding || "UTF-8";
       if (type === "strz") {
@@ -2376,7 +3002,7 @@ var TypeInterpreter = class _TypeInterpreter {
   }
   /**
    * Apply processing transformation to data.
-   * Supports basic transformations like zlib decompression.
+   * Delegates to the process utility module.
    *
    * @param data - Data to process
    * @param process - Processing specification
@@ -2384,13 +3010,35 @@ var TypeInterpreter = class _TypeInterpreter {
    * @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 applyProcess(data, process2);
+  }
+  /**
+   * Evaluate expression-based endianness (switch-on).
+   *
+   * @param endianExpr - Endianness expression with switch-on and cases
+   * @param context - Execution context
+   * @returns Resolved endianness ('le' or 'be')
+   * @private
+   */
+  evaluateEndianExpression(endianExpr, context) {
+    const switchOn = endianExpr["switch-on"];
+    const cases = endianExpr.cases;
+    if (!switchOn || typeof switchOn !== "string") {
+      throw new ParseError('Endian expression missing "switch-on" field');
+    }
+    if (!cases || typeof cases !== "object") {
+      throw new ParseError('Endian expression missing "cases" field');
+    }
+    const switchValue = this.evaluateValue(switchOn, context);
+    const key = String(switchValue);
+    if (key in cases) {
+      const endian = cases[key];
+      if (endian !== "le" && endian !== "be") {
+        throw new ParseError(`Invalid endianness value: ${endian}`);
+      }
+      return endian;
     }
-    return data;
+    return "le";
   }
   /**
    * Evaluate a value that can be an expression or literal.
@@ -2420,16 +3068,6 @@ var TypeInterpreter = class _TypeInterpreter {
   }
 };
 
-// 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
 function getVersion() {
   try {
@@ -2551,6 +3189,43 @@ function readFile(filePath, description) {
     process.exit(1);
   }
 }
+function loadImports(ksyPath, ksyContent, quiet) {
+  const imports = /* @__PURE__ */ new Map();
+  try {
+    const schema = (0, import_yaml2.parse)(ksyContent);
+    if (!schema.meta?.imports || schema.meta.imports.length === 0) {
+      return imports;
+    }
+    const ksyDir = (0, import_path.dirname)((0, import_path.resolve)(ksyPath));
+    for (const importPath of schema.meta.imports) {
+      const normalizedPath = importPath.startsWith("/") ? importPath.slice(1) : importPath;
+      const importFilePath = (0, import_path.resolve)(ksyDir, "..", normalizedPath + ".ksy");
+      if (!(0, import_fs.existsSync)(importFilePath)) {
+        console.error(
+          `Error: Import file not found: ${importFilePath} (from import: ${importPath})`
+        );
+        process.exit(1);
+      }
+      if (!quiet) {
+        console.error(`  Loading import: ${importPath} -> ${importFilePath}`);
+      }
+      const importContent = (0, import_fs.readFileSync)(importFilePath, "utf-8");
+      imports.set(importPath, importContent);
+      const nestedImports = loadImports(importFilePath, importContent, quiet);
+      for (const [nestedPath, nestedContent] of nestedImports) {
+        if (!imports.has(nestedPath)) {
+          imports.set(nestedPath, nestedContent);
+        }
+      }
+    }
+  } catch (error) {
+    console.error(
+      `Error loading imports: ${error instanceof Error ? error.message : String(error)}`
+    );
+    process.exit(1);
+  }
+  return imports;
+}
 function extractField(obj, path) {
   const parts = path.split(".");
   let current = obj;
@@ -2562,17 +3237,44 @@ function extractField(obj, path) {
   }
   return current;
 }
-function jsonReplacer(_key, value) {
-  if (typeof value === "bigint") {
-    return value.toString();
+function safeStringify(data, pretty) {
+  function safeClone(obj, seen = /* @__PURE__ */ new WeakSet()) {
+    if (obj === null || obj === void 0) return obj;
+    if (typeof obj === "bigint") return String(obj);
+    if (typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean")
+      return obj;
+    if (obj instanceof Uint8Array) return Array.from(obj);
+    if (typeof obj === "object") {
+      if (seen.has(obj)) return "[Circular]";
+      seen.add(obj);
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((item) => safeClone(item, seen));
+    }
+    if (typeof obj === "object") {
+      const result = {};
+      const objRecord = obj;
+      for (const key in objRecord) {
+        if (key === "_io" || key === "_root" || key === "_parent") continue;
+        try {
+          const value = objRecord[key];
+          result[key] = safeClone(value, seen);
+        } catch (error) {
+          result[key] = `[Error: ${error instanceof Error ? error.message : "unavailable"}]`;
+        }
+      }
+      return result;
+    }
+    return obj;
   }
-  return value;
+  const safe = safeClone(data);
+  return pretty ? JSON.stringify(safe, null, 2) : JSON.stringify(safe);
 }
 function formatOutput(data, format, pretty) {
   if (format === "yaml") {
-    return JSON.stringify(data, jsonReplacer, 2).replace(/^{$/gm, "").replace(/^}$/gm, "").replace(/^\s*"([^"]+)":\s*/gm, "$1: ").replace(/,$/gm, "");
+    return safeStringify(data, true).replace(/^{$/gm, "").replace(/^}$/gm, "").replace(/^\s*"([^"]+)":\s*/gm, "$1: ").replace(/,$/gm, "");
   }
-  return pretty ? JSON.stringify(data, jsonReplacer, 2) : JSON.stringify(data, jsonReplacer);
+  return safeStringify(data, pretty);
 }
 function main() {
   const { options, positional } = parseCliArgs();
@@ -2608,16 +3310,30 @@ function main() {
   }
   const ksyContent = readFile(ksyFile, "KSY definition file").toString("utf-8");
   const binaryData = readFile(binaryFile, "Binary file");
+  if (!options.quiet) {
+    console.error("Detecting imports...");
+  }
+  const imports = loadImports(ksyFile, ksyContent, options.quiet || false);
+  if (!options.quiet && imports.size > 0) {
+    console.error(`Loaded ${imports.size} import(s)`);
+  }
   const parseOptions = {
     validate: options.validate,
     strict: options.strict
   };
   if (!options.quiet) {
-    console.error("Parsing...");
+    console.error("Parsing schema...");
   }
   let result;
   try {
-    result = parse(ksyContent, binaryData, parseOptions);
+    const parser = new KsyParser();
+    const schema = imports.size > 0 ? parser.parseWithImports(ksyContent, imports, parseOptions) : parser.parse(ksyContent, parseOptions);
+    if (!options.quiet) {
+      console.error("Parsing binary data...");
+    }
+    const stream = new KaitaiStream(binaryData);
+    const interpreter = new TypeInterpreter(schema);
+    result = interpreter.parse(stream);
   } catch (error) {
     console.error(
       `Parse error: ${error instanceof Error ? error.message : String(error)}`
@@ -2664,50 +3380,44 @@ function main() {
 }
 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
+ * @fileoverview Type definitions for Kaitai Struct YAML schema (.ksy files)
+ * @module parser/schema
  * @author Fabiano Pinto
  * @license MIT
  */
 /**
- * @fileoverview Binary stream reader for Kaitai Struct
- * @module stream/KaitaiStream
+ * @fileoverview Custom error classes for Kaitai Struct parsing and validation
+ * @module utils/errors
  * @author Fabiano Pinto
  * @license MIT
  */
 /**
- * @fileoverview Binary stream reading functionality
- * @module stream
+ * @fileoverview Parser for Kaitai Struct YAML (.ksy) files
+ * @module parser/KsyParser
  * @author Fabiano Pinto
  * @license MIT
  */
 /**
- * @fileoverview Type definitions for Kaitai Struct YAML schema (.ksy files)
- * @module parser/schema
+ * @fileoverview Parser module for Kaitai Struct YAML files
+ * @module parser
  * @author Fabiano Pinto
  * @license MIT
  */
 /**
- * @fileoverview Parser for Kaitai Struct YAML (.ksy) files
- * @module parser/KsyParser
+ * @fileoverview Execution context for Kaitai Struct parsing
+ * @module interpreter/Context
  * @author Fabiano Pinto
  * @license MIT
  */
 /**
- * @fileoverview Parser module for Kaitai Struct YAML files
- * @module parser
+ * @fileoverview String encoding and decoding utilities for binary data
+ * @module utils/encoding
  * @author Fabiano Pinto
  * @license MIT
  */
 /**
- * @fileoverview Execution context for Kaitai Struct parsing
- * @module interpreter/Context
+ * @fileoverview Binary stream reader for Kaitai Struct
+ * @module stream/KaitaiStream
  * @author Fabiano Pinto
  * @license MIT
  */
@@ -2747,6 +3457,12 @@ main();
  * @author Fabiano Pinto
  * @license MIT
  */
+/**
+ * @fileoverview Data processing utilities for Kaitai Struct
+ * @module utils/process
+ * @author Fabiano Pinto
+ * @license MIT
+ */
 /**
  * @fileoverview Type interpreter for executing Kaitai Struct schemas
  * @module interpreter/TypeInterpreter
@@ -2760,35 +3476,10 @@ main();
  * @license MIT
  */
 /**
- * @fileoverview Main entry point for kaitai-struct-ts library
- * @module kaitai-struct-ts
+ * @fileoverview Binary stream reading functionality
+ * @module stream
  * @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