llmtxt 2026.4.0

package/wasm/llmtxt_core.js

@@ -0,0 +1,719 @@
+/* @ts-self-types="./llmtxt_core.d.ts" */
+
+/**
+ * Result of computing a line-based diff between two texts.
+ */
+class DiffResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(DiffResult.prototype);
+        obj.__wbg_ptr = ptr;
+        DiffResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DiffResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_diffresult_free(ptr, 0);
+    }
+    /**
+     * Number of lines added in the new text.
+     * @returns {number}
+     */
+    get added_lines() {
+        const ret = wasm.diffresult_added_lines(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Estimated tokens added.
+     * @returns {number}
+     */
+    get added_tokens() {
+        const ret = wasm.diffresult_added_tokens(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of lines removed from the old text.
+     * @returns {number}
+     */
+    get removed_lines() {
+        const ret = wasm.diffresult_removed_lines(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Estimated tokens removed.
+     * @returns {number}
+     */
+    get removed_tokens() {
+        const ret = wasm.diffresult_removed_tokens(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) DiffResult.prototype[Symbol.dispose] = DiffResult.prototype.free;
+exports.DiffResult = DiffResult;
+
+/**
+ * Apply a unified diff patch to an original string.
+ * Returns the updated string on success, or an error if the patch is invalid
+ * or fails to apply cleanly.
+ * @param {string} original
+ * @param {string} patch_text
+ * @returns {string}
+ */
+function apply_patch(original, patch_text) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(original, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(patch_text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.apply_patch(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+exports.apply_patch = apply_patch;
+
+/**
+ * Calculate the compression ratio (original / compressed), rounded to 2 decimals.
+ * Returns 1.0 when `compressed_size` is 0.
+ * @param {number} original_size
+ * @param {number} compressed_size
+ * @returns {number}
+ */
+function calculate_compression_ratio(original_size, compressed_size) {
+    const ret = wasm.calculate_compression_ratio(original_size, compressed_size);
+    return ret;
+}
+exports.calculate_compression_ratio = calculate_compression_ratio;
+
+/**
+ * Estimate token count using the ~4 chars/token heuristic.
+ * @param {string} text
+ * @returns {number}
+ */
+function calculate_tokens(text) {
+    const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.calculate_tokens(ptr0, len0);
+    return ret >>> 0;
+}
+exports.calculate_tokens = calculate_tokens;
+
+/**
+ * Compress a UTF-8 string using zlib-wrapped deflate (RFC 1950).
+ *
+ * Matches Node.js `zlib.deflate` output for backward compatibility
+ * with existing stored data.
+ *
+ * # Errors
+ * Returns an error string if compression fails.
+ * @param {string} data
+ * @returns {Uint8Array}
+ */
+function compress(data) {
+    const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.compress(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;
+}
+exports.compress = compress;
+
+/**
+ * Compute a line-based diff between two texts.
+ *
+ * Uses a hash-based LCS (Longest Common Subsequence) approach for
+ * O(n*m) comparison where n and m are line counts. Returns counts
+ * of added/removed lines and estimated token impact.
+ * @param {string} old_text
+ * @param {string} new_text
+ * @returns {DiffResult}
+ */
+function compute_diff(old_text, new_text) {
+    const ptr0 = passStringToWasm0(old_text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(new_text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.compute_diff(ptr0, len0, ptr1, len1);
+    return DiffResult.__wrap(ret);
+}
+exports.compute_diff = compute_diff;
+
+/**
+ * Compute the HMAC-SHA256 signature for org-scoped signed URL parameters.
+ * Includes `org_id` in the HMAC payload for organization-level access control.
+ * Returns the first 32 hex characters (128 bits) by default.
+ * @param {string} slug
+ * @param {string} agent_id
+ * @param {string} conversation_id
+ * @param {string} org_id
+ * @param {number} expires_at
+ * @param {string} secret
+ * @returns {string}
+ */
+function compute_org_signature(slug, agent_id, conversation_id, org_id, expires_at, secret) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        const ptr0 = passStringToWasm0(slug, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(agent_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(conversation_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(org_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(secret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ret = wasm.compute_org_signature(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, expires_at, ptr4, len4);
+        deferred6_0 = ret[0];
+        deferred6_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+    }
+}
+exports.compute_org_signature = compute_org_signature;
+
+/**
+ * Compute org-scoped HMAC-SHA256 signature with configurable output length.
+ * @param {string} slug
+ * @param {string} agent_id
+ * @param {string} conversation_id
+ * @param {string} org_id
+ * @param {number} expires_at
+ * @param {string} secret
+ * @param {number} sig_length
+ * @returns {string}
+ */
+function compute_org_signature_with_length(slug, agent_id, conversation_id, org_id, expires_at, secret, sig_length) {
+    let deferred6_0;
+    let deferred6_1;
+    try {
+        const ptr0 = passStringToWasm0(slug, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(agent_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(conversation_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(org_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(secret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ret = wasm.compute_org_signature_with_length(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, expires_at, ptr4, len4, sig_length);
+        deferred6_0 = ret[0];
+        deferred6_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
+    }
+}
+exports.compute_org_signature_with_length = compute_org_signature_with_length;
+
+/**
+ * Compute the HMAC-SHA256 signature for signed URL parameters.
+ * Returns the first 16 hex characters of the digest (64 bits).
+ * For longer signatures, use [`compute_signature_with_length`].
+ * @param {string} slug
+ * @param {string} agent_id
+ * @param {string} conversation_id
+ * @param {number} expires_at
+ * @param {string} secret
+ * @returns {string}
+ */
+function compute_signature(slug, agent_id, conversation_id, expires_at, secret) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const ptr0 = passStringToWasm0(slug, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(agent_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(conversation_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(secret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.compute_signature(ptr0, len0, ptr1, len1, ptr2, len2, expires_at, ptr3, len3);
+        deferred5_0 = ret[0];
+        deferred5_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+    }
+}
+exports.compute_signature = compute_signature;
+
+/**
+ * Compute the HMAC-SHA256 signature with configurable output length.
+ *
+ * `sig_length` controls how many hex characters to return (max 64).
+ * Use 16 for short-lived URLs (backward compat), 32 for long-lived URLs (128 bits).
+ * @param {string} slug
+ * @param {string} agent_id
+ * @param {string} conversation_id
+ * @param {number} expires_at
+ * @param {string} secret
+ * @param {number} sig_length
+ * @returns {string}
+ */
+function compute_signature_with_length(slug, agent_id, conversation_id, expires_at, secret, sig_length) {
+    let deferred5_0;
+    let deferred5_1;
+    try {
+        const ptr0 = passStringToWasm0(slug, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(agent_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(conversation_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(secret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.compute_signature_with_length(ptr0, len0, ptr1, len1, ptr2, len2, expires_at, ptr3, len3, sig_length);
+        deferred5_0 = ret[0];
+        deferred5_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+    }
+}
+exports.compute_signature_with_length = compute_signature_with_length;
+
+/**
+ * Create a unified diff patch representing the difference between `original`
+ * and `modified`.
+ * @param {string} original
+ * @param {string} modified
+ * @returns {string}
+ */
+function create_patch(original, modified) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(original, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(modified, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.create_patch(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.create_patch = create_patch;
+
+/**
+ * Decode a base62-encoded string back into an integer.
+ * @param {string} s
+ * @returns {bigint}
+ */
+function decode_base62(s) {
+    const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.decode_base62(ptr0, len0);
+    return BigInt.asUintN(64, ret);
+}
+exports.decode_base62 = decode_base62;
+
+/**
+ * Decompress zlib-wrapped deflate bytes back to a UTF-8 string.
+ *
+ * Matches Node.js `zlib.inflate` for backward compatibility.
+ *
+ * # Errors
+ * Returns an error string if decompression or UTF-8 conversion fails.
+ * @param {Uint8Array} data
+ * @returns {string}
+ */
+function decompress(data) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.decompress(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.decompress = decompress;
+
+/**
+ * Derive a per-agent signing key from their API key.
+ * Uses `HMAC-SHA256(api_key, "llmtxt-signing")`.
+ * @param {string} api_key
+ * @returns {string}
+ */
+function derive_signing_key(api_key) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(api_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.derive_signing_key(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.derive_signing_key = derive_signing_key;
+
+/**
+ * Encode a non-negative integer into a base62 string.
+ *
+ * Uses the alphabet `0-9A-Za-z`. Zero encodes to `"0"`.
+ * @param {bigint} num
+ * @returns {string}
+ */
+function encode_base62(num) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.encode_base62(num);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.encode_base62 = encode_base62;
+
+/**
+ * Generate an 8-character base62 ID from a UUID v4.
+ * @returns {string}
+ */
+function generate_id() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.generate_id();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.generate_id = generate_id;
+
+/**
+ * Compute the SHA-256 hash of a UTF-8 string, returned as lowercase hex.
+ * @param {string} data
+ * @returns {string}
+ */
+function hash_content(data) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hash_content(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.hash_content = hash_content;
+
+/**
+ * Check whether a timestamp (milliseconds) has expired.
+ * Returns false for 0 (no expiration).
+ *
+ * Uses `js_sys::Date::now()` in WASM, `std::time::SystemTime` natively.
+ * @param {number} expires_at_ms
+ * @returns {boolean}
+ */
+function is_expired(expires_at_ms) {
+    const ret = wasm.is_expired(expires_at_ms);
+    return ret !== 0;
+}
+exports.is_expired = is_expired;
+
+/**
+ * Apply a sequence of patches to base content, returning the content at the
+ * target version. This avoids N WASM boundary crossings by performing all
+ * patch applications in a single Rust call.
+ *
+ * `patches_json` is a JSON array of patch strings: `["patch1", "patch2", ...]`.
+ * `target` is the 1-based version to reconstruct (0 returns `base` unchanged).
+ * If `target` exceeds the number of patches, all patches are applied.
+ * @param {string} base
+ * @param {string} patches_json
+ * @param {number} target
+ * @returns {string}
+ */
+function reconstruct_version(base, patches_json, target) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(base, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(patches_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.reconstruct_version(ptr0, len0, ptr1, len1, target);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+exports.reconstruct_version = reconstruct_version;
+
+/**
+ * Apply all patches sequentially to base content, then produce a single
+ * unified diff from the original base to the final state.
+ *
+ * `patches_json` is a JSON array of patch strings: `["patch1", "patch2", ...]`.
+ * @param {string} base
+ * @param {string} patches_json
+ * @returns {string}
+ */
+function squash_patches(base, patches_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(base, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(patches_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.squash_patches(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+exports.squash_patches = squash_patches;
+
+/**
+ * Compute character-level n-gram Jaccard similarity between two texts.
+ * Returns 0.0 (no overlap) to 1.0 (identical). Default n=3.
+ *
+ * Suitable for finding similar messages without vector embeddings.
+ * @param {string} a
+ * @param {string} b
+ * @returns {number}
+ */
+function text_similarity(a, b) {
+    const ptr0 = passStringToWasm0(a, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(b, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.text_similarity(ptr0, len0, ptr1, len1);
+    return ret;
+}
+exports.text_similarity = text_similarity;
+
+/**
+ * Compute n-gram Jaccard similarity with configurable gram size.
+ * @param {string} a
+ * @param {string} b
+ * @param {number} n
+ * @returns {number}
+ */
+function text_similarity_ngram(a, b, n) {
+    const ptr0 = passStringToWasm0(a, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(b, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.text_similarity_ngram(ptr0, len0, ptr1, len1, n);
+    return ret;
+}
+exports.text_similarity_ngram = text_similarity_ngram;
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_throw_6ddd609b62940d55: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_getRandomValues_a1cf2e70b003a59d: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
+        __wbg_now_16f0c993d5dd6c27: function() {
+            const ret = Date.now();
+            return ret;
+        },
+        __wbindgen_cast_0000000000000001: 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,
+        "./llmtxt_core_bg.js": import0,
+    };
+}
+
+const DiffResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_diffresult_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 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 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();
+function decodeText(ptr, 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;
+
+const wasmPath = `${__dirname}/llmtxt_core_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
+wasm.__wbindgen_start();