lib0 0.2.115-3 → 0.2.115-5

package/delta/abstract-array.js

@@ -1,421 +0,0 @@
-import * as s from '../schema.js'
-import * as d from './abstract.js'
-import * as traits from '../traits.js'
-import * as object from '../object.js'
-import * as fun from '../function.js'
-import * as array from '../array.js'
-import * as dops from './ops.js'
-import * as error from '../error.js'
-import * as math from '../math.js'
-import { InsertOp, DeleteOp, RetainOp, ModifyOp, TextOp } from './ops.js'
-
-/**
- * @typedef {Array<dops.DeltaJsonOp>} DeltaJson
- */
-
-/**
- * @template {'array' | 'text' | 'custom'} Type
- * @template {dops.AbstractDeltaArrayOps<any>} OPS
- * @extends {d.AbstractDelta}
- */
-export class AbstractDeltaArray extends d.AbstractDelta {
-  /**
-   * @param {Type} type
-   */
-  constructor (type) {
-    super()
-    this.type = type
-    /**
-     * @type {Array<OPS>}
-     */
-    this.ops = []
-  }
-
-  isEmpty () {
-    return this.ops.length === 0
-  }
-
-  /**
-   * @template M
-   * @param {(d:OPS) => dops.AbstractDeltaArrayOps<M>} f
-   * @return {AbstractDeltaArrayBuilder<Type,M>}
-   */
-  map (f) {
-    const d = /** @type {AbstractDeltaArrayBuilder<Type,any>} */ (new /** @type {any} */ (this.constructor)(this.type))
-    d.ops = this.ops.map(f)
-    d.lastOp = d.ops[d.ops.length - 1] ?? null
-    return d
-  }
-
-  /**
-   *
-   * Iterate through the changes. There are two approches to iterate through the changes. The
-   * following examples achieve the same thing:
-   *
-   * @example
-   *   d.forEach((op, index) => {
-   *     if (op instanceof delta.InsertArrayOp) {
-   *       op.insert
-   *     } else if (op instanceof delta.RetainOp ) {
-   *       op.retain
-   *     } else if (op instanceof delta.DeleteOp) {
-   *       op.delete
-   *     }
-   *   })
-   *
-   * The second approach doesn't require instanceof checks.
-   *
-   * @example
-   *   d.forEach(null,
-   *     (insertOp, index) => insertOp.insert,
-   *     (retainOp, index) => insertOp.retain
-   *     (deleteOp, index) => insertOp.delete
-   *   )
-   *
-   * @param {null|((d:OPS,index:number)=>void)} f
-   * @param {null|((insertOp:Extract<OPS,InsertOp<any>|TextOp>,index:number)=>void)} insertHandler
-   * @param {null|((retainOp:RetainOp,index:number)=>void)} retainHandler
-   * @param {null|((deleteOp:DeleteOp,index:number)=>void)} deleteHandler
-   * @param {null|((modifyOp:OPS extends ModifyOp<infer M> ? ModifyOp<M> : never,index:number)=>void)} modifyHandler
-   */
-  forEach (f = null, insertHandler = null, retainHandler = null, deleteHandler = null, modifyHandler = null) {
-    for (
-      let i = 0, index = 0, op = this.ops[i];
-      i < this.ops.length;
-      i++, index += op.length, op = this.ops[i]
-    ) {
-      f?.(op, index)
-      switch (op.constructor) {
-        case RetainOp:
-          retainHandler?.(/** @type {RetainOp} */ (op), index)
-          break
-        case DeleteOp:
-          deleteHandler?.(/** @type {DeleteOp} */ (op), index)
-          break
-        case ModifyOp:
-          modifyHandler?.(/** @type {any}) */ (op), index)
-          break
-        default:
-          insertHandler?.(/** @type {any} */ (op), index)
-      }
-    }
-  }
-
-  /**
-   * @param {AbstractDeltaArray<Type, OPS>} other
-   * @return {boolean}
-   */
-  equals (other) {
-    return this[traits.EqualityTraitSymbol](other)
-  }
-
-  /**
-   * @returns {DeltaJson}
-   */
-  toJSON () {
-    return this.ops.map(o => o.toJSON())
-  }
-
-  get size () {
-    return this.ops.length
-  }
-
-  /**
-   * @param {AbstractDeltaArray<Type,OPS>} other
-   */
-  [traits.EqualityTraitSymbol] (other) {
-    return fun.equalityDeep(this.ops, other.ops)
-  }
-}
-
-/**
- * @template {'text' | 'array' | 'custom'} Type
- * @template {dops.AbstractDeltaArrayOps<any>} OPS
- * @extends {AbstractDeltaArray<Type,OPS>}
- */
-export class AbstractDeltaArrayBuilder extends AbstractDeltaArray {
-  /**
-   * @param {Type} type
-   * @param {s.Schema<OPS extends dops.AbstractDeltaArrayOps<infer V> ? V : never>} $insert
-   */
-  constructor (type, $insert) {
-    super(type)
-    this.$insert = $insert
-    /**
-     * @type {dops.FormattingAttributes?}
-     */
-    this.usedAttributes = null
-    /**
-     * @type {d.Attribution?}
-     */
-    this.usedAttribution = null
-    /**
-     * @type {dops.AbstractDeltaArrayOps<any>?}
-     */
-    this.lastOp = null
-  }
-
-  /**
-   * @return {this}
-   */
-  clone () {
-    const d = /** @type {this} */ (new AbstractDeltaArrayBuilder(this.type, this.$insert))
-    d.ops = /** @type {OPS[]} */ (this.ops.map(op => op.clone()))
-    d.origin = this.origin
-    d.isDiff = this.isDiff
-    return d
-  }
-
-  /**
-   * @param {dops.FormattingAttributes?} attributes
-   * @return {this}
-   */
-  useAttributes (attributes) {
-    this.usedAttributes = attributes
-    return this
-  }
-
-  /**
-   * @param {string} name
-   * @param {any} value
-   */
-  updateUsedAttributes (name, value) {
-    if (value == null) {
-      this.usedAttributes = object.assign({}, this.usedAttributes)
-      delete this.usedAttributes?.[name]
-      if (object.isEmpty(this.usedAttributes)) {
-        this.usedAttributes = null
-      }
-    } else if (!fun.equalityDeep(this.usedAttributes?.[name], value)) {
-      this.usedAttributes = object.assign({}, this.usedAttributes)
-      this.usedAttributes[name] = value
-    }
-    return this
-  }
-
-  /**
-   * @template {keyof d.Attribution} NAME
-   * @param {NAME} name
-   * @param {d.Attribution[NAME]?} value
-   */
-  updateUsedAttribution (name, value) {
-    if (value == null) {
-      this.usedAttribution = object.assign({}, this.usedAttribution)
-      delete this.usedAttribution?.[name]
-      if (object.isEmpty(this.usedAttribution)) {
-        this.usedAttribution = null
-      }
-    } else if (!fun.equalityDeep(this.usedAttribution?.[name], value)) {
-      this.usedAttribution = object.assign({}, this.usedAttribution)
-      this.usedAttribution[name] = value
-    }
-    return this
-  }
-
-  /**
-   * @param {d.Attribution?} attribution
-   */
-  useAttribution (attribution) {
-    this.usedAttribution = attribution
-    return this
-  }
-
-  /**
-   * @param {(OPS extends TextOp ? string : never) | (OPS extends InsertOp<infer Content> ? Array<Content> : never) } insert
-   * @param {dops.FormattingAttributes?} attributes
-   * @param {d.Attribution?} attribution
-   * @return {this}
-   */
-  insert (insert, attributes = null, attribution = null) {
-    const mergedAttributes = d.mergeAttrs(this.usedAttributes, attributes)
-    const mergedAttribution = d.mergeAttrs(this.usedAttribution, attribution)
-    /**
-     * @param {TextOp | InsertOp<any>} lastOp
-     */
-    const checkMergedEquals = lastOp => (mergedAttributes === lastOp.attributes || fun.equalityDeep(mergedAttributes, lastOp.attributes)) && (mergedAttribution === lastOp.attribution || fun.equalityDeep(mergedAttribution, lastOp.attribution))
-    if (s.$string.check(insert)) {
-      if (dops.$textOp.check(this.lastOp) && checkMergedEquals(this.lastOp)) {
-        this.lastOp.insert += insert
-      } else if (insert.length > 0) {
-        this.ops.push(this.lastOp = /** @type {OPS} */ (new TextOp(insert, object.isEmpty(mergedAttributes) ? null : mergedAttributes, object.isEmpty(mergedAttribution) ? null : mergedAttribution)))
-      }
-    } else if (array.isArray(insert)) {
-      insert.forEach(/** @param {any} ins */ ins => this.$insert.expect(ins))
-      if (dops.$insertOp.check(this.lastOp) && checkMergedEquals(this.lastOp)) {
-        this.lastOp.insert.push(...insert)
-      } else if (insert.length > 0) {
-        this.ops.push(this.lastOp = /** @type {OPS} */ (new InsertOp(insert, object.isEmpty(mergedAttributes) ? null : mergedAttributes, object.isEmpty(mergedAttribution) ? null : mergedAttribution)))
-      }
-    }
-    return this
-  }
-
-  /**
-   * @param {OPS extends ModifyOp<infer Mod> ? Mod : never } modify
-   * @param {dops.FormattingAttributes?} attributes
-   * @param {d.Attribution?} attribution
-   * @return {this}
-   */
-  modify (modify, attributes = null, attribution = null) {
-    const mergedAttributes = d.mergeAttrs(this.usedAttributes, attributes)
-    const mergedAttribution = d.mergeAttrs(this.usedAttribution, attribution)
-    this.ops.push(this.lastOp = /** @type {OPS} */ (new ModifyOp(modify, object.isEmpty(mergedAttributes) ? null : mergedAttributes, object.isEmpty(mergedAttribution) ? null : mergedAttribution)))
-    return this
-  }
-
-  /**
-   * @param {number} retain
-   * @param {dops.FormattingAttributes?} attributes
-   * @param {d.Attribution?} attribution
-   * @return {this}
-   */
-  retain (retain, attributes = null, attribution = null) {
-    const mergedAttributes = d.mergeAttrs(this.usedAttributes, attributes)
-    const mergedAttribution = d.mergeAttrs(this.usedAttribution, attribution)
-    if (this.lastOp instanceof RetainOp && fun.equalityDeep(mergedAttributes, this.lastOp.attributes) && fun.equalityDeep(mergedAttribution, this.lastOp.attribution)) {
-      this.lastOp.retain += retain
-    } else if (retain > 0) {
-      // @ts-ignore
-      this.ops.push(this.lastOp = new RetainOp(retain, mergedAttributes, mergedAttribution))
-    }
-    return this
-  }
-
-  /**
-   * @param {number} len
-   * @return {this}
-   */
-  delete (len) {
-    if (this.lastOp instanceof DeleteOp) {
-      this.lastOp.delete += len
-    } else if (len > 0) {
-      // @ts-ignore
-      this.ops.push(this.lastOp = new DeleteOp(len))
-    }
-    return this
-  }
-
-  /**
-   * @todo this is basically untested and is in dire need of randomized testing.
-   * @param {AbstractDeltaArray<Type, OPS>} other
-   */
-  apply (other) {
-    let opsI = 0
-    let offset = 0
-    other.forEach(
-      null,
-      insertOp => {
-        const o = this.ops[opsI]
-        if (offset === 0) {
-          this.ops.splice(opsI, 0, /** @type {OPS} */ (insertOp.clone()))
-          opsI++
-        } else {
-          const cpy = o.clone()
-          cpy._splice(0, offset)
-          o._splice(offset, o.length - offset)
-          this.ops.splice(opsI + 1, 0, /** @type {OPS} */ (insertOp.clone()), /** @type {OPS} */ (cpy))
-          opsI += 2
-          offset = 0
-        }
-      },
-      retainOp => {
-        let skipLen = retainOp.length
-        let o = this.ops[opsI]
-        while (o.length - offset <= skipLen) {
-          skipLen -= o.length - offset
-          o = this.ops[++opsI]
-          offset = 0
-        }
-        offset = skipLen
-      },
-      deleteOp => {
-        let remainingLen = deleteOp.length
-        while (remainingLen > 0) {
-          const o = this.ops[opsI]
-          if (o instanceof DeleteOp) {
-            const delLen = o.length - offset
-            // the same content can't be deleted twice, remove duplicated deletes
-            if (delLen >= remainingLen) {
-              offset = 0
-              opsI++
-            } else {
-              offset += remainingLen
-            }
-            remainingLen -= delLen
-          } else { // insert / embed / retain / modify ⇒ replace
-            // case1: delete o fully
-            // case2: delete some part of beginning
-            // case3: delete some part of end
-            // case4: delete some part of center
-            const delLen = math.min(o.length - offset, remainingLen)
-            if (o.length === delLen) {
-              // case 1
-              offset = 0
-              this.ops.splice(opsI, 1)
-            } else if (offset === 0) {
-              // case 2
-              offset = 0
-              o._splice(0, delLen)
-            } else if (offset + delLen === o.length) {
-              // case 3
-              o._splice(offset, delLen)
-              offset = 0
-              opsI++
-            } else {
-              // case 4
-              o._splice(offset, delLen)
-            }
-            remainingLen -= delLen
-          }
-        }
-      },
-      modifyOp => {
-        if (opsI >= this.ops.length) {
-          this.ops.push(/** @type {OPS} */ (modifyOp.clone()))
-          return
-        }
-        let o = this.ops[opsI]
-        if (dops.$modifyOp.check(o)) {
-          o.modify.apply(modifyOp.modify)
-        } else if (dops.$insertOp.check(o)) {
-          const d = o.insert[offset]
-          d.apply(modifyOp.modify)
-        } else if (dops.$retainOp.check(o)) {
-          if (offset > 0) {
-            const cpy = o.clone()
-            cpy._splice(0, offset)
-            o._splice(offset, o.length - offset)
-            this.ops.splice(opsI + 1, 0, /** @type {OPS} */ (cpy))
-            opsI++
-            o = /** @type {OPS} */ (cpy)
-            offset = 0
-          }
-          if (o.length === 1) {
-            this.ops[opsI] = /** @type {OPS} */ (modifyOp.clone())
-            opsI++
-          } else {
-            this.ops.splice(opsI, 0, /** @type {OPS} */ (modifyOp.clone()))
-            o._splice(0, 1)
-            opsI++
-          }
-        } else if (dops.$deleteOp.check(o)) {
-          // nop
-        } else {
-          error.unexpectedCase()
-        }
-      }
-    )
-    this.lastOp = this.ops[this.ops.length - 1]
-  }
-
-  /**
-   * @return {Type extends 'array' ? (OPS extends dops.InsertOp<infer C> ? import('./array.js').DeltaArray<C> : never) : (Type extends 'text' ? (OPS extends dops.DeltaTextOps<infer Embeds> ? import('./text.js').DeltaText<Embeds> : never) : AbstractDeltaArray<Type,OPS>)}
-   */
-  done () {
-    while (this.lastOp != null && this.lastOp instanceof RetainOp && this.lastOp.attributes === null && this.lastOp.attribution === null) {
-      this.ops.pop()
-      this.lastOp = this.ops[this.ops.length - 1] ?? null
-    }
-    return /** @type {any} */ (this)
-  }
-}

