@payloadcms/plugin-form-builder 1.0.16-beta.0 → 1.1.1

package/dist/utilities/lexical/converters/list.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ListHTMLConverter: function() {
+        return ListHTMLConverter;
+    },
+    ListItemHTMLConverter: function() {
+        return ListItemHTMLConverter;
+    }
+});
+const _serializeLexical = require("../serializeLexical");
+const ListHTMLConverter = {
+    converter: async ({ converters, node, parent })=>{
+        const childrenText = await (0, _serializeLexical.convertLexicalNodesToHTML)({
+            converters,
+            lexicalNodes: node.children,
+            parent: {
+                ...node,
+                parent
+            }
+        });
+        return `<${node?.tag} class="${node?.listType}">${childrenText}</${node?.tag}>`;
+    },
+    nodeTypes: [
+        'list'
+    ]
+};
+const ListItemHTMLConverter = {
+    converter: async ({ converters, node, parent })=>{
+        const childrenText = await (0, _serializeLexical.convertLexicalNodesToHTML)({
+            converters,
+            lexicalNodes: node.children,
+            parent: {
+                ...node,
+                parent
+            }
+        });
+        if ('listType' in parent && parent?.listType === 'check') {
+            return `<li aria-checked=${node.checked ? 'true' : 'false'} class="${'list-item-checkbox' + node.checked ? 'list-item-checkbox-checked' : 'list-item-checkbox-unchecked'}"
+          role="checkbox"
+          tabIndex=${-1}
+          value=${node?.value}
+      >
+          {serializedChildren}
+          </li>`;
+        } else {
+            return `<li value=${node?.value}>${childrenText}</li>`;
+        }
+    },
+    nodeTypes: [
+        'listitem'
+    ]
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utilities/lexical/converters/paragraph.d.ts

@@ -0,0 +1,3 @@
+import type { HTMLConverter } from '../types';
+export declare const ParagraphHTMLConverter: HTMLConverter<any>;
+//# sourceMappingURL=paragraph.d.ts.map

package/dist/utilities/lexical/converters/paragraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph.d.ts","sourceRoot":"","sources":["../../../../src/utilities/lexical/converters/paragraph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAI7C,eAAO,MAAM,sBAAsB,EAAE,aAAa,CAAC,GAAG,CAarD,CAAA"}

package/dist/utilities/lexical/converters/paragraph.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ParagraphHTMLConverter", {
+    enumerable: true,
+    get: function() {
+        return ParagraphHTMLConverter;
+    }
+});
+const _serializeLexical = require("../serializeLexical");
+const ParagraphHTMLConverter = {
+    async converter ({ converters, node, parent }) {
+        const childrenText = await (0, _serializeLexical.convertLexicalNodesToHTML)({
+            converters,
+            lexicalNodes: node.children,
+            parent: {
+                ...node,
+                parent
+            }
+        });
+        return `<p>${childrenText}</p>`;
+    },
+    nodeTypes: [
+        'paragraph'
+    ]
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy91dGlsaXRpZXMvbGV4aWNhbC9jb252ZXJ0ZXJzL3BhcmFncmFwaC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEhUTUxDb252ZXJ0ZXIgfSBmcm9tICcuLi90eXBlcydcblxuaW1wb3J0IHsgY29udmVydExleGljYWxOb2Rlc1RvSFRNTCB9IGZyb20gJy4uL3NlcmlhbGl6ZUxleGljYWwnXG5cbmV4cG9ydCBjb25zdCBQYXJhZ3JhcGhIVE1MQ29udmVydGVyOiBIVE1MQ29udmVydGVyPGFueT4gPSB7XG4gIGFzeW5jIGNvbnZlcnRlcih7IGNvbnZlcnRlcnMsIG5vZGUsIHBhcmVudCB9KSB7XG4gICAgY29uc3QgY2hpbGRyZW5UZXh0ID0gYXdhaXQgY29udmVydExleGljYWxOb2Rlc1RvSFRNTCh7XG4gICAgICBjb252ZXJ0ZXJzLFxuICAgICAgbGV4aWNhbE5vZGVzOiBub2RlLmNoaWxkcmVuLFxuICAgICAgcGFyZW50OiB7XG4gICAgICAgIC4uLm5vZGUsXG4gICAgICAgIHBhcmVudCxcbiAgICAgIH0sXG4gICAgfSlcbiAgICByZXR1cm4gYDxwPiR7Y2hpbGRyZW5UZXh0fTwvcD5gXG4gIH0sXG4gIG5vZGVUeXBlczogWydwYXJhZ3JhcGgnXSxcbn1cbiJdLCJuYW1lcyI6WyJQYXJhZ3JhcGhIVE1MQ29udmVydGVyIiwiY29udmVydGVyIiwiY29udmVydGVycyIsIm5vZGUiLCJwYXJlbnQiLCJjaGlsZHJlblRleHQiLCJjb252ZXJ0TGV4aWNhbE5vZGVzVG9IVE1MIiwibGV4aWNhbE5vZGVzIiwiY2hpbGRyZW4iLCJub2RlVHlwZXMiXSwibWFwcGluZ3MiOiI7Ozs7K0JBSWFBOzs7ZUFBQUE7OztrQ0FGNkI7QUFFbkMsTUFBTUEseUJBQTZDO0lBQ3hELE1BQU1DLFdBQVUsRUFBRUMsVUFBVSxFQUFFQyxJQUFJLEVBQUVDLE1BQU0sRUFBRTtRQUMxQyxNQUFNQyxlQUFlLE1BQU1DLElBQUFBLDJDQUF5QixFQUFDO1lBQ25ESjtZQUNBSyxjQUFjSixLQUFLSyxRQUFRO1lBQzNCSixRQUFRO2dCQUNOLEdBQUdELElBQUk7Z0JBQ1BDO1lBQ0Y7UUFDRjtRQUNBLE9BQU8sQ0FBQyxHQUFHLEVBQUVDLGFBQWEsSUFBSSxDQUFDO0lBQ2pDO0lBQ0FJLFdBQVc7UUFBQztLQUFZO0FBQzFCIn0=

package/dist/utilities/lexical/converters/quote.d.ts

@@ -0,0 +1,3 @@
+import type { HTMLConverter } from '../types';
+export declare const QuoteHTMLConverter: HTMLConverter<any>;
+//# sourceMappingURL=quote.d.ts.map

package/dist/utilities/lexical/converters/quote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quote.d.ts","sourceRoot":"","sources":["../../../../src/utilities/lexical/converters/quote.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAI7C,eAAO,MAAM,kBAAkB,EAAE,aAAa,CAAC,GAAG,CAcjD,CAAA"}

package/dist/utilities/lexical/converters/quote.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "QuoteHTMLConverter", {
+    enumerable: true,
+    get: function() {
+        return QuoteHTMLConverter;
+    }
+});
+const _serializeLexical = require("../serializeLexical");
+const QuoteHTMLConverter = {
+    async converter ({ converters, node, parent }) {
+        const childrenText = await (0, _serializeLexical.convertLexicalNodesToHTML)({
+            converters,
+            lexicalNodes: node.children,
+            parent: {
+                ...node,
+                parent
+            }
+        });
+        return `<blockquote>${childrenText}</blockquote>`;
+    },
+    nodeTypes: [
+        'quote'
+    ]
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy91dGlsaXRpZXMvbGV4aWNhbC9jb252ZXJ0ZXJzL3F1b3RlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgSFRNTENvbnZlcnRlciB9IGZyb20gJy4uL3R5cGVzJ1xuXG5pbXBvcnQgeyBjb252ZXJ0TGV4aWNhbE5vZGVzVG9IVE1MIH0gZnJvbSAnLi4vc2VyaWFsaXplTGV4aWNhbCdcblxuZXhwb3J0IGNvbnN0IFF1b3RlSFRNTENvbnZlcnRlcjogSFRNTENvbnZlcnRlcjxhbnk+ID0ge1xuICBhc3luYyBjb252ZXJ0ZXIoeyBjb252ZXJ0ZXJzLCBub2RlLCBwYXJlbnQgfSkge1xuICAgIGNvbnN0IGNoaWxkcmVuVGV4dCA9IGF3YWl0IGNvbnZlcnRMZXhpY2FsTm9kZXNUb0hUTUwoe1xuICAgICAgY29udmVydGVycyxcbiAgICAgIGxleGljYWxOb2Rlczogbm9kZS5jaGlsZHJlbixcbiAgICAgIHBhcmVudDoge1xuICAgICAgICAuLi5ub2RlLFxuICAgICAgICBwYXJlbnQsXG4gICAgICB9LFxuICAgIH0pXG5cbiAgICByZXR1cm4gYDxibG9ja3F1b3RlPiR7Y2hpbGRyZW5UZXh0fTwvYmxvY2txdW90ZT5gXG4gIH0sXG4gIG5vZGVUeXBlczogWydxdW90ZSddLFxufVxuIl0sIm5hbWVzIjpbIlF1b3RlSFRNTENvbnZlcnRlciIsImNvbnZlcnRlciIsImNvbnZlcnRlcnMiLCJub2RlIiwicGFyZW50IiwiY2hpbGRyZW5UZXh0IiwiY29udmVydExleGljYWxOb2Rlc1RvSFRNTCIsImxleGljYWxOb2RlcyIsImNoaWxkcmVuIiwibm9kZVR5cGVzIl0sIm1hcHBpbmdzIjoiOzs7OytCQUlhQTs7O2VBQUFBOzs7a0NBRjZCO0FBRW5DLE1BQU1BLHFCQUF5QztJQUNwRCxNQUFNQyxXQUFVLEVBQUVDLFVBQVUsRUFBRUMsSUFBSSxFQUFFQyxNQUFNLEVBQUU7UUFDMUMsTUFBTUMsZUFBZSxNQUFNQyxJQUFBQSwyQ0FBeUIsRUFBQztZQUNuREo7WUFDQUssY0FBY0osS0FBS0ssUUFBUTtZQUMzQkosUUFBUTtnQkFDTixHQUFHRCxJQUFJO2dCQUNQQztZQUNGO1FBQ0Y7UUFFQSxPQUFPLENBQUMsWUFBWSxFQUFFQyxhQUFhLGFBQWEsQ0FBQztJQUNuRDtJQUNBSSxXQUFXO1FBQUM7S0FBUTtBQUN0QiJ9

package/dist/utilities/lexical/converters/text.d.ts

@@ -0,0 +1,3 @@
+import type { HTMLConverter } from '../types';
+export declare const TextHTMLConverter: HTMLConverter<any>;
+//# sourceMappingURL=text.d.ts.map

package/dist/utilities/lexical/converters/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../../src/utilities/lexical/converters/text.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAI7C,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,GAAG,CA6BhD,CAAA"}

package/dist/utilities/lexical/converters/text.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TextHTMLConverter", {
+    enumerable: true,
+    get: function() {
+        return TextHTMLConverter;
+    }
+});
+const _nodeFormat = require("../nodeFormat");
+const TextHTMLConverter = {
+    converter ({ node }) {
+        let text = node.text;
+        if (node.format & _nodeFormat.NodeFormat.IS_BOLD) {
+            text = `<strong>${text}</strong>`;
+        }
+        if (node.format & _nodeFormat.NodeFormat.IS_ITALIC) {
+            text = `<em>${text}</em>`;
+        }
+        if (node.format & _nodeFormat.NodeFormat.IS_STRIKETHROUGH) {
+            text = `<span style="text-decoration: line-through">${text}</span>`;
+        }
+        if (node.format & _nodeFormat.NodeFormat.IS_UNDERLINE) {
+            text = `<span style="text-decoration: underline">${text}</span>`;
+        }
+        if (node.format & _nodeFormat.NodeFormat.IS_CODE) {
+            text = `<code>${text}</code>`;
+        }
+        if (node.format & _nodeFormat.NodeFormat.IS_SUBSCRIPT) {
+            text = `<sub>${text}</sub>`;
+        }
+        if (node.format & _nodeFormat.NodeFormat.IS_SUPERSCRIPT) {
+            text = `<sup>${text}</sup>`;
+        }
+        return text;
+    },
+    nodeTypes: [
+        'text'
+    ]
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utilities/lexical/defaultConverters.d.ts

@@ -0,0 +1,3 @@
+import type { HTMLConverter } from './types';
+export declare const defaultHTMLConverters: HTMLConverter[];
+//# sourceMappingURL=defaultConverters.d.ts.map

package/dist/utilities/lexical/defaultConverters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultConverters.d.ts","sourceRoot":"","sources":["../../../src/utilities/lexical/defaultConverters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAU5C,eAAO,MAAM,qBAAqB,EAAE,aAAa,EAShD,CAAA"}

package/dist/utilities/lexical/defaultConverters.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "defaultHTMLConverters", {
+    enumerable: true,
+    get: function() {
+        return defaultHTMLConverters;
+    }
+});
+const _heading = require("./converters/heading");
+const _linebreak = require("./converters/linebreak");
+const _link = require("./converters/link");
+const _list = require("./converters/list");
+const _paragraph = require("./converters/paragraph");
+const _quote = require("./converters/quote");
+const _text = require("./converters/text");
+const defaultHTMLConverters = [
+    _paragraph.ParagraphHTMLConverter,
+    _text.TextHTMLConverter,
+    _linebreak.LinebreakHTMLConverter,
+    _link.LinkHTMLConverter,
+    _heading.HeadingHTMLConverter,
+    _quote.QuoteHTMLConverter,
+    _list.ListHTMLConverter,
+    _list.ListItemHTMLConverter
+];
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlsaXRpZXMvbGV4aWNhbC9kZWZhdWx0Q29udmVydGVycy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEhUTUxDb252ZXJ0ZXIgfSBmcm9tICcuL3R5cGVzJ1xuXG5pbXBvcnQgeyBIZWFkaW5nSFRNTENvbnZlcnRlciB9IGZyb20gJy4vY29udmVydGVycy9oZWFkaW5nJ1xuaW1wb3J0IHsgTGluZWJyZWFrSFRNTENvbnZlcnRlciB9IGZyb20gJy4vY29udmVydGVycy9saW5lYnJlYWsnXG5pbXBvcnQgeyBMaW5rSFRNTENvbnZlcnRlciB9IGZyb20gJy4vY29udmVydGVycy9saW5rJ1xuaW1wb3J0IHsgTGlzdEhUTUxDb252ZXJ0ZXIsIExpc3RJdGVtSFRNTENvbnZlcnRlciB9IGZyb20gJy4vY29udmVydGVycy9saXN0J1xuaW1wb3J0IHsgUGFyYWdyYXBoSFRNTENvbnZlcnRlciB9IGZyb20gJy4vY29udmVydGVycy9wYXJhZ3JhcGgnXG5pbXBvcnQgeyBRdW90ZUhUTUxDb252ZXJ0ZXIgfSBmcm9tICcuL2NvbnZlcnRlcnMvcXVvdGUnXG5pbXBvcnQgeyBUZXh0SFRNTENvbnZlcnRlciB9IGZyb20gJy4vY29udmVydGVycy90ZXh0J1xuXG5leHBvcnQgY29uc3QgZGVmYXVsdEhUTUxDb252ZXJ0ZXJzOiBIVE1MQ29udmVydGVyW10gPSBbXG4gIFBhcmFncmFwaEhUTUxDb252ZXJ0ZXIsXG4gIFRleHRIVE1MQ29udmVydGVyLFxuICBMaW5lYnJlYWtIVE1MQ29udmVydGVyLFxuICBMaW5rSFRNTENvbnZlcnRlcixcbiAgSGVhZGluZ0hUTUxDb252ZXJ0ZXIsXG4gIFF1b3RlSFRNTENvbnZlcnRlcixcbiAgTGlzdEhUTUxDb252ZXJ0ZXIsXG4gIExpc3RJdGVtSFRNTENvbnZlcnRlcixcbl1cbiJdLCJuYW1lcyI6WyJkZWZhdWx0SFRNTENvbnZlcnRlcnMiLCJQYXJhZ3JhcGhIVE1MQ29udmVydGVyIiwiVGV4dEhUTUxDb252ZXJ0ZXIiLCJMaW5lYnJlYWtIVE1MQ29udmVydGVyIiwiTGlua0hUTUxDb252ZXJ0ZXIiLCJIZWFkaW5nSFRNTENvbnZlcnRlciIsIlF1b3RlSFRNTENvbnZlcnRlciIsIkxpc3RIVE1MQ29udmVydGVyIiwiTGlzdEl0ZW1IVE1MQ29udmVydGVyIl0sIm1hcHBpbmdzIjoiOzs7OytCQVVhQTs7O2VBQUFBOzs7eUJBUndCOzJCQUNFO3NCQUNMO3NCQUN1QjsyQkFDbEI7dUJBQ0o7c0JBQ0Q7QUFFM0IsTUFBTUEsd0JBQXlDO0lBQ3BEQyxpQ0FBc0I7SUFDdEJDLHVCQUFpQjtJQUNqQkMsaUNBQXNCO0lBQ3RCQyx1QkFBaUI7SUFDakJDLDZCQUFvQjtJQUNwQkMseUJBQWtCO0lBQ2xCQyx1QkFBaUI7SUFDakJDLDJCQUFxQjtDQUN0QiJ9

