lib0 0.2.115-4 → 0.2.115-6

package/delta/map.js

@@ -1,304 +0,0 @@
-import * as gmap from '../map.js'
-import * as fun from '../function.js'
-import * as traits from '../traits.js'
-import * as s from '../schema.js'
-import * as ops from './ops.js'
-import { AbstractDelta, mergeAttrs, $delta } from './abstract.js'
-
-export const $mapJson = s.$record(s.$string, ops.$deltaMapChangeJson)
-
-/**
- * @template {{ [key:string]: ops.DeltaMapOps }} OPS
- * @typedef {{ [K in keyof OPS]: (Extract<OPS[K],ops.MapInsertOp<any>> extends ops.MapInsertOp<infer V,any> ? ops.MapInsertOp<V, K> : never) | (Extract<OPS[K],ops.MapDeleteOp<any>> extends ops.MapDeleteOp<infer V,any> ? ops.MapDeleteOp<V,K> : never) | (Extract<OPS[K],ops.MapModifyOp<any>> extends ops.MapModifyOp<infer V,any> ? (ops.MapModifyOp<V,K>&OPS[K]) : never) }[keyof OPS]} KeyedOps */
-
-/**
- * @template {{ [key: string]: any }} [Vals={[key:string]:any}]
- * @extends AbstractDelta
- */
-export class DeltaMap extends AbstractDelta {
-  /**
-   * @param {s.Schema<Vals>} $vals
-   */
-  constructor ($vals) {
-    super()
-    this.$vals = s.$$object.check($vals) ? $vals.partial : $vals
-    /**
-     * @type {gmap.GlobalMap<any,ops.DeltaMapOps>}
-     */
-    this._changes = gmap.create()
-    /**
-     * @type {import('./abstract.js').Attribution?}
-     */
-    this.usedAttribution = null
-  }
-
-  isEmpty () {
-    return this._changes.size === 0
-  }
-
-  /**
-   *
-   * Iterate through the changes. There are two approches to iterate through changes. The
-   * following two examples achieve the same thing:
-   *
-   * @example
-   *   d.forEach(op => {
-   *     if (op instanceof dmap.MapInsertOp) {
-   *       console.log('content inserted:', op.key, op.value)
-   *     } else if (op instanceof dmap.MapDeleteOp) {
-   *       console.log('content deleted:', op.key, op.prevValue)
-   *     } else if (op instanceof delta.MapModifyOp) {
-   *       console.log('content was modified:', op.key, op.)
-   *       op.modify
-   *     }
-   *   })
-   *
-   * The second approach doesn't require instanceof checks.
-   *
-   * @example
-   *   d.forEach(null,
-   *     (insertOp) => insertOp.insert,
-   *     (retainOp) => insertOp.retain
-   *     (deleteOp) => insertOp.delete
-   *     (modifyOp) => insertOp.modify
-   *   )
-   *
-   * @template {Vals} ValsX
-   * @param {null|((op:KeyedOps<MapOpsFromValues<ValsX>>)=>void)} changeHandler
-   * @param {null|((insertOp:Extract<KeyedOps<MapOpsFromValues<ValsX>>,ops.MapInsertOp<any,any>>)=>void)} insertHandler
-   * @param {null|((deleteOp:Extract<KeyedOps<MapOpsFromValues<ValsX>>,ops.MapDeleteOp<any,any>>)=>void)} deleteHandler
-   * @param {null|((modifyOp:Extract<KeyedOps<MapOpsFromValues<ValsX>>,ops.MapModifyOp<any,any>>)=>void)} modifyHandler
-   */
-  forEach (changeHandler = null, insertHandler = null, deleteHandler = null, modifyHandler = null) {
-    this._changes.forEach((change) => {
-      changeHandler?.(/** @type {any} */ (change))
-      switch (change.constructor) {
-        case ops.MapDeleteOp:
-          deleteHandler?.(/** @type {any} */ (change))
-          break
-        case ops.MapInsertOp:
-          insertHandler?.(/** @type {any} */ (change))
-          break
-        case ops.MapModifyOp:
-          modifyHandler?.(/** @type {any} */ (change))
-          break
-      }
-    })
-  }
-
-  /**
-   * @template {keyof Vals} K
-   * @param {K} key
-   * @return {MapOpsFromValues<Vals>[K] | undefined}
-   */
-  get (key) {
-    return /** @type {(MapOpsFromValues<Vals>[K] & { key:K })|undefined} */ (this._changes.get(key))
-  }
-
-  /**
-   * @param {keyof Vals} key
-   */
-  has (key) {
-    return this._changes.has(key)
-  }
-
-  /**
-   * @param {DeltaMap<any>} other
-   * @return {boolean}
-   */
-  equals (other) {
-    return this[traits.EqualityTraitSymbol](other)
-  }
-
-  get size () {
-    return this._changes.size
-  }
-
-  /**
-   * @return {s.Unwrap<$mapJson>}
-   */
-  toJSON () {
-    /**
-     * @type {s.Unwrap<$mapJson>}
-     */
-    const changes = {}
-    this._changes.forEach((change, key) => {
-      changes[/** @type {string} */ (key)] = change.toJSON()
-    })
-    return changes
-  }
-
-  /**
-   * @template {keyof Vals} K
-   * @param {K} key
-   * @param {Extract<Vals[K], AbstractDelta>} delta
-   */
-  modify (key, delta) {
-    this._changes.set(key, /** @type {any} */ (new ops.MapModifyOp(key, valsKeySchema(this.$vals, key).cast(delta))))
-    return this
-  }
-
-  /**
-   * @template {keyof Vals} K
-   * @param {K} key
-   * @param {Vals[K]} newVal
-   * @param {Vals[K]|undefined} prevValue
-   * @param {import('./abstract.js').Attribution?} attribution
-   */
-  set (key, newVal, prevValue = undefined, attribution = null) {
-    const mergedAttribution = mergeAttrs(this.usedAttribution, attribution)
-    const $v = valsKeySchema(this.$vals, key)
-    this._changes.set(key, /** @type {any} */ (new ops.MapInsertOp(key, $v.cast(newVal), prevValue && $v.cast(prevValue), mergedAttribution)))
-    return this
-  }
-
-  /**
-   * @param {Partial<Vals>} kv
-   * @param {import('./abstract.js').Attribution?} attribution
-   */
-  setMany (kv, attribution = null) {
-    for (const key in kv) {
-      this.set(key, /** @type {Vals[any]} */ (kv[key]), undefined, attribution)
-    }
-    return this
-  }
-
-  /**
-   * @template {keyof Vals} K
-   * @param {K} key
-   * @param {Vals[K]|undefined} prevValue
-   * @param {import('./abstract.js').Attribution?} attribution
-   */
-  delete (key, prevValue = undefined, attribution = null) {
-    const mergedAttribution = mergeAttrs(this.usedAttribution, attribution)
-    this._changes.set(key, /** @type {any} */ (new ops.MapDeleteOp(key, prevValue === undefined ? prevValue : valsKeySchema(this.$vals, key).cast(prevValue), mergedAttribution)))
-    return this
-  }
-
-  /**
-   * @param {import('./abstract.js').Attribution?} attribution
-   */
-  useAttribution (attribution) {
-    this.usedAttribution = attribution
-    return this
-  }
-
-  /**
-   *
-   * - insert vs delete ⇒ insert takes precedence
-   * - insert vs modify ⇒ insert takes precedence
-   * - insert vs insert ⇒ priority decides
-   * - delete vs modify ⇒ delete takes precedence
-   * - delete vs delete ⇒ current delete op is removed because item has already been deleted
-   * - modify vs modify ⇒ rebase using priority
-   *
-   * @param {DeltaMap<Vals>} other
-   * @param {boolean} priority
-   */
-  rebase (other, priority) {
-    this.forEach(null,
-      insertOp => {
-        if (other.get(insertOp.key)?.constructor === ops.MapInsertOp && !priority) {
-          this._changes.delete(insertOp.key)
-        }
-      },
-      deleteOp => {
-        const otherOp = other.get(deleteOp.key)
-        if (otherOp?.constructor === ops.MapInsertOp) {
-          this._changes.delete(otherOp.key)
-        }
-      },
-      modifyOp => {
-        const otherOp = other.get(modifyOp.key)
-        if (otherOp == null) {
-          // nop
-        } else if (otherOp.constructor === ops.MapModifyOp) {
-          modifyOp.value.rebase(otherOp.value, priority)
-        } else {
-          this._changes.delete(otherOp.key)
-        }
-      }
-    )
-  }
-
-  /**
-   * @param {DeltaMap<Partial<Vals>>} other
-   */
-  apply (other) {
-    /** @type {DeltaMap<Vals>} */ (other).forEach(op => {
-      const c = this._changes.get(op.key)
-      if (ops.$modifyOp.check(op)) {
-        if ($delta.check(c?.value)) {
-          /** @type {DeltaMap<any>} */ (c.value).apply(op.value)
-        } else {
-          // then this is a simple modify
-          this._changes.set(op.key, /** @type {any} */ (op))
-        }
-      } else {
-        op.prevValue = c?.value
-        this._changes.set(op.key, /** @type {any} */ (op))
-      }
-    }
-    )
-  }
-
-  /**
-   * @return {this}
-   */
-  clone () {
-    const d = /** @type {this} */ (new DeltaMap(this.$vals))
-    this.forEach(change => {
-      d._changes.set(change.key, /** @type {any} */ (change))
-    })
-    d.origin = this.origin
-    d.isDiff = this.isDiff
-    return d
-  }
-
-  done () {
-    return /** @type {DeltaMap<Vals>} */ (this)
-  }
-
-  /**
-   * @param {DeltaMap<Partial<Vals>>} other
-   */
-  [traits.EqualityTraitSymbol] (other) {
-    return fun.equalityDeep(this._changes, other._changes)
-  }
-}
-
-/**
- * @template {s.Schema<{ [Key:string]: ops.DeltaMapOps }>} OPS
- * @template {keyof s.Unwrap<OPS>} K
- * @param {OPS} $ops
- * @param {K} k
- * @return {s.Schema<s.Unwrap<OPS>[K]>}
- */
-const valsKeySchema = ($ops, k) => s.$$object.check($ops) ? ($ops.shape[k] || s.$never) : ((s.$$record.check($ops) && $ops.shape.keys.check(k)) ? ($ops.shape.values) : s.$never)
-
-/**
- * @template {{ [key:string]: any }} Vals
- * @typedef {{ [K in keyof Vals]: Vals[K] extends DeltaMap<infer DM> ? ops.MapInsertOp<Vals[K]>|ops.MapDeleteOp<Vals[K]>|ops.MapModifyOp<DeltaMap<DM>> : (ops.MapInsertOp<Exclude<Vals[K],undefined>>|ops.MapDeleteOp<Exclude<Vals[K],undefined>>) }} MapOpsFromValues
- */
-
-/**
- * Create a new DeltaMap, optionally supply a schema.
- *
- * @template {s.Schema<{ [key:string]: any }> | { [key:string]: s.Schema<any> }} [$Vals=s.Schema<{ [key:string]: any }>]
- * @param {$Vals} $vals
- * @return {DeltaMap<$Vals extends s.Schema<infer $V> ? $V : (s._ReadObjectDef<$Vals> extends s.Schema<infer $V> ? $V : never)>}
- */
-export const map = ($vals = /** @type {any} */ (s.$record(s.$string, s.$any))) => /** @type {any} */ (new DeltaMap(/** @type {any} */ (s.$$schema.check($vals) ? $vals : s.$object($vals))))
-
-/**
- * @template {{ [key:string]: any }} Vals
- * @param {s.Schema<Vals>} $vals
- * @return {s.Schema<DeltaMap<Vals>>}
- */
-export const $map = $vals => {
-  const $valsPartial = s.$$object.check($vals) ? $vals.partial : $vals
-  return /** @type {any} */ (s.$instanceOf(DeltaMap, o => Array.from(o._changes.entries()).every(([k, op]) =>
-    !ops.$insertOp.check(op) || $valsPartial.check({ [k]: op.value })
-  )))
-}
-export const $mapAny = s.$instanceOf(DeltaMap)

