@unicom-cloud/ui 0.8.108 → 0.8.110

package/types/pc/rich-text/eventemitter/index.d.ts

@@ -0,0 +1,101 @@
+export default EventEmitter;
+/**
+ * Minimal `EventEmitter` interface that is molded against the Node.js
+ * `EventEmitter` interface.
+ *
+ * @constructor
+ * @public
+ */
+export function EventEmitter(): void;
+export class EventEmitter {
+    _events: Events;
+    _eventsCount: number;
+    /**
+     * Return an array listing the events for which the emitter has registered
+     * listeners.
+     *
+     * @returns {Array}
+     * @public
+     */
+    public eventNames(): any[];
+    /**
+     * Return the listeners registered for a given event.
+     *
+     * @param {(String|Symbol)} event The event name.
+     * @returns {Array} The registered listeners.
+     * @public
+     */
+    public listeners(event: (string | Symbol)): any[];
+    /**
+     * Return the number of listeners listening to a given event.
+     *
+     * @param {(String|Symbol)} event The event name.
+     * @returns {Number} The number of listeners.
+     * @public
+     */
+    public listenerCount(event: (string | Symbol)): number;
+    /**
+     * Calls each of the listeners registered for a given event.
+     *
+     * @param {(String|Symbol)} event The event name.
+     * @returns {Boolean} `true` if the event had listeners, else `false`.
+     * @public
+     */
+    public emit(event: (string | Symbol), a1: any, a2: any, a3: any, a4: any, a5: any, ...args: any[]): boolean;
+    /**
+     * Add a listener for a given event.
+     *
+     * @param {(String|Symbol)} event The event name.
+     * @param {Function} fn The listener function.
+     * @param {*} [context=this] The context to invoke the listener with.
+     * @returns {EventEmitter} `this`.
+     * @public
+     */
+    public on(event: (string | Symbol), fn: Function, context?: any): EventEmitter;
+    /**
+     * Add a one-time listener for a given event.
+     *
+     * @param {(String|Symbol)} event The event name.
+     * @param {Function} fn The listener function.
+     * @param {*} [context=this] The context to invoke the listener with.
+     * @returns {EventEmitter} `this`.
+     * @public
+     */
+    public once(event: (string | Symbol), fn: Function, context?: any): EventEmitter;
+    /**
+     * Remove the listeners of a given event.
+     *
+     * @param {(String|Symbol)} event The event name.
+     * @param {Function} fn Only remove the listeners that match this function.
+     * @param {*} context Only remove the listeners that have this context.
+     * @param {Boolean} once Only remove one-time listeners.
+     * @returns {EventEmitter} `this`.
+     * @public
+     */
+    public removeListener(event: (string | Symbol), fn: Function, context: any, once: boolean): EventEmitter;
+    /**
+     * Remove all listeners, or those of the specified event.
+     *
+     * @param {(String|Symbol)} [event] The event name.
+     * @returns {EventEmitter} `this`.
+     * @public
+     */
+    public removeAllListeners(event?: (string | Symbol)): EventEmitter;
+    off: any;
+    addListener: any;
+}
+export namespace EventEmitter {
+    export { prefix as prefixed };
+    export { EventEmitter };
+}
+/**
+ * Constructor to create a storage for our `EE` objects.
+ * An `Events` instance is a plain object whose properties are event names.
+ *
+ * @constructor
+ * @private
+ */
+declare function Events(): void;
+declare class Events {
+}
+declare var prefix: string;

package/types/pc/rich-text/formats/align.d.ts

@@ -0,0 +1,5 @@
+import { Attributor, ClassAttributor, StyleAttributor } from '../parchment';
+declare const AlignAttribute: Attributor;
+declare const AlignClass: ClassAttributor;
+declare const AlignStyle: StyleAttributor;
+export { AlignAttribute, AlignClass, AlignStyle };

package/types/pc/rich-text/formats/background.d.ts

@@ -0,0 +1,5 @@
+import { ClassAttributor } from '../parchment';
+import { ColorAttributor } from './color.js';
+declare const BackgroundClass: ClassAttributor;
+declare const BackgroundStyle: ColorAttributor;
+export { BackgroundClass, BackgroundStyle };

package/types/pc/rich-text/formats/blockquote.d.ts

