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

package/node_modules/prosemirror-schema-list/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "prosemirror-schema-list",
+  "version": "1.5.1",
+  "description": "List-related schema elements and commands for ProseMirror",
+  "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-schema-list.git"
+  },
+  "dependencies": {
+    "prosemirror-model": "^1.0.0",
+    "prosemirror-transform": "^1.7.3",
+    "prosemirror-state": "^1.0.0"
+  },
+  "devDependencies": {
+    "prosemirror-state": "^1.0.0",
+    "@prosemirror/buildhelper": "^0.1.5",
+    "prosemirror-test-builder": "^1.0.0"
+  },
+  "scripts": {
+    "test": "pm-runtests",
+    "prepare": "pm-buildhelper src/schema-list.ts"
+  }
+}

package/node_modules/prosemirror-schema-list/src/README.md

@@ -0,0 +1,29 @@
+This module exports list-related schema elements and commands. The
+commands assume lists to be nestable, with the restriction that the
+first child of a list item is a plain paragraph.
+
+These are the node specs:
+
+@orderedList
+@bulletList
+@listItem
+
+@addListNodes
+
+Using this would look something like this:
+
+```javascript
+const mySchema = new Schema({
+  nodes: addListNodes(baseSchema.spec.nodes, "paragraph block*", "block"),
+  marks: baseSchema.spec.marks
+})
+```
+
+The following functions are [commands](/docs/guide/#commands) and utilities:
+
+@wrapInList
+@wrapRangeInList
+@splitListItem
+@splitListItemKeepMarks
+@liftListItem
+@sinkListItem

package/node_modules/prosemirror-schema-list/src/schema-list.ts

@@ -0,0 +1,267 @@
+import {findWrapping, liftTarget, canSplit, ReplaceAroundStep, canJoin} from "prosemirror-transform"
+import {Slice, Fragment, NodeSpec, DOMOutputSpec, NodeType, Attrs, NodeRange} from "prosemirror-model"
+import OrderedMap from "orderedmap"
+import {Command, EditorState, Transaction, NodeSelection, Selection} from "prosemirror-state"
+
+const olDOM: DOMOutputSpec = ["ol", 0], ulDOM: DOMOutputSpec = ["ul", 0], liDOM: DOMOutputSpec = ["li", 0]
+
+/// An ordered list [node spec](#model.NodeSpec). Has a single
+/// attribute, `order`, which determines the number at which the list
+/// starts counting, and defaults to 1. Represented as an `<ol>`
+/// element.
+export const orderedList = {
+  attrs: {order: {default: 1, validate: "number"}},
+  parseDOM: [{tag: "ol", getAttrs(dom: HTMLElement) {
+    return {order: dom.hasAttribute("start") ? +dom.getAttribute("start")! : 1}
+  }}],
+  toDOM(node) {
+    return node.attrs.order == 1 ? olDOM : ["ol", {start: node.attrs.order}, 0]
+  }
+} as NodeSpec
+
+/// A bullet list node spec, represented in the DOM as `<ul>`.
+export const bulletList: NodeSpec = {
+  parseDOM: [{tag: "ul"}],
+  toDOM() { return ulDOM }
+}
+
+/// A list item (`<li>`) spec.
+export const listItem: NodeSpec = {
+  parseDOM: [{tag: "li"}],
+  toDOM() { return liDOM },
+  defining: true
+}
+
+function add(obj: {[prop: string]: any}, props: {[prop: string]: any}) {
+  let copy: {[prop: string]: any} = {}
+  for (let prop in obj) copy[prop] = obj[prop]
+  for (let prop in props) copy[prop] = props[prop]
+  return copy
+}
+
+/// Convenience function for adding list-related node types to a map
+/// specifying the nodes for a schema. Adds
+/// [`orderedList`](#schema-list.orderedList) as `"ordered_list"`,
+/// [`bulletList`](#schema-list.bulletList) as `"bullet_list"`, and
+/// [`listItem`](#schema-list.listItem) as `"list_item"`.
+///
+/// `itemContent` determines the content expression for the list items.
+/// If you want the commands defined in this module to apply to your
+/// list structure, it should have a shape like `"paragraph block*"` or
+/// `"paragraph (ordered_list | bullet_list)*"`. `listGroup` can be
+/// given to assign a group name to the list node types, for example
+/// `"block"`.
+export function addListNodes(nodes: OrderedMap<NodeSpec>, itemContent: string, listGroup?: string): OrderedMap<NodeSpec> {
+  return nodes.append({
+    ordered_list: add(orderedList, {content: "list_item+", group: listGroup}),
+    bullet_list: add(bulletList, {content: "list_item+", group: listGroup}),
+    list_item: add(listItem, {content: itemContent})
+  })
+}
+
+/// Returns a command function that wraps the selection in a list with
+/// the given type an attributes. If `dispatch` is null, only return a
+/// value to indicate whether this is possible, but don't actually
+/// perform the change.
+export function wrapInList(listType: NodeType, attrs: Attrs | null = null): Command {
+  return function(state: EditorState, dispatch?: (tr: Transaction) => void) {
+    let {$from, $to} = state.selection
+    let range = $from.blockRange($to)
+    if (!range) return false
+    let tr = dispatch ? state.tr : null
+    if (!wrapRangeInList(tr, range, listType, attrs)) return false
+    if (dispatch) dispatch(tr!.scrollIntoView())
+    return true
+  }
+}
+
+/// Try to wrap the given node range in a list of the given type.
+/// Return `true` when this is possible, `false` otherwise. When `tr`
+/// is non-null, the wrapping is added to that transaction. When it is
+/// `null`, the function only queries whether the wrapping is
+/// possible.
+export function wrapRangeInList(tr: Transaction | null, range: NodeRange, listType: NodeType, attrs: Attrs | null = null) {
+  let doJoin = false, outerRange = range, doc = range.$from.doc
+  // This is at the top of an existing list item
+  if (range.depth >= 2 && range.$from.node(range.depth - 1).type.compatibleContent(listType) && range.startIndex == 0) {
+    // Don't do anything if this is the top of the list
+    if (range.$from.index(range.depth - 1) == 0) return false
+    let $insert = doc.resolve(range.start - 2)
+    outerRange = new NodeRange($insert, $insert, range.depth)
+    if (range.endIndex < range.parent.childCount)
+      range = new NodeRange(range.$from, doc.resolve(range.$to.end(range.depth)), range.depth)
+    doJoin = true
+  }
+  let wrap = findWrapping(outerRange, listType, attrs, range)
+  if (!wrap) return false
+  if (tr) doWrapInList(tr, range, wrap, doJoin, listType)
+  return true
+}
+
+function doWrapInList(tr: Transaction, range: NodeRange, wrappers: {type: NodeType, attrs?: Attrs | null}[],
+                      joinBefore: boolean, listType: NodeType) {
+  let content = Fragment.empty
+  for (let i = wrappers.length - 1; i >= 0; i--)
+    content = Fragment.from(wrappers[i].type.create(wrappers[i].attrs, content))
+
+  tr.step(new ReplaceAroundStep(range.start - (joinBefore ? 2 : 0), range.end, range.start, range.end,
+                                new Slice(content, 0, 0), wrappers.length, true))
+
+  let found = 0
+  for (let i = 0; i < wrappers.length; i++) if (wrappers[i].type == listType) found = i + 1
+  let splitDepth = wrappers.length - found
+
+  let splitPos = range.start + wrappers.length - (joinBefore ? 2 : 0), parent = range.parent
+  for (let i = range.startIndex, e = range.endIndex, first = true; i < e; i++, first = false) {
+    if (!first && canSplit(tr.doc, splitPos, splitDepth)) {
+      tr.split(splitPos, splitDepth)
+      splitPos += 2 * splitDepth
+    }
+    splitPos += parent.child(i).nodeSize
+  }
+  return tr
+}
+
+/// Build a command that splits a non-empty textblock at the top level
+/// of a list item by also splitting that list item.
+export function splitListItem(itemType: NodeType, itemAttrs?: Attrs): Command {
+  return function(state: EditorState, dispatch?: (tr: Transaction) => void) {
+    let {$from, $to, node} = state.selection as NodeSelection
+    if ((node && node.isBlock) || $from.depth < 2 || !$from.sameParent($to)) return false
+    let grandParent = $from.node(-1)
+    if (grandParent.type != itemType) return false
+    if ($from.parent.content.size == 0 && $from.node(-1).childCount == $from.indexAfter(-1)) {
+      // In an empty block. If this is a nested list, the wrapping
+      // list item should be split. Otherwise, bail out and let next
+      // command handle lifting.
+      if ($from.depth == 3 || $from.node(-3).type != itemType ||
+          $from.index(-2) != $from.node(-2).childCount - 1) return false
+      if (dispatch) {
+        let wrap = Fragment.empty
+        let depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3
+        // Build a fragment containing empty versions of the structure
+        // from the outer list item to the parent node of the cursor
+        for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d--)
+          wrap = Fragment.from($from.node(d).copy(wrap))
+        let depthAfter = $from.indexAfter(-1) < $from.node(-2).childCount ? 1
+            : $from.indexAfter(-2) < $from.node(-3).childCount ? 2 : 3
+        // Add a second list item with an empty default start node
+        wrap = wrap.append(Fragment.from(itemType.createAndFill()))
+        let start = $from.before($from.depth - (depthBefore - 1))
+        let tr = state.tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0))
+        let sel = -1
+        tr.doc.nodesBetween(start, tr.doc.content.size, (node, pos) => {
+          if (sel > -1) return false
+          if (node.isTextblock && node.content.size == 0) sel = pos + 1
+        })
+        if (sel > -1) tr.setSelection(Selection.near(tr.doc.resolve(sel)))
+        dispatch(tr.scrollIntoView())
+      }
+      return true
+    }
+    let nextType = $to.pos == $from.end() ? grandParent.contentMatchAt(0).defaultType : null
+    let tr = state.tr.delete($from.pos, $to.pos)
+    let types = nextType ? [itemAttrs ? {type: itemType, attrs: itemAttrs} : null, {type: nextType}] : undefined
+    if (!canSplit(tr.doc, $from.pos, 2, types)) return false
+    if (dispatch) dispatch(tr.split($from.pos, 2, types).scrollIntoView())
+    return true
+  }
+}
+
+/// Acts like [`splitListItem`](#schema-list.splitListItem), but
+/// without resetting the set of active marks at the cursor.
+export function splitListItemKeepMarks(itemType: NodeType, itemAttrs?: Attrs): Command {
+  let split = splitListItem(itemType, itemAttrs)
+  return (state, dispatch) => {
+    return split(state, dispatch && (tr => {
+      let marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks())
+      if (marks) tr.ensureMarks(marks)
+      dispatch(tr)
+    }))
+  }
+}
+
+/// Create a command to lift the list item around the selection up into
+/// a wrapping list.
+export function liftListItem(itemType: NodeType): Command {
+  return function(state: EditorState, dispatch?: (tr: Transaction) => void) {
+    let {$from, $to} = state.selection
+    let range = $from.blockRange($to, node => node.childCount > 0 && node.firstChild!.type == itemType)
+    if (!range) return false
+    if (!dispatch) return true
+    if ($from.node(range.depth - 1).type == itemType) // Inside a parent list
+      return liftToOuterList(state, dispatch, itemType, range)
+    else // Outer list node
+      return liftOutOfList(state, dispatch, range)
+  }
+}
+
+function liftToOuterList(state: EditorState, dispatch: (tr: Transaction) => void, itemType: NodeType, range: NodeRange) {
+  let tr = state.tr, end = range.end, endOfList = range.$to.end(range.depth)
+  if (end < endOfList) {
+    // There are siblings after the lifted items, which must become
+    // children of the last item
+    tr.step(new ReplaceAroundStep(end - 1, endOfList, end, endOfList,
+                                  new Slice(Fragment.from(itemType.create(null, range.parent.copy())), 1, 0), 1, true))
+    range = new NodeRange(tr.doc.resolve(range.$from.pos), tr.doc.resolve(endOfList), range.depth)
+  }
+  const target = liftTarget(range)
+  if (target == null) return false
+  tr.lift(range, target)
+  let $after = tr.doc.resolve(tr.mapping.map(end, -1) - 1)
+  if (canJoin(tr.doc, $after.pos) && $after.nodeBefore!.type == $after.nodeAfter!.type) tr.join($after.pos)
+  dispatch(tr.scrollIntoView())
+  return true
+}
+
+function liftOutOfList(state: EditorState, dispatch: (tr: Transaction) => void, range: NodeRange) {
+  let tr = state.tr, list = range.parent
+  // Merge the list items into a single big item
+  for (let pos = range.end, i = range.endIndex - 1, e = range.startIndex; i > e; i--) {
+    pos -= list.child(i).nodeSize
+    tr.delete(pos - 1, pos + 1)
+  }
+  let $start = tr.doc.resolve(range.start), item = $start.nodeAfter!
+  if (tr.mapping.map(range.end) != range.start + $start.nodeAfter!.nodeSize) return false
+  let atStart = range.startIndex == 0, atEnd = range.endIndex == list.childCount
+  let parent = $start.node(-1), indexBefore = $start.index(-1)
+  if (!parent.canReplace(indexBefore + (atStart ? 0 : 1), indexBefore + 1,
+                         item.content.append(atEnd ? Fragment.empty : Fragment.from(list))))
+    return false
+  let start = $start.pos, end = start + item.nodeSize
+  // Strip off the surrounding list. At the sides where we're not at
+  // the end of the list, the existing list is closed. At sides where
+  // this is the end, it is overwritten to its end.
+  tr.step(new ReplaceAroundStep(start - (atStart ? 1 : 0), end + (atEnd ? 1 : 0), start + 1, end - 1,
+                                new Slice((atStart ? Fragment.empty : Fragment.from(list.copy(Fragment.empty)))
+                                          .append(atEnd ? Fragment.empty : Fragment.from(list.copy(Fragment.empty))),
+                                          atStart ? 0 : 1, atEnd ? 0 : 1), atStart ? 0 : 1))
+  dispatch(tr.scrollIntoView())
+  return true
+}
+
+/// Create a command to sink the list item around the selection down
+/// into an inner list.
+export function sinkListItem(itemType: NodeType): Command {
+  return function(state, dispatch) {
+    let {$from, $to} = state.selection
+    let range = $from.blockRange($to, node => node.childCount > 0 && node.firstChild!.type == itemType)
+    if (!range) return false
+    let startIndex = range.startIndex
+    if (startIndex == 0) return false
+    let parent = range.parent, nodeBefore = parent.child(startIndex - 1)
+    if (nodeBefore.type != itemType) return false
+
+    if (dispatch) {
+      let nestedBefore = nodeBefore.lastChild && nodeBefore.lastChild.type == parent.type
+      let inner = Fragment.from(nestedBefore ? itemType.create() : null)
+      let slice = new Slice(Fragment.from(itemType.create(null, Fragment.from(parent.type.create(null, inner)))),
+                            nestedBefore ? 3 : 1, 0)
+      let before = range.start, after = range.end
+      dispatch(state.tr.step(new ReplaceAroundStep(before - (nestedBefore ? 3 : 1), after,
+                                                   before, after, slice, 1, true))
+               .scrollIntoView())
+    }
+    return true
+  }
+}

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

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

