@blade-hq/agent-react 2612.0.0-beta.2 → 2612.0.0-beta.21

package/node_modules/prosemirror-transform/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "prosemirror-transform",
+  "version": "1.11.0",
+  "description": "ProseMirror document transformations",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    "import": "./dist/index.js",
+    "require": "./dist/index.cjs"
+  },
+  "sideEffects": false,
+  "license": "MIT",
+  "maintainers": [
+    {
+      "name": "Marijn Haverbeke",
+      "email": "marijn@haverbeke.berlin",
+      "web": "http://marijnhaverbeke.nl"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/prosemirror/prosemirror-transform.git"
+  },
+  "dependencies": {
+    "prosemirror-model": "^1.21.0"
+  },
+  "devDependencies": {
+    "@prosemirror/buildhelper": "^0.1.5",
+    "prosemirror-test-builder": "^1.0.0"
+  },
+  "scripts": {
+    "test": "pm-runtests",
+    "prepare": "pm-buildhelper src/index.ts"
+  }
+}

package/node_modules/prosemirror-transform/src/README.md

@@ -0,0 +1,59 @@
+This module defines a way of modifying documents that allows changes
+to be recorded, replayed, and reordered. You can read more about
+transformations in [the guide](/docs/guide/#transform).
+
+### Steps
+
+Transforming happens in `Step`s, which are atomic, well-defined
+modifications to a document. [Applying](#transform.Step.apply) a step
+produces a new document.
+
+Each step provides a [change map](#transform.StepMap) that maps
+positions in the old document to position in the transformed document.
+Steps can be [inverted](#transform.Step.invert) to create a step that
+undoes their effect, and chained together in a convenience object
+called a [`Transform`](#transform.Transform).
+
+@Step
+@StepResult
+@ReplaceStep
+@ReplaceAroundStep
+@AddMarkStep
+@RemoveMarkStep
+@AddNodeMarkStep
+@RemoveNodeMarkStep
+@AttrStep
+@DocAttrStep
+
+### Position Mapping
+
+Mapping positions from one document to another by running through the
+[step maps](#transform.StepMap) produced by steps is an important
+operation in ProseMirror. It is used, for example, for updating the
+selection when the document changes.
+
+@Mappable
+@MapResult
+@StepMap
+@Mapping
+
+### Document transforms
+
+Because you often need to collect a number of steps together to effect
+a composite change, ProseMirror provides an abstraction to make this
+easy. [State transactions](#state.Transaction) are a subclass of
+transforms.
+
+@Transform
+
+The following helper functions can be useful when creating
+transformations or determining whether they are even possible.
+
+@replaceStep
+@liftTarget
+@findWrapping
+@canSplit
+@canJoin
+@joinPoint
+@insertPoint
+@dropPoint

package/node_modules/prosemirror-transform/src/attr_step.ts

@@ -0,0 +1,98 @@
+import {Fragment, Slice, Node, Schema} from "prosemirror-model"
+import {Step, StepResult} from "./step"
+import {StepMap, Mappable} from "./map"
+
+/// Update an attribute in a specific node.
+export class AttrStep extends Step {
+  /// Construct an attribute step.
+  constructor(
+    /// The position of the target node.
+    readonly pos: number,
+    /// The attribute to set.
+    readonly attr: string,
+    // The attribute's new value.
+    readonly value: any
+  ) {
+    super()
+  }
+
+  apply(doc: Node) {
+    let node = doc.nodeAt(this.pos)
+    if (!node) return StepResult.fail("No node at attribute step's position")
+    let attrs = Object.create(null)
+    for (let name in node.attrs) attrs[name] = node.attrs[name]
+    attrs[this.attr] = this.value
+    let updated = node.type.create(attrs, null, node.marks)
+    return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1))
+  }
+
+  getMap() {
+    return StepMap.empty
+  }
+
+  invert(doc: Node) {
+    return new AttrStep(this.pos, this.attr, doc.nodeAt(this.pos)!.attrs[this.attr])
+  }
+
+  map(mapping: Mappable) {
+    let pos = mapping.mapResult(this.pos, 1)
+    return pos.deletedAfter ? null : new AttrStep(pos.pos, this.attr, this.value)
+  }
+
+  toJSON(): any {
+    return {stepType: "attr", pos: this.pos, attr: this.attr, value: this.value}
+  }
+
+  static fromJSON(schema: Schema, json: any) {
+    if (typeof json.pos != "number" || typeof json.attr != "string")
+      throw new RangeError("Invalid input for AttrStep.fromJSON")
+    return new AttrStep(json.pos, json.attr, json.value)
+  }
+}
+
+Step.jsonID("attr", AttrStep)
+
+/// Update an attribute in the doc node.
+export class DocAttrStep extends Step {
+  /// Construct an attribute step.
+  constructor(
+    /// The attribute to set.
+    readonly attr: string,
+    // The attribute's new value.
+    readonly value: any
+  ) {
+    super()
+  }
+
+  apply(doc: Node) {
+    let attrs = Object.create(null)
+    for (let name in doc.attrs) attrs[name] = doc.attrs[name]
+    attrs[this.attr] = this.value
+    let updated = doc.type.create(attrs, doc.content, doc.marks)
+    return StepResult.ok(updated)
+  }
+
+  getMap() {
+    return StepMap.empty
+  }
+
+  invert(doc: Node) {
+    return new DocAttrStep(this.attr, doc.attrs[this.attr])
+  }
+
+  map(mapping: Mappable) {
+    return this
+  }
+
+  toJSON(): any {
+    return {stepType: "docAttr", attr: this.attr, value: this.value}
+  }
+
+  static fromJSON(schema: Schema, json: any) {
+    if (typeof json.attr != "string")
+      throw new RangeError("Invalid input for DocAttrStep.fromJSON")
+    return new DocAttrStep(json.attr, json.value)
+  }
+}
+
+Step.jsonID("docAttr", DocAttrStep)

package/node_modules/prosemirror-transform/src/index.ts

@@ -0,0 +1,11 @@
+export {Transform} from "./transform"
+/// @internal
+export {TransformError} from "./transform"
+export {Step, StepResult} from "./step"
+export {joinPoint, canJoin, canSplit, insertPoint, dropPoint, liftTarget, findWrapping} from "./structure"
+export {StepMap, MapResult, Mapping, Mappable} from "./map"
+export {AddMarkStep, RemoveMarkStep, AddNodeMarkStep, RemoveNodeMarkStep} from "./mark_step"
+export {ReplaceStep, ReplaceAroundStep} from "./replace_step"
+export {AttrStep, DocAttrStep} from "./attr_step"
+import "./mark"
+export {replaceStep} from "./replace"

package/node_modules/prosemirror-transform/src/map.ts

@@ -0,0 +1,284 @@
+/// There are several things that positions can be mapped through.
+/// Such objects conform to this interface.
+export interface Mappable {
+  /// Map a position through this object. When given, `assoc` (should
+  /// be -1 or 1, defaults to 1) determines with which side the
+  /// position is associated, which determines in which direction to
+  /// move when a chunk of content is inserted at the mapped position.
+  map: (pos: number, assoc?: number) => number
+
+  /// Map a position, and return an object containing additional
+  /// information about the mapping. The result's `deleted` field tells
+  /// you whether the position was deleted (completely enclosed in a
+  /// replaced range) during the mapping. When content on only one side
+  /// is deleted, the position itself is only considered deleted when
+  /// `assoc` points in the direction of the deleted content.
+  mapResult: (pos: number, assoc?: number) => MapResult
+}
+
+// Recovery values encode a range index and an offset. They are
+// represented as numbers, because tons of them will be created when
+// mapping, for example, a large number of decorations. The number's
+// lower 16 bits provide the index, the remaining bits the offset.
+//
+// Note: We intentionally don't use bit shift operators to en- and
+// decode these, since those clip to 32 bits, which we might in rare
+// cases want to overflow. A 64-bit float can represent 48-bit
+// integers precisely.
+
+const lower16 = 0xffff
+const factor16 = Math.pow(2, 16)
+
+function makeRecover(index: number, offset: number) { return index + offset * factor16 }
+function recoverIndex(value: number) { return value & lower16 }
+function recoverOffset(value: number) { return (value - (value & lower16)) / factor16 }
+
+const DEL_BEFORE = 1, DEL_AFTER = 2, DEL_ACROSS = 4, DEL_SIDE = 8
+
+/// An object representing a mapped position with extra
+/// information.
+export class MapResult {
+  /// @internal
+  constructor(
+    /// The mapped version of the position.
+    readonly pos: number,
+    /// @internal
+    readonly delInfo: number,
+    /// @internal
+    readonly recover: number | null
+  ) {}
+
+  /// 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 }
+}
+
+/// A map describing the deletions and insertions made by a step, which
+/// can be used to find the correspondence between positions in the
+/// pre-step version of a document and the same position in the
+/// post-step version.
+export class StepMap implements Mappable {
+  /// 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(
+    /// @internal
+    readonly ranges: readonly number[],
+    /// @internal
+    readonly inverted = false
+  ) {
+    if (!ranges.length && StepMap.empty) return StepMap.empty
+  }
+
+  /// @internal
+  recover(value: number) {
+    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: number, assoc = 1): MapResult { return this._map(pos, assoc, false) as MapResult }
+
+  map(pos: number, assoc = 1): number { return this._map(pos, assoc, true) as number }
+
+  /// @internal
+  _map(pos: number, assoc: number, simple: boolean) {
+    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: number, recover: number) {
+    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: (oldStart: number, oldEnd: number, newStart: number, newEnd: number) => void) {
+    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: number) {
+    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([])
+}
+
+/// A mapping represents a pipeline of zero or more [step
+/// maps](#transform.StepMap). It has special provisions for losslessly
+/// handling mapping positions through a series of steps in which some
+/// steps are inverted versions of earlier steps. (This comes up when
+/// ‘[rebasing](/docs/guide/#transform.rebasing)’ steps for
+/// collaboration or history management.)
+export class Mapping implements Mappable {
+  /// Create a new mapping with the given position maps.
+  constructor(
+    maps?: readonly StepMap[],
+    /// @internal
+    public mirror?: number[],
+    /// The starting position in the `maps` array, used when `map` or
+    /// `mapResult` is called.
+    public from = 0,
+    /// The end position in the `maps` array.
+    public to = maps ? maps.length : 0
+  ) {
+    this._maps = (maps as StepMap[]) || []
+    this.ownData = !(maps || mirror)
+  }
+
+  /// The step maps in this mapping.
+  get maps(): readonly StepMap[] { return this._maps }
+
+  private _maps: StepMap[]
+  // False if maps/mirror are shared arrays that we shouldn't mutate
+  private ownData: boolean
+
+  /// 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: StepMap, mirrors?: number) {
+    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: 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 : undefined)
+    }
+  }
+
+  /// 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: number): number | undefined {
+    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)]
+  }
+
+  /// @internal
+  setMirror(n: number, m: number) {
+    if (!this.mirror) this.mirror = []
+    this.mirror.push(n, m)
+  }
+
+  /// Append the inverse of the given mapping to this one.
+  appendMappingInverted(mapping: 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 : undefined)
+    }
+  }
+
+  /// 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: number, assoc = 1) {
+    if (this.mirror) return this._map(pos, assoc, true) as number
+    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: number, assoc = 1) { return this._map(pos, assoc, false) as MapResult }
+
+  /// @internal
+  _map(pos: number, assoc: number, simple: boolean) {
+    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)
+  }
+}

