@vizel/core 0.0.1-alpha.5 → 0.0.1-alpha.6

package/dist/index65.js

@@ -1,27 +1,736 @@
-function l(e, i = "defs") {
-  let f = "";
-  const s = e.indexOf("<" + i);
-  for (; s >= 0; ) {
-    const d = e.indexOf(">", s), r = e.indexOf("</" + i);
-    if (d === -1 || r === -1) break;
-    const n = e.indexOf(">", r);
-    if (n === -1) break;
-    f += e.slice(d + 1, r).trim(), e = e.slice(0, s).trim() + e.slice(n + 1);
-  }
-  return {
-    defs: f,
-    content: e
-  };
-}
-function t(e, i) {
-  return e ? "<defs>" + e + "</defs>" + i : i;
-}
-function u(e, i, f) {
-  const s = l(e);
-  return t(s.defs, i + s.content + f);
+import { Slice as c, ReplaceError as W, Fragment as E } from "./index64.js";
+const A = 65535, L = Math.pow(2, 16);
+function G(h, t) {
+  return h + t * L;
 }
+function z(h) {
+  return h & A;
+}
+function H(h) {
+  return (h - (h & A)) / L;
+}
+const C = 1, B = 2, I = 4, $ = 8;
+class R {
+  /**
+  @internal
+  */
+  constructor(t, e, r) {
+    this.pos = t, this.delInfo = e, this.recover = r;
+  }
+  /**
+  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 & $) > 0;
+  }
+  /**
+  Tells you whether the token before the mapped position was deleted.
+  */
+  get deletedBefore() {
+    return (this.delInfo & (C | I)) > 0;
+  }
+  /**
+  True when the token after the mapped position was deleted.
+  */
+  get deletedAfter() {
+    return (this.delInfo & (B | I)) > 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 & I) > 0;
+  }
+}
+class p {
+  /**
+  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(t, e = !1) {
+    if (this.ranges = t, this.inverted = e, !t.length && p.empty)
+      return p.empty;
+  }
+  /**
+  @internal
+  */
+  recover(t) {
+    let e = 0, r = z(t);
+    if (!this.inverted)
+      for (let s = 0; s < r; s++)
+        e += this.ranges[s * 3 + 2] - this.ranges[s * 3 + 1];
+    return this.ranges[r * 3] + e + H(t);
+  }
+  mapResult(t, e = 1) {
+    return this._map(t, e, !1);
+  }
+  map(t, e = 1) {
+    return this._map(t, e, !0);
+  }
+  /**
+  @internal
+  */
+  _map(t, e, r) {
+    let s = 0, i = this.inverted ? 2 : 1, n = this.inverted ? 1 : 2;
+    for (let o = 0; o < this.ranges.length; o += 3) {
+      let a = this.ranges[o] - (this.inverted ? s : 0);
+      if (a > t)
+        break;
+      let f = this.ranges[o + i], u = this.ranges[o + n], d = a + f;
+      if (t <= d) {
+        let q = f ? t == a ? -1 : t == d ? 1 : e : e, M = a + s + (q < 0 ? 0 : u);
+        if (r)
+          return M;
+        let P = t == (e < 0 ? a : d) ? null : G(o / 3, t - a), D = t == a ? B : t == d ? C : I;
+        return (e < 0 ? t != a : t != d) && (D |= $), new R(M, D, P);
+      }
+      s += u - f;
+    }
+    return r ? t + s : new R(t + s, 0, null);
+  }
+  /**
+  @internal
+  */
+  touches(t, e) {
+    let r = 0, s = z(e), i = this.inverted ? 2 : 1, n = this.inverted ? 1 : 2;
+    for (let o = 0; o < this.ranges.length; o += 3) {
+      let a = this.ranges[o] - (this.inverted ? r : 0);
+      if (a > t)
+        break;
+      let f = this.ranges[o + i], u = a + f;
+      if (t <= u && o == s * 3)
+        return !0;
+      r += this.ranges[o + n] - f;
+    }
+    return !1;
+  }
+  /**
+  Calls the given function on each of the changed ranges included in
+  this map.
+  */
+  forEach(t) {
+    let e = this.inverted ? 2 : 1, r = this.inverted ? 1 : 2;
+    for (let s = 0, i = 0; s < this.ranges.length; s += 3) {
+      let n = this.ranges[s], o = n - (this.inverted ? i : 0), a = n + (this.inverted ? 0 : i), f = this.ranges[s + e], u = this.ranges[s + r];
+      t(o, o + f, a, a + u), i += u - f;
+    }
+  }
+  /**
+  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 p(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(t) {
+    return t == 0 ? p.empty : new p(t < 0 ? [0, -t, 0] : [0, 0, t]);
+  }
+}
+p.empty = new p([]);
+class x {
+  /**
+  Create a new mapping with the given position maps.
+  */
+  constructor(t, e, r = 0, s = t ? t.length : 0) {
+    this.mirror = e, this.from = r, this.to = s, this._maps = t || [], this.ownData = !(t || e);
+  }
+  /**
+  The step maps in this mapping.
+  */
+  get maps() {
+    return this._maps;
+  }
+  /**
+  Create a mapping that maps only through a part of this one.
+  */
+  slice(t = 0, e = this.maps.length) {
+    return new x(this._maps, this.mirror, t, e);
+  }
+  /**
+  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(t, e) {
+    this.ownData || (this._maps = this._maps.slice(), this.mirror = this.mirror && this.mirror.slice(), this.ownData = !0), this.to = this._maps.push(t), e != null && this.setMirror(this._maps.length - 1, e);
+  }
+  /**
+  Add all the step maps in a given mapping to this one (preserving
+  mirroring information).
+  */
+  appendMapping(t) {
+    for (let e = 0, r = this._maps.length; e < t._maps.length; e++) {
+      let s = t.getMirror(e);
+      this.appendMap(t._maps[e], s != null && s < e ? r + s : 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(t) {
+    if (this.mirror) {
+      for (let e = 0; e < this.mirror.length; e++)
+        if (this.mirror[e] == t)
+          return this.mirror[e + (e % 2 ? -1 : 1)];
+    }
+  }
+  /**
+  @internal
+  */
+  setMirror(t, e) {
+    this.mirror || (this.mirror = []), this.mirror.push(t, e);
+  }
+  /**
+  Append the inverse of the given mapping to this one.
+  */
+  appendMappingInverted(t) {
+    for (let e = t.maps.length - 1, r = this._maps.length + t._maps.length; e >= 0; e--) {
+      let s = t.getMirror(e);
+      this.appendMap(t._maps[e].invert(), s != null && s > e ? r - s - 1 : void 0);
+    }
+  }
+  /**
+  Create an inverted version of this mapping.
+  */
+  invert() {
+    let t = new x();
+    return t.appendMappingInverted(this), t;
+  }
+  /**
+  Map a position through this mapping.
+  */
+  map(t, e = 1) {
+    if (this.mirror)
+      return this._map(t, e, !0);
+    for (let r = this.from; r < this.to; r++)
+      t = this._maps[r].map(t, e);
+    return t;
+  }
+  /**
+  Map a position through this mapping, returning a mapping
+  result.
+  */
+  mapResult(t, e = 1) {
+    return this._map(t, e, !1);
+  }
+  /**
+  @internal
+  */
+  _map(t, e, r) {
+    let s = 0;
+    for (let i = this.from; i < this.to; i++) {
+      let n = this._maps[i], o = n.mapResult(t, e);
+      if (o.recover != null) {
+        let a = this.getMirror(i);
+        if (a != null && a > i && a < this.to) {
+          i = a, t = this._maps[a].recover(o.recover);
+          continue;
+        }
+      }
+      s |= o.delInfo, t = o.pos;
+    }
+    return r ? t : new R(t, s, null);
+  }
+}
+const T = /* @__PURE__ */ Object.create(null);
+class m {
+  /**
+  Get the step map that represents the changes made by this step,
+  and which can be used to transform between positions in the old
+  and the new document.
+  */
+  getMap() {
+    return p.empty;
+  }
+  /**
+  Try to merge this step with another one, to be applied directly
+  after it. Returns the merged step when possible, null if the
+  steps can't be merged.
+  */
+  merge(t) {
+    return null;
+  }
+  /**
+  Deserialize a step from its JSON representation. Will call
+  through to the step class' own implementation of this method.
+  */
+  static fromJSON(t, e) {
+    if (!e || !e.stepType)
+      throw new RangeError("Invalid input for Step.fromJSON");
+    let r = T[e.stepType];
+    if (!r)
+      throw new RangeError(`No step type ${e.stepType} defined`);
+    return r.fromJSON(t, e);
+  }
+  /**
+  To be able to serialize steps to JSON, each step needs a string
+  ID to attach to its JSON representation. Use this method to
+  register an ID for your step classes. Try to pick something
+  that's unlikely to clash with steps from other modules.
+  */
+  static jsonID(t, e) {
+    if (t in T)
+      throw new RangeError("Duplicate use of step JSON ID " + t);
+    return T[t] = e, e.prototype.jsonID = t, e;
+  }
+}
+class l {
+  /**
+  @internal
+  */
+  constructor(t, e) {
+    this.doc = t, this.failed = e;
+  }
+  /**
+  Create a successful step result.
+  */
+  static ok(t) {
+    return new l(t, null);
+  }
+  /**
+  Create a failed step result.
+  */
+  static fail(t) {
+    return new l(null, t);
+  }
+  /**
+  Call [`Node.replace`](https://prosemirror.net/docs/ref/#model.Node.replace) with the given
+  arguments. Create a successful result if it succeeds, and a
+  failed one if it throws a `ReplaceError`.
+  */
+  static fromReplace(t, e, r, s) {
+    try {
+      return l.ok(t.replace(e, r, s));
+    } catch (i) {
+      if (i instanceof W)
+        return l.fail(i.message);
+      throw i;
+    }
+  }
+}
+function F(h, t, e) {
+  let r = [];
+  for (let s = 0; s < h.childCount; s++) {
+    let i = h.child(s);
+    i.content.size && (i = i.copy(F(i.content, t, i))), i.isInline && (i = t(i, e, s)), r.push(i);
+  }
+  return E.fromArray(r);
+}
+class w extends m {
+  /**
+  Create a mark step.
+  */
+  constructor(t, e, r) {
+    super(), this.from = t, this.to = e, this.mark = r;
+  }
+  apply(t) {
+    let e = t.slice(this.from, this.to), r = t.resolve(this.from), s = r.node(r.sharedDepth(this.to)), i = new c(F(e.content, (n, o) => !n.isAtom || !o.type.allowsMarkType(this.mark.type) ? n : n.mark(this.mark.addToSet(n.marks)), s), e.openStart, e.openEnd);
+    return l.fromReplace(t, this.from, this.to, i);
+  }
+  invert() {
+    return new k(this.from, this.to, this.mark);
+  }
+  map(t) {
+    let e = t.mapResult(this.from, 1), r = t.mapResult(this.to, -1);
+    return e.deleted && r.deleted || e.pos >= r.pos ? null : new w(e.pos, r.pos, this.mark);
+  }
+  merge(t) {
+    return t instanceof w && t.mark.eq(this.mark) && this.from <= t.to && this.to >= t.from ? new w(Math.min(this.from, t.from), Math.max(this.to, t.to), this.mark) : null;
+  }
+  toJSON() {
+    return {
+      stepType: "addMark",
+      mark: this.mark.toJSON(),
+      from: this.from,
+      to: this.to
+    };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(t, e) {
+    if (typeof e.from != "number" || typeof e.to != "number")
+      throw new RangeError("Invalid input for AddMarkStep.fromJSON");
+    return new w(e.from, e.to, t.markFromJSON(e.mark));
+  }
+}
+m.jsonID("addMark", w);
+class k extends m {
+  /**
+  Create a mark-removing step.
+  */
+  constructor(t, e, r) {
+    super(), this.from = t, this.to = e, this.mark = r;
+  }
+  apply(t) {
+    let e = t.slice(this.from, this.to), r = new c(F(e.content, (s) => s.mark(this.mark.removeFromSet(s.marks)), t), e.openStart, e.openEnd);
+    return l.fromReplace(t, this.from, this.to, r);
+  }
+  invert() {
+    return new w(this.from, this.to, this.mark);
+  }
+  map(t) {
+    let e = t.mapResult(this.from, 1), r = t.mapResult(this.to, -1);
+    return e.deleted && r.deleted || e.pos >= r.pos ? null : new k(e.pos, r.pos, this.mark);
+  }
+  merge(t) {
+    return t instanceof k && t.mark.eq(this.mark) && this.from <= t.to && this.to >= t.from ? new k(Math.min(this.from, t.from), Math.max(this.to, t.to), this.mark) : null;
+  }
+  toJSON() {
+    return {
+      stepType: "removeMark",
+      mark: this.mark.toJSON(),
+      from: this.from,
+      to: this.to
+    };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(t, e) {
+    if (typeof e.from != "number" || typeof e.to != "number")
+      throw new RangeError("Invalid input for RemoveMarkStep.fromJSON");
+    return new k(e.from, e.to, t.markFromJSON(e.mark));
+  }
+}
+m.jsonID("removeMark", k);
+class y extends m {
+  /**
+  Create a node mark step.
+  */
+  constructor(t, e) {
+    super(), this.pos = t, this.mark = e;
+  }
+  apply(t) {
+    let e = t.nodeAt(this.pos);
+    if (!e)
+      return l.fail("No node at mark step's position");
+    let r = e.type.create(e.attrs, null, this.mark.addToSet(e.marks));
+    return l.fromReplace(t, this.pos, this.pos + 1, new c(E.from(r), 0, e.isLeaf ? 0 : 1));
+  }
+  invert(t) {
+    let e = t.nodeAt(this.pos);
+    if (e) {
+      let r = this.mark.addToSet(e.marks);
+      if (r.length == e.marks.length) {
+        for (let s = 0; s < e.marks.length; s++)
+          if (!e.marks[s].isInSet(r))
+            return new y(this.pos, e.marks[s]);
+        return new y(this.pos, this.mark);
+      }
+    }
+    return new O(this.pos, this.mark);
+  }
+  map(t) {
+    let e = t.mapResult(this.pos, 1);
+    return e.deletedAfter ? null : new y(e.pos, this.mark);
+  }
+  toJSON() {
+    return { stepType: "addNodeMark", pos: this.pos, mark: this.mark.toJSON() };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(t, e) {
+    if (typeof e.pos != "number")
+      throw new RangeError("Invalid input for AddNodeMarkStep.fromJSON");
+    return new y(e.pos, t.markFromJSON(e.mark));
+  }
+}
+m.jsonID("addNodeMark", y);
+class O extends m {
+  /**
+  Create a mark-removing step.
+  */
+  constructor(t, e) {
+    super(), this.pos = t, this.mark = e;
+  }
+  apply(t) {
+    let e = t.nodeAt(this.pos);
+    if (!e)
+      return l.fail("No node at mark step's position");
+    let r = e.type.create(e.attrs, null, this.mark.removeFromSet(e.marks));
+    return l.fromReplace(t, this.pos, this.pos + 1, new c(E.from(r), 0, e.isLeaf ? 0 : 1));
+  }
+  invert(t) {
+    let e = t.nodeAt(this.pos);
+    return !e || !this.mark.isInSet(e.marks) ? this : new y(this.pos, this.mark);
+  }
+  map(t) {
+    let e = t.mapResult(this.pos, 1);
+    return e.deletedAfter ? null : new O(e.pos, this.mark);
+  }
+  toJSON() {
+    return { stepType: "removeNodeMark", pos: this.pos, mark: this.mark.toJSON() };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(t, e) {
+    if (typeof e.pos != "number")
+      throw new RangeError("Invalid input for RemoveNodeMarkStep.fromJSON");
+    return new O(e.pos, t.markFromJSON(e.mark));
+  }
+}
+m.jsonID("removeNodeMark", O);
+class g extends m {
+  /**
+  The given `slice` should fit the 'gap' between `from` and
+  `to`—the depths must line up, and the surrounding nodes must be
+  able to be joined with the open sides of the slice. When
+  `structure` is true, the step will fail if the content between
+  from and to is not just a sequence of closing and then opening
+  tokens (this is to guard against rebased replace steps
+  overwriting something they weren't supposed to).
+  */
+  constructor(t, e, r, s = !1) {
+    super(), this.from = t, this.to = e, this.slice = r, this.structure = s;
+  }
+  apply(t) {
+    return this.structure && b(t, this.from, this.to) ? l.fail("Structure replace would overwrite content") : l.fromReplace(t, this.from, this.to, this.slice);
+  }
+  getMap() {
+    return new p([this.from, this.to - this.from, this.slice.size]);
+  }
+  invert(t) {
+    return new g(this.from, this.from + this.slice.size, t.slice(this.from, this.to));
+  }
+  map(t) {
+    let e = t.mapResult(this.from, 1), r = t.mapResult(this.to, -1);
+    return e.deletedAcross && r.deletedAcross ? null : new g(e.pos, Math.max(e.pos, r.pos), this.slice, this.structure);
+  }
+  merge(t) {
+    if (!(t instanceof g) || t.structure || this.structure)
+      return null;
+    if (this.from + this.slice.size == t.from && !this.slice.openEnd && !t.slice.openStart) {
+      let e = this.slice.size + t.slice.size == 0 ? c.empty : new c(this.slice.content.append(t.slice.content), this.slice.openStart, t.slice.openEnd);
+      return new g(this.from, this.to + (t.to - t.from), e, this.structure);
+    } else if (t.to == this.from && !this.slice.openStart && !t.slice.openEnd) {
+      let e = this.slice.size + t.slice.size == 0 ? c.empty : new c(t.slice.content.append(this.slice.content), t.slice.openStart, this.slice.openEnd);
+      return new g(t.from, this.to, e, this.structure);
+    } else
+      return null;
+  }
+  toJSON() {
+    let t = { stepType: "replace", from: this.from, to: this.to };
+    return this.slice.size && (t.slice = this.slice.toJSON()), this.structure && (t.structure = !0), t;
+  }
+  /**
+  @internal
+  */
+  static fromJSON(t, e) {
+    if (typeof e.from != "number" || typeof e.to != "number")
+      throw new RangeError("Invalid input for ReplaceStep.fromJSON");
+    return new g(e.from, e.to, c.fromJSON(t, e.slice), !!e.structure);
+  }
+}
+m.jsonID("replace", g);
+class v extends m {
+  /**
+  Create a replace-around step with the given range and gap.
+  `insert` should be the point in the slice into which the content
+  of the gap should be moved. `structure` has the same meaning as
+  it has in the [`ReplaceStep`](https://prosemirror.net/docs/ref/#transform.ReplaceStep) class.
+  */
+  constructor(t, e, r, s, i, n, o = !1) {
+    super(), this.from = t, this.to = e, this.gapFrom = r, this.gapTo = s, this.slice = i, this.insert = n, this.structure = o;
+  }
+  apply(t) {
+    if (this.structure && (b(t, this.from, this.gapFrom) || b(t, this.gapTo, this.to)))
+      return l.fail("Structure gap-replace would overwrite content");
+    let e = t.slice(this.gapFrom, this.gapTo);
+    if (e.openStart || e.openEnd)
+      return l.fail("Gap is not a flat range");
+    let r = this.slice.insertAt(this.insert, e.content);
+    return r ? l.fromReplace(t, this.from, this.to, r) : l.fail("Content does not fit in gap");
+  }
+  getMap() {
+    return new p([
+      this.from,
+      this.gapFrom - this.from,
+      this.insert,
+      this.gapTo,
+      this.to - this.gapTo,
+      this.slice.size - this.insert
+    ]);
+  }
+  invert(t) {
+    let e = this.gapTo - this.gapFrom;
+    return new v(this.from, this.from + this.slice.size + e, this.from + this.insert, this.from + this.insert + e, t.slice(this.from, this.to).removeBetween(this.gapFrom - this.from, this.gapTo - this.from), this.gapFrom - this.from, this.structure);
+  }
+  map(t) {
+    let e = t.mapResult(this.from, 1), r = t.mapResult(this.to, -1), s = this.from == this.gapFrom ? e.pos : t.map(this.gapFrom, -1), i = this.to == this.gapTo ? r.pos : t.map(this.gapTo, 1);
+    return e.deletedAcross && r.deletedAcross || s < e.pos || i > r.pos ? null : new v(e.pos, r.pos, s, i, this.slice, this.insert, this.structure);
+  }
+  toJSON() {
+    let t = {
+      stepType: "replaceAround",
+      from: this.from,
+      to: this.to,
+      gapFrom: this.gapFrom,
+      gapTo: this.gapTo,
+      insert: this.insert
+    };
+    return this.slice.size && (t.slice = this.slice.toJSON()), this.structure && (t.structure = !0), t;
+  }
+  /**
+  @internal
+  */
+  static fromJSON(t, e) {
+    if (typeof e.from != "number" || typeof e.to != "number" || typeof e.gapFrom != "number" || typeof e.gapTo != "number" || typeof e.insert != "number")
+      throw new RangeError("Invalid input for ReplaceAroundStep.fromJSON");
+    return new v(e.from, e.to, e.gapFrom, e.gapTo, c.fromJSON(t, e.slice), e.insert, !!e.structure);
+  }
+}
+m.jsonID("replaceAround", v);
+function b(h, t, e) {
+  let r = h.resolve(t), s = e - t, i = r.depth;
+  for (; s > 0 && i > 0 && r.indexAfter(i) == r.node(i).childCount; )
+    i--, s--;
+  if (s > 0) {
+    let n = r.node(i).maybeChild(r.indexAfter(i));
+    for (; s > 0; ) {
+      if (!n || n.isLeaf)
+        return !0;
+      n = n.firstChild, s--;
+    }
+  }
+  return !1;
+}
+function Q(h, t, e) {
+  let r = h.resolve(t);
+  if (!e.content.size)
+    return t;
+  let s = e.content;
+  for (let i = 0; i < e.openStart; i++)
+    s = s.firstChild.content;
+  for (let i = 1; i <= (e.openStart == 0 && e.size ? 2 : 1); i++)
+    for (let n = r.depth; n >= 0; n--) {
+      let o = n == r.depth ? 0 : r.pos <= (r.start(n + 1) + r.end(n + 1)) / 2 ? -1 : 1, a = r.index(n) + (o > 0 ? 1 : 0), f = r.node(n), u = !1;
+      if (i == 1)
+        u = f.canReplace(a, a, s);
+      else {
+        let d = f.contentMatchAt(a).findWrapping(s.firstChild.type);
+        u = d && f.canReplaceWith(a, a, d[0]);
+      }
+      if (u)
+        return o == 0 ? r.pos : o < 0 ? r.before(n + 1) : r.after(n + 1);
+    }
+  return null;
+}
+class S extends m {
+  /**
+  Construct an attribute step.
+  */
+  constructor(t, e, r) {
+    super(), this.pos = t, this.attr = e, this.value = r;
+  }
+  apply(t) {
+    let e = t.nodeAt(this.pos);
+    if (!e)
+      return l.fail("No node at attribute step's position");
+    let r = /* @__PURE__ */ Object.create(null);
+    for (let i in e.attrs)
+      r[i] = e.attrs[i];
+    r[this.attr] = this.value;
+    let s = e.type.create(r, null, e.marks);
+    return l.fromReplace(t, this.pos, this.pos + 1, new c(E.from(s), 0, e.isLeaf ? 0 : 1));
+  }
+  getMap() {
+    return p.empty;
+  }
+  invert(t) {
+    return new S(this.pos, this.attr, t.nodeAt(this.pos).attrs[this.attr]);
+  }
+  map(t) {
+    let e = t.mapResult(this.pos, 1);
+    return e.deletedAfter ? null : new S(e.pos, this.attr, this.value);
+  }
+  toJSON() {
+    return { stepType: "attr", pos: this.pos, attr: this.attr, value: this.value };
+  }
+  static fromJSON(t, e) {
+    if (typeof e.pos != "number" || typeof e.attr != "string")
+      throw new RangeError("Invalid input for AttrStep.fromJSON");
+    return new S(e.pos, e.attr, e.value);
+  }
+}
+m.jsonID("attr", S);
+class J extends m {
+  /**
+  Construct an attribute step.
+  */
+  constructor(t, e) {
+    super(), this.attr = t, this.value = e;
+  }
+  apply(t) {
+    let e = /* @__PURE__ */ Object.create(null);
+    for (let s in t.attrs)
+      e[s] = t.attrs[s];
+    e[this.attr] = this.value;
+    let r = t.type.create(e, t.content, t.marks);
+    return l.ok(r);
+  }
+  getMap() {
+    return p.empty;
+  }
+  invert(t) {
+    return new J(this.attr, t.attrs[this.attr]);
+  }
+  map(t) {
+    return this;
+  }
+  toJSON() {
+    return { stepType: "docAttr", attr: this.attr, value: this.value };
+  }
+  static fromJSON(t, e) {
+    if (typeof e.attr != "string")
+      throw new RangeError("Invalid input for DocAttrStep.fromJSON");
+    return new J(e.attr, e.value);
+  }
+}
+m.jsonID("docAttr", J);
+let N = class extends Error {
+};
+N = function h(t) {
+  let e = Error.call(this, t);
+  return e.__proto__ = h.prototype, e;
+};
+N.prototype = Object.create(Error.prototype);
+N.prototype.constructor = N;
+N.prototype.name = "TransformError";
 export {
-  t as mergeDefsAndContent,
-  l as splitSVGDefs,
-  u as wrapSVGContent
+  w as AddMarkStep,
+  y as AddNodeMarkStep,
+  S as AttrStep,
+  J as DocAttrStep,
+  R as MapResult,
+  x as Mapping,
+  k as RemoveMarkStep,
+  O as RemoveNodeMarkStep,
+  v as ReplaceAroundStep,
+  g as ReplaceStep,
+  m as Step,
+  p as StepMap,
+  l as StepResult,
+  N as TransformError,
+  Q as dropPoint
 };