@unicom-cloud/ui 0.8.108 → 0.8.110

package/types/pc/rich-text/blots/embed.d.ts

@@ -0,0 +1,18 @@
+import type { ScrollBlot } from '../parchment';
+import { EmbedBlot } from '../parchment';
+export interface EmbedContextRange {
+    startNode: Node | Text;
+    startOffset: number;
+    endNode?: Node | Text;
+    endOffset?: number;
+}
+declare class Embed extends EmbedBlot {
+    contentNode: HTMLSpanElement;
+    leftGuard: Text;
+    rightGuard: Text;
+    constructor(scroll: ScrollBlot, node: Node);
+    index(node: Node, offset: number): number;
+    restore(node: Text): EmbedContextRange | null;
+    update(mutations: MutationRecord[], context: Record<string, unknown>): void;
+}
+export default Embed;

package/types/pc/rich-text/blots/inline.d.ts

@@ -0,0 +1,12 @@
+import type { BlotConstructor } from '../parchment';
+import { InlineBlot } from '../parchment';
+declare class Inline extends InlineBlot {
+    static allowedChildren: BlotConstructor[];
+    static order: string[];
+    static compare(self: string, other: string): number;
+    formatAt(index: number, length: number, name: string, value: unknown): void;
+    optimize(context: {
+        [key: string]: any;
+    }): void;
+}
+export default Inline;

package/types/pc/rich-text/blots/scroll.d.ts

@@ -0,0 +1,49 @@
+import type { EmitterSource } from '../core/emitter.js';
+import Emitter from '../core/emitter.js';
+import Delta from '../delta';
+import type { Blot, Registry } from '../parchment';
+import { LeafBlot, ScrollBlot } from '../parchment';
+import Block, { BlockEmbed } from './block.js';
+import Container from './container.js';
+declare class Scroll extends ScrollBlot {
+    static blotName: string;
+    static className: string;
+    static tagName: string;
+    static defaultChild: typeof Block;
+    static allowedChildren: (typeof Block | typeof BlockEmbed | typeof Container)[];
+    emitter: Emitter;
+    batch: false | MutationRecord[];
+    constructor(registry: Registry, domNode: HTMLDivElement, { emitter }: {
+        emitter: Emitter;
+    });
+    batchStart(): void;
+    batchEnd(): void;
+    emitMount(blot: Blot): void;
+    emitUnmount(blot: Blot): void;
+    emitEmbedUpdate(blot: Blot, change: unknown): void;
+    deleteAt(index: number, length: number): void;
+    enable(enabled?: boolean): void;
+    formatAt(index: number, length: number, format: string, value: unknown): void;
+    insertAt(index: number, value: string, def?: unknown): void;
+    insertBefore(blot: Blot, ref?: Blot | null): void;
+    insertContents(index: number, delta: Delta): void;
+    isEnabled(): boolean;
+    leaf(index: number): [LeafBlot | null, number];
+    line(index: number): [Block | BlockEmbed | null, number];
+    lines(index?: number, length?: number): (Block | BlockEmbed)[];
+    optimize(context?: {
+        [key: string]: any;
+    }): void;
+    optimize(mutations?: MutationRecord[], context?: {
+        [key: string]: any;
+    }): void;
+    path(index: number): [Blot, number][];
+    remove(): void;
+    update(source?: EmitterSource): void;
+    update(mutations?: MutationRecord[]): void;
+    updateEmbedAt(index: number, key: string, change: unknown): void;
+    protected handleDragStart(event: DragEvent): void;
+    private deltaToRenderBlocks;
+    private createBlock;
+}
+export default Scroll;

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

@@ -0,0 +1,5 @@
+import { TextBlot } from '../parchment';
+declare class Text extends TextBlot {
+}
+declare function escapeText(text: string): string;
+export { Text as default, escapeText };

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

@@ -0,0 +1 @@
+export declare const RICH_TEXT_CLASS_NAME_PREFIX = "pqb-rich-text";

package/types/pc/rich-text/core/composition.d.ts

