@portabletext/markdown 2.1.0 → 2.2.0

package/dist/index.d.ts

@@ -359,196 +359,24 @@ interface Serializable<T> {
 }
 type Options$1 = Partial<PortableTextRenderers> & {
   blockSpacing?: BlockSpacingRenderer;
+  /**
+   * Compiled schema that gates the built-in type renderers; it never
+   * validates the value. A default renderer runs only when the schema
+   * declares its type (`blockObjects` for block position, `inlineObjects`
+   * for inline); undeclared types render through `unknownType`, whose
+   * default output reparses back to the same value. The gate checks the
+   * type name only, so declare the type's fields too:
+   * `markdownToPortableText` cannot rebuild a value from a fieldless
+   * declaration. Renderers passed in `types` are never gated. Pass the
+   * same schema to `markdownToPortableText` to keep the round trip
+   * consistent. Omitted, all default renderers stay active.
+   */
+  schema?: Schema;
 };
 /**
  * @public
  */
 declare function portableTextToMarkdown<Block extends TypedObject = PortableTextBlock$1 | ArbitraryTypedObject>(blocks: Array<Block>, options?: Options$1): string;
-/**
- * @public
- */
-declare const DefaultHardBreakRenderer: () => string;
-/**
- * @public
- */
-declare const DefaultListItemRenderer: PortableTextListItemRenderer;
-type PortableTextBlockRenderer$1 = PortableTextRenderer<PortableTextBlock$1>;
-/**
- * @public
- */
-declare const DefaultNormalRenderer: PortableTextBlockRenderer$1;
-/**
- * @public
- */
-declare const DefaultBlockquoteRenderer: PortableTextBlockRenderer$1;
-/**
- * @public
- */
-declare const DefaultH1Renderer: PortableTextBlockRenderer$1;
-/**
- * @public
- */
-declare const DefaultH2Renderer: PortableTextBlockRenderer$1;
-/**
- * @public
- */
-declare const DefaultH3Renderer: PortableTextBlockRenderer$1;
-/**
- * @public
- */
-declare const DefaultH4Renderer: PortableTextBlockRenderer$1;
-/**
- * @public
- */
-declare const DefaultH5Renderer: PortableTextBlockRenderer$1;
-/**
- * @public
- */
-declare const DefaultH6Renderer: PortableTextBlockRenderer$1;
-/**
- * @public
- */
-declare const DefaultEmRenderer: PortableTextMarkRenderer;
-/**
- * @public
- */
-declare const DefaultStrongRenderer: PortableTextMarkRenderer;
-/**
- * Renders a `code` decorator from the raw span text, bypassing the escaped
- * `children`: code content is verbatim, never markdown syntax. The
- * backtick fence is widened past the longest run of backticks already in
- * the text (CommonMark: the fence must be longer than any run it encloses).
- *
- * A space is padded on each side when the content starts or ends with a
- * backtick, so the fence and the content's own backtick never merge into
- * one run, and also when the content starts and ends with a space and
- * isn't all whitespace (`text.trim() !== ''`; an all-space code span has
- * nothing else for CommonMark's strip rule to leave behind, so padding it
- * would only add visible spaces), because CommonMark itself would
- * otherwise strip one such space per side on reparse; the padding
- * pre-compensates for that strip.
- *
- * @public
- */
-declare const DefaultCodeRenderer: PortableTextMarkRenderer;
-/**
- * @public
- */
-declare const DefaultUnderlineRenderer: PortableTextMarkRenderer;
-/**
- * @public
- */
-declare const DefaultStrikeThroughRenderer: PortableTextMarkRenderer;
-interface DefaultLink extends TypedObject {
-  _type: 'link';
-  href: string;
-  title: string | undefined;
-}
-/**
- * @public
- */
-declare const DefaultLinkRenderer: PortableTextMarkRenderer<DefaultLink>;
-/**
- * @public
- */
-declare const DefaultCodeBlockRenderer: PortableTextTypeRenderer<{
-  _type: 'code';
-  code: string;
-  language: string | undefined;
-}>;
-/**
- * @public
- */
-declare const DefaultHorizontalRuleRenderer: PortableTextTypeRenderer;
-/**
- * @public
- */
-declare const DefaultHtmlRenderer: PortableTextTypeRenderer<{
-  _type: 'html';
-  html: string;
-}>;
-/**
- * @public
- */
-declare const DefaultImageRenderer: PortableTextTypeRenderer<{
-  _type: 'image';
-  src: string;
-  alt: string | undefined;
-  title: string | undefined;
-}>;
-/**
- * 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
- */
-declare const DefaultTableRenderer: PortableTextTypeRenderer<{
-  _type: 'table';
-  headerRows: number | undefined;
-  alignment: Array<'left' | 'center' | 'right' | null> | undefined;
-  rows: Array<{
-    _key: string;
-    cells: Array<{
-      _key: string;
-      value: Array<PortableTextBlock$1>;
-    }>;
-  }>;
-}>;
-/**
- * @public
- */
-declare const DefaultCalloutRenderer: PortableTextTypeRenderer<{
-  _type: 'callout';
-  tone: string;
-  content: Array<PortableTextBlock$1>;
-}>;
-/**
- * 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
- */
-declare const DefaultBlockquoteObjectRenderer: PortableTextTypeRenderer<{
-  _type: 'blockquote';
-  content: Array<PortableTextBlock$1>;
-}>;
-/**
- * Renders a structural list block-object (the `types.list` shape produced by
- * `markdownToPortableText` when a `types.list` matcher is provided) back to
- * Markdown. Items render as `- ` for `kind: 'bullet'`, `1. `/`2. ` for `'number'`,
- * and `- [x] ` / `- [ ] ` for `'task'`. Items can hold any blocks - text blocks,
- * code blocks, callouts, images, and nested lists - and content other than the
- * leading text block is indented to keep it inside the item.
- *
- * @public
- */
-declare const DefaultListRenderer: PortableTextTypeRenderer<{
-  _type: 'list';
-  kind: 'bullet' | 'number' | 'task';
-  items: Array<{
-    _type: 'list-item';
-    _key: string;
-    checked?: boolean;
-    content: Array<PortableTextBlock$1 | TypedObject>;
-  }>;
-}>;
 /**
  * Matcher function for mapping markdown elements to Portable Text block styles.
  *
@@ -642,6 +470,11 @@ type Degradation = {
   snippet?: string;
 };
 type Options = {
+  /**
+   * Compiled schema deciding which Portable Text constructs the
+   * conversion may build; pairs with the same option on
+   * `portableTextToMarkdown` to keep the round trip consistent.
+   */
   schema?: Schema;
   keyGenerator?: () => string;
   /**
@@ -751,5 +584,401 @@ type Options = {
  * @public
  */
 declare function markdownToPortableText(markdown: string, options?: Options): Array<PortableTextBlock>;