package/node_modules/prosemirror-transform/src/mark.ts

@@ -0,0 +1,106 @@
+import {Mark, MarkType, Slice, Fragment, NodeType} from "prosemirror-model"
+
+import {Step} from "./step"
+import {Transform} from "./transform"
+import {AddMarkStep, RemoveMarkStep} from "./mark_step"
+import {ReplaceStep} from "./replace_step"
+
+export function addMark(tr: Transform, from: number, to: number, mark: Mark) {
+  let removed: Step[] = [], added: Step[] = []
+  let removing: RemoveMarkStep | undefined, adding: AddMarkStep | undefined
+  tr.doc.nodesBetween(from, to, (node, pos, parent) => {
+    if (!node.isInline) return
+    let marks = node.marks
+    if (!mark.isInSet(marks) && parent!.type.allowsMarkType(mark.type)) {
+      let start = Math.max(pos, from), end = Math.min(pos + node.nodeSize, to)
+      let newSet = mark.addToSet(marks)
+
+      for (let i = 0; i < marks.length; i++) {
+        if (!marks[i].isInSet(newSet)) {
+          if (removing && removing.to == start && removing.mark.eq(marks[i]))
+            (removing as any).to = end
+          else
+            removed.push(removing = new RemoveMarkStep(start, end, marks[i]))
+        }
+      }
+
+      if (adding && adding.to == start)
+        (adding as any).to = end
+      else
+        added.push(adding = new AddMarkStep(start, end, mark))
+    }
+  })
+
+  removed.forEach(s => tr.step(s))
+  added.forEach(s => tr.step(s))
+}
+
+export function removeMark(tr: Transform, from: number, to: number, mark?: Mark | MarkType | null) {
+  let matched: {style: Mark, from: number, to: number, step: number}[] = [], step = 0
+  tr.doc.nodesBetween(from, to, (node, pos) => {
+    if (!node.isInline) return
+    step++
+    let toRemove = null
+    if (mark instanceof MarkType) {
+      let set = node.marks, found
+      while (found = mark.isInSet(set)) {
+        ;(toRemove || (toRemove = [])).push(found)
+        set = found.removeFromSet(set)
+      }
+    } else if (mark) {
+      if (mark.isInSet(node.marks)) toRemove = [mark]
+    } else {
+      toRemove = node.marks
+    }
+    if (toRemove && toRemove.length) {
+      let end = Math.min(pos + node.nodeSize, to)
+      for (let i = 0; i < toRemove.length; i++) {
+        let style = toRemove[i], found
+        for (let j = 0; j < matched.length; j++) {
+          let m = matched[j]
+          if (m.step == step - 1 && style.eq(matched[j].style)) found = m
+        }
+        if (found) {
+          found.to = end
+          found.step = step
+        } else {
+          matched.push({style, from: Math.max(pos, from), to: end, step})
+        }
+      }
+    }
+  })
+  matched.forEach(m => tr.step(new RemoveMarkStep(m.from, m.to, m.style)))
+}
+
+export function clearIncompatible(tr: Transform, pos: number, parentType: NodeType,
+                                  match = parentType.contentMatch,
+                                  clearNewlines = true) {
+  let node = tr.doc.nodeAt(pos)!
+  let replSteps: Step[] = [], cur = pos + 1
+  for (let i = 0; i < node.childCount; i++) {
+    let child = node.child(i), end = cur + child.nodeSize
+    let allowed = match.matchType(child.type)
+    if (!allowed) {
+      replSteps.push(new ReplaceStep(cur, end, Slice.empty))
+    } else {
+      match = allowed
+      for (let j = 0; j < child.marks.length; j++) if (!parentType.allowsMarkType(child.marks[j].type))
+        tr.step(new RemoveMarkStep(cur, end, child.marks[j]))
+
+      if (clearNewlines && child.isText && parentType.whitespace != "pre") {
+        let m, newline = /\r?\n|\r/g, slice
+        while (m = newline.exec(child.text!)) {
+          if (!slice) slice = new Slice(Fragment.from(parentType.schema.text(" ", parentType.allowedMarks(child.marks))),
+                                        0, 0)
+          replSteps.push(new ReplaceStep(cur + m.index, cur + m.index + m[0].length, slice))
+        }
+      }
+    }
+    cur = end
+  }
+  if (!match.validEnd) {
+    let fill = match.fillBefore(Fragment.empty, true)
+    tr.replace(cur, cur, new Slice(fill!, 0, 0))
+  }
+  for (let i = replSteps.length - 1; i >= 0; i--) tr.step(replSteps[i])
+}