@@ -0,0 +1,12 @@
+import type Scroll from '../blots/scroll.js';
+import Emitter from './emitter.js';
+declare class Composition {
+    private scroll;
+    private emitter;
+    isComposing: boolean;
+    constructor(scroll: Scroll, emitter: Emitter);
+    private setupListeners;
+    private handleCompositionStart;
+    private handleCompositionEnd;
+}
+export default Composition;

package/types/pc/rich-text/core/editor.d.ts

@@ -0,0 +1,28 @@
+import type Scroll from '../blots/scroll.js';
+import Delta from '../delta';
+import { Range } from './selection.js';
+type SelectionInfo = {
+    newRange: Range;
+    oldRange: Range;
+};
+declare class Editor {
+    scroll: Scroll;
+    delta: Delta;
+    constructor(scroll: Scroll);
+    applyDelta(delta: Delta): Delta;
+    deleteText(index: number, length: number): Delta;
+    formatLine(index: number, length: number, formats?: Record<string, unknown>): Delta;
+    formatText(index: number, length: number, formats?: Record<string, unknown>): Delta;
+    getContents(index: number, length: number): Delta;
+    getDelta(): Delta;
+    getFormat(index: number, length?: number): Record<string, unknown>;
+    getHTML(index: number, length: number): string;
+    getText(index: number, length: number): string;
+    insertContents(index: number, contents: Delta): Delta;
+    insertEmbed(index: number, embed: string, value: unknown): Delta;
+    insertText(index: number, text: string, formats?: Record<string, unknown>): Delta;
+    isBlank(): boolean;
+    removeFormat(index: number, length: number): Delta;
+    update(change: Delta | null, mutations?: MutationRecord[], selectionInfo?: SelectionInfo | undefined): Delta;
+}
+export default Editor;

package/types/pc/rich-text/core/emitter.d.ts

@@ -0,0 +1,37 @@
+declare class Emitter {
+    static events: {
+        readonly EDITOR_CHANGE: "editor-change";
+        readonly SCROLL_BEFORE_UPDATE: "scroll-before-update";
+        readonly SCROLL_BLOT_MOUNT: "scroll-blot-mount";
+        readonly SCROLL_BLOT_UNMOUNT: "scroll-blot-unmount";
+        readonly SCROLL_OPTIMIZE: "scroll-optimize";
+        readonly SCROLL_UPDATE: "scroll-update";
+        readonly SCROLL_EMBED_UPDATE: "scroll-embed-update";
+        readonly SELECTION_CHANGE: "selection-change";
+        readonly TEXT_CHANGE: "text-change";
+        readonly COMPOSITION_BEFORE_START: "composition-before-start";
+        readonly COMPOSITION_START: "composition-start";
+        readonly COMPOSITION_BEFORE_END: "composition-before-end";
+        readonly COMPOSITION_END: "composition-end";
+    };
+    static sources: {
+        readonly API: "api";
+        readonly SILENT: "silent";
+        readonly USER: "user";
+    };
+    protected domListeners: Record<string, {
+        node: Node;
+        handler: Function;
+    }[]>;
+    constructor();
+    private emitter;
+    on(...args: any[]): void;
+    once(...args: any[]): void;
+    emit(...args: unknown[]): boolean;
+    off(...args: any[]): void;
+    offAll(...args: any[]): void;
+    handleDOM(event: Event, ...args: unknown[]): void;
+    listenDOM(eventName: string, node: Node, handler: EventListener): void;
+}
+export type EmitterSource = (typeof Emitter.sources)[keyof typeof Emitter.sources];
+export default Emitter;

package/types/pc/rich-text/core/instances.d.ts

@@ -0,0 +1,3 @@
+import type Rich from '../core.js';
+declare const _default: WeakMap<Node, Rich>;
+export default _default;

package/types/pc/rich-text/core/logger.d.ts

