@andesine/converters 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## 0.1.0
+
+- Async Markdown, MDX, Markdoc, and HTML conversion, plus plain-text output.
+- Configurable title, property, and fragment mappings.
+- Async exact and wildcard handlers, native AST access, and a custom format adapter interface.
+- Published-content image URL helpers with explicit variant selection and async callbacks, without network access or an SDK dependency.
+- Shared heading anchors, HTML heading IDs, AST metadata, and `context.anchor` for custom renderers.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vrite, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,366 @@
+# @andesine/converters
+
+MIT-licensed, async converters for Andesine ProseMirror JSON. ESM only. Use in
+Node.js 22+, browsers, and workers. No editor instance, DOM, API client, or network
+connection is required. The library does not save content or upload assets.
+
+```sh
+npm install @andesine/converters
+```
+
+See the [release guide](https://github.com/vriteio/andesine/blob/andesine/packages/public/README.md)
+for builds, archive checks, versioning, and npm publishing. This package uses the
+[MIT license](./LICENSE).
+
+## Formats
+
+| Import                          | Output       | Input          |
+| ------------------------------- | ------------ | -------------- |
+| `@andesine/converters/markdown` | `toMarkdown` | `fromMarkdown` |
+| `@andesine/converters/mdx`      | `toMDX`      | `fromMDX`      |
+| `@andesine/converters/markdoc`  | `toMarkdoc`  | `fromMarkdoc`  |
+| `@andesine/converters/html`     | `toHTML`     | `fromHTML`     |
+| `@andesine/converters/text`     | `toText`     | —              |
+
+All conversion functions return promises. Callbacks and handlers may return a
+value or a promise. Formats have separate entry points; there is no root export
+that loads every parser. Installation includes all format dependencies.
+
+Markdoc's declarations reference its React renderer types, so this package also
+includes `@types/react` for strict TypeScript consumers. No React runtime is
+required or loaded by the converters.
+
+```ts
+import { toMarkdown, fromMarkdown } from "@andesine/converters/markdown";
+
+const source = await toMarkdown(document);
+const importedDocument = await fromMarkdown("# Title\n\nHello **world**.");
+```
+
+Input converters return a `doc` with a title and body content. If no title is
+mapped, the title is empty. Use `{ document: "fragment" }` to return body content
+without a title. The same setting prevents the first heading from becoming a
+title. Use `targetFragment: "body"` to put imported body content in a named
+fragment.
+
+## Reusable mapping options
+
+```ts
+import { createMDXConverter } from "@andesine/converters/mdx";
+
+const converter = createMDXConverter({
+  title: { as: "frontmatter", key: "title" },
+  properties: { as: "frontmatter" },
+  fragments: {
+    default: "unwrap",
+    named: {
+      summary: { as: "element", name: "Fragment" },
+      internalNotes: "omit"
+    }
+  }
+});
+
+const source = await converter.encode(document);
+const restored = await converter.decode(source);
+```
+
+Factory names are `createMarkdownConverter`, `createMDXConverter`,
+`createMarkdocConverter`, `createHTMLConverter`, and `createTextConverter`.
+Per-call options override saved options; handler maps and named fragment mappings
+merge by key.
+
+| Field      | Default             | Other mappings                                  |
+| ---------- | ------------------- | ----------------------------------------------- |
+| Title      | First-level heading | `"omit"`, `{ as: "frontmatter", key: "title" }` |
+| Properties | Omit                | `{ as: "frontmatter" }`                         |
+| Fragments  | `"unwrap"`          | `"omit"`, `{ as: "element", name: "Fragment" }` |
+
+Unwrap removes the fragment boundary and retains its content in document order.
+Omit removes the content too. The number of fragments does not change the default.
+MDX wrappers become components; Markdoc wrappers become tags; HTML wrappers use
+`data-andesine-element` and JSON `data-andesine-props` on a `div`. Markdown needs
+a custom handler for fragment wrappers. HTML and plain text reject frontmatter
+output; use their AST result or your own surrounding document for metadata.
+
+On import, matching named wrappers become fragments. Unwrapped boundaries cannot
+be recovered. With heading mapping, only the first root heading, at level one,
+becomes the title. With frontmatter mapping, the selected field becomes the title.
+
+Property labels become frontmatter keys. Duplicate keys, including a collision
+with the title field, cause an error. Import infers text, number, checkbox, and
+multi-select properties from scalar values and string arrays. Date, URL, and
+select fields import as text; select options and schema metadata are not retained.
+Object-valued properties need custom handling. Unmapped frontmatter is ignored.
+
+## Heading anchors
+
+`getHeadingAnchors(document)` returns `{ path, text, anchor }` for each heading in
+document order. It is exported from the package root and the dependency-free
+`@andesine/converters/anchors` entry point. `path` is the array of child indexes
+from the document root. The same helper supplies search and answer-source anchors.
+
+Anchors use NFC-normalized lowercase heading text. Punctuation is removed,
+whitespace and underscores become hyphens, and empty results use `section`.
+Letters, numbers, and combining marks are retained. Collisions receive `-1`,
+`-2`, and later suffixes until the ID is unique, including collisions with names
+that already contain a suffix. All fragments share one counter. Titles and
+properties do not create anchors or consume IDs.
+
+HTML headings receive the ID automatically. Markdown and MDX AST headings carry
+it in `data.hProperties.id`; Markdoc AST headings carry it in `attributes.id`.
+String serialization for Markdown, MDX, and Markdoc does not preserve this AST
+metadata. Configure the final renderer to apply these IDs, or use a custom
+heading handler. Do not assume a renderer's own slug rules match Andesine.
+
+Custom encode handlers receive `context.anchor` for original heading nodes:
+
+```ts
+const html = await toHTML(document, {
+  encode: {
+    nodes: {
+      heading: async (node, context) => ({
+        type: "element",
+        tagName: `h${node.attrs?.level || 1}`,
+        properties: { id: context.anchor },
+        children: await context.children(node)
+      })
+    }
+  }
+});
+```
+
+The converter calculates anchors before applying fragment mappings. Omitting a
+fragment does not renumber later headings, but links to omitted headings have no
+target. A renderer that reorders, replaces, or omits content is responsible for
+adapting links. Anchors are stable within a content version, not across edits.
+Plain text does not have link targets. Import does not retain supplied heading IDs;
+anchors are derived again from the imported document.
+
+## Images
+
+Published content already includes image URLs. Use them directly:
+
+```ts
+import { publishedContentOptions } from "@andesine/converters";
+import { toMarkdown } from "@andesine/converters/markdown";
+
+const page = await client.content.get({ path: "/Docs/Getting started" });
+const source = await toMarkdown(page.content, {
+  ...publishedContentOptions(page),
+  title: { as: "frontmatter" }
+});
+```
+
+`publishedContentOptions(page, options?)` returns only an `imageURL` callback.
+It works with single published-content responses and full items from
+`content.listEntries`. It does not change title, property, or fragment mappings.
+The converter package has no SDK dependency; any object with a compatible
+`assets` array works.
+
+`createImageURLResolver(assets, options?)` returns that async callback directly.
+Each asset needs `assetID`, `variant`, and `url`. The default variant is `display`.
+Set `{ variant: "thumbnail" }`, or select a variant per image:
+
+```ts
+const options = publishedContentOptions(page, {
+  variant: async (image) => (image.attrs?.small ? "thumbnail" : "display")
+});
+```
+
+The resolver returns the supplied URL unchanged. It does not fetch images, build
+URLs, or fall back to another variant. Missing assets or variants throw
+`ConversionError`. Keep assets from the same entry and snapshot as the content.
+An explicit `imageURL` callback can override this helper through the normal
+converter options. Import still needs your own `imageAssetID` callback.
+
+Images need reference resolution in both directions:
+
+```ts
+const source = await toMarkdown(document, {
+  imageURL: async (image) => {
+    const assetID = String(image.attrs?.assetID);
+    return assets.get(assetID)!.url;
+  }
+});
+
+const importedDocument = await fromMarkdown(source, {
+  imageAssetID: async ({ url, alt, title }) => resolveAsset(url, alt, title)
+});
+```
+
+Callbacks return a URL or asset ID. A missing resolution causes an error. The
+caller may perform network work in callbacks; the library performs none itself.
+Plain text uses alt text, or the caption when alt text is absent, without resolving
+an image URL. Published snapshot URLs may expire; decide where exported assets
+will live before resolving them.
+
+## Custom and wildcard handlers
+
+Handlers can return a node, an array of nodes, or `null` to omit content. Exact
+element handlers take precedence over wildcard element handlers. Node and mark
+handlers also support `"*"`. Custom handlers take precedence over built-ins.
+
+```ts
+import { createMDXConverter, mdxAdapter } from "@andesine/converters/mdx";
+
+const converter = createMDXConverter({
+  encode: {
+    elements: {
+      "Callout": async (node, context) =>
+        mdxAdapter.encode(
+          {
+            ...node,
+            attrs: { ...node.attrs, name: "Notice" }
+          },
+          context
+        ),
+      "*": async (node, context) =>
+        mdxAdapter.encode(
+          {
+            ...node,
+            attrs: { ...node.attrs, name: `Components.${node.attrs?.name}` }
+          },
+          context
+        )
+    }
+  }
+});
+```
+
+The built-in MDX element handler already maps arbitrary Andesine element names
+and static properties to MDX elements. Wildcards let you change that mapping for
+all elements. Decode handlers are independent: define a matching handler when
+custom output should convert back to the original element.
+
+```ts
+import { element } from "@andesine/converters";
+
+const converter = createMDXConverter({
+  decode: {
+    elements: {
+      Notice: async (node, context) => {
+        if (node.type !== "mdxJsxFlowElement") {
+          throw new Error("Notice must be a block element");
+        }
+        return element("Callout", {}, await context.children(node.children));
+      }
+    }
+  }
+});
+```
+
+Encoder contexts expose `encode`, `children`, `imageURL`, options, and the content
+path. Decoder contexts expose `decode`, `children`, `image`, options, and the AST
+path. Calling the adapter's built-in handler bypasses custom dispatch; calling
+`context.encode` or `context.decode` uses custom dispatch again. Avoid passing the
+same unchanged node back through dispatch from its own handler.
+
+`encode.nodes` is keyed by Andesine node type; `encode.marks` by mark type.
+`decode.nodes` is keyed by native AST type (HTML uses tag names for elements).
+`decode.marks` uses Andesine mark names. `decode.elements` uses component/tag names.
+A node wildcard also matches the document root; delegate roots if your wildcard
+is intended to omit only unknown leaves.
+
+## Syntax trees and custom formats
+
+Each bidirectional format exports `to…AST` and `from…AST`. They use
+`{ tree, frontmatter }`, so metadata is separate from the format tree. The trees are
+mdast for Markdown/MDX, Markdoc nodes for Markdoc, and hast for HTML. Plain text
+exports `toTextAST` with a small text tree.
+
+```ts
+const result = await converter.toAST(document);
+// Inspect or change result.tree and result.frontmatter.
+const restored = await converter.fromAST(result);
+```
+
+To add a format, implement `FormatAdapter<T>` and call `createConverter(adapter)`.
+The adapter supplies root creation, parsing, stringification, node/mark encoding,
+decoding, and optional element/mark name lookup. The core supplies async traversal,
+custom handler dispatch, title/property/fragment mapping, and image callbacks.
+It does not require a Markdown tree.
+
+For example, this small custom format stores document text as a JSON array. It is
+intentionally lossy and supports only paragraphs and text:
+
+```ts
+import { createConverter, ConversionError, type FormatAdapter } from "@andesine/converters";
+
+interface ArrayNode {
+  type: "root" | "paragraph" | "text";
+  value?: string;
+  children?: ArrayNode[];
+}
+
+const adapter: FormatAdapter<ArrayNode> = {
+  name: "Paragraph array",
+  type: (node) => node.type,
+  root: (children) => ({ type: "root", children }),
+  parse: (source) => ({
+    type: "root",
+    children: (JSON.parse(source) as string[]).map((value) => ({
+      type: "paragraph",
+      children: [{ type: "text", value }]
+    }))
+  }),
+  stringify: (root) =>
+    JSON.stringify(
+      root.children?.map((node) => node.children?.map((child) => child.value || "").join(""))
+    ),
+  async encode(node, context) {
+    if (node.type === "text") return { type: "text", value: node.text };
+    if (node.type === "paragraph")
+      return { type: "paragraph", children: await context.children(node) };
+    throw new ConversionError(`Unsupported node: ${node.type}`);
+  },
+  mark: (_mark, children) => children,
+  async decode(node, context) {
+    if (node.type === "text") return { type: "text", text: node.value || "" };
+    const content = await context.children(node.children || []);
+    return node.type === "root" ? content : { type: "paragraph", content };
+  }
+};
+
+const converter = createConverter(adapter, { title: "omit", document: "fragment" });
+```
+
+## Preservation and limits
+
+These are content conversions, not document backups. They preserve the supported
+content subset, not exact source text. Node IDs, schema links, inherited-field
+metadata, editor layout, original whitespace, and source syntax choices are not
+preserved. There is no detailed loss report. Unsupported nodes, marks, or syntax
+throw; explicit mappings and the losses below do not.
+
+| Feature                             | Markdown / MDX                            | Markdoc                          | HTML                              | Plain text          |
+| ----------------------------------- | ----------------------------------------- | -------------------------------- | --------------------------------- | ------------------- |
+| Paragraphs, headings, quotes, lists | Yes                                       | Yes                              | Yes                               | Text and separators |
+| Bold, italic, strike, code, links   | Yes                                       | Yes                              | Yes                               | Formatting removed  |
+| Subscript, superscript, highlight   | Custom handlers                           | Custom handlers                  | Yes; highlight color omitted      | Formatting removed  |
+| Task lists                          | GFM                                       | Custom handlers                  | Andesine data attributes          | Checkbox markers    |
+| Code blocks                         | Language retained                         | Language retained                | Language retained                 | Code text           |
+| Images                              | URL, alt, caption as title                | URL, alt, caption as title       | Image and optional figure caption | Alt/caption text    |
+| Tables                              | GFM; single-paragraph cells, no spans     | Single-paragraph cells, no spans | Cell spans and block content      | Tab-separated cells |
+| Custom elements                     | MD: custom handler; MDX: static block JSX | Static tags                      | Andesine data attributes          | Custom handler      |
+
+Markdown-like tables normalize the first row to headers. Alignment, column widths,
+link targets/titles, image size, and aspect ratio are not preserved. Empty
+paragraphs can collapse in Markdown-like output. Mark ordering and adjacent text
+node boundaries can change without changing displayed content.
+
+MDX supports block components with static JSON-compatible properties. Expressions
+inside property values may contain literal arrays/objects, but no calls, variable
+references, spreads, imports, exports, or executable code. Inline JSX and JSX
+fragments require custom handlers. Markdoc variables/functions also require custom
+handlers. No source is evaluated during conversion.
+
+Mixed bullet/task lists import as task lists with unchecked plain items. Ordered
+task lists, Markdown footnotes, and raw HTML require custom handlers. HTML import supports
+semantic elements, not arbitrary CSS/layout. Whitespace follows basic HTML
+normalization. Scripts, styles, comments, and unknown elements require explicit
+handlers. Built-in HTML output escapes text and rejects unsafe URL schemes; custom
+handlers are responsible for the output they create. This is not an HTML sanitizer.
+
+Import is not full editor-schema validation. A custom handler must return content
+that is valid for its destination, including block/inline placement and allowed
+fragment children. If you need a document backup, retain the original JSON.

package/dist/anchors.d.ts

@@ -0,0 +1,18 @@
+import { r as ContentNode } from "./chunks/types-SDFWRP3z.js";
+//#region src/anchors.d.ts
+interface HeadingAnchor {
+  path: readonly number[];
+  text: string;
+  anchor: string;
+}
+/**
+ * Compute heading anchors that match Andesine search results and citations.
+ * @param document - The full ProseMirror document. Titles and properties are excluded.
+ * @returns Headings in document order with text, child-index path, and unique anchor.
+ * Duplicate anchors receive numeric suffixes. Anchors are stable within a content version;
+ * converting a fragment alone can produce different suffixes than converting the full document.
+ */
+declare const getHeadingAnchors: (document: ContentNode) => HeadingAnchor[];
+//#endregion
+export { type HeadingAnchor, getHeadingAnchors };
+//# sourceMappingURL=anchors.d.ts.map

package/dist/anchors.js

@@ -0,0 +1,36 @@
+//#region src/anchors.ts
+const getHeadingText = (node) => node.type === "hardBreak" ? " " : node.text ?? (node.content || []).map(getHeadingText).join("");
+/**
+* Compute heading anchors that match Andesine search results and citations.
+* @param document - The full ProseMirror document. Titles and properties are excluded.
+* @returns Headings in document order with text, child-index path, and unique anchor.
+* Duplicate anchors receive numeric suffixes. Anchors are stable within a content version;
+* converting a fragment alone can produce different suffixes than converting the full document.
+*/
+const getHeadingAnchors = (document) => {
+	const headings = [];
+	const used = /* @__PURE__ */ new Set();
+	const visit = (node, path) => {
+		if (node.type === "title" || node.type === "property") return;
+		if (node.type === "heading") {
+			const text = getHeadingText(node).normalize("NFC").replace(/\s+/g, " ").trim();
+			const base = text.toLowerCase().replace(/[^\p{L}\p{N}\p{M}\s_-]/gu, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "section";
+			let anchor = base;
+			let suffix = 1;
+			while (used.has(anchor)) anchor = `${base}-${suffix++}`;
+			used.add(anchor);
+			headings.push({
+				path,
+				text,
+				anchor
+			});
+		}
+		(node.content || []).forEach((child, index) => visit(child, [...path, index]));
+	};
+	visit(document, []);
+	return headings;
+};
+//#endregion
+export { getHeadingAnchors };
+
+//# sourceMappingURL=anchors.js.map

package/dist/anchors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchors.js","names":[],"sources":["../src/anchors.ts"],"sourcesContent":["import type { ContentNode } from \"./types\";\n\ninterface HeadingAnchor {\n  path: readonly number[];\n  text: string;\n  anchor: string;\n}\n\nconst getHeadingText = (node: ContentNode): string =>\n  node.type === \"hardBreak\"\n    ? \" \"\n    : (node.text ?? (node.content || []).map(getHeadingText).join(\"\"));\n/**\n * Compute heading anchors that match Andesine search results and citations.\n * @param document - The full ProseMirror document. Titles and properties are excluded.\n * @returns Headings in document order with text, child-index path, and unique anchor.\n * Duplicate anchors receive numeric suffixes. Anchors are stable within a content version;\n * converting a fragment alone can produce different suffixes than converting the full document.\n */\nconst getHeadingAnchors = (document: ContentNode): HeadingAnchor[] => {\n  const headings: HeadingAnchor[] = [];\n  const used = new Set<string>();\n  const visit = (node: ContentNode, path: number[]): void => {\n    if (node.type === \"title\" || node.type === \"property\") return;\n\n    if (node.type === \"heading\") {\n      const text = getHeadingText(node).normalize(\"NFC\").replace(/\\s+/g, \" \").trim();\n      const base =\n        text\n          .toLowerCase()\n          .replace(/[^\\p{L}\\p{N}\\p{M}\\s_-]/gu, \"\")\n          .replace(/[\\s_]+/g, \"-\")\n          .replace(/-+/g, \"-\")\n          .replace(/^-|-$/g, \"\") || \"section\";\n\n      let anchor = base;\n      let suffix = 1;\n\n      while (used.has(anchor)) anchor = `${base}-${suffix++}`;\n\n      used.add(anchor);\n      headings.push({ path, text, anchor });\n    }\n\n    (node.content || []).forEach((child, index) => visit(child, [...path, index]));\n  };\n\n  visit(document, []);\n\n  return headings;\n};\n\nexport { getHeadingAnchors };\nexport type { HeadingAnchor };\n"],"mappings":";AAQA,MAAM,kBAAkB,SACtB,KAAK,SAAS,cACV,MACC,KAAK,SAAS,KAAK,WAAW,CAAC,EAAA,CAAG,IAAI,cAAc,CAAC,CAAC,KAAK,EAAE;;;;;;;;AAQpE,MAAM,qBAAqB,aAA2C;CACpE,MAAM,WAA4B,CAAC;CACnC,MAAM,uBAAO,IAAI,IAAY;CAC7B,MAAM,SAAS,MAAmB,SAAyB;EACzD,IAAI,KAAK,SAAS,WAAW,KAAK,SAAS,YAAY;EAEvD,IAAI,KAAK,SAAS,WAAW;GAC3B,MAAM,OAAO,eAAe,IAAI,CAAC,CAAC,UAAU,KAAK,CAAC,CAAC,QAAQ,QAAQ,GAAG,CAAC,CAAC,KAAK;GAC7E,MAAM,OACJ,KACG,YAAY,CAAC,CACb,QAAQ,4BAA4B,EAAE,CAAC,CACvC,QAAQ,WAAW,GAAG,CAAC,CACvB,QAAQ,OAAO,GAAG,CAAC,CACnB,QAAQ,UAAU,EAAE,KAAK;GAE9B,IAAI,SAAS;GACb,IAAI,SAAS;GAEb,OAAO,KAAK,IAAI,MAAM,GAAG,SAAS,GAAG,KAAK,GAAG;GAE7C,KAAK,IAAI,MAAM;GACf,SAAS,KAAK;IAAE;IAAM;IAAM;GAAO,CAAC;EACtC;EAEA,CAAC,KAAK,WAAW,CAAC,EAAA,CAAG,SAAS,OAAO,UAAU,MAAM,OAAO,CAAC,GAAG,MAAM,KAAK,CAAC,CAAC;CAC/E;CAEA,MAAM,UAAU,CAAC,CAAC;CAElB,OAAO;AACT"}

