opentiny 6.9.0

package/src/core/main/ts/textpatterns/core/InlinePattern.ts

@@ -0,0 +1,326 @@
+import { Arr, Id, Optional, Strings } from '@ephox/katamari';
+
+import * as Spot from '../../alien/Spot';
+import * as TextSearch from '../../alien/TextSearch';
+import DOMUtils from '../../api/dom/DOMUtils';
+import Editor from '../../api/Editor';
+import { createMarker, Marker, rangeFromMarker, removeMarker } from '../utils/Marker';
+import { generatePathRange, generatePathRangeFromRange } from '../utils/PathRange';
+import * as Utils from '../utils/Utils';
+import { InlinePattern, InlinePatternMatch, PatternSet } from './PatternTypes';
+
+interface PatternDetails {
+  readonly pattern: InlinePattern;
+  readonly remainingPatterns: InlinePattern[];
+  readonly position: Spot.SpotPoint<Text>;
+}
+
+interface SearchResults {
+  readonly matches: InlinePatternMatch[];
+  readonly position: Spot.SpotPoint<Text>;
+}
+
+interface InlinePatternMatchWithMarkers extends InlinePatternMatch {
+  readonly endMarker: Marker;
+  readonly startMarker: Marker;
+}
+
+const isReplacementPattern = (pattern: InlinePattern): boolean =>
+  pattern.start.length === 0;
+
+const matchesPattern = (patternContent: string) => (element: Text, offset: number): number => {
+  const text = element.data;
+  const searchText = text.substring(0, offset);
+  const startEndIndex = searchText.lastIndexOf(patternContent.charAt(patternContent.length - 1));
+  const startIndex = searchText.lastIndexOf(patternContent);
+  if (startIndex !== -1) {
+    // Complete string found
+    return startIndex + patternContent.length;
+  } else if (startEndIndex !== -1) {
+    // Potential partial string found
+    return startEndIndex + 1;
+  } else {
+    // No match in current node, so continue
+    return -1;
+  }
+};
+
+const findPatternStartFromSpot = (dom: DOMUtils, pattern: InlinePattern, block: Node, spot: Spot.SpotPoint<Text>): Optional<Range> => {
+  const startPattern = pattern.start;
+  const startSpot = TextSearch.repeatLeft(dom, spot.container, spot.offset, matchesPattern(startPattern), block);
+  return startSpot.bind((spot) => {
+    const startPatternIndex = block.textContent?.indexOf(startPattern) ?? -1;
+    const isCompleteMatch = startPatternIndex !== -1 && spot.offset >= startPatternIndex + startPattern.length;
+
+    if (isCompleteMatch) {
+      // Complete match
+      const rng = dom.createRng();
+      rng.setStart(spot.container, spot.offset - startPattern.length);
+      rng.setEnd(spot.container, spot.offset);
+      return Optional.some(rng);
+    } else {
+      // Partial match so lean left to see if the string exists over fragmented text nodes
+      const offset = spot.offset - startPattern.length;
+      return TextSearch.scanLeft(spot.container, offset, block).map((nextSpot) => {
+        // Build up the range between the last char and the first char
+        const rng = dom.createRng();
+        rng.setStart(nextSpot.container, nextSpot.offset);
+        rng.setEnd(spot.container, spot.offset);
+        return rng;
+      }).filter((rng) =>
+        // Ensure the range content matches the start
+        rng.toString() === startPattern
+      ).orThunk(() =>
+        // No match found, so continue searching
+        findPatternStartFromSpot(dom, pattern, block, Spot.point(spot.container, 0))
+      );
+    }
+  });
+};
+
+const findPatternStart = (dom: DOMUtils, pattern: InlinePattern, node: Node, offset: number, block: Node, requireGap = false): Optional<Range> => {
+  if (pattern.start.length === 0 && !requireGap) {
+    const rng = dom.createRng();
+    rng.setStart(node, offset);
+    rng.setEnd(node, offset);
+    return Optional.some(rng);
+  }
+
+  return TextSearch.textBefore(node, offset, block).bind((spot) => {
+    const start = findPatternStartFromSpot(dom, pattern, block, spot);
+    return start.bind((startRange: Range) => {
+      if (requireGap) {
+        if (startRange.endContainer === spot.container && startRange.endOffset === spot.offset) {
+          return Optional.none();
+        } else if (spot.offset === 0 && startRange.endContainer.textContent?.length === startRange.endOffset) {
+          return Optional.none();
+        }
+      }
+
+      return Optional.some(startRange);
+    });
+  });
+};
+
+const findPattern = (editor: Editor, block: Element, details: PatternDetails, normalizedMatches: boolean): Optional<SearchResults> => {
+  const dom = editor.dom;
+  const root = dom.getRoot();
+  const pattern = details.pattern;
+  const endNode = details.position.container;
+  const endOffset = details.position.offset;
+
+  // Lean left to find the start of the end pattern, as it could be across fragmented nodes
+  return TextSearch.scanLeft(endNode, endOffset - details.pattern.end.length, block).bind((spot) => {
+    const endPathRng = generatePathRange(dom, root, spot.container, spot.offset, endNode, endOffset, normalizedMatches);
+
+    // If we have a replacement pattern, then it can't have nested patterns so just return immediately
+    if (isReplacementPattern(pattern)) {
+      return Optional.some({
+        matches: [{
+          pattern,
+          startRng: endPathRng,
+          endRng: endPathRng
+        }],
+        position: spot
+      });
+    } else {
+      // Find any nested patterns, making sure not to process the current pattern again
+      const resultsOpt = findPatternsRec(editor, details.remainingPatterns, spot.container, spot.offset, block, normalizedMatches);
+      const results: SearchResults = resultsOpt.getOr({ matches: [], position: spot });
+      const pos = results.position;
+
+      // Find the start of the matched pattern
+      const start = findPatternStart(dom, pattern, pos.container, pos.offset, block, resultsOpt.isNone());
+      return start.map((startRng) => {
+        const startPathRng = generatePathRangeFromRange(dom, root, startRng, normalizedMatches);
+        return {
+          matches: results.matches.concat([{
+            pattern,
+            startRng: startPathRng,
+            endRng: endPathRng
+          }]),
+          position: Spot.point(startRng.startContainer as Text, startRng.startOffset)
+        };
+      });
+    }
+  });
+};
+
+// Assumptions:
+// 0. Patterns are sorted by priority so we should preferentially match earlier entries
+// 1. Patterns may be nested but may only occur once
+// 2. Patterns will not have matching prefixes which contain space or standard punctuation ',', '.', ';', ':', '!', '?'
+// 3. Patterns will not extend outside of the root element
+// 4. All pattern ends must be directly before the cursor (represented by node + offset)
+// 5. Only text nodes matter
+const findPatternsRec = (
+  editor: Editor,
+  patterns: InlinePattern[],
+  node: Node,
+  offset: number,
+  block: Element,
+  normalizedMatches: boolean
+): Optional<SearchResults> => {
+  const dom = editor.dom;
+
+  return TextSearch.textBefore(node, offset, dom.getRoot()).bind((endSpot) => {
+    const text = Utils.getBeforeText(dom, block, node, offset);
+    for (let i = 0; i < patterns.length; i++) {
+      const pattern = patterns[i];
+      // If the text does not end with the same string as the pattern, then we can exit
+      // early, because this pattern isn't going to match this text. This saves us doing more
+      // expensive matching calls.
+      if (!Strings.endsWith(text, pattern.end)) {
+        continue;
+      }
+
+      // Generate a new array without the current pattern
+      const patternsWithoutCurrent = patterns.slice();
+      patternsWithoutCurrent.splice(i, 1);
+
+      // Try to find the current pattern
+      const result = findPattern(editor, block, {
+        pattern,
+        remainingPatterns: patternsWithoutCurrent,
+        position: endSpot
+      }, normalizedMatches);
+
+      if (result.isNone() && offset > 0) {
+        return findPatternsRec(
+          editor,
+          patterns,
+          node,
+          offset - 1,
+          block,
+          normalizedMatches
+        );
+      }
+
+      // If a match was found then return that
+      if (result.isSome()) {
+        return result;
+      }
+    }
+
+    return Optional.none();
+  });
+};
+
+const applyPattern = (editor: Editor, pattern: InlinePattern, patternRange: Range): void => {
+  editor.selection.setRng(patternRange);
+  if (pattern.type === 'inline-format') {
+    Arr.each(pattern.format, (format) => {
+      editor.formatter.apply(format);
+    });
+  } else {
+    editor.execCommand(pattern.cmd, false, pattern.value);
+  }
+};
+
+const applyReplacementPattern = (editor: Editor, pattern: InlinePattern, marker: Marker, isRoot: (e: Node) => boolean): void => {
+  // Remove the original text
+  const markerRange = rangeFromMarker(editor.dom, marker);
+  Utils.deleteRng(editor.dom, markerRange, isRoot);
+
+  // Apply the replacement
+  applyPattern(editor, pattern, markerRange);
+};
+
+const applyPatternWithContent = (editor: Editor, pattern: InlinePattern, startMarker: Marker, endMarker: Marker, isRoot: (e: Node) => boolean): void => {
+  const dom = editor.dom;
+
+  // Create the marker ranges for the patterns start/end content
+  const markerEndRange = rangeFromMarker(dom, endMarker);
+  const markerStartRange = rangeFromMarker(dom, startMarker);
+
+  // Clean up the pattern start/end content
+  Utils.deleteRng(dom, markerStartRange, isRoot);
+  Utils.deleteRng(dom, markerEndRange, isRoot);
+
+  // Apply the pattern
+  const patternMarker = { prefix: startMarker.prefix, start: startMarker.end, end: endMarker.start };
+  const patternRange = rangeFromMarker(dom, patternMarker);
+  applyPattern(editor, pattern, patternRange);
+};
+
+const addMarkers = (dom: DOMUtils, matches: InlinePatternMatch[]): InlinePatternMatchWithMarkers[] => {
+  const markerPrefix = Id.generate('mce_textpattern');
+
+  // Add end markers
+  const matchesWithEnds = Arr.foldr(matches, (acc, match) => {
+    const endMarker = createMarker(dom, markerPrefix + `_end${acc.length}`, match.endRng);
+    return acc.concat([{
+      ...match,
+      endMarker
+    }]);
+  }, [] as Array<InlinePatternMatch & { endMarker: Marker }>);
+
+  // Add start markers
+  return Arr.foldr(matchesWithEnds, (acc, match) => {
+    const idx = matchesWithEnds.length - acc.length - 1;
+    const startMarker = isReplacementPattern(match.pattern) ? match.endMarker : createMarker(dom, markerPrefix + `_start${idx}`, match.startRng);
+    return acc.concat([{
+      ...match,
+      startMarker
+    }]);
+  }, [] as InlinePatternMatchWithMarkers[]);
+};
+
+const sortPatterns = (patterns: InlinePattern[]) => Arr.sort(patterns, (a, b) => b.end.length - a.end.length);
+
+const getBestMatches = (matches: InlinePatternMatch[], matchesWithSortedPatterns: InlinePatternMatch[]) => {
+  const hasSameMatches = Arr.forall(matches, (match) =>
+    Arr.exists(matchesWithSortedPatterns, (sortedMatch) =>
+      match.pattern.start === sortedMatch.pattern.start && match.pattern.end === sortedMatch.pattern.end
+    )
+  );
+
+  if (matches.length === matchesWithSortedPatterns.length) {
+    if (hasSameMatches) {
+      return matches;
+    } else {
+      return matchesWithSortedPatterns;
+    }
+  }
+  return matches.length > matchesWithSortedPatterns.length ? matches : matchesWithSortedPatterns;
+};
+
+const findPatterns = (editor: Editor, block: Element, node: Node, offset: number, patternSet: PatternSet, normalizedMatches: boolean): InlinePatternMatch[] => {
+  const matches = findPatternsRec(editor, patternSet.inlinePatterns, node, offset, block, normalizedMatches).fold(() => [], (result) => result.matches);
+  const matchesWithSortedPatterns = findPatternsRec(editor, sortPatterns(patternSet.inlinePatterns), node, offset, block, normalizedMatches).fold(() => [], (result) => result.matches);
+
+  return getBestMatches(matches, matchesWithSortedPatterns);
+};
+
+const applyMatches = (editor: Editor, matches: InlinePatternMatch[]): void => {
+  if (matches.length === 0) {
+    return;
+  }
+
+  // Store the current selection
+  const dom = editor.dom;
+  const bookmark = editor.selection.getBookmark();
+
+  // Add markers for the matched patterns
+  const matchesWithMarkers = addMarkers(dom, matches);
+
+  // Do the replacements
+  Arr.each(matchesWithMarkers, (match) => {
+    const block = dom.getParent(match.startMarker.start, dom.isBlock);
+    const isRoot = (node: Node) => node === block;
+    if (isReplacementPattern(match.pattern)) {
+      applyReplacementPattern(editor, match.pattern, match.endMarker, isRoot);
+    } else {
+      applyPatternWithContent(editor, match.pattern, match.startMarker, match.endMarker, isRoot);
+    }
+
+    // Remove the markers
+    removeMarker(dom, match.endMarker, isRoot);
+    removeMarker(dom, match.startMarker, isRoot);
+  });
+
+  // Restore the selection
+  editor.selection.moveToBookmark(bookmark);
+};
+
+export { applyMatches, findPatterns };

