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

package/node_modules/prosemirror-inputrules/dist/index.js

@@ -0,0 +1,239 @@
+import { Plugin } from 'prosemirror-state';
+import { findWrapping, canJoin } from 'prosemirror-transform';
+
+/**
+Input rules are regular expressions describing a piece of text
+that, when typed, causes something to happen. This might be
+changing two dashes into an emdash, wrapping a paragraph starting
+with `"> "` into a blockquote, or something entirely different.
+*/
+class InputRule {
+    /**
+    Create an input rule. The rule applies when the user typed
+    something and the text directly in front of the cursor matches
+    `match`, which should end with `$`.
+    
+    The `handler` can be a string, in which case the matched text, or
+    the first matched group in the regexp, is replaced by that
+    string.
+    
+    Or a it can be a function, which will be called with the match
+    array produced by
+    [`RegExp.exec`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec),
+    as well as the start and end of the matched range, and which can
+    return a [transaction](https://prosemirror.net/docs/ref/#state.Transaction) that describes the
+    rule's effect, or null to indicate the input was not handled.
+    */
+    constructor(
+    /**
+    @internal
+    */
+    match, handler, options = {}) {
+        this.match = match;
+        this.match = match;
+        this.handler = typeof handler == "string" ? stringHandler(handler) : handler;
+        this.undoable = options.undoable !== false;
+        this.inCode = options.inCode || false;
+        this.inCodeMark = options.inCodeMark !== false;
+    }
+}
+function stringHandler(string) {
+    return function (state, match, start, end) {
+        let insert = string;
+        if (match[1]) {
+            let offset = match[0].lastIndexOf(match[1]);
+            insert += match[0].slice(offset + match[1].length);
+            start += offset;
+            let cutOff = start - end;
+            if (cutOff > 0) {
+                insert = match[0].slice(offset - cutOff, offset) + insert;
+                start = end;
+            }
+        }
+        return state.tr.insertText(insert, start, end);
+    };
+}
+const MAX_MATCH = 500;
+/**
+Create an input rules plugin. When enabled, it will cause text
+input that matches any of the given rules to trigger the rule's
+action.
+*/
+function inputRules({ rules }) {
+    let plugin = new Plugin({
+        state: {
+            init() { return null; },
+            apply(tr, prev) {
+                let stored = tr.getMeta(this);
+                if (stored)
+                    return stored;
+                return tr.selectionSet || tr.docChanged ? null : prev;
+            }
+        },
+        props: {
+            handleTextInput(view, from, to, text) {
+                return run(view, from, to, text, rules, plugin);
+            },
+            handleDOMEvents: {
+                compositionend: (view) => {
+                    setTimeout(() => {
+                        let { $cursor } = view.state.selection;
+                        if ($cursor)
+                            run(view, $cursor.pos, $cursor.pos, "", rules, plugin);
+                    });
+                }
+            }
+        },
+        isInputRules: true
+    });
+    return plugin;
+}
+function run(view, from, to, text, rules, plugin) {
+    if (view.composing)
+        return false;
+    let state = view.state, $from = state.doc.resolve(from);
+    let textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - MAX_MATCH), $from.parentOffset, null, "\ufffc") + text;
+    for (let i = 0; i < rules.length; i++) {
+        let rule = rules[i];
+        if (!rule.inCodeMark && $from.marks().some(m => m.type.spec.code))
+            continue;
+        if ($from.parent.type.spec.code) {
+            if (!rule.inCode)
+                continue;
+        }
+        else if (rule.inCode === "only") {
+            continue;
+        }
+        let match = rule.match.exec(textBefore);
+        if (!match || match[0].length < text.length)
+            continue;
+        let startPos = from - (match[0].length - text.length);
+        if (!rule.inCodeMark) {
+            let hasMark = false;
+            state.doc.nodesBetween(startPos, $from.pos, node => {
+                if (node.isInline && node.marks.some(m => m.type.spec.code))
+                    hasMark = true;
+            });
+            if (hasMark)
+                continue;
+        }
+        let tr = rule.handler(state, match, startPos, to);
+        if (!tr)
+            continue;
+        if (rule.undoable)
+            tr.setMeta(plugin, { transform: tr, from, to, text });
+        view.dispatch(tr);
+        return true;
+    }
+    return false;
+}
+/**
+This is a command that will undo an input rule, if applying such a
+rule was the last thing that the user did.
+*/
+const undoInputRule = (state, dispatch) => {
+    let plugins = state.plugins;
+    for (let i = 0; i < plugins.length; i++) {
+        let plugin = plugins[i], undoable;
+        if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {
+            if (dispatch) {
+                let tr = state.tr, toUndo = undoable.transform;
+                for (let j = toUndo.steps.length - 1; j >= 0; j--)
+                    tr.step(toUndo.steps[j].invert(toUndo.docs[j]));
+                if (undoable.text) {
+                    let marks = tr.doc.resolve(undoable.from).marks();
+                    tr.replaceWith(undoable.from, undoable.to, state.schema.text(undoable.text, marks));
+                }
+                else {
+                    tr.delete(undoable.from, undoable.to);
+                }
+                dispatch(tr);
+            }
+            return true;
+        }
+    }
+    return false;
+};
+
+/**
+Converts double dashes to an emdash.
+*/
+const emDash = new InputRule(/--$/, "—", { inCodeMark: false });
+/**
+Converts three dots to an ellipsis character.
+*/
+const ellipsis = new InputRule(/\.\.\.$/, "…", { inCodeMark: false });
+/**
+“Smart” opening double quotes.
+*/
+const openDoubleQuote = new InputRule(/(?:^|[\s\{\[\(\<'"\u2018\u201C])(")$/, "“", { inCodeMark: false });
+/**
+“Smart” closing double quotes.
+*/
+const closeDoubleQuote = new InputRule(/"$/, "”", { inCodeMark: false });
+/**
+“Smart” opening single quotes.
+*/
+const openSingleQuote = new InputRule(/(?:^|[\s\{\[\(\<'"\u2018\u201C])(')$/, "‘", { inCodeMark: false });
+/**
+“Smart” closing single quotes.
+*/
+const closeSingleQuote = new InputRule(/'$/, "’", { inCodeMark: false });
+/**
+Smart-quote related input rules.
+*/
+const smartQuotes = [openDoubleQuote, closeDoubleQuote, openSingleQuote, closeSingleQuote];
+
+/**
+Build an input rule for automatically wrapping a textblock when a
+given string is typed. The `regexp` argument is
+directly passed through to the `InputRule` constructor. You'll
+probably want the regexp to start with `^`, so that the pattern can
+only occur at the start of a textblock.
+
+`nodeType` is the type of node to wrap in. If it needs attributes,
+you can either pass them directly, or pass a function that will
+compute them from the regular expression match.
+
+By default, if there's a node with the same type above the newly
+wrapped node, the rule will try to [join](https://prosemirror.net/docs/ref/#transform.Transform.join) those
+two nodes. You can pass a join predicate, which takes a regular
+expression match and the node before the wrapped node, and can
+return a boolean to indicate whether a join should happen.
+*/
+function wrappingInputRule(regexp, nodeType, getAttrs = null, joinPredicate) {
+    return new InputRule(regexp, (state, match, start, end) => {
+        let attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+        let tr = state.tr.delete(start, end);
+        let $start = tr.doc.resolve(start), range = $start.blockRange(), wrapping = range && findWrapping(range, nodeType, attrs);
+        if (!wrapping)
+            return null;
+        tr.wrap(range, wrapping);
+        let before = tr.doc.resolve(start - 1).nodeBefore;
+        if (before && before.type == nodeType && canJoin(tr.doc, start - 1) &&
+            (!joinPredicate || joinPredicate(match, before)))
+            tr.join(start - 1);
+        return tr;
+    });
+}
+/**
+Build an input rule that changes the type of a textblock when the
+matched text is typed into it. You'll usually want to start your
+regexp with `^` to that it is only matched at the start of a
+textblock. The optional `getAttrs` parameter can be used to compute
+the new node's attributes, and works the same as in the
+`wrappingInputRule` function.
+*/
+function textblockTypeInputRule(regexp, nodeType, getAttrs = null) {
+    return new InputRule(regexp, (state, match, start, end) => {
+        let $start = state.doc.resolve(start);
+        let attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+        if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType))
+            return null;
+        return state.tr
+            .delete(start, end)
+            .setBlockType(start, start, nodeType, attrs);
+    });
+}
+
+export { InputRule, closeDoubleQuote, closeSingleQuote, ellipsis, emDash, inputRules, openDoubleQuote, openSingleQuote, smartQuotes, textblockTypeInputRule, undoInputRule, wrappingInputRule };

package/node_modules/prosemirror-inputrules/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "prosemirror-inputrules",
+  "version": "1.5.1",
+  "description": "Automatic transforms on text input 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-inputrules.git"
+  },
+  "dependencies": {
+    "prosemirror-state": "^1.0.0",
+    "prosemirror-transform": "^1.0.0"
+  },
+  "devDependencies": {
+    "@prosemirror/buildhelper": "^0.1.5"
+  },
+  "scripts": {
+    "prepare": "pm-buildhelper src/index.ts"
+  }
+}

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

@@ -0,0 +1,23 @@
+This module defines a plugin for attaching _input rules_ to an editor,
+which can react to or transform text typed by the user. It also comes
+with a bunch of default rules that can be enabled in this plugin.
+
+@InputRule
+@inputRules
+@undoInputRule
+
+The module comes with a number of predefined rules:
+
+@emDash
+@ellipsis
+@openDoubleQuote
+@closeDoubleQuote
+@openSingleQuote
+@closeSingleQuote
+@smartQuotes
+
+These utility functions take schema-specific parameters and create
+input rules specific to that schema.
+
+@wrappingInputRule
+@textblockTypeInputRule

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

@@ -0,0 +1,4 @@
+export {InputRule, inputRules, undoInputRule} from "./inputrules"
+export {emDash, ellipsis, openDoubleQuote, closeDoubleQuote, openSingleQuote, closeSingleQuote,
+        smartQuotes} from "./rules"
+export {wrappingInputRule, textblockTypeInputRule} from "./rulebuilders"

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

@@ -0,0 +1,167 @@
+import {Plugin, Transaction, EditorState, TextSelection, Command} from "prosemirror-state"
+import {EditorView} from "prosemirror-view"
+
+/// Input rules are regular expressions describing a piece of text
+/// that, when typed, causes something to happen. This might be
+/// changing two dashes into an emdash, wrapping a paragraph starting
+/// with `"> "` into a blockquote, or something entirely different.
+export class InputRule {
+  /// @internal
+  handler: (state: EditorState, match: RegExpMatchArray, start: number, end: number) => Transaction | null
+
+  /// @internal
+  undoable: boolean
+  inCode: boolean | "only"
+  inCodeMark: boolean | "only"
+
+  /// Create an input rule. The rule applies when the user typed
+  /// something and the text directly in front of the cursor matches
+  /// `match`, which should end with `$`.
+  ///
+  /// The `handler` can be a string, in which case the matched text, or
+  /// the first matched group in the regexp, is replaced by that
+  /// string.
+  ///
+  /// Or a it can be a function, which will be called with the match
+  /// array produced by
+  /// [`RegExp.exec`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec),
+  /// as well as the start and end of the matched range, and which can
+  /// return a [transaction](#state.Transaction) that describes the
+  /// rule's effect, or null to indicate the input was not handled.
+  constructor(
+    /// @internal
+    readonly match: RegExp,
+    handler: string | ((state: EditorState, match: RegExpMatchArray, start: number, end: number) => Transaction | null),
+    options: {
+      /// When set to false,
+      /// [`undoInputRule`](#inputrules.undoInputRule) doesn't work on
+      /// this rule.
+      undoable?: boolean,
+      /// By default, input rules will not apply inside nodes marked
+      /// as [code](#model.NodeSpec.code). Set this to true to change
+      /// that, or to `"only"` to _only_ match in such nodes.
+      inCode?: boolean | "only"
+      /// When set to `false`, this rule will not fire inside marks
+      /// marked as [code](#model.MarkSpec.code). The default is
+      /// `true`.
+      inCodeMark?: boolean
+    } = {}
+  ) {
+    this.match = match
+    this.handler = typeof handler == "string" ? stringHandler(handler) : handler
+    this.undoable = options.undoable !== false
+    this.inCode = options.inCode || false
+    this.inCodeMark = options.inCodeMark !== false
+  }
+}
+
+function stringHandler(string: string) {
+  return function(state: EditorState, match: RegExpMatchArray, start: number, end: number) {
+    let insert = string
+    if (match[1]) {
+      let offset = match[0].lastIndexOf(match[1])
+      insert += match[0].slice(offset + match[1].length)
+      start += offset
+      let cutOff = start - end
+      if (cutOff > 0) {
+        insert = match[0].slice(offset - cutOff, offset) + insert
+        start = end
+      }
+    }
+    return state.tr.insertText(insert, start, end)
+  }
+}
+
+const MAX_MATCH = 500
+
+type PluginState = {transform: Transaction, from: number, to: number, text: string} | null
+
+/// Create an input rules plugin. When enabled, it will cause text
+/// input that matches any of the given rules to trigger the rule's
+/// action.
+export function inputRules({rules}: {rules: readonly InputRule[]}) {
+  let plugin: Plugin<PluginState> = new Plugin<PluginState>({
+    state: {
+      init() { return null },
+      apply(this: typeof plugin, tr, prev) {
+        let stored = tr.getMeta(this)
+        if (stored) return stored
+        return tr.selectionSet || tr.docChanged ? null : prev
+      }
+    },
+
+    props: {
+      handleTextInput(view, from, to, text) {
+        return run(view, from, to, text, rules, plugin)
+      },
+      handleDOMEvents: {
+        compositionend: (view) => {
+          setTimeout(() => {
+            let {$cursor} = view.state.selection as TextSelection
+            if ($cursor) run(view, $cursor.pos, $cursor.pos, "", rules, plugin)
+          })
+        }
+      }
+    },
+
+    isInputRules: true
+  })
+  return plugin
+}
+
+function run(view: EditorView, from: number, to: number, text: string, rules: readonly InputRule[], plugin: Plugin) {
+  if (view.composing) return false
+  let state = view.state, $from = state.doc.resolve(from)
+  let textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - MAX_MATCH), $from.parentOffset,
+                                            null, "\ufffc") + text
+  for (let i = 0; i < rules.length; i++) {
+    let rule = rules[i];
+    if (!rule.inCodeMark && $from.marks().some(m => m.type.spec.code)) continue
+    if ($from.parent.type.spec.code) {
+      if (!rule.inCode) continue
+    } else if (rule.inCode === "only") {
+      continue
+    }
+    let match = rule.match.exec(textBefore)
+    if (!match || match[0].length < text.length) continue
+    let startPos = from - (match[0].length - text.length)
+    if (!rule.inCodeMark) {
+      let hasMark = false
+      state.doc.nodesBetween(startPos, $from.pos, node => {
+        if (node.isInline && node.marks.some(m => m.type.spec.code)) hasMark = true
+      })
+      if (hasMark) continue
+    }
+    let tr = rule.handler(state, match, startPos, to)
+    if (!tr) continue
+    if (rule.undoable) tr.setMeta(plugin, {transform: tr, from, to, text})
+    view.dispatch(tr)
+    return true
+  }
+  return false
+}
+
+/// This is a command that will undo an input rule, if applying such a
+/// rule was the last thing that the user did.
+export const undoInputRule: Command = (state, dispatch) => {
+  let plugins = state.plugins
+  for (let i = 0; i < plugins.length; i++) {
+    let plugin = plugins[i], undoable
+    if ((plugin.spec as any).isInputRules && (undoable = plugin.getState(state))) {
+      if (dispatch) {
+        let tr = state.tr, toUndo = undoable.transform
+        for (let j = toUndo.steps.length - 1; j >= 0; j--)
+          tr.step(toUndo.steps[j].invert(toUndo.docs[j]))
+        if (undoable.text) {
+          let marks = tr.doc.resolve(undoable.from).marks()
+          tr.replaceWith(undoable.from, undoable.to, state.schema.text(undoable.text, marks))
+        } else {
+          tr.delete(undoable.from, undoable.to)
+        }
+        dispatch(tr)
+      }
+      return true
+    }
+  }
+  return false
+}

package/node_modules/prosemirror-inputrules/src/rulebuilders.ts

@@ -0,0 +1,59 @@
+import {InputRule} from "./inputrules"
+import {findWrapping, canJoin} from "prosemirror-transform"
+import {NodeType, Node, Attrs} from "prosemirror-model"
+
+/// Build an input rule for automatically wrapping a textblock when a
+/// given string is typed. The `regexp` argument is
+/// directly passed through to the `InputRule` constructor. You'll
+/// probably want the regexp to start with `^`, so that the pattern can
+/// only occur at the start of a textblock.
+///
+/// `nodeType` is the type of node to wrap in. If it needs attributes,
+/// you can either pass them directly, or pass a function that will
+/// compute them from the regular expression match.
+///
+/// By default, if there's a node with the same type above the newly
+/// wrapped node, the rule will try to [join](#transform.Transform.join) those
+/// two nodes. You can pass a join predicate, which takes a regular
+/// expression match and the node before the wrapped node, and can
+/// return a boolean to indicate whether a join should happen.
+export function wrappingInputRule(
+  regexp: RegExp,
+  nodeType: NodeType,
+  getAttrs: Attrs | null | ((matches: RegExpMatchArray) => Attrs | null) = null,
+  joinPredicate?: (match: RegExpMatchArray, node: Node) => boolean
+) {
+  return new InputRule(regexp, (state, match, start, end) => {
+    let attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs
+    let tr = state.tr.delete(start, end)
+    let $start = tr.doc.resolve(start), range = $start.blockRange(), wrapping = range && findWrapping(range, nodeType, attrs)
+    if (!wrapping) return null
+    tr.wrap(range!, wrapping)
+    let before = tr.doc.resolve(start - 1).nodeBefore
+    if (before && before.type == nodeType && canJoin(tr.doc, start - 1) &&
+        (!joinPredicate || joinPredicate(match, before)))
+      tr.join(start - 1)
+    return tr
+  })
+}
+
+/// Build an input rule that changes the type of a textblock when the
+/// matched text is typed into it. You'll usually want to start your
+/// regexp with `^` to that it is only matched at the start of a
+/// textblock. The optional `getAttrs` parameter can be used to compute
+/// the new node's attributes, and works the same as in the
+/// `wrappingInputRule` function.
+export function textblockTypeInputRule(
+  regexp: RegExp,
+  nodeType: NodeType,
+  getAttrs: Attrs | null | ((match: RegExpMatchArray) => Attrs | null) = null
+) {
+  return new InputRule(regexp, (state, match, start, end) => {
+    let $start = state.doc.resolve(start)
+    let attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs
+    if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType)) return null
+    return state.tr
+      .delete(start, end)
+      .setBlockType(start, start, nodeType, attrs)
+  })
+}

package/node_modules/prosemirror-inputrules/src/rules.ts

@@ -0,0 +1,17 @@
+import {InputRule} from "./inputrules"
+
+/// Converts double dashes to an emdash.
+export const emDash = new InputRule(/--$/, "—", {inCodeMark: false})
+/// Converts three dots to an ellipsis character.
+export const ellipsis = new InputRule(/\.\.\.$/, "…", {inCodeMark: false})
+/// “Smart” opening double quotes.
+export const openDoubleQuote = new InputRule(/(?:^|[\s\{\[\(\<'"\u2018\u201C])(")$/, "“", {inCodeMark: false})
+/// “Smart” closing double quotes.
+export const closeDoubleQuote = new InputRule(/"$/, "”", {inCodeMark: false})
+/// “Smart” opening single quotes.
+export const openSingleQuote = new InputRule(/(?:^|[\s\{\[\(\<'"\u2018\u201C])(')$/, "‘", {inCodeMark: false})
+/// “Smart” closing single quotes.
+export const closeSingleQuote = new InputRule(/'$/, "’", {inCodeMark: false})
+
+/// Smart-quote related input rules.
+export const smartQuotes: readonly InputRule[] = [openDoubleQuote, closeDoubleQuote, openSingleQuote, closeSingleQuote]

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

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

package/node_modules/prosemirror-keymap/CHANGELOG.md

@@ -0,0 +1,104 @@
+## 1.2.3 (2025-05-04)
+
+### Bug fixes
+
+Fix an issue where the library was too eager to dispatch keys by key code when the character produced isn't ASCII.
+
+## 1.2.2 (2023-05-17)
+
+### Bug fixes
+
+Include CommonJS type declarations in the package to please new TypeScript resolution settings.
+
+## 1.2.1 (2023-02-14)
+
+### Bug fixes
+
+Work around macOS putting the unmodified character in `KeyboardEvent.key` when Cmd is held down, fixing shift-cmd-letter bindings.
+
+## 1.2.0 (2022-05-30)
+
+### New features
+
+Include TypeScript type declarations.
+
+## 1.1.5 (2021-10-29)
+
+### Bug fixes
+
+Fix issue where iPhones and iPads with a hardware keyboard didn't have Mod converted to Cmd.
+
+## 1.1.4 (2020-05-18)
+
+### Bug fixes
+
+Fall through to the name associated with a key's `keyCode` when the character produced isn't ASCII and isn't directly bound.
+
+## 1.1.3 (2019-11-20)
+
+### Bug fixes
+
+Rename ES module files to use a .js extension, since Webpack gets confused by .mjs
+
+## 1.1.2 (2019-11-19)
+
+### Bug fixes
+
+The file referred to in the package's `module` field now is compiled down to ES5.
+
+## 1.1.1 (2019-11-15)
+
+### Bug fixes
+
+Fix an issue where keyboards layouts that use shift to produce characters that are created without shift on a US keyboard would fail to fire bindings for those keys that include the Shift- modifier.
+
+## 1.1.0 (2019-11-08)
+
+### New features
+
+Add a `module` field to package json file.
+
+## 1.0.2 (2019-10-16)
+
+### Bug fixes
+
+Upgrade w3c-keyname package dependency.
+
+## 1.0.1 (2018-02-23)
+
+### Bug fixes
+
+Upgrade `w3c-keyname` dependency to version 1.1.8 to prevent users getting stuck with a buggy version.
+
+## 0.22.1 (2017-07-14)
+
+### Bug fixes
+
+Bindings like Alt-3 should now fire even if your keyboard produces a special character for that combination.
+
+## 0.18.0 (2017-02-24)
+
+### New features
+
+Add a [`keydownHandler`](https://prosemirror.net/docs/ref/version/0.18.0.html#keymap.keydownHandler) function, which takes a keymap and produces a [`handleKeydown` prop](https://prosemirror.net/docs/ref/version/0.18.0.html#view.EditorProps.handleKeydown)-style function.
+
+## 0.12.0 (2016-10-21)
+
+### Breaking changes
+
+Key names are now based on
+[`KeyboardEvent.key`](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key)
+instead of
+[`.code`](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code).
+This means that, for character-producing keys, you'll want to use the
+character typed, not the key name. So `Ctrl-Z` now means uppercase Z,
+and you'll usually want `Ctrl-z` instead. Single-quoted key names are
+no longer supported.
+
+## 0.11.0 (2016-09-21)
+
+### Breaking changes
+
+New module, takes the same role as the old built-in keymap support in
+the `ProseMirror` class.
+