@y/y 14.0.0-16

package/dist/src/types/YText.d.ts

@@ -0,0 +1,216 @@
+export class ItemTextListPosition {
+    /**
+     * @param {Item|null} left
+     * @param {Item|null} right
+     * @param {number} index
+     * @param {Map<string,any>} currentAttributes
+     * @param {AbstractAttributionManager} am
+     */
+    constructor(left: Item | null, right: Item | null, index: number, currentAttributes: Map<string, any>, am: AbstractAttributionManager);
+    left: Item | null;
+    right: Item | null;
+    index: number;
+    currentAttributes: Map<string, any>;
+    am: AbstractAttributionManager;
+    /**
+     * Only call this if you know that this.right is defined
+     */
+    forward(): void;
+    /**
+     * @param {Transaction} transaction
+     * @param {import('../utils/types.js').YType} parent
+     * @param {number} length
+     * @param {Object<string,any>} attributes
+     *
+     * @function
+     */
+    formatText(transaction: Transaction, parent: import("../utils/types.js").YType, length: number, attributes: {
+        [x: string]: any;
+    }): void;
+}
+export function insertText(transaction: Transaction, parent: import("../utils/types.js").YType, currPos: ItemTextListPosition, text: string | object | import("../utils/types.js").YType, attributes: {
+    [x: string]: any;
+}): void;
+export function cleanupYTextFormatting(type: YText<any>): number;
+export function cleanupYTextAfterTransaction(transaction: Transaction): void;
+export function deleteText(transaction: Transaction, currPos: ItemTextListPosition, length: number): ItemTextListPosition;
+/**
+ * The Quill Delta format represents changes on a text document with
+ * formatting information. For more information visit {@link https://quilljs.com/docs/delta/|Quill Delta}
+ *
+ * @example
+ *   {
+ *     ops: [
+ *       { insert: 'Gandalf', attributes: { bold: true } },
+ *       { insert: ' the ' },
+ *       { insert: 'Grey', attributes: { color: '#cccccc' } }
+ *     ]
+ *   }
+ *
+ */
+/**
+  * Attributes that can be assigned to a selection of text.
+  *
+  * @example
+  *   {
+  *     bold: true,
+  *     font-size: '40px'
+  *   }
+  *
+  * @typedef {Object} TextAttributes
+  */
+/**
+ * Type that represents text with formatting information.
+ *
+ * This type replaces y-richtext as this implementation is able to handle
+ * block formats (format information on a paragraph), embeds (complex elements
+ * like pictures and videos), and text formats (**bold**, *italic*).
+ *
+ * @template {{ [key:string]:any } | import('../utils/types.js').YType} [Embeds={ [key:string]:any } | import('../utils/types.js').YType]
+ * @extends {AbstractType<import('lib0/delta').TextDelta<Embeds>>}
+ */
+export class YText<Embeds extends {
+    [key: string]: any;
+} | import("../utils/types.js").YType = AbstractType<any, any> | {
+    [key: string]: any;
+}> extends AbstractType<import("lib0/delta").TextDelta<Embeds>, any> {
+    /**
+     * @param {String} [string] The initial value of the YText.
+     */
+    constructor(string?: string);
+    /**
+     * Array of pending operations on this type
+     * @type {Array<function():void>?}
+     */
+    _pending: Array<() => void> | null;
+    /**
+     * Whether this YText contains formatting attributes.
+     * This flag is updated when a formatting item is integrated (see ContentFormat.integrate)
+     */
+    _hasFormatting: boolean;
+    /**
+     * Number of characters of this text type.
+     *
+     * @type {number}
+     */
+    get length(): number;
+    /**
+     * Makes a copy of this data type that can be included somewhere else.
+     *
+     * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
+     *
+     * @return {YText<Embeds>}
+     */
+    clone(): YText<Embeds>;
+    /**
+     * Returns the unformatted string representation of this YText type.
+     *
+     * @return {string}
+     * @public
+     */
+    public toJSON(): string;
+    /**
+     * Insert text at a given index.
+     *
+     * @param {number} index The index at which to start inserting.
+     * @param {String} text The text to insert at the specified position.
+     * @param {TextAttributes} [attributes] Optionally define some formatting
+     *                                    information to apply on the inserted
+     *                                    Text.
+     * @public
+     */
+    public insert(index: number, text: string, attributes?: TextAttributes): void;
+    /**
+     * Inserts an embed at a index.
+     *
+     * @param {number} index The index to insert the embed at.
+     * @param {Object | AbstractType<any>} embed The Object that represents the embed.
+     * @param {TextAttributes} [attributes] Attribute information to apply on the
+     *                                    embed
+     *
+     * @public
+     */
+    public insertEmbed(index: number, embed: Object | AbstractType<any>, attributes?: TextAttributes): void;
+    /**
+     * Deletes text starting from an index.
+     *
+     * @param {number} index Index at which to start deleting.
+     * @param {number} length The number of characters to remove. Defaults to 1.
+     *
+     * @public
+     */
+    public delete(index: number, length: number): void;
+    /**
+     * Assigns properties to a range of text.
+     *
+     * @param {number} index The position where to start formatting.
+     * @param {number} length The amount of characters to assign properties to.
+     * @param {TextAttributes} attributes Attribute information to apply on the
+     *                                    text.
+     *
+     * @public
+     */
+    public format(index: number, length: number, attributes: TextAttributes): void;
+    /**
+     * Removes an attribute.
+     *
+     * @note Xml-Text nodes don't have attributes. You can use this feature to assign properties to complete text-blocks.
+     *
+     * @param {String} attributeName The attribute name that is to be removed.
+     *
+     * @public
+     */
+    public removeAttribute(attributeName: string): void;
+    /**
+     * Sets or updates an attribute.
+     *
+     * @note Xml-Text nodes don't have attributes. You can use this feature to assign properties to complete text-blocks.
+     *
+     * @param {String} attributeName The attribute name that is to be set.
+     * @param {any} attributeValue The attribute value that is to be set.
+     *
+     * @public
+     */
+    public setAttribute(attributeName: string, attributeValue: any): void;
+    /**
+     * Returns an attribute value that belongs to the attribute name.
+     *
+     * @note Xml-Text nodes don't have attributes. You can use this feature to assign properties to complete text-blocks.
+     *
+     * @param {String} attributeName The attribute name that identifies the
+     *                               queried value.
+     * @return {any} The queried attribute value.
+     *
+     * @public
+     */
+    public getAttribute(attributeName: string): any;
+    /**
+     * Returns all attribute name/value pairs in a JSON Object.
+     *
+     * @note Xml-Text nodes don't have attributes. You can use this feature to assign properties to complete text-blocks.
+     *
+     * @return {Object<string, any>} A JSON Object that describes the attributes.
+     *
+     * @public
+     */
+    public getAttributes(): {
+        [x: string]: any;
+    };
+    /**
+     * @param {this} other
+     */
+    [traits.EqualityTraitSymbol](other: this): boolean;
+}
+export function readYText(_decoder: UpdateDecoderV1 | UpdateDecoderV2): import("../utils/types.js").YType;
+/**
+ * Attributes that can be assigned to a selection of text.
+ */
+export type TextAttributes = Object;
+import { Item } from '../internals.js';
+import { AbstractAttributionManager } from '../internals.js';
+import { Transaction } from '../internals.js';
+import { AbstractType } from '../internals.js';
+import * as traits from 'lib0/traits';
+import { UpdateDecoderV1 } from '../internals.js';
+import { UpdateDecoderV2 } from '../internals.js';
+//# sourceMappingURL=YText.d.ts.map