package/src/core/main/ts/textpatterns/core/Pattern.ts

@@ -0,0 +1,141 @@
+import { Arr, Result, Results, Type } from '@ephox/katamari';
+
+import { BlockPattern, DynamicPatternContext, DynamicPatternsLookup, InlineCmdPattern, InlinePattern, Pattern, PatternError, PatternSet, RawDynamicPatternsLookup, RawPattern, BlockPatternTrigger } from './PatternTypes';
+
+const isInlinePattern = (pattern: Pattern): pattern is InlinePattern =>
+  pattern.type === 'inline-command' || pattern.type === 'inline-format';
+
+const isBlockPattern = (pattern: Pattern): pattern is BlockPattern =>
+  pattern.type === 'block-command' || pattern.type === 'block-format';
+
+const hasBlockTrigger = (pattern: Pattern, trigger: BlockPatternTrigger): boolean =>
+  (pattern.type === 'block-command' || pattern.type === 'block-format') && pattern.trigger === trigger;
+
+const normalizePattern = (pattern: RawPattern): Result<Pattern, PatternError> => {
+  const err = (message: string) => Result.error({ message, pattern });
+  const formatOrCmd = <T> (name: string, onFormat: (formats: string[]) => T, onCommand: (cmd: string, value: any) => T): Result<T, PatternError> => {
+    if (pattern.format !== undefined) {
+      let formats: string[];
+      if (Type.isArray(pattern.format)) {
+        if (!Arr.forall(pattern.format, Type.isString)) {
+          return err(name + ' pattern has non-string items in the `format` array');
+        }
+        formats = pattern.format as string[];
+      } else if (Type.isString(pattern.format)) {
+        formats = [ pattern.format ];
+      } else {
+        return err(name + ' pattern has non-string `format` parameter');
+      }
+      return Result.value(onFormat(formats));
+    } else if (pattern.cmd !== undefined) {
+      if (!Type.isString(pattern.cmd)) {
+        return err(name + ' pattern has non-string `cmd` parameter');
+      }
+      return Result.value(onCommand(pattern.cmd, pattern.value));
+    } else {
+      return err(name + ' pattern is missing both `format` and `cmd` parameters');
+    }
+  };
+  if (!Type.isObject(pattern)) {
+    return err('Raw pattern is not an object');
+  }
+  if (!Type.isString(pattern.start)) {
+    return err('Raw pattern is missing `start` parameter');
+  }
+  if (pattern.end !== undefined) {
+    // inline pattern
+    if (!Type.isString(pattern.end)) {
+      return err('Inline pattern has non-string `end` parameter');
+    }
+    if (pattern.start.length === 0 && pattern.end.length === 0) {
+      return err('Inline pattern has empty `start` and `end` parameters');
+    }
+    let start = pattern.start;
+    let end = pattern.end;
+    // when the end is empty swap with start as it is more efficient
+    if (end.length === 0) {
+      end = start;
+      start = '';
+    }
+    return formatOrCmd<InlinePattern>('Inline',
+      (format) => ({ type: 'inline-format', start, end, format }),
+      (cmd, value) => ({ type: 'inline-command', start, end, cmd, value }));
+  } else if (pattern.replacement !== undefined) {
+    // replacement pattern
+    if (!Type.isString(pattern.replacement)) {
+      return err('Replacement pattern has non-string `replacement` parameter');
+    }
+    if (pattern.start.length === 0) {
+      return err('Replacement pattern has empty `start` parameter');
+    }
+    return Result.value<InlineCmdPattern>({
+      type: 'inline-command',
+      start: '',
+      end: pattern.start,
+      cmd: 'mceInsertContent',
+      value: pattern.replacement
+    });
+  } else {
+    // block pattern
+    const trigger = pattern.trigger ?? 'space';
+
+    if (pattern.start.length === 0) {
+      return err('Block pattern has empty `start` parameter');
+    }
+    return formatOrCmd<BlockPattern>('Block', (formats) => ({
+      type: 'block-format',
+      start: pattern.start,
+      format: formats[0],
+      trigger
+    }), (command, commandValue) => ({
+      type: 'block-command',
+      start: pattern.start,
+      cmd: command,
+      value: commandValue,
+      trigger
+    }));
+  }
+};
+
+const getBlockPatterns = (patterns: Pattern[]): BlockPattern[] =>
+  Arr.filter(patterns, isBlockPattern);
+
+const getInlinePatterns = (patterns: Pattern[]): InlinePattern[] =>
+  Arr.filter(patterns, isInlinePattern);
+
+const createPatternSet = (patterns: Pattern[], dynamicPatternsLookup: DynamicPatternsLookup): PatternSet => ({
+  inlinePatterns: getInlinePatterns(patterns),
+  blockPatterns: getBlockPatterns(patterns),
+  dynamicPatternsLookup
+});
+
+const filterByTrigger = (patterns: PatternSet, trigger: BlockPatternTrigger): PatternSet => {
+  return {
+    ...patterns,
+    blockPatterns: Arr.filter(patterns.blockPatterns, (pattern) => hasBlockTrigger(pattern, trigger))
+  };
+};
+
+const fromRawPatterns = (patterns: RawPattern[]): Pattern[] => {
+  const normalized = Results.partition(Arr.map(patterns, normalizePattern));
+  // eslint-disable-next-line no-console
+  Arr.each(normalized.errors, (err) => console.error(err.message, err.pattern));
+  return normalized.values;
+};
+
+const fromRawPatternsLookup = (lookupFn: RawDynamicPatternsLookup): DynamicPatternsLookup => {
+  return (ctx: DynamicPatternContext) => {
+    const rawPatterns = lookupFn(ctx);
+    return fromRawPatterns(rawPatterns);
+  };
+};
+
+export {
+  normalizePattern,
+  createPatternSet,
+  getBlockPatterns,
+  getInlinePatterns,
+  fromRawPatterns,
+  fromRawPatternsLookup,
+  filterByTrigger
+};

