@mdxeditor/editor 1.14.3 → 2.0.0

package/dist/gurx/realm.js

@@ -1,489 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-import { tap } from "../utils/fp.js";
-import { uuidv4 } from "../utils/uuid4.js";
-function defaultComparator(current, next) {
-  return current === next;
-}
-class SetMap {
-  constructor() {
-    __publicField(this, "map", /* @__PURE__ */ new Map());
-  }
-  getOrCreate(key) {
-    let record = this.map.get(key);
-    if (!record) {
-      record = /* @__PURE__ */ new Set();
-      this.map.set(key, record);
-    }
-    return record;
-  }
-  get(key) {
-    return this.map.get(key);
-  }
-  use(key, cb) {
-    const set = this.get(key);
-    if (set !== void 0) {
-      cb(set);
-    }
-  }
-  delete(key) {
-    return this.map.delete(key);
-  }
-}
-class RefCount {
-  constructor(map = /* @__PURE__ */ new Map()) {
-    __publicField(this, "map");
-    this.map = map;
-  }
-  clone() {
-    return new RefCount(new Map(this.map));
-  }
-  increment(key) {
-    const counter = this.map.get(key) ?? 0;
-    this.map.set(key, counter + 1);
-  }
-  decrement(key, ifZero) {
-    let counter = this.map.get(key);
-    if (counter !== void 0) {
-      counter -= 1;
-      this.map.set(key, counter);
-      if (counter === 0) {
-        ifZero();
-      }
-    }
-  }
-}
-const NO_VALUE = Symbol("NO_VALUE");
-function realm() {
-  const subscriptions = new SetMap();
-  const singletonSubscriptions = /* @__PURE__ */ new Map();
-  const graph = new SetMap();
-  const state = /* @__PURE__ */ new Map();
-  const distinctNodes = /* @__PURE__ */ new Map();
-  const labels = {};
-  function node(value = NO_VALUE, distinct = false) {
-    const key = uuidv4();
-    if (value !== NO_VALUE) {
-      state.set(key, value);
-    }
-    if (distinct !== false) {
-      distinctNodes.set(key, distinct === true ? defaultComparator : distinct);
-    }
-    return { key, toString: () => key };
-  }
-  function subSingle({ key }, subscription) {
-    const nodeSubscriptions = subscriptions.getOrCreate(key);
-    nodeSubscriptions.add(subscription);
-    return () => nodeSubscriptions.delete(subscription);
-  }
-  function singletonSub({ key }, subscription) {
-    if (!subscription) {
-      singletonSubscriptions.delete(key);
-    } else {
-      singletonSubscriptions.set(key, subscription);
-    }
-    return () => singletonSubscriptions.delete(key);
-  }
-  function singletonSubKey(key, subscription) {
-    return singletonSub(labels[key], subscription);
-  }
-  function resetSingletonSubs() {
-    singletonSubscriptions.clear();
-  }
-  function subMultiple(sources, cb) {
-    const sink = node();
-    connect({
-      map: (done) => (...args) => {
-        done(args);
-      },
-      sink,
-      sources
-    });
-    return subSingle(sink, cb);
-  }
-  function sub(...args) {
-    const [subscription] = args.slice(-1);
-    const nodes = args.slice(0, -1);
-    if (nodes.length === 1) {
-      return subSingle(nodes[0], subscription);
-    } else {
-      return subMultiple(nodes, subscription);
-    }
-  }
-  function calculateExecutionMap(keys) {
-    const participatingNodeKeys = [];
-    const visitedNodes = /* @__PURE__ */ new Set();
-    const pendingPulls = new SetMap();
-    const refCount = new RefCount();
-    const projections = new SetMap();
-    function visit(key, insertIndex = 0) {
-      refCount.increment(key);
-      if (visitedNodes.has(key)) {
-        return;
-      }
-      pendingPulls.use(key, (pulls) => {
-        insertIndex = Math.max(...Array.from(pulls).map((key2) => participatingNodeKeys.indexOf(key2))) + 1;
-      });
-      graph.use(key, (sinkProjections) => {
-        sinkProjections.forEach((projection) => {
-          if (projection.sources.has(key)) {
-            projections.getOrCreate(projection.sink).add(projection);
-            visit(projection.sink, insertIndex);
-          } else {
-            pendingPulls.getOrCreate(projection.sink).add(key);
-          }
-        });
-      });
-      visitedNodes.add(key);
-      participatingNodeKeys.splice(insertIndex, 0, key);
-    }
-    keys.forEach((key) => visit(key));
-    return { participatingNodeKeys, pendingPulls, projections, refCount };
-  }
-  const executionMaps = /* @__PURE__ */ new Map();
-  function pubIn(values) {
-    var _a;
-    const keys = Object.keys(values);
-    const executionMapKey = keys.join(",");
-    if (!executionMaps.has(executionMapKey)) {
-      executionMaps.set(executionMapKey, calculateExecutionMap(keys));
-    }
-    const map2 = executionMaps.get(executionMapKey);
-    const refCount = map2.refCount.clone();
-    const participatingNodeKeys = map2.participatingNodeKeys.slice();
-    const transientState = new Map(state);
-    function nodeWillNotEmit(key) {
-      graph.use(key, (projections) => {
-        projections.forEach(({ sources, sink }) => {
-          if (sources.has(key)) {
-            refCount.decrement(sink, () => {
-              participatingNodeKeys.splice(participatingNodeKeys.indexOf(sink), 1);
-              nodeWillNotEmit(sink);
-            });
-          }
-        });
-      });
-    }
-    let nodeKey;
-    while (nodeKey = participatingNodeKeys.shift()) {
-      let resolved = false;
-      const done = (value) => {
-        if (distinctNodes.has(nodeKey) && distinctNodes.get(nodeKey)(state.get(nodeKey), value)) {
-          resolved = false;
-          return;
-        }
-        resolved = true;
-        transientState.set(nodeKey, value);
-        if (state.has(nodeKey)) {
-          state.set(nodeKey, value);
-        }
-      };
-      if (Object.prototype.hasOwnProperty.call(values, nodeKey)) {
-        done(values[nodeKey]);
-      } else {
-        map2.projections.use(nodeKey, (nodeProjections) => {
-          nodeProjections.forEach((projection) => {
-            const args = [...Array.from(projection.sources), ...Array.from(projection.pulls)].map((id) => transientState.get(id));
-            projection.map(done)(...args);
-          });
-        });
-      }
-      if (resolved) {
-        const value = transientState.get(nodeKey);
-        subscriptions.use(nodeKey, (nodeSubscriptions) => {
-          nodeSubscriptions.forEach((subscription) => subscription(value));
-        });
-        (_a = singletonSubscriptions.get(nodeKey)) == null ? void 0 : _a(value);
-      } else {
-        nodeWillNotEmit(nodeKey);
-      }
-    }
-  }
-  function nodesToKeySet(nodes) {
-    return new Set(nodes.map((s) => s.key));
-  }
-  function connect({ sources, pulls = [], map: map2, sink: { key: sink } }) {
-    const dependency = {
-      map: map2,
-      pulls: nodesToKeySet(pulls),
-      sink,
-      sources: nodesToKeySet(sources)
-    };
-    [...sources, ...pulls].forEach(({ key: sourceKey }) => {
-      graph.getOrCreate(sourceKey).add(dependency);
-    });
-    executionMaps.clear();
-  }
-  function pub(...args) {
-    const map2 = {};
-    for (let index = 0; index < args.length; index += 2) {
-      const node2 = args[index];
-      map2[node2.key] = args[index + 1];
-    }
-    pubIn(map2);
-  }
-  function label(newLabels) {
-    Object.assign(labels, newLabels);
-  }
-  function pipe(source, ...operators) {
-    for (const operator of operators) {
-      source = operator(source);
-    }
-    return source;
-  }
-  function spread(source, initialValues) {
-    return initialValues.map((initialValue, index) => {
-      return tap(node(initialValue, true), (sink) => {
-        connect({
-          map: (done) => (sourceValue) => {
-            done(sourceValue[index]);
-          },
-          sink,
-          sources: [source]
-        });
-      });
-    });
-  }
-  function link(source, sink) {
-    connect({ map: (done) => (value) => done(value), sink, sources: [source] });
-  }
-  function derive(source, initial) {
-    return tap(node(initial, true), (sink) => {
-      connect({ map: (done) => (value) => done(value), sink, sources: [source] });
-    });
-  }
-  function map(mapFunction) {
-    return (source) => {
-      const sink = node();
-      connect({
-        map: (done) => (value) => {
-          done(mapFunction(value));
-        },
-        sink,
-        sources: [source]
-      });
-      return sink;
-    };
-  }
-  function mapTo(value) {
-    return (source) => {
-      const sink = node();
-      connect({ map: (done) => () => done(value), sink, sources: [source] });
-      return sink;
-    };
-  }
-  function filter(predicate) {
-    return (source) => {
-      const sink = node();
-      connect({ map: (done) => (value) => predicate(value) && done(value), sink, sources: [source] });
-      return sink;
-    };
-  }
-  function once() {
-    return (source) => {
-      const sink = node();
-      let passed = false;
-      connect({
-        map: (done) => (value) => {
-          if (!passed) {
-            passed = true;
-            done(value);
-          }
-        },
-        sink,
-        sources: [source]
-      });
-      return sink;
-    };
-  }
-  function scan(accumulator, seed) {
-    return (source) => {
-      const sink = node();
-      connect({ map: (done) => (value) => done(seed = accumulator(seed, value)), sink, sources: [source] });
-      return sink;
-    };
-  }
-  function throttleTime(delay) {
-    return (source) => {
-      const sink = node();
-      let currentValue;
-      let timeout;
-      sub(source, (value) => {
-        currentValue = value;
-        if (timeout) {
-          return;
-        }
-        timeout = setTimeout(() => {
-          timeout = void 0;
-          pub(sink, currentValue);
-        }, delay);
-      });
-      return sink;
-    };
-  }
-  function delayWithMicrotask() {
-    return (source) => {
-      const sink = node();
-      sub(source, (value) => queueMicrotask(() => pub(sink, value)));
-      return sink;
-    };
-  }
-  function debounceTime(delay) {
-    return (source) => {
-      const sink = node();
-      let currentValue;
-      let timeout;
-      sub(source, (value) => {
-        currentValue = value;
-        if (timeout) {
-          clearTimeout(timeout);
-        }
-        timeout = setTimeout(() => {
-          pub(sink, currentValue);
-        }, delay);
-      });
-      return sink;
-    };
-  }
-  function onNext(bufNode) {
-    return (source) => {
-      const sink = node();
-      let pendingValue = NO_VALUE;
-      sub(source, (value) => pendingValue = value);
-      connect({
-        map: (done) => (value) => {
-          if (pendingValue !== NO_VALUE) {
-            done([pendingValue, value]);
-            pendingValue = NO_VALUE;
-          }
-        },
-        sink,
-        sources: [bufNode]
-      });
-      return sink;
-    };
-  }
-  function passOnlyAfterNodeHasEmittedBefore(starterNode, durationNode) {
-    return (source) => {
-      const sink = node();
-      let startTime = 0;
-      sub(starterNode, () => startTime = Date.now());
-      connect({
-        map: (done) => (value) => {
-          if (Date.now() < startTime + state.get(durationNode.key)) {
-            done(value);
-          }
-        },
-        sink,
-        sources: [source]
-      });
-      return sink;
-    };
-  }
-  function withLatestFrom(...nodes) {
-    return (source) => {
-      const sink = node();
-      connect({
-        map: (done) => (...args) => done(args),
-        pulls: nodes,
-        sink,
-        sources: [source]
-      });
-      return sink;
-    };
-  }
-  function combine(...nodes) {
-    const sink = node();
-    connect({
-      map: (done) => (...args) => done(args),
-      sink,
-      sources: nodes
-    });
-    return sink;
-  }
-  function subKey(key, subscription) {
-    return sub(labels[key], subscription);
-  }
-  function subKeys(keys, subscription) {
-    const nodes = keys.map((key) => labels[key]);
-    return sub(...nodes.concat(subscription));
-  }
-  function pubKey(key, value) {
-    pubKeys({ [key]: value });
-  }
-  function pubKeys(values) {
-    const valuesWithInternalKeys = Object.entries(values).reduce(
-      (acc, [key, value]) => tap(acc, (acc2) => {
-        const label2 = labels[key];
-        if (!label2) {
-          throw new Error(`No label for key ${key}. Do you miss a plugin?`);
-        }
-        acc2[label2.key] = value;
-        return value;
-      }),
-      {}
-    );
-    pubIn(valuesWithInternalKeys);
-  }
-  function getKeyValue(key) {
-    return state.get(labels[key].key);
-  }
-  function getValue(node2) {
-    return state.get(node2.key);
-  }
-  function getKeyValues(keys) {
-    return keys.map((key) => {
-      const label2 = labels[key];
-      if (!label2) {
-        throw new Error(`No label for key ${key}. Do you miss a plugin?`);
-      }
-      return state.get(label2.key);
-    });
-  }
-  return {
-    combine,
-    connect,
-    derive,
-    getKeyValue,
-    getValue,
-    getKeyValues,
-    label,
-    labels,
-    link,
-    node,
-    o: {
-      delayWithMicrotask,
-      debounceTime,
-      filter,
-      map,
-      mapTo,
-      onNext,
-      scan,
-      throttleTime,
-      withLatestFrom,
-      once,
-      passOnlyAfterNodeHasEmittedBefore
-    },
-    pipe,
-    pub,
-    pubIn,
-    pubKey,
-    pubKeys,
-    resetSingletonSubs,
-    singletonSub,
-    singletonSubKey,
-    spread,
-    sub,
-    subKey,
-    subKeys
-  };
-}
-export {
-  RefCount,
-  defaultComparator,
-  realm
-};

