jww-parser 2025.12.2 → 2025.12.4

package/dist/index.d.ts

@@ -3,129 +3,829 @@
  *
  * This module provides functionality to parse JWW binary files
  * and convert them to DXF format using WebAssembly.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Error codes for JWW parser operations
+ */
+export declare enum JwwErrorCode {
+    /** Parser has not been initialized */
+    NOT_INITIALIZED = "NOT_INITIALIZED",
+    /** WASM module failed to load */
+    WASM_LOAD_FAILED = "WASM_LOAD_FAILED",
+    /** WASM functions not available after timeout */
+    WASM_TIMEOUT = "WASM_TIMEOUT",
+    /** Invalid JWW file signature */
+    INVALID_SIGNATURE = "INVALID_SIGNATURE",
+    /** Unsupported JWW version */
+    UNSUPPORTED_VERSION = "UNSUPPORTED_VERSION",
+    /** General parse error */
+    PARSE_ERROR = "PARSE_ERROR",
+    /** DXF conversion error */
+    CONVERSION_ERROR = "CONVERSION_ERROR",
+    /** Validation error */
+    VALIDATION_ERROR = "VALIDATION_ERROR",
+    /** Memory allocation error */
+    MEMORY_ERROR = "MEMORY_ERROR",
+    /** Invalid argument provided */
+    INVALID_ARGUMENT = "INVALID_ARGUMENT"
+}
+/**
+ * Base error class for JWW parser errors
+ */
+export declare class JwwParserError extends Error {
+    /** Error code identifying the error type */
+    readonly code: JwwErrorCode;
+    /** Original error that caused this error, if any */
+    readonly cause?: Error;
+    /** Additional context about the error */
+    readonly context?: Record<string, unknown>;
+    /** Timestamp when the error occurred */
+    readonly timestamp: Date;
+    constructor(code: JwwErrorCode, message: string, options?: {
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+    /**
+     * Returns a detailed string representation of the error
+     */
+    toDetailedString(): string;
+    /**
+     * Converts the error to a plain object for logging/serialization
+     */
+    toJSON(): Record<string, unknown>;
+}
+/**
+ * Error thrown when the parser is not initialized
+ */
+export declare class NotInitializedError extends JwwParserError {
+    constructor();
+}
+/**
+ * Error thrown when WASM module fails to load
+ */
+export declare class WasmLoadError extends JwwParserError {
+    constructor(message: string, cause?: Error);
+}
+/**
+ * Error thrown when file validation fails
  */
-interface JwwDocument {
+export declare class ValidationError extends JwwParserError {
+    /** Specific validation issues found */
+    readonly issues: ValidationIssue[];
+    constructor(message: string, issues: ValidationIssue[]);
+}
+/**
+ * Error thrown during parsing
+ */
+export declare class ParseError extends JwwParserError {
+    /** Byte offset where the error occurred, if available */
+    readonly offset?: number;
+    /** Section being parsed when the error occurred */
+    readonly section?: string;
+    constructor(message: string, options?: {
+        cause?: Error;
+        offset?: number;
+        section?: string;
+    });
+}
+/**
+ * Complete JWW document structure
+ */
+export interface JwwDocument {
+    /** JWW file version number */
     Version: number;
+    /** Document memo/comments */
     Memo: string;
+    /** Paper size code */
     PaperSize: number;
-    LayerGroups: LayerGroup[];
+    /** Layer groups (16 groups) */
+    LayerGroups: JwwLayerGroup[];
+    /** All entities in the document */
     Entities: JwwEntity[];
+    /** Block definitions */
     Blocks: JwwBlock[];
 }
-interface LayerGroup {
+/**
+ * JWW layer group containing 16 layers
+ */
+export interface JwwLayerGroup {
+    /** Layer group name */
     Name: string;
-    Layers: Layer[];
+    /** Layers within this group (16 layers) */
+    Layers: JwwLayer[];
 }
-interface Layer {
+/**
+ * JWW layer within a layer group
+ */
+export interface JwwLayer {
+    /** Layer name */
     Name: string;
+    /** Whether the layer is visible */
     Visible: boolean;
+    /** Whether the layer is locked */
     Locked: boolean;
 }
-interface JwwEntityBase {
+/**
+ * Base interface for all JWW entities
+ */
+export interface JwwEntityBase {
+    /** Entity type discriminator */
     Type: string;
+    /** Curve attribute number */
     Group: number;
+    /** Line type/style */
     PenStyle: number;
+    /** Color code */
     PenColor: number;
+    /** Line width */
     PenWidth: number;
+    /** Layer index within the group (0-15) */
     Layer: number;
+    /** Layer group index (0-15) */
     LayerGroup: number;
 }
-interface JwwLine extends JwwEntityBase {
+/**
+ * JWW Line entity
+ */
+export interface JwwLine extends JwwEntityBase {
     Type: "Line";
+    /** Start X coordinate */
     X1: number;
+    /** Start Y coordinate */
     Y1: number;
+    /** End X coordinate */
     X2: number;
+    /** End Y coordinate */
     Y2: number;
 }
-interface JwwArc extends JwwEntityBase {
+/**
+ * JWW Arc entity (includes circles and ellipses)
+ */
+export interface JwwArc extends JwwEntityBase {
     Type: "Arc";
+    /** Center X coordinate */
     CenterX: number;
+    /** Center Y coordinate */
     CenterY: number;
+    /** Arc radius */
     Radius: number;
+    /** Start angle in degrees */
     StartAngle: number;
+    /** End angle in degrees */
     EndAngle: number;
+    /** Flatness ratio (1.0 for circles, other values for ellipses) */
     Flatness: number;
 }
-interface JwwPoint extends JwwEntityBase {
+/**
+ * JWW Point entity
+ */
+export interface JwwPoint extends JwwEntityBase {
     Type: "Point";
+    /** X coordinate */
     X: number;
+    /** Y coordinate */
     Y: number;
+    /** Point code/type */
     Code: number;
 }
-interface JwwText extends JwwEntityBase {
+/**
+ * JWW Text entity
+ */
+export interface JwwText extends JwwEntityBase {
     Type: "Text";
+    /** Text insertion X coordinate */
     X: number;
+    /** Text insertion Y coordinate */
     Y: number;
+    /** Text content */
     Text: string;
+    /** Font name */
     FontName: string;
+    /** Text height */
     Height: number;
+    /** Text width (character width) */
     Width: number;
+    /** Rotation angle in degrees */
     Angle: number;
 }
-interface JwwSolid extends JwwEntityBase {
+/**
+ * JWW Solid (filled polygon) entity
+ */
+export interface JwwSolid extends JwwEntityBase {
     Type: "Solid";
+    /** Array of [x, y] coordinate pairs */
     Points: [number, number][];
 }
-interface JwwBlockRef extends JwwEntityBase {
+/**
+ * JWW Block reference entity
+ */
+export interface JwwBlockRef extends JwwEntityBase {
     Type: "Block";
+    /** Insertion X coordinate */
     X: number;
+    /** Insertion Y coordinate */
     Y: number;
+    /** X scale factor */
     ScaleX: number;
+    /** Y scale factor */
     ScaleY: number;
+    /** Rotation angle in degrees */
     Angle: number;
+    /** Referenced block definition number */
     BlockNumber: number;
 }
-type JwwEntity = JwwLine | JwwArc | JwwPoint | JwwText | JwwSolid | JwwBlockRef;
-interface JwwBlock {
+/**
+ * Union type of all JWW entity types
+ */
+export type JwwEntity = JwwLine | JwwArc | JwwPoint | JwwText | JwwSolid | JwwBlockRef;
+/**
+ * JWW block definition
+ */
+export interface JwwBlock {
+    /** Block name */
     Name: string;
+    /** Entities within the block */
     Entities: JwwEntity[];
 }
-interface DxfDocument {
+/**
+ * DXF document structure
+ */
+export interface DxfDocument {
+    /** DXF layers */
     Layers: DxfLayer[];
+    /** All entities in the document */
     Entities: DxfEntity[];
+    /** Block definitions */
     Blocks: DxfBlock[];
 }
-interface DxfLayer {
+/**
+ * DXF layer definition
+ */
+export interface DxfLayer {
+    /** Layer name */
     Name: string;
+    /** ACI color code (1-255) */
     Color: number;
+    /** Whether the layer is frozen */
     Frozen: boolean;
+    /** Whether the layer is locked */
     Locked: boolean;
 }
-interface DxfEntity {
+/**
+ * Base interface for all DXF entities
+ */
+export interface DxfEntityBase {
+    /** Entity type (LINE, CIRCLE, ARC, etc.) */
     Type: string;
+    /** Layer name */
     Layer: string;
+    /** Optional ACI color code */
     Color?: number;
-    [key: string]: unknown;
+    /** Optional line type name */
+    LineType?: string;
+}
+/**
+ * DXF LINE entity
+ */
+export interface DxfLine extends DxfEntityBase {
+    Type: "LINE";
+    /** Start X coordinate */
+    X1: number;
+    /** Start Y coordinate */
+    Y1: number;
+    /** Start Z coordinate */
+    Z1?: number;
+    /** End X coordinate */
+    X2: number;
+    /** End Y coordinate */
+    Y2: number;
+    /** End Z coordinate */
+    Z2?: number;
 }
-interface DxfBlock {
+/**
+ * DXF CIRCLE entity
+ */
+export interface DxfCircle extends DxfEntityBase {
+    Type: "CIRCLE";
+    /** Center X coordinate */
+    CenterX: number;
+    /** Center Y coordinate */
+    CenterY: number;
+    /** Center Z coordinate */
+    CenterZ?: number;
+    /** Circle radius */
+    Radius: number;
+}
+/**
+ * DXF ARC entity
+ */
+export interface DxfArc extends DxfEntityBase {
+    Type: "ARC";
+    /** Center X coordinate */
+    CenterX: number;
+    /** Center Y coordinate */
+    CenterY: number;
+    /** Center Z coordinate */
+    CenterZ?: number;
+    /** Arc radius */
+    Radius: number;
+    /** Start angle in degrees */
+    StartAngle: number;
+    /** End angle in degrees */
+    EndAngle: number;
+}
+/**
+ * DXF ELLIPSE entity
+ */
+export interface DxfEllipse extends DxfEntityBase {
+    Type: "ELLIPSE";
+    /** Center X coordinate */
+    CenterX: number;
+    /** Center Y coordinate */
+    CenterY: number;
+    /** Center Z coordinate */
+    CenterZ?: number;
+    /** Major axis X component (relative to center) */
+    MajorAxisX: number;
+    /** Major axis Y component (relative to center) */
+    MajorAxisY: number;
+    /** Major axis Z component (relative to center) */
+    MajorAxisZ?: number;
+    /** Minor to major axis ratio (0 to 1) */
+    MinorRatio: number;
+    /** Start parameter (0 to 2*PI) */
+    StartParam: number;
+    /** End parameter (0 to 2*PI) */
+    EndParam: number;
+}
+/**
+ * DXF POINT entity
+ */
+export interface DxfPoint extends DxfEntityBase {
+    Type: "POINT";
+    /** X coordinate */
+    X: number;
+    /** Y coordinate */
+    Y: number;
+    /** Z coordinate */
+    Z?: number;
+}
+/**
+ * DXF TEXT entity
+ */
+export interface DxfText extends DxfEntityBase {
+    Type: "TEXT";
+    /** Insertion X coordinate */
+    X: number;
+    /** Insertion Y coordinate */
+    Y: number;
+    /** Insertion Z coordinate */
+    Z?: number;
+    /** Text height */
+    Height: number;
+    /** Text content */
+    Content: string;
+    /** Rotation angle in degrees */
+    Rotation?: number;
+    /** Text style name */
+    Style?: string;
+}
+/**
+ * DXF MTEXT (multiline text) entity
+ */
+export interface DxfMText extends DxfEntityBase {
+    Type: "MTEXT";
+    /** Insertion X coordinate */
+    X: number;
+    /** Insertion Y coordinate */
+    Y: number;
+    /** Insertion Z coordinate */
+    Z?: number;
+    /** Text height */
+    Height: number;
+    /** Text content (with formatting codes) */
+    Content: string;
+    /** Rotation angle in degrees */
+    Rotation?: number;
+    /** Reference rectangle width */
+    Width?: number;
+}
+/**
+ * DXF SOLID entity (filled triangle or quadrilateral)
+ */
+export interface DxfSolid extends DxfEntityBase {
+    Type: "SOLID";
+    /** First corner X */
+    X1: number;
+    /** First corner Y */
+    Y1: number;
+    /** Second corner X */
+    X2: number;
+    /** Second corner Y */
+    Y2: number;
+    /** Third corner X */
+    X3: number;
+    /** Third corner Y */
+    Y3: number;
+    /** Fourth corner X (same as third for triangles) */
+    X4: number;
+    /** Fourth corner Y (same as third for triangles) */
+    Y4: number;
+}
+/**
+ * DXF INSERT entity (block reference)
+ */
+export interface DxfInsert extends DxfEntityBase {
+    Type: "INSERT";
+    /** Block name */
+    BlockName: string;
+    /** Insertion X coordinate */
+    X: number;
+    /** Insertion Y coordinate */
+    Y: number;
+    /** Insertion Z coordinate */
+    Z?: number;
+    /** X scale factor */
+    ScaleX?: number;
+    /** Y scale factor */
+    ScaleY?: number;
+    /** Z scale factor */
+    ScaleZ?: number;
+    /** Rotation angle in degrees */
+    Rotation?: number;
+}
+/**
+ * DXF POLYLINE vertex
+ */
+export interface DxfVertex {
+    /** X coordinate */
+    X: number;
+    /** Y coordinate */
+    Y: number;
+    /** Z coordinate */
+    Z?: number;
+    /** Bulge factor (for curved segments) */
+    Bulge?: number;
+}
+/**
+ * DXF LWPOLYLINE entity
+ */
+export interface DxfLwPolyline extends DxfEntityBase {
+    Type: "LWPOLYLINE";
+    /** Whether the polyline is closed */
+    Closed: boolean;
+    /** Polyline vertices */
+    Vertices: DxfVertex[];
+}
+/**
+ * Union type of all DXF entity types
+ */
+export type DxfEntity = DxfLine | DxfCircle | DxfArc | DxfEllipse | DxfPoint | DxfText | DxfMText | DxfSolid | DxfInsert | DxfLwPolyline | (DxfEntityBase & Record<string, unknown>);
+/**
+ * DXF block definition
+ */
+export interface DxfBlock {
+    /** Block name */
     Name: string;
+    /** Base point X coordinate */
+    BaseX?: number;
+    /** Base point Y coordinate */
+    BaseY?: number;
+    /** Base point Z coordinate */
+    BaseZ?: number;
+    /** Entities within the block */
     Entities: DxfEntity[];
 }
+/**
+ * Progress stages during parsing
+ */
+export type ProgressStage = "loading" | "parsing_header" | "parsing_layers" | "parsing_entities" | "parsing_blocks" | "converting" | "complete";
+/**
+ * Progress information during parsing
+ */
+export interface ProgressInfo {
+    /** Current stage of parsing */
+    stage: ProgressStage;
+    /** Progress within the current stage (0-100) */
+    progress: number;
+    /** Overall progress (0-100) */
+    overallProgress: number;
+    /** Optional message about current operation */
+    message?: string;
+    /** Number of entities processed so far */
+    entitiesProcessed?: number;
+    /** Total number of entities (if known) */
+    totalEntities?: number;
+    /** Elapsed time in milliseconds */
+    elapsedMs: number;
+    /** Estimated remaining time in milliseconds (if available) */
+    estimatedRemainingMs?: number;
+}
+/**
+ * Callback function for reporting progress
+ */
+export type ProgressCallback = (progress: ProgressInfo) => void;
+/**
+ * Options for parsing JWW files
+ */
+export interface ParseOptions {
+    /**
+     * Enable streaming mode for lower memory usage
+     * When enabled, entities are processed in chunks
+     * @default false
+     */
+    streamingMode?: boolean;
+    /**
+     * Skip parsing of specific entity types
+     * Useful for improving performance when not all entities are needed
+     */
+    skipEntityTypes?: Array<JwwEntity["Type"]>;
+    /**
+     * Only parse entities on specific layer groups
+     * Array of layer group indices (0-15)
+     */
+    layerGroupFilter?: number[];
+    /**
+     * Only parse entities on specific layers
+     * Format: { layerGroup: layerIndex[] }
+     */
+    layerFilter?: Record<number, number[]>;
+    /**
+     * Limit the number of entities to parse
+     * Useful for previewing large files
+     */
+    maxEntities?: number;
+    /**
+     * Include block definitions in the output
+     * @default true
+     */
+    includeBlocks?: boolean;
+    /**
+     * Expand block references inline (replaces INSERT with actual entities)
+     * Warning: May significantly increase output size
+     * @default false
+     */
+    expandBlockReferences?: boolean;
+    /**
+     * Progress callback function
+     * Called periodically during parsing with progress information
+     */
+    onProgress?: ProgressCallback;
+    /**
+     * Abort signal for cancelling the parse operation
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Options for DXF conversion
+ */
+export interface ConvertOptions extends ParseOptions {
+    /**
+     * Convert temporary points (Code > 0)
+     * @default false
+     */
+    includeTemporaryPoints?: boolean;
+    /**
+     * Color mapping override
+     * Maps JWW color codes to DXF ACI colors
+     */
+    colorMapping?: Record<number, number>;
+    /**
+     * Layer naming pattern
+     * Use {group} and {layer} placeholders
+     * @default "{group}-{layer}"
+     */
+    layerNamePattern?: string;
+    /**
+     * Precision for coordinate values (decimal places)
+     * @default 6
+     */
+    precision?: number;
+}
+/**
+ * Severity level for validation issues
+ */
+export type ValidationSeverity = "error" | "warning" | "info";
+/**
+ * A single validation issue
+ */
+export interface ValidationIssue {
+    /** Severity of the issue */
+    severity: ValidationSeverity;
+    /** Issue code */
+    code: string;
+    /** Human-readable message */
+    message: string;
+    /** Byte offset where the issue was found, if applicable */
+    offset?: number;
+    /** Additional details */
+    details?: Record<string, unknown>;
+}
+/**
+ * Result of file validation
+ */
+export interface ValidationResult {
+    /** Whether the file is valid (no errors) */
+    valid: boolean;
+    /** File format version, if detected */
+    version?: number;
+    /** Estimated file size category */
+    sizeCategory: "small" | "medium" | "large" | "very_large";
+    /** Estimated entity count, if detectable */
+    estimatedEntityCount?: number;
+    /** List of validation issues found */
+    issues: ValidationIssue[];
+    /** Validation took this many milliseconds */
+    validationTimeMs: number;
+}
+/**
+ * Debug log levels
+ */
+export type LogLevel = "debug" | "info" | "warn" | "error";
+/**
+ * Debug log entry
+ */
+export interface DebugLogEntry {
+    /** Timestamp of the log entry */
+    timestamp: Date;
+    /** Log level */
+    level: LogLevel;
+    /** Log message */
+    message: string;
+    /** Additional data */
+    data?: Record<string, unknown>;
+}
+/**
+ * Debug callback function
+ */
+export type DebugCallback = (entry: DebugLogEntry) => void;
+/**
+ * Debug options
+ */
+export interface DebugOptions {
+    /**
+     * Enable debug mode
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Minimum log level to capture
+     * @default "info"
+     */
+    logLevel?: LogLevel;
+    /**
+     * Debug callback function
+     * If not provided, logs will be stored internally
+     */
+    onDebug?: DebugCallback;
+    /**
+     * Log to console
+     * @default false
+     */
+    logToConsole?: boolean;
+    /**
+     * Maximum number of log entries to store
+     * @default 1000
+     */
+    maxLogEntries?: number;
+    /**
+     * Include timing information
+     * @default true
+     */
+    includeTiming?: boolean;
+    /**
+     * Include memory usage information
+     * @default false
+     */
+    includeMemoryUsage?: boolean;
+}
+/**
+ * Memory usage statistics
+ */
+export interface MemoryStats {
+    /** WASM memory buffer size in bytes */
+    wasmMemoryBytes: number;
+    /** Estimated JS heap usage in bytes (if available) */
+    jsHeapBytes?: number;
+    /** Total estimated memory usage */
+    totalBytes: number;
+    /** Human-readable total */
+    totalFormatted: string;
+}
+/**
+ * Parser statistics
+ */
+export interface ParserStats {
+    /** Number of parse operations performed */
+    parseCount: number;
+    /** Total bytes processed */
+    totalBytesProcessed: number;
+    /** Average parse time in milliseconds */
+    averageParseTimeMs: number;
+    /** Fastest parse time in milliseconds */
+    fastestParseTimeMs: number;
+    /** Slowest parse time in milliseconds */
+    slowestParseTimeMs: number;
+    /** Number of errors encountered */
+    errorCount: number;
+    /** Current memory usage */
+    memoryStats: MemoryStats;
+}
+/**
+ * Result type from WASM operations
+ * @internal
+ */
 interface WasmResult {
     ok: boolean;
     data?: string;
     error?: string;
+    errorCode?: string;
+    offset?: number;
+    section?: string;
+}
+/**
+ * Validation result from WASM
+ * @internal
+ */
+interface WasmValidationResult {
+    ok: boolean;
+    valid: boolean;
+    version?: number;
+    estimatedEntities?: number;
+    issues?: Array<{
+        severity: string;
+        code: string;
+        message: string;
+        offset?: number;
+    }>;
+    error?: string;
 }
 declare global {
     var Go: new () => GoInstance;
-    var jwwParse: (data: Uint8Array) => WasmResult;
-    var jwwToDxf: (data: Uint8Array) => WasmResult;
-    var jwwToDxfString: (data: Uint8Array) => WasmResult;
+    var jwwParse: ((data: Uint8Array) => WasmResult) | undefined;
+    var jwwToDxf: ((data: Uint8Array) => WasmResult) | undefined;
+    var jwwToDxfString: ((data: Uint8Array) => WasmResult) | undefined;
+    var jwwValidate: ((data: Uint8Array) => WasmValidationResult) | undefined;
+    var jwwGetVersion: (() => string) | undefined;
+    var jwwSetDebug: ((enabled: boolean) => void) | undefined;
 }
 interface GoInstance {
     importObject: WebAssembly.Imports;
     run(instance: WebAssembly.Instance): Promise<void>;
+    _inst?: WebAssembly.Instance;
 }
-declare class JwwParser {
+/**
+ * JWW file parser with WebAssembly backend
+ *
+ * @example
+ * ```typescript
+ * // Using the factory function (recommended)
+ * const parser = await createParser();
+ * const doc = parser.parse(fileData);
+ *
+ * // Manual initialization
+ * const parser = new JwwParser();
+ * await parser.init();
+ * const doc = parser.parse(fileData);
+ * ```
+ */
+export declare class JwwParser {
     private initialized;
     private initPromise;
     private wasmPath;
+    private goInstance;
+    private wasmInstance;
+    private debugOptions;
+    private debugLogs;
+    private stats;
     /**
      * Create a new JWW parser instance
      * @param wasmPath - Path to the jww-parser.wasm file
      */
     constructor(wasmPath?: string);
     private getDefaultWasmPath;
+    /**
+     * Enable or configure debug mode
+     * @param options - Debug configuration options
+     */
+    setDebug(options: DebugOptions | boolean): void;
+    /**
+     * Get debug logs
+     * @param level - Optional minimum log level to filter
+     * @returns Array of debug log entries
+     */
+    getDebugLogs(level?: LogLevel): DebugLogEntry[];
+    /**
+     * Clear debug logs
+     */
+    clearDebugLogs(): void;
+    private log;
+    /**
+     * Check if the parser is initialized
+     */
+    isInitialized(): boolean;
     /**
      * Initialize the WASM module
      * Must be called before using parse methods
@@ -135,34 +835,113 @@ declare class JwwParser {
     private loadWasmExec;
     private waitForWasmFunctions;
     private ensureInitialized;
+    /**
+     * 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: Uint8Array): ValidationResult;
+    /**
+     * 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: Uint8Array): void;
     /**
      * 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: Uint8Array): JwwDocument;
+    parse(data: Uint8Array, options?: ParseOptions): JwwDocument;
+    private applyParseOptions;
     /**
      * 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: Uint8Array): DxfDocument;
+    toDxf(data: Uint8Array, options?: ConvertOptions): DxfDocument;
     /**
      * 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: Uint8Array, options?: ConvertOptions): string;
+    /**
+     * Get current memory usage statistics
+     */
+    getMemoryStats(): MemoryStats;
+    /**
+     * Get parser statistics
+     */
+    getStats(): ParserStats;
+    /**
+     * Reset parser statistics
+     */
+    resetStats(): void;
+    /**
+     * Clean up resources and release memory
+     * Call this when you're done using the parser to free WASM memory
+     */
+    dispose(): void;
+    /**
+     * Get the WASM module version
      */
-    toDxfString(data: Uint8Array): string;
+    getVersion(): string;
 }
 /**
  * Create and initialize a JWW parser instance
+ *
  * @param wasmPath - Optional path to the jww-parser.wasm file
+ * @param options - Optional debug options
  * @returns Initialized JwwParser instance
+ *
+ * @example
+ * ```typescript
+ * const parser = await createParser();
+ * const doc = parser.parse(fileData);
+ * ```
+ */
+export declare function createParser(wasmPath?: string, options?: {
+    debug?: DebugOptions;
+}): Promise<JwwParser>;
+/**
+ * Quick validate a JWW file without initializing a full parser
+ * Performs basic validation only (signature, version check)
+ *
+ * @param data - JWW file content as Uint8Array
+ * @returns Validation result
+ */
+export declare function quickValidate(data: Uint8Array): ValidationResult;
+/**
+ * Check if a Uint8Array looks like a JWW file
+ *
+ * @param data - File content as Uint8Array
+ * @returns true if the file appears to be a JWW file
  */
-declare function createParser(wasmPath?: string): Promise<JwwParser>;
+export declare function isJwwFile(data: Uint8Array): boolean;
 declare const _default: {
     JwwParser: typeof JwwParser;
     createParser: typeof createParser;
+    quickValidate: typeof quickValidate;
+    isJwwFile: typeof isJwwFile;
+    JwwParserError: typeof JwwParserError;
+    NotInitializedError: typeof NotInitializedError;
+    WasmLoadError: typeof WasmLoadError;
+    ValidationError: typeof ValidationError;
+    ParseError: typeof ParseError;
+    JwwErrorCode: typeof JwwErrorCode;
 };
-
-export { type DxfBlock, type DxfDocument, type DxfEntity, type DxfLayer, type JwwArc, type JwwBlock, type JwwBlockRef, type JwwDocument, type JwwEntity, type JwwEntityBase, type JwwLine, JwwParser, type JwwPoint, type JwwSolid, type JwwText, type Layer, type LayerGroup, createParser, _default as default };
+export default _default;
+//# sourceMappingURL=index.d.ts.map