-export { type AnnotationMatcher, type BlockSpacingRenderer, type DecoratorMatcher, DefaultBlockSpacingRenderer, DefaultBlockquoteObjectRenderer, DefaultBlockquoteRenderer, DefaultCalloutRenderer, DefaultCodeBlockRenderer, DefaultCodeRenderer, DefaultEmRenderer, DefaultH1Renderer, DefaultH2Renderer, DefaultH3Renderer, DefaultH4Renderer, DefaultH5Renderer, DefaultH6Renderer, DefaultHardBreakRenderer, DefaultHorizontalRuleRenderer, DefaultHtmlRenderer, DefaultImageRenderer, DefaultLinkRenderer, DefaultListItemRenderer, DefaultListRenderer, DefaultNormalRenderer, DefaultStrikeThroughRenderer, DefaultStrongRenderer, DefaultTableRenderer, DefaultUnderlineRenderer, type Degradation, type ListItemMatcher, type ObjectMatcher, type PortableTextBlockRenderer, type PortableTextListItemRenderer, type PortableTextMarkRenderer, type PortableTextMarkRendererOptions, type PortableTextRenderer, type PortableTextRendererOptions, type PortableTextRenderers, type PortableTextTypeRenderer, type PortableTextTypeRendererOptions, type StyleMatcher, markdownToPortableText, portableTextToMarkdown };
+/**
+ * @public
+ */
+type ApplyMarkdownEditOptions = {
+  /**
+   * One compiled schema governing both conversion directions, the same
+   * object the standalone converters accept. Taking it once is what
+   * keeps the internal canonical dialect consistent: serializing and
+   * reparsing under different schemas would change node counts or
+   * types, refuse the origin trace, and reset keys document-wide.
+   */
+  schema?: Schema;
+  /**
+   * Options for the markdown → Portable Text conversion of
+   * `editedMarkdown` (matchers, `keyGenerator`). The same options
+   * also govern the internal canonicalization of `storedPortableText`
+   * used to align the two documents, except `onDegradation`, which is
+   * scoped to `editedMarkdown` alone: `keyGenerator` supplies every
+   * fresh key the function mints, both for new content and for the
+   * sibling-uniqueness key-rename sweep.
+   */
+  deserialize?: Omit<NonNullable<Parameters<typeof markdownToPortableText>[1]>, 'schema'>;
+  /**
+   * Options for the Portable Text → markdown conversion. Pass the same
+   * options that produced the markdown that was edited: key
+   * resolution aligns the edit against a fresh canonical serialization
+   * of `storedPortableText`, so the two serializations must agree for
+   * that alignment to be meaningful.
+   */
+  serialize?: Omit<NonNullable<Parameters<typeof portableTextToMarkdown>[1]>, 'schema'>;
+  /**
+   * Reports how stored `_key`s were reconciled onto the converted
+   * value. Reconciliation here is key restoration against the exact
+   * snapshot that produced the markdown, never a merge of concurrent
+   * edits: those are the caller's job (see the README's Concurrent
+   * edits section). Called at most once, and exactly once whenever the
+   * option is set and `applyMarkdownEdit` returns (a conversion that
+   * throws never reports), synchronously, immediately before the
+   * return, including when key matching is skipped outright: that is
+   * when a caller needs the report most. A node absent from a performed report's
+   * `preservedKeys` was not preserved from the stored value, whether
+   * it is a fresh key or a `json:object` payload key that carried its
+   * own; the report does not distinguish the two. Which keys
+   * survived, every `key` and `path`, and `renamedKeys` are facts of
+   * that invocation, safe to branch on for that invocation; a skipped
+   * report's `reason` is advisory only, since near the evidence caps
+   * it can vary with machine speed, and should never drive behavior.
+   *
+   * @beta
+   */
+  onReconciliation?: (report: ReconciliationReport) => void;
+};
+/**
+ * A path segment into the value `applyMarkdownEdit` returns: a string
+ * field name for container nesting (`rows`, `cells`, `value`, and the
+ * like), `{_key}` wherever the path lands on a keyed array element,
+ * and a number wherever it lands on a keyless one instead. A block's
+ * own path is a single `{_key}` segment, or a single number for a
+ * keyless top-level block; a child's path is
+ * `[{_key: <block key>}, 'children', {_key: <child key>}]`. A keyless
+ * node (a `json:object` payload without a `_key` of its own, at the
+ * top level or wrapping keyed content in a nested array) contributes
+ * its index as a number segment instead of a `{_key}` segment.
+ *
+ * @beta
+ */
+type ReconciliationKeyPath = Array<{
+  _key: string;
+} | string | number>;
+/**
+ * What `applyMarkdownEdit` did with every key, delivered through
+ * `onReconciliation`. `keyMatching: 'skipped'` means key matching gave
+ * up on the whole document rather than at some local point: the
+ * returned value is the plain markdown→Portable Text conversion, so
+ * every key in it is fresh except a `json:object` payload key carried
+ * through the markdown verbatim, and no preserved key or local key
+ * fallback can have happened. `preservedKeys` and `renamedKeys` list
+ * their entries in document order, each block before its children and
+ * its mark definitions after them; `keyFallbacks` groups by kind
+ * instead: `ambiguous-region-too-large` entries in the order their
+ * gaps were resolved, then `annotation-key-conflict` entries. `basis`
+ * names the matching method that preserved a key, not the edit's
+ * semantics: a swap reports one block `content-moved` and its partner
+ * `content-unchanged`. The report carries no edit intent: a deleted
+ * stored node is not listed at all, so derive deletions as stored
+ * keys minus the keys `applyMarkdownEdit` returned.
+ *
+ * @beta
+ */
+type ReconciliationReport = {
+  keyMatching: 'performed';
+  /**
+   * One entry per node whose stored `_key` key resolution
+   * preserved, at every depth (blocks, spans and other inline
+   * children, and mark definitions). A node absent from this list
+   * did not have its key preserved from the stored value: that
+   * covers both a freshly generated key and a `json:object`
+   * payload key carried through the markdown verbatim, which the
+   * report does not distinguish. `basis` names the tier that
+   * matched: `content-unchanged` for an exact content match (a
+   * block-level anchor, a uniquely matched child, a preserved
+   * empty-block run, or a mark definition uniquely matched by
+   * content); `content-moved` for a unique leftover matched
+   * across gaps; `content-split` for a fragment that kept its
+   * source block's key; `content-merged` for a merge that kept
+   * its first contributor's key; `same-position` for an
+   * equal-count in-order pairing (also a same-content
+   * mark-definition tie, or a single leftover mark definition
+   * paired positionally); `similar-content` for a mutual-best
+   * match under an unequal count.
+   */
+  preservedKeys: Array<{
+    basis: 'content-unchanged' | 'content-moved' | 'content-split' | 'content-merged' | 'same-position' | 'similar-content';
+    key: string;
+    path: ReconciliationKeyPath;
+  }>;
+  /**
+   * One entry per local point where key resolution gave up rather
+   * than adopt, while the rest of the document still resolves
+   * keys: `ambiguous-region-too-large` when a gap's residual
+   * similarity pairing crossed the evidence pair cap, listing the
+   * affected result block keys that fell back to fresh;
+   * `annotation-key-conflict` when an adopted mark definition key
+   * would have collided with a sibling. The span-merge pair cap,
+   * the per-diff similarity timeout, and the gap's earlier
+   * concatenation-search cap degrade the same way but are not
+   * reported: `ambiguous-region-too-large` covers the residual
+   * similarity tier only (a gap that trips the concatenation cap
+   * trips it too).
+   */
+  keyFallbacks: Array<{
+    type: 'ambiguous-region-too-large';
+    keys: Array<string>;
+  } | {
+    type: 'annotation-key-conflict';
+    path: ReconciliationKeyPath;
+  }>;
+  /**
+   * One entry per key `applyMarkdownEdit` rewrote to keep
+   * siblings unique, most commonly a `json:object` payload
+   * duplicating a key already present elsewhere in the document.
+   */
+  renamedKeys: Array<{
+    previousKey: string;
+    key: string;
+    path: ReconciliationKeyPath;
+  }>;
+} | {
+  keyMatching: 'skipped';
+  /**
+   * `round-trip-mismatch` when the stored value's own
+   * canonicalization changed its node count, type sequence, or
+   * per-position text; `document-too-large` when the document
+   * holds more distinct block forms than alignment can token.
+   * Advisory only, since near the evidence caps it can vary with
+   * machine speed, and should never drive behavior.
+   */
+  reason: 'round-trip-mismatch' | 'document-too-large';
+  /**
+   * One entry per key `applyMarkdownEdit` rewrote to keep
+   * siblings unique, most commonly a `json:object` payload
+   * duplicating a key already present elsewhere in the document.
+   * The sibling-uniqueness pass still runs on a skipped document:
+   * a pasted duplicate `json:object` fence key still gets
+   * renamed even though nothing else adopted.
+   */
+  renamedKeys: Array<{
+    previousKey: string;
+    key: string;
+    path: ReconciliationKeyPath;
+  }>;
+};
+/**
+ * Converts edited markdown to Portable Text, restores stored keys, and
+ * restores fields the markdown dialect cannot express (dropped by
+ * serialization, so the edit could not have touched them); a field
+ * markdown does express follows the edit. The same rule covers a
+ * custom style or decorator markdown has no syntax for, coerced to a
+ * built-in on the round trip. An empty or whitespace-only text block
+ * is the same case taken to the whole block: markdown has no form for
+ * either, so it is restored next to its surviving neighbor and
+ * dropped along with that neighbor if the neighbor does not survive.
+ * Keys aim for what the
+ * same edit would have produced in an editor:
+ * unchanged, moved, and rewritten-in-place content keeps its keys
+ * (rewriting a paragraph in place keeps its identity, like typing over
+ * it), a split keeps the key on its first non-empty fragment, a merge
+ * keeps the first source block's key, and a `json:object` payload keeps
+ * the key it carries, unless reconciliation matches it to stored
+ * content, which takes the stored key even over a differing key in the
+ * payload. When an insertion or deletion makes positions ambiguous,
+ * only clear similarity evidence adopts a key and everything else gets
+ * a new one; gathering that evidence is time-capped, so on very large
+ * ambiguous edits the set of adopted keys can differ across machine
+ * speeds, degrading toward fresh keys.
+ * Output keys are unique among siblings. The function does not mutate
+ * `storedPortableText` and returns a value, not patches. The `schema`
+ * is taken once and governs both directions; pass the same `serialize`
+ * options that produced the markdown that was edited. A throwing or
+ * stateful custom matcher or renderer propagates or degrades matching
+ * respectively.
+ * Reconciliation never merges concurrent edits: compare the stored
+ * field against the live document before writing the result back.
+ * The trades in one line: same-position replacement inherits identity,
+ * a count-preserving rewrite pairs positionally (block-level and
+ * sibling-level alike), and evidence gathering is capped, degrading to
+ * fresh keys.
+ *
+ * @public
+ */
+declare function applyMarkdownEdit(storedPortableText: ReadonlyArray<PortableTextBlock>, editedMarkdown: string, options?: ApplyMarkdownEditOptions): Array<PortableTextBlock>;
+/**
+ * @public
+ */
+declare const DefaultHardBreakRenderer: () => string;
+/**
+ * @public
+ */
+declare const DefaultListItemRenderer: PortableTextListItemRenderer;
+type PortableTextBlockRenderer$1 = PortableTextRenderer<PortableTextBlock$1>;
+/**
+ * @public
+ */
+declare const DefaultNormalRenderer: PortableTextBlockRenderer$1;
+/**
+ * @public
+ */
+declare const DefaultBlockquoteRenderer: PortableTextBlockRenderer$1;
+/**
+ * @public
+ */
+declare const DefaultH1Renderer: PortableTextBlockRenderer$1;
+/**
+ * @public
+ */
+declare const DefaultH2Renderer: PortableTextBlockRenderer$1;
+/**
+ * @public
+ */
+declare const DefaultH3Renderer: PortableTextBlockRenderer$1;
+/**
+ * @public
+ */
+declare const DefaultH4Renderer: PortableTextBlockRenderer$1;
+/**
+ * @public
+ */
+declare const DefaultH5Renderer: PortableTextBlockRenderer$1;
+/**
+ * @public
+ */
+declare const DefaultH6Renderer: PortableTextBlockRenderer$1;
+/**
+ * @public
+ */
+declare const DefaultEmRenderer: PortableTextMarkRenderer;
+/**
+ * @public
+ */
+declare const DefaultStrongRenderer: PortableTextMarkRenderer;
+/**
+ * Renders a `code` decorator from the raw span text, bypassing the escaped
+ * `children`: code content is verbatim, never markdown syntax. The
+ * backtick fence is widened past the longest run of backticks already in
+ * the text (CommonMark: the fence must be longer than any run it encloses).
+ *
+ * A space is padded on each side when the content starts or ends with a
+ * backtick, so the fence and the content's own backtick never merge into
+ * one run, and also when the content starts and ends with a space and
+ * isn't all whitespace (`text.trim() !== ''`; an all-space code span has
+ * nothing else for CommonMark's strip rule to leave behind, so padding it
+ * would only add visible spaces), because CommonMark itself would
+ * otherwise strip one such space per side on reparse; the padding
+ * pre-compensates for that strip.
+ *
+ * @public
+ */
+declare const DefaultCodeRenderer: PortableTextMarkRenderer;
+/**
+ * @public
+ */
+declare const DefaultUnderlineRenderer: PortableTextMarkRenderer;
+/**
+ * @public
+ */
+declare const DefaultStrikeThroughRenderer: PortableTextMarkRenderer;
+interface DefaultLink extends TypedObject {
+  _type: 'link';
+  href: string;
+  title: string | undefined;
+}
+/**
+ * @public
+ */
+declare const DefaultLinkRenderer: PortableTextMarkRenderer<DefaultLink>;
+/**
+ * @public
+ */
+declare const DefaultCodeBlockRenderer: PortableTextTypeRenderer<{
+  _type: 'code';
+  code: string;
+  language: string | undefined;
+}>;
+/**
+ * @public
+ */
+declare const DefaultHorizontalRuleRenderer: PortableTextTypeRenderer;
+/**
+ * @public
+ */
+declare const DefaultHtmlRenderer: PortableTextTypeRenderer<{
+  _type: 'html';
+  html: string;
+}>;
+/**
+ * @public
+ */
+declare const DefaultImageRenderer: PortableTextTypeRenderer<{
+  _type: 'image';
+  src: string;
+  alt: string | undefined;
+  title: string | undefined;
+}>;
+/**
+ * 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
+ */
+declare const DefaultTableRenderer: PortableTextTypeRenderer<{
+  _type: 'table';
+  headerRows: number | undefined;
+  alignment: Array<'left' | 'center' | 'right' | null> | undefined;
+  rows: Array<{
+    _key: string;
+    cells: Array<{
+      _key: string;
+      value: Array<PortableTextBlock$1>;
+    }>;
+  }>;
+}>;
+/**
+ * @public
+ */
+declare const DefaultCalloutRenderer: PortableTextTypeRenderer<{
+  _type: 'callout';
+  tone: string;
+  content: Array<PortableTextBlock$1>;
+}>;
+/**
+ * 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
+ */
+declare const DefaultBlockquoteObjectRenderer: PortableTextTypeRenderer<{
+  _type: 'blockquote';
+  content: Array<PortableTextBlock$1>;
+}>;
+/**
+ * Renders a structural list block-object (the `types.list` shape produced by
+ * `markdownToPortableText` when a `types.list` matcher is provided) back to
+ * Markdown. Items render as `- ` for `kind: 'bullet'`, `1. `/`2. ` for `'number'`,
+ * and `- [x] ` / `- [ ] ` for `'task'`. Items can hold any blocks - text blocks,
+ * code blocks, callouts, images, and nested lists - and content other than the
+ * leading text block is indented to keep it inside the item.
+ *
+ * @public
+ */
+declare const DefaultListRenderer: PortableTextTypeRenderer<{
+  _type: 'list';
+  kind: 'bullet' | 'number' | 'task';
+  items: Array<{
+    _type: 'list-item';
+    _key: string;
+    checked?: boolean;
+    content: Array<PortableTextBlock$1 | TypedObject>;
+  }>;
+}>;
+export { type AnnotationMatcher, type ApplyMarkdownEditOptions, type BlockSpacingRenderer, type DecoratorMatcher, DefaultBlockSpacingRenderer, DefaultBlockquoteObjectRenderer, DefaultBlockquoteRenderer, DefaultCalloutRenderer, DefaultCodeBlockRenderer, DefaultCodeRenderer, DefaultEmRenderer, DefaultH1Renderer, DefaultH2Renderer, DefaultH3Renderer, DefaultH4Renderer, DefaultH5Renderer, DefaultH6Renderer, DefaultHardBreakRenderer, DefaultHorizontalRuleRenderer, DefaultHtmlRenderer, DefaultImageRenderer, DefaultLinkRenderer, DefaultListItemRenderer, DefaultListRenderer, DefaultNormalRenderer, DefaultStrikeThroughRenderer, DefaultStrongRenderer, DefaultTableRenderer, DefaultUnderlineRenderer, type Degradation, type ListItemMatcher, type ObjectMatcher, type PortableTextBlockRenderer, type PortableTextListItemRenderer, type PortableTextMarkRenderer, type PortableTextMarkRendererOptions, type PortableTextRenderer, type PortableTextRendererOptions, type PortableTextRenderers, type PortableTextTypeRenderer, type PortableTextTypeRendererOptions, type ReconciliationKeyPath, type ReconciliationReport, type StyleMatcher, applyMarkdownEdit, markdownToPortableText, portableTextToMarkdown };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -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":"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"}
+{"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/to-portable-text/matchers.ts","../src/to-portable-text/markdown-to-portable-text.ts","../src/apply-markdown-edit.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"],"x_google_ignoreList":[0],"mappings":"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"}