synset 0.9.0 → 0.9.2

package/dist/cli.js

@@ -1,250 +1,7 @@
 #!/usr/bin/env node
 
-// src/loader.ts
-import { existsSync, statSync, writeFileSync, mkdirSync, readdirSync } from "fs";
-import path from "path";
-
-// node_modules/@dbushell/xml-streamify/src/node.ts
-var Node = class {
-  #type;
-  #children;
-  #parent;
-  #attr;
-  #raw;
-  constructor(type, parent, raw) {
-    this.#type = type;
-    this.#parent = parent;
-    this.#raw = raw;
-    this.#children = [];
-  }
-  get type() {
-    return this.#type;
-  }
-  get raw() {
-    return this.#raw ?? "";
-  }
-  get parent() {
-    return this.#parent;
-  }
-  get children() {
-    return this.#children;
-  }
-  get attributes() {
-    if (this.#attr) {
-      return this.#attr;
-    }
-    this.#attr = {};
-    if (this.raw) {
-      const regex = /([\w:.-]+)\s*=\s*(["'])(.*?)\2/g;
-      let match;
-      while ((match = regex.exec(this.raw)) !== null) {
-        this.#attr[match[1]] = match[3];
-      }
-    }
-    return this.#attr;
-  }
-  get innerText() {
-    if (this.children.length) {
-      let text = "";
-      for (const child of this.children) {
-        text += child.innerText;
-      }
-      return text;
-    }
-    return (this.raw.match(/<!\[CDATA\[(.*?)]]>/s) ?? [, this.raw])[1];
-  }
-  addChild(child) {
-    this.#children.push(child);
-  }
-  /**
-   * Returns true if node and parents match the key hierarchy
-   * @param keys - XML tag names
-   */
-  is(...keys) {
-    if (!keys.length) return false;
-    let parent;
-    for (const key of keys.toReversed()) {
-      parent = parent ? parent.parent : this;
-      if (parent?.type !== key) {
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * Return the first child matching the key
-   * @param key - XML tag name
-   */
-  first(key) {
-    return this.children.find((n) => n.type === key);
-  }
-  /**
-   * Return all children matching the key hierarchy
-   * @param keys - XML tag names
-   */
-  all(...keys) {
-    let nodes = this.children;
-    let found = [];
-    for (const [i, k] of Object.entries(keys)) {
-      if (Number.parseInt(i) === keys.length - 1) {
-        found = nodes.filter((n) => n.type === k);
-        break;
-      }
-      nodes = nodes?.find((n) => n.type === k)?.children;
-      if (!nodes) return [];
-    }
-    return found;
-  }
-};
-
-// node_modules/@dbushell/xml-streamify/src/stream.ts
-var ENTITIES = {
-  cdata: {
-    end: "]]>",
-    start: /^<!\[CDATA\[/
-  },
-  comment: {
-    end: "-->",
-    start: /^<!--/
-  },
-  declaration: {
-    end: "?>",
-    start: /^<\?/
-  },
-  doctype: {
-    end: ">",
-    start: /^<!DOCTYPE/i
-  },
-  element: {
-    end: ">",
-    start: /^<[\w:.-/]/
-  }
-};
-var transformer = {
-  buf: "",
-  state: "skip" /* SKIP */,
-  previous: ["skip" /* SKIP */, -1],
-  flush(controller) {
-    if (this.buf.length > 0) {
-      controller.enqueue(["text" /* TEXT */, this.buf]);
-    }
-  },
-  transform(chunk, controller) {
-    this.buf += chunk;
-    while (this.buf.length) {
-      if (this.state === this.previous[0] && this.buf.length === this.previous[1]) {
-        break;
-      }
-      this.previous = [this.state, this.buf.length];
-      if (this.state === "skip" /* SKIP */) {
-        const index = this.buf.indexOf("<");
-        if (index < 0) break;
-        controller.enqueue(["text" /* TEXT */, this.buf.substring(0, index)]);
-        this.buf = this.buf.substring(index);
-        this.state = "search" /* SEARCH */;
-      }
-      if (this.state === "search" /* SEARCH */) {
-        if (this.buf.length < 3) break;
-        for (const [state, entity] of Object.entries(ENTITIES)) {
-          if (this.buf.match(entity.start)) {
-            this.state = state;
-            break;
-          }
-        }
-        continue;
-      }
-      if (Object.hasOwn(ENTITIES, this.state)) {
-        const { end } = ENTITIES[this.state];
-        const index = this.buf.indexOf(end);
-        if (index < 0) break;
-        controller.enqueue([
-          this.state,
-          this.buf.substring(0, index + end.length)
-        ]);
-        this.buf = this.buf.substring(index + end.length);
-        this.state = "skip" /* SKIP */;
-        continue;
-      }
-      throw new Error();
-    }
-  }
-};
-var XMLStream = class extends TransformStream {
-  constructor() {
-    super({ ...transformer });
-  }
-};
-
-// node_modules/@dbushell/xml-streamify/src/parse.ts
-var ignoreTypes = {
-  ["comment" /* COMMENT */]: "ignoreComments",
-  ["declaration" /* DECLARATION */]: "ignoreDeclaration",
-  ["doctype" /* DOCTYPE */]: "ignoreDoctype"
-};
-async function* parse(input, options) {
-  const document = new Node("@document");
-  try {
-    const init = { ...options?.fetchOptions };
-    if (options?.signal) {
-      init.signal = options.signal;
-    }
-    let source;
-    if (typeof input === "string" || input instanceof URL) {
-      input = new URL(input);
-      const response = await fetch(input, init);
-      if (!response.ok || !response.body) {
-        throw new Error(`Bad response`);
-      }
-      source = response.body;
-    } else {
-      source = input;
-    }
-    const stream = source.pipeThrough(new TextDecoderStream()).pipeThrough(new XMLStream(), {
-      signal: options?.signal
-    });
-    let node = document;
-    for await (const [type, value] of stream) {
-      if (options?.signal?.aborted) {
-        break;
-      }
-      if (type === "text" /* TEXT */) {
-        if (options?.ignoreWhitespace !== false && value.trim().length === 0) {
-          continue;
-        }
-      }
-      if (type in ignoreTypes && options?.[ignoreTypes[type]] === false) {
-        const newNode = new Node(type, node, value);
-        node.addChild(newNode);
-        yield newNode;
-        continue;
-      }
-      if (type === "element" /* ELEMENT */) {
-        const name = value.match(/<\/?([\w:.-]+)/)[1];
-        if (value.endsWith("/>")) {
-          const newNode2 = new Node(name, node, value);
-          node.addChild(newNode2);
-          yield newNode2;
-          continue;
-        }
-        if (value.startsWith("</")) {
-          yield node;
-          node = node.parent;
-          continue;
-        }
-        const newNode = new Node(name, node, value);
-        node.addChild(newNode);
-        node = newNode;
-        continue;
-      }
-      node.addChild(new Node(type, node, value));
-    }
-  } catch (err) {
-    if (options?.silent === false) {
-      throw err;
-    }
-  }
-  return document;
-}
+// src/export-sqlite.ts
+import { Database } from "bun:sqlite";
 
 // src/types.ts
 import { z } from "zod";
@@ -411,7 +168,9 @@ var Lexicon = z.object({
   synsets: z.array(Synset).min(0),
   syntacticBehaviors: z.array(SyntacticBehavior).min(0)
 });
-var partsOfSpeechList = PartsOfSpeech.options.map((v) => v.value);
+var partsOfSpeechList = PartsOfSpeech.options.map(
+  (v) => v.value
+);
 
 // src/helpers.ts
 function PronunciationNode(node) {
@@ -439,7 +198,7 @@ function SenseRelationNode(node) {
     dcType: optAttr(node, "dc:type")
   };
   return SenseRelation.parse(
-    extendWithRestAttr(node, obj, (s) => s == "dc:type" ? "dcType" : s)
+    extendWithRestAttr(node, obj, (s) => s === "dc:type" ? "dcType" : s)
   );
 }
 function SenseNode(node) {
@@ -455,7 +214,7 @@ function SenseNode(node) {
     extendWithRestAttr(
       node,
       obj,
-      (s) => s == "subcat" ? "subCat" : s == "adjposition" ? "adjPosition" : s
+      (s) => s === "subcat" ? "subCat" : s === "adjposition" ? "adjPosition" : s
     )
   );
 }
@@ -486,7 +245,7 @@ function ExampleNode(node) {
     dcSource: optAttr(node, "dc:source")
   };
   return Example.parse(
-    extendWithRestAttr(node, obj, (s) => s == "dc:source" ? "dcSource" : s)
+    extendWithRestAttr(node, obj, (s) => s === "dc:source" ? "dcSource" : s)
   );
 }
 function ILIDefinitionNode(node) {
@@ -523,7 +282,7 @@ function SynsetNode(node) {
     synsetRelations: children(node, "SynsetRelation", SynsetRelationNode)
   };
   return Synset.parse(
-    extendWithRestAttr(node, obj, (s) => s == "dc:source" ? "dcSource" : s)
+    extendWithRestAttr(node, obj, (s) => s === "dc:source" ? "dcSource" : s)
   );
 }
 function LexiconNode(node) {
@@ -552,7 +311,9 @@ var decodeXmlEntities = (s) => {
 var attr = (node, attrName) => {
   const value = decodeXmlEntities(node.attributes[attrName]);
   if (value === void 0) {
-    throw new Error(`Missing required attribute "${attrName}" on node "${node.type}"`);
+    throw new Error(
+      `Missing required attribute "${attrName}" on node "${node.type}"`
+    );
   }
   return value;
 };
@@ -570,21 +331,505 @@ var extendWithRestAttr = (node, obj, proxy) => {
   return Object.assign(obj, restAttrs(node, obj, proxy));
 };
 var children = (node, type, fn) => {
-  return node.children.filter((v) => v.type == type).map((v) => fn(v));
+  return node.children.filter((v) => v.type === type).map((v) => fn(v));
 };
 
-// src/loader.ts
-var BASE_VERSION = "2024";
-function getFilename(version) {
-  return `english-wordnet-${version}.xml`;
-}
-function getDownloadUrl(version) {
-  return `https://en-word.net/static/${getFilename(version)}.gz`;
-}
-function getDefaultCacheDir() {
-  const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return path.join(homeDir, ".cache", "synset");
-}
+// src/export-sqlite.ts
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS words (
+  id INTEGER PRIMARY KEY,
+  word TEXT NOT NULL,
+  word_display TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_words_word ON words(word);
+
+CREATE TABLE IF NOT EXISTS synsets (
+  id TEXT PRIMARY KEY,
+  pos TEXT NOT NULL,
+  definition TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS word_synsets (
+  word_id INTEGER NOT NULL,
+  synset_id TEXT NOT NULL,
+  PRIMARY KEY (word_id, synset_id)
+);
+CREATE INDEX IF NOT EXISTS idx_ws_word ON word_synsets(word_id);
+`;
+function exportToSQLite(lexicon, outputPath, options = {}) {
+  const { onProgress } = options;
+  const db = new Database(outputPath, { create: true });
+  db.exec("PRAGMA journal_mode = OFF");
+  db.exec("PRAGMA synchronous = OFF");
+  db.exec(SCHEMA);
+  const wordToEntries = /* @__PURE__ */ new Map();
+  for (const entry of lexicon.lexicalEntries) {
+    const word = entry.lemmas[0]?.writtenForm;
+    if (word) {
+      const lower = word.toLowerCase();
+      const existing = wordToEntries.get(lower) || [];
+      existing.push(entry);
+      wordToEntries.set(lower, existing);
+    }
+  }
+  const synsetMap = /* @__PURE__ */ new Map();
+  for (const synset of lexicon.synsets) {
+    synsetMap.set(synset.id, synset);
+  }
+  const insertWord = db.prepare(
+    "INSERT INTO words (word, word_display) VALUES (?, ?)"
+  );
+  const wordIds = /* @__PURE__ */ new Map();
+  const words = Array.from(wordToEntries.keys()).sort();
+  const totalWords = words.length;
+  db.exec("BEGIN TRANSACTION");
+  let wordId = 0;
+  for (let i = 0; i < words.length; i++) {
+    const word = words[i];
+    const entries = wordToEntries.get(word);
+    if (!entries) continue;
+    const display = entries[0].lemmas[0]?.writtenForm || word;
+    insertWord.run(word, display);
+    wordId++;
+    wordIds.set(word, wordId);
+    if (onProgress && i % 1e4 === 0) {
+      onProgress({ phase: "words", current: i, total: totalWords });
+    }
+  }
+  db.exec("COMMIT");
+  const usedSynsetIds = /* @__PURE__ */ new Set();
+  for (const entries of wordToEntries.values()) {
+    for (const entry of entries) {
+      for (const sense of entry.senses) {
+        usedSynsetIds.add(sense.synset);
+      }
+    }
+  }
+  const insertSynset = db.prepare(
+    "INSERT OR IGNORE INTO synsets (id, pos, definition) VALUES (?, ?, ?)"
+  );
+  const synsetList = Array.from(usedSynsetIds);
+  const totalSynsets = synsetList.length;
+  db.exec("BEGIN TRANSACTION");
+  for (let i = 0; i < synsetList.length; i++) {
+    const synsetId = synsetList[i];
+    const synset = synsetMap.get(synsetId);
+    if (synset) {
+      const def = decodeXmlEntities(synset.definitions[0]?.inner) || "";
+      insertSynset.run(synsetId, synset.partOfSpeech, def);
+    }
+    if (onProgress && i % 1e4 === 0) {
+      onProgress({ phase: "synsets", current: i, total: totalSynsets });
+    }
+  }
+  db.exec("COMMIT");
+  const insertRelation = db.prepare(
+    "INSERT OR IGNORE INTO word_synsets (word_id, synset_id) VALUES (?, ?)"
+  );
+  let relationCount = 0;
+  const totalRelations = Array.from(wordToEntries.values()).reduce(
+    (sum, entries) => sum + entries.reduce((s, e) => s + e.senses.length, 0),
+    0
+  );
+  db.exec("BEGIN TRANSACTION");
+  for (const [word, entries] of wordToEntries) {
+    const wordId2 = wordIds.get(word);
+    if (!wordId2) continue;
+    for (const entry of entries) {
+      for (const sense of entry.senses) {
+        insertRelation.run(wordId2, sense.synset);
+        relationCount++;
+        if (onProgress && relationCount % 1e4 === 0) {
+          onProgress({
+            phase: "relations",
+            current: relationCount,
+            total: totalRelations
+          });
+        }
+      }
+    }
+  }
+  db.exec("COMMIT");
+  db.close();
+}
+
+// src/literals.ts
+var PartsOfSpeech2 = {
+  n: "Noun",
+  v: "Verb",
+  a: "Adjective",
+  r: "Adverb",
+  s: "Adjective Satellite",
+  t: "?",
+  c: "Conjunction",
+  p: "Adposition (Preposition, postposition, etc.)",
+  x: "Other (inc. particle, classifier, bound morphemes, determiners)",
+  u: "Unknown"
+};
+var SynsetRelationRelType2 = {
+  agent: "Agent",
+  also: "See also",
+  anto_converse: "Converse antonym",
+  anto_gradable: "Gradable antonym",
+  anto_simple: "Simple antonym",
+  antonym: "Antonym",
+  attribute: "Attribute",
+  augmentative: "Augmentative",
+  be_in_state: "Be in state",
+  cause: "Cause",
+  causes: "Causes",
+  classified_by: "Classified by",
+  classifies: "Classifies",
+  co_agent_instrument: "Co-agent instrument",
+  co_agent_patient: "Co-agent patient",
+  co_agent_result: "Co-agent result",
+  co_instrument_agent: "Co-instrument agent",
+  co_instrument_patient: "Co-instrument patient",
+  co_instrument_result: "Co-instrument result",
+  co_patient_agent: "Co-patient agent",
+  co_patient_instrument: "Co-patient instrument",
+  co_result_agent: "Co-result agent",
+  co_result_instrument: "Co-result instrument",
+  co_role: "Co-role",
+  diminutive: "Diminutive",
+  direction: "Direction",
+  domain_member_region: "Domain member region",
+  domain_member_topic: "Domain member topic",
+  domain_region: "Domain region",
+  domain_topic: "Domain topic",
+  entail: "Entail",
+  entails: "Entails",
+  eq_synonym: "Equivalent synonym",
+  exemplifies: "Exemplifies",
+  feminine: "Feminine",
+  has_augmentative: "Has augmentative",
+  has_diminutive: "Has diminutive",
+  has_domain_region: "Has domain region",
+  has_domain_topic: "Has domain topic",
+  has_feminine: "Has feminine",
+  has_masculine: "Has masculine",
+  has_young: "Has young",
+  holo_location: "Holonym location",
+  holo_member: "Member holonym",
+  holo_part: "Part holonym",
+  holo_portion: "Portion holonym",
+  holo_substance: "Substance holonym",
+  holonym: "Holonym",
+  hypernym: "Hypernym",
+  hyponym: "Hyponym",
+  in_manner: "In manner",
+  instance_hypernym: "Instance hypernym",
+  instance_hyponym: "Instance hyponym",
+  instrument: "Instrument",
+  involved: "Involved",
+  involved_agent: "Involved agent",
+  involved_direction: "Involved direction",
+  involved_instrument: "Involved instrument",
+  involved_location: "Involved location",
+  involved_patient: "Involved patient",
+  involved_result: "Involved result",
+  involved_source_direction: "Involved source direction",
+  involved_target_direction: "Involved target direction",
+  ir_synonym: "IR synonym",
+  is_caused_by: "Is caused by",
+  is_entailed_by: "Is entailed by",
+  is_exemplified_by: "Is exemplified by",
+  is_subevent_of: "Is subevent of",
+  location: "Location",
+  manner_of: "Manner of",
+  masculine: "Masculine",
+  member_holonym: "Member holonym",
+  member_meronym: "Member meronym",
+  mero_location: "Meronym location",
+  mero_member: "Member meronym",
+  mero_part: "Part meronym",
+  mero_portion: "Portion meronym",
+  mero_substance: "Substance meronym",
+  meronym: "Meronym",
+  other: "Other",
+  part_holonym: "Part holonym",
+  part_meronym: "Part meronym",
+  patient: "Patient",
+  restricted_by: "Restricted by",
+  restricts: "Restricts",
+  result: "Result",
+  role: "Role",
+  similar: "Similar",
+  source_direction: "Source direction",
+  state_of: "State of",
+  subevent: "Subevent",
+  substance_holonym: "Substance holonym",
+  substance_meronym: "Substance meronym",
+  target_direction: "Target direction",
+  young: "Young"
+};
+
+// src/loader.ts
+import {
+  createReadStream,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import path from "path";
+import { Readable } from "stream";
+
+// node_modules/@dbushell/xml-streamify/src/node.ts
+var Node = class {
+  #type;
+  #children;
+  #parent;
+  #attr;
+  #raw;
+  constructor(type, parent, raw) {
+    this.#type = type;
+    this.#parent = parent;
+    this.#raw = raw;
+    this.#children = [];
+  }
+  get type() {
+    return this.#type;
+  }
+  get raw() {
+    return this.#raw ?? "";
+  }
+  get parent() {
+    return this.#parent;
+  }
+  get children() {
+    return this.#children;
+  }
+  get attributes() {
+    if (this.#attr) {
+      return this.#attr;
+    }
+    this.#attr = {};
+    if (this.raw) {
+      const regex = /([\w:.-]+)\s*=\s*(["'])(.*?)\2/g;
+      let match;
+      while ((match = regex.exec(this.raw)) !== null) {
+        this.#attr[match[1]] = match[3];
+      }
+    }
+    return this.#attr;
+  }
+  get innerText() {
+    if (this.children.length) {
+      let text = "";
+      for (const child of this.children) {
+        text += child.innerText;
+      }
+      return text;
+    }
+    return (this.raw.match(/<!\[CDATA\[(.*?)]]>/s) ?? [, this.raw])[1];
+  }
+  addChild(child) {
+    this.#children.push(child);
+  }
+  /**
+   * Returns true if node and parents match the key hierarchy
+   * @param keys - XML tag names
+   */
+  is(...keys) {
+    if (!keys.length) return false;
+    let parent;
+    for (const key of keys.toReversed()) {
+      parent = parent ? parent.parent : this;
+      if (parent?.type !== key) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Return the first child matching the key
+   * @param key - XML tag name
+   */
+  first(key) {
+    return this.children.find((n) => n.type === key);
+  }
+  /**
+   * Return all children matching the key hierarchy
+   * @param keys - XML tag names
+   */
+  all(...keys) {
+    let nodes = this.children;
+    let found = [];
+    for (const [i, k] of Object.entries(keys)) {
+      if (Number.parseInt(i) === keys.length - 1) {
+        found = nodes.filter((n) => n.type === k);
+        break;
+      }
+      nodes = nodes?.find((n) => n.type === k)?.children;
+      if (!nodes) return [];
+    }
+    return found;
+  }
+};
+
+// node_modules/@dbushell/xml-streamify/src/stream.ts
+var ENTITIES = {
+  cdata: {
+    end: "]]>",
+    start: /^<!\[CDATA\[/
+  },
+  comment: {
+    end: "-->",
+    start: /^<!--/
+  },
+  declaration: {
+    end: "?>",
+    start: /^<\?/
+  },
+  doctype: {
+    end: ">",
+    start: /^<!DOCTYPE/i
+  },
+  element: {
+    end: ">",
+    start: /^<[\w:.-/]/
+  }
+};
+var transformer = {
+  buf: "",
+  state: "skip" /* SKIP */,
+  previous: ["skip" /* SKIP */, -1],
+  flush(controller) {
+    if (this.buf.length > 0) {
+      controller.enqueue(["text" /* TEXT */, this.buf]);
+    }
+  },
+  transform(chunk, controller) {
+    this.buf += chunk;
+    while (this.buf.length) {
+      if (this.state === this.previous[0] && this.buf.length === this.previous[1]) {
+        break;
+      }
+      this.previous = [this.state, this.buf.length];
+      if (this.state === "skip" /* SKIP */) {
+        const index = this.buf.indexOf("<");
+        if (index < 0) break;
+        controller.enqueue(["text" /* TEXT */, this.buf.substring(0, index)]);
+        this.buf = this.buf.substring(index);
+        this.state = "search" /* SEARCH */;
+      }
+      if (this.state === "search" /* SEARCH */) {
+        if (this.buf.length < 3) break;
+        for (const [state, entity] of Object.entries(ENTITIES)) {
+          if (this.buf.match(entity.start)) {
+            this.state = state;
+            break;
+          }
+        }
+        continue;
+      }
+      if (Object.hasOwn(ENTITIES, this.state)) {
+        const { end } = ENTITIES[this.state];
+        const index = this.buf.indexOf(end);
+        if (index < 0) break;
+        controller.enqueue([
+          this.state,
+          this.buf.substring(0, index + end.length)
+        ]);
+        this.buf = this.buf.substring(index + end.length);
+        this.state = "skip" /* SKIP */;
+        continue;
+      }
+      throw new Error();
+    }
+  }
+};
+var XMLStream = class extends TransformStream {
+  constructor() {
+    super({ ...transformer });
+  }
+};
+
+// node_modules/@dbushell/xml-streamify/src/parse.ts
+var ignoreTypes = {
+  ["comment" /* COMMENT */]: "ignoreComments",
+  ["declaration" /* DECLARATION */]: "ignoreDeclaration",
+  ["doctype" /* DOCTYPE */]: "ignoreDoctype"
+};
+async function* parse(input, options) {
+  const document = new Node("@document");
+  try {
+    const init = { ...options?.fetchOptions };
+    if (options?.signal) {
+      init.signal = options.signal;
+    }
+    let source;
+    if (typeof input === "string" || input instanceof URL) {
+      input = new URL(input);
+      const response = await fetch(input, init);
+      if (!response.ok || !response.body) {
+        throw new Error(`Bad response`);
+      }
+      source = response.body;
+    } else {
+      source = input;
+    }
+    const stream = source.pipeThrough(new TextDecoderStream()).pipeThrough(new XMLStream(), {
+      signal: options?.signal
+    });
+    let node = document;
+    for await (const [type, value] of stream) {
+      if (options?.signal?.aborted) {
+        break;
+      }
+      if (type === "text" /* TEXT */) {
+        if (options?.ignoreWhitespace !== false && value.trim().length === 0) {
+          continue;
+        }
+      }
+      if (type in ignoreTypes && options?.[ignoreTypes[type]] === false) {
+        const newNode = new Node(type, node, value);
+        node.addChild(newNode);
+        yield newNode;
+        continue;
+      }
+      if (type === "element" /* ELEMENT */) {
+        const name = value.match(/<\/?([\w:.-]+)/)[1];
+        if (value.endsWith("/>")) {
+          const newNode2 = new Node(name, node, value);
+          node.addChild(newNode2);
+          yield newNode2;
+          continue;
+        }
+        if (value.startsWith("</")) {
+          yield node;
+          node = node.parent;
+          continue;
+        }
+        const newNode = new Node(name, node, value);
+        node.addChild(newNode);
+        node = newNode;
+        continue;
+      }
+      node.addChild(new Node(type, node, value));
+    }
+  } catch (err) {
+    if (options?.silent === false) {
+      throw err;
+    }
+  }
+  return document;
+}
+
+// src/loader.ts
+var BASE_VERSION = "2024";
+function getFilename(version) {
+  return `english-wordnet-${version}.xml`;
+}
+function getDownloadUrl(version) {
+  return `https://en-word.net/static/${getFilename(version)}.gz`;
+}
+function getDefaultCacheDir() {
+  const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
+  return path.join(homeDir, ".cache", "synset");
+}
 function fileExists(filePath) {
   if (existsSync(filePath)) {
     const stat = statSync(filePath);
@@ -638,7 +883,6 @@ async function findLatestVersion(onProgress, cacheDir) {
     for (let year = baseYear + 1; year <= lastReleasableYear; year++) {
       const version = year.toString();
       if (await urlExists(getDownloadUrl(version))) {
-        continue;
       } else {
         return (year - 1).toString();
       }
@@ -659,9 +903,13 @@ async function downloadWordNet(version, destPath) {
   const url = getDownloadUrl(version);
   const response = await fetch(url);
   if (!response.ok || !response.body) {
-    throw new Error(`Failed to download WordNet ${version}: ${response.statusText}`);
+    throw new Error(
+      `Failed to download WordNet ${version}: ${response.statusText}`
+    );
   }
-  const decompressed = response.body.pipeThrough(new DecompressionStream("gzip"));
+  const decompressed = response.body.pipeThrough(
+    new DecompressionStream("gzip")
+  );
   const arrayBuffer = await new Response(decompressed).arrayBuffer();
   const dir = path.dirname(destPath);
   if (!existsSync(dir)) {
@@ -671,8 +919,9 @@ async function downloadWordNet(version, destPath) {
 }
 function createParser(filePath) {
   const resolvedPath = path.resolve(filePath);
-  const fileUrl = resolvedPath.startsWith("/") ? `file://${resolvedPath}` : `file:///${resolvedPath.replace(/\\/g, "/")}`;
-  return parse(fileUrl, {
+  const nodeStream = createReadStream(resolvedPath);
+  const webStream = Readable.toWeb(nodeStream);
+  return parse(webStream, {
     ignoreDeclaration: false,
     silent: false
   });
@@ -825,117 +1074,6 @@ function getSynsetWords(index, synset) {
   return synset.members.map((id) => index.entries.get(id)).filter((e) => e !== void 0).map((e) => e.lemmas[0]?.writtenForm).filter((w) => w !== void 0);
 }
 
-// src/literals.ts
-var PartsOfSpeech2 = {
-  n: "Noun",
-  v: "Verb",
-  a: "Adjective",
-  r: "Adverb",
-  s: "Adjective Satellite",
-  t: "?",
-  c: "Conjunction",
-  p: "Adposition (Preposition, postposition, etc.)",
-  x: "Other (inc. particle, classifier, bound morphemes, determiners)",
-  u: "Unknown"
-};
-var SynsetRelationRelType2 = {
-  agent: "Agent",
-  also: "See also",
-  anto_converse: "Converse antonym",
-  anto_gradable: "Gradable antonym",
-  anto_simple: "Simple antonym",
-  antonym: "Antonym",
-  attribute: "Attribute",
-  augmentative: "Augmentative",
-  be_in_state: "Be in state",
-  cause: "Cause",
-  causes: "Causes",
-  classified_by: "Classified by",
-  classifies: "Classifies",
-  co_agent_instrument: "Co-agent instrument",
-  co_agent_patient: "Co-agent patient",
-  co_agent_result: "Co-agent result",
-  co_instrument_agent: "Co-instrument agent",
-  co_instrument_patient: "Co-instrument patient",
-  co_instrument_result: "Co-instrument result",
-  co_patient_agent: "Co-patient agent",
-  co_patient_instrument: "Co-patient instrument",
-  co_result_agent: "Co-result agent",
-  co_result_instrument: "Co-result instrument",
-  co_role: "Co-role",
-  diminutive: "Diminutive",
-  direction: "Direction",
-  domain_member_region: "Domain member region",
-  domain_member_topic: "Domain member topic",
-  domain_region: "Domain region",
-  domain_topic: "Domain topic",
-  entail: "Entail",
-  entails: "Entails",
-  eq_synonym: "Equivalent synonym",
-  exemplifies: "Exemplifies",
-  feminine: "Feminine",
-  has_augmentative: "Has augmentative",
-  has_diminutive: "Has diminutive",
-  has_domain_region: "Has domain region",
-  has_domain_topic: "Has domain topic",
-  has_feminine: "Has feminine",
-  has_masculine: "Has masculine",
-  has_young: "Has young",
-  holo_location: "Holonym location",
-  holo_member: "Member holonym",
-  holo_part: "Part holonym",
-  holo_portion: "Portion holonym",
-  holo_substance: "Substance holonym",
-  holonym: "Holonym",
-  hypernym: "Hypernym",
-  hyponym: "Hyponym",
-  in_manner: "In manner",
-  instance_hypernym: "Instance hypernym",
-  instance_hyponym: "Instance hyponym",
-  instrument: "Instrument",
-  involved: "Involved",
-  involved_agent: "Involved agent",
-  involved_direction: "Involved direction",
-  involved_instrument: "Involved instrument",
-  involved_location: "Involved location",
-  involved_patient: "Involved patient",
-  involved_result: "Involved result",
-  involved_source_direction: "Involved source direction",
-  involved_target_direction: "Involved target direction",
-  ir_synonym: "IR synonym",
-  is_caused_by: "Is caused by",
-  is_entailed_by: "Is entailed by",
-  is_exemplified_by: "Is exemplified by",
-  is_subevent_of: "Is subevent of",
-  location: "Location",
-  manner_of: "Manner of",
-  masculine: "Masculine",
-  member_holonym: "Member holonym",
-  member_meronym: "Member meronym",
-  mero_location: "Meronym location",
-  mero_member: "Member meronym",
-  mero_part: "Part meronym",
-  mero_portion: "Portion meronym",
-  mero_substance: "Substance meronym",
-  meronym: "Meronym",
-  other: "Other",
-  part_holonym: "Part holonym",
-  part_meronym: "Part meronym",
-  patient: "Patient",
-  restricted_by: "Restricted by",
-  restricts: "Restricts",
-  result: "Result",
-  role: "Role",
-  similar: "Similar",
-  source_direction: "Source direction",
-  state_of: "State of",
-  subevent: "Subevent",
-  substance_holonym: "Substance holonym",
-  substance_meronym: "Substance meronym",
-  target_direction: "Target direction",
-  young: "Young"
-};
-
 // src/cli.ts
 var decode = (s) => decodeXmlEntities(s) ?? "";
 var HELP = `
@@ -952,6 +1090,7 @@ Commands:
   related <word>      Show all relations for a word
   info <synset-id>    Show details for a synset ID
   fetch               Download WordNet data to cache
+  export-sqlite <out> Export dictionary to SQLite database
 
 Options:
   --file <path>       Use a local WordNet XML file instead of cache
@@ -962,6 +1101,7 @@ Examples:
   synset synonyms happy
   synset related computer --file ./wordnet.xml
   synset fetch
+  synset export-sqlite dictionary.db
 `;
 async function main() {
   const args = process.argv.slice(2);
@@ -983,6 +1123,24 @@ async function main() {
     console.log(`WordNet ${version} cached at: ${cachedPath}`);
     return;
   }
+  if (command === "export-sqlite") {
+    const outputPath = cleanArgs[1];
+    if (!outputPath) {
+      console.error("Error: Missing output path for export-sqlite");
+      process.exit(1);
+    }
+    console.log("Loading WordNet data...");
+    const lexicon2 = filePath ? await loadWordNet(filePath) : (await fetchWordNet({ onProgress: console.log })).lexicon;
+    console.log(`Exporting to ${outputPath}...`);
+    exportToSQLite(lexicon2, outputPath, {
+      onProgress: ({ phase, current, total }) => {
+        process.stdout.write(`\r${phase}: ${current}/${total}`);
+      }
+    });
+    console.log(`
+Exported to ${outputPath}`);
+    return;
+  }
   if (!word && command !== "fetch") {
     console.error(`Error: Missing word argument for command '${command}'`);
     process.exit(1);
@@ -1066,7 +1224,7 @@ async function main() {
         for (const [relType, words] of relsByType) {
           const label = SynsetRelationRelType2[relType] || relType;
           console.log(`  ${label}:`);
-          words.forEach((w) => console.log(`    - ${w}`));
+          for (const w of words) console.log(`    - ${w}`);
         }
       }
       break;
@@ -1085,11 +1243,12 @@ async function main() {
       console.log(`ILI: ${synset.ili}`);
       console.log(`
 Definitions:`);
-      synset.definitions.forEach((d) => console.log(`  - ${decode(d.inner)}`));
+      for (const d of synset.definitions) console.log(`  - ${decode(d.inner)}`);
       if (synset.examples.length > 0) {
         console.log(`
 Examples:`);
-        synset.examples.forEach((e) => console.log(`  - "${decode(e.inner)}"`));
+        for (const e of synset.examples)
+          console.log(`  - "${decode(e.inner)}"`);
       }
       if (synset.synsetRelations.length > 0) {
         console.log(`