@portabletext/markdown 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,599 @@
+import { PortableTextBlock, PortableTextObject, Schema } from "@portabletext/schema";
+/**
+ * Any object with an `_type` that is a string. Can hold any other properties.
+ * @public
+ */
+declare type ArbitraryTypedObject = TypedObject & {
+  [key: string]: any;
+};
+/**
+ * A Portable Text Block can be thought of as one paragraph, quote or list item.
+ * In other words, it is a container for text, that can have a visual style associated with it.
+ * The actual text value is stored in portable text spans inside of the `childen` array.
+ *
+ * @typeParam M - Mark types that be used for text spans
+ * @typeParam C - Types allowed as children of this block
+ * @typeParam S - Allowed block styles (eg `normal`, `blockquote`, `h3` etc)
+ * @typeParam L - Allowed list item types (eg `number`, `bullet` etc)
+ * @public
+ */
+declare interface PortableTextBlock$1<M extends PortableTextMarkDefinition = PortableTextMarkDefinition, C extends TypedObject = ArbitraryTypedObject | PortableTextSpan, S extends string = PortableTextBlockStyle, L extends string = PortableTextListItemType> extends TypedObject {
+  /**
+   * Type name identifying this as a portable text block.
+   * All items within a portable text array should have a `_type` property.
+   *
+   * Usually 'block', but can be customized to other values
+   */
+  _type: "block" | string;
+  /**
+   * A key that identifies this block uniquely within the parent array. Used to more easily address
+   * the block when editing collaboratively, but is also very useful for keys inside of React and
+   * other rendering frameworks that can use keys to optimize operations.
+   */
+  _key?: string;
+  /**
+   * Array of inline items for this block. Usually contain text spans, but can be
+   * configured to include inline objects of other types as well.
+   */
+  children: C[];
+  /**
+   * Array of mark definitions used in child text spans. By having them be on the block level,
+   * the same mark definition can be reused for multiple text spans, which is often the case
+   * with nested marks.
+   */
+  markDefs?: M[];
+  /**
+   * Visual style of the block
+   * Common values: 'normal', 'blockquote', 'h1'...'h6'
+   */
+  style?: S;
+  /**
+   * If this block is a list item, identifies which style of list item this is
+   * Common values: 'bullet', 'number', but can be configured
+   */
+  listItem?: L;
+  /**
+   * If this block is a list item, identifies which level of nesting it belongs within
+   */
+  level?: number;
+}
+/**
+ * A set of _common_ (but not required/standarized) block styles
+ * @public
+ */
+declare type PortableTextBlockStyle = "normal" | "blockquote" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | string;
+/**
+ * Strictly speaking the same as a portable text block, but `listItem` is required
+ *
+ * @typeParam M - Mark types that be used for text spans
+ * @typeParam C - Types allowed as children of this block
+ * @typeParam S - Allowed block styles (eg `normal`, `blockquote`, `h3` etc)
+ * @typeParam L - Allowed list item types (eg `number`, `bullet` etc)
+ * @public
+ */
+declare interface PortableTextListItemBlock<M extends PortableTextMarkDefinition = PortableTextMarkDefinition, C extends TypedObject = PortableTextSpan, S extends string = PortableTextBlockStyle, L extends string = PortableTextListItemType> extends Omit<PortableTextBlock$1<M, C, S, L>, "listItem"> {
+  listItem: L;
+}
+/**
+ * A set of _common_ (but not required/standardized) list item types
+ * @public
+ */
+declare type PortableTextListItemType = "bullet" | "number" | string;
+/**
+ * A mark definition holds information for marked text. For instance, a text span could reference
+ * a mark definition for a hyperlink, a geoposition, a reference to a document or anything that is
+ * representable as a JSON object.
+ * @public
+ */
+declare interface PortableTextMarkDefinition {
+  /**
+   * Unknown properties
+   */
+  [key: string]: unknown;
+  /**
+   * Identifies the type of mark this is, and is used to pick the correct React components to use
+   * when rendering a text span marked with this mark type.
+   */
+  _type: string;
+  /**
+   * Uniquely identifies this mark definition within the block
+   */
+  _key: string;
+}
+/**
+ * A Portable Text Span holds a chunk of the actual text value of a Portable Text Block
+ * @public
+ */
+declare interface PortableTextSpan {
+  /**
+   * Type is always `span` for portable text spans, as these don't vary in shape
+   */
+  _type: "span";
+  /**
+   * Unique (within parent block) key for this portable text span
+   */
+  _key?: string;
+  /**
+   * The actual text value of this text span
+   */
+  text: string;
+  /**
+   * An array of marks this text span is annotated with, identified by its `_key`.
+   * If the key cannot be found in the parent blocks mark definition, the mark is assumed to be a
+   * decorator (a simpler mark without any properties - for instance `strong` or `em`)
+   */
+  marks?: string[];
+}
+/**
+ * Any object with an `_type` property (which is required in portable text arrays),
+ * as well as a _potential_ `_key` (highly encouraged)
+ * @public
+ */
+declare interface TypedObject {
+  /**
+   * Identifies the type of object/span this is, and is used to pick the correct React components
+   * to use when rendering a span or inline object with this type.
+   */
+  _type: string;
+  /**
+   * Uniquely identifies this object within its parent block.
+   * Not _required_, but highly encouraged.
+   */
+  _key?: string;
+}
+/**
+ * @public
+ */
+type BlockSpacingRenderer = (options: {
+  current: TypedObject;
+  next: TypedObject;
+}) => string | undefined;
+/**
+ * @public
+ */
+declare const DefaultBlockSpacingRenderer: BlockSpacingRenderer;
+/**
+ * Generic type for portable text renderers that takes blocks/inline blocks
+ *
+ * @public
+ */
+type PortableTextRenderer<N> = (options: PortableTextRendererOptions<N>) => string;
+/**
+ * Renderer function type for rendering portable text blocks (paragraphs, headings, blockquotes etc)
+ *
+ * @public
+ */
+type PortableTextBlockRenderer = PortableTextRenderer<PortableTextBlock$1>;
+/**
+ * Renderer function type for rendering portable text list items
+ *
+ * @public
+ */
+type PortableTextListItemRenderer = PortableTextRenderer<PortableTextListItemBlock>;
+/**
+ * Renderer function type for rendering portable text marks and/or decorators
+ *
+ * @public
+ */
+type PortableTextMarkRenderer<M extends TypedObject = any> = (options: PortableTextMarkRendererOptions<M>) => string;
+/**
+ * @public
+ */
+type PortableTextTypeRenderer<V extends TypedObject = any> = (options: PortableTextTypeRendererOptions<V>) => string;
+/**
+ * Object defining the different renderer functions to use for rendering various aspects
+ * of Portable Text and user-provided types to Markdown.
+ *
+ * @public
+ */
+interface PortableTextRenderers {
+  /**
+   * Object of renderer functions for different types of objects that might appear
+   * both as part of the blocks array, or as inline objects _inside_ of a block,
+   * alongside text spans.
+   *
+   * Use the `isInline` property to check whether or not this is an inline object or a block.
+   *
+   * The object has the shape `{typeName: RendererFn}`, where `typeName` is the value set
+   * in individual `_type` attributes.
+   */
+  types: Record<string, PortableTextTypeRenderer | undefined>;
+  /**
+   * Object of renderer functions for different types of marks that might appear in spans.
+   *
+   * The object has the shape `{markName: RendererFn}`, where `markName` is the value set
+   * in individual `_type` attributes, values being stored in the parent blocks `markDefs`.
+   */
+  marks: Record<string, PortableTextMarkRenderer | undefined>;
+  /**
+   * Object of renderer functions for blocks with different `style` properties.
+   *
+   * The object has the shape `{styleName: RendererFn}`, where `styleName` is the value set
+   * in individual `style` attributes on blocks.
+   *
+   * Can also be set to a single renderer function, which would handle block styles of _any_ type.
+   */
+  block: Record<PortableTextBlockStyle, PortableTextBlockRenderer | undefined> | PortableTextBlockRenderer;
+  /**
+   * Object of renderer functions used to render different list item styles.
+   *
+   * The object has the shape `{listItemType: RendererFn}`, where `listItemType` is the value
+   * set in individual `listItem` attributes on blocks.
+   *
+   * Can also be set to a single renderer function, which would handle list items of _any_ type.
+   */
+  listItem: Record<PortableTextListItemType, PortableTextListItemRenderer | undefined> | PortableTextListItemRenderer;
+  /**
+   * Renderer for "hard breaks", eg `\n` inside of text spans.
+   * By default renders as Markdown hard break (`  \n` - two trailing spaces).
+   */
+  hardBreak: () => string;
+  /**
+   * Renderer function used when encountering a mark type there is no registered renderer for
+   * in the `marks` option.
+   */
+  unknownMark: PortableTextMarkRenderer;
+  /**
+   * Renderer function used when encountering an object type there is no registered renderer for
+   * in the `types` option.
+   */
+  unknownType: PortableTextRenderer<UnknownNodeType>;
+  /**
+   * Renderer function used when encountering a block style there is no registered renderer for
+   * in the `block` option. Only used if `block` is an object.
+   */
+  unknownBlockStyle: PortableTextRenderer<PortableTextBlock$1>;
+  /**
+   * Renderer function used when encountering a list item style there is no registered renderer for
+   * in the `listItem` option. Only used if `listItem` is an object.
+   */
+  unknownListItem: PortableTextRenderer<PortableTextListItemBlock>;
+}
+/**
+ * Options received by most Portable Text renderers
+ *
+ * @public
+ */
+interface PortableTextRendererOptions<T> {
+  /**
+   * Data associated with this portable text node, eg the raw JSON value of a block/type
+   */
+  value: T;
+  /**
+   * Index within its parent
+   */
+  index: number;
+  /**
+   * Index of a list item
+   */
+  listIndex?: number | undefined;
+  /**
+   * Whether or not this node is "inline" - ie as a child of a text block,
+   * alongside text spans, or a block in and of itself.
+   */
+  isInline: boolean;
+  /**
+   * Serialized Markdown of child nodes of this block/type
+   */
+  children?: string;
+  /**
+   * Function used to render any node that might appear in a portable text array or block,
+   * including virtual "toolkit"-nodes like lists and nested spans. You will rarely need
+   * to use this.
+   */
+  renderNode: RenderNode;
+}
+/**
+ * Options received by any user-defined type renderer in the input array that is not a text block
+ *
+ * @public
+ */
+type PortableTextTypeRendererOptions<T> = Omit<PortableTextRendererOptions<T>, 'children'>;
+/**
+ * Options received by Portable Text mark renderers
+ *
+ * @public
+ */
+interface PortableTextMarkRendererOptions<M extends TypedObject = ArbitraryTypedObject> {
+  /**
+   * Mark definition, eg the actual data of the annotation. If the mark is a simple decorator, this will be `undefined`
+   */
+  value?: M;
+  /**
+   * Text content of this mark
+   */
+  text: string;
+  /**
+   * Key for this mark. The same key can be used amongst multiple text spans within the same block, so don't rely on this to be unique.
+   */
+  markKey: string | undefined;
+  /**
+   * Type of mark - ie value of `_type` in the case of annotations, or the name of the decorator otherwise - eg `em`, `italic`.
+   */
+  markType: string;
+  /**
+   * Serialized Markdown of child nodes of this mark
+   */
+  children: string;
+  /**
+   * Function used to render any node that might appear in a portable text array or block,
+   * including virtual "toolkit"-nodes like lists and nested spans. You will rarely need
+   * to use this.
+   */
+  renderNode: RenderNode;
+}
+/**
+ * Any node type that we can't identify - eg it has an `_type`,
+ * but we don't know anything about its other properties
+ */
+type UnknownNodeType = {
+  [key: string]: unknown;
+  _type: string;
+} | TypedObject;
+type RenderNode = <T extends TypedObject>(options: Serializable<T>) => string;
+interface Serializable<T> {
+  node: T;
+  index: number;
+  isInline: boolean;
+  renderNode: RenderNode;
+}
+type Options$1 = Partial<PortableTextRenderers> & {
+  blockSpacing?: BlockSpacingRenderer;
+};
+/**
+ * @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;
+/**
+ * @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;
+}>;
+/**
+ * @public
+ */
+declare const DefaultTableRenderer: PortableTextTypeRenderer<{
+  _type: 'table';
+  headerRows: number | undefined;
+  rows: Array<{
+    _key: string;
+    cells: Array<{
+      _key: string;
+      value: Array<PortableTextBlock$1>;
+    }>;
+  }>;
+}>;
+/**
+ * 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;
+  };
+  types?: {
+    code?: ObjectMatcher<{
+      language: string | undefined;
+      code: string;
+    }>;
+    horizontalRule?: ObjectMatcher;
+    html?: ObjectMatcher<{
+      html: string;
+    }>;
+    table?: ObjectMatcher<{
+      headerRows: number | 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;
+    }>;
+  };
+  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, DefaultBlockquoteRenderer, DefaultCodeBlockRenderer, DefaultCodeRenderer, DefaultEmRenderer, DefaultH1Renderer, DefaultH2Renderer, DefaultH3Renderer, DefaultH4Renderer, DefaultH5Renderer, DefaultH6Renderer, DefaultHardBreakRenderer, DefaultHorizontalRuleRenderer, DefaultHtmlRenderer, DefaultImageRenderer, DefaultLinkRenderer, DefaultListItemRenderer, 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 };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["ArbitraryTypedObject","TypedObject","PortableTextBlock","M","C","S","L","PortableTextMarkDefinition","PortableTextSpan","PortableTextBlockStyle","PortableTextListItemType","PortableTextLink","PortableTextListItemBlock","Omit"],"sources":["../../../node_modules/.pnpm/@portabletext+types@3.0.0/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"],"sourcesContent":["/**\n * Any object with an `_type` that is a string. Can hold any other properties.\n * @public\n */\nexport declare type ArbitraryTypedObject = TypedObject & {\n  [key: string]: any;\n};\n\n/**\n * A Portable Text Block can be thought of as one paragraph, quote or list item.\n * In other words, it is a container for text, that can have a visual style associated with it.\n * The actual text value is stored in portable text spans inside of the `childen` array.\n *\n * @typeParam M - Mark types that be used for text spans\n * @typeParam C - Types allowed as children of this block\n * @typeParam S - Allowed block styles (eg `normal`, `blockquote`, `h3` etc)\n * @typeParam L - Allowed list item types (eg `number`, `bullet` etc)\n * @public\n */\nexport declare interface PortableTextBlock<\n  M extends PortableTextMarkDefinition = PortableTextMarkDefinition,\n  C extends TypedObject = ArbitraryTypedObject | PortableTextSpan,\n  S extends string = PortableTextBlockStyle,\n  L extends string = PortableTextListItemType,\n> extends TypedObject {\n  /**\n   * Type name identifying this as a portable text block.\n   * All items within a portable text array should have a `_type` property.\n   *\n   * Usually 'block', but can be customized to other values\n   */\n  _type: \"block\" | string;\n  /**\n   * A key that identifies this block uniquely within the parent array. Used to more easily address\n   * the block when editing collaboratively, but is also very useful for keys inside of React and\n   * other rendering frameworks that can use keys to optimize operations.\n   */\n  _key?: string;\n  /**\n   * Array of inline items for this block. Usually contain text spans, but can be\n   * configured to include inline objects of other types as well.\n   */\n  children: C[];\n  /**\n   * Array of mark definitions used in child text spans. By having them be on the block level,\n   * the same mark definition can be reused for multiple text spans, which is often the case\n   * with nested marks.\n   */\n  markDefs?: M[];\n  /**\n   * Visual style of the block\n   * Common values: 'normal', 'blockquote', 'h1'...'h6'\n   */\n  style?: S;\n  /**\n   * If this block is a list item, identifies which style of list item this is\n   * Common values: 'bullet', 'number', but can be configured\n   */\n  listItem?: L;\n  /**\n   * If this block is a list item, identifies which level of nesting it belongs within\n   */\n  level?: number;\n}\n\n/**\n * A set of _common_ (but not required/standarized) block styles\n * @public\n */\nexport declare type PortableTextBlockStyle =\n  | \"normal\"\n  | \"blockquote\"\n  | \"h1\"\n  | \"h2\"\n  | \"h3\"\n  | \"h4\"\n  | \"h5\"\n  | \"h6\"\n  | string;\n\n/**\n * The simplest representation of a link\n * @public\n */\nexport declare interface PortableTextLink {\n  _type: \"link\";\n  href: string;\n}\n\n/**\n * Strictly speaking the same as a portable text block, but `listItem` is required\n *\n * @typeParam M - Mark types that be used for text spans\n * @typeParam C - Types allowed as children of this block\n * @typeParam S - Allowed block styles (eg `normal`, `blockquote`, `h3` etc)\n * @typeParam L - Allowed list item types (eg `number`, `bullet` etc)\n * @public\n */\nexport declare interface PortableTextListItemBlock<\n  M extends PortableTextMarkDefinition = PortableTextMarkDefinition,\n  C extends TypedObject = PortableTextSpan,\n  S extends string = PortableTextBlockStyle,\n  L extends string = PortableTextListItemType,\n> extends Omit<PortableTextBlock<M, C, S, L>, \"listItem\"> {\n  listItem: L;\n}\n\n/**\n * A set of _common_ (but not required/standardized) list item types\n * @public\n */\nexport declare type PortableTextListItemType = \"bullet\" | \"number\" | string;\n\n/**\n * A mark definition holds information for marked text. For instance, a text span could reference\n * a mark definition for a hyperlink, a geoposition, a reference to a document or anything that is\n * representable as a JSON object.\n * @public\n */\nexport declare interface PortableTextMarkDefinition {\n  /**\n   * Unknown properties\n   */\n  [key: string]: unknown;\n  /**\n   * Identifies the type of mark this is, and is used to pick the correct React components to use\n   * when rendering a text span marked with this mark type.\n   */\n  _type: string;\n  /**\n   * Uniquely identifies this mark definition within the block\n   */\n  _key: string;\n}\n\n/**\n * A Portable Text Span holds a chunk of the actual text value of a Portable Text Block\n * @public\n */\nexport declare interface PortableTextSpan {\n  /**\n   * Type is always `span` for portable text spans, as these don't vary in shape\n   */\n  _type: \"span\";\n  /**\n   * Unique (within parent block) key for this portable text span\n   */\n  _key?: string;\n  /**\n   * The actual text value of this text span\n   */\n  text: string;\n  /**\n   * An array of marks this text span is annotated with, identified by its `_key`.\n   * If the key cannot be found in the parent blocks mark definition, the mark is assumed to be a\n   * decorator (a simpler mark without any properties - for instance `strong` or `em`)\n   */\n  marks?: string[];\n}\n\n/**\n * Any object with an `_type` property (which is required in portable text arrays),\n * as well as a _potential_ `_key` (highly encouraged)\n * @public\n */\nexport declare interface TypedObject {\n  /**\n   * Identifies the type of object/span this is, and is used to pick the correct React components\n   * to use when rendering a span or inline object with this type.\n   */\n  _type: string;\n  /**\n   * Uniquely identifies this object within its parent block.\n   * Not _required_, but highly encouraged.\n   */\n  _key?: string;\n}\n\nexport {};\n"],"x_google_ignoreList":[0],"mappings":"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xKH;EACA,CAAA,GAAA,EAAA,MAAA,CAAA,EAAA,OAAA;EACA,KAAA,EAAA,MAAA;CACA,GRuKL,WQvKK;AACA,KRwKG,UAAA,GQxKH,CAAA,URwK2B,WQxK3B,CAAA,CAAA,OAAA,ERyKE,YQzKF,CRyKe,CQzKf,CAAA,EAAA,GAAA,MAAA;AACA,UR2KQ,YQ3KR,CAAA,CAAA,CAAA,CAAA;EAGI,IAAA,ERyKL,CQzKK;EACA,KAAA,EAAA,MAAA;EAGF,QAAA,EAAA,OAAA;EACU,UAAA,ERuKP,UQvKO;;AVpDrB,KGkDK,SAAA,GAAU,OHlDUC,CGkDF,qBHlDmBI,CAAAA,GAAA;EAC9BC,YAAAA,CAAAA,EGkDK,oBHlDLA;CAA6BA;;;;AAEpBE,iBGsDL,sBHtDKA,CAAAA,cGuDL,WHvDKA,GGuDS,mBHvDTA,GGuD6B,oBHvD7BA,CAAAA,CAAAA,MAAAA,EGwDX,KHxDWA,CGwDL,KHxDKA,CAAAA,EAAAA,OAAAA,CAAAA,EGwDY,SHxDZA,CAAAA,EAAAA,MAAAA;;;AAlBrB;AAeyBP,cIhBZ,wBJgB6BI,EAAAA,GAAA,GAAA,MAAA;;AAf1C;AAeA;AACYC,cKfC,uBLeDA,EKf0B,4BLe1BA;AAhBZ,KMDK,2BAAA,GAA4B,oBNCqB,CMDA,mBNCA,CAAA;AAetD;;;AAEYN,cMbC,qBNaDA,EMbwB,2BNaxBA;;;;AAESS,cMDR,yBNCQA,EMDmB,2BNCnBA;;;;AAmCRJ,cMpBA,iBNoBAA,EMpBmB,2BNoBnBA;;;AAWb;AA6ByBM,cMtDZ,iBNsDqC,EMtDlB,2BNsDkB;;;;AAExBJ,cMlDb,iBNkDaA,EMlDM,2BNkDNA;;;;AAGUJ,cM/CvB,iBN+CuBA,EM/CJ,2BN+CIA;;;;AACxBE,cM1CC,iBN0CDA,EM1CoB,2BN0CpBA;;;AAOZ;AAQyBC,cMnDZ,iBNmDsC,EMnDnB,2BNmDmB;AAnHnD;AAeA;;AACyCA,cOd5B,iBPc4BA,EOdT,wBPcSA;;;;AAEpBE,cOVR,qBPUQA,EOVe,wBPUfA;;;;AA+BXJ,cOnCG,mBPmCHA,EOnCwB,wBPmCxBA;;;;AAgBUI,cO7CP,wBP6C6B,EO7CH,wBP6CG;AA6B1C;;;A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"}