npm - @portabletext/markdown - Versions diffs - 1.4.7 → 2.0.0 - Mend

@portabletext/markdown 1.4.7 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/README.md CHANGED Viewed

@@ -70,19 +70,44 @@ const markdown = portableTextToMarkdown([
 | Blockquotes      | ✅                       | ✅                       |
 | Ordered lists    | ✅                       | ✅                       |
 | Unordered lists  | ✅                       | ✅                       |
-| Task lists       | ✅\*                     | ✅\*                     |
+| Task lists       | ✅                       | ✅                       |
 | Nested lists     | ✅                       | ✅                       |
-| Code blocks      | ✅                       | ✅\*                     |
-| Horizontal rules | ✅                       | ✅\*                     |
-| Images           | ✅                       | ✅\*                     |
-| Tables           | ✅\*                     | ✅\*                     |
-| HTML blocks      | ✅                       | ✅\*                     |
-| Callouts         | ✅\*                     | ✅\*                     |
+| Code blocks      | ✅                       | ✅                       |
+| Horizontal rules | ✅                       | ✅                       |
+| Images           | ✅                       | ✅                       |
+| Tables           | ✅                       | ✅                       |
+| HTML blocks      | ✅                       | ✅                       |
+| Callouts         | ✅                       | ✅                       |
-\* Requires custom configuration (see usage below)
+## Round-trip behavior
+1. Translation preserves semantics, not source spelling. The first MD→PT→MD pass normalizes Markdown to one canonical spelling: autolinks and reference links become inline links, indented code becomes fenced code, and emphasis, headings, lists, and tables each get one canonical form.
+   ```
+   <https://portabletext.org>  ->  [https://portabletext.org](https://portabletext.org)
+   [ref link][id]              ->  [ref link](https://example.com "title")
+   ```
+2. The normalized Markdown is a fixpoint for the constructs in the [Supported features](#supported-features) table above: parsing it and serializing again reproduces it byte-for-byte, pinned by a full-document round-trip test. This doesn't yet extend to plain text that happens to contain literal Markdown punctuation: serialization doesn't escape it, so a second parse reads it back as markup instead of literal text.
+   ```
+   \*bar\*  ->  *bar*  (serialized unescaped; a second parse reads this as emphasis)
+   ```
+3. MD→PT survival is schema-driven. Constructs whose type the schema doesn't declare degrade predictably: they keep their content and drop the structure that named them. Marks drop formatting but keep the text (`**bar**` with no `strong` decorator in the schema becomes a plain span reading `bar`); tables flatten their cell content into top-level blocks; images fall back to their Markdown source as plain text; task-list checkboxes strip to plain list items.
+4. PT structures with no Markdown form degrade predictably on PT→MD. GFM tables have one header row, so header rows beyond the first flatten into the body. Deep or level-skipping lists collapse to relative nesting. A list's first item renders at the top level whatever its `level`, and each deeper jump between items indents one step, however many levels it skips. Multi-block table cells join their blocks with spaces. Unknown object types render as a fenced JSON block; unknown marks pass their text through unformatted.
+5. Identity does not round-trip. Keys are regenerated on every parse, and adjacent spans with identical marks merge into one.
 ## Usage
+<!-- The schema table, matcher table, supported-features table, and
+     round-trip section have condensed twins on the docs site
+     (apps/docs/src/content/docs/conversion/markdown-to-portable-text.mdx).
+     Keep them in sync: a claim corrected in one place is stale in the
+     other. -->
 ### `markdownToPortableText`
 ```ts
@@ -162,14 +187,14 @@ Out of the box, the library includes sensible defaults for both. Customize them
 The default schema includes the following definitions:
-| Type            | Values                                                                                                                                                                                                                                  |
-| --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `styles`        | `'normal'`, `'h1'`, `'h2'`, `'h3'`, `'h4'`, `'h5'`, `'h6'`, `'blockquote'`                                                                                                                                                              |
-| `lists`         | `'number'`, `'bullet'`                                                                                                                                                                                                                  |
-| `decorators`    | `'strong'`, `'em'`, `'code'`, `'strike-through'`                                                                                                                                                                                        |
-| `annotations`   | `'link'` (fields: `'href'`, `'title'`)                                                                                                                                                                                                  |
-| `blockObjects`  | `'code'` (fields: `'language'`, `'code'`), `'image'` (fields: `'src'`, `'alt'`, `'title'`), `'horizontal-rule'`, `'html'` (fields: `'html'`), `'table'` (fields: `'headerRows'`, `'rows'`), `'callout'` (fields: `'tone'`, `'content'`) |
-| `inlineObjects` | `'image'` (fields: `'src'`, `'alt'`, `'title'`)                                                                                                                                                                                         |
+| Type            | Values                                                                                                                                                                                                                                                                       |
+| --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `styles`        | `'normal'`, `'h1'`, `'h2'`, `'h3'`, `'h4'`, `'h5'`, `'h6'`, `'blockquote'`                                                                                                                                                                                                   |
+| `lists`         | `'number'`, `'bullet'`, `'task'`                                                                                                                                                                                                                                             |
+| `decorators`    | `'strong'`, `'em'`, `'code'`, `'strike-through'`                                                                                                                                                                                                                             |
+| `annotations`   | `'link'` (fields: `'href'`, `'title'`)                                                                                                                                                                                                                                       |
+| `blockObjects`  | `'code'` (fields: `'language'`, `'code'`), `'image'` (fields: `'src'`, `'alt'`, `'title'`), `'horizontal-rule'`, `'html'` (fields: `'html'`), `'table'` (the canonical nested shape, see [Default behavior](#default-behavior)), `'callout'` (fields: `'tone'`, `'content'`) |
+| `inlineObjects` | `'image'` (fields: `'src'`, `'alt'`, `'title'`)                                                                                                                                                                                                                              |
 To use a custom Schema, import `compileSchema` and `defineSchema` from `@portabletext/schema`:
@@ -218,8 +243,38 @@ Matchers map Markdown concepts to Portable Text types defined in the Schema. Eac
 |            | `image`          | `![alt](src)`           | `'image'`           |
 |            | `html`           | HTML blocks             | `'html'`            |
 |            | `callout`        | `> [!NOTE]`, etc.       | `'callout'`         |
-|            | `blockquote`     | `>` blockquotes         | `'blockquote'`      |
-|            | `list`           | `- ` or `1. ` lists     | `'list'`            |
+|            | `table`          | GFM pipe tables         | `'table'`           |
+|            | `blockquote`\*   | `>` blockquotes         | `'blockquote'`      |
+|            | `list`\*         | `- ` or `1. ` lists     | `'list'`            |
+\* Opt-in, not registered by default: `blockquote` and `list` map onto structural container shapes, and the parser only produces those shapes when you register the matcher (see [Configuring matchers](#configuring-matchers)). Without them, blockquotes and lists parse to flat text blocks, which is the standard Portable Text shape for both, not a degraded fallback.
+#### Default behavior
+**Tables** (GFM pipe tables) convert by default, in the canonical shape `@portabletext/plugin-table` expects: a `table` block object (`headerRows`, `rows`), each row a `row` object (`cells`), each cell a `cell` object (`value`, an array of Portable Text blocks; a cell holding a single image becomes a standalone block-level `image` object instead of a text block wrapping it). `alignment` is a `@portabletext/markdown` extension field; `@portabletext/plugin-table` ignores it. This needs no configuration when the schema declares a `table` block object with a `rows` field (see `blockObjects` above). A schema whose `table` doesn't declare `rows`, or that doesn't declare `table` at all, produces no table object at all: the table's cell content flattens into top-level blocks, in reading order, and the table structure is discarded.
+**Images** are handled based on context:
+- Standalone images (a paragraph containing only an image) become block-level `'image'` objects
+- Images mixed with text become inline `'image'` objects (if the schema includes `'image'` in `inlineObjects`)
+- If neither is supported, falls back to plain text: `![alt](src)`
+The default image matcher requires the schema type to have a `'src'` field. If your `'image'` type doesn't include this field, the matcher returns `undefined`.
+**Code** is handled based on the Markdown syntax:
+- Fenced code blocks (` ``` `) become `'code'` block objects with `language` and `code` fields
+- Inline code (`` ` ``) applies the `'code'` decorator to a span
+The default code block matcher requires the schema type to have a `'code'` field. If your `'code'` type doesn't include this field, the matcher returns `undefined`.
+**Links** support optional titles using `[text](url "title")` syntax. The title is captured in the `'title'` field of the `'link'` annotation.
+**Nested lists** are handled automatically. Each list item block includes a `level` property indicating its nesting depth (1 for top-level, 2 for nested, etc.).
+**HTML blocks** (like `<div>...</div>`) become `'html'` block objects with the raw HTML in the `'html'` field. Inline HTML is controlled by the `html.inline` option.
+**Callouts** use the `> [!TYPE]` syntax (GFM alerts) where `TYPE` is one of `NOTE`, `TIP`, `WARNING`, `CAUTION`, or `IMPORTANT`. They become `'callout'` block objects with a `'tone'` field (the lowercased type name) and a `'content'` field (an array of Portable Text blocks). When the schema doesn't include a `'callout'` block object, the content falls back to blockquote-styled blocks.
 #### Configuring matchers
@@ -246,7 +301,7 @@ markdownToPortableText(markdown, {
 > **Note:** Checking if the type exists in the schema isn't required, but it's good practice. Returning `undefined` gracefully skips unsupported types.
-**Table matcher:** Markdown tables are parsed but there's no default matcher. Provide one if your schema includes tables:
+**Table matcher:** GFM pipe tables convert by default (see [Default behavior](#default-behavior)). Provide your own matcher to map onto a differently-shaped `table` type:
 ```ts
 markdownToPortableText(markdown, {
@@ -288,7 +343,7 @@ The matcher receives `value.items` already assembled. Each item's `content` arra
 Without `types.list`, the existing flat-block path runs unchanged.
-**GFM task lists** (`- [ ]` / `- [x]`): Task lists are recognized when the schema declares a `task` list item. Without a `task` definition, the checkbox markers are stripped from the text and the items render as their surrounding list type (bullet or number). With a `task` definition, items carrying a checkbox become text blocks with `listItem: 'task'` and a `checked: boolean` field; items without a checkbox keep their surrounding list type.
+**GFM task lists** (`- [ ]` / `- [x]`): Task lists are recognized when the schema declares a `task` list item; the default schema does, so task lists parse zero-config. Without a `task` definition (a custom schema that omits it), the checkbox markers are stripped from the text and the items render as their surrounding list type (bullet or number). With a `task` definition, items carrying a checkbox become text blocks with `listItem: 'task'` and a `checked: boolean` field; items without a checkbox keep their surrounding list type.
 ```ts
 markdownToPortableText('- [x] done\n- [ ] todo', {
@@ -348,31 +403,6 @@ Matchers receive:
 Return `undefined` to skip the element (e.g., if the type isn't in the schema).
-#### Default behavior for images and code
-**Images** are handled based on context:
-- Standalone images (a paragraph containing only an image) become block-level `'image'` objects
-- Images mixed with text become inline `'image'` objects (if the schema includes `'image'` in `inlineObjects`)
-- If neither is supported, falls back to plain text: `![alt](src)`
-The default image matcher requires the schema type to have a `'src'` field. If your `'image'` type doesn't include this field, the matcher returns `undefined`.
-**Code** is handled based on the Markdown syntax:
-- Fenced code blocks (` ``` `) become `'code'` block objects with `language` and `code` fields
-- Inline code (`` ` ``) applies the `'code'` decorator to a span
-The default code block matcher requires the schema type to have a `'code'` field. If your `'code'` type doesn't include this field, the matcher returns `undefined`.
-**Links** support optional titles using `[text](url "title")` syntax. The title is captured in the `'title'` field of the `'link'` annotation.
-**Nested lists** are handled automatically. Each list item block includes a `level` property indicating its nesting depth (1 for top-level, 2 for nested, etc.).
-**HTML blocks** (like `<div>...</div>`) become `'html'` block objects with the raw HTML in the `'html'` field. Inline HTML is controlled by the `html.inline` option.
-**Callouts** use the `> [!TYPE]` syntax (GFM alerts) where `TYPE` is one of `NOTE`, `TIP`, `WARNING`, `CAUTION`, or `IMPORTANT`. They become `'callout'` block objects with a `'tone'` field (the lowercased type name) and a `'content'` field (an array of Portable Text blocks). When the schema doesn't include a `'callout'` block object, the content falls back to blockquote-styled blocks.
 #### Other options
 ```ts
@@ -449,34 +479,42 @@ The conversion is driven by **Renderers**: functions that render Portable Text e
 #### Default renderers
-| Group               | Renderer         | Renders                           | Output                   |
-| ------------------- | ---------------- | --------------------------------- | ------------------------ |
-| `block`             | `normal`         | Paragraphs                        | `{children}`             |
-|                     | `h1`–`h6`        | Headings                          | `# `–`###### `           |
-|                     | `blockquote`     | Blockquotes                       | `> {children}`           |
-| `marks`             | `strong`         | Bold text                         | `**{children}**`         |
-|                     | `em`             | Italic text                       | `_{children}_`           |
-|                     | `code`           | Inline code                       | `` `{children}` ``       |
-|                     | `underline`      | Underlined text                   | `<u>{children}</u>`      |
-|                     | `strike-through` | Strikethrough                     | `~~{children}~~`         |
-|                     | `link`           | Links                             | `[{children}](url)`      |
-| `listItem`          |                  | List items (bullet, number, task) | `- `, `1. `, or `- [x] ` |
-| `hardBreak`         |                  | Line breaks within blocks         | `  \n` (two spaces)      |
-| `blockSpacing`      |                  | Spacing between blocks            | `\n\n`, `\n`, `\n>\n`    |
-| `unknownType`       |                  | Unknown block types               | JSON code block          |
-| `unknownBlockStyle` |                  | Unknown block styles              | `{children}`             |
-| `unknownListItem`   |                  | Unknown list item types           | `- {children}`           |
-| `unknownMark`       |                  | Unknown marks                     | `{children}`             |
+| Group               | Renderer          | Renders                           | Output                   |
+| ------------------- | ----------------- | --------------------------------- | ------------------------ |
+| `types`             | `callout`         | `callout` block objects           | `> [!TYPE]\n> content`   |
+|                     | `code`            | `code` block objects              | Fenced code block        |
+|                     | `horizontal-rule` | `horizontal-rule` block objects   | `---`                    |
+|                     | `html`            | `html` block objects              | Raw HTML                 |
+|                     | `image`           | `image` block/inline objects      | `![alt](src "title")`    |
+|                     | `table`           | `table` block objects             | Markdown table           |
+| `block`             | `normal`          | Paragraphs                        | `{children}`             |
+|                     | `h1`–`h6`         | Headings                          | `# `–`###### `           |
+|                     | `blockquote`      | Blockquotes                       | `> {children}`           |
+| `marks`             | `strong`          | Bold text                         | `**{children}**`         |
+|                     | `em`              | Italic text                       | `_{children}_`           |
+|                     | `code`            | Inline code                       | `` `{children}` ``       |
+|                     | `underline`       | Underlined text                   | `<u>{children}</u>`      |
+|                     | `strike-through`  | Strikethrough                     | `~~{children}~~`         |
+|                     | `link`            | Links                             | `[{children}](url)`      |
+| `listItem`          |                   | List items (bullet, number, task) | `- `, `1. `, or `- [x] ` |
+| `hardBreak`         |                   | Line breaks within blocks         | `  \n` (two spaces)      |
+| `blockSpacing`      |                   | Spacing between blocks            | `\n\n`, `\n`, `\n>\n`    |
+| `unknownType`       |                   | Unknown block types               | JSON code block          |
+| `unknownBlockStyle` |                   | Unknown block styles              | `{children}`             |
+| `unknownListItem`   |                   | Unknown list item types           | `- {children}`           |
+| `unknownMark`       |                   | Unknown marks                     | `{children}`             |
 Unknown types render as JSON code blocks by default; unknown styles, list items, and marks pass through their children.
+The default type renderers are collision-safe: because the serializer dispatches on the `_type` name alone, `code`, `html`, `image`, `callout`, and `table` fall back to the `unknownType` renderer (a JSON code block) when a value doesn't match the shape their renderer expects (say, your own differently-shaped `code` type); `horizontal-rule` has no shape to check and always renders `---`. Register your own `types.<name>` renderer to override how any of them serialize, or to handle a same-named type of a different shape.
 > **Note:** The `underline` renderer is included for Portable Text that uses it, but there's no standard Markdown syntax for underline, so it renders as HTML.
 #### Configuring renderers
 Provide custom renderers to control how Portable Text renders to Markdown.
-**Custom type renderers:** Render custom block types (objects in the blocks array):
+**Custom type renderers:** Render custom block types (objects in the blocks array). A custom renderer under a default's name (see [Default renderers](#default-renderers)) replaces that default:
 ```ts
 portableTextToMarkdown(blocks, {
@@ -500,31 +538,19 @@ portableTextToMarkdown(blocks, {
 })
 ```
-**Built-in type renderers:** The library exports default renderers for common block types:
+**Built-in type renderers:** the library exports every built-in type renderer, in case you want to compose one into a different renderer or reuse it under a different type name. Two of them are exported but not registered by default: `DefaultBlockquoteObjectRenderer` and `DefaultListRenderer` render the structural container shapes (`types.blockquote`/`types.list` on the parser side) and stay opt-in, since the parser only produces those shapes when a matcher is registered for them:
 ```ts
 import {
   DefaultBlockquoteObjectRenderer,
-  DefaultCalloutRenderer,
-  DefaultCodeBlockRenderer,
-  DefaultHorizontalRuleRenderer,
-  DefaultHtmlRenderer,
-  DefaultImageRenderer,
   DefaultListRenderer,
-  DefaultTableRenderer,
   portableTextToMarkdown,
 } from '@portabletext/markdown'
 portableTextToMarkdown(blocks, {
   types: {
-    'blockquote': DefaultBlockquoteObjectRenderer,
-    'callout': DefaultCalloutRenderer,
-    'code': DefaultCodeBlockRenderer,
-    'horizontal-rule': DefaultHorizontalRuleRenderer,
-    'html': DefaultHtmlRenderer,
-    'image': DefaultImageRenderer,
-    'list': DefaultListRenderer,
-    'table': DefaultTableRenderer,
+    blockquote: DefaultBlockquoteObjectRenderer,
+    list: DefaultListRenderer,
   },
 })
 ```

package/dist/index.d.ts CHANGED Viewed

@@ -454,13 +454,13 @@ declare const DefaultImageRenderer: PortableTextTypeRenderer<{
 /**
  * Renders a Portable Text table block-object back to Markdown.
  *
- * The PT `headerRows` field decides the header. `headerRows === 0` is an
- * explicit headerless table: GFM has no headerless form, so an empty header
- * row is emitted and every row goes in the body (that empty header reads back
- * as `headerRows: 0` via `markdownToPortableText`). Any other value
- * (`undefined` or `>= 1`) promotes `rows[0]` to the header. GFM allows exactly
- * one header row, so header rows beyond the first flatten into the body,
- * lossy, but the extra rows stay on the Portable Text side.
+ * The PT `headerRows` field decides the header. Missing `headerRows` and
+ * `headerRows === 0` both render headerless: GFM has no headerless form, so
+ * an empty header row is emitted and every row goes in the body (that empty
+ * header reads back as `headerRows: 0` via `markdownToPortableText`).
+ * `headerRows >= 1` promotes `rows[0]` to the header. GFM allows exactly one
+ * header row, so header rows beyond the first flatten into the body, lossy,
+ * but the extra rows stay on the Portable Text side.
  *
  * Asymmetric tables (rows of varying cell counts) are widened to match
  * the row with the most cells. Narrower rows are padded with empty cells

package/dist/index.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.ts","names":[],"sources":["../../../node_modules/.pnpm/@portabletext+types@4.0.2/node_modules/@portabletext/types/dist/index.d.ts","../src/from-portable-text/renderers/block-spacing.ts","../src/from-portable-text/types.ts","../src/from-portable-text/portable-text-to-markdown.ts","../src/from-portable-text/renderers/hard-break.ts","../src/from-portable-text/renderers/list-item.ts","../src/from-portable-text/renderers/style.ts","../src/from-portable-text/renderers/marks.ts","../src/from-portable-text/renderers/type.ts","../src/to-portable-text/matchers.ts","../src/to-portable-text/markdown-to-portable-text.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;UAKU;;;;;EAKR;;;;;EAKA;;;;;;KAMG,uBAAuB;GACzB;;;;;;;;;;;;;UAaO,oBAAkB,UAAU,6BAA6B,4BAA4B,UAAU,cAAc,uBAAuB,kBAAkB,mBAAmB,wBAAwB,mBAAmB,kCAAkC;;;;;;;EAO9P;;;;;;EAMA;;;;;EAKA,UAAU;;;;;;EAMV,WAAW;;;;;EAKX,QAAQ;;;;;EAKR,WAAW;;;;EAIX;;;;;;;;;;;UAWQ,0BAA0B,UAAU,6BAA6B,4BAA4B,UAAU,cAAc,kBAAkB,mBAAmB,wBAAwB,mBAAmB,kCAAkC,KAAK,oBAAkB,GAAG,GAAG,GAAG;EAC/Q,UAAU;;;;;;KAMP;;;;;KAKA;;;;;;;UAOK;;;;GAIP;;;;;EAKD;;;;EAIA;;;;;;UAMQ;;;;EAIR;;;;EAIA;;;;EAIA;;;;;;EAMA;;;;;KCnIU,wBAAwB;EAClC,SAAS;EACT,MAAM;;;;;cAMK,6BAA6B;KCRrC,YAAY,kBAAkB,KAAK,eAAe,QACpD,KAAK,KAAK;;;;;;KAQD,qBAAqB,MAC/B,SAAS,4BAA4B;;;;;;KAQ3B,4BAA4B,qBAAqB;;;;;;KAOjD,+BACV,qBAAqB;;;;;;KAOX,yBAAyB,UAAU,sBAC7C,SAAS,gCAAgC;;;;KAM/B,yBAAyB,UAAU,sBAC7C,SAAS,gCAAgC;;;;;;;UAS1B;;;;;;;;;;;EAWf,OAAO,eAAe;;;;;;;EAQtB,OAAO,eAAe;;;;;;;;;EAUtB,OACI,YAAY,wBAAwB,yCACpC;;;;;;;;;EAUJ,UACI,YACE,0BACA,4CAEF;;;;;EAMJ;;;;;EAMA,aAAa;;;;;EAMb,aAAa,qBAAqB;;;;;EAMlC,mBAAmB,qBAAqB;;;;;EAMxC,iBAAiB,qBAAqB;;;;;;;UAQvB,4BAA4B;;;;EAI3C,OAAO;;;;EAKP;;;;EAKA;;;;;;;;EASA;;;;;EAMA;;;;EAKA;;;;;;EAOA,YAAY;;;;;;;KAQF,gCAAgC,KAAK,KAC/C,4BAA4B;;;;;;UASb,gCACf,UAAU,cAAc;;;;EAKxB,QAAQ;;;;EAKR;;;;EAKA;;;;EAKA;;;;EAKA;;;;;;EAOA,YAAY;;;;;;KAOF;GACN;EAAuB;IACzB;KAEQ,cAAc,UAAU,aAClC,SAAS,aAAa;UAGP,aAAa;EAC5B,MAAM;EACN;EACA;EACA,YAAY;;~~KCzLT~~,YAAU,QAAQ;EACrB,eAAe;;;;;iBAMD,uBACd,cAAc,cAAc,sBAAoB,sBAChD,QAAQ,MAAM,QAAQ,UAAS;;;;~~cC3EpB~~;;;;cCEA,yBAAyB;KCFjC,8BAA4B,qBAAqB;;;;cAKzC,uBAAuB;;;;cAcvB,2BAA2B;;;;cAkB3B,mBAAmB;;;;cAMnB,mBAAmB;;;;cAMnB,mBAAmB;;;;cAMnB,mBAAmB;;;;cAMnB,mBAAmB;;;;cAMnB,mBAAmB;;;;cC/DnB,mBAAmB;;;;cAMnB,uBAAuB;;;;cAMvB,qBAAqB;;;;cAMrB,0BAA0B;;;;cAO1B,8BAA8B;UAIjC,oBAAoB;EAC5B;EACA;EACA;;;;;cAMW,qBAAqB,yBAAyB;;;;~~cClC9C~~,0BAA0B;EACrC;EACA;EACA;;;;;~~cAQW~~,+BAA+B;;;;cAO/B,qBAAqB;EAChC;EACA;;;;;~~cAQW~~,sBAAsB;EACjC;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;~~cAwBW~~,sBAAsB;EACjC;EACA;EACA,WAAW;EACX,MAAM;IACJ;IACA,OAAO;MACL;MACA,OAAO,MAAM;;;;;;;~~cAwGN~~,wBAAwB;EACnC;EACA;EACA,SAAS,MAAM;;;;;;;;;;;;;;~~cAiCJ~~,iCAAiC;EAC5C;EACA,SAAS,MAAM;;;;;;;;;;;;cA6BJ,qBAAqB;EAChC;EACA;EACA,OAAO;IACL;IACA;IACA;IACA,SAAS,MAAM,sBAAoB;;;;;;;;~~KClP3B~~,kBACV;EAEA;IAAU,QAAQ;;;;;;;;KAwBR,qBACV;EAEA;IAAU,QAAQ;;;;;;;;KAwBR,sBACV;EAEA;IAAU,QAAQ;;;;;;;;KAwBR,kBACV,eAAe,0BAA0B,4BAEzC,SACA;EAEA;IAAU,QAAQ;IAAQ;;EAC1B,OAAO;MACH;;;;;;KAuCM,cACV,eAAe,0BAA0B,4BAEzC,SACA,OACA;EAEA;IAAU,QAAQ;IAAQ;;EAC1B,OAAO;EACP;MACI;~~KCnGD~~;EACH,SAAS;EACT;EACA;IACE,SAAS;IACT,KAAK;IACL,OAAO;IACP,gBAAgB;IAChB,OAAO;MAAmB;MAAc;;;EAE1C;IACE,SAAS;IACT,aAAa;IACb,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;;EAEP;IACE,SAAS;IACT,SAAS;IACT,OAAO;;EAET;IACE,OAAO;MAAe;MAA8B;;IACpD,iBAAiB;IACjB,OAAO;MAAe;;IACtB,QAAQ;MACN;MACA,WAAW;MACX,MAAM;QACJ;QACA;QACA,OAAO;UACL;UACA;UACA,OAAO,MAAM;;;;IAInB,QAAQ;MAAe;MAAa;MAAa;;IACjD,UAAU;MAAe;MAAc,SAAS,MAAM;;IACtD,aAAa;MAAe,SAAS,MAAM;;IAC3C,OAAO;MACL;MACA,OAAO;QACL;QACA;QACA;QACA,SAAS,MAAM,oBAAoB;;;;EAIzC;;;;;;;;IAQE;;;;;;;;~~iBAqJY~~,uBACd,kBACA,UAAU,UACT,MAAM"}
1	+ {"version":3,"file":"index.d.ts","names":[],"sources":["../../../node_modules/.pnpm/@portabletext+types@4.0.2/node_modules/@portabletext/types/dist/index.d.ts","../src/from-portable-text/renderers/block-spacing.ts","../src/from-portable-text/types.ts","../src/from-portable-text/portable-text-to-markdown.ts","../src/from-portable-text/renderers/hard-break.ts","../src/from-portable-text/renderers/list-item.ts","../src/from-portable-text/renderers/style.ts","../src/from-portable-text/renderers/marks.ts","../src/from-portable-text/renderers/type.ts","../src/to-portable-text/matchers.ts","../src/to-portable-text/markdown-to-portable-text.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;UAKU;;;;;EAKR;;;;;EAKA;;;;;;KAMG,uBAAuB;GACzB;;;;;;;;;;;;;UAaO,oBAAkB,UAAU,6BAA6B,4BAA4B,UAAU,cAAc,uBAAuB,kBAAkB,mBAAmB,wBAAwB,mBAAmB,kCAAkC;;;;;;;EAO9P;;;;;;EAMA;;;;;EAKA,UAAU;;;;;;EAMV,WAAW;;;;;EAKX,QAAQ;;;;;EAKR,WAAW;;;;EAIX;;;;;;;;;;;UAWQ,0BAA0B,UAAU,6BAA6B,4BAA4B,UAAU,cAAc,kBAAkB,mBAAmB,wBAAwB,mBAAmB,kCAAkC,KAAK,oBAAkB,GAAG,GAAG,GAAG;EAC/Q,UAAU;;;;;;KAMP;;;;;KAKA;;;;;;;UAOK;;;;GAIP;;;;;EAKD;;;;EAIA;;;;;;UAMQ;;;;EAIR;;;;EAIA;;;;EAIA;;;;;;EAMA;;;;;KCnIU,wBAAwB;EAClC,SAAS;EACT,MAAM;;;;;cAMK,6BAA6B;KCRrC,YAAY,kBAAkB,KAAK,eAAe,QACpD,KAAK,KAAK;;;;;;KAQD,qBAAqB,MAC/B,SAAS,4BAA4B;;;;;;KAQ3B,4BAA4B,qBAAqB;;;;;;KAOjD,+BACV,qBAAqB;;;;;;KAOX,yBAAyB,UAAU,sBAC7C,SAAS,gCAAgC;;;;KAM/B,yBAAyB,UAAU,sBAC7C,SAAS,gCAAgC;;;;;;;UAS1B;;;;;;;;;;;EAWf,OAAO,eAAe;;;;;;;EAQtB,OAAO,eAAe;;;;;;;;;EAUtB,OACI,YAAY,wBAAwB,yCACpC;;;;;;;;;EAUJ,UACI,YACE,0BACA,4CAEF;;;;;EAMJ;;;;;EAMA,aAAa;;;;;EAMb,aAAa,qBAAqB;;;;;EAMlC,mBAAmB,qBAAqB;;;;;EAMxC,iBAAiB,qBAAqB;;;;;;;UAQvB,4BAA4B;;;;EAI3C,OAAO;;;;EAKP;;;;EAKA;;;;;;;;EASA;;;;;EAMA;;;;EAKA;;;;;;EAOA,YAAY;;;;;;;KAQF,gCAAgC,KAAK,KAC/C,4BAA4B;;;;;;UASb,gCACf,UAAU,cAAc;;;;EAKxB,QAAQ;;;;EAKR;;;;EAKA;;;;EAKA;;;;EAKA;;;;;;EAOA,YAAY;;;;;;KAOF;GACN;EAAuB;IACzB;KAEQ,cAAc,UAAU,aAClC,SAAS,aAAa;UAGP,aAAa;EAC5B,MAAM;EACN;EACA;EACA,YAAY;;KC1KT,YAAU,QAAQ;EACrB,eAAe;;;;;iBAMD,uBACd,cAAc,cAAc,sBAAoB,sBAChD,QAAQ,MAAM,QAAQ,UAAS;;;;cC1FpB;;;;cCEA,yBAAyB;KCFjC,8BAA4B,qBAAqB;;;;cAKzC,uBAAuB;;;;cAcvB,2BAA2B;;;;cAkB3B,mBAAmB;;;;cAMnB,mBAAmB;;;;cAMnB,mBAAmB;;;;cAMnB,mBAAmB;;;;cAMnB,mBAAmB;;;;cAMnB,mBAAmB;;;;cC/DnB,mBAAmB;;;;cAMnB,uBAAuB;;;;cAMvB,qBAAqB;;;;cAMrB,0BAA0B;;;;cAO1B,8BAA8B;UAIjC,oBAAoB;EAC5B;EACA;EACA;;;;;cAMW,qBAAqB,yBAAyB;;;;cCjC9C,0BAA0B;EACrC;EACA;EACA;;;;;cA6BW,+BAA+B;;;;cAO/B,qBAAqB;EAChC;EACA;;;;;cAeW,sBAAsB;EACjC;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;cA6EW,sBAAsB;EACjC;EACA;EACA,WAAW;EACX,MAAM;IACJ;IACA,OAAO;MACL;MACA,OAAO,MAAM;;;;;;;cAoHN,wBAAwB;EACnC;EACA;EACA,SAAS,MAAM;;;;;;;;;;;;;;cAgDJ,iCAAiC;EAC5C;EACA,SAAS,MAAM;;;;;;;;;;;;cA6BJ,qBAAqB;EAChC;EACA;EACA,OAAO;IACL;IACA;IACA;IACA,SAAS,MAAM,sBAAoB;;;;;;;;KC/V3B,kBACV;EAEA;IAAU,QAAQ;;;;;;;;KAwBR,qBACV;EAEA;IAAU,QAAQ;;;;;;;;KAwBR,sBACV;EAEA;IAAU,QAAQ;;;;;;;;KAwBR,kBACV,eAAe,0BAA0B,4BAEzC,SACA;EAEA;IAAU,QAAQ;IAAQ;;EAC1B,OAAO;MACH;;;;;;KAuCM,cACV,eAAe,0BAA0B,4BAEzC,SACA,OACA;EAEA;IAAU,QAAQ;IAAQ;;EAC1B,OAAO;EACP;MACI;KClGD;EACH,SAAS;EACT;EACA;IACE,SAAS;IACT,KAAK;IACL,OAAO;IACP,gBAAgB;IAChB,OAAO;MAAmB;MAAc;;;EAE1C;IACE,SAAS;IACT,aAAa;IACb,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;;EAEP;IACE,SAAS;IACT,SAAS;IACT,OAAO;;EAET;IACE,OAAO;MAAe;MAA8B;;IACpD,iBAAiB;IACjB,OAAO;MAAe;;IACtB,QAAQ;MACN;MACA,WAAW;MACX,MAAM;QACJ;QACA;QACA,OAAO;UACL;UACA;UACA,OAAO,MAAM;;;;IAInB,QAAQ;MAAe;MAAa;MAAa;;IACjD,UAAU;MAAe;MAAc,SAAS,MAAM;;IACtD,aAAa;MAAe,SAAS,MAAM;;IAC3C,OAAO;MACL;MACA,OAAO;QACL;QACA;QACA;QACA,SAAS,MAAM,oBAAoB;;;;EAIzC;;;;;;;;IAQE;;;;;;;;iBAuKY,uBACd,kBACA,UAAU,UACT,MAAM"}

package/dist/index.js CHANGED Viewed

@@ -1,4 +1,4 @@
-import { compileSchema, defineSchema, isSpan, isTextBlock } from "@portabletext/schema";
+import { compileSchema, defineSchema, isSpan, isTextBlock, isTypedObject } from "@portabletext/schema";
 import { buildMarksTree, isPortableTextBlock, isPortableTextListItemBlock, isPortableTextToolkitSpan, isPortableTextToolkitTextNode, spanToPlainText } from "@portabletext/toolkit";
 import { alert } from "@mdit/plugin-alert";
 import markdownit from "markdown-it";
@@ -255,11 +255,75 @@ function uriLooksSafe(uri) {
 /**
 * @public
 */
-const DefaultUnknownMarkRenderer = ({ children }) => children, DefaultNormalRenderer = ({ children }) => !children || children.trim() === "" ? "" : children, DefaultBlockquoteRenderer = ({ children }) => children ? children.split("\n").map((line) => `> ${line}`).join("\n") : ">", DefaultH1Renderer = ({ children }) => `# ${children}`, DefaultH2Renderer = ({ children }) => `## ${children}`, DefaultH3Renderer = ({ children }) => `### ${children}`, DefaultH4Renderer = ({ children }) => `#### ${children}`, DefaultH5Renderer = ({ children }) => `##### ${children}`, DefaultH6Renderer = ({ children }) => `###### ${children}`, DefaultUnknownStyleRenderer = ({ children }) => children ?? "", DefaultCodeBlockRenderer = ({ value }) => `\`\`\`${value.language ?? ""}\n${value.code}\n\`\`\``, DefaultHorizontalRuleRenderer = () => "---", DefaultHtmlRenderer = ({ value }) => value.html, DefaultImageRenderer = ({ value }) => {
-	let alt = escapeImageAndLinkText(value.alt ?? ""), title = value.title ? ` "${escapeImageAndLinkTitle(value.title)}"` : "";
-	return `![${alt}](${value.src}${title})`;
-}, DefaultTableRenderer = ({ value, renderNode }) => {
-	let rows = value.rows, alignment = value.alignment, headerRow = rows.at(0);
+const DefaultUnknownMarkRenderer = ({ children }) => children, DefaultNormalRenderer = ({ children }) => !children || children.trim() === "" ? "" : children, DefaultBlockquoteRenderer = ({ children }) => children ? children.split("\n").map((line) => `> ${line}`).join("\n") : ">", DefaultH1Renderer = ({ children }) => `# ${children}`, DefaultH2Renderer = ({ children }) => `## ${children}`, DefaultH3Renderer = ({ children }) => `### ${children}`, DefaultH4Renderer = ({ children }) => `#### ${children}`, DefaultH5Renderer = ({ children }) => `##### ${children}`, DefaultH6Renderer = ({ children }) => `###### ${children}`, DefaultUnknownStyleRenderer = ({ children }) => children ?? "", DefaultCodeBlockRenderer = (options) => isCodeShaped(options.value) ? `\`\`\`${normalizeLanguage(options.value.language)}\n${options.value.code}\n\`\`\`` : DefaultUnknownTypeRenderer(options);
+function isCodeShaped(value) {
+	return typeof value?.code == "string";
+}
+/**
+* A fence info string is everything after the opening fence on the same
+* line, so a real `language` can never contain a newline, and the parser
+* only ever produces a string. Junk in this optional field should not send
+* an otherwise valid code block to the fenced-JSON path, so it is treated
+* as absent instead of guarded.
+*/
+function normalizeLanguage(language) {
+	return typeof language != "string" || language.includes("\n") ? "" : language;
+}
+/**
+* @public
+*/
+const DefaultHorizontalRuleRenderer = () => "---", DefaultHtmlRenderer = (options) => isHtmlShaped(options.value) ? options.value.html : DefaultUnknownTypeRenderer(options);
+function isHtmlShaped(value) {
+	return typeof value?.html == "string";
+}
+/**
+* @public
+*/
+const DefaultImageRenderer = (options) => {
+	if (!isImageShaped(options.value)) return DefaultUnknownTypeRenderer(options);
+	let alt = escapeImageAndLinkText(options.value.alt ?? ""), title = options.value.title ? ` "${escapeImageAndLinkTitle(options.value.title)}"` : "";
+	return `![${alt}](${options.value.src}${title})`;
+};
+function isImageShaped(value) {
+	let image = value;
+	return typeof image?.src == "string" && (image.alt == null || typeof image.alt == "string") && (image.title == null || typeof image.title == "string");
+}
+/**
+* A table is table-shaped when everything the renderer dereferences is
+* there: `rows` an array of typed objects with a `cells` array, every cell
+* a typed object whose `value` array holds typed objects (`renderNode`'s
+* input contract). The predicate narrows to exactly what `renderTable`
+* consumes, so the renderer needs no casts. A malformed `table` value
+* (e.g. a consumer's differently-shaped `table` type) falls back to the
+* fenced-JSON path instead of throwing.
+*/
+function isTableShaped(value) {
+	let rows = value?.rows;
+	return Array.isArray(rows) && rows.every((row) => isTypedObject(row) && Array.isArray(row.cells) && row.cells.every((cell) => isTypedObject(cell) && Array.isArray(cell.value) && cell.value.every(isTypedObject)));
+}
+/**
+* Renders a Portable Text table block-object back to Markdown.
+*
+* The PT `headerRows` field decides the header. Missing `headerRows` and
+* `headerRows === 0` both render headerless: GFM has no headerless form, so
+* an empty header row is emitted and every row goes in the body (that empty
+* header reads back as `headerRows: 0` via `markdownToPortableText`).
+* `headerRows >= 1` promotes `rows[0]` to the header. GFM allows exactly one
+* header row, so header rows beyond the first flatten into the body, lossy,
+* but the extra rows stay on the Portable Text side.
+*
+* Asymmetric tables (rows of varying cell counts) are widened to match
+* the row with the most cells. Narrower rows are padded with empty cells
+* so a GFM parser doesn't silently drop the extra cells in wider rows.
+*
+* @public
+*/
+const DefaultTableRenderer = (options) => {
+	let { value, renderNode } = options;
+	return isTableShaped(value) ? renderTable(value, renderNode) : DefaultUnknownTypeRenderer(options);
+};
+function renderTable(value, renderNode) {
+	let rows = value.rows, alignment = Array.isArray(value.alignment) ? value.alignment : void 0, headerRow = rows.at(0);
 	if (!headerRow) return "";
 	let getCellText = (cellBlocks) => cellBlocks.map((block, index) => renderNode({
 		node: block,
@@ -274,33 +338,55 @@ const DefaultUnknownMarkRenderer = ({ children }) => children, DefaultNormalRend
 		let align = alignment?.at(index);
 		return align === "left" ? " :--- " : align === "center" ? " :---: " : align === "right" ? " ---: " : " --- ";
 	}).join("|")}|`;
-	if (value.headerRows === 0) {
-		lines.push(renderCells([])), lines.push(delimiter);
-		for (let row of rows) lines.push(renderRow(row.cells));
-	} else {
+	if ((Number(value.headerRows) || 0) >= 1) {
 		lines.push(renderRow(headerRow.cells)), lines.push(delimiter);
 		for (let i = 1; i < rows.length; i++) {
 			let row = rows.at(i);
 			row && lines.push(renderRow(row.cells));
 		}
+	} else {
+		lines.push(renderCells([])), lines.push(delimiter);
+		for (let row of rows) lines.push(renderRow(row.cells));
 	}
 	return lines.join("\n");
-}, DefaultCalloutRenderer = ({ value, renderNode }) => {
-	let prefixed = value.content.map((block, index) => renderNode({
-		node: {
+}
+/**
+* @public
+*/
+const DefaultCalloutRenderer = (options) => {
+	if (!isCalloutShaped(options.value)) return DefaultUnknownTypeRenderer(options);
+	let { renderNode } = options, prefixed = options.value.content.map((block, index) => renderNode({
+		node: block._type === "block" ? {
 			...block,
 			style: "normal"
-		},
+		} : block,
 		index,
 		isInline: !1,
 		renderNode
 	})).join("\n\n").split("\n").map((line) => line === "" ? ">" : `> ${line}`).join("\n");
-	return `> [!${value.tone.toUpperCase()}]\n${prefixed}`;
-}, DefaultBlockquoteObjectRenderer = ({ value, renderNode }) => value.content.map((block, index) => renderNode({
-	node: {
+	return `> [!${options.value.tone.toUpperCase()}]\n${prefixed}`;
+};
+function isCalloutShaped(value) {
+	let callout = value;
+	return typeof callout?.tone == "string" && Array.isArray(callout.content) && callout.content.every(isTypedObject);
+}
+/**
+* Renders a structural blockquote block-object (the `types.blockquote` shape
+* produced by `markdownToPortableText` when a `types.blockquote` matcher is
+* provided) back to Markdown. Each content block is rendered via the
+* recursive renderer pipeline, joined with blank lines, and every line is
+* prefixed with `> ` to form a Markdown blockquote.
+*
+* Distinct from `DefaultBlockquoteRenderer`, which renders flat-path text
+* blocks with `style: 'blockquote'`.
+*
+* @public
+*/
+const DefaultBlockquoteObjectRenderer = ({ value, renderNode }) => value.content.map((block, index) => renderNode({
+	node: block._type === "block" ? {
 		...block,
 		style: "normal"
-	},
+	} : block,
 	index,
 	isInline: !1,
 	renderNode
@@ -332,7 +418,14 @@ const DefaultUnknownTypeRenderer = ({ value, isInline }) => {
 	let json = `\`\`\`json\n${JSON.stringify(value, null, 2)}\n\`\`\``;
 	return isInline ? `\n${json}\n` : json;
 }, defaultRenderers = {
-	types: {},
+	types: {
+		callout: DefaultCalloutRenderer,
+		code: DefaultCodeBlockRenderer,
+		"horizontal-rule": DefaultHorizontalRuleRenderer,
+		html: DefaultHtmlRenderer,
+		image: DefaultImageRenderer,
+		table: DefaultTableRenderer
+	},
 	block: {
 		normal: DefaultNormalRenderer,
 		blockquote: DefaultBlockquoteRenderer,
@@ -453,7 +546,24 @@ const normalStyleDefinition = { name: "normal" }, h1StyleDefinition = { name: "h
 		},
 		{
 			name: "rows",
-			type: "array"
+			type: "array",
+			of: [{
+				type: "object",
+				name: "row",
+				fields: [{
+					name: "cells",
+					type: "array",
+					of: [{
+						type: "object",
+						name: "cell",
+						fields: [{
+							name: "value",
+							type: "array",
+							of: [{ type: "block" }, { type: "image" }]
+						}]
+					}]
+				}]
+			}]
 		}
 	]
 }, defaultCalloutObjectDefinition = {
@@ -564,6 +674,13 @@ const codeBlockMatcher = ({ context, value, isInline }) => {
 		isInline
 	});
 	if (imageObject && "src" in imageObject) return imageObject;
+}, tableBlockMatcher = ({ context, value, isInline }) => {
+	let tableObject = buildObjectMatcher(defaultTableObjectDefinition)({
+		context,
+		value,
+		isInline
+	});
+	if (tableObject && "rows" in tableObject) return tableObject;
 }, defaultOptions = {
 	schema: defaultSchema,
 	keyGenerator: defaultKeyGenerator,
@@ -595,7 +712,8 @@ const codeBlockMatcher = ({ context, value, isInline }) => {
 		horizontalRule: buildObjectMatcher(defaultHorizontalRuleObjectDefinition),
 		html: buildObjectMatcher(defaultHtmlObjectDefinition),
 		image: imageBlockMatcher,
-		callout: buildObjectMatcher(defaultCalloutObjectDefinition)
+		callout: buildObjectMatcher(defaultCalloutObjectDefinition),
+		table: tableBlockMatcher
 	}
 };
 /**