@mdxeditor/editor 1.14.3 → 2.0.0

package/dist/exportMarkdownFromLexical.d.ts

@@ -1,138 +0,0 @@
-import { LexicalNode, RootNode as LexicalRootNode } from 'lexical';
-import * as Mdast from 'mdast';
-import { Options as ToMarkdownOptions } from 'mdast-util-to-markdown';
-import type { JsxComponentDescriptor } from './plugins/jsx';
-export type { Options as ToMarkdownOptions } from 'mdast-util-to-markdown';
-/**
- * A set of covenience utilities to manipulate the mdast tree when processing lexical nodes.
- */
-export interface LexicalVisitActions<T extends LexicalNode> {
-    /**
-     * Iterate over the immediate children of a lexical node with the given mdast node as a parent.
-     */
-    visitChildren(node: T, mdastParent: Mdast.Parent): void;
-    /**
-     * Create a new mdast node with the given type, and props.
-     * Iterate over the immediate children of the current lexical node with the new mdast node as a parent.
-     * @param hasChildren - true by default. Pass false to skip iterating over the lexical node children.
-     */
-    addAndStepInto(type: string, props?: Record<string, unknown>, hasChildren?: boolean): void;
-    /**
-     * Append a new mdast node to a parent node.
-     * @param parentNode - the mdast parent node to append the new node to.
-     * @param node - the mdast node to append.
-     */
-    appendToParent<T extends Mdast.Parent>(parentNode: T, node: T['children'][number]): T['children'][number] | Mdast.Root;
-    /**
-     * Used when processing JSX nodes so that later, the correct import statement can be added to the document.
-     * @param componentName - the name of the component that has to be imported.
-     * @see {@link JsxComponentDescriptor}
-     */
-    registerReferredComponent(componentName: string): void;
-}
-/**
- * The params passed to the {@link LexicalExportVisitor.visitLexicalNode} method.
- */
-export interface LexicalNodeVisitParams<T extends LexicalNode> {
-    /**
-     * The lexical node that is being visited.
-     */
-    lexicalNode: T;
-    /**
-     * The mdast parent node that the result of the lexical node conversion should be appended to.
-     */
-    mdastParent: Mdast.Parent;
-    /**
-     * A set of actions that can be used to manipulate the mdast tree.
-     * These are "convenience" utilities that avoid the repetitive boilerplate of creating mdast nodes.
-     */
-    actions: LexicalVisitActions<T>;
-}
-/**
- * Implement this interface in order to process mdast node(s) into a lexical tree.
- * This is part of the process that converts the editor contents to markdown.
- */
-export interface LexicalExportVisitor<LN extends LexicalNode, UN extends Mdast.Content> {
-    /**
-     * Return true if the given node is of the type that this visitor can process.
-     * You can safely use the node type guard functions (as in $isParagraphNode, $isLinkNode, etc.) here.
-     */
-    testLexicalNode?(lexicalNode: LexicalNode): lexicalNode is LN;
-    /**
-     * Process the given node and manipulate the mdast tree accordingly.
-     * @see {@link LexicalNodeVisitParams} and {@link LexicalVisitActions} for more information.
-     */
-    visitLexicalNode?(params: LexicalNodeVisitParams<LN>): void;
-    /**
-     * Return true if the current node should be joined with the previous node.
-     * This is necessary due to some inconsistencies between the lexical tree and the mdast tree when it comes to formatting.
-     */
-    shouldJoin?(prevNode: Mdast.Content, currentNode: UN): boolean;
-    /**
-     * Join the current node with the previous node, returning the resulting new node
-     * For this to be called by the tree walk, shouldJoin must return true.
-     */
-    join?<T extends Mdast.Content>(prevNode: T, currentNode: T): T;
-    /**
-     * Default 0, optional, sets the priority of the visitor. The higher the number, the earlier it will be called.
-     */
-    priority?: number;
-}
-/**
- * The "any" type for LexicalExportVisitor.
- * @internal
- */
-export type LexicalVisitor = LexicalExportVisitor<LexicalNode, Mdast.Content>;
-/**
- * @internal
- */
-export interface ExportLexicalTreeOptions {
-    root: LexicalRootNode;
-    visitors: LexicalVisitor[];
-    jsxComponentDescriptors: JsxComponentDescriptor[];
-    jsxIsAvailable: boolean;
-    addImportStatements?: boolean;
-}
-/**
- * @internal
- */
-export declare function exportLexicalTreeToMdast({ root, visitors, jsxComponentDescriptors, jsxIsAvailable, addImportStatements }: ExportLexicalTreeOptions): Mdast.Root;
-/**
- * @internal
- */
-export type ToMarkdownExtension = NonNullable<ToMarkdownOptions['extensions']>[number];
-/**
- * @internal
- */
-export interface ExportMarkdownFromLexicalOptions extends ExportLexicalTreeOptions {
-    visitors: LexicalVisitor[];
-    /**
-     * the markdown extensions to use
-     */
-    toMarkdownExtensions: ToMarkdownExtension[];
-    /**
-     * The options to pass to `toMarkdown`
-     */
-    toMarkdownOptions: ToMarkdownOptions;
-}
-/**
- * Configures how the lexical tree is converted to a mdast tree and then to markdown.
- */
-export interface LexicalConvertOptions {
-    /**
-     * The visitors to use when processing the lexical tree
-     */
-    visitors?: LexicalVisitor[];
-    /**
-     * the markdown extensions to use
-     */
-    toMarkdownExtensions?: ToMarkdownExtension[];
-    /**
-     * The options to pass to `toMarkdown`
-     */
-    toMarkdownOptions?: ToMarkdownOptions;
-}
-/**
- * @internal
- */
-export declare function exportMarkdownFromLexical({ root, toMarkdownOptions, toMarkdownExtensions, visitors, jsxComponentDescriptors, jsxIsAvailable }: ExportMarkdownFromLexicalOptions): string;

