@portabletext/markdown 2.0.0 → 2.2.0

package/dist/index.d.ts

@@ -282,7 +282,9 @@ interface PortableTextRendererOptions<T> {
    */
   isInline: boolean;
   /**
-   * Serialized Markdown of child nodes of this block/type
+   * Serialized Markdown of child nodes of this block/type: nested marks
+   * rendered, markdown-significant punctuation in plain text
+   * backslash-escaped. Safe to embed in markdown output as-is.
    */
   children?: string;
   /**
@@ -309,7 +311,12 @@ interface PortableTextMarkRendererOptions<M extends TypedObject = ArbitraryTyped
    */
   value?: M;
   /**
-   * Text content of this mark
+   * The raw text content of this mark: the span text exactly as stored in
+   * the Portable Text, unescaped, with no nested mark rendering. Read this
+   * when your renderer emits its own delimiters or non-markdown output
+   * (code fences, HTML tags), where backslash escapes would appear
+   * literally. The built-in `code` decorator renderer works from this
+   * field.
    */
   text: string;
   /**
@@ -321,7 +328,11 @@ interface PortableTextMarkRendererOptions<M extends TypedObject = ArbitraryTyped
    */
   markType: string;
   /**
-   * Serialized Markdown of child nodes of this mark
+   * Serialized Markdown of this mark's child nodes: nested marks are
+   * rendered and markdown-significant punctuation in plain text is
+   * backslash-escaped. Safe to embed in markdown output as-is; wrapping
+   * renderers (`**${children}**`) should always use this. For the raw,
+   * unescaped text, read `text` instead.
    */
   children: string;
   /**
@@ -348,11 +359,442 @@ 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;
+/**
+ * Matcher function for mapping markdown elements to Portable Text block styles.
+ *
+ * @public
+ */
+type StyleMatcher = ({ context }: {
+  context: {
+    schema: Schema;
+  };
+}) => string | undefined;
+/**
+ * Matcher function for mapping markdown list items to Portable Text list types.
+ *
+ * @public
+ */
+type ListItemMatcher = ({ context }: {
+  context: {
+    schema: Schema;
+  };
+}) => string | undefined;
+/**
+ * Matcher function for mapping markdown inline formatting to Portable Text decorators.
+ *
+ * @public
+ */
+type DecoratorMatcher = ({ context }: {
+  context: {
+    schema: Schema;
+  };
+}) => string | undefined;
+/**
+ * Matcher function for mapping markdown links to Portable Text annotations.
+ *
+ * @public
+ */
+type AnnotationMatcher<TValue extends Record<string, unknown> = Record<string, never>> = ({ context, value }: {
+  context: {
+    schema: Schema;
+    keyGenerator: () => string;
+  };
+  value: TValue;
+}) => PortableTextObject | undefined;
+/**
+ * Matcher function for mapping markdown objects to Portable Text block or inline objects.
+ *
+ * @public
+ */
+type ObjectMatcher<TValue extends Record<string, unknown> = Record<string, never>> = ({ context, value, isInline }: {
+  context: {
+    schema: Schema;
+    keyGenerator: () => string;
+  };
+  value: TValue;
+  isInline: boolean;
+}) => PortableTextObject | undefined;
+/**
+ * The classification of a lossy conversion encountered while converting
+ * markdown to Portable Text: a markdown construct the conversion couldn't
+ * carry through losslessly, whether because the target schema (or the
+ * active matchers) doesn't represent it, or because the surrounding
+ * structure (a table cell, for instance) can't hold the shape markdown
+ * expressed, so the conversion fell back to a lossier representation
+ * instead of failing.
+ *
+ * @public
+ */
+type DegradationType = 'decorator-dropped' | 'annotation-dropped' | 'style-fallback' | 'list-flattened' | 'task-checkbox-stripped' | 'table-flattened' | 'code-block-to-text' | 'horizontal-rule-to-text' | 'html-block-to-text' | 'inline-html-dropped' | 'image-block-to-inline' | 'image-inline-to-block' | 'image-to-text' | 'callout-fallback' | 'fields-dropped' | 'object-carrier-invalid';
+/**
+ * Reports a single lossy conversion, in encounter order: as the conversion
+ * walks the markdown, that's the order nested constructs close in, not
+ * necessarily top-to-bottom document order. `line` is the 1-based markdown
+ * source line: usually the line of the token that degraded, but for a
+ * token without its own line (an inline construct inside a table cell, for
+ * instance) the enclosing construct's line instead; absent when no token
+ * carries a usable line at all. `snippet` is the offending construct's
+ * text, truncated to 40 characters with an ellipsis, present whenever the
+ * degradation has a specific piece of source text to quote (a dropped
+ * decorator's span, an unsupported image's alt text) and absent when the
+ * construct has nothing to quote (a table with no `table` block object, a
+ * callout whose type isn't in the schema). `message` is human-readable and
+ * may change between releases; match on `type`, not `message`. The set of
+ * `type` values grows in minor releases as new degradation sites report, so
+ * compare against the values you handle rather than switching exhaustively.
+ *
+ * @public
+ */
+type Degradation = {
+  type: DegradationType;
+  message: string;
+  line?: number;
+  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;
+  /**
+   * Called at most once, after the conversion has walked the whole
+   * document, only when at least one construct degraded. Left unset, the
+   * conversion stays silent and returns the lossiest representation it can
+   * build. Passed a function, observe every degradation via
+   * `report.degradations`, in encounter order. Enforce against lossy output by
+   * throwing your own error from inside the callback, using
+   * `report.message` (the canonical grouped text) as its message; the
+   * throw propagates out of `markdownToPortableText`.
+   *
+   * ```ts
+   * markdownToPortableText(markdown, {onDegradation: ({message}) => { throw new Error(message) }})
+   * ```
+   *
+   * `report` is a single object, not positional parameters, so it can gain
+   * fields later without a breaking change.
+   */
+  onDegradation?: (report: {
+    degradations: Array<Degradation>;
+    message: string;
+  }) => void;
+  marks?: {
+    strong?: DecoratorMatcher;
+    em?: DecoratorMatcher;
+    code?: DecoratorMatcher;
+    strikeThrough?: DecoratorMatcher;
+    link?: AnnotationMatcher<{
+      href: string;
+      title: string | undefined;
+    }>;
+  };
+  block?: {
+    normal?: StyleMatcher;
+    blockquote?: StyleMatcher;
+    h1?: StyleMatcher;
+    h2?: StyleMatcher;
+    h3?: StyleMatcher;
+    h4?: StyleMatcher;
+    h5?: StyleMatcher;
+    h6?: StyleMatcher;
+  };
+  listItem?: {
+    number?: ListItemMatcher;
+    bullet?: ListItemMatcher;
+    task?: ListItemMatcher;
+  };
+  types?: {
+    code?: ObjectMatcher<{
+      language: string | undefined;
+      code: string;
+    }>;
+    horizontalRule?: ObjectMatcher;
+    html?: ObjectMatcher<{
+      html: string;
+    }>;
+    table?: ObjectMatcher<{
+      headerRows: number | undefined;
+      alignment: Array<'left' | 'center' | 'right' | null> | undefined;
+      rows: Array<{
+        _key: string;
+        _type: 'row';
+        cells: Array<{
+          _type: 'cell';
+          _key: string;
+          value: Array<PortableTextBlock>;
+        }>;
+      }>;
+    }>;
+    image?: ObjectMatcher<{
+      src: string;
+      alt: string;
+      title: string | undefined;
+    }>;
+    callout?: ObjectMatcher<{
+      tone: string;
+      content: Array<PortableTextBlock>;
+    }>;
+    blockquote?: ObjectMatcher<{
+      content: Array<PortableTextBlock>;
+    }>;
+    list?: ObjectMatcher<{
+      kind: 'bullet' | 'number' | 'task';
+      items: Array<{
+        _type: 'list-item';
+        _key: string;
+        checked?: boolean;
+        content: Array<PortableTextBlock | PortableTextObject>;
+      }>;
+    }>;
+  };
+  html?: {
+    /**
+     * How to handle inline HTML.
+     * - 'skip': Ignore inline HTML (default)
+     * - 'text': Convert inline HTML to plain text
+     *
+     * @defaultValue 'skip'
+     */
+    inline?: 'skip' | 'text';
+  };
+};
+/**
+ * Converts a markdown string to an array of Portable Text blocks.
+ *
+ * @public
+ */
+declare function markdownToPortableText(markdown: string, options?: Options): Array<PortableTextBlock>;
+/**
+ * @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
  */
@@ -403,6 +845,20 @@ declare const DefaultEmRenderer: PortableTextMarkRenderer;
  */
 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;
@@ -524,149 +980,5 @@ declare const DefaultListRenderer: PortableTextTypeRenderer<{
     content: Array<PortableTextBlock$1 | TypedObject>;
   }>;
 }>;
