@webiny/lexical-converter 0.0.0-unstable.06b2ede40f

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,106 @@
+# @webiny/lexical-converter
+
+[![](https://img.shields.io/npm/dw/@webiny/lexical-converter.svg)](https://www.npmjs.com/package/@webiny/llexical-lexical-converter)
+[![](https://img.shields.io/npm/v/@webiny/lexical-converter.svg)](https://www.npmjs.com/package/@webiny/lexical-converter)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+
+## About
+
+This package provides features that will enable you to parse your HTML pages into Lexical editor state object.
+
+Further, this lexical state object can be imported into Webiny's apps like the Page builder and Headless CMS, trough the [Webiny's graphql API](https://www.webiny.com/docs/headless-cms/basics/graphql-api).
+
+> Webiny use the Lexical editor as primary rich text editor across the platform.
+
+Note: This module is built to be used in the `node.js` environment.
+
+## Usage
+
+To parse the HTML to lexical editor state object, you need to import `createHtmlToLexicalParser` factory function,
+to create the parser function (with default or custom configuration) and provide the HTML content as parameter.
+Parser will return Lexical editor state object.
+
+> The parser uses the default configuration with the Webiny's Lexical nodes. DOM elements like headings and
+> paragraph, for example, will be converted to our custom Webiny Lexical nodes.
+
+```tsx
+import { createHtmlToLexicalParser } from "@webiny/lexical-converter";
+
+const htmlString = "<p>My paragraph</p>";
+
+// Create a parser function.
+const myParser = createHtmlToLexicalParser();
+
+// Parse the HTML string to Lexical editor state object.
+const lexicalEditorState = myParser(htmlString);
+```
+
+Here is the result in JSON format. This object structure is a valid Lexical editor state.
+
+```json
+{
+  "root": {
+    "children": [
+      {
+        "children": [
+          {
+            "detail": 0,
+            "format": 0,
+            "mode": "normal",
+            "style": "",
+            "text": "Space",
+            "type": "text",
+            "version": 1
+          }
+        ],
+        "direction": null,
+        "format": "",
+        "indent": 0,
+        "styles": [],
+        "type": "paragraph-element",
+        "version": 1
+      }
+    ],
+    "direction": null,
+    "format": "",
+    "indent": 0,
+    "type": "root",
+    "version": 1
+  }
+}
+```
+
+## Configuration
+
+To configure the parser, you can pass an optional configuration object to the parser factory.
+
+```ts
+import { createHtmlToLexicalParser } from "@webiny/lexical-converter";
+import { myCustomTheme } from "./theme/myCustomTheme";
+import { MyCustomLexicalNode } from "./lexical/nodes/MyCustomLexicalNode";
+
+const addCustomThemeStyleToHeadings = (node: LexicalNode): LexicalNode => {
+  if (node.getType() === "heading-element") {
+    return (node as HeadingNode).setThemeStyles([{ styleId: "my-default-id", type: "typography" }]);
+  }
+  return node;
+};
+
+// Create your parser with custom configuration
+const myParser = createHtmlToLexicalParser({
+  // Lexical editor configuration
+  editorConfig: {
+    // Add custom nodes for parsing
+    nodes: [MyCustomLexicalNode],
+    // Add you custom theme
+    theme: myCustomTheme
+  },
+  nodeMapper: addCustomThemeStyleToHeadings,
+  normalizeTextNodes: false // Default: true
+});
+
+const lexicalEditorState = myParser(htmlString);
+```
+
+To learn more about how to create custom Lexical nodes, please visit [Lexical's documentation web page](https://lexical.dev/docs/intro).

package/createHtmlToLexicalParser.d.ts

@@ -0,0 +1,5 @@
+import type { ParserConfigurationOptions } from "./types";
+/**
+ * Parse html string to lexical JSON object.
+ */
+export declare const createHtmlToLexicalParser: (config?: ParserConfigurationOptions) => (domDocument: Document) => Record<string, any> | null;

package/createHtmlToLexicalParser.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createHtmlToLexicalParser = void 0;
+var _headless = require("@lexical/headless");
+var _html = require("@lexical/html");
+var _lexical = require("lexical");
+var _lexicalNodes = require("@webiny/lexical-nodes");
+const passthroughMapper = node => node;
+
+/**
+ * Parse html string to lexical JSON object.
+ */
+const createHtmlToLexicalParser = (config = {}) => {
+  return domDocument => {
+    const customNodeMapper = config.nodeMapper ?? passthroughMapper;
+    const editor = (0, _headless.createHeadlessEditor)({
+      ...config.editorConfig,
+      nodes: [..._lexicalNodes.allNodes, ...(config.editorConfig?.nodes || [])]
+    });
+    let parsingError;
+    editor.update(() => {
+      // Convert to lexical node objects that can be stored in db.
+      const lexicalNodes = (0, _html.$generateNodesFromDOM)(editor, domDocument).map(customNodeMapper);
+
+      // Select the root
+      (0, _lexical.$getRoot)().select();
+
+      // Insert the nodes at a selection.
+      const selection = (0, _lexical.$getSelection)();
+      if (selection) {
+        try {
+          selection.insertNodes(lexicalNodes);
+        } catch (err) {
+          parsingError = err;
+        }
+      }
+    },
+    /**
+     * Prevents this update from being batched, forcing it to run synchronously.
+     */
+    {
+      discrete: true
+    });
+    if (parsingError) {
+      throw parsingError;
+    }
+    return editor.getEditorState().toJSON();
+  };
+};
+exports.createHtmlToLexicalParser = createHtmlToLexicalParser;
+
+//# sourceMappingURL=createHtmlToLexicalParser.js.map

package/createHtmlToLexicalParser.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_headless","require","_html","_lexical","_lexicalNodes","passthroughMapper","node","createHtmlToLexicalParser","config","domDocument","customNodeMapper","nodeMapper","editor","createHeadlessEditor","editorConfig","nodes","allNodes","parsingError","update","lexicalNodes","$generateNodesFromDOM","map","$getRoot","select","selection","$getSelection","insertNodes","err","discrete","getEditorState","toJSON","exports"],"sources":["createHtmlToLexicalParser.ts"],"sourcesContent":["import { createHeadlessEditor } from \"@lexical/headless\";\nimport { $generateNodesFromDOM } from \"@lexical/html\";\nimport { $getRoot, $getSelection } from \"lexical\";\nimport { allNodes } from \"@webiny/lexical-nodes\";\nimport type { NodeMapper, ParserConfigurationOptions } from \"~/types\";\n\nconst passthroughMapper: NodeMapper = node => node;\n\n/**\n * Parse html string to lexical JSON object.\n */\nexport const createHtmlToLexicalParser = (config: ParserConfigurationOptions = {}) => {\n    return (domDocument: Document): Record<string, any> | null => {\n        const customNodeMapper: NodeMapper = config.nodeMapper ?? passthroughMapper;\n\n        const editor = createHeadlessEditor({\n            ...config.editorConfig,\n            nodes: [...allNodes, ...(config.editorConfig?.nodes || [])]\n        });\n\n        let parsingError;\n\n        editor.update(\n            () => {\n                // Convert to lexical node objects that can be stored in db.\n                const lexicalNodes = $generateNodesFromDOM(editor, domDocument).map(\n                    customNodeMapper\n                );\n\n                // Select the root\n                $getRoot().select();\n\n                // Insert the nodes at a selection.\n                const selection = $getSelection();\n                if (selection) {\n                    try {\n                        selection.insertNodes(lexicalNodes);\n                    } catch (err) {\n                        parsingError = err;\n                    }\n                }\n            },\n            /**\n             * Prevents this update from being batched, forcing it to run synchronously.\n             */\n            { discrete: true }\n        );\n\n        if (parsingError) {\n            throw parsingError;\n        }\n\n        return editor.getEditorState().toJSON();\n    };\n};\n"],"mappings":";;;;;;AAAA,IAAAA,SAAA,GAAAC,OAAA;AACA,IAAAC,KAAA,GAAAD,OAAA;AACA,IAAAE,QAAA,GAAAF,OAAA;AACA,IAAAG,aAAA,GAAAH,OAAA;AAGA,MAAMI,iBAA6B,GAAGC,IAAI,IAAIA,IAAI;;AAElD;AACA;AACA;AACO,MAAMC,yBAAyB,GAAGA,CAACC,MAAkC,GAAG,CAAC,CAAC,KAAK;EAClF,OAAQC,WAAqB,IAAiC;IAC1D,MAAMC,gBAA4B,GAAGF,MAAM,CAACG,UAAU,IAAIN,iBAAiB;IAE3E,MAAMO,MAAM,GAAG,IAAAC,8BAAoB,EAAC;MAChC,GAAGL,MAAM,CAACM,YAAY;MACtBC,KAAK,EAAE,CAAC,GAAGC,sBAAQ,EAAE,IAAIR,MAAM,CAACM,YAAY,EAAEC,KAAK,IAAI,EAAE,CAAC;IAC9D,CAAC,CAAC;IAEF,IAAIE,YAAY;IAEhBL,MAAM,CAACM,MAAM,CACT,MAAM;MACF;MACA,MAAMC,YAAY,GAAG,IAAAC,2BAAqB,EAACR,MAAM,EAAEH,WAAW,CAAC,CAACY,GAAG,CAC/DX,gBACJ,CAAC;;MAED;MACA,IAAAY,iBAAQ,EAAC,CAAC,CAACC,MAAM,CAAC,CAAC;;MAEnB;MACA,MAAMC,SAAS,GAAG,IAAAC,sBAAa,EAAC,CAAC;MACjC,IAAID,SAAS,EAAE;QACX,IAAI;UACAA,SAAS,CAACE,WAAW,CAACP,YAAY,CAAC;QACvC,CAAC,CAAC,OAAOQ,GAAG,EAAE;UACVV,YAAY,GAAGU,GAAG;QACtB;MACJ;IACJ,CAAC;IACD;AACZ;AACA;IACY;MAAEC,QAAQ,EAAE;IAAK,CACrB,CAAC;IAED,IAAIX,YAAY,EAAE;MACd,MAAMA,YAAY;IACtB;IAEA,OAAOL,MAAM,CAACiB,cAAc,CAAC,CAAC,CAACC,MAAM,CAAC,CAAC;EAC3C,CAAC;AACL,CAAC;AAACC,OAAA,CAAAxB,yBAAA,GAAAA,yBAAA","ignoreList":[]}

package/createLexicalStateTransformer.d.ts

@@ -0,0 +1,17 @@
+import type { CreateEditorArgs, SerializedEditorState, LexicalNode } from "lexical";
+interface LexicalStateTransformerConfig {
+    editorConfig?: Pick<CreateEditorArgs, "nodes" | "theme">;
+}
+export type FlatStateWithHTML = Array<{
+    node: LexicalNode;
+    html: string;
+}>;
+declare class LexicalStateTransformer {
+    private readonly editor;
+    constructor(config?: LexicalStateTransformerConfig);
+    flatten(state: string | SerializedEditorState): FlatStateWithHTML;
+    toHtml(state: string | SerializedEditorState): string;
+    private getNodeDescendants;
+}
+export declare const createLexicalStateTransformer: (config?: LexicalStateTransformerConfig) => LexicalStateTransformer;
+export {};

package/createLexicalStateTransformer.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createLexicalStateTransformer = void 0;
+var _lexical = require("lexical");
+var _html = require("@lexical/html");
+var _headless = require("@lexical/headless");
+var _lexicalNodes = require("@webiny/lexical-nodes");
+var _postProcessHtml = require("./postProcessHtml");
+class LexicalStateTransformer {
+  constructor(config = {}) {
+    this.editor = (0, _headless.createHeadlessEditor)({
+      ...config.editorConfig,
+      nodes: [..._lexicalNodes.allNodes, ...(config.editorConfig?.nodes || [])]
+    });
+  }
+  flatten(state) {
+    const editorState = this.editor.parseEditorState((0, _lexicalNodes.prepareLexicalState)(state));
+    this.editor.setEditorState(editorState);
+    let flattenedNodes = [];
+    this.editor.update(() => {
+      const children = (0, _lexical.$getRoot)().getChildren();
+      flattenedNodes = children.map(childNode => {
+        const selection = (0, _lexical.$createNodeSelection)();
+        selection.add(childNode.getKey());
+        this.getNodeDescendants(childNode).forEach(node => {
+          selection.add(node.getKey());
+        });
+        const html = (0, _html.$generateHtmlFromNodes)(this.editor, selection);
+        return {
+          node: childNode,
+          html: (0, _postProcessHtml.postProcessHtml)(html)
+        };
+      });
+    });
+    return flattenedNodes;
+  }
+  toHtml(state) {
+    const preparedState = (0, _lexicalNodes.prepareLexicalState)(state);
+    const editorState = this.editor.parseEditorState(preparedState);
+    this.editor.setEditorState(editorState);
+    let html = "";
+    this.editor.update(() => {
+      html = (0, _html.$generateHtmlFromNodes)(this.editor);
+    });
+    return (0, _postProcessHtml.postProcessHtml)(html);
+  }
+  getNodeDescendants(node) {
+    if (!(0, _lexical.$isElementNode)(node)) {
+      return [];
+    }
+    const children = node.getChildren();
+    return [...children, ...children.map(child => this.getNodeDescendants(child)).flat()];
+  }
+}
+const createLexicalStateTransformer = config => {
+  return new LexicalStateTransformer(config);
+};
+exports.createLexicalStateTransformer = createLexicalStateTransformer;
+
+//# sourceMappingURL=createLexicalStateTransformer.js.map

package/createLexicalStateTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_lexical","require","_html","_headless","_lexicalNodes","_postProcessHtml","LexicalStateTransformer","constructor","config","editor","createHeadlessEditor","editorConfig","nodes","allNodes","flatten","state","editorState","parseEditorState","prepareLexicalState","setEditorState","flattenedNodes","update","children","$getRoot","getChildren","map","childNode","selection","$createNodeSelection","add","getKey","getNodeDescendants","forEach","node","html","$generateHtmlFromNodes","postProcessHtml","toHtml","preparedState","$isElementNode","child","flat","createLexicalStateTransformer","exports"],"sources":["createLexicalStateTransformer.ts"],"sourcesContent":["import type { CreateEditorArgs, LexicalEditor, SerializedEditorState, LexicalNode } from \"lexical\";\nimport { $getRoot, $createNodeSelection, $isElementNode } from \"lexical\";\nimport { $generateHtmlFromNodes } from \"@lexical/html\";\nimport { createHeadlessEditor } from \"@lexical/headless\";\nimport { allNodes, prepareLexicalState } from \"@webiny/lexical-nodes\";\nimport { postProcessHtml } from \"./postProcessHtml\";\n\ninterface LexicalStateTransformerConfig {\n    editorConfig?: Pick<CreateEditorArgs, \"nodes\" | \"theme\">;\n}\n\nexport type FlatStateWithHTML = Array<{ node: LexicalNode; html: string }>;\n\nclass LexicalStateTransformer {\n    private readonly editor: LexicalEditor;\n\n    constructor(config: LexicalStateTransformerConfig = {}) {\n        this.editor = createHeadlessEditor({\n            ...config.editorConfig,\n            nodes: [...allNodes, ...(config.editorConfig?.nodes || [])]\n        });\n    }\n\n    public flatten(state: string | SerializedEditorState) {\n        const editorState = this.editor.parseEditorState(prepareLexicalState(state));\n        this.editor.setEditorState(editorState);\n\n        let flattenedNodes: FlatStateWithHTML = [];\n\n        this.editor.update(() => {\n            const children = $getRoot().getChildren();\n\n            flattenedNodes = children.map(childNode => {\n                const selection = $createNodeSelection();\n                selection.add(childNode.getKey());\n\n                this.getNodeDescendants(childNode).forEach(node => {\n                    selection.add(node.getKey());\n                });\n\n                const html = $generateHtmlFromNodes(this.editor, selection);\n\n                return {\n                    node: childNode,\n                    html: postProcessHtml(html)\n                };\n            });\n        });\n\n        return flattenedNodes;\n    }\n\n    public toHtml(state: string | SerializedEditorState) {\n        const preparedState = prepareLexicalState(state);\n        const editorState = this.editor.parseEditorState(preparedState);\n        this.editor.setEditorState(editorState);\n\n        let html = \"\";\n\n        this.editor.update(() => {\n            html = $generateHtmlFromNodes(this.editor);\n        });\n\n        return postProcessHtml(html);\n    }\n\n    private getNodeDescendants(node: LexicalNode): LexicalNode[] {\n        if (!$isElementNode(node)) {\n            return [];\n        }\n        const children = node.getChildren();\n        return [...children, ...children.map(child => this.getNodeDescendants(child)).flat()];\n    }\n}\n\nexport const createLexicalStateTransformer = (config?: LexicalStateTransformerConfig) => {\n    return new LexicalStateTransformer(config);\n};\n"],"mappings":"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","ignoreList":[]}

package/index.d.ts

@@ -0,0 +1,3 @@
+export { SerializedEditorState } from "lexical";
+export * from "./createHtmlToLexicalParser";
+export * from "./createLexicalStateTransformer";

package/index.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  SerializedEditorState: true
+};
+Object.defineProperty(exports, "SerializedEditorState", {
+  enumerable: true,
+  get: function () {
+    return _lexical.SerializedEditorState;
+  }
+});
+var _lexical = require("lexical");
+var _createHtmlToLexicalParser = require("./createHtmlToLexicalParser");
+Object.keys(_createHtmlToLexicalParser).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _createHtmlToLexicalParser[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createHtmlToLexicalParser[key];
+    }
+  });
+});
+var _createLexicalStateTransformer = require("./createLexicalStateTransformer");
+Object.keys(_createLexicalStateTransformer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _createLexicalStateTransformer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _createLexicalStateTransformer[key];
+    }
+  });
+});
+
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_lexical","require","_createHtmlToLexicalParser","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_createLexicalStateTransformer"],"sources":["index.ts"],"sourcesContent":["export { SerializedEditorState } from \"lexical\";\nexport * from \"./createHtmlToLexicalParser\";\nexport * from \"./createLexicalStateTransformer\";\n"],"mappings":";;;;;;;;;;;;;;AAAA,IAAAA,QAAA,GAAAC,OAAA;AACA,IAAAC,0BAAA,GAAAD,OAAA;AAAAE,MAAA,CAAAC,IAAA,CAAAF,0BAAA,EAAAG,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAJ,0BAAA,CAAAI,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAZ,0BAAA,CAAAI,GAAA;IAAA;EAAA;AAAA;AACA,IAAAS,8BAAA,GAAAd,OAAA;AAAAE,MAAA,CAAAC,IAAA,CAAAW,8BAAA,EAAAV,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAS,8BAAA,CAAAT,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,8BAAA,CAAAT,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