package/dist/utilities/lexical/nodeFormat.d.ts

@@ -0,0 +1,39 @@
+export declare const NodeFormat: {
+    readonly DOM_ELEMENT_TYPE: 1;
+    readonly DOM_TEXT_TYPE: 3;
+    readonly NO_DIRTY_NODES: 0;
+    readonly HAS_DIRTY_NODES: 1;
+    readonly FULL_RECONCILE: 2;
+    readonly IS_NORMAL: 0;
+    readonly IS_TOKEN: 1;
+    readonly IS_SEGMENTED: 2;
+    readonly IS_INERT: 3;
+    readonly IS_BOLD: 1;
+    readonly IS_ITALIC: number;
+    readonly IS_STRIKETHROUGH: number;
+    readonly IS_UNDERLINE: number;
+    readonly IS_CODE: number;
+    readonly IS_SUBSCRIPT: number;
+    readonly IS_SUPERSCRIPT: number;
+    readonly IS_HIGHLIGHT: number;
+    readonly IS_DIRECTIONLESS: 1;
+    readonly IS_UNMERGEABLE: number;
+    readonly IS_ALIGN_LEFT: 1;
+    readonly IS_ALIGN_CENTER: 2;
+    readonly IS_ALIGN_RIGHT: 3;
+    readonly IS_ALIGN_JUSTIFY: 4;
+    readonly IS_ALIGN_START: 5;
+    readonly IS_ALIGN_END: 6;
+};
+export declare const IS_ALL_FORMATTING: number;
+export declare const NON_BREAKING_SPACE = "\u00A0";
+export declare const DOUBLE_LINE_BREAK = "\n\n";
+export declare const RTL_REGEX: RegExp;
+export declare const LTR_REGEX: RegExp;
+export declare const TEXT_TYPE_TO_FORMAT: Record<any | string, number>;
+export declare const DETAIL_TYPE_TO_DETAIL: Record<any | string, number>;
+export declare const ELEMENT_TYPE_TO_FORMAT: Record<Exclude<any, ''>, number>;
+export declare const ELEMENT_FORMAT_TO_TYPE: Record<number, any>;
+export declare const TEXT_MODE_TO_TYPE: Record<any, 0 | 1 | 2>;
+export declare const TEXT_TYPE_TO_MODE: Record<number, any>;
+//# sourceMappingURL=nodeFormat.d.ts.map

