@titaui/pc 1.10.4 → 1.10.6-3.beta-2

package/lib/components/rich-editor/plugins/block/heading/index.js

@@ -0,0 +1,190 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HeadingSchema = exports.HeadingPlugin = void 0;
+
+var _getLocale = require("../../../../../utils/getLocale");
+
+var _controller = _interopRequireDefault(require("../../../models/controller"));
+
+var _plugin = _interopRequireDefault(require("../../../models/plugin"));
+
+var _schema = require("../../../models/schema");
+
+var _util = require("../../util");
+
+var _commonds = require("./commonds");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+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, 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 _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+var PLUGIN_NAME = 'heading';
+
+var HeadingSchema = /*#__PURE__*/function (_BlockSchema) {
+  _inherits(HeadingSchema, _BlockSchema);
+
+  var _super = _createSuper(HeadingSchema);
+
+  function HeadingSchema() {
+    var _this;
+
+    _classCallCheck(this, HeadingSchema);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return _possibleConstructorReturn(_this, (_this = _super.call.apply(_super, [this].concat(args)), _this.name = PLUGIN_NAME, _this.attrs = {
+      level: {
+        "default": 1
+      },
+      textAlign: {
+        "default": 'left'
+      }
+    }, _this.parseDOM = [{
+      tag: 'h1',
+      attrs: {
+        level: 1
+      }
+    }, {
+      tag: 'h2',
+      attrs: {
+        level: 2
+      }
+    }, {
+      tag: 'h3',
+      attrs: {
+        level: 3
+      }
+    }, {
+      tag: 'h4',
+      attrs: {
+        level: 4
+      }
+    }, {
+      tag: 'h5',
+      attrs: {
+        level: 5
+      }
+    }, {
+      tag: 'h6',
+      attrs: {
+        level: 6
+      }
+    }], _assertThisInitialized(_this)));
+  }
+
+  _createClass(HeadingSchema, [{
+    key: "toDOM",
+    value: function toDOM(node) {
+      return ["h".concat(node.attrs.level), {
+        style: "text-align:".concat(node.attrs["textAlign"])
+      }, 0];
+    }
+  }]);
+
+  return HeadingSchema;
+}(_schema.BlockSchema);
+
+exports.HeadingSchema = HeadingSchema;
+
+var HeadingController = /*#__PURE__*/function (_BaseController) {
+  _inherits(HeadingController, _BaseController);
+
+  var _super2 = _createSuper(HeadingController);
+
+  function HeadingController() {
+    var _this2;
+
+    _classCallCheck(this, HeadingController);
+
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+
+    return _possibleConstructorReturn(_this2, (_this2 = _super2.call.apply(_super2, [this].concat(args)), _this2.toolbar = [{
+      title: (0, _getLocale.getLocale)('Rtx_HeadingONE'),
+      icon: 'tu-icon-text-H1',
+      handler: function handler(editor) {
+        (0, _commonds.setHeadLine)(editor, 1);
+        editor.view.focus();
+      },
+      active: function active(state) {
+        return (0, _util.isBlockActive)(state, PLUGIN_NAME, {
+          level: 1
+        });
+      }
+    }, {
+      title: (0, _getLocale.getLocale)('Rtx_HeadingTWO'),
+      icon: 'tu-icon-text-H2',
+      handler: function handler(editor) {
+        (0, _commonds.setHeadLine)(editor, 2);
+        editor.view.focus();
+      },
+      active: function active(state) {
+        return (0, _util.isBlockActive)(state, PLUGIN_NAME, {
+          level: 2
+        });
+      }
+    }, {
+      title: (0, _getLocale.getLocale)('Rtx_HeadingTHR'),
+      icon: 'tu-icon-text-H3',
+      handler: function handler(editor) {
+        (0, _commonds.setHeadLine)(editor, 3);
+        editor.view.focus();
+      },
+      active: function active(state) {
+        return (0, _util.isBlockActive)(state, PLUGIN_NAME, {
+          level: 3
+        });
+      }
+    }], _assertThisInitialized(_this2)));
+  }
+
+  return _createClass(HeadingController);
+}(_controller["default"]);
+
+var HeadingPlugin = /*#__PURE__*/function (_BasePlugin) {
+  _inherits(HeadingPlugin, _BasePlugin);
+
+  var _super3 = _createSuper(HeadingPlugin);
+
+  function HeadingPlugin() {
+    var _this3;
+
+    _classCallCheck(this, HeadingPlugin);
+
+    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      args[_key3] = arguments[_key3];
+    }
+
+    return _possibleConstructorReturn(_this3, (_this3 = _super3.call.apply(_super3, [this].concat(args)), _this3.name = PLUGIN_NAME, _this3.schema = HeadingSchema, _this3.controller = HeadingController, _assertThisInitialized(_this3)));
+  }
+
+  return _createClass(HeadingPlugin);
+}(_plugin["default"]);
+
+exports.HeadingPlugin = HeadingPlugin;