@@ -0,0 +1,7 @@
+declare const levels: readonly ["error", "warn", "log", "info"];
+export type DebugLevel = (typeof levels)[number];
+declare function namespace(ns: string): Record<DebugLevel, (...args: unknown[]) => void>;
+declare namespace namespace {
+    var level: (newLevel: DebugLevel | false) => void;
+}
+export default namespace;

package/types/pc/rich-text/core/module.d.ts

@@ -0,0 +1,8 @@
+import type Rich from './rich.js';
+declare abstract class Module<T extends {} = {}> {
+    rich: Rich;
+    protected options: Partial<T>;
+    static DEFAULTS: {};
+    constructor(rich: Rich, options?: Partial<T>);
+}
+export default Module;

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

@@ -0,0 +1,217 @@
+import type Block from '../blots/block.js';
+import type { BlockEmbed } from '../blots/block.js';
+import type Scroll from '../blots/scroll.js';
+import type { Op } from '../delta/index.js';
+import Delta from '../delta/index.js';
+import type Clipboard from '../modules/clipboard.js';
+import type History from '../modules/history.js';
+import type Keyboard from '../modules/keyboard.js';
+import type Uploader from '../modules/uploader.js';
+import * as Parchment from '../parchment/index.js';
+import Composition from './composition.js';
+import Editor from './editor.js';
+import type { EmitterSource } from './emitter.js';
+import Emitter from './emitter.js';
+import type { DebugLevel } from './logger.js';
+import Module from './module.js';
+import type { Bounds } from './selection.js';
+import Selection, { Range } from './selection.js';
+import type { ThemeConstructor } from './theme.js';
+import Theme from './theme.js';
+import type { Rect, ScrollRectIntoViewOptions } from './utils/scrollRectIntoView.js';
+declare const globalRegistry: Parchment.Registry;
+/**
+ * Options for initializing a Rich instance
+ */
+export interface RichOptions {
+    theme?: string;
+    debug?: DebugLevel | boolean;
+    registry?: Parchment.Registry;
+    /**
+     * Whether to disable the editing
+     * @default false
+     */
+    readOnly?: boolean;
+    /**
+     * Placeholder text to display when the editor is empty
+     * @default ""
+     */
+    placeholder?: string;
+    bounds?: HTMLElement | string | null;
+    modules?: Record<string, unknown>;
+    /**
+     * A list of formats that are recognized and can exist within the editor contents.
+     * `null` means all formats are allowed.
+     * @default null
+     */
+    formats?: string[] | null;
+}
+/**
+ * Similar to RichOptions, but with all properties expanded to their default values,
+ * and all selectors resolved to HTMLElements.
+ */
+export interface ExpandedRichOptions extends Omit<RichOptions, 'theme' | 'formats'> {
+    theme: ThemeConstructor;
+    registry: Parchment.Registry;
+    container: HTMLElement;
+    modules: Record<string, unknown>;
+    bounds?: HTMLElement | null;
+    readOnly: boolean;
+}
+declare class Rich {
+    static DEFAULTS: {
+        bounds: null;
+        modules: {
+            clipboard: boolean;
+            keyboard: boolean;
+            history: boolean;
+            uploader: boolean;
+        };
+        placeholder: string;
+        readOnly: false;
+        registry: Parchment.Registry;
+        theme: string;
+    };
+    static events: {
+        readonly EDITOR_CHANGE: "editor-change";
+        readonly SCROLL_BEFORE_UPDATE: "scroll-before-update";
+        readonly SCROLL_BLOT_MOUNT: "scroll-blot-mount";
+        readonly SCROLL_BLOT_UNMOUNT: "scroll-blot-unmount";
+        readonly SCROLL_OPTIMIZE: "scroll-optimize";
+        readonly SCROLL_UPDATE: "scroll-update";
+        readonly SCROLL_EMBED_UPDATE: "scroll-embed-update";
+        readonly SELECTION_CHANGE: "selection-change";
+        readonly TEXT_CHANGE: "text-change";
+        readonly COMPOSITION_BEFORE_START: "composition-before-start";
+        readonly COMPOSITION_START: "composition-start";
+        readonly COMPOSITION_BEFORE_END: "composition-before-end";
+        readonly COMPOSITION_END: "composition-end";
+    };
+    static sources: {
+        readonly API: "api";
+        readonly SILENT: "silent";
+        readonly USER: "user";
+    };
+    static imports: Record<string, unknown>;
+    static debug(limit: DebugLevel | boolean): void;
+    static find(node: Node, bubble?: boolean): Parchment.Blot | Rich | null;
+    static import(name: 'core/module'): typeof Module;
+    static import(name: `themes/${string}`): typeof Theme;
+    static import(name: '../parchment'): typeof Parchment;
+    static import(name: 'delta'): typeof Delta;
+    static import(name: string): unknown;
+    static register(targets: Record<string, Parchment.RegistryDefinition | Record<string, unknown> | Theme | Module | Function>, overwrite?: boolean): void;
+    static register(target: Parchment.RegistryDefinition, overwrite?: boolean): void;
+    static register(path: string, target: any, overwrite?: boolean): void;
+    container: HTMLElement;
+    root: HTMLDivElement;
+    scroll: Scroll;
+    emitter: Emitter;
+    protected allowReadOnlyEdits: boolean;
+    editor: Editor;
+    composition: Composition;
+    selection: Selection;
+    theme: Theme;
+    keyboard: Keyboard;
+    clipboard: Clipboard;
+    history: History;
+    uploader: Uploader;
+    options: ExpandedRichOptions;
+    constructor(container: HTMLElement | string, options?: RichOptions);
+    addContainer(container: string, refNode?: Node | null): HTMLDivElement;
+    addContainer(container: HTMLElement, refNode?: Node | null): HTMLElement;
+    blur(): void;
+    deleteText(range: Range, source?: EmitterSource): Delta;
+    deleteText(index: number, length: number, source?: EmitterSource): Delta;
+    disable(): void;
+    editReadOnly<T>(modifier: () => T): T;
+    enable(enabled?: boolean): void;
+    focus(options?: {
+        preventScroll?: boolean;
+    }): void;
+    format(name: string, value: unknown, source?: EmitterSource): Delta;
+    formatLine(index: number, length: number, formats: Record<string, unknown>, source?: EmitterSource): Delta;
+    formatLine(index: number, length: number, name: string, value?: unknown, source?: EmitterSource): Delta;
+    formatText(range: Range, name: string, value: unknown, source?: EmitterSource): Delta;
+    formatText(index: number, length: number, name: string, value: unknown, source?: EmitterSource): Delta;
+    formatText(index: number, length: number, formats: Record<string, unknown>, source?: EmitterSource): Delta;
+    getBounds(index: number | Range, length?: number): Bounds | null;
+    getContents(index?: number, length?: number): Delta;
+    getFormat(index?: number, length?: number): {
+        [format: string]: unknown;
+    };
+    getFormat(range?: Range): {
+        [format: string]: unknown;
+    };
+    getIndex(blot: Parchment.Blot): number;
+    getLength(): number;
+    getLeaf(index: number): [Parchment.LeafBlot | null, number];
+    getLine(index: number): [Block | BlockEmbed | null, number];
+    getLines(range: Range): (Block | BlockEmbed)[];
+    getLines(index?: number, length?: number): (Block | BlockEmbed)[];
+    getModule(name: string): unknown;
+    getSelection(focus: true): Range;
+    getSelection(focus?: boolean): Range | null;
+    getSemanticHTML(range: Range): string;
+    getSemanticHTML(index?: number, length?: number): string;
+    getText(range?: Range): string;
+    getText(index?: number, length?: number): string;
+    hasFocus(): boolean;
+    insertEmbed(index: number, embed: string, value: unknown, source?: EmitterSource): Delta;
+    insertText(index: number, text: string, source?: EmitterSource): Delta;
+    insertText(index: number, text: string, formats: Record<string, unknown>, source?: EmitterSource): Delta;
+    insertText(index: number, text: string, name: string, value: unknown, source?: EmitterSource): Delta;
+    isEnabled(): boolean;
+    off(...args: Parameters<(typeof Emitter)['prototype']['off']>): void;
+    on(event: (typeof Emitter)['events']['TEXT_CHANGE'], handler: (delta: Delta, oldContent: Delta, source: EmitterSource) => void): Emitter;
+    on(event: (typeof Emitter)['events']['SELECTION_CHANGE'], handler: (range: Range, oldRange: Range, source: EmitterSource) => void): Emitter;
+    on(event: (typeof Emitter)['events']['EDITOR_CHANGE'], handler: (...args: [
+        (typeof Emitter)['events']['TEXT_CHANGE'],
+        Delta,
+        Delta,
+        EmitterSource
+    ] | [
+        (typeof Emitter)['events']['SELECTION_CHANGE'],
+        Range,
+        Range,
+        EmitterSource
+    ]) => void): Emitter;
+    on(event: string, ...args: unknown[]): Emitter;
+    once(...args: Parameters<(typeof Emitter)['prototype']['once']>): void;
+    removeFormat(index: number, length: number, source?: EmitterSource): Delta;
+    scrollRectIntoView(rect: Rect, options?: ScrollRectIntoViewOptions): void;
+    /**
+     * @deprecated Use Rich#scrollSelectionIntoView() instead.
+     */
+    scrollIntoView(): void;
+    /**
+     * Scroll the current selection into the visible area.
+     * If the selection is already visible, no scrolling will occur.
+     */
+    scrollSelectionIntoView(options?: ScrollRectIntoViewOptions): void;
+    setContents(delta: Delta | Op[], source?: EmitterSource): Delta;
+    setSelection(range: Range | null, source?: EmitterSource): void;
+    setSelection(index: number, source?: EmitterSource): void;
+    setSelection(index: number, length?: number, source?: EmitterSource): void;
+    setSelection(index: number, source?: EmitterSource): void;
+    setText(text: string, source?: EmitterSource): Delta;
+    update(source?: EmitterSource): void;
+    updateContents(delta: Delta | Op[], source?: EmitterSource): Delta;
+}
+declare function expandConfig(containerOrSelector: HTMLElement | string, options: RichOptions): ExpandedRichOptions;
+type NormalizedIndexLength = [
+    number,
+    number,
+    Record<string, unknown>,
+    EmitterSource
+];
+declare function overload(index: number, source?: EmitterSource): NormalizedIndexLength;
+declare function overload(index: number, length: number, source?: EmitterSource): NormalizedIndexLength;
+declare function overload(index: number, length: number, format: string, value: unknown, source?: EmitterSource): NormalizedIndexLength;
+declare function overload(index: number, length: number, format: Record<string, unknown>, source?: EmitterSource): NormalizedIndexLength;
+declare function overload(range: Range, source?: EmitterSource): NormalizedIndexLength;
+declare function overload(range: Range, format: string, value: unknown, source?: EmitterSource): NormalizedIndexLength;
+declare function overload(range: Range, format: Record<string, unknown>, source?: EmitterSource): NormalizedIndexLength;
+export { Parchment, Range };
+export type { Bounds, DebugLevel, EmitterSource };
+export { Rich as default, expandConfig, globalRegistry, overload };

