@storyteller-platform/align 0.1.9 → 0.1.11

package/dist/markup/map.cjs

@@ -0,0 +1,261 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var map_exports = {};
+__export(map_exports, {
+  MapResult: () => MapResult,
+  Mapping: () => Mapping,
+  StepMap: () => StepMap
+});
+module.exports = __toCommonJS(map_exports);
+const lower16 = 65535;
+const factor16 = Math.pow(2, 16);
+function makeRecover(index, offset) {
+  return index + offset * factor16;
+}
+function recoverIndex(value) {
+  return value & lower16;
+}
+function recoverOffset(value) {
+  return (value - (value & lower16)) / factor16;
+}
+const DEL_BEFORE = 1, DEL_AFTER = 2, DEL_ACROSS = 4, DEL_SIDE = 8;
+class MapResult {
+  /// @internal
+  constructor(pos, delInfo, recover) {
+    this.pos = pos;
+    this.delInfo = delInfo;
+    this.recover = recover;
+  }
+  /// Tells you whether the position was deleted, that is, whether the
+  /// step removed the token on the side queried (via the `assoc`)
+  /// argument from the document.
+  get deleted() {
+    return (this.delInfo & DEL_SIDE) > 0;
+  }
+  /// Tells you whether the token before the mapped position was deleted.
+  get deletedBefore() {
+    return (this.delInfo & (DEL_BEFORE | DEL_ACROSS)) > 0;
+  }
+  /// True when the token after the mapped position was deleted.
+  get deletedAfter() {
+    return (this.delInfo & (DEL_AFTER | DEL_ACROSS)) > 0;
+  }
+  /// Tells whether any of the steps mapped through deletes across the
+  /// position (including both the token before and after the
+  /// position).
+  get deletedAcross() {
+    return (this.delInfo & DEL_ACROSS) > 0;
+  }
+}
+class StepMap {
+  /// Create a position map. The modifications to the document are
+  /// represented as an array of numbers, in which each group of three
+  /// represents a modified chunk as `[start, oldSize, newSize]`.
+  constructor(ranges, inverted = false) {
+    this.ranges = ranges;
+    this.inverted = inverted;
+    if (!ranges.length) return StepMap.empty;
+  }
+  /// @internal
+  recover(value) {
+    let diff = 0, index = recoverIndex(value);
+    if (!this.inverted)
+      for (let i = 0; i < index; i++)
+        diff += this.ranges[i * 3 + 2] - this.ranges[i * 3 + 1];
+    return this.ranges[index * 3] + diff + recoverOffset(value);
+  }
+  mapResult(pos, assoc = 1) {
+    return this._map(pos, assoc, false);
+  }
+  map(pos, assoc = 1) {
+    return this._map(pos, assoc, true);
+  }
+  /// @internal
+  _map(pos, assoc, simple) {
+    let diff = 0, oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
+    for (let i = 0; i < this.ranges.length; i += 3) {
+      let start = this.ranges[i] - (this.inverted ? diff : 0);
+      if (start > pos) break;
+      let oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex], end = start + oldSize;
+      if (pos <= end) {
+        let side = !oldSize ? assoc : pos == start ? -1 : pos == end ? 1 : assoc;
+        let result = start + diff + (side < 0 ? 0 : newSize);
+        if (simple) return result;
+        let recover = pos == (assoc < 0 ? start : end) ? null : makeRecover(i / 3, pos - start);
+        let del = pos == start ? DEL_AFTER : pos == end ? DEL_BEFORE : DEL_ACROSS;
+        if (assoc < 0 ? pos != start : pos != end) del |= DEL_SIDE;
+        return new MapResult(result, del, recover);
+      }
+      diff += newSize - oldSize;
+    }
+    return simple ? pos + diff : new MapResult(pos + diff, 0, null);
+  }
+  /// @internal
+  touches(pos, recover) {
+    let diff = 0, index = recoverIndex(recover);
+    let oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
+    for (let i = 0; i < this.ranges.length; i += 3) {
+      let start = this.ranges[i] - (this.inverted ? diff : 0);
+      if (start > pos) break;
+      let oldSize = this.ranges[i + oldIndex], end = start + oldSize;
+      if (pos <= end && i == index * 3) return true;
+      diff += this.ranges[i + newIndex] - oldSize;
+    }
+    return false;
+  }
+  /// Calls the given function on each of the changed ranges included in
+  /// this map.
+  forEach(f) {
+    let oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
+    for (let i = 0, diff = 0; i < this.ranges.length; i += 3) {
+      let start = this.ranges[i], oldStart = start - (this.inverted ? diff : 0), newStart = start + (this.inverted ? 0 : diff);
+      let oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex];
+      f(oldStart, oldStart + oldSize, newStart, newStart + newSize);
+      diff += newSize - oldSize;
+    }
+  }
+  /// Create an inverted version of this map. The result can be used to
+  /// map positions in the post-step document to the pre-step document.
+  invert() {
+    return new StepMap(this.ranges, !this.inverted);
+  }
+  /// @internal
+  toString() {
+    return (this.inverted ? "-" : "") + JSON.stringify(this.ranges);
+  }
+  /// Create a map that moves all positions by offset `n` (which may be
+  /// negative). This can be useful when applying steps meant for a
+  /// sub-document to a larger document, or vice-versa.
+  static offset(n) {
+    return n == 0 ? StepMap.empty : new StepMap(n < 0 ? [0, -n, 0] : [0, 0, n]);
+  }
+  /// A StepMap that contains no changed ranges.
+  static empty = new StepMap([]);
+}
+class Mapping {
+  /// Create a new mapping with the given position maps.
+  constructor(maps, mirror, from = 0, to = maps ? maps.length : 0) {
+    this.mirror = mirror;
+    this.from = from;
+    this.to = to;
+    this._maps = maps || [];
+    this.ownData = !(maps || mirror);
+  }
+  /// The step maps in this mapping.
+  get maps() {
+    return this._maps;
+  }
+  _maps;
+  // False if maps/mirror are shared arrays that we shouldn't mutate
+  ownData;
+  /// Create a mapping that maps only through a part of this one.
+  slice(from = 0, to = this.maps.length) {
+    return new Mapping(this._maps, this.mirror, from, to);
+  }
+  /// Add a step map to the end of this mapping. If `mirrors` is
+  /// given, it should be the index of the step map that is the mirror
+  /// image of this one.
+  appendMap(map, mirrors) {
+    if (!this.ownData) {
+      this._maps = this._maps.slice();
+      this.mirror = this.mirror && this.mirror.slice();
+      this.ownData = true;
+    }
+    this.to = this._maps.push(map);
+    if (mirrors != null) this.setMirror(this._maps.length - 1, mirrors);
+  }
+  /// Add all the step maps in a given mapping to this one (preserving
+  /// mirroring information).
+  appendMapping(mapping) {
+    for (let i = 0, startSize = this._maps.length; i < mapping._maps.length; i++) {
+      let mirr = mapping.getMirror(i);
+      this.appendMap(
+        mapping._maps[i],
+        mirr != null && mirr < i ? startSize + mirr : void 0
+      );
+    }
+  }
+  /// Finds the offset of the step map that mirrors the map at the
+  /// given offset, in this mapping (as per the second argument to
+  /// `appendMap`).
+  getMirror(n) {
+    if (this.mirror) {
+      for (let i = 0; i < this.mirror.length; i++)
+        if (this.mirror[i] == n) return this.mirror[i + (i % 2 ? -1 : 1)];
+    }
+    return void 0;
+  }
+  /// @internal
+  setMirror(n, m) {
+    if (!this.mirror) this.mirror = [];
+    this.mirror.push(n, m);
+  }
+  /// Append the inverse of the given mapping to this one.
+  appendMappingInverted(mapping) {
+    for (let i = mapping.maps.length - 1, totalSize = this._maps.length + mapping._maps.length; i >= 0; i--) {
+      let mirr = mapping.getMirror(i);
+      this.appendMap(
+        mapping._maps[i].invert(),
+        mirr != null && mirr > i ? totalSize - mirr - 1 : void 0
+      );
+    }
+  }
+  /// Create an inverted version of this mapping.
+  invert() {
+    let inverse = new Mapping();
+    inverse.appendMappingInverted(this);
+    return inverse;
+  }
+  /// Map a position through this mapping.
+  map(pos, assoc = 1) {
+    if (this.mirror) return this._map(pos, assoc, true);
+    for (let i = this.from; i < this.to; i++)
+      pos = this._maps[i].map(pos, assoc);
+    return pos;
+  }
+  /// Map a position through this mapping, returning a mapping
+  /// result.
+  mapResult(pos, assoc = 1) {
+    return this._map(pos, assoc, false);
+  }
+  /// @internal
+  _map(pos, assoc, simple) {
+    let delInfo = 0;
+    for (let i = this.from; i < this.to; i++) {
+      let map = this._maps[i], result = map.mapResult(pos, assoc);
+      if (result.recover != null) {
+        let corr = this.getMirror(i);
+        if (corr != null && corr > i && corr < this.to) {
+          i = corr;
+          pos = this._maps[corr].recover(result.recover);
+          continue;
+        }
+      }
+      delInfo |= result.delInfo;
+      pos = result.pos;
+    }
+    return simple ? pos : new MapResult(pos, delInfo, null);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MapResult,
+  Mapping,
+  StepMap
+});

