@f5-sales-demo/docs-theme 4.13.9 → 4.13.11

package/config.ts

@@ -23,6 +23,7 @@ import { defaultLocale as f5xcDefaultLocale, f5xcDefaultLocales } from './src/i1
 import { mobileLabels } from './src/i18n/mega-menu-translations.ts';
 import { sidebarTranslations } from './src/i18n/translations.ts';
 import remarkMermaid from './src/plugins/remark-mermaid.mjs';
+import { englishSearchEngineIntegration } from './src/search/pagefind-engine.mjs';
 import { sharedSearchIntegration } from './src/shared/search-integration.mjs';
 import { sharedMode } from './src/shared/settings.mjs';
 import canonicalLlms from './src/utils/canonical-llms.mjs';
@@ -474,6 +475,7 @@ export function createF5xcDocsConfig(options: F5xcDocsConfigOptions = {}) {
         : []),
       ...(githubRepository === 'f5-sales-demo/statistics' ? [statisticsScriptMarkdown()] : []),
       ...additionalIntegrations,
+      englishSearchEngineIntegration(),
     ],
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@f5-sales-demo/docs-theme",
-  "version": "4.13.9",
+  "version": "4.13.11",
   "description": "F5 Distributed Cloud branded Starlight documentation theme",
   "type": "module",
   "engines": {
@@ -64,7 +64,8 @@
     "assets/",
     "components/",
     "src/",
-    "canonical-route-middleware.ts"
+    "canonical-route-middleware.ts",
+    "vendor/pagefind/"
   ],
   "keywords": [
     "starlight",
@@ -95,6 +96,7 @@
     "@types/react": "^19.2.18",
     "@types/react-dom": "^19.2.7",
     "astro": "7.2.8",
+    "pagefind": "1.5.2",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
     "vitest": "^4.1.11"

package/src/search/README.md

@@ -0,0 +1,17 @@
+# English Pagefind matching
+
+The engine uses indexed words beginning with the query term and retains Pagefind's English stemming. It rejects inverse-prefix matches and requires every word in a multiword query to match. Unknown tokens therefore produce no results without disabling autocomplete, ranking, filters, or quoted searches.
+
+The build integration replaces only the English WebAssembly engine after Starlight generates its index. It verifies the Pagefind version, sealed artifact checksum, and the generated module's import/export interface before replacing the file. Other language engines remain untouched.
+
+The artifact uses Pagefind 1.5.2 at the immutable upstream commit recorded in `../../vendor/pagefind/manifest.json`. `../../vendor/pagefind/pagefind-1.5.2.patch` contains both corrections and their Rust regression tests; the upstream license is retained. The adjacent generated bindings exercise the actual WebAssembly module in Node tests against a real Pagefind index.
+
+To reproduce the artifact, use the recorded Rust compiler, the `wasm32-unknown-unknown` target, Python 3.15, and the matching wasm-bindgen CLI:
+
+```sh
+WASM_BINDGEN_BIN=/path/to/wasm-bindgen node src/search/rebuild-engine.mjs
+```
+
+Build paths are remapped to synthetic source and dependency roots before sealing the artifact.
+
+The rebuild verifies the pinned source patch and Cargo lock, runs the native regressions, and requires the resulting artifact to match its recorded checksum. The published package includes the sealed engine; ordinary documentation builds require no Rust toolchain.

package/src/search/pagefind-engine.mjs

@@ -0,0 +1,52 @@
+import { createHash } from 'node:crypto';
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { gunzipSync } from 'node:zlib';
+
+const vendor = new URL('../../vendor/pagefind/', import.meta.url);
+const sha256 = (bytes) => createHash('sha256').update(bytes).digest('hex');
+const magic = Buffer.from('pagefind_dcd');
+
+function moduleInterface(bytes) {
+  const unpacked = gunzipSync(bytes);
+  if (!unpacked.subarray(0, magic.length).equals(magic)) throw new Error('Invalid Pagefind WASM envelope');
+  const module = new WebAssembly.Module(unpacked.subarray(magic.length));
+  return JSON.stringify({ imports: WebAssembly.Module.imports(module), exports: WebAssembly.Module.exports(module) });
+}
+
+export async function installEnglishSearchEngine(directory) {
+  const root = directory instanceof URL ? fileURLToPath(directory) : directory;
+  const pagefind = path.join(root, 'pagefind');
+  let entry;
+  try {
+    entry = JSON.parse(await readFile(path.join(pagefind, 'pagefind-entry.json'), 'utf8'));
+  } catch (error) {
+    if (error.code === 'ENOENT') return { applied: false };
+    throw error;
+  }
+  if (entry.languages?.en?.wasm !== 'en') return { applied: false };
+  const manifest = JSON.parse(await readFile(new URL('manifest.json', vendor), 'utf8'));
+  if (entry.version !== manifest.pagefindVersion) throw new Error(`Unsupported Pagefind version ${entry.version}`);
+  const replacement = await readFile(new URL('wasm.en.pagefind', vendor));
+  if (sha256(replacement) !== manifest.sha256) throw new Error('Pagefind search engine integrity mismatch');
+  const destination = path.join(pagefind, 'wasm.en.pagefind');
+  const original = await readFile(destination);
+  if (moduleInterface(original) !== moduleInterface(replacement))
+    throw new Error('Pagefind search engine ABI mismatch');
+  if (sha256(original) !== manifest.sha256) await writeFile(destination, replacement);
+  return { applied: true, sha256: manifest.sha256, pagefindVersion: manifest.pagefindVersion };
+}
+
+export function englishSearchEngineIntegration() {
+  return {
+    name: 'f5-pagefind-search-matching',
+    hooks: {
+      'astro:build:done': async ({ dir, logger }) => {
+        const result = await installEnglishSearchEngine(dir);
+        if (result.applied)
+          logger.info(`English Pagefind matching engine ${result.pagefindVersion} sha256:${result.sha256}`);
+      },
+    },
+  };
+}

package/src/search/pagefind-engine.test.ts

@@ -0,0 +1,88 @@
+import { createHash } from 'node:crypto';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+import { gunzipSync } from 'node:zlib';
+import * as pagefind from 'pagefind';
+import { afterAll, beforeAll, expect, it } from 'vitest';
+import { installEnglishSearchEngine } from './pagefind-engine.mjs';
+
+let directory: string;
+const require = createRequire(import.meta.url);
+const checksum = (bytes: Buffer) => createHash('sha256').update(bytes).digest('hex');
+const unpack = (bytes: Buffer) => gunzipSync(bytes).subarray(12);
+
+beforeAll(async () => {
+  directory = await mkdtemp(path.join(os.tmpdir(), 'pagefind-matching-'));
+  const { index, errors } = await pagefind.createIndex();
+  expect(errors).toEqual([]);
+  if (!index) throw new Error('Missing Pagefind index');
+  for (const [slug, title, body] of [
+    ['alias', 'Command alias', 'Search also answers to q.'],
+    ['manifest', 'Manifest guide', 'Create and apply manifests with xcsh.'],
+  ]) {
+    const result = await index.addHTMLFile({
+      sourcePath: `${slug}/index.html`,
+      content: `<html lang="en"><body><main data-pagefind-body><h1>${title}</h1><p>${body}</p></main></body></html>`,
+    });
+    expect(result.errors).toEqual([]);
+  }
+  const output = await index.writeFiles({ outputPath: path.join(directory, 'pagefind') });
+  expect(output.errors).toEqual([]);
+  await pagefind.close();
+}, 30000);
+
+afterAll(async () => {
+  await rm(directory, { recursive: true, force: true });
+});
+
+it('rejects unsupported engines before modifying their output', async () => {
+  const file = path.join(directory, 'pagefind/pagefind-entry.json');
+  const original = await readFile(file, 'utf8');
+  const engine = await readFile(path.join(directory, 'pagefind/wasm.en.pagefind'));
+  const entry = JSON.parse(original);
+  entry.version = '999.0.0';
+  await writeFile(file, JSON.stringify(entry));
+  await expect(installEnglishSearchEngine(directory)).rejects.toThrow('Unsupported Pagefind version');
+  expect(await readFile(path.join(directory, 'pagefind/wasm.en.pagefind'))).toEqual(engine);
+  await writeFile(file, original);
+});
+
+it('installs the sealed compatible engine and is idempotent', async () => {
+  const installed = await installEnglishSearchEngine(directory);
+  expect(installed.applied).toBe(true);
+  const file = path.join(directory, 'pagefind/wasm.en.pagefind');
+  const first = await readFile(file);
+  expect(checksum(first)).toBe(installed.sha256);
+  expect(await installEnglishSearchEngine(directory)).toEqual(installed);
+  expect(await readFile(file)).toEqual(first);
+});
+
+it('runs the actual WASM against a real index with strict word and forward-prefix matching', async () => {
+  await installEnglishSearchEngine(directory);
+  const backend = require('../../vendor/pagefind/pagefind-bindings.cjs');
+  const bytes = unpack(await readFile(path.join(directory, 'pagefind/wasm.en.pagefind')));
+  await backend({ module_or_path: bytes });
+  const entry = JSON.parse(await readFile(path.join(directory, 'pagefind/pagefind-entry.json'), 'utf8'));
+  const metadata = unpack(await readFile(path.join(directory, `pagefind/pagefind.${entry.languages.en.hash}.pf_meta`)));
+  const pointer = backend.init_pagefind(metadata);
+  expect(pointer).not.toBe(0);
+  for (const [query, expected] of [
+    ['qzxwvjknypvzrltg', 0],
+    ['qzxwvjknypvzrltg manifest', 0],
+    ['manifestunknownsuffix', 0],
+    ['manifest', 1],
+    ['manif', 1],
+    ['manifests', 1],
+    ['q', 1],
+  ] as const) {
+    for (const hash of JSON.parse(backend.request_indexes(pointer, query))) {
+      const chunk = unpack(await readFile(path.join(directory, `pagefind/index/${hash}.pf_index`)));
+      backend.load_index_chunk(pointer, chunk);
+    }
+    const result = JSON.parse(backend.search(pointer, query, query, '', '', false, false));
+    expect(result.results.length, query).toBe(expected);
+    expect(result.unfiltered_total, query).toBe(expected);
+  }
+});

package/src/search/rebuild-engine.mjs

@@ -0,0 +1,78 @@
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const vendor = new URL('../../vendor/pagefind/', import.meta.url);
+const manifest = JSON.parse(await readFile(new URL('manifest.json', vendor), 'utf8'));
+const checksum = (bytes) => createHash('sha256').update(bytes).digest('hex');
+const run = (command, args, options = {}) => {
+  const result = spawnSync(command, args, { encoding: 'utf8', stdio: 'pipe', ...options });
+  if (result.error || result.status !== 0) throw result.error || new Error(`${command} failed: ${result.stderr}`);
+  return result.stdout;
+};
+const wasmBindgen = process.env.WASM_BINDGEN_BIN || 'wasm-bindgen';
+if (run('rustc', ['--version']).trim() !== manifest.rustCompiler) throw new Error('Use the recorded Rust compiler');
+if (run(wasmBindgen, ['--version']).trim() !== `wasm-bindgen ${manifest.wasmBindgenVersion}`)
+  throw new Error('Use the recorded wasm-bindgen version');
+const patch = await readFile(new URL('pagefind-1.5.2.patch', vendor));
+if (checksum(patch) !== manifest.patchSha256) throw new Error('Source patch integrity mismatch');
+const workspace = await mkdtemp(path.join(os.tmpdir(), 'pagefind-engine-source-'));
+try {
+  const source = path.join(workspace, 'source');
+  run('git', ['clone', '--quiet', '--no-checkout', 'https://github.com/Pagefind/pagefind.git', source]);
+  run('git', ['checkout', '--detach', manifest.upstreamCommit], { cwd: source });
+  run('git', ['apply', '--unidiff-zero', fileURLToPath(new URL('pagefind-1.5.2.patch', vendor))], { cwd: source });
+  const cargoFile = path.join(source, 'pagefind_web/Cargo.toml');
+  const cargoHome = process.env.CARGO_HOME || path.join(os.homedir(), '.cargo');
+  const remap = [`--remap-path-prefix=${source}=/pagefind`, `--remap-path-prefix=${cargoHome}=/cargo`];
+  const cargoEnvironment = { ...process.env, CARGO_ENCODED_RUSTFLAGS: remap.join('\u001f') };
+
+  if (checksum(await readFile(path.join(source, 'pagefind_web/Cargo.lock'))) !== manifest.cargoLockSha256)
+    throw new Error('Cargo lock integrity mismatch');
+  run(
+    'cargo',
+    ['test', '--manifest-path', cargoFile, '--locked', '--release', '--features', 'en', 'forward_prefix_tests'],
+    { env: cargoEnvironment },
+  );
+  run(
+    'cargo',
+    [
+      'build',
+      '--manifest-path',
+      cargoFile,
+      '--locked',
+      '--release',
+      '--features',
+      'en',
+      '--target',
+      'wasm32-unknown-unknown',
+    ],
+    { env: cargoEnvironment },
+  );
+  const output = path.join(workspace, 'bindings');
+  run(wasmBindgen, [
+    path.join(source, 'pagefind_web/target/wasm32-unknown-unknown/release/pagefind_web.wasm'),
+    '--target',
+    'no-modules',
+    '--out-dir',
+    output,
+  ]);
+  const packet = path.join(workspace, 'wasm.en.pagefind');
+  run('python3', [
+    '-c',
+    'import gzip,pathlib,sys; pathlib.Path(sys.argv[2]).write_bytes(gzip.compress(b"pagefind_dcd"+pathlib.Path(sys.argv[1]).read_bytes(),compresslevel=9,mtime=0))',
+    path.join(output, 'pagefind_web_bg.wasm'),
+    packet,
+  ]);
+  const bytes = await readFile(packet);
+  if (checksum(bytes) !== manifest.sha256) throw new Error(`Rebuilt engine differs: ${checksum(bytes)}`);
+  await writeFile(new URL('wasm.en.pagefind', vendor), bytes);
+  const bindings = await readFile(path.join(output, 'pagefind_web.js'), 'utf8');
+  await writeFile(new URL('pagefind-bindings.cjs', vendor), `${bindings}\nmodule.exports = wasm_bindgen;\n`);
+  console.log(`Reproduced Pagefind ${manifest.pagefindVersion} engine sha256:${manifest.sha256}`);
+} finally {
+  await rm(workspace, { recursive: true, force: true });
+}

package/vendor/pagefind/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2022 Pagefind
+
+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/vendor/pagefind/manifest.json

@@ -0,0 +1,13 @@
+{
+  "pagefindVersion": "1.5.2",
+  "upstreamCommit": "bf17396721be637cc67c8ed7ead1dc7b8ac43d96",
+  "sha256": "bb201cd6460bacb5399d77ef12f076413655122dd54a529314ffa96bcace5d5d",
+  "patchSha256": "73db39627af42174a3a0732c8450f469d350ccbd4d715872eed9ae77a6c6fb96",
+  "wasmBindgenVersion": "0.2.117",
+  "rustCompiler": "rustc 1.99.0 (b940084d7 2026-09-28)",
+  "cargoLockSha256": "bd45029efb862c7aef38ccb524194eb8d36b0eb28ac7cc22467474d27d6556dd",
+  "pathRemapping": {
+    "source": "/pagefind",
+    "dependencies": "/cargo"
+  }
+}

package/vendor/pagefind/pagefind-1.5.2.patch

@@ -0,0 +1,91 @@
+diff --git a/pagefind_web/Cargo.lock b/pagefind_web/Cargo.lock
+index 1c15fdf..0ec7782 100644
+--- a/pagefind_web/Cargo.lock
++++ b/pagefind_web/Cargo.lock
+@@ -61 +61 @@ name = "pagefind_web"
+-version = "0.0.0"
++version = "1.5.2"
+diff --git a/pagefind_web/Cargo.toml b/pagefind_web/Cargo.toml
+index de44fac..90669d5 100644
+--- a/pagefind_web/Cargo.toml
++++ b/pagefind_web/Cargo.toml
+@@ -3 +3 @@ name = "pagefind_web"
+-version = "0.0.0"
++version = "1.5.2"
+diff --git a/pagefind_web/src/search.rs b/pagefind_web/src/search.rs
+index 24a75b2..61210ca 100644
+--- a/pagefind_web/src/search.rs
++++ b/pagefind_web/src/search.rs
+@@ -504,0 +505 @@ impl SearchIndex {
++                maps.push(BitSet::new());
+@@ -812,26 +813 @@ impl SearchIndex {
+-        let mut extensions = vec![];
+-        let mut longest_prefix = None;
+-        for (key, results) in self.words.iter() {
+-            if key.starts_with(term) {
+-                debug!({
+-                    format! {"Adding {:#?} to the query", key}
+-                });
+-                extensions.push((key, results));
+-            } else if term.starts_with(key)
+-                && key.len() > longest_prefix.map(String::len).unwrap_or_default()
+-            {
+-                longest_prefix = Some(key);
+-            }
+-        }
+-        if extensions.is_empty() {
+-            debug!({ "No word extensions found, checking the inverse" });
+-            if let Some(longest_prefix) = longest_prefix {
+-                if let Some(results) = self.words.get(longest_prefix) {
+-                    debug!({
+-                        format! {"Adding the prefix {:#?} to the query", longest_prefix}
+-                    });
+-                    extensions.push((longest_prefix, results));
+-                }
+-            }
+-        }
+-        extensions
++        self.words.iter().filter(|(word, _)| word.starts_with(term)).collect()
+@@ -838,0 +815 @@ impl SearchIndex {
++
+@@ -878,0 +856,40 @@ fn union_maps(mut maps: Vec<BitSet>) -> Option<BitSet> {
++
++#[cfg(test)]
++mod forward_prefix_tests {
++    use super::*;
++    use crate::{RankingWeights, WordData, Page, PageWord};
++    use std::collections::BTreeMap;
++    fn fixture() -> SearchIndex {
++        SearchIndex {
++            web_version: "1.5.2", playground_mode: false, generator_version: None,
++            pages: vec![Page { hash: "fixture".into(), word_count: 2 }], average_page_length: 2.0, chunks: vec![], filter_chunks: BTreeMap::new(),
++            words: ["q", "manifest"].into_iter().map(|word| (word.to_string(), WordData { pages: vec![PageWord { page: 0, locs: vec![(24, 0)], meta_locs: vec![] }], additional_variants: vec![] })).collect(),
++            filters: BTreeMap::new(), sorts: BTreeMap::new(), meta_fields: vec![], ranking_weights: RankingWeights::default(),
++        }
++    }
++    #[test]
++    fn unknown_query_cannot_match_a_short_indexed_prefix() {
++        let index = fixture();
++        assert!(index.find_word_extensions("qzxwvjknypvzrltg").is_empty());
++        assert!(index.find_word_extensions("manifestunknownsuffix").is_empty());
++    }
++    #[test]
++    fn autocomplete_and_explicit_short_terms_still_match() {
++        let index = fixture();
++        for (query, expected) in [("manif", "manifest"), ("manifest", "manifest"), ("q", "q")] {
++            let found = index.find_word_extensions(query);
++            assert_eq!(found.len(), 1);
++            assert_eq!(found[0].0, expected);
++        }
++    }
++    #[test]
++    fn english_inflections_are_stemmed_before_prefix_matching() {
++        assert_eq!(stems_from_term("manifests")[0].as_ref(), "manifest");
++    }    #[test]
++    fn every_word_in_a_multiword_query_must_match() {
++        let index = fixture();
++        assert!(index.search_term("qzxwvjknypvzrltg manifest", "qzxwvjknypvzrltg manifest", None, false).1.is_empty());
++        assert_eq!(index.search_term("manifest", "manifest", None, false).1.len(), 1);
++    }
++
++}

package/vendor/pagefind/pagefind-bindings.cjs

@@ -0,0 +1,381 @@
+let wasm_bindgen = (function(exports) {
+    let script_src;
+    if (typeof document !== 'undefined' && document.currentScript !== null) {
+        script_src = new URL(document.currentScript.src, location.href).toString();
+    }
+
+    /**
+     * @param {number} ptr
+     * @param {string} filter
+     * @returns {number}
+     */
+    function add_synthetic_filter(ptr, filter) {
+        const ptr0 = passStringToWasm0(filter, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.add_synthetic_filter(ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    exports.add_synthetic_filter = add_synthetic_filter;
+
+    /**
+     * @param {number} ptr
+     * @returns {number}
+     */
+    function enter_playground_mode(ptr) {
+        const ret = wasm.enter_playground_mode(ptr);
+        return ret >>> 0;
+    }
+    exports.enter_playground_mode = enter_playground_mode;
+
+    /**
+     * @param {number} ptr
+     * @returns {string}
+     */
+    function filters(ptr) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.filters(ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    exports.filters = filters;
+
+    /**
+     * @param {Uint8Array} metadata_bytes
+     * @returns {number}
+     */
+    function init_pagefind(metadata_bytes) {
+        const ptr0 = passArray8ToWasm0(metadata_bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.init_pagefind(ptr0, len0);
+        return ret >>> 0;
+    }
+    exports.init_pagefind = init_pagefind;
+
+    /**
+     * @param {number} ptr
+     * @param {Uint8Array} chunk_bytes
+     * @returns {number}
+     */
+    function load_filter_chunk(ptr, chunk_bytes) {
+        const ptr0 = passArray8ToWasm0(chunk_bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.load_filter_chunk(ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    exports.load_filter_chunk = load_filter_chunk;
+
+    /**
+     * @param {number} ptr
+     * @param {Uint8Array} chunk_bytes
+     * @returns {number}
+     */
+    function load_index_chunk(ptr, chunk_bytes) {
+        const ptr0 = passArray8ToWasm0(chunk_bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.load_index_chunk(ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    exports.load_index_chunk = load_index_chunk;
+
+    /**
+     * @param {number} ptr
+     * @returns {string}
+     */
+    function request_all_filter_indexes(ptr) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.request_all_filter_indexes(ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    exports.request_all_filter_indexes = request_all_filter_indexes;
+
+    /**
+     * @param {number} ptr
+     * @param {string} filters
+     * @returns {string}
+     */
+    function request_filter_indexes(ptr, filters) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ptr0 = passStringToWasm0(filters, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.request_filter_indexes(ptr, 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.request_filter_indexes = request_filter_indexes;
+
+    /**
+     * @param {number} ptr
+     * @param {string} query
+     * @returns {string}
+     */
+    function request_indexes(ptr, query) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.request_indexes(ptr, 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.request_indexes = request_indexes;
+
+    /**
+     * @param {number} ptr
+     * @param {string} query
+     * @param {string} original_query
+     * @param {string} filter
+     * @param {string} sort
+     * @param {boolean} exact
+     * @param {boolean} exact_diacritics
+     * @returns {string}
+     */
+    function search(ptr, query, original_query, filter, sort, exact, exact_diacritics) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const ptr0 = passStringToWasm0(query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(original_query, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(filter, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passStringToWasm0(sort, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len3 = WASM_VECTOR_LEN;
+            const ret = wasm.search(ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, exact, exact_diacritics);
+            deferred5_0 = ret[0];
+            deferred5_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+        }
+    }
+    exports.search = search;
+
+    /**
+     * @param {number} ptr
+     * @param {string} weights
+     * @returns {number}
+     */
+    function set_ranking_weights(ptr, weights) {
+        const ptr0 = passStringToWasm0(weights, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.set_ranking_weights(ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    exports.set_ranking_weights = set_ranking_weights;
+
+    function __wbg_get_imports() {
+        const import0 = {
+            __proto__: null,
+            __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,
+            "./pagefind_web_bg.js": import0,
+        };
+    }
+
+    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 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;
+    }
+
+    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;
+
+    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 && script_src !== undefined) {
+            module_or_path = script_src.replace(/\.js$/, "_bg.wasm");
+        }
+        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);
+    }
+
+    return Object.assign(__wbg_init, { initSync }, exports);
+})({ __proto__: null });
+
+module.exports = wasm_bindgen;