package/delta/abstract.d.ts

@@ -1,69 +0,0 @@
-export const $attribution: s.Schema<{
-    insert?: string[] | undefined;
-    insertAt?: number | undefined;
-    delete?: string[] | undefined;
-    deleteAt?: number | undefined;
-    attributes?: {
-        [x: string]: string[];
-    } | undefined;
-    attributesAt?: number | undefined;
-}>;
-/**
- * @typedef {s.TypeOf<$attribution>} Attribution
- */
-/**
- * @implements {traits.EqualityTrait}
- */
-export class AbstractDelta implements traits.EqualityTrait {
-    remote: boolean;
-    /**
-     * @type {any} origin
-     */
-    origin: any;
-    isDiff: boolean;
-    /**
-     * @return {any}
-     */
-    toJSON(): any;
-    /**
-     * @return {boolean}
-     */
-    isEmpty(): boolean;
-    /**
-     * @param {AbstractDelta} other
-     * @param {boolean} priority
-     */
-    rebase(other: AbstractDelta, priority: boolean): void;
-    /**
-     * @param {AbstractDelta} other
-     */
-    apply(other: AbstractDelta): void;
-    /**
-     * @return {this}
-     */
-    clone(): this;
-    /**
-     * @param {any} _other
-     * @return {boolean}
-     */
-    [traits.EqualityTraitSymbol](_other: any): boolean;
-}
-export const $delta: s.Schema<AbstractDelta>;
-export const $$delta: s.Schema<s.$InstanceOf<AbstractDelta>>;
-export function mergeAttrs<T extends {
-    [key: string]: any;
-}>(a: T | null, b: T | null): T | null;
-export function mergeDeltas<D extends AbstractDelta | null>(a: D, b: D): D;
-export type Attribution = s.TypeOf<s.Schema<{
-    insert?: string[] | undefined;
-    insertAt?: number | undefined;
-    delete?: string[] | undefined;
-    deleteAt?: number | undefined;
-    attributes?: {
-        [x: string]: string[];
-    } | undefined;
-    attributesAt?: number | undefined;
-}>>;
-import * as s from '../schema.js';
-import * as traits from '../traits.js';
-//# sourceMappingURL=abstract.d.ts.map