package/dist/src/types/YText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"YText.d.ts","sourceRoot":"","sources":["../../../src/types/YText.js"],"names":[],"mappings":"AAkCA;IACE;;;;;;OAMG;IACH,kBANW,IAAI,GAAC,IAAI,SACT,IAAI,GAAC,IAAI,SACT,MAAM,qBACN,GAAG,CAAC,MAAM,EAAC,GAAG,CAAC,MACf,0BAA0B,EAQpC;IALC,kBAAgB;IAChB,mBAAkB;IAClB,cAAkB;IAClB,oCAA0C;IAC1C,+BAAY;IAGd;;OAEG;IACH,gBAgBC;IAED;;;;;;;OAOG;IACH,wBAPW,WAAW,UACX,OAAO,mBAAmB,EAAE,KAAK,UACjC,MAAM;;aAuFhB;CACF;AA8KM,wCATI,WAAW,UACX,OAAO,mBAAmB,EAAE,KAAK,WACjC,oBAAoB,QACpB,MAAM,GAAC,MAAM,GAAC,OAAO,mBAAmB,EAAE,KAAK;;SA4BzD;AA2GM,6CAHI,KAAK,CAAC,GAAG,CAAC,GACT,MAAM,CA2BjB;AAQM,0DAFI,WAAW,QAsCrB;AAWM,wCARI,WAAW,WACX,oBAAoB,UACpB,MAAM,GACL,oBAAoB,CAwD/B;AAED;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;;;IAUI;AAEJ;;;;;;;;;GASG;AACH,mBAHyE,MAAM,SAAjE;IAAE,CAAC,GAAG,EAAC,MAAM,GAAE,GAAG,CAAA;CAAE,GAAG,OAAO,mBAAmB,EAAE,KAAM;;;IAIrE;;OAEG;IACH,6BAgBC;IAdC;;;OAGG;IACH,UAFU,KAAK,CAAC,MAAW,IAAI,CAAC,OAAC,CAEyC;IAK1E;;;OAGG;IACH,wBAA2B;IAG7B;;;;OAIG;IACH,cAFU,MAAM,CAKf;IAgBD;;;;;;OAMG;IACH,SAFY,KAAK,CAAC,MAAM,CAAC,CASxB;IAqCD;;;;;OAKG;IACH,iBAHY,MAAM,CAKjB;IAED;;;;;;;;;OASG;IACH,qBAPW,MAAM,6BAEN,cAAc,QAuBxB;IAED;;;;;;;;;OASG;IACH,0BAPW,MAAM,SACN,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,eAC1B,cAAc,QAexB;IAED;;;;;;;OAOG;IACH,qBALW,MAAM,UACN,MAAM,QAgBhB;IAED;;;;;;;;;OASG;IACH,qBAPW,MAAM,UACN,MAAM,cACN,cAAc,QAqBxB;IAED;;;;;;;;OAQG;IACH,oDAQC;IAED;;;;;;;;;OASG;IACH,2DAJW,GAAG,QAYb;IAED;;;;;;;;;;OAUG;IACH,4CAJY,GAAG,CAMd;IAED;;;;;;;;OAQG;IACH;;MAEC;IASD;;OAEG;IACH,oCAFW,IAAI,WAId;CACF;AASM,oCANI,eAAe,GAAG,eAAe,GAChC,OAAO,mBAAmB,EAAE,KAAK,CAKG;;;;6BAvTlC,MAAM;qBAnlBb,iBAAiB;2CAAjB,iBAAiB;4BAAjB,iBAAiB;6BAAjB,iBAAiB;wBAGA,aAAa;gCAH9B,iBAAiB;gCAAjB,iBAAiB"}