package/types/pc/rich-text/core/selection.d.ts

@@ -0,0 +1,74 @@
+import type Cursor from '../blots/cursor.js';
+import type Scroll from '../blots/scroll.js';
+import type { EmitterSource } from './emitter.js';
+import Emitter from './emitter.js';
+type NativeRange = AbstractRange;
+interface NormalizedRange {
+    start: {
+        node: NativeRange['startContainer'];
+        offset: NativeRange['startOffset'];
+    };
+    end: {
+        node: NativeRange['endContainer'];
+        offset: NativeRange['endOffset'];
+    };
+    native: NativeRange;
+}
+export interface Bounds {
+    bottom: number;
+    height: number;
+    left: number;
+    right: number;
+    top: number;
+    width: number;
+}
+export declare class Range {
+    index: number;
+    length: number;
+    constructor(index: number, length?: number);
+}
+declare class Selection {
+    scroll: Scroll;
+    emitter: Emitter;
+    composing: boolean;
+    mouseDown: boolean;
+    root: HTMLElement;
+    cursor: Cursor;
+    savedRange: Range;
+    lastRange: Range | null;
+    lastNative: NormalizedRange | null;
+    constructor(scroll: Scroll, emitter: Emitter);
+    handleComposition(): void;
+    handleDragging(): void;
+    focus(): void;
+    format(format: string, value: unknown): void;
+    getBounds(index: number, length?: number): DOMRect | {
+        bottom: number;
+        height: number;
+        left: number;
+        right: number;
+        top: number;
+        width: number;
+    } | null;
+    getNativeRange(): NormalizedRange | null;
+    getRange(): [Range, NormalizedRange] | [null, null];
+    hasFocus(): boolean;
+    normalizedToRange(range: NormalizedRange): Range;
+    normalizeNative(nativeRange: NativeRange): {
+        start: {
+            node: Node;
+            offset: number;
+        };
+        end: {
+            node: Node;
+            offset: number;
+        };
+        native: AbstractRange;
+    } | null;
+    rangeToNative(range: Range): [Node | null, number, Node | null, number];
+    setNativeRange(startNode: Node | null, startOffset?: number, endNode?: Node | null, endOffset?: number | undefined, force?: boolean): void;
+    setRange(range: Range | null, force: boolean, source?: EmitterSource): void;
+    setRange(range: Range | null, source?: EmitterSource): void;
+    update(source?: EmitterSource): void;
+}
+export default Selection;