package/delta/node.d.ts

@@ -1,117 +0,0 @@
-/**
- * @template {string|undefined} [NodeName=string]
- * @template {{[key:string]:any}} [Attrs={[key:string]:any}]
- * @template [Children=any]
- * @template {boolean} [WithText=true]
- */
-export class DeltaNode<NodeName extends string | undefined = string, Attrs extends {
-    [key: string]: any;
-} = {
-    [key: string]: any;
-}, Children = any, WithText extends boolean = true> extends dabstract.AbstractDelta {
-    /**
-     * @param {NodeName} nodeName
-     * @param {dmap.DeltaMap<Attrs>} attributes
-     * @param {darray.DeltaArray<Children,WithText>} children
-     */
-    constructor(nodeName: NodeName, attributes: dmap.DeltaMap<Attrs>, children: darray.DeltaArray<Children, WithText>);
-    name: NodeName;
-    /**
-     * @type {dmap.DeltaMap<Attrs>}
-     */
-    attributes: dmap.DeltaMap<Attrs>;
-    /**
-     * @type {darray.DeltaArray<Children,WithText>}
-     */
-    children: darray.DeltaArray<Children, WithText>;
-    /**
-     * @return {this}
-     */
-    clone(): this;
-    /**
-     * @param {(WithText extends true ? string : never) | Array<Children>} insert
-     */
-    insert(insert: (WithText extends true ? string : never) | Array<Children>): this;
-    /**
-     * @template {keyof Attrs} K
-     * @param {K} key
-     * @param {Attrs[K]} newVal
-     * @param {Attrs[K]|undefined} prevVal
-     * @param {import('./abstract.js').Attribution?} attribution
-     */
-    set<K extends keyof Attrs>(key: K, newVal: Attrs[K], prevVal: Attrs[K] | undefined, attribution: import("./abstract.js").Attribution | null): this;
-    /**
-     * @param {import('./abstract.js').Attribution?} attribution
-     * @param {Partial<Attrs>} kv
-     */
-    setMany(kv: Partial<Attrs>, attribution?: import("./abstract.js").Attribution | null): this;
-    toJSON(): {
-        name: NodeName;
-        attributes: {
-            [x: string]: {
-                attribution?: {
-                    insert?: string[] | undefined;
-                    insertAt?: number | undefined;
-                    delete?: string[] | undefined;
-                    deleteAt?: number | undefined;
-                    attributes?: {
-                        [x: string]: string[];
-                    } | undefined;
-                    attributesAt?: number | undefined;
-                } | null | undefined;
-                type: "insert";
-                value: any;
-            } | {
-                type: "modify";
-                value: any;
-            } | {
-                attribution?: {
-                    insert?: string[] | undefined;
-                    insertAt?: number | undefined;
-                    delete?: string[] | undefined;
-                    deleteAt?: number | undefined;
-                    attributes?: {
-                        [x: string]: string[];
-                    } | undefined;
-                    attributesAt?: number | undefined;
-                } | null | undefined;
-                type: "delete";
-            };
-        };
-        children: import("./abstract-array.js").DeltaJson;
-    };
-    /**
-     * @return {DeltaNode<NodeName, Attrs, Children, WithText>}
-     */
-    done(): DeltaNode<NodeName, Attrs, Children, WithText>;
-    /**
-     * @param {DeltaNode<NodeName,Partial<Attrs>,Children,WithText>} other
-     */
-    [traits.EqualityTraitSymbol](other: DeltaNode<NodeName, Partial<Attrs>, Children, WithText>): boolean;
-}
-export function node<NodeName extends string | undefined = string, Attrs extends {
-    [key: string]: any;
-} | dmap.DeltaMap<any> = {
-    [key: string]: any;
-}, Children extends Array<any> | string | darray.DeltaArray<any, any> = any[]>(nodeName: NodeName, attributes?: Attrs, children?: Children): DeltaNode<NodeName, Attrs extends dmap.DeltaMap<infer AttrsDef> ? AttrsDef : Attrs, Children extends Array<infer ChildTypes> ? ChildTypes : (Children extends darray.DeltaArray<infer ChildTypes, any> ? ChildTypes : never)>;
-export function $node<NodeName extends string, Attributes extends {
-    [key: string]: any;
-}, Children, Recursive extends boolean = false, WithText extends boolean = false>($nodeName: s.Schema<NodeName>, $attributes: s.Schema<Attributes>, $children: s.Schema<Children>, { recursive, withText }?: {
-    recursive?: Recursive | undefined;
-    withText?: WithText | undefined;
-}): s.Schema<Recursive extends true ? RecursiveDeltaNode<NodeName, Partial<Attributes>, Children, WithText> : DeltaNode<NodeName, Partial<Attributes>, Children, WithText | undefined>>;
-/**
- * @type {s.Schema<DeltaNode<any,{[key:string]: any},any,any>>}
- */
-export const $nodeAny: s.Schema<DeltaNode<any, {
-    [key: string]: any;
-}, any, any>>;
-export type RecursiveDeltaNode<NodeName extends string, Attributes extends {
-    [key: string]: any;
-}, Children, WithText extends boolean> = DeltaNode<NodeName, Attributes, Children | RecursiveDeltaNode<NodeName, Attributes, Children, WithText>, WithText>;
-import * as dabstract from './abstract.js';
-import * as dmap from './map.js';
-import * as darray from './array.js';
-import * as traits from '../traits.js';
-import * as s from '../schema.js';
-//# sourceMappingURL=node.d.ts.map

