@markup-carve/pandoc-carve 0.1.0 → 0.1.2

package/README.md

@@ -144,7 +144,7 @@ node -e "import('@markup-carve/pandoc-carve').then(m => process.stdout.write(m.c
 | `::: \|` line blocks (verse) | LineBlock, one entry per line, an empty entry per stanza break |
 | Ordered markers `1.` / `1)` / `a.` / `iv.` | OrderedList with the matching style and delimiter. Pandoc's example list `(@)` and its `(1)` marker have no Carve form and are reported |
 | A no-break space the parser resolved (`\ `) | U+00A0 (the engines publish a private-use sentinel for it) |
-| A reference link or image nothing defines (`[r][]`) | the literal source as text, which is what Carve renders, plus a warning naming the label - as an unresolved footnote already did |
+| A reference link, image or footnote nothing defines (`[r][]`, `[^f]`) | the literal source as text, which is what Carve renders, plus a warning naming the label |
 
 The complete node-by-node contract lives in the test goldens. Worked
 input/output pairs in both directions - including how interactive constructs
@@ -204,13 +204,15 @@ a processor with neither extension enabled would render.
   per-column alignment, a foot, and a body group's intermediate header rows.
   It converts back to the pandoc table by default; `listTable: false` returns
   the degraded div instead.
-- A pandoc table with ROW-HEAD COLUMNS takes the same route on the source path,
-  because `header-cols=N` is exactly pandoc's `RowHeadColumns` and a pipe table
-  cannot say it. Only when every body group agrees on the count: `header-cols`
-  is one number for the whole table, so a table whose bodies differ keeps the
-  pipe form rather than come back with row headers ADDED to the rows that had
-  none. The AST path keeps the plain table, where `rowGroups` carries the whole
-  partition and nothing has to be traded for it.
+- A pandoc table with ROW-HEAD COLUMNS stays a pipe table. `RowHeadColumns` says
+  the leading N cells of every body row are row headers, and a pipe table says
+  that per cell: `|= Mercury | 4,879.4 |` is a `<th scope="row">`. Marking the
+  cells needs no extension and round-trips, because the export direction derives
+  the count back from the leading run.
+- On the way out, one TableBody per RUN of body rows that agree on that leading
+  run. Pandoc's `RowHeadColumns` is a count on a body and a `Table` holds a list
+  of bodies, so rows that disagree are simply different bodies. A table whose
+  body rows all agree emits exactly one body, as before.
 - Pandoc `SmallCaps` has no Carve node and is not getting one: it imports as a
   `[text]{.smallcaps}` span, with a warning saying so. The span is not a dead
   end, though - the export direction reads that class back as `SmallCaps`, the
@@ -266,9 +268,9 @@ a processor with neither extension enabled would render.
   rows or row-head columns) survives into the exchange AST, so
   `pandocToCarveAst` hands it on whole - but PART 9 section 16's pipe table
   spells only a leading run of header rows, so `pandocToCarve` flattens the
-  rest into body rows and says so. Row-head columns are the exception - they
-  have a list-table spelling and take it (above). Use the AST entry point when
-  a foot or a second body group has to survive.
+  rest into body rows and says so. Row-head columns are the exception - the pipe
+  table marks them on the cells (above). Use the AST entry point when a foot or
+  a second body group has to survive.
 - A marker on a HEAD cell (`|=> Name |`) is the column's alignment and becomes
   pandoc's `ColSpec`; a marker on a BODY cell (`|> 12 |`) aligns that cell alone
   and becomes the cell's own `Alignment`. The two are not interchangeable: a

package/dist/convert.js