package/types/pc/rich-text/core/theme.d.ts

@@ -0,0 +1,32 @@
+import type Rich from '../core.js';
+import type Clipboard from '../modules/clipboard.js';
+import type History from '../modules/history.js';
+import type Keyboard from '../modules/keyboard.js';
+import type { ToolbarProps } from '../modules/toolbar.js';
+import type Uploader from '../modules/uploader.js';
+export interface ThemeOptions {
+    modules: Record<string, unknown> & {
+        toolbar?: null | ToolbarProps;
+    };
+}
+declare class Theme {
+    protected rich: Rich;
+    protected options: ThemeOptions;
+    static DEFAULTS: ThemeOptions;
+    static themes: {
+        default: typeof Theme;
+    };
+    modules: ThemeOptions['modules'];
+    constructor(rich: Rich, options: ThemeOptions);
+    init(): void;
+    addModule(name: 'clipboard'): Clipboard;
+    addModule(name: 'keyboard'): Keyboard;
+    addModule(name: 'uploader'): Uploader;
+    addModule(name: 'history'): History;
+    addModule(name: string): unknown;
+}
+export interface ThemeConstructor {
+    new (rich: Rich, options: unknown): Theme;
+    DEFAULTS: ThemeOptions;
+}
+export default Theme;

package/types/pc/rich-text/core/utils/createRegistryWithFormats.d.ts

