@atlaskit/editor-core 191.0.8 → 191.1.0

package/dist/es2019/plugins/find-replace/ui/FindReplaceTooltipButton.js

@@ -1,50 +0,0 @@
-import _extends from "@babel/runtime/helpers/extends";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import React from 'react';
-import Tooltip from '@atlaskit/tooltip';
-import { ToolTipContent, findKeymapByDescription } from '@atlaskit/editor-common/keymaps';
-import Button from '@atlaskit/button/standard-button';
-export class FindReplaceTooltipButton extends React.PureComponent {
-  constructor(...args) {
-    super(...args);
-    _defineProperty(this, "buttonRef", /*#__PURE__*/React.createRef());
-    _defineProperty(this, "handleClick", () => {
-      this.props.onClick(this.buttonRef);
-    });
-  }
-  render() {
-    const {
-      title,
-      icon,
-      keymapDescription,
-      disabled,
-      isPressed
-    } = this.props;
-    const pressedProps = {
-      ...(typeof isPressed === 'boolean' && {
-        'aria-pressed': isPressed
-      })
-    };
-    return /*#__PURE__*/React.createElement(Tooltip, {
-      content: /*#__PURE__*/React.createElement(ToolTipContent, {
-        description: title,
-        keymap: findKeymapByDescription(keymapDescription)
-      }),
-      hideTooltipOnClick: true,
-      position: 'top'
-    }, /*#__PURE__*/React.createElement(Button, _extends({
-      label: title,
-      appearance: "subtle",
-      testId: title,
-      ref: this.buttonRef,
-      iconBefore: icon,
-      isDisabled: disabled,
-      onClick: this.handleClick,
-      isSelected: isPressed,
-      shouldFitContainer: true
-    }, pressedProps)));
-  }
-}
-_defineProperty(FindReplaceTooltipButton, "defaultProps", {
-  keymapDescription: 'no-keymap'
-});

package/dist/es2019/plugins/find-replace/ui/Replace.js