package/lib/components/rich-editor/plugins/block/index.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _blockQuote = require("./block-quote");
+
+Object.keys(_blockQuote).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _blockQuote[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _blockQuote[key];
+    }
+  });
+});
+
+var _heading = require("./heading");
+
+Object.keys(_heading).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _heading[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _heading[key];
+    }
+  });
+});
+
+var _paragraph = require("./paragraph");
+
+Object.keys(_paragraph).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _paragraph[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _paragraph[key];
+    }
+  });
+});
+
+var _lists = require("./lists");
+
+Object.keys(_lists).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _lists[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _lists[key];
+    }
+  });
+});

package/lib/components/rich-editor/plugins/block/lists/actions/conversions.js

@@ -0,0 +1,172 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertListType = convertListType;
+
+var _prosemirrorState = require("prosemirror-state");
+
+var _prosemirrorModel = require("prosemirror-model");
+
+var _prosemirrorTransform = require("prosemirror-transform");
+
+var _prosemirrorUtils = require("prosemirror-utils");
+
+var _node = require("../utils/node");
+
+var _find = require("../utils/find");
+
+// import { isEmptyParagraph } from '../../../utils';
+function isEmptyParagraph(node) {
+  return !!node && node.type.name === 'paragraph' && !node.childCount;
+}
+
+function convertListType(_ref) {
+  var tr = _ref.tr,
+      nextListNodeType = _ref.nextListNodeType;
+  var doc = tr.doc,
+      _tr$selection = tr.selection,
+      $from = _tr$selection.$from,
+      $to = _tr$selection.$to;
+  var listRange = $from.blockRange($to, _node.isListNode);
+
+  if (listRange) {
+    return convertSelectedList({
+      tr: tr,
+      nextListNodeType: nextListNodeType
+    });
+  }
+
+  var nodeRangeAroundList = $from.blockRange($to);
+
+  if (!nodeRangeAroundList) {
+    return;
+  }
+
+  var parentNode = nodeRangeAroundList.parent;
+  var startIndex = nodeRangeAroundList.startIndex,
+      endIndex = nodeRangeAroundList.endIndex,
+      depth = nodeRangeAroundList.depth; // Checking for invalid nodes to prevent conversion
+  // eg. a panel cannot be wrapped in a list so return
+  // It will skip this check if the selection begins within a list
+  // This is to match the behaviour of the toolbar buttons being disabled
+
+  if (!(0, _find.findFirstParentListNode)($from)) {
+    for (var i = startIndex; i < endIndex; i++) {
+      var position = nodeRangeAroundList.$from.posAtIndex(i, depth);
+      var resolvedPosition = doc.resolve(position);
+      var currentChild = parentNode.child(i);
+      var currentNodeRange = resolvedPosition.blockRange(tr.doc.resolve(position + currentChild.nodeSize));
+
+      if (currentNodeRange && !(0, _node.isListNode)(currentChild) && !(0, _prosemirrorTransform.findWrapping)(currentNodeRange, nextListNodeType)) {
+        return;
+      }
+    }
+  } // Checking for any non list nodes and wrapping them in a list
+  // so they can be converted
+
+
+  tr.doc.nodesBetween(nodeRangeAroundList.start, nodeRangeAroundList.end, function (node, pos) {
+    // Skip over any nodes that are part of a list
+    if ((0, _find.findFirstParentListNode)(tr.doc.resolve(tr.mapping.map(pos)))) {
+      return false;
+    } // The following applies to suitable nodes that are not within a list
+
+
+    var currentNodeNotWrappedInList = node;
+    var isNotAnEmptyParagraphAndIsParagraphOrLeafNode = !isEmptyParagraph(currentNodeNotWrappedInList) && (!node.type.isBlock || node.type.name === 'paragraph');
+
+    if (isNotAnEmptyParagraphAndIsParagraphOrLeafNode) {
+      var remainingNodeRange = new _prosemirrorModel.NodeRange(tr.doc.resolve(tr.mapping.map(pos)), tr.doc.resolve(tr.mapping.map(pos) + currentNodeNotWrappedInList.nodeSize), nodeRangeAroundList.depth);
+      convertAroundList({
+        tr: tr,
+        nextListNodeType: nextListNodeType,
+        nodeRange: remainingNodeRange
+      });
+      return false;
+    }
+  });
+  convertSelectedList({
+    tr: tr,
+    nextListNodeType: nextListNodeType
+  });
+
+  if (tr.docChanged) {
+    (0, _node.joinSiblingLists)({
+      tr: tr,
+      forceListType: nextListNodeType
+    });
+  }
+}
+
+var convertSelectedList = function convertSelectedList(_ref2) {
+  var tr = _ref2.tr,
+      nextListNodeType = _ref2.nextListNodeType;
+  var selection = tr.selection,
+      _tr$selection2 = tr.selection,
+      from = _tr$selection2.from,
+      to = _tr$selection2.to; // get the positions of all the leaf nodes within the selection
+
+  var nodePositions = [];
+
+  if (selection instanceof _prosemirrorState.TextSelection && selection.$cursor) {
+    nodePositions.push(from);
+  } else {
+    // nodesBetween doesn't return leaf nodes that are outside of from and to
+    tr.doc.nodesBetween(from, to, function (node, pos) {
+      if (!node.isLeaf) {
+        return true;
+      }
+
+      nodePositions.push(pos);
+    });
+  } // use those positions to get the closest parent list nodes
+
+
+  nodePositions.reduce(function (acc, pos) {
+    var closestParentListNode = (0, _prosemirrorUtils.findParentNodeClosestToPos)(tr.doc.resolve(pos), _node.isListNode);
+
+    if (!closestParentListNode) {
+      return acc;
+    } // don't add duplicates if the parent has already been added into the array
+
+
+    var existingParent = acc.find(function (node) {
+      return node.pos === closestParentListNode.pos && node.start === closestParentListNode.start && node.depth === closestParentListNode.depth;
+    });
+
+    if (!existingParent) {
+      acc.push(closestParentListNode);
+    }
+
+    return acc;
+  }, []).forEach(function (item) {
+    tr.setNodeMarkup(item.pos, nextListNodeType);
+  });
+};
+
+var convertAroundList = function convertAroundList(_ref3) {
+  var tr = _ref3.tr,
+      nextListNodeType = _ref3.nextListNodeType,
+      nodeRange = _ref3.nodeRange;
+
+  for (var i = nodeRange.endIndex - 1; i >= nodeRange.startIndex; i--) {
+    // @ts-ignore posAtIndex is a public API but has no type yet
+    var position = nodeRange.$from.posAtIndex(i, nodeRange.depth);
+    var resolvedPos = tr.doc.resolve(position + 1);
+    var range = resolvedPos.blockRange(resolvedPos);
+
+    if (!range) {
+      return;
+    }
+
+    var wrappings = (0, _prosemirrorTransform.findWrapping)(range, nextListNodeType);
+
+    if (!range || !wrappings) {
+      return;
+    }
+
+    tr.wrap(range, wrappings);
+  }
+};