package/delta/abstract.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"abstract.d.ts","sourceRoot":"","sources":["abstract.js"],"names":[],"mappings":"AAKA;;;;;;;;;GAOE;AAEF;;GAEG;AAEH;;GAEG;AACH,sCAFgB,MAAM,CAAC,aAAa;IAIhC,gBAAmB;IACnB;;OAEG;IACH,QAFU,GAAG,CAEK;IAClB,gBAAkB;IAGpB;;OAEG;IACH,UAFY,GAAG,CAId;IAED;;OAEG;IACH,WAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,cAHW,aAAa,YACb,OAAO,QAIjB;IAED;;OAEG;IACH,aAFW,aAAa,QAIvB;IAED;;OAEG;IACH,SAFY,IAAI,CAIf;IAED;;;OAGG;IACH,qCAHW,GAAG,GACF,OAAO,CAIlB;CACF;AAED,6CAAkD;AAClD,sBAAkC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAuF;AASxJ,2BAJ+B,CAAC,SAA1B;IAAG,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAG,KAC1B,CAAC,GAAG,IAAI,KACR,CAAC,GAAG,IAAI,YAE0F;AAQtG,4BALuB,CAAC,SAAjB,aAAa,OAAE,KAClB,CAAC,KACD,CAAC,GACA,CAAC,CASZ;0BAtFY,CAAC,CAAC,MAAM;;;;;;;;;GAAc;mBAZhB,cAAc;wBAFT,cAAc"}