@@ -0,0 +1,6 @@
+import Block from '../blots/block.js';
+declare class Blockquote extends Block {
+    static blotName: string;
+    static tagName: string;
+}
+export default Blockquote;

package/types/pc/rich-text/formats/bold.d.ts

@@ -0,0 +1,11 @@
+import Inline from '../blots/inline.js';
+declare class Bold extends Inline {
+    static blotName: string;
+    static tagName: string[];
+    static create(): HTMLElement;
+    static formats(): boolean;
+    optimize(context: {
+        [key: string]: any;
+    }): void;
+}
+export default Bold;

package/types/pc/rich-text/formats/code.d.ts

@@ -0,0 +1,15 @@
+import Block from '../blots/block.js';
+import Container from '../blots/container.js';
+import Inline from '../blots/inline.js';
+declare class CodeBlockContainer extends Container {
+    static create(value: string): Element;
+    code(index: number, length: number): string;
+    html(index: number, length: number): string;
+}
+declare class CodeBlock extends Block {
+    static TAB: string;
+    static register(): void;
+}
+declare class Code extends Inline {
+}
+export { Code, CodeBlockContainer, CodeBlock as default };

package/types/pc/rich-text/formats/color.d.ts

@@ -0,0 +1,7 @@
+import { ClassAttributor, StyleAttributor } from '../parchment';
+declare class ColorAttributor extends StyleAttributor {
+    value(domNode: HTMLElement): string;
+}
+declare const ColorClass: ClassAttributor;
+declare const ColorStyle: ColorAttributor;
+export { ColorAttributor, ColorClass, ColorStyle };

package/types/pc/rich-text/formats/direction.d.ts

@@ -0,0 +1,5 @@
+import { Attributor, ClassAttributor, StyleAttributor } from '../parchment';
+declare const DirectionAttribute: Attributor;
+declare const DirectionClass: ClassAttributor;
+declare const DirectionStyle: StyleAttributor;
+export { DirectionAttribute, DirectionClass, DirectionStyle };

package/types/pc/rich-text/formats/font.d.ts

@@ -0,0 +1,7 @@
+import { ClassAttributor, StyleAttributor } from '../parchment';
+declare const FontClass: ClassAttributor;
+declare class FontStyleAttributor extends StyleAttributor {
+    value(node: HTMLElement): any;
+}
+declare const FontStyle: FontStyleAttributor;
+export { FontClass, FontStyle };

package/types/pc/rich-text/formats/formula.d.ts

@@ -0,0 +1,10 @@
+import Embed from '../blots/embed.js';
+declare class Formula extends Embed {
+    static blotName: string;
+    static className: string;
+    static tagName: string;
+    static create(value: string): Element;
+    static value(domNode: Element): string | null;
+    html(): string;
+}
+export default Formula;

package/types/pc/rich-text/formats/header.d.ts

@@ -0,0 +1,7 @@
+import Block from '../blots/block.js';
+declare class Header extends Block {
+    static blotName: string;
+    static tagName: string[];
+    static formats(domNode: Element): number;
+}
+export default Header;

package/types/pc/rich-text/formats/image.d.ts

@@ -0,0 +1,13 @@
+import { EmbedBlot } from '../parchment';
+declare class Image extends EmbedBlot {
+    static blotName: string;
+    static tagName: string;
+    static create(value: string): Element;
+    static formats(domNode: Element): Record<string, string | null>;
+    static match(url: string): boolean;
+    static sanitize(url: string): string;
+    static value(domNode: Element): string | null;
+    domNode: HTMLImageElement;
+    format(name: string, value: string): void;
+}
+export default Image;

package/types/pc/rich-text/formats/indent.d.ts

@@ -0,0 +1,8 @@
+import { ClassAttributor } from '../parchment';
+declare class IndentAttributor extends ClassAttributor {
+    add(node: HTMLElement, value: string | number): boolean;
+    canAdd(node: HTMLElement, value: string): boolean;
+    value(node: HTMLElement): number | undefined;
+}
+declare const IndentClass: IndentAttributor;
+export default IndentClass;

package/types/pc/rich-text/formats/italic.d.ts

@@ -0,0 +1,6 @@
+import Bold from './bold.js';
+declare class Italic extends Bold {
+    static blotName: string;
+    static tagName: string[];
+}
+export default Italic;

package/types/pc/rich-text/formats/link.d.ts