package/dist/chunks/adapter-CeNgvE5W.js

@@ -0,0 +1,177 @@
+import { c as textContent, i as ConversionError } from "./core-DC64ddB7.js";
+import { t as decodeMarkdown } from "./decode-B-xzTJFV.js";
+import { n as normalizeMarkdown, t as markdownStringifyOptions } from "./stringify-DdPaV2y4.js";
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkStringify from "remark-stringify";
+import remarkGFM from "remark-gfm";
+//#region src/markdown/encode.ts
+const encodeMarkdown = async (node, context) => {
+	const attrs = node.attrs || {};
+	const children = await context.children(node);
+	switch (node.type) {
+		case "text": return {
+			type: "text",
+			value: node.text || ""
+		};
+		case "paragraph": return {
+			type: "paragraph",
+			children
+		};
+		case "heading": return {
+			type: "heading",
+			...context.anchor ? { data: { hProperties: { id: context.anchor } } } : {},
+			depth: Number(attrs.level || 1),
+			children
+		};
+		case "blockquote": return {
+			type: "blockquote",
+			children
+		};
+		case "bulletList":
+		case "orderedList":
+		case "taskList": return {
+			type: "list",
+			ordered: node.type === "orderedList",
+			...node.type === "orderedList" ? { start: Number(attrs.start || 1) } : {},
+			spread: false,
+			children
+		};
+		case "listItem":
+		case "taskItem": return {
+			type: "listItem",
+			...node.type === "taskItem" ? { checked: Boolean(attrs.checked) } : {},
+			spread: false,
+			children
+		};
+		case "hardBreak": return { type: "break" };
+		case "horizontalRule": return { type: "thematicBreak" };
+		case "codeBlock": return {
+			type: "code",
+			lang: typeof attrs.language === "string" ? attrs.language : null,
+			value: textContent(node)
+		};
+		case "image": return {
+			type: "image",
+			url: await context.imageURL(node),
+			alt: String(attrs.alt || ""),
+			title: attrs.caption ? String(attrs.caption) : null
+		};
+		case "table": return {
+			type: "table",
+			children
+		};
+		case "tableRow": return {
+			type: "tableRow",
+			children
+		};
+		case "tableCell":
+		case "tableHeader":
+			if (Number(attrs.colspan || 1) !== 1 || Number(attrs.rowspan || 1) !== 1 || children.some((child) => child.type !== "paragraph") || children.length > 1) throw new ConversionError("Markdown tables require single-paragraph cells without spans", context.path);
+			return {
+				type: "tableCell",
+				children: children.flatMap((child) => child.type === "paragraph" ? child.children : [])
+			};
+		default: throw new ConversionError(`Unsupported Markdown node: ${node.type}`, context.path);
+	}
+};
+const encodeMarkdownMark = (mark, children, context) => {
+	const content = children;
+	switch (mark.type) {
+		case "bold": return {
+			type: "strong",
+			children: content
+		};
+		case "italic": return {
+			type: "emphasis",
+			children: content
+		};
+		case "strike": return {
+			type: "delete",
+			children: content
+		};
+		case "link": return {
+			type: "link",
+			url: String(mark.attrs?.href || ""),
+			title: null,
+			children: content
+		};
+		case "code":
+			if (children.some((node) => node.type !== "text")) throw new ConversionError("Code marks must wrap plain text", context.path);
+			return {
+				type: "inlineCode",
+				value: children.map((node) => node.type === "text" ? node.value : "").join("")
+			};
+		default: throw new ConversionError(`Unsupported Markdown mark: ${mark.type}`, context.path);
+	}
+};
+//#endregion
+//#region src/markdown/adapter.ts
+const createMarkdownAdapter = (mdx) => {
+	const processor = unified().use(remarkParse).use(remarkGFM).use(remarkStringify, markdownStringifyOptions);
+	if (mdx) processor.use(mdx);
+	const marks = {
+		strong: "bold",
+		emphasis: "italic",
+		delete: "strike",
+		inlineCode: "code",
+		link: "link"
+	};
+	return {
+		name: mdx ? "MDX" : "Markdown",
+		frontmatter: true,
+		type: (node) => node.type,
+		markName: (node) => marks[node.type],
+		root: (children) => ({
+			type: "root",
+			children: children.map((node) => node.type === "image" ? {
+				type: "paragraph",
+				children: [node]
+			} : node)
+		}),
+		parse(source) {
+			const root = processor.parse(source);
+			const definitions = /* @__PURE__ */ new Map();
+			const collectDefinitions = (node) => {
+				if (node.type === "definition") {
+					const identifier = node.identifier.toUpperCase();
+					if (!definitions.has(identifier)) definitions.set(identifier, node);
+				}
+				if ("children" in node) node.children.forEach(collectDefinitions);
+			};
+			const resolve = (node) => {
+				if (node.type === "linkReference" || node.type === "imageReference") {
+					const definition = definitions.get(node.identifier.toUpperCase());
+					if (!definition) throw new ConversionError(`Missing Markdown definition: ${node.identifier}`);
+					if (node.type === "imageReference") return {
+						type: "image",
+						url: definition.url,
+						title: definition.title,
+						alt: node.alt
+					};
+					return {
+						type: "link",
+						url: definition.url,
+						title: definition.title,
+						children: node.children.map(resolve)
+					};
+				}
+				if ("children" in node) return {
+					...node,
+					children: node.children.map(resolve)
+				};
+				return node;
+			};
+			collectDefinitions(root);
+			return resolve(root);
+		},
+		stringify: (root) => processor.stringify(normalizeMarkdown(root)),
+		encode: (node, context) => encodeMarkdown(node, context),
+		mark: (mark, children, context) => encodeMarkdownMark(mark, children, context),
+		decode: decodeMarkdown
+	};
+};
+//#endregion
+export { createMarkdownAdapter as t };
+
+//# sourceMappingURL=adapter-CeNgvE5W.js.map

