@kevinpeckham/barkdown 0.1.0

package/dist/serialize-footnote-defs.js

@@ -0,0 +1,106 @@
+/**
+ * Post-processing pass for footnote definitions in serialized markdown.
+ *
+ * marked-footnote renders nothing for a definition that is never
+ * referenced outside the footnote section itself, so emitting such a
+ * definition would vanish one trip late. This pass canonicalizes the
+ * output by dropping unreferenced definitions up front. Pure
+ * string → string; no DOM involvement.
+ */
+/** A footnote definition line: `[^label]: …` at column 0. */
+const DEF_LINE = /^\[\^([A-Za-z0-9_-]+)\]:/;
+/** A fenced-code fence line (up to 3 leading spaces, ``` or ~~~). */
+const FENCE_LINE = /^ {0,3}(?:`{3,}|~{3,})/;
+/**
+ * Drop footnote definitions that nothing references. Dropping a
+ * definition can orphan another (its content held the only ref) —
+ * iterate to a fixpoint. Bounded by the number of definitions.
+ */
+export function dropUnreferencedFootnoteDefs(markdown) {
+    let current = markdown;
+    for (let pass = 0; pass < 50; pass++) {
+        if (!/^\[\^[A-Za-z0-9_-]+\]:/m.test(current))
+            return current;
+        const { text, dropped } = dropDefsOnce(current);
+        current = text;
+        if (!dropped)
+            return current;
+    }
+    return current;
+}
+/** One sweep: remove every currently-unreferenced definition. */
+function dropDefsOnce(markdown) {
+    const lines = markdown.split("\n");
+    const inCode = codeLineMask(lines);
+    const kept = [];
+    let dropped = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        const match = inCode[i] ? null : line.match(DEF_LINE);
+        if (match && !isReferenced(lines, inCode, match[1] ?? "")) {
+            dropped = true;
+            i = skipDroppedDefinition(lines, i);
+            continue;
+        }
+        kept.push(line);
+    }
+    return { text: kept.join("\n"), dropped };
+}
+/**
+ * Fenced-code regions are opaque: def-looking lines inside them are not
+ * definitions and ref-looking text is not a reference. Returns a
+ * per-line mask; the fence lines themselves count as code context.
+ */
+function codeLineMask(lines) {
+    const inCode = [];
+    let codeOpen = false;
+    for (const line of lines) {
+        if (FENCE_LINE.test(line)) {
+            inCode.push(true); // the fence line itself is code context
+            codeOpen = !codeOpen;
+        }
+        else {
+            inCode.push(codeOpen);
+        }
+    }
+    return inCode;
+}
+/**
+ * A "reference" is any unescaped [^label] occurrence (outside code) that
+ * is not itself the prefix of a definition line — marked-footnote counts
+ * refs inside definition content (including self-refs).
+ */
+function isReferenced(lines, inCode, label) {
+    const needle = new RegExp(`(?<!\\\\)\\[\\^${label}\\](:?)`, "g");
+    for (let i = 0; i < lines.length; i++) {
+        if (inCode[i])
+            continue;
+        const line = lines[i] ?? "";
+        for (const m of line.matchAll(needle)) {
+            if (!(m[1] === ":" && m.index === 0 && DEF_LINE.test(line))) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Skip past a dropped definition's continuation lines (4-space-indented,
+ * possibly separated by blank lines), plus one following blank line so
+ * no double blank is left behind. Returns the last consumed index.
+ */
+function skipDroppedDefinition(lines, index) {
+    let i = index;
+    while (i + 1 < lines.length) {
+        const next = lines[i + 1] ?? "";
+        if (/^ {4}/.test(next))
+            i++;
+        else if (next.trim() === "" && /^ {4}/.test(lines[i + 2] ?? "x"))
+            i++;
+        else
+            break;
+    }
+    if ((lines[i + 1] ?? "x").trim() === "")
+        i++;
+    return i;
+}

package/dist/serialize.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Serialize a DOM subtree back to markdown. Inverse of `toDom` — walks
+ * the HTML shape that `marked` produces plus the tags contenteditable
+ * editors inject, and emits GFM-flavored markdown.
+ *
+ * Design principles:
+ * - Closed subset. We only serialize elements we know about. Anything
+ *   else is preserved as raw `outerHTML` so leaks surface early rather
+ *   than silently disappearing.
+ * - Adapter-seamed. Element inputs are walked through the structural
+ *   `HtmlElementLike` interface; string inputs are parsed via a
+ *   `DomAdapter` (browser document by default).
+ * - Cursor-agnostic. Selection state is the caller's responsibility;
+ *   this function just reads DOM → returns a string.
+ * - No side effects. Pure. Callers can invoke it debounced without
+ *   worrying about mutation of the input.
+ */
+import type { DomAdapter, HtmlElementLike } from "./adapter.js";
+export interface ToMarkdownOptions {
+    /**
+     * DOM adapter used to parse string inputs. Defaults to the platform
+     * document; required in runtimes without one (Node, Bun).
+     */
+    adapter?: DomAdapter;
+}
+export declare function toMarkdown(input: HtmlElementLike | string, options?: ToMarkdownOptions): string;