@k67/kaitai-struct-ts 0.6.0 → 0.7.1

package/dist/index.mjs

@@ -151,7 +151,6 @@ var KaitaiStream = class _KaitaiStream {
     if (buffer instanceof ArrayBuffer) {
       this.buffer = new Uint8Array(buffer);
       this.view = new DataView(buffer);
-      this._size = buffer.byteLength;
     } else {
       this.buffer = buffer;
       this.view = new DataView(
@@ -159,7 +158,6 @@ var KaitaiStream = class _KaitaiStream {
         buffer.byteOffset,
         buffer.byteLength
       );
-      this._size = buffer.byteLength;
     }
   }
   /**
@@ -176,13 +174,13 @@ var KaitaiStream = class _KaitaiStream {
    * Total size of the stream in bytes
    */
   get size() {
-    return this._size;
+    return this.buffer.length;
   }
   /**
    * Check if we've reached the end of the stream
    */
   isEof() {
-    return this._pos >= this._size;
+    return this._pos >= this.buffer.length;
   }
   /**
    * Seek to a specific position in the stream
@@ -602,7 +600,6 @@ var KsyParser = class {
       throw new ParseError("KSY file must contain an object");
     }
     const schema = parsed;
-    this.processParametricTypes(schema);
     if (validate) {
       const result = this.validate(schema, { strict });
       if (!result.valid) {
@@ -620,65 +617,6 @@ var KsyParser = class {
     }
     return schema;
   }
-  /**
-   * Process parametric type syntax in schema.
-   * Converts "type_name(arg1, arg2)" to structured format.
-   *
-   * @param schema - Schema to process
-   * @private
-   */
-  processParametricTypes(schema) {
-    if (schema.seq) {
-      for (const attr of schema.seq) {
-        if (typeof attr.type === "string") {
-          this.parseParametricType(attr);
-        }
-      }
-    }
-    if (schema.instances) {
-      for (const instance of Object.values(schema.instances)) {
-        if (typeof instance.type === "string") {
-          this.parseParametricType(instance);
-        }
-      }
-    }
-    if (schema.types) {
-      for (const type of Object.values(schema.types)) {
-        this.processParametricTypes(type);
-      }
-    }
-  }
-  /**
-   * Parse parametric type syntax from a type string.
-   * Converts "type_name(arg1, arg2)" to type + type-args.
-   *
-   * @param attr - Attribute to process
-   * @private
-   */
-  parseParametricType(attr) {
-    if (typeof attr.type !== "string") return;
-    const match = attr.type.match(/^([a-z_][a-z0-9_]*)\((.*)\)$/i);
-    if (!match) return;
-    const [, typeName, argsStr] = match;
-    const args = [];
-    if (argsStr.trim()) {
-      const argParts = argsStr.split(",").map((s) => s.trim());
-      for (const arg of argParts) {
-        const num = Number(arg);
-        if (!isNaN(num)) {
-          args.push(num);
-        } else if (arg === "true") {
-          args.push(true);
-        } else if (arg === "false") {
-          args.push(false);
-        } else {
-          args.push(arg);
-        }
-      }
-    }
-    attr.type = typeName;
-    attr["type-args"] = args;
-  }
   /**
    * Validate a schema object.
    *
@@ -1974,10 +1912,6 @@ var TypeInterpreter = class _TypeInterpreter {
   constructor(schema, parentMeta) {
     this.schema = schema;
     this.parentMeta = parentMeta;
-    // Performance optimization: cache for constant expressions
-    // Limited size to prevent memory leaks
-    this.expressionCache = /* @__PURE__ */ new Map();
-    this.MAX_CACHE_SIZE = 1e3;
     if (!schema.meta && !parentMeta) {
       throw new ParseError("Schema must have meta section");
     }
@@ -2082,10 +2016,7 @@ var TypeInterpreter = class _TypeInterpreter {
           );
         }
       }
-      const value = this.parseAttribute(
-        instance,
-        context
-      );
+      const value = this.parseAttribute(instance, context);
       return value;
     } finally {
       if (instance.pos !== void 0) {
@@ -2122,11 +2053,6 @@ var TypeInterpreter = class _TypeInterpreter {
     if (attr.io) {
       throw new NotImplementedError("Custom I/O streams");
     }
-    if (!attr.type && !attr.size && !attr["size-eos"] && !attr.contents) {
-      throw new ParseError(
-        `Attribute "${attr.id || "unknown"}" must have type, size, size-eos, or contents`
-      );
-    }
     if (attr.repeat) {
       return this.parseRepeated(attr, context);
     }
@@ -2176,13 +2102,7 @@ var TypeInterpreter = class _TypeInterpreter {
           throw new ParseError("repeat-until expression is required");
         }
         let index = 0;
-        const maxIterations = 1e6;
         while (true) {
-          if (index >= maxIterations) {
-            throw new ParseError(
-              `repeat-until exceeded maximum iterations (${maxIterations}). Possible infinite loop.`
-            );
-          }
           context.set("_index", index);
           const value = this.parseAttribute(
             { ...attr, repeat: void 0, "repeat-until": void 0 },
@@ -2257,11 +2177,6 @@ var TypeInterpreter = class _TypeInterpreter {
       if (size < 0) {
         throw new ParseError(`size must be non-negative, got ${size}`);
       }
-      if (stream.pos + size > stream.size) {
-        throw new ParseError(
-          `Not enough data: need ${size} bytes at position ${stream.pos}, but only ${stream.size - stream.pos} bytes available`
-        );
-      }
       if (type === "str" || !type) {
         const encoding = attr.encoding || this.schema.meta.encoding || "UTF-8";
         let data;
@@ -2383,13 +2298,6 @@ var TypeInterpreter = class _TypeInterpreter {
     const meta = this.schema.meta || this.parentMeta;
     const metaEndian = meta?.endian;
     const endian = typeEndian || (typeof metaEndian === "string" ? metaEndian : "le");
-    if (type.startsWith("b") && type.length > 1) {
-      const bits = parseInt(type.substring(1), 10);
-      if (!isNaN(bits) && bits >= 1 && bits <= 64) {
-        const value = endian === "be" ? stream.readBitsIntBe(bits) : stream.readBitsIntLe(bits);
-        return bits <= 32 ? Number(value) : value;
-      }
-    }
     if (isIntegerType(type)) {
       return this.readInteger(base, endian, stream);
     }
@@ -2485,21 +2393,8 @@ var TypeInterpreter = class _TypeInterpreter {
       return value;
     }
     if (typeof value === "string") {
-      if (!value.includes("_") && !value.includes(".")) {
-        const cached = this.expressionCache.get(value);
-        if (cached !== void 0) {
-          return cached;
-        }
-      }
       try {
-        const result = evaluateExpression(value, context);
-        if (!value.includes("_") && !value.includes(".")) {
-          if (this.expressionCache.size >= this.MAX_CACHE_SIZE) {
-            this.expressionCache.clear();
-          }
-          this.expressionCache.set(value, result);
-        }
-        return result;
+        return evaluateExpression(value, context);
       } catch (error) {
         throw new ParseError(
           `Failed to evaluate expression "${value}": ${error instanceof Error ? error.message : String(error)}`
@@ -2639,7 +2534,7 @@ export {
  * @module kaitai-struct-ts
  * @author Fabiano Pinto
  * @license MIT
- * @version 0.6.0
+ * @version 0.2.0
  *
  * @description
  * A runtime interpreter for Kaitai Struct binary format definitions in TypeScript.