@@ -0,0 +1,5 @@
+import { Registry } from '../../parchment';
+declare const createRegistryWithFormats: (formats: string[], sourceRegistry: Registry, debug: {
+    error: (errorMessage: string) => void;
+}) => Registry;
+export default createRegistryWithFormats;

package/types/pc/rich-text/core/utils/scrollRectIntoView.d.ts

@@ -0,0 +1,11 @@
+export type Rect = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+export interface ScrollRectIntoViewOptions {
+    smooth?: boolean;
+}
+declare const scrollRectIntoView: (root: HTMLElement, targetRect: Rect, options?: ScrollRectIntoViewOptions) => void;
+export default scrollRectIntoView;

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

@@ -0,0 +1,7 @@
+import type { Bounds, DebugLevel, EmitterSource, ExpandedRichOptions, RichOptions } from './core/rich.js';
+import Rich, { Parchment, Range } from './core/rich.js';
+import Delta, { AttributeMap, Op, OpIterator } from './delta';
+export { default as Module } from './core/module.js';
+export { AttributeMap, Delta, Op, OpIterator, Parchment, Range };
+export type { Bounds, DebugLevel, EmitterSource, ExpandedRichOptions, RichOptions, };
+export default Rich;

package/types/pc/rich-text/delta/AttributeMap.d.ts