package/dist/src/types/YXmlElement.d.ts

@@ -0,0 +1,106 @@
+/**
+ * @typedef {Object|number|null|Array<any>|string|Uint8Array|AbstractType<any>} ValueTypes
+ */
+/**
+ * An YXmlElement imitates the behavior of a
+ * https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element
+ *
+ * * An YXmlElement has attributes (key value pairs)
+ * * An YXmlElement has childElements that must inherit from YXmlElement
+ *
+ * @template {{ [key: string]: any }} [Attrs={ [key: string]: string }]
+ * @template {any} [Children=any]
+ * @extends YXmlFragment<Children,Attrs>
+ */
+export class YXmlElement<Attrs extends {
+    [key: string]: any;
+} = {
+    [key: string]: string;
+}, Children extends unknown = any> extends YXmlFragment<Children, Attrs> {
+    constructor(nodeName?: string);
+    nodeName: string;
+    /**
+     * @type {Map<string, any>|null}
+     */
+    _prelimAttrs: Map<string, any> | null;
+    /**
+     * @type {YXmlElement|YXmlText|null}
+     */
+    get nextSibling(): YXmlElement | YXmlText | null;
+    /**
+     * @type {YXmlElement|YXmlText|null}
+     */
+    get prevSibling(): YXmlElement | YXmlText | null;
+    /**
+     * Creates an Item with the same effect as this Item (without position effect)
+     *
+     * @return {this}
+     */
+    _copy(): this;
+    /**
+     * Makes a copy of this data type that can be included somewhere else.
+     *
+     * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
+     *
+     * @return {this}
+     */
+    clone(): this;
+    /**
+     * Removes an attribute from this YXmlElement.
+     *
+     * @param {string} attributeName The attribute name that is to be removed.
+     *
+     * @public
+     */
+    public removeAttribute(attributeName: string): void;
+    /**
+     * Sets or updates an attribute.
+     *
+     * @template {keyof Attrs & string} KEY
+     *
+     * @param {KEY} attributeName The attribute name that is to be set.
+     * @param {Attrs[KEY]} attributeValue The attribute value that is to be set.
+     *
+     * @public
+     */
+    public setAttribute<KEY extends keyof Attrs & string>(attributeName: KEY, attributeValue: Attrs[KEY]): void;
+    /**
+     * Returns an attribute value that belongs to the attribute name.
+     *
+     * @template {keyof Attrs & string} KEY
+     *
+     * @param {KEY} attributeName The attribute name that identifies the
+     *                               queried value.
+     * @return {Attrs[KEY]|undefined} The queried attribute value.
+     *
+     * @public
+     */
+    public getAttribute<KEY extends keyof Attrs & string>(attributeName: KEY): Attrs[KEY] | undefined;
+    /**
+     * Returns whether an attribute exists
+     *
+     * @param {string} attributeName The attribute name to check for existence.
+     * @return {boolean} whether the attribute exists.
+     *
+     * @public
+     */
+    public hasAttribute(attributeName: string): boolean;
+    /**
+     * Returns all attribute name/value pairs in a JSON Object.
+     *
+     * @param {Snapshot} [snapshot]
+     * @return {{ [Key in Extract<keyof Attrs,string>]?: Attrs[Key]}} A JSON Object that describes the attributes.
+     *
+     * @public
+     */
+    public getAttributes(snapshot?: Snapshot): { [Key in Extract<keyof Attrs, string>]?: Attrs[Key]; };
+}
+export function readYXmlElement(decoder: UpdateDecoderV1 | UpdateDecoderV2): import("../utils/types.js").YType;
+export type ValueTypes = Object | number | null | Array<any> | string | Uint8Array | AbstractType<any>;
+import { YXmlFragment } from '../internals.js';
+import { YXmlText } from '../internals.js';
+import { Snapshot } from '../internals.js';
+import { UpdateDecoderV1 } from '../internals.js';
+import { UpdateDecoderV2 } from '../internals.js';
+import { AbstractType } from '../internals.js';
+//# sourceMappingURL=YXmlElement.d.ts.map

