rar-stream 4.0.0 → 4.0.2

package/README.md

@@ -30,24 +30,133 @@ pnpm add rar-stream
 ```javascript
 import { LocalFileMedia, RarFilesPackage } from 'rar-stream';
 
-// Single RAR file
+// Open a RAR archive
 const media = new LocalFileMedia('./archive.rar');
 const pkg = new RarFilesPackage([media]);
 
-// Parse archive and get inner files
+// Parse and list inner files
 const files = await pkg.parse();
 
 for (const file of files) {
   console.log(`${file.name}: ${file.length} bytes`);
   
-  // Read entire file
+  // Read entire file into memory
   const buffer = await file.readToEnd();
   
-  // Or read a specific range
-  const chunk = await file.createReadStream({ start: 0, end: 1024 });
+  // Or read a specific byte range (for streaming)
+  const chunk = await file.createReadStream({ start: 0, end: 1023 });
 }
 ```
 
+## Examples
+
+### Extract a File to Disk
+
+```javascript
+import { LocalFileMedia, RarFilesPackage } from 'rar-stream';
+import fs from 'fs';
+
+const media = new LocalFileMedia('./archive.rar');
+const pkg = new RarFilesPackage([media]);
+const files = await pkg.parse();
+
+// Find a specific file
+const targetFile = files.find(f => f.name.endsWith('.txt'));
+if (targetFile) {
+  const content = await targetFile.readToEnd();
+  fs.writeFileSync('./extracted.txt', content);
+  console.log(`Extracted ${targetFile.name} (${content.length} bytes)`);
+}
+```
+
+### Stream Video from RAR (Partial Reads)
+
+```javascript
+import { LocalFileMedia, RarFilesPackage } from 'rar-stream';
+
+const media = new LocalFileMedia('./movie.rar');
+const pkg = new RarFilesPackage([media]);
+const files = await pkg.parse();
+
+const video = files.find(f => f.name.endsWith('.mkv'));
+if (video) {
+  // Read first 1MB for header analysis
+  const header = await video.createReadStream({ start: 0, end: 1024 * 1024 - 1 });
+  console.log(`Video: ${video.name}, Total size: ${video.length} bytes`);
+  
+  // Stream in chunks
+  const chunkSize = 1024 * 1024; // 1MB chunks
+  for (let offset = 0; offset < video.length; offset += chunkSize) {
+    const end = Math.min(offset + chunkSize - 1, video.length - 1);
+    const chunk = await video.createReadStream({ start: offset, end });
+    // Process chunk...
+  }
+}
+```
+
+### Multi-Volume Archives
+
+```javascript
+import { LocalFileMedia, RarFilesPackage } from 'rar-stream';
+import fs from 'fs';
+import path from 'path';
+
+// Find all volumes in a directory
+const dir = './my-archive';
+const volumeFiles = fs.readdirSync(dir)
+  .filter(f => /\.(rar|r\d{2})$/i.test(f))
+  .sort()
+  .map(f => new LocalFileMedia(path.join(dir, f)));
+
+console.log(`Found ${volumeFiles.length} volumes`);
+
+const pkg = new RarFilesPackage(volumeFiles);
+const files = await pkg.parse();
+
+// Files spanning multiple volumes are handled automatically
+for (const file of files) {
+  console.log(`${file.name}: ${file.length} bytes`);
+}
+```
+
+### Check if a File is a RAR Archive
+
+```javascript
+import { isRarArchive, parseRarHeader } from 'rar-stream';
+import fs from 'fs';
+
+// Read first 300 bytes (enough for header detection)
+const buffer = Buffer.alloc(300);
+const fd = fs.openSync('./unknown-file', 'r');
+fs.readSync(fd, buffer, 0, 300, 0);
+fs.closeSync(fd);
+
+if (isRarArchive(buffer)) {
+  const info = parseRarHeader(buffer);
+  if (info) {
+    console.log(`First file: ${info.name}`);
+    console.log(`Packed size: ${info.packedSize} bytes`);
+    console.log(`Unpacked size: ${info.unpackedSize} bytes`);
+    console.log(`Compression method: 0x${info.method.toString(16)}`);
+  }
+} else {
+  console.log('Not a RAR archive');
+}
+```
+
+### Limit Number of Files Parsed
+
+```javascript
+import { LocalFileMedia, RarFilesPackage } from 'rar-stream';
+
+const media = new LocalFileMedia('./large-archive.rar');
+const pkg = new RarFilesPackage([media]);
+
+// Only parse first 10 files (useful for previewing large archives)
+const files = await pkg.parse({ maxFiles: 10 });
+console.log(`Showing first ${files.length} files`);
+```
+
 ## API Reference
 
 ### LocalFileMedia