package/dist/chunks/adapter-CeNgvE5W.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-CeNgvE5W.js","names":[],"sources":["../../src/markdown/encode.ts","../../src/markdown/adapter.ts"],"sourcesContent":["import type {\n  RootContent,\n  PhrasingContent,\n  BlockContent,\n  ListContent,\n  TableContent,\n  RowContent\n} from \"mdast\";\nimport { ConversionError, textContent } from \"../utils\";\nimport type { ContentMark, ContentNode, EncodeContext } from \"../types\";\n\nconst encodeMarkdown = async (\n  node: ContentNode,\n  context: EncodeContext<RootContent>\n): Promise<RootContent> => {\n  const attrs = node.attrs || {};\n  const children = await context.children(node);\n\n  switch (node.type) {\n    case \"text\":\n      return { type: \"text\", value: node.text || \"\" };\n    case \"paragraph\":\n      return { type: \"paragraph\", children: children as PhrasingContent[] };\n    case \"heading\":\n      return {\n        type: \"heading\",\n        ...(context.anchor ? { data: { hProperties: { id: context.anchor } } } : {}),\n        depth: Number(attrs.level || 1) as 1 | 2 | 3 | 4 | 5 | 6,\n        children: children as PhrasingContent[]\n      };\n    case \"blockquote\":\n      return { type: \"blockquote\", children: children as BlockContent[] };\n    case \"bulletList\":\n    case \"orderedList\":\n    case \"taskList\":\n      return {\n        type: \"list\",\n        ordered: node.type === \"orderedList\",\n        ...(node.type === \"orderedList\" ? { start: Number(attrs.start || 1) } : {}),\n        spread: false,\n        children: children as ListContent[]\n      };\n    case \"listItem\":\n    case \"taskItem\":\n      return {\n        type: \"listItem\",\n        ...(node.type === \"taskItem\" ? { checked: Boolean(attrs.checked) } : {}),\n        spread: false,\n        children: children as BlockContent[]\n      };\n    case \"hardBreak\":\n      return { type: \"break\" };\n    case \"horizontalRule\":\n      return { type: \"thematicBreak\" };\n    case \"codeBlock\":\n      return {\n        type: \"code\",\n        lang: typeof attrs.language === \"string\" ? attrs.language : null,\n        value: textContent(node)\n      };\n    case \"image\":\n      return {\n        type: \"image\",\n        url: await context.imageURL(node),\n        alt: String(attrs.alt || \"\"),\n        title: attrs.caption ? String(attrs.caption) : null\n      };\n    case \"table\":\n      return { type: \"table\", children: children as TableContent[] };\n    case \"tableRow\":\n      return { type: \"tableRow\", children: children as RowContent[] };\n    case \"tableCell\":\n    case \"tableHeader\": {\n      if (\n        Number(attrs.colspan || 1) !== 1 ||\n        Number(attrs.rowspan || 1) !== 1 ||\n        children.some((child) => child.type !== \"paragraph\") ||\n        children.length > 1\n      ) {\n        throw new ConversionError(\n          \"Markdown tables require single-paragraph cells without spans\",\n          context.path\n        );\n      }\n      return {\n        type: \"tableCell\",\n        children: children.flatMap((child) => (child.type === \"paragraph\" ? child.children : []))\n      };\n    }\n    default:\n      throw new ConversionError(`Unsupported Markdown node: ${node.type}`, context.path);\n  }\n};\nconst encodeMarkdownMark = (\n  mark: ContentMark,\n  children: RootContent[],\n  context: EncodeContext<RootContent>\n): RootContent => {\n  const content = children as PhrasingContent[];\n\n  switch (mark.type) {\n    case \"bold\":\n      return { type: \"strong\", children: content };\n    case \"italic\":\n      return { type: \"emphasis\", children: content };\n    case \"strike\":\n      return { type: \"delete\", children: content };\n    case \"link\":\n      return { type: \"link\", url: String(mark.attrs?.href || \"\"), title: null, children: content };\n    case \"code\": {\n      if (children.some((node) => node.type !== \"text\"))\n        throw new ConversionError(\"Code marks must wrap plain text\", context.path);\n\n      return {\n        type: \"inlineCode\",\n        value: children.map((node) => (node.type === \"text\" ? node.value : \"\")).join(\"\")\n      };\n    }\n    default:\n      throw new ConversionError(`Unsupported Markdown mark: ${mark.type}`, context.path);\n  }\n};\n\nexport { encodeMarkdown, encodeMarkdownMark };\n","import { unified, type Plugin } from \"unified\";\nimport remarkParse from \"remark-parse\";\nimport remarkStringify from \"remark-stringify\";\nimport remarkGFM from \"remark-gfm\";\nimport type { Definition, PhrasingContent, Root, RootContent } from \"mdast\";\nimport { encodeMarkdown, encodeMarkdownMark } from \"./encode\";\nimport { decodeMarkdown, type MarkdownNode } from \"./decode\";\nimport { normalizeMarkdown } from \"./normalize\";\nimport { markdownStringifyOptions } from \"./stringify\";\nimport { ConversionError } from \"../utils\";\nimport type { FormatAdapter } from \"../types\";\n\nconst createMarkdownAdapter = (mdx?: Plugin): FormatAdapter<MarkdownNode> => {\n  const processor = unified()\n    .use(remarkParse)\n    .use(remarkGFM)\n    .use(remarkStringify, markdownStringifyOptions);\n\n  if (mdx) processor.use(mdx);\n\n  const marks: Record<string, string> = {\n    strong: \"bold\",\n    emphasis: \"italic\",\n    delete: \"strike\",\n    inlineCode: \"code\",\n    link: \"link\"\n  };\n\n  return {\n    name: mdx ? \"MDX\" : \"Markdown\",\n    frontmatter: true,\n    type: (node) => node.type,\n    markName: (node) => marks[node.type],\n    root: (children) => ({\n      type: \"root\",\n      children: children.map((node) =>\n        node.type === \"image\" ? { type: \"paragraph\", children: [node] } : node\n      ) as RootContent[]\n    }),\n    parse(source) {\n      const root = processor.parse(source);\n      const definitions = new Map<string, Definition>();\n      const collectDefinitions = (node: MarkdownNode): void => {\n        if (node.type === \"definition\") {\n          const identifier = node.identifier.toUpperCase();\n\n          if (!definitions.has(identifier)) definitions.set(identifier, node);\n        }\n\n        if (\"children\" in node) node.children.forEach(collectDefinitions);\n      };\n      const resolve = (node: MarkdownNode): MarkdownNode => {\n        if (node.type === \"linkReference\" || node.type === \"imageReference\") {\n          const definition = definitions.get(node.identifier.toUpperCase());\n\n          if (!definition)\n            throw new ConversionError(`Missing Markdown definition: ${node.identifier}`);\n          if (node.type === \"imageReference\")\n            return { type: \"image\", url: definition.url, title: definition.title, alt: node.alt };\n\n          return {\n            type: \"link\",\n            url: definition.url,\n            title: definition.title,\n            children: node.children.map(resolve) as PhrasingContent[]\n          };\n        }\n        if (\"children\" in node)\n          return { ...node, children: node.children.map(resolve) } as MarkdownNode;\n\n        return node;\n      };\n      collectDefinitions(root);\n      return resolve(root);\n    },\n    stringify: (root) => processor.stringify(normalizeMarkdown(root as Root)),\n    encode: (node, context) =>\n      encodeMarkdown(node, context as Parameters<typeof encodeMarkdown>[1]),\n    mark: (mark, children, context) =>\n      encodeMarkdownMark(\n        mark,\n        children as RootContent[],\n        context as Parameters<typeof encodeMarkdownMark>[2]\n      ),\n    decode: decodeMarkdown\n  };\n};\n\nexport { createMarkdownAdapter };\n"],"mappings":"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"}