package/dist/src/types/YXmlElement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"YXmlElement.d.ts","sourceRoot":"","sources":["../../../src/types/YXmlElement.js"],"names":[],"mappings":"AAeA;;GAEG;AAEH;;;;;;;;;;GAUG;AACH,yBAJuC,KAAK,SAA/B;IAAG,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAG;;GACjB,QAAQ;IAI1B,+BAOC;IALC,iBAAwB;IACxB;;OAEG;IACH,cAFU,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAAC,IAAI,CAEF;IAG/B;;OAEG;IACH,mBAFU,WAAW,GAAC,QAAQ,GAAC,IAAI,CAKlC;IAED;;OAEG;IACH,mBAFU,WAAW,GAAC,QAAQ,GAAC,IAAI,CAKlC;IAoBD;;;;OAIG;IACH,SAFY,IAAI,CAIf;IAED;;;;;;OAMG;IACH,SAFY,IAAI,CAaf;IA6BD;;;;;;OAMG;IACH,sCAJW,MAAM,QAYhB;IAED;;;;;;;;;OASG;IACH,oBAPoC,GAAG,SAAzB,MAAM,KAAK,GAAG,MAAO,iBAExB,GAAG,kBACH,KAAK,CAAC,GAAG,CAAC,QAYpB;IAED;;;;;;;;;;OAUG;IACH,oBARoC,GAAG,SAAzB,MAAM,KAAK,GAAG,MAAO,iBAExB,GAAG,GAEF,KAAK,CAAC,GAAG,CAAC,GAAC,SAAS,CAM/B;IAED;;;;;;;OAOG;IACH,mCALW,MAAM,GACL,OAAO,CAMlB;IAED;;;;;;;OAOG;IACH,gCALW,QAAQ,GACP,GAAG,GAAG,IAAI,OAAO,CAAC,MAAM,KAAK,EAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,GAAC,CAM/D;CAcF;AAQM,yCALI,eAAe,GAAG,eAAe,GAChC,OAAO,mBAAmB,EAAE,KAAK,CAI+B;yBAlN/D,MAAM,GAAC,MAAM,GAAC,IAAI,GAAC,KAAK,CAAC,GAAG,CAAC,GAAC,MAAM,GAAC,UAAU,GAAC,YAAY,CAAC,GAAG,CAAC;6BAHvE,iBAAiB;yBAAjB,iBAAiB;yBAAjB,iBAAiB;gCAAjB,iBAAiB;gCAAjB,iBAAiB;6BAAjB,iBAAiB"}