package/node_modules/prosemirror-state/CHANGELOG.md

@@ -0,0 +1,296 @@
+## 1.4.4 (2025-10-23)
+
+### Bug fixes
+
+Avoid a problematic TypeScript compilation issue of `Selection.visible` in some configurations.
+
+Fix an issue in `insertText` where it would always clear non-empty selections, even when not near the inserted text.
+
+## 1.4.3 (2023-05-17)
+
+### Bug fixes
+
+Include CommonJS type declarations in the package to please new TypeScript resolution settings.
+
+## 1.4.2 (2022-10-17)
+
+### Bug fixes
+
+Make sure the `this` bindings in editor props defined as part of a plugin spec refers to the proper plugin type.
+
+## 1.4.1 (2022-06-23)
+
+### Bug fixes
+
+Make the `SelectionRange` constructor public in the types.
+
+## 1.4.0 (2022-05-30)
+
+### Bug fixes
+
+Creating a `TextSelection` with endpoints that don't point at inline positions now emits a warning. (It is technically an error, but crashing on it might be too disruptive for some existing setups.)
+
+### New features
+
+Include TypeScript type declarations.
+
+## 1.3.4 (2021-01-20)
+
+### Bug fixes
+
+Remove (broken, poorly conceptualized) `schema` option to `EditorState.reconfigure`.
+
+## 1.3.3 (2020-03-18)
+
+### Bug fixes
+
+When deleting a whole-document-selection causes default content to be generated, make sure the selection is moved to the start of the document.
+
+## 1.3.2 (2019-11-20)
+
+### Bug fixes
+
+Rename ES module files to use a .js extension, since Webpack gets confused by .mjs
+
+## 1.3.1 (2019-11-19)
+
+### Bug fixes
+
+The file referred to in the package's `module` field now is compiled down to ES5.
+
+## 1.3.0 (2019-11-08)
+
+### New features
+
+Add a `module` field to package json file.
+
+## 1.2.4 (2019-08-12)
+
+### Bug fixes
+
+`Transaction.setSelection` now immediately checks whether the given selection points into the proper document, rather than silently accepting an invalid selection.
+
+## 1.2.3 (2019-05-08)
+
+### Bug fixes
+
+The [`insertText`](https://prosemirror.net/docs/ref/#state.Transaction.insertText) method now collapses the selection to the end of the inserted text, even when given explicit start/end positions.
+
+## 1.2.2 (2018-07-23)
+
+### Bug fixes
+
+The `"appendedTransaction"` meta property on appended transactions now points to the root transaction instead of at the transaction itself, which it accidentally did before.
+
+## 1.2.1 (2018-07-02)
+
+### Bug fixes
+
+Fixes a bug in the default implementation of `Selection.getBookmark`.
+
+## 1.2.0 (2018-04-05)
+
+### New features
+
+[`EditorState.create`](https://prosemirror.net/docs/ref/#state.EditorState^create) now accepts a `storedMark` option to set the state's stored marks.
+
+[`EditorState.toJSON`](https://prosemirror.net/docs/ref/#state.EditorState.toJSON) and [`fromJSON`](https://prosemirror.net/docs/ref/#state.EditorState^fromJSON) persist the set of stored marks, when available.
+
+## 1.1.1 (2018-03-15)
+
+### Bug fixes
+
+Throw errors, rather than constructing invalid objects, when deserializing from invalid JSON data.
+
+## 1.1.0 (2018-01-22)
+
+### New features
+
+[`EditorState.toJSON`](https://prosemirror.net/docs/ref/#state.EditorState.toJSON) now accepts a string or number as argument to support the way `JSON.stringify` can call it.
+
+## 1.0.2 (2017-12-13)
+
+### Bug fixes
+
+Fix issue where a character might be selected after overwriting across block nodes.
+
+Make sure `replaceSelectionWith` doesn't needlessly copy unmarked nodes.
+
+## 1.0.1 (2017-11-01)
+
+### Bug fixes
+
+Typing over marked text now properly makes the new text inherit the old text's marks.
+
+## 0.21.0 (2017-05-03)
+
+### Breaking changes
+
+[`Selection.atStart`](https://prosemirror.net/docs/ref/version/0.21.0.html#state.Selection^atStart), and [`atEnd`](https://prosemirror.net/docs/ref/version/0.21.0.html#state.Selection^atEnd) no longer take a second `textOnly` parameter.
+
+### New features
+
+[`Selection.near`](https://prosemirror.net/docs/ref/version/0.21.0.html#state.Selection^near), [`atStart`](https://prosemirror.net/docs/ref/version/0.21.0.html#state.Selection^atStart), and [`atEnd`](https://prosemirror.net/docs/ref/version/0.21.0.html#state.Selection^atEnd) will now fall back to returning an [`AllSelection`](https://prosemirror.net/docs/ref/version/0.21.0.html#state.AllSelection) when unable to find a valid selection. This removes the (undocumented) requirement that documents always contain a valid selection position (though you'll probably still want to maintain this for practical UI reasons).
+
+## 0.20.0 (2017-04-03)
+
+### Breaking changes
+
+[`Selection.near`](https://prosemirror.net/docs/ref/version/0.20.0.html#state.Selection^near) no longer accepts a `textOnly` parameter.
+
+### Bug fixes
+
+[`TextSelection.between`](https://prosemirror.net/docs/ref/version/0.20.0.html#state.TextSelection^between) may now return a node selection when the document does not contain a valid cursor position.
+
+### New features
+
+[`Selection`](https://prosemirror.net/docs/ref/version/0.20.0.html#model.Selection) objects now implement a [`content`](https://prosemirror.net/docs/ref/version/0.20.0.html#model.Selection.content) method that returns their content. This is used to determine what ends up on the clipboard when the selection is copied or dragged.
+
+Selections may now specify multiple [ranges](https://prosemirror.net/docs/ref/version/0.20.0.html#state.Selection.ranges) that they cover, to generalize to more types of selections. The [`Selection`](https://prosemirror.net/docs/ref/version/0.20.0.html#state.Selection) superclass constructor takes an array of [ranges](https://prosemirror.net/docs/ref/version/0.20.0.html#state.SelectionRange) as optional third argument.
+
+Selections gained new methods [`replace`](https://prosemirror.net/docs/ref/version/0.20.0.html#state.Selection.replace) and [`replaceWith`](https://prosemirror.net/docs/ref/version/0.20.0.html#state.Selection.replaceWith) to provide subclasses more control over how selections of that type respond to being deleted or overwritten.
+
+Selections have a new method [`getBookmark`](https://prosemirror.net/docs/ref/version/0.20.0.html#state.Selection.getBookmark) that custom selection classes can implement to allow the undo history to accurately store and restore them.
+
+The new selection class [`AllSelection`](https://prosemirror.net/docs/ref/version/0.20.0.html#state.AllSelection) can be used to select the entire document.
+
+## 0.19.1 (2017-03-17)
+
+### Bug fixes
+
+Fix an issue where `ensureMarks` would fail to reset the marks to the empty set when turning off the last mark.
+
+## 0.19.0 (2017-03-16)
+
+### Breaking changes
+
+`Selection.between` is now called [`TextSelection.between`](state.TextSelection^between), and only returns text selections.
+
+The JSON representation of selections changed. [`fromJSON`](https://prosemirror.net/docs/ref/version/0.19.0.html#state.Selection^fromJSON) will continue to understand the old representation, but if your own code touches the JSON data, you'll have to adjust it.
+
+All `Selection` objects now have [`$head`](https://prosemirror.net/docs/ref/version/0.19.0.html#state.Selection.$head)/[`$anchor`](https://prosemirror.net/docs/ref/version/0.19.0.html#state.Selection.$anchor) properties, so those can no longer be used to recognize text selections (use [`$cursor`](https://prosemirror.net/docs/ref/version/0.19.0.html#state.TextSelection.$cursor) or `instanceof`).
+
+### New features
+
+It is now possible to write your own [`Selection`](https://prosemirror.net/docs/ref/version/0.19.0.html#state.Selection) subclasses and set the editor selection to an instance of them (provided you implement all required methods and register them with [`Selection.jsonID`](https://prosemirror.net/docs/ref/version/0.19.0.html#state.Selection^jsonID)).
+
+Text selections now have a [`$cursor`](https://prosemirror.net/docs/ref/version/0.19.0.html#state.TextSelection.$cursor) getter which returns a position only if this is a cursor selection.
+
+The new [`Transaction.ensureMarks`](https://prosemirror.net/docs/ref/version/0.19.0.html#state.Transaction.ensureMarks) method makes it easier to ensure given set of active marks without needlessly setting `storedMarks`.
+
+## 0.18.0 (2017-02-24)
+
+### Breaking changes
+
+Plugin objects now store their spec under a [`spec`](https://prosemirror.net/docs/ref/version/0.18.0.html#state.PluginSpec.spec) instead of an `options` property. The `options` property still works with a warning in this release.
+
+## 0.17.1 (2017-02-08)
+
+### Bug fixes
+
+[`Transaction.scrolledIntoView`](https://prosemirror.net/docs/ref/version/0.17.0.html##state.Transaction.scrolledIntoView) no longer always returns true.
+
+[`Selection.near`](https://prosemirror.net/docs/ref/version/0.17.0.html#state.Selection^neard) now takes a third `textOnly` argument, as the docs already claimed.
+
+## 0.17.0 (2017-01-05)
+
+### Breaking changes
+
+The way state is updated was changed. Instead of applying an action (a raw object with a `type` property), it is now done by [applying](https://prosemirror.net/docs/ref/version/0.17.0.html#state.EditorState.apply) a [`Transaction`](https://prosemirror.net/docs/ref/version/0.17.0.html#state.Transaction).
+
+The `EditorTransform` class was renamed [`Transaction`](https://prosemirror.net/docs/ref/version/0.17.0.html#state.Transaction), and extended to allow changing the set of stored marks and attaching custom metadata.
+
+### New features
+
+Plugins now accept a [`filterTransaction`](https://prosemirror.net/docs/ref/version/0.17.0.html#state.Plugin.constructor^options.filterTransaction) option that can be used to filter out transactions as they come in.
+
+Plugins also got an [`appendTransaction`](https://prosemirror.net/docs/ref/version/0.17.0.html#state.Plugin.constructor^options.appendTransaction) option making it possible to follow up transactions with another transaction.
+
+## 0.16.0 (2016-12-23)
+
+### New features
+
+Plugins now take a [`view` option](https://prosemirror.net/docs/ref/version/0.16.0.html#state.Plugin.constructor^options.view) that can be used to interact with the [editor view](https://prosemirror.net/docs/ref/version/0.16.0.html#view.EditorView).
+
+## 0.15.0 (2016-12-10)
+
+### Breaking changes
+
+Selection actions no longer scroll the new selection into view by default (they never were supposed to, but due to a bug they did). Add a `scrollIntoView` property to the action to get this behavior.
+
+## 0.14.0 (2016-11-28)
+
+### New features
+
+[Selection actions](https://prosemirror.net/docs/ref/version/0.14.0.html#state.SelectionAction) now have a `time` field and an (optional) `origin` field.
+
+## 0.13.0 (2016-11-11)
+
+### Breaking changes
+
+[`EditorTransform.replaceSelection`](https://prosemirror.net/docs/ref/version/0.13.0.html#state.EditorTransform.replaceSelection) now takes a [slice](https://prosemirror.net/docs/ref/version/0.13.0.html#model.Slice), no longer a node. The new [`replaceSelectionWith`](https://prosemirror.net/docs/ref/version/0.13.0.html#state.EditorTransform.replaceSelectionWith) method should be used to replace the selection with a node. Until the next release, calling it the old way will still work and emit a warning.
+
+### Bug fixes
+
+The documentation for [`applyAction`](https://prosemirror.net/docs/ref/version/0.13.0.html#state.StateField.applyAction) now actually reflects the arguments this method is given.
+
+### New features
+
+A state field's [`applyAction`](https://prosemirror.net/docs/ref/version/0.13.0.html#state.StateField.applyAction) method is now passed the previous state as 4th argument, so that it has access to the new doc and selection.
+
+[`EditorTransform.replaceSelection`](https://prosemirror.net/docs/ref/version/0.13.0.html#state.EditorTransform.replaceSelection) now accepts a slice (or, as before, as a node), and uses a revised algorithm, relying on the [`defining`](https://prosemirror.net/docs/ref/version/0.13.0.html#model.NodeSpec.defining) node flag.
+
+The [`TextSelection`](https://prosemirror.net/docs/ref/version/0.13.0.html#state.TextSelection) and [`NodeSelection`](https://prosemirror.net/docs/ref/version/0.13.0.html#state.NodeSelection) classes now have a static [`create`](https://prosemirror.net/docs/ref/version/0.13.0.html#state.TextSelection^create) convenience method for creating selections from unresolved positions.
+
+Allow [transform actions](https://prosemirror.net/docs/ref/version/0.13.0.html#state.TransformAction) to be extended during dispatch using [`extendTransformAction`](https://prosemirror.net/docs/ref/version/0.13.0.html#state.extendTransformAction). Introduce [`sealed`](https://prosemirror.net/docs/ref/version/0.13.0.html#state.TransformAction.sealed) flag to indicate when this is not safe.
+
+A new utility function [`NodeSelection.isSelectable`](https://prosemirror.net/docs/ref/version/0.13.0.html#state.NodeSelection.isSelectable) can be used to test whether a node can be the target of a node selection.
+
+## 0.12.0 (2016-10-21)
+
+### Breaking changes
+
+The interace to
+[`EditorState.toJSON`](https://prosemirror.net/docs/ref/version/0.12.0.html#state.EditorState.toJSON) and
+[`EditorState.fromJSON`](https://prosemirror.net/docs/ref/version/0.12.0.html#state.EditorState.fromJSON) has changed.
+
+The way plugins declare their [state
+field](https://prosemirror.net/docs/ref/version/0.12.0.html#state.Plugin.constructor.options.state) has changed. Only one
+state field per plugin is supported, and state fields no longer have
+hard-coded names. [`Plugin.getState`](https://prosemirror.net/docs/ref/version/0.12.0.html#state.Plugin.getState) is the
+way to access plugin state now.
+
+Plugin dependencies are no longer supported.
+
+`Plugin.reconfigure` is gone. Plugins are now always created
+with [`new Plugin`](https://prosemirror.net/docs/ref/version/0.12.0.html#state.Plugin.constructor).
+
+Plugins no longer have a `config` field.
+
+### Bug fixes
+
+Node selections are now properly dropped when mapped over a
+change that replaces their nodes.
+
+### New features
+
+[Plugin keys](https://prosemirror.net/docs/ref/version/0.12.0.html#state.PluginKey) can now be used to find
+plugins by identity.
+
+[Transform actions](https://prosemirror.net/docs/ref/version/0.12.0.html#state.TransformAction) now have a
+`time` field containing the timestamp when the change was made.
+
+## 0.11.0 (2016-09-21)
+
+### Breaking changes
+
+New module inheriting the [`Selection`](https://prosemirror.net/docs/ref/version/0.11.0.html#state.Selection) and
+[`EditorTransform`](https://prosemirror.net/docs/ref/version/0.11.0.html#state.EditorTransform) abstraction, along with
+the persistent [state](https://prosemirror.net/docs/ref/version/0.11.0.html#state.EditorState) value that is now separate
+from the display logic, and the [plugin](https://prosemirror.net/docs/ref/version/0.11.0.html#state.Plugin) system.
+
+`Selection.findAtStart`/`End` was renamed to
+[`Selection.atStart`](https://prosemirror.net/docs/ref/version/0.11.0.html#state.Selection^atStart)/[`End`](https://prosemirror.net/docs/ref/version/0.11.0.html#state.Selection^atEnd),
+and `Selection.findNear` to
+[`Selection.near`](https://prosemirror.net/docs/ref/version/0.11.0.html#state.Selection^near).
+