@etrepum/lexical-builder-markdown 0.0.25

package/README.md

@@ -0,0 +1,3 @@
+# `@etrepum/lexical-builder-markdown`
+
+**EXPERIMENTAL** Lexical Builder Markdown

package/dist/MarkdownExport.d.ts

@@ -0,0 +1,8 @@
+import { ElementNode } from 'lexical';
+import { MarkdownTransformerOptions, TransformersByType } from './types';
+
+/**
+ * Renders string from markdown. The selection is moved to the start after the operation.
+ */
+export declare function createMarkdownExport(byType: TransformersByType, { shouldPreserveNewlines }: MarkdownTransformerOptions): (node?: ElementNode) => string;
+//# sourceMappingURL=MarkdownExport.d.ts.map

package/dist/MarkdownExport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownExport.d.ts","sourceRoot":"","sources":["../src/MarkdownExport.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH,OAAO,KAAK,EACV,WAAW,EAIZ,MAAM,SAAS,CAAC;AAajB,OAAO,KAAK,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE9E;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,kBAAkB,EAC1B,EAAE,sBAAsB,EAAE,EAAE,0BAA0B,GACrD,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,MAAM,CAsChC"}

package/dist/MarkdownImport.d.ts

@@ -0,0 +1,8 @@
+import { ElementNode } from 'lexical';
+import { MarkdownTransformerOptions, TransformersByType } from './types';
+
+/**
+ * Creates an array of ElementNode from the given markdown string
+ */
+export declare function createMarkdownImport(byType: TransformersByType, defaultOptions: MarkdownTransformerOptions): (markdownString: string, options?: MarkdownTransformerOptions) => ElementNode[];
+//# sourceMappingURL=MarkdownImport.d.ts.map

package/dist/MarkdownImport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownImport.d.ts","sourceRoot":"","sources":["../src/MarkdownImport.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAmBH,OAAO,EAML,WAAW,EACZ,MAAM,SAAS,CAAC;AAIjB,OAAO,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AASzE;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,kBAAkB,EAC1B,cAAc,EAAE,0BAA0B,GACzC,CACD,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,0BAA0B,KACjC,WAAW,EAAE,CA0DjB"}

package/dist/MarkdownShortcutsPlan.d.ts

@@ -0,0 +1,13 @@
+import { LexicalEditor } from 'lexical';
+import { TransformersByType } from './types';
+
+export declare function registerMarkdownShortcuts(editor: LexicalEditor, byType: TransformersByType): () => void;
+export interface MarkdownShortcutsConfig {
+    enabled: boolean;
+}
+export interface MarkdownShortcutsOutput {
+    getEnabled: () => boolean;
+    setEnabled: (enabled: boolean) => void;
+}
+export declare const MarkdownShortcutsPlan: import('@etrepum/lexical-builder').LexicalPlan<MarkdownShortcutsConfig, "@etrepum/lexical-builder-markdown/MarkdownShortcuts", MarkdownShortcutsOutput, unknown>;
+//# sourceMappingURL=MarkdownShortcutsPlan.d.ts.map

package/dist/MarkdownShortcutsPlan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownShortcutsPlan.d.ts","sourceRoot":"","sources":["../src/MarkdownShortcutsPlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAQH,OAAO,EAEL,KAAK,aAAa,EAUnB,MAAM,SAAS,CAAC;AAKjB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AA0SlD,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,kBAAkB,GACzB,MAAM,IAAI,CA+FZ;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAC;CAClB;AACD,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,OAAO,CAAC;IAC1B,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;CACxC;AAED,eAAO,MAAM,qBAAqB,kKA6BhC,CAAC"}

package/dist/MarkdownTransformersPlan.d.ts