package/dist/src/types/YXmlFragment.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Define the elements to which a set of CSS queries apply.
+ * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors|CSS_Selectors}
+ *
+ * @example
+ *   query = '.classSelector'
+ *   query = 'nodeSelector'
+ *   query = '#idSelector'
+ *
+ * @typedef {string} CSS_Selector
+ */
+/**
+ * Dom filter function.
+ *
+ * @callback domFilter
+ * @param {string} nodeName The nodeName of the element
+ * @param {Map} attributes The map of attributes.
+ * @return {boolean} Whether to include the Dom node in the YXmlElement.
+ */
+/**
+ * Represents a list of {@link YXmlElement}.and {@link YXmlText} types.
+ * A YxmlFragment is similar to a {@link YXmlElement}, but it does not have a
+ * nodeName and it does not have attributes. Though it can be bound to a DOM
+ * element - in this case the attributes and the nodeName are not shared.
+ *
+ * @public
+ * @template {any} [Children=any]
+ * @template {{[K in string]:any}} [Attrs={}]
+ * @extends AbstractType<delta.Delta<any,Attrs,Children,any>>
+ */
+export class YXmlFragment<Children extends unknown = any, Attrs extends { [K in string]: any; } = {}> extends AbstractType<delta.Delta<any, Attrs, Children, any, any>, any> {
+    constructor();
+    /**
+     * @todo remove _prelimContent
+     * @type {Array<any>|null}
+     */
+    _prelimContent: Array<any> | null;
+    /**
+     * @type {YXmlElement|YXmlText|null}
+     */
+    get firstChild(): YXmlElement | YXmlText | null;
+    /**
+     * Makes a copy of this data type that can be included somewhere else.
+     *
+     * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
+     *
+     * @return {this}
+     */
+    clone(): this;
+    get length(): number;
+    /**
+     * @return {string}
+     */
+    toJSON(): string;
+    /**
+     * Inserts new content at an index.
+     *
+     * @example
+     *  // Insert character 'a' at position 0
+     *  xml.insert(0, [new Y.XmlText('text')])
+     *
+     * @param {number} index The index to insert content at
+     * @param {Array<YXmlElement|YXmlText|YXmlHook>} content The array of content
+     */
+    insert(index: number, content: Array<YXmlElement | YXmlText | YXmlHook>): void;
+    /**
+     * Inserts new content at an index.
+     *
+     * @example
+     *  // Insert character 'a' at position 0
+     *  xml.insert(0, [new Y.XmlText('text')])
+     *
+     * @param {null|Item|YXmlElement|YXmlText} ref The index to insert content at
+     * @param {Array<YXmlElement|YXmlText>} content The array of content
+     */
+    insertAfter(ref: null | Item | YXmlElement | YXmlText, content: Array<YXmlElement | YXmlText>): void;
+    /**
+     * Deletes elements starting from an index.
+     *
+     * @param {number} index Index at which to start deleting elements
+     * @param {number} [length=1] The number of elements to remove. Defaults to 1.
+     */
+    delete(index: number, length?: number): void;
+    /**
+     * Transforms this YArray to a JavaScript Array.
+     *
+     * @return {Array<YXmlElement|YXmlText|YXmlHook>}
+     */
+    toArray(): Array<YXmlElement | YXmlText | YXmlHook>;
+    /**
+     * Appends content to this YArray.
+     *
+     * @param {Array<YXmlElement|YXmlText>} content Array of content to append.
+     */
+    push(content: Array<YXmlElement | YXmlText>): void;
+    /**
+     * Prepends content to this YArray.
+     *
+     * @param {Array<YXmlElement|YXmlText>} content Array of content to prepend.
+     */
+    unshift(content: Array<YXmlElement | YXmlText>): void;
+    /**
+     * Returns the i-th element from a YArray.
+     *
+     * @param {number} index The index of the element to return from the YArray
+     * @return {YXmlElement|YXmlText}
+     */
+    get(index: number): YXmlElement | YXmlText;
+    /**
+     * Returns a portion of this YXmlFragment into a JavaScript Array selected
+     * from start to end (end not included).
+     *
+     * @param {number} [start]
+     * @param {number} [end]
+     * @return {Array<YXmlElement|YXmlText>}
+     */
+    slice(start?: number, end?: number): Array<YXmlElement | YXmlText>;
+    /**
+     * Executes a provided function on once on every child element.
+     *
+     * @param {function(YXmlElement|YXmlText,number, typeof self):void} f A function to execute on every element of this YArray.
+     */
+    forEach(f: (arg0: YXmlElement | YXmlText, arg1: number, arg2: typeof self) => void): void;
+}
+export function readYXmlFragment(_decoder: UpdateDecoderV1 | UpdateDecoderV2): import("../utils/types.js").YType;
+/**
+ * Define the elements to which a set of CSS queries apply.
+ * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors|CSS_Selectors}
+ */
+export type CSS_Selector = string;
+/**
+ * Dom filter function.
+ */
+export type domFilter = (nodeName: string, attributes: Map<any, any>) => boolean;
+import * as delta from 'lib0/delta';
+import { AbstractType } from '../internals.js';
+import { YXmlElement } from '../internals.js';
+import { YXmlText } from '../internals.js';
+import { YXmlHook } from '../internals.js';
+import { Item } from '../internals.js';
+import { UpdateDecoderV1 } from '../internals.js';
+import { UpdateDecoderV2 } from '../internals.js';
+//# sourceMappingURL=YXmlFragment.d.ts.map