package/delta/abstract.js

@@ -1,102 +0,0 @@
-import * as object from '../object.js'
-import * as traits from '../traits.js'
-import * as error from '../error.js'
-import * as s from '../schema.js'
-
-export const $attribution = s.$object({
-  insert: s.$array(s.$string).optional,
-  insertAt: s.$number.optional,
-  delete: s.$array(s.$string).optional,
-  deleteAt: s.$number.optional,
-  attributes: s.$record(s.$string, s.$array(s.$string)).optional,
-  attributesAt: s.$number.optional
-})
-
-/**
- * @typedef {s.TypeOf<$attribution>} Attribution
- */
-
-/**
- * @implements {traits.EqualityTrait}
- */
-export class AbstractDelta {
-  constructor () {
-    this.remote = false
-    /**
-     * @type {any} origin
-     */
-    this.origin = null
-    this.isDiff = true
-  }
-
-  /**
-   * @return {any}
-   */
-  toJSON () {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * @return {boolean}
-   */
-  isEmpty () {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * @param {AbstractDelta} other
-   * @param {boolean} priority
-   */
-  rebase (other, priority) {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * @param {AbstractDelta} other
-   */
-  apply (other) {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * @return {this}
-   */
-  clone () {
-    error.methodUnimplemented()
-  }
-
-  /**
-   * @param {any} _other
-   * @return {boolean}
-   */
-  [traits.EqualityTraitSymbol] (_other) {
-    error.methodUnimplemented()
-  }
-}
-
-export const $delta = s.$instanceOf(AbstractDelta)
-export const $$delta = /** @type {s.Schema<s.$InstanceOf<AbstractDelta>>} */ (s.$constructedBy(s.$InstanceOf, s => s.shape.prototype instanceof AbstractDelta))
-
-/**
- * Helper function to merge attribution and attributes. The latter input "wins".
- *
- * @template {{ [key: string]: any }} T
- * @param {T | null} a
- * @param {T | null} b
- */
-export const mergeAttrs = (a, b) => object.isEmpty(a) ? b : (object.isEmpty(b) ? a : object.assign({}, a, b))
-
-/**
- * @template {AbstractDelta?} D
- * @param {D} a
- * @param {D} b
- * @return {D}
- */
-export const mergeDeltas = (a, b) => {
-  if (a != null && b != null) {
-    const c = /** @type {D & AbstractDelta} */ (a.clone())
-    c.apply(b)
-    return c
-  }
-  return a == null ? b : (a || null)
-}

package/delta/array.d.ts

@@ -1,23 +0,0 @@
-/**
- * @template ArrayContent
- * @template {boolean} [WithText=false]
- * @extends AbstractDeltaArrayBuilder<'array', import('./ops.js').DeltaArrayOps<ArrayContent,WithText>>
- */
-export class DeltaArray<ArrayContent, WithText extends boolean = false> extends AbstractDeltaArrayBuilder<"array", ops.DeltaArrayOps<ArrayContent, WithText>> {
-    /**
-     * @param {s.Schema<ArrayContent>} $insert
-     * @param {WithText} withText
-     */
-    constructor($insert: s.Schema<ArrayContent>, withText: WithText);
-    withText: WithText;
-}
-export function $array<ArrayContent, WithText extends boolean = false>($insert: s.Schema<ArrayContent>, withText?: WithText): s.Schema<DeltaArray<ArrayContent, WithText>>;
-/**
- * @type {s.Schema<DeltaArray<any,any>>}
- */
-export const $arrayAny: s.Schema<DeltaArray<any, any>>;
-export function array<V = any, WithText extends boolean = any>($insert?: s.Schema<V>, withText?: WithText): DeltaArray<V, WithText>;
-import * as ops from './ops.js';
-import { AbstractDeltaArrayBuilder } from './abstract-array.js';
-import * as s from '../schema.js';
-//# sourceMappingURL=array.d.ts.map

package/delta/array.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["array.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,wBAJa,YAAY,EACD,QAAQ,SAAnB,OAAS;IAIpB;;;OAGG;IACH,qBAHW,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,YACtB,QAAQ,EAKlB;IADC,mBAAwB;CAE3B;AASM,uBANM,YAAY,EACD,QAAQ,SAAnB,OAAS,mBACX,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,aACtB,QAAQ,GACP,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC,CAMpD;AACJ;;GAEG;AACH,wBAFU,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,EAAC,GAAG,CAAC,CAAC,CAEwE;AASxG,sBANO,CAAC,QACS,QAAQ,SAAnB,OAAS,kBACX,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,aACX,QAAQ,GACP,UAAU,CAAC,CAAC,EAAC,QAAQ,CAAC,CAEoG;qBA1CjH,UAAU;0CADW,qBAAqB;mBAD5C,cAAc"}

package/delta/array.js

@@ -1,45 +0,0 @@
-import * as s from '../schema.js'
-import { AbstractDeltaArrayBuilder } from './abstract-array.js'
-import * as ops from './ops.js'
-
-/**
- * @template ArrayContent
- * @template {boolean} [WithText=false]
- * @extends AbstractDeltaArrayBuilder<'array', import('./ops.js').DeltaArrayOps<ArrayContent,WithText>>
- */
-export class DeltaArray extends AbstractDeltaArrayBuilder {
-  /**
-   * @param {s.Schema<ArrayContent>} $insert
-   * @param {WithText} withText
-   */
-  constructor ($insert, withText) {
-    super('array', $insert)
-    this.withText = withText
-  }
-}
-
-/**
- * @template ArrayContent
- * @template {boolean} [WithText=false]
- * @param {s.Schema<ArrayContent>} $insert
- * @param {WithText} [withText]
- * @return {s.Schema<DeltaArray<ArrayContent, WithText>>}
- */
-export const $array = ($insert, withText) => /** @type {any} */ (s.$instanceOf(AbstractDeltaArrayBuilder, o => o.type === 'array' && o.ops.every(op => {
-  if (ops.$textOp.check(op)) return !!withText
-  if (ops.$insertOp.check(op)) return op.insert.every(opi => $insert.check(opi))
-  return true
-})))
-/**
- * @type {s.Schema<DeltaArray<any,any>>}
- */
-export const $arrayAny = /** @type {any} */ (s.$instanceOf(AbstractDeltaArrayBuilder, o => o.type === 'array'))
-
-/**
- * @template [V=any]
- * @template {boolean} [WithText=any]
- * @param {s.Schema<V>} $insert
- * @param {WithText} [withText]
- * @return {DeltaArray<V,WithText>}
- */
-export const array = ($insert = s.$any, withText) => /** @type {DeltaArray<V,WithText>} */ (new DeltaArray($insert, withText ?? true))

package/delta/array.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=array.test.d.ts.map

package/delta/array.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.test.d.ts","sourceRoot":"","sources":["array.test.js"],"names":[],"mappings":""}