@@ -0,0 +1,13 @@
+import Inline from '../blots/inline.js';
+declare class Link extends Inline {
+    static blotName: string;
+    static tagName: string;
+    static SANITIZED_URL: string;
+    static PROTOCOL_WHITELIST: string[];
+    static create(value: string): HTMLElement;
+    static formats(domNode: HTMLElement): string | null;
+    static sanitize(url: string): string;
+    format(name: string, value: unknown): void;
+}
+declare function sanitize(url: string, protocols: string[]): boolean;
+export { Link as default, sanitize };

package/types/pc/rich-text/formats/list.d.ts

@@ -0,0 +1,13 @@
+import Block from '../blots/block.js';
+import Container from '../blots/container.js';
+import type Scroll from '../blots/scroll.js';
+declare class ListContainer extends Container {
+}
+declare class ListItem extends Block {
+    static create(value: string): HTMLElement;
+    static formats(domNode: HTMLElement): string | undefined;
+    static register(): void;
+    constructor(scroll: Scroll, domNode: HTMLElement);
+    format(name: string, value: string): void;
+}
+export { ListItem as default, ListContainer };

package/types/pc/rich-text/formats/script.d.ts

@@ -0,0 +1,8 @@
+import Inline from '../blots/inline.js';
+declare class Script extends Inline {
+    static blotName: string;
+    static tagName: string[];
+    static create(value: 'super' | 'sub' | (string & {})): HTMLElement;
+    static formats(domNode: HTMLElement): "sub" | "super" | undefined;
+}
+export default Script;

package/types/pc/rich-text/formats/size.d.ts

@@ -0,0 +1,4 @@
+import { ClassAttributor, StyleAttributor } from '../parchment';
+declare const SizeClass: ClassAttributor;
+declare const SizeStyle: StyleAttributor;
+export { SizeClass, SizeStyle };

package/types/pc/rich-text/formats/strike.d.ts

@@ -0,0 +1,6 @@
+import Bold from './bold.js';
+declare class Strike extends Bold {
+    static blotName: string;
+    static tagName: string[];
+}
+export default Strike;

package/types/pc/rich-text/formats/table.d.ts

@@ -0,0 +1,45 @@
+import Block from '../blots/block.js';
+import Container from '../blots/container.js';
+import type { LinkedList } from '../parchment';
+declare class TableCell extends Block {
+    static blotName: string;
+    static tagName: string;
+    static create(value: string): HTMLElement;
+    static formats(domNode: HTMLElement): string | null | undefined;
+    next: this | null;
+    cellOffset(): number;
+    format(name: string, value: string): void;
+    row(): TableRow;
+    rowOffset(): number;
+    table(): import("../parchment").Parent;
+}
+declare class TableRow extends Container {
+    static blotName: string;
+    static tagName: string;
+    children: LinkedList<TableCell>;
+    next: this | null;
+    checkMerge(): boolean;
+    optimize(context: {
+        [key: string]: any;
+    }): void;
+    rowOffset(): number;
+    table(): import("../parchment").Parent;
+}
+declare class TableBody extends Container {
+    static blotName: string;
+    static tagName: string;
+    children: LinkedList<TableRow>;
+}
+declare class TableContainer extends Container {
+    static blotName: string;
+    static tagName: string;
+    children: LinkedList<TableBody>;
+    balanceCells(): void;
+    cells(column: number): any[];
+    deleteColumn(index: number): void;
+    insertColumn(index: number): void;
+    insertRow(index: number): void;
+    rows(): any[];
+}
+declare function tableId(): string;
+export { TableBody, TableCell, TableContainer, tableId, TableRow };

package/types/pc/rich-text/formats/underline.d.ts

@@ -0,0 +1,6 @@
+import Inline from '../blots/inline.js';
+declare class Underline extends Inline {
+    static blotName: string;
+    static tagName: string;
+}
+export default Underline;

package/types/pc/rich-text/formats/video.d.ts

@@ -0,0 +1,14 @@
+import { BlockEmbed } from '../blots/block.js';
+declare class Video extends BlockEmbed {
+    static blotName: string;
+    static className: string;
+    static tagName: string;
+    static create(value: string): Element;
+    static formats(domNode: Element): Record<string, string | null>;
+    static sanitize(url: string): string;
+    static value(domNode: Element): string | null;
+    domNode: HTMLVideoElement;
+    format(name: string, value: string): void;
+    html(): string;
+}
+export default Video;

