@xevos117/mcp-zotero 2.0.4 → 2.1.0

package/build/citation-injector/pipeline.js

@@ -0,0 +1,189 @@
+import JSZip from "jszip";
+import { readFile } from "node:fs/promises";
+import { format, parse } from "node:path";
+import { ZOTERO_KEY } from "../utils/zotero-keys.js";
+import { writeFileAtomic } from "../utils/atomic-write.js";
+import { InjectionError } from "./model.js";
+import { parseZciteTags } from "./zcite.js";
+import { parsePandocCitesInBody, countPandocMarkers } from "./pandoc-body.js";
+import { resolveCitekeys } from "./citekey-resolver.js";
+import { assignNumbers } from "../cited-document/number.js";
+import { buildCitationItems } from "./citation-json.js";
+import { formatCitationText } from "./citation-formatter.js";
+const NO_ZCITE_WARNING = 'No <zcite> placeholders found: the output is an unchanged copy. Write them in the document body as <zcite keys="ITEMKEY"/> ' +
+    "(headers, footers, footnotes and comments are not scanned).";
+function mixedWarning(count) {
+    return (`The document also has ${count} Pandoc citation marker(s) ([@key]): they were left as text, because a document with ` +
+        "<zcite> placeholders is treated as a zcite document. To turn them into citations too, call inject_citations again " +
+        "on the output file.");
+}
+const EXISTING_BIBLIOGRAPHY_WARNING = "The document already has a Zotero bibliography: the new citations were added but no second bibliography was written " +
+    "(Zotero rebuilds the single bibliography on Refresh).";
+function numberedWarning(style, withNum, total, app) {
+    return (`Style '${style}' requires 'num' attribute on <zcite> tags. Found ${withNum}/${total} tags with num. ` +
+        `Citations without num show [?] until the user runs Zotero → Refresh in ${app}; to get the numbers now, add ` +
+        'num="N" (order of first citation) to every <zcite> in the original file and run again.');
+}
+/**
+ * Risolve le richieste di citazione: valida le chiavi (solo chiavi Zotero ben formate raggiungono l'API),
+ * recupera le voci dalla sorgente, verifica le chiavi mancanti e costruisce le citazioni con il testo
+ * provvisorio. Lancia InjectionError senza scrivere nulla se una chiave è invalida o assente.
+ */
+export async function resolveCitations(requests, itemSource, opts) {
+    const uniqueKeys = new Set(requests.flatMap((r) => r.keys));
+    // Keys from the document go into API URL paths and Zotero URIs: only well-formed Zotero keys, so a
+    // crafted <zcite> cannot point the request at another endpoint, and a key Zotero would reject never
+    // reaches the document. The skill's inject.js applies the same check.
+    const invalid = [...uniqueKeys].filter((k) => !ZOTERO_KEY.test(k));
+    if (invalid.length > 0) {
+        throw new InjectionError("invalid_key", `Invalid Zotero item key(s) in <zcite>: ${invalid.join(", ")} (a key is 8 characters from 23456789ABCDEFGHIJKLMNPQRSTUVWXYZ). ` +
+            "No file was written. Use the keys returned by search_library, add_items_by_doi or add_items.");
+    }
+    const cslData = await itemSource(uniqueKeys);
+    // No placeholder citations: a citation of a nonexistent item fails the injection, like the skill's
+    // inject.js with a key missing from metadata.json.
+    const missingKeys = [...uniqueKeys].filter((k) => !cslData.has(k));
+    if (missingKeys.length > 0) {
+        throw new InjectionError("missing_keys", `${missingKeys.length} cited key(s) not found in the library: ${missingKeys.join(", ")}. No file was written. ` +
+            "Fix these keys in the document (find existing items with search_library, or add the missing ones with add_items_by_doi " +
+            "or add_items) and call again; for a group library pass library_type and library_id.");
+    }
+    return requests.map((request) => {
+        const items = buildCitationItems(request, cslData, opts.libraryType, opts.userId);
+        const itemData = request.keys.map((k) => cslData.get(k) ?? { type: "article-journal" });
+        const formattedText = formatCitationText(itemData, opts.style, request);
+        return { request, items, itemData, formattedText };
+    });
+}
+/**
+ * Inietta le citazioni nel pacchetto `zip` già caricato, con lo scrittore dato: normalizza il corpo, trova
+ * i segnaposto, li risolve e li sostituisce, aggiunge la bibliografia e scrive le preferenze del documento.
+ * Non scrive su disco (lo fa injectFile). Restituisce il numero di segnaposto trovati/iniettati e gli avvisi.
+ */
+export async function injectPackage(zip, writer, itemSource, opts, citekeyLookup) {
+    const rawBody = await zip.file(writer.bodyPart).async("string");
+    // Internal recognition, no input flag. A document that contains <zcite> is a zcite document and takes
+    // exactly the path it does today (same code, same byte output); Pandoc markers in it, if any, are only
+    // reported. Otherwise, if it has Pandoc markers, the Pandoc branch runs. Neither: an unchanged copy.
+    if (rawBody.includes("zcite")) {
+        return injectZciteBranch(rawBody, zip, writer, itemSource, opts);
+    }
+    if (citekeyLookup) {
+        // The Pandoc branch itself returns an unchanged copy (found 0) if it finds no markers.
+        return injectPandocBranch(rawBody, zip, writer, itemSource, opts, citekeyLookup);
+    }
+    return { found: 0, injected: 0, warnings: [NO_ZCITE_WARNING] };
+}
+/** The zcite path, identical to before, plus a note when the document also carries Pandoc markers. */
+async function injectZciteBranch(rawBody, zip, writer, itemSource, opts) {
+    let body = writer.normalize(rawBody);
+    const requests = parseZciteTags(body);
+    if (requests.length === 0) {
+        return { found: 0, injected: 0, warnings: [NO_ZCITE_WARNING] };
+    }
+    const warnings = [];
+    if (opts.style === "ieee" || opts.style === "vancouver") {
+        const withNum = requests.filter((r) => r.num !== undefined).length;
+        if (withNum < requests.length)
+            warnings.push(numberedWarning(opts.style, withNum, requests.length, writer.app));
+    }
+    const prepared = await resolveCitations(requests, itemSource, opts);
+    let injected = 0;
+    for (const p of prepared) {
+        const citationXml = writer.citationXml(p);
+        const newBody = writer.replaceTag(body, p.request.raw, citationXml);
+        if (newBody !== body) {
+            body = newBody;
+            injected++;
+        }
+    }
+    body = writer.appendBibliography(body);
+    zip.file(writer.bodyPart, body);
+    const prefs = await writer.writePrefs(zip, opts.style);
+    warnings.push(...writer.prefsWarnings(prefs));
+    // Mixed document: report the Pandoc markers left as text (counted on the unmodified body).
+    const pandoc = countPandocMarkers(rawBody, writer.format);
+    if (pandoc > 0)
+        warnings.push(mixedWarning(pandoc));
+    return { found: requests.length, injected, warnings };
+}
+/**
+ * The Pandoc path: merge split markers, parse `[@key]`/inline citations, resolve Better BibTeX citekeys to
+ * Zotero keys, then reuse the same resolve + writer machinery as zcite. If the document already has a
+ * Zotero bibliography (e.g. a second call on a once-injected file), no second one is written.
+ */
+async function injectPandocBranch(rawBody, zip, writer, itemSource, opts, citekeyLookup) {
+    let body = normalizePandocBody(writer, rawBody);
+    const parsed = parsePandocCitesInBody(body, writer.format);
+    if (parsed.length === 0) {
+        return { found: 0, injected: 0, warnings: [NO_ZCITE_WARNING] };
+    }
+    // Resolve Better BibTeX citekeys. Unresolved inline markers are dropped (kept as text) with a warning;
+    // an unknown/ambiguous bracketed key throws, so nothing is written.
+    const { requests, warnings } = await resolveCitekeys(parsed, citekeyLookup);
+    if (requests.length === 0) {
+        // every marker was an inline that did not resolve → unchanged copy, like a document with no markers
+        warnings.push(NO_ZCITE_WARNING);
+        return { found: 0, injected: 0, warnings };
+    }
+    // Numbered styles: number by order of first citation (Pandoc markers carry no num attribute).
+    if (opts.style === "ieee" || opts.style === "vancouver") {
+        const nums = assignNumbers(requests);
+        for (const r of requests)
+            r.num = nums.get(r);
+    }
+    const prepared = await resolveCitations(requests, itemSource, opts);
+    let injected = 0;
+    // Replace longer markers first: an inline `@KEY` is a substring of `-@KEY` (and of a longer citekey), so
+    // replacing the shorter one first could match inside the longer. Length-descending removes that overlap;
+    // numbering was already assigned in document order above.
+    for (const p of [...prepared].sort((a, b) => b.request.raw.length - a.request.raw.length)) {
+        const citationXml = writer.citationXml(p);
+        const newBody = writer.replaceTag(body, p.request.raw, citationXml);
+        if (newBody !== body) {
+            body = newBody;
+            injected++;
+        }
+    }
+    // A once-injected document already has one bibliography; do not add a second (Zotero keeps one).
+    if (body.includes("ZOTERO_BIBL")) {
+        warnings.push(EXISTING_BIBLIOGRAPHY_WARNING);
+    }
+    else {
+        body = writer.appendBibliography(body);
+    }
+    zip.file(writer.bodyPart, body);
+    const prefs = await writer.writePrefs(zip, opts.style);
+    warnings.push(...writer.prefsWarnings(prefs));
+    return { found: requests.length, injected, warnings };
+}
+/** Pandoc run/span merge for the writer's format; falls back to the body unchanged for an unknown format. */
+function normalizePandocBody(writer, body) {
+    return writer.normalizePandoc ? writer.normalizePandoc(body) : body;
+}
+/**
+ * Iniezione completa su un file: deriva "<nome>_cited<ext>" dal solo basename (una cartella che contiene
+ * ".docx" resta intatta), carica il pacchetto, inietta e salva l'output in modo atomico.
+ */
+export async function injectFile(filePath, writer, itemSource, opts, citekeyLookup) {
+    const { dir, name, ext } = parse(filePath);
+    const outputPath = format({ dir, name: `${name}_cited`, ext });
+    const fileBuffer = await readFile(filePath);
+    let zip;
+    try {
+        zip = await JSZip.loadAsync(fileBuffer);
+    }
+    catch (err) {
+        throw new InjectionError("invalid_package", writer.invalidPackageMessage(err instanceof Error ? err.message : String(err)));
+    }
+    writer.sniff?.(zip); // mismatch di formato (docx vs odt): messaggio chiaro prima del controllo del corpo
+    if (!zip.file(writer.bodyPart)) {
+        throw new InjectionError("no_document", writer.bodyMissingMessage);
+    }
+    const { found, injected, warnings } = await injectPackage(zip, writer, itemSource, opts, citekeyLookup);
+    if (writer.finalize)
+        await writer.finalize(zip);
+    const buffer = await zip.generateAsync({ type: "nodebuffer", ...writer.generateOptions });
+    await writeFileAtomic(outputPath, buffer);
+    return { outputPath, found, injected, warnings };
+}