@@ -1,152 +0,0 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-/** @jsx jsx */
-import React from 'react';
-import { jsx } from '@emotion/react';
-import Button from '@atlaskit/button/standard-button';
-import { defineMessages, injectIntl } from 'react-intl-next';
-import Textfield from '@atlaskit/textfield';
-import { sectionWrapperStyles, replaceSectionButtonStyles } from './styles';
-import { EVENT_TYPE, ACTION, ACTION_SUBJECT, TRIGGER_METHOD } from '@atlaskit/editor-common/analytics';
-const messages = defineMessages({
-  replaceWith: {
-    id: 'fabric.editor.replaceWith',
-    defaultMessage: 'Replace with',
-    description: 'The value that will replace the word or phrase that was searched for'
-  },
-  replace: {
-    id: 'fabric.editor.replace',
-    defaultMessage: 'Replace',
-    description: 'Replace only the currently selected instance of the word or phrase'
-  },
-  replaceAll: {
-    id: 'fabric.editor.replaceAll',
-    defaultMessage: 'Replace all',
-    description: 'Replace all instances of the word or phrase throughout the entire document'
-  }
-});
-class Replace extends React.PureComponent {
-  constructor(props) {
-    super(props);
-    _defineProperty(this, "replaceTextfieldRef", /*#__PURE__*/React.createRef());
-    _defineProperty(this, "skipWhileComposing", fn => {
-      if (this.state.isComposing) {
-        return;
-      }
-      fn();
-    });
-    _defineProperty(this, "handleReplaceClick", () => this.skipWhileComposing(() => {
-      this.props.onReplace({
-        triggerMethod: TRIGGER_METHOD.BUTTON,
-        replaceText: this.state.replaceText
-      });
-    }));
-    _defineProperty(this, "handleReplaceChange", event => this.skipWhileComposing(() => {
-      this.updateReplaceValue(event.target.value);
-    }));
-    _defineProperty(this, "updateReplaceValue", replaceText => {
-      const {
-        dispatchAnalyticsEvent
-      } = this.props;
-      if (dispatchAnalyticsEvent) {
-        dispatchAnalyticsEvent({
-          eventType: EVENT_TYPE.TRACK,
-          action: ACTION.CHANGED_REPLACEMENT_TEXT,
-          actionSubject: ACTION_SUBJECT.FIND_REPLACE_DIALOG
-        });
-      }
-      this.setState({
-        replaceText
-      });
-    });
-    _defineProperty(this, "handleReplaceKeyDown", event => this.skipWhileComposing(() => {
-      if (event.key === 'Enter') {
-        this.props.onReplace({
-          triggerMethod: TRIGGER_METHOD.KEYBOARD,
-          replaceText: this.state.replaceText
-        });
-      } else if (event.key === 'ArrowUp') {
-        // we want to move focus between find & replace texfields when user hits up/down arrows
-        this.props.onArrowUp();
-      }
-    }));
-    _defineProperty(this, "handleReplaceAllClick", () => this.skipWhileComposing(() => {
-      this.props.onReplaceAll({
-        replaceText: this.state.replaceText
-      });
-    }));
-    _defineProperty(this, "handleCompositionStart", () => {
-      this.setState({
-        isComposing: true
-      });
-    });
-    _defineProperty(this, "handleCompositionEnd", event => {
-      this.setState({
-        isComposing: false
-      });
-      // type for React.CompositionEvent doesn't set type for target correctly
-      this.updateReplaceValue(event.target.value);
-    });
-    const {
-      replaceText: _replaceText,
-      intl: {
-        formatMessage
-      }
-    } = props;
-    this.state = {
-      replaceText: _replaceText || '',
-      isComposing: false
-    };
-    this.replaceWith = formatMessage(messages.replaceWith);
-    this.replace = formatMessage(messages.replace);
-    this.replaceAll = formatMessage(messages.replaceAll);
-  }
-  componentDidMount() {
-    this.props.onReplaceTextfieldRefSet(this.replaceTextfieldRef);
-  }
-  componentDidUpdate({
-    replaceText: prevReplaceText
-  }) {
-    const {
-      replaceText
-    } = this.props;
-    if (replaceText && replaceText !== prevReplaceText) {
-      this.setState({
-        replaceText,
-        isComposing: false
-      });
-    }
-  }
-  render() {
-    const {
-      replaceText
-    } = this.state;
-    const {
-      canReplace
-    } = this.props;
-    return jsx("div", {
-      css: sectionWrapperStyles
-    }, jsx(Textfield, {
-      name: "replace",
-      appearance: "none",
-      placeholder: this.replaceWith,
-      defaultValue: replaceText,
-      ref: this.replaceTextfieldRef,
-      autoComplete: "off",
-      onChange: this.handleReplaceChange,
-      onKeyDown: this.handleReplaceKeyDown,
-      onCompositionStart: this.handleCompositionStart,
-      onCompositionEnd: this.handleCompositionEnd
-    }), jsx(Button, {
-      css: replaceSectionButtonStyles,
-      testId: this.replace,
-      onClick: this.handleReplaceClick,
-      isDisabled: !canReplace
-    }, this.replace), jsx(Button, {
-      css: replaceSectionButtonStyles,
-      testId: this.replaceAll,
-      onClick: this.handleReplaceAllClick,
-      isDisabled: !canReplace
-    }, this.replaceAll));
-  }
-}
-export default injectIntl(Replace);

package/dist/es2019/plugins/find-replace/ui/styles.js

@@ -1,48 +0,0 @@
-/** @jsx jsx */
-import { css } from '@emotion/react';
-import { N60, N30A } from '@atlaskit/theme/colors';
-import { relativeFontSizeToBase16 } from '@atlaskit/editor-shared-styles';
-export const replaceSectionButtonStyles = css({
-  marginLeft: "var(--ds-space-050, 4px)"
-});
-export const ruleStyles = css({
-  width: '100%',
-  border: 'none',
-  backgroundColor: `${`var(--ds-border, ${N30A})`}`,
-  margin: `${"var(--ds-space-050, 4px)"} 0px`,
-  height: '1px',
-  borderRadius: '1px'
-});
-export const wrapperStyles = css({
-  display: 'flex',
-  flexDirection: 'column',
-  '> *:not(#replace-hr-element)': {
-    margin: `0px ${"var(--ds-space-050, 4px)"}`
-  }
-});
-export const sectionWrapperStyles = css`
-  display: flex;
-
-  & > * {
-    display: inline-flex;
-    height: 32px;
-    flex: 0 0 auto;
-  }
-
-  & > [data-ds--text-field--container] {
-    display: flex;
-    flex: 1 1 auto;
-  }
-`;
-export const countStyles = css({
-  color: `${`var(--ds-text-subtlest, ${N60})`}`,
-  fontSize: `${relativeFontSizeToBase16(12)}`,
-  flex: '0 0 auto',
-  justifyContent: 'center',
-  alignItems: 'center',
-  marginLeft: "var(--ds-space-050, 4px)",
-  marginRight: "var(--ds-space-100, 8px)"
-});
-export const countWrapperStyles = css({
-  alignItems: 'center'
-});

