synset 0.9.0

package/dist/cli.cjs

@@ -0,0 +1,1139 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/loader.ts
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"), 1);
+
+// 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/types.ts
+var import_zod = require("zod");
+var LexiconId = import_zod.z.string();
+var LexicalEntryId = import_zod.z.string();
+var SynsetId = import_zod.z.string();
+var SenseId = import_zod.z.string();
+var SyntacticBehaviorId = import_zod.z.string();
+var PartsOfSpeech = import_zod.z.union([
+  import_zod.z.literal("a"),
+  import_zod.z.literal("c"),
+  import_zod.z.literal("n"),
+  import_zod.z.literal("p"),
+  import_zod.z.literal("r"),
+  import_zod.z.literal("s"),
+  import_zod.z.literal("u"),
+  import_zod.z.literal("v"),
+  import_zod.z.literal("x")
+]);
+var SenseRelationRelType = import_zod.z.union([
+  import_zod.z.literal("also"),
+  import_zod.z.literal("antonym"),
+  import_zod.z.literal("derivation"),
+  import_zod.z.literal("domain_member_region"),
+  import_zod.z.literal("domain_member_topic"),
+  import_zod.z.literal("domain_region"),
+  import_zod.z.literal("domain_topic"),
+  import_zod.z.literal("exemplifies"),
+  import_zod.z.literal("is_exemplified_by"),
+  import_zod.z.literal("other"),
+  // TODO: Then "dc:type" attribute should define what relation
+  import_zod.z.literal("participle"),
+  import_zod.z.literal("pertainym"),
+  import_zod.z.literal("similar")
+]);
+var SynsetRelationRelType = import_zod.z.union([
+  import_zod.z.literal("also"),
+  import_zod.z.literal("attribute"),
+  import_zod.z.literal("cause"),
+  import_zod.z.literal("causes"),
+  import_zod.z.literal("domain_member_region"),
+  import_zod.z.literal("domain_member_topic"),
+  import_zod.z.literal("domain_region"),
+  import_zod.z.literal("domain_topic"),
+  import_zod.z.literal("entail"),
+  import_zod.z.literal("entails"),
+  import_zod.z.literal("exemplifies"),
+  import_zod.z.literal("has_domain_region"),
+  import_zod.z.literal("has_domain_topic"),
+  import_zod.z.literal("holo_member"),
+  import_zod.z.literal("holo_part"),
+  import_zod.z.literal("holo_substance"),
+  import_zod.z.literal("hypernym"),
+  import_zod.z.literal("hyponym"),
+  import_zod.z.literal("instance_hypernym"),
+  import_zod.z.literal("instance_hyponym"),
+  import_zod.z.literal("is_caused_by"),
+  import_zod.z.literal("is_entailed_by"),
+  import_zod.z.literal("is_exemplified_by"),
+  import_zod.z.literal("member_holonym"),
+  import_zod.z.literal("member_meronym"),
+  import_zod.z.literal("mero_member"),
+  import_zod.z.literal("mero_part"),
+  import_zod.z.literal("mero_substance"),
+  import_zod.z.literal("part_holonym"),
+  import_zod.z.literal("part_meronym"),
+  import_zod.z.literal("similar"),
+  import_zod.z.literal("substance_holonym"),
+  import_zod.z.literal("substance_meronym")
+]);
+var AdjPosition = import_zod.z.union([
+  import_zod.z.literal("a"),
+  import_zod.z.literal("ip"),
+  import_zod.z.literal("p")
+]);
+var Pronunciation = import_zod.z.object({
+  variety: import_zod.z.string().optional(),
+  // TODO: "GB", "US", ...
+  inner: import_zod.z.string()
+  // Actual value
+});
+var Lemma = import_zod.z.object({
+  writtenForm: import_zod.z.string(),
+  // Actual value
+  partOfSpeech: PartsOfSpeech,
+  pronunciations: import_zod.z.array(Pronunciation).min(0)
+});
+var SenseRelation = import_zod.z.object({
+  relType: SenseRelationRelType,
+  dcType: import_zod.z.string().optional(),
+  // TODO: This is only when relType is "other"
+  target: SenseId
+});
+var Sense = import_zod.z.object({
+  id: SenseId,
+  synset: SynsetId,
+  subCat: SyntacticBehaviorId.optional(),
+  adjPosition: AdjPosition.optional(),
+  senseRelations: import_zod.z.array(SenseRelation).min(0)
+});
+var Form = import_zod.z.object({
+  writtenForm: import_zod.z.string()
+  // This is where huge variety lives
+});
+var LexicalEntry = import_zod.z.object({
+  id: LexicalEntryId,
+  lemmas: import_zod.z.array(Lemma).length(1),
+  senses: import_zod.z.array(Sense).min(1),
+  forms: import_zod.z.array(Form).min(0)
+});
+var Definition = import_zod.z.object({
+  inner: import_zod.z.string()
+  // Actual value
+});
+var Example = import_zod.z.object({
+  inner: import_zod.z.string(),
+  // Actual value
+  dcSource: import_zod.z.string().optional()
+});
+var ILIDefinition = import_zod.z.object({
+  inner: import_zod.z.string()
+  // Actual value
+});
+var SynsetRelation = import_zod.z.object({
+  relType: SynsetRelationRelType,
+  target: SynsetId
+});
+var Synset = import_zod.z.object({
+  id: SynsetId,
+  ili: import_zod.z.string(),
+  members: import_zod.z.array(LexicalEntryId).min(1),
+  // space-separated list of refs that we unwrap to array
+  partOfSpeech: PartsOfSpeech,
+  lexfile: import_zod.z.string(),
+  dcSource: import_zod.z.string().optional(),
+  definitions: import_zod.z.array(Definition).min(1),
+  examples: import_zod.z.array(Example).min(0),
+  iliDefinitions: import_zod.z.array(ILIDefinition).min(0),
+  synsetRelations: import_zod.z.array(SynsetRelation).min(0)
+});
+var SyntacticBehavior = import_zod.z.object({
+  id: SyntacticBehaviorId,
+  subcategorizationFrame: import_zod.z.string()
+  // Sentence structure. This is where (not very huge) variety lives
+});
+var Lexicon = import_zod.z.object({
+  id: LexiconId,
+  // "oewn"
+  label: import_zod.z.string(),
+  // "Open English WordNet"
+  language: import_zod.z.string(),
+  // "en"
+  email: import_zod.z.string(),
+  // "english-wordnet@googlegroups.com"
+  license: import_zod.z.string(),
+  // "https://creativecommons.org/licenses/by/4.0/"
+  version: import_zod.z.string(),
+  // "2023"
+  url: import_zod.z.string(),
+  // "https://github.com/globalwordnet/english-wordnet">
+  citation: import_zod.z.string().optional(),
+  // "John P. McCrae, Alexandre Rademaker, Francis Bond, Ewa Rudnicka and Christiane Fellbaum (2019) English WordNet 2019 – An Open-Source WordNet for English, *Proceedings of the 10th Global WordNet Conference* – GWC 2019"
+  lexicalEntries: import_zod.z.array(LexicalEntry).min(0),
+  synsets: import_zod.z.array(Synset).min(0),
+  syntacticBehaviors: import_zod.z.array(SyntacticBehavior).min(0)
+});
+var partsOfSpeechList = PartsOfSpeech.options.map((v) => v.value);
+
+// src/helpers.ts
+function PronunciationNode(node) {
+  const obj = {
+    variety: optAttr(node, "variety"),
+    inner: node.innerText
+  };
+  return Pronunciation.parse(extendWithRestAttr(node, obj, (s) => s));
+}
+function LemmaNode(node) {
+  const obj = {
+    writtenForm: attr(node, "writtenForm"),
+    partOfSpeech: PartsOfSpeech.parse(attr(node, "partOfSpeech")),
+    pronunciations: (
+      //
+      children(node, "Pronunciation", (v) => PronunciationNode(v))
+    )
+  };
+  return Lemma.parse(extendWithRestAttr(node, obj, (s) => s));
+}
+function SenseRelationNode(node) {
+  const obj = {
+    relType: SenseRelationRelType.parse(attr(node, "relType")),
+    target: attr(node, "target"),
+    dcType: optAttr(node, "dc:type")
+  };
+  return SenseRelation.parse(
+    extendWithRestAttr(node, obj, (s) => s == "dc:type" ? "dcType" : s)
+  );
+}
+function SenseNode(node) {
+  const adjPos = optAttr(node, "adjposition");
+  const obj = {
+    id: attr(node, "id"),
+    synset: SynsetId.parse(attr(node, "synset")),
+    senseRelations: children(node, "SenseRelation", SenseRelationNode),
+    subCat: optAttr(node, "subcat"),
+    adjPosition: adjPos ? AdjPosition.parse(adjPos) : void 0
+  };
+  return Sense.parse(
+    extendWithRestAttr(
+      node,
+      obj,
+      (s) => s == "subcat" ? "subCat" : s == "adjposition" ? "adjPosition" : s
+    )
+  );
+}
+function FormNode(node) {
+  const obj = {
+    writtenForm: attr(node, "writtenForm")
+  };
+  return Form.parse(extendWithRestAttr(node, obj, (s) => s));
+}
+function LexicalEntryNode(node) {
+  const obj = {
+    id: attr(node, "id"),
+    lemmas: children(node, "Lemma", LemmaNode),
+    senses: children(node, "Sense", SenseNode),
+    forms: children(node, "Form", FormNode)
+  };
+  return LexicalEntry.parse(extendWithRestAttr(node, obj, (s) => s));
+}
+function DefinitionNode(node) {
+  const obj = {
+    inner: node.innerText
+  };
+  return Definition.parse(extendWithRestAttr(node, obj, (s) => s));
+}
+function ExampleNode(node) {
+  const obj = {
+    inner: node.innerText,
+    dcSource: optAttr(node, "dc:source")
+  };
+  return Example.parse(
+    extendWithRestAttr(node, obj, (s) => s == "dc:source" ? "dcSource" : s)
+  );
+}
+function ILIDefinitionNode(node) {
+  const obj = {
+    inner: node.innerText
+  };
+  return ILIDefinition.parse(extendWithRestAttr(node, obj, (s) => s));
+}
+function SynsetRelationNode(node) {
+  const obj = {
+    relType: SynsetRelationRelType.parse(attr(node, "relType")),
+    target: attr(node, "target")
+  };
+  return SynsetRelation.parse(extendWithRestAttr(node, obj, (s) => s));
+}
+function SyntacticBehaviorNode(node) {
+  const obj = {
+    id: attr(node, "id"),
+    subcategorizationFrame: attr(node, "subcategorizationFrame")
+  };
+  return SyntacticBehavior.parse(extendWithRestAttr(node, obj, (s) => s));
+}
+function SynsetNode(node) {
+  const obj = {
+    id: attr(node, "id"),
+    ili: attr(node, "ili"),
+    lexfile: attr(node, "lexfile"),
+    members: attr(node, "members").split(" "),
+    dcSource: optAttr(node, "dc:source"),
+    partOfSpeech: PartsOfSpeech.parse(attr(node, "partOfSpeech")),
+    definitions: children(node, "Definition", (v) => DefinitionNode(v)),
+    examples: children(node, "Example", (v) => ExampleNode(v)),
+    iliDefinitions: children(node, "ILIDefinition", ILIDefinitionNode),
+    synsetRelations: children(node, "SynsetRelation", SynsetRelationNode)
+  };
+  return Synset.parse(
+    extendWithRestAttr(node, obj, (s) => s == "dc:source" ? "dcSource" : s)
+  );
+}
+function LexiconNode(node) {
+  const obj = {
+    id: attr(node, "id"),
+    label: attr(node, "label"),
+    language: attr(node, "language"),
+    email: attr(node, "email"),
+    license: attr(node, "license"),
+    version: attr(node, "version"),
+    citation: optAttr(node, "citation"),
+    url: attr(node, "url"),
+    lexicalEntries: children(node, "LexicalEntry", LexicalEntryNode),
+    synsets: children(node, "Synset", SynsetNode),
+    syntacticBehaviors: (
+      //
+      children(node, "SyntacticBehaviour", SyntacticBehaviorNode)
+    )
+  };
+  return Lexicon.parse(extendWithRestAttr(node, obj, (s) => s));
+}
+var decodeXmlEntities = (s) => {
+  if (s === void 0) return void 0;
+  return s.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&apos;/g, "'").replace(/&quot;/g, '"');
+};
+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}"`);
+  }
+  return value;
+};
+var optAttr = (node, attrName) => {
+  return decodeXmlEntities(node.attributes[attrName]);
+};
+var restAttrs = (node, obj, proxy) => {
+  const result = {};
+  Object.keys(node.attributes).filter((a) => !(proxy(a) in obj)).forEach((k) => {
+    result[k] = decodeXmlEntities(node.attributes[k]) ?? node.attributes[k];
+  });
+  return result;
+};
+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));
+};
+
+// 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 import_node_path.default.join(homeDir, ".cache", "synset");
+}
+function fileExists(filePath) {
+  if ((0, import_node_fs.existsSync)(filePath)) {
+    const stat = (0, import_node_fs.statSync)(filePath);
+    return stat.isFile();
+  }
+  return false;
+}
+async function urlExists(url) {
+  try {
+    const response = await fetch(url, { method: "HEAD" });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function extractVersionFromFilename(filename) {
+  const match = filename.match(/english-wordnet-(\d{4})\.xml/);
+  return match ? parseInt(match[1], 10) : null;
+}
+function findCachedVersion(cacheDir) {
+  if (!(0, import_node_fs.existsSync)(cacheDir)) return null;
+  const files = (0, import_node_fs.readdirSync)(cacheDir);
+  const wordnetFiles = files.map((f) => ({ file: f, year: extractVersionFromFilename(f) })).filter((x) => x.year !== null).sort((a, b) => b.year - a.year);
+  return wordnetFiles.length > 0 ? wordnetFiles[0].year.toString() : null;
+}
+async function findLatestVersion(onProgress, cacheDir) {
+  const log = onProgress || (() => {
+  });
+  const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+  const lastReleasableYear = currentYear - 1;
+  const baseYear = parseInt(BASE_VERSION, 10);
+  const dir = cacheDir || getDefaultCacheDir();
+  const cachedVersion = findCachedVersion(dir);
+  if (cachedVersion) {
+    const cachedYear = parseInt(cachedVersion, 10);
+    if (cachedYear >= lastReleasableYear) {
+      return cachedVersion;
+    }
+    log(`Checking for newer version...`);
+    for (let year = cachedYear + 1; year <= lastReleasableYear; year++) {
+      const version = year.toString();
+      if (await urlExists(getDownloadUrl(version))) {
+        log(`Found ${version}`);
+        return version;
+      }
+    }
+    return cachedVersion;
+  }
+  log(`Checking available versions...`);
+  if (await urlExists(getDownloadUrl(BASE_VERSION))) {
+    for (let year = baseYear + 1; year <= lastReleasableYear; year++) {
+      const version = year.toString();
+      if (await urlExists(getDownloadUrl(version))) {
+        continue;
+      } else {
+        return (year - 1).toString();
+      }
+    }
+    return lastReleasableYear.toString();
+  }
+  for (let year = baseYear + 1; year <= lastReleasableYear; year++) {
+    const version = year.toString();
+    if (await urlExists(getDownloadUrl(version))) {
+      return version;
+    }
+  }
+  throw new Error(
+    `No WordNet version found between ${BASE_VERSION} and ${lastReleasableYear}`
+  );
+}
+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}`);
+  }
+  const decompressed = response.body.pipeThrough(new DecompressionStream("gzip"));
+  const arrayBuffer = await new Response(decompressed).arrayBuffer();
+  const dir = import_node_path.default.dirname(destPath);
+  if (!(0, import_node_fs.existsSync)(dir)) {
+    (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+  }
+  (0, import_node_fs.writeFileSync)(destPath, Buffer.from(arrayBuffer));
+}
+function createParser(filePath) {
+  const resolvedPath = import_node_path.default.resolve(filePath);
+  const fileUrl = resolvedPath.startsWith("/") ? `file://${resolvedPath}` : `file:///${resolvedPath.replace(/\\/g, "/")}`;
+  return parse(fileUrl, {
+    ignoreDeclaration: false,
+    silent: false
+  });
+}
+async function parseLexicon(parser) {
+  for await (const node of parser) {
+    if (node.type === "Lexicon") {
+      return LexiconNode(node);
+    }
+  }
+  return void 0;
+}
+async function loadWordNet(filePath) {
+  if (!fileExists(filePath)) {
+    throw new Error(`WordNet file not found: ${filePath}`);
+  }
+  const parser = createParser(filePath);
+  const lexicon = await parseLexicon(parser);
+  if (!lexicon) {
+    throw new Error("Failed to parse WordNet: no Lexicon node found");
+  }
+  return lexicon;
+}
+async function fetchWordNet(options = {}) {
+  const cacheDir = options.cacheDir || getDefaultCacheDir();
+  const log = options.onProgress || (() => {
+  });
+  const version = options.version || await findLatestVersion(log, cacheDir);
+  const filename = getFilename(version);
+  const cachedPath = import_node_path.default.join(cacheDir, filename);
+  if (!fileExists(cachedPath) || options.forceDownload) {
+    const url = getDownloadUrl(version);
+    log(`Downloading WordNet ${version} from ${url}`);
+    await downloadWordNet(version, cachedPath);
+    log(`Saved to ${cachedPath}`);
+  } else {
+    log(`Using cached ${cachedPath}`);
+  }
+  const lexicon = await loadWordNet(cachedPath);
+  return { lexicon, version, filePath: cachedPath };
+}
+async function ensureWordNetCached(options = {}) {
+  const cacheDir = options.cacheDir || getDefaultCacheDir();
+  const log = options.onProgress || (() => {
+  });
+  const version = options.version || await findLatestVersion(log, cacheDir);
+  const filename = getFilename(version);
+  const cachedPath = import_node_path.default.join(cacheDir, filename);
+  if (!fileExists(cachedPath) || options.forceDownload) {
+    const url = getDownloadUrl(version);
+    log(`Downloading WordNet ${version} from ${url}`);
+    await downloadWordNet(version, cachedPath);
+    log(`Saved to ${cachedPath}`);
+  } else {
+    log(`Using cached ${cachedPath}`);
+  }
+  return { filePath: cachedPath, version };
+}
+var WORDNET_FILENAME = getFilename(BASE_VERSION);
+var WORDNET_URL = getDownloadUrl(BASE_VERSION);
+
+// src/query.ts
+function buildIndex(lexicon) {
+  const synsets = /* @__PURE__ */ new Map();
+  const senses = /* @__PURE__ */ new Map();
+  const entries = /* @__PURE__ */ new Map();
+  const byWord = /* @__PURE__ */ new Map();
+  const sensesByWord = /* @__PURE__ */ new Map();
+  const synsetsByWord = /* @__PURE__ */ new Map();
+  for (const synset of lexicon.synsets) {
+    synsets.set(synset.id, synset);
+  }
+  for (const entry of lexicon.lexicalEntries) {
+    entries.set(entry.id, entry);
+    const word = entry.lemmas[0]?.writtenForm.toLowerCase();
+    if (word) {
+      const existing = byWord.get(word) || [];
+      existing.push(entry);
+      byWord.set(word, existing);
+      for (const sense of entry.senses) {
+        senses.set(sense.id, sense);
+        const existingSenses = sensesByWord.get(word) || [];
+        existingSenses.push(sense);
+        sensesByWord.set(word, existingSenses);
+        const synset = synsets.get(sense.synset);
+        if (synset) {
+          const existingSynsets = synsetsByWord.get(word) || [];
+          if (!existingSynsets.includes(synset)) {
+            existingSynsets.push(synset);
+            synsetsByWord.set(word, existingSynsets);
+          }
+        }
+      }
+    }
+  }
+  return {
+    synsets,
+    senses,
+    entries,
+    byWord,
+    sensesByWord,
+    synsetsByWord,
+    lexicon
+  };
+}
+function findSynsets(index, word) {
+  return index.synsetsByWord.get(word.toLowerCase()) || [];
+}
+function getDefinitions(index, word) {
+  const synsets = findSynsets(index, word);
+  return synsets.flatMap(
+    (synset) => synset.definitions.map((d) => ({
+      text: d.inner,
+      synset,
+      partOfSpeech: synset.partOfSpeech
+    }))
+  );
+}
+function getRelated(index, synset, relType) {
+  return synset.synsetRelations.filter((r) => r.relType === relType).map((r) => index.synsets.get(r.target)).filter((s) => s !== void 0);
+}
+function getHypernyms(index, word) {
+  const synsets = findSynsets(index, word);
+  return synsets.flatMap((s) => getRelated(index, s, "hypernym"));
+}
+function getHyponyms(index, word) {
+  const synsets = findSynsets(index, word);
+  return synsets.flatMap((s) => getRelated(index, s, "hyponym"));
+}
+function getSynonyms(index, word) {
+  const synsets = findSynsets(index, word);
+  const lowerWord = word.toLowerCase();
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const synset of synsets) {
+    for (const memberId of synset.members) {
+      const entry = index.entries.get(memberId);
+      if (entry) {
+        const lemma = entry.lemmas[0]?.writtenForm;
+        if (lemma && lemma.toLowerCase() !== lowerWord && !seen.has(lemma)) {
+          seen.add(lemma);
+          results.push({ word: lemma, entry, synset });
+        }
+      }
+    }
+  }
+  return results;
+}
+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 = `
+synset - WordNet dictionary explorer
+
+Usage:
+  synset <command> [options]
+
+Commands:
+  define <word>       Show definitions for a word
+  synonyms <word>     List synonyms for a word
+  hypernyms <word>    Show hypernyms (more general terms)
+  hyponyms <word>     Show hyponyms (more specific terms)
+  related <word>      Show all relations for a word
+  info <synset-id>    Show details for a synset ID
+  fetch               Download WordNet data to cache
+
+Options:
+  --file <path>       Use a local WordNet XML file instead of cache
+  --help, -h          Show this help message
+
+Examples:
+  synset define dog
+  synset synonyms happy
+  synset related computer --file ./wordnet.xml
+  synset fetch
+`;
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
+    console.log(HELP);
+    process.exit(0);
+  }
+  const command = args[0];
+  const fileIndex = args.indexOf("--file");
+  const filePath = fileIndex !== -1 ? args[fileIndex + 1] : void 0;
+  const cleanArgs = fileIndex === -1 ? args : args.filter((_, i) => i !== fileIndex && i !== fileIndex + 1);
+  const word = cleanArgs[1];
+  if (command === "fetch") {
+    console.log("Downloading WordNet data...");
+    const { filePath: cachedPath, version } = await ensureWordNetCached({
+      forceDownload: args.includes("--force"),
+      onProgress: console.log
+    });
+    console.log(`WordNet ${version} cached at: ${cachedPath}`);
+    return;
+  }
+  if (!word && command !== "fetch") {
+    console.error(`Error: Missing word argument for command '${command}'`);
+    process.exit(1);
+  }
+  const lexicon = filePath ? await loadWordNet(filePath) : (await fetchWordNet({ onProgress: console.log })).lexicon;
+  const index = buildIndex(lexicon);
+  switch (command) {
+    case "define": {
+      const definitions = getDefinitions(index, word);
+      if (definitions.length === 0) {
+        console.log(`No definitions found for "${word}"`);
+      } else {
+        console.log(`Definitions for "${word}":`);
+        definitions.forEach((def, i) => {
+          const pos = PartsOfSpeech2[def.partOfSpeech] || def.partOfSpeech;
+          console.log(`  ${i + 1}. [${pos}] ${decode(def.text)}`);
+        });
+      }
+      break;
+    }
+    case "synonyms": {
+      const synonyms = getSynonyms(index, word);
+      if (synonyms.length === 0) {
+        console.log(`No synonyms found for "${word}"`);
+      } else {
+        console.log(`Synonyms for "${word}":`);
+        console.log(`  ${synonyms.map((s) => s.word).join(", ")}`);
+      }
+      break;
+    }
+    case "hypernyms": {
+      const hypernyms = getHypernyms(index, word);
+      if (hypernyms.length === 0) {
+        console.log(`No hypernyms found for "${word}"`);
+      } else {
+        console.log(`Hypernyms for "${word}" (more general):`);
+        hypernyms.forEach((s) => {
+          const words = getSynsetWords(index, s);
+          const def = decode(s.definitions[0]?.inner);
+          console.log(`  - ${words.join(", ")}: ${def}`);
+        });
+      }
+      break;
+    }
+    case "hyponyms": {
+      const hyponyms = getHyponyms(index, word);
+      if (hyponyms.length === 0) {
+        console.log(`No hyponyms found for "${word}"`);
+      } else {
+        console.log(`Hyponyms for "${word}" (more specific):`);
+        hyponyms.forEach((s) => {
+          const words = getSynsetWords(index, s);
+          const def = decode(s.definitions[0]?.inner);
+          console.log(`  - ${words.join(", ")}: ${def}`);
+        });
+      }
+      break;
+    }
+    case "related": {
+      const synsets = findSynsets(index, word);
+      if (synsets.length === 0) {
+        console.log(`No synsets found for "${word}"`);
+        break;
+      }
+      console.log(`Relations for "${word}":`);
+      for (const synset of synsets) {
+        const pos = PartsOfSpeech2[synset.partOfSpeech] || synset.partOfSpeech;
+        const def = decode(synset.definitions[0]?.inner);
+        console.log(`
+[${pos}] ${def}`);
+        const relsByType = /* @__PURE__ */ new Map();
+        for (const rel of synset.synsetRelations) {
+          const relatedSynset = index.synsets.get(rel.target);
+          if (relatedSynset) {
+            const words = getSynsetWords(index, relatedSynset);
+            const existing = relsByType.get(rel.relType) || [];
+            existing.push(words.join(", "));
+            relsByType.set(rel.relType, existing);
+          }
+        }
+        for (const [relType, words] of relsByType) {
+          const label = SynsetRelationRelType2[relType] || relType;
+          console.log(`  ${label}:`);
+          words.forEach((w) => console.log(`    - ${w}`));
+        }
+      }
+      break;
+    }
+    case "info": {
+      const synset = index.synsets.get(word);
+      if (!synset) {
+        console.log(`Synset not found: ${word}`);
+        break;
+      }
+      const pos = PartsOfSpeech2[synset.partOfSpeech] || synset.partOfSpeech;
+      const words = getSynsetWords(index, synset);
+      console.log(`Synset: ${synset.id}`);
+      console.log(`Words: ${words.join(", ")}`);
+      console.log(`Part of Speech: ${pos}`);
+      console.log(`ILI: ${synset.ili}`);
+      console.log(`
+Definitions:`);
+      synset.definitions.forEach((d) => console.log(`  - ${decode(d.inner)}`));
+      if (synset.examples.length > 0) {
+        console.log(`
+Examples:`);
+        synset.examples.forEach((e) => console.log(`  - "${decode(e.inner)}"`));
+      }
+      if (synset.synsetRelations.length > 0) {
+        console.log(`
+Relations:`);
+        for (const rel of synset.synsetRelations) {
+          const label = SynsetRelationRelType2[rel.relType] || rel.relType;
+          const relatedSynset = index.synsets.get(rel.target);
+          const relatedWords = relatedSynset ? getSynsetWords(index, relatedSynset).join(", ") : rel.target;
+          console.log(`  ${label}: ${relatedWords}`);
+        }
+      }
+      break;
+    }
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.log(HELP);
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error("Error:", err.message);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.cjs.map