package/dist/gurx/index.d.ts

@@ -1,3 +0,0 @@
-export * from './realm';
-export * from './react';
-export * from './realmFactory';

package/dist/gurx/react.d.ts

@@ -1,152 +0,0 @@
-import React from 'react';
-import { RealmNode } from './realm';
-import type { ValuesForKeys, TypedRealm,  System,  RealmFactory,  ValueForKey,  SystemKeys,  SystemDict,  AnySystemSpec,  SystemOfSpecs } from './realmFactory';
-/**
- * Describes the mapping between the system streams and the component properties.
- * Each property uses the keys as the names of the properties and the values as the corresponding stream names.
- * @typeParam SS - the type of the system.
- */
-export interface SystemPropsMap<Sys extends System, K = keyof Sys, D = {
-    [name: string]: K;
-}> {
-    /**
-     * Specifies the required component properties.
-     */
-    required?: D;
-    /**
-     * Specifies the optional component properties.
-     */
-    optional?: D;
-    /**
-     * Specifies the component methods, if any. Streams are converted to methods with a single argument.
-     * When invoked, the method publishes the value of the argument to the specified stream.
-     */
-    methods?: D;
-    /**
-     * Specifies the component "event" properties, if any.
-     * Event properties accept callback functions which get executed when the stream emits a new value.
-     */
-    events?: D;
-}
-type StringKeys<T> = Extract<keyof T, string>;
-/** @internal */
-export type PropsFromPropMap<Sys extends System, Map extends SystemPropsMap<Sys>> = {
-    [K in StringKeys<Map['required']>]: Map['required'][K] extends string ? Sys[Map['required'][K]] extends RealmNode<infer R> ? R : never : never;
-} & {
-    [K in StringKeys<Map['optional']>]?: Map['optional'][K] extends string ? Sys[Map['optional'][K]] extends RealmNode<infer R> ? R : never : never;
-} & {
-    [K in StringKeys<Map['events']>]?: Map['events'][K] extends string ? Sys[Map['events'][K]] extends RealmNode<infer R> ? (value: R) => void : never : never;
-};
-/** @internal */
-export type MethodsFromPropMap<Sys extends System, Map extends SystemPropsMap<Sys>> = {
-    [K in StringKeys<Map['methods']>]: Map['methods'][K] extends string ? Sys[Map['methods'][K]] extends RealmNode<infer R> ? (value: R) => void : never : never;
-};
-/**
- * @internal
- * Used to correctly specify type refs for system components.
- *
- * @example
- * ```tsx
- * const s = system(() => { return { a: statefulStream(0) } })
- * const { Component } = systemToComponent(s)
- *
- * const App = () => {
- *  const ref = useRef<RefHandle<typeof Component>>()
- *  return <Component ref={ref} />
- * }
- * ```
- *
- * @typeParam T - the type of the component
- */
-export type RefHandle<T> = T extends React.ForwardRefExoticComponent<React.RefAttributes<infer Handle>> ? Handle : never;
-/**
- * Converts a system spec to React component by mapping the system streams to component properties, events and methods. Returns hooks for querying and modifying
- * the system streams from the component's child components.
- * @param realmFactory - The return value from a [[system]] call.
- * @param map - The streams to props / events / methods mapping Check [[SystemPropsMap]] for more details.
- * @param Root - The optional React component to render. By default, the resulting component renders nothing, acting as a logical wrapper for its children.
- * @returns an object containing the following:
- *  - `Component`: the React component.
- *  - `useEmitterValue`: a hook that lets child components use values emitted from the specified output stream.
- *  - `useEmitter`: a hook that calls the provided callback whenever the specified stream emits a value.
- *  - `usePublisher`: a hook which lets child components publish values to the specified stream.
- *  <hr />
- */
-export declare function realmFactoryToComponent<RootComp, RF extends RealmFactory<Sys>, Sys extends System = RF extends RealmFactory<infer S> ? S : never, Realm extends TypedRealm<Sys> = TypedRealm<Sys>, M extends SystemPropsMap<Sys> = SystemPropsMap<Sys>>(realmFactory: RF, map: M, Root?: RootComp): {
-    useRealmContext: () => TypedRealm<Sys>;
-    useEmitter: <K extends Extract<keyof Sys, string>>(key: K, callback: (value: ValueForKey<Sys, K>) => void) => void;
-    useEmitterValues: <K_1 extends SystemKeys<Sys>>(...keys: K_1) => ValuesForKeys<Sys, K_1>;
-    usePubKeys: () => (values: SystemDict<Sys>) => void;
-    usePublisher: <K_2 extends keyof Sys>(key: K_2) => (value: ValueForKey<Sys, K_2>) => void;
-    Component: React.ForwardRefExoticComponent<React.PropsWithoutRef<{ [K_3 in Extract<keyof M["required"], string>]: M["required"][K_3] extends string ? Sys[M["required"][K_3]] extends RealmNode<infer R> ? R : never : never; } & { [K_4 in Extract<keyof M["optional"], string>]?: (M["optional"][K_4] extends string ? Sys[M["optional"][K_4]] extends RealmNode<infer R_1> ? R_1 : never : never) | undefined; } & { [K_5 in Extract<keyof M["events"], string>]?: (M["events"][K_5] extends string ? Sys[M["events"][K_5]] extends RealmNode<infer R_2> ? (value: R_2) => void : never : never) | undefined; } & (RootComp extends React.ComponentType<infer RP> ? RP : {
-        children?: React.ReactNode;
-    })> & React.RefAttributes<MethodsFromPropMap<Sys, M>>>;
-};
-/** @internal */
-export declare function sysHooks<Sys extends System>(): {
-    useRealmContext: () => TypedRealm<Sys>;
-    useEmitter: <K extends Extract<keyof Sys, string>>(key: K, callback: (value: ValueForKey<Sys, K>) => void) => void;
-    useEmitterValues: <K_1 extends SystemKeys<Sys>>(...keys: K_1) => ValuesForKeys<Sys, K_1>;
-    usePubKeys: () => (values: SystemDict<Sys>) => void;
-    usePublisher: <K_2 extends keyof Sys>(key: K_2) => (value: ValueForKey<Sys, K_2>) => void;
-};
-type SystemAndDependencies<Spec extends AnySystemSpec> = SystemOfSpecs<[Spec]> & SystemOfSpecs<Spec['dependencies']>;
-/**
- * The parameters of a plugin declaration. THe best way to understand what each one does is to examine the source code of the existing plugins.
- */
-export interface RealmPluginParams<Spec extends AnySystemSpec, Params extends object> {
-    /**
-     * The id of the plugin. Used to declare conditional features that are activated only if the plugin is present.
-     */
-    id: string;
-    /**
-     * The ids of the plugins that this plugin depends on. The plugin will not be activated if any of the dependencies is not present.
-     */
-    dependencies?: string[];
-    /**
-     * The system spec of the plugin. Construct one using {@link system}.
-     */
-    systemSpec: Spec;
-    /**
-     * The callback is executed every time the react component is re-rendered.
-     */
-    applyParamsToSystem?: (realm: TypedRealm<SystemAndDependencies<Spec>>, props: Params) => void;
-    /**
-     * Executed when the component mounts. Use this to register import/export visitors, add lexical nodes to the editor, etc.
-     * @param realm - the realm instance
-     * @param params - the parameters passed to the plugin in the component declaration
-     * @param pluginIds - the ids of all the plugins that are present in the component declaration
-     */
-    init?: (realm: TypedRealm<SystemAndDependencies<Spec>>, params: Params, pluginIds: string[]) => void;
-}
-/** @internal */
-export interface PluginConstructor<Spec extends AnySystemSpec, Params extends object> {
-    (params?: Params): {
-        pluginParams?: Params;
-    } & RealmPluginParams<Spec, Params>;
-}
-/**
- * Declares a new MDXEditor plugin.
- */
-export declare function realmPlugin<Spec extends AnySystemSpec, Params extends object>(params: RealmPluginParams<Spec, Params>): readonly [PluginConstructor<Spec, Params>, {
-    useRealmContext: () => TypedRealm<SystemAndDependencies<Spec>>;
-    useEmitter: <K extends Extract<keyof (Spec extends AnySystemSpec ? {} & ReturnType<Spec["constructor"]> : never), string> | Extract<keyof SystemOfSpecs<Spec["dependencies"]>, string>>(key: K, callback: (value: ValueForKey<SystemAndDependencies<Spec>, K>) => void) => void;
-    useEmitterValues: <K_1 extends SystemKeys<SystemAndDependencies<Spec>>>(...keys: K_1) => ValuesForKeys<SystemAndDependencies<Spec>, K_1>;
-    usePubKeys: () => (values: SystemDict<SystemAndDependencies<Spec>>) => void;
-    usePublisher: <K_2 extends keyof (Spec extends AnySystemSpec ? {} & ReturnType<Spec["constructor"]> : never) | keyof SystemOfSpecs<Spec["dependencies"]>>(key: K_2) => (value: ValueForKey<SystemAndDependencies<Spec>, K_2>) => void;
-}];
-/** @internal */
-export declare const RealmPluginInitializer: <P extends ({
-    pluginParams?: any;
-} & RealmPluginParams<AnySystemSpec, any>)[]>({ plugins, children }: {
-    plugins: P;
-    children?: React.ReactNode;
-}) => React.FunctionComponentElement<React.ProviderProps<TypedRealm<any>>>;
-/** @internal */
-export declare function useHasPlugin(id: string): boolean;
-/** @internal */
-export declare const RequirePlugin: React.FC<{
-    id: string;
-    children: React.ReactNode;
-}>;
-export {};