@@ -0,0 +1,15 @@
+import { createMarkdownImport } from './MarkdownImport';
+import { MarkdownTransformerOptions, TransformersByType } from './types';
+import { createMarkdownExport } from './MarkdownExport';
+
+export type MarkdownTransformersConfig = MarkdownTransformerOptions & {
+    [K in keyof TransformersByType as `${K}Transformers`]: TransformersByType[K];
+};
+export interface MarkdownTransformersOutput {
+    readonly transformerOptions: MarkdownTransformerOptions;
+    readonly transformersByType: TransformersByType;
+    readonly $markdownImport: ReturnType<typeof createMarkdownImport>;
+    readonly $markdownExport: ReturnType<typeof createMarkdownExport>;
+}
+export declare const MarkdownTransformersPlan: import('@etrepum/lexical-builder').LexicalPlan<MarkdownTransformersConfig, "@etrepum/lexical-builder-markdown/MarkdownTransformers", MarkdownTransformersOutput, MarkdownTransformersOutput>;
+//# sourceMappingURL=MarkdownTransformersPlan.d.ts.map

package/dist/MarkdownTransformersPlan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownTransformersPlan.d.ts","sourceRoot":"","sources":["../src/MarkdownTransformersPlan.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAGxD,MAAM,MAAM,0BAA0B,GAAG,0BAA0B,GAAG;KACnE,CAAC,IAAI,MAAM,kBAAkB,IAAI,GAAG,CAAC,cAAc,GAAG,kBAAkB,CAAC,CAAC,CAAC;CAC7E,CAAC;AASF,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,kBAAkB,EAAE,0BAA0B,CAAC;IACxD,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAC;IAChD,QAAQ,CAAC,eAAe,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;IAClE,QAAQ,CAAC,eAAe,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;CACnE;AAED,eAAO,MAAM,wBAAwB,8LAuCnC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+export { type MarkdownTransformerOptions, type TransformersByType, } from './types';
+export { type MarkdownTransformersConfig, type MarkdownTransformersOutput, MarkdownTransformersPlan, } from './MarkdownTransformersPlan';
+export declare const PACKAGE_VERSION: string;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,kBAAkB,GACxB,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,0BAA0B,EAC/B,wBAAwB,GACzB,MAAM,4BAA4B,CAAC;AACpC,eAAO,MAAM,eAAe,EAAE,MAAwC,CAAC"}

package/dist/index.js

