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

package/node_modules/prosemirror-gapcursor/src/gapcursor.ts

@@ -0,0 +1,141 @@
+import {Selection, NodeSelection} from "prosemirror-state"
+import {Slice, ResolvedPos, Node, NodeType} from "prosemirror-model"
+import {Mappable} from "prosemirror-transform"
+
+/// Gap cursor selections are represented using this class. Its
+/// `$anchor` and `$head` properties both point at the cursor position.
+export class GapCursor extends Selection {
+  /// Create a gap cursor.
+  constructor($pos: ResolvedPos) {
+    super($pos, $pos)
+  }
+
+  map(doc: Node, mapping: Mappable): Selection {
+    let $pos = doc.resolve(mapping.map(this.head))
+    return GapCursor.valid($pos) ? new GapCursor($pos) : Selection.near($pos)
+  }
+
+  content() { return Slice.empty }
+
+  eq(other: Selection): boolean {
+    return other instanceof GapCursor && other.head == this.head
+  }
+
+  toJSON(): any {
+    return {type: "gapcursor", pos: this.head}
+  }
+
+  /// @internal
+  static fromJSON(doc: Node, json: any): GapCursor {
+    if (typeof json.pos != "number") throw new RangeError("Invalid input for GapCursor.fromJSON")
+    return new GapCursor(doc.resolve(json.pos))
+  }
+
+  /// @internal
+  getBookmark() { return new GapBookmark(this.anchor) }
+
+  /// @internal
+  static valid($pos: ResolvedPos) {
+    let parent = $pos.parent
+    if (parent.inlineContent || !closedBefore($pos) || !closedAfter($pos)) return false
+    let override = parent.type.spec.allowGapCursor
+    if (override != null) return override
+    let deflt = parent.contentMatchAt($pos.index()).defaultType
+    return deflt && deflt.isTextblock
+  }
+
+  /// @internal
+  static findGapCursorFrom($pos: ResolvedPos, dir: number, mustMove = false) {
+    search: for (;;) {
+      if (!mustMove && GapCursor.valid($pos)) return $pos
+      let pos = $pos.pos, next = null
+      // Scan up from this position
+      for (let d = $pos.depth;; d--) {
+        let parent = $pos.node(d)
+        if (dir > 0 ? $pos.indexAfter(d) < parent.childCount : $pos.index(d) > 0) {
+          next = parent.child(dir > 0 ? $pos.indexAfter(d) : $pos.index(d) - 1)
+          break
+        } else if (d == 0) {
+          return null
+        }
+        pos += dir
+        let $cur = $pos.doc.resolve(pos)
+        if (GapCursor.valid($cur)) return $cur
+      }
+
+      // And then down into the next node
+      for (;;) {
+        let inside: Node | null = dir > 0 ? next.firstChild : next.lastChild
+        if (!inside) {
+          if (next.isAtom && !next.isText && !NodeSelection.isSelectable(next)) {
+            $pos = $pos.doc.resolve(pos + next.nodeSize * dir)
+            mustMove = false
+            continue search
+          }
+          break
+        }
+        next = inside
+        pos += dir
+        let $cur = $pos.doc.resolve(pos)
+        if (GapCursor.valid($cur)) return $cur
+      }
+
+      return null
+    }
+  }
+}
+
+GapCursor.prototype.visible = false
+
+;(GapCursor as any).findFrom = GapCursor.findGapCursorFrom
+
+Selection.jsonID("gapcursor", GapCursor)
+
+class GapBookmark {
+  constructor(readonly pos: number) {}
+
+  map(mapping: Mappable) {
+    return new GapBookmark(mapping.map(this.pos))
+  }
+  resolve(doc: Node) {
+    let $pos = doc.resolve(this.pos)
+    return GapCursor.valid($pos) ? new GapCursor($pos) : Selection.near($pos)
+  }
+}
+
+function needsGap(type: NodeType) {
+  return type.isAtom || type.spec.isolating || type.spec.createGapCursor
+}
+
+function closedBefore($pos: ResolvedPos) {
+  for (let d = $pos.depth; d >= 0; d--) {
+    let index = $pos.index(d), parent = $pos.node(d)
+    // At the start of this parent, look at next one
+    if (index == 0) {
+      if (parent.type.spec.isolating) return true
+      continue
+    }
+    // See if the node before (or its first ancestor) is closed
+    for (let before = parent.child(index - 1);; before = before.lastChild!) {
+      if ((before.childCount == 0 && !before.inlineContent) || needsGap(before.type)) return true
+      if (before.inlineContent) return false
+    }
+  }
+  // Hit start of document
+  return true
+}
+
+function closedAfter($pos: ResolvedPos) {
+  for (let d = $pos.depth; d >= 0; d--) {
+    let index = $pos.indexAfter(d), parent = $pos.node(d)
+    if (index == parent.childCount) {
+      if (parent.type.spec.isolating) return true
+      continue
+    }
+    for (let after = parent.child(index);; after = after.firstChild!) {
+      if ((after.childCount == 0 && !after.inlineContent) || needsGap(after.type)) return true
+      if (after.inlineContent) return false
+    }
+  }
+  return true
+}

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