@@ -0,0 +1,10 @@
+interface AttributeMap {
+    [key: string]: unknown;
+}
+declare namespace AttributeMap {
+    function compose(a?: AttributeMap, b?: AttributeMap, keepNull?: boolean): AttributeMap | undefined;
+    function diff(a?: AttributeMap, b?: AttributeMap): AttributeMap | undefined;
+    function invert(attr?: AttributeMap, base?: AttributeMap): AttributeMap;
+    function transform(a: AttributeMap | undefined, b: AttributeMap | undefined, priority?: boolean): AttributeMap | undefined;
+}
+export default AttributeMap;

package/types/pc/rich-text/delta/Op.d.ts

@@ -0,0 +1,11 @@
+import AttributeMap from './AttributeMap';
+interface Op {
+    insert?: string | Record<string, unknown>;
+    delete?: number;
+    retain?: number | Record<string, unknown>;
+    attributes?: AttributeMap;
+}
+declare namespace Op {
+    function length(op: Op): number;
+}
+export default Op;

package/types/pc/rich-text/delta/OpIterator.d.ts

@@ -0,0 +1,13 @@
+import Op from './Op';
+export default class Iterator {
+    ops: Op[];
+    index: number;
+    offset: number;
+    constructor(ops: Op[]);
+    hasNext(): boolean;
+    next(length?: number): Op;
+    peek(): Op;
+    peekLength(): number;
+    peekType(): string;
+    rest(): Op[];
+}

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

@@ -0,0 +1,45 @@
+import diff from '@unicom-cloud/utils/diff';
+import AttributeMap from './AttributeMap';
+import Op from './Op';
+import OpIterator from './OpIterator';
+interface EmbedHandler<T> {
+    compose(a: T, b: T, keepNull: boolean): T;
+    invert(a: T, b: T): T;
+    transform(a: T, b: T, priority: boolean): T;
+}
+declare class Delta {
+    static Op: typeof Op;
+    static OpIterator: typeof OpIterator;
+    static AttributeMap: typeof AttributeMap;
+    private static handlers;
+    static registerEmbed<T>(embedType: string, handler: EmbedHandler<T>): void;
+    static unregisterEmbed(embedType: string): void;
+    private static getHandler;
+    ops: Op[];
+    constructor(ops?: Op[] | {
+        ops: Op[];
+    });
+    insert(arg: string | Record<string, unknown>, attributes?: AttributeMap | null): this;
+    delete(length: number): this;
+    retain(length: number | Record<string, unknown>, attributes?: AttributeMap | null): this;
+    push(newOp: Op): this;
+    chop(): this;
+    filter(predicate: (op: Op, index: number) => boolean): Op[];
+    forEach(predicate: (op: Op, index: number) => void): void;
+    map<T>(predicate: (op: Op, index: number) => T): T[];
+    partition(predicate: (op: Op) => boolean): [Op[], Op[]];
+    reduce<T>(predicate: (accum: T, curr: Op, index: number) => T, initialValue: T): T;
+    changeLength(): number;
+    length(): number;
+    slice(start?: number, end?: number): Delta;
+    compose(other: Delta): Delta;
+    concat(other: Delta): Delta;
+    diff(other: Delta, cursor?: number | diff.CursorInfo): Delta;
+    eachLine(predicate: (line: Delta, attributes: AttributeMap, index: number) => boolean | void, newline?: string): void;
+    invert(base: Delta): Delta;
+    transform(index: number, priority?: boolean): number;
+    transform(other: Delta, priority?: boolean): Delta;
+    transformPosition(index: number, priority?: boolean): number;
+}
+export default Delta;
+export { AttributeMap, Op, OpIterator };