package/dist/gurx/react.js

@@ -1,206 +0,0 @@
-import React__default, { useEffect } from "react";
-import { tap, always } from "../utils/fp.js";
-import { realmFactory } from "./realmFactory.js";
-function omit(keys, obj) {
-  const result = {};
-  const index = {};
-  let idx = 0;
-  const len = keys.length;
-  while (idx < len) {
-    index[keys[idx]] = 1;
-    idx += 1;
-  }
-  for (const prop in obj) {
-    if (!Object.prototype.hasOwnProperty.call(index, prop)) {
-      result[prop] = obj[prop];
-    }
-  }
-  return result;
-}
-const useIsomorphicLayoutEffect = typeof document !== "undefined" ? React__default.useLayoutEffect : React__default.useEffect;
-const GurxContext = React__default.createContext(void 0);
-function realmFactoryToComponent(realmFactory2, map, Root) {
-  const requiredPropNames = Object.keys(map.required || {});
-  const optionalPropNames = Object.keys(map.optional || {});
-  const methodNames = Object.keys(map.methods || {});
-  const eventNames = Object.keys(map.events || {});
-  const Context = GurxContext;
-  function applyPropsToRealm(realm, props) {
-    const toBePublished = {};
-    for (const requiredPropName of requiredPropNames) {
-      const nodeName = map.required[requiredPropName];
-      toBePublished[nodeName] = props[requiredPropName];
-    }
-    for (const optionalPropName of optionalPropNames) {
-      const value = props[optionalPropName];
-      if (value !== void 0) {
-        const nodeName = map.optional[optionalPropName];
-        toBePublished[nodeName] = value;
-      }
-    }
-    realm.pubKeys(toBePublished);
-  }
-  function buildMethods(realm) {
-    return methodNames.reduce((acc, methodName) => {
-      const nodeName = map.methods[methodName];
-      acc[methodName] = (value) => {
-        realm.pubKey(nodeName, value);
-      };
-      return acc;
-    }, {});
-  }
-  const Component = React__default.forwardRef((props, ref) => {
-    const realm = React__default.useMemo(() => {
-      return tap(realmFactory2(), (realm2) => applyPropsToRealm(realm2, props));
-    }, []);
-    useIsomorphicLayoutEffect(() => {
-      applyPropsToRealm(realm, props);
-      realm.resetSingletonSubs();
-      for (const eventName of eventNames) {
-        if (eventName in props) {
-          realm.singletonSubKey(map.events[eventName], props[eventName]);
-        }
-      }
-      return () => {
-        realm.resetSingletonSubs();
-      };
-    }, [props]);
-    React__default.useImperativeHandle(ref, always(buildMethods(realm)));
-    const children = props.children;
-    return React__default.createElement(
-      Context.Provider,
-      { value: realm },
-      Root ? React__default.createElement(
-        Root,
-        omit([...requiredPropNames, ...optionalPropNames, ...eventNames], props),
-        children
-      ) : children
-    );
-  });
-  Component.displayName = "Gurx Component";
-  return {
-    Component,
-    ...sysHooks()
-  };
-}
-function sysHooks() {
-  const Context = GurxContext;
-  const usePublisher = (key) => {
-    const realm = React__default.useContext(Context);
-    return React__default.useCallback(
-      (value) => {
-        realm.pubKey(key, value);
-      },
-      // eslint-disable-next-line react-hooks/exhaustive-deps
-      [key, realm]
-    );
-  };
-  const useEmitterValues = (...keys) => {
-    const realm = React__default.useContext(Context);
-    const [values, setValues] = React__default.useState(() => realm.getKeyValues(keys));
-    useEffect(
-      () => realm == null ? void 0 : realm.subKeys(keys, (newValues) => {
-        const setter = () => {
-          if (keys.length === 1) {
-            newValues = [newValues];
-          }
-          for (let i = 0; i < keys.length; i++) {
-            if (newValues[i] !== values[i]) {
-              setValues(newValues);
-            }
-          }
-        };
-        setter();
-      }),
-      [keys, realm, values]
-    );
-    return values;
-  };
-  const usePubKeys = () => {
-    return React__default.useContext(Context).pubKeys;
-  };
-  const useEmitter = (key, callback) => {
-    const realm = React__default.useContext(Context);
-    useIsomorphicLayoutEffect(() => realm.subKey(key, callback), [callback]);
-  };
-  const useRealmContext = () => {
-    return React__default.useContext(Context);
-  };
-  return {
-    useRealmContext,
-    useEmitter,
-    useEmitterValues,
-    usePubKeys,
-    usePublisher
-  };
-}
-const UsedPluginsContext = React__default.createContext(/* @__PURE__ */ new Set());
-function realmPlugin(params) {
-  const plugin = (pluginParams) => {
-    return {
-      systemSpec: params.systemSpec,
-      pluginParams,
-      applyParamsToSystem: params.applyParamsToSystem,
-      init: params.init,
-      id: params.id,
-      dependencies: params.dependencies
-    };
-  };
-  return [plugin, sysHooks()];
-}
-const RealmPluginInitializer = function({
-  plugins,
-  children
-}) {
-  const validPlugins = React__default.useMemo(() => {
-    const availablePlugins = plugins.map((plugin) => plugin.id);
-    const validPlugins2 = plugins.filter((plugin) => {
-      if (plugin.dependencies) {
-        if (plugin.dependencies.some((dep) => !availablePlugins.includes(dep))) {
-          console.warn("MDXEditor plugin", plugin.id, "has some missing dependencies", plugin.dependencies, ", skipping");
-          return false;
-        }
-      }
-      return true;
-    });
-    return validPlugins2;
-  }, [plugins]);
-  const realm = React__default.useMemo(() => {
-    const specs = validPlugins.map((plugin) => plugin.systemSpec);
-    const pluginIds = validPlugins.map((plugin) => plugin.id);
-    const realm2 = realmFactory(...specs);
-    validPlugins.forEach((plugin) => {
-      var _a, _b;
-      (_a = plugin.init) == null ? void 0 : _a.call(plugin, realm2, plugin.pluginParams, pluginIds);
-      (_b = plugin.applyParamsToSystem) == null ? void 0 : _b.call(plugin, realm2, plugin.pluginParams);
-    });
-    return realm2;
-  }, []);
-  React__default.useEffect(() => {
-    validPlugins.forEach((plugin) => {
-      var _a;
-      (_a = plugin.applyParamsToSystem) == null ? void 0 : _a.call(plugin, realm, plugin.pluginParams);
-    });
-  }, [realm, validPlugins]);
-  const Context = GurxContext;
-  return React__default.createElement(
-    Context.Provider,
-    { value: realm },
-    React__default.createElement(UsedPluginsContext.Provider, { value: new Set(plugins.map((plugin) => plugin.id)) }, children)
-  );
-};
-function useHasPlugin(id) {
-  const usedPlugins = React__default.useContext(UsedPluginsContext);
-  return usedPlugins.has(id);
-}
-const RequirePlugin = ({ id, children }) => {
-  return useHasPlugin(id) ? React__default.createElement(React__default.Fragment, {}, children) : null;
-};
-export {
-  RealmPluginInitializer,
-  RequirePlugin,
-  realmFactoryToComponent,
-  realmPlugin,
-  sysHooks,
-  useHasPlugin
-};

