jww-parser 2025.12.1 → 2025.12.3

package/dist/index.mjs

@@ -1,4 +1,128 @@
 // src/index.ts
+var JwwErrorCode = /* @__PURE__ */ ((JwwErrorCode2) => {
+  JwwErrorCode2["NOT_INITIALIZED"] = "NOT_INITIALIZED";
+  JwwErrorCode2["WASM_LOAD_FAILED"] = "WASM_LOAD_FAILED";
+  JwwErrorCode2["WASM_TIMEOUT"] = "WASM_TIMEOUT";
+  JwwErrorCode2["INVALID_SIGNATURE"] = "INVALID_SIGNATURE";
+  JwwErrorCode2["UNSUPPORTED_VERSION"] = "UNSUPPORTED_VERSION";
+  JwwErrorCode2["PARSE_ERROR"] = "PARSE_ERROR";
+  JwwErrorCode2["CONVERSION_ERROR"] = "CONVERSION_ERROR";
+  JwwErrorCode2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+  JwwErrorCode2["MEMORY_ERROR"] = "MEMORY_ERROR";
+  JwwErrorCode2["INVALID_ARGUMENT"] = "INVALID_ARGUMENT";
+  return JwwErrorCode2;
+})(JwwErrorCode || {});
+var JwwParserError = class _JwwParserError extends Error {
+  constructor(code, message, options) {
+    super(message);
+    this.name = "JwwParserError";
+    this.code = code;
+    this.cause = options?.cause;
+    this.context = options?.context;
+    this.timestamp = /* @__PURE__ */ new Date();
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _JwwParserError);
+    }
+  }
+  /**
+   * Returns a detailed string representation of the error
+   */
+  toDetailedString() {
+    let details = `[${this.code}] ${this.message}`;
+    if (this.context) {
+      details += `
+Context: ${JSON.stringify(this.context, null, 2)}`;
+    }
+    if (this.cause) {
+      details += `
+Caused by: ${this.cause.message}`;
+    }
+    return details;
+  }
+  /**
+   * Converts the error to a plain object for logging/serialization
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      context: this.context,
+      timestamp: this.timestamp.toISOString(),
+      cause: this.cause?.message,
+      stack: this.stack
+    };
+  }
+};
+var NotInitializedError = class extends JwwParserError {
+  constructor() {
+    super(
+      "NOT_INITIALIZED" /* NOT_INITIALIZED */,
+      "Parser not initialized. Call init() first or use createParser() factory function."
+    );
+    this.name = "NotInitializedError";
+  }
+};
+var WasmLoadError = class extends JwwParserError {
+  constructor(message, cause) {
+    super("WASM_LOAD_FAILED" /* WASM_LOAD_FAILED */, message, { cause });
+    this.name = "WasmLoadError";
+  }
+};
+var ValidationError = class extends JwwParserError {
+  constructor(message, issues) {
+    super("VALIDATION_ERROR" /* VALIDATION_ERROR */, message, {
+      context: { issues }
+    });
+    this.name = "ValidationError";
+    this.issues = issues;
+  }
+};
+var ParseError = class extends JwwParserError {
+  constructor(message, options) {
+    super("PARSE_ERROR" /* PARSE_ERROR */, message, {
+      cause: options?.cause,
+      context: {
+        offset: options?.offset,
+        section: options?.section
+      }
+    });
+    this.name = "ParseError";
+    this.offset = options?.offset;
+    this.section = options?.section;
+  }
+};
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
+  if (bytes < 1024 * 1024 * 1024)
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+function getSizeCategory(bytes) {
+  if (bytes < 100 * 1024) return "small";
+  if (bytes < 1024 * 1024) return "medium";
+  if (bytes < 10 * 1024 * 1024) return "large";
+  return "very_large";
+}
+function createParseError(result) {
+  const message = result.error || "Parse failed";
+  if (message.includes("invalid JWW signature")) {
+    return new ParseError("Invalid JWW file format: missing or corrupt signature", {
+      section: "header",
+      offset: 0
+    });
+  }
+  if (message.includes("unsupported") && message.includes("version")) {
+    return new ParseError(message, {
+      section: "header"
+    });
+  }
+  return new ParseError(message, {
+    offset: result.offset,
+    section: result.section
+  });
+}
 var JwwParser = class {
   /**
    * Create a new JWW parser instance
@@ -7,6 +131,18 @@ var JwwParser = class {
   constructor(wasmPath) {
     this.initialized = false;
     this.initPromise = null;
+    this.goInstance = null;
+    this.wasmInstance = null;
+    // Debug and logging
+    this.debugOptions = { enabled: false };
+    this.debugLogs = [];
+    // Statistics
+    this.stats = {
+      parseCount: 0,
+      totalBytesProcessed: 0,
+      parseTimes: [],
+      errorCount: 0
+    };
     this.wasmPath = wasmPath || this.getDefaultWasmPath();
   }
   getDefaultWasmPath() {
@@ -15,6 +151,75 @@ var JwwParser = class {
     }
     return "jww-parser.wasm";
   }
+  // ===========================================================================
+  // Debug Methods
+  // ===========================================================================
+  /**
+   * Enable or configure debug mode
+   * @param options - Debug configuration options
+   */
+  setDebug(options) {
+    if (typeof options === "boolean") {
+      this.debugOptions = { enabled: options };
+    } else {
+      this.debugOptions = { ...this.debugOptions, ...options };
+    }
+    if (this.initialized && typeof globalThis.jwwSetDebug === "function") {
+      globalThis.jwwSetDebug(this.debugOptions.enabled ?? false);
+    }
+    this.log("info", "Debug mode " + (this.debugOptions.enabled ? "enabled" : "disabled"));
+  }
+  /**
+   * Get debug logs
+   * @param level - Optional minimum log level to filter
+   * @returns Array of debug log entries
+   */
+  getDebugLogs(level) {
+    if (!level) return [...this.debugLogs];
+    const levels = ["debug", "info", "warn", "error"];
+    const minIndex = levels.indexOf(level);
+    return this.debugLogs.filter(
+      (entry) => levels.indexOf(entry.level) >= minIndex
+    );
+  }
+  /**
+   * Clear debug logs
+   */
+  clearDebugLogs() {
+    this.debugLogs = [];
+  }
+  log(level, message, data) {
+    if (!this.debugOptions.enabled) return;
+    const levels = ["debug", "info", "warn", "error"];
+    const minLevel = this.debugOptions.logLevel || "info";
+    if (levels.indexOf(level) < levels.indexOf(minLevel)) return;
+    const entry = {
+      timestamp: /* @__PURE__ */ new Date(),
+      level,
+      message,
+      data: this.debugOptions.includeMemoryUsage ? { ...data, memory: this.getMemoryStats() } : data
+    };
+    this.debugLogs.push(entry);
+    if (this.debugLogs.length > (this.debugOptions.maxLogEntries || 1e3)) {
+      this.debugLogs.shift();
+    }
+    if (this.debugOptions.onDebug) {
+      this.debugOptions.onDebug(entry);
+    }
+    if (this.debugOptions.logToConsole) {
+      const consoleFn = level === "error" ? console.error : level === "warn" ? console.warn : level === "debug" ? console.debug : console.log;
+      consoleFn(`[JwwParser:${level}] ${message}`, data || "");
+    }
+  }
+  // ===========================================================================
+  // Initialization Methods
+  // ===========================================================================
+  /**
+   * Check if the parser is initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
   /**
    * Initialize the WASM module
    * Must be called before using parse methods
@@ -22,43 +227,72 @@ var JwwParser = class {
   async init() {
     if (this.initialized) return;
     if (this.initPromise) return this.initPromise;
+    this.log("info", "Initializing WASM module");
+    const startTime = Date.now();
     this.initPromise = this.loadWasm();
-    await this.initPromise;
-    this.initialized = true;
+    try {
+      await this.initPromise;
+      this.initialized = true;
+      this.log("info", "WASM module initialized", {
+        elapsedMs: Date.now() - startTime
+      });
+    } catch (error) {
+      this.initPromise = null;
+      this.log("error", "WASM initialization failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
   }
   async loadWasm() {
     if (typeof Go === "undefined") {
       await this.loadWasmExec();
     }
-    const go = new Go();
-    let wasmInstance;
-    if (typeof process !== "undefined" && process.versions?.node) {
-      const fs = await import("fs");
-      const path = await import("path");
-      const wasmBuffer = fs.readFileSync(this.wasmPath);
-      const wasmModule = await WebAssembly.compile(wasmBuffer);
-      wasmInstance = await WebAssembly.instantiate(wasmModule, go.importObject);
-    } else {
-      const result = await WebAssembly.instantiateStreaming(
-        fetch(this.wasmPath),
-        go.importObject
-      ).catch(async () => {
-        const response = await fetch(this.wasmPath);
-        const bytes = await response.arrayBuffer();
-        return WebAssembly.instantiate(bytes, go.importObject);
-      });
-      wasmInstance = result.instance;
+    this.goInstance = new Go();
+    try {
+      if (typeof process !== "undefined" && process.versions?.node) {
+        const fs = await import("fs");
+        const wasmBuffer = fs.readFileSync(this.wasmPath);
+        const wasmModule = await WebAssembly.compile(wasmBuffer);
+        this.wasmInstance = await WebAssembly.instantiate(
+          wasmModule,
+          this.goInstance.importObject
+        );
+      } else {
+        const result = await WebAssembly.instantiateStreaming(
+          fetch(this.wasmPath),
+          this.goInstance.importObject
+        ).catch(async () => {
+          const response = await fetch(this.wasmPath);
+          if (!response.ok) {
+            throw new WasmLoadError(
+              `Failed to fetch WASM file: ${response.status} ${response.statusText}`
+            );
+          }
+          const bytes = await response.arrayBuffer();
+          return WebAssembly.instantiate(bytes, this.goInstance.importObject);
+        });
+        this.wasmInstance = result.instance;
+      }
+    } catch (error) {
+      throw new WasmLoadError(
+        `Failed to load WASM module: ${error instanceof Error ? error.message : String(error)}`,
+        error instanceof Error ? error : void 0
+      );
     }
-    go.run(wasmInstance);
+    this.goInstance.run(this.wasmInstance);
     await this.waitForWasmFunctions();
+    if (this.debugOptions.enabled && typeof globalThis.jwwSetDebug === "function") {
+      globalThis.jwwSetDebug(true);
+    }
   }
   async loadWasmExec() {
     if (typeof process !== "undefined" && process.versions?.node) {
       const wasmExecPath = new URL("../wasm/wasm_exec.js", import.meta.url).pathname;
       await import(wasmExecPath);
     } else {
-      throw new Error(
-        "Go runtime not loaded. Please include wasm_exec.js in your HTML."
+      throw new WasmLoadError(
+        "Go runtime not loaded. Please include wasm_exec.js in your HTML before using the parser."
       );
     }
   }
@@ -70,61 +304,420 @@ var JwwParser = class {
       }
       await new Promise((resolve) => setTimeout(resolve, interval));
     }
-    throw new Error("WASM functions not available after timeout");
+    throw new JwwParserError(
+      "WASM_TIMEOUT" /* WASM_TIMEOUT */,
+      "WASM functions not available after timeout. The WASM module may have failed to initialize."
+    );
   }
   ensureInitialized() {
     if (!this.initialized) {
-      throw new Error("Parser not initialized. Call init() first.");
+      throw new NotInitializedError();
+    }
+  }
+  // ===========================================================================
+  // Validation Methods
+  // ===========================================================================
+  /**
+   * Validate a JWW file without fully parsing it
+   * Useful for checking file validity before processing
+   *
+   * @param data - JWW file content as Uint8Array
+   * @returns Validation result with any issues found
+   */
+  validate(data) {
+    const startTime = Date.now();
+    const issues = [];
+    if (data.length < 16) {
+      issues.push({
+        severity: "error",
+        code: "FILE_TOO_SMALL",
+        message: "File is too small to be a valid JWW file",
+        details: { size: data.length, minimumRequired: 16 }
+      });
+    }
+    const signature = new TextDecoder().decode(data.slice(0, 8));
+    if (signature !== "JwwData.") {
+      issues.push({
+        severity: "error",
+        code: "INVALID_SIGNATURE",
+        message: `Invalid file signature: expected "JwwData.", got "${signature.replace(/[^\x20-\x7E]/g, "?")}"`,
+        offset: 0
+      });
+    }
+    let version;
+    if (data.length >= 12) {
+      const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+      version = view.getInt32(8, true);
+      if (version < 200 || version > 1e3) {
+        issues.push({
+          severity: "warning",
+          code: "UNUSUAL_VERSION",
+          message: `Unusual version number: ${version}. Expected between 200-1000.`,
+          details: { version }
+        });
+      }
+    }
+    const estimatedEntityCount = Math.floor(data.length / 75);
+    const sizeCategory = getSizeCategory(data.length);
+    if (sizeCategory === "very_large") {
+      issues.push({
+        severity: "warning",
+        code: "LARGE_FILE",
+        message: `File is very large (${formatBytes(data.length)}). Consider using streaming mode for better performance.`,
+        details: { size: data.length, sizeFormatted: formatBytes(data.length) }
+      });
+    }
+    const hasErrors = issues.some((i) => i.severity === "error");
+    return {
+      valid: !hasErrors,
+      version,
+      sizeCategory,
+      estimatedEntityCount,
+      issues,
+      validationTimeMs: Date.now() - startTime
+    };
+  }
+  /**
+   * Validate and throw if invalid
+   * Convenience method that throws a ValidationError if the file is invalid
+   *
+   * @param data - JWW file content as Uint8Array
+   * @throws {ValidationError} If the file is invalid
+   */
+  validateOrThrow(data) {
+    const result = this.validate(data);
+    if (!result.valid) {
+      throw new ValidationError(
+        "File validation failed: " + result.issues.filter((i) => i.severity === "error").map((i) => i.message).join("; "),
+        result.issues
+      );
     }
   }