package/dist/es2019/plugins/find-replace/utils/batch-decorations.js

@@ -1,189 +0,0 @@
-import { createDecorations, findDecorationFromMatch } from './index';
-import { getPluginState } from '../plugin';
-
-// max number of decorations to apply at once
-const batchIncrement = 100;
-// position range to apply decorations between before alternating above or below viewport
-const posIncrement = 2000;
-/**
- * Provides support for applying search match highlight decorations in batches
- */
-class BatchDecorations {
-  stop() {
-    if (this.rafId) {
-      cancelAnimationFrame(this.rafId);
-    }
-  }
-
-  /**
-   * Applies the decorations needed for the current search results
-   * It does so async, splitting them up into batches to help with performance
-   */
-  async applyAllSearchDecorations(editorView, containerElement, addDecorations, removeDecorations) {
-    this.stop();
-    this.addDecorations = addDecorations;
-    this.removeDecorations = removeDecorations;
-    if (!containerElement) {
-      return;
-    }
-    const pmElement = containerElement.querySelector('.ProseMirror');
-    if (!pmElement) {
-      return;
-    }
-    const positions = this.calcDecorationPositions(editorView, containerElement, pmElement);
-    const {
-      startPos,
-      endPos,
-      viewportStartPos,
-      viewportEndPos
-    } = positions;
-    let dir = 0;
-    let before = viewportStartPos;
-    let after = viewportEndPos - posIncrement;
-    await this.updateDecorationsBetween(editorView, viewportStartPos, viewportEndPos);
-    while (before > startPos || after < endPos) {
-      if (dir++ % 2 === 0 && before > startPos || after >= endPos) {
-        const diff = before - startPos;
-        before = Math.max(before - posIncrement, startPos);
-        await this.updateDecorationsBetween(editorView, before, before + Math.min(diff, posIncrement));
-      } else {
-        after = Math.min(after + posIncrement, endPos);
-        await this.updateDecorationsBetween(editorView, after, Math.min(after + posIncrement, endPos));
-      }
-    }
-  }
-  async updateDecorationsBetween(editorView, startPos, endPos) {
-    await this.removeDecorationsBetween(editorView, startPos, endPos);
-    await this.addDecorationsBetween(editorView, startPos, endPos);
-  }
-  async addDecorationsBetween(editorView, startPos, endPos) {
-    const {
-      selection
-    } = editorView.state;
-    const {
-      matches,
-      decorationSet
-    } = getPluginState(editorView.state);
-    if (matches.length === 0) {
-      return;
-    }
-    const matchesBetween = matches.filter(m => m.start >= startPos && (endPos === undefined || m.start < endPos));
-    const selectionMatch = matches.find(match => match.start >= selection.from);
-    const selectionIndex = matchesBetween.findIndex(match => match === selectionMatch);
-    return await this.batchRequests(counter => {
-      let matchesToDecorate = matchesBetween.slice(counter, counter + batchIncrement);
-      if (matchesToDecorate.length === 0) {
-        return false;
-      }
-      let useSelectionIndex = selectionIndex >= counter && selectionIndex < counter + batchIncrement;
-      if (selectionMatch && useSelectionIndex) {
-        const selectionMatchDecoration = findDecorationFromMatch(decorationSet, selectionMatch);
-        if (selectionMatchDecoration) {
-          matchesToDecorate.splice(selectionIndex % batchIncrement, 1);
-          useSelectionIndex = false;
-        }
-      }
-      if (this.addDecorations) {
-        this.addDecorations(createDecorations(useSelectionIndex ? selectionIndex % batchIncrement : -1, matchesToDecorate));
-      }
-    }, {
-      increment: batchIncrement,
-      until: matchesBetween.length
-    });
-  }
-  async removeDecorationsBetween(editorView, startPos, endPos) {
-    const {
-      decorationSet
-    } = getPluginState(editorView.state);
-    const decorations = decorationSet.find(startPos, endPos);
-    if (decorations.length === 0) {
-      return;
-    }
-    return await this.batchRequests(counter => {
-      let decorationsToRemove = decorations.slice(counter, counter + batchIncrement);
-      if (decorationsToRemove.length === 0) {
-        return false;
-      }
-      // only get those decorations whose from >= startPos
-      for (let i = 0; i < decorationsToRemove.length; i++) {
-        if (decorationsToRemove[i].from >= startPos) {
-          break;
-        }
-        decorationsToRemove = decorationsToRemove.slice(1);
-      }
-      if (this.removeDecorations) {
-        this.removeDecorations(decorationsToRemove);
-      }
-    }, {
-      increment: batchIncrement,
-      until: decorations.length
-    });
-  }
-
-  /**
-   * Calculates Prosemirror start and end positions we want to apply the decorations
-   * between
-   * Also calculates the positions the are the start and end of the user's viewport
-   * so we can apply decorations there first and work outwards
-   */
-  calcDecorationPositions(editorView, containerElement, pmElement) {
-    const containerRect = containerElement.getBoundingClientRect();
-    const pmRect = pmElement.getBoundingClientRect();
-    const viewportStartPos = this.getStartPos(editorView, 0, pmRect.left);
-    const viewportEndPos = this.getEndPos(editorView, containerRect.top + containerRect.height, pmRect.left);
-    return {
-      viewportStartPos,
-      viewportEndPos,
-      startPos: 1,
-      endPos: editorView.state.doc.nodeSize
-    };
-  }
-  getStartPos(editorView, y, x) {
-    const startPos = editorView.posAtCoords({
-      top: y,
-      left: x
-    });
-    return startPos ? startPos.pos : 1;
-  }
-  getEndPos(editorView, y, x) {
-    const maxPos = editorView.state.doc.nodeSize;
-    const endPos = editorView.posAtCoords({
-      top: y,
-      left: x
-    });
-    return endPos ? endPos.pos : maxPos;
-  }
-
-  /**
-   * Util to batch function calls by animation frames
-   * A counter will start at 0 and increment by provided value until reaches limit
-   * Passed in fn receives the counter as a param, return false to skip waiting
-   * for the animation frame for the next call
-   */
-  batchRequests(fn, opts) {
-    let counter = 0;
-    const {
-      increment,
-      until
-    } = opts;
-    return new Promise(resolve => {
-      const batchedFn = () => {
-        let result = fn(counter);
-        while (result === false && counter < until) {
-          counter += increment;
-          result = fn(counter);
-        }
-        if (counter < until) {
-          counter += increment;
-          this.rafId = requestAnimationFrame(batchedFn);
-        } else {
-          this.rafId = undefined;
-          resolve();
-        }
-      };
-      this.rafId = requestAnimationFrame(batchedFn);
-    });
-  }
-}
-const batchDecorations = new BatchDecorations();
-export default batchDecorations;