package/dist/gurx/realm.d.ts

@@ -1,148 +0,0 @@
-import { LongTuple } from './realmFactory';
-/** @internal */
-export type NodeKey = string;
-/** @internal */
-export interface RealmNode<_T = unknown> {
-    key: NodeKey;
-    toString(): string;
-}
-/** @internal */
-type RN<T = unknown> = RealmNode<T>;
-/** @internal **/
-export type Subscription<T = any> = (value: T) => unknown;
-/** @internal */
-export type UnsubscribeHandle = () => void;
-type ProjectionFunc<T extends unknown[] = unknown[]> = (done: (...values: unknown[]) => void) => (...args: T) => void;
-/** @internal */
-export interface RealmProjection<T extends unknown[] = unknown[]> {
-    sources: Set<NodeKey>;
-    pulls: Set<NodeKey>;
-    sink: NodeKey;
-    map: ProjectionFunc<T>;
-}
-/** @internal */
-export interface RealmProjectionSpec<T extends unknown[] = unknown[]> {
-    sources: RealmNode[];
-    pulls?: RealmNode[];
-    sink: RealmNode;
-    map: ProjectionFunc<T>;
-}
-/**
- * A function which determines if two values are equal.
- * Implement custom comparators when the distinctUntilChanged operator needs to work on non-primitive objects.
- * @returns true if values should be considered equal.
- */
-export interface Comparator<T = any> {
-    (current: T, next: T): boolean;
-}
-type NodesFromValuesRec<T extends unknown[], Acc extends unknown[]> = T extends [infer Head, ...infer Tail] ? NodesFromValuesRec<Tail, [...Acc, Head extends unknown ? RealmNode<Head> : never]> : Acc;
-/** @internal */
-export type NodesFromValues<T extends unknown[]> = T extends unknown[] ? NodesFromValuesRec<T, []> : never;
-/**
- * A comparator function to determine if two values are equal. Used by distinctUntilChanged  operator.
- */
-export declare function defaultComparator<T>(current: T, next: T): boolean;
-declare class SetMap<T> {
-    map: Map<string, Set<T>>;
-    getOrCreate(key: NodeKey): Set<T>;
-    get(key: NodeKey): Set<T> | undefined;
-    use(key: NodeKey, cb: (value: Set<T>) => unknown): void;
-    delete(key: NodeKey): boolean;
-}
-/**
- * @internal
- */
-export declare class RefCount {
-    map: Map<NodeKey, number>;
-    constructor(map?: Map<string, number>);
-    clone(): RefCount;
-    increment(key: NodeKey): void;
-    decrement(key: NodeKey, ifZero: () => void): void;
-}
-/** @internal */
-export type RealmGraph = SetMap<RealmProjection>;
-/** @internal */
-export declare function realm(): {
-    combine: {
-        <T1>(nodes_0: RN<T1>): RN<T1>;
-        <T1_1, T2>(nodes_0: RN<T1_1>, nodes_1: RN<T2>): RN<[T1_1, T2]>;
-        <T1_2, T2_1, T3>(nodes_0: RN<T1_2>, nodes_1: RN<T2_1>, nodes_2: RN<T3>): RN<[T1_2, T2_1, T3]>;
-        <T1_3, T2_2, T3_1, T4>(nodes_0: RN<T1_3>, nodes_1: RN<T2_2>, nodes_2: RN<T3_1>, nodes_3: RN<T4>): RN<[T1_3, T2_2, T3_1, T4]>;
-        <T1_4, T2_3, T3_2, T4_1, T5>(nodes_0: RN<T1_4>, nodes_1: RN<T2_3>, nodes_2: RN<T3_2>, nodes_3: RN<T4_1>, nodes_4: RN<T5>): RN<[T1_4, T2_3, T3_2, T4_1, T5]>;
-        <T1_5, T2_4, T3_3, T4_2, T5_1, T6>(nodes_0: RN<T1_5>, nodes_1: RN<T2_4>, nodes_2: RN<T3_3>, nodes_3: RN<T4_2>, nodes_4: RN<T5_1>, nodes_5: RN<T6>): RN<[T1_5, T2_4, T3_3, T4_2, T5_1, T6]>;
-        <T1_6, T2_5, T3_4, T4_3, T5_2, T6_1, T7>(nodes_0: RN<T1_6>, nodes_1: RN<T2_5>, nodes_2: RN<T3_4>, nodes_3: RN<T4_3>, nodes_4: RN<T5_2>, nodes_5: RN<T6_1>, nodes_6: RN<T7>): RN<[T1_6, T2_5, T3_4, T4_3, T5_2, T6_1, T7]>;
-        <T1_7, T2_6, T3_5, T4_4, T5_3, T6_2, T7_1, T8>(nodes_0: RN<T1_7>, nodes_1: RN<T2_6>, nodes_2: RN<T3_5>, nodes_3: RN<T4_4>, nodes_4: RN<T5_3>, nodes_5: RN<T6_2>, nodes_6: RN<T7_1>, nodes_7: RN<T8>): RN<[T1_7, T2_6, T3_5, T4_4, T5_3, T6_2, T7_1, T8]>;
-        <T1_8, T2_7, T3_6, T4_5, T5_4, T6_3, T7_2, T8_1, T9>(nodes_0: RN<T1_8>, nodes_1: RN<T2_7>, nodes_2: RN<T3_6>, nodes_3: RN<T4_5>, nodes_4: RN<T5_4>, nodes_5: RN<T6_3>, nodes_6: RN<T7_2>, nodes_7: RN<T8_1>, nodes_8: RN<T9>): RN<[T1_8, T2_7, T3_6, T4_5, T5_4, T6_3, T7_2, T8_1, T9]>;
-        <T1_9, T2_8, T3_7, T4_6, T5_5, T6_4, T7_3, T8_2, T9_1, T10>(nodes_0: RN<T1_9>, nodes_1: RN<T2_8>, nodes_2: RN<T3_7>, nodes_3: RN<T4_6>, nodes_4: RN<T5_5>, nodes_5: RN<T6_4>, nodes_6: RN<T7_3>, nodes_7: RN<T8_2>, nodes_8: RN<T9_1>, nodes_9: RN<T10>): RN<[T1_9, T2_8, T3_7, T4_6, T5_5, T6_4, T7_3, T8_2, T9_1, T10]>;
-        <T1_10, T2_9, T3_8, T4_7, T5_6, T6_5, T7_4, T8_3, T9_2, T10_1, T11>(nodes_0: RN<T1_10>, nodes_1: RN<T2_9>, nodes_2: RN<T3_8>, nodes_3: RN<T4_7>, nodes_4: RN<T5_6>, nodes_5: RN<T6_5>, nodes_6: RN<T7_4>, nodes_7: RN<T8_3>, nodes_8: RN<T9_2>, nodes_9: RN<T10_1>, nodes_10: RN<T11>): RN<[T1_10, T2_9, T3_8, T4_7, T5_6, T6_5, T7_4, T8_3, T9_2, T10_1, T11]>;
-        <T1_11, T2_10, T3_9, T4_8, T5_7, T6_6, T7_5, T8_4, T9_3, T10_2, T11_1, T12, T13>(nodes_0: RN<T1_11>, nodes_1: RN<T2_10>, nodes_2: RN<T3_9>, nodes_3: RN<T4_8>, nodes_4: RN<T5_7>, nodes_5: RN<T6_6>, nodes_6: RN<T7_5>, nodes_7: RN<T8_4>, nodes_8: RN<T9_3>, nodes_9: RN<T10_2>, nodes_10: RN<T11_1>, nodes_11: RN<T12>, nodes_12: RN<T13>): RN<[T1_11, T2_10, T3_9, T4_8, T5_7, T6_6, T7_5, T8_4, T9_3, T10_2, T11_1, T12, T13]>;
-        <T1_12, T2_11, T3_10, T4_9, T5_8, T6_7, T7_6, T8_5, T9_4, T10_3, T11_2, T12_1, T13_1, T14>(nodes_0: RN<T1_12>, nodes_1: RN<T2_11>, nodes_2: RN<T3_10>, nodes_3: RN<T4_9>, nodes_4: RN<T5_8>, nodes_5: RN<T6_7>, nodes_6: RN<T7_6>, nodes_7: RN<T8_5>, nodes_8: RN<T9_4>, nodes_9: RN<T10_3>, nodes_10: RN<T11_2>, nodes_11: RN<T12_1>, nodes_12: RN<T13_1>, nodes_13: RN<T14>): RN<[T1_12, T2_11, T3_10, T4_9, T5_8, T6_7, T7_6, T8_5, T9_4, T10_3, T11_2, T12_1, T13_1, T14]>;
-        <T1_13, T2_12, T3_11, T4_10, T5_9, T6_8, T7_7, T8_6, T9_5, T10_4, T11_3, T12_2, T13_2, T14_1, T15>(nodes_0: RN<T1_13>, nodes_1: RN<T2_12>, nodes_2: RN<T3_11>, nodes_3: RN<T4_10>, nodes_4: RN<T5_9>, nodes_5: RN<T6_8>, nodes_6: RN<T7_7>, nodes_7: RN<T8_6>, nodes_8: RN<T9_5>, nodes_9: RN<T10_4>, nodes_10: RN<T11_3>, nodes_11: RN<T12_2>, nodes_12: RN<T13_2>, nodes_13: RN<T14_1>, nodes_14: RN<T15>): RN<[T1_13, T2_12, T3_11, T4_10, T5_9, T6_8, T7_7, T8_6, T9_5, T10_4, T11_3, T12_2, T13_2, T14_1, T15]>;
-        <T1_14, T2_13, T3_12, T4_11, T5_10, T6_9, T7_8, T8_7, T9_6, T10_5, T11_4, T12_3, T13_3, T14_2, T15_1, T16>(nodes_0: RN<T1_14>, nodes_1: RN<T2_13>, nodes_2: RN<T3_12>, nodes_3: RN<T4_11>, nodes_4: RN<T5_10>, nodes_5: RN<T6_9>, nodes_6: RN<T7_8>, nodes_7: RN<T8_7>, nodes_8: RN<T9_6>, nodes_9: RN<T10_5>, nodes_10: RN<T11_4>, nodes_11: RN<T12_3>, nodes_12: RN<T13_3>, nodes_13: RN<T14_2>, nodes_14: RN<T15_1>, nodes_15: RN<T16>): RN<[T1_14, T2_13, T3_12, T4_11, T5_10, T6_9, T7_8, T8_7, T9_6, T10_5, T11_4, T12_3, T13_3, T14_2, T15_1, T16]>;
-    };
-    connect: <T extends unknown[] = unknown[]>({ sources, pulls, map, sink: { key: sink } }: RealmProjectionSpec<T>) => void;
-    derive: <T_1>(source: RealmNode<T_1>, initial: T_1) => RealmNode<T_1>;
-    getKeyValue: (key: string) => unknown;
-    getValue: <T_2>(node: RN<T_2>) => T_2;
-    getKeyValues: (keys: string[]) => unknown[];
-    label: (newLabels: Record<string, RealmNode<unknown>>) => void;
-    labels: Record<string, RealmNode<unknown>>;
-    link: <T_3>(source: RealmNode<T_3>, sink: RealmNode<T_3>) => void;
-    node: <T_4>(value?: symbol | T_4, distinct?: boolean | Comparator<T_4>) => RealmNode<T_4>;
-    o: {
-        delayWithMicrotask: <I>() => (source: RealmNode<I>) => RealmNode<I>;
-        debounceTime: <I_1>(delay: number) => (source: RealmNode<I_1>) => RealmNode<I_1>;
-        filter: <I_2, O_1 = I_2>(predicate: (value: I_2) => boolean) => (source: RealmNode<I_2>) => RealmNode<O_1>;
-        map: <I_3, O_2>(mapFunction: (value: I_3) => O_2) => (source: RealmNode<I_3>) => RealmNode<O_2>;
-        mapTo: <I_4, O_3>(value: O_3) => (source: RealmNode<I_4>) => RealmNode<O_3>;
-        onNext: <I_5, O_4>(bufNode: RN<O_4>) => (source: RealmNode<I_5>) => RealmNode<[I_5, O_4]>;
-        scan: <I_6, O_5>(accumulator: (current: O_5, value: I_6) => O_5, seed: O_5) => (source: RealmNode<I_6>) => RealmNode<O_5>;
-        throttleTime: <I_7>(delay: number) => (source: RealmNode<I_7>) => RealmNode<I_7>;
-        withLatestFrom: {
-            <I_8, T1_15>(nodes_0: RN<T1_15>): (source: RN<I_8>) => RN<[I_8, T1_15]>;
-            <I_9, T1_16, T2_14>(nodes_0: RN<T1_16>, nodes_1: RN<T2_14>): (source: RN<I_9>) => RN<[I_9, T1_16, T2_14]>;
-            <I_10, T1_17, T2_15, T3_13>(nodes_0: RN<T1_17>, nodes_1: RN<T2_15>, nodes_2: RN<T3_13>): (source: RN<I_10>) => RN<[I_10, T1_17, T2_15, T3_13]>;
-            <I_11, T1_18, T2_16, T3_14, T4_12>(nodes_0: RN<T1_18>, nodes_1: RN<T2_16>, nodes_2: RN<T3_14>, nodes_3: RN<T4_12>): (source: RN<I_11>) => RN<[I_11, T1_18, T2_16, T3_14, T4_12]>;
-            <I_12, T1_19, T2_17, T3_15, T4_13, T5_11>(nodes_0: RN<T1_19>, nodes_1: RN<T2_17>, nodes_2: RN<T3_15>, nodes_3: RN<T4_13>, nodes_4: RN<T5_11>): (source: RN<I_12>) => RN<[I_12, T1_19, T2_17, T3_15, T4_13, T5_11]>;
-            <I_13, T1_20, T2_18, T3_16, T4_14, T5_12, T6_10>(nodes_0: RN<T1_20>, nodes_1: RN<T2_18>, nodes_2: RN<T3_16>, nodes_3: RN<T4_14>, nodes_4: RN<T5_12>, nodes_5: RN<T6_10>): (source: RN<I_13>) => RN<[I_13, T1_20, T2_18, T3_16, T4_14, T5_12, T6_10]>;
-            <I_14, T1_21, T2_19, T3_17, T4_15, T5_13, T6_11, T7_9>(nodes_0: RN<T1_21>, nodes_1: RN<T2_19>, nodes_2: RN<T3_17>, nodes_3: RN<T4_15>, nodes_4: RN<T5_13>, nodes_5: RN<T6_11>, nodes_6: RN<T7_9>): (source: RN<I_14>) => RN<[I_14, T1_21, T2_19, T3_17, T4_15, T5_13, T6_11, T7_9]>;
-            <I_15, T1_22, T2_20, T3_18, T4_16, T5_14, T6_12, T7_10, T8_8>(nodes_0: RN<T1_22>, nodes_1: RN<T2_20>, nodes_2: RN<T3_18>, nodes_3: RN<T4_16>, nodes_4: RN<T5_14>, nodes_5: RN<T6_12>, nodes_6: RN<T7_10>, nodes_7: RN<T8_8>): (source: RN<I_15>) => RN<[I_15, T1_22, T2_20, T3_18, T4_16, T5_14, T6_12, T7_10, T8_8]>;
-        };
-        once: <I_16>() => (source: RealmNode<I_16>) => RealmNode<I_16>;
-        passOnlyAfterNodeHasEmittedBefore: <I_17>(starterNode: RN<unknown>, durationNode: RN<number>) => (source: RealmNode<I_17>) => RealmNode<I_17>;
-    };
-    pipe: {
-        <T_5>(s: RealmNode<T_5>): RealmNode<T_5>;
-        <T_6, O1>(s: RealmNode<T_6>, o1: (source: RealmNode<T_6>) => RealmNode<O1>): RealmNode<O1>;
-        <T_7, O1_1, O2>(s: RealmNode<T_7>, o_0: (source: RealmNode<T_7>) => RealmNode<O1_1>, o_1: (source: RealmNode<O1_1>) => RealmNode<O2>): RealmNode<O2>;
-        <T_8, O1_2, O2_1, O3>(s: RealmNode<T_8>, o_0: (source: RealmNode<T_8>) => RealmNode<O1_2>, o_1: (source: RealmNode<O1_2>) => RealmNode<O2_1>, o_2: (source: RealmNode<O2_1>) => RealmNode<O3>): RealmNode<O3>;
-        <T_9, O1_3, O2_2, O3_1, O4>(s: RealmNode<T_9>, o_0: (source: RealmNode<T_9>) => RealmNode<O1_3>, o_1: (source: RealmNode<O1_3>) => RealmNode<O2_2>, o_2: (source: RealmNode<O2_2>) => RealmNode<O3_1>, o_3: (source: RealmNode<O3_1>) => RealmNode<O4>): RealmNode<O4>;
-        <T_10, O1_4, O2_3, O3_2, O4_1, O5>(s: RealmNode<T_10>, o_0: (source: RealmNode<T_10>) => RealmNode<O1_4>, o_1: (source: RealmNode<O1_4>) => RealmNode<O2_3>, o_2: (source: RealmNode<O2_3>) => RealmNode<O3_2>, o_3: (source: RealmNode<O3_2>) => RealmNode<O4_1>, o_4: (source: RealmNode<O4_1>) => RealmNode<O5>): RealmNode<O5>;
-        <T_11, O1_5, O2_4, O3_3, O4_2, O5_1, O6>(s: RealmNode<T_11>, o_0: (source: RealmNode<T_11>) => RealmNode<O1_5>, o_1: (source: RealmNode<O1_5>) => RealmNode<O2_4>, o_2: (source: RealmNode<O2_4>) => RealmNode<O3_3>, o_3: (source: RealmNode<O3_3>) => RealmNode<O4_2>, o_4: (source: RealmNode<O4_2>) => RealmNode<O5_1>, o_5: (source: RealmNode<O5_1>) => RealmNode<O6>): RealmNode<O6>;
-        <T_12, O1_6, O2_5, O3_4, O4_3, O5_2, O6_1, O7>(s: RealmNode<T_12>, o_0: (source: RealmNode<T_12>) => RealmNode<O1_6>, o_1: (source: RealmNode<O1_6>) => RealmNode<O2_5>, o_2: (source: RealmNode<O2_5>) => RealmNode<O3_4>, o_3: (source: RealmNode<O3_4>) => RealmNode<O4_3>, o_4: (source: RealmNode<O4_3>) => RealmNode<O5_2>, o_5: (source: RealmNode<O5_2>) => RealmNode<O6_1>, o_6: (source: RealmNode<O6_1>) => RealmNode<O7>): RealmNode<O7>;
-    };
-    pub: {
-        <T1_23>(args_0: RN<T1_23>, args_1: T1_23): void;
-        <T1_24, T2_21>(args_0: RN<T1_24>, args_1: T1_24, args_2: RN<T2_21>, args_3: T2_21): void;
-        <T1_25, T2_22, T3_19>(args_0: RN<T1_25>, args_1: T1_25, args_2: RN<T2_22>, args_3: T2_22, args_4: RN<T3_19>, args_5: T3_19): void;
-        <T1_26, T2_23, T3_20, T4_17>(args_0: RN<T1_26>, args_1: T1_26, args_2: RN<T2_23>, args_3: T2_23, args_4: RN<T3_20>, args_5: T3_20, args_6: T4_17): void;
-    };
-    pubIn: (values: Record<NodeKey, unknown>) => void;
-    pubKey: (key: string, value: unknown) => void;
-    pubKeys: (values: Record<string, unknown>) => void;
-    resetSingletonSubs: () => void;
-    singletonSub: <T_13>({ key }: RealmNode<T_13>, subscription: Subscription<T_13> | undefined) => UnsubscribeHandle;
-    singletonSubKey: <T_14>(key: string, subscription: Subscription<T_14> | undefined) => UnsubscribeHandle;
-    spread: <T_15 extends LongTuple<unknown>>(source: RealmNode<T_15>, initialValues: T_15) => NodesFromValues<T_15>;
-    sub: {
-        <T1_27>(args_0: RN<T1_27>, args_1: Subscription<T1_27>): UnsubscribeHandle;
-        <T1_28, T2_24>(args_0: RN<T1_28>, args_1: RN<T2_24>, args_2: Subscription<[T1_28, T2_24]>): UnsubscribeHandle;
-        <T1_29, T2_25, T3_21>(args_0: RN<T1_29>, args_1: RN<T2_25>, args_2: RN<T3_21>, args_3: Subscription<[T1_29, T2_25, T3_21]>): UnsubscribeHandle;
-    };
-    subKey: (key: string, subscription: Subscription<unknown>) => UnsubscribeHandle;
-    subKeys: (keys: string[], subscription: Subscription<unknown>) => UnsubscribeHandle;
-};
-/** @internal */
-export interface Realm extends ReturnType<typeof realm> {
-}
-export {};