+  // ===========================================================================
+  // Parsing Methods
+  // ===========================================================================
   /**
    * Parse a JWW file and return the document structure
+   *
    * @param data - JWW file content as Uint8Array
+   * @param options - Optional parsing options
    * @returns Parsed JWW document
+   * @throws {NotInitializedError} If parser is not initialized
+   * @throws {ParseError} If parsing fails
    */
-  parse(data) {
+  parse(data, options) {
     this.ensureInitialized();
-    const result = globalThis.jwwParse(data);
-    if (!result.ok) {
-      throw new Error(result.error || "Parse failed");
+    if (options?.signal?.aborted) {
+      throw new JwwParserError(
+        "PARSE_ERROR" /* PARSE_ERROR */,
+        "Parse operation was aborted"
+      );
+    }
+    const startTime = Date.now();
+    this.log("info", "Starting parse operation", {
+      dataSize: data.length,
+      options: options ? { ...options, onProgress: void 0 } : void 0
+    });
+    if (options?.onProgress) {
+      options.onProgress({
+        stage: "loading",
+        progress: 0,
+        overallProgress: 0,
+        message: "Loading file data",
+        elapsedMs: 0
+      });
+    }
+    try {
+      const result = globalThis.jwwParse(data);
+      if (!result.ok) {
+        this.stats.errorCount++;
+        throw createParseError(result);
+      }
+      if (options?.onProgress) {
+        options.onProgress({
+          stage: "complete",
+          progress: 100,
+          overallProgress: 100,
+          message: "Parsing complete",
+          elapsedMs: Date.now() - startTime
+        });
+      }
+      const doc = JSON.parse(result.data);
+      let filteredDoc = doc;
+      if (options) {
+        filteredDoc = this.applyParseOptions(doc, options);
+      }
+      const parseTime = Date.now() - startTime;
+      this.stats.parseCount++;
+      this.stats.totalBytesProcessed += data.length;
+      this.stats.parseTimes.push(parseTime);
+      if (this.stats.parseTimes.length > 100) {
+        this.stats.parseTimes.shift();
+      }
+      this.log("info", "Parse complete", {
+        parseTimeMs: parseTime,
+        entityCount: filteredDoc.Entities.length,
+        blockCount: filteredDoc.Blocks.length
+      });
+      return filteredDoc;
+    } catch (error) {
+      this.stats.errorCount++;
+      this.log("error", "Parse failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      if (error instanceof JwwParserError) {
+        throw error;
+      }
+      throw new ParseError(
+        error instanceof Error ? error.message : String(error),
+        { cause: error instanceof Error ? error : void 0 }
+      );
+    }
+  }
+  applyParseOptions(doc, options) {
+    let entities = doc.Entities;
+    let blocks = doc.Blocks;
+    if (options.skipEntityTypes && options.skipEntityTypes.length > 0) {
+      const skipTypes = new Set(options.skipEntityTypes);
+      entities = entities.filter((e) => !skipTypes.has(e.Type));
+    }
+    if (options.layerGroupFilter && options.layerGroupFilter.length > 0) {
+      const groups = new Set(options.layerGroupFilter);
+      entities = entities.filter((e) => groups.has(e.LayerGroup));
+    }
+    if (options.layerFilter) {
+      const filter = options.layerFilter;
+      entities = entities.filter((e) => {
+        const layers = filter[e.LayerGroup];
+        return !layers || layers.includes(e.Layer);
+      });
     }
-    return JSON.parse(result.data);
+    if (options.maxEntities && entities.length > options.maxEntities) {
+      entities = entities.slice(0, options.maxEntities);
+    }
+    if (options.includeBlocks === false) {
+      blocks = [];
+    }
+    return {
+      ...doc,
+      Entities: entities,
+      Blocks: blocks
+    };
   }
   /**
    * Parse a JWW file and convert to DXF document structure
+   *
    * @param data - JWW file content as Uint8Array
+   * @param options - Optional conversion options
    * @returns DXF document object
    */
-  toDxf(data) {
+  toDxf(data, options) {
     this.ensureInitialized();
-    const result = globalThis.jwwToDxf(data);
-    if (!result.ok) {
-      throw new Error(result.error || "Conversion failed");
+    const startTime = Date.now();
+    this.log("info", "Starting DXF conversion", { dataSize: data.length });
+    if (options?.onProgress) {
+      options.onProgress({
+        stage: "converting",
+        progress: 0,
+        overallProgress: 0,
+        message: "Converting to DXF",
+        elapsedMs: 0
+      });
+    }
+    try {
+      const result = globalThis.jwwToDxf(data);
+      if (!result.ok) {
+        this.stats.errorCount++;
+        throw createParseError(result);
+      }
+      if (options?.onProgress) {
+        options.onProgress({
+          stage: "complete",
+          progress: 100,
+          overallProgress: 100,
+          message: "Conversion complete",
+          elapsedMs: Date.now() - startTime
+        });
+      }
+      const doc = JSON.parse(result.data);
+      const parseTime = Date.now() - startTime;
+      this.stats.parseCount++;
+      this.stats.totalBytesProcessed += data.length;
+      this.stats.parseTimes.push(parseTime);
+      this.log("info", "DXF conversion complete", {
+        parseTimeMs: parseTime,
+        entityCount: doc.Entities.length
+      });
+      return doc;
+    } catch (error) {
+      this.stats.errorCount++;
+      this.log("error", "DXF conversion failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      if (error instanceof JwwParserError) {
+        throw error;
+      }
+      throw new ParseError(
+        error instanceof Error ? error.message : String(error),
+        { cause: error instanceof Error ? error : void 0 }
+      );
     }
-    return JSON.parse(result.data);
   }
   /**
    * Parse a JWW file and convert to DXF file content string
+   *
    * @param data - JWW file content as Uint8Array
-   * @returns DXF file content as string
+   * @param options - Optional conversion options
+   * @returns DXF file content as string (ready to save as .dxf file)
    */
-  toDxfString(data) {
+  toDxfString(data, options) {
     this.ensureInitialized();
-    const result = globalThis.jwwToDxfString(data);
-    if (!result.ok) {
-      throw new Error(result.error || "Conversion failed");
+    const startTime = Date.now();
+    this.log("info", "Starting DXF string generation", { dataSize: data.length });
+    try {
+      const result = globalThis.jwwToDxfString(data);
+      if (!result.ok) {
+        this.stats.errorCount++;
+        throw createParseError(result);
+      }
+      const parseTime = Date.now() - startTime;
+      this.stats.parseCount++;
+      this.stats.totalBytesProcessed += data.length;
+      this.stats.parseTimes.push(parseTime);
+      this.log("info", "DXF string generation complete", {
+        parseTimeMs: parseTime,
+        outputLength: result.data.length
+      });
+      return result.data;
+    } catch (error) {
+      this.stats.errorCount++;
+      if (error instanceof JwwParserError) {
+        throw error;
+      }
+      throw new ParseError(
+        error instanceof Error ? error.message : String(error),
+        { cause: error instanceof Error ? error : void 0 }
+      );
+    }
+  }
+  // ===========================================================================
+  // Memory Management
+  // ===========================================================================
+  /**
+   * Get current memory usage statistics
+   */
+  getMemoryStats() {
+    let wasmMemoryBytes = 0;
+    if (this.wasmInstance?.exports.memory) {
+      const memory = this.wasmInstance.exports.memory;
+      wasmMemoryBytes = memory.buffer.byteLength;
+    }
+    let jsHeapBytes;
+    if (typeof process !== "undefined" && typeof process.memoryUsage === "function") {
+      jsHeapBytes = process.memoryUsage().heapUsed;
+    }
+    const totalBytes = wasmMemoryBytes + (jsHeapBytes || 0);
+    return {
+      wasmMemoryBytes,
+      jsHeapBytes,
+      totalBytes,
+      totalFormatted: formatBytes(totalBytes)
+    };
+  }
+  /**
+   * Get parser statistics
+   */
+  getStats() {
+    const parseTimes = this.stats.parseTimes;
+    return {
+      parseCount: this.stats.parseCount,
+      totalBytesProcessed: this.stats.totalBytesProcessed,
+      averageParseTimeMs: parseTimes.length > 0 ? parseTimes.reduce((a, b) => a + b, 0) / parseTimes.length : 0,
+      fastestParseTimeMs: parseTimes.length > 0 ? Math.min(...parseTimes) : 0,
+      slowestParseTimeMs: parseTimes.length > 0 ? Math.max(...parseTimes) : 0,
+      errorCount: this.stats.errorCount,
+      memoryStats: this.getMemoryStats()
+    };
+  }
+  /**
+   * Reset parser statistics
+   */
+  resetStats() {
+    this.stats = {
+      parseCount: 0,
+      totalBytesProcessed: 0,
+      parseTimes: [],
+      errorCount: 0
+    };
+    this.log("debug", "Statistics reset");
+  }
+  /**
+   * Clean up resources and release memory
+   * Call this when you're done using the parser to free WASM memory
+   */
+  dispose() {
+    this.log("info", "Disposing parser resources");
+    this.goInstance = null;
+    this.wasmInstance = null;
+    this.initialized = false;
+    this.initPromise = null;
+    this.stats = {
+      parseCount: 0,
+      totalBytesProcessed: 0,
+      parseTimes: [],
+      errorCount: 0
+    };
+    this.debugLogs = [];
+  }
+  /**
+   * Get the WASM module version
+   */
+  getVersion() {
+    if (typeof globalThis.jwwGetVersion === "function") {
+      return globalThis.jwwGetVersion();
     }
-    return result.data;
+    return "1.0.0";
   }
 };
-async function createParser(wasmPath) {
+async function createParser(wasmPath, options) {
   const parser = new JwwParser(wasmPath);
+  if (options?.debug) {
+    parser.setDebug(options.debug);
+  }
   await parser.init();
   return parser;
 }
-var index_default = { JwwParser, createParser };
+function quickValidate(data) {
+  const parser = new JwwParser();
+  return parser.validate(data);
+}
+function isJwwFile(data) {
+  if (data.length < 8) return false;
+  const signature = new TextDecoder().decode(data.slice(0, 8));
+  return signature === "JwwData.";
+}
+var index_default = {
+  JwwParser,
+  createParser,
+  quickValidate,
+  isJwwFile,
+  JwwParserError,
+  NotInitializedError,
+  WasmLoadError,
+  ValidationError,
+  ParseError,
+  JwwErrorCode
+};
 export {
+  JwwErrorCode,
   JwwParser,
+  JwwParserError,
+  NotInitializedError,
+  ParseError,
+  ValidationError,
+  WasmLoadError,
   createParser,
-  index_default as default
+  index_default as default,
+  isJwwFile,
+  quickValidate
 };