@blade-hq/agent-react 2612.0.0-beta.1 → 2612.0.0-beta.10

package/node_modules/prosemirror-model/src/replace.ts

@@ -0,0 +1,225 @@
+import {Fragment} from "./fragment"
+import {Schema} from "./schema"
+import {Node, TextNode} from "./node"
+import {ResolvedPos} from "./resolvedpos"
+
+/// Error type raised by [`Node.replace`](#model.Node.replace) when
+/// given an invalid replacement.
+export class ReplaceError extends Error {}
+/*
+ReplaceError = function(this: any, message: string) {
+  let err = Error.call(this, message)
+  ;(err as any).__proto__ = ReplaceError.prototype
+  return err
+} as any
+
+ReplaceError.prototype = Object.create(Error.prototype)
+ReplaceError.prototype.constructor = ReplaceError
+ReplaceError.prototype.name = "ReplaceError"
+*/
+
+/// A slice represents a piece cut out of a larger document. It
+/// stores not only a fragment, but also the depth up to which nodes on
+/// both side are ‘open’ (cut through).
+export class Slice {
+  /// Create a slice. When specifying a non-zero open depth, you must
+  /// make sure that there are nodes of at least that depth at the
+  /// appropriate side of the fragment—i.e. if the fragment is an
+  /// empty paragraph node, `openStart` and `openEnd` can't be greater
+  /// than 1.
+  ///
+  /// It is not necessary for the content of open nodes to conform to
+  /// the schema's content constraints, though it should be a valid
+  /// start/end/middle for such a node, depending on which sides are
+  /// open.
+  constructor(
+    /// The slice's content.
+    readonly content: Fragment,
+    /// The open depth at the start of the fragment.
+    readonly openStart: number,
+    /// The open depth at the end.
+    readonly openEnd: number
+  ) {}
+
+  /// The size this slice would add when inserted into a document.
+  get size(): number {
+    return this.content.size - this.openStart - this.openEnd
+  }
+
+  /// @internal
+  insertAt(pos: number, fragment: Fragment) {
+    let content = insertInto(this.content, pos + this.openStart, fragment)
+    return content && new Slice(content, this.openStart, this.openEnd)
+  }
+
+  /// @internal
+  removeBetween(from: number, to: number) {
+    return new Slice(removeRange(this.content, from + this.openStart, to + this.openStart), this.openStart, this.openEnd)
+  }
+
+  /// Tests whether this slice is equal to another slice.
+  eq(other: Slice): boolean {
+    return this.content.eq(other.content) && this.openStart == other.openStart && this.openEnd == other.openEnd
+  }
+
+  /// @internal
+  toString() {
+    return this.content + "(" + this.openStart + "," + this.openEnd + ")"
+  }
+
+  /// Convert a slice to a JSON-serializable representation.
+  toJSON(): any {
+    if (!this.content.size) return null
+    let json: any = {content: this.content.toJSON()}
+    if (this.openStart > 0) json.openStart = this.openStart
+    if (this.openEnd > 0) json.openEnd = this.openEnd
+    return json
+  }
+
+  /// Deserialize a slice from its JSON representation.
+  static fromJSON(schema: Schema, json: any): Slice {
+    if (!json) return Slice.empty
+    let openStart = json.openStart || 0, openEnd = json.openEnd || 0
+    if (typeof openStart != "number" || typeof openEnd != "number")
+      throw new RangeError("Invalid input for Slice.fromJSON")
+    return new Slice(Fragment.fromJSON(schema, json.content), openStart, openEnd)
+  }
+
+  /// Create a slice from a fragment by taking the maximum possible
+  /// open value on both side of the fragment.
+  static maxOpen(fragment: Fragment, openIsolating = true) {
+    let openStart = 0, openEnd = 0
+    for (let n = fragment.firstChild; n && !n.isLeaf && (openIsolating || !n.type.spec.isolating); n = n.firstChild) openStart++
+    for (let n = fragment.lastChild; n && !n.isLeaf && (openIsolating || !n.type.spec.isolating); n = n.lastChild) openEnd++
+    return new Slice(fragment, openStart, openEnd)
+  }
+
+  /// The empty slice.
+  static empty = new Slice(Fragment.empty, 0, 0)
+}
+
+function removeRange(content: Fragment, from: number, to: number): Fragment {
+  let {index, offset} = content.findIndex(from), child = content.maybeChild(index)
+  let {index: indexTo, offset: offsetTo} = content.findIndex(to)
+  if (offset == from || child!.isText) {
+    if (offsetTo != to && !content.child(indexTo).isText) throw new RangeError("Removing non-flat range")
+    return content.cut(0, from).append(content.cut(to))
+  }
+  if (index != indexTo) throw new RangeError("Removing non-flat range")
+  return content.replaceChild(index, child!.copy(removeRange(child!.content, from - offset - 1, to - offset - 1)))
+}
+
+function insertInto(content: Fragment, dist: number, insert: Fragment, parent?: Node | null): Fragment | null {
+  let {index, offset} = content.findIndex(dist), child = content.maybeChild(index)
+  if (offset == dist || child!.isText) {
+    if (parent && !parent.canReplace(index, index, insert)) return null
+    return content.cut(0, dist).append(insert).append(content.cut(dist))
+  }
+  let inner = insertInto(child!.content, dist - offset - 1, insert, child)
+  return inner && content.replaceChild(index, child!.copy(inner))
+}
+
+export function replace($from: ResolvedPos, $to: ResolvedPos, slice: Slice) {
+  if (slice.openStart > $from.depth)
+    throw new ReplaceError("Inserted content deeper than insertion position")
+  if ($from.depth - slice.openStart != $to.depth - slice.openEnd)
+    throw new ReplaceError("Inconsistent open depths")
+  return replaceOuter($from, $to, slice, 0)
+}
+
+function replaceOuter($from: ResolvedPos, $to: ResolvedPos, slice: Slice, depth: number): Node {
+  let index = $from.index(depth), node = $from.node(depth)
+  if (index == $to.index(depth) && depth < $from.depth - slice.openStart) {
+    let inner = replaceOuter($from, $to, slice, depth + 1)
+    return node.copy(node.content.replaceChild(index, inner))
+  } else if (!slice.content.size) {
+    return close(node, replaceTwoWay($from, $to, depth))
+  } else if (!slice.openStart && !slice.openEnd && $from.depth == depth && $to.depth == depth) { // Simple, flat case
+    let parent = $from.parent, content = parent.content
+    return close(parent, content.cut(0, $from.parentOffset).append(slice.content).append(content.cut($to.parentOffset)))
+  } else {
+    let {start, end} = prepareSliceForReplace(slice, $from)
+    return close(node, replaceThreeWay($from, start, end, $to, depth))
+  }
+}
+
+function checkJoin(main: Node, sub: Node) {
+  if (!sub.type.compatibleContent(main.type))
+    throw new ReplaceError("Cannot join " + sub.type.name + " onto " + main.type.name)
+}
+
+function joinable($before: ResolvedPos, $after: ResolvedPos, depth: number) {
+  let node = $before.node(depth)
+  checkJoin(node, $after.node(depth))
+  return node
+}
+
+function addNode(child: Node, target: Node[]) {
+  let last = target.length - 1
+  if (last >= 0 && child.isText && child.sameMarkup(target[last]))
+    target[last] = (child as TextNode).withText(target[last].text! + child.text!)
+  else
+    target.push(child)
+}
+
+function addRange($start: ResolvedPos | null, $end: ResolvedPos | null, depth: number, target: Node[]) {
+  let node = ($end || $start)!.node(depth)
+  let startIndex = 0, endIndex = $end ? $end.index(depth) : node.childCount
+  if ($start) {
+    startIndex = $start.index(depth)
+    if ($start.depth > depth) {
+      startIndex++
+    } else if ($start.textOffset) {
+      addNode($start.nodeAfter!, target)
+      startIndex++
+    }
+  }
+  for (let i = startIndex; i < endIndex; i++) addNode(node.child(i), target)
+  if ($end && $end.depth == depth && $end.textOffset)
+    addNode($end.nodeBefore!, target)
+}
+
+function close(node: Node, content: Fragment) {
+  node.type.checkContent(content)
+  return node.copy(content)
+}
+
+function replaceThreeWay($from: ResolvedPos, $start: ResolvedPos, $end: ResolvedPos, $to: ResolvedPos, depth: number) {
+  let openStart = $from.depth > depth && joinable($from, $start, depth + 1)
+  let openEnd = $to.depth > depth && joinable($end, $to, depth + 1)
+
+  let content: Node[] = []
+  addRange(null, $from, depth, content)
+  if (openStart && openEnd && $start.index(depth) == $end.index(depth)) {
+    checkJoin(openStart, openEnd)
+    addNode(close(openStart, replaceThreeWay($from, $start, $end, $to, depth + 1)), content)
+  } else {
+    if (openStart)
+      addNode(close(openStart, replaceTwoWay($from, $start, depth + 1)), content)
+    addRange($start, $end, depth, content)
+    if (openEnd)
+      addNode(close(openEnd, replaceTwoWay($end, $to, depth + 1)), content)
+  }
+  addRange($to, null, depth, content)
+  return new Fragment(content)
+}
+
+function replaceTwoWay($from: ResolvedPos, $to: ResolvedPos, depth: number) {
+  let content: Node[] = []
+  addRange(null, $from, depth, content)
+  if ($from.depth > depth) {
+    let type = joinable($from, $to, depth + 1)
+    addNode(close(type, replaceTwoWay($from, $to, depth + 1)), content)
+  }
+  addRange($to, null, depth, content)
+  return new Fragment(content)
+}
+
+function prepareSliceForReplace(slice: Slice, $along: ResolvedPos) {
+  let extra = $along.depth - slice.openStart, parent = $along.node(extra)
+  let node = parent.copy(slice.content)
+  for (let i = extra - 1; i >= 0; i--)
+    node = $along.node(i).copy(Fragment.from(node))
+  return {start: node.resolveNoCache(slice.openStart + extra),
+          end: node.resolveNoCache(node.content.size - slice.openEnd - extra)}
+}

