simile-search 0.3.2 → 0.4.1

package/dist/engine.test.js

@@ -1,270 +1,84 @@
 import { describe, it, expect } from "vitest";
 import { Simile } from "./engine";
-import { getByPath, extractText } from "./utils";
-import * as fs from "fs";
-import * as path from "path";
-const testItems = [
-    {
-        id: "1",
-        text: "Bathroom floor cleaner",
-        metadata: { category: "Cleaning" },
-    },
-    {
-        id: "2",
-        text: "Dishwashing liquid",
-        metadata: { category: "Kitchen" },
-    },
-    {
-        id: "3",
-        text: "Ipod Charger",
-        metadata: { category: "Electronics" },
-    },
-    {
-        id: "4",
-        text: "Kitchen cleaning spray",
-        metadata: { category: "Cleaning" },
-    },
-    {
-        id: "5",
-        text: "USB-C phone charger cable",
-        metadata: { category: "Electronics" },
-    },
-];
 describe("simile search", () => {
     it("returns semantically similar items", async () => {
-        const engine = await Simile.from(testItems.slice(0, 3));
-        const results = await engine.search("cleaner", { explain: true });
-        console.log("Search for 'cleaner':", results);
-        expect(results.length).toBeGreaterThan(0);
-        expect(results[0].id).toBe("1");
-        expect(results[0].score).toBeGreaterThan(0.5);
-    }, 30000);
-    it("differentiates between unrelated items", async () => {
-        const engine = await Simile.from(testItems);
-        // Search for "phone charger" - should clearly prefer electronics
-        const results = await engine.search("phone charger", { explain: true });
-        console.log("Search for 'phone charger':", results);
-        // Both chargers should be in top 2 (order may vary based on model)
-        const topTwoIds = [results[0].id, results[1].id];
-        expect(topTwoIds).toContain("5"); // USB-C phone charger
-        expect(topTwoIds).toContain("3"); // iPod Charger
-        // Both chargers should score significantly higher than cleaning products
-        const chargerScores = results.filter((r) => r.metadata?.category === "Electronics");
-        const cleaningScores = results.filter((r) => r.metadata?.category === "Cleaning");
-        // Electronics should score higher than cleaning items
-        expect(chargerScores[0].score).toBeGreaterThan(cleaningScores[0].score);
-    }, 30000);
-    it("applies threshold filtering", async () => {
-        const engine = await Simile.from(testItems);
-        // With high threshold, should filter out low-scoring results
-        const results = await engine.search("cleaner", { threshold: 0.5 });
-        console.log("Search with threshold 0.5:", results);
-        results.forEach((r) => {
-            expect(r.score).toBeGreaterThanOrEqual(0.5);
-        });
-    }, 30000);
-    it("sorts results by relevance (highest score first)", async () => {
-        const engine = await Simile.from(testItems);
-        const results = await engine.search("cleaning products");
-        // Verify results are sorted by score descending
-        for (let i = 1; i < results.length; i++) {
-            expect(results[i - 1].score).toBeGreaterThanOrEqual(results[i].score);
-        }
-    }, 30000);
-});
-describe("min character limit", () => {
-    it("returns empty results when query is below minLength", async () => {
-        const engine = await Simile.from(testItems);
-        // Default minLength is 1
-        const results1 = await engine.search("c");
-        expect(results1.length).toBeGreaterThan(0);
-        // With minLength: 3, short queries return empty
-        const results2 = await engine.search("cl", { minLength: 3 });
-        expect(results2.length).toBe(0);
-        // Exactly 3 characters should work
-        const results3 = await engine.search("usb", { minLength: 3 });
-        expect(results3.length).toBeGreaterThan(0);
-    }, 30000);
-});
-describe("nested path search", () => {
-    const nestedItems = [
-        {
-            id: "1",
-            text: "",
-            metadata: {
-                author: { firstName: "John", lastName: "Doe" },
-                title: "The Art of Programming",
-                tags: ["coding", "javascript"],
+        const engine = await Simile.from([
+            {
+                id: "1",
+                text: "Bathroom floor cleaner",
+                metadata: { category: "Cleaning" },
             },
-        },
-        {
-            id: "2",
-            text: "",
-            metadata: {
-                author: { firstName: "Jane", lastName: "Smith" },
-                title: "Machine Learning Basics",
-                tags: ["ai", "python"],
+            {
+                id: "2",
+                text: "Dishwashing liquid",
+                metadata: { category: "Kitchen" },
             },
-        },
-        {
-            id: "3",
-            text: "",
-            metadata: {
-                author: { firstName: "John", lastName: "Smith" },
-                title: "Advanced JavaScript",
-                tags: ["coding", "javascript", "advanced"],
+            {
+                id: "3",
+                text: "Ipod Charger",
+                metadata: { categoryq: "Electronics" },
             },
-        },
-    ];
-    it("extracts text from nested paths", () => {
-        const item = nestedItems[0];
-        expect(getByPath(item, "metadata.author.firstName")).toBe("John");
-        expect(getByPath(item, "metadata.title")).toBe("The Art of Programming");
-        expect(getByPath(item, "metadata.tags[0]")).toBe("coding");
-        expect(getByPath(item, "metadata.tags[1]")).toBe("javascript");
-    });
-    it("combines multiple paths into searchable text", () => {
-        const text = extractText(nestedItems[0], [
-            "metadata.author.firstName",
-            "metadata.author.lastName",
-            "metadata.title",
         ]);
-        expect(text).toBe("John Doe The Art of Programming");
-    });
-    it("searches using nested paths", async () => {
-        const engine = await Simile.from(nestedItems, {
-            textPaths: [
-                "metadata.author.firstName",
-                "metadata.author.lastName",
-                "metadata.title",
-            ],
-        });
-        // Search by author name
-        const johnResults = await engine.search("John");
-        expect(johnResults.length).toBeGreaterThan(0);
-        expect(johnResults[0].metadata?.author.firstName).toBe("John");
-        // Search by title
-        const jsResults = await engine.search("JavaScript programming");
-        expect(jsResults.length).toBeGreaterThan(0);
+        const results = await engine.search("cleaner");
+        console.log(results);
+        expect(results.length).toBeGreaterThan(0);
+        expect(results[0].id).toBe("1");
+        expect(results[0].score).toBeGreaterThan(0.5);
     }, 30000);
-    it("includes tags in nested path search", async () => {
-        const engine = await Simile.from(nestedItems, {
-            textPaths: ["metadata.title", "metadata.tags"],
+    it("performance test: 10K items should search in <100ms", async () => {
+        // Generate 10K test items
+        const items = Array.from({ length: 10000 }, (_, i) => ({
+            id: `item-${i}`,
+            text: `Product ${i} - ${[
+                "cleaner",
+                "charger",
+                "liquid",
+                "cable",
+                "headphones",
+                "keyboard",
+                "mouse",
+                "monitor",
+            ][i % 8]}`,
+            metadata: { category: ["Electronics", "Cleaning", "Kitchen"][i % 3] },
+        }));
+        // Create engine with optimized ANN settings
+        const engine = await Simile.from(items, {
+            useANN: {
+                efSearch: 20, // Fast search
+                M: 16,
+                efConstruction: 200,
+            },
+            annThreshold: 100, // Enable ANN early
         });
-        const pythonResults = await engine.search("python ai");
-        expect(pythonResults[0].id).toBe("2"); // Machine Learning Basics
-    }, 30000);
-});
-describe("score normalization", () => {
-    it("includes raw scores in explain output", async () => {
-        const engine = await Simile.from(testItems);
-        const results = await engine.search("cleaner", { explain: true });
-        expect(results[0].explain).toBeDefined();
-        expect(results[0].explain?.raw).toBeDefined();
-        expect(results[0].explain?.raw?.semantic).toBeDefined();
-        expect(results[0].explain?.raw?.fuzzy).toBeDefined();
-        expect(results[0].explain?.raw?.keyword).toBeDefined();
-    }, 30000);
-    it("can disable score normalization", async () => {
-        const engine = await Simile.from(testItems, { normalizeScores: false });
-        const results = await engine.search("cleaner", { explain: true });
-        // Without normalization, normalized scores should equal raw scores
-        expect(results[0].explain?.semantic).toBe(results[0].explain?.raw?.semantic);
-    }, 30000);
-});
-describe("simile persistence", () => {
-    const snapshotPath = path.join(__dirname, "../.test-snapshot.json");
-    it("saves and loads from snapshot", async () => {
-        // Create engine and save
-        const engine = await Simile.from(testItems);
-        const snapshot = engine.save();
-        expect(snapshot.version).toBe("0.2.0");
-        expect(snapshot.items.length).toBe(5);
-        expect(snapshot.vectors.length).toBe(5);
-        expect(snapshot.model).toBe("Xenova/all-MiniLM-L6-v2");
-        // Load from snapshot (instant - no embedding!)
-        const loadedEngine = Simile.load(snapshot);
-        expect(loadedEngine.size).toBe(5);
-        // Search should work the same
-        const results = await loadedEngine.search("cleaner");
-        expect(results[0].text).toContain("cleaner");
-    }, 30000);
-    it("saves and loads from JSON file", async () => {
-        // Create and save to file
-        const engine = await Simile.from(testItems);
-        const json = engine.toJSON();
-        fs.writeFileSync(snapshotPath, json);
-        // Load from file (instant!)
-        const loadedJson = fs.readFileSync(snapshotPath, "utf-8");
-        const loadedEngine = Simile.loadFromJSON(loadedJson);
-        expect(loadedEngine.size).toBe(5);
-        // Cleanup
-        fs.unlinkSync(snapshotPath);
-    }, 30000);
-    it("preserves textPaths in snapshot", async () => {
-        const nestedItems = [
-            { id: "1", text: "", metadata: { title: "Hello World" } },
-        ];
-        const engine = await Simile.from(nestedItems, {
-            textPaths: ["metadata.title"],
+        // Verify ANN is enabled
+        const info = engine.getIndexInfo();
+        expect(info.type).toBe("hnsw");
+        expect(info.size).toBe(10000);
+        // Warm up: first search includes embedding time
+        await engine.search("cleaner");
+        // Performance test: search should be <100ms (excluding first-time embedding)
+        const query = "phone charger";
+        const startTime = performance.now();
+        const results = await engine.search(query, {
+            topK: 5,
+            semanticOnly: true, // Fast mode: skip fuzzy/keyword
         });
-        const snapshot = engine.save();
-        expect(snapshot.textPaths).toEqual(["metadata.title"]);
-        const loaded = Simile.load(snapshot);
-        const results = await loaded.search("Hello");
+        const endTime = performance.now();
+        const searchTime = endTime - startTime;
+        console.log(`Search time for 10K items: ${searchTime.toFixed(2)}ms`);
+        console.log(`Results: ${results.length}`);
+        console.log(`Index info:`, info);
         expect(results.length).toBeGreaterThan(0);
-    }, 30000);
-});
-describe("simile dynamic items", () => {
-    it("adds new items", async () => {
-        const engine = await Simile.from(testItems.slice(0, 2));
-        expect(engine.size).toBe(2);
-        await engine.add([testItems[2], testItems[3]]);
-        expect(engine.size).toBe(4);
-        const results = await engine.search("charger");
-        expect(results.some((r) => r.id === "3")).toBe(true);
-    }, 30000);
-    it("removes items", async () => {
-        const engine = await Simile.from(testItems);
-        expect(engine.size).toBe(5);
-        engine.remove(["1", "2"]);
-        expect(engine.size).toBe(3);
-        expect(engine.get("1")).toBeUndefined();
-        expect(engine.get("3")).toBeDefined();
-    }, 30000);
-    it("updates existing items", async () => {
-        const engine = await Simile.from(testItems.slice(0, 2));
-        // Update item with same ID but different text
-        await engine.add([
-            { id: "1", text: "Wireless Bluetooth headphones", metadata: { category: "Electronics" } },
-        ]);
-        expect(engine.size).toBe(2); // Still 2 items, not 3
-        expect(engine.get("1")?.text).toBe("Wireless Bluetooth headphones");
-    }, 30000);
-});
-describe("simile custom weights", () => {
-    it("respects custom weights", async () => {
-        // Engine with high semantic weight
-        const semanticEngine = await Simile.from(testItems, {
-            weights: { semantic: 0.9, fuzzy: 0.05, keyword: 0.05 },
+        expect(searchTime).toBeLessThan(100); // Should be <100ms
+        // Also test with full hybrid search
+        const startTime2 = performance.now();
+        const results2 = await engine.search(query, {
+            topK: 5,
+            semanticOnly: false, // Full hybrid search
         });
-        // Engine with high keyword weight
-        const keywordEngine = await Simile.from(testItems, {
-            weights: { semantic: 0.1, fuzzy: 0.1, keyword: 0.8 },
-        });
-        const query = "floor";
-        const semanticResults = await semanticEngine.search(query, { explain: true });
-        const keywordResults = await keywordEngine.search(query, { explain: true });
-        console.log("Semantic-weighted results:", semanticResults.map((r) => ({
-            text: r.text,
-            score: r.score,
-        })));
-        console.log("Keyword-weighted results:", keywordResults.map((r) => ({
-            text: r.text,
-            score: r.score,
-        })));
-        // Both should find floor cleaner first (it has "floor" in text)
-        expect(semanticResults[0].text).toContain("floor");
-        expect(keywordResults[0].text).toContain("floor");
-    }, 30000);
+        const endTime2 = performance.now();
+        const hybridTime = endTime2 - startTime2;
+        console.log(`Hybrid search time: ${hybridTime.toFixed(2)}ms`);
+        expect(hybridTime).toBeLessThan(200);
+    }, 300000); // Longer timeout for 10K items (embedding takes ~3 minutes)
 });

package/dist/index.d.ts

@@ -4,3 +4,7 @@ export { cosine, fuzzyScore, keywordScore, calculateScoreStats } from "./similar
 export { hybridScore, getDefaultWeights } from "./ranker.js";
 export { Simile } from "./engine.js";
 export { getByPath, extractText, normalizeScore } from "./utils.js";
+export { HNSWIndex } from "./ann.js";
+export { VectorCache, createCacheKey } from "./cache.js";
+export { BackgroundUpdater, DebouncedUpdater, PriorityUpdater } from "./updater.js";
+export { quantizeVector, dequantizeVector, cosineQuantized, quantizedToBase64, base64ToQuantized } from "./quantization.js";

package/dist/index.js

@@ -4,3 +4,7 @@ export { cosine, fuzzyScore, keywordScore, calculateScoreStats } from "./similar
 export { hybridScore, getDefaultWeights } from "./ranker.js";
 export { Simile } from "./engine.js";
 export { getByPath, extractText, normalizeScore } from "./utils.js";
+export { HNSWIndex } from "./ann.js";
+export { VectorCache, createCacheKey } from "./cache.js";
+export { BackgroundUpdater, DebouncedUpdater, PriorityUpdater } from "./updater.js";
+export { quantizeVector, dequantizeVector, cosineQuantized, quantizedToBase64, base64ToQuantized } from "./quantization.js";

package/dist/quantization.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Vector Quantization - Reduce memory footprint by 50-75%.
+ *
+ * Quantization levels:
+ * - Float32: Full precision (4 bytes per dimension) - default
+ * - Float16: Half precision (2 bytes, ~0.1% accuracy loss)
+ * - Int8: 8-bit quantization (1 byte, ~1% accuracy loss)
+ */
+export type QuantizationType = 'float32' | 'float16' | 'int8';
+export interface QuantizedVector {
+    data: ArrayBuffer;
+    type: QuantizationType;
+    /** Scale factor for Int8 quantization */
+    scale?: number;
+    /** Offset for Int8 quantization */
+    offset?: number;
+}
+/**
+ * Quantize a Float32Array to a more memory-efficient format.
+ */
+export declare function quantizeVector(vector: Float32Array, type: QuantizationType): QuantizedVector;
+/**
+ * Dequantize back to Float32Array for computation.
+ */
+export declare function dequantizeVector(quantized: QuantizedVector): Float32Array;
+/**
+ * Compute cosine similarity directly on quantized vectors.
+ * More efficient than dequantizing first for large batches.
+ */
+export declare function cosineQuantized(a: QuantizedVector, b: QuantizedVector): number;
+/**
+ * Serialize quantized vector to base64 for storage.
+ */
+export declare function quantizedToBase64(quantized: QuantizedVector): string;
+/**
+ * Deserialize quantized vector from base64.
+ */
+export declare function base64ToQuantized(base64: string): QuantizedVector;
+/**
+ * Get bytes per dimension for a quantization type.
+ */
+export declare function getBytesPerDimension(type: QuantizationType): number;
+/**
+ * Estimate memory savings compared to Float32.
+ */
+export declare function estimateMemorySavings(vectorCount: number, dimensions: number, type: QuantizationType): {
+    original: number;
+    quantized: number;
+    savings: number;
+};

package/dist/quantization.js

@@ -0,0 +1,271 @@
+/**
+ * Vector Quantization - Reduce memory footprint by 50-75%.
+ *
+ * Quantization levels:
+ * - Float32: Full precision (4 bytes per dimension) - default
+ * - Float16: Half precision (2 bytes, ~0.1% accuracy loss)
+ * - Int8: 8-bit quantization (1 byte, ~1% accuracy loss)
+ */
+/**
+ * Quantize a Float32Array to a more memory-efficient format.
+ */
+export function quantizeVector(vector, type) {
+    switch (type) {
+        case 'float32':
+            // Ensure we get a proper ArrayBuffer (not SharedArrayBuffer)
+            const float32Data = new ArrayBuffer(vector.byteLength);
+            new Float32Array(float32Data).set(vector);
+            return {
+                data: float32Data,
+                type: 'float32',
+            };
+        case 'float16':
+            return {
+                data: float32ToFloat16(vector),
+                type: 'float16',
+            };
+        case 'int8':
+            return quantizeToInt8(vector);
+        default:
+            throw new Error(`Unknown quantization type: ${type}`);
+    }
+}
+/**
+ * Dequantize back to Float32Array for computation.
+ */
+export function dequantizeVector(quantized) {
+    switch (quantized.type) {
+        case 'float32':
+            return new Float32Array(quantized.data);
+        case 'float16':
+            return float16ToFloat32(quantized.data);
+        case 'int8':
+            return dequantizeFromInt8(quantized);
+        default:
+            throw new Error(`Unknown quantization type: ${quantized.type}`);
+    }
+}
+/**
+ * Compute cosine similarity directly on quantized vectors.
+ * More efficient than dequantizing first for large batches.
+ */
+export function cosineQuantized(a, b) {
+    if (a.type !== b.type) {
+        throw new Error('Cannot compute similarity between different quantization types');
+    }
+    switch (a.type) {
+        case 'float32': {
+            const va = new Float32Array(a.data);
+            const vb = new Float32Array(b.data);
+            return cosineFloat32(va, vb);
+        }
+        case 'float16': {
+            // For Float16, dequantize and compute (hardware Float16 not widely supported)
+            const va = float16ToFloat32(a.data);
+            const vb = float16ToFloat32(b.data);
+            return cosineFloat32(va, vb);
+        }
+        case 'int8': {
+            // For Int8, use integer arithmetic then scale
+            return cosineInt8(a, b);
+        }
+        default:
+            throw new Error(`Unknown quantization type: ${a.type}`);
+    }
+}
+/**
+ * Serialize quantized vector to base64 for storage.
+ */
+export function quantizedToBase64(quantized) {
+    const meta = JSON.stringify({
+        type: quantized.type,
+        scale: quantized.scale,
+        offset: quantized.offset,
+    });
+    const metaBuffer = Buffer.from(meta);
+    const dataBuffer = Buffer.from(quantized.data);
+    // Format: [2 bytes meta length][meta][data]
+    const combined = Buffer.alloc(2 + metaBuffer.length + dataBuffer.length);
+    combined.writeUInt16LE(metaBuffer.length, 0);
+    metaBuffer.copy(combined, 2);
+    dataBuffer.copy(combined, 2 + metaBuffer.length);
+    return combined.toString('base64');
+}
+/**
+ * Deserialize quantized vector from base64.
+ */
+export function base64ToQuantized(base64) {
+    const combined = Buffer.from(base64, 'base64');
+    const metaLength = combined.readUInt16LE(0);
+    const metaBuffer = combined.subarray(2, 2 + metaLength);
+    const dataBuffer = combined.subarray(2 + metaLength);
+    const meta = JSON.parse(metaBuffer.toString());
+    return {
+        data: dataBuffer.buffer.slice(dataBuffer.byteOffset, dataBuffer.byteOffset + dataBuffer.length),
+        type: meta.type,
+        scale: meta.scale,
+        offset: meta.offset,
+    };
+}
+/**
+ * Get bytes per dimension for a quantization type.
+ */
+export function getBytesPerDimension(type) {
+    switch (type) {
+        case 'float32': return 4;
+        case 'float16': return 2;
+        case 'int8': return 1;
+        default: return 4;
+    }
+}
+/**
+ * Estimate memory savings compared to Float32.
+ */
+export function estimateMemorySavings(vectorCount, dimensions, type) {
+    const original = vectorCount * dimensions * 4; // Float32
+    const quantized = vectorCount * dimensions * getBytesPerDimension(type);
+    return {
+        original,
+        quantized,
+        savings: 1 - (quantized / original),
+    };
+}
+// ============ Internal Helpers ============
+/**
+ * Convert Float32Array to Float16 (stored as Uint16Array buffer).
+ */
+function float32ToFloat16(float32) {
+    const uint16 = new Uint16Array(float32.length);
+    for (let i = 0; i < float32.length; i++) {
+        uint16[i] = floatToHalf(float32[i]);
+    }
+    return uint16.buffer;
+}
+/**
+ * Convert Float16 buffer back to Float32Array.
+ */
+function float16ToFloat32(buffer) {
+    const uint16 = new Uint16Array(buffer);
+    const float32 = new Float32Array(uint16.length);
+    for (let i = 0; i < uint16.length; i++) {
+        float32[i] = halfToFloat(uint16[i]);
+    }
+    return float32;
+}
+/**
+ * Quantize Float32Array to Int8 with scale/offset.
+ */
+function quantizeToInt8(vector) {
+    let min = Infinity;
+    let max = -Infinity;
+    for (let i = 0; i < vector.length; i++) {
+        if (vector[i] < min)
+            min = vector[i];
+        if (vector[i] > max)
+            max = vector[i];
+    }
+    const scale = (max - min) / 255;
+    const offset = min;
+    const int8 = new Int8Array(vector.length);
+    for (let i = 0; i < vector.length; i++) {
+        // Map to 0-255 range, then shift to -128 to 127
+        const normalized = scale > 0 ? (vector[i] - offset) / scale : 0;
+        int8[i] = Math.round(normalized) - 128;
+    }
+    return {
+        data: int8.buffer,
+        type: 'int8',
+        scale,
+        offset,
+    };
+}
+/**
+ * Dequantize Int8 back to Float32Array.
+ */
+function dequantizeFromInt8(quantized) {
+    const int8 = new Int8Array(quantized.data);
+    const float32 = new Float32Array(int8.length);
+    const scale = quantized.scale ?? 1;
+    const offset = quantized.offset ?? 0;
+    for (let i = 0; i < int8.length; i++) {
+        float32[i] = (int8[i] + 128) * scale + offset;
+    }
+    return float32;
+}
+/**
+ * Cosine similarity for Float32 vectors.
+ */
+function cosineFloat32(a, b) {
+    let dot = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+    }
+    return dot;
+}
+/**
+ * Cosine similarity for Int8 quantized vectors.
+ * Uses integer arithmetic for speed.
+ */
+function cosineInt8(a, b) {
+    const int8A = new Int8Array(a.data);
+    const int8B = new Int8Array(b.data);
+    // Compute dot product in integer space
+    let dotInt = 0;
+    let normAInt = 0;
+    let normBInt = 0;
+    for (let i = 0; i < int8A.length; i++) {
+        const valA = int8A[i] + 128;
+        const valB = int8B[i] + 128;
+        dotInt += valA * valB;
+        normAInt += valA * valA;
+        normBInt += valB * valB;
+    }
+    // For normalized vectors, we can simplify
+    // Since embeddings are already normalized, dot product ≈ cosine
+    const scaleA = a.scale ?? 1;
+    const scaleB = b.scale ?? 1;
+    return (dotInt * scaleA * scaleB) / (Math.sqrt(normAInt) * Math.sqrt(normBInt) * scaleA * scaleB);
+}
+/**
+ * Convert a 32-bit float to 16-bit half precision.
+ */
+function floatToHalf(val) {
+    const floatView = new Float32Array(1);
+    const int32View = new Int32Array(floatView.buffer);
+    floatView[0] = val;
+    const x = int32View[0];
+    let bits = (x >> 16) & 0x8000; // Sign
+    let m = (x >> 12) & 0x07ff; // Mantissa
+    const e = (x >> 23) & 0xff; // Exponent
+    if (e < 103) {
+        return bits;
+    }
+    if (e > 142) {
+        bits |= 0x7c00;
+        bits |= (e === 255 ? 0 : 1) && (x & 0x007fffff);
+        return bits;
+    }
+    if (e < 113) {
+        m |= 0x0800;
+        bits |= (m >> (114 - e)) + ((m >> (113 - e)) & 1);
+        return bits;
+    }
+    bits |= ((e - 112) << 10) | (m >> 1);
+    bits += m & 1;
+    return bits;
+}
+/**
+ * Convert a 16-bit half precision to 32-bit float.
+ */
+function halfToFloat(val) {
+    const s = (val & 0x8000) >> 15;
+    const e = (val & 0x7c00) >> 10;
+    const f = val & 0x03ff;
+    if (e === 0) {
+        return (s ? -1 : 1) * Math.pow(2, -14) * (f / Math.pow(2, 10));
+    }
+    else if (e === 0x1f) {
+        return f ? NaN : (s ? -Infinity : Infinity);
+    }
+    return (s ? -1 : 1) * Math.pow(2, e - 15) * (1 + f / Math.pow(2, 10));
+}