@k67/kaitai-struct-ts 0.7.3 → 0.9.0

package/dist/index.mjs

@@ -549,7 +549,9 @@ var BUILTIN_TYPES = [
   "strz"
 ];
 function isBuiltinType(type) {
-  return BUILTIN_TYPES.includes(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";
@@ -809,11 +811,83 @@ var KsyParser = class {
    * @param imports - Map of import names to their YAML content
    * @param options - Parsing options
    * @returns Parsed schema with resolved imports
-   */
-  parseWithImports(mainYaml, _imports, options = {}) {
+   * @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;
   }
+  /**
+   * 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
+   */
+  extractNamespace(importPath) {
+    const normalized = importPath.startsWith("/") ? importPath.slice(1) : importPath;
+    const segments = normalized.split("/");
+    return segments[segments.length - 1];
+  }
 };
 
 // src/interpreter/Context.ts
@@ -1124,6 +1198,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();
@@ -1335,6 +1420,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 {
@@ -1631,6 +1719,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
@@ -1669,6 +1768,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}`);
     }
@@ -1857,8 +1958,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
@@ -1893,7 +2016,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();
@@ -1919,6 +2043,18 @@ 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.
    *
@@ -1931,6 +2067,7 @@ var TypeInterpreter = class _TypeInterpreter {
     const result = {};
     const context = new Context(stream, result, parent, this.schema.enums);
     context.current = result;
+    result["_io"] = stream;
     if (typeArgs && this.schema.params) {
       for (let i = 0; i < this.schema.params.length && i < typeArgs.length; i++) {
         const param = this.schema.params[i];
@@ -2033,7 +2170,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) {
@@ -2050,9 +2202,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);
     }
@@ -2149,7 +2298,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(
@@ -2178,7 +2327,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);
@@ -2204,11 +2353,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) {
@@ -2304,8 +2461,21 @@ var TypeInterpreter = class _TypeInterpreter {
     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)) {
-      throw new ParseError("String types require size, size-eos, or terminator");
+      const encoding = this.schema.meta?.encoding || "UTF-8";
+      if (type === "strz") {
+        return stream.readStrz(encoding, 0, false, true, true);
+      } else if (type === "str") {
+        throw new ParseError(
+          "str type requires size, size-eos, or terminator attribute"
+        );
+      }
     }
     throw new ParseError(`Unknown built-in type: ${type}`);
   }