@payloadcms/richtext-lexical 3.0.0-beta.13 → 3.0.0-beta.131

package/dist/features/migrations/slateToLexical/converter/index.js

@@ -0,0 +1,117 @@
+import { NodeFormat } from '../../../../lexical/utils/nodeFormat.js';
+export function convertSlateToLexical({
+  converters,
+  slateData
+}) {
+  return {
+    root: {
+      type: 'root',
+      children: convertSlateNodesToLexical({
+        canContainParagraphs: true,
+        converters,
+        parentNodeType: 'root',
+        slateNodes: slateData
+      }),
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      version: 1
+    }
+  };
+}
+export function convertSlateNodesToLexical({
+  canContainParagraphs,
+  converters,
+  parentNodeType,
+  slateNodes
+}) {
+  if (!converters?.length || !slateNodes?.length) {
+    return [];
+  }
+  const unknownConverter = converters.find(converter => converter.nodeTypes.includes('unknown'));
+  // @ts-expect-error - vestiges of the migration to strict mode. Probably not important enough in this file to fix
+  return slateNodes.map((slateNode, i) => {
+    if (!('type' in slateNode)) {
+      if (canContainParagraphs) {
+        // This is a paragraph node. They do not have a type property in Slate
+        return convertParagraphNode(converters, slateNode);
+      } else {
+        // This is a simple text node. canContainParagraphs may be false if this is nested inside a paragraph already, since paragraphs cannot contain paragraphs
+        return convertTextNode(slateNode);
+      }
+    }
+    if (slateNode.type === 'p') {
+      return convertParagraphNode(converters, slateNode);
+    }
+    const converter = converters.find(converter => converter.nodeTypes.includes(slateNode.type));
+    if (converter) {
+      return converter.converter({
+        childIndex: i,
+        converters,
+        parentNodeType,
+        slateNode
+      });
+    }
+    console.warn('slateToLexical > No converter found for node type: ' + slateNode.type);
+    return unknownConverter?.converter({
+      childIndex: i,
+      converters,
+      parentNodeType,
+      slateNode
+    });
+  }) || [];
+}
+export function convertParagraphNode(converters, node) {
+  return {
+    type: 'paragraph',
+    children: convertSlateNodesToLexical({
+      canContainParagraphs: false,
+      converters,
+      parentNodeType: 'paragraph',
+      slateNodes: node.children || []
+    }),
+    direction: 'ltr',
+    format: '',
+    indent: 0,
+    textFormat: 0,
+    textStyle: '',
+    version: 1
+  };
+}
+export function convertTextNode(node) {
+  return {
+    type: 'text',
+    detail: 0,
+    format: convertNodeToFormat(node),
+    mode: 'normal',
+    style: '',
+    text: node.text,
+    version: 1
+  };
+}
+export function convertNodeToFormat(node) {
+  let format = 0;
+  if (node.bold) {
+    format = format | NodeFormat.IS_BOLD;
+  }
+  if (node.italic) {
+    format = format | NodeFormat.IS_ITALIC;
+  }
+  if (node.strikethrough) {
+    format = format | NodeFormat.IS_STRIKETHROUGH;
+  }
+  if (node.underline) {
+    format = format | NodeFormat.IS_UNDERLINE;
+  }
+  if (node.subscript) {
+    format = format | NodeFormat.IS_SUBSCRIPT;
+  }
+  if (node.superscript) {
+    format = format | NodeFormat.IS_SUPERSCRIPT;
+  }
+  if (node.code) {
+    format = format | NodeFormat.IS_CODE;
+  }
+  return format;
+}
+//# sourceMappingURL=index.js.map