package/dist/markup/map.d.cts

@@ -0,0 +1,50 @@
+interface Mappable {
+    map: (pos: number, assoc?: number) => number;
+    mapResult: (pos: number, assoc?: number) => MapResult;
+}
+declare class MapResult {
+    readonly pos: number;
+    readonly delInfo: number;
+    readonly recover: number | null;
+    constructor(pos: number, delInfo: number, recover: number | null);
+    get deleted(): boolean;
+    get deletedBefore(): boolean;
+    get deletedAfter(): boolean;
+    get deletedAcross(): boolean;
+}
+declare class StepMap implements Mappable {
+    readonly ranges: readonly number[];
+    readonly inverted: boolean;
+    constructor(ranges: readonly number[], inverted?: boolean);
+    recover(value: number): number;
+    mapResult(pos: number, assoc?: number): MapResult;
+    map(pos: number, assoc?: number): number;
+    _map(pos: number, assoc: number, simple: boolean): number | MapResult;
+    touches(pos: number, recover: number): boolean;
+    forEach(f: (oldStart: number, oldEnd: number, newStart: number, newEnd: number) => void): void;
+    invert(): StepMap;
+    toString(): string;
+    static offset(n: number): StepMap;
+    static empty: StepMap;
+}
+declare class Mapping implements Mappable {
+    mirror?: number[] | undefined;
+    from: number;
+    to: number;
+    constructor(maps?: readonly StepMap[], mirror?: number[] | undefined, from?: number, to?: number);
+    get maps(): readonly StepMap[];
+    private _maps;
+    private ownData;
+    slice(from?: number, to?: number): Mapping;
+    appendMap(map: StepMap, mirrors?: number): void;
+    appendMapping(mapping: Mapping): void;
+    getMirror(n: number): number | undefined;
+    setMirror(n: number, m: number): void;
+    appendMappingInverted(mapping: Mapping): void;
+    invert(): Mapping;
+    map(pos: number, assoc?: number): number;
+    mapResult(pos: number, assoc?: number): MapResult;
+    _map(pos: number, assoc: number, simple: boolean): number | MapResult;
+}
+
+export { MapResult, type Mappable, Mapping, StepMap };