package/delta/node.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["node.js"],"names":[],"mappings":"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"}

package/delta/node.js

@@ -1,183 +0,0 @@
-import * as traits from '../traits.js'
-import * as dabstract from './abstract.js'
-import * as darray from './array.js'
-import * as dmap from './map.js'
-import * as s from '../schema.js'
-import * as error from '../error.js'
-
-/**
- * @template {string|undefined} [NodeName=string]
- * @template {{[key:string]:any}} [Attrs={[key:string]:any}]
- * @template [Children=any]
- * @template {boolean} [WithText=true]
- */
-export class DeltaNode extends dabstract.AbstractDelta {
-  /**
-   * @param {NodeName} nodeName
-   * @param {dmap.DeltaMap<Attrs>} attributes
-   * @param {darray.DeltaArray<Children,WithText>} children
-   */
-  constructor (nodeName, attributes, children) {
-    super()
-    this.name = nodeName
-    /**
-     * @type {dmap.DeltaMap<Attrs>}
-     */
-    this.attributes = /** @type {any} */ (attributes)
-    /**
-     * @type {darray.DeltaArray<Children,WithText>}
-     */
-    this.children = /** @type {any} */ (children)
-  }
-
-  isEmpty () {
-    return this.children.isEmpty() && this.attributes.isEmpty()
-  }
-
-  /**
-   * @return {this}
-   */
-  clone () {
-    return /** @type {this} */ (new DeltaNode(this.name, this.attributes.clone(), this.children.clone()))
-  }
-
-  /**
-   * @param {(WithText extends true ? string : never) | Array<Children>} insert
-   */
-  insert (insert) {
-    // @ts-ignore
-    this.children.insert(insert)
-    return this
-  }
-
-  /**
-   * @template {keyof Attrs} K
-   * @param {K} key
-   * @param {Attrs[K]} newVal
-   * @param {Attrs[K]|undefined} prevVal
-   * @param {import('./abstract.js').Attribution?} attribution
-   */
-  set (key, newVal, prevVal, attribution) {
-    this.attributes.set(key, newVal, prevVal, attribution)
-    return this
-  }
-
-  /**
-   * @param {import('./abstract.js').Attribution?} attribution
-   * @param {Partial<Attrs>} kv
-   */
-  setMany (kv, attribution = null) {
-    this.attributes.setMany(kv, attribution)
-    return this
-  }
-
-  /**
-   * @param {dabstract.AbstractDelta} other
-   */
-  apply (other) {
-    if ($nodeAny.check(other)) {
-      // @ts-ignore
-      this.attributes.apply(other.attributes)
-      // @ts-ignore
-      this.children.apply(other.children)
-    } else if (dmap.$mapAny.check(other)) {
-      // @ts-ignore
-      this.attributes.apply(other)
-    } else if (darray.$arrayAny.check(other)) {
-      // @ts-ignore
-      this.children.apply(other)
-    } else {
-      error.unexpectedCase()
-    }
-  }
-
-  toJSON () {
-    return {
-      name: this.name,
-      attributes: this.attributes.toJSON(),
-      children: this.children.toJSON()
-    }
-  }
-
-  /**
-   * @return {DeltaNode<NodeName, Attrs, Children, WithText>}
-   */
-  done () {
-    /** @type {darray.DeltaArray<any>} */ (this.children).done()
-    ;/** @type {dmap.DeltaMap<any>} */ (this.attributes).done()
-    return /** @type {any} */ (this)
-  }
-
-  /**
-   * @param {DeltaNode<NodeName,Partial<Attrs>,Children,WithText>} other
-   */
-  [traits.EqualityTraitSymbol] (other) {
-    return this.name === other.name && this.children[traits.EqualityTraitSymbol](other.children) && this.attributes[traits.EqualityTraitSymbol](other.attributes)
-  }
-}
-
-/**
- * @template {string|undefined} [NodeName=string]
- * @template {{[key:string]:any} | dmap.DeltaMap<any>} [Attrs={[key:string]:any}]
- * @template {Array<any> | string | darray.DeltaArray<any,any>} [Children=Array<any>]
- * @param {NodeName} nodeName
- * @param {Attrs} [attributes]
- * @param {Children} [children]
- * @return {DeltaNode<NodeName,Attrs extends dmap.DeltaMap<infer AttrsDef> ? AttrsDef : Attrs,Children extends Array<infer ChildTypes> ? ChildTypes : (Children extends darray.DeltaArray<infer ChildTypes,any> ? ChildTypes : never)>}
- */
-export const node = (nodeName, attributes, children) =>
-  new DeltaNode(
-    nodeName,
-    attributes == null
-      ? dmap.map()
-      : (dmap.$mapAny.check(attributes)
-          ? /** @type {dmap.DeltaMap<any>} */ (attributes)
-          : dmap.map().setMany(/** @type {any} */ (attributes))
-        ),
-    children == null
-      ? darray.array()
-      : (darray.$arrayAny.check(children)
-          ? /** @type {darray.DeltaArray<any>} */ (children)
-          : darray.array().insert(children)
-        )
-  )
-
-/**
- * @template {string} NodeName
- * @template {{ [key:string]: any }} Attributes
- * @template Children
- * @template {boolean} WithText
- * @typedef {DeltaNode<NodeName, Attributes, Children | RecursiveDeltaNode<NodeName,Attributes,Children,WithText>, WithText>} RecursiveDeltaNode
- */
-
-/**
- * @template {string} NodeName
- * @template {{ [key:string]: any }} Attributes
- * @template Children
- * @template {boolean} [Recursive=false]
- * @template {boolean} [WithText=false]
- * @param {s.Schema<NodeName>} $nodeName
- * @param {s.Schema<Children>} $children
- * @param {s.Schema<Attributes>} $attributes
- * @param {object} [opts]
- * @param {Recursive} [opts.recursive]
- * @param {WithText} [opts.withText]
- * @return {s.Schema<Recursive extends true ? RecursiveDeltaNode<NodeName, Partial<Attributes>, Children, WithText> : DeltaNode<NodeName, Partial<Attributes>, Children, withText>>}
- */
-export const $node = ($nodeName, $attributes, $children, { recursive, withText } = {}) => {
-  /**
-   * @type {s.Schema<darray.DeltaArray<any,any>>}
-   */
-  let $dchildren = darray.$array($children)
-  const $dattrs = dmap.$map($attributes)
-  const $nodeSchema = /** @type {s.Schema<DeltaNode<NodeName, any, any, any>>} */ (s.$instanceOf(DeltaNode, o => $nodeName.check(o.name) && $dchildren.check(o.children) && $dattrs.check(o.attributes)))
-  if (recursive) {
-    $dchildren = darray.$array(s.$union($children, $nodeSchema), withText)
-  }
-  return /** @type {any} */ ($nodeSchema)
-}
-
-/**
- * @type {s.Schema<DeltaNode<any,{[key:string]: any},any,any>>}
- */
-export const $nodeAny = s.$constructedBy(DeltaNode)

package/delta/node.test.d.ts

@@ -1,4 +0,0 @@
-export function testNodeDelta(_tc: t.TestCase): void;
-export function testRecursiveNode(): void;
-import * as t from 'lib0/testing';
-//# sourceMappingURL=node.test.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"node.test.d.ts","sourceRoot":"","sources":["node.test.js"],"names":[],"mappings":"AAOO,mCAFI,CAAC,CAAC,QAAQ,QAgCpB;AAEM,0CAqBN;mBA5DkB,cAAc"}