@@ -0,0 +1,365 @@
+import { definePlan as b, RichTextPlan as L, safeCast as D, getKnownTypesAndNodes as y, provideOutput as j } from "@etrepum/lexical-builder";
+import { ELEMENT_TRANSFORMERS as z, TEXT_FORMAT_TRANSFORMERS as K, TEXT_MATCH_TRANSFORMERS as W } from "@lexical/markdown";
+import { $createCodeNode as X } from "@lexical/code";
+import { $isListNode as x, $isListItemNode as G } from "@lexical/list";
+import { $isQuoteNode as U } from "@lexical/rich-text";
+import { $findMatchingParent as H, IS_SAFARI as N, IS_IOS as E, IS_APPLE_WEBKIT as $ } from "@lexical/utils";
+import { $getSelection as S, $setSelection as Q, $isParagraphNode as P, $isTextNode as p, $createParagraphNode as _, $isElementNode as m, $createTextNode as F, $createLineBreakNode as V, $isRootOrShadowRoot as Y, $getRoot as q, $isDecoratorNode as k, $isLineBreakNode as J } from "lexical";
+const R = /[!-/:-@[-`{-~\s]/, Z = /^\s{0,3}$/;
+function T(e) {
+  if (!P(e))
+    return !1;
+  const t = e.getFirstChild();
+  return t == null || e.getChildrenSize() === 1 && p(t) && Z.test(t.getTextContent());
+}
+function ee(e) {
+  return function(...n) {
+    const i = S(), s = i ? i.clone() : null, r = e(...n), c = S(), o = s && s.is(i) && !Object.isFrozen(i) ? i : s;
+    return c !== o && Q(o), r;
+  };
+}
+function u(e, t, ...n) {
+  if (!e)
+    throw new Error(
+      n.reduce((i, s) => i.replace("%s", String(s)), t || "")
+    );
+}
+const w = /^[ \t]*```(\w{1,10})?\s?$/;
+function te(e, t) {
+  const n = ie(
+    e.textFormat || []
+  );
+  return function(s, { shouldPreserveNewlines: r } = t) {
+    const c = s.split(`
+`), o = c.length, l = _();
+    for (let f = 0; f < o; f++) {
+      const A = c[f], [B, I] = oe(c, f, l);
+      if (B != null) {
+        f = I;
+        continue;
+      }
+      ne(
+        A,
+        l,
+        e.element,
+        n,
+        e.textMatch
+      );
+    }
+    const a = [];
+    for (let f = l.getFirstChild(); f; f = f.getNextSibling())
+      u(
+        m(f),
+        "markdownImport: Expected child of type %s to be an ElementNode",
+        f.getType()
+      ), (r || !T(f)) && a.push(f);
+    return l.clear(), a;
+  };
+}
+function ne(e, t, n, i, s) {
+  const r = e.trim(), c = F(r), o = _();
+  o.append(c), t.append(o);
+  for (const { regExp: l, replace: a } of n) {
+    const f = e.match(l);
+    if (f) {
+      c.setTextContent(e.slice(f[0].length)), a(o, [c], f, !0);
+      break;
+    }
+  }
+  if (d(
+    c,
+    i,
+    s
+  ), o.isAttached() && r.length > 0) {
+    const l = o.getPreviousSibling();
+    if (P(l) || U(l) || x(l)) {
+      let a = l;
+      if (x(l)) {
+        const f = l.getLastDescendant();
+        f == null ? a = null : a = H(f, G);
+      }
+      a != null && a.getTextContentSize() > 0 && (a.splice(a.getChildrenSize(), 0, [
+        V(),
+        ...o.getChildren()
+      ]), o.remove());
+    }
+  }
+}
+function oe(e, t, n) {
+  const i = e[t].match(w);
+  if (i) {
+    let s = t;
+    const r = e.length;
+    for (; ++s < r; )
+      if (e[s].match(w)) {
+        const o = X(i[1]), l = F(
+          e.slice(t + 1, s).join(`
+`)
+        );
+        return o.append(l), n.append(o), [o, s];
+      }
+  }
+  return [null, t];
+}
+function d(e, t, n) {
+  const i = e.getTextContent(), s = re(i, t);
+  if (!s) {
+    O(e, n);
+    return;
+  }
+  u(
+    s[1] !== void 0 && s[2] !== void 0,
+    "importTextMatchTransformers: expecting match with two groups"
+  );
+  let r, c, o;
+  if (s[0] === i)
+    r = e;
+  else {
+    const a = s.index || 0, f = a + s[0].length;
+    a === 0 ? [r, c] = e.splitText(f) : [o, r, c] = e.splitText(
+      a,
+      f
+    );
+  }
+  u(
+    r !== void 0,
+    "importTextMatchTransformers: currentNode must be defined"
+  ), r.setTextContent(s[2]);
+  const l = t.transformersByTag[s[1]];
+  if (l)
+    for (const a of l.format)
+      r.hasFormat(a) || r.toggleFormat(a);
+  r.hasFormat("code") || d(
+    r,
+    t,
+    n
+  ), o && d(
+    o,
+    t,
+    n
+  ), c && d(
+    c,
+    t,
+    n
+  );
+}
+function O(e, t) {
+  let n = e;
+  e:
+    for (; n; ) {
+      for (const i of t) {
+        const s = n.getTextContent().match(i.importRegExp);
+        if (!s)
+          continue;
+        const r = s.index || 0, c = r + s[0].length;
+        let o, l;
+        if (r === 0) {
+          const a = n.splitText(c);
+          u(
+            a[0] !== void 0 && a[1] !== void 0,
+            "importTextMatchTransformers: splitText expected two nodes"
+          ), [o, n] = a;
+        } else {
+          const a = n.splitText(r, c);
+          u(
+            a[1] !== void 0 && a[2] !== void 0,
+            "importTextMatchTransformers: splitText expected three nodes"
+          ), [, o, l] = a, l && O(l, t);
+        }
+        i.replace(o, s);
+        continue e;
+      }
+      break;
+    }
+}
+function re(e, t) {
+  const n = e.match(t.openTagsRegExp);
+  if (n == null)
+    return null;
+  for (const i of n) {
+    const s = i.replace(/^\s/, ""), r = t.fullMatchRegExpByTag[s];
+    if (r == null)
+      continue;
+    const c = e.match(r), o = t.transformersByTag[s];
+    if (c != null && o != null) {
+      if (o.intraword !== !1)
+        return c;
+      const { index: l = 0 } = c, a = e[l - 1], f = e[l + c[0].length];
+      if ((!a || R.test(a)) && (!f || R.test(f)))
+        return c;
+    }
+  }
+  return null;
+}
+function ie(e) {
+  const t = {}, n = {}, i = [], s = "(?<![\\\\])";
+  for (const r of e) {
+    const { tag: c } = r;
+    t[c] = r;
+    const o = c.replace(/(\*|\^|\+)/g, "\\$1");
+    i.push(o), N || E || $ ? n[c] = new RegExp(
+      `(${o})(?![${o}\\s])(.*?[^${o}\\s])${o}(?!${o})`
+    ) : n[c] = new RegExp(
+      `(?<![\\\\${o}])(${o})((\\\\${o})?.*?[^${o}\\s](\\\\${o})?)((?<!\\\\)|(?<=\\\\\\\\))(${o})(?![\\\\${o}])`
+    );
+  }
+  return {
+    // Reg exp to find open tag + content + close tag
+    fullMatchRegExpByTag: n,
+    // Reg exp to find opening tags
+    openTagsRegExp: new RegExp(
+      (N || E || $ ? "" : `${s}`) + "(" + i.join("|") + ")",
+      "g"
+    ),
+    transformersByTag: t
+  };
+}
+function se(e, { shouldPreserveNewlines: t }) {
+  const n = !t, i = e.textFormat.filter(
+    (s) => s.format.length === 1
+  );
+  return function(r = q()) {
+    const c = [], o = Y(r) ? r.getChildren() : [r];
+    for (let l = 0; l < o.length; l++) {
+      const a = o[l], f = ce(
+        a,
+        e.element,
+        i,
+        e.textMatch
+      );
+      f != null && c.push(
+        // separate consecutive group of texts with a line break: eg. ["hello", "world"] -> ["hello", "\nworld"]
+        n && l > 0 && !T(a) && !T(o[l - 1]) ? `
+`.concat(f) : f
+      );
+    }
+    return c.join(`
+`);
+  };
+}
+function ce(e, t, n, i) {
+  for (const s of t) {
+    const r = s.export(
+      e,
+      (c) => g(c, n, i)
+    );
+    if (r != null)
+      return r;
+  }
+  return m(e) ? g(e, n, i) : k(e) ? e.getTextContent() : null;
+}
+function g(e, t, n) {
+  const i = [], s = e.getChildren();
+  e:
+    for (const r of s) {
+      for (const c of n) {
+        const o = c.export(
+          r,
+          (l) => g(
+            l,
+            t,
+            n
+          ),
+          (l, a) => C(l, a, t)
+        );
+        if (o != null) {
+          i.push(o);
+          continue e;
+        }
+      }
+      J(r) ? i.push(`
+`) : p(r) ? i.push(
+        C(r, r.getTextContent(), t)
+      ) : m(r) ? i.push(
+        g(r, t, n)
+      ) : k(r) && i.push(r.getTextContent());
+    }
+  return i.join("");
+}
+function C(e, t, n) {
+  const i = t.trim();
+  let s = i;
+  const r = /* @__PURE__ */ new Set();
+  for (const c of n) {
+    const o = c.format[0], l = c.tag;
+    if (u(
+      o !== void 0,
+      "TextFormatTransformer for tag %s has empty format array",
+      l
+    ), h(e, o) && !r.has(o)) {
+      r.add(o);
+      const a = v(e, !0);
+      h(a, o) || (s = l + s);
+      const f = v(e, !1);
+      h(f, o) || (s += l);
+    }
+  }
+  return t.replace(i, () => s);
+}
+function v(e, t) {
+  let n = t ? e.getPreviousSibling() : e.getNextSibling();
+  if (!n) {
+    const i = e.getParentOrThrow();
+    i.isInline() && (n = t ? i.getPreviousSibling() : i.getNextSibling());
+  }
+  for (; n; ) {
+    if (m(n)) {
+      if (!n.isInline())
+        break;
+      const i = t ? n.getLastDescendant() : n.getFirstDescendant();
+      if (p(i))
+        return i;
+      n = t ? n.getPreviousSibling() : n.getNextSibling();
+    }
+    if (p(n))
+      return n;
+    if (!m(n))
+      return null;
+  }
+  return null;
+}
+function h(e, t) {
+  return p(e) && e.hasFormat(t);
+}
+function M({ nodes: e }, t) {
+  const n = e.has.bind(e);
+  return t.filter((i) => i.dependencies.every(n));
+}
+const ge = b({
+  name: "@etrepum/lexical-builder-markdown/MarkdownTransformers",
+  dependencies: [L],
+  config: D({
+    elementTransformers: z,
+    textFormatTransformers: K,
+    textMatchTransformers: W,
+    shouldPreserveNewlines: !1
+  }),
+  // For now we replace the transformer arrays with the default
+  // shallowMergeConfig. I think ideally these should be additive
+  init(e, t, n) {
+    const i = y(e), s = {
+      shouldPreserveNewlines: t.shouldPreserveNewlines
+    }, r = {
+      // Only register transforms for nodes that are configured
+      element: M(i, t.elementTransformers),
+      textMatch: M(i, t.textMatchTransformers),
+      textFormat: t.textFormatTransformers
+    }, c = ee(
+      te(r, s)
+    ), o = se(
+      r,
+      s
+    );
+    return {
+      transformerOptions: s,
+      transformersByType: r,
+      $markdownExport: o,
+      $markdownImport: c
+    };
+  },
+  register: (e, t, n) => j(n.getInitResult())
+}), he = "0.0.25";
+export {
+  ge as MarkdownTransformersPlan,
+  he as PACKAGE_VERSION
+};

package/dist/shared/invariant.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+export default function invariant(cond?: boolean, message?: string, ...args: string[]): asserts cond;
+//# sourceMappingURL=invariant.d.ts.map

package/dist/shared/invariant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invariant.d.ts","sourceRoot":"","sources":["../../src/shared/invariant.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,IAAI,CAAC,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,MAAM,EAChB,GAAG,IAAI,EAAE,MAAM,EAAE,GAChB,OAAO,CAAC,IAAI,CAQd"}

package/dist/types.d.ts

@@ -0,0 +1,14 @@
+import { Transformer } from '@lexical/markdown';
+
+export interface MarkdownTransformerOptions {
+    shouldPreserveNewlines: boolean;
+}
+type Filter<T, U> = T extends U ? T : never;
+type KebabToCamel<S extends string> = S extends `${infer T}-${infer U}` ? `${T}${Capitalize<KebabToCamel<U>>}` : S;
+export type TransformersByType = {
+    readonly [K in Transformer["type"] as KebabToCamel<K>]: Filter<Transformer, {
+        type: K;
+    }>[];
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,MAAM,WAAW,0BAA0B;IACzC,sBAAsB,EAAE,OAAO,CAAC;CACjC;AAED,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAC5C,KAAK,YAAY,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,IAAI,MAAM,CAAC,EAAE,GACnE,GAAG,CAAC,GAAG,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,EAAE,GACpC,CAAC,CAAC;AAEN,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,CAAC,IAAI,WAAW,CAAC,MAAM,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,GAAG,MAAM,CAC5D,WAAW,EACX;QAAE,IAAI,EAAE,CAAC,CAAA;KAAE,CACZ,EAAE;CACJ,CAAC"}

package/dist/utils.d.ts

@@ -0,0 +1,21 @@
+import { ParagraphNode, Spread, LexicalNode } from 'lexical';
+
+export declare function indexBy<T>(list: Array<T>, callback: (arg0: T) => string): Readonly<Record<string, Array<T>>>;
+export declare const PUNCTUATION_OR_SPACE: RegExp;
+declare const EmptyParagraphNodeBrand: unique symbol;
+export declare function $isEmptyParagraph(node: LexicalNode | undefined | null): node is Spread<{
+    [EmptyParagraphNodeBrand]: never;
+}, ParagraphNode>;
+/**
+ * Run a update function but make sure it does not change the selection.
+ * This is useful for when you know that the selection should not change,
+ * the update will not change any content under the selection, but the
+ * update you're running includes selection modifications that you do not
+ * want.
+ *
+ * This is useful because the existing @lexical/markdown importers
+ * mangle the selection because of legacy mistakes.
+ */
+export declare function $wrapWithIgnoreSelection<Parameters extends any[], Returns>($update: (...args: Parameters) => Returns): (...args: Parameters) => Returns;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,MAAM,EACX,KAAK,WAAW,EAGjB,MAAM,SAAS,CAAC;AAEjB,wBAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EACd,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAC5B,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAcpC;AAED,eAAO,MAAM,oBAAoB,QAAqB,CAAC;AAIvD,QAAA,MAAM,uBAAuB,EAAE,OAAO,MAErC,CAAC;AAEF,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI,GACnC,IAAI,IAAI,MAAM,CAAC;IAAE,CAAC,uBAAuB,CAAC,EAAE,KAAK,CAAA;CAAE,EAAE,aAAa,CAAC,CAYrE;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,SAAS,GAAG,EAAE,EAAE,OAAO,EACxE,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,UAAU,KAAK,OAAO,GACxC,CAAC,GAAG,IAAI,EAAE,UAAU,KAAK,OAAO,CAqBlC"}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@etrepum/lexical-builder-markdown",
+  "description": "[EXPERIMENTAL] Lexical Builder @etrepum/lexical-builder-markdown",
+  "type": "module",
+  "keywords": [
+    "lexical",
+    "lexical-builder",
+    "plug-in",
+    "plan",
+    "markdown"
+  ],
+  "scripts": {
+    "build": "tsc --noEmit && vite build",
+    "dev": "vite",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "version": "0.0.25",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/etrepum/lexical-builder.git",
+    "directory": "packages/lexical-builder-markdown"
+  },
+  "bugs": {
+    "url": "https://github.com/etrepum/lexical-builder/issues"
+  },
+  "homepage": "https://github.com/etrepum/lexical-builder",
+  "dependencies": {
+    "@etrepum/lexical-builder": "*"
+  },
+  "peerDependencies": {
+    "lexical": ">=0.16.0-0",
+    "@lexical/code": ">=0.16.0-0",
+    "@lexical/list": ">=0.16.0-0",
+    "@lexical/markdown": ">=0.16.0-0",
+    "@lexical/rich-text": ">=0.16.0-0",
+    "@lexical/utils": ">=0.16.0-0"
+  },
+  "sideEffects": false,
+  "devDependencies": {
+    "@testing-library/dom": "^10.1.0",
+    "@testing-library/jest-dom": "^6.4.5",
+    "@testing-library/user-event": "^14.5.2",
+    "jsdom": "^24.1.0",
+    "tslib": "^2.6.2",
+    "typescript": "^5.4.5",
+    "vite": "^5.2.11",
+    "vite-plugin-dts": "^3.9.1",
+    "vite-plugin-package-version": "^1.1.0",
+    "vitest": "^1.6.0"
+  },
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ]
+}