package/package.json

@@ -0,0 +1,26 @@
+{
+	"name": "@webiny/lexical-converter",
+	"version": "0.0.0-unstable.06b2ede40f",
+	"dependencies": {
+		"@lexical/headless": "0.23.1",
+		"@lexical/html": "0.23.1",
+		"@webiny/lexical-nodes": "0.0.0-unstable.06b2ede40f",
+		"cheerio": "1.1.2",
+		"lexical": "0.23.1"
+	},
+	"devDependencies": {
+		"@types/jsdom": "^21.1.6",
+		"@webiny/project-utils": "0.0.0-unstable.06b2ede40f",
+		"jsdom": "25.0.1"
+	},
+	"publishConfig": {
+		"access": "public",
+		"directory": "dist"
+	},
+	"scripts": {
+		"build": "node ../cli/bin.js run build",
+		"watch": "node ../cli/bin.js run watch"
+	},
+	"test": "jest --verbose --runInBand --detectOpenHandles --forceExit",
+	"gitHead": "06b2ede40fc2212a70eeafd74afd50b56fb0ce82"
+}

package/postProcessHtml.d.ts

@@ -0,0 +1 @@
+export declare const postProcessHtml: (html: string) => string;

package/postProcessHtml.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.postProcessHtml = void 0;
+var _cheerio = require("cheerio");
+const postProcessHtml = html => {
+  const $ = (0, _cheerio.load)(html);
+
+  // Replace <b> elements with their text content (unwrap them)
+  $("b").each((_, el) => {
+    $(el).replaceWith($(el).html() ?? "");
+  });
+  return $("body").html() ?? html;
+};
+exports.postProcessHtml = postProcessHtml;
+
+//# sourceMappingURL=postProcessHtml.js.map