package/src/core/main/ts/textpatterns/core/PatternTypes.ts

@@ -0,0 +1,86 @@
+import { PathRange } from '../utils/PathRange';
+
+export type BlockPatternTrigger = 'enter' | 'space';
+
+export interface RawPattern {
+  start?: any;
+  end?: any;
+  format?: any;
+  cmd?: any;
+  value?: any;
+  replacement?: any;
+  trigger?: BlockPatternTrigger;
+}
+
+export interface PatternError {
+  readonly message: string;
+  readonly pattern: RawPattern;
+}
+
+interface InlineBasePattern {
+  readonly start: string;
+  readonly end: string;
+}
+
+export interface InlineFormatPattern extends InlineBasePattern {
+  readonly type: 'inline-format';
+  readonly format: string[];
+}
+
+export interface InlineCmdPattern extends InlineBasePattern {
+  readonly type: 'inline-command';
+  readonly cmd: string;
+  readonly value?: any;
+}
+
+export type InlinePattern = InlineFormatPattern | InlineCmdPattern;
+
+interface BlockBasePattern {
+  readonly start: string;
+  readonly trigger: BlockPatternTrigger;
+}
+
+export interface BlockFormatPattern extends BlockBasePattern {
+  readonly type: 'block-format';
+  readonly format: string;
+}
+
+export interface BlockCmdPattern extends BlockBasePattern {
+  readonly type: 'block-command';
+  readonly cmd: string;
+  readonly value?: any;
+}
+
+export type BlockPattern = BlockFormatPattern | BlockCmdPattern;
+
+export type Pattern = InlinePattern | BlockPattern;
+
+export interface DynamicPatternContext {
+  readonly text: string; // the string from the start of the block to the cursor
+  readonly block: Element; // the parent block element
+}
+
+export type DynamicPatternsLookup = (ctx: DynamicPatternContext) => Pattern[];
+export type RawDynamicPatternsLookup = (ctx: DynamicPatternContext) => RawPattern[];
+
+// NOTE: A PatternSet should be looked up from the Options *each* time that text_patterns are
+// processed, so that text_patterns respond to changes in options. This is required for some
+// complex integrations and plugins.
+export interface PatternSet {
+  readonly inlinePatterns: InlinePattern[];
+  readonly blockPatterns: BlockPattern[];
+  readonly dynamicPatternsLookup: DynamicPatternsLookup;
+}
+
+interface PatternMatch<T extends Pattern> {
+  readonly pattern: T;
+}
+
+export interface BlockPatternMatch extends PatternMatch<BlockPattern> {
+  readonly range: PathRange;
+}
+
+export interface InlinePatternMatch extends PatternMatch<InlinePattern> {
+  readonly startRng: PathRange;
+  readonly endRng: PathRange;
+}