package/dist/src/types/YXmlFragment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"YXmlFragment.d.ts","sourceRoot":"","sources":["../../../src/types/YXmlFragment.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;GAUG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;GAUG;AACH,0BAJoB,QAAQ,wBACQ,KAAK,SAA5B,GAAG,CAAC,IAAI,MAAM,GAAE,GAAG,GAAE;IAIhC,cAOC;IALC;;;OAGG;IACH,gBAFU,KAAK,CAAC,GAAG,CAAC,GAAC,IAAI,CAED;IAG1B;;OAEG;IACH,kBAFU,WAAW,GAAC,QAAQ,GAAC,IAAI,CAKlC;IAkBD;;;;;;OAMG;IACH,SAFY,IAAI,CAMf;IAED,qBAGC;IAWD;;OAEG;IACH,UAFY,MAAM,CAIjB;IAED;;;;;;;;;OASG;IACH,cAHW,MAAM,WACN,KAAK,CAAC,WAAW,GAAC,QAAQ,GAAC,QAAQ,CAAC,QAW9C;IAED;;;;;;;;;OASG;IACH,iBAHW,IAAI,GAAC,IAAI,GAAC,WAAW,GAAC,QAAQ,WAC9B,KAAK,CAAC,WAAW,GAAC,QAAQ,CAAC,QAgBrC;IAED;;;;;OAKG;IACH,cAHW,MAAM,WACN,MAAM,QAWhB;IAED;;;;OAIG;IACH,WAFY,KAAK,CAAC,WAAW,GAAC,QAAQ,GAAC,QAAQ,CAAC,CAI/C;IAED;;;;OAIG;IACH,cAFW,KAAK,CAAC,WAAW,GAAC,QAAQ,CAAC,QAIrC;IAED;;;;OAIG;IACH,iBAFW,KAAK,CAAC,WAAW,GAAC,QAAQ,CAAC,QAIrC;IAED;;;;;OAKG;IACH,WAHW,MAAM,GACL,WAAW,GAAC,QAAQ,CAI/B;IAED;;;;;;;OAOG;IACH,cAJW,MAAM,QACN,MAAM,GACL,KAAK,CAAC,WAAW,GAAC,QAAQ,CAAC,CAItC;IAED;;;;OAIG;IACH,WAFW,CAAS,IAAoB,EAApB,WAAW,GAAC,QAAQ,EAAC,IAAM,EAAN,MAAM,EAAE,IAAW,EAAX,OAAO,IAAI,KAAE,IAAI,QAIjE;CAaF;AASM,2CANI,eAAe,GAAG,eAAe,GAChC,OAAO,mBAAmB,EAAE,KAAK,CAKiB;;;;;2BAzOjD,MAAM;;;;mCAOR,MAAM,gCAEL,OAAO;uBArBI,YAAY;6BAF5B,iBAAiB;4BAAjB,iBAAiB;yBAAjB,iBAAiB;yBAAjB,iBAAiB;qBAAjB,iBAAiB;gCAAjB,iBAAiB;gCAAjB,iBAAiB"}

