@hawkeyexl/manni 4.1.0 → 4.2.0

package/dist/graph/runtime.js

@@ -0,0 +1,3067 @@
+// src/graph/core/sort.ts
+function byCodeUnit(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+// src/graph/core/vocab.ts
+var NS = {
+  dcterms: "http://purl.org/dc/terms/",
+  foaf: "http://xmlns.com/foaf/0.1/",
+  graph: "https://hawkeyexl.github.io/manni/graph/ns#",
+  iirds: "http://iirds.tekom.de/iirds#",
+  iirdsSft: "http://iirds.tekom.de/iirds/domain/software#",
+  prov: "http://www.w3.org/ns/prov#",
+  rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+  schema: "https://schema.org/",
+  skos: "http://www.w3.org/2004/02/skos/core#",
+  xsd: "http://www.w3.org/2001/XMLSchema#"
+};
+var PREFIXES = Object.entries(NS).sort(([a], [b]) => a < b ? -1 : 1);
+var RDF_TYPE = `${NS.rdf}type`;
+var ROLE = {
+  author: `${NS.graph}authorRole`,
+  generator: `${NS.graph}generatorRole`,
+  tool: `${NS.graph}toolRole`
+};
+
+// src/graph/runtime/graph.ts
+var XSD_STRING = "http://www.w3.org/2001/XMLSchema#string";
+function compareValues(a, b) {
+  if (a.kind !== b.kind) return a.kind === "iri" ? -1 : 1;
+  const v = byCodeUnit(a.value, b.value);
+  if (v !== 0) return v;
+  const da = a.kind === "literal" ? a.datatype ?? "" : "";
+  const db = b.kind === "literal" ? b.datatype ?? "" : "";
+  return byCodeUnit(da, db);
+}
+var GraphIndex = class _GraphIndex {
+  nodes = /* @__PURE__ */ new Map();
+  /** subject → predicate → object IRIs (sorted). */
+  outbound = /* @__PURE__ */ new Map();
+  /** object → predicate → subject IRIs (sorted). */
+  inbound = /* @__PURE__ */ new Map();
+  /** class IRI → instance IRIs (sorted). */
+  byType = /* @__PURE__ */ new Map();
+  /** prefix → namespace, from the artifact's own `@context`. */
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+  /**
+   * Build from a `graph.jsonld` document — a JSON string or the parsed object.
+   * CURIE keys and `@type` values are expanded using the document's own
+   * `@context`, so the index is self-describing.
+   */
+  static fromJsonLd(input) {
+    const doc = typeof input === "string" ? JSON.parse(input) : input;
+    const context = doc["@context"] ?? {};
+    const index = new _GraphIndex({ ...context });
+    for (const raw of doc["@graph"] ?? []) {
+      index.addJsonLdNode(raw);
+    }
+    index.finalize();
+    return index;
+  }
+  /** Build from dockg's internal quad shape (the Node/CLI path). */
+  static fromQuads(quads, context = {}) {
+    const index = new _GraphIndex({ ...context });
+    for (const q of quads) {
+      const o = q.o;
+      const value = o.kind === "iri" ? { kind: "iri", value: o.value } : o.datatype && o.datatype !== XSD_STRING ? { kind: "literal", value: o.value, datatype: o.datatype } : { kind: "literal", value: o.value };
+      index.addTriple(q.s, q.p, value);
+    }
+    index.finalize();
+    return index;
+  }
+  /** Expand a CURIE (`dcterms:title`) to a full IRI using `@context`. */
+  expand(term) {
+    const colon = term.indexOf(":");
+    if (colon <= 0) return term;
+    const ns = this.context[term.slice(0, colon)];
+    return ns ? `${ns}${term.slice(colon + 1)}` : term;
+  }
+  /** Compact a full IRI to a CURIE when a context namespace matches. */
+  compact(iri) {
+    let best = iri;
+    let bestNs = "";
+    for (const [prefix, ns] of Object.entries(this.context)) {
+      if (iri.startsWith(ns) && iri.length > ns.length && ns.length > bestNs.length) {
+        best = `${prefix}:${iri.slice(ns.length)}`;
+        bestNs = ns;
+      }
+    }
+    return best;
+  }
+  addJsonLdNode(raw) {
+    const id = typeof raw["@id"] === "string" ? this.expand(raw["@id"]) : "";
+    if (!id) return;
+    this.ensureNode(id);
+    const rawTypes = raw["@type"];
+    for (const t of toArray(rawTypes)) {
+      if (typeof t === "string") {
+        this.addTriple(id, RDF_TYPE, { kind: "iri", value: this.expand(t) });
+      }
+    }
+    for (const [key, rawValue] of Object.entries(raw)) {
+      if (key === "@id" || key === "@type") continue;
+      const predicate = this.expand(key);
+      for (const v of toArray(rawValue)) {
+        const value = this.toValue(v);
+        if (value) this.addTriple(id, predicate, value);
+      }
+    }
+  }
+  toValue(v) {
+    if (typeof v === "string") return { kind: "literal", value: v };
+    if (typeof v === "number" || typeof v === "boolean") {
+      return { kind: "literal", value: String(v) };
+    }
+    if (v && typeof v === "object") {
+      const o = v;
+      if (typeof o["@id"] === "string") {
+        return { kind: "iri", value: this.expand(o["@id"]) };
+      }
+      if (o["@value"] !== void 0) {
+        const raw = o["@value"];
+        const lexical = typeof raw === "string" ? raw : JSON.stringify(raw);
+        const dt = typeof o["@type"] === "string" ? this.expand(o["@type"]) : void 0;
+        return dt && dt !== XSD_STRING ? { kind: "literal", value: lexical, datatype: dt } : { kind: "literal", value: lexical };
+      }
+    }
+    return void 0;
+  }
+  ensureNode(id) {
+    let node = this.nodes.get(id);
+    if (!node) {
+      node = { id, types: [], props: /* @__PURE__ */ new Map() };
+      this.nodes.set(id, node);
+    }
+    return node;
+  }
+  addTriple(s, p, o) {
+    const node = this.ensureNode(s);
+    let values = node.props.get(p);
+    if (!values) {
+      values = [];
+      node.props.set(p, values);
+    }
+    values.push(o);
+    if (p === RDF_TYPE && o.kind === "iri") {
+      node.types.push(o.value);
+      const instances = this.byType.get(o.value);
+      if (instances) instances.push(s);
+      else this.byType.set(o.value, [s]);
+    }
+    if (o.kind === "iri") {
+      addEdge(this.outbound, s, p, o.value);
+      addEdge(this.inbound, o.value, p, s);
+      this.ensureNode(o.value);
+    }
+  }
+  /** Sort every collection so traversal order is deterministic. */
+  finalize() {
+    for (const node of this.nodes.values()) {
+      node.types.sort(byCodeUnit);
+      for (const values of node.props.values()) values.sort(compareValues);
+    }
+    for (const instances of this.byType.values()) instances.sort(byCodeUnit);
+    for (const map of [this.outbound, this.inbound]) {
+      for (const preds of map.values()) {
+        for (const targets of preds.values()) targets.sort(byCodeUnit);
+      }
+    }
+  }
+  /** Every node IRI, sorted. */
+  ids() {
+    return [...this.nodes.keys()].sort(byCodeUnit);
+  }
+  size() {
+    return this.nodes.size;
+  }
+  node(iri) {
+    return this.nodes.get(iri);
+  }
+  has(iri) {
+    return this.nodes.has(iri);
+  }
+  /** Class IRIs of a node, sorted. */
+  types(iri) {
+    return this.nodes.get(iri)?.types ?? [];
+  }
+  /** Instances of a class, sorted. */
+  instancesOf(classIri) {
+    return this.byType.get(classIri) ?? [];
+  }
+  /** All values for a predicate, sorted. */
+  values(iri, predicate) {
+    return this.nodes.get(iri)?.props.get(predicate) ?? [];
+  }
+  /** Literal lexical forms for a predicate, sorted. */
+  literals(iri, predicate) {
+    return this.values(iri, predicate).filter((v) => v.kind === "literal").map((v) => v.value);
+  }
+  /** The first literal for a predicate, if any. */
+  literal(iri, predicate) {
+    return this.literals(iri, predicate)[0];
+  }
+  /** Outbound IRI targets: all predicates, or one. Sorted. */
+  out(iri, predicate) {
+    return edges(this.outbound, iri, predicate);
+  }
+  /** Inbound IRI sources (who points at this node). Sorted. */
+  in(iri, predicate) {
+    return edges(this.inbound, iri, predicate);
+  }
+};
+function addEdge(map, key, predicate, target) {
+  let preds = map.get(key);
+  if (!preds) {
+    preds = /* @__PURE__ */ new Map();
+    map.set(key, preds);
+  }
+  const targets = preds.get(predicate);
+  if (targets) targets.push(target);
+  else preds.set(predicate, [target]);
+}
+function edges(map, iri, predicate) {
+  const preds = map.get(iri);
+  if (!preds) return [];
+  const out = [];
+  const keys = predicate ? [predicate] : [...preds.keys()].sort(byCodeUnit);
+  for (const p of keys) {
+    for (const target of preds.get(p) ?? []) out.push({ predicate: p, target });
+  }
+  return out;
+}
+function toArray(v) {
+  if (v === void 0 || v === null) return [];
+  return Array.isArray(v) ? v : [v];
+}
+
+// src/graph/runtime/trace.ts
+function createTrace() {
+  return { entry: [], hops: [], exclusions: [], resolutions: [] };
+}
+function reachedNodes(trace) {
+  const reached = /* @__PURE__ */ new Set();
+  for (const e of trace.entry) reached.add(e.iri);
+  for (const h of trace.hops) reached.add(h.to);
+  return reached;
+}
+
+// src/graph/core/localizations.ts
+var LOCALIZATIONS_FILENAME = "localizations.json";
+var UNDETERMINED = "und";
+var LANGUAGE_TAG = /^[A-Za-z]{2,3}(-[A-Za-z]{4})?(-([A-Za-z]{2}|[0-9]{3}))?(-([A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*$/;
+function isLanguageTag(value) {
+  return LANGUAGE_TAG.test(value);
+}
+function canonicalLanguageTag(tag) {
+  try {
+    return Intl.getCanonicalLocales(tag)[0] ?? tag;
+  } catch {
+    return tag;
+  }
+}
+function searchIndexFilename(language) {
+  return `search.${language}.json`;
+}
+function vectorIndexFilename(language) {
+  return `vectors.${language}.bin`;
+}
+function emitLocalizations(doc) {
+  const languages = [...doc.languages].sort(
+    (a, b) => byCodeUnit(a.language, b.language)
+  );
+  return `${JSON.stringify({ version: doc.version, languages }, null, 2)}
+`;
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function parseLocalizations(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(parsed)) return void 0;
+  if (parsed["version"] !== 1 || !Array.isArray(parsed["languages"])) {
+    return void 0;
+  }
+  for (const entry of parsed["languages"]) {
+    if (!isRecord(entry)) return void 0;
+    const language = entry["language"];
+    const search = entry["search"];
+    if (typeof language !== "string" || !isLanguageTag(language) || typeof entry["documents"] !== "number" || !isRecord(search) || typeof search["path"] !== "string" || typeof search["entries"] !== "number" || typeof search["digest"] !== "string" || !ownsFilename(search["path"], searchIndexFilename(language))) {
+      return void 0;
+    }
+    const v = entry["vectors"];
+    if (v !== void 0) {
+      if (!isRecord(v) || typeof v["path"] !== "string" || typeof v["model"] !== "string" || typeof v["dtype"] !== "string" || typeof v["dims"] !== "number" || typeof v["count"] !== "number" || // Same constraint `search.path` gets: the last segment must be the
+      // filename this language's sidecar would be given. Without it,
+      // `isSafeRelativePath` alone leaves `vectors.path` far more reachable
+      // than `search.path` — and `search --mode vector` opens it.
+      !ownsFilename(v["path"], vectorIndexFilename(language))) {
+        return void 0;
+      }
+    }
+  }
+  return parsed;
+}
+function isSafeRelativePath(path) {
+  if (path === "" || path.startsWith("/") || /^[A-Za-z]:/.test(path)) {
+    return false;
+  }
+  if (path.includes("\\")) return false;
+  const segments = path.split("/");
+  let leading = true;
+  for (const segment of segments) {
+    if (segment === "" || segment === ".") return false;
+    if (segment === "..") {
+      if (!leading) return false;
+      continue;
+    }
+    leading = false;
+  }
+  return true;
+}
+function ownsFilename(path, expected) {
+  if (!isSafeRelativePath(path)) return false;
+  return path.slice(path.lastIndexOf("/") + 1) === expected;
+}
+
+// src/graph/core/iirds.ts
+var IIRDS_HAS_TOPIC_TYPE = `${NS.iirds}has-topic-type`;
+var IIRDS_RELATES_TO_PRODUCT_VARIANT = `${NS.iirds}relates-to-product-variant`;
+var IIRDS_RELATES_TO_LIFECYCLE_PHASE = `${NS.iirds}relates-to-product-lifecycle-phase`;
+var IIRDS_HAS_SUBJECT = `${NS.iirds}has-subject`;
+var IIRDS_PRODUCT_VARIANT = `${NS.iirds}ProductVariant`;
+var IIRDS_PACKAGE = `${NS.iirds}Package`;
+var IIRDS_IIRDS_VERSION = `${NS.iirds}iiRDSVersion`;
+var IIRDS_TOPIC = `${NS.iirds}Topic`;
+var IIRDS_IS_PART_OF_PACKAGE = `${NS.iirds}is-part-of-package`;
+var IIRDS_HAS_RENDITION = `${NS.iirds}has-rendition`;
+var IIRDS_RENDITION = `${NS.iirds}Rendition`;
+var IIRDS_SOURCE = `${NS.iirds}source`;
+var IIRDS_FORMAT = `${NS.iirds}format`;
+var IIRDS_TITLE = `${NS.iirds}title`;
+var IIRDS_LANGUAGE = `${NS.iirds}language`;
+var IIRDS_PARTY = `${NS.iirds}Party`;
+var IIRDS_HAS_PARTY_ROLE = `${NS.iirds}has-party-role`;
+var IIRDS_CREATOR = `${NS.iirds}Creator`;
+var IIRDS_RELATES_TO_PARTY = `${NS.iirds}relates-to-party`;
+var IIRDS_RELATES_TO_VCARD = `${NS.iirds}relates-to-vcard`;
+var VCARD_NS = "http://www.w3.org/2006/vcard/ns#";
+var VCARD_ORGANIZATION = `${VCARD_NS}Organization`;
+var VCARD_ORGANIZATION_NAME = `${VCARD_NS}organization-name`;
+var GRAPH_NOT_APPLICABLE_TO_VARIANT = `${NS.graph}notApplicableToVariant`;
+var GRAPH_NOT_SOFTWARE_SUBJECT = `${NS.graph}notSoftwareSubject`;
+var TOPIC_TYPE_IRIS = {
+  task: `${NS.iirds}GenericTask`,
+  concept: `${NS.iirds}GenericConcept`,
+  reference: `${NS.iirds}GenericReference`,
+  learning: `${NS.iirds}GenericLearning`,
+  troubleshooting: `${NS.iirds}GenericTroubleshooting`,
+  form: `${NS.iirds}GenericForm`
+};
+var SOFTWARE_LIFECYCLE_IRIS = {
+  administration: `${NS.iirdsSft}Administration`,
+  customization: `${NS.iirdsSft}Customization`,
+  update: `${NS.iirdsSft}Update`,
+  deployment: `${NS.iirdsSft}Deployment`,
+  integration: `${NS.iirdsSft}Integration`,
+  deinstallation: `${NS.iirdsSft}Deinstallation`
+};
+var SOFTWARE_SUBJECT_IRIS = {
+  architecture: `${NS.iirdsSft}Architecture`,
+  interface: `${NS.iirdsSft}Interface`,
+  "system-requirement": `${NS.iirdsSft}SystemRequirement`
+};
+
+// src/graph/runtime/traverse.ts
+var DCTERMS_TITLE = `${NS.dcterms}title`;
+var DCTERMS_REFERENCES = `${NS.dcterms}references`;
+var DCTERMS_LANGUAGE = `${NS.dcterms}language`;
+function documentOf(iri) {
+  const hash = iri.indexOf("#");
+  return hash === -1 ? iri : iri.slice(0, hash);
+}
+function resolveVariant(graph, input) {
+  if (graph.has(input)) return input;
+  const wanted = input.toLowerCase();
+  const variants = graph.instancesOf(`${NS.iirds}ProductVariant`);
+  for (const v of variants) {
+    if (graph.literal(v, DCTERMS_TITLE)?.toLowerCase() === wanted) return v;
+  }
+  for (const v of variants) {
+    if (v.slice(v.lastIndexOf("/") + 1).toLowerCase() === wanted) return v;
+  }
+  return void 0;
+}
+function resolveSubject(graph, input) {
+  const mapped = SOFTWARE_SUBJECT_IRIS[input.toLowerCase()];
+  if (mapped) return mapped;
+  const expanded = graph.expand(input);
+  return expanded.startsWith("http") ? expanded : void 0;
+}
+function scopeExclusion(graph, iri, scope) {
+  const checks = [
+    [
+      scope.variantIri,
+      IIRDS_RELATES_TO_PRODUCT_VARIANT,
+      GRAPH_NOT_APPLICABLE_TO_VARIANT,
+      "iri"
+    ],
+    [scope.subjectIri, IIRDS_HAS_SUBJECT, GRAPH_NOT_SOFTWARE_SUBJECT, "iri"],
+    [scope.language, DCTERMS_LANGUAGE, void 0, "literal"]
+  ];
+  for (const [target, positive, negative, kind] of checks) {
+    if (!target) continue;
+    if (negative !== void 0) {
+      const denied = graph.values(iri, negative).some((v) => v.kind === kind && v.value === target);
+      if (denied) return { node: iri, rule: negative, value: target };
+    }
+    const subject = positive === DCTERMS_LANGUAGE ? documentOf(iri) : iri;
+    const claimed = graph.values(subject, positive);
+    if (claimed.length > 0) {
+      const matches = claimed.some(
+        (v) => v.kind === kind && v.value === target
+      );
+      if (!matches) return { node: iri, rule: positive, value: target };
+    }
+  }
+  return void 0;
+}
+function traverse(graph, options) {
+  const trace = options.trace ?? createTrace();
+  const maxDepth = options.depth ?? 1;
+  const direction = options.direction ?? "out";
+  const allowed = options.predicates && options.predicates.length > 0 ? new Set(options.predicates.map((p) => graph.expand(p))) : void 0;
+  const variantIri = options.variant ? resolveVariant(graph, options.variant) : void 0;
+  const subjectIri = options.subject ? resolveSubject(graph, options.subject) : void 0;
+  const language = options.language === void 0 ? void 0 : canonicalLanguageTag(options.language);
+  const scope = { variantIri, subjectIri, language };
+  const followTypes = options.includeTypeEdges === true || allowed?.has(RDF_TYPE) === true;
+  const excluded = /* @__PURE__ */ new Set();
+  const keep = (iri) => {
+    if (excluded.has(iri)) return false;
+    const exclusion = scopeExclusion(graph, iri, scope);
+    if (exclusion) {
+      excluded.add(iri);
+      trace.exclusions.push(exclusion);
+      return false;
+    }
+    return true;
+  };
+  const nodes = [];
+  const seen = /* @__PURE__ */ new Set();
+  let frontier = [];
+  const alreadySeeded = new Set(trace.entry.map((e) => e.iri));
+  for (const seed of [...options.seeds].sort(byCodeUnit)) {
+    if (!graph.has(seed) || seen.has(seed)) continue;
+    seen.add(seed);
+    if (!alreadySeeded.has(seed)) {
+      trace.entry.push({ iri: seed, score: 1, via: "explicit" });
+    }
+    if (keep(seed)) nodes.push({ iri: seed, depth: 0 });
+    frontier.push(seed);
+  }
+  const limit = options.limit ?? Infinity;
+  for (let depth = 1; depth <= maxDepth && frontier.length > 0; depth++) {
+    const next = [];
+    for (const from of frontier) {
+      if (nodes.length >= limit) break;
+      for (const { predicate, target, dir } of neighbors(
+        graph,
+        from,
+        direction
+      )) {
+        if (allowed && !allowed.has(predicate)) continue;
+        if (!followTypes && predicate === RDF_TYPE) continue;
+        trace.hops.push({ from, predicate, to: target, depth, direction: dir });
+        if (seen.has(target)) continue;
+        seen.add(target);
+        if (!keep(target)) continue;
+        if (nodes.length >= limit) break;
+        nodes.push({ iri: target, depth });
+        next.push(target);
+      }
+    }
+    frontier = next;
+  }
+  return { nodes, trace };
+}
+function neighbors(graph, iri, direction) {
+  const out = [];
+  if (direction === "out" || direction === "both") {
+    for (const e of graph.out(iri)) out.push({ ...e, dir: "out" });
+  }
+  if (direction === "in" || direction === "both") {
+    for (const e of graph.in(iri)) out.push({ ...e, dir: "in" });
+  }
+  return out;
+}
+function reverseReferences(graph, iri, options = {}) {
+  return traverse(graph, {
+    ...options,
+    seeds: [iri],
+    direction: "in",
+    predicates: [DCTERMS_REFERENCES],
+    depth: options.depth ?? 1
+  });
+}
+function impact(graph, iri, options = {}) {
+  const result = traverse(graph, {
+    ...options,
+    seeds: [iri],
+    direction: "in",
+    depth: options.depth ?? 3,
+    // The seed *may* occupy a slot in the walker's limit, so ask for one more:
+    // `limit` means "this many *affected* nodes". Whether it actually takes
+    // one depends on the scope filter — a seed the filter excludes still
+    // expands but is not in `nodes` — so the slack is trimmed below rather
+    // than assumed spent.
+    limit: options.limit === void 0 ? void 0 : options.limit + 1
+  });
+  const affected = result.nodes.filter((n) => n.iri !== iri);
+  return {
+    nodes: options.limit === void 0 ? affected : affected.slice(0, options.limit),
+    trace: result.trace
+  };
+}
+
+// src/graph/runtime/resolve.ts
+var GRAPH_PATH = `${NS.graph}path`;
+var DCTERMS_TITLE2 = `${NS.dcterms}title`;
+var DCTERMS_HAS_PART = `${NS.dcterms}hasPart`;
+var GRAPH_LEVEL = `${NS.graph}level`;
+var GRAPH_ORDER = `${NS.graph}order`;
+function splitFragment(iri) {
+  const hash = iri.indexOf("#");
+  return hash < 0 ? { doc: iri } : { doc: iri.slice(0, hash), fragment: iri.slice(hash + 1) };
+}
+function fencedLines(lines) {
+  const mask = new Array(lines.length).fill(false);
+  let open;
+  for (const [i, line] of lines.entries()) {
+    const m = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+    const delimiter = m?.[1];
+    const info = m?.[2];
+    const isFence = delimiter !== void 0 && info !== void 0;
+    if (open === void 0) {
+      if (isFence && !(delimiter.startsWith("`") && info.includes("`"))) {
+        open = delimiter;
+        mask[i] = true;
+      }
+      continue;
+    }
+    mask[i] = true;
+    if (isFence && delimiter[0] === open[0] && delimiter.length >= open.length && info.trim() === "") {
+      open = void 0;
+    }
+  }
+  return mask;
+}
+var ATX = /^ {0,3}(#{1,6})(?:[ \t]+(.*?))?[ \t]*$/;
+var SETEXT_UNDERLINE = /^ {0,3}(=+|-+)[ \t]*$/;
+function isParagraphLine(line) {
+  if (line.trim() === "") return false;
+  if (ATX.test(line)) return false;
+  if (/^ {0,3}([-+*]|\d{1,9}[.)])([ \t]|$)/.test(line)) return false;
+  if (/^ {0,3}>/.test(line)) return false;
+  if (/^ {0,3}([-*_])([ \t]*\1){2,}[ \t]*$/.test(line)) return false;
+  return !/^ {4}/.test(line);
+}
+function frontmatterLength(lines) {
+  if (lines[0]?.trim() !== "---") return 0;
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i]?.trim();
+    if (line === "---" || line === "...") return i + 1;
+  }
+  return 0;
+}
+function sourceHeadings(lines) {
+  const fenced = fencedLines(lines);
+  const skip = frontmatterLength(lines);
+  const headings = [];
+  let paragraph = -1;
+  for (const [i, line] of lines.entries()) {
+    if (i < skip || fenced[i]) {
+      paragraph = -1;
+      continue;
+    }
+    const atx = ATX.exec(line);
+    const hashes = atx?.[1];
+    if (hashes !== void 0) {
+      const text = (atx?.[2] ?? "").replace(/(^|[ \t]+)#+$/, "");
+      headings.push({ start: i, level: hashes.length, text });
+      paragraph = -1;
+      continue;
+    }
+    const underline = SETEXT_UNDERLINE.exec(line)?.[1];
+    if (underline !== void 0 && paragraph >= 0) {
+      headings.push({
+        start: paragraph,
+        level: underline.startsWith("=") ? 1 : 2,
+        text: lines.slice(paragraph, i).join("\n")
+      });
+      paragraph = -1;
+      continue;
+    }
+    if (isParagraphLine(line)) {
+      if (paragraph < 0) paragraph = i;
+    } else {
+      paragraph = -1;
+    }
+  }
+  return headings;
+}
+var ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: "\xA0"
+};
+function decodeEntities(text) {
+  return text.replace(
+    /&(#x[0-9a-f]+|#[0-9]+|[a-z]+);/gi,
+    (whole, name) => {
+      if (name.startsWith("#")) {
+        const hex = name[1] === "x" || name[1] === "X";
+        const code = Number.parseInt(name.slice(hex ? 2 : 1), hex ? 16 : 10);
+        return Number.isNaN(code) || code > 1114111 ? whole : String.fromCodePoint(code);
+      }
+      return ENTITIES[name.toLowerCase()] ?? whole;
+    }
+  );
+}
+function headingKey(text) {
+  return text.replace(/[`*_~\\[\]]/g, "").replace(/\s+/g, " ").trim().toLowerCase();
+}
+function stripInline(raw) {
+  return decodeEntities(
+    raw.replace(/!?\[([^\]]*)\]\((?:[^()]|\([^()]*\))*\)/g, "$1").replace(/!?\[([^\]]*)\]\[[^\]]*\]/g, "$1").replace(/<((?:https?|mailto):[^>\s]+)>/gi, "$1")
+  );
+}
+function documentSectionOrder(graph, docIri) {
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const childrenOf = (iri) => graph.out(iri, DCTERMS_HAS_PART).map((e) => e.target).sort((a, b) => {
+    const oa = Number.parseInt(graph.literal(a, GRAPH_ORDER) ?? "", 10);
+    const ob = Number.parseInt(graph.literal(b, GRAPH_ORDER) ?? "", 10);
+    if (Number.isNaN(oa) || Number.isNaN(ob) || oa === ob) {
+      return a < b ? -1 : a > b ? 1 : 0;
+    }
+    return oa - ob;
+  });
+  const walk = (iri) => {
+    for (const child of childrenOf(iri)) {
+      if (seen.has(child)) continue;
+      seen.add(child);
+      ordered.push(child);
+      walk(child);
+    }
+  };
+  walk(docIri);
+  return ordered;
+}
+function sectionOccurrences(graph, docIri) {
+  const occurrences = /* @__PURE__ */ new Map();
+  const counts = /* @__PURE__ */ new Map();
+  for (const section of documentSectionOrder(graph, docIri)) {
+    const rawTitle = graph.literal(section, DCTERMS_TITLE2);
+    if (rawTitle === void 0) {
+      occurrences.set(section, 0);
+      continue;
+    }
+    const title = headingKey(rawTitle);
+    const level = graph.literal(section, GRAPH_LEVEL) ?? "";
+    let byLevel = counts.get(title);
+    if (!byLevel) {
+      byLevel = /* @__PURE__ */ new Map();
+      counts.set(title, byLevel);
+    }
+    const seen = byLevel.get(level) ?? 0;
+    occurrences.set(section, seen);
+    byLevel.set(level, seen + 1);
+  }
+  return occurrences;
+}
+function sectionOccurrence(graph, sectionIri) {
+  const { doc } = splitFragment(sectionIri);
+  return sectionOccurrences(graph, doc).get(sectionIri) ?? 0;
+}
+function documentPreamble(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  const end = sourceHeadings(lines)[0]?.start ?? lines.length;
+  const text = lines.slice(0, end).join("\n").trim();
+  return text === "" ? void 0 : text;
+}
+function sliceSection(markdown, title, level, occurrence = 0) {
+  return slice(markdown, title, level, occurrence, false);
+}
+function sectionOwnText(markdown, title, level, occurrence = 0) {
+  return slice(markdown, title, level, occurrence, true);
+}
+function slice(markdown, title, level, occurrence, ownTextOnly) {
+  const lines = markdown.split(/\r?\n/);
+  const headings = sourceHeadings(lines);
+  const wanted = headingKey(title);
+  let remaining = occurrence;
+  let found = -1;
+  for (const [n, heading] of headings.entries()) {
+    if (level !== void 0 && heading.level !== level) continue;
+    if (headingKey(stripInline(heading.text)) !== wanted) continue;
+    if (remaining > 0) {
+      remaining -= 1;
+      continue;
+    }
+    found = n;
+    break;
+  }
+  const match = headings[found];
+  if (match === void 0) return void 0;
+  const next = headings.slice(found + 1).find((h) => ownTextOnly || h.level <= match.level);
+  const end = next?.start ?? lines.length;
+  return lines.slice(match.start, end).join("\n").trimEnd();
+}
+function createFetchResolver(graph, options = {}) {
+  const doFetch = options.fetch ?? ((url) => globalThis.fetch(url));
+  const toUrl = options.pathToUrl ?? ((path) => `${options.baseUrl ?? ""}${path}`);
+  const cache = /* @__PURE__ */ new Map();
+  const occurrenceCache = /* @__PURE__ */ new Map();
+  const occurrenceOf = (docIri, sectionIri) => {
+    let map = occurrenceCache.get(docIri);
+    if (!map) {
+      map = sectionOccurrences(graph, docIri);
+      occurrenceCache.set(docIri, map);
+    }
+    return map.get(sectionIri) ?? 0;
+  };
+  const fetchDoc = (url) => {
+    let pending = cache.get(url);
+    if (!pending) {
+      pending = doFetch(url).then((r) => r.ok ? r.text() : void 0).catch(() => void 0);
+      cache.set(url, pending);
+    }
+    return pending;
+  };
+  return {
+    async resolve(iri) {
+      const { doc, fragment } = splitFragment(iri);
+      const path = graph.literal(doc, GRAPH_PATH);
+      if (!path) return void 0;
+      const sourceUrl = toUrl(path);
+      const body = await fetchDoc(sourceUrl);
+      const title = graph.literal(iri, DCTERMS_TITLE2);
+      if (body === void 0) {
+        options.trace?.resolutions.push({
+          iri,
+          sourceUrl,
+          ok: false,
+          error: "fetch failed"
+        });
+        return void 0;
+      }
+      let text = body;
+      if (fragment) {
+        const levelText = graph.literal(iri, GRAPH_LEVEL);
+        const level = levelText ? Number.parseInt(levelText, 10) : void 0;
+        const slice2 = title === void 0 ? void 0 : sliceSection(
+          body,
+          title,
+          Number.isNaN(level) ? void 0 : level,
+          occurrenceOf(doc, iri)
+        );
+        if (slice2 === void 0) {
+          options.trace?.resolutions.push({
+            iri,
+            sourceUrl,
+            ok: false,
+            error: "section heading not found"
+          });
+          return void 0;
+        }
+        text = slice2;
+      }
+      options.trace?.resolutions.push({ iri, sourceUrl, ok: true });
+      return { iri, text, sourceUrl, title };
+    }
+  };
+}
+
+// src/graph/runtime/assemble.ts
+async function assemble(resolver, nodes, options = {}) {
+  const trace = options.trace ?? createTrace();
+  const budget = options.maxChars ?? Infinity;
+  if (nodes.length === 0) {
+    return {
+      ...options.entry ? { entry: options.entry } : {},
+      context: [],
+      citations: [],
+      trace,
+      truncated: false,
+      refusal: {
+        reason: "no-route",
+        detail: "No node in the graph was reachable for this query under the active scope filter."
+      }
+    };
+  }
+  const context = [];
+  let used = 0;
+  let truncated = false;
+  let resolvedAny = false;
+  for (const node of nodes) {
+    const resolved = await resolver.resolve(node.iri);
+    if (!resolved) continue;
+    resolvedAny = true;
+    if (used + resolved.text.length > budget) {
+      truncated = true;
+      continue;
+    }
+    used += resolved.text.length;
+    context.push({
+      iri: resolved.iri,
+      title: resolved.title,
+      text: resolved.text,
+      sourceUrl: resolved.sourceUrl,
+      depth: node.depth
+    });
+  }
+  if (context.length === 0) {
+    return {
+      ...options.entry ? { entry: options.entry } : {},
+      context: [],
+      citations: [],
+      trace,
+      truncated,
+      refusal: {
+        reason: "no-content",
+        detail: resolvedAny ? "Every matching node's content exceeded the character budget." : "Matching nodes were found, but none of them resolved to readable content."
+      }
+    };
+  }
+  return {
+    ...options.entry ? { entry: options.entry } : {},
+    context,
+    citations: context.map((b) => ({
+      iri: b.iri,
+      title: b.title,
+      sourceUrl: b.sourceUrl
+    })),
+    trace,
+    truncated
+  };
+}
+
+// src/graph/runtime/rdfjs.ts
+var XSD_STRING2 = "http://www.w3.org/2001/XMLSchema#string";
+function namedNode(value) {
+  return {
+    termType: "NamedNode",
+    value,
+    equals(other) {
+      return !!other && other.termType === "NamedNode" && other.value === value;
+    }
+  };
+}
+function defaultGraph() {
+  return {
+    termType: "DefaultGraph",
+    value: "",
+    equals(other) {
+      return !!other && other.termType === "DefaultGraph";
+    }
+  };
+}
+function literal(value, datatype) {
+  const dt = namedNode(datatype ?? XSD_STRING2);
+  return {
+    termType: "Literal",
+    value,
+    language: "",
+    datatype: dt,
+    equals(other) {
+      return !!other && other.termType === "Literal" && other.value === value && !!other.datatype && other.datatype.value === dt.value;
+    }
+  };
+}
+function toTerm(v) {
+  return v.kind === "iri" ? namedNode(v.value) : literal(v.value, v.datatype);
+}
+function makeQuad(s, p, o) {
+  const subject = namedNode(s);
+  const predicate = namedNode(p);
+  const object = toTerm(o);
+  const graph = defaultGraph();
+  return {
+    termType: "Quad",
+    subject,
+    predicate,
+    object,
+    graph,
+    equals(other) {
+      return !!other && subject.equals(other.subject) && predicate.equals(other.predicate) && object.equals(other.object);
+    }
+  };
+}
+function rdfjsQuads(graph) {
+  const quads = [];
+  for (const s of graph.ids()) {
+    const node = graph.node(s);
+    if (!node) continue;
+    for (const p of [...node.props.keys()].sort(byCodeUnit)) {
+      for (const v of node.props.get(p) ?? []) quads.push(makeQuad(s, p, v));
+    }
+  }
+  return quads;
+}
+function matchQuads(graph, subject, predicate, object) {
+  const quads = [];
+  const subjects = subject ? [subject] : graph.ids();
+  for (const s of subjects) {
+    const node = graph.node(s);
+    if (!node) continue;
+    const predicates = predicate ? [predicate] : [...node.props.keys()].sort(byCodeUnit);
+    for (const p of predicates) {
+      for (const v of node.props.get(p) ?? []) {
+        if (object !== void 0 && object !== null && v.value !== object) {
+          continue;
+        }
+        quads.push(makeQuad(s, p, v));
+      }
+    }
+  }
+  return quads;
+}
+
+// node_modules/minisearch/dist/es/index.js
+var ENTRIES = "ENTRIES";
+var KEYS = "KEYS";
+var VALUES = "VALUES";
+var LEAF = "";
+var TreeIterator = class {
+  constructor(set, type) {
+    const node = set._tree;
+    const keys = Array.from(node.keys());
+    this.set = set;
+    this._type = type;
+    this._path = keys.length > 0 ? [{ node, keys }] : [];
+  }
+  next() {
+    const value = this.dive();
+    this.backtrack();
+    return value;
+  }
+  dive() {
+    if (this._path.length === 0) {
+      return { done: true, value: void 0 };
+    }
+    const { node, keys } = last$1(this._path);
+    if (last$1(keys) === LEAF) {
+      return { done: false, value: this.result() };
+    }
+    const child = node.get(last$1(keys));
+    this._path.push({ node: child, keys: Array.from(child.keys()) });
+    return this.dive();
+  }
+  backtrack() {
+    if (this._path.length === 0) {
+      return;
+    }
+    const keys = last$1(this._path).keys;
+    keys.pop();
+    if (keys.length > 0) {
+      return;
+    }
+    this._path.pop();
+    this.backtrack();
+  }
+  key() {
+    return this.set._prefix + this._path.map(({ keys }) => last$1(keys)).filter((key) => key !== LEAF).join("");
+  }
+  value() {
+    return last$1(this._path).node.get(LEAF);
+  }
+  result() {
+    switch (this._type) {
+      case VALUES:
+        return this.value();
+      case KEYS:
+        return this.key();
+      default:
+        return [this.key(), this.value()];
+    }
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+};
+var last$1 = (array) => {
+  return array[array.length - 1];
+};
+var fuzzySearch = (node, query, maxDistance) => {
+  const results = /* @__PURE__ */ new Map();
+  if (query === void 0)
+    return results;
+  const n = query.length + 1;
+  const m = n + maxDistance;
+  const matrix = new Uint8Array(m * n).fill(maxDistance + 1);
+  for (let j = 0; j < n; ++j)
+    matrix[j] = j;
+  for (let i = 1; i < m; ++i)
+    matrix[i * n] = i;
+  recurse(node, query, maxDistance, results, matrix, 1, n, "");
+  return results;
+};
+var recurse = (node, query, maxDistance, results, matrix, m, n, prefix) => {
+  const offset = m * n;
+  key: for (const key of node.keys()) {
+    if (key === LEAF) {
+      const distance = matrix[offset - 1];
+      if (distance <= maxDistance) {
+        results.set(prefix, [node.get(key), distance]);
+      }
+    } else {
+      let i = m;
+      for (let pos = 0; pos < key.length; ++pos, ++i) {
+        const char = key[pos];
+        const thisRowOffset = n * i;
+        const prevRowOffset = thisRowOffset - n;
+        let minDistance = matrix[thisRowOffset];
+        const jmin = Math.max(0, i - maxDistance - 1);
+        const jmax = Math.min(n - 1, i + maxDistance);
+        for (let j = jmin; j < jmax; ++j) {
+          const different = char !== query[j];
+          const rpl = matrix[prevRowOffset + j] + +different;
+          const del = matrix[prevRowOffset + j + 1] + 1;
+          const ins = matrix[thisRowOffset + j] + 1;
+          const dist = matrix[thisRowOffset + j + 1] = Math.min(rpl, del, ins);
+          if (dist < minDistance)
+            minDistance = dist;
+        }
+        if (minDistance > maxDistance) {
+          continue key;
+        }
+      }
+      recurse(node.get(key), query, maxDistance, results, matrix, i, n, prefix + key);
+    }
+  }
+};
+var SearchableMap = class _SearchableMap {
+  /**
+   * The constructor is normally called without arguments, creating an empty
+   * map. In order to create a {@link SearchableMap} from an iterable or from an
+   * object, check {@link SearchableMap.from} and {@link
+   * SearchableMap.fromObject}.
+   *
+   * The constructor arguments are for internal use, when creating derived
+   * mutable views of a map at a prefix.
+   */
+  constructor(tree = /* @__PURE__ */ new Map(), prefix = "") {
+    this._size = void 0;
+    this._tree = tree;
+    this._prefix = prefix;
+  }
+  /**
+   * Creates and returns a mutable view of this {@link SearchableMap},
+   * containing only entries that share the given prefix.
+   *
+   * ### Usage:
+   *
+   * ```javascript
+   * let map = new SearchableMap()
+   * map.set("unicorn", 1)
+   * map.set("universe", 2)
+   * map.set("university", 3)
+   * map.set("unique", 4)
+   * map.set("hello", 5)
+   *
+   * let uni = map.atPrefix("uni")
+   * uni.get("unique") // => 4
+   * uni.get("unicorn") // => 1
+   * uni.get("hello") // => undefined
+   *
+   * let univer = map.atPrefix("univer")
+   * univer.get("unique") // => undefined
+   * univer.get("universe") // => 2
+   * univer.get("university") // => 3
+   * ```
+   *
+   * @param prefix  The prefix
+   * @return A {@link SearchableMap} representing a mutable view of the original
+   * Map at the given prefix
+   */
+  atPrefix(prefix) {
+    if (!prefix.startsWith(this._prefix)) {
+      throw new Error("Mismatched prefix");
+    }
+    const [node, path] = trackDown(this._tree, prefix.slice(this._prefix.length));
+    if (node === void 0) {
+      const [parentNode, key] = last(path);
+      for (const k of parentNode.keys()) {
+        if (k !== LEAF && k.startsWith(key)) {
+          const node2 = /* @__PURE__ */ new Map();
+          node2.set(k.slice(key.length), parentNode.get(k));
+          return new _SearchableMap(node2, prefix);
+        }
+      }
+    }
+    return new _SearchableMap(node, prefix);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/clear
+   */
+  clear() {
+    this._size = void 0;
+    this._tree.clear();
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/delete
+   * @param key  Key to delete
+   */
+  delete(key) {
+    this._size = void 0;
+    return remove(this._tree, key);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries
+   * @return An iterator iterating through `[key, value]` entries.
+   */
+  entries() {
+    return new TreeIterator(this, ENTRIES);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/forEach
+   * @param fn  Iteration function
+   */
+  forEach(fn) {
+    for (const [key, value] of this) {
+      fn(key, value, this);
+    }
+  }
+  /**
+   * Returns a Map of all the entries that have a key within the given edit
+   * distance from the search key. The keys of the returned Map are the matching
+   * keys, while the values are two-element arrays where the first element is
+   * the value associated to the key, and the second is the edit distance of the
+   * key to the search key.
+   *
+   * ### Usage:
+   *
+   * ```javascript
+   * let map = new SearchableMap()
+   * map.set('hello', 'world')
+   * map.set('hell', 'yeah')
+   * map.set('ciao', 'mondo')
+   *
+   * // Get all entries that match the key 'hallo' with a maximum edit distance of 2
+   * map.fuzzyGet('hallo', 2)
+   * // => Map(2) { 'hello' => ['world', 1], 'hell' => ['yeah', 2] }
+   *
+   * // In the example, the "hello" key has value "world" and edit distance of 1
+   * // (change "e" to "a"), the key "hell" has value "yeah" and edit distance of 2
+   * // (change "e" to "a", delete "o")
+   * ```
+   *
+   * @param key  The search key
+   * @param maxEditDistance  The maximum edit distance (Levenshtein)
+   * @return A Map of the matching keys to their value and edit distance
+   */
+  fuzzyGet(key, maxEditDistance) {
+    return fuzzySearch(this._tree, key, maxEditDistance);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get
+   * @param key  Key to get
+   * @return Value associated to the key, or `undefined` if the key is not
+   * found.
+   */
+  get(key) {
+    const node = lookup(this._tree, key);
+    return node !== void 0 ? node.get(LEAF) : void 0;
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has
+   * @param key  Key
+   * @return True if the key is in the map, false otherwise
+   */
+  has(key) {
+    const node = lookup(this._tree, key);
+    return node !== void 0 && node.has(LEAF);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/keys
+   * @return An `Iterable` iterating through keys
+   */
+  keys() {
+    return new TreeIterator(this, KEYS);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/set
+   * @param key  Key to set
+   * @param value  Value to associate to the key
+   * @return The {@link SearchableMap} itself, to allow chaining
+   */
+  set(key, value) {
+    if (typeof key !== "string") {
+      throw new Error("key must be a string");
+    }
+    this._size = void 0;
+    const node = createPath(this._tree, key);
+    node.set(LEAF, value);
+    return this;
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/size
+   */
+  get size() {
+    if (this._size) {
+      return this._size;
+    }
+    this._size = 0;
+    const iter = this.entries();
+    while (!iter.next().done)
+      this._size += 1;
+    return this._size;
+  }
+  /**
+   * Updates the value at the given key using the provided function. The function
+   * is called with the current value at the key, and its return value is used as
+   * the new value to be set.
+   *
+   * ### Example:
+   *
+   * ```javascript
+   * // Increment the current value by one
+   * searchableMap.update('somekey', (currentValue) => currentValue == null ? 0 : currentValue + 1)
+   * ```
+   *
+   * If the value at the given key is or will be an object, it might not require
+   * re-assignment. In that case it is better to use `fetch()`, because it is
+   * faster.
+   *
+   * @param key  The key to update
+   * @param fn  The function used to compute the new value from the current one
+   * @return The {@link SearchableMap} itself, to allow chaining
+   */
+  update(key, fn) {
+    if (typeof key !== "string") {
+      throw new Error("key must be a string");
+    }
+    this._size = void 0;
+    const node = createPath(this._tree, key);
+    node.set(LEAF, fn(node.get(LEAF)));
+    return this;
+  }
+  /**
+   * Fetches the value of the given key. If the value does not exist, calls the
+   * given function to create a new value, which is inserted at the given key
+   * and subsequently returned.
+   *
+   * ### Example:
+   *
+   * ```javascript
+   * const map = searchableMap.fetch('somekey', () => new Map())
+   * map.set('foo', 'bar')
+   * ```
+   *
+   * @param key  The key to update
+   * @param initial  A function that creates a new value if the key does not exist
+   * @return The existing or new value at the given key
+   */
+  fetch(key, initial) {
+    if (typeof key !== "string") {
+      throw new Error("key must be a string");
+    }
+    this._size = void 0;
+    const node = createPath(this._tree, key);
+    let value = node.get(LEAF);
+    if (value === void 0) {
+      node.set(LEAF, value = initial());
+    }
+    return value;
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/values
+   * @return An `Iterable` iterating through values.
+   */
+  values() {
+    return new TreeIterator(this, VALUES);
+  }
+  /**
+   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/@@iterator
+   */
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  /**
+   * Creates a {@link SearchableMap} from an `Iterable` of entries
+   *
+   * @param entries  Entries to be inserted in the {@link SearchableMap}
+   * @return A new {@link SearchableMap} with the given entries
+   */
+  static from(entries) {
+    const tree = new _SearchableMap();
+    for (const [key, value] of entries) {
+      tree.set(key, value);
+    }
+    return tree;
+  }
+  /**
+   * Creates a {@link SearchableMap} from the iterable properties of a JavaScript object
+   *
+   * @param object  Object of entries for the {@link SearchableMap}
+   * @return A new {@link SearchableMap} with the given entries
+   */
+  static fromObject(object) {
+    return _SearchableMap.from(Object.entries(object));
+  }
+};
+var trackDown = (tree, key, path = []) => {
+  if (key.length === 0 || tree == null) {
+    return [tree, path];
+  }
+  for (const k of tree.keys()) {
+    if (k !== LEAF && key.startsWith(k)) {
+      path.push([tree, k]);
+      return trackDown(tree.get(k), key.slice(k.length), path);
+    }
+  }
+  path.push([tree, key]);
+  return trackDown(void 0, "", path);
+};
+var lookup = (tree, key) => {
+  if (key.length === 0 || tree == null) {
+    return tree;
+  }
+  for (const k of tree.keys()) {
+    if (k !== LEAF && key.startsWith(k)) {
+      return lookup(tree.get(k), key.slice(k.length));
+    }
+  }
+};
+var createPath = (node, key) => {
+  const keyLength = key.length;
+  outer: for (let pos = 0; node && pos < keyLength; ) {
+    for (const k of node.keys()) {
+      if (k !== LEAF && key[pos] === k[0]) {
+        const len = Math.min(keyLength - pos, k.length);
+        let offset = 1;
+        while (offset < len && key[pos + offset] === k[offset])
+          ++offset;
+        const child2 = node.get(k);
+        if (offset === k.length) {
+          node = child2;
+        } else {
+          const intermediate = /* @__PURE__ */ new Map();
+          intermediate.set(k.slice(offset), child2);
+          node.set(key.slice(pos, pos + offset), intermediate);
+          node.delete(k);
+          node = intermediate;
+        }
+        pos += offset;
+        continue outer;
+      }
+    }
+    const child = /* @__PURE__ */ new Map();
+    node.set(key.slice(pos), child);
+    return child;
+  }
+  return node;
+};
+var remove = (tree, key) => {
+  const [node, path] = trackDown(tree, key);
+  if (node === void 0) {
+    return;
+  }
+  node.delete(LEAF);
+  if (node.size === 0) {
+    cleanup(path);
+  } else if (node.size === 1) {
+    const [key2, value] = node.entries().next().value;
+    merge(path, key2, value);
+  }
+};
+var cleanup = (path) => {
+  if (path.length === 0) {
+    return;
+  }
+  const [node, key] = last(path);
+  node.delete(key);
+  if (node.size === 0) {
+    cleanup(path.slice(0, -1));
+  } else if (node.size === 1) {
+    const [key2, value] = node.entries().next().value;
+    if (key2 !== LEAF) {
+      merge(path.slice(0, -1), key2, value);
+    }
+  }
+};
+var merge = (path, key, value) => {
+  if (path.length === 0) {
+    return;
+  }
+  const [node, nodeKey] = last(path);
+  node.set(nodeKey + key, value);
+  node.delete(nodeKey);
+};
+var last = (array) => {
+  return array[array.length - 1];
+};
+var OR = "or";
+var AND = "and";
+var AND_NOT = "and_not";
+var MiniSearch = class _MiniSearch {
+  /**
+   * @param options  Configuration options
+   *
+   * ### Examples:
+   *
+   * ```javascript
+   * // Create a search engine that indexes the 'title' and 'text' fields of your
+   * // documents:
+   * const miniSearch = new MiniSearch({ fields: ['title', 'text'] })
+   * ```
+   *
+   * ### ID Field:
+   *
+   * ```javascript
+   * // Your documents are assumed to include a unique 'id' field, but if you want
+   * // to use a different field for document identification, you can set the
+   * // 'idField' option:
+   * const miniSearch = new MiniSearch({ idField: 'key', fields: ['title', 'text'] })
+   * ```
+   *
+   * ### Options and defaults:
+   *
+   * ```javascript
+   * // The full set of options (here with their default value) is:
+   * const miniSearch = new MiniSearch({
+   *   // idField: field that uniquely identifies a document
+   *   idField: 'id',
+   *
+   *   // extractField: function used to get the value of a field in a document.
+   *   // By default, it assumes the document is a flat object with field names as
+   *   // property keys and field values as string property values, but custom logic
+   *   // can be implemented by setting this option to a custom extractor function.
+   *   extractField: (document, fieldName) => document[fieldName],
+   *
+   *   // tokenize: function used to split fields into individual terms. By
+   *   // default, it is also used to tokenize search queries, unless a specific
+   *   // `tokenize` search option is supplied. When tokenizing an indexed field,
+   *   // the field name is passed as the second argument.
+   *   tokenize: (string, _fieldName) => string.split(SPACE_OR_PUNCTUATION),
+   *
+   *   // processTerm: function used to process each tokenized term before
+   *   // indexing. It can be used for stemming and normalization. Return a falsy
+   *   // value in order to discard a term. By default, it is also used to process
+   *   // search queries, unless a specific `processTerm` option is supplied as a
+   *   // search option. When processing a term from a indexed field, the field
+   *   // name is passed as the second argument.
+   *   processTerm: (term, _fieldName) => term.toLowerCase(),
+   *
+   *   // searchOptions: default search options, see the `search` method for
+   *   // details
+   *   searchOptions: undefined,
+   *
+   *   // fields: document fields to be indexed. Mandatory, but not set by default
+   *   fields: undefined
+   *
+   *   // storeFields: document fields to be stored and returned as part of the
+   *   // search results.
+   *   storeFields: []
+   * })
+   * ```
+   */
+  constructor(options) {
+    if ((options === null || options === void 0 ? void 0 : options.fields) == null) {
+      throw new Error('MiniSearch: option "fields" must be provided');
+    }
+    const autoVacuum = options.autoVacuum == null || options.autoVacuum === true ? defaultAutoVacuumOptions : options.autoVacuum;
+    this._options = {
+      ...defaultOptions,
+      ...options,
+      autoVacuum,
+      searchOptions: { ...defaultSearchOptions, ...options.searchOptions || {} },
+      autoSuggestOptions: { ...defaultAutoSuggestOptions, ...options.autoSuggestOptions || {} }
+    };
+    this._index = new SearchableMap();
+    this._documentCount = 0;
+    this._documentIds = /* @__PURE__ */ new Map();
+    this._idToShortId = /* @__PURE__ */ new Map();
+    this._fieldIds = {};
+    this._fieldLength = /* @__PURE__ */ new Map();
+    this._avgFieldLength = [];
+    this._nextId = 0;
+    this._storedFields = /* @__PURE__ */ new Map();
+    this._dirtCount = 0;
+    this._currentVacuum = null;
+    this._enqueuedVacuum = null;
+    this._enqueuedVacuumConditions = defaultVacuumConditions;
+    this.addFields(this._options.fields);
+  }
+  /**
+   * Adds a document to the index
+   *
+   * @param document  The document to be indexed
+   */
+  add(document) {
+    const { extractField, stringifyField, tokenize, processTerm, fields, idField } = this._options;
+    const id = extractField(document, idField);
+    if (id == null) {
+      throw new Error(`MiniSearch: document does not have ID field "${idField}"`);
+    }
+    if (this._idToShortId.has(id)) {
+      throw new Error(`MiniSearch: duplicate ID ${id}`);
+    }
+    const shortDocumentId = this.addDocumentId(id);
+    this.saveStoredFields(shortDocumentId, document);
+    for (const field of fields) {
+      const fieldValue = extractField(document, field);
+      if (fieldValue == null)
+        continue;
+      const tokens = tokenize(stringifyField(fieldValue, field), field);
+      const fieldId = this._fieldIds[field];
+      const uniqueTerms = new Set(tokens).size;
+      this.addFieldLength(shortDocumentId, fieldId, this._documentCount - 1, uniqueTerms);
+      for (const term of tokens) {
+        const processedTerm = processTerm(term, field);
+        if (Array.isArray(processedTerm)) {
+          for (const t of processedTerm) {
+            this.addTerm(fieldId, shortDocumentId, t);
+          }
+        } else if (processedTerm) {
+          this.addTerm(fieldId, shortDocumentId, processedTerm);
+        }
+      }
+    }
+  }
+  /**
+   * Adds all the given documents to the index
+   *
+   * @param documents  An array of documents to be indexed
+   */
+  addAll(documents) {
+    for (const document of documents)
+      this.add(document);
+  }
+  /**
+   * Adds all the given documents to the index asynchronously.
+   *
+   * Returns a promise that resolves (to `undefined`) when the indexing is done.
+   * This method is useful when index many documents, to avoid blocking the main
+   * thread. The indexing is performed asynchronously and in chunks.
+   *
+   * @param documents  An array of documents to be indexed
+   * @param options  Configuration options
+   * @return A promise resolving to `undefined` when the indexing is done
+   */
+  addAllAsync(documents, options = {}) {
+    const { chunkSize = 10 } = options;
+    const acc = { chunk: [], promise: Promise.resolve() };
+    const { chunk, promise } = documents.reduce(({ chunk: chunk2, promise: promise2 }, document, i) => {
+      chunk2.push(document);
+      if ((i + 1) % chunkSize === 0) {
+        return {
+          chunk: [],
+          promise: promise2.then(() => new Promise((resolve) => setTimeout(resolve, 0))).then(() => this.addAll(chunk2))
+        };
+      } else {
+        return { chunk: chunk2, promise: promise2 };
+      }
+    }, acc);
+    return promise.then(() => this.addAll(chunk));
+  }
+  /**
+   * Removes the given document from the index.
+   *
+   * The document to remove must NOT have changed between indexing and removal,
+   * otherwise the index will be corrupted.
+   *
+   * This method requires passing the full document to be removed (not just the
+   * ID), and immediately removes the document from the inverted index, allowing
+   * memory to be released. A convenient alternative is {@link
+   * MiniSearch#discard}, which needs only the document ID, and has the same
+   * visible effect, but delays cleaning up the index until the next vacuuming.
+   *
+   * @param document  The document to be removed
+   */
+  remove(document) {
+    const { tokenize, processTerm, extractField, stringifyField, fields, idField } = this._options;
+    const id = extractField(document, idField);
+    if (id == null) {
+      throw new Error(`MiniSearch: document does not have ID field "${idField}"`);
+    }
+    const shortId = this._idToShortId.get(id);
+    if (shortId == null) {
+      throw new Error(`MiniSearch: cannot remove document with ID ${id}: it is not in the index`);
+    }
+    for (const field of fields) {
+      const fieldValue = extractField(document, field);
+      if (fieldValue == null)
+        continue;
+      const tokens = tokenize(stringifyField(fieldValue, field), field);
+      const fieldId = this._fieldIds[field];
+      const uniqueTerms = new Set(tokens).size;
+      this.removeFieldLength(shortId, fieldId, this._documentCount, uniqueTerms);
+      for (const term of tokens) {
+        const processedTerm = processTerm(term, field);
+        if (Array.isArray(processedTerm)) {
+          for (const t of processedTerm) {
+            this.removeTerm(fieldId, shortId, t);
+          }
+        } else if (processedTerm) {
+          this.removeTerm(fieldId, shortId, processedTerm);
+        }
+      }
+    }
+    this._storedFields.delete(shortId);
+    this._documentIds.delete(shortId);
+    this._idToShortId.delete(id);
+    this._fieldLength.delete(shortId);
+    this._documentCount -= 1;
+  }
+  /**
+   * Removes all the given documents from the index. If called with no arguments,
+   * it removes _all_ documents from the index.
+   *
+   * @param documents  The documents to be removed. If this argument is omitted,
+   * all documents are removed. Note that, for removing all documents, it is
+   * more efficient to call this method with no arguments than to pass all
+   * documents.
+   */
+  removeAll(documents) {
+    if (documents) {
+      for (const document of documents)
+        this.remove(document);
+    } else if (arguments.length > 0) {
+      throw new Error("Expected documents to be present. Omit the argument to remove all documents.");
+    } else {
+      this._index = new SearchableMap();
+      this._documentCount = 0;
+      this._documentIds = /* @__PURE__ */ new Map();
+      this._idToShortId = /* @__PURE__ */ new Map();
+      this._fieldLength = /* @__PURE__ */ new Map();
+      this._avgFieldLength = [];
+      this._storedFields = /* @__PURE__ */ new Map();
+      this._nextId = 0;
+    }
+  }
+  /**
+   * Discards the document with the given ID, so it won't appear in search results
+   *
+   * It has the same visible effect of {@link MiniSearch.remove} (both cause the
+   * document to stop appearing in searches), but a different effect on the
+   * internal data structures:
+   *
+   *   - {@link MiniSearch#remove} requires passing the full document to be
+   *   removed as argument, and removes it from the inverted index immediately.
+   *
+   *   - {@link MiniSearch#discard} instead only needs the document ID, and
+   *   works by marking the current version of the document as discarded, so it
+   *   is immediately ignored by searches. This is faster and more convenient
+   *   than {@link MiniSearch#remove}, but the index is not immediately
+   *   modified. To take care of that, vacuuming is performed after a certain
+   *   number of documents are discarded, cleaning up the index and allowing
+   *   memory to be released.
+   *
+   * After discarding a document, it is possible to re-add a new version, and
+   * only the new version will appear in searches. In other words, discarding
+   * and re-adding a document works exactly like removing and re-adding it. The
+   * {@link MiniSearch.replace} method can also be used to replace a document
+   * with a new version.
+   *
+   * #### Details about vacuuming
+   *
+   * Repetite calls to this method would leave obsolete document references in
+   * the index, invisible to searches. Two mechanisms take care of cleaning up:
+   * clean up during search, and vacuuming.
+   *
+   *   - Upon search, whenever a discarded ID is found (and ignored for the
+   *   results), references to the discarded document are removed from the
+   *   inverted index entries for the search terms. This ensures that subsequent
+   *   searches for the same terms do not need to skip these obsolete references
+   *   again.
+   *
+   *   - In addition, vacuuming is performed automatically by default (see the
+   *   `autoVacuum` field in {@link Options}) after a certain number of
+   *   documents are discarded. Vacuuming traverses all terms in the index,
+   *   cleaning up all references to discarded documents. Vacuuming can also be
+   *   triggered manually by calling {@link MiniSearch#vacuum}.
+   *
+   * @param id  The ID of the document to be discarded
+   */
+  discard(id) {
+    const shortId = this._idToShortId.get(id);
+    if (shortId == null) {
+      throw new Error(`MiniSearch: cannot discard document with ID ${id}: it is not in the index`);
+    }
+    this._idToShortId.delete(id);
+    this._documentIds.delete(shortId);
+    this._storedFields.delete(shortId);
+    (this._fieldLength.get(shortId) || []).forEach((fieldLength, fieldId) => {
+      this.removeFieldLength(shortId, fieldId, this._documentCount, fieldLength);
+    });
+    this._fieldLength.delete(shortId);
+    this._documentCount -= 1;
+    this._dirtCount += 1;
+    this.maybeAutoVacuum();
+  }
+  maybeAutoVacuum() {
+    if (this._options.autoVacuum === false) {
+      return;
+    }
+    const { minDirtFactor, minDirtCount, batchSize, batchWait } = this._options.autoVacuum;
+    this.conditionalVacuum({ batchSize, batchWait }, { minDirtCount, minDirtFactor });
+  }
+  /**
+   * Discards the documents with the given IDs, so they won't appear in search
+   * results
+   *
+   * It is equivalent to calling {@link MiniSearch#discard} for all the given
+   * IDs, but with the optimization of triggering at most one automatic
+   * vacuuming at the end.
+   *
+   * Note: to remove all documents from the index, it is faster and more
+   * convenient to call {@link MiniSearch.removeAll} with no argument, instead
+   * of passing all IDs to this method.
+   */
+  discardAll(ids) {
+    const autoVacuum = this._options.autoVacuum;
+    try {
+      this._options.autoVacuum = false;
+      for (const id of ids) {
+        this.discard(id);
+      }
+    } finally {
+      this._options.autoVacuum = autoVacuum;
+    }
+    this.maybeAutoVacuum();
+  }
+  /**
+   * It replaces an existing document with the given updated version
+   *
+   * It works by discarding the current version and adding the updated one, so
+   * it is functionally equivalent to calling {@link MiniSearch#discard}
+   * followed by {@link MiniSearch#add}. The ID of the updated document should
+   * be the same as the original one.
+   *
+   * Since it uses {@link MiniSearch#discard} internally, this method relies on
+   * vacuuming to clean up obsolete document references from the index, allowing
+   * memory to be released (see {@link MiniSearch#discard}).
+   *
+   * @param updatedDocument  The updated document to replace the old version
+   * with
+   */
+  replace(updatedDocument) {
+    const { idField, extractField } = this._options;
+    const id = extractField(updatedDocument, idField);
+    this.discard(id);
+    this.add(updatedDocument);
+  }
+  /**
+   * Triggers a manual vacuuming, cleaning up references to discarded documents
+   * from the inverted index
+   *
+   * Vacuuming is only useful for applications that use the {@link
+   * MiniSearch#discard} or {@link MiniSearch#replace} methods.
+   *
+   * By default, vacuuming is performed automatically when needed (controlled by
+   * the `autoVacuum` field in {@link Options}), so there is usually no need to
+   * call this method, unless one wants to make sure to perform vacuuming at a
+   * specific moment.
+   *
+   * Vacuuming traverses all terms in the inverted index in batches, and cleans
+   * up references to discarded documents from the posting list, allowing memory
+   * to be released.
+   *
+   * The method takes an optional object as argument with the following keys:
+   *
+   *   - `batchSize`: the size of each batch (1000 by default)
+   *
+   *   - `batchWait`: the number of milliseconds to wait between batches (10 by
+   *   default)
+   *
+   * On large indexes, vacuuming could have a non-negligible cost: batching
+   * avoids blocking the thread for long, diluting this cost so that it is not
+   * negatively affecting the application. Nonetheless, this method should only
+   * be called when necessary, and relying on automatic vacuuming is usually
+   * better.
+   *
+   * It returns a promise that resolves (to undefined) when the clean up is
+   * completed. If vacuuming is already ongoing at the time this method is
+   * called, a new one is enqueued immediately after the ongoing one, and a
+   * corresponding promise is returned. However, no more than one vacuuming is
+   * enqueued on top of the ongoing one, even if this method is called more
+   * times (enqueuing multiple ones would be useless).
+   *
+   * @param options  Configuration options for the batch size and delay. See
+   * {@link VacuumOptions}.
+   */
+  vacuum(options = {}) {
+    return this.conditionalVacuum(options);
+  }
+  conditionalVacuum(options, conditions) {
+    if (this._currentVacuum) {
+      this._enqueuedVacuumConditions = this._enqueuedVacuumConditions && conditions;
+      if (this._enqueuedVacuum != null) {
+        return this._enqueuedVacuum;
+      }
+      this._enqueuedVacuum = this._currentVacuum.then(() => {
+        const conditions2 = this._enqueuedVacuumConditions;
+        this._enqueuedVacuumConditions = defaultVacuumConditions;
+        return this.performVacuuming(options, conditions2);
+      });
+      return this._enqueuedVacuum;
+    }
+    if (this.vacuumConditionsMet(conditions) === false) {
+      return Promise.resolve();
+    }
+    this._currentVacuum = this.performVacuuming(options);
+    return this._currentVacuum;
+  }
+  async performVacuuming(options, conditions) {
+    const initialDirtCount = this._dirtCount;
+    if (this.vacuumConditionsMet(conditions)) {
+      const batchSize = options.batchSize || defaultVacuumOptions.batchSize;
+      const batchWait = options.batchWait || defaultVacuumOptions.batchWait;
+      let i = 1;
+      for (const [term, fieldsData] of this._index) {
+        for (const [fieldId, fieldIndex] of fieldsData) {
+          for (const [shortId] of fieldIndex) {
+            if (this._documentIds.has(shortId)) {
+              continue;
+            }
+            if (fieldIndex.size <= 1) {
+              fieldsData.delete(fieldId);
+            } else {
+              fieldIndex.delete(shortId);
+            }
+          }
+        }
+        if (this._index.get(term).size === 0) {
+          this._index.delete(term);
+        }
+        if (i % batchSize === 0) {
+          await new Promise((resolve) => setTimeout(resolve, batchWait));
+        }
+        i += 1;
+      }
+      this._dirtCount -= initialDirtCount;
+    }
+    await null;
+    this._currentVacuum = this._enqueuedVacuum;
+    this._enqueuedVacuum = null;
+  }
+  vacuumConditionsMet(conditions) {
+    if (conditions == null) {
+      return true;
+    }
+    let { minDirtCount, minDirtFactor } = conditions;
+    minDirtCount = minDirtCount || defaultAutoVacuumOptions.minDirtCount;
+    minDirtFactor = minDirtFactor || defaultAutoVacuumOptions.minDirtFactor;
+    return this.dirtCount >= minDirtCount && this.dirtFactor >= minDirtFactor;
+  }
+  /**
+   * Is `true` if a vacuuming operation is ongoing, `false` otherwise
+   */
+  get isVacuuming() {
+    return this._currentVacuum != null;
+  }
+  /**
+   * The number of documents discarded since the most recent vacuuming
+   */
+  get dirtCount() {
+    return this._dirtCount;
+  }
+  /**
+   * A number between 0 and 1 giving an indication about the proportion of
+   * documents that are discarded, and can therefore be cleaned up by vacuuming.
+   * A value close to 0 means that the index is relatively clean, while a higher
+   * value means that the index is relatively dirty, and vacuuming could release
+   * memory.
+   */
+  get dirtFactor() {
+    return this._dirtCount / (1 + this._documentCount + this._dirtCount);
+  }
+  /**
+   * Returns `true` if a document with the given ID is present in the index and
+   * available for search, `false` otherwise
+   *
+   * @param id  The document ID
+   */
+  has(id) {
+    return this._idToShortId.has(id);
+  }
+  /**
+   * Returns the stored fields (as configured in the `storeFields` constructor
+   * option) for the given document ID. Returns `undefined` if the document is
+   * not present in the index.
+   *
+   * @param id  The document ID
+   */
+  getStoredFields(id) {
+    const shortId = this._idToShortId.get(id);
+    if (shortId == null) {
+      return void 0;
+    }
+    return this._storedFields.get(shortId);
+  }
+  /**
+   * Search for documents matching the given search query.
+   *
+   * The result is a list of scored document IDs matching the query, sorted by
+   * descending score, and each including data about which terms were matched and
+   * in which fields.
+   *
+   * ### Basic usage:
+   *
+   * ```javascript
+   * // Search for "zen art motorcycle" with default options: terms have to match
+   * // exactly, and individual terms are joined with OR
+   * miniSearch.search('zen art motorcycle')
+   * // => [ { id: 2, score: 2.77258, match: { ... } }, { id: 4, score: 1.38629, match: { ... } } ]
+   * ```
+   *
+   * ### Restrict search to specific fields:
+   *
+   * ```javascript
+   * // Search only in the 'title' field
+   * miniSearch.search('zen', { fields: ['title'] })
+   * ```
+   *
+   * ### Field boosting:
+   *
+   * ```javascript
+   * // Boost a field
+   * miniSearch.search('zen', { boost: { title: 2 } })
+   * ```
+   *
+   * ### Prefix search:
+   *
+   * ```javascript
+   * // Search for "moto" with prefix search (it will match documents
+   * // containing terms that start with "moto" or "neuro")
+   * miniSearch.search('moto neuro', { prefix: true })
+   * ```
+   *
+   * ### Fuzzy search:
+   *
+   * ```javascript
+   * // Search for "ismael" with fuzzy search (it will match documents containing
+   * // terms similar to "ismael", with a maximum edit distance of 0.2 term.length
+   * // (rounded to nearest integer)
+   * miniSearch.search('ismael', { fuzzy: 0.2 })
+   * ```
+   *
+   * ### Combining strategies:
+   *
+   * ```javascript
+   * // Mix of exact match, prefix search, and fuzzy search
+   * miniSearch.search('ismael mob', {
+   *  prefix: true,
+   *  fuzzy: 0.2
+   * })
+   * ```
+   *
+   * ### Advanced prefix and fuzzy search:
+   *
+   * ```javascript
+   * // Perform fuzzy and prefix search depending on the search term. Here
+   * // performing prefix and fuzzy search only on terms longer than 3 characters
+   * miniSearch.search('ismael mob', {
+   *  prefix: term => term.length > 3
+   *  fuzzy: term => term.length > 3 ? 0.2 : null
+   * })
+   * ```
+   *
+   * ### Combine with AND:
+   *
+   * ```javascript
+   * // Combine search terms with AND (to match only documents that contain both
+   * // "motorcycle" and "art")
+   * miniSearch.search('motorcycle art', { combineWith: 'AND' })
+   * ```
+   *
+   * ### Combine with AND_NOT:
+   *
+   * There is also an AND_NOT combinator, that finds documents that match the
+   * first term, but do not match any of the other terms. This combinator is
+   * rarely useful with simple queries, and is meant to be used with advanced
+   * query combinations (see later for more details).
+   *
+   * ### Filtering results:
+   *
+   * ```javascript
+   * // Filter only results in the 'fiction' category (assuming that 'category'
+   * // is a stored field)
+   * miniSearch.search('motorcycle art', {
+   *   filter: (result) => result.category === 'fiction'
+   * })
+   * ```
+   *
+   * ### Wildcard query
+   *
+   * Searching for an empty string (assuming the default tokenizer) returns no
+   * results. Sometimes though, one needs to match all documents, like in a
+   * "wildcard" search. This is possible by passing the special value
+   * {@link MiniSearch.wildcard} as the query:
+   *
+   * ```javascript
+   * // Return search results for all documents
+   * miniSearch.search(MiniSearch.wildcard)
+   * ```
+   *
+   * Note that search options such as `filter` and `boostDocument` are still
+   * applied, influencing which results are returned, and their order:
+   *
+   * ```javascript
+   * // Return search results for all documents in the 'fiction' category
+   * miniSearch.search(MiniSearch.wildcard, {
+   *   filter: (result) => result.category === 'fiction'
+   * })
+   * ```
+   *
+   * ### Advanced combination of queries:
+   *
+   * It is possible to combine different subqueries with OR, AND, and AND_NOT,
+   * and even with different search options, by passing a query expression
+   * tree object as the first argument, instead of a string.
+   *
+   * ```javascript
+   * // Search for documents that contain "zen" and ("motorcycle" or "archery")
+   * miniSearch.search({
+   *   combineWith: 'AND',
+   *   queries: [
+   *     'zen',
+   *     {
+   *       combineWith: 'OR',
+   *       queries: ['motorcycle', 'archery']
+   *     }
+   *   ]
+   * })
+   *
+   * // Search for documents that contain ("apple" or "pear") but not "juice" and
+   * // not "tree"
+   * miniSearch.search({
+   *   combineWith: 'AND_NOT',
+   *   queries: [
+   *     {
+   *       combineWith: 'OR',
+   *       queries: ['apple', 'pear']
+   *     },
+   *     'juice',
+   *     'tree'
+   *   ]
+   * })
+   * ```
+   *
+   * Each node in the expression tree can be either a string, or an object that
+   * supports all {@link SearchOptions} fields, plus a `queries` array field for
+   * subqueries.
+   *
+   * Note that, while this can become complicated to do by hand for complex or
+   * deeply nested queries, it provides a formalized expression tree API for
+   * external libraries that implement a parser for custom query languages.
+   *
+   * @param query  Search query
+   * @param searchOptions  Search options. Each option, if not given, defaults to the corresponding value of `searchOptions` given to the constructor, or to the library default.
+   */
+  search(query, searchOptions = {}) {
+    const { searchOptions: globalSearchOptions } = this._options;
+    const searchOptionsWithDefaults = { ...globalSearchOptions, ...searchOptions };
+    const rawResults = this.executeQuery(query, searchOptions);
+    const results = [];
+    for (const [docId, { score, terms, match }] of rawResults) {
+      const quality = terms.length || 1;
+      const result = {
+        id: this._documentIds.get(docId),
+        score: score * quality,
+        terms: Object.keys(match),
+        queryTerms: terms,
+        match
+      };
+      Object.assign(result, this._storedFields.get(docId));
+      if (searchOptionsWithDefaults.filter == null || searchOptionsWithDefaults.filter(result)) {
+        results.push(result);
+      }
+    }
+    if (query === _MiniSearch.wildcard && searchOptionsWithDefaults.boostDocument == null) {
+      return results;
+    }
+    results.sort(byScore);
+    return results;
+  }
+  /**
+   * Provide suggestions for the given search query
+   *
+   * The result is a list of suggested modified search queries, derived from the
+   * given search query, each with a relevance score, sorted by descending score.
+   *
+   * By default, it uses the same options used for search, except that by
+   * default it performs prefix search on the last term of the query, and
+   * combine terms with `'AND'` (requiring all query terms to match). Custom
+   * options can be passed as a second argument. Defaults can be changed upon
+   * calling the {@link MiniSearch} constructor, by passing a
+   * `autoSuggestOptions` option.
+   *
+   * ### Basic usage:
+   *
+   * ```javascript
+   * // Get suggestions for 'neuro':
+   * miniSearch.autoSuggest('neuro')
+   * // => [ { suggestion: 'neuromancer', terms: [ 'neuromancer' ], score: 0.46240 } ]
+   * ```
+   *
+   * ### Multiple words:
+   *
+   * ```javascript
+   * // Get suggestions for 'zen ar':
+   * miniSearch.autoSuggest('zen ar')
+   * // => [
+   * //  { suggestion: 'zen archery art', terms: [ 'zen', 'archery', 'art' ], score: 1.73332 },
+   * //  { suggestion: 'zen art', terms: [ 'zen', 'art' ], score: 1.21313 }
+   * // ]
+   * ```
+   *
+   * ### Fuzzy suggestions:
+   *
+   * ```javascript
+   * // Correct spelling mistakes using fuzzy search:
+   * miniSearch.autoSuggest('neromancer', { fuzzy: 0.2 })
+   * // => [ { suggestion: 'neuromancer', terms: [ 'neuromancer' ], score: 1.03998 } ]
+   * ```
+   *
+   * ### Filtering:
+   *
+   * ```javascript
+   * // Get suggestions for 'zen ar', but only within the 'fiction' category
+   * // (assuming that 'category' is a stored field):
+   * miniSearch.autoSuggest('zen ar', {
+   *   filter: (result) => result.category === 'fiction'
+   * })
+   * // => [
+   * //  { suggestion: 'zen archery art', terms: [ 'zen', 'archery', 'art' ], score: 1.73332 },
+   * //  { suggestion: 'zen art', terms: [ 'zen', 'art' ], score: 1.21313 }
+   * // ]
+   * ```
+   *
+   * @param queryString  Query string to be expanded into suggestions
+   * @param options  Search options. The supported options and default values
+   * are the same as for the {@link MiniSearch#search} method, except that by
+   * default prefix search is performed on the last term in the query, and terms
+   * are combined with `'AND'`.
+   * @return  A sorted array of suggestions sorted by relevance score.
+   */
+  autoSuggest(queryString, options = {}) {
+    options = { ...this._options.autoSuggestOptions, ...options };
+    const suggestions = /* @__PURE__ */ new Map();
+    for (const { score, terms } of this.search(queryString, options)) {
+      const phrase = terms.join(" ");
+      const suggestion = suggestions.get(phrase);
+      if (suggestion != null) {
+        suggestion.score += score;
+        suggestion.count += 1;
+      } else {
+        suggestions.set(phrase, { score, terms, count: 1 });
+      }
+    }
+    const results = [];
+    for (const [suggestion, { score, terms, count }] of suggestions) {
+      results.push({ suggestion, terms, score: score / count });
+    }
+    results.sort(byScore);
+    return results;
+  }
+  /**
+   * Total number of documents available to search
+   */
+  get documentCount() {
+    return this._documentCount;
+  }
+  /**
+   * Number of terms in the index
+   */
+  get termCount() {
+    return this._index.size;
+  }
+  /**
+   * Deserializes a JSON index (serialized with `JSON.stringify(miniSearch)`)
+   * and instantiates a MiniSearch instance. It should be given the same options
+   * originally used when serializing the index.
+   *
+   * ### Usage:
+   *
+   * ```javascript
+   * // If the index was serialized with:
+   * let miniSearch = new MiniSearch({ fields: ['title', 'text'] })
+   * miniSearch.addAll(documents)
+   *
+   * const json = JSON.stringify(miniSearch)
+   * // It can later be deserialized like this:
+   * miniSearch = MiniSearch.loadJSON(json, { fields: ['title', 'text'] })
+   * ```
+   *
+   * @param json  JSON-serialized index
+   * @param options  configuration options, same as the constructor
+   * @return An instance of MiniSearch deserialized from the given JSON.
+   */
+  static loadJSON(json, options) {
+    if (options == null) {
+      throw new Error("MiniSearch: loadJSON should be given the same options used when serializing the index");
+    }
+    return this.loadJS(JSON.parse(json), options);
+  }
+  /**
+   * Async equivalent of {@link MiniSearch.loadJSON}
+   *
+   * This function is an alternative to {@link MiniSearch.loadJSON} that returns
+   * a promise, and loads the index in batches, leaving pauses between them to avoid
+   * blocking the main thread. It tends to be slower than the synchronous
+   * version, but does not block the main thread, so it can be a better choice
+   * when deserializing very large indexes.
+   *
+   * @param json  JSON-serialized index
+   * @param options  configuration options, same as the constructor
+   * @return A Promise that will resolve to an instance of MiniSearch deserialized from the given JSON.
+   */
+  static async loadJSONAsync(json, options) {
+    if (options == null) {
+      throw new Error("MiniSearch: loadJSON should be given the same options used when serializing the index");
+    }
+    return this.loadJSAsync(JSON.parse(json), options);
+  }
+  /**
+   * Returns the default value of an option. It will throw an error if no option
+   * with the given name exists.
+   *
+   * @param optionName  Name of the option
+   * @return The default value of the given option
+   *
+   * ### Usage:
+   *
+   * ```javascript
+   * // Get default tokenizer
+   * MiniSearch.getDefault('tokenize')
+   *
+   * // Get default term processor
+   * MiniSearch.getDefault('processTerm')
+   *
+   * // Unknown options will throw an error
+   * MiniSearch.getDefault('notExisting')
+   * // => throws 'MiniSearch: unknown option "notExisting"'
+   * ```
+   */
+  static getDefault(optionName) {
+    if (defaultOptions.hasOwnProperty(optionName)) {
+      return getOwnProperty(defaultOptions, optionName);
+    } else {
+      throw new Error(`MiniSearch: unknown option "${optionName}"`);
+    }
+  }
+  /**
+   * @ignore
+   */
+  static loadJS(js, options) {
+    const { index, documentIds, fieldLength, storedFields, serializationVersion } = js;
+    const miniSearch = this.instantiateMiniSearch(js, options);
+    miniSearch._documentIds = objectToNumericMap(documentIds);
+    miniSearch._fieldLength = objectToNumericMap(fieldLength);
+    miniSearch._storedFields = objectToNumericMap(storedFields);
+    for (const [shortId, id] of miniSearch._documentIds) {
+      miniSearch._idToShortId.set(id, shortId);
+    }
+    for (const [term, data] of index) {
+      const dataMap = /* @__PURE__ */ new Map();
+      for (const fieldId of Object.keys(data)) {
+        let indexEntry = data[fieldId];
+        if (serializationVersion === 1) {
+          indexEntry = indexEntry.ds;
+        }
+        dataMap.set(parseInt(fieldId, 10), objectToNumericMap(indexEntry));
+      }
+      miniSearch._index.set(term, dataMap);
+    }
+    return miniSearch;
+  }
+  /**
+   * @ignore
+   */
+  static async loadJSAsync(js, options) {
+    const { index, documentIds, fieldLength, storedFields, serializationVersion } = js;
+    const miniSearch = this.instantiateMiniSearch(js, options);
+    miniSearch._documentIds = await objectToNumericMapAsync(documentIds);
+    miniSearch._fieldLength = await objectToNumericMapAsync(fieldLength);
+    miniSearch._storedFields = await objectToNumericMapAsync(storedFields);
+    for (const [shortId, id] of miniSearch._documentIds) {
+      miniSearch._idToShortId.set(id, shortId);
+    }
+    let count = 0;
+    for (const [term, data] of index) {
+      const dataMap = /* @__PURE__ */ new Map();
+      for (const fieldId of Object.keys(data)) {
+        let indexEntry = data[fieldId];
+        if (serializationVersion === 1) {
+          indexEntry = indexEntry.ds;
+        }
+        dataMap.set(parseInt(fieldId, 10), await objectToNumericMapAsync(indexEntry));
+      }
+      if (++count % 1e3 === 0)
+        await wait(0);
+      miniSearch._index.set(term, dataMap);
+    }
+    return miniSearch;
+  }
+  /**
+   * @ignore
+   */
+  static instantiateMiniSearch(js, options) {
+    const { documentCount, nextId, fieldIds, averageFieldLength, dirtCount, serializationVersion } = js;
+    if (serializationVersion !== 1 && serializationVersion !== 2) {
+      throw new Error("MiniSearch: cannot deserialize an index created with an incompatible version");
+    }
+    const miniSearch = new _MiniSearch(options);
+    miniSearch._documentCount = documentCount;
+    miniSearch._nextId = nextId;
+    miniSearch._idToShortId = /* @__PURE__ */ new Map();
+    miniSearch._fieldIds = fieldIds;
+    miniSearch._avgFieldLength = averageFieldLength;
+    miniSearch._dirtCount = dirtCount || 0;
+    miniSearch._index = new SearchableMap();
+    return miniSearch;
+  }
+  /**
+   * @ignore
+   */
+  executeQuery(query, searchOptions = {}) {
+    if (query === _MiniSearch.wildcard) {
+      return this.executeWildcardQuery(searchOptions);
+    }
+    if (typeof query !== "string") {
+      const options2 = { ...searchOptions, ...query, queries: void 0 };
+      const results2 = query.queries.map((subquery) => this.executeQuery(subquery, options2));
+      return this.combineResults(results2, options2.combineWith);
+    }
+    const { tokenize, processTerm, searchOptions: globalSearchOptions } = this._options;
+    const options = { tokenize, processTerm, ...globalSearchOptions, ...searchOptions };
+    const { tokenize: searchTokenize, processTerm: searchProcessTerm } = options;
+    const terms = searchTokenize(query).flatMap((term) => searchProcessTerm(term)).filter((term) => !!term);
+    const queries = terms.map(termToQuerySpec(options));
+    const results = queries.map((query2) => this.executeQuerySpec(query2, options));
+    return this.combineResults(results, options.combineWith);
+  }
+  /**
+   * @ignore
+   */
+  executeQuerySpec(query, searchOptions) {
+    const options = { ...this._options.searchOptions, ...searchOptions };
+    const boosts = (options.fields || this._options.fields).reduce((boosts2, field) => ({ ...boosts2, [field]: getOwnProperty(options.boost, field) || 1 }), {});
+    const { boostDocument, weights, maxFuzzy, bm25: bm25params } = options;
+    const { fuzzy: fuzzyWeight, prefix: prefixWeight } = { ...defaultSearchOptions.weights, ...weights };
+    const data = this._index.get(query.term);
+    const results = this.termResults(query.term, query.term, 1, query.termBoost, data, boosts, boostDocument, bm25params);
+    let prefixMatches;
+    let fuzzyMatches;
+    if (query.prefix) {
+      prefixMatches = this._index.atPrefix(query.term);
+    }
+    if (query.fuzzy) {
+      const fuzzy = query.fuzzy === true ? 0.2 : query.fuzzy;
+      const maxDistance = fuzzy < 1 ? Math.min(maxFuzzy, Math.round(query.term.length * fuzzy)) : fuzzy;
+      if (maxDistance)
+        fuzzyMatches = this._index.fuzzyGet(query.term, maxDistance);
+    }
+    if (prefixMatches) {
+      for (const [term, data2] of prefixMatches) {
+        const distance = term.length - query.term.length;
+        if (!distance) {
+          continue;
+        }
+        fuzzyMatches === null || fuzzyMatches === void 0 ? void 0 : fuzzyMatches.delete(term);
+        const weight = prefixWeight * term.length / (term.length + 0.3 * distance);
+        this.termResults(query.term, term, weight, query.termBoost, data2, boosts, boostDocument, bm25params, results);
+      }
+    }
+    if (fuzzyMatches) {
+      for (const term of fuzzyMatches.keys()) {
+        const [data2, distance] = fuzzyMatches.get(term);
+        if (!distance) {
+          continue;
+        }
+        const weight = fuzzyWeight * term.length / (term.length + distance);
+        this.termResults(query.term, term, weight, query.termBoost, data2, boosts, boostDocument, bm25params, results);
+      }
+    }
+    return results;
+  }
+  /**
+   * @ignore
+   */
+  executeWildcardQuery(searchOptions) {
+    const results = /* @__PURE__ */ new Map();
+    const options = { ...this._options.searchOptions, ...searchOptions };
+    for (const [shortId, id] of this._documentIds) {
+      const score = options.boostDocument ? options.boostDocument(id, "", this._storedFields.get(shortId)) : 1;
+      results.set(shortId, {
+        score,
+        terms: [],
+        match: {}
+      });
+    }
+    return results;
+  }
+  /**
+   * @ignore
+   */
+  combineResults(results, combineWith = OR) {
+    if (results.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const operator = combineWith.toLowerCase();
+    const combinator = combinators[operator];
+    if (!combinator) {
+      throw new Error(`Invalid combination operator: ${combineWith}`);
+    }
+    return results.reduce(combinator) || /* @__PURE__ */ new Map();
+  }
+  /**
+   * Allows serialization of the index to JSON, to possibly store it and later
+   * deserialize it with {@link MiniSearch.loadJSON}.
+   *
+   * Normally one does not directly call this method, but rather call the
+   * standard JavaScript `JSON.stringify()` passing the {@link MiniSearch}
+   * instance, and JavaScript will internally call this method. Upon
+   * deserialization, one must pass to {@link MiniSearch.loadJSON} the same
+   * options used to create the original instance that was serialized.
+   *
+   * ### Usage:
+   *
+   * ```javascript
+   * // Serialize the index:
+   * let miniSearch = new MiniSearch({ fields: ['title', 'text'] })
+   * miniSearch.addAll(documents)
+   * const json = JSON.stringify(miniSearch)
+   *
+   * // Later, to deserialize it:
+   * miniSearch = MiniSearch.loadJSON(json, { fields: ['title', 'text'] })
+   * ```
+   *
+   * @return A plain-object serializable representation of the search index.
+   */
+  toJSON() {
+    const index = [];
+    for (const [term, fieldIndex] of this._index) {
+      const data = {};
+      for (const [fieldId, freqs] of fieldIndex) {
+        data[fieldId] = Object.fromEntries(freqs);
+      }
+      index.push([term, data]);
+    }
+    return {
+      documentCount: this._documentCount,
+      nextId: this._nextId,
+      documentIds: Object.fromEntries(this._documentIds),
+      fieldIds: this._fieldIds,
+      fieldLength: Object.fromEntries(this._fieldLength),
+      averageFieldLength: this._avgFieldLength,
+      storedFields: Object.fromEntries(this._storedFields),
+      dirtCount: this._dirtCount,
+      index,
+      serializationVersion: 2
+    };
+  }
+  /**
+   * @ignore
+   */
+  termResults(sourceTerm, derivedTerm, termWeight, termBoost, fieldTermData, fieldBoosts, boostDocumentFn, bm25params, results = /* @__PURE__ */ new Map()) {
+    if (fieldTermData == null)
+      return results;
+    for (const field of Object.keys(fieldBoosts)) {
+      const fieldBoost = fieldBoosts[field];
+      const fieldId = this._fieldIds[field];
+      const fieldTermFreqs = fieldTermData.get(fieldId);
+      if (fieldTermFreqs == null)
+        continue;
+      let matchingFields = fieldTermFreqs.size;
+      const avgFieldLength = this._avgFieldLength[fieldId];
+      for (const docId of fieldTermFreqs.keys()) {
+        if (!this._documentIds.has(docId)) {
+          this.removeTerm(fieldId, docId, derivedTerm);
+          matchingFields -= 1;
+          continue;
+        }
+        const docBoost = boostDocumentFn ? boostDocumentFn(this._documentIds.get(docId), derivedTerm, this._storedFields.get(docId)) : 1;
+        if (!docBoost)
+          continue;
+        const termFreq = fieldTermFreqs.get(docId);
+        const fieldLength = this._fieldLength.get(docId)[fieldId];
+        const rawScore = calcBM25Score(termFreq, matchingFields, this._documentCount, fieldLength, avgFieldLength, bm25params);
+        const weightedScore = termWeight * termBoost * fieldBoost * docBoost * rawScore;
+        const result = results.get(docId);
+        if (result) {
+          result.score += weightedScore;
+          assignUniqueTerm(result.terms, sourceTerm);
+          const match = getOwnProperty(result.match, derivedTerm);
+          if (match) {
+            match.push(field);
+          } else {
+            result.match[derivedTerm] = [field];
+          }
+        } else {
+          results.set(docId, {
+            score: weightedScore,
+            terms: [sourceTerm],
+            match: { [derivedTerm]: [field] }
+          });
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * @ignore
+   */
+  addTerm(fieldId, documentId, term) {
+    const indexData = this._index.fetch(term, createMap);
+    let fieldIndex = indexData.get(fieldId);
+    if (fieldIndex == null) {
+      fieldIndex = /* @__PURE__ */ new Map();
+      fieldIndex.set(documentId, 1);
+      indexData.set(fieldId, fieldIndex);
+    } else {
+      const docs = fieldIndex.get(documentId);
+      fieldIndex.set(documentId, (docs || 0) + 1);
+    }
+  }
+  /**
+   * @ignore
+   */
+  removeTerm(fieldId, documentId, term) {
+    if (!this._index.has(term)) {
+      this.warnDocumentChanged(documentId, fieldId, term);
+      return;
+    }
+    const indexData = this._index.fetch(term, createMap);
+    const fieldIndex = indexData.get(fieldId);
+    if (fieldIndex == null || fieldIndex.get(documentId) == null) {
+      this.warnDocumentChanged(documentId, fieldId, term);
+    } else if (fieldIndex.get(documentId) <= 1) {
+      if (fieldIndex.size <= 1) {
+        indexData.delete(fieldId);
+      } else {
+        fieldIndex.delete(documentId);
+      }
+    } else {
+      fieldIndex.set(documentId, fieldIndex.get(documentId) - 1);
+    }
+    if (this._index.get(term).size === 0) {
+      this._index.delete(term);
+    }
+  }
+  /**
+   * @ignore
+   */
+  warnDocumentChanged(shortDocumentId, fieldId, term) {
+    for (const fieldName of Object.keys(this._fieldIds)) {
+      if (this._fieldIds[fieldName] === fieldId) {
+        this._options.logger("warn", `MiniSearch: document with ID ${this._documentIds.get(shortDocumentId)} has changed before removal: term "${term}" was not present in field "${fieldName}". Removing a document after it has changed can corrupt the index!`, "version_conflict");
+        return;
+      }
+    }
+  }
+  /**
+   * @ignore
+   */
+  addDocumentId(documentId) {
+    const shortDocumentId = this._nextId;
+    this._idToShortId.set(documentId, shortDocumentId);
+    this._documentIds.set(shortDocumentId, documentId);
+    this._documentCount += 1;
+    this._nextId += 1;
+    return shortDocumentId;
+  }
+  /**
+   * @ignore
+   */
+  addFields(fields) {
+    for (let i = 0; i < fields.length; i++) {
+      this._fieldIds[fields[i]] = i;
+    }
+  }
+  /**
+   * @ignore
+   */
+  addFieldLength(documentId, fieldId, count, length) {
+    let fieldLengths = this._fieldLength.get(documentId);
+    if (fieldLengths == null)
+      this._fieldLength.set(documentId, fieldLengths = []);
+    fieldLengths[fieldId] = length;
+    const averageFieldLength = this._avgFieldLength[fieldId] || 0;
+    const totalFieldLength = averageFieldLength * count + length;
+    this._avgFieldLength[fieldId] = totalFieldLength / (count + 1);
+  }
+  /**
+   * @ignore
+   */
+  removeFieldLength(documentId, fieldId, count, length) {
+    if (count === 1) {
+      this._avgFieldLength[fieldId] = 0;
+      return;
+    }
+    const totalFieldLength = this._avgFieldLength[fieldId] * count - length;
+    this._avgFieldLength[fieldId] = totalFieldLength / (count - 1);
+  }
+  /**
+   * @ignore
+   */
+  saveStoredFields(documentId, doc) {
+    const { storeFields, extractField } = this._options;
+    if (storeFields == null || storeFields.length === 0) {
+      return;
+    }
+    let documentFields = this._storedFields.get(documentId);
+    if (documentFields == null)
+      this._storedFields.set(documentId, documentFields = {});
+    for (const fieldName of storeFields) {
+      const fieldValue = extractField(doc, fieldName);
+      if (fieldValue !== void 0)
+        documentFields[fieldName] = fieldValue;
+    }
+  }
+};
+MiniSearch.wildcard = /* @__PURE__ */ Symbol("*");
+var getOwnProperty = (object, property) => Object.prototype.hasOwnProperty.call(object, property) ? object[property] : void 0;
+var combinators = {
+  [OR]: (a, b) => {
+    for (const docId of b.keys()) {
+      const existing = a.get(docId);
+      if (existing == null) {
+        a.set(docId, b.get(docId));
+      } else {
+        const { score, terms, match } = b.get(docId);
+        existing.score = existing.score + score;
+        existing.match = Object.assign(existing.match, match);
+        assignUniqueTerms(existing.terms, terms);
+      }
+    }
+    return a;
+  },
+  [AND]: (a, b) => {
+    const combined = /* @__PURE__ */ new Map();
+    for (const docId of b.keys()) {
+      const existing = a.get(docId);
+      if (existing == null)
+        continue;
+      const { score, terms, match } = b.get(docId);
+      assignUniqueTerms(existing.terms, terms);
+      combined.set(docId, {
+        score: existing.score + score,
+        terms: existing.terms,
+        match: Object.assign(existing.match, match)
+      });
+    }
+    return combined;
+  },
+  [AND_NOT]: (a, b) => {
+    for (const docId of b.keys())
+      a.delete(docId);
+    return a;
+  }
+};
+var defaultBM25params = { k: 1.2, b: 0.7, d: 0.5 };
+var calcBM25Score = (termFreq, matchingCount, totalCount, fieldLength, avgFieldLength, bm25params) => {
+  const { k, b, d } = bm25params;
+  const invDocFreq = Math.log(1 + (totalCount - matchingCount + 0.5) / (matchingCount + 0.5));
+  return invDocFreq * (d + termFreq * (k + 1) / (termFreq + k * (1 - b + b * fieldLength / avgFieldLength)));
+};
+var termToQuerySpec = (options) => (term, i, terms) => {
+  const fuzzy = typeof options.fuzzy === "function" ? options.fuzzy(term, i, terms) : options.fuzzy || false;
+  const prefix = typeof options.prefix === "function" ? options.prefix(term, i, terms) : options.prefix === true;
+  const termBoost = typeof options.boostTerm === "function" ? options.boostTerm(term, i, terms) : 1;
+  return { term, fuzzy, prefix, termBoost };
+};
+var defaultOptions = {
+  idField: "id",
+  extractField: (document, fieldName) => document[fieldName],
+  stringifyField: (fieldValue, fieldName) => fieldValue.toString(),
+  tokenize: (text) => text.split(SPACE_OR_PUNCTUATION),
+  processTerm: (term) => term.toLowerCase(),
+  fields: void 0,
+  searchOptions: void 0,
+  storeFields: [],
+  logger: (level, message) => {
+    if (typeof (console === null || console === void 0 ? void 0 : console[level]) === "function")
+      console[level](message);
+  },
+  autoVacuum: true
+};
+var defaultSearchOptions = {
+  combineWith: OR,
+  prefix: false,
+  fuzzy: false,
+  maxFuzzy: 6,
+  boost: {},
+  weights: { fuzzy: 0.45, prefix: 0.375 },
+  bm25: defaultBM25params
+};
+var defaultAutoSuggestOptions = {
+  combineWith: AND,
+  prefix: (term, i, terms) => i === terms.length - 1
+};
+var defaultVacuumOptions = { batchSize: 1e3, batchWait: 10 };
+var defaultVacuumConditions = { minDirtFactor: 0.1, minDirtCount: 20 };
+var defaultAutoVacuumOptions = { ...defaultVacuumOptions, ...defaultVacuumConditions };
+var assignUniqueTerm = (target, term) => {
+  if (!target.includes(term))
+    target.push(term);
+};
+var assignUniqueTerms = (target, source) => {
+  for (const term of source) {
+    if (!target.includes(term))
+      target.push(term);
+  }
+};
+var byScore = ({ score: a }, { score: b }) => b - a;
+var createMap = () => /* @__PURE__ */ new Map();
+var objectToNumericMap = (object) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(object)) {
+    map.set(parseInt(key, 10), object[key]);
+  }
+  return map;
+};
+var objectToNumericMapAsync = async (object) => {
+  const map = /* @__PURE__ */ new Map();
+  let count = 0;
+  for (const key of Object.keys(object)) {
+    map.set(parseInt(key, 10), object[key]);
+    if (++count % 1e3 === 0) {
+      await wait(0);
+    }
+  }
+  return map;
+};
+var wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var SPACE_OR_PUNCTUATION = /[\n\r\p{Z}\p{P}]+/u;
+
+// src/graph/runtime/lexical.ts
+function createLexicalIndex(input) {
+  const doc = typeof input === "string" ? JSON.parse(input) : input;
+  const entries = Array.isArray(doc?.entries) ? doc.entries : [];
+  const mini = new MiniSearch({
+    fields: ["title", "labels", "description", "text"],
+    storeFields: ["id"],
+    idField: "id",
+    // Titles and labels are the strongest signal that a node *is* the subject;
+    // body text is evidence it merely mentions it.
+    searchOptions: {
+      boost: { title: 3, labels: 2, description: 1.5 },
+      prefix: true,
+      fuzzy: 0.2
+    }
+  });
+  mini.addAll(entries);
+  const byIri = new Map(entries.map((e) => [e.id, e]));
+  return {
+    size: () => entries.length,
+    entry: (iri) => byIri.get(iri),
+    search(query, options = {}) {
+      const trimmed = query.trim();
+      if (trimmed === "") return [];
+      const hits = mini.search(trimmed);
+      hits.sort(
+        (a, b) => a.score === b.score ? byCodeUnit(String(a.id), String(b.id)) : b.score - a.score
+      );
+      return hits.slice(0, options.limit ?? 10).map((h) => ({ iri: String(h.id), score: h.score, via: "lexical" }));
+    }
+  };
+}
+
+// src/graph/core/vector-index.ts
+var MAGIC = new Uint8Array([77, 71, 82, 86]);
+var FORMAT_VERSION = 2;
+var HEADER_OFFSET = 12;
+var VectorIndexError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "VectorIndexError";
+  }
+};
+function normalize(vector) {
+  let sum = 0;
+  for (const value of vector) sum += value * value;
+  if (sum === 0) return vector;
+  const inv = 1 / Math.sqrt(sum);
+  vector.set(vector.map((value) => value * inv));
+  return vector;
+}
+function encodeVectorIndex(entries, meta) {
+  const sorted = [...entries].sort((a, b) => byCodeUnit(a.id, b.id));
+  const dims = sorted[0]?.vector.length ?? 0;
+  for (const entry of sorted) {
+    if (entry.vector.length !== dims) {
+      throw new VectorIndexError(
+        `Inconsistent vector dimensions: ${entry.id} has ${entry.vector.length}, expected ${dims}.`
+      );
+    }
+  }
+  const header = {
+    model: meta.model,
+    dtype: meta.dtype,
+    dims,
+    count: sorted.length,
+    ids: sorted.map((e) => e.id),
+    source: meta.source,
+    language: meta.language
+  };
+  const headerBytes = new TextEncoder().encode(JSON.stringify(header));
+  const payloadBytes = sorted.length * dims * 4;
+  const out = new Uint8Array(HEADER_OFFSET + headerBytes.length + payloadBytes);
+  const view = new DataView(out.buffer);
+  out.set(MAGIC, 0);
+  view.setUint32(4, FORMAT_VERSION, true);
+  view.setUint32(8, headerBytes.length, true);
+  out.set(headerBytes, HEADER_OFFSET);
+  let offset = HEADER_OFFSET + headerBytes.length;
+  for (const entry of sorted) {
+    const vector = normalize(Float32Array.from(entry.vector));
+    for (const value of vector) {
+      view.setFloat32(offset, value, true);
+      offset += 4;
+    }
+  }
+  return out;
+}
+function decodeVectorIndex(bytes) {
+  if (bytes.length < HEADER_OFFSET) {
+    throw new VectorIndexError("Not a manni graph vector index: file is too short.");
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (!MAGIC.every((byte, i) => bytes[i] === byte)) {
+    throw new VectorIndexError(
+      "Not a manni graph vector index: bad magic \u2014 is this the right file?"
+    );
+  }
+  const version = view.getUint32(4, true);
+  if (version !== FORMAT_VERSION) {
+    throw new VectorIndexError(
+      `Unsupported vector index version ${version} (this build reads ${FORMAT_VERSION}) \u2014 re-run \`manni graph embed\`.`
+    );
+  }
+  const headerLength = view.getUint32(8, true);
+  if (HEADER_OFFSET + headerLength > bytes.length) {
+    throw new VectorIndexError("Vector index is truncated: header overruns.");
+  }
+  let header;
+  try {
+    header = JSON.parse(
+      new TextDecoder().decode(
+        bytes.subarray(HEADER_OFFSET, HEADER_OFFSET + headerLength)
+      )
+    );
+  } catch {
+    throw new VectorIndexError("Vector index header is not valid JSON.");
+  }
+  if (!Array.isArray(header.ids) || typeof header.dims !== "number" || header.ids.length !== header.count) {
+    throw new VectorIndexError("Vector index header is malformed.");
+  }
+  const start = HEADER_OFFSET + headerLength;
+  const expected = header.count * header.dims * 4;
+  if (bytes.length - start !== expected) {
+    throw new VectorIndexError(
+      `Vector index is truncated: expected ${expected} payload bytes, found ${bytes.length - start}.`
+    );
+  }
+  const vectors = new Float32Array(header.count * header.dims);
+  for (let i = 0; i < vectors.length; i++) {
+    vectors[i] = view.getFloat32(start + i * 4, true);
+  }
+  return { header, vectors };
+}
+
+// src/graph/runtime/vector.ts
+var VectorMismatchError = class extends Error {
+  reason;
+  constructor(mismatch) {
+    super(mismatch.detail);
+    this.name = "VectorMismatchError";
+    this.reason = mismatch.reason;
+  }
+};
+async function searchIndexDigest(raw) {
+  const webCrypto = globalThis.crypto;
+  const subtle = webCrypto?.subtle;
+  if (!subtle) {
+    throw new Error(
+      "searchIndexDigest needs Web Crypto (globalThis.crypto.subtle), which is unavailable here \u2014 a page served over plain HTTP does not get it."
+    );
+  }
+  const digest = await subtle.digest("SHA-256", new TextEncoder().encode(raw));
+  const hex = [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `sha256:${hex}`;
+}
+function createVectorIndex(bytes) {
+  const { header, vectors } = decodeVectorIndex(bytes);
+  const { dims, ids } = header;
+  return {
+    model: header.model,
+    dtype: header.dtype,
+    dims,
+    source: header.source,
+    size: () => ids.length,
+    idAt: (row) => ids[row],
+    check(expected) {
+      if (expected.model !== void 0 && expected.model !== header.model) {
+        return {
+          reason: "model",
+          detail: `Vector index was built with ${header.model}, but the embedder is ${expected.model}. Re-run \`manni graph embed\`.`
+        };
+      }
+      if (expected.dtype !== void 0 && expected.dtype !== header.dtype) {
+        return {
+          reason: "dtype",
+          detail: `Vector index was built at dtype ${header.dtype}, but the embedder is at ${expected.dtype} \u2014 different weights are a different function. Re-run \`manni graph embed\`.`
+        };
+      }
+      if (expected.dims !== void 0 && expected.dims !== dims) {
+        return {
+          reason: "dims",
+          detail: `Vector index has ${dims} dimensions, but the embedder produces ${expected.dims}.`
+        };
+      }
+      if (expected.source !== void 0 && expected.source !== header.source) {
+        return {
+          reason: "stale-source",
+          detail: "Vector index was built from a different search index \u2014 the corpus changed. Re-run `manni graph embed`."
+        };
+      }
+      return void 0;
+    },
+    search(query, options = {}) {
+      if (dims === 0 || ids.length === 0) return [];
+      if (query.length !== dims) {
+        throw new VectorMismatchError({
+          reason: "dims",
+          detail: `Query vector has ${query.length} dimensions, but the index has ${dims}.`
+        });
+      }
+      const limit = normalizeLimit(options.limit);
+      if (limit === 0) return [];
+      const minScore = options.minScore ?? 0;
+      const q = normalize(Float32Array.from(query));
+      const scored = [];
+      for (const [row, iri] of ids.entries()) {
+        const stored = vectors.subarray(row * dims, (row + 1) * dims);
+        let score = 0;
+        for (const [i, value] of q.entries()) score += value * (stored[i] ?? 0);
+        if (score >= minScore) {
+          scored.push({ iri, score, via: "vector" });
+        }
+      }
+      scored.sort(
+        (a, b) => a.score === b.score ? byCodeUnit(a.iri, b.iri) : b.score - a.score
+      );
+      return scored.slice(0, limit);
+    }
+  };
+}
+function normalizeLimit(limit) {
+  return typeof limit === "number" && Number.isInteger(limit) && limit >= 0 ? limit : 10;
+}
+
+// src/graph/runtime/entry.ts
+function rrfMerge(rankings, k = 60) {
+  const fused = /* @__PURE__ */ new Map();
+  for (const ranking of rankings) {
+    ranking.forEach((candidate, i) => {
+      const current = fused.get(candidate.iri) ?? {
+        score: 0,
+        vias: /* @__PURE__ */ new Set()
+      };
+      current.score += 1 / (k + i + 1);
+      current.vias.add(candidate.via);
+      fused.set(candidate.iri, current);
+    });
+  }
+  return [...fused.entries()].map(([iri, { score, vias }]) => {
+    const [only] = vias;
+    return {
+      iri,
+      score,
+      via: vias.size === 1 && only !== void 0 ? only : "hybrid"
+    };
+  }).sort(
+    (a, b) => a.score === b.score ? byCodeUnit(a.iri, b.iri) : b.score - a.score
+  );
+}
+async function findEntry(query, options) {
+  const trace = options.trace ?? createTrace();
+  const limit = typeof options.limit === "number" && Number.isInteger(options.limit) && options.limit >= 0 ? options.limit : 10;
+  const lexical = options.lexical.search(query, { limit });
+  const embedder = options.embedder;
+  const embed = embedder ? (q) => embedder.embed(q) : options.embedQuery;
+  let vector = [];
+  if (options.vectors && embed && query.trim() !== "") {
+    const mismatch = options.vectors.check({
+      ...options.embedder ? { model: options.embedder.model, dtype: options.embedder.dtype } : {},
+      // Staleness is checked whichever way the query is embedded — it is a
+      // property of the corpus, not of the embedder, so even the unverified
+      // `embedQuery` path gets it when the caller supplies a digest.
+      ...options.source === void 0 ? {} : { source: options.source }
+    });
+    if (mismatch) throw new VectorMismatchError(mismatch);
+    const queryVector = await embed(query);
+    vector = options.vectors.search(queryVector, { limit });
+  }
+  const rankings = vector.length > 0 ? [lexical, vector] : [lexical];
+  const candidates = rrfMerge(rankings).slice(0, limit);
+  for (const candidate of candidates) trace.entry.push(candidate);
+  return { candidates, lexical, vector, trace };
+}
+export {
+  GraphIndex,
+  LOCALIZATIONS_FILENAME,
+  UNDETERMINED,
+  VectorIndexError,
+  VectorMismatchError,
+  assemble,
+  createFetchResolver,
+  createLexicalIndex,
+  createTrace,
+  createVectorIndex,
+  decodeVectorIndex,
+  defaultGraph,
+  documentPreamble,
+  documentSectionOrder,
+  emitLocalizations,
+  encodeVectorIndex,
+  findEntry,
+  impact,
+  literal,
+  matchQuads,
+  namedNode,
+  normalize,
+  parseLocalizations,
+  rdfjsQuads,
+  reachedNodes,
+  resolveSubject,
+  resolveVariant,
+  reverseReferences,
+  rrfMerge,
+  scopeExclusion,
+  searchIndexDigest,
+  searchIndexFilename,
+  sectionOccurrence,
+  sectionOccurrences,
+  sectionOwnText,
+  sliceSection,
+  splitFragment,
+  traverse,
+  vectorIndexFilename
+};
+//# sourceMappingURL=runtime.js.map