package/types/pc/rich-text/index.d.ts

@@ -0,0 +1,6 @@
+import Rich from './rich';
+export * from './rich';
+export type { Bounds, DebugLevel, EmitterSource, ExpandedRichOptions, RichOptions, } from './rich';
+export { Rich };
+declare const RichText: import("react").ForwardRefExoticComponent<Omit<any, "ref"> & import("react").RefAttributes<unknown>>;
+export default RichText;

package/types/pc/rich-text/interface.d.ts

@@ -0,0 +1,17 @@
+import { CSSProperties } from 'react';
+import type { EmitterSource } from './core/emitter';
+import Delta from './delta';
+/**
+ * @title RichText
+ */
+export interface RichTextProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    readOnly?: boolean;
+    defaultValue?: object | string;
+    value?: object | string;
+    onChange?: (value: Delta, delta: Delta, preValue: Delta, source: EmitterSource) => void;
+    onTextChange?: (delta: Delta, preValue: Delta, source: EmitterSource) => void;
+    onSelectionChange?: (...args: any[]) => void;
+    onEditorChange?: (...args: any[]) => void;
+}

package/types/pc/rich-text/modules/clipboard.d.ts

@@ -0,0 +1,43 @@
+import type { EmitterSource } from '../core/emitter.js';
+import Module from '../core/module.js';
+import Rich from '../core/rich.js';
+import type { Range } from '../core/selection.js';
+import Delta from '../delta';
+import type { ScrollBlot } from '../parchment';
+type Selector = string | Node['TEXT_NODE'] | Node['ELEMENT_NODE'];
+type Matcher = (node: Node, delta: Delta, scroll: ScrollBlot) => Delta;
+interface ClipboardOptions {
+    matchers: [Selector, Matcher][];
+}
+declare class Clipboard extends Module<ClipboardOptions> {
+    static DEFAULTS: ClipboardOptions;
+    matchers: [Selector, Matcher][];
+    constructor(rich: Rich, options: Partial<ClipboardOptions>);
+    addMatcher(selector: Selector, matcher: Matcher): void;
+    convert({ html, text }: {
+        html?: string;
+        text?: string;
+    }, formats?: Record<string, unknown>): Delta;
+    protected normalizeHTML(doc: Document): void;
+    protected convertHTML(html: string): Delta;
+    dangerouslyPasteHTML(html: string, source?: EmitterSource): void;
+    dangerouslyPasteHTML(index: number, html: string, source?: EmitterSource): void;
+    onCaptureCopy(e: ClipboardEvent, isCut?: boolean): void;
+    private normalizeURIList;
+    onCapturePaste(e: ClipboardEvent): void;
+    onCopy(range: Range, isCut: boolean): {
+        html: string;
+        text: string;
+    };
+    onPaste(range: Range, { text, html }: {
+        text?: string;
+        html?: string;
+    }): void;
+    prepareMatching(container: Element, nodeMatches: WeakMap<Node, Matcher[]>): Matcher[][];
+}
+declare function traverse(scroll: ScrollBlot, node: ChildNode, elementMatchers: Matcher[], textMatchers: Matcher[], nodeMatches: WeakMap<Node, Matcher[]>): Delta;
+declare function matchAttributor(node: HTMLElement, delta: Delta, scroll: ScrollBlot): Delta;
+declare function matchBlot(node: Node, delta: Delta, scroll: ScrollBlot): Delta;
+declare function matchNewline(node: Node, delta: Delta, scroll: ScrollBlot): Delta;
+declare function matchText(node: HTMLElement, delta: Delta, scroll: ScrollBlot): Delta;
+export { Clipboard as default, matchAttributor, matchBlot, matchNewline, matchText, traverse, };

package/types/pc/rich-text/modules/history.d.ts