package/dist/gurx/realmFactory.d.ts

@@ -1,79 +0,0 @@
-import { Realm, RealmNode, Subscription, UnsubscribeHandle } from './realm';
-/**
- * The system interface is the runtime representation of a state management module, a record of nodes.
- */
-export interface System {
-    [key: string]: RealmNode<any>;
-}
-/**
- * a SystemSpec is the result from a [[system]] call. To obtain the [[system]], pass the spec to [[init]].
- * @typeParam Dependencies - The dependencies of the system.
- * @typeParam Constructor - The system constructor.
- */
-export interface SystemSpec<Dependencies extends AnySystemSpecs, /** @internal */ Constructor extends SystemConstructor<Dependencies>> {
-    id: string;
-    constructor: Constructor;
-    dependencies: Dependencies;
-}
-/** @internal **/
-export interface AnySystemSpec extends SystemSpec<AnySystemSpecs, any> {
-    id: string;
-}
-/** @internal **/
-export type AnySystemSpecs = Array<AnySystemSpec>;
-/** @internal **/
-export type SystemOfSpec<Spec extends AnySystemSpec> = ReturnType<Spec['constructor']>;
-/** @internal **/
-export type SSR<Spec extends AnySystemSpec> = SystemOfSpec<Spec>;
-/** @internal **/
-export type SystemsFromSpecs<ST extends AnySystemSpecs> = ST extends unknown[] ? SystemsFromSpecsRec<ST, []> : never;
-type SystemsFromSpecsRec<ST extends unknown[], Acc extends unknown[]> = ST extends [infer Head, ...infer Tail] ? SystemsFromSpecsRec<Tail, [...Acc, Head extends AnySystemSpec ? SystemOfSpec<Head> : never]> : Acc;
-/**
- * The system constructor is a function which initializes and connects nodes and returns them as a [[system]].
- * If the [[system]] call specifies system dependencies, the constructor receives the dependencies as an array argument.
- */
-export interface SystemConstructor<D extends AnySystemSpecs> {
-    (r: Realm, dependencies: SystemsFromSpecs<D>): System;
-}
-/**
- * Declare a new state management module (system). The constructor receives the realm and the dependencies as arguments.
- * @param constructor - The system constructor.
- * @param dependencies - The dependencies of the system - other systems.
- */
-export declare function system<Dependencies extends LongTuple<AnySystemSpec>, Constructor extends SystemConstructor<Dependencies>>(constructor: Constructor, dependencies?: Dependencies): SystemSpec<Dependencies, Constructor>;
-type SystemKey<S extends System> = Extract<keyof S, string>;
-/** @internal */
-export type ValuesForKeys<S extends System, K extends SystemKey<S>[]> = K extends unknown[] ? ValuesForKeysRec<S, K, []> : never;
-type ValuesForKeysRec<S extends Record<any, RealmNode>, K extends unknown[], Acc extends unknown[]> = K extends [infer Head, ...infer Tail] ? ValuesForKeysRec<S, Tail, [...Acc, S[Head] extends RealmNode<infer R> ? R : never]> : Acc;
-/** @internal **/
-export type SystemOfSpecs<Specs extends AnySystemSpec[]> = Specs extends unknown[] ? SystemOfSpecsRec<Specs, {}> : Specs;
-type SystemOfSpecsRec<Specs extends unknown[], Acc extends {}> = Specs extends [infer Head, ...infer Tail] ? SystemOfSpecsRec<Tail, Head extends AnySystemSpec ? Acc & SystemOfSpec<Head> : never> : Acc;
-/** @internal */
-export type LongTuple<K> = [] | [K] | [K, K] | [K, K, K] | [K, K, K, K] | [K, K, K, K, K] | [K, K, K, K, K, K] | [K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K];
-/** @internal */
-export type SystemKeys<S extends System, K extends Extract<keyof S, string> = Extract<keyof S, string>> = LongTuple<K>;
-/** @internal */
-export type ValueForKey<S extends System, K extends keyof S> = S[K] extends RealmNode<infer V> ? V : never;
-/** @internal */
-export type SystemDict<S extends System> = {
-    [K in keyof S]?: ValueForKey<S, K>;
-};
-/** @internal */
-export type SystemKeysArray<S extends System> = Array<keyof S>;
-/** @internal */
-export interface TypedRealm<S extends System> extends Pick<Realm, 'sub' | 'pub' | 'spread' | 'derive' | 'singletonSubKey' | 'resetSingletonSubs'> {
-    getKeyValues<K extends SystemKeys<S>>(keys: K): ValuesForKeys<S, K>;
-    getKeyValue<K extends keyof S>(key: K): ValueForKey<S, K>;
-    labels: S;
-    pubKey<K extends keyof S>(key: K, value: ValueForKey<S, K>): void;
-    pubKeys: (values: SystemDict<S>) => void;
-    subKey<K extends keyof S>(key: K, subscription: Subscription<ValueForKey<S, K>>): UnsubscribeHandle;
-    subKeys<K extends SystemKeys<S>>(keys: K, subscription: Subscription<ValuesForKeys<S, K>>): UnsubscribeHandle;
-}
-/** @internal */
-export declare function realmFactory<Specs extends LongTuple<AnySystemSpec>>(...specs: Specs): TypedRealm<SystemOfSpecs<Specs>>;
-/** @internal */
-export type RealmFactory<Sys extends System> = () => TypedRealm<Sys>;
-/** @internal */
-export declare function getRealmFactory<Specs extends LongTuple<AnySystemSpec>>(...specs: Specs): () => TypedRealm<SystemOfSpecs<[...Specs]>>;
-export {};