package/dist/markup/map.d.ts

@@ -0,0 +1,50 @@
+interface Mappable {
+    map: (pos: number, assoc?: number) => number;
+    mapResult: (pos: number, assoc?: number) => MapResult;
+}
+declare class MapResult {
+    readonly pos: number;
+    readonly delInfo: number;
+    readonly recover: number | null;
+    constructor(pos: number, delInfo: number, recover: number | null);
+    get deleted(): boolean;
+    get deletedBefore(): boolean;
+    get deletedAfter(): boolean;
+    get deletedAcross(): boolean;
+}
+declare class StepMap implements Mappable {
+    readonly ranges: readonly number[];
+    readonly inverted: boolean;
+    constructor(ranges: readonly number[], inverted?: boolean);
+    recover(value: number): number;
+    mapResult(pos: number, assoc?: number): MapResult;
+    map(pos: number, assoc?: number): number;
+    _map(pos: number, assoc: number, simple: boolean): number | MapResult;
+    touches(pos: number, recover: number): boolean;
+    forEach(f: (oldStart: number, oldEnd: number, newStart: number, newEnd: number) => void): void;
+    invert(): StepMap;
+    toString(): string;
+    static offset(n: number): StepMap;
+    static empty: StepMap;
+}
+declare class Mapping implements Mappable {
+    mirror?: number[] | undefined;
+    from: number;
+    to: number;
+    constructor(maps?: readonly StepMap[], mirror?: number[] | undefined, from?: number, to?: number);
+    get maps(): readonly StepMap[];
+    private _maps;
+    private ownData;
+    slice(from?: number, to?: number): Mapping;
+    appendMap(map: StepMap, mirrors?: number): void;
+    appendMapping(mapping: Mapping): void;
+    getMirror(n: number): number | undefined;
+    setMirror(n: number, m: number): void;
+    appendMappingInverted(mapping: Mapping): void;
+    invert(): Mapping;
+    map(pos: number, assoc?: number): number;
+    mapResult(pos: number, assoc?: number): MapResult;
+    _map(pos: number, assoc: number, simple: boolean): number | MapResult;
+}
+
+export { MapResult, type Mappable, Mapping, StepMap };

package/dist/markup/map.js