package/node_modules/prosemirror-model/src/resolvedpos.ts

@@ -0,0 +1,289 @@
+import {Mark} from "./mark"
+import {Node} from "./node"
+
+/// You can [_resolve_](#model.Node.resolve) a position to get more
+/// information about it. Objects of this class represent such a
+/// resolved position, providing various pieces of context
+/// information, and some helper methods.
+///
+/// Throughout this interface, methods that take an optional `depth`
+/// parameter will interpret undefined as `this.depth` and negative
+/// numbers as `this.depth + value`.
+export class ResolvedPos {
+  /// The number of levels the parent node is from the root. If this
+  /// position points directly into the root node, it is 0. If it
+  /// points into a top-level paragraph, 1, and so on.
+  depth: number
+
+  /// @internal
+  constructor(
+    /// The position that was resolved.
+    readonly pos: number,
+    /// @internal
+    readonly path: any[],
+    /// The offset this position has into its parent node.
+    readonly parentOffset: number
+  ) {
+    this.depth = path.length / 3 - 1
+  }
+
+  /// @internal
+  resolveDepth(val: number | undefined | null) {
+    if (val == null) return this.depth
+    if (val < 0) return this.depth + val
+    return val
+  }
+
+  /// The parent node that the position points into. Note that even if
+  /// a position points into a text node, that node is not considered
+  /// the parent—text nodes are ‘flat’ in this model, and have no content.
+  get parent() { return this.node(this.depth) }
+
+  /// The root node in which the position was resolved.
+  get doc() { return this.node(0) }
+
+  /// The ancestor node at the given level. `p.node(p.depth)` is the
+  /// same as `p.parent`.
+  node(depth?: number | null): Node { return this.path[this.resolveDepth(depth) * 3] }
+
+  /// The index into the ancestor at the given level. If this points
+  /// at the 3rd node in the 2nd paragraph on the top level, for
+  /// example, `p.index(0)` is 1 and `p.index(1)` is 2.
+  index(depth?: number | null): number { return this.path[this.resolveDepth(depth) * 3 + 1] }
+
+  /// The index pointing after this position into the ancestor at the
+  /// given level.
+  indexAfter(depth?: number | null): number {
+    depth = this.resolveDepth(depth)
+    return this.index(depth) + (depth == this.depth && !this.textOffset ? 0 : 1)
+  }
+
+  /// The (absolute) position at the start of the node at the given
+  /// level.
+  start(depth?: number | null): number {
+    depth = this.resolveDepth(depth)
+    return depth == 0 ? 0 : this.path[depth * 3 - 1] + 1
+  }
+
+  /// The (absolute) position at the end of the node at the given
+  /// level.
+  end(depth?: number | null): number {
+    depth = this.resolveDepth(depth)
+    return this.start(depth) + this.node(depth).content.size
+  }
+
+  /// The (absolute) position directly before the wrapping node at the
+  /// given level, or, when `depth` is `this.depth + 1`, the original
+  /// position.
+  before(depth?: number | null): number {
+    depth = this.resolveDepth(depth)
+    if (!depth) throw new RangeError("There is no position before the top-level node")
+    return depth == this.depth + 1 ? this.pos : this.path[depth * 3 - 1]
+  }
+
+  /// The (absolute) position directly after the wrapping node at the
+  /// given level, or the original position when `depth` is `this.depth + 1`.
+  after(depth?: number | null): number {
+    depth = this.resolveDepth(depth)
+    if (!depth) throw new RangeError("There is no position after the top-level node")
+    return depth == this.depth + 1 ? this.pos : this.path[depth * 3 - 1] + this.path[depth * 3].nodeSize
+  }
+
+  /// When this position points into a text node, this returns the
+  /// distance between the position and the start of the text node.
+  /// Will be zero for positions that point between nodes.
+  get textOffset(): number { return this.pos - this.path[this.path.length - 1] }
+
+  /// Get the node directly after the position, if any. If the position
+  /// points into a text node, only the part of that node after the
+  /// position is returned.
+  get nodeAfter(): Node | null {
+    let parent = this.parent, index = this.index(this.depth)
+    if (index == parent.childCount) return null
+    let dOff = this.pos - this.path[this.path.length - 1], child = parent.child(index)
+    return dOff ? parent.child(index).cut(dOff) : child
+  }
+
+  /// Get the node directly before the position, if any. If the
+  /// position points into a text node, only the part of that node
+  /// before the position is returned.
+  get nodeBefore(): Node | null {
+    let index = this.index(this.depth)
+    let dOff = this.pos - this.path[this.path.length - 1]
+    if (dOff) return this.parent.child(index).cut(0, dOff)
+    return index == 0 ? null : this.parent.child(index - 1)
+  }
+
+  /// Get the position at the given index in the parent node at the
+  /// given depth (which defaults to `this.depth`).
+  posAtIndex(index: number, depth?: number | null): number {
+    depth = this.resolveDepth(depth)
+    let node = this.path[depth * 3], pos = depth == 0 ? 0 : this.path[depth * 3 - 1] + 1
+    for (let i = 0; i < index; i++) pos += node.child(i).nodeSize
+    return pos
+  }
+
+  /// Get the marks at this position, factoring in the surrounding
+  /// marks' [`inclusive`](#model.MarkSpec.inclusive) property. If the
+  /// position is at the start of a non-empty node, the marks of the
+  /// node after it (if any) are returned.
+  marks(): readonly Mark[] {
+    let parent = this.parent, index = this.index()
+
+    // In an empty parent, return the empty array
+    if (parent.content.size == 0) return Mark.none
+
+    // When inside a text node, just return the text node's marks
+    if (this.textOffset) return parent.child(index).marks
+
+    let main = parent.maybeChild(index - 1), other = parent.maybeChild(index)
+    // If the `after` flag is true of there is no node before, make
+    // the node after this position the main reference.
+    if (!main) { let tmp = main; main = other; other = tmp }
+
+    // Use all marks in the main node, except those that have
+    // `inclusive` set to false and are not present in the other node.
+    let marks = main!.marks
+    for (var i = 0; i < marks.length; i++)
+      if (marks[i].type.spec.inclusive === false && (!other || !marks[i].isInSet(other.marks)))
+        marks = marks[i--].removeFromSet(marks)
+
+    return marks
+  }
+
+  /// Get the marks after the current position, if any, except those
+  /// that are non-inclusive and not present at position `$end`. This
+  /// is mostly useful for getting the set of marks to preserve after a
+  /// deletion. Will return `null` if this position is at the end of
+  /// its parent node or its parent node isn't a textblock (in which
+  /// case no marks should be preserved).
+  marksAcross($end: ResolvedPos): readonly Mark[] | null {
+    let after = this.parent.maybeChild(this.index())
+    if (!after || !after.isInline) return null
+
+    let marks = after.marks, next = $end.parent.maybeChild($end.index())
+    for (var i = 0; i < marks.length; i++)
+      if (marks[i].type.spec.inclusive === false && (!next || !marks[i].isInSet(next.marks)))
+        marks = marks[i--].removeFromSet(marks)
+    return marks
+  }
+
+  /// The depth up to which this position and the given (non-resolved)
+  /// position share the same parent nodes.
+  sharedDepth(pos: number): number {
+    for (let depth = this.depth; depth > 0; depth--)
+      if (this.start(depth) <= pos && this.end(depth) >= pos) return depth
+    return 0
+  }
+
+  /// Returns a range based on the place where this position and the
+  /// given position diverge around block content. If both point into
+  /// the same textblock, for example, a range around that textblock
+  /// will be returned. If they point into different blocks, the range
+  /// around those blocks in their shared ancestor is returned. You can
+  /// pass in an optional predicate that will be called with a parent
+  /// node to see if a range into that parent is acceptable.
+  blockRange(other: ResolvedPos = this, pred?: (node: Node) => boolean): NodeRange | null {
+    if (other.pos < this.pos) return other.blockRange(this)
+    for (let d = this.depth - (this.parent.inlineContent || this.pos == other.pos ? 1 : 0); d >= 0; d--)
+      if (other.pos <= this.end(d) && (!pred || pred(this.node(d))))
+        return new NodeRange(this, other, d)
+    return null
+  }
+
+  /// Query whether the given position shares the same parent node.
+  sameParent(other: ResolvedPos): boolean {
+    return this.pos - this.parentOffset == other.pos - other.parentOffset
+  }
+
+  /// Return the greater of this and the given position.
+  max(other: ResolvedPos): ResolvedPos {
+    return other.pos > this.pos ? other : this
+  }
+
+  /// Return the smaller of this and the given position.
+  min(other: ResolvedPos): ResolvedPos {
+    return other.pos < this.pos ? other : this
+  }
+
+  /// @internal
+  toString() {
+    let str = ""
+    for (let i = 1; i <= this.depth; i++)
+      str += (str ? "/" : "") + this.node(i).type.name + "_" + this.index(i - 1)
+    return str + ":" + this.parentOffset
+  }
+
+  /// @internal
+  static resolve(doc: Node, pos: number): ResolvedPos {
+    if (!(pos >= 0 && pos <= doc.content.size)) throw new RangeError("Position " + pos + " out of range")
+    let path: Array<Node | number> = []
+    let start = 0, parentOffset = pos
+    for (let node = doc;;) {
+      let {index, offset} = node.content.findIndex(parentOffset)
+      let rem = parentOffset - offset
+      path.push(node, index, start + offset)
+      if (!rem) break
+      node = node.child(index)
+      if (node.isText) break
+      parentOffset = rem - 1
+      start += offset + 1
+    }
+    return new ResolvedPos(pos, path, parentOffset)
+  }
+
+  /// @internal
+  static resolveCached(doc: Node, pos: number): ResolvedPos {
+    let cache = resolveCache.get(doc)
+    if (cache) {
+      for (let i = 0; i < cache.elts.length; i++) {
+        let elt = cache.elts[i]
+        if (elt.pos == pos) return elt
+      }
+    } else {
+      resolveCache.set(doc, cache = new ResolveCache)
+    }
+    let result = cache.elts[cache.i] = ResolvedPos.resolve(doc, pos)
+    cache.i = (cache.i + 1) % resolveCacheSize
+    return result
+  }
+}
+
+class ResolveCache {
+  elts: ResolvedPos[] = []
+  i = 0
+}
+
+const resolveCacheSize = 12, resolveCache = new WeakMap<Node, ResolveCache>()
+
+/// Represents a flat range of content, i.e. one that starts and
+/// ends in the same node.
+export class NodeRange {
+  /// Construct a node range. `$from` and `$to` should point into the
+  /// same node until at least the given `depth`, since a node range
+  /// denotes an adjacent set of nodes in a single parent node.
+  constructor(
+    /// A resolved position along the start of the content. May have a
+    /// `depth` greater than this object's `depth` property, since
+    /// these are the positions that were used to compute the range,
+    /// not re-resolved positions directly at its boundaries.
+    readonly $from: ResolvedPos,
+    /// A position along the end of the content. See
+    /// caveat for [`$from`](#model.NodeRange.$from).
+    readonly $to: ResolvedPos,
+    /// The depth of the node that this range points into.
+    readonly depth: number
+  ) {}
+
+  /// The position at the start of the range.
+  get start() { return this.$from.before(this.depth + 1) }
+  /// The position at the end of the range.
+  get end() { return this.$to.after(this.depth + 1) }
+
+  /// The parent node that the range points into.
+  get parent() { return this.$from.node(this.depth) }
+  /// The start index of the range in the parent node.
+  get startIndex() { return this.$from.index(this.depth) }
+  /// The end index of the range in the parent node.
+  get endIndex() { return this.$to.indexAfter(this.depth) }
+}