package/dist/src/types/YXmlHook.d.ts

@@ -0,0 +1,32 @@
+/**
+ * You can manage binding to a custom type with YXmlHook.
+ *
+ * @extends {YMap<any>}
+ */
+export class YXmlHook extends YMap<any> {
+    /**
+     * @param {string} hookName nodeName of the Dom Node.
+     */
+    constructor(hookName: string);
+    /**
+     * @type {string}
+     */
+    hookName: string;
+    /**
+     * @return {this}
+     */
+    _copy(): this;
+    /**
+     * Makes a copy of this data type that can be included somewhere else.
+     *
+     * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
+     *
+     * @return {this}
+     */
+    clone(): this;
+}
+export function readYXmlHook(decoder: UpdateDecoderV1 | UpdateDecoderV2): import("../utils/types.js").YType;
+import { YMap } from '../internals.js';
+import { UpdateDecoderV1 } from '../internals.js';
+import { UpdateDecoderV2 } from '../internals.js';
+//# sourceMappingURL=YXmlHook.d.ts.map

package/dist/src/types/YXmlHook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"YXmlHook.d.ts","sourceRoot":"","sources":["../../../src/types/YXmlHook.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH;IACE;;OAEG;IACH,sBAFW,MAAM,EAQhB;IAJC;;OAEG;IACH,UAFU,MAAM,CAEQ;IAG1B;;OAEG;IACH,SAFY,IAAI,CAIf;IAED;;;;;;OAMG;IACH,SAFY,IAAI,CAQf;CAcF;AASM,sCANI,eAAe,GAAG,eAAe,GAChC,OAAO,mBAAmB,EAAE,KAAK,CAMZ;qBA/D1B,iBAAiB;gCAAjB,iBAAiB;gCAAjB,iBAAiB"}