@@ -0,0 +1,91 @@
+import {keydownHandler} from "prosemirror-keymap"
+import {TextSelection, NodeSelection, Plugin, Command, EditorState} from "prosemirror-state"
+import {Fragment, Slice} from "prosemirror-model"
+import {Decoration, DecorationSet, EditorView} from "prosemirror-view"
+
+import {GapCursor} from "./gapcursor"
+
+/// Create a gap cursor plugin. When enabled, this will capture clicks
+/// near and arrow-key-motion past places that don't have a normally
+/// selectable position nearby, and create a gap cursor selection for
+/// them. The cursor is drawn as an element with class
+/// `ProseMirror-gapcursor`. You can either include
+/// `style/gapcursor.css` from the package's directory or add your own
+/// styles to make it visible.
+export function gapCursor(): Plugin {
+  return new Plugin({
+    props: {
+      decorations: drawGapCursor,
+
+      createSelectionBetween(_view, $anchor, $head) {
+        return $anchor.pos == $head.pos && GapCursor.valid($head) ? new GapCursor($head) : null
+      },
+
+      handleClick,
+      handleKeyDown,
+      handleDOMEvents: {beforeinput: beforeinput as any}
+    }
+  })
+}
+
+export {GapCursor}
+
+const handleKeyDown = keydownHandler({
+  "ArrowLeft": arrow("horiz", -1),
+  "ArrowRight": arrow("horiz", 1),
+  "ArrowUp": arrow("vert", -1),
+  "ArrowDown": arrow("vert", 1)
+})
+
+function arrow(axis: "vert" | "horiz", dir: number): Command {
+  const dirStr = axis == "vert" ? (dir > 0 ? "down" : "up") : (dir > 0 ? "right" : "left")
+  return function(state, dispatch, view) {
+    let sel = state.selection
+    let $start = dir > 0 ? sel.$to : sel.$from, mustMove = sel.empty
+    if (sel instanceof TextSelection) {
+      if (!view!.endOfTextblock(dirStr) || $start.depth == 0) return false
+      mustMove = false
+      $start = state.doc.resolve(dir > 0 ? $start.after() : $start.before())
+    }
+    let $found = GapCursor.findGapCursorFrom($start, dir, mustMove)
+    if (!$found) return false
+    if (dispatch) dispatch(state.tr.setSelection(new GapCursor($found)))
+    return true
+  }
+}
+
+function handleClick(view: EditorView, pos: number, event: MouseEvent) {
+  if (!view || !view.editable) return false
+  let $pos = view.state.doc.resolve(pos)
+  if (!GapCursor.valid($pos)) return false
+  let clickPos = view.posAtCoords({left: event.clientX, top: event.clientY})
+  if (clickPos && clickPos.inside > -1 && NodeSelection.isSelectable(view.state.doc.nodeAt(clickPos.inside)!)) return false
+  view.dispatch(view.state.tr.setSelection(new GapCursor($pos)))
+  return true
+}
+
+// This is a hack that, when a composition starts while a gap cursor
+// is active, quickly creates an inline context for the composition to
+// happen in, to avoid it being aborted by the DOM selection being
+// moved into a valid position.
+function beforeinput(view: EditorView, event: InputEvent) {
+  if (event.inputType != "insertCompositionText" || !(view.state.selection instanceof GapCursor)) return false
+
+  let {$from} = view.state.selection
+  let insert = $from.parent.contentMatchAt($from.index()).findWrapping(view.state.schema.nodes.text)
+  if (!insert) return false
+
+  let frag = Fragment.empty
+  for (let i = insert.length - 1; i >= 0; i--) frag = Fragment.from(insert[i].createAndFill(null, frag))
+  let tr = view.state.tr.replace($from.pos, $from.pos, new Slice(frag, 0, 0))
+  tr.setSelection(TextSelection.near(tr.doc.resolve($from.pos + 1)))
+  view.dispatch(tr)
+  return false
+}
+
+function drawGapCursor(state: EditorState) {
+  if (!(state.selection instanceof GapCursor)) return null
+  let node = document.createElement("div")
+  node.className = "ProseMirror-gapcursor"
+  return DecorationSet.create(state.doc, [Decoration.widget(state.selection.head, node, {key: "gapcursor"})])
+}