-/**
- * Matcher function for mapping markdown elements to Portable Text block styles.
- *
- * @public
- */
-type StyleMatcher = ({ context }: {
-  context: {
-    schema: Schema;
-  };
-}) => string | undefined;
-/**
- * Matcher function for mapping markdown list items to Portable Text list types.
- *
- * @public
- */
-type ListItemMatcher = ({ context }: {
-  context: {
-    schema: Schema;
-  };
-}) => string | undefined;
-/**
- * Matcher function for mapping markdown inline formatting to Portable Text decorators.
- *
- * @public
- */
-type DecoratorMatcher = ({ context }: {
-  context: {
-    schema: Schema;
-  };
-}) => string | undefined;
-/**
- * Matcher function for mapping markdown links to Portable Text annotations.
- *
- * @public
- */
-type AnnotationMatcher<TValue extends Record<string, unknown> = Record<string, never>> = ({ context, value }: {
-  context: {
-    schema: Schema;
-    keyGenerator: () => string;
-  };
-  value: TValue;
-}) => PortableTextObject | undefined;
-/**
- * Matcher function for mapping markdown objects to Portable Text block or inline objects.
- *
- * @public
- */
-type ObjectMatcher<TValue extends Record<string, unknown> = Record<string, never>> = ({ context, value, isInline }: {
-  context: {
-    schema: Schema;
-    keyGenerator: () => string;
-  };
-  value: TValue;
-  isInline: boolean;
-}) => PortableTextObject | undefined;
-type Options = {
-  schema?: Schema;
-  keyGenerator?: () => string;
-  marks?: {
-    strong?: DecoratorMatcher;
-    em?: DecoratorMatcher;
-    code?: DecoratorMatcher;
-    strikeThrough?: DecoratorMatcher;
-    link?: AnnotationMatcher<{
-      href: string;
-      title: string | undefined;
-    }>;
-  };
-  block?: {
-    normal?: StyleMatcher;
-    blockquote?: StyleMatcher;
-    h1?: StyleMatcher;
-    h2?: StyleMatcher;
-    h3?: StyleMatcher;
-    h4?: StyleMatcher;
-    h5?: StyleMatcher;
-    h6?: StyleMatcher;
-  };
-  listItem?: {
-    number?: ListItemMatcher;
-    bullet?: ListItemMatcher;
-    task?: ListItemMatcher;
-  };
-  types?: {
-    code?: ObjectMatcher<{
-      language: string | undefined;
-      code: string;
-    }>;
-    horizontalRule?: ObjectMatcher;
-    html?: ObjectMatcher<{
-      html: string;
-    }>;
-    table?: ObjectMatcher<{
-      headerRows: number | undefined;
-      alignment: Array<'left' | 'center' | 'right' | null> | undefined;
-      rows: Array<{
-        _key: string;
-        _type: 'row';
-        cells: Array<{
-          _type: 'cell';
-          _key: string;
-          value: Array<PortableTextBlock>;
-        }>;
-      }>;
-    }>;
-    image?: ObjectMatcher<{
-      src: string;
-      alt: string;
-      title: string | undefined;
-    }>;
-    callout?: ObjectMatcher<{
-      tone: string;
-      content: Array<PortableTextBlock>;
-    }>;
-    blockquote?: ObjectMatcher<{
-      content: Array<PortableTextBlock>;
-    }>;
-    list?: ObjectMatcher<{
-      kind: 'bullet' | 'number' | 'task';
-      items: Array<{
-        _type: 'list-item';
-        _key: string;
-        checked?: boolean;
-        content: Array<PortableTextBlock | PortableTextObject>;
-      }>;
-    }>;
-  };
-  html?: {
-    /**
-     * How to handle inline HTML.
-     * - 'skip': Ignore inline HTML (default)
-     * - 'text': Convert inline HTML to plain text
-     *
-     * @defaultValue 'skip'
-     */
-    inline?: 'skip' | 'text';
-  };
-};
-/**
- * Converts a markdown string to an array of Portable Text blocks.
- *
- * @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 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 };
+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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"}