package/dist/es2019/plugins/find-replace/utils/commands.js

@@ -1,6 +0,0 @@
-export const withScrollIntoView = command => (state, dispatch, view) => command(state, tr => {
-  tr.scrollIntoView();
-  if (dispatch) {
-    dispatch(tr);
-  }
-}, view);

package/dist/es2019/plugins/find-replace/utils/index.js

@@ -1,249 +0,0 @@
-import { Decoration } from '@atlaskit/editor-prosemirror/view';
-import { TextSelection } from '@atlaskit/editor-prosemirror/state';
-import { selectedSearchMatchClass, searchMatchClass } from '../styles';
-export function getSelectedText(selection) {
-  let text = '';
-  const selectedContent = selection.content().content;
-  for (let i = 0; i < selectedContent.childCount; i++) {
-    text += selectedContent.child(i).textContent;
-  }
-  return text;
-}
-export const createDecorations = (selectedIndex, matches) => matches.map(({
-  start,
-  end
-}, i) => createDecoration(start, end, i === selectedIndex));
-export const createDecoration = (start, end, isSelected) => {
-  let className = searchMatchClass;
-  if (isSelected) {
-    className += ` ${selectedSearchMatchClass}`;
-  }
-  return Decoration.inline(start, end, {
-    class: className
-  });
-};
-export function findMatches(content, searchText, shouldMatchCase, contentIndex = 0) {
-  let matches = [];
-  const searchTextLength = searchText.length;
-  let textGrouping = null;
-  const collectMatch = textGrouping => {
-    if (!textGrouping) {
-      return;
-    }
-    let {
-      text,
-      pos: relativePos
-    } = textGrouping;
-    const pos = contentIndex + relativePos;
-    if (!shouldMatchCase) {
-      searchText = searchText.toLowerCase();
-      text = text.toLowerCase();
-    }
-    let index = text.indexOf(searchText);
-    while (index !== -1) {
-      // Find the next substring from the end of the first, so that they don't overlap
-      const end = index + searchTextLength;
-      // Add the substring index to the position of the node
-      matches.push({
-        start: pos + index,
-        end: pos + end
-      });
-      index = text.indexOf(searchText, end);
-    }
-  };
-  if (searchTextLength > 0) {
-    content.descendants((node, pos) => {
-      if (node.isText) {
-        if (textGrouping === null) {
-          textGrouping = {
-            text: node.text,
-            pos
-          };
-        } else {
-          textGrouping.text = textGrouping.text + node.text;
-        }
-      } else {
-        collectMatch(textGrouping);
-        textGrouping = null;
-      }
-    });
-    // if there's a dangling text grouping and no non-text node to trigger collectMatch, manually collectMatch
-    if (textGrouping) {
-      collectMatch(textGrouping);
-    }
-  }
-  return matches;
-}
-
-/**
- * Finds index of first item in matches array that comes after user's cursor pos.
- * If `backward` is `true`, finds index of first item that comes before instead.
- */
-export function findSearchIndex(selectionPos, matches, backward = false) {
-  if (backward) {
-    let matchIndex = matches.findIndex(match => match.start >= selectionPos) - 1;
-    if (matchIndex < 0) {
-      matchIndex = matches.length - 1; // wrap around from the end
-    }
-
-    return matchIndex;
-  }
-  return Math.max(matches.findIndex(match => match.start >= selectionPos), 0);
-}
-export const nextIndex = (currentIndex, total) => (currentIndex + 1) % total;
-export const prevIndex = (currentIndex, total) => (currentIndex - 1 + total) % total;
-export const getSelectionForMatch = (selection, doc, index, matches, offset = 0) => {
-  if (matches[index]) {
-    return TextSelection.create(doc, matches[index].start + offset);
-  }
-  return selection;
-};
-export const findDecorationFromMatch = (decorationSet, match) => {
-  if (!match) {
-    return;
-  }
-  const decorations = decorationSet.find(match.start, match.end);
-  return decorations.length ? decorations.find(
-  // decorationSet.find() returns any decorations that touch the specifided
-  // positions, but we want to be stricter
-  decoration => decoration.from === match.start && decoration.to === match.end) : undefined;
-};
-export const removeDecorationsFromSet = (decorationSet, decorationsToRemove, doc) => {
-  const prevDecorations = decorationSet.find();
-
-  // it is essential that we copy the decorations otherwise in some rare cases
-  // prosemirror-view will update our decorationsToRemove array to contain nulls
-  // instead of Decorations which ruins our check for lost decorations below
-  decorationSet = decorationSet.remove(decorationsToRemove.map(decoration =>
-  // copy exists but isn't on the type definition
-  decoration.copy(decoration.from, decoration.to)));
-  const newDecorations = decorationSet.find();
-
-  // there is a bug in prosemirror-view where it can't cope with deleting inline
-  // decorations from a set in some cases (where there are multiple levels of nested
-  // children arrays), and it deletes more decorations than it should
-  // todo: ticket link
-  const lostDecorations = findLostAdjacentDecorations(decorationsToRemove, prevDecorations, newDecorations);
-  if (lostDecorations.length > 0) {
-    decorationSet = decorationSet.add(doc, lostDecorations);
-  }
-  return decorationSet;
-};
-export const removeMatchesFromSet = (decorationSet, matches, doc) => {
-  const decorationsToRemove = matches.filter(match => !!match).map(match => findDecorationFromMatch(decorationSet, match));
-  decorationsToRemove.forEach(decoration => {
-    if (decoration) {
-      decorationSet = removeDecorationsFromSet(decorationSet, [decoration], doc);
-    }
-  });
-  return decorationSet;
-};
-
-/**
- * Finds decorations in prevDecorations that are not in newDecorations or decorationsToRemove
- * These decorations have been lost by Prosemirror during an over eager decoration removal
- * We need to be smart to cope with thousands of decorations without crashing everything
- */
-export const findLostAdjacentDecorations = (decorationsToRemove, prevDecorations, newDecorations) => {
-  let lostDecorations = [];
-  if (prevDecorations.length - decorationsToRemove.length > newDecorations.length) {
-    const position = decorationsToRemove.length > 0 ? decorationsToRemove[0].from : 0;
-    const prevDecorationsStartIdx = findIndexBeforePosition(prevDecorations, position);
-    const newDecorationsStartIdx = findIndexBeforePosition(newDecorations, position);
-    const startIdx = Math.min(prevDecorationsStartIdx, newDecorationsStartIdx);
-    const prevDecorationsToCheck = prevDecorations.slice(startIdx);
-    const newDecorationsToCheck = newDecorations.slice(startIdx);
-    const uniqueInPrev = [];
-    const numToFind = prevDecorationsToCheck.length - newDecorationsToCheck.length;
-    let foundAll = false;
-    let newDecorationsIdxOffset = 0;
-    for (let i = 0; i < prevDecorationsToCheck.length; i++) {
-      const prevDecoration = prevDecorationsToCheck[i];
-      // this was a legit removal, skip and continue
-      if (decorationsToRemove.find(decoration => decoration.from === prevDecoration.from)) {
-        newDecorationsIdxOffset -= 1;
-        continue;
-      }
-      let j = i + newDecorationsIdxOffset;
-
-      // this is a lost decoration
-      if (j >= newDecorationsToCheck.length) {
-        uniqueInPrev.push(prevDecoration);
-        if (uniqueInPrev.length === numToFind) {
-          foundAll = true;
-        }
-      }
-      for (; j < newDecorationsToCheck.length; j++) {
-        const newDecoration = newDecorationsToCheck[j];
-
-        // decoration found in both arrays, skip and continue
-        if (prevDecoration.from === newDecoration.from) {
-          break;
-        }
-
-        // this is a lost decoration
-        if (newDecoration.from > prevDecoration.from || j === newDecorationsToCheck.length - 1) {
-          uniqueInPrev.push(prevDecoration);
-          newDecorationsIdxOffset -= 1;
-          if (uniqueInPrev.length === numToFind) {
-            foundAll = true;
-          }
-          break;
-        }
-      }
-      if (foundAll) {
-        break;
-      }
-    }
-
-    // make sure we ignore any that we wanted to delete
-    lostDecorations = uniqueInPrev.filter(decoration => !decorationsToRemove.find(decorationToRemove => decoration.from === decorationToRemove.from));
-  }
-  return lostDecorations;
-};
-
-/**
- * Searches through array in bumps of 100 to return the index of the first
- * decoration whose 'from' value is before or equal to the position
- */
-export const findIndexBeforePosition = (items, position) => {
-  // jump in batches to cope with arrays with thousands of decorations
-  const increment = 100;
-  let index = 0;
-  for (let i = items.length - 1; i >= 0; i -= increment) {
-    if (items[i].from < position) {
-      // now we have found the 100 range, we can narrow it down to exact index
-      index = i;
-      for (let j = i; j <= items.length - 1; j++) {
-        if (items[j].from <= position) {
-          index = j;
-        } else {
-          break;
-        }
-      }
-      break;
-    }
-    if (i < 100 && i > 0) {
-      i = 100;
-    }
-  }
-  return index;
-};
-
-/**
- * Determines whether a find/replace text Match will be changed as a result
- * of a Step modification to the document. This is evaluated by checking
- * both mapped and unmapped versions of the Step as in different cases the
- * matches will match.
- *
- * **Note:** Match state received here is after step has been applied.
- */
-export const isMatchAffectedByStep = (match, step, tr) => {
-  const {
-    from,
-    to,
-    slice
-  } = step;
-  const sliceSize = slice.content.size;
-  return from + sliceSize >= match.start && to - sliceSize <= match.end || tr.mapping.map(from) + sliceSize >= match.start && tr.mapping.map(to) - sliceSize <= match.end;
-};

package/dist/es2019/utils/array.js

@@ -1,3 +0,0 @@
-export function findUniqueItemsIn(findIn, checkWith, comparator) {
-  return findIn.filter(firstItem => checkWith.findIndex(secondItem => comparator ? comparator(firstItem, secondItem) : firstItem === secondItem) === -1);
-}