@@ -58,8 +167,8 @@ Represents a local RAR file.
 class LocalFileMedia {
   constructor(path: string);
   
-  readonly name: string;
-  readonly length: number;
+  readonly name: string;    // Filename (basename)
+  readonly length: number;  // File size in bytes
   
   createReadStream(opts: { start: number; end: number }): Promise<Buffer>;
 }
@@ -74,7 +183,7 @@ class RarFilesPackage {
   constructor(files: LocalFileMedia[]);
   
   parse(opts?: {
-    maxFiles?: number;
+    maxFiles?: number;  // Limit number of files to parse
   }): Promise<InnerFile[]>;
 }
 ```
@@ -85,8 +194,8 @@ Represents a file inside the RAR archive.
 
 ```typescript
 class InnerFile {
-  readonly name: string;
-  readonly length: number;
+  readonly name: string;    // Full path inside archive
+  readonly length: number;  // Uncompressed size in bytes
   
   readToEnd(): Promise<Buffer>;
   createReadStream(opts: { start: number; end: number }): Promise<Buffer>;
@@ -96,45 +205,18 @@ class InnerFile {
 ### Utility Functions
 
 ```typescript
-// Check if buffer contains RAR signature
+// Check if buffer starts with RAR signature
 function isRarArchive(buffer: Buffer): boolean;
 
-// Parse RAR header from buffer (useful for detecting files)
+// Parse RAR header from buffer (needs ~300 bytes)
 function parseRarHeader(buffer: Buffer): RarFileInfo | null;
-```
-
-## Multi-Volume Archives
-
-```javascript
-import { LocalFileMedia, RarFilesPackage } from 'rar-stream';
-
-// Load all volumes
-const volumes = [
-  new LocalFileMedia('./archive.rar'),
-  new LocalFileMedia('./archive.r00'),
-  new LocalFileMedia('./archive.r01'),
-];
-
-const pkg = new RarFilesPackage(volumes);
-const files = await pkg.parse();
 
-// Files spanning multiple volumes are handled automatically
-const content = await files[0].readToEnd();
-```
-
-## Browser Usage (WASM)
-
-```javascript
-import init, { isRarArchive, WasmRarDecoder } from 'rar-stream/wasm';
-
-await init();
-
-// Check if data is a RAR archive
-const buffer = new Uint8Array(/* ... */);
-if (isRarArchive(buffer)) {
-  // Create decoder
-  const decoder = new WasmRarDecoder(unpackedSize);
-  const decompressed = decoder.decompress(compressedData);
+interface RarFileInfo {
+  name: string;
+  packedSize: number;
+  unpackedSize: number;
+  method: number;
+  continuesInNext: boolean;
 }
 ```
 
@@ -149,9 +231,9 @@ if (isRarArchive(buffer)) {
 
 ## Performance
 
-Benchmarks on M1 MacBook Pro:
+Benchmarks on M1 MacBook Pro (v4.x vs v3.x):
 
-| Operation | rar-stream v2 (Rust) | rar-stream v1 (JS) |
+| Operation | rar-stream v4 (Rust) | rar-stream v3 (JS) |
 |-----------|---------------------|-------------------|
 | Parse 1GB archive | ~50ms | ~200ms |
 | Decompress 100MB | ~800ms | ~3000ms |
@@ -159,7 +241,7 @@ Benchmarks on M1 MacBook Pro:
 
 ## Migrating from v3.x
 
-rar-stream v4.0 is a complete Rust rewrite with the same API. It's a drop-in replacement:
+rar-stream v4 is a complete Rust rewrite with the same API. It's a drop-in replacement:
 
 ```javascript
 // Works the same in v3.x and v4.x
@@ -173,12 +255,11 @@ const files = await pkg.parse();
 ### Breaking Changes
 
 - Node.js 18+ required (was 14+)
-- WASM module path changed to `rar-stream/wasm`
 - Native Rust implementation (faster, lower memory)
 
 ## License
 
-MIT © beam.cat
+MIT
 
 ## Credits
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rar-stream",
-  "version": "4.0.0",
+  "version": "4.0.2",
   "description": "RAR streaming library - Rust implementation with NAPI and WASM bindings",
   "main": "index.js",
   "browser": "browser.js",
@@ -56,7 +56,8 @@
     "build": "napi build --platform --release --features napi",
     "build:debug": "napi build --platform --features napi",
     "build:wasm": "wasm-pack build --target web --features wasm --no-default-features",
-    "lint": "eslint . && cargo clippy --all-features -- -D warnings",
+    "lint": "eslint .",
+    "lint:rust": "cargo clippy --features napi -- -D warnings && cargo clippy --features wasm --no-default-features -- -D warnings",
     "lint:fix": "eslint . --fix",
     "format": "cargo fmt && prettier --write '**/*.{ts,js,json,md}'",
     "format:check": "cargo fmt --check && prettier --check '**/*.{ts,js,json,md}'",
@@ -88,12 +89,12 @@
     "*.node"
   ],
   "optionalDependencies": {
-    "rar-stream-win32-x64-msvc": "4.0.0",
-    "rar-stream-darwin-x64": "4.0.0",
-    "rar-stream-linux-x64-gnu": "4.0.0",
-    "rar-stream-linux-x64-musl": "4.0.0",
-    "rar-stream-linux-arm64-gnu": "4.0.0",
-    "rar-stream-darwin-arm64": "4.0.0",
-    "rar-stream-linux-arm64-musl": "4.0.0"
+    "rar-stream-win32-x64-msvc": "4.0.2",
+    "rar-stream-darwin-x64": "4.0.2",
+    "rar-stream-linux-x64-gnu": "4.0.2",
+    "rar-stream-linux-x64-musl": "4.0.2",
+    "rar-stream-linux-arm64-gnu": "4.0.2",
+    "rar-stream-darwin-arm64": "4.0.2",
+    "rar-stream-linux-arm64-musl": "4.0.2"
   }
 }

package/pkg/rar_stream.d.ts

@@ -1,90 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-
-/**
- * WASM-compatible RAR decompressor.
- */
-export class WasmRarDecoder {
-    free(): void;
-    [Symbol.dispose](): void;
-    /**
-     * Get total bytes decompressed so far.
-     */
-    bytes_written(): bigint;
-    /**
-     * Decompress a chunk of data.
-     */
-    decompress(data: Uint8Array): Uint8Array;
-    /**
-     * Check if decompression is complete.
-     */
-    is_complete(): boolean;
-    /**
-     * Create a new decoder for the specified unpacked size.
-     */
-    constructor(unpacked_size: bigint);
-    /**
-     * Reset the decoder for a new file.
-     */
-    reset(): void;
-}
-
-/**
- * Get the RAR format version from a buffer.
- * Returns 15 for RAR 1.5-4.x, 50 for RAR 5.0+, or 0 if not a RAR archive.
- */
-export function get_rar_version(data: Uint8Array): number;
-
-/**
- * Check if a buffer contains a RAR signature.
- */
-export function is_rar_archive(data: Uint8Array): boolean;
-
-/**
- * Parse RAR file header information.
- */
-export function parse_rar_header(data: Uint8Array): any;
-
-export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
-
-export interface InitOutput {
-    readonly memory: WebAssembly.Memory;
-    readonly __wbg_wasmrardecoder_free: (a: number, b: number) => void;
-    readonly get_rar_version: (a: number, b: number) => number;
-    readonly is_rar_archive: (a: number, b: number) => number;
-    readonly parse_rar_header: (a: number, b: number) => [number, number, number];
-    readonly wasmrardecoder_bytes_written: (a: number) => bigint;
-    readonly wasmrardecoder_decompress: (a: number, b: number, c: number) => [number, number, number, number];
-    readonly wasmrardecoder_is_complete: (a: number) => number;
-    readonly wasmrardecoder_new: (a: bigint) => number;
-    readonly wasmrardecoder_reset: (a: number) => void;
-    readonly __wbindgen_exn_store: (a: number) => void;
-    readonly __externref_table_alloc: () => number;
-    readonly __wbindgen_externrefs: WebAssembly.Table;
-    readonly __wbindgen_malloc: (a: number, b: number) => number;
-    readonly __externref_table_dealloc: (a: number) => void;
-    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
-    readonly __wbindgen_start: () => void;
-}
-
-export type SyncInitInput = BufferSource | WebAssembly.Module;
-
-/**
- * Instantiates the given `module`, which can either be bytes or
- * a precompiled `WebAssembly.Module`.
- *
- * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
- *
- * @returns {InitOutput}
- */
-export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
-
-/**
- * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
- * for everything else, calls `WebAssembly.instantiate` directly.
- *
- * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
- *
- * @returns {Promise<InitOutput>}
- */
-export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/pkg/rar_stream.js

@@ -1,308 +0,0 @@
-/* @ts-self-types="./rar_stream.d.ts" */
-
-/**
- * WASM-compatible RAR decompressor.
- */
-export class WasmRarDecoder {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmRarDecoderFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmrardecoder_free(ptr, 0);
-    }
-    /**
-     * Get total bytes decompressed so far.
-     * @returns {bigint}
-     */
-    bytes_written() {
-        const ret = wasm.wasmrardecoder_bytes_written(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
-    }
-    /**
-     * Decompress a chunk of data.
-     * @param {Uint8Array} data
-     * @returns {Uint8Array}
-     */
-    decompress(data) {
-        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmrardecoder_decompress(this.__wbg_ptr, ptr0, len0);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v2;
-    }
-    /**
-     * Check if decompression is complete.
-     * @returns {boolean}
-     */
-    is_complete() {
-        const ret = wasm.wasmrardecoder_is_complete(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Create a new decoder for the specified unpacked size.
-     * @param {bigint} unpacked_size
-     */
-    constructor(unpacked_size) {
-        const ret = wasm.wasmrardecoder_new(unpacked_size);
-        this.__wbg_ptr = ret >>> 0;
-        WasmRarDecoderFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Reset the decoder for a new file.
-     */
-    reset() {
-        wasm.wasmrardecoder_reset(this.__wbg_ptr);
-    }
-}
-if (Symbol.dispose) WasmRarDecoder.prototype[Symbol.dispose] = WasmRarDecoder.prototype.free;
-
-/**
- * Get the RAR format version from a buffer.
- * Returns 15 for RAR 1.5-4.x, 50 for RAR 5.0+, or 0 if not a RAR archive.
- * @param {Uint8Array} data
- * @returns {number}
- */
-export function get_rar_version(data) {
-    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.get_rar_version(ptr0, len0);
-    return ret;
-}
-
-/**
- * Check if a buffer contains a RAR signature.
- * @param {Uint8Array} data
- * @returns {boolean}
- */
-export function is_rar_archive(data) {
-    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.is_rar_archive(ptr0, len0);
-    return ret !== 0;
-}
-
-/**
- * Parse RAR file header information.
- * @param {Uint8Array} data
- * @returns {any}
- */
-export function parse_rar_header(data) {
-    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.parse_rar_header(ptr0, len0);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
-function __wbg_get_imports() {
-    const import0 = {
-        __proto__: null,
-        __wbg_Error_8c4e43fe74559d73: function(arg0, arg1) {
-            const ret = Error(getStringFromWasm0(arg0, arg1));
-            return ret;
-        },
-        __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
-            throw new Error(getStringFromWasm0(arg0, arg1));
-        },
-        __wbg_new_361308b2356cecd0: function() {
-            const ret = new Object();
-            return ret;
-        },
-        __wbg_set_6cb8631f80447a67: function() { return handleError(function (arg0, arg1, arg2) {
-            const ret = Reflect.set(arg0, arg1, arg2);
-            return ret;
-        }, arguments); },
-        __wbindgen_cast_0000000000000001: function(arg0) {
-            // Cast intrinsic for `F64 -> Externref`.
-            const ret = arg0;
-            return ret;
-        },
-        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Ref(String) -> Externref`.
-            const ret = getStringFromWasm0(arg0, arg1);
-            return ret;
-        },
-        __wbindgen_init_externref_table: function() {
-            const table = wasm.__wbindgen_externrefs;
-            const offset = table.grow(4);
-            table.set(0, undefined);
-            table.set(offset + 0, undefined);
-            table.set(offset + 1, null);
-            table.set(offset + 2, true);
-            table.set(offset + 3, false);
-        },
-    };
-    return {
-        __proto__: null,
-        "./rar_stream_bg.js": import0,
-    };
-}
-
-const WasmRarDecoderFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmrardecoder_free(ptr >>> 0, 1));
-
-function addToExternrefTable0(obj) {
-    const idx = wasm.__externref_table_alloc();
-    wasm.__wbindgen_externrefs.set(idx, obj);
-    return idx;
-}
-
-function getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
-}
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return decodeText(ptr, len);
-}
-
-let cachedUint8ArrayMemory0 = null;
-function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8ArrayMemory0;
-}
-
-function handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        const idx = addToExternrefTable0(e);
-        wasm.__wbindgen_exn_store(idx);
-    }
-}
-
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_externrefs.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
-}
-
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-cachedTextDecoder.decode();
-const MAX_SAFARI_DECODE_BYTES = 2146435072;
-let numBytesDecoded = 0;
-function decodeText(ptr, len) {
-    numBytesDecoded += len;
-    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
-        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-        cachedTextDecoder.decode();
-        numBytesDecoded = len;
-    }
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
-let WASM_VECTOR_LEN = 0;
-
-let wasmModule, wasm;
-function __wbg_finalize_init(instance, module) {
-    wasm = instance.exports;
-    wasmModule = module;
-    cachedUint8ArrayMemory0 = null;
-    wasm.__wbindgen_start();
-    return wasm;
-}
-
-async function __wbg_load(module, imports) {
-    if (typeof Response === 'function' && module instanceof Response) {
-        if (typeof WebAssembly.instantiateStreaming === 'function') {
-            try {
-                return await WebAssembly.instantiateStreaming(module, imports);
-            } catch (e) {
-                const validResponse = module.ok && expectedResponseType(module.type);
-
-                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
-                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
-
-                } else { throw e; }
-            }
-        }
-
-        const bytes = await module.arrayBuffer();
-        return await WebAssembly.instantiate(bytes, imports);
-    } else {
-        const instance = await WebAssembly.instantiate(module, imports);
-
-        if (instance instanceof WebAssembly.Instance) {
-            return { instance, module };
-        } else {
-            return instance;
-        }
-    }
-
-    function expectedResponseType(type) {
-        switch (type) {
-            case 'basic': case 'cors': case 'default': return true;
-        }
-        return false;
-    }
-}
-
-function initSync(module) {
-    if (wasm !== undefined) return wasm;
-
-
-    if (module !== undefined) {
-        if (Object.getPrototypeOf(module) === Object.prototype) {
-            ({module} = module)
-        } else {
-            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
-        }
-    }
-
-    const imports = __wbg_get_imports();
-    if (!(module instanceof WebAssembly.Module)) {
-        module = new WebAssembly.Module(module);
-    }
-    const instance = new WebAssembly.Instance(module, imports);
-    return __wbg_finalize_init(instance, module);
-}
-
-async function __wbg_init(module_or_path) {
-    if (wasm !== undefined) return wasm;
-
-
-    if (module_or_path !== undefined) {
-        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
-            ({module_or_path} = module_or_path)
-        } else {
-            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
-        }
-    }
-
-    if (module_or_path === undefined) {
-        module_or_path = new URL('rar_stream_bg.wasm', import.meta.url);
-    }
-    const imports = __wbg_get_imports();
-
-    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
-        module_or_path = fetch(module_or_path);
-    }
-
-    const { instance, module } = await __wbg_load(await module_or_path, imports);
-
-    return __wbg_finalize_init(instance, module);
-}
-
-export { initSync, __wbg_init as default };

package/pkg/rar_stream_bg.wasm.d.ts

@@ -1,19 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-export const memory: WebAssembly.Memory;
-export const __wbg_wasmrardecoder_free: (a: number, b: number) => void;
-export const get_rar_version: (a: number, b: number) => number;
-export const is_rar_archive: (a: number, b: number) => number;
-export const parse_rar_header: (a: number, b: number) => [number, number, number];
-export const wasmrardecoder_bytes_written: (a: number) => bigint;
-export const wasmrardecoder_decompress: (a: number, b: number, c: number) => [number, number, number, number];
-export const wasmrardecoder_is_complete: (a: number) => number;
-export const wasmrardecoder_new: (a: bigint) => number;
-export const wasmrardecoder_reset: (a: number) => void;
-export const __wbindgen_exn_store: (a: number) => void;
-export const __externref_table_alloc: () => number;
-export const __wbindgen_externrefs: WebAssembly.Table;
-export const __wbindgen_malloc: (a: number, b: number) => number;
-export const __externref_table_dealloc: (a: number) => void;
-export const __wbindgen_free: (a: number, b: number, c: number) => void;
-export const __wbindgen_start: () => void;