package/dist/features/migrations/slateToLexical/converter/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["NodeFormat","convertSlateToLexical","converters","slateData","root","type","children","convertSlateNodesToLexical","canContainParagraphs","parentNodeType","slateNodes","direction","format","indent","version","length","unknownConverter","find","converter","nodeTypes","includes","map","slateNode","i","convertParagraphNode","convertTextNode","childIndex","console","warn","node","textFormat","textStyle","detail","convertNodeToFormat","mode","style","text","bold","IS_BOLD","italic","IS_ITALIC","strikethrough","IS_STRIKETHROUGH","underline","IS_UNDERLINE","subscript","IS_SUBSCRIPT","superscript","IS_SUPERSCRIPT","code","IS_CODE"],"sources":["../../../../../src/features/migrations/slateToLexical/converter/index.ts"],"sourcesContent":["import type {\n  SerializedEditorState,\n  SerializedLexicalNode,\n  SerializedParagraphNode,\n  SerializedTextNode,\n} from 'lexical'\n\nimport type { SlateNode, SlateNodeConverter } from './types.js'\n\nimport { NodeFormat } from '../../../../lexical/utils/nodeFormat.js'\n\nexport function convertSlateToLexical({\n  converters,\n  slateData,\n}: {\n  converters: SlateNodeConverter[]\n  slateData: SlateNode[]\n}): SerializedEditorState {\n  return {\n    root: {\n      type: 'root',\n      children: convertSlateNodesToLexical({\n        canContainParagraphs: true,\n        converters,\n        parentNodeType: 'root',\n        slateNodes: slateData,\n      }),\n      direction: 'ltr',\n      format: '',\n      indent: 0,\n      version: 1,\n    },\n  }\n}\n\nexport function convertSlateNodesToLexical({\n  canContainParagraphs,\n  converters,\n  parentNodeType,\n  slateNodes,\n}: {\n  canContainParagraphs: boolean\n  converters: SlateNodeConverter[] | undefined\n  /**\n   * Type of the parent lexical node (not the type of the original, parent slate type)\n   */\n  parentNodeType: string\n  slateNodes: SlateNode[]\n}): SerializedLexicalNode[] {\n  if (!converters?.length || !slateNodes?.length) {\n    return []\n  }\n  const unknownConverter = converters.find((converter) => converter.nodeTypes.includes('unknown'))\n  // @ts-expect-error - vestiges of the migration to strict mode. Probably not important enough in this file to fix\n  return (\n    slateNodes.map((slateNode, i) => {\n      if (!('type' in slateNode)) {\n        if (canContainParagraphs) {\n          // This is a paragraph node. They do not have a type property in Slate\n          return convertParagraphNode(converters, slateNode)\n        } else {\n          // This is a simple text node. canContainParagraphs may be false if this is nested inside a paragraph already, since paragraphs cannot contain paragraphs\n          return convertTextNode(slateNode)\n        }\n      }\n      if (slateNode.type === 'p') {\n        return convertParagraphNode(converters, slateNode)\n      }\n\n      const converter = converters.find((converter) =>\n        converter.nodeTypes.includes(slateNode.type!),\n      )\n\n      if (converter) {\n        return converter.converter({ childIndex: i, converters, parentNodeType, slateNode })\n      }\n\n      console.warn('slateToLexical > No converter found for node type: ' + slateNode.type)\n      return unknownConverter?.converter({\n        childIndex: i,\n        converters,\n        parentNodeType,\n        slateNode,\n      })\n    }) || []\n  )\n}\n\nexport function convertParagraphNode(\n  converters: SlateNodeConverter[],\n  node: SlateNode,\n): SerializedParagraphNode {\n  return {\n    type: 'paragraph',\n    children: convertSlateNodesToLexical({\n      canContainParagraphs: false,\n      converters,\n      parentNodeType: 'paragraph',\n      slateNodes: node.children || [],\n    }),\n    direction: 'ltr',\n    format: '',\n    indent: 0,\n    textFormat: 0,\n    textStyle: '',\n    version: 1,\n  }\n}\nexport function convertTextNode(node: SlateNode): SerializedTextNode {\n  return {\n    type: 'text',\n    detail: 0,\n    format: convertNodeToFormat(node),\n    mode: 'normal',\n    style: '',\n    text: node.text,\n    version: 1,\n  }\n}\n\nexport function convertNodeToFormat(node: SlateNode): number {\n  let format = 0\n  if (node.bold) {\n    format = format | NodeFormat.IS_BOLD\n  }\n  if (node.italic) {\n    format = format | NodeFormat.IS_ITALIC\n  }\n  if (node.strikethrough) {\n    format = format | NodeFormat.IS_STRIKETHROUGH\n  }\n  if (node.underline) {\n    format = format | NodeFormat.IS_UNDERLINE\n  }\n  if (node.subscript) {\n    format = format | NodeFormat.IS_SUBSCRIPT\n  }\n  if (node.superscript) {\n    format = format | NodeFormat.IS_SUPERSCRIPT\n  }\n  if (node.code) {\n    format = format | NodeFormat.IS_CODE\n  }\n  return format\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/features/migrations/slateToLexical/converter/types.d.ts

@@ -0,0 +1,16 @@
+import type { SerializedLexicalNode } from 'lexical';
+export type SlateNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {
+    converter: ({ childIndex, converters, parentNodeType, slateNode, }: {
+        childIndex: number;
+        converters: SlateNodeConverter[];
+        parentNodeType: string;
+        slateNode: SlateNode;
+    }) => T;
+    nodeTypes: string[];
+};
+export type SlateNode = {
+    [key: string]: any;
+    children?: SlateNode[];
+    type?: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/features/migrations/slateToLexical/converter/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/features/migrations/slateToLexical/converter/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAEpD,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,qBAAqB,GAAG,qBAAqB,IAAI;IACxF,SAAS,EAAE,CAAC,EACV,UAAU,EACV,UAAU,EACV,cAAc,EACd,SAAS,GACV,EAAE;QACD,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,kBAAkB,EAAE,CAAA;QAChC,cAAc,EAAE,MAAM,CAAA;QACtB,SAAS,EAAE,SAAS,CAAA;KACrB,KAAK,CAAC,CAAA;IACP,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;IAClB,QAAQ,CAAC,EAAE,SAAS,EAAE,CAAA;IACtB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA"}

package/dist/features/migrations/slateToLexical/converter/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/features/migrations/slateToLexical/converter/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../../src/features/migrations/slateToLexical/converter/types.ts"],"sourcesContent":["import type { SerializedLexicalNode } from 'lexical'\n\nexport type SlateNodeConverter<T extends SerializedLexicalNode = SerializedLexicalNode> = {\n  converter: ({\n    childIndex,\n    converters,\n    parentNodeType,\n    slateNode,\n  }: {\n    childIndex: number\n    converters: SlateNodeConverter[]\n    parentNodeType: string\n    slateNode: SlateNode\n  }) => T\n  nodeTypes: string[]\n}\n\nexport type SlateNode = {\n  [key: string]: any\n  children?: SlateNode[]\n  type?: string // doesn't always have type, e.g. for paragraphs\n}\n"],"mappings":"AAiBA","ignoreList":[]}

package/dist/features/migrations/slateToLexical/feature.client.d.ts

@@ -0,0 +1,2 @@
+export declare const SlateToLexicalFeatureClient: import("../../typesClient.js").FeatureProviderProviderClient<undefined, undefined>;
+//# sourceMappingURL=feature.client.d.ts.map

package/dist/features/migrations/slateToLexical/feature.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/slateToLexical/feature.client.tsx"],"names":[],"mappings":"AAKA,eAAO,MAAM,2BAA2B,oFAItC,CAAA"}

package/dist/features/migrations/slateToLexical/feature.client.js

@@ -0,0 +1,10 @@
+'use client';
+
+import { createClientFeature } from '../../../utilities/createClientFeature.js';
+import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
+export const SlateToLexicalFeatureClient = createClientFeature(() => {
+  return {
+    nodes: [UnknownConvertedNode]
+  };
+});
+//# sourceMappingURL=feature.client.js.map

package/dist/features/migrations/slateToLexical/feature.client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.client.js","names":["createClientFeature","UnknownConvertedNode","SlateToLexicalFeatureClient","nodes"],"sources":["../../../../src/features/migrations/slateToLexical/feature.client.tsx"],"sourcesContent":["'use client'\n\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport const SlateToLexicalFeatureClient = createClientFeature(() => {\n  return {\n    nodes: [UnknownConvertedNode],\n  }\n})\n"],"mappings":"AAAA;;AAEA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,oBAAoB,QAAQ;AAErC,OAAO,MAAMC,2BAAA,GAA8BF,mBAAA,CAAoB;EAC7D,OAAO;IACLG,KAAA,EAAO,CAACF,oBAAA;EACV;AACF","ignoreList":[]}

package/dist/features/migrations/slateToLexical/feature.server.d.ts

@@ -0,0 +1,11 @@
+import type { SlateNodeConverter } from './converter/types.js';
+export type SlateToLexicalFeatureProps = {
+    converters?: (({ defaultConverters }: {
+        defaultConverters: SlateNodeConverter[];
+    }) => SlateNodeConverter[]) | SlateNodeConverter[];
+    disableHooks?: boolean;
+};
+export declare const SlateToLexicalFeature: import("../../typesServer.js").FeatureProviderProviderServer<SlateToLexicalFeatureProps, {
+    converters?: SlateNodeConverter[];
+}, undefined>;
+//# sourceMappingURL=feature.server.d.ts.map

package/dist/features/migrations/slateToLexical/feature.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.d.ts","sourceRoot":"","sources":["../../../../src/features/migrations/slateToLexical/feature.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAO9D,MAAM,MAAM,0BAA0B,GAAG;IACvC,UAAU,CAAC,EACP,CAAC,CAAC,EAAE,iBAAiB,EAAE,EAAE;QAAE,iBAAiB,EAAE,kBAAkB,EAAE,CAAA;KAAE,KAAK,kBAAkB,EAAE,CAAC,GAC9F,kBAAkB,EAAE,CAAA;IACxB,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA;AAED,eAAO,MAAM,qBAAqB;iBAGjB,kBAAkB,EAAE;aAkDnC,CAAA"}

package/dist/features/migrations/slateToLexical/feature.server.js

@@ -0,0 +1,50 @@
+import { createServerFeature } from '../../../utilities/createServerFeature.js';
+import { defaultSlateConverters } from './converter/defaultConverters.js';
+import { convertSlateToLexical } from './converter/index.js';
+import { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js';
+export const SlateToLexicalFeature = createServerFeature({
+  feature: ({
+    props
+  }) => {
+    if (!props) {
+      props = {};
+    }
+    let converters = [];
+    if (props?.converters && typeof props?.converters === 'function') {
+      converters = props.converters({
+        defaultConverters: defaultSlateConverters
+      });
+    } else if (props.converters && typeof props?.converters !== 'function') {
+      converters = props.converters;
+    } else {
+      converters = defaultSlateConverters;
+    }
+    props.converters = converters;
+    return {
+      ClientFeature: '@payloadcms/richtext-lexical/client#SlateToLexicalFeatureClient',
+      hooks: props.disableHooks ? undefined : {
+        afterRead: [({
+          value
+        }) => {
+          if (!value || !Array.isArray(value) || 'root' in value) {
+            // incomingEditorState null or not from Slate
+            return value;
+          }
+          // Slate => convert to lexical
+          return convertSlateToLexical({
+            converters: props.converters,
+            slateData: value
+          });
+        }]
+      },
+      nodes: [{
+        node: UnknownConvertedNode
+      }],
+      sanitizedServerFeatureProps: {
+        converters
+      }
+    };
+  },
+  key: 'slateToLexical'
+});
+//# sourceMappingURL=feature.server.js.map

package/dist/features/migrations/slateToLexical/feature.server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature.server.js","names":["createServerFeature","defaultSlateConverters","convertSlateToLexical","UnknownConvertedNode","SlateToLexicalFeature","feature","props","converters","defaultConverters","ClientFeature","hooks","disableHooks","undefined","afterRead","value","Array","isArray","slateData","nodes","node","sanitizedServerFeatureProps","key"],"sources":["../../../../src/features/migrations/slateToLexical/feature.server.ts"],"sourcesContent":["import type { SlateNodeConverter } from './converter/types.js'\n\nimport { createServerFeature } from '../../../utilities/createServerFeature.js'\nimport { defaultSlateConverters } from './converter/defaultConverters.js'\nimport { convertSlateToLexical } from './converter/index.js'\nimport { UnknownConvertedNode } from './nodes/unknownConvertedNode/index.js'\n\nexport type SlateToLexicalFeatureProps = {\n  converters?:\n    | (({ defaultConverters }: { defaultConverters: SlateNodeConverter[] }) => SlateNodeConverter[])\n    | SlateNodeConverter[]\n  disableHooks?: boolean\n}\n\nexport const SlateToLexicalFeature = createServerFeature<\n  SlateToLexicalFeatureProps,\n  {\n    converters?: SlateNodeConverter[]\n  }\n>({\n  feature: ({ props }) => {\n    if (!props) {\n      props = {}\n    }\n\n    let converters: SlateNodeConverter[] = []\n    if (props?.converters && typeof props?.converters === 'function') {\n      converters = props.converters({ defaultConverters: defaultSlateConverters })\n    } else if (props.converters && typeof props?.converters !== 'function') {\n      converters = props.converters\n    } else {\n      converters = defaultSlateConverters\n    }\n\n    props.converters = converters\n\n    return {\n      ClientFeature: '@payloadcms/richtext-lexical/client#SlateToLexicalFeatureClient',\n      hooks: props.disableHooks\n        ? undefined\n        : {\n            afterRead: [\n              ({ value }) => {\n                if (!value || !Array.isArray(value) || 'root' in value) {\n                  // incomingEditorState null or not from Slate\n                  return value\n                }\n\n                // Slate => convert to lexical\n                return convertSlateToLexical({\n                  converters: props.converters as SlateNodeConverter[],\n                  slateData: value,\n                })\n              },\n            ],\n          },\n      nodes: [\n        {\n          node: UnknownConvertedNode,\n        },\n      ],\n      sanitizedServerFeatureProps: {\n        converters,\n      },\n    }\n  },\n  key: 'slateToLexical',\n})\n"],"mappings":"AAEA,SAASA,mBAAmB,QAAQ;AACpC,SAASC,sBAAsB,QAAQ;AACvC,SAASC,qBAAqB,QAAQ;AACtC,SAASC,oBAAoB,QAAQ;AASrC,OAAO,MAAMC,qBAAA,GAAwBJ,mBAAA,CAKnC;EACAK,OAAA,EAASA,CAAC;IAAEC;EAAK,CAAE;IACjB,IAAI,CAACA,KAAA,EAAO;MACVA,KAAA,GAAQ,CAAC;IACX;IAEA,IAAIC,UAAA,GAAmC,EAAE;IACzC,IAAID,KAAA,EAAOC,UAAA,IAAc,OAAOD,KAAA,EAAOC,UAAA,KAAe,YAAY;MAChEA,UAAA,GAAaD,KAAA,CAAMC,UAAU,CAAC;QAAEC,iBAAA,EAAmBP;MAAuB;IAC5E,OAAO,IAAIK,KAAA,CAAMC,UAAU,IAAI,OAAOD,KAAA,EAAOC,UAAA,KAAe,YAAY;MACtEA,UAAA,GAAaD,KAAA,CAAMC,UAAU;IAC/B,OAAO;MACLA,UAAA,GAAaN,sBAAA;IACf;IAEAK,KAAA,CAAMC,UAAU,GAAGA,UAAA;IAEnB,OAAO;MACLE,aAAA,EAAe;MACfC,KAAA,EAAOJ,KAAA,CAAMK,YAAY,GACrBC,SAAA,GACA;QACEC,SAAA,EAAW,CACT,CAAC;UAAEC;QAAK,CAAE;UACR,IAAI,CAACA,KAAA,IAAS,CAACC,KAAA,CAAMC,OAAO,CAACF,KAAA,KAAU,UAAUA,KAAA,EAAO;YACtD;YACA,OAAOA,KAAA;UACT;UAEA;UACA,OAAOZ,qBAAA,CAAsB;YAC3BK,UAAA,EAAYD,KAAA,CAAMC,UAAU;YAC5BU,SAAA,EAAWH;UACb;QACF;MAEJ;MACJI,KAAA,EAAO,CACL;QACEC,IAAA,EAAMhB;MACR,EACD;MACDiB,2BAAA,EAA6B;QAC3Bb;MACF;IACF;EACF;EACAc,GAAA,EAAK;AACP","ignoreList":[]}

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Component.d.ts","sourceRoot":"","sources":["../../../../../../src/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAE1D,OAAO,cAAc,CAAA;AAErB,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,wBAAwB,CAAA;CAC/B,CAAA;AAED,eAAO,MAAM,6BAA6B,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CAQzD,CAAA"}

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.js

@@ -0,0 +1,15 @@
+'use client';
+
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+export const UnknownConvertedNodeComponent = props => {
+  const {
+    data
+  } = props;
+  return /*#__PURE__*/_jsxs("div", {
+    children: ["Unknown converted Slate node: ", /*#__PURE__*/_jsx("strong", {
+      children: data?.nodeType
+    })]
+  });
+};
+//# sourceMappingURL=Component.js.map

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Component.js","names":["React","UnknownConvertedNodeComponent","props","data","_jsxs","_jsx","nodeType"],"sources":["../../../../../../src/features/migrations/slateToLexical/nodes/unknownConvertedNode/Component.tsx"],"sourcesContent":["'use client'\nimport React from 'react'\n\nimport type { UnknownConvertedNodeData } from './index.js'\n\nimport './index.scss'\n\ntype Props = {\n  data: UnknownConvertedNodeData\n}\n\nexport const UnknownConvertedNodeComponent: React.FC<Props> = (props) => {\n  const { data } = props\n\n  return (\n    <div>\n      Unknown converted Slate node: <strong>{data?.nodeType}</strong>\n    </div>\n  )\n}\n"],"mappings":"AAAA;;;AACA,OAAOA,KAAA,MAAW;AAUlB,OAAO,MAAMC,6BAAA,GAAkDC,KAAA;EAC7D,MAAM;IAAEC;EAAI,CAAE,GAAGD,KAAA;EAEjB,oBACEE,KAAA,CAAC;eAAI,kC,aAC2BC,IAAA,CAAC;gBAAQF,IAAA,EAAMG;;;AAGnD","ignoreList":[]}

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.d.ts

@@ -0,0 +1,33 @@
+import type { EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical';
+import type { JSX } from 'react';
+import { DecoratorNode } from 'lexical';
+export type UnknownConvertedNodeData = {
+    nodeData: unknown;
+    nodeType: string;
+};
+export type SerializedUnknownConvertedNode = Spread<{
+    data: UnknownConvertedNodeData;
+}, SerializedLexicalNode>;
+/** @noInheritDoc */
+export declare class UnknownConvertedNode extends DecoratorNode<JSX.Element> {
+    __data: UnknownConvertedNodeData;
+    constructor({ data, key }: {
+        data: UnknownConvertedNodeData;
+        key?: NodeKey;
+    });
+    static clone(node: UnknownConvertedNode): UnknownConvertedNode;
+    static getType(): string;
+    static importJSON(serializedNode: SerializedUnknownConvertedNode): UnknownConvertedNode;
+    canInsertTextAfter(): true;
+    canInsertTextBefore(): true;
+    createDOM(config: EditorConfig): HTMLElement;
+    decorate(): JSX.Element;
+    exportJSON(): SerializedUnknownConvertedNode;
+    isInline(): boolean;
+    updateDOM(prevNode: UnknownConvertedNode, dom: HTMLElement): boolean;
+}
+export declare function $createUnknownConvertedNode({ data, }: {
+    data: UnknownConvertedNodeData;
+}): UnknownConvertedNode;
+export declare function $isUnknownConvertedNode(node: LexicalNode | null | undefined): node is UnknownConvertedNode;
+//# sourceMappingURL=index.d.ts.map

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAChG,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAGhC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAGvC,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,8BAA8B,GAAG,MAAM,CACjD;IACE,IAAI,EAAE,wBAAwB,CAAA;CAC/B,EACD,qBAAqB,CACtB,CAAA;AAQD,oBAAoB;AACpB,qBAAa,oBAAqB,SAAQ,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC;IAClE,MAAM,EAAE,wBAAwB,CAAA;gBAEpB,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;QAAE,IAAI,EAAE,wBAAwB,CAAC;QAAC,GAAG,CAAC,EAAE,OAAO,CAAA;KAAE;IAK5E,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,oBAAoB,GAAG,oBAAoB;IAO9D,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,8BAA8B,GAAG,oBAAoB;IAKvF,kBAAkB,IAAI,IAAI;IAI1B,mBAAmB,IAAI,IAAI;IAI3B,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAM5C,QAAQ,IAAI,GAAG,CAAC,OAAO;IAIvB,UAAU,IAAI,8BAA8B;IAU5C,QAAQ,IAAI,OAAO;IAInB,SAAS,CAAC,QAAQ,EAAE,oBAAoB,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO;CAGrE;AAED,wBAAgB,2BAA2B,CAAC,EAC1C,IAAI,GACL,EAAE;IACD,IAAI,EAAE,wBAAwB,CAAA;CAC/B,GAAG,oBAAoB,CAIvB;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACnC,IAAI,IAAI,oBAAoB,CAE9B"}

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.js

@@ -0,0 +1,74 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { addClassNamesToElement } from '@lexical/utils';
+import { DecoratorNode } from 'lexical';
+import * as React from 'react';
+const Component = /*#__PURE__*/React.lazy(() => import('./Component.js').then(module => ({
+  default: module.UnknownConvertedNodeComponent
+})));
+/** @noInheritDoc */
+export class UnknownConvertedNode extends DecoratorNode {
+  __data;
+  constructor({
+    data,
+    key
+  }) {
+    super(key);
+    this.__data = data;
+  }
+  static clone(node) {
+    return new UnknownConvertedNode({
+      data: node.__data,
+      key: node.__key
+    });
+  }
+  static getType() {
+    return 'unknownConverted';
+  }
+  static importJSON(serializedNode) {
+    const node = $createUnknownConvertedNode({
+      data: serializedNode.data
+    });
+    return node;
+  }
+  canInsertTextAfter() {
+    return true;
+  }
+  canInsertTextBefore() {
+    return true;
+  }
+  createDOM(config) {
+    const element = document.createElement('span');
+    addClassNamesToElement(element, 'unknownConverted');
+    return element;
+  }
+  decorate() {
+    return /*#__PURE__*/_jsx(Component, {
+      data: this.__data
+    });
+  }
+  exportJSON() {
+    return {
+      type: this.getType(),
+      data: this.__data,
+      version: 1
+    };
+  }
+  // Mutation
+  isInline() {
+    return true;
+  }
+  updateDOM(prevNode, dom) {
+    return false;
+  }
+}
+export function $createUnknownConvertedNode({
+  data
+}) {
+  return new UnknownConvertedNode({
+    data
+  });
+}
+export function $isUnknownConvertedNode(node) {
+  return node instanceof UnknownConvertedNode;
+}
+//# sourceMappingURL=index.js.map

package/dist/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["addClassNamesToElement","DecoratorNode","React","Component","lazy","then","module","default","UnknownConvertedNodeComponent","UnknownConvertedNode","__data","constructor","data","key","clone","node","__key","getType","importJSON","serializedNode","$createUnknownConvertedNode","canInsertTextAfter","canInsertTextBefore","createDOM","config","element","document","createElement","decorate","_jsx","exportJSON","type","version","isInline","updateDOM","prevNode","dom","$isUnknownConvertedNode"],"sources":["../../../../../../src/features/migrations/slateToLexical/nodes/unknownConvertedNode/index.tsx"],"sourcesContent":["import type { EditorConfig, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical'\nimport type { JSX } from 'react'\n\nimport { addClassNamesToElement } from '@lexical/utils'\nimport { DecoratorNode } from 'lexical'\nimport * as React from 'react'\n\nexport type UnknownConvertedNodeData = {\n  nodeData: unknown\n  nodeType: string\n}\n\nexport type SerializedUnknownConvertedNode = Spread<\n  {\n    data: UnknownConvertedNodeData\n  },\n  SerializedLexicalNode\n>\n\nconst Component = React.lazy(() =>\n  import('./Component.js').then((module) => ({\n    default: module.UnknownConvertedNodeComponent,\n  })),\n)\n\n/** @noInheritDoc */\nexport class UnknownConvertedNode extends DecoratorNode<JSX.Element> {\n  __data: UnknownConvertedNodeData\n\n  constructor({ data, key }: { data: UnknownConvertedNodeData; key?: NodeKey }) {\n    super(key)\n    this.__data = data\n  }\n\n  static clone(node: UnknownConvertedNode): UnknownConvertedNode {\n    return new UnknownConvertedNode({\n      data: node.__data,\n      key: node.__key,\n    })\n  }\n\n  static getType(): string {\n    return 'unknownConverted'\n  }\n\n  static importJSON(serializedNode: SerializedUnknownConvertedNode): UnknownConvertedNode {\n    const node = $createUnknownConvertedNode({ data: serializedNode.data })\n    return node\n  }\n\n  canInsertTextAfter(): true {\n    return true\n  }\n\n  canInsertTextBefore(): true {\n    return true\n  }\n\n  createDOM(config: EditorConfig): HTMLElement {\n    const element = document.createElement('span')\n    addClassNamesToElement(element, 'unknownConverted')\n    return element\n  }\n\n  decorate(): JSX.Element {\n    return <Component data={this.__data} />\n  }\n\n  exportJSON(): SerializedUnknownConvertedNode {\n    return {\n      type: this.getType(),\n      data: this.__data,\n      version: 1,\n    }\n  }\n\n  // Mutation\n\n  isInline(): boolean {\n    return true\n  }\n\n  updateDOM(prevNode: UnknownConvertedNode, dom: HTMLElement): boolean {\n    return false\n  }\n}\n\nexport function $createUnknownConvertedNode({\n  data,\n}: {\n  data: UnknownConvertedNodeData\n}): UnknownConvertedNode {\n  return new UnknownConvertedNode({\n    data,\n  })\n}\n\nexport function $isUnknownConvertedNode(\n  node: LexicalNode | null | undefined,\n): node is UnknownConvertedNode {\n  return node instanceof UnknownConvertedNode\n}\n"],"mappings":";AAGA,SAASA,sBAAsB,QAAQ;AACvC,SAASC,aAAa,QAAQ;AAC9B,YAAYC,KAAA,MAAW;AAcvB,MAAMC,SAAA,gBAAYD,KAAA,CAAME,IAAI,CAAC,MAC3B,MAAM,CAAC,kBAAkBC,IAAI,CAAEC,MAAA,KAAY;EACzCC,OAAA,EAASD,MAAA,CAAOE;AAClB;AAGF;AACA,OAAO,MAAMC,oBAAA,SAA6BR,aAAA;EACxCS,MAAA;EAEAC,YAAY;IAAEC,IAAI;IAAEC;EAAG,CAAqD,EAAE;IAC5E,KAAK,CAACA,GAAA;IACN,IAAI,CAACH,MAAM,GAAGE,IAAA;EAChB;EAEA,OAAOE,MAAMC,IAA0B,EAAwB;IAC7D,OAAO,IAAIN,oBAAA,CAAqB;MAC9BG,IAAA,EAAMG,IAAA,CAAKL,MAAM;MACjBG,GAAA,EAAKE,IAAA,CAAKC;IACZ;EACF;EAEA,OAAOC,QAAA,EAAkB;IACvB,OAAO;EACT;EAEA,OAAOC,WAAWC,cAA8C,EAAwB;IACtF,MAAMJ,IAAA,GAAOK,2BAAA,CAA4B;MAAER,IAAA,EAAMO,cAAA,CAAeP;IAAK;IACrE,OAAOG,IAAA;EACT;EAEAM,mBAAA,EAA2B;IACzB,OAAO;EACT;EAEAC,oBAAA,EAA4B;IAC1B,OAAO;EACT;EAEAC,UAAUC,MAAoB,EAAe;IAC3C,MAAMC,OAAA,GAAUC,QAAA,CAASC,aAAa,CAAC;IACvC3B,sBAAA,CAAuByB,OAAA,EAAS;IAChC,OAAOA,OAAA;EACT;EAEAG,SAAA,EAAwB;IACtB,oBAAOC,IAAA,CAAC1B,SAAA;MAAUS,IAAA,EAAM,IAAI,CAACF;;EAC/B;EAEAoB,WAAA,EAA6C;IAC3C,OAAO;MACLC,IAAA,EAAM,IAAI,CAACd,OAAO;MAClBL,IAAA,EAAM,IAAI,CAACF,MAAM;MACjBsB,OAAA,EAAS;IACX;EACF;EAEA;EAEAC,SAAA,EAAoB;IAClB,OAAO;EACT;EAEAC,UAAUC,QAA8B,EAAEC,GAAgB,EAAW;IACnE,OAAO;EACT;AACF;AAEA,OAAO,SAAShB,4BAA4B;EAC1CR;AAAI,CAGL;EACC,OAAO,IAAIH,oBAAA,CAAqB;IAC9BG;EACF;AACF;AAEA,OAAO,SAASyB,wBACdtB,IAAoC;EAEpC,OAAOA,IAAA,YAAgBN,oBAAA;AACzB","ignoreList":[]}

package/dist/features/paragraph/client/index.d.ts

@@ -0,0 +1,2 @@
+export declare const ParagraphFeatureClient: import("../../typesClient.js").FeatureProviderProviderClient<undefined, undefined>;
+//# sourceMappingURL=index.d.ts.map

package/dist/features/paragraph/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/features/paragraph/client/index.tsx"],"names":[],"mappings":"AA0CA,eAAO,MAAM,sBAAsB,oFA2BjC,CAAA"}

package/dist/features/paragraph/client/index.js

@@ -0,0 +1,68 @@
+'use client';
+
+import { $setBlocksType } from '@lexical/selection';
+import { $createParagraphNode, $getSelection, $isParagraphNode, $isRangeSelection } from 'lexical';
+import { TextIcon } from '../../../lexical/ui/icons/Text/index.js';
+import { createClientFeature } from '../../../utilities/createClientFeature.js';
+import { slashMenuBasicGroupWithItems } from '../../shared/slashMenu/basicGroup.js';
+import { toolbarTextDropdownGroupWithItems } from '../../shared/toolbar/textDropdownGroup.js';
+const toolbarGroups = [toolbarTextDropdownGroupWithItems([{
+  ChildComponent: TextIcon,
+  isActive: ({
+    selection
+  }) => {
+    if (!$isRangeSelection(selection)) {
+      return false;
+    }
+    for (const node of selection.getNodes()) {
+      if (!$isParagraphNode(node) && !$isParagraphNode(node.getParent())) {
+        return false;
+      }
+    }
+    return true;
+  },
+  key: 'paragraph',
+  label: ({
+    i18n
+  }) => {
+    return i18n.t('lexical:paragraph:label2');
+  },
+  onSelect: ({
+    editor
+  }) => {
+    editor.update(() => {
+      const selection = $getSelection();
+      $setBlocksType(selection, () => $createParagraphNode());
+    });
+  },
+  order: 1
+}])];
+export const ParagraphFeatureClient = createClientFeature({
+  slashMenu: {
+    groups: [slashMenuBasicGroupWithItems([{
+      Icon: TextIcon,
+      key: 'paragraph',
+      keywords: ['normal', 'paragraph', 'p', 'text'],
+      label: ({
+        i18n
+      }) => {
+        return i18n.t('lexical:paragraph:label');
+      },
+      onSelect: ({
+        editor
+      }) => {
+        editor.update(() => {
+          const selection = $getSelection();
+          $setBlocksType(selection, () => $createParagraphNode());
+        });
+      }
+    }])]
+  },
+  toolbarFixed: {
+    groups: toolbarGroups
+  },
+  toolbarInline: {
+    groups: toolbarGroups
+  }
+});
+//# sourceMappingURL=index.js.map

package/dist/features/paragraph/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["$setBlocksType","$createParagraphNode","$getSelection","$isParagraphNode","$isRangeSelection","TextIcon","createClientFeature","slashMenuBasicGroupWithItems","toolbarTextDropdownGroupWithItems","toolbarGroups","ChildComponent","isActive","selection","node","getNodes","getParent","key","label","i18n","t","onSelect","editor","update","order","ParagraphFeatureClient","slashMenu","groups","Icon","keywords","toolbarFixed","toolbarInline"],"sources":["../../../../src/features/paragraph/client/index.tsx"],"sourcesContent":["'use client'\n\nimport { $setBlocksType } from '@lexical/selection'\nimport { $createParagraphNode, $getSelection, $isParagraphNode, $isRangeSelection } from 'lexical'\n\nimport type { ToolbarGroup } from '../../toolbars/types.js'\n\nimport { TextIcon } from '../../../lexical/ui/icons/Text/index.js'\nimport { createClientFeature } from '../../../utilities/createClientFeature.js'\nimport { slashMenuBasicGroupWithItems } from '../../shared/slashMenu/basicGroup.js'\nimport { toolbarTextDropdownGroupWithItems } from '../../shared/toolbar/textDropdownGroup.js'\n\nconst toolbarGroups: ToolbarGroup[] = [\n  toolbarTextDropdownGroupWithItems([\n    {\n      ChildComponent: TextIcon,\n      isActive: ({ selection }) => {\n        if (!$isRangeSelection(selection)) {\n          return false\n        }\n        for (const node of selection.getNodes()) {\n          if (!$isParagraphNode(node) && !$isParagraphNode(node.getParent())) {\n            return false\n          }\n        }\n        return true\n      },\n      key: 'paragraph',\n      label: ({ i18n }) => {\n        return i18n.t('lexical:paragraph:label2')\n      },\n      onSelect: ({ editor }) => {\n        editor.update(() => {\n          const selection = $getSelection()\n          $setBlocksType(selection, () => $createParagraphNode())\n        })\n      },\n      order: 1,\n    },\n  ]),\n]\n\nexport const ParagraphFeatureClient = createClientFeature({\n  slashMenu: {\n    groups: [\n      slashMenuBasicGroupWithItems([\n        {\n          Icon: TextIcon,\n          key: 'paragraph',\n          keywords: ['normal', 'paragraph', 'p', 'text'],\n          label: ({ i18n }) => {\n            return i18n.t('lexical:paragraph:label')\n          },\n          onSelect: ({ editor }) => {\n            editor.update(() => {\n              const selection = $getSelection()\n              $setBlocksType(selection, () => $createParagraphNode())\n            })\n          },\n        },\n      ]),\n    ],\n  },\n  toolbarFixed: {\n    groups: toolbarGroups,\n  },\n  toolbarInline: {\n    groups: toolbarGroups,\n  },\n})\n"],"mappings":"AAAA;;AAEA,SAASA,cAAc,QAAQ;AAC/B,SAASC,oBAAoB,EAAEC,aAAa,EAAEC,gBAAgB,EAAEC,iBAAiB,QAAQ;AAIzF,SAASC,QAAQ,QAAQ;AACzB,SAASC,mBAAmB,QAAQ;AACpC,SAASC,4BAA4B,QAAQ;AAC7C,SAASC,iCAAiC,QAAQ;AAElD,MAAMC,aAAA,GAAgC,CACpCD,iCAAA,CAAkC,CAChC;EACEE,cAAA,EAAgBL,QAAA;EAChBM,QAAA,EAAUA,CAAC;IAAEC;EAAS,CAAE;IACtB,IAAI,CAACR,iBAAA,CAAkBQ,SAAA,GAAY;MACjC,OAAO;IACT;IACA,KAAK,MAAMC,IAAA,IAAQD,SAAA,CAAUE,QAAQ,IAAI;MACvC,IAAI,CAACX,gBAAA,CAAiBU,IAAA,KAAS,CAACV,gBAAA,CAAiBU,IAAA,CAAKE,SAAS,KAAK;QAClE,OAAO;MACT;IACF;IACA,OAAO;EACT;EACAC,GAAA,EAAK;EACLC,KAAA,EAAOA,CAAC;IAAEC;EAAI,CAAE;IACd,OAAOA,IAAA,CAAKC,CAAC,CAAC;EAChB;EACAC,QAAA,EAAUA,CAAC;IAAEC;EAAM,CAAE;IACnBA,MAAA,CAAOC,MAAM,CAAC;MACZ,MAAMV,SAAA,GAAYV,aAAA;MAClBF,cAAA,CAAeY,SAAA,EAAW,MAAMX,oBAAA;IAClC;EACF;EACAsB,KAAA,EAAO;AACT,EACD,EACF;AAED,OAAO,MAAMC,sBAAA,GAAyBlB,mBAAA,CAAoB;EACxDmB,SAAA,EAAW;IACTC,MAAA,EAAQ,CACNnB,4BAAA,CAA6B,CAC3B;MACEoB,IAAA,EAAMtB,QAAA;MACNW,GAAA,EAAK;MACLY,QAAA,EAAU,CAAC,UAAU,aAAa,KAAK,OAAO;MAC9CX,KAAA,EAAOA,CAAC;QAAEC;MAAI,CAAE;QACd,OAAOA,IAAA,CAAKC,CAAC,CAAC;MAChB;MACAC,QAAA,EAAUA,CAAC;QAAEC;MAAM,CAAE;QACnBA,MAAA,CAAOC,MAAM,CAAC;UACZ,MAAMV,SAAA,GAAYV,aAAA;UAClBF,cAAA,CAAeY,SAAA,EAAW,MAAMX,oBAAA;QAClC;MACF;IACF,EACD;EAEL;EACA4B,YAAA,EAAc;IACZH,MAAA,EAAQjB;EACV;EACAqB,aAAA,EAAe;IACbJ,MAAA,EAAQjB;EACV;AACF","ignoreList":[]}

package/dist/features/paragraph/server/i18n.d.ts

@@ -0,0 +1,3 @@
+import type { GenericLanguages } from '@payloadcms/translations';
+export declare const i18n: Partial<GenericLanguages>;
+//# sourceMappingURL=i18n.d.ts.map

package/dist/features/paragraph/server/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../../../src/features/paragraph/server/i18n.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAEhE,eAAO,MAAM,IAAI,EAAE,OAAO,CAAC,gBAAgB,CAiI1C,CAAA"}

package/dist/features/paragraph/server/i18n.js

@@ -0,0 +1,131 @@
+export const i18n = {
+  ar: {
+    label: 'فقرة',
+    label2: 'نص عادي'
+  },
+  az: {
+    label: 'Paraqraf',
+    label2: 'Normal Mətn'
+  },
+  bg: {
+    label: 'Параграф',
+    label2: 'Нормален текст'
+  },
+  cs: {
+    label: 'Odstavec',
+    label2: 'Normální text'
+  },
+  de: {
+    label: 'Paragraph',
+    label2: 'Normaler Text'
+  },
+  en: {
+    label: 'Paragraph',
+    label2: 'Normal Text'
+  },
+  es: {
+    label: 'Párrafo',
+    label2: 'Texto normal'
+  },
+  fa: {
+    label: 'پاراگراف',
+    label2: 'متن عادی'
+  },
+  fr: {
+    label: 'Paragraphe',
+    label2: 'Texte normal'
+  },
+  he: {
+    label: 'פסקה',
+    label2: 'טקסט רגיל'
+  },
+  hr: {
+    label: 'Odlomak',
+    label2: 'Normalan tekst'
+  },
+  hu: {
+    label: 'Bekezdés',
+    label2: 'Normál szöveg'
+  },
+  it: {
+    label: 'Paragrafo',
+    label2: 'Testo normale'
+  },
+  ja: {
+    label: '段落',
+    label2: '通常のテキスト'
+  },
+  ko: {
+    label: '문단',
+    label2: '일반 텍스트'
+  },
+  my: {
+    label: 'Perenggan',
+    label2: 'ပုံမှန်စာသား'
+  },
+  nb: {
+    label: 'Avsnitt',
+    label2: 'Normal tekst'
+  },
+  nl: {
+    label: 'Paragraaf',
+    label2: 'Normale tekst'
+  },
+  pl: {
+    label: 'Akapit',
+    label2: 'Normalny tekst'
+  },
+  pt: {
+    label: 'Parágrafo',
+    label2: 'Texto Normal'
+  },
+  ro: {
+    label: 'Paragraf',
+    label2: 'Text normal'
+  },
+  rs: {
+    label: 'Paragraf',
+    label2: 'Normalan tekst'
+  },
+  'rs-latin': {
+    label: 'Paragraf',
+    label2: 'Normalan tekst'
+  },
+  ru: {
+    label: 'Параграф',
+    label2: 'Нормальный текст'
+  },
+  sk: {
+    label: 'Odsek',
+    label2: 'Normálny text'
+  },
+  sv: {
+    label: 'Stycke',
+    label2: 'Normal Text'
+  },
+  th: {
+    label: 'ย่อหน้า',
+    label2: 'ข้อความธรรมดา'
+  },
+  tr: {
+    label: 'Paragraf',
+    label2: 'Normal Metin'
+  },
+  uk: {
+    label: 'Абзац',
+    label2: 'Звичайний текст'
+  },
+  vi: {
+    label: 'Đoạn văn',
+    label2: 'Văn bản bình thường'
+  },
+  zh: {
+    label: '段落',
+    label2: '正常文本'
+  },
+  'zh-TW': {
+    label: '段落',
+    label2: '正常文本'
+  }
+};
+//# sourceMappingURL=i18n.js.map