package/dist/utilities/lexical/nodeFormat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeFormat.d.ts","sourceRoot":"","sources":["../../../src/utilities/lexical/nodeFormat.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;CA+Bb,CAAA;AAEV,eAAO,MAAM,iBAAiB,QAQL,CAAA;AAGzB,eAAO,MAAM,kBAAkB,WAAW,CAAA;AAE1C,eAAO,MAAM,iBAAiB,SAAS,CAAA;AAYvC,eAAO,MAAM,SAAS,QAA8C,CAAA;AAEpE,eAAO,MAAM,SAAS,QAA8C,CAAA;AAEpE,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,GAAG,GAAG,MAAM,EAAE,MAAM,CAS5D,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,GAAG,GAAG,MAAM,EAAE,MAAM,CAG9D,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,MAAM,CAOnE,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAOtD,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAIpD,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAIjD,CAAA"}

package/dist/utilities/lexical/nodeFormat.js

@@ -0,0 +1,133 @@
+/* eslint-disable perfectionist/sort-objects */ /* eslint-disable regexp/no-obscure-range */ /* eslint-disable @typescript-eslint/no-redundant-type-constituents */ //This copy-and-pasted from lexical here: https://github.com/facebook/lexical/blob/c2ceee223f46543d12c574e62155e619f9a18a5d/packages/lexical/src/LexicalConstants.ts
+// DOM
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    NodeFormat: function() {
+        return NodeFormat;
+    },
+    IS_ALL_FORMATTING: function() {
+        return IS_ALL_FORMATTING;
+    },
+    NON_BREAKING_SPACE: function() {
+        return NON_BREAKING_SPACE;
+    },
+    DOUBLE_LINE_BREAK: function() {
+        return DOUBLE_LINE_BREAK;
+    },
+    RTL_REGEX: function() {
+        return RTL_REGEX;
+    },
+    LTR_REGEX: function() {
+        return LTR_REGEX;
+    },
+    TEXT_TYPE_TO_FORMAT: function() {
+        return TEXT_TYPE_TO_FORMAT;
+    },
+    DETAIL_TYPE_TO_DETAIL: function() {
+        return DETAIL_TYPE_TO_DETAIL;
+    },
+    ELEMENT_TYPE_TO_FORMAT: function() {
+        return ELEMENT_TYPE_TO_FORMAT;
+    },
+    ELEMENT_FORMAT_TO_TYPE: function() {
+        return ELEMENT_FORMAT_TO_TYPE;
+    },
+    TEXT_MODE_TO_TYPE: function() {
+        return TEXT_MODE_TO_TYPE;
+    },
+    TEXT_TYPE_TO_MODE: function() {
+        return TEXT_TYPE_TO_MODE;
+    }
+});
+const NodeFormat = {
+    DOM_ELEMENT_TYPE: 1,
+    DOM_TEXT_TYPE: 3,
+    // Reconciling
+    NO_DIRTY_NODES: 0,
+    HAS_DIRTY_NODES: 1,
+    FULL_RECONCILE: 2,
+    // Text node modes
+    IS_NORMAL: 0,
+    IS_TOKEN: 1,
+    IS_SEGMENTED: 2,
+    IS_INERT: 3,
+    // Text node formatting
+    IS_BOLD: 1,
+    IS_ITALIC: 1 << 1,
+    IS_STRIKETHROUGH: 1 << 2,
+    IS_UNDERLINE: 1 << 3,
+    IS_CODE: 1 << 4,
+    IS_SUBSCRIPT: 1 << 5,
+    IS_SUPERSCRIPT: 1 << 6,
+    IS_HIGHLIGHT: 1 << 7,
+    // Text node details
+    IS_DIRECTIONLESS: 1,
+    IS_UNMERGEABLE: 1 << 1,
+    // Element node formatting
+    IS_ALIGN_LEFT: 1,
+    IS_ALIGN_CENTER: 2,
+    IS_ALIGN_RIGHT: 3,
+    IS_ALIGN_JUSTIFY: 4,
+    IS_ALIGN_START: 5,
+    IS_ALIGN_END: 6
+};
+const IS_ALL_FORMATTING = NodeFormat.IS_BOLD | NodeFormat.IS_ITALIC | NodeFormat.IS_STRIKETHROUGH | NodeFormat.IS_UNDERLINE | NodeFormat.IS_CODE | NodeFormat.IS_SUBSCRIPT | NodeFormat.IS_SUPERSCRIPT | NodeFormat.IS_HIGHLIGHT;
+const NON_BREAKING_SPACE = '\u00A0';
+const DOUBLE_LINE_BREAK = '\n\n';
+// For FF, we need to use a non-breaking space, or it gets composition
+// in a stuck state.
+const RTL = '\u0591-\u07FF\uFB1D-\uFDFD\uFE70-\uFEFC';
+const LTR = 'A-Za-z\u00C0-\u00D6\u00D8-\u00F6' + '\u00F8-\u02B8\u0300-\u0590\u0800-\u1FFF\u200E\u2C00-\uFB1C' + '\uFE00-\uFE6F\uFEFD-\uFFFF';
+const RTL_REGEX = new RegExp('^[^' + LTR + ']*[' + RTL + ']');
+const LTR_REGEX = new RegExp('^[^' + RTL + ']*[' + LTR + ']');
+const TEXT_TYPE_TO_FORMAT = {
+    bold: NodeFormat.IS_BOLD,
+    code: NodeFormat.IS_CODE,
+    highlight: NodeFormat.IS_HIGHLIGHT,
+    italic: NodeFormat.IS_ITALIC,
+    strikethrough: NodeFormat.IS_STRIKETHROUGH,
+    subscript: NodeFormat.IS_SUBSCRIPT,
+    superscript: NodeFormat.IS_SUPERSCRIPT,
+    underline: NodeFormat.IS_UNDERLINE
+};
+const DETAIL_TYPE_TO_DETAIL = {
+    directionless: NodeFormat.IS_DIRECTIONLESS,
+    unmergeable: NodeFormat.IS_UNMERGEABLE
+};
+const ELEMENT_TYPE_TO_FORMAT = {
+    center: NodeFormat.IS_ALIGN_CENTER,
+    end: NodeFormat.IS_ALIGN_END,
+    justify: NodeFormat.IS_ALIGN_JUSTIFY,
+    left: NodeFormat.IS_ALIGN_LEFT,
+    right: NodeFormat.IS_ALIGN_RIGHT,
+    start: NodeFormat.IS_ALIGN_START
+};
+const ELEMENT_FORMAT_TO_TYPE = {
+    [NodeFormat.IS_ALIGN_CENTER]: 'center',
+    [NodeFormat.IS_ALIGN_END]: 'end',
+    [NodeFormat.IS_ALIGN_JUSTIFY]: 'justify',
+    [NodeFormat.IS_ALIGN_LEFT]: 'left',
+    [NodeFormat.IS_ALIGN_RIGHT]: 'right',
+    [NodeFormat.IS_ALIGN_START]: 'start'
+};
+const TEXT_MODE_TO_TYPE = {
+    normal: NodeFormat.IS_NORMAL,
+    segmented: NodeFormat.IS_SEGMENTED,
+    token: NodeFormat.IS_TOKEN
+};
+const TEXT_TYPE_TO_MODE = {
+    [NodeFormat.IS_NORMAL]: 'normal',
+    [NodeFormat.IS_SEGMENTED]: 'segmented',
+    [NodeFormat.IS_TOKEN]: 'token'
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/utilities/lexical/nodeFormat.ts"],"sourcesContent":["/* eslint-disable perfectionist/sort-objects */\n/* eslint-disable regexp/no-obscure-range */\n/* eslint-disable @typescript-eslint/no-redundant-type-constituents */\n//This copy-and-pasted from lexical here: https://github.com/facebook/lexical/blob/c2ceee223f46543d12c574e62155e619f9a18a5d/packages/lexical/src/LexicalConstants.ts\n\n// DOM\nexport const NodeFormat = {\n  DOM_ELEMENT_TYPE: 1,\n  DOM_TEXT_TYPE: 3,\n  // Reconciling\n  NO_DIRTY_NODES: 0,\n  HAS_DIRTY_NODES: 1,\n  FULL_RECONCILE: 2,\n  // Text node modes\n  IS_NORMAL: 0,\n  IS_TOKEN: 1,\n  IS_SEGMENTED: 2,\n  IS_INERT: 3,\n  // Text node formatting\n  IS_BOLD: 1,\n  IS_ITALIC: 1 << 1,\n  IS_STRIKETHROUGH: 1 << 2,\n  IS_UNDERLINE: 1 << 3,\n  IS_CODE: 1 << 4,\n  IS_SUBSCRIPT: 1 << 5,\n  IS_SUPERSCRIPT: 1 << 6,\n  IS_HIGHLIGHT: 1 << 7,\n  // Text node details\n  IS_DIRECTIONLESS: 1,\n  IS_UNMERGEABLE: 1 << 1,\n  // Element node formatting\n  IS_ALIGN_LEFT: 1,\n  IS_ALIGN_CENTER: 2,\n  IS_ALIGN_RIGHT: 3,\n  IS_ALIGN_JUSTIFY: 4,\n  IS_ALIGN_START: 5,\n  IS_ALIGN_END: 6,\n} as const\n\nexport const IS_ALL_FORMATTING =\n  NodeFormat.IS_BOLD |\n  NodeFormat.IS_ITALIC |\n  NodeFormat.IS_STRIKETHROUGH |\n  NodeFormat.IS_UNDERLINE |\n  NodeFormat.IS_CODE |\n  NodeFormat.IS_SUBSCRIPT |\n  NodeFormat.IS_SUPERSCRIPT |\n  NodeFormat.IS_HIGHLIGHT\n\n// Reconciliation\nexport const NON_BREAKING_SPACE = '\\u00A0'\n\nexport const DOUBLE_LINE_BREAK = '\\n\\n'\n\n// For FF, we need to use a non-breaking space, or it gets composition\n// in a stuck state.\n\nconst RTL = '\\u0591-\\u07FF\\uFB1D-\\uFDFD\\uFE70-\\uFEFC'\nconst LTR =\n  'A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6' +\n  '\\u00F8-\\u02B8\\u0300-\\u0590\\u0800-\\u1FFF\\u200E\\u2C00-\\uFB1C' +\n  '\\uFE00-\\uFE6F\\uFEFD-\\uFFFF'\n\n// eslint-disable-next-line no-misleading-character-class\nexport const RTL_REGEX = new RegExp('^[^' + LTR + ']*[' + RTL + ']')\n// eslint-disable-next-line no-misleading-character-class\nexport const LTR_REGEX = new RegExp('^[^' + RTL + ']*[' + LTR + ']')\n\nexport const TEXT_TYPE_TO_FORMAT: Record<any | string, number> = {\n  bold: NodeFormat.IS_BOLD,\n  code: NodeFormat.IS_CODE,\n  highlight: NodeFormat.IS_HIGHLIGHT,\n  italic: NodeFormat.IS_ITALIC,\n  strikethrough: NodeFormat.IS_STRIKETHROUGH,\n  subscript: NodeFormat.IS_SUBSCRIPT,\n  superscript: NodeFormat.IS_SUPERSCRIPT,\n  underline: NodeFormat.IS_UNDERLINE,\n}\n\nexport const DETAIL_TYPE_TO_DETAIL: Record<any | string, number> = {\n  directionless: NodeFormat.IS_DIRECTIONLESS,\n  unmergeable: NodeFormat.IS_UNMERGEABLE,\n}\n\nexport const ELEMENT_TYPE_TO_FORMAT: Record<Exclude<any, ''>, number> = {\n  center: NodeFormat.IS_ALIGN_CENTER,\n  end: NodeFormat.IS_ALIGN_END,\n  justify: NodeFormat.IS_ALIGN_JUSTIFY,\n  left: NodeFormat.IS_ALIGN_LEFT,\n  right: NodeFormat.IS_ALIGN_RIGHT,\n  start: NodeFormat.IS_ALIGN_START,\n}\n\nexport const ELEMENT_FORMAT_TO_TYPE: Record<number, any> = {\n  [NodeFormat.IS_ALIGN_CENTER]: 'center',\n  [NodeFormat.IS_ALIGN_END]: 'end',\n  [NodeFormat.IS_ALIGN_JUSTIFY]: 'justify',\n  [NodeFormat.IS_ALIGN_LEFT]: 'left',\n  [NodeFormat.IS_ALIGN_RIGHT]: 'right',\n  [NodeFormat.IS_ALIGN_START]: 'start',\n}\n\nexport const TEXT_MODE_TO_TYPE: Record<any, 0 | 1 | 2> = {\n  normal: NodeFormat.IS_NORMAL,\n  segmented: NodeFormat.IS_SEGMENTED,\n  token: NodeFormat.IS_TOKEN,\n}\n\nexport const TEXT_TYPE_TO_MODE: Record<number, any> = {\n  [NodeFormat.IS_NORMAL]: 'normal',\n  [NodeFormat.IS_SEGMENTED]: 'segmented',\n  [NodeFormat.IS_TOKEN]: 'token',\n}\n"],"names":["NodeFormat","IS_ALL_FORMATTING","NON_BREAKING_SPACE","DOUBLE_LINE_BREAK","RTL_REGEX","LTR_REGEX","TEXT_TYPE_TO_FORMAT","DETAIL_TYPE_TO_DETAIL","ELEMENT_TYPE_TO_FORMAT","ELEMENT_FORMAT_TO_TYPE","TEXT_MODE_TO_TYPE","TEXT_TYPE_TO_MODE","DOM_ELEMENT_TYPE","DOM_TEXT_TYPE","NO_DIRTY_NODES","HAS_DIRTY_NODES","FULL_RECONCILE","IS_NORMAL","IS_TOKEN","IS_SEGMENTED","IS_INERT","IS_BOLD","IS_ITALIC","IS_STRIKETHROUGH","IS_UNDERLINE","IS_CODE","IS_SUBSCRIPT","IS_SUPERSCRIPT","IS_HIGHLIGHT","IS_DIRECTIONLESS","IS_UNMERGEABLE","IS_ALIGN_LEFT","IS_ALIGN_CENTER","IS_ALIGN_RIGHT","IS_ALIGN_JUSTIFY","IS_ALIGN_START","IS_ALIGN_END","RTL","LTR","RegExp","bold","code","highlight","italic","strikethrough","subscript","superscript","underline","directionless","unmergeable","center","end","justify","left","right","start","normal","segmented","token"],"mappings":"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"}

package/dist/utilities/lexical/serializeLexical.d.ts

@@ -0,0 +1,8 @@
+import type { HTMLConverter, SerializedLexicalNodeWithParent } from './types';
+export declare function serializeLexical(data?: any, submissionData?: any): Promise<string>;
+export declare function convertLexicalNodesToHTML({ converters, lexicalNodes, parent, }: {
+    converters: HTMLConverter[];
+    lexicalNodes: any[];
+    parent: SerializedLexicalNodeWithParent;
+}): Promise<string>;
+//# sourceMappingURL=serializeLexical.d.ts.map

package/dist/utilities/lexical/serializeLexical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializeLexical.d.ts","sourceRoot":"","sources":["../../../src/utilities/lexical/serializeLexical.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,+BAA+B,EAAE,MAAM,SAAS,CAAA;AAI7E,wBAAsB,gBAAgB,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,cAAc,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,CAWxF;AAED,wBAAsB,yBAAyB,CAAC,EAC9C,UAAU,EACV,YAAY,EACZ,MAAM,GACP,EAAE;IACD,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,YAAY,EAAE,GAAG,EAAE,CAAA;IACnB,MAAM,EAAE,+BAA+B,CAAA;CACxC,GAAG,OAAO,CAAC,MAAM,CAAC,CAwBlB"}

package/dist/utilities/lexical/serializeLexical.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    serializeLexical: function() {
+        return serializeLexical;
+    },
+    convertLexicalNodesToHTML: function() {
+        return convertLexicalNodesToHTML;
+    }
+});
+const _defaultConverters = require("./defaultConverters");
+async function serializeLexical(data, submissionData) {
+    const converters = _defaultConverters.defaultHTMLConverters;
+    if (data?.root?.children?.length) {
+        return await convertLexicalNodesToHTML({
+            converters,
+            lexicalNodes: data?.root?.children,
+            parent: data?.root
+        });
+    }
+    return '';
+}
+async function convertLexicalNodesToHTML({ converters, lexicalNodes, parent }) {
+    const unknownConverter = converters.find((converter)=>converter.nodeTypes.includes('unknown'));
+    const htmlArray = await Promise.all(lexicalNodes.map(async (node, i)=>{
+        const converterForNode = converters.find((converter)=>converter.nodeTypes.includes(node.type));
+        if (!converterForNode) {
+            if (unknownConverter) {
+                return unknownConverter.converter({
+                    childIndex: i,
+                    converters,
+                    node,
+                    parent
+                });
+            }
+            return '<span>unknown node</span>';
+        }
+        return converterForNode.converter({
+            childIndex: i,
+            converters,
+            node,
+            parent
+        });
+    }));
+    return htmlArray.join('') || '';
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utilities/lexical/types.d.ts

@@ -0,0 +1,13 @@
+export type HTMLConverter<T = any> = {
+    converter: ({ childIndex, converters, node, parent, }: {
+        childIndex: number;
+        converters: HTMLConverter[];
+        node: T;
+        parent: SerializedLexicalNodeWithParent;
+    }) => Promise<string> | string;
+    nodeTypes: string[];
+};
+export type SerializedLexicalNodeWithParent = any & {
+    parent?: any;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/utilities/lexical/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/utilities/lexical/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,CAAC,CAAC,GAAG,GAAG,IAAI;IACnC,SAAS,EAAE,CAAC,EACV,UAAU,EACV,UAAU,EACV,IAAI,EACJ,MAAM,GACP,EAAE;QACD,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,aAAa,EAAE,CAAA;QAC3B,IAAI,EAAE,CAAC,CAAA;QACP,MAAM,EAAE,+BAA+B,CAAA;KACxC,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAA;IAC9B,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,+BAA+B,GAAG,GAAG,GAAG;IAClD,MAAM,CAAC,EAAE,GAAG,CAAA;CACb,CAAA"}

package/dist/utilities/lexical/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/utilities/slate/serializeSlate.d.ts

@@ -0,0 +1,12 @@
+interface Node {
+    bold?: boolean;
+    children?: Node[];
+    code?: boolean;
+    italic?: boolean;
+    text?: string;
+    type?: string;
+    url?: string;
+}
+export declare const serializeSlate: (children?: Node[], submissionData?: any) => string | undefined;
+export {};
+//# sourceMappingURL=serializeSlate.d.ts.map

package/dist/utilities/slate/serializeSlate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializeSlate.d.ts","sourceRoot":"","sources":["../../../src/utilities/slate/serializeSlate.ts"],"names":[],"mappings":"AAIA,UAAU,IAAI;IACZ,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,QAAQ,CAAC,EAAE,IAAI,EAAE,CAAA;IACjB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAMD,eAAO,MAAM,cAAc,cAAe,IAAI,EAAE,mBAAmB,GAAG,KAAG,MAAM,GAAG,SAwHrE,CAAA"}