lavinhash 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 LavinHash Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,501 @@
+# LavinHash
+
+High-performance fuzzy hashing library implementing the Dual-Layer Adaptive Hashing (DLAH) algorithm for detecting file and text similarity.
+
+## Overview
+
+LavinHash is a Rust-based fuzzy hashing library that analyzes both structural patterns and content features to compute similarity scores between data. The library uses a dual-layer approach that separates structural similarity (topology) from content similarity (semantic features), providing accurate similarity detection even for modified or partially similar data.
+
+**Key Features:**
+
+- Dual-layer similarity analysis (structure + content)
+- Adaptive scaling for constant-time comparison regardless of file size
+- Cross-platform support (Linux, macOS, Windows, WebAssembly)
+- High performance with SIMD optimizations and parallel processing
+- Multiple language bindings (JavaScript/TypeScript, with more planned)
+- Deterministic hashing across all platforms
+
+## Installation
+
+### JavaScript/TypeScript (npm)
+
+```bash
+npm install lavinhash
+```
+
+### Rust (crates.io)
+
+```toml
+[dependencies]
+lavinhash = "1.0"
+```
+
+### Building from Source
+
+```bash
+git clone https://github.com/RafaCalRob/LavinHash.git
+cd LavinHash
+cargo build --release
+```
+
+## Quick Start
+
+### React (Vite, Create React App, Next.js)
+
+```javascript
+import { wasm_compare_data } from 'lavinhash';
+
+function App() {
+  const checkSimilarity = () => {
+    const encoder = new TextEncoder();
+    const text1 = encoder.encode("The quick brown fox jumps over the lazy dog");
+    const text2 = encoder.encode("The quick brown fox leaps over the lazy dog");
+
+    const similarity = wasm_compare_data(text1, text2);
+    console.log(`Similarity: ${similarity}%`); // Output: Similarity: 95%
+  };
+
+  return <button onClick={checkSimilarity}>Check Similarity</button>;
+}
+```
+
+### Angular
+
+```typescript
+import { Component } from '@angular/core';
+import { wasm_compare_data } from 'lavinhash';
+
+@Component({
+  selector: 'app-root',
+  template: '<button (click)="checkSimilarity()">Check Similarity</button>'
+})
+export class AppComponent {
+  checkSimilarity() {
+    const encoder = new TextEncoder();
+    const text1 = encoder.encode("Sample text");
+    const text2 = encoder.encode("Sample text modified");
+
+    const similarity = wasm_compare_data(text1, text2);
+    console.log(`Similarity: ${similarity}%`);
+  }
+}
+```
+
+### Vue 3 (Vite, Nuxt 3)
+
+```vue
+<script setup>
+import { wasm_compare_data } from 'lavinhash';
+
+const checkSimilarity = () => {
+  const encoder = new TextEncoder();
+  const text1 = encoder.encode("Sample text");
+  const text2 = encoder.encode("Sample text modified");
+
+  const similarity = wasm_compare_data(text1, text2);
+  console.log(`Similarity: ${similarity}%`);
+};
+</script>
+
+<template>
+  <button @click="checkSimilarity">Check Similarity</button>
+</template>
+```
+
+### Vanilla JavaScript (with bundler)
+
+```javascript
+import { wasm_compare_data, wasm_generate_hash } from 'lavinhash';
+
+const encoder = new TextEncoder();
+const text1 = encoder.encode("Sample text");
+const text2 = encoder.encode("Sample text modified");
+
+const similarity = wasm_compare_data(text1, text2);
+console.log(`Similarity: ${similarity}%`);
+```
+
+### Rust
+
+```rust
+use lavinhash::{generate_hash, compare_hashes, HashConfig};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let data1 = b"Document content version 1";
+    let data2 = b"Document content version 2";
+
+    let config = HashConfig::default();
+
+    let hash1 = generate_hash(data1, &config)?;
+    let hash2 = generate_hash(data2, &config)?;
+
+    let similarity = compare_hashes(&hash1, &hash2, 0.3);
+    println!("Similarity: {}%", similarity);
+
+    Ok(())
+}
+```
+
+## API Reference
+
+### JavaScript/WASM API
+
+#### `wasm_generate_hash(data: Uint8Array): Uint8Array`
+
+Generates a fuzzy hash fingerprint from input data.
+
+**Parameters:**
+- `data`: Input data as Uint8Array
+
+**Returns:**
+- Serialized fingerprint (approximately 1KB)
+
+**Example:**
+```javascript
+const data = encoder.encode("Text to hash");
+const hash = wasm_generate_hash(data);
+console.log(`Hash size: ${hash.length} bytes`);
+```
+
+#### `wasm_compare_hashes(hash_a: Uint8Array, hash_b: Uint8Array): number`
+
+Compares two previously generated hashes.
+
+**Parameters:**
+- `hash_a`: First fingerprint
+- `hash_b`: Second fingerprint
+
+**Returns:**
+- Similarity score (0-100)
+
+**Example:**
+```javascript
+const hash1 = wasm_generate_hash(data1);
+const hash2 = wasm_generate_hash(data2);
+const similarity = wasm_compare_hashes(hash1, hash2);
+```
+
+#### `wasm_compare_data(data_a: Uint8Array, data_b: Uint8Array): number`
+
+Generates hashes and compares in a single operation.
+
+**Parameters:**
+- `data_a`: First data array
+- `data_b`: Second data array
+
+**Returns:**
+- Similarity score (0-100)
+
+**Example:**
+```javascript
+const similarity = wasm_compare_data(text1, text2);
+```
+
+### Rust API
+
+#### `generate_hash(data: &[u8], config: &HashConfig) -> Result<FuzzyFingerprint, FingerprintError>`
+
+Generates a fuzzy hash from input data.
+
+**Parameters:**
+- `data`: Input data slice
+- `config`: Configuration options
+
+**Returns:**
+- `Ok(FuzzyFingerprint)`: Generated fingerprint
+- `Err(FingerprintError)`: Error if data is invalid
+
+#### `compare_hashes(hash_a: &FuzzyFingerprint, hash_b: &FuzzyFingerprint, alpha: f32) -> u8`
+
+Compares two fingerprints.
+
+**Parameters:**
+- `hash_a`: First fingerprint
+- `hash_b`: Second fingerprint
+- `alpha`: Weight coefficient (0.0-1.0, default 0.3)
+
+**Returns:**
+- Similarity score (0-100)
+
+#### `HashConfig`
+
+Configuration structure for hash generation.
+
+**Fields:**
+- `enable_parallel: bool` - Enable parallel processing for large files (default: true)
+- `alpha: f32` - Weight for structure vs content (default: 0.3)
+- `min_modulus: u64` - Feature density control (default: 16)
+
+**Example:**
+```rust
+let mut config = HashConfig::default();
+config.alpha = 0.5;  // 50% structure, 50% content
+config.enable_parallel = false;  // Disable parallel processing
+```
+
+## Algorithm Details
+
+### DLAH (Dual-Layer Adaptive Hashing)
+
+LavinHash implements a three-phase pipeline:
+
+**Phase I: Adaptive Normalization**
+- Case folding (A-Z to a-z)
+- Whitespace normalization
+- Control character filtering
+- Zero-copy iterator-based processing
+
+**Phase II: Structural Hash**
+- Shannon entropy calculation with adaptive block sizing
+- Quantization to 4-bit nibbles
+- Compact vector representation
+- Levenshtein distance for comparison
+
+**Phase III: Content Hash**
+- BuzHash rolling hash algorithm
+- Adaptive modulus scaling
+- 8192-bit Bloom filter (1KB)
+- Jaccard similarity for comparison
+
+### Similarity Formula
+
+```
+Similarity = α × Levenshtein(Structure) + (1-α) × Jaccard(Content)
+```
+
+Where:
+- `α = 0.3` (default) - 30% weight to structure, 70% to content
+- Levenshtein: Normalized edit distance on entropy vectors
+- Jaccard: Set similarity on Bloom filter features
+
+### Performance Characteristics
+
+**Time Complexity:**
+- Hash generation: O(n) where n is data size
+- Hash comparison: O(1) - constant time regardless of file size
+
+**Space Complexity:**
+- Fingerprint size: ~1KB + O(log n) structural data
+- Memory usage: O(1) for comparison, O(n) for generation
+
+**Throughput:**
+- Single-threaded: ~500 MB/s
+- Multi-threaded: ~2 GB/s (files larger than 1MB)
+
+## Configuration
+
+### Basic Configuration
+
+```rust
+use lavinhash::HashConfig;
+
+let config = HashConfig {
+    enable_parallel: true,
+    alpha: 0.3,
+    min_modulus: 16,
+};
+```
+
+### Advanced Configuration
+
+**Adjusting Structure vs Content Weight:**
+
+```rust
+// More weight to structure (topology)
+config.alpha = 0.5;  // 50% structure, 50% content
+
+// More weight to content (features)
+config.alpha = 0.1;  // 10% structure, 90% content
+```
+
+**Controlling Feature Density:**
+
+```rust
+// Higher sensitivity (more features)
+config.min_modulus = 8;
+
+// Lower sensitivity (fewer features)
+config.min_modulus = 32;
+```
+
+**Parallel Processing:**
+
+```rust
+// Force sequential processing
+config.enable_parallel = false;
+
+// Enable automatic parallel processing for files > 1MB
+config.enable_parallel = true;
+```
+
+## Use Cases
+
+### Document Similarity Detection
+
+Compare different versions of documents to detect modifications and measure similarity.
+
+```javascript
+import { wasm_compare_data } from 'lavinhash';
+
+// In a React/Vue/Angular app with file upload
+async function compareDocuments(file1, file2) {
+  const buffer1 = await file1.arrayBuffer();
+  const buffer2 = await file2.arrayBuffer();
+
+  const data1 = new Uint8Array(buffer1);
+  const data2 = new Uint8Array(buffer2);
+
+  const similarity = wasm_compare_data(data1, data2);
+  console.log(`Similarity: ${similarity}%`);
+  return similarity;
+}
+```
+
+### Duplicate Detection
+
+Identify duplicate or near-duplicate files in large datasets.
+
+```rust
+let files = vec![file1, file2, file3];
+let hashes: Vec<_> = files.iter()
+    .map(|f| generate_hash(f, &config).unwrap())
+    .collect();
+
+for i in 0..hashes.len() {
+    for j in i+1..hashes.len() {
+        let sim = compare_hashes(&hashes[i], &hashes[j], 0.3);
+        if sim > 90 {
+            println!("Files {} and {} are similar: {}%", i, j, sim);
+        }
+    }
+}
+```
+
+### Version Tracking
+
+Track changes between different versions of files or content.
+
+```javascript
+import { wasm_generate_hash, wasm_compare_hashes } from 'lavinhash';
+
+// Compare multiple file versions
+async function trackVersions(files) {
+  const encoder = new TextEncoder();
+
+  const hashes = files.map(content => {
+    const data = encoder.encode(content);
+    return wasm_generate_hash(data);
+  });
+
+  const results = [];
+  for (let i = 0; i < hashes.length - 1; i++) {
+    const sim = wasm_compare_hashes(hashes[i], hashes[i + 1]);
+    results.push({
+      from: `v${i+1}`,
+      to: `v${i+2}`,
+      similarity: sim
+    });
+  }
+
+  return results;
+}
+```
+
+## Framework Compatibility
+
+LavinHash works seamlessly with all modern JavaScript frameworks and build tools:
+
+- **React**: Vite, Create React App, Next.js, Remix
+- **Angular**: Angular CLI (v12+)
+- **Vue**: Vue 3, Nuxt 3, Vite
+- **Svelte**: SvelteKit, Vite
+- **Build Tools**: Webpack 5+, Vite, Rollup, Parcel, esbuild
+
+The library uses ES modules and is optimized for modern bundlers.
+
+## Building WASM
+
+To build the WebAssembly bindings:
+
+```bash
+# Install wasm-pack
+cargo install wasm-pack
+
+# Build for modern bundlers (React, Angular, Vue, etc.)
+wasm-pack build --target bundler --out-dir pkg --out-name lavinhash
+
+# The compiled files will be in the pkg/ directory
+```
+
+## Testing
+
+### Rust Tests
+
+```bash
+# Run all tests
+cargo test
+
+# Run tests with output
+cargo test -- --nocapture
+
+# Run specific test
+cargo test test_generate_hash_basic
+```
+
+### Benchmarks
+
+```bash
+# Run benchmarks
+cargo bench
+```
+
+## Technical Specifications
+
+**Fingerprint Format:**
+
+```
+Offset | Field            | Type     | Size
+-------|------------------|----------|-------------
+0x00   | Magic            | u8       | 1 byte (0x48)
+0x01   | Version          | u8       | 1 byte (0x01)
+0x02   | Struct Length    | u16 LE   | 2 bytes
+0x04   | Content Bloom    | u64[128] | 1024 bytes
+0x404  | Structural Data  | u8[]     | Variable
+```
+
+**Cross-Platform Determinism:**
+- Identical input produces identical hash on all platforms
+- Little-endian byte ordering
+- IEEE 754 floating-point compliance
+
+**Thread Safety:**
+- Hash generation is thread-safe
+- Parallel processing uses Rayon for data parallelism
+- No global state or locks
+
+## Examples
+
+See the `examples/` directory for complete working examples:
+
+- `basic_usage.rs` - Rust usage examples
+- `javascript_example.js` - Node.js integration
+- `browser_example.html` - Browser-based demo
+
+## Documentation
+
+- **API Documentation**: Available at [docs.rs/lavinhash](https://docs.rs/lavinhash)
+- **Technical Specification**: See `docs/TECHNICAL.md` in the repository
+- **Contributing Guide**: See `CONTRIBUTING.md`
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Repository
+
+Source code: [https://github.com/RafaCalRob/LavinHash](https://github.com/RafaCalRob/LavinHash)
+
+## Support
+
+For bug reports and feature requests, please open an issue on GitHub:
+[https://github.com/RafaCalRob/LavinHash/issues](https://github.com/RafaCalRob/LavinHash/issues)

package/lavinhash.d.ts

@@ -0,0 +1,47 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Initialize the WASM module
+ */
+export function init(): void;
+
+/**
+ * Generate hash and compare in one step (WASM wrapper)
+ *
+ * # Arguments
+ * * `data_a` - First data as Uint8Array
+ * * `data_b` - Second data as Uint8Array
+ *
+ * # Returns
+ * Similarity score 0-100
+ */
+export function wasm_compare_data(data_a: Uint8Array, data_b: Uint8Array): number;
+
+/**
+ * Compare two fuzzy hashes (WASM wrapper)
+ *
+ * # Arguments
+ * * `hash_a` - First fingerprint (serialized)
+ * * `hash_b` - Second fingerprint (serialized)
+ *
+ * # Returns
+ * Similarity score 0-100
+ */
+export function wasm_compare_hashes(hash_a: Uint8Array, hash_b: Uint8Array): number;
+
+/**
+ * Get fingerprint size in bytes (WASM wrapper)
+ */
+export function wasm_fingerprint_size(hash: Uint8Array): number;
+
+/**
+ * Generate a fuzzy hash from data (WASM wrapper)
+ *
+ * # Arguments
+ * * `data` - Input data as Uint8Array
+ *
+ * # Returns
+ * Serialized fingerprint as Uint8Array
+ */
+export function wasm_generate_hash(data: Uint8Array): Uint8Array;

package/lavinhash.js

@@ -0,0 +1,5 @@
+import * as wasm from "./lavinhash_bg.wasm";
+export * from "./lavinhash_bg.js";
+import { __wbg_set_wasm } from "./lavinhash_bg.js";
+__wbg_set_wasm(wasm);
+wasm.__wbindgen_start();

package/lavinhash_bg.js

@@ -0,0 +1,294 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+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 getObject(idx) { return heap[idx]; }
+
+let heap = new Array(128).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+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 passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+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));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+let WASM_VECTOR_LEN = 0;
+
+/**
+ * Initialize the WASM module
+ */
+export function init() {
+    wasm.init();
+}
+
+/**
+ * Generate hash and compare in one step (WASM wrapper)
+ *
+ * # Arguments
+ * * `data_a` - First data as Uint8Array
+ * * `data_b` - Second data as Uint8Array
+ *
+ * # Returns
+ * Similarity score 0-100
+ * @param {Uint8Array} data_a
+ * @param {Uint8Array} data_b
+ * @returns {number}
+ */
+export function wasm_compare_data(data_a, data_b) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data_a, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(data_b, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.wasm_compare_data(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return r0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Compare two fuzzy hashes (WASM wrapper)
+ *
+ * # Arguments
+ * * `hash_a` - First fingerprint (serialized)
+ * * `hash_b` - Second fingerprint (serialized)
+ *
+ * # Returns
+ * Similarity score 0-100
+ * @param {Uint8Array} hash_a
+ * @param {Uint8Array} hash_b
+ * @returns {number}
+ */
+export function wasm_compare_hashes(hash_a, hash_b) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(hash_a, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(hash_b, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.wasm_compare_hashes(retptr, ptr0, len0, ptr1, len1);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return r0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Get fingerprint size in bytes (WASM wrapper)
+ * @param {Uint8Array} hash
+ * @returns {number}
+ */
+export function wasm_fingerprint_size(hash) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(hash, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasm_fingerprint_size(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return r0 >>> 0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Generate a fuzzy hash from data (WASM wrapper)
+ *
+ * # Arguments
+ * * `data` - Input data as Uint8Array
+ *
+ * # Returns
+ * Serialized fingerprint as Uint8Array
+ * @param {Uint8Array} data
+ * @returns {Uint8Array}
+ */
+export function wasm_generate_hash(data) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.wasm_generate_hash(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v2 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export(r0, r1 * 1, 1);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+export function __wbg_error_7534b8e9a36f1ab4(arg0, arg1) {
+    let deferred0_0;
+    let deferred0_1;
+    try {
+        deferred0_0 = arg0;
+        deferred0_1 = arg1;
+        console.error(getStringFromWasm0(arg0, arg1));
+    } finally {
+        wasm.__wbindgen_export(deferred0_0, deferred0_1, 1);
+    }
+};
+
+export function __wbg_new_8a6f238a6ece86ea() {
+    const ret = new Error();
+    return addHeapObject(ret);
+};
+
+export function __wbg_stack_0ed75d68575b0f3c(arg0, arg1) {
+    const ret = getObject(arg1).stack;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_object_drop_ref(arg0) {
+    takeObject(arg0);
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "lavinhash",
+  "type": "module",
+  "collaborators": [
+    "LavinHash Contributors"
+  ],
+  "description": "High-performance fuzzy hashing library implementing the DLAH (Dual-Layer Adaptive Hashing) algorithm",
+  "version": "1.0.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/RafaCalRob/lavinhash"
+  },
+  "files": [
+    "lavinhash_bg.wasm",
+    "lavinhash.js",
+    "lavinhash_bg.js",
+    "lavinhash.d.ts"
+  ],
+  "main": "lavinhash.js",
+  "homepage": "https://bdovenbird.com/lavinhash/",
+  "types": "lavinhash.d.ts",
+  "sideEffects": [
+    "./lavinhash.js",
+    "./snippets/*"
+  ],
+  "keywords": [
+    "fuzzy-hashing",
+    "similarity",
+    "hash",
+    "fingerprint",
+    "dlah",
+    "wasm",
+    "webassembly",
+    "rust",
+    "duplicate-detection",
+    "text-similarity",
+    "file-similarity",
+    "content-hashing",
+    "bloom-filter",
+    "react",
+    "angular",
+    "vue",
+    "typescript"
+  ]
+}