@ncukondo/reference-manager 0.1.0 → 0.3.0

package/dist/chunks/{detector-BF8Mcc72.js → loader-mQ25o6cV.js}

@@ -1,10 +1,11 @@
 import { randomUUID, createHash } from "node:crypto";
 import { createReadStream, existsSync, readFileSync } from "node:fs";
 import { readFile, mkdir, writeFile } from "node:fs/promises";
-import { z } from "zod";
+import { C as CslLibrarySchema } from "./detector-DHztTaFY.js";
 import { dirname, join } from "node:path";
+import { homedir, tmpdir } from "node:os";
 import { parse } from "@iarna/toml";
-import { tmpdir, homedir } from "node:os";
+import { z } from "zod";
 function normalizeText(text) {
   return text.toLowerCase().replace(/\s+/g, "_").replace(/[^a-z0-9_]/g, "").replace(/_+/g, "_").replace(/^_|_$/g, "");
 }
@@ -32,7 +33,7 @@ function extractAuthorName(item) {
   }
   return "";
 }
-function extractYear$3(item) {
+function extractYear(item) {
   if (!item.issued || !item.issued["date-parts"] || item.issued["date-parts"].length === 0) {
     return "";
   }
@@ -57,7 +58,7 @@ function determineTitlePart(hasAuthor, hasYear, title) {
 }
 function generateId(item) {
   const author = extractAuthorName(item);
-  const year = extractYear$3(item);
+  const year = extractYear(item);
   const title = item.title ? normalizeTitleSlug(item.title) : "";
   const authorPart = author || "anon";
   const yearPart = year || "nd";
@@ -295,54 +296,6 @@ async function computeFileHash(filePath) {
     stream.on("error", (error) => reject(error));
   });
 }
-const CslNameSchema = z.object({
-  family: z.string().optional(),
-  given: z.string().optional(),
-  literal: z.string().optional(),
-  "dropping-particle": z.string().optional(),
-  "non-dropping-particle": z.string().optional(),
-  suffix: z.string().optional()
-});
-const CslDateSchema = z.object({
-  "date-parts": z.array(z.array(z.number())).optional(),
-  raw: z.string().optional(),
-  season: z.string().optional(),
-  circa: z.boolean().optional(),
-  literal: z.string().optional()
-});
-const CslCustomSchema = z.object({
-  uuid: z.string(),
-  created_at: z.string(),
-  timestamp: z.string(),
-  additional_urls: z.array(z.string()).optional()
-});
-const CslItemSchema = z.object({
-  id: z.string(),
-  type: z.string(),
-  title: z.string().optional(),
-  author: z.array(CslNameSchema).optional(),
-  editor: z.array(CslNameSchema).optional(),
-  issued: CslDateSchema.optional(),
-  accessed: CslDateSchema.optional(),
-  "container-title": z.string().optional(),
-  volume: z.string().optional(),
-  issue: z.string().optional(),
-  page: z.string().optional(),
-  DOI: z.string().optional(),
-  PMID: z.string().optional(),
-  PMCID: z.string().optional(),
-  ISBN: z.string().optional(),
-  ISSN: z.string().optional(),
-  URL: z.string().optional(),
-  abstract: z.string().optional(),
-  publisher: z.string().optional(),
-  "publisher-place": z.string().optional(),
-  note: z.string().optional(),
-  keyword: z.array(z.string()).optional(),
-  custom: CslCustomSchema.optional()
-  // Allow additional fields
-}).passthrough();
-const CslLibrarySchema = z.array(CslItemSchema);
 function parseKeyword(keyword) {
   if (typeof keyword !== "string") {
     return void 0;
@@ -478,6 +431,32 @@ class Library {
     }
     return this.removeReference(ref);
   }
+  /**
+   * Update a reference by UUID.
+   * @param uuid - The UUID of the reference to update
+   * @param updates - Partial updates to apply to the reference
+   * @returns true if the reference was found and updated, false otherwise
+   */
+  updateByUuid(uuid, updates, options = {}) {
+    const ref = this.uuidIndex.get(uuid);
+    if (!ref) {
+      return { updated: false };
+    }
+    return this.updateReference(ref, updates, options);
+  }
+  /**
+   * Update a reference by ID.
+   * @param id - The ID of the reference to update
+   * @param updates - Partial updates to apply to the reference
+   * @returns true if the reference was found and updated, false otherwise
+   */
+  updateById(id, updates, options = {}) {
+    const ref = this.idIndex.get(id);
+    if (!ref) {
+      return { updated: false };
+    }
+    return this.updateReference(ref, updates, options);
+  }
   /**
    * Find a reference by UUID
    */
@@ -545,6 +524,82 @@ class Library {
       return false;
     }
     this.references.splice(index, 1);
+    this.removeFromIndices(ref);
+    return true;
+  }
+  /**
+   * Update a reference with partial updates.
+   * Preserves uuid and created_at, updates timestamp.
+   */
+  updateReference(ref, updates, options = {}) {
+    const index = this.references.indexOf(ref);
+    if (index === -1) {
+      return { updated: false };
+    }
+    const existingItem = ref.getItem();
+    const currentId = ref.getId();
+    const { newId, idChanged, collision } = this.resolveNewId(
+      updates.id ?? existingItem.id,
+      currentId,
+      options
+    );
+    if (collision) {
+      return { updated: false, idCollision: true };
+    }
+    const updatedItem = this.buildUpdatedItem(existingItem, updates, newId);
+    this.removeFromIndices(ref);
+    const newRef = new Reference(updatedItem);
+    this.references[index] = newRef;
+    this.addToIndices(newRef);
+    const result = { updated: true };
+    if (idChanged) {
+      result.idChanged = true;
+      result.newId = newId;
+    }
+    return result;
+  }
+  /**
+   * Resolve the new ID, handling collisions based on options.
+   */
+  resolveNewId(requestedId, currentId, options) {
+    if (requestedId === currentId) {
+      return { newId: requestedId, idChanged: false, collision: false };
+    }
+    const conflictingRef = this.idIndex.get(requestedId);
+    if (!conflictingRef) {
+      return { newId: requestedId, idChanged: false, collision: false };
+    }
+    const onIdCollision = options.onIdCollision ?? "fail";
+    if (onIdCollision === "fail") {
+      return { newId: requestedId, idChanged: false, collision: true };
+    }
+    const existingIds = new Set(this.references.map((r) => r.getId()));
+    existingIds.delete(currentId);
+    const resolvedId = this.resolveIdCollision(requestedId, existingIds);
+    return { newId: resolvedId, idChanged: true, collision: false };
+  }
+  /**
+   * Build the updated CslItem, preserving uuid and created_at.
+   */
+  buildUpdatedItem(existingItem, updates, newId) {
+    return {
+      ...existingItem,
+      ...updates,
+      id: newId,
+      type: updates.type ?? existingItem.type,
+      custom: {
+        ...existingItem.custom || {},
+        ...updates.custom || {},
+        uuid: existingItem.custom?.uuid || "",
+        created_at: existingItem.custom?.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  }
+  /**
+   * Remove a reference from all indices.
+   */
+  removeFromIndices(ref) {
     this.uuidIndex.delete(ref.getUuid());
     this.idIndex.delete(ref.getId());
     const doi = ref.getDoi();
@@ -555,7 +610,36 @@ class Library {
     if (pmid) {
       this.pmidIndex.delete(pmid);
     }
-    return true;
+  }
+  /**
+   * Generate an alphabetic suffix for ID collision resolution.
+   * 0 -> 'a', 1 -> 'b', ..., 25 -> 'z', 26 -> 'aa', etc.
+   */
+  generateSuffix(index) {
+    const alphabet = "abcdefghijklmnopqrstuvwxyz";
+    let suffix = "";
+    let n = index;
+    do {
+      suffix = alphabet[n % 26] + suffix;
+      n = Math.floor(n / 26) - 1;
+    } while (n >= 0);
+    return suffix;
+  }
+  /**
+   * Resolve ID collision by appending alphabetic suffix.
+   */
+  resolveIdCollision(baseId, existingIds) {
+    if (!existingIds.has(baseId)) {
+      return baseId;
+    }
+    let index = 0;
+    let newId;
+    do {
+      const suffix = this.generateSuffix(index);
+      newId = `${baseId}${suffix}`;
+      index++;
+    } while (existingIds.has(newId));
+    return newId;
   }
 }
 const logLevelSchema = z.enum(["silent", "info", "debug"]);
@@ -575,12 +659,29 @@ const serverConfigSchema = z.object({
   autoStart: z.boolean(),
   autoStopMinutes: z.number().int().nonnegative()
 });
+const citationFormatSchema = z.enum(["text", "html", "rtf"]);
+const citationConfigSchema = z.object({
+  defaultStyle: z.string(),
+  cslDirectory: z.array(z.string()),
+  defaultLocale: z.string(),
+  defaultFormat: citationFormatSchema
+});
+const pubmedConfigSchema = z.object({
+  email: z.string().optional(),
+  apiKey: z.string().optional()
+});
+const fulltextConfigSchema = z.object({
+  directory: z.string().min(1)
+});
 const configSchema = z.object({
   library: z.string().min(1),
   logLevel: logLevelSchema,
   backup: backupConfigSchema,
   watch: watchConfigSchema,
-  server: serverConfigSchema
+  server: serverConfigSchema,
+  citation: citationConfigSchema,
+  pubmed: pubmedConfigSchema,
+  fulltext: fulltextConfigSchema
 });
 const partialConfigSchema = z.object({
   library: z.string().min(1).optional(),
@@ -610,6 +711,24 @@ const partialConfigSchema = z.object({
     auto_start: z.boolean().optional(),
     autoStopMinutes: z.number().int().nonnegative().optional(),
     auto_stop_minutes: z.number().int().nonnegative().optional()
+  }).optional(),
+  citation: z.object({
+    defaultStyle: z.string().optional(),
+    default_style: z.string().optional(),
+    cslDirectory: z.union([z.string(), z.array(z.string())]).optional(),
+    csl_directory: z.union([z.string(), z.array(z.string())]).optional(),
+    defaultLocale: z.string().optional(),
+    default_locale: z.string().optional(),
+    defaultFormat: citationFormatSchema.optional(),
+    default_format: citationFormatSchema.optional()
+  }).optional(),
+  pubmed: z.object({
+    email: z.string().optional(),
+    apiKey: z.string().optional(),
+    api_key: z.string().optional()
+  }).optional(),
+  fulltext: z.object({
+    directory: z.string().min(1).optional()
   }).optional()
 }).passthrough();
 function normalizeBackupConfig(backup) {
@@ -662,6 +781,37 @@ function normalizeServerConfig(server) {
   }
   return Object.keys(normalized).length > 0 ? normalized : void 0;
 }
+function normalizeCitationConfig(citation) {
+  const normalized = {};
+  const defaultStyle = citation.defaultStyle ?? citation.default_style;
+  if (defaultStyle !== void 0) {
+    normalized.defaultStyle = defaultStyle;
+  }
+  const cslDirectory = citation.cslDirectory ?? citation.csl_directory;
+  if (cslDirectory !== void 0) {
+    normalized.cslDirectory = Array.isArray(cslDirectory) ? cslDirectory : [cslDirectory];
+  }
+  const defaultLocale = citation.defaultLocale ?? citation.default_locale;
+  if (defaultLocale !== void 0) {
+    normalized.defaultLocale = defaultLocale;
+  }
+  const defaultFormat = citation.defaultFormat ?? citation.default_format;
+  if (defaultFormat !== void 0) {
+    normalized.defaultFormat = defaultFormat;
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function normalizePubmedConfig(pubmed) {
+  const normalized = {};
+  if (pubmed.email !== void 0) {
+    normalized.email = pubmed.email;
+  }
+  const apiKey = pubmed.apiKey ?? pubmed.api_key;
+  if (apiKey !== void 0) {
+    normalized.apiKey = apiKey;
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
 function normalizePartialConfig(partial) {
   const normalized = {};
   if (partial.library !== void 0) {
@@ -671,30 +821,39 @@ function normalizePartialConfig(partial) {
   if (logLevel !== void 0) {
     normalized.logLevel = logLevel;
   }
-  if (partial.backup !== void 0) {
-    const backup = normalizeBackupConfig(
-      partial.backup
-    );
-    if (backup) {
-      normalized.backup = backup;
-    }
+  const backup = partial.backup !== void 0 ? normalizeBackupConfig(partial.backup) : void 0;
+  if (backup) {
+    normalized.backup = backup;
   }
-  if (partial.watch !== void 0) {
-    const watch = normalizeWatchConfig(partial.watch);
-    if (watch) {
-      normalized.watch = watch;
-    }
+  const watch = partial.watch !== void 0 ? normalizeWatchConfig(partial.watch) : void 0;
+  if (watch) {
+    normalized.watch = watch;
   }
-  if (partial.server !== void 0) {
-    const server = normalizeServerConfig(
-      partial.server
-    );
-    if (server) {
-      normalized.server = server;
-    }
+  const server = partial.server !== void 0 ? normalizeServerConfig(partial.server) : void 0;
+  if (server) {
+    normalized.server = server;
+  }
+  const citation = partial.citation !== void 0 ? normalizeCitationConfig(partial.citation) : void 0;
+  if (citation) {
+    normalized.citation = citation;
+  }
+  const pubmed = partial.pubmed !== void 0 ? normalizePubmedConfig(partial.pubmed) : void 0;
+  if (pubmed) {
+    normalized.pubmed = pubmed;
+  }
+  const fulltext = partial.fulltext !== void 0 ? normalizeFulltextConfig(partial.fulltext) : void 0;
+  if (fulltext) {
+    normalized.fulltext = fulltext;
   }
   return normalized;
 }
+function normalizeFulltextConfig(fulltext) {
+  const normalized = {};
+  if (fulltext.directory !== void 0) {
+    normalized.directory = fulltext.directory;
+  }
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
 function getDefaultBackupDirectory() {
   return join(tmpdir(), "reference-manager", "backups");
 }
@@ -707,6 +866,12 @@ function getDefaultUserConfigPath() {
 function getDefaultCurrentDirConfigFilename() {
   return ".reference-manager.config.toml";
 }
+function getDefaultCslDirectory() {
+  return join(homedir(), ".reference-manager", "csl");
+}
+function getDefaultFulltextDirectory() {
+  return join(homedir(), ".reference-manager", "fulltext");
+}
 const defaultConfig = {
   library: getDefaultLibraryPath(),
   logLevel: "info",
@@ -725,6 +890,19 @@ const defaultConfig = {
   server: {
     autoStart: false,
     autoStopMinutes: 0
+  },
+  citation: {
+    defaultStyle: "apa",
+    cslDirectory: [getDefaultCslDirectory()],
+    defaultLocale: "en-US",
+    defaultFormat: "text"
+  },
+  pubmed: {
+    email: void 0,
+    apiKey: void 0
+  },
+  fulltext: {
+    directory: getDefaultFulltextDirectory()
   }
 };
 function loadTOMLFile(path) {
@@ -744,6 +922,7 @@ function loadTOMLFile(path) {
 }
 function mergeConfigs(base, ...overrides) {
   const result = { ...base };
+  const sectionKeys = ["backup", "watch", "server", "citation", "pubmed", "fulltext"];
   for (const override of overrides) {
     if (!override) continue;
     if (override.library !== void 0) {
@@ -752,23 +931,13 @@ function mergeConfigs(base, ...overrides) {
     if (override.logLevel !== void 0) {
       result.logLevel = override.logLevel;
     }
-    if (override.backup !== void 0) {
-      result.backup = {
-        ...result.backup,
-        ...override.backup
-      };
-    }
-    if (override.watch !== void 0) {
-      result.watch = {
-        ...result.watch,
-        ...override.watch
-      };
-    }
-    if (override.server !== void 0) {
-      result.server = {
-        ...result.server,
-        ...override.server
-      };
+    for (const key of sectionKeys) {
+      if (override[key] !== void 0) {
+        result[key] = {
+          ...result[key],
+          ...override[key]
+        };
+      }
     }
   }
   return result;
@@ -792,7 +961,39 @@ function fillDefaults(partial) {
     server: {
       autoStart: partial.server?.autoStart ?? defaultConfig.server.autoStart,
       autoStopMinutes: partial.server?.autoStopMinutes ?? defaultConfig.server.autoStopMinutes
-    }
+    },
+    citation: fillCitationDefaults(partial.citation),
+    pubmed: fillPubmedDefaults(partial.pubmed),
+    fulltext: fillFulltextDefaults(partial.fulltext)
+  };
+}
+function fillCitationDefaults(partial) {
+  return {
+    defaultStyle: partial?.defaultStyle ?? defaultConfig.citation.defaultStyle,
+    cslDirectory: partial?.cslDirectory ?? defaultConfig.citation.cslDirectory,
+    defaultLocale: partial?.defaultLocale ?? defaultConfig.citation.defaultLocale,
+    defaultFormat: partial?.defaultFormat ?? defaultConfig.citation.defaultFormat
+  };
+}
+function fillPubmedDefaults(partial) {
+  const email = process.env.PUBMED_EMAIL ?? partial?.email ?? defaultConfig.pubmed.email;
+  const apiKey = process.env.PUBMED_API_KEY ?? partial?.apiKey ?? defaultConfig.pubmed.apiKey;
+  return {
+    email,
+    apiKey
+  };
+}
+function expandTilde(path) {
+  if (path.startsWith("~/")) {
+    return join(homedir(), path.slice(2));
+  }
+  return path;
+}
+function fillFulltextDefaults(partial) {
+  const envDir = process.env.REFERENCE_MANAGER_FULLTEXT_DIR;
+  const directory = envDir ?? partial?.directory ?? defaultConfig.fulltext.directory;
+  return {
+    directory: expandTilde(directory)
   };
 }
 function loadConfig(options = {}) {
@@ -822,567 +1023,7 @@ function loadConfig(options = {}) {
     );
   }
 }
-const VALID_FIELDS = /* @__PURE__ */ new Set([
-  "author",
-  "title",
-  "year",
-  "doi",
-  "pmid",
-  "pmcid",
-  "url",
-  "keyword"
-]);
-function isWhitespace(query, index) {
-  return /\s/.test(query.charAt(index));
-}
-function isQuote(query, index) {
-  return query.charAt(index) === '"';
-}
-function tokenize(query) {
-  const tokens = [];
-  let i = 0;
-  while (i < query.length) {
-    if (isWhitespace(query, i)) {
-      i++;
-      continue;
-    }
-    const result = parseNextToken(query, i);
-    if (result.token) {
-      tokens.push(result.token);
-    }
-    i = result.nextIndex;
-  }
-  return {
-    original: query,
-    tokens
-  };
-}
-function hasWhitespaceBetween(query, start, end) {
-  for (let j = start; j < end; j++) {
-    if (isWhitespace(query, j)) {
-      return true;
-    }
-  }
-  return false;
-}
-function tryParseFieldValue(query, startIndex) {
-  const colonIndex = query.indexOf(":", startIndex);
-  if (colonIndex === -1) {
-    return null;
-  }
-  if (hasWhitespaceBetween(query, startIndex, colonIndex)) {
-    return null;
-  }
-  const fieldName = query.substring(startIndex, colonIndex);
-  if (!VALID_FIELDS.has(fieldName)) {
-    return null;
-  }
-  const afterColon = colonIndex + 1;
-  if (afterColon >= query.length || isWhitespace(query, afterColon)) {
-    return { token: null, nextIndex: afterColon };
-  }
-  if (isQuote(query, afterColon)) {
-    const quoteResult = parseQuotedValue(query, afterColon);
-    if (quoteResult.value !== null) {
-      return {
-        token: {
-          raw: query.substring(startIndex, quoteResult.nextIndex),
-          value: quoteResult.value,
-          field: fieldName,
-          isPhrase: true
-        },
-        nextIndex: quoteResult.nextIndex
-      };
-    }
-    return null;
-  }
-  const valueResult = parseUnquotedValue(query, afterColon);
-  return {
-    token: {
-      raw: query.substring(startIndex, valueResult.nextIndex),
-      value: valueResult.value,
-      field: fieldName,
-      isPhrase: false
-    },
-    nextIndex: valueResult.nextIndex
-  };
-}
-function parseQuotedToken(query, startIndex) {
-  const quoteResult = parseQuotedValue(query, startIndex);
-  if (quoteResult.value !== null) {
-    return {
-      token: {
-        raw: query.substring(startIndex, quoteResult.nextIndex),
-        value: quoteResult.value,
-        isPhrase: true
-      },
-      nextIndex: quoteResult.nextIndex
-    };
-  }
-  if (quoteResult.nextIndex > startIndex) {
-    return { token: null, nextIndex: quoteResult.nextIndex };
-  }
-  const valueResult = parseUnquotedValue(query, startIndex, true);
-  return {
-    token: {
-      raw: valueResult.value,
-      value: valueResult.value,
-      isPhrase: false
-    },
-    nextIndex: valueResult.nextIndex
-  };
-}
-function parseRegularToken(query, startIndex) {
-  const valueResult = parseUnquotedValue(query, startIndex);
-  return {
-    token: {
-      raw: valueResult.value,
-      value: valueResult.value,
-      isPhrase: false
-    },
-    nextIndex: valueResult.nextIndex
-  };
-}
-function parseNextToken(query, startIndex) {
-  const fieldResult = tryParseFieldValue(query, startIndex);
-  if (fieldResult !== null) {
-    return fieldResult;
-  }
-  if (isQuote(query, startIndex)) {
-    return parseQuotedToken(query, startIndex);
-  }
-  return parseRegularToken(query, startIndex);
-}
-function parseQuotedValue(query, startIndex) {
-  if (!isQuote(query, startIndex)) {
-    return { value: null, nextIndex: startIndex };
-  }
-  let i = startIndex + 1;
-  const valueStart = i;
-  while (i < query.length && !isQuote(query, i)) {
-    i++;
-  }
-  if (i >= query.length) {
-    return { value: null, nextIndex: startIndex };
-  }
-  const value = query.substring(valueStart, i);
-  i++;
-  if (value.trim() === "") {
-    return { value: null, nextIndex: i };
-  }
-  return { value, nextIndex: i };
-}
-function parseUnquotedValue(query, startIndex, includeQuotes = false) {
-  let i = startIndex;
-  while (i < query.length && !isWhitespace(query, i)) {
-    if (!includeQuotes && isQuote(query, i)) {
-      break;
-    }
-    i++;
-  }
-  return {
-    value: query.substring(startIndex, i),
-    nextIndex: i
-  };
-}
-function normalize(text) {
-  let normalized = text.normalize("NFKC");
-  normalized = normalized.toLowerCase();
-  normalized = normalized.normalize("NFD").replace(new RegExp("\\p{M}", "gu"), "");
-  normalized = normalized.replace(/[^\p{L}\p{N}/\s]/gu, " ");
-  normalized = normalized.replace(/\s+/g, " ").trim();
-  return normalized;
-}
-const ID_FIELDS = /* @__PURE__ */ new Set(["DOI", "PMID", "PMCID", "URL"]);
-function extractYear$2(reference) {
-  if (reference.issued?.["date-parts"]?.[0]?.[0]) {
-    return String(reference.issued["date-parts"][0][0]);
-  }
-  return "0000";
-}
-function extractAuthors(reference) {
-  if (!reference.author || reference.author.length === 0) {
-    return "";
-  }
-  return reference.author.map((author) => {
-    const family = author.family || "";
-    const givenInitial = author.given ? author.given[0] : "";
-    return givenInitial ? `${family} ${givenInitial}` : family;
-  }).join(" ");
-}
-function getFieldValue(reference, field) {
-  if (field === "year") {
-    return extractYear$2(reference);
-  }
-  if (field === "author") {
-    return extractAuthors(reference);
-  }
-  const value = reference[field];
-  if (typeof value === "string") {
-    return value;
-  }
-  if (field.startsWith("custom.")) {
-    const customField = field.substring(7);
-    const customValue = reference.custom?.[customField];
-    if (typeof customValue === "string") {
-      return customValue;
-    }
-  }
-  return null;
-}
-function matchUrl(queryValue, reference) {
-  if (reference.URL === queryValue) {
-    return {
-      field: "URL",
-      strength: "exact",
-      value: reference.URL
-    };
-  }
-  const additionalUrls = reference.custom?.additional_urls;
-  if (Array.isArray(additionalUrls)) {
-    for (const url of additionalUrls) {
-      if (typeof url === "string" && url === queryValue) {
-        return {
-          field: "custom.additional_urls",
-          strength: "exact",
-          value: url
-        };
-      }
-    }
-  }
-  return null;
-}
-function matchKeyword(queryValue, reference) {
-  if (!reference.keyword || !Array.isArray(reference.keyword)) {
-    return null;
-  }
-  const normalizedQuery = normalize(queryValue);
-  for (const keyword of reference.keyword) {
-    if (typeof keyword === "string") {
-      const normalizedKeyword = normalize(keyword);
-      if (normalizedKeyword.includes(normalizedQuery)) {
-        return {
-          field: "keyword",
-          strength: "partial",
-          value: keyword
-        };
-      }
-    }
-  }
-  return null;
-}
-const FIELD_MAP = {
-  author: "author",
-  title: "title",
-  doi: "DOI",
-  pmid: "PMID",
-  pmcid: "PMCID"
-};
-function matchYearField(tokenValue, reference) {
-  const year = extractYear$2(reference);
-  if (year === tokenValue) {
-    return {
-      field: "year",
-      strength: "exact",
-      value: year
-    };
-  }
-  return null;
-}
-function matchFieldValue(field, tokenValue, reference) {
-  const fieldValue = getFieldValue(reference, field);
-  if (fieldValue === null) {
-    return null;
-  }
-  if (ID_FIELDS.has(field)) {
-    if (fieldValue === tokenValue) {
-      return {
-        field,
-        strength: "exact",
-        value: fieldValue
-      };
-    }
-    return null;
-  }
-  const normalizedFieldValue = normalize(fieldValue);
-  const normalizedQuery = normalize(tokenValue);
-  if (normalizedFieldValue.includes(normalizedQuery)) {
-    return {
-      field,
-      strength: "partial",
-      value: fieldValue
-    };
-  }
-  return null;
-}
-function matchSpecificField(token, reference) {
-  const matches = [];
-  const fieldToSearch = token.field;
-  if (fieldToSearch === "url") {
-    const urlMatch = matchUrl(token.value, reference);
-    if (urlMatch) matches.push(urlMatch);
-    return matches;
-  }
-  if (fieldToSearch === "year") {
-    const yearMatch = matchYearField(token.value, reference);
-    if (yearMatch) matches.push(yearMatch);
-    return matches;
-  }
-  if (fieldToSearch === "keyword") {
-    const keywordMatch = matchKeyword(token.value, reference);
-    if (keywordMatch) matches.push(keywordMatch);
-    return matches;
-  }
-  const actualField = FIELD_MAP[fieldToSearch] || fieldToSearch;
-  const match = matchFieldValue(actualField, token.value, reference);
-  if (match) matches.push(match);
-  return matches;
-}
-const STANDARD_SEARCH_FIELDS = [
-  "title",
-  "author",
-  "container-title",
-  "publisher",
-  "DOI",
-  "PMID",
-  "PMCID",
-  "abstract"
-];
-function matchSingleField(field, tokenValue, reference) {
-  if (field === "year") {
-    return matchYearField(tokenValue, reference);
-  }
-  if (field === "URL") {
-    return matchUrl(tokenValue, reference);
-  }
-  if (field === "keyword") {
-    return matchKeyword(tokenValue, reference);
-  }
-  return matchFieldValue(field, tokenValue, reference);
-}
-function matchAllFields(token, reference) {
-  const matches = [];
-  const specialFields = ["year", "URL", "keyword"];
-  for (const field of specialFields) {
-    const match = matchSingleField(field, token.value, reference);
-    if (match) matches.push(match);
-  }
-  for (const field of STANDARD_SEARCH_FIELDS) {
-    const match = matchFieldValue(field, token.value, reference);
-    if (match) matches.push(match);
-  }
-  return matches;
-}
-function matchToken(token, reference) {
-  if (token.field) {
-    return matchSpecificField(token, reference);
-  }
-  return matchAllFields(token, reference);
-}
-function matchReference(reference, tokens) {
-  if (tokens.length === 0) {
-    return null;
-  }
-  const tokenMatches = [];
-  let overallStrength = "none";
-  for (const token of tokens) {
-    const matches = matchToken(token, reference);
-    if (matches.length === 0) {
-      return null;
-    }
-    const tokenStrength = matches.some((m) => m.strength === "exact") ? "exact" : "partial";
-    if (tokenStrength === "exact") {
-      overallStrength = "exact";
-    } else if (tokenStrength === "partial" && overallStrength === "none") {
-      overallStrength = "partial";
-    }
-    tokenMatches.push({
-      token,
-      matches
-    });
-  }
-  const score = overallStrength === "exact" ? 100 + tokenMatches.length : 50 + tokenMatches.length;
-  return {
-    reference,
-    tokenMatches,
-    overallStrength,
-    score
-  };
-}
-function search(references, tokens) {
-  const results = [];
-  for (const reference of references) {
-    const match = matchReference(reference, tokens);
-    if (match) {
-      results.push(match);
-    }
-  }
-  return results;
-}
-function extractYear$1(reference) {
-  if (reference.issued?.["date-parts"]?.[0]?.[0]) {
-    return String(reference.issued["date-parts"][0][0]);
-  }
-  return "0000";
-}
-function extractFirstAuthorFamily(reference) {
-  if (!reference.author || reference.author.length === 0) {
-    return "";
-  }
-  return reference.author[0]?.family || "";
-}
-function extractTitle(reference) {
-  return reference.title || "";
-}
-function compareStrength(a, b) {
-  const strengthOrder = { exact: 2, partial: 1, none: 0 };
-  return strengthOrder[b] - strengthOrder[a];
-}
-function compareYear(a, b) {
-  const yearA = extractYear$1(a);
-  const yearB = extractYear$1(b);
-  return Number(yearB) - Number(yearA);
-}
-function compareAuthor(a, b) {
-  const authorA = extractFirstAuthorFamily(a).toLowerCase();
-  const authorB = extractFirstAuthorFamily(b).toLowerCase();
-  if (authorA === "" && authorB !== "") return 1;
-  if (authorA !== "" && authorB === "") return -1;
-  return authorA.localeCompare(authorB);
-}
-function compareTitle(a, b) {
-  const titleA = extractTitle(a).toLowerCase();
-  const titleB = extractTitle(b).toLowerCase();
-  if (titleA === "" && titleB !== "") return 1;
-  if (titleA !== "" && titleB === "") return -1;
-  return titleA.localeCompare(titleB);
-}
-function sortResults(results) {
-  const indexed = results.map((result, index) => ({ result, index }));
-  const sorted = indexed.sort((a, b) => {
-    const strengthDiff = compareStrength(a.result.overallStrength, b.result.overallStrength);
-    if (strengthDiff !== 0) return strengthDiff;
-    const yearDiff = compareYear(a.result.reference, b.result.reference);
-    if (yearDiff !== 0) return yearDiff;
-    const authorDiff = compareAuthor(a.result.reference, b.result.reference);
-    if (authorDiff !== 0) return authorDiff;
-    const titleDiff = compareTitle(a.result.reference, b.result.reference);
-    if (titleDiff !== 0) return titleDiff;
-    return a.index - b.index;
-  });
-  return sorted.map((item) => item.result);
-}
-function normalizeDoi(doi) {
-  const normalized = doi.replace(/^https?:\/\/doi\.org\//i, "").replace(/^https?:\/\/dx\.doi\.org\//i, "").replace(/^doi:/i, "");
-  return normalized;
-}
-function extractYear(item) {
-  const dateParts = item.issued?.["date-parts"]?.[0];
-  if (!dateParts || dateParts.length === 0) {
-    return null;
-  }
-  return String(dateParts[0]);
-}
-function normalizeAuthors(item) {
-  if (!item.author || item.author.length === 0) {
-    return null;
-  }
-  const authorStrings = item.author.map((author) => {
-    const family = author.family || "";
-    const givenInitial = author.given ? author.given.charAt(0) : "";
-    return `${family} ${givenInitial}`.trim();
-  });
-  return normalize(authorStrings.join(" "));
-}
-function checkDoiMatch(item, existing) {
-  if (!item.DOI || !existing.DOI) {
-    return null;
-  }
-  const normalizedItemDoi = normalizeDoi(item.DOI);
-  const normalizedExistingDoi = normalizeDoi(existing.DOI);
-  if (normalizedItemDoi === normalizedExistingDoi) {
-    return {
-      type: "doi",
-      existing,
-      details: {
-        doi: normalizedExistingDoi
-      }
-    };
-  }
-  return null;
-}
-function checkPmidMatch(item, existing) {
-  if (!item.PMID || !existing.PMID) {
-    return null;
-  }
-  if (item.PMID === existing.PMID) {
-    return {
-      type: "pmid",
-      existing,
-      details: {
-        pmid: existing.PMID
-      }
-    };
-  }
-  return null;
-}
-function checkTitleAuthorYearMatch(item, existing) {
-  const itemTitle = item.title ? normalize(item.title) : null;
-  const existingTitle = existing.title ? normalize(existing.title) : null;
-  const itemAuthors = normalizeAuthors(item);
-  const existingAuthors = normalizeAuthors(existing);
-  const itemYear = extractYear(item);
-  const existingYear = extractYear(existing);
-  if (!itemTitle || !existingTitle || !itemAuthors || !existingAuthors || !itemYear || !existingYear) {
-    return null;
-  }
-  if (itemTitle === existingTitle && itemAuthors === existingAuthors && itemYear === existingYear) {
-    return {
-      type: "title-author-year",
-      existing,
-      details: {
-        normalizedTitle: existingTitle,
-        normalizedAuthors: existingAuthors,
-        year: existingYear
-      }
-    };
-  }
-  return null;
-}
-function checkSingleDuplicate(item, existing) {
-  const doiMatch = checkDoiMatch(item, existing);
-  if (doiMatch) {
-    return doiMatch;
-  }
-  const pmidMatch = checkPmidMatch(item, existing);
-  if (pmidMatch) {
-    return pmidMatch;
-  }
-  return checkTitleAuthorYearMatch(item, existing);
-}
-function detectDuplicate(item, existingReferences) {
-  const matches = [];
-  const itemUuid = item.custom?.uuid;
-  for (const existing of existingReferences) {
-    if (itemUuid && existing.custom?.uuid === itemUuid) {
-      continue;
-    }
-    const match = checkSingleDuplicate(item, existing);
-    if (match) {
-      matches.push(match);
-    }
-  }
-  return {
-    isDuplicate: matches.length > 0,
-    matches
-  };
-}
 export {
-  generateUuid as A,
-  isValidUuid as B,
-  CslLibrarySchema as C,
-  ensureCustomMetadata as D,
-  extractUuidFromCustom as E,
   Library as L,
   Reference as R,
   computeHash as a,
@@ -1395,21 +1036,19 @@ export {
   getDefaultLibraryPath as h,
   getDefaultUserConfigPath as i,
   logLevelSchema as j,
-  normalize as k,
+  parseCslJson as k,
   loadConfig as l,
-  sortResults as m,
+  writeCslJson as m,
   normalizePartialConfig as n,
-  detectDuplicate as o,
+  generateId as o,
   partialConfigSchema as p,
-  CslItemSchema as q,
-  parseCslJson as r,
-  search as s,
-  tokenize as t,
-  serializeCslJson as u,
-  writeCslJson as v,
+  generateIdWithCollisionCheck as q,
+  normalizeText as r,
+  serializeCslJson as s,
+  generateUuid as t,
+  isValidUuid as u,
+  ensureCustomMetadata as v,
   watchConfigSchema as w,
-  generateId as x,
-  generateIdWithCollisionCheck as y,
-  normalizeText as z
+  extractUuidFromCustom as x
 };
-//# sourceMappingURL=detector-BF8Mcc72.js.map
+//# sourceMappingURL=loader-mQ25o6cV.js.map