package/build/citation-injector/zcite-normalizer.js

@@ -2,6 +2,10 @@ import { XMLParser, XMLBuilder } from "fast-xml-parser";
 // Pattern to detect a complete zcite tag in entity-encoded text
 // (processEntities: false keeps < etc. as literals)
 const ZCITE_PATTERN = /<zcite\s+[\s\S]*?\/>/;
+// A complete Pandoc bracketed citation `[... @key ...]` within a single text node (no tag `<` inside).
+// Used by the Pandoc branch of inject_citations to merge a marker Word split across runs. The zcite
+// path keeps ZCITE_PATTERN, so its behaviour (and the golden Word output) is unchanged.
+const PANDOC_PATTERN = /\[[^\]<]*@[^\]<]*\]/;
 const PARSER_OPTIONS = {
     preserveOrder: true,
     ignoreAttributes: false,
@@ -89,7 +93,7 @@ function collectConsecutiveRunGroups(children) {
  * Returns the sub-range [startOffset, endOffset] within the group (0-indexed),
  * or null if no split zcite found.
  */
-function findSplitZcite(group) {
+function findSplitZcite(group, pattern) {
     const { texts } = group;
     // Sliding window: try all start positions
     for (let start = 0; start < texts.length; start++) {
@@ -99,7 +103,7 @@ function findSplitZcite(group) {
             // Only interested in splits (spanning 2+ runs)
             if (end <= start)
                 continue;
-            const m = ZCITE_PATTERN.exec(concat);
+            const m = pattern.exec(concat);
             if (m) {
                 // Verify the match actually spans runs: the zcite must start before
                 // the last run's text and end at or after the last run's start.
@@ -163,7 +167,7 @@ function mergeRunsInPlace(children, group, startOffset, endOffset) {
  * Scan a paragraph's children for split zcite tags and merge them.
  * Returns true if any modifications were made.
  */
-function normalizeParagraphRuns(children) {
+function normalizeParagraphRuns(children, pattern) {
     let modified = false;
     // Use a while loop since indices shift after each merge
     let changed = true;
@@ -171,7 +175,7 @@ function normalizeParagraphRuns(children) {
         changed = false;
         const groups = collectConsecutiveRunGroups(children);
         for (const group of groups) {
-            const split = findSplitZcite(group);
+            const split = findSplitZcite(group, pattern);
             if (split) {
                 mergeRunsInPlace(children, group, split.startOffset, split.endOffset);
                 modified = true;
@@ -186,12 +190,12 @@ function normalizeParagraphRuns(children) {
  * Recursively walk the parsed tree, finding w:p elements and normalizing
  * their runs.
  */
-function walkAndNormalize(nodes) {
+function walkAndNormalize(nodes, pattern) {
     let modified = false;
     for (const node of nodes) {
         if ("w:p" in node) {
             const pChildren = node["w:p"];
-            if (normalizeParagraphRuns(pChildren)) {
+            if (normalizeParagraphRuns(pChildren, pattern)) {
                 modified = true;
             }
         }
@@ -201,7 +205,7 @@ function walkAndNormalize(nodes) {
                 continue;
             const value = node[key];
             if (Array.isArray(value)) {
-                if (walkAndNormalize(value)) {
+                if (walkAndNormalize(value, pattern)) {
                     modified = true;
                 }
             }
@@ -216,17 +220,29 @@ function walkAndNormalize(nodes) {
  * If no split zcites are found, returns the original string unchanged
  * (zero risk of round-trip encoding differences).
  */
-export function normalizeZciteTags(documentXml) {
-    // Quick check: if no zcite at all, skip parsing entirely
-    if (!documentXml.includes("zcite")) {
+function normalizeMarkers(documentXml, pattern, quick) {
+    // Quick check: if the marker cannot be present, skip parsing entirely
+    if (!documentXml.includes(quick)) {
         return documentXml;
     }
     const parser = new XMLParser(PARSER_OPTIONS);
     const parsed = parser.parse(documentXml);
-    const modified = walkAndNormalize(parsed);
+    const modified = walkAndNormalize(parsed, pattern);
     if (!modified) {
         return documentXml; // Return original string, no changes
     }
     const builder = new XMLBuilder(BUILDER_OPTIONS);
     return builder.build(parsed);
 }
+export function normalizeZciteTags(documentXml) {
+    return normalizeMarkers(documentXml, ZCITE_PATTERN, "zcite");
+}
+/**
+ * Merge Pandoc `[@…]` citation markers that Word split across runs, so the whole bracket is one run and
+ * the Pandoc branch can find and replace it. The quick-check requires both `[` and `@` to be present.
+ */
+export function normalizePandocMarkers(documentXml) {
+    if (!documentXml.includes("[") || !documentXml.includes("@"))
+        return documentXml;
+    return normalizeMarkers(documentXml, PANDOC_PATTERN, "[");
+}

package/build/citation-injector/zcite.js

@@ -0,0 +1,36 @@
+import { unescapeXml } from "./xml-utils.js";
+/**
+ * Trova i tag <zcite .../> nel corpo del documento e li traduce in CitationRequest neutre. Lavora sul
+ * testo con l'escape XML (lo stesso in `w:t` di Word e in ODF), così è condiviso tra i formati.
+ *
+ * Tollera `keys="A, B"`: uno spazio di troppo diventerebbe parte della chiave (404 in fetch), quindi le
+ * chiavi vengono ripulite. I valori degli attributi hanno un secondo unescape perché il tag è a sua volta
+ * XML (p.es. un locator `pp. 12 &amp; 15`).
+ */
+export function parseZciteTags(documentXml) {
+    const findRegex = /&lt;zcite\s+[\s\S]*?\/&gt;/g;
+    const requests = [];
+    let findMatch;
+    while ((findMatch = findRegex.exec(documentXml)) !== null) {
+        const fullMatch = findMatch[0];
+        const cleanTag = unescapeXml(fullMatch);
+        const attrRegex = /(\w+)="([^"]*)"/g;
+        const attrs = {};
+        let attrMatch;
+        while ((attrMatch = attrRegex.exec(cleanTag)) !== null) {
+            attrs[attrMatch[1]] = unescapeXml(attrMatch[2]);
+        }
+        const keys = (attrs["keys"] ?? "").split(",").map((k) => k.trim()).filter(Boolean);
+        if (keys.length === 0)
+            continue;
+        requests.push({
+            raw: fullMatch,
+            keys,
+            locator: attrs["locator"] || undefined,
+            prefix: attrs["prefix"] || undefined,
+            suffix: attrs["suffix"] || undefined,
+            num: attrs["num"] || undefined,
+        });
+    }
+    return requests;
+}

package/build/cited-document/create.js

@@ -0,0 +1,40 @@
+import { resolveCitations } from "../citation-injector/pipeline.js";
+import { zoteroItemSource } from "../citation-injector/injector.js";
+import { docxWriter } from "../citation-injector/formats/docx.js";
+import { odtWriter } from "../citation-injector/formats/odt.js";
+import { writeFileAtomic } from "../utils/atomic-write.js";
+import { parseMarkdown } from "./markdown.js";
+import { assignNumbers } from "./number.js";
+import { buildCitedDocument } from "./document.js";
+const WRITERS = { docx: docxWriter, odt: odtWriter };
+/**
+ * Crea un documento (.docx o .odt) da markdown con citazioni Zotero native. Riusa resolveCitations (stessi
+ * controlli ed errori di inject_citations), lo scheletro dello scrittore, le preferenze e la bibliografia.
+ * Non sovrascrive mai un file esistente (writeFileAtomic overwrite:false → EEXIST).
+ */
+export async function createCitedDocument(markdown, outputPath, zoteroApi, libraryType, userId, style, format) {
+    const { blocks, warnings } = parseMarkdown(markdown);
+    // richieste di citazione in ordine di documento
+    const requests = [];
+    for (const b of blocks)
+        for (const i of b.inlines)
+            if (i.kind === "cite")
+                requests.push(i.request);
+    // numerazione per gli stili numerici
+    if (style === "ieee" || style === "vancouver") {
+        const nums = assignNumbers(requests);
+        for (const r of requests)
+            r.num = nums.get(r);
+    }
+    const prepared = await resolveCitations(requests, zoteroItemSource(zoteroApi, libraryType, userId), { libraryType, userId, style });
+    const byRequest = new Map(prepared.map((p) => [p.request, p]));
+    const resolvedBlocks = blocks.map((b) => ({
+        type: b.type,
+        level: b.level,
+        inlines: b.inlines.map((i) => (i.kind === "cite" ? { kind: "cite", prepared: byRequest.get(i.request) } : i)),
+    }));
+    const writer = WRITERS[format] ?? docxWriter;
+    const { buffer, warnings: buildWarnings } = await buildCitedDocument(writer, resolvedBlocks, style, requests.length > 0);
+    await writeFileAtomic(outputPath, buffer, { overwrite: false });
+    return { outputPath, blocks: blocks.length, citations: requests.length, warnings: [...warnings, ...buildWarnings] };
+}

package/build/cited-document/document.js

@@ -0,0 +1,83 @@
+import { escapeXml } from "../citation-injector/xml-utils.js";
+/**
+ * Costruisce il corpo del documento (da zero) a partire dai blocchi del markdown, inserendo le citazioni
+ * native con lo scrittore di formato. Grassetto/corsivo in linea, titoli, elenchi a un livello (resi come
+ * paragrafi con un punto elenco, per restare un pacchetto valido senza numbering/stili aggiuntivi).
+ */
+// ─── docx ───────────────────────────────────────────────────────
+function docxRun(text, { bold, italic }) {
+    const props = [];
+    if (bold)
+        props.push("<w:b/>");
+    if (italic)
+        props.push("<w:i/>");
+    const rPr = props.length ? `<w:rPr>${props.join("")}</w:rPr>` : "";
+    return `<w:r>${rPr}<w:t xml:space="preserve">${escapeXml(text)}</w:t></w:r>`;
+}
+function docxInlines(inlines, writer) {
+    return inlines.map((i) => (i.kind === "text" ? docxRun(i.text, { bold: i.bold, italic: i.italic }) : writer.citationXml(i.prepared))).join("");
+}
+export function renderDocxBlocks(blocks, writer) {
+    return blocks
+        .map((b) => {
+        // titoli con lo stile Heading<n> (outlineLvl): pannello di navigazione e sommario di Word
+        if (b.type === "heading")
+            return `<w:p><w:pPr><w:pStyle w:val="Heading${Math.min(b.level ?? 1, 6)}"/></w:pPr>${docxInlines(b.inlines, writer)}</w:p>`;
+        if (b.type === "list-item")
+            return `<w:p>${docxRun("•\t", {})}${docxInlines(b.inlines, writer)}</w:p>`;
+        return `<w:p>${docxInlines(b.inlines, writer)}</w:p>`;
+    })
+        .join("");
+}
+// ─── odt ────────────────────────────────────────────────────────
+function odtInline(i, writer) {
+    if (i.kind === "cite")
+        return writer.citationXml(i.prepared);
+    const style = i.bold ? ' text:style-name="T_Bold"' : i.italic ? ' text:style-name="T_Italic"' : "";
+    return `<text:span${style}>${escapeXml(i.text)}</text:span>`;
+}
+export function renderOdtBlocks(blocks, writer) {
+    return blocks
+        .map((b) => {
+        const inner = b.inlines.map((i) => odtInline(i, writer)).join("");
+        if (b.type === "heading") {
+            const level = Math.min(b.level ?? 1, 6);
+            return `<text:h text:style-name="Heading_20_${level}" text:outline-level="${level}">${inner}</text:h>`;
+        }
+        if (b.type === "list-item")
+            return `<text:p>• ${inner}</text:p>`;
+        return `<text:p>${inner}</text:p>`;
+    })
+        .join("");
+}
+/**
+ * Assembla il documento: scheletro dello scrittore, corpo dai blocchi, bibliografia (solo se ci sono
+ * citazioni) e preferenze del documento. Non scrive su disco. `hasCitations` decide bibliografia/preferenze.
+ */
+export async function buildCitedDocument(writer, blocks, style, hasCitations) {
+    if (!writer.skeleton)
+        throw new Error(`format ${writer.format} has no skeleton`);
+    const zip = await writer.skeleton();
+    const rendered = writer.format === "odt" ? renderOdtBlocks(blocks, writer) : renderDocxBlocks(blocks, writer);
+    let body = await zip.file(writer.bodyPart).async("string");
+    if (writer.format === "odt") {
+        body = body.replace("</office:text>", `${rendered}</office:text>`);
+    }
+    else {
+        body = body.includes("<w:sectPr") ? body.replace("<w:sectPr", `${rendered}<w:sectPr`) : body.replace("</w:body>", `${rendered}</w:body>`);
+    }
+    const warnings = [];
+    if (hasCitations) {
+        body = writer.appendBibliography(body);
+        zip.file(writer.bodyPart, body);
+        const prefs = await writer.writePrefs(zip, style);
+        warnings.push(...writer.prefsWarnings(prefs));
+    }
+    else {
+        zip.file(writer.bodyPart, body);
+    }
+    if (writer.finalize)
+        await writer.finalize(zip);
+    const buffer = (await zip.generateAsync({ type: "nodebuffer", ...writer.generateOptions }));
+    return { buffer, warnings };
+}

package/build/cited-document/markdown.js

@@ -0,0 +1,104 @@
+import { parseCites } from "./pandoc-cite.js";
+/**
+ * Sottoinsieme di markdown sostenuto da create_cited_document: titoli (#…), paragrafi, grassetto (**…**),
+ * corsivo (*…* o _…_), elenchi a un livello (- o *). Tutto il resto diventa testo, con un avviso. Le
+ * citazioni in stile pandoc nel testo vengono riconosciute da pandoc-cite.
+ */
+/** Grassetto/corsivo, poi le citazioni dentro ciascun pezzo di testo (che ne eredita lo stile). */
+function parseInlines(text, onWarning) {
+    const segments = [];
+    const re = /\*\*([^*]+)\*\*|\*([^*]+)\*|_([^_]+)_/g;
+    let last = 0;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        if (m.index > last)
+            segments.push({ text: text.slice(last, m.index) });
+        if (m[1] !== undefined)
+            segments.push({ text: m[1], bold: true });
+        else if (m[2] !== undefined)
+            segments.push({ text: m[2], italic: true });
+        else
+            segments.push({ text: m[3], italic: true });
+        last = m.index + m[0].length;
+    }
+    if (last < text.length)
+        segments.push({ text: text.slice(last) });
+    const out = [];
+    for (const s of segments) {
+        for (const inl of parseCites(s.text, onWarning)) {
+            if (inl.kind === "text") {
+                if (inl.text)
+                    out.push({ kind: "text", text: inl.text, bold: s.bold, italic: s.italic });
+            }
+            else {
+                out.push(inl);
+            }
+        }
+    }
+    return out;
+}
+export function parseMarkdown(md) {
+    const blocks = [];
+    const warnings = new Set();
+    const warn = (m) => warnings.add(m);
+    const lines = md.replace(/\r\n?/g, "\n").split("\n");
+    let paragraph = [];
+    const flush = () => {
+        if (paragraph.length) {
+            blocks.push({ type: "paragraph", inlines: parseInlines(paragraph.join(" "), warn) });
+            paragraph = [];
+        }
+    };
+    let inFence = false;
+    for (const line of lines) {
+        if (/^\s*```/.test(line)) {
+            // blocco di codice: reso come testo
+            warnings.add("code blocks are rendered as plain text");
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence) {
+            flush();
+            blocks.push({ type: "paragraph", inlines: [{ kind: "text", text: line }] });
+            continue;
+        }
+        if (line.trim() === "") {
+            flush();
+            continue;
+        }
+        const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+        if (heading) {
+            flush();
+            if (heading[1].length > 6)
+                warnings.add("heading levels deeper than 6 are rendered as level 6");
+            blocks.push({ type: "heading", level: Math.min(heading[1].length, 6), inlines: parseInlines(heading[2].trim(), warn) });
+            continue;
+        }
+        const item = /^(\s*)[-*+]\s+(.*)$/.exec(line);
+        if (item) {
+            flush();
+            if (item[1].length > 0)
+                warnings.add("nested lists are flattened to one level");
+            blocks.push({ type: "list-item", level: 1, inlines: parseInlines(item[2].trim(), warn) });
+            continue;
+        }
+        const ordered = /^\s*\d+\.\s+(.*)$/.exec(line);
+        if (ordered) {
+            flush();
+            warnings.add("ordered lists are rendered as bullet lists");
+            blocks.push({ type: "list-item", level: 1, inlines: parseInlines(ordered[1].trim(), warn) });
+            continue;
+        }
+        if (/^\s*>/.test(line))
+            warnings.add("block quotes are rendered as plain text");
+        if (/^\s*\|/.test(line))
+            warnings.add("tables are rendered as plain text");
+        if (/!\[[^\]]*\]\([^)]*\)/.test(line))
+            warnings.add("images are dropped; their alt text is kept");
+        paragraph.push(line.replace(/^\s*>\s?/, "").replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1"));
+    }
+    flush();
+    if (blocks.length === 0)
+        warnings.add("the Markdown is empty; an empty document was created");
+    return { blocks, warnings: [...warnings] };
+}

package/build/cited-document/model.js

@@ -0,0 +1 @@
+export {};

package/build/cited-document/number.js

@@ -0,0 +1,17 @@
+/**
+ * Numera le citazioni per gli stili numerici (ieee/vancouver): ogni chiave prende il numero della sua
+ * prima comparsa nel testo; una chiave ripetuta mantiene lo stesso numero. Per una citazione con più voci
+ * il `num` è "n1,n2" nell'ordine delle chiavi. Restituisce la stringa `num` per ciascuna richiesta, così
+ * il testo provvisorio ([1], [1,2]) combacia con quello che Zotero scriverà al Refresh.
+ */
+export function assignNumbers(requests) {
+    const order = new Map();
+    for (const r of requests)
+        for (const k of r.keys)
+            if (!order.has(k))
+                order.set(k, order.size + 1);
+    const out = new Map();
+    for (const r of requests)
+        out.set(r, r.keys.map((k) => order.get(k)).join(","));
+    return out;
+}

package/build/cited-document/pandoc-cite.js

@@ -0,0 +1,74 @@
+import { ZOTERO_KEY } from "../utils/zotero-keys.js";
+/**
+ * Riconosce le citazioni in stile pandoc dentro un testo e lo spezza in pezzi di testo e citazioni:
+ *   [@K]              una citazione
+ *   [@K1; @K2]        una citazione con due voci
+ *   [see @K, p. 12]   prefisso "see", locator "p. 12"
+ *   -@K   @K          soppressione dell'autore / citazione in linea
+ * Le chiavi non vengono validate qui: resolveCitations rifiuta quelle non valide con lo stesso errore di
+ * inject_citations.
+ */
+const LOCATOR_RE = /^(?:p{1,2}\.|pp?\b|pages?\b|chap\.?|ch\.|sec\.?|§|fig\.?|no\.?|vol\.?|art\.?)/i;
+/** Una voce dentro le parentesi: `-?@KEY` con eventuale testo prima (prefix) e dopo (locator o suffix). */
+function parseBracket(inner) {
+    const parts = inner.split(";");
+    const keys = [];
+    let prefix;
+    let suffix;
+    let locator;
+    let suppressAuthor = false;
+    for (const part of parts) {
+        const mm = /(-?)@([A-Za-z0-9]+)/.exec(part);
+        if (!mm)
+            continue;
+        keys.push(mm[2]);
+        if (parts.length === 1) {
+            const before = part.slice(0, mm.index).trim();
+            if (before)
+                prefix = before;
+            suppressAuthor = mm[1] === "-";
+            const after = part.slice(mm.index + mm[0].length).replace(/^,\s*/, "").trim();
+            if (after) {
+                if (LOCATOR_RE.test(after))
+                    locator = after;
+                else
+                    suffix = after;
+            }
+        }
+    }
+    if (keys.length === 0)
+        return null;
+    return { keys, prefix, suffix, locator, suppressAuthor, raw: `[${inner}]` };
+}
+export function parseCites(text, onWarning = () => { }) {
+    const out = [];
+    let last = 0;
+    // una citazione tra parentesi che contiene @, oppure una citazione in linea -@K / @K. Come pandoc, una
+    // citazione in linea comincia solo a inizio testo o dopo un carattere non alfanumerico: così "a@b.com"
+    // (una email) non viene scambiato per la citazione "@b".
+    const re = /\[([^\]]*@[^\]]*)\]|(?<![A-Za-z0-9])(-?)@([A-Za-z0-9]+)/g;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        if (m.index > last)
+            out.push({ kind: "text", text: text.slice(last, m.index) });
+        if (m[1] !== undefined) {
+            const req = parseBracket(m[1]);
+            if (req)
+                out.push({ kind: "cite", request: req });
+            else
+                out.push({ kind: "text", text: m[0] });
+        }
+        else if (ZOTERO_KEY.test(m[3])) {
+            out.push({ kind: "cite", request: { keys: [m[3]], suppressAuthor: m[2] === "-", raw: m[0] } });
+        }
+        else {
+            // una @parola in linea che non è una chiave Zotero ben formata resta testo, con un avviso (mai un errore)
+            out.push({ kind: "text", text: m[0] });
+            onWarning(`"${m[0]}" is not a well-formed Zotero item key (8 characters from 23456789ABCDEFGHIJKLMNPQRSTUVWXYZ); kept as text`);
+        }
+        last = m.index + m[0].length;
+    }
+    if (last < text.length)
+        out.push({ kind: "text", text: text.slice(last) });
+    return out;
+}