decap-cms-widget-markdown 2.16.0-beta.0

package/dist/esm/MarkdownControl/plugins/CommandsAndQueries.js

@@ -0,0 +1,188 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _castArray2 = _interopRequireDefault(require("lodash/castArray"));
+var _tail2 = _interopRequireDefault(require("lodash/tail"));
+var _isArray2 = _interopRequireDefault(require("lodash/isArray"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function CommandsAndQueries({
+  defaultType
+}) {
+  return {
+    queries: {
+      atStartOf(editor, node) {
+        const {
+          selection
+        } = editor.value;
+        return selection.isCollapsed && selection.start.isAtStartOfNode(node);
+      },
+      getAncestor(editor, firstKey, lastKey) {
+        if (firstKey === lastKey) {
+          return editor.value.document.getParent(firstKey);
+        }
+        return editor.value.document.getCommonAncestor(firstKey, lastKey);
+      },
+      getOffset(editor, node) {
+        const parent = editor.value.document.getParent(node.key);
+        return parent.nodes.indexOf(node);
+      },
+      getSelectedChildren(editor, node) {
+        return node.nodes.filter(child => editor.isSelected(child));
+      },
+      getCommonAncestor(editor) {
+        const {
+          startBlock,
+          endBlock,
+          document: doc
+        } = editor.value;
+        return doc.getCommonAncestor(startBlock.key, endBlock.key);
+      },
+      getClosestType(editor, node, type) {
+        const types = (0, _castArray2.default)(type);
+        return editor.value.document.getClosest(node.key, n => types.includes(n.type));
+      },
+      getBlockContainer(editor, node) {
+        const targetTypes = ['bulleted-list', 'numbered-list', 'list-item', 'quote', 'table-cell'];
+        const {
+          startBlock,
+          selection
+        } = editor.value;
+        const target = node ? editor.value.document.getParent(node.key) : selection.isCollapsed && startBlock || editor.getCommonAncestor();
+        if (!target) {
+          return editor.value.document;
+        }
+        if (targetTypes.includes(target.type)) {
+          return target;
+        }
+        return editor.getBlockContainer(target);
+      },
+      isSelected(editor, nodes) {
+        return (0, _castArray2.default)(nodes).every(node => {
+          return editor.value.document.isInRange(node.key, editor.value.selection);
+        });
+      },
+      isFirstChild(editor, node) {
+        return editor.value.document.getParent(node.key).nodes.first().key === node.key;
+      },
+      areSiblings(editor, nodes) {
+        if (!(0, _isArray2.default)(nodes) || nodes.length < 2) {
+          return true;
+        }
+        const parent = editor.value.document.getParent(nodes[0].key);
+        return (0, _tail2.default)(nodes).every(node => {
+          return editor.value.document.getParent(node.key).key === parent.key;
+        });
+      },
+      everyBlock(editor, type) {
+        return editor.value.blocks.every(block => block.type === type);
+      },
+      hasMark(editor, type) {
+        return editor.value.activeMarks.some(mark => mark.type === type);
+      },
+      hasBlock(editor, type) {
+        return editor.value.blocks.some(node => node.type === type);
+      },
+      hasInline(editor, type) {
+        return editor.value.inlines.some(node => node.type === type);
+      },
+      hasQuote(editor, quoteLabel) {
+        const {
+          value
+        } = editor;
+        const {
+          document,
+          blocks
+        } = value;
+        return blocks.some(node => {
+          const {
+            key: descendantNodeKey
+          } = node;
+          /* When focusing a quote block, the actual block that gets the focus is the paragraph block whose parent is a `quote` block.
+          Hence, we need to get its parent and check if its type is `quote`. This parent will always be defined because every block in the editor
+          has a Document object as parent by default.
+          */
+          const parent = document.getParent(descendantNodeKey);
+          return parent.type === quoteLabel;
+        });
+      },
+      hasListItems(editor, listType) {
+        const {
+          value
+        } = editor;
+        const {
+          document,
+          blocks
+        } = value;
+        return blocks.some(node => {
+          const {
+            key: lowestNodeKey
+          } = node;
+          /* A list block has the following structure:
+          <ol>
+            <li>
+              <p>Coffee</p>
+            </li>
+            <li>
+              <p>Tea</p>
+            </li>
+          </ol>
+          */
+          const parent = document.getParent(lowestNodeKey);
+          const grandparent = document.getParent(parent.key);
+          return parent.type === 'list-item' && (grandparent === null || grandparent === void 0 ? void 0 : grandparent.type) === listType;
+        });
+      }
+    },
+    commands: {
+      toggleBlock(editor, type) {
+        switch (type) {
+          case 'heading-one':
+          case 'heading-two':
+          case 'heading-three':
+          case 'heading-four':
+          case 'heading-five':
+          case 'heading-six':
+            return editor.setBlocks(editor.everyBlock(type) ? defaultType : type);
+          case 'quote':
+            return editor.toggleQuoteBlock();
+          case 'numbered-list':
+          case 'bulleted-list':
+            {
+              return editor.toggleList(type);
+            }
+        }
+      },
+      unwrapBlockChildren(editor, block) {
+        if (!block || block.object !== 'block') {
+          throw Error(`Expected block but received ${block}.`);
+        }
+        const index = editor.value.document.getPath(block.key).last();
+        const parent = editor.value.document.getParent(block.key);
+        editor.withoutNormalizing(() => {
+          block.nodes.forEach((node, idx) => {
+            editor.moveNodeByKey(node.key, parent.key, index + idx);
+          });
+          editor.removeNodeByKey(block.key);
+        });
+      },
+      unwrapNodeToDepth(editor, node, depth) {
+        let currentDepth = 0;
+        editor.withoutNormalizing(() => {
+          while (currentDepth < depth) {
+            editor.unwrapNodeByKey(node.key);
+            currentDepth += 1;
+          }
+        });
+      },
+      unwrapNodeFromAncestor(editor, node, ancestor) {
+        const depth = ancestor.getDepth(node.key);
+        editor.unwrapNodeToDepth(node, depth);
+      }
+    }
+  };
+}
+var _default = CommandsAndQueries;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/ForceInsert.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function ForceInsert({
+  defaultType
+}) {
+  return {
+    queries: {
+      canInsertBeforeNode(editor, node) {
+        if (!editor.isVoid(node)) {
+          return true;
+        }
+        return !!editor.value.document.getPreviousSibling(node.key);
+      },
+      canInsertAfterNode(editor, node) {
+        if (!editor.isVoid(node)) {
+          return true;
+        }
+        const nextSibling = editor.value.document.getNextSibling(node.key);
+        return nextSibling && !editor.isVoid(nextSibling);
+      }
+    },
+    commands: {
+      forceInsertBeforeNode(editor, node) {
+        const block = {
+          type: defaultType,
+          object: 'block'
+        };
+        const parent = editor.value.document.getParent(node.key);
+        return editor.insertNodeByKey(parent.key, 0, block).moveToStartOfNode(parent).focus();
+      },
+      forceInsertAfterNode(editor, node) {
+        return editor.moveToEndOfNode(node).insertBlock(defaultType).focus();
+      },
+      moveToEndOfDocument(editor) {
+        const lastBlock = editor.value.document.nodes.last();
+        if (editor.isVoid(lastBlock)) {
+          editor.insertBlock(defaultType);
+        }
+        return editor.moveToEndOfNode(lastBlock).focus();
+      }
+    }
+  };
+}
+var _default = ForceInsert;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/Hotkey.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.HOT_KEY_MAP = void 0;
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const HOT_KEY_MAP = {
+  bold: 'mod+b',
+  code: 'mod+shift+c',
+  italic: 'mod+i',
+  strikethrough: 'mod+shift+s',
+  'heading-one': 'mod+1',
+  'heading-two': 'mod+2',
+  'heading-three': 'mod+3',
+  'heading-four': 'mod+4',
+  'heading-five': 'mod+5',
+  'heading-six': 'mod+6',
+  link: 'mod+k'
+};
+exports.HOT_KEY_MAP = HOT_KEY_MAP;
+function Hotkey(key, fn) {
+  return {
+    onKeyDown(event, editor, next) {
+      if (!(0, _isHotkey.default)(key, event)) {
+        return next();
+      }
+      event.preventDefault();
+      editor.command(fn);
+    }
+  };
+}
+var _default = Hotkey;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/LineBreak.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function LineBreak() {
+  return {
+    onKeyDown(event, editor, next) {
+      const isShiftEnter = (0, _isHotkey.default)('shift+enter', event);
+      if (!isShiftEnter) {
+        return next();
+      }
+      return editor.insertInline('break').insertText('').moveToStartOfNextText();
+    }
+  };
+}
+var _default = LineBreak;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/Link.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function Link({
+  type
+}) {
+  return {
+    commands: {
+      toggleLink(editor, getUrl) {
+        const selection = editor.value.selection;
+        const isCollapsed = selection && selection.isCollapsed;
+        if (editor.hasInline(type)) {
+          const inlines = editor.value.inlines.toJSON();
+          const link = inlines.find(item => item.type === type);
+          const url = getUrl(link.data.url);
+          if (url) {
+            // replace the old link
+            return editor.setInlines({
+              data: {
+                url
+              }
+            });
+          } else {
+            // remove url if it was removed by the user
+            return editor.unwrapInline(type);
+          }
+        } else {
+          const url = getUrl();
+          if (!url) {
+            return;
+          }
+          return isCollapsed ? editor.insertInline({
+            type,
+            data: {
+              url
+            },
+            nodes: [{
+              object: 'text',
+              text: url
+            }]
+          }) : editor.wrapInline({
+            type,
+            data: {
+              url
+            }
+          }).moveToEnd();
+        }
+      }
+    }
+  };
+}
+var _default = Link;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/blocks/defaultEmptyBlock.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function defaultEmptyBlock(text = '') {
+  return {
+    type: 'paragraph',
+    children: [{
+      text
+    }]
+  };
+}
+var _default = defaultEmptyBlock;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/blocks/events/keyDown.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _isHotkey = _interopRequireDefault(require("is-hotkey"));
+var _keyDownEnter = _interopRequireDefault(require("./keyDownEnter"));
+var _keyDownBackspace = _interopRequireDefault(require("./keyDownBackspace"));
+var _isCursorInNonDefaultBlock = _interopRequireDefault(require("../locations/isCursorInNonDefaultBlock"));
+var _toggleBlock = _interopRequireDefault(require("./toggleBlock"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const HEADING_HOTKEYS = {
+  'mod+1': 'heading-one',
+  'mod+2': 'heading-two',
+  'mod+3': 'heading-three',
+  'mod+4': 'heading-four',
+  'mod+5': 'heading-five',
+  'mod+6': 'heading-six'
+};
+function keyDown(event, editor) {
+  if (!editor.selection) return;
+  for (const hotkey in HEADING_HOTKEYS) {
+    if ((0, _isHotkey.default)(hotkey, event)) {
+      (0, _toggleBlock.default)(editor, HEADING_HOTKEYS[hotkey]);
+      event.preventDefault();
+      return false;
+    }
+  }
+  if (!(0, _isCursorInNonDefaultBlock.default)(editor)) return;
+  if ((0, _isHotkey.default)('enter', event)) {
+    const eventIntercepted = (0, _keyDownEnter.default)(editor);
+    if (eventIntercepted) {
+      event.preventDefault();
+      return false;
+    }
+  }
+  if ((0, _isHotkey.default)('backspace', event)) {
+    const eventIntercepted = (0, _keyDownBackspace.default)(editor);
+    if (eventIntercepted) {
+      event.preventDefault();
+      return false;
+    }
+  }
+}
+var _default = keyDown;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/blocks/events/keyDownBackspace.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _unwrapIfCursorAtStart = _interopRequireDefault(require("../transforms/unwrapIfCursorAtStart"));
+var _isCursorAtStartOfNonEmptyHeading = _interopRequireDefault(require("../locations/isCursorAtStartOfNonEmptyHeading"));
+var _lowestMatchedAncestor = _interopRequireDefault(require("../../matchers/lowestMatchedAncestor"));
+var _areCurrentAndPreviousBlocksOfType = _interopRequireDefault(require("../locations/areCurrentAndPreviousBlocksOfType"));
+var _isCursorAtStartOfBlockType = _interopRequireDefault(require("../locations/isCursorAtStartOfBlockType"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function keyDownBackspace(editor) {
+  if (!editor.selection) return;
+  if ((0, _isCursorAtStartOfNonEmptyHeading.default)(editor)) {
+    return;
+  }
+  if ((0, _isCursorAtStartOfBlockType.default)(editor, 'quote') && (0, _areCurrentAndPreviousBlocksOfType.default)(editor, 'quote')) {
+    _slate.Transforms.mergeNodes(editor, (0, _lowestMatchedAncestor.default)(editor, 'quote'));
+    return true;
+  }
+  return (0, _unwrapIfCursorAtStart.default)(editor, true);
+}
+var _default = keyDownBackspace;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/blocks/events/keyDownEnter.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _isCursorInBlockType = _interopRequireDefault(require("../locations/isCursorInBlockType"));
+var _splitIntoParagraph = _interopRequireDefault(require("../transforms/splitIntoParagraph"));
+var _unwrapIfCursorAtStart = _interopRequireDefault(require("../transforms/unwrapIfCursorAtStart"));
+var _isCursorAtEndOfParagraph = _interopRequireDefault(require("../locations/isCursorAtEndOfParagraph"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function keyDownEnter(editor) {
+  if (!editor.selection) return;
+  if ((0, _isCursorInBlockType.default)(editor, 'heading', true)) {
+    return handleHeading(editor);
+  }
+  return (0, _unwrapIfCursorAtStart.default)(editor);
+}
+function handleHeading(editor) {
+  if ((0, _isCursorAtEndOfParagraph.default)(editor)) {
+    // split into paragraph if cursor is at the end of heading
+    (0, _splitIntoParagraph.default)(editor);
+    return true;
+  }
+  return;
+}
+var _default = keyDownEnter;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/blocks/events/toggleBlock.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _isCursorInBlockType = _interopRequireDefault(require("../locations/isCursorInBlockType"));
+var _getListTypeAtCursor = _interopRequireDefault(require("../locations/getListTypeAtCursor"));
+var _wrapListItemsInBlock = _interopRequireDefault(require("../transforms/wrapListItemsInBlock"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function toggleBlock(editor, type) {
+  const {
+    selection
+  } = editor;
+  if (!selection) return;
+  const isHeading = type.startsWith('heading-');
+  const isActive = (0, _isCursorInBlockType.default)(editor, type, isHeading, _slate.Range.isExpanded(selection));
+  const listType = (0, _getListTypeAtCursor.default)(editor);
+
+  // headings do not contain paragraphs so they could be converted, not wrapped/unwrapped
+  if (isHeading) {
+    _slate.Transforms.setNodes(editor, {
+      type: isActive ? 'paragraph' : type
+    });
+    return;
+  }
+  const {
+    focus,
+    anchor
+  } = selection;
+  if (!isActive && listType && focus.path[focus.path.length - 3] != anchor.path[anchor.path.length - 3]) {
+    return (0, _wrapListItemsInBlock.default)(editor, type, listType);
+  }
+  if (!isActive) {
+    return _slate.Transforms.wrapNodes(editor, {
+      type
+    });
+  }
+  _slate.Transforms.unwrapNodes(editor, {
+    match: n => n.type === type
+  });
+  return;
+}
+var _default = toggleBlock;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/blocks/locations/areCurrentAndPreviousBlocksOfType.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _lowestMatchedAncestor = _interopRequireDefault(require("../../matchers/lowestMatchedAncestor"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function areCurrentAndPreviousBlocksOfType(editor, type) {
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  const [current] = _slate.Editor.nodes(editor, (0, _lowestMatchedAncestor.default)(editor, 'block'));
+  const previous = _slate.Editor.previous(editor, (0, _lowestMatchedAncestor.default)(editor, type));
+  return current && previous && current[0].type === previous[0].type;
+}
+var _default = areCurrentAndPreviousBlocksOfType;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/blocks/locations/getListTypeAtCursor.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _lowestMatchedAncestor = _interopRequireDefault(require("../../matchers/lowestMatchedAncestor"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function getListTypeAtCursor(editor) {
+  const list = _slate.Editor.above(editor, (0, _lowestMatchedAncestor.default)(editor, 'list'));
+  if (!list) return null;
+  return list[0].type;
+}
+var _default = getListTypeAtCursor;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/blocks/locations/isCursorAtEndOfParagraph.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _lowestMatchedAncestor = _interopRequireDefault(require("../../matchers/lowestMatchedAncestor"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function isCursorAtEndOfParagraph(editor) {
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  const paragraph = _slate.Editor.above(editor, (0, _lowestMatchedAncestor.default)(editor, 'paragraph'));
+  return !!paragraph && _slate.Editor.isEnd(editor, editor.selection.focus, paragraph[1]);
+}
+var _default = isCursorAtEndOfParagraph;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/blocks/locations/isCursorAtStartOfBlockType.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+var _lowestMatchedAncestor = _interopRequireDefault(require("../../matchers/lowestMatchedAncestor"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function isCursorAtStartOfBlockType(editor, type) {
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  const block = _slate.Editor.above(editor, (0, _lowestMatchedAncestor.default)(editor, type));
+  return !!block && _slate.Editor.isStart(editor, editor.selection.focus, block[1]);
+}
+var _default = isCursorAtStartOfBlockType;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/blocks/locations/isCursorAtStartOfNonEmptyHeading.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function isCursorAtStartOfNonEmptyHeading(editor) {
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  const [match] = Array.from(_slate.Editor.nodes(editor, {
+    match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n) && `${n.type}`.startsWith('heading-'),
+    mode: 'lowest'
+  }));
+  return !!match && _slate.Editor.isStart(editor, editor.selection.focus, match[1]) && !_slate.Editor.isEmpty(editor, match[0]);
+}
+var _default = isCursorAtStartOfNonEmptyHeading;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/blocks/locations/isCursorInBlockType.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function isCursorInBlockType(editor, type, ignoreHeadings, ignoreLists) {
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  const [match] = Array.from(_slate.Editor.nodes(editor, {
+    match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n) && n.type !== 'paragraph' && n.type !== 'list-item' && (ignoreHeadings || !`${n.type}`.startsWith('heading-')) && (!ignoreLists || !`${n.type}`.endsWith('-list')),
+    mode: 'lowest'
+  }));
+  return !!match && (match[0].type === type || `${match[0].type}`.startsWith(`${type}-` || `${match[0].type}`.endsWith(`-${type}`)));
+}
+var _default = isCursorInBlockType;
+exports.default = _default;

package/dist/esm/MarkdownControl/plugins/blocks/locations/isCursorInNonDefaultBlock.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _slate = require("slate");
+function isCursorInNonDefaultBlock(editor) {
+  const {
+    selection
+  } = editor;
+  if (!selection) return false;
+  const [match] = Array.from(_slate.Editor.nodes(editor, {
+    match: n => _slate.Element.isElement(n) && _slate.Editor.isBlock(editor, n) && n.type !== 'paragraph',
+    mode: 'lowest'
+  }));
+  return !!match && !_slate.Editor.isEditor(match[0]);
+}
+var _default = isCursorInNonDefaultBlock;
+exports.default = _default;