@@ -0,0 +1,36 @@
+import type Scroll from '../blots/scroll.js';
+import Module from '../core/module.js';
+import Rich from '../core/rich.js';
+import type { Range } from '../core/selection.js';
+import type Delta from '../delta';
+export interface HistoryOptions {
+    userOnly: boolean;
+    delay: number;
+    maxStack: number;
+}
+export interface StackItem {
+    delta: Delta;
+    range: Range | null;
+}
+interface Stack {
+    undo: StackItem[];
+    redo: StackItem[];
+}
+declare class History extends Module<HistoryOptions> {
+    static DEFAULTS: HistoryOptions;
+    lastRecorded: number;
+    ignoreChange: boolean;
+    stack: Stack;
+    currentRange: Range | null;
+    constructor(rich: Rich, options: Partial<HistoryOptions>);
+    change(source: 'undo' | 'redo', dest: 'redo' | 'undo'): void;
+    clear(): void;
+    cutoff(): void;
+    record(changeDelta: Delta, oldDelta: Delta): void;
+    redo(): void;
+    transform(delta: Delta): void;
+    undo(): void;
+    protected restoreSelection(stackItem: StackItem): void;
+}
+declare function getLastChangeIndex(scroll: Scroll, delta: Delta): number;
+export { History as default, getLastChangeIndex };

package/types/pc/rich-text/modules/input.d.ts

@@ -0,0 +1,10 @@
+import Module from '../core/module.js';
+import Rich from '../core/rich.js';
+declare class Input extends Module {
+    constructor(rich: Rich, options: Record<string, never>);
+    private deleteRange;
+    private replaceText;
+    private handleBeforeInput;
+    private handleCompositionStart;
+}
+export default Input;

package/types/pc/rich-text/modules/keyboard.d.ts

@@ -0,0 +1,58 @@
+import type { BlockEmbed } from '../blots/block.js';
+import Module from '../core/module.js';
+import Rich from '../core/rich.js';
+import type { Range } from '../core/selection.js';
+import type { BlockBlot } from '../parchment';
+declare const SHORTKEY: string;
+export interface Context {
+    collapsed: boolean;
+    empty: boolean;
+    offset: number;
+    prefix: string;
+    suffix: string;
+    format: Record<string, unknown>;
+    event: KeyboardEvent;
+    line: BlockEmbed | BlockBlot;
+}
+interface BindingObject extends Partial<Omit<Context, 'prefix' | 'suffix' | 'format'>> {
+    key: number | string | string[];
+    shortKey?: boolean | null;
+    shiftKey?: boolean | null;
+    altKey?: boolean | null;
+    metaKey?: boolean | null;
+    ctrlKey?: boolean | null;
+    prefix?: RegExp;
+    suffix?: RegExp;
+    format?: Record<string, unknown> | string[];
+    handler?: (this: {
+        rich: Rich;
+    }, range: Range, curContext: Context, binding: NormalizedBinding) => boolean | void;
+}
+type Binding = BindingObject | string | number;
+interface NormalizedBinding extends Omit<BindingObject, 'key' | 'shortKey'> {
+    key: string | number;
+}
+interface KeyboardOptions {
+    bindings: Record<string, Binding>;
+}
+interface KeyboardOptions {
+    bindings: Record<string, Binding>;
+}
+declare class Keyboard extends Module<KeyboardOptions> {
+    static DEFAULTS: KeyboardOptions;
+    static match(evt: KeyboardEvent, binding: BindingObject): boolean;
+    bindings: Record<string, NormalizedBinding[]>;
+    constructor(rich: Rich, options: Partial<KeyboardOptions>);
+    addBinding(keyBinding: Binding, context?: Required<BindingObject['handler']> | Partial<Omit<BindingObject, 'key' | 'handler'>>, handler?: Required<BindingObject['handler']> | Partial<Omit<BindingObject, 'key' | 'handler'>>): void;
+    listen(): void;
+    handleBackspace(range: Range, context: Context): void;
+    handleDelete(range: Range, context: Context): void;
+    handleDeleteRange(range: Range): void;
+    handleEnter(range: Range, context: Context): void;
+}
+declare function normalize(binding: Binding): BindingObject | null;
+declare function deleteRange({ rich, range }: {
+    rich: Rich;
+    range: Range;
+}): void;
+export { Keyboard as default, deleteRange, normalize, SHORTKEY };

package/types/pc/rich-text/modules/normalizeExternalHTML/index.d.ts

@@ -0,0 +1,2 @@
+declare const normalizeExternalHTML: (doc: Document) => void;
+export default normalizeExternalHTML;

package/types/pc/rich-text/modules/normalizeExternalHTML/normalizers/googleDocs.d.ts

