@payloadcms/richtext-lexical 4.0.0-canary.2 → 4.0.0-canary.20

package/dist/lexical/ui/ContentEditable.css

@@ -5,49 +5,53 @@
     position: relative;
     tab-size: 1;
     outline: 0;
-    padding-top: var(--spacer-2);
-    padding-bottom: var(--spacer-2);
-    padding-left: 0;
-    padding-right: 0;
+    padding: var(--spacer-3) var(--spacer-3);
+    /* Reserve space for the InsertParagraphAtEnd hover "+" affordance, which
+       overlaps this bottom padding; shrinking it would cover the last line. */
+    padding-bottom: var(--spacer-4);
 
     &:focus-visible {
       outline: none !important;
     }
-
-    & > * {
-      transition: transform 0.2s ease-in-out;
-    }
   }
 
-  .rich-text-lexical--show-gutter
-    > .rich-text-lexical__wrap
-    > .editor-container
-    > .editor-scroller
-    > .editor {
-    > .ContentEditable__root {
+  @media (min-width: 768px) {
+    .ContentEditable__root {
       padding: var(--spacer-4) var(--spacer-5);
     }
+
+    .rich-text-lexical:not(.rich-text-lexical--show-gutter)
+      > .rich-text-lexical__wrap
+      > .rich-text-lexical__editor-content
+      > .editor-container
+      > .editor-scroller
+      > .editor
+      > .ContentEditable__root {
+      padding: var(--spacer-2) 0;
+    }
   }
 
   html[data-theme='light'] {
     .rich-text-lexical.rich-text-lexical--show-gutter {
       &.error:not(:hover) {
         > .rich-text-lexical__wrap
+          > .rich-text-lexical__editor-content
           > .editor-container
           > .editor-scroller
           > .editor
           > .ContentEditable__root::before {
-          border-left: 2px solid var(--color-border-danger);
+          border-inline-start: var(--stroke-width-medium) solid var(--color-border-danger);
         }
       }
 
       &.error:hover {
         > .rich-text-lexical__wrap
+          > .rich-text-lexical__editor-content
           > .editor-container
           > .editor-scroller
           > .editor
           > .ContentEditable__root::before {
-          border-left: 2px solid var(--color-border-danger);
+          border-inline-start: var(--stroke-width-medium) solid var(--color-border-danger);
         }
       }
     }
@@ -68,11 +72,12 @@
     .rich-text-lexical.rich-text-lexical--show-gutter {
       &.error {
         > .rich-text-lexical__wrap
+          > .rich-text-lexical__editor-content
           > .editor-container
           > .editor-scroller
           > .editor
           > .ContentEditable__root::before {
-          border-left: 2px solid var(--color-border-danger);
+          border-inline-start: var(--stroke-width-medium) solid var(--color-border-danger);
         }
       }
     }

package/dist/lexical/utils/markdown/convertFromMarkdownString.d.ts

@@ -0,0 +1,17 @@
+import type { Transformer } from '@lexical/markdown';
+import type { ElementNode } from 'lexical';
+/**
+ * Payload's markdown import. Wraps `@lexical/markdown`'s `$convertFromMarkdownString`
+ * with Payload's `normalizeMarkdown` preprocessing (nested code fences + table-row
+ * whitespace handling).
+ *
+ * TODO: Remove this wrapper and the `normalizeMarkdown` import once
+ * https://github.com/facebook/lexical/pull/8734 is merged and we upgrade to a
+ * release that includes it. At that point callers can use `@lexical/markdown`'s
+ * `$convertFromMarkdownString` directly.
+ *
+ * @param shouldPreserveNewLines By setting this to true, new lines will be preserved between conversions.
+ * @param shouldMergeAdjacentLines By setting this to true, adjacent non empty lines will be merged according to commonmark spec: https://spec.commonmark.org/0.24/#example-177. Not applicable if shouldPreserveNewLines = true.
+ */
+export declare function $convertFromMarkdownString(markdown: string, transformers?: Array<Transformer>, node?: ElementNode, shouldPreserveNewLines?: boolean, shouldMergeAdjacentLines?: boolean): void;
+//# sourceMappingURL=convertFromMarkdownString.d.ts.map

package/dist/lexical/utils/markdown/convertFromMarkdownString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertFromMarkdownString.d.ts","sourceRoot":"","sources":["../../../../src/lexical/utils/markdown/convertFromMarkdownString.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAU1C;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,MAAM,EAChB,YAAY,GAAE,KAAK,CAAC,WAAW,CAAgB,EAC/C,IAAI,CAAC,EAAE,WAAW,EAClB,sBAAsB,UAAQ,EAC9B,wBAAwB,UAAQ,GAC/B,IAAI,CASN"}

package/dist/lexical/utils/markdown/convertFromMarkdownString.js

@@ -0,0 +1,27 @@
+import { $convertFromMarkdownString as $convertFromMarkdownStringUpstream,
+// eslint-disable-next-line payload/no-conflicting-lexical-markdown-imports -- this wrapper intentionally uses upstream's default transformer set
+TRANSFORMERS } from '@lexical/markdown';
+import { normalizeMarkdown } from './normalizeMarkdown.js';
+/**
+ * Payload's markdown import. Wraps `@lexical/markdown`'s `$convertFromMarkdownString`
+ * with Payload's `normalizeMarkdown` preprocessing (nested code fences + table-row
+ * whitespace handling).
+ *
+ * TODO: Remove this wrapper and the `normalizeMarkdown` import once
+ * https://github.com/facebook/lexical/pull/8734 is merged and we upgrade to a
+ * release that includes it. At that point callers can use `@lexical/markdown`'s
+ * `$convertFromMarkdownString` directly.
+ *
+ * @param shouldPreserveNewLines By setting this to true, new lines will be preserved between conversions.
+ * @param shouldMergeAdjacentLines By setting this to true, adjacent non empty lines will be merged according to commonmark spec: https://spec.commonmark.org/0.24/#example-177. Not applicable if shouldPreserveNewLines = true.
+ */
+export function $convertFromMarkdownString(markdown, transformers = TRANSFORMERS, node, shouldPreserveNewLines = false, shouldMergeAdjacentLines = false) {
+  if (shouldPreserveNewLines) {
+    return $convertFromMarkdownStringUpstream(markdown, transformers, node, true);
+  }
+  // Passing shouldMergeAdjacentLines = false to upstream stops it from
+  // re-normalizing markdown that normalizeMarkdown has already normalized.
+  const sanitizedMarkdown = normalizeMarkdown(markdown, shouldMergeAdjacentLines);
+  return $convertFromMarkdownStringUpstream(sanitizedMarkdown, transformers, node, false, false);
+}
+//# sourceMappingURL=convertFromMarkdownString.js.map

package/dist/lexical/utils/markdown/convertFromMarkdownString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertFromMarkdownString.js","names":["$convertFromMarkdownString","$convertFromMarkdownStringUpstream","TRANSFORMERS","normalizeMarkdown","markdown","transformers","node","shouldPreserveNewLines","shouldMergeAdjacentLines","sanitizedMarkdown"],"sources":["../../../../src/lexical/utils/markdown/convertFromMarkdownString.ts"],"sourcesContent":["import type { Transformer } from '@lexical/markdown'\nimport type { ElementNode } from 'lexical'\n\nimport {\n  $convertFromMarkdownString as $convertFromMarkdownStringUpstream,\n  // eslint-disable-next-line payload/no-conflicting-lexical-markdown-imports -- this wrapper intentionally uses upstream's default transformer set\n  TRANSFORMERS,\n} from '@lexical/markdown'\n\nimport { normalizeMarkdown } from './normalizeMarkdown.js'\n\n/**\n * Payload's markdown import. Wraps `@lexical/markdown`'s `$convertFromMarkdownString`\n * with Payload's `normalizeMarkdown` preprocessing (nested code fences + table-row\n * whitespace handling).\n *\n * TODO: Remove this wrapper and the `normalizeMarkdown` import once\n * https://github.com/facebook/lexical/pull/8734 is merged and we upgrade to a\n * release that includes it. At that point callers can use `@lexical/markdown`'s\n * `$convertFromMarkdownString` directly.\n *\n * @param shouldPreserveNewLines By setting this to true, new lines will be preserved between conversions.\n * @param shouldMergeAdjacentLines By setting this to true, adjacent non empty lines will be merged according to commonmark spec: https://spec.commonmark.org/0.24/#example-177. Not applicable if shouldPreserveNewLines = true.\n */\nexport function $convertFromMarkdownString(\n  markdown: string,\n  transformers: Array<Transformer> = TRANSFORMERS,\n  node?: ElementNode,\n  shouldPreserveNewLines = false,\n  shouldMergeAdjacentLines = false,\n): void {\n  if (shouldPreserveNewLines) {\n    return $convertFromMarkdownStringUpstream(markdown, transformers, node, true)\n  }\n\n  // Passing shouldMergeAdjacentLines = false to upstream stops it from\n  // re-normalizing markdown that normalizeMarkdown has already normalized.\n  const sanitizedMarkdown = normalizeMarkdown(markdown, shouldMergeAdjacentLines)\n  return $convertFromMarkdownStringUpstream(sanitizedMarkdown, transformers, node, false, false)\n}\n"],"mappings":"AAGA,SACEA,0BAAA,IAA8BC,kCAAkC;AAEhE;AAAAC,YAAY,QACP;AAEP,SAASC,iBAAiB,QAAQ;AAElC;;;;;;;;;;;;;AAaA,OAAO,SAASH,2BACdI,QAAgB,EAChBC,YAAA,GAAmCH,YAAY,EAC/CI,IAAkB,EAClBC,sBAAA,GAAyB,KAAK,EAC9BC,wBAAA,GAA2B,KAAK;EAEhC,IAAID,sBAAA,EAAwB;IAC1B,OAAON,kCAAA,CAAmCG,QAAA,EAAUC,YAAA,EAAcC,IAAA,EAAM;EAC1E;EAEA;EACA;EACA,MAAMG,iBAAA,GAAoBN,iBAAA,CAAkBC,QAAA,EAAUI,wBAAA;EACtD,OAAOP,kCAAA,CAAmCQ,iBAAA,EAAmBJ,YAAA,EAAcC,IAAA,EAAM,OAAO;AAC1F","ignoreList":[]}

package/dist/lexical/utils/markdown/convertFromMarkdownString.spec.js

@@ -0,0 +1,88 @@
+import { createHeadlessEditor } from '@lexical/headless';
+import { LinkNode } from '@lexical/link';
+import { ListItemNode, ListNode } from '@lexical/list';
+import { $convertToMarkdownString } from '@lexical/markdown';
+import { HeadingNode, QuoteNode } from '@lexical/rich-text';
+import { $getRoot, $isElementNode, $isLineBreakNode } from 'lexical';
+import { describe, expect, it } from 'vitest';
+import { $convertFromMarkdownString } from './convertFromMarkdownString.js';
+function createEditor() {
+  return createHeadlessEditor({
+    nodes: [HeadingNode, QuoteNode, ListNode, ListItemNode, LinkNode]
+  });
+}
+// Payload's editor imports markdown with shouldMergeAdjacentLines = true, so the
+// specs exercise that path: hard line breaks must survive even when adjacent lines
+// are merged, while soft wraps collapse to a single space.
+function importMarkdown(markdown) {
+  const editor = createEditor();
+  editor.update(() => $convertFromMarkdownString(markdown, undefined, undefined, false, true), {
+    discrete: true
+  });
+  let result = {
+    hasLineBreak: false,
+    textContent: ''
+  };
+  editor.getEditorState().read(() => {
+    const firstChild = $getRoot().getFirstChild();
+    if (!$isElementNode(firstChild)) {
+      throw new Error('Expected an element block');
+    }
+    result = {
+      hasLineBreak: firstChild.getChildren().some(child => $isLineBreakNode(child)),
+      textContent: firstChild.getTextContent()
+    };
+  });
+  return result;
+}
+function roundTrip(markdown) {
+  const editor = createEditor();
+  editor.update(() => $convertFromMarkdownString(markdown, undefined, undefined, false, true), {
+    discrete: true
+  });
+  let output = '';
+  editor.getEditorState().read(() => {
+    output = $convertToMarkdownString();
+  });
+  return output;
+}
+describe('markdown hard line break import', () => {
+  it('should import a trailing-space hard break as a line break node with the marker stripped', () => {
+    const {
+      hasLineBreak,
+      textContent
+    } = importMarkdown(['foo  ', 'bar'].join('\n'));
+    expect(hasLineBreak).toBe(true);
+    expect(textContent).toBe('foo\nbar');
+  });
+  it('should import a backslash hard break as a line break node with the marker stripped', () => {
+    const {
+      hasLineBreak,
+      textContent
+    } = importMarkdown('foo\\\nbar');
+    expect(hasLineBreak).toBe(true);
+    expect(textContent).toBe('foo\nbar');
+  });
+});
+describe('markdown hard line break round trip', () => {
+  it('should round trip a trailing-space hard break', () => {
+    const md = ['foo  ', 'bar'].join('\n');
+    expect(roundTrip(md)).toBe(md);
+  });
+  it('should round trip a backslash hard break', () => {
+    const md = 'foo\\\nbar';
+    expect(roundTrip(md)).toBe(md);
+  });
+  it('should not introduce a hard break for a soft wrap', () => {
+    expect(roundTrip(['foo', 'bar'].join('\n'))).toBe('foo bar');
+  });
+  it('should round trip a hard break after formatted text', () => {
+    const md = '**foo**  \nbar';
+    expect(roundTrip(md)).toBe(md);
+  });
+  it('should round trip a hard break after a link', () => {
+    const md = '[foo](https://payloadcms.com)  \nbar';
+    expect(roundTrip(md)).toBe(md);
+  });
+});
+//# sourceMappingURL=convertFromMarkdownString.spec.js.map

package/dist/lexical/utils/markdown/convertFromMarkdownString.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertFromMarkdownString.spec.js","names":["createHeadlessEditor","LinkNode","ListItemNode","ListNode","$convertToMarkdownString","HeadingNode","QuoteNode","$getRoot","$isElementNode","$isLineBreakNode","describe","expect","it","$convertFromMarkdownString","createEditor","nodes","importMarkdown","markdown","editor","update","undefined","discrete","result","hasLineBreak","textContent","getEditorState","read","firstChild","getFirstChild","Error","getChildren","some","child","getTextContent","roundTrip","output","join","toBe","md"],"sources":["../../../../src/lexical/utils/markdown/convertFromMarkdownString.spec.ts"],"sourcesContent":["import { createHeadlessEditor } from '@lexical/headless'\nimport { LinkNode } from '@lexical/link'\nimport { ListItemNode, ListNode } from '@lexical/list'\nimport { $convertToMarkdownString } from '@lexical/markdown'\nimport { HeadingNode, QuoteNode } from '@lexical/rich-text'\nimport { $getRoot, $isElementNode, $isLineBreakNode } from 'lexical'\nimport { describe, expect, it } from 'vitest'\n\nimport { $convertFromMarkdownString } from './convertFromMarkdownString.js'\n\nfunction createEditor() {\n  return createHeadlessEditor({\n    nodes: [HeadingNode, QuoteNode, ListNode, ListItemNode, LinkNode],\n  })\n}\n\n// Payload's editor imports markdown with shouldMergeAdjacentLines = true, so the\n// specs exercise that path: hard line breaks must survive even when adjacent lines\n// are merged, while soft wraps collapse to a single space.\nfunction importMarkdown(markdown: string): { hasLineBreak: boolean; textContent: string } {\n  const editor = createEditor()\n  editor.update(() => $convertFromMarkdownString(markdown, undefined, undefined, false, true), {\n    discrete: true,\n  })\n  let result = { hasLineBreak: false, textContent: '' }\n  editor.getEditorState().read(() => {\n    const firstChild = $getRoot().getFirstChild()\n    if (!$isElementNode(firstChild)) {\n      throw new Error('Expected an element block')\n    }\n    result = {\n      hasLineBreak: firstChild.getChildren().some((child) => $isLineBreakNode(child)),\n      textContent: firstChild.getTextContent(),\n    }\n  })\n  return result\n}\n\nfunction roundTrip(markdown: string): string {\n  const editor = createEditor()\n  editor.update(() => $convertFromMarkdownString(markdown, undefined, undefined, false, true), {\n    discrete: true,\n  })\n  let output = ''\n  editor.getEditorState().read(() => {\n    output = $convertToMarkdownString()\n  })\n  return output\n}\n\ndescribe('markdown hard line break import', () => {\n  it('should import a trailing-space hard break as a line break node with the marker stripped', () => {\n    const { hasLineBreak, textContent } = importMarkdown(['foo  ', 'bar'].join('\\n'))\n\n    expect(hasLineBreak).toBe(true)\n    expect(textContent).toBe('foo\\nbar')\n  })\n\n  it('should import a backslash hard break as a line break node with the marker stripped', () => {\n    const { hasLineBreak, textContent } = importMarkdown('foo\\\\\\nbar')\n\n    expect(hasLineBreak).toBe(true)\n    expect(textContent).toBe('foo\\nbar')\n  })\n})\n\ndescribe('markdown hard line break round trip', () => {\n  it('should round trip a trailing-space hard break', () => {\n    const md = ['foo  ', 'bar'].join('\\n')\n    expect(roundTrip(md)).toBe(md)\n  })\n\n  it('should round trip a backslash hard break', () => {\n    const md = 'foo\\\\\\nbar'\n    expect(roundTrip(md)).toBe(md)\n  })\n\n  it('should not introduce a hard break for a soft wrap', () => {\n    expect(roundTrip(['foo', 'bar'].join('\\n'))).toBe('foo bar')\n  })\n\n  it('should round trip a hard break after formatted text', () => {\n    const md = '**foo**  \\nbar'\n    expect(roundTrip(md)).toBe(md)\n  })\n\n  it('should round trip a hard break after a link', () => {\n    const md = '[foo](https://payloadcms.com)  \\nbar'\n    expect(roundTrip(md)).toBe(md)\n  })\n})\n"],"mappings":"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","ignoreList":[]}

package/dist/lexical/utils/markdown/createBlockNode.d.ts

@@ -1,4 +1,4 @@
+import type { ElementTransformer } from '@lexical/markdown';
 import type { ElementNode } from 'lexical';
-import type { ElementTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js';
-export declare const createBlockNode: (createNode: (match: Array<string>) => ElementNode) => ElementTransformer["replace"];
+export declare const createBlockNode: (createNode: (match: Array<string>) => ElementNode) => ElementTransformer['replace'];
 //# sourceMappingURL=createBlockNode.d.ts.map

package/dist/lexical/utils/markdown/createBlockNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createBlockNode.d.ts","sourceRoot":"","sources":["../../../../src/lexical/utils/markdown/createBlockNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6DAA6D,CAAA;AAErG,eAAO,MAAM,eAAe,GAC1B,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,WAAW,KAChD,kBAAkB,CAAC,SAAS,CAS9B,CAAA"}
+{"version":3,"file":"createBlockNode.d.ts","sourceRoot":"","sources":["../../../../src/lexical/utils/markdown/createBlockNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C,eAAO,MAAM,eAAe,eACd,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,WAAW,KAChD,kBAAkB,CAAC,SAAS,CAS9B,CAAA"}

package/dist/lexical/utils/markdown/createBlockNode.js.map

@@ -1 +1 @@
-{"version":3,"file":"createBlockNode.js","names":["createBlockNode","createNode","parentNode","children","match","node","append","replace","select"],"sources":["../../../../src/lexical/utils/markdown/createBlockNode.ts"],"sourcesContent":["import type { ElementNode } from 'lexical'\n\nimport type { ElementTransformer } from '../../../packages/@lexical/markdown/MarkdownTransformers.js'\n\nexport const createBlockNode = (\n  createNode: (match: Array<string>) => ElementNode,\n): ElementTransformer['replace'] => {\n  return (parentNode, children, match) => {\n    const node = createNode(match)\n    if (node) {\n      node.append(...children)\n      parentNode.replace(node)\n      node.select(0, 0)\n    }\n  }\n}\n"],"mappings":"AAIA,OAAO,MAAMA,eAAA,GACXC,UAAA;EAEA,OAAO,CAACC,UAAA,EAAYC,QAAA,EAAUC,KAAA;IAC5B,MAAMC,IAAA,GAAOJ,UAAA,CAAWG,KAAA;IACxB,IAAIC,IAAA,EAAM;MACRA,IAAA,CAAKC,MAAM,IAAIH,QAAA;MACfD,UAAA,CAAWK,OAAO,CAACF,IAAA;MACnBA,IAAA,CAAKG,MAAM,CAAC,GAAG;IACjB;EACF;AACF","ignoreList":[]}
+{"version":3,"file":"createBlockNode.js","names":["createBlockNode","createNode","parentNode","children","match","node","append","replace","select"],"sources":["../../../../src/lexical/utils/markdown/createBlockNode.ts"],"sourcesContent":["import type { ElementTransformer } from '@lexical/markdown'\nimport type { ElementNode } from 'lexical'\n\nexport const createBlockNode = (\n  createNode: (match: Array<string>) => ElementNode,\n): ElementTransformer['replace'] => {\n  return (parentNode, children, match) => {\n    const node = createNode(match)\n    if (node) {\n      node.append(...children)\n      parentNode.replace(node)\n      node.select(0, 0)\n    }\n  }\n}\n"],"mappings":"AAGA,OAAO,MAAMA,eAAA,GACXC,UAAA;EAEA,OAAO,CAACC,UAAA,EAAYC,QAAA,EAAUC,KAAA;IAC5B,MAAMC,IAAA,GAAOJ,UAAA,CAAWG,KAAA;IACxB,IAAIC,IAAA,EAAM;MACRA,IAAA,CAAKC,MAAM,IAAIH,QAAA;MACfD,UAAA,CAAWK,OAAO,CAACF,IAAA;MACnBA,IAAA,CAAKG,MAAM,CAAC,GAAG;IACjB;EACF;AACF","ignoreList":[]}

package/dist/lexical/utils/markdown/normalizeMarkdown.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Payload-specific markdown normalization, run by `$convertFromMarkdownString`
+ * before delegating the import to `@lexical/markdown`. Handles nested code
+ * fences and preserves table-row whitespace.
+ *
+ * TODO: Remove this file once https://github.com/facebook/lexical/pull/8734 is
+ * merged and we upgrade to a release that includes it. That PR fixes the nested
+ * code fence handling upstream, so `$convertFromMarkdownString` can call
+ * `@lexical/markdown` directly instead of pre-normalizing here.
+ */
+/**
+ * Represents a CommonMark hard line break marker: either a trailing backslash
+ * or two-or-more trailing spaces.
+ *
+ * See https://spec.commonmark.org/0.31.2/#hard-line-breaks
+ */
+export type MarkdownHardLineBreak = string;
+/**
+ * Detects a CommonMark hard line break marker at the end of a raw line.
+ *
+ * @returns a tuple of `[textWithoutMarker, marker]` when a marker is found, otherwise null.
+ */
+export declare function parseMarkdownHardLineBreak(line: string): [string, MarkdownHardLineBreak] | null;
+export declare function normalizeMarkdown(input: string, shouldMergeAdjacentLines: boolean): string;
+//# sourceMappingURL=normalizeMarkdown.d.ts.map

package/dist/lexical/utils/markdown/normalizeMarkdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeMarkdown.d.ts","sourceRoot":"","sources":["../../../../src/lexical/utils/markdown/normalizeMarkdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAoBH;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAA;AAE1C;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,GAAG,IAAI,CAO/F;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,wBAAwB,EAAE,OAAO,GAAG,MAAM,CAgF1F"}

package/dist/lexical/utils/markdown/normalizeMarkdown.js

@@ -0,0 +1,91 @@
+/**
+ * Payload-specific markdown normalization, run by `$convertFromMarkdownString`
+ * before delegating the import to `@lexical/markdown`. Handles nested code
+ * fences and preserves table-row whitespace.
+ *
+ * TODO: Remove this file once https://github.com/facebook/lexical/pull/8734 is
+ * merged and we upgrade to a release that includes it. That PR fixes the nested
+ * code fence handling upstream, so `$convertFromMarkdownString` can call
+ * `@lexical/markdown` directly instead of pre-normalizing here.
+ */ // These regexes are only used with `.test()` here, so their capturing groups
+// are unused in this module.
+/* eslint-disable regexp/no-unused-capturing-group */const EMPTY_OR_WHITESPACE_ONLY = /^[\t ]*$/;
+const ORDERED_LIST_REGEX = /^(\s*)(\d+)\.\s/;
+const UNORDERED_LIST_REGEX = /^(\s*)[-*+]\s/;
+const CHECK_LIST_REGEX = /^(\s*)(?:-\s)?\s?(\[(\s|x)?\])\s/i;
+const HEADING_REGEX = /^(#{1,6})\s/;
+const QUOTE_REGEX = /^>\s/;
+const CODE_START_REGEX = /^[ \t]*(\\`\\`\\`|```)(\w+)?/;
+const CODE_END_REGEX = /[ \t]*(\\`\\`\\`|```)$/;
+const CODE_SINGLE_LINE_REGEX = /^[ \t]*```[^`]+(?:(?:`{1,2}|`{4,})[^`]+)*```(?:[^`]|$)/;
+const TABLE_ROW_REG_EXP = /^\|(.+)\|\s?$/;
+const TABLE_ROW_DIVIDER_REG_EXP = /^(\| ?:?-*:? ?)+\|\s?$/;
+const TAG_START_REGEX = /^[ \t]*<[a-z_][\w-]*(?:\s[^<>]*)?\/?>/i;
+const TAG_END_REGEX = /^[ \t]*<\/[a-z_][\w-]*\s*>/i;
+/**
+ * Detects a CommonMark hard line break marker at the end of a raw line.
+ *
+ * @returns a tuple of `[textWithoutMarker, marker]` when a marker is found, otherwise null.
+ */
+export function parseMarkdownHardLineBreak(line) {
+  if (line.endsWith('\\')) {
+    return [line.slice(0, -1), '\\'];
+  }
+  const spaces = line.match(/^(.*?\S)( {2,})$/);
+  return spaces ? [spaces[1], spaces[2]] : null;
+}
+export function normalizeMarkdown(input, shouldMergeAdjacentLines) {
+  const lines = input.split('\n');
+  let inCodeBlock = false;
+  const sanitizedLines = [];
+  let nestedDeepCodeBlock = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lastLine = sanitizedLines[sanitizedLines.length - 1];
+    // A hard line break marker on the current line only matters if another line follows it.
+    const hardLineBreak = i < lines.length - 1 ? parseMarkdownHardLineBreak(line) : null;
+    const lastLineHasHardLineBreak = lastLine !== undefined && parseMarkdownHardLineBreak(lastLine) !== null;
+    // Code blocks of ```single line``` don't toggle the inCodeBlock flag
+    if (CODE_SINGLE_LINE_REGEX.test(line)) {
+      sanitizedLines.push(line);
+      continue;
+    }
+    if (CODE_END_REGEX.test(line)) {
+      if (nestedDeepCodeBlock === 0) {
+        inCodeBlock = true;
+      }
+      if (nestedDeepCodeBlock === 1) {
+        inCodeBlock = false;
+      }
+      if (nestedDeepCodeBlock > 0) {
+        nestedDeepCodeBlock--;
+      }
+      sanitizedLines.push(line);
+      continue;
+    }
+    // Toggle inCodeBlock state when encountering start or end of a code block
+    if (CODE_START_REGEX.test(line)) {
+      inCodeBlock = true;
+      nestedDeepCodeBlock++;
+      sanitizedLines.push(line);
+      continue;
+    }
+    // If we are inside a code block, keep the line unchanged
+    if (inCodeBlock) {
+      sanitizedLines.push(line);
+      continue;
+    }
+    // In markdown the concept of "empty paragraphs" does not exist.
+    // Blocks must be separated by an empty line. Non-empty adjacent lines must be merged.
+    if (EMPTY_OR_WHITESPACE_ONLY.test(line) || EMPTY_OR_WHITESPACE_ONLY.test(lastLine) || !lastLine || HEADING_REGEX.test(lastLine) || HEADING_REGEX.test(line) || QUOTE_REGEX.test(line) || ORDERED_LIST_REGEX.test(line) || UNORDERED_LIST_REGEX.test(line) || CHECK_LIST_REGEX.test(line) || TABLE_ROW_REG_EXP.test(line) || TABLE_ROW_DIVIDER_REG_EXP.test(line) ||
+    // Don't merge the next line into a line that ends with a hard line break marker.
+    lastLineHasHardLineBreak || !shouldMergeAdjacentLines || TAG_START_REGEX.test(line) || TAG_END_REGEX.test(line) || TAG_START_REGEX.test(lastLine) || TAG_END_REGEX.test(lastLine) || CODE_END_REGEX.test(lastLine)) {
+      sanitizedLines.push(line);
+    } else {
+      // Preserve a trailing hard line break marker on the merged line so it survives import.
+      sanitizedLines[sanitizedLines.length - 1] = lastLine + ' ' + (hardLineBreak === null ? line.trim() : line.trimStart());
+    }
+  }
+  return sanitizedLines.join('\n');
+}
+//# sourceMappingURL=normalizeMarkdown.js.map

package/dist/lexical/utils/markdown/normalizeMarkdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeMarkdown.js","names":["EMPTY_OR_WHITESPACE_ONLY","ORDERED_LIST_REGEX","UNORDERED_LIST_REGEX","CHECK_LIST_REGEX","HEADING_REGEX","QUOTE_REGEX","CODE_START_REGEX","CODE_END_REGEX","CODE_SINGLE_LINE_REGEX","TABLE_ROW_REG_EXP","TABLE_ROW_DIVIDER_REG_EXP","TAG_START_REGEX","TAG_END_REGEX","parseMarkdownHardLineBreak","line","endsWith","slice","spaces","match","normalizeMarkdown","input","shouldMergeAdjacentLines","lines","split","inCodeBlock","sanitizedLines","nestedDeepCodeBlock","i","length","lastLine","hardLineBreak","lastLineHasHardLineBreak","undefined","test","push","trim","trimStart","join"],"sources":["../../../../src/lexical/utils/markdown/normalizeMarkdown.ts"],"sourcesContent":["/**\n * Payload-specific markdown normalization, run by `$convertFromMarkdownString`\n * before delegating the import to `@lexical/markdown`. Handles nested code\n * fences and preserves table-row whitespace.\n *\n * TODO: Remove this file once https://github.com/facebook/lexical/pull/8734 is\n * merged and we upgrade to a release that includes it. That PR fixes the nested\n * code fence handling upstream, so `$convertFromMarkdownString` can call\n * `@lexical/markdown` directly instead of pre-normalizing here.\n */\n\n// These regexes are only used with `.test()` here, so their capturing groups\n// are unused in this module.\n/* eslint-disable regexp/no-unused-capturing-group */\n\nconst EMPTY_OR_WHITESPACE_ONLY = /^[\\t ]*$/\nconst ORDERED_LIST_REGEX = /^(\\s*)(\\d+)\\.\\s/\nconst UNORDERED_LIST_REGEX = /^(\\s*)[-*+]\\s/\nconst CHECK_LIST_REGEX = /^(\\s*)(?:-\\s)?\\s?(\\[(\\s|x)?\\])\\s/i\nconst HEADING_REGEX = /^(#{1,6})\\s/\nconst QUOTE_REGEX = /^>\\s/\nconst CODE_START_REGEX = /^[ \\t]*(\\\\`\\\\`\\\\`|```)(\\w+)?/\nconst CODE_END_REGEX = /[ \\t]*(\\\\`\\\\`\\\\`|```)$/\nconst CODE_SINGLE_LINE_REGEX = /^[ \\t]*```[^`]+(?:(?:`{1,2}|`{4,})[^`]+)*```(?:[^`]|$)/\nconst TABLE_ROW_REG_EXP = /^\\|(.+)\\|\\s?$/\nconst TABLE_ROW_DIVIDER_REG_EXP = /^(\\| ?:?-*:? ?)+\\|\\s?$/\nconst TAG_START_REGEX = /^[ \\t]*<[a-z_][\\w-]*(?:\\s[^<>]*)?\\/?>/i\nconst TAG_END_REGEX = /^[ \\t]*<\\/[a-z_][\\w-]*\\s*>/i\n\n/**\n * Represents a CommonMark hard line break marker: either a trailing backslash\n * or two-or-more trailing spaces.\n *\n * See https://spec.commonmark.org/0.31.2/#hard-line-breaks\n */\nexport type MarkdownHardLineBreak = string\n\n/**\n * Detects a CommonMark hard line break marker at the end of a raw line.\n *\n * @returns a tuple of `[textWithoutMarker, marker]` when a marker is found, otherwise null.\n */\nexport function parseMarkdownHardLineBreak(line: string): [string, MarkdownHardLineBreak] | null {\n  if (line.endsWith('\\\\')) {\n    return [line.slice(0, -1), '\\\\']\n  }\n\n  const spaces = line.match(/^(.*?\\S)( {2,})$/)\n  return spaces ? [spaces[1]!, spaces[2]!] : null\n}\n\nexport function normalizeMarkdown(input: string, shouldMergeAdjacentLines: boolean): string {\n  const lines = input.split('\\n')\n  let inCodeBlock = false\n  const sanitizedLines: string[] = []\n  let nestedDeepCodeBlock = 0\n\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i]!\n    const lastLine = sanitizedLines[sanitizedLines.length - 1]\n    // A hard line break marker on the current line only matters if another line follows it.\n    const hardLineBreak = i < lines.length - 1 ? parseMarkdownHardLineBreak(line) : null\n    const lastLineHasHardLineBreak =\n      lastLine !== undefined && parseMarkdownHardLineBreak(lastLine) !== null\n\n    // Code blocks of ```single line``` don't toggle the inCodeBlock flag\n    if (CODE_SINGLE_LINE_REGEX.test(line)) {\n      sanitizedLines.push(line)\n      continue\n    }\n\n    if (CODE_END_REGEX.test(line)) {\n      if (nestedDeepCodeBlock === 0) {\n        inCodeBlock = true\n      }\n      if (nestedDeepCodeBlock === 1) {\n        inCodeBlock = false\n      }\n      if (nestedDeepCodeBlock > 0) {\n        nestedDeepCodeBlock--\n      }\n      sanitizedLines.push(line)\n      continue\n    }\n\n    // Toggle inCodeBlock state when encountering start or end of a code block\n    if (CODE_START_REGEX.test(line)) {\n      inCodeBlock = true\n      nestedDeepCodeBlock++\n      sanitizedLines.push(line)\n      continue\n    }\n\n    // If we are inside a code block, keep the line unchanged\n    if (inCodeBlock) {\n      sanitizedLines.push(line)\n      continue\n    }\n\n    // In markdown the concept of \"empty paragraphs\" does not exist.\n    // Blocks must be separated by an empty line. Non-empty adjacent lines must be merged.\n    if (\n      EMPTY_OR_WHITESPACE_ONLY.test(line) ||\n      EMPTY_OR_WHITESPACE_ONLY.test(lastLine!) ||\n      !lastLine ||\n      HEADING_REGEX.test(lastLine) ||\n      HEADING_REGEX.test(line) ||\n      QUOTE_REGEX.test(line) ||\n      ORDERED_LIST_REGEX.test(line) ||\n      UNORDERED_LIST_REGEX.test(line) ||\n      CHECK_LIST_REGEX.test(line) ||\n      TABLE_ROW_REG_EXP.test(line) ||\n      TABLE_ROW_DIVIDER_REG_EXP.test(line) ||\n      // Don't merge the next line into a line that ends with a hard line break marker.\n      lastLineHasHardLineBreak ||\n      !shouldMergeAdjacentLines ||\n      TAG_START_REGEX.test(line) ||\n      TAG_END_REGEX.test(line) ||\n      TAG_START_REGEX.test(lastLine) ||\n      TAG_END_REGEX.test(lastLine) ||\n      CODE_END_REGEX.test(lastLine)\n    ) {\n      sanitizedLines.push(line)\n    } else {\n      // Preserve a trailing hard line break marker on the merged line so it survives import.\n      sanitizedLines[sanitizedLines.length - 1] =\n        lastLine + ' ' + (hardLineBreak === null ? line.trim() : line.trimStart())\n    }\n  }\n\n  return sanitizedLines.join('\\n')\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -1 +1 @@
-{"version":3,"file":"nodeFormat.d.ts","sourceRoot":"","sources":["../../../src/lexical/utils/nodeFormat.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAC9E,MAAM,MAAM,cAAc,GAAG,eAAe,GAAG,YAAY,CAAA;AAG3D,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,MAAM,GAAG,cAAc,EAAE,MAAM,CASvE,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,GAAG,cAAc,EAAE,MAAM,CAGzE,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,OAAO,CAAC,iBAAiB,EAAE,EAAE,CAAC,EAAE,MAAM,CAOjF,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAOpE,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,YAAY,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAI7D,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAI1D,CAAA"}
+{"version":3,"file":"nodeFormat.d.ts","sourceRoot":"","sources":["../../../src/lexical/utils/nodeFormat.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAC9E,MAAM,MAAM,cAAc,GAAG,eAAe,GAAG,YAAY,CAAA;AAG3D,eAAO,MAAM,UAAU;aACrB,gBAAgB,EAAE,CAAC;aACnB,aAAa,EAAE,CAAC;aAEhB,cAAc,EAAE,CAAC;aACjB,eAAe,EAAE,CAAC;aAClB,cAAc,EAAE,CAAC;aAEjB,SAAS,EAAE,CAAC;aACZ,QAAQ,EAAE,CAAC;aACX,YAAY,EAAE,CAAC;aACf,QAAQ,EAAE,CAAC;aAEX,OAAO,EAAE,CAAC;aACV,SAAS;aACT,gBAAgB;aAChB,YAAY;aACZ,OAAO;aACP,YAAY;aACZ,cAAc;aACd,YAAY;aAEZ,gBAAgB,EAAE,CAAC;aACnB,cAAc;aAEd,aAAa,EAAE,CAAC;aAChB,eAAe,EAAE,CAAC;aAClB,cAAc,EAAE,CAAC;aACjB,gBAAgB,EAAE,CAAC;aACnB,cAAc,EAAE,CAAC;aACjB,YAAY,EAAE,CAAC;CACP,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,MAAM,GAAG,cAAc,EAAE,MAAM,CASvE,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,GAAG,cAAc,EAAE,MAAM,CAGzE,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,OAAO,CAAC,iBAAiB,EAAE,EAAE,CAAC,EAAE,MAAM,CAOjF,CAAA;AAED,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAOpE,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,YAAY,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAI7D,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAI1D,CAAA"}

package/dist/lexical/utils/point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/lexical/utils/point.ts"],"names":[],"mappings":"AACA,qBAAa,KAAK;IAChB,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAQ;IAE3B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAQ;gBAEf,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAKzB,YAAY,CAAC,EAAE,CAAC,EAAE,EAAE,KAAK,GAAG,MAAM;IAIlC,YAAY,CAAC,EAAE,CAAC,EAAE,EAAE,KAAK,GAAG,MAAM;IAIlC,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;IAIpC,wBAAwB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;IAI9C,oBAAoB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;IAI1C,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,KAAK,GAAG,OAAO;IAIvC,IAAI,CAAC,IAAI,MAAM,CAEd;IAED,IAAI,CAAC,IAAI,MAAM,CAEd;CACF;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,KAAK,CAE9C"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/lexical/utils/point.ts"],"names":[],"mappings":"AACA,qBAAa,KAAK;IAChB,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAQ;IAE3B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAQ;IAE3B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAG/B;IAEM,YAAY,CAAC,EAAE,CAAC,EAAE,EAAE,KAAK,GAAG,MAAM,CAExC;IAEM,YAAY,CAAC,EAAE,CAAC,EAAE,EAAE,KAAK,GAAG,MAAM,CAExC;IAEM,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAE1C;IAEM,wBAAwB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAEpD;IAEM,oBAAoB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAEhD;IAEM,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,KAAK,GAAG,OAAO,CAEtC;IAED,IAAI,CAAC,IAAI,MAAM,CAEd;IAED,IAAI,CAAC,IAAI,MAAM,CAEd;CACF;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,KAAK,CAE9C"}

package/dist/lexical/utils/rect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rect.d.ts","sourceRoot":"","sources":["../../../src/lexical/utils/rect.ts"],"names":[],"mappings":"AACA,OAAO,EAAW,KAAK,KAAK,EAAE,MAAM,YAAY,CAAA;AAEhD,UAAU,mBAAmB;IAC3B,MAAM,EAAE;QACN,cAAc,EAAE,OAAO,CAAA;QACvB,YAAY,EAAE,OAAO,CAAA;QACrB,aAAa,EAAE,OAAO,CAAA;QACtB,WAAW,EAAE,OAAO,CAAA;KACrB,CAAA;IACD,MAAM,EAAE,OAAO,CAAA;CAChB;AAED,qBAAa,IAAI;IACf,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;IAEhC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;IAE9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAE/B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAQ;gBAEjB,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAWpE,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI;IAKtC,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAK1C,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAI/E,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAI/E,MAAM,CAAC,UAAU,CAAC,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,GAAG,IAAI;IAMpD,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,KAAK,GAAG,mBAAmB;IAE9C,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,IAAI,GAAG,OAAO;IAqCrD,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG;QACtC,QAAQ,EAAE,MAAM,CAAA;QAChB,cAAc,EAAE,OAAO,CAAA;QACvB,YAAY,EAAE,OAAO,CAAA;QACrB,aAAa,EAAE,OAAO,CAAA;QACtB,WAAW,EAAE,OAAO,CAAA;KACrB;IA2CM,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,IAAI,GAAG,OAAO;IAMnD,eAAe,CAAC,EACrB,MAAoB,EACpB,IAAgB,EAChB,KAAkB,EAClB,GAAc,GACf;;;;;KAAA,GAAG,IAAI;IAID,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO;IAU1C,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,GAAG,IAAI,MAAM,CAEhB;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;CACF"}
+{"version":3,"file":"rect.d.ts","sourceRoot":"","sources":["../../../src/lexical/utils/rect.ts"],"names":[],"mappings":"AACA,OAAO,EAAW,KAAK,KAAK,EAAE,MAAM,YAAY,CAAA;AAEhD,UAAU,mBAAmB;IAC3B,MAAM,EAAE;QACN,cAAc,EAAE,OAAO,CAAA;QACvB,YAAY,EAAE,OAAO,CAAA;QACrB,aAAa,EAAE,OAAO,CAAA;QACtB,WAAW,EAAE,OAAO,CAAA;KACrB,CAAA;IACD,MAAM,EAAE,OAAO,CAAA;CAChB;AAED,qBAAa,IAAI;IACf,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;IAEhC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;IAE9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAE/B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAQ;IAE7B,YAAY,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EASnE;IAED,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI,CAGrC;IAED,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAGzC;IAED,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9E;IAED,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAE9E;IAED,MAAM,CAAC,UAAU,CAAC,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,GAAG,IAAI,CAI1D;IAEM,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,KAAK,GAAG,mBAAmB,CAAA;IAE9C,QAAQ,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,IAAI,GAAG,OAAO,CAAA;IAqCrD,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG;QACtC,QAAQ,EAAE,MAAM,CAAA;QAChB,cAAc,EAAE,OAAO,CAAA;QACvB,YAAY,EAAE,OAAO,CAAA;QACrB,aAAa,EAAE,OAAO,CAAA;QACtB,WAAW,EAAE,OAAO,CAAA;KACrB,CAyCA;IAEM,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,IAAI,GAAG,OAAO,CAIzD;IAEM,eAAe,CAAC,EACrB,MAAoB,EACpB,IAAgB,EAChB,KAAkB,EAClB,GAAc,GACf;;;;;KAAA,GAAG,IAAI,CAEP;IAEM,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAQzC;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,IAAI,GAAG,IAAI,MAAM,CAEhB;IAED,IAAI,KAAK,IAAI,MAAM,CAElB;CACF"}

package/dist/lexical-proxy/@lexical-markdown.d.ts

@@ -1,2 +1,2 @@
-export * from '../packages/@lexical/markdown/index.js';
+export * from '@lexical/markdown';
 //# sourceMappingURL=@lexical-markdown.d.ts.map

package/dist/lexical-proxy/@lexical-markdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"@lexical-markdown.d.ts","sourceRoot":"","sources":["../../src/lexical-proxy/@lexical-markdown.ts"],"names":[],"mappings":"AAAA,cAAc,wCAAwC,CAAA"}
+{"version":3,"file":"@lexical-markdown.d.ts","sourceRoot":"","sources":["../../src/lexical-proxy/@lexical-markdown.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA"}

package/dist/lexical-proxy/@lexical-markdown.js

@@ -1,2 +1,2 @@
-export * from '../packages/@lexical/markdown/index.js';
+export * from '@lexical/markdown';
 //# sourceMappingURL=@lexical-markdown.js.map

package/dist/lexical-proxy/@lexical-markdown.js.map

@@ -1 +1 @@
-{"version":3,"file":"@lexical-markdown.js","names":[],"sources":["../../src/lexical-proxy/@lexical-markdown.ts"],"sourcesContent":["export * from '../packages/@lexical/markdown/index.js'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}
+{"version":3,"file":"@lexical-markdown.js","names":[],"sources":["../../src/lexical-proxy/@lexical-markdown.ts"],"sourcesContent":["export * from '@lexical/markdown'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/ExtensionComponent.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/ExtensionComponent';
+//# sourceMappingURL=ExtensionComponent.d.ts.map

package/dist/lexical-proxy/@lexical-react/ExtensionComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionComponent.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/ExtensionComponent.tsx"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAA"}

package/dist/lexical-proxy/@lexical-react/ExtensionComponent.js

@@ -0,0 +1,2 @@
+export * from '@lexical/react/ExtensionComponent';
+//# sourceMappingURL=ExtensionComponent.js.map

package/dist/lexical-proxy/@lexical-react/ExtensionComponent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionComponent.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/ExtensionComponent.tsx"],"sourcesContent":["export * from '@lexical/react/ExtensionComponent'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/LexicalExtensionComposer.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/LexicalExtensionComposer';
+//# sourceMappingURL=LexicalExtensionComposer.d.ts.map

package/dist/lexical-proxy/@lexical-react/LexicalExtensionComposer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LexicalExtensionComposer.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/LexicalExtensionComposer.tsx"],"names":[],"mappings":"AAAA,cAAc,yCAAyC,CAAA"}

package/dist/lexical-proxy/@lexical-react/LexicalExtensionComposer.js

@@ -0,0 +1,2 @@
+export * from '@lexical/react/LexicalExtensionComposer';
+//# sourceMappingURL=LexicalExtensionComposer.js.map

package/dist/lexical-proxy/@lexical-react/LexicalExtensionComposer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LexicalExtensionComposer.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/LexicalExtensionComposer.tsx"],"sourcesContent":["export * from '@lexical/react/LexicalExtensionComposer'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/LexicalExtensionEditorComposer.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/LexicalExtensionEditorComposer';
+//# sourceMappingURL=LexicalExtensionEditorComposer.d.ts.map

package/dist/lexical-proxy/@lexical-react/LexicalExtensionEditorComposer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LexicalExtensionEditorComposer.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/LexicalExtensionEditorComposer.tsx"],"names":[],"mappings":"AAAA,cAAc,+CAA+C,CAAA"}

package/dist/lexical-proxy/@lexical-react/LexicalExtensionEditorComposer.js

@@ -0,0 +1,2 @@
+export * from '@lexical/react/LexicalExtensionEditorComposer';
+//# sourceMappingURL=LexicalExtensionEditorComposer.js.map

package/dist/lexical-proxy/@lexical-react/LexicalExtensionEditorComposer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LexicalExtensionEditorComposer.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/LexicalExtensionEditorComposer.tsx"],"sourcesContent":["export * from '@lexical/react/LexicalExtensionEditorComposer'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/LexicalSelectionAlwaysOnDisplay.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/LexicalSelectionAlwaysOnDisplay';
+//# sourceMappingURL=LexicalSelectionAlwaysOnDisplay.d.ts.map

package/dist/lexical-proxy/@lexical-react/LexicalSelectionAlwaysOnDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LexicalSelectionAlwaysOnDisplay.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/LexicalSelectionAlwaysOnDisplay.tsx"],"names":[],"mappings":"AAAA,cAAc,gDAAgD,CAAA"}

package/dist/lexical-proxy/@lexical-react/LexicalSelectionAlwaysOnDisplay.js

@@ -0,0 +1,2 @@
+export * from '@lexical/react/LexicalSelectionAlwaysOnDisplay';
+//# sourceMappingURL=LexicalSelectionAlwaysOnDisplay.js.map

package/dist/lexical-proxy/@lexical-react/LexicalSelectionAlwaysOnDisplay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LexicalSelectionAlwaysOnDisplay.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/LexicalSelectionAlwaysOnDisplay.tsx"],"sourcesContent":["export * from '@lexical/react/LexicalSelectionAlwaysOnDisplay'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/ReactExtension.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/ReactExtension';
+//# sourceMappingURL=ReactExtension.d.ts.map

package/dist/lexical-proxy/@lexical-react/ReactExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactExtension.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/ReactExtension.tsx"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAA"}

package/dist/lexical-proxy/@lexical-react/ReactExtension.js

@@ -0,0 +1,2 @@
+export * from '@lexical/react/ReactExtension';
+//# sourceMappingURL=ReactExtension.js.map

package/dist/lexical-proxy/@lexical-react/ReactExtension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactExtension.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/ReactExtension.tsx"],"sourcesContent":["export * from '@lexical/react/ReactExtension'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/ReactPluginHostExtension.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/ReactPluginHostExtension';
+//# sourceMappingURL=ReactPluginHostExtension.d.ts.map

package/dist/lexical-proxy/@lexical-react/ReactPluginHostExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactPluginHostExtension.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/ReactPluginHostExtension.tsx"],"names":[],"mappings":"AAAA,cAAc,yCAAyC,CAAA"}

package/dist/lexical-proxy/@lexical-react/ReactPluginHostExtension.js

@@ -0,0 +1,2 @@
+export * from '@lexical/react/ReactPluginHostExtension';
+//# sourceMappingURL=ReactPluginHostExtension.js.map

package/dist/lexical-proxy/@lexical-react/ReactPluginHostExtension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactPluginHostExtension.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/ReactPluginHostExtension.tsx"],"sourcesContent":["export * from '@lexical/react/ReactPluginHostExtension'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/ReactProviderExtension.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/ReactProviderExtension';
+//# sourceMappingURL=ReactProviderExtension.d.ts.map

package/dist/lexical-proxy/@lexical-react/ReactProviderExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactProviderExtension.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/ReactProviderExtension.tsx"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAA"}

package/dist/lexical-proxy/@lexical-react/ReactProviderExtension.js

@@ -0,0 +1,2 @@
+export * from '@lexical/react/ReactProviderExtension';
+//# sourceMappingURL=ReactProviderExtension.js.map

package/dist/lexical-proxy/@lexical-react/ReactProviderExtension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactProviderExtension.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/ReactProviderExtension.tsx"],"sourcesContent":["export * from '@lexical/react/ReactProviderExtension'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/TreeViewExtension.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/TreeViewExtension';
+//# sourceMappingURL=TreeViewExtension.d.ts.map

package/dist/lexical-proxy/@lexical-react/TreeViewExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeViewExtension.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/TreeViewExtension.tsx"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAA"}

package/dist/lexical-proxy/@lexical-react/TreeViewExtension.js

@@ -0,0 +1,2 @@
+export * from '@lexical/react/TreeViewExtension';
+//# sourceMappingURL=TreeViewExtension.js.map

package/dist/lexical-proxy/@lexical-react/TreeViewExtension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeViewExtension.js","names":[],"sources":["../../../src/lexical-proxy/@lexical-react/TreeViewExtension.tsx"],"sourcesContent":["export * from '@lexical/react/TreeViewExtension'\n"],"mappings":"AAAA,cAAc","ignoreList":[]}

package/dist/lexical-proxy/@lexical-react/useExtensionComponent.d.ts

@@ -0,0 +1,2 @@
+export * from '@lexical/react/useExtensionComponent';
+//# sourceMappingURL=useExtensionComponent.d.ts.map

package/dist/lexical-proxy/@lexical-react/useExtensionComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExtensionComponent.d.ts","sourceRoot":"","sources":["../../../src/lexical-proxy/@lexical-react/useExtensionComponent.tsx"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAA"}