@blade-hq/agent-react 2612.0.0-beta.5 → 2612.0.0-beta.6

package/node_modules/prosemirror-state/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "prosemirror-state",
+  "version": "1.4.4",
+  "description": "ProseMirror editor state",
+  "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-state.git"
+  },
+  "dependencies": {
+    "prosemirror-model": "^1.0.0",
+    "prosemirror-transform": "^1.0.0",
+    "prosemirror-view": "^1.27.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-state/src/README.md

@@ -0,0 +1,42 @@
+This module implements the state object of a ProseMirror editor, along
+with the representation of the selection and the plugin abstraction.
+
+### Editor State
+
+ProseMirror keeps all editor state (the things, basically, that would
+be required to create an editor just like the current one) in a single
+[object](#state.EditorState). That object is updated (creating a new
+state) by applying [transactions](#state.Transaction) to it.
+
+@EditorState
+@EditorStateConfig
+@Transaction
+@Command
+
+### Selection
+
+A ProseMirror selection can be one of several types. This module
+defines types for classical [text selections](#state.TextSelection)
+(of which cursors are a special case) and [_node_
+selections](#state.NodeSelection), where a specific document node is
+selected. It is possible to extend the editor with custom selection
+types.
+
+@Selection
+@TextSelection
+@NodeSelection
+@AllSelection
+
+@SelectionRange
+@SelectionBookmark
+
+### Plugin System
+
+To make it easy to package and enable extra editor functionality,
+ProseMirror has a plugin system.
+
+@PluginSpec
+@StateField
+@PluginView
+@Plugin
+@PluginKey

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

@@ -0,0 +1,7 @@
+export {Selection, SelectionRange, TextSelection, NodeSelection, AllSelection, SelectionBookmark} from "./selection"
+
+export {Transaction, Command} from "./transaction"
+
+export {EditorState, EditorStateConfig} from "./state"
+
+export {Plugin, PluginKey, PluginSpec, StateField, PluginView} from "./plugin"

package/node_modules/prosemirror-state/src/plugin.ts

@@ -0,0 +1,142 @@
+import {type EditorView, type EditorProps} from "prosemirror-view"
+import {EditorState, EditorStateConfig} from "./state"
+import {Transaction} from "./transaction"
+
+/// This is the type passed to the [`Plugin`](#state.Plugin)
+/// constructor. It provides a definition for a plugin.
+export interface PluginSpec<PluginState> {
+  /// The [view props](#view.EditorProps) added by this plugin. Props
+  /// that are functions will be bound to have the plugin instance as
+  /// their `this` binding.
+  props?: EditorProps<Plugin<PluginState>>
+
+  /// Allows a plugin to define a [state field](#state.StateField), an
+  /// extra slot in the state object in which it can keep its own data.
+  state?: StateField<PluginState>
+
+  /// Can be used to make this a keyed plugin. You can have only one
+  /// plugin with a given key in a given state, but it is possible to
+  /// access the plugin's configuration and state through the key,
+  /// without having access to the plugin instance object.
+  key?: PluginKey
+
+  /// When the plugin needs to interact with the editor view, or
+  /// set something up in the DOM, use this field. The function
+  /// will be called when the plugin's state is associated with an
+  /// editor view.
+  view?: (view: EditorView) => PluginView
+
+  /// When present, this will be called before a transaction is
+  /// applied by the state, allowing the plugin to cancel it (by
+  /// returning false).
+  filterTransaction?: (tr: Transaction, state: EditorState) => boolean
+
+  /// Allows the plugin to append another transaction to be applied
+  /// after the given array of transactions. When another plugin
+  /// appends a transaction after this was called, it is called again
+  /// with the new state and new transactions—but only the new
+  /// transactions, i.e. it won't be passed transactions that it
+  /// already saw.
+  appendTransaction?: (transactions: readonly Transaction[], oldState: EditorState, newState: EditorState) => Transaction | null | undefined
+
+  /// Additional properties are allowed on plugin specs, which can be
+  /// read via [`Plugin.spec`](#state.Plugin.spec).
+  [key: string]: any
+}
+
+/// A stateful object that can be installed in an editor by a
+/// [plugin](#state.PluginSpec.view).
+export type PluginView = {
+  /// Called whenever the view's state is updated.
+  update?: (view: EditorView, prevState: EditorState) => void
+
+  /// Called when the view is destroyed or receives a state
+  /// with different plugins.
+  destroy?: () => void
+}
+
+function bindProps(obj: {[prop: string]: any}, self: any, target: {[prop: string]: any}) {
+  for (let prop in obj) {
+    let val = obj[prop]
+    if (val instanceof Function) val = val.bind(self)
+    else if (prop == "handleDOMEvents") val = bindProps(val, self, {})
+    target[prop] = val
+  }
+  return target
+}
+
+/// Plugins bundle functionality that can be added to an editor.
+/// They are part of the [editor state](#state.EditorState) and
+/// may influence that state and the view that contains it.
+export class Plugin<PluginState = any> {
+  /// Create a plugin.
+  constructor(
+    /// The plugin's [spec object](#state.PluginSpec).
+    readonly spec: PluginSpec<PluginState>
+  ) {
+    if (spec.props) bindProps(spec.props, this, this.props)
+    this.key = spec.key ? spec.key.key : createKey("plugin")
+  }
+
+  /// The [props](#view.EditorProps) exported by this plugin.
+  readonly props: EditorProps<Plugin<PluginState>> = {}
+
+  /// @internal
+  key: string
+
+  /// Extract the plugin's state field from an editor state.
+  getState(state: EditorState): PluginState | undefined { return (state as any)[this.key] }
+}
+
+/// A plugin spec may provide a state field (under its
+/// [`state`](#state.PluginSpec.state) property) of this type, which
+/// describes the state it wants to keep. Functions provided here are
+/// always called with the plugin instance as their `this` binding.
+export interface StateField<T> {
+  /// Initialize the value of the field. `config` will be the object
+  /// passed to [`EditorState.create`](#state.EditorState^create). Note
+  /// that `instance` is a half-initialized state instance, and will
+  /// not have values for plugin fields initialized after this one.
+  init: (config: EditorStateConfig, instance: EditorState) => T
+
+  /// Apply the given transaction to this state field, producing a new
+  /// field value. Note that the `newState` argument is again a partially
+  /// constructed state does not yet contain the state from plugins
+  /// coming after this one.
+  apply: (tr: Transaction, value: T, oldState: EditorState, newState: EditorState) => T
+
+  /// Convert this field to JSON. Optional, can be left off to disable
+  /// JSON serialization for the field.
+  toJSON?: (value: T) => any
+
+  /// Deserialize the JSON representation of this field. Note that the
+  /// `state` argument is again a half-initialized state.
+  fromJSON?: (config: EditorStateConfig, value: any, state: EditorState) => T
+}
+
+const keys = Object.create(null)
+
+function createKey(name: string) {
+  if (name in keys) return name + "$" + ++keys[name]
+  keys[name] = 0
+  return name + "$"
+}
+
+/// A key is used to [tag](#state.PluginSpec.key) plugins in a way
+/// that makes it possible to find them, given an editor state.
+/// Assigning a key does mean only one plugin of that type can be
+/// active in a state.
+export class PluginKey<PluginState = any> {
+  /// @internal
+  key: string
+
+  /// Create a plugin key.
+  constructor(name = "key") { this.key = createKey(name) }
+
+  /// Get the active plugin with this key, if any, from an editor
+  /// state.
+  get(state: EditorState): Plugin<PluginState> | undefined { return state.config.pluginsByKey[this.key] }
+
+  /// Get the plugin's state from an editor state.
+  getState(state: EditorState): PluginState | undefined { return (state as any)[this.key] }
+}

package/node_modules/prosemirror-state/src/selection.ts

@@ -0,0 +1,462 @@
+import {Slice, Fragment, ResolvedPos, Node} from "prosemirror-model"
+import {ReplaceStep, ReplaceAroundStep, Mappable} from "prosemirror-transform"
+import {Transaction} from "./transaction"
+
+const classesById = Object.create(null)
+
+/// Superclass for editor selections. Every selection type should
+/// extend this. Should not be instantiated directly.
+export abstract class Selection {
+  /// Initialize a selection with the head and anchor and ranges. If no
+  /// ranges are given, constructs a single range across `$anchor` and
+  /// `$head`.
+  constructor(
+    /// The resolved anchor of the selection (the side that stays in
+    /// place when the selection is modified).
+    readonly $anchor: ResolvedPos,
+    /// The resolved head of the selection (the side that moves when
+    /// the selection is modified).
+    readonly $head: ResolvedPos,
+    ranges?: readonly SelectionRange[]
+  ) {
+    this.ranges = ranges || [new SelectionRange($anchor.min($head), $anchor.max($head))]
+  }
+
+  /// The ranges covered by the selection.
+  ranges: readonly SelectionRange[]
+
+  /// The selection's anchor, as an unresolved position.
+  get anchor() { return this.$anchor.pos }
+
+  /// The selection's head.
+  get head() { return this.$head.pos }
+
+  /// The lower bound of the selection's main range.
+  get from() { return this.$from.pos }
+
+  /// The upper bound of the selection's main range.
+  get to() { return this.$to.pos }
+
+  /// The resolved lower  bound of the selection's main range.
+  get $from() {
+    return this.ranges[0].$from
+  }
+
+  /// The resolved upper bound of the selection's main range.
+  get $to() {
+    return this.ranges[0].$to
+  }
+
+  /// Indicates whether the selection contains any content.
+  get empty(): boolean {
+    let ranges = this.ranges
+    for (let i = 0; i < ranges.length; i++)
+      if (ranges[i].$from.pos != ranges[i].$to.pos) return false
+    return true
+  }
+
+  /// Test whether the selection is the same as another selection.
+  abstract eq(selection: Selection): boolean
+
+  /// Map this selection through a [mappable](#transform.Mappable)
+  /// thing. `doc` should be the new document to which we are mapping.
+  abstract map(doc: Node, mapping: Mappable): Selection
+
+  /// Get the content of this selection as a slice.
+  content() {
+    return this.$from.doc.slice(this.from, this.to, true)
+  }
+
+  /// Replace the selection with a slice or, if no slice is given,
+  /// delete the selection. Will append to the given transaction.
+  replace(tr: Transaction, content = Slice.empty) {
+    // Put the new selection at the position after the inserted
+    // content. When that ended in an inline node, search backwards,
+    // to get the position after that node. If not, search forward.
+    let lastNode = content.content.lastChild, lastParent = null
+    for (let i = 0; i < content.openEnd; i++) {
+      lastParent = lastNode!
+      lastNode = lastNode!.lastChild
+    }
+
+    let mapFrom = tr.steps.length, ranges = this.ranges
+    for (let i = 0; i < ranges.length; i++) {
+      let {$from, $to} = ranges[i], mapping = tr.mapping.slice(mapFrom)
+      tr.replaceRange(mapping.map($from.pos), mapping.map($to.pos), i ? Slice.empty : content)
+      if (i == 0)
+        selectionToInsertionEnd(tr, mapFrom, (lastNode ? lastNode.isInline : lastParent && lastParent.isTextblock) ? -1 : 1)
+    }
+  }
+
+  /// Replace the selection with the given node, appending the changes
+  /// to the given transaction.
+  replaceWith(tr: Transaction, node: Node) {
+    let mapFrom = tr.steps.length, ranges = this.ranges
+    for (let i = 0; i < ranges.length; i++) {
+      let {$from, $to} = ranges[i], mapping = tr.mapping.slice(mapFrom)
+      let from = mapping.map($from.pos), to = mapping.map($to.pos)
+      if (i) {
+        tr.deleteRange(from, to)
+      } else {
+        tr.replaceRangeWith(from, to, node)
+        selectionToInsertionEnd(tr, mapFrom, node.isInline ? -1 : 1)
+      }
+    }
+  }
+
+  /// Convert the selection to a JSON representation. When implementing
+  /// this for a custom selection class, make sure to give the object a
+  /// `type` property whose value matches the ID under which you
+  /// [registered](#state.Selection^jsonID) your class.
+  abstract toJSON(): any
+
+  /// Find a valid cursor or leaf node selection starting at the given
+  /// position and searching back if `dir` is negative, and forward if
+  /// positive. When `textOnly` is true, only consider cursor
+  /// selections. Will return null when no valid selection position is
+  /// found.
+  static findFrom($pos: ResolvedPos, dir: number, textOnly: boolean = false): Selection | null {
+    let inner = $pos.parent.inlineContent ? new TextSelection($pos)
+        : findSelectionIn($pos.node(0), $pos.parent, $pos.pos, $pos.index(), dir, textOnly)
+    if (inner) return inner
+
+    for (let depth = $pos.depth - 1; depth >= 0; depth--) {
+      let found = dir < 0
+          ? findSelectionIn($pos.node(0), $pos.node(depth), $pos.before(depth + 1), $pos.index(depth), dir, textOnly)
+          : findSelectionIn($pos.node(0), $pos.node(depth), $pos.after(depth + 1), $pos.index(depth) + 1, dir, textOnly)
+      if (found) return found
+    }
+    return null
+  }
+
+  /// Find a valid cursor or leaf node selection near the given
+  /// position. Searches forward first by default, but if `bias` is
+  /// negative, it will search backwards first.
+  static near($pos: ResolvedPos, bias = 1): Selection {
+    return this.findFrom($pos, bias) || this.findFrom($pos, -bias) || new AllSelection($pos.node(0))
+  }
+
+  /// Find the cursor or leaf node selection closest to the start of
+  /// the given document. Will return an
+  /// [`AllSelection`](#state.AllSelection) if no valid position
+  /// exists.
+  static atStart(doc: Node): Selection {
+    return findSelectionIn(doc, doc, 0, 0, 1) || new AllSelection(doc)
+  }
+
+  /// Find the cursor or leaf node selection closest to the end of the
+  /// given document.
+  static atEnd(doc: Node): Selection {
+    return findSelectionIn(doc, doc, doc.content.size, doc.childCount, -1) || new AllSelection(doc)
+  }
+
+  /// Deserialize the JSON representation of a selection. Must be
+  /// implemented for custom classes (as a static class method).
+  static fromJSON(doc: Node, json: any): Selection {
+    if (!json || !json.type) throw new RangeError("Invalid input for Selection.fromJSON")
+    let cls = classesById[json.type]
+    if (!cls) throw new RangeError(`No selection type ${json.type} defined`)
+    return cls.fromJSON(doc, json)
+  }
+
+  /// To be able to deserialize selections from JSON, custom selection
+  /// classes must register themselves with an ID string, so that they
+  /// can be disambiguated. Try to pick something that's unlikely to
+  /// clash with classes from other modules.
+  static jsonID(id: string, selectionClass: {fromJSON: (doc: Node, json: any) => Selection}) {
+    if (id in classesById) throw new RangeError("Duplicate use of selection JSON ID " + id)
+    classesById[id] = selectionClass
+    ;(selectionClass as any).prototype.jsonID = id
+    return selectionClass
+  }
+
+  /// Get a [bookmark](#state.SelectionBookmark) for this selection,
+  /// which is a value that can be mapped without having access to a
+  /// current document, and later resolved to a real selection for a
+  /// given document again. (This is used mostly by the history to
+  /// track and restore old selections.) The default implementation of
+  /// this method just converts the selection to a text selection and
+  /// returns the bookmark for that.
+  getBookmark(): SelectionBookmark {
+    return TextSelection.between(this.$anchor, this.$head).getBookmark()
+  }
+
+  /// Controls whether, when a selection of this type is active in the
+  /// browser, the selected range should be visible to the user.
+  /// Defaults to `true`.
+  declare visible: boolean
+}
+
+Selection.prototype.visible = true
+
+/// A lightweight, document-independent representation of a selection.
+/// You can define a custom bookmark type for a custom selection class
+/// to make the history handle it well.
+export interface SelectionBookmark {
+  /// Map the bookmark through a set of changes.
+  map: (mapping: Mappable) => SelectionBookmark
+
+  /// Resolve the bookmark to a real selection again. This may need to
+  /// do some error checking and may fall back to a default (usually
+  /// [`TextSelection.between`](#state.TextSelection^between)) if
+  /// mapping made the bookmark invalid.
+  resolve: (doc: Node) => Selection
+}
+
+/// Represents a selected range in a document.
+export class SelectionRange {
+  /// Create a range.
+  constructor(
+    /// The lower bound of the range.
+    readonly $from: ResolvedPos,
+    /// The upper bound of the range.
+    readonly $to: ResolvedPos
+  ) {}
+}
+
+let warnedAboutTextSelection = false
+function checkTextSelection($pos: ResolvedPos) {
+  if (!warnedAboutTextSelection && !$pos.parent.inlineContent) {
+    warnedAboutTextSelection = true
+    console["warn"]("TextSelection endpoint not pointing into a node with inline content (" + $pos.parent.type.name + ")")
+  }
+}
+
+/// A text selection represents a classical editor selection, with a
+/// head (the moving side) and anchor (immobile side), both of which
+/// point into textblock nodes. It can be empty (a regular cursor
+/// position).
+export class TextSelection extends Selection {
+  /// Construct a text selection between the given points.
+  constructor($anchor: ResolvedPos, $head = $anchor) {
+    checkTextSelection($anchor)
+    checkTextSelection($head)
+    super($anchor, $head)
+  }
+
+  /// Returns a resolved position if this is a cursor selection (an
+  /// empty text selection), and null otherwise.
+  get $cursor() { return this.$anchor.pos == this.$head.pos ? this.$head : null }
+
+  map(doc: Node, mapping: Mappable): Selection {
+    let $head = doc.resolve(mapping.map(this.head))
+    if (!$head.parent.inlineContent) return Selection.near($head)
+    let $anchor = doc.resolve(mapping.map(this.anchor))
+    return new TextSelection($anchor.parent.inlineContent ? $anchor : $head, $head)
+  }
+
+  replace(tr: Transaction, content = Slice.empty) {
+    super.replace(tr, content)
+    if (content == Slice.empty) {
+      let marks = this.$from.marksAcross(this.$to)
+      if (marks) tr.ensureMarks(marks)
+    }
+  }
+
+  eq(other: Selection): boolean {
+    return other instanceof TextSelection && other.anchor == this.anchor && other.head == this.head
+  }
+
+  getBookmark() {
+    return new TextBookmark(this.anchor, this.head)
+  }
+
+  toJSON(): any {
+    return {type: "text", anchor: this.anchor, head: this.head}
+  }
+
+  /// @internal
+  static fromJSON(doc: Node, json: any) {
+    if (typeof json.anchor != "number" || typeof json.head != "number")
+      throw new RangeError("Invalid input for TextSelection.fromJSON")
+    return new TextSelection(doc.resolve(json.anchor), doc.resolve(json.head))
+  }
+
+  /// Create a text selection from non-resolved positions.
+  static create(doc: Node, anchor: number, head = anchor) {
+    let $anchor = doc.resolve(anchor)
+    return new this($anchor, head == anchor ? $anchor : doc.resolve(head))
+  }
+
+  /// Return a text selection that spans the given positions or, if
+  /// they aren't text positions, find a text selection near them.
+  /// `bias` determines whether the method searches forward (default)
+  /// or backwards (negative number) first. Will fall back to calling
+  /// [`Selection.near`](#state.Selection^near) when the document
+  /// doesn't contain a valid text position.
+  static between($anchor: ResolvedPos, $head: ResolvedPos, bias?: number): Selection {
+    let dPos = $anchor.pos - $head.pos
+    if (!bias || dPos) bias = dPos >= 0 ? 1 : -1
+    if (!$head.parent.inlineContent) {
+      let found = Selection.findFrom($head, bias, true) || Selection.findFrom($head, -bias, true)
+      if (found) $head = found.$head
+      else return Selection.near($head, bias)
+    }
+    if (!$anchor.parent.inlineContent) {
+      if (dPos == 0) {
+        $anchor = $head
+      } else {
+        $anchor = (Selection.findFrom($anchor, -bias, true) || Selection.findFrom($anchor, bias, true))!.$anchor
+        if (($anchor.pos < $head.pos) != (dPos < 0)) $anchor = $head
+      }
+    }
+    return new TextSelection($anchor, $head)
+  }
+}
+
+Selection.jsonID("text", TextSelection)
+
+class TextBookmark {
+  constructor(readonly anchor: number, readonly head: number) {}
+
+  map(mapping: Mappable) {
+    return new TextBookmark(mapping.map(this.anchor), mapping.map(this.head))
+  }
+  resolve(doc: Node) {
+    return TextSelection.between(doc.resolve(this.anchor), doc.resolve(this.head))
+  }
+}
+
+/// A node selection is a selection that points at a single node. All
+/// nodes marked [selectable](#model.NodeSpec.selectable) can be the
+/// target of a node selection. In such a selection, `from` and `to`
+/// point directly before and after the selected node, `anchor` equals
+/// `from`, and `head` equals `to`..
+export class NodeSelection extends Selection {
+  /// Create a node selection. Does not verify the validity of its
+  /// argument.
+  constructor($pos: ResolvedPos) {
+    let node = $pos.nodeAfter!
+    let $end = $pos.node(0).resolve($pos.pos + node.nodeSize)
+    super($pos, $end)
+    this.node = node
+  }
+
+  /// The selected node.
+  node: Node
+
+  map(doc: Node, mapping: Mappable): Selection {
+    let {deleted, pos} = mapping.mapResult(this.anchor)
+    let $pos = doc.resolve(pos)
+    if (deleted) return Selection.near($pos)
+    return new NodeSelection($pos)
+  }
+
+  content() {
+    return new Slice(Fragment.from(this.node), 0, 0)
+  }
+
+  eq(other: Selection): boolean {
+    return other instanceof NodeSelection && other.anchor == this.anchor
+  }
+
+  toJSON(): any {
+    return {type: "node", anchor: this.anchor}
+  }
+
+  getBookmark() { return new NodeBookmark(this.anchor) }
+
+  /// @internal
+  static fromJSON(doc: Node, json: any) {
+    if (typeof json.anchor != "number")
+      throw new RangeError("Invalid input for NodeSelection.fromJSON")
+    return new NodeSelection(doc.resolve(json.anchor))
+  }
+
+  /// Create a node selection from non-resolved positions.
+  static create(doc: Node, from: number) {
+    return new NodeSelection(doc.resolve(from))
+  }
+
+  /// Determines whether the given node may be selected as a node
+  /// selection.
+  static isSelectable(node: Node) {
+    return !node.isText && node.type.spec.selectable !== false
+  }
+}
+
+NodeSelection.prototype.visible = false
+
+Selection.jsonID("node", NodeSelection)
+
+class NodeBookmark {
+  constructor(readonly anchor: number) {}
+  map(mapping: Mappable) {
+    let {deleted, pos} = mapping.mapResult(this.anchor)
+    return deleted ? new TextBookmark(pos, pos) : new NodeBookmark(pos)
+  }
+  resolve(doc: Node) {
+    let $pos = doc.resolve(this.anchor), node = $pos.nodeAfter
+    if (node && NodeSelection.isSelectable(node)) return new NodeSelection($pos)
+    return Selection.near($pos)
+  }
+}
+
+/// A selection type that represents selecting the whole document
+/// (which can not necessarily be expressed with a text selection, when
+/// there are for example leaf block nodes at the start or end of the
+/// document).
+export class AllSelection extends Selection {
+  /// Create an all-selection over the given document.
+  constructor(doc: Node) {
+    super(doc.resolve(0), doc.resolve(doc.content.size))
+  }
+
+  replace(tr: Transaction, content = Slice.empty) {
+    if (content == Slice.empty) {
+      tr.delete(0, tr.doc.content.size)
+      let sel = Selection.atStart(tr.doc)
+      if (!sel.eq(tr.selection)) tr.setSelection(sel)
+    } else {
+      super.replace(tr, content)
+    }
+  }
+
+  toJSON(): any { return {type: "all"} }
+
+  /// @internal
+  static fromJSON(doc: Node) { return new AllSelection(doc) }
+
+  map(doc: Node) { return new AllSelection(doc) }
+
+  eq(other: Selection) { return other instanceof AllSelection }
+
+  getBookmark() { return AllBookmark }
+}
+
+Selection.jsonID("all", AllSelection)
+
+const AllBookmark = {
+  map() { return this },
+  resolve(doc: Node) { return new AllSelection(doc) }
+}
+
+// FIXME we'll need some awareness of text direction when scanning for selections
+
+// Try to find a selection inside the given node. `pos` points at the
+// position where the search starts. When `text` is true, only return
+// text selections.
+function findSelectionIn(doc: Node, node: Node, pos: number, index: number, dir: number, text = false): Selection | null {
+  if (node.inlineContent) return TextSelection.create(doc, pos)
+  for (let i = index - (dir > 0 ? 0 : 1); dir > 0 ? i < node.childCount : i >= 0; i += dir) {
+    let child = node.child(i)
+    if (!child.isAtom) {
+      let inner = findSelectionIn(doc, child, pos + dir, dir < 0 ? child.childCount : 0, dir, text)
+      if (inner) return inner
+    } else if (!text && NodeSelection.isSelectable(child)) {
+      return NodeSelection.create(doc, pos - (dir < 0 ? child.nodeSize : 0))
+    }
+    pos += child.nodeSize * dir
+  }
+  return null
+}
+
+function selectionToInsertionEnd(tr: Transaction, startLen: number, bias: number) {
+  let last = tr.steps.length - 1
+  if (last < startLen) return
+  let step = tr.steps[last]
+  if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep)) return
+  let map = tr.mapping.maps[last], end: number | undefined
+  map.forEach((_from, _to, _newFrom, newTo) => { if (end == null) end = newTo })
+  tr.setSelection(Selection.near(tr.doc.resolve(end!), bias))
+}