@@ -0,0 +1 @@
+export default function normalize(doc: Document): void;

package/types/pc/rich-text/modules/normalizeExternalHTML/normalizers/msWord.d.ts

@@ -0,0 +1 @@
+export default function normalize(doc: Document): void;

package/types/pc/rich-text/modules/syntax.d.ts

@@ -0,0 +1,50 @@
+import Inline from '../blots/inline.js';
+import Module from '../core/module.js';
+import Rich from '../core/rich.js';
+import Delta from '../delta';
+import CodeBlock, { CodeBlockContainer } from '../formats/code.js';
+import type { Blot, ScrollBlot } from '../parchment';
+declare class CodeToken extends Inline {
+    static formats(node: Element, scroll: ScrollBlot): any;
+    constructor(scroll: ScrollBlot, domNode: Node, value: unknown);
+    format(format: string, value: unknown): void;
+    optimize(...args: unknown[]): void;
+}
+declare class SyntaxCodeBlock extends CodeBlock {
+    static create(value: unknown): HTMLElement;
+    static formats(domNode: Node): any;
+    static register(): void;
+    format(name: string, value: unknown): void;
+    replaceWith(name: string | Blot, value?: any): Blot;
+}
+declare class SyntaxCodeBlockContainer extends CodeBlockContainer {
+    forceNext?: boolean;
+    cachedText?: string | null;
+    attach(): void;
+    format(name: string, value: unknown): void;
+    formatAt(index: number, length: number, name: string, value: unknown): void;
+    highlight(highlight: (text: string, language: string) => Delta, forced?: boolean): void;
+    html(index: number, length: number): string;
+    optimize(context: Record<string, any>): void;
+}
+interface SyntaxOptions {
+    interval: number;
+    languages: {
+        key: string;
+        label: string;
+    }[];
+    hljs: any;
+}
+declare class Syntax extends Module<SyntaxOptions> {
+    static DEFAULTS: SyntaxOptions & {
+        hljs: any;
+    };
+    static register(): void;
+    languages: Record<string, true>;
+    constructor(rich: Rich, options: Partial<SyntaxOptions>);
+    initListener(): void;
+    initTimer(): void;
+    highlight(blot?: SyntaxCodeBlockContainer | null, force?: boolean): void;
+    highlightBlot(text: string, language?: string): Delta;
+}
+export { SyntaxCodeBlock as CodeBlock, CodeToken, Syntax as default };

package/types/pc/rich-text/modules/table.d.ts

@@ -0,0 +1,20 @@
+import Module from '../core/module.js';
+import { TableCell, TableRow } from '../formats/table.js';
+declare class Table extends Module {
+    static register(): void;
+    constructor(...args: ConstructorParameters<typeof Module>);
+    balanceTables(): void;
+    deleteColumn(): void;
+    deleteRow(): void;
+    deleteTable(): void;
+    getTable(range?: import("../core.js").Range | null): [null, null, null, -1] | [Table, TableRow, TableCell, number];
+    insertColumn(offset: number): void;
+    insertColumnLeft(): void;
+    insertColumnRight(): void;
+    insertRow(offset: number): void;
+    insertRowAbove(): void;
+    insertRowBelow(): void;
+    insertTable(rows: number, columns: number): void;
+    listenBalanceCells(): void;
+}
+export default Table;

package/types/pc/rich-text/modules/tableEmbed.d.ts

@@ -0,0 +1,27 @@
+import Module from '../core/module.js';
+import type { Op } from '../delta';
+import Delta from '../delta';
+export type CellData = {
+    content?: Delta['ops'];
+    attributes?: Record<string, unknown>;
+};
+export type TableRowColumnOp = Omit<Op, 'insert'> & {
+    insert?: {
+        id: string;
+    };
+};
+export interface TableData {
+    rows?: Delta['ops'];
+    columns?: Delta['ops'];
+    cells?: Record<string, CellData>;
+}
+export declare const composePosition: (delta: Delta, index: number) => number | null;
+export declare const tableHandler: {
+    compose(a: TableData, b: TableData, keepNull?: boolean): TableData;
+    transform(a: TableData, b: TableData, priority: boolean): TableData;
+    invert(change: TableData, base: TableData): TableData;
+};
+declare class TableEmbed extends Module {
+    static register(): void;
+}
+export default TableEmbed;