@@ -0,0 +1,236 @@
+import "../chunk-BIEQXUOY.js";
+const lower16 = 65535;
+const factor16 = Math.pow(2, 16);
+function makeRecover(index, offset) {
+  return index + offset * factor16;
+}
+function recoverIndex(value) {
+  return value & lower16;
+}
+function recoverOffset(value) {
+  return (value - (value & lower16)) / factor16;
+}
+const DEL_BEFORE = 1, DEL_AFTER = 2, DEL_ACROSS = 4, DEL_SIDE = 8;
+class MapResult {
+  /// @internal
+  constructor(pos, delInfo, recover) {
+    this.pos = pos;
+    this.delInfo = delInfo;
+    this.recover = recover;
+  }
+  /// Tells you whether the position was deleted, that is, whether the
+  /// step removed the token on the side queried (via the `assoc`)
+  /// argument from the document.
+  get deleted() {
+    return (this.delInfo & DEL_SIDE) > 0;
+  }
+  /// Tells you whether the token before the mapped position was deleted.
+  get deletedBefore() {
+    return (this.delInfo & (DEL_BEFORE | DEL_ACROSS)) > 0;
+  }
+  /// True when the token after the mapped position was deleted.
+  get deletedAfter() {
+    return (this.delInfo & (DEL_AFTER | DEL_ACROSS)) > 0;
+  }
+  /// Tells whether any of the steps mapped through deletes across the
+  /// position (including both the token before and after the
+  /// position).
+  get deletedAcross() {
+    return (this.delInfo & DEL_ACROSS) > 0;
+  }
+}
+class StepMap {
+  /// Create a position map. The modifications to the document are
+  /// represented as an array of numbers, in which each group of three
+  /// represents a modified chunk as `[start, oldSize, newSize]`.
+  constructor(ranges, inverted = false) {
+    this.ranges = ranges;
+    this.inverted = inverted;
+    if (!ranges.length) return StepMap.empty;
+  }
+  /// @internal
+  recover(value) {
+    let diff = 0, index = recoverIndex(value);
+    if (!this.inverted)
+      for (let i = 0; i < index; i++)
+        diff += this.ranges[i * 3 + 2] - this.ranges[i * 3 + 1];
+    return this.ranges[index * 3] + diff + recoverOffset(value);
+  }
+  mapResult(pos, assoc = 1) {
+    return this._map(pos, assoc, false);
+  }
+  map(pos, assoc = 1) {
+    return this._map(pos, assoc, true);
+  }
+  /// @internal
+  _map(pos, assoc, simple) {
+    let diff = 0, oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
+    for (let i = 0; i < this.ranges.length; i += 3) {
+      let start = this.ranges[i] - (this.inverted ? diff : 0);
+      if (start > pos) break;
+      let oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex], end = start + oldSize;
+      if (pos <= end) {
+        let side = !oldSize ? assoc : pos == start ? -1 : pos == end ? 1 : assoc;
+        let result = start + diff + (side < 0 ? 0 : newSize);
+        if (simple) return result;
+        let recover = pos == (assoc < 0 ? start : end) ? null : makeRecover(i / 3, pos - start);
+        let del = pos == start ? DEL_AFTER : pos == end ? DEL_BEFORE : DEL_ACROSS;
+        if (assoc < 0 ? pos != start : pos != end) del |= DEL_SIDE;
+        return new MapResult(result, del, recover);
+      }
+      diff += newSize - oldSize;
+    }
+    return simple ? pos + diff : new MapResult(pos + diff, 0, null);
+  }
+  /// @internal
+  touches(pos, recover) {
+    let diff = 0, index = recoverIndex(recover);
+    let oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
+    for (let i = 0; i < this.ranges.length; i += 3) {
+      let start = this.ranges[i] - (this.inverted ? diff : 0);
+      if (start > pos) break;
+      let oldSize = this.ranges[i + oldIndex], end = start + oldSize;
+      if (pos <= end && i == index * 3) return true;
+      diff += this.ranges[i + newIndex] - oldSize;
+    }
+    return false;
+  }
+  /// Calls the given function on each of the changed ranges included in
+  /// this map.
+  forEach(f) {
+    let oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
+    for (let i = 0, diff = 0; i < this.ranges.length; i += 3) {
+      let start = this.ranges[i], oldStart = start - (this.inverted ? diff : 0), newStart = start + (this.inverted ? 0 : diff);
+      let oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex];
+      f(oldStart, oldStart + oldSize, newStart, newStart + newSize);
+      diff += newSize - oldSize;
+    }
+  }
+  /// Create an inverted version of this map. The result can be used to
+  /// map positions in the post-step document to the pre-step document.
+  invert() {
+    return new StepMap(this.ranges, !this.inverted);
+  }
+  /// @internal
+  toString() {
+    return (this.inverted ? "-" : "") + JSON.stringify(this.ranges);
+  }
+  /// Create a map that moves all positions by offset `n` (which may be
+  /// negative). This can be useful when applying steps meant for a
+  /// sub-document to a larger document, or vice-versa.
+  static offset(n) {
+    return n == 0 ? StepMap.empty : new StepMap(n < 0 ? [0, -n, 0] : [0, 0, n]);
+  }
+  /// A StepMap that contains no changed ranges.
+  static empty = new StepMap([]);
+}
+class Mapping {
+  /// Create a new mapping with the given position maps.
+  constructor(maps, mirror, from = 0, to = maps ? maps.length : 0) {
+    this.mirror = mirror;
+    this.from = from;
+    this.to = to;
+    this._maps = maps || [];
+    this.ownData = !(maps || mirror);
+  }
+  /// The step maps in this mapping.
+  get maps() {
+    return this._maps;
+  }
+  _maps;
+  // False if maps/mirror are shared arrays that we shouldn't mutate
+  ownData;
+  /// Create a mapping that maps only through a part of this one.
+  slice(from = 0, to = this.maps.length) {
+    return new Mapping(this._maps, this.mirror, from, to);
+  }
+  /// Add a step map to the end of this mapping. If `mirrors` is
+  /// given, it should be the index of the step map that is the mirror
+  /// image of this one.
+  appendMap(map, mirrors) {
+    if (!this.ownData) {
+      this._maps = this._maps.slice();
+      this.mirror = this.mirror && this.mirror.slice();
+      this.ownData = true;
+    }
+    this.to = this._maps.push(map);
+    if (mirrors != null) this.setMirror(this._maps.length - 1, mirrors);
+  }
+  /// Add all the step maps in a given mapping to this one (preserving
+  /// mirroring information).
+  appendMapping(mapping) {
+    for (let i = 0, startSize = this._maps.length; i < mapping._maps.length; i++) {
+      let mirr = mapping.getMirror(i);
+      this.appendMap(
+        mapping._maps[i],
+        mirr != null && mirr < i ? startSize + mirr : void 0
+      );
+    }
+  }
+  /// Finds the offset of the step map that mirrors the map at the
+  /// given offset, in this mapping (as per the second argument to
+  /// `appendMap`).
+  getMirror(n) {
+    if (this.mirror) {
+      for (let i = 0; i < this.mirror.length; i++)
+        if (this.mirror[i] == n) return this.mirror[i + (i % 2 ? -1 : 1)];
+    }
+    return void 0;
+  }
+  /// @internal
+  setMirror(n, m) {
+    if (!this.mirror) this.mirror = [];
+    this.mirror.push(n, m);
+  }
+  /// Append the inverse of the given mapping to this one.
+  appendMappingInverted(mapping) {
+    for (let i = mapping.maps.length - 1, totalSize = this._maps.length + mapping._maps.length; i >= 0; i--) {
+      let mirr = mapping.getMirror(i);
+      this.appendMap(
+        mapping._maps[i].invert(),
+        mirr != null && mirr > i ? totalSize - mirr - 1 : void 0
+      );
+    }
+  }
+  /// Create an inverted version of this mapping.
+  invert() {
+    let inverse = new Mapping();
+    inverse.appendMappingInverted(this);
+    return inverse;
+  }
+  /// Map a position through this mapping.
+  map(pos, assoc = 1) {
+    if (this.mirror) return this._map(pos, assoc, true);
+    for (let i = this.from; i < this.to; i++)
+      pos = this._maps[i].map(pos, assoc);
+    return pos;
+  }
+  /// Map a position through this mapping, returning a mapping
+  /// result.
+  mapResult(pos, assoc = 1) {
+    return this._map(pos, assoc, false);
+  }
+  /// @internal
+  _map(pos, assoc, simple) {
+    let delInfo = 0;
+    for (let i = this.from; i < this.to; i++) {
+      let map = this._maps[i], result = map.mapResult(pos, assoc);
+      if (result.recover != null) {
+        let corr = this.getMirror(i);
+        if (corr != null && corr > i && corr < this.to) {
+          i = corr;
+          pos = this._maps[corr].recover(result.recover);
+          continue;
+        }
+      }
+      delInfo |= result.delInfo;
+      pos = result.pos;
+    }
+    return simple ? pos : new MapResult(pos, delInfo, null);
+  }
+}
+export {
+  MapResult,
+  Mapping,
+  StepMap
+};