package/node_modules/prosemirror-gapcursor/style/gapcursor.css

@@ -0,0 +1,25 @@
+.ProseMirror-gapcursor {
+  display: none;
+  pointer-events: none;
+  position: absolute;
+}
+
+.ProseMirror-gapcursor:after {
+  content: "";
+  display: block;
+  position: absolute;
+  top: -2px;
+  width: 20px;
+  border-top: 1px solid black;
+  animation: ProseMirror-cursor-blink 1.1s steps(2, start) infinite;
+}
+
+@keyframes ProseMirror-cursor-blink {
+  to {
+    visibility: hidden;
+  }
+}
+
+.ProseMirror-focused .ProseMirror-gapcursor {
+  display: block;
+}

package/node_modules/prosemirror-history/.tern-project

@@ -0,0 +1,8 @@
+{
+  "libs": ["browser"],
+  "plugins": {
+    "node": {},
+    "complete_strings": {},
+    "es_modules": {}
+  }
+}

package/node_modules/prosemirror-history/CHANGELOG.md

@@ -0,0 +1,170 @@
+## 1.5.0 (2025-11-13)
+
+### Bug fixes
+
+Don't call undo/redo commands in response to beforeinput events when the view isn't editable. Add isHistoryTransaction
+
+### New features
+
+The new `isHistoryTransaction` predicate can be used to recognize transactions generated by the history system.
+
+## 1.4.1 (2024-07-10)
+
+### Bug fixes
+
+Fix an issue where mark steps could cause the history to treat otherwise adjacent changes as non-adjacent, and start superfluous new undo events.
+
+## 1.4.0 (2024-03-21)
+
+### New features
+
+Add `undoNoScroll`/`redoNoScroll` commands.
+
+## 1.3.2 (2023-05-17)
+
+### Bug fixes
+
+Include CommonJS type declarations in the package to please new TypeScript resolution settings.
+
+## 1.3.1 (2023-04-26)
+
+### Bug fixes
+
+Fix an issue where, if a composition moved the selection, it might get split across multiple undo events.
+
+## 1.3.0 (2022-05-30)
+
+### Bug fixes
+
+Fix an issue where the default behavior of history beforeInput events could still go through when the undo history is empty.
+
+### New features
+
+Include TypeScript type declarations.
+
+## 1.2.0 (2021-08-18)
+
+### Bug fixes
+
+Fix a bug that caused the `beforeInput` handler to not actually invoke the history commands properly.
+
+### New features
+
+The history plugin now listens for `beforeInput` events with `historyUndo` or `historyRedo` type, and applies the undo/redo commands when they occur.
+
+## 1.1.3 (2019-12-10)
+
+### Bug fixes
+
+Fixes a regression where appeneded transactions were combined into the previous history event even if that had been explicitly closed.
+
+## 1.1.2 (2019-11-20)
+
+### Bug fixes
+
+Rename ES module files to use a .js extension, since Webpack gets confused by .mjs
+
+## 1.1.1 (2019-11-19)
+
+### Bug fixes
+
+The file referred to in the package's `module` field now is compiled down to ES5.
+
+## 1.1.0 (2019-11-08)
+
+### Bug fixes
+
+Prevents appended transactions from starting a new event group, even if they were created a while after the previous transaction.
+
+### New features
+
+Add a `module` field to package json file.
+
+## 1.0.4 (2019-02-19)
+
+### Bug fixes
+
+Fix a bug that corrupted selection data in the history when applying remote steps in some cases.
+
+## 1.0.3 (2018-10-08)
+
+### Bug fixes
+
+Appending a transaction to an undo transaction will no longer immediately clear the redo history.
+
+When handling appended transactions, the history will keep the last step in the original transaction, not the one from the appended transaction, for testing whether a subsequent transaction is adjacent to the previous one.
+
+## 1.0.2 (2018-03-13)
+
+### Bug fixes
+
+Fix a bug that could corrupt the history when rebasing changes because of collaborative editing.
+
+## 1.0.1 (2018-03-05)
+
+### Bug fixes
+
+Fix crash that could occur (in specific circumstance) when redoing.
+
+## 0.24.0 (2017-09-25)
+
+### New features
+
+It is no longer necessary to manually enable the `preserveItems` option to the history plugin when using collaborative editing. (This behavior is now automatically enabled when necessary.)
+
+## 0.20.0 (2017-04-03)
+
+### Bug fixes
+
+Appended transactions no longer generate undo history events.
+
+## 0.19.0 (2017-03-16)
+
+### New features
+
+A new function [`closeHistory`](https://prosemirror.net/docs/ref/version/0.19.0.html#history.closeHistory) can be used to force separation of history events at the start of a given transaction.
+
+## 0.18.0 (2017-02-24)
+
+### Bug fixes
+
+Fix a problem where simultaneous collaborative editing could break the undo history.
+
+## 0.17.1 (2017-02-02)
+
+### Bug fixes
+
+Fix issue where collaborative editing corner cases could corrupt the history.
+
+## 0.12.1 (2016-11-01)
+
+### Bug fixes
+
+Fix crash in undo or redo commands when the history is empty.
+
+## 0.12.0 (2016-10-21)
+
+### Breaking changes
+
+The [`history`](https://prosemirror.net/docs/ref/version/0.12.0.html#history.history) export is now a function
+that creates a history plugin, rather than a plugin instance.
+
+### New features
+
+Add a
+[`newGroupDelay`](https://prosemirror.net/docs/ref/version/0.12.0.html#history.history^config.newGroupDelay) plugin
+option. This brings back the behavior where pausing between edits will
+automatically cause the history to put subsequent changes in a new
+undo event.
+
+## 0.11.0 (2016-09-21)
+
+### Breaking changes
+
+Moved into a separate module. Now acts as a plugin that can be omitted
+or replaced by a different implementation if desired.
+
+Merging subsequent changes into a single undo 'event' is now done by
+proximity in the document (the changes must touch) rather than in
+time. This will probably have to be further refined.
+

package/node_modules/prosemirror-history/CONTRIBUTING.md

@@ -0,0 +1,104 @@
+# How to contribute
+
+- [Getting help](#getting-help)
+- [Submitting bug reports](#submitting-bug-reports)
+- [Contributing code](#contributing-code)
+
+## Getting help
+
+Community discussion, questions, and informal bug reporting is done on the
+[discuss.ProseMirror forum](http://discuss.prosemirror.net).
+
+## Submitting bug reports
+
+Report bugs on the
+[GitHub issue tracker](http://github.com/prosemirror/prosemirror/issues).
+Before reporting a bug, please read these pointers.
+
+- The issue tracker is for *bugs*, not requests for help. Questions
+  should be asked on the [forum](http://discuss.prosemirror.net).
+
+- Include information about the version of the code that exhibits the
+  problem. For browser-related issues, include the browser and browser
+  version on which the problem occurred.
+
+- Mention very precisely what went wrong. "X is broken" is not a good
+  bug report. What did you expect to happen? What happened instead?
+  Describe the exact steps a maintainer has to take to make the
+  problem occur. A screencast can be useful, but is no substitute for
+  a textual description.
+
+- A great way to make it easy to reproduce your problem, if it can not
+  be trivially reproduced on the website demos, is to submit a script
+  that triggers the issue.
+
+## Contributing code
+
+If you want to make a change that involves a significant overhaul of
+the code or introduces a user-visible new feature, create an
+[RFC](https://github.com/ProseMirror/rfcs/) first with your proposal.
+
+- Make sure you have a [GitHub Account](https://github.com/signup/free)
+
+- Fork the relevant repository
+  ([how to fork a repo](https://help.github.com/articles/fork-a-repo))
+
+- Create a local checkout of the code. You can use the
+  [main repository](https://github.com/prosemirror/prosemirror) to
+  easily check out all core modules.
+
+- Make your changes, and commit them
+
+- Follow the code style of the rest of the project (see below). Run
+  `npm run lint` (in the main repository checkout) to make sure that
+  the linter is happy.
+
+- If your changes are easy to test or likely to regress, add tests in
+  the relevant `test/` directory. Either put them in an existing
+  `test-*.js` file, if they fit there, or add a new file.
+
+- Make sure all tests pass. Run `npm run test` to verify tests pass
+  (you will need Node.js v6+).
+
+- Submit a pull request ([how to create a pull request](https://help.github.com/articles/fork-a-repo)).
+  Don't put more than one feature/fix in a single pull request.
+
+By contributing code to ProseMirror you
+
+ - Agree to license the contributed code under the project's [MIT
+   license](https://github.com/ProseMirror/prosemirror/blob/master/LICENSE).
+
+ - Confirm that you have the right to contribute and license the code
+   in question. (Either you hold all rights on the code, or the rights
+   holder has explicitly granted the right to use it like this,
+   through a compatible open source license or through a direct
+   agreement with you.)
+
+### Coding standards
+
+- ES6 syntax, targeting an ES5 runtime (i.e. don't use library
+  elements added by ES6, don't use ES7/ES.next syntax).
+
+- 2 spaces per indentation level, no tabs.
+
+- No semicolons except when necessary.
+
+- Follow the surrounding code when it comes to spacing, brace
+  placement, etc.
+
+- Brace-less single-statement bodies are encouraged (whenever they
+  don't impact readability).
+
+- [getdocs](https://github.com/marijnh/getdocs)-style doc comments
+  above items that are part of the public API.
+
+- When documenting non-public items, you can put the type after a
+  single colon, so that getdocs doesn't pick it up and add it to the
+  API reference.
+
+- The linter (`npm run lint`) complains about unused variables and
+  functions. Prefix their names with an underscore to muffle it.
+
+- ProseMirror does *not* follow JSHint or JSLint prescribed style.
+  Patches that try to 'fix' code to pass one of these linters will not
+  be accepted.

package/node_modules/prosemirror-history/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2015-2017 by Marijn Haverbeke <marijn@haverbeke.berlin> and others
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/node_modules/prosemirror-history/README.md

@@ -0,0 +1,27 @@
+# prosemirror-history
+
+[ [**WEBSITE**](https://prosemirror.net) | [**ISSUES**](https://github.com/prosemirror/prosemirror/issues) | [**FORUM**](https://discuss.prosemirror.net) | [**CHANGELOG**](https://github.com/ProseMirror/prosemirror-history/blob/master/CHANGELOG.md) ]
+
+This is a [core module](https://prosemirror.net/docs/ref/#history) of [ProseMirror](https://prosemirror.net).
+ProseMirror is a well-behaved rich semantic content editor based on
+contentEditable, with support for collaborative editing and custom
+document schemas.
+
+This [module](https://prosemirror.net/docs/ref/#history) implements an
+undo/redo history plugin for ProseMirror.
+
+The [project page](https://prosemirror.net) has more information, a
+number of [examples](https://prosemirror.net/examples/) and the
+[documentation](https://prosemirror.net/docs/).
+
+This code is released under an
+[MIT license](https://github.com/prosemirror/prosemirror/tree/master/LICENSE).
+There's a [forum](http://discuss.prosemirror.net) for general
+discussion and support requests, and the
+[Github bug tracker](https://github.com/prosemirror/prosemirror/issues)
+is the place to report issues.
+
+We aim to be an inclusive, welcoming community. To make that explicit,
+we have a [code of
+conduct](http://contributor-covenant.org/version/1/1/0/) that applies
+to communication around the project.