@@ -389,6 +389,24 @@ function kids(ctx, n) {
  * Returns null when the node is not an unresolved reference, so the caller
  * converts it normally.
  */
+/**
+ * The heading a COLLAPSED reference reaches, or null.
+ *
+ * `[Some Heading][]` with no definition anywhere links to the heading whose
+ * RENDERED text matches, case-insensitively - so `[plain one][]` reaches
+ * `# Plain One`. The engine resolves this after the parse, which is why the
+ * node still carries an empty `href` here.
+ *
+ * Only the collapsed form. `[text][Some Heading]` does not reach a heading,
+ * measured on the engine: it renders as its literal source. Detected on
+ * `rawRef` ending in `][]`, which is what makes the form collapsed.
+ */
+function collapsedHeadingRef(ctx, n) {
+    if (!String(n.rawRef ?? '').endsWith('][]'))
+        return undefined;
+    const text = plainText(n.children ?? []).trim().toLowerCase();
+    return text ? ctx.headingIdByText.get(text) : undefined;
+}
 function unresolvedReference(ctx, n, kind) {
     if (n.ref === undefined)
         return null;
@@ -453,6 +471,12 @@ function inline(ctx, n) {
                 : text;
         }
         case 'link': {
+            // A collapsed reference to a heading is RESOLVED, not missing, so
+            // it is tried before the missing-definition path reports one.
+            const heading = String(n.href ?? '') === '' ? collapsedHeadingRef(ctx, n) : undefined;
+            if (heading !== undefined) {
+                return [P.Link(toAttr(n.attrs), kids(ctx, n), ['#' + heading, ''])];
+            }
             const unresolved = unresolvedReference(ctx, n, 'link');
             if (unresolved)
                 return unresolved;
@@ -466,7 +490,18 @@ function inline(ctx, n) {
         case 'autolink': {
             const href = String(n.href ?? '');
             const cls = href.startsWith('mailto:') ? 'email' : 'uri';
-            return [P.Link(P.attr(undefined, [cls]), [P.Str(String(n.text ?? href))], [href, ''])];
+            // An autolink takes a trailing attribute like any other inline
+            // (`<https://example.com>{.ext}`), and pandoc's Link has the slot
+            // for it, but only the synthesized `uri`/`email` class was written -
+            // so the author's id, classes and key-values left the document with
+            // nothing reported. They join the synthesized class rather than
+            // replace it: the class says what KIND of link this is, and a
+            // consumer keying on it should not lose that because the author
+            // added one of their own.
+            const [id, classes, kvs] = toAttr(n.attrs);
+            return [
+                P.Link([id, [cls, ...classes], kvs], [P.Str(String(n.text ?? href))], [href, '']),
+            ];
         }
         case 'image': {
             const unresolved = unresolvedReference(ctx, n, 'image');
@@ -506,10 +541,15 @@ function inline(ctx, n) {
                 ctx.crossrefTargets.get(target.toLowerCase()) ??
                 findCaseInsensitive(ctx.crossrefTargets, target);
             if (found) {
+                // A caption target cannot come back as a crossref (see
+                // `captionTargets`), so it goes out as a plain link.
+                const classes = ctx.captionTargets.has(target.toLowerCase())
+                    ? []
+                    : ['crossref'];
                 ctx.inCrossref = true;
                 try {
                     return [
-                        P.Link(P.attr(undefined, ['crossref']), inlines(ctx, found), [
+                        P.Link(P.attr(undefined, classes), inlines(ctx, found), [
                             `#${target}`,
                             '',
                         ]),
@@ -540,8 +580,27 @@ function inline(ctx, n) {
             const id = String(n.id ?? '');
             const def = ctx.footnoteDefs[id];
             if (!def) {
-                warn(ctx, `footnote: missing definition for [^${id}]`);
-                return [P.Superscript([P.Str(id)])];
+                // THE LITERAL SOURCE, not a superscript.
+                //
+                // Carve renders an unresolved `[^f]` as the four characters the
+                // author typed. This used to emit `Superscript [Str "f"]`, which
+                // is a construct the document does not contain: the reader saw a
+                // raised `f` where the source says `[^f]`, and the round trip
+                // came back spelling it `{^f^}` - a superscript in Carve too, so
+                // the loss was permanent rather than merely cosmetic.
+                //
+                // The sibling path has been right all along. An unresolved link
+                // or image reference returns its `rawRef` as text for exactly
+                // this reason (see `unresolvedReference`), and there was no
+                // reason for a footnote to be the one construct that invented a
+                // node instead.
+                //
+                // A footnote reference carries no `rawRef`, so the source is
+                // rebuilt from the id. That is faithful even where the author
+                // wrote a trailing attribute: the engine drops the attribute
+                // along with the reference, so `[^a]{.ref}` renders `[^a]` too.
+                warn(ctx, `footnote: missing definition for [^${id}] - emitting the literal source`);
+                return textInlines(`[^${id}]`);
             }
             const note = P.Note(blocks(ctx, def));
             ctx.noteCount++;
@@ -752,6 +811,15 @@ function block(ctx, n) {
     // A block-attribute line can attach attrs to ANY block. Pandoc's Para,
     // BlockQuote, lists etc. have no Attr slot - preserve via a Div wrapper.
     const a = n.attrs;
+    // NOTHING IS NOT WRAPPED. A node that renders nothing where it sits - a
+    // link reference definition, an abbreviation definition - converts to no
+    // blocks, and wrapping that in a Div to carry its attrs put a visible empty
+    // element into every writer's output where Carve renders none:
+    // `[a]: /u {.c}` came back as `<div class="c"></div>`. The attrs are not
+    // lost by skipping it; they are already on whatever the definition feeds,
+    // which is where they render.
+    if (!result.length)
+        return result;
     if (!ATTR_CARRYING.has(n.type) && hasAttrs(a)) {
         // In roundtrip mode the carve-block marker lets the reverse direction
         // restore the attrs onto the inner block instead of keeping a wrapper.
@@ -1066,7 +1134,26 @@ function table(ctx, n, caption, shortCaption = null) {
     // that was never in the source.
     const firstRowIsHead = headCount > 0;
     const firstRow = rows[0] ?? [];
-    const colAligns = firstRow.map((c) => (firstRowIsHead ? ALIGN[c.align ?? ''] ?? 'AlignDefault' : 'AlignDefault'));
+    // THE COLUMN COUNT IS THE WIDEST ROW, NOT THE FIRST. A Carve table is
+    // RAGGED - PART 9 §16 keeps each row's own cell count - while a pandoc
+    // table is rectangular and its ColSpec list DEFINES the width. Sizing the
+    // list from the first row therefore emitted a table whose later rows have
+    // cells past the last column, which is not a shape pandoc's own readers
+    // produce: `| ~x~ |` above `| a | b |` declared one column, and `b` was
+    // dropped on the way back with nothing reported. The alignment of a column
+    // no first-row cell covers is simply unset.
+    const width = Math.max(0, ...rows.map((row) => row.length));
+    if (rows.some((row) => row.length < width)) {
+        // Padding is the conversion, not a defect - but it is a change the
+        // author can see, so it is reported like every other one.
+        warn(ctx, `table: ${rows.filter((row) => row.length < width).length} row(s) shorter than the `
+            + `widest (${width} cells) are padded with empty cells - a pandoc table is `
+            + 'rectangular, and PART 9 §16 keeps each row\'s own cell count');
+    }
+    const colAligns = Array.from({ length: width }, (_, c) => {
+        const cell = firstRow[c];
+        return firstRowIsHead && cell ? ALIGN[cell.align ?? ''] ?? 'AlignDefault' : 'AlignDefault';
+    });
     const origin = rows.map(() => []);
     const emitted = rows.map((row) => row.map(() => null));
     for (let r = 0; r < rows.length; r++) {
@@ -1173,8 +1260,50 @@ function table(ctx, n, caption, shortCaption = null) {
         footRows = toRows(at, at + groups.footRows);
     }
     else {
-        // The implicit structure: everything after the head is one body.
-        bodies = [{ bodyRows: toRows(headCount, rows.length) }];
+        // ROW HEADERS ARE DERIVED WHEN NOTHING DECLARED THEM. A body row may
+        // open with header cells (`|= Mercury | 4,879.4 |`), which the engine
+        // renders as `<th scope="row">`. Pandoc says the same thing with
+        // `RowHeadColumns`, a COUNT on the body - and the count was only ever
+        // read from an explicit `rowGroups`, so a table that simply marked its
+        // first cells came out as ordinary `<td>` and lost the row headers.
+        //
+        // ONE BODY PER RUN OF ROWS THAT AGREE, not one body for the table.
+        //
+        // This used to take the MINIMUM leading run across every body row,
+        // because one `RowHeadColumns` is one number. A body whose rows disagree
+        // therefore lost every row header above that minimum, and lost it
+        // SILENTLY - the cells simply came out `<td>`. Corpus 354-2 is the
+        // smallest case: a plain row followed by a row-header row takes the
+        // minimum 0, so `<th scope="row">b c</th>` came back `<td>b c</td>`.
+        //
+        // Pandoc's own model has the slot for this. A `Table` holds a LIST of
+        // bodies and each carries its own `RowHeadColumns`, so consecutive rows
+        // that agree become one body and a change starts the next one. Nothing
+        // is invented: a document with a single run still emits exactly one
+        // body, which is what every table that agreed already produced.
+        bodies = [];
+        const leadOf = (row) => {
+            let n = 0;
+            while (n < row.length && row[n].header === true)
+                n++;
+            return Math.min(n, width);
+        };
+        let at = headCount;
+        while (at < rows.length) {
+            const lead = leadOf(rows[at]);
+            let to = at + 1;
+            while (to < rows.length && leadOf(rows[to]) === lead)
+                to++;
+            const group = { bodyRows: toRows(at, to) };
+            if (lead > 0)
+                group.rowHeadColumns = lead;
+            bodies.push(group);
+            at = to;
+        }
+        // A table with a head and no body rows at all still needs a body,
+        // because that is the shape pandoc's own readers produce.
+        if (!bodies.length)
+            bodies = [{ bodyRows: [] }];
     }
     return P.Table(toAttr(n.attrs), caption, colAligns, toRows(0, headCount), bodies, footRows, shortCaption);
 }
@@ -1652,6 +1781,8 @@ export function convert(ast, options = {}) {
         warnings: [],
         footnoteDefs,
         crossrefTargets: new Map(),
+        headingIdByText: new Map(),
+        captionTargets: new Set(),
         tight: false,
         inCrossref: false,
         captionCounts: new Map(),
@@ -1726,6 +1857,10 @@ function collectCrossrefTargets(ctx, nodes, captionCounts, inPanel = false) {
             const id = a.id ?? slugify(plainText(children));
             if (id && !ctx.crossrefTargets.has(id))
                 ctx.crossrefTargets.set(id, children);
+            const text = plainText(children).trim().toLowerCase();
+            // First heading wins, the same way the id map resolves a duplicate.
+            if (id && text && !ctx.headingIdByText.has(text))
+                ctx.headingIdByText.set(text, id);
         }
         else if (!inPanel && (n.type === 'figure' || n.type === 'table')) {
             // Every figure counts, whatever it wraps. A quote used to be
@@ -1740,6 +1875,7 @@ function collectCrossrefTargets(ctx, nodes, captionCounts, inPanel = false) {
                 const a = (n.attrs ?? {});
                 if (a.id && !ctx.crossrefTargets.has(a.id)) {
                     ctx.crossrefTargets.set(a.id, [{ type: 'text', value: `${label} ${next}` }]);
+                    ctx.captionTargets.add(a.id.toLowerCase());
                 }
             }
         }
@@ -1784,6 +1920,7 @@ function figureGroupTargets(ctx, n, captionCounts, inPanel) {
         const a = (n.attrs ?? {});
         if (a.id && !ctx.crossrefTargets.has(a.id)) {
             ctx.crossrefTargets.set(a.id, [{ type: 'text', value: resolved }]);
+            ctx.captionTargets.add(a.id.toLowerCase());
         }
     }
     let panelIndex = 0;

package/dist/reverse.js

@@ -270,7 +270,16 @@ function link(ctx, c) {
     const [a, xs, [href, title]] = c;
     const [, classes] = a;
     if (classes.includes('uri') || classes.includes('email')) {
-        return [{ type: 'autolink', href, text: stringify(xs) }];
+        const node = { type: 'autolink', href, text: stringify(xs) };
+        // `uri`/`email` is the class the forward direction SYNTHESIZES to say
+        // what kind of link this is, so it is not the author's and does not
+        // come back. Anything else on the Attr is the author's - an autolink
+        // takes a trailing attribute like any other inline - and used to be
+        // dropped here without a word.
+        const rest = fromAttr([a[0], classes.filter((c) => c !== 'uri' && c !== 'email'), a[2]]);
+        if (rest)
+            node.attrs = rest;
+        return [node];
     }
     if (classes.includes('crossref')) {
         return [{ type: 'heading_ref', target: href.replace(/^#/, '') }];
@@ -746,12 +755,25 @@ function table(ctx, c, captionOverride, shortCaptionOverride = null) {
     // leading run.
     const allRaw = [...headRaw];
     const isHeaderRow = headRaw.map(() => true);
+    // How many LEADING cells of each row are row headers.
+    //
+    // This is pandoc's `RowHeadColumns`, and the pipe table spells it directly:
+    // a body row opening `|= Mercury |` is a row header, `<th scope="row">`,
+    // measured on the engine. It used to be treated as unspellable, so such a
+    // table left the pipe form for a `::: list-table {header-cols=N}` - more
+    // markup, an extension the reader has to enable, and one number for the
+    // whole table where the cells can each say it. Marking the cells keeps the
+    // readable form and round-trips, because the forward direction derives the
+    // count back from exactly this run.
+    const rowHeadCols = headRaw.map(() => 0);
     const groupBodies = [];
     for (const body of tbodies) {
         const bodyHead = body[2];
         const bodyRows = body[3];
         allRaw.push(...bodyHead, ...bodyRows);
         isHeaderRow.push(...bodyHead.map(() => true), ...bodyRows.map(() => false));
+        const heads = typeof body[1] === 'number' && body[1] > 0 ? body[1] : 0;
+        rowHeadCols.push(...bodyHead.map(() => 0), ...bodyRows.map(() => heads));
         const group = { headRows: bodyHead.length, bodyRows: bodyRows.length };
         const rowHeadColumns = body[1];
         if (typeof rowHeadColumns === 'number' && rowHeadColumns > 0) {
@@ -764,6 +786,7 @@ function table(ctx, c, captionOverride, shortCaptionOverride = null) {
     }
     allRaw.push(...footRaw);
     isHeaderRow.push(...footRaw.map(() => false));
+    rowHeadCols.push(...footRaw.map(() => 0));
     // Occupancy grid: pending[r][c] = continuation marker owed at that position.
     // Decided BEFORE the grid walk: the pipe path flattens as it goes and warns
     // while doing it, and that warning is wrong for a table that is about to be
@@ -772,28 +795,12 @@ function table(ctx, c, captionOverride, shortCaptionOverride = null) {
         const cellBlocks = raw[4];
         return Array.isArray(cellBlocks) && !isInlineShaped(cellBlocks);
     }));
-    // ROW-HEAD COLUMNS are the second reason to leave the pipe form, and the
-    // only one that is a straight gain: `header-cols=N` (extensions.md §5.1) IS
-    // pandoc's `RowHeadColumns`, so the list-table spells exactly what the pipe
-    // table drops. The other things `rowGroups` can carry - a foot, a second
-    // body, a body's intermediate header rows - have no list-table spelling
-    // either, so a table that has only those keeps the readable pipe form and
-    // `reportUnspellableGroups` names the loss instead.
-    //
-    // ONLY WHEN THE BODIES AGREE. `header-cols` is one number for the whole
-    // table, so a table whose bodies differ - and `1` beside a plain `0` is the
-    // ordinary way they differ - would come back with row headers ADDED to the
-    // bodies that had none. Widening the markup is worse than the flattening it
-    // was meant to avoid: dropping a row header renders a `td` where a `th`
-    // belonged, while inventing one asserts a heading the source never made.
-    // Such a table keeps the pipe form, where the loss is only a loss and is
-    // reported. A table forced onto the list-table path by its block cells has
-    // no such choice, and `listTable` reports the widening there instead.
-    const rowHeadCounts = new Set(groupBodies.map((b) => b.rowHeadColumns ?? 0));
-    const hasRowHeadColumns = ctx.target === 'source'
-        && rowHeadCounts.size === 1
-        && (groupBodies[0]?.rowHeadColumns ?? 0) > 0;
-    const useListTable = hasBlockCells || hasRowHeadColumns;
+    // Row-head columns no longer send a table to the list-table form: the pipe
+    // table marks those cells directly (see `rowHeadCols` above), which is
+    // readable, needs no extension, and round-trips. Block cells remain the one
+    // reason to leave, because a Carve `table_cell` holds INLINES and there is
+    // no pipe form for a cell holding blocks at all.
+    const useListTable = hasBlockCells;
     const pending = allRaw.map(() => Array(nCols));
     const rows = [];
     // The pandoc blocks that sat at each grid position, kept alongside the
@@ -801,29 +808,35 @@ function table(ctx, c, captionOverride, shortCaptionOverride = null) {
     // as blocks without walking the occupancy grid a second time.
     const cellBlocksAt = allRaw.map(() => []);
     for (let r = 0; r < allRaw.length; r++) {
-        const isHeader = isHeaderRow[r] === true;
+        // A row is header cells throughout when it is a header ROW, and for its
+        // leading run when the body declared row-head columns.
+        const headTo = isHeaderRow[r] === true ? nCols : (rowHeadCols[r] ?? 0);
         const cells = [];
         const rawCells = allRaw[r][1];
         let rawIdx = 0;
         for (let col = 0; col < nCols; col++) {
             if (pending[r][col]) {
-                cells.push({ type: 'table_cell', header: isHeader, children: [], span: 'rowspan' });
+                cells.push({ type: 'table_cell', header: col < headTo, children: [], span: 'rowspan' });
                 continue;
             }
             const raw = rawCells[rawIdx++];
             if (!raw) {
-                cells.push({ type: 'table_cell', header: isHeader, children: [] });
+                cells.push({ type: 'table_cell', header: col < headTo, children: [] });
                 continue;
             }
             const [cellAttr, cellAlign, rowSpan, colSpan, cellBlocks] = raw;
             cellBlocksAt[r][col] = cellBlocks;
             const cell = {
                 type: 'table_cell',
-                header: isHeader,
+                header: col < headTo,
                 children: useListTable ? [] : cellInlines(ctx, cellBlocks),
             };
+            // The column's alignment is carried by a HEADER ROW's cells, or by
+            // every cell when there is no header row. A row-head cell is not a
+            // header row, so it does not carry the column - its own marker
+            // aligns itself alone, which is what the engine does.
             const align = ALIGN_BACK[cellAlign.t]
-                ?? (isHeader || !hasHeaderRow ? colAligns[col] : '');
+                ?? (isHeaderRow[r] === true || !hasHeaderRow ? colAligns[col] : '');
             if (align)
                 cell.align = align;
             const cellAttrs = fromAttr(cellAttr);
@@ -831,7 +844,7 @@ function table(ctx, c, captionOverride, shortCaptionOverride = null) {
                 cell.attrs = cellAttrs;
             cells.push(cell);
             for (let j = 1; j < colSpan && col + j < nCols; j++) {
-                cells.push({ type: 'table_cell', header: isHeader, children: [], span: 'colspan' });
+                cells.push({ type: 'table_cell', header: col + j < headTo, children: [], span: 'colspan' });
             }
             // A 2D block gets a rowspan continuation at EVERY covered column
             // of the lower rows - that is how Carve's grid expresses it.
@@ -1222,6 +1235,48 @@ function figure(ctx, c) {
         out.push({ type: 'paragraph', children: caption });
     return out;
 }
+/**
+ * The inverse of convert.ts's `citationDefinition`: citeproc's own bibliography
+ * entry, `Div ("ref-<key>", ["csl-entry"], ...)`, back to a Carve `[@key]:`
+ * definition line.
+ *
+ * The forward direction has written this shape since the arm was added, but
+ * nothing read it, so a bibliography line went out as a definition and came
+ * back as a fenced div carrying an id and a class - the entry rendered in the
+ * body of the document, and the key that binds it to its citations survived
+ * only as the text of an id. That asymmetry was invisible while the engine
+ * still handed a definition line to the bridge as a paragraph holding a
+ * citation group; it surfaced the moment carve-js started emitting a real
+ * `citation_definition` node for one.
+ *
+ * Only the exact shape the forward direction produces converts back: a
+ * `ref-`-prefixed id, `csl-entry` first among the classes, and a body that is
+ * empty or one `Para`. A `--citeproc` bibliography whose entry runs to several
+ * blocks has no Carve definition to be, so it stays the div it is rather than
+ * being flattened into one.
+ */
+function citationDefinition(ctx, id, classes, kvs, body) {
+    if (classes[0] !== 'csl-entry')
+        return undefined;
+    if (!id.startsWith('ref-') || id === 'ref-')
+        return undefined;
+    if (body.length > 1)
+        return undefined;
+    const only = body[0];
+    if (only && only.t !== 'Para')
+        return undefined;
+    const node = {
+        type: 'citation_definition',
+        key: id.slice('ref-'.length),
+        children: only ? inlines(ctx, only.c) : [],
+    };
+    // The id is the key's carrier here, so it is spent; anything else the Attr
+    // holds is the author's and rides back as the definition's attributes.
+    const attrs = fromAttr(['', classes.slice(1), kvs]);
+    if (attrs)
+        node.attrs = attrs;
+    return node;
+}
 function div(ctx, c) {
     const [a, body] = c;
     const [id, classes, rawKvs] = a;
@@ -1243,6 +1298,9 @@ function div(ctx, c) {
             return [child];
         }
     }
+    const definition = citationDefinition(ctx, id, classes, kvs, body);
+    if (definition)
+        return [definition];
     let kind;
     let rest = [];
     if (classes.includes('admonition')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markup-carve/pandoc-carve",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Carve to Pandoc bridge: convert Carve markup to Pandoc's JSON AST and reach every pandoc output format (LaTeX, Typst, DOCX, PDF, ...)",
   "keywords": [
     "carve",
@@ -49,7 +49,7 @@
     "source": "https://github.com/markup-carve/pandoc-carve"
   },
   "dependencies": {
-    "@markup-carve/carve": "git+https://github.com/markup-carve/carve-js.git#db224f30d10a3c2d7a192b0e60de66563404b7e5"
+    "@markup-carve/carve": "^0.1.4"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",