package/postProcessHtml.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_cheerio","require","postProcessHtml","html","$","load","each","_","el","replaceWith","exports"],"sources":["postProcessHtml.ts"],"sourcesContent":["import { load } from \"cheerio\";\n\nexport const postProcessHtml = (html: string) => {\n    const $ = load(html);\n\n    // Replace <b> elements with their text content (unwrap them)\n    $(\"b\").each((_, el) => {\n        $(el).replaceWith($(el).html() ?? \"\");\n    });\n\n    return $(\"body\").html() ?? html;\n};\n"],"mappings":";;;;;;AAAA,IAAAA,QAAA,GAAAC,OAAA;AAEO,MAAMC,eAAe,GAAIC,IAAY,IAAK;EAC7C,MAAMC,CAAC,GAAG,IAAAC,aAAI,EAACF,IAAI,CAAC;;EAEpB;EACAC,CAAC,CAAC,GAAG,CAAC,CAACE,IAAI,CAAC,CAACC,CAAC,EAAEC,EAAE,KAAK;IACnBJ,CAAC,CAACI,EAAE,CAAC,CAACC,WAAW,CAACL,CAAC,CAACI,EAAE,CAAC,CAACL,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;EACzC,CAAC,CAAC;EAEF,OAAOC,CAAC,CAAC,MAAM,CAAC,CAACD,IAAI,CAAC,CAAC,IAAIA,IAAI;AACnC,CAAC;AAACO,OAAA,CAAAR,eAAA,GAAAA,eAAA","ignoreList":[]}

package/types.d.ts

@@ -0,0 +1,6 @@
+import type { CreateEditorArgs, LexicalNode } from "lexical";
+export type NodeMapper = (node: LexicalNode) => LexicalNode;
+export interface ParserConfigurationOptions {
+    editorConfig?: Pick<CreateEditorArgs, "nodes" | "theme">;
+    nodeMapper?: NodeMapper;
+}

package/types.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+//# sourceMappingURL=types.js.map

package/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type { CreateEditorArgs, LexicalNode } from \"lexical\";\n\nexport type NodeMapper = (node: LexicalNode) => LexicalNode;\n\nexport interface ParserConfigurationOptions {\n    editorConfig?: Pick<CreateEditorArgs, \"nodes\" | \"theme\">;\n    nodeMapper?: NodeMapper;\n}\n"],"mappings":"","ignoreList":[]}