package/lib/components/rich-editor/plugins/block/lists/actions/indent-list-items-selected.js

@@ -0,0 +1,163 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.indentListItemsSelected = void 0;
+
+var _prosemirrorState = require("prosemirror-state");
+
+var _prosemirrorModel = require("prosemirror-model");
+
+var _node = require("../utils/node");
+
+var _find = require("../utils/find");
+
+var _selection = require("../utils/selection");
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+// import { GapCursorSelection } from '../../selection/gap-cursor-selection';
+var indentListItemsSelected = function indentListItemsSelected(tr) {
+  var originalSelection = tr.selection;
+  var normalizedSelection = (0, _selection.normalizeListItemsSelection)({
+    selection: originalSelection,
+    doc: tr.doc
+  });
+  var $from = normalizedSelection.$from,
+      $to = normalizedSelection.$to;
+  var range = calculateRange({
+    selection: normalizedSelection
+  });
+
+  if (!range) {
+    return false;
+  }
+
+  var listItemsSelected = {
+    from: (0, _find.findFirstParentListItemNode)($from),
+    to: (0, _find.findFirstParentListItemNode)($to)
+  };
+
+  if (listItemsSelected.from === null || listItemsSelected.to === null) {
+    return null;
+  }
+
+  var resolvedPos = tr.doc.resolve(listItemsSelected.from.pos);
+  var listItemIndex = resolvedPos.index(); // @ts-ignore
+
+  var positionListItemPosition = resolvedPos.posAtIndex(listItemIndex - 1);
+  var previousListItem = tr.doc.nodeAt(positionListItemPosition);
+
+  if (!previousListItem || !(0, _node.isListItemNode)(previousListItem)) {
+    return null;
+  }
+
+  if ((0, _node.isListItemNode)(previousListItem) && listItemIndex === 0) {
+    return null;
+  }
+
+  var listItemSelectedCommonParent = range.parent;
+  var previousNestedList = (0, _node.isListNode)(previousListItem.lastChild) ? previousListItem.lastChild : null;
+  var listNodeType = previousNestedList ? previousNestedList.type : listItemSelectedCommonParent.type;
+  var nestedList = listItemsSelected.to.node.lastChild;
+  var nestedItemsOffset = nestedList && (0, _node.isListNode)(nestedList) ? nestedList.nodeSize : 0;
+  var from = listItemsSelected.from.pos;
+  var to = listItemsSelected.to.pos + listItemsSelected.to.node.nodeSize - nestedItemsOffset;
+
+  var _createIndentedListIt = createIndentedListItemsSlice({
+    tr: tr,
+    listNodeType: listNodeType,
+    range: range,
+    from: from,
+    to: to
+  }),
+      _createIndentedListIt2 = _slicedToArray(_createIndentedListIt, 2),
+      sliceSelected = _createIndentedListIt2[0],
+      nestedListItemsLeftover = _createIndentedListIt2[1];
+
+  var hasPreviousNestedList = Boolean(previousNestedList);
+  var start = from - 1;
+  tr.replaceRange(hasPreviousNestedList ? start - 1 : start, range.end, sliceSelected);
+  var leftoverContentPosition = tr.mapping.map(to) - 2;
+
+  if (nestedListItemsLeftover.openStart === 0) {
+    tr.insert(leftoverContentPosition, nestedListItemsLeftover.content);
+  } else {
+    tr.replace(leftoverContentPosition - nestedListItemsLeftover.openStart, leftoverContentPosition - nestedListItemsLeftover.openStart, nestedListItemsLeftover);
+  }
+
+  var nextSelection = calculateNewSelection({
+    originalSelection: originalSelection,
+    normalizedSelection: normalizedSelection,
+    tr: tr,
+    hasPreviousNestedList: hasPreviousNestedList
+  });
+  tr.setSelection(nextSelection);
+};
+
+exports.indentListItemsSelected = indentListItemsSelected;
+
+var calculateRange = function calculateRange(_ref) {
+  var selection = _ref.selection;
+  var $from = selection.$from,
+      $to = selection.$to;
+  var range = $from.blockRange($to, _node.isListNode);
+
+  if (!range) {
+    return null;
+  }
+
+  return range;
+};
+
+var calculateNewSelection = function calculateNewSelection(_ref2) {
+  var tr = _ref2.tr,
+      normalizedSelection = _ref2.normalizedSelection,
+      originalSelection = _ref2.originalSelection,
+      hasPreviousNestedList = _ref2.hasPreviousNestedList;
+  var offset = hasPreviousNestedList ? 2 : 0;
+  var $from = normalizedSelection.$from,
+      $to = normalizedSelection.$to; // if (normalizedSelection instanceof GapCursorSelection) {
+  //   const nextSelectionFrom = tr.doc.resolve($from.pos - offset);
+  //   return new GapCursorSelection(nextSelectionFrom, normalizedSelection.side);
+  // }
+
+  if (originalSelection instanceof _prosemirrorState.NodeSelection) {
+    return _prosemirrorState.NodeSelection.create(tr.doc, $from.pos - offset);
+  }
+
+  var _Selection$near = _prosemirrorState.Selection.near(tr.doc.resolve($from.pos - offset)),
+      nextSelectionFrom = _Selection$near.$from;
+
+  var _Selection$near2 = _prosemirrorState.Selection.near(tr.doc.resolve($to.pos - offset), -1),
+      nextSelectionTo = _Selection$near2.$to;
+
+  return new _prosemirrorState.TextSelection(nextSelectionFrom, nextSelectionTo);
+};
+
+var createIndentedListItemsSlice = function createIndentedListItemsSlice(_ref3) {
+  var tr = _ref3.tr,
+      from = _ref3.from,
+      to = _ref3.to,
+      listNodeType = _ref3.listNodeType,
+      range = _ref3.range;
+  var listItemsSlice = tr.doc.slice(from, to - 2);
+
+  var listFragment = _prosemirrorModel.Fragment.from(listNodeType.create(null, listItemsSlice.content));
+
+  var nonSelectedListItemsSlice = tr.doc.slice(to, range.end - 2);
+  var openStart = tr.doc.slice(from - 1, range.end).openStart;
+  var slice = new _prosemirrorModel.Slice(listFragment, openStart, 0);
+  return [slice, nonSelectedListItemsSlice];
+};