package/dist/src/types/YXmlText.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @todo can we deprecate this?
+ *
+ * Represents text in a Dom Element. In the future this type will also handle
+ * simple formatting information like bold and italic.
+ * @extends YText
+ */
+export class YXmlText extends YText<import("./AbstractType.js").AbstractType<any, any> | {
+    [key: string]: any;
+}> {
+    constructor(string?: string);
+    /**
+     * @type {YXmlElement|YXmlText|null}
+     */
+    get nextSibling(): YXmlElement | YXmlText | null;
+    /**
+     * @type {YXmlElement|YXmlText|null}
+     */
+    get prevSibling(): YXmlElement | YXmlText | null;
+    /**
+     * Makes a copy of this data type that can be included somewhere else.
+     *
+     * Note that the content is only readable _after_ it has been included somewhere in the Ydoc.
+     *
+     * @return {this}
+     */
+    clone(): this;
+}
+export function readYXmlText(_decoder: UpdateDecoderV1 | UpdateDecoderV2): import("../utils/types.js").YType;
+import { YText } from '../internals.js';
+import { YXmlElement } from '../internals.js';
+import { UpdateDecoderV1 } from '../internals.js';
+import { UpdateDecoderV2 } from '../internals.js';
+//# sourceMappingURL=YXmlText.d.ts.map

package/dist/src/types/YXmlText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"YXmlText.d.ts","sourceRoot":"","sources":["../../../src/types/YXmlText.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH;;;;IACE;;OAEG;IACH,mBAFU,WAAW,GAAC,QAAQ,GAAC,IAAI,CAKlC;IAED;;OAEG;IACH,mBAFU,WAAW,GAAC,QAAQ,GAAC,IAAI,CAKlC;IAED;;;;;;OAMG;IACH,SAFY,IAAI,CAMf;CAeF;AASM,uCANI,eAAe,GAAG,eAAe,GAChC,OAAO,mBAAmB,EAAE,KAAK,CAKS;sBA7D/C,iBAAiB;4BAAjB,iBAAiB;gCAAjB,iBAAiB;gCAAjB,iBAAiB"}

package/dist/src/utils/AbstractConnector.d.ts

@@ -0,0 +1,20 @@
+/**
+ * This is an abstract interface that all Connectors should implement to keep them interchangeable.
+ *
+ * @note This interface is experimental and it is not advised to actually inherit this class.
+ *       It just serves as typing information.
+ *
+ * @extends {ObservableV2<any>}
+ */
+export class AbstractConnector extends ObservableV2<any> {
+    /**
+     * @param {Doc} ydoc
+     * @param {any} awareness
+     */
+    constructor(ydoc: Doc, awareness: any);
+    doc: Doc;
+    awareness: any;
+}
+import { ObservableV2 } from 'lib0/observable';
+import { Doc } from '../internals.js';
+//# sourceMappingURL=AbstractConnector.d.ts.map

package/dist/src/utils/AbstractConnector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractConnector.d.ts","sourceRoot":"","sources":["../../../src/utils/AbstractConnector.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH;IACE;;;OAGG;IACH,kBAHW,GAAG,aACH,GAAG,EAMb;IAFC,SAAe;IACf,eAA0B;CAE7B;6BAxB4B,iBAAiB;oBAIvC,iBAAiB"}