package/src/core/main/ts/textpatterns/keyboard/KeyHandler.ts

@@ -0,0 +1,97 @@
+import { Fun, Unicode } from '@ephox/katamari';
+
+import * as TextSearch from '../../alien/TextSearch';
+import Editor from '../../api/Editor';
+import VK from '../../api/util/VK';
+import * as Zwsp from '../../text/Zwsp';
+import * as BlockPattern from '../core/BlockPattern';
+import * as BlockPatternOnSpace from '../core/BlockPatternOnSpace';
+import * as InlinePattern from '../core/InlinePattern';
+import { PatternSet } from '../core/PatternTypes';
+import * as Utils from '../utils/Utils';
+
+const handleEnter = (editor: Editor, patternSet: PatternSet): boolean =>
+  BlockPattern.getMatches(editor, patternSet).fold(
+    Fun.never,
+    ({ inlineMatches, blockMatches }) => {
+      editor.undoManager.add();
+      editor.undoManager.extra(
+        () => {
+          editor.execCommand('mceInsertNewLine');
+        },
+        () => {
+          // create a cursor position that we can move to avoid the inline formats
+          Zwsp.insert(editor);
+          InlinePattern.applyMatches(editor, inlineMatches);
+          BlockPattern.applyMatches(editor, blockMatches);
+          // find the spot before the cursor position
+          const range = editor.selection.getRng();
+          const spot = TextSearch.textBefore(range.startContainer, range.startOffset, editor.dom.getRoot());
+          editor.execCommand('mceInsertNewLine');
+          // clean up the cursor position we used to preserve the format
+          spot.each((s) => {
+            const node = s.container;
+            if (node.data.charAt(s.offset - 1) === Unicode.zeroWidth) {
+              node.deleteData(s.offset - 1, 1);
+              Utils.cleanEmptyNodes(editor.dom, node.parentNode, (e: Node) => e === editor.dom.getRoot());
+            }
+          });
+        }
+      );
+      return true;
+    });
+
+const handleInlineKey = (
+  editor: Editor,
+  patternSet: PatternSet
+): void => {
+  const rng = editor.selection.getRng();
+  Utils.getParentBlock(editor, rng).map((block) => {
+    const offset = Math.max(0, rng.startOffset - 1);
+    const beforeText = Utils.getBeforeText(editor.dom, block, rng.startContainer, offset);
+    const dynamicPatternSet = Utils.resolveFromDynamicPatterns(patternSet, block, beforeText);
+    const inlineMatches = InlinePattern.findPatterns(editor, block, rng.startContainer, offset, dynamicPatternSet, false);
+    if (inlineMatches.length > 0) {
+      editor.undoManager.transact(() => {
+        InlinePattern.applyMatches(editor, inlineMatches);
+      });
+    }
+  });
+};
+
+const handleBlockPatternOnSpace = (editor: Editor, patternSet: PatternSet): boolean =>
+  BlockPatternOnSpace.getMatches(editor, patternSet).fold(
+    Fun.never,
+    (matches) => {
+      editor.undoManager.transact(() => {
+        BlockPatternOnSpace.applyMatches(editor, matches);
+      });
+      return true;
+    });
+
+const checkKeyEvent = <T>(codes: T[], event: KeyboardEvent, predicate: (code: T, event: KeyboardEvent) => boolean): boolean => {
+  for (let i = 0; i < codes.length; i++) {
+    if (predicate(codes[i], event)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+const checkKeyCode = (codes: number[], event: KeyboardEvent): boolean =>
+  checkKeyEvent(codes, event, (code, event) => {
+    return code === event.keyCode && !VK.modifierPressed(event);
+  });
+
+const checkCharCode = (chars: string[], event: KeyboardEvent): boolean =>
+  checkKeyEvent(chars, event, (chr, event) => {
+    return chr.charCodeAt(0) === event.charCode;
+  });
+
+export {
+  handleEnter,
+  handleInlineKey,
+  handleBlockPatternOnSpace,
+  checkCharCode,
+  checkKeyCode
+};