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

package/node_modules/prosemirror-inputrules/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-inputrules/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-inputrules/README.md

@@ -0,0 +1,29 @@
+# prosemirror-inputrules
+
+[ [**WEBSITE**](https://prosemirror.net) | [**ISSUES**](https://github.com/prosemirror/prosemirror/issues) | [**FORUM**](https://discuss.prosemirror.net) | [**CHANGELOG**](https://github.com/ProseMirror/prosemirror-inputrules/blob/master/CHANGELOG.md) ]
+
+This is a [core module](https://prosemirror.net/docs/ref/#inputrules) 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/#inputrules) exports a
+plugin that can be used to define _input rules_, things that should
+happen when input matching a given pattern is typed, along with a
+number of predefined rules.
+
+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.

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

@@ -0,0 +1,194 @@
+'use strict';
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+var prosemirrorState = require('prosemirror-state');
+var prosemirrorTransform = require('prosemirror-transform');
+var InputRule = _createClass(function InputRule(match, handler) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  _classCallCheck(this, InputRule);
+  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) {
+    var insert = string;
+    if (match[1]) {
+      var offset = match[0].lastIndexOf(match[1]);
+      insert += match[0].slice(offset + match[1].length);
+      start += offset;
+      var cutOff = start - end;
+      if (cutOff > 0) {
+        insert = match[0].slice(offset - cutOff, offset) + insert;
+        start = end;
+      }
+    }
+    return state.tr.insertText(insert, start, end);
+  };
+}
+var MAX_MATCH = 500;
+function inputRules(_ref) {
+  var rules = _ref.rules;
+  var plugin = new prosemirrorState.Plugin({
+    state: {
+      init: function init() {
+        return null;
+      },
+      apply: function apply(tr, prev) {
+        var stored = tr.getMeta(this);
+        if (stored) return stored;
+        return tr.selectionSet || tr.docChanged ? null : prev;
+      }
+    },
+    props: {
+      handleTextInput: function handleTextInput(view, from, to, text) {
+        return run(view, from, to, text, rules, plugin);
+      },
+      handleDOMEvents: {
+        compositionend: function compositionend(view) {
+          setTimeout(function () {
+            var $cursor = view.state.selection.$cursor;
+            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;
+  var state = view.state,
+    $from = state.doc.resolve(from);
+  var textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - MAX_MATCH), $from.parentOffset, null, "\uFFFC") + text;
+  var _loop = function _loop() {
+      var rule = rules[i];
+      if (!rule.inCodeMark && $from.marks().some(function (m) {
+        return m.type.spec.code;
+      })) return 0;
+      if ($from.parent.type.spec.code) {
+        if (!rule.inCode) return 0;
+      } else if (rule.inCode === "only") {
+        return 0;
+      }
+      var match = rule.match.exec(textBefore);
+      if (!match || match[0].length < text.length) return 0;
+      var startPos = from - (match[0].length - text.length);
+      if (!rule.inCodeMark) {
+        var hasMark = false;
+        state.doc.nodesBetween(startPos, $from.pos, function (node) {
+          if (node.isInline && node.marks.some(function (m) {
+            return m.type.spec.code;
+          })) hasMark = true;
+        });
+        if (hasMark) return 0;
+      }
+      var tr = rule.handler(state, match, startPos, to);
+      if (!tr) return 0;
+      if (rule.undoable) tr.setMeta(plugin, {
+        transform: tr,
+        from: from,
+        to: to,
+        text: text
+      });
+      view.dispatch(tr);
+      return {
+        v: true
+      };
+    },
+    _ret;
+  for (var i = 0; i < rules.length; i++) {
+    _ret = _loop();
+    if (_ret === 0) continue;
+    if (_ret) return _ret.v;
+  }
+  return false;
+}
+var undoInputRule = function undoInputRule(state, dispatch) {
+  var plugins = state.plugins;
+  for (var i = 0; i < plugins.length; i++) {
+    var plugin = plugins[i],
+      undoable = void 0;
+    if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {
+      if (dispatch) {
+        var tr = state.tr,
+          toUndo = undoable.transform;
+        for (var j = toUndo.steps.length - 1; j >= 0; j--) tr.step(toUndo.steps[j].invert(toUndo.docs[j]));
+        if (undoable.text) {
+          var 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;
+};
+var emDash = new InputRule(/--$/, "—", {
+  inCodeMark: false
+});
+var ellipsis = new InputRule(/\.\.\.$/, "…", {
+  inCodeMark: false
+});
+var openDoubleQuote = new InputRule(/(?:^|[\s\{\[\(\<'"\u2018\u201C])(")$/, "“", {
+  inCodeMark: false
+});
+var closeDoubleQuote = new InputRule(/"$/, "”", {
+  inCodeMark: false
+});
+var openSingleQuote = new InputRule(/(?:^|[\s\{\[\(\<'"\u2018\u201C])(')$/, "‘", {
+  inCodeMark: false
+});
+var closeSingleQuote = new InputRule(/'$/, "’", {
+  inCodeMark: false
+});
+var smartQuotes = [openDoubleQuote, closeDoubleQuote, openSingleQuote, closeSingleQuote];
+function wrappingInputRule(regexp, nodeType) {
+  var getAttrs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+  var joinPredicate = arguments.length > 3 ? arguments[3] : undefined;
+  return new InputRule(regexp, function (state, match, start, end) {
+    var attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+    var tr = state.tr["delete"](start, end);
+    var $start = tr.doc.resolve(start),
+      range = $start.blockRange(),
+      wrapping = range && prosemirrorTransform.findWrapping(range, nodeType, attrs);
+    if (!wrapping) return null;
+    tr.wrap(range, wrapping);
+    var before = tr.doc.resolve(start - 1).nodeBefore;
+    if (before && before.type == nodeType && prosemirrorTransform.canJoin(tr.doc, start - 1) && (!joinPredicate || joinPredicate(match, before))) tr.join(start - 1);
+    return tr;
+  });
+}
+function textblockTypeInputRule(regexp, nodeType) {
+  var getAttrs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+  return new InputRule(regexp, function (state, match, start, end) {
+    var $start = state.doc.resolve(start);
+    var 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);
+  });
+}
+exports.InputRule = InputRule;
+exports.closeDoubleQuote = closeDoubleQuote;
+exports.closeSingleQuote = closeSingleQuote;
+exports.ellipsis = ellipsis;
+exports.emDash = emDash;
+exports.inputRules = inputRules;
+exports.openDoubleQuote = openDoubleQuote;
+exports.openSingleQuote = openSingleQuote;
+exports.smartQuotes = smartQuotes;
+exports.textblockTypeInputRule = textblockTypeInputRule;
+exports.undoInputRule = undoInputRule;
+exports.wrappingInputRule = wrappingInputRule;

package/node_modules/prosemirror-inputrules/dist/index.d.cts

@@ -0,0 +1,131 @@
+import { EditorState, Transaction, Plugin, Command } from 'prosemirror-state';
+import { NodeType, Attrs, Node } from 'prosemirror-model';
+
+/**
+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.
+*/
+declare class InputRule {
+    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](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: RegExp, handler: string | ((state: EditorState, match: RegExpMatchArray, start: number, end: number) => Transaction | null), options?: {
+        /**
+        When set to false,
+        [`undoInputRule`](https://prosemirror.net/docs/ref/#inputrules.undoInputRule) doesn't work on
+        this rule.
+        */
+        undoable?: boolean;
+        /**
+        By default, input rules will not apply inside nodes marked
+        as [code](https://prosemirror.net/docs/ref/#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](https://prosemirror.net/docs/ref/#model.MarkSpec.code). The default is
+        `true`.
+        */
+        inCodeMark?: boolean;
+    });
+}
+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.
+*/
+declare function inputRules({ rules }: {
+    rules: readonly InputRule[];
+}): Plugin<PluginState>;
+/**
+This is a command that will undo an input rule, if applying such a
+rule was the last thing that the user did.
+*/
+declare const undoInputRule: Command;
+
+/**
+Converts double dashes to an emdash.
+*/
+declare const emDash: InputRule;
+/**
+Converts three dots to an ellipsis character.
+*/
+declare const ellipsis: InputRule;
+/**
+“Smart” opening double quotes.
+*/
+declare const openDoubleQuote: InputRule;
+/**
+“Smart” closing double quotes.
+*/
+declare const closeDoubleQuote: InputRule;
+/**
+“Smart” opening single quotes.
+*/
+declare const openSingleQuote: InputRule;
+/**
+“Smart” closing single quotes.
+*/
+declare const closeSingleQuote: InputRule;
+/**
+Smart-quote related input rules.
+*/
+declare const smartQuotes: readonly InputRule[];
+
+/**
+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.
+*/
+declare function wrappingInputRule(regexp: RegExp, nodeType: NodeType, getAttrs?: Attrs | null | ((matches: RegExpMatchArray) => Attrs | null), joinPredicate?: (match: RegExpMatchArray, node: Node) => boolean): InputRule;
+/**
+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.
+*/
+declare function textblockTypeInputRule(regexp: RegExp, nodeType: NodeType, getAttrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null)): InputRule;
+
+export { InputRule, closeDoubleQuote, closeSingleQuote, ellipsis, emDash, inputRules, openDoubleQuote, openSingleQuote, smartQuotes, textblockTypeInputRule, undoInputRule, wrappingInputRule };

package/node_modules/prosemirror-inputrules/dist/index.d.ts

@@ -0,0 +1,131 @@
+import { EditorState, Transaction, Plugin, Command } from 'prosemirror-state';
+import { NodeType, Attrs, Node } from 'prosemirror-model';
+
+/**
+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.
+*/
+declare class InputRule {
+    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](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: RegExp, handler: string | ((state: EditorState, match: RegExpMatchArray, start: number, end: number) => Transaction | null), options?: {
+        /**
+        When set to false,
+        [`undoInputRule`](https://prosemirror.net/docs/ref/#inputrules.undoInputRule) doesn't work on
+        this rule.
+        */
+        undoable?: boolean;
+        /**
+        By default, input rules will not apply inside nodes marked
+        as [code](https://prosemirror.net/docs/ref/#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](https://prosemirror.net/docs/ref/#model.MarkSpec.code). The default is
+        `true`.
+        */
+        inCodeMark?: boolean;
+    });
+}
+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.
+*/
+declare function inputRules({ rules }: {
+    rules: readonly InputRule[];
+}): Plugin<PluginState>;
+/**
+This is a command that will undo an input rule, if applying such a
+rule was the last thing that the user did.
+*/
+declare const undoInputRule: Command;
+
+/**
+Converts double dashes to an emdash.
+*/
+declare const emDash: InputRule;
+/**
+Converts three dots to an ellipsis character.
+*/
+declare const ellipsis: InputRule;
+/**
+“Smart” opening double quotes.
+*/
+declare const openDoubleQuote: InputRule;
+/**
+“Smart” closing double quotes.
+*/
+declare const closeDoubleQuote: InputRule;
+/**
+“Smart” opening single quotes.
+*/
+declare const openSingleQuote: InputRule;
+/**
+“Smart” closing single quotes.
+*/
+declare const closeSingleQuote: InputRule;
+/**
+Smart-quote related input rules.
+*/
+declare const smartQuotes: readonly InputRule[];
+
+/**
+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.
+*/
+declare function wrappingInputRule(regexp: RegExp, nodeType: NodeType, getAttrs?: Attrs | null | ((matches: RegExpMatchArray) => Attrs | null), joinPredicate?: (match: RegExpMatchArray, node: Node) => boolean): InputRule;
+/**
+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.
+*/
+declare function textblockTypeInputRule(regexp: RegExp, nodeType: NodeType, getAttrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null)): InputRule;
+
+export { InputRule, closeDoubleQuote, closeSingleQuote, ellipsis, emDash, inputRules, openDoubleQuote, openSingleQuote, smartQuotes, textblockTypeInputRule, undoInputRule, wrappingInputRule };