package/lib/components/rich-editor/plugins/block/lists/actions/indent-list.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.indentList = void 0;
+
+var _prosemirrorTransform = require("prosemirror-transform");
+
+var _prosemirrorModel = require("prosemirror-model");
+
+// adapted from https://github.com/ProseMirror/prosemirror-schema-list/blob/master/src/schema-list.js#L206:L231
+var indentList = function indentList(tr) {
+  var _tr$selection = tr.selection,
+      $from = _tr$selection.$from,
+      $to = _tr$selection.$to;
+  var listItem = tr.doc.type.schema.nodes.listItem;
+  var range = $from.blockRange($to, function (node) {
+    return !!node.childCount && !!node.firstChild && node.firstChild.type === listItem;
+  });
+
+  if (!range) {
+    return false;
+  } // get the index of the selected list item in the list it is part of
+
+
+  var startIndex = range.startIndex;
+
+  if (startIndex === 0) {
+    return false;
+  } // get the parent list of the list item(s) in the selected range
+
+
+  var parent = range.parent; // get the list immediately before the selection start
+
+  var previousListItem = parent.child(startIndex - 1);
+
+  if (previousListItem.type !== listItem) {
+    return false;
+  } // if that list was nested, join the selected list items into the same
+  // nested list; if not, create a new child list of the same type and
+  // nest it under the current level
+
+
+  var isPreviousListNested = previousListItem.lastChild && ['bulletList', 'orderedList'].includes(previousListItem.lastChild.type.name);
+
+  var inner = _prosemirrorModel.Fragment.from(isPreviousListNested ? listItem.create() : undefined);
+
+  var nextListNodeType = isPreviousListNested ? previousListItem.lastChild.type : parent.type;
+
+  var nextListNodeContent = _prosemirrorModel.Fragment.from(nextListNodeType.create(null, inner));
+
+  var slice = new _prosemirrorModel.Slice(_prosemirrorModel.Fragment.from(listItem.create(null, nextListNodeContent)), isPreviousListNested ? 3 : 1, 0);
+  var before = range.start;
+  var after = range.end;
+  tr.step(new _prosemirrorTransform.ReplaceAroundStep(before - (isPreviousListNested ? 3 : 1), after, before, after, slice, 1, true));
+};
+
+exports.indentList = indentList;