package/dist/gurx/realmFactory.js

@@ -1,32 +0,0 @@
-import { uuidv4 } from "../utils/uuid4.js";
-import { realm } from "./realm.js";
-function system(constructor, dependencies = []) {
-  return {
-    constructor,
-    dependencies,
-    id: uuidv4()
-  };
-}
-function realmFactory(...specs) {
-  const singletons = /* @__PURE__ */ new Map();
-  const r = realm();
-  const _init = ({ id, constructor, dependencies }) => {
-    if (singletons.has(id)) {
-      return singletons.get(id);
-    }
-    const system2 = constructor(r, dependencies.map((t) => _init(specs.find((spec) => spec.id === t.id))));
-    r.label(system2);
-    singletons.set(id, system2);
-    return system2;
-  };
-  specs.forEach(_init);
-  return r;
-}
-function getRealmFactory(...specs) {
-  return () => realmFactory(...specs);
-}
-export {
-  getRealmFactory,
-  realmFactory,
-  system
-};

package/dist/importMarkdownToLexical.d.ts

@@ -1,101 +0,0 @@
-import { LexicalNode, RootNode as LexicalRootNode } from 'lexical';
-import * as Mdast from 'mdast';
-import { type Options } from 'mdast-util-from-markdown';
-import { ParseOptions } from 'micromark-util-types';
-import { IS_BOLD, IS_CODE, IS_ITALIC, IS_UNDERLINE } from './FormatConstants';
-/** @internal */
-export type MdastExtensions = Options['mdastExtensions'];
-/**
- * A set of actions that can be used to modify the lexical tree while visiting the mdast tree.
- */
-export interface MdastVisitActions {
-    /**
-     * Iterate the children of the node with the lexical node as the parent.
-     */
-    visitChildren(node: Mdast.Parent, lexicalParent: LexicalNode): void;
-    /**
-     * Add the given node to the lexical tree, and iterate the current mdast node's children with the newly created lexical node as a parent.
-     */
-    addAndStepInto(lexicalNode: LexicalNode): void;
-    /**
-     * Adds formatting as a context for the current node and its children.
-     * This is necessary due to mdast treating formatting as a node, while lexical considering it an attribute of a node.
-     */
-    addFormatting(format: typeof IS_BOLD | typeof IS_ITALIC | typeof IS_UNDERLINE | typeof IS_CODE, node?: Mdast.Content): void;
-    /**
-     * Adds formatting as a context for the current node and its children.
-     * This is necessary due to mdast treating formatting as a node, while lexical considering it an attribute of a node.
-     */
-    removeFormatting(format: typeof IS_BOLD | typeof IS_ITALIC | typeof IS_UNDERLINE | typeof IS_CODE, node?: Mdast.Content): void;
-    /**
-     * Access the current formatting context.
-     */
-    getParentFormatting(): number;
-}
-/**
- * Parameters passed to the {@link MdastImportVisitor.visitNode} function.
- * @param mdastNode - The node that is currently being visited.
- * @param lexicalParent - The parent lexical node to which the results of the processing should be added.
- * @param actions - A set of convenience utilities that can be used to add nodes to the lexical tree.
- * @typeParam T - The type of the mdast node that is being visited.
- */
-export interface MdastVisitParams<T extends Mdast.Content> {
-    mdastNode: T;
-    mdastParent: Mdast.Parent | null;
-    lexicalParent: LexicalNode;
-    actions: MdastVisitActions;
-}
-/**
- * Implement this interface to convert certian mdast nodes into lexical nodes.
- * @typeParam UN - The type of the mdast node that is being visited.
- */
-export interface MdastImportVisitor<UN extends Mdast.Content> {
-    /**
-     * The test function that determines if this visitor should be used for the given node.
-     * As a convenience, you can also pass a string here, which will be compared to the node's type.
-     */
-    testNode: ((mdastNode: Mdast.Content | Mdast.Root) => boolean) | string;
-    /**
-     * The function that is called when the node is visited. See {@link MdastVisitParams} for details.
-     */
-    visitNode(params: MdastVisitParams<UN>): void;
-    /**
-     * Default 0, optional, sets the priority of the visitor. The higher the number, the earlier it will be called.
-     */
-    priority?: number;
-}
-/**
- * The options of the tree import utility. Not meant to be used directly.
- * @internal
- */
-export interface MdastTreeImportOptions {
-    root: LexicalRootNode;
-    visitors: MdastImportVisitor<Mdast.Content>[];
-    mdastRoot: Mdast.Root;
-}
-/** @internal */
-export interface MarkdownParseOptions extends Omit<MdastTreeImportOptions, 'mdastRoot'> {
-    markdown: string;
-    syntaxExtensions: NonNullable<ParseOptions['extensions']>;
-    mdastExtensions: MdastExtensions;
-}
-/**
- * An extension for the `fromMarkdown` utility tree construction.
- * @internal
- */
-export type MdastExtension = NonNullable<MdastExtensions>[number];
-/**
- * An extension for the `fromMarkdown` utility markdown parse.
- * @internal
- */
-export type SyntaxExtension = MarkdownParseOptions['syntaxExtensions'][number];
-export declare class MarkdownParseError extends Error {
-    constructor(message: string, cause: unknown);
-}
-export declare class UnrecognizedMarkdownConstructError extends Error {
-    constructor(message: string);
-}
-/** @internal */
-export declare function importMarkdownToLexical({ root, markdown, visitors, syntaxExtensions, mdastExtensions }: MarkdownParseOptions): void;
-/** @internal */
-export declare function importMdastTreeToLexical({ root, mdastRoot, visitors }: MdastTreeImportOptions): void;