@atlaskit/editor-plugin-code-block 0.1.0

package/CHANGELOG.md

@@ -0,0 +1 @@
+# @atlaskit/editor-plugin-code-block

package/LICENSE.md

@@ -0,0 +1,13 @@
+Copyright 2023 Atlassian Pty Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,30 @@
+# Editor plugin code block
+
+Code Block plugin for @atlaskit/editor-core
+
+**Note:** This component is designed for internal Atlassian development.
+External contributors will be able to use this component but will not be able to submit issues.
+
+## Install
+---
+- **Install** - *yarn add @atlaskit/editor-plugin-code-block*
+- **npm** - [@atlaskit/editor-plugin-code-block](https://www.npmjs.com/package/@atlaskit/editor-plugin-code-block)
+- **Source** - [Bitbucket](https://bitbucket.org/atlassian/atlassian-frontend/src/master/packages/editor/editor-plugin-code-block)
+- **Bundle** - [unpkg.com](https://unpkg.com/@atlaskit/editor-plugin-code-block/dist/)
+
+## Usage
+---
+**Internal use only**
+
+@atlaskit/editor-plugin-code-block is intended for internal use by the @atlaskit/editor-core and as a plugin dependency of the Editor within your product.
+
+Direct use of this component is not supported.
+
+Please see [Atlaskit - Editor plugin code block](https://atlaskit.atlassian.com/packages/editor/editor-plugin-code-block) for documentation and examples for this package.
+
+## Support
+---
+For internal Atlassian, visit the slack channel [#help-editor](https://atlassian.slack.com/archives/CFG3PSQ9E) for support or visit [go/editor-help](https://go/editor-help) to submit a bug.
+## License
+---
+ Please see [Atlassian Frontend - License](https://hello.atlassian.net/wiki/spaces/AF/pages/2589099144/Documentation#License) for more licensing information.

package/dist/cjs/actions.js

@@ -0,0 +1,201 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.copyContentToClipboard = exports.changeLanguage = void 0;
+exports.createInsertCodeBlockTransaction = createInsertCodeBlockTransaction;
+exports.ignoreFollowingMutations = void 0;
+exports.insertCodeBlockWithAnalytics = insertCodeBlockWithAnalytics;
+exports.resetShouldIgnoreFollowingMutations = exports.resetCopiedState = exports.removeCodeBlock = void 0;
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _clipboard = require("@atlaskit/editor-common/clipboard");
+var _editorAnalytics = require("@atlaskit/editor-common/editor-analytics");
+var _insert = require("@atlaskit/editor-common/insert");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _utils = require("@atlaskit/editor-prosemirror/utils");
+var _pluginKey = require("./plugin-key");
+var _actions = require("./pm-plugins/actions");
+var _codeBlockCopySelectionPlugin = require("./pm-plugins/codeBlockCopySelectionPlugin");
+var _transformToCodeBlock = require("./transform-to-code-block");
+var removeCodeBlock = exports.removeCodeBlock = function removeCodeBlock(state, dispatch) {
+  var nodes = state.schema.nodes,
+    tr = state.tr;
+  if (dispatch) {
+    var removeTr = tr;
+    if ((0, _utils.findSelectedNodeOfType)(nodes.codeBlock)(tr.selection)) {
+      removeTr = (0, _utils.removeSelectedNode)(tr);
+    } else {
+      removeTr = (0, _utils.removeParentNodeOfType)(nodes.codeBlock)(tr);
+    }
+    dispatch(removeTr);
+  }
+  return true;
+};
+var changeLanguage = exports.changeLanguage = function changeLanguage(editorAnalyticsAPI) {
+  return function (language) {
+    return function (state, dispatch) {
+      var _pluginKey$getState;
+      var codeBlock = state.schema.nodes.codeBlock;
+      var pos = (_pluginKey$getState = _pluginKey.pluginKey.getState(state)) === null || _pluginKey$getState === void 0 ? void 0 : _pluginKey$getState.pos;
+      if (typeof pos !== 'number') {
+        return false;
+      }
+      var tr = state.tr.setNodeMarkup(pos, codeBlock, {
+        language: language
+      }).setMeta('scrollIntoView', false);
+      var selection = (0, _utils.isNodeSelection)(state.selection) ? _state.NodeSelection.create(tr.doc, pos) : tr.selection;
+      var result = tr.setSelection(selection);
+      if (dispatch) {
+        editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent({
+          action: _analytics.ACTION.LANGUAGE_SELECTED,
+          actionSubject: _analytics.ACTION_SUBJECT.CODE_BLOCK,
+          attributes: {
+            language: language
+          },
+          eventType: _analytics.EVENT_TYPE.TRACK
+        })(result);
+        dispatch(result);
+      }
+      return true;
+    };
+  };
+};
+var copyContentToClipboard = exports.copyContentToClipboard = function copyContentToClipboard(state, dispatch) {
+  var nodes = state.schema.nodes,
+    tr = state.tr;
+  var codeBlock = (0, _utils.findParentNodeOfType)(nodes.codeBlock)(tr.selection);
+  var textContent = codeBlock && codeBlock.node.textContent;
+  if (textContent) {
+    (0, _clipboard.copyToClipboard)(textContent);
+    var copyToClipboardTr = tr;
+    copyToClipboardTr.setMeta(_pluginKey.pluginKey, {
+      type: _actions.ACTIONS.SET_COPIED_TO_CLIPBOARD,
+      data: true
+    });
+    copyToClipboardTr.setMeta(_codeBlockCopySelectionPlugin.copySelectionPluginKey, 'remove-selection');
+    if (dispatch) {
+      dispatch(copyToClipboardTr);
+    }
+  }
+  return true;
+};
+var resetCopiedState = exports.resetCopiedState = function resetCopiedState(state, dispatch) {
+  var tr = state.tr;
+  var codeBlockState = _pluginKey.pluginKey.getState(state);
+  var resetCopiedStateTr = tr;
+  if (codeBlockState && codeBlockState.contentCopied) {
+    resetCopiedStateTr.setMeta(_pluginKey.pluginKey, {
+      type: _actions.ACTIONS.SET_COPIED_TO_CLIPBOARD,
+      data: false
+    });
+    resetCopiedStateTr.setMeta(_codeBlockCopySelectionPlugin.copySelectionPluginKey, 'remove-selection');
+    if (dispatch) {
+      dispatch(resetCopiedStateTr);
+    }
+  } else {
+    var clearSelectionStateTransaction = state.tr;
+    clearSelectionStateTransaction.setMeta(_codeBlockCopySelectionPlugin.copySelectionPluginKey, 'remove-selection');
+    // note: dispatch should always be defined when called from the
+    // floating toolbar. Howver the Command type which floating toolbar uses
+    // (and resetCopiedState) uses suggests it's optional.
+    if (dispatch) {
+      dispatch(clearSelectionStateTransaction);
+    }
+  }
+  return true;
+};
+var ignoreFollowingMutations = exports.ignoreFollowingMutations = function ignoreFollowingMutations(state, dispatch) {
+  var tr = state.tr;
+  var ignoreFollowingMutationsTr = tr;
+  ignoreFollowingMutationsTr.setMeta(_pluginKey.pluginKey, {
+    type: _actions.ACTIONS.SET_SHOULD_IGNORE_FOLLOWING_MUTATIONS,
+    data: true
+  });
+  if (dispatch) {
+    dispatch(ignoreFollowingMutationsTr);
+  }
+  return true;
+};
+var resetShouldIgnoreFollowingMutations = exports.resetShouldIgnoreFollowingMutations = function resetShouldIgnoreFollowingMutations(state, dispatch) {
+  var tr = state.tr;
+  var ignoreFollowingMutationsTr = tr;
+  ignoreFollowingMutationsTr.setMeta(_pluginKey.pluginKey, {
+    type: _actions.ACTIONS.SET_SHOULD_IGNORE_FOLLOWING_MUTATIONS,
+    data: false
+  });
+  if (dispatch) {
+    dispatch(ignoreFollowingMutationsTr);
+  }
+  return true;
+};
+
+/**
+ * This function creates a new transaction that inserts a code block,
+ * if there is text selected it will wrap the current selection if not it will
+ * append the codeblock to the end of the document.
+ */
+function createInsertCodeBlockTransaction(_ref) {
+  var _state$selection$$fro;
+  var state = _ref.state;
+  var tr = state.tr;
+  var from = state.selection.from;
+  var codeBlock = state.schema.nodes.codeBlock;
+  var grandParentNodeType = (_state$selection$$fro = state.selection.$from.node(-1)) === null || _state$selection$$fro === void 0 ? void 0 : _state$selection$$fro.type;
+  var parentNodeType = state.selection.$from.parent.type;
+
+  /** We always want to append a codeBlock unless we're inserting into a paragraph
+   * AND it's a valid child of the grandparent node.
+   * Insert the current selection as codeBlock content unless it contains nodes other
+   * than paragraphs and inline.
+   */
+  var canInsertCodeBlock = (0, _insert.shouldSplitSelectedNodeOnNodeInsertion)({
+    parentNodeType: parentNodeType,
+    grandParentNodeType: grandParentNodeType,
+    content: codeBlock.createAndFill()
+  }) && contentAllowedInCodeBlock(state);
+  if (canInsertCodeBlock) {
+    tr = (0, _transformToCodeBlock.transformToCodeBlockAction)(state, from);
+  } else {
+    (0, _utils.safeInsert)(codeBlock.createAndFill())(tr).scrollIntoView();
+  }
+  return tr;
+}
+
+/**
+ * Check if the current selection contains any nodes that are not permitted
+ * as codeBlock child nodes. Note that this allows paragraphs and inline nodes
+ * as we extract their text content.
+ */
+function contentAllowedInCodeBlock(state) {
+  var _state$selection = state.selection,
+    $from = _state$selection.$from,
+    $to = _state$selection.$to;
+  var isAllowedChild = true;
+  state.doc.nodesBetween($from.pos, $to.pos, function (node) {
+    if (!isAllowedChild) {
+      return false;
+    }
+    return isAllowedChild = node.type === state.schema.nodes.listItem || node.type === state.schema.nodes.bulletList || node.type === state.schema.nodes.orderedList || node.type === state.schema.nodes.paragraph || node.isInline || node.isText;
+  });
+  return isAllowedChild;
+}
+function insertCodeBlockWithAnalytics(inputMethod, analyticsAPI) {
+  return (0, _editorAnalytics.withAnalytics)(analyticsAPI, {
+    action: _analytics.ACTION.INSERTED,
+    actionSubject: _analytics.ACTION_SUBJECT.DOCUMENT,
+    actionSubjectId: _analytics.ACTION_SUBJECT_ID.CODE_BLOCK,
+    attributes: {
+      inputMethod: inputMethod
+    },
+    eventType: _analytics.EVENT_TYPE.TRACK
+  })(function (state, dispatch) {
+    var tr = createInsertCodeBlockTransaction({
+      state: state
+    });
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return true;
+  });
+}

package/dist/cjs/ide-ux/bracket-handling.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shouldAutoCloseBracket = exports.getAutoClosingBracketInfo = exports.BRACKET_MAP = void 0;
+var BRACKET_MAP = exports.BRACKET_MAP = {
+  '{': '}',
+  '[': ']',
+  '(': ')'
+};
+var shouldAutoCloseBracket = exports.shouldAutoCloseBracket = function shouldAutoCloseBracket(before, after) {
+  // when directly before a closing bracket
+  if (/^[}\])]/.test(after)) {
+    return true;
+  }
+
+  // exclusion: when directly before a non-whitespace character
+  if (/^[^\s]/.test(after)) {
+    return false;
+  }
+  return true;
+};
+var getAutoClosingBracketInfo = exports.getAutoClosingBracketInfo = function getAutoClosingBracketInfo(before, after) {
+  var left = Object.keys(BRACKET_MAP).find(function (item) {
+    return before.endsWith(item);
+  });
+  var right = left ? BRACKET_MAP[left] : undefined;
+  var hasTrailingMatchingBracket = right ? after.startsWith(right) : false;
+  return {
+    left: left,
+    right: right,
+    hasTrailingMatchingBracket: hasTrailingMatchingBracket
+  };
+};

package/dist/cjs/ide-ux/commands.js

@@ -0,0 +1,115 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.indent = void 0;
+exports.insertIndent = insertIndent;
+exports.insertNewlineWithIndent = insertNewlineWithIndent;
+exports.outdent = void 0;
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _lineHandling = require("./line-handling");
+/**
+ * Return the current indentation level
+ * @param indentText - Text in the code block that represent an indentation
+ * @param indentSize - Size of the indentation token in a string
+ */
+function getIndentLevel(indentText, indentSize) {
+  if (indentSize === 0 || indentText.length === 0) {
+    return 0;
+  }
+  return indentText.length / indentSize;
+}
+var indent = exports.indent = function indent(editorAnalyticsAPI) {
+  return function (state, dispatch) {
+    var _getLinesFromSelectio = (0, _lineHandling.getLinesFromSelection)(state),
+      text = _getLinesFromSelectio.text,
+      start = _getLinesFromSelectio.start;
+    var tr = state.tr,
+      selection = state.selection;
+    (0, _lineHandling.forEachLine)(text, function (line, offset) {
+      var _getLineInfo = (0, _lineHandling.getLineInfo)(line),
+        indentText = _getLineInfo.indentText,
+        indentToken = _getLineInfo.indentToken;
+      var indentLevel = getIndentLevel(indentText, indentToken.size);
+      var indentToAdd = indentToken.token.repeat(indentToken.size - indentText.length % indentToken.size || indentToken.size);
+      tr.insertText(indentToAdd, tr.mapping.map(start + offset, -1));
+      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent({
+        action: _analytics.ACTION.FORMATTED,
+        actionSubject: _analytics.ACTION_SUBJECT.TEXT,
+        actionSubjectId: _analytics.ACTION_SUBJECT_ID.FORMAT_INDENT,
+        eventType: _analytics.EVENT_TYPE.TRACK,
+        attributes: {
+          inputMethod: _analytics.INPUT_METHOD.KEYBOARD,
+          previousIndentationLevel: indentLevel,
+          newIndentLevel: indentLevel + 1,
+          direction: _analytics.INDENT_DIRECTION.INDENT,
+          indentType: _analytics.INDENT_TYPE.CODE_BLOCK
+        }
+      })(tr);
+      if (!selection.empty) {
+        tr.setSelection(_state.TextSelection.create(tr.doc, tr.mapping.map(selection.from, -1), tr.selection.to));
+      }
+    });
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return true;
+  };
+};
+var outdent = exports.outdent = function outdent(editorAnalyticsAPI) {
+  return function (state, dispatch) {
+    var _getLinesFromSelectio2 = (0, _lineHandling.getLinesFromSelection)(state),
+      text = _getLinesFromSelectio2.text,
+      start = _getLinesFromSelectio2.start;
+    var tr = state.tr;
+    (0, _lineHandling.forEachLine)(text, function (line, offset) {
+      var _getLineInfo2 = (0, _lineHandling.getLineInfo)(line),
+        indentText = _getLineInfo2.indentText,
+        indentToken = _getLineInfo2.indentToken;
+      if (indentText) {
+        var indentLevel = getIndentLevel(indentText, indentToken.size);
+        var unindentLength = indentText.length % indentToken.size || indentToken.size;
+        tr.delete(tr.mapping.map(start + offset), tr.mapping.map(start + offset + unindentLength));
+        editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent({
+          action: _analytics.ACTION.FORMATTED,
+          actionSubject: _analytics.ACTION_SUBJECT.TEXT,
+          actionSubjectId: _analytics.ACTION_SUBJECT_ID.FORMAT_INDENT,
+          eventType: _analytics.EVENT_TYPE.TRACK,
+          attributes: {
+            inputMethod: _analytics.INPUT_METHOD.KEYBOARD,
+            previousIndentationLevel: indentLevel,
+            newIndentLevel: indentLevel - 1,
+            direction: _analytics.INDENT_DIRECTION.OUTDENT,
+            indentType: _analytics.INDENT_TYPE.CODE_BLOCK
+          }
+        })(tr);
+      }
+    });
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return true;
+  };
+};
+function insertIndent(state, dispatch) {
+  var _getStartOfCurrentLin = (0, _lineHandling.getStartOfCurrentLine)(state),
+    textAtStartOfLine = _getStartOfCurrentLin.text;
+  var _getLineInfo3 = (0, _lineHandling.getLineInfo)(textAtStartOfLine),
+    indentToken = _getLineInfo3.indentToken;
+  var indentToAdd = indentToken.token.repeat(indentToken.size - textAtStartOfLine.length % indentToken.size || indentToken.size);
+  dispatch(state.tr.insertText(indentToAdd));
+  return true;
+}
+function insertNewlineWithIndent(state, dispatch) {
+  var _getStartOfCurrentLin2 = (0, _lineHandling.getStartOfCurrentLine)(state),
+    textAtStartOfLine = _getStartOfCurrentLin2.text;
+  var _getLineInfo4 = (0, _lineHandling.getLineInfo)(textAtStartOfLine),
+    indentText = _getLineInfo4.indentText;
+  if (indentText && dispatch) {
+    dispatch(state.tr.insertText('\n' + indentText));
+    return true;
+  }
+  return false;
+}

package/dist/cjs/ide-ux/line-handling.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLineInfo = exports.getEndOfCurrentLine = exports.forEachLine = void 0;
+exports.getLinesFromSelection = getLinesFromSelection;
+exports.isSelectionEntirelyInsideCodeBlock = exports.isCursorInsideCodeBlock = exports.getStartOfCurrentLine = void 0;
+var _utils = require("../utils");
+var isSelectionEntirelyInsideCodeBlock = exports.isSelectionEntirelyInsideCodeBlock = function isSelectionEntirelyInsideCodeBlock(state) {
+  return state.selection.$from.sameParent(state.selection.$to) && state.selection.$from.parent.type === state.schema.nodes.codeBlock;
+};
+var isCursorInsideCodeBlock = exports.isCursorInsideCodeBlock = function isCursorInsideCodeBlock(state) {
+  return !!(0, _utils.getCursor)(state.selection) && isSelectionEntirelyInsideCodeBlock(state);
+};
+var getStartOfCurrentLine = exports.getStartOfCurrentLine = function getStartOfCurrentLine(state) {
+  var $from = state.selection.$from;
+  if ($from.nodeBefore && $from.nodeBefore.isText) {
+    var prevNewLineIndex = $from.nodeBefore.text.lastIndexOf('\n');
+    return {
+      text: $from.nodeBefore.text.substring(prevNewLineIndex + 1),
+      pos: $from.start() + prevNewLineIndex + 1
+    };
+  }
+  return {
+    text: '',
+    pos: $from.pos
+  };
+};
+var getEndOfCurrentLine = exports.getEndOfCurrentLine = function getEndOfCurrentLine(state) {
+  var $to = state.selection.$to;
+  if ($to.nodeAfter && $to.nodeAfter.isText) {
+    var nextNewLineIndex = $to.nodeAfter.text.indexOf('\n');
+    return {
+      text: $to.nodeAfter.text.substring(0, nextNewLineIndex >= 0 ? nextNewLineIndex : undefined),
+      pos: nextNewLineIndex >= 0 ? $to.pos + nextNewLineIndex : $to.end()
+    };
+  }
+  return {
+    text: '',
+    pos: $to.pos
+  };
+};
+function getLinesFromSelection(state) {
+  var _getStartOfCurrentLin = getStartOfCurrentLine(state),
+    start = _getStartOfCurrentLin.pos;
+  var _getEndOfCurrentLine = getEndOfCurrentLine(state),
+    end = _getEndOfCurrentLine.pos;
+  var text = state.doc.textBetween(start, end);
+  return {
+    text: text,
+    start: start,
+    end: end
+  };
+}
+var forEachLine = exports.forEachLine = function forEachLine(text, callback) {
+  var offset = 0;
+  text.split('\n').forEach(function (line) {
+    callback(line, offset);
+    offset += line.length + 1;
+  });
+};
+var SPACE = {
+  token: ' ',
+  size: 2,
+  regex: /[^ ]/
+};
+var TAB = {
+  token: '\t',
+  size: 1,
+  regex: /[^\t]/
+};
+var getLineInfo = exports.getLineInfo = function getLineInfo(line) {
+  var indentToken = line.startsWith('\t') ? TAB : SPACE;
+  var indentLength = line.search(indentToken.regex);
+  var indentText = line.substring(0, indentLength >= 0 ? indentLength : line.length);
+  return {
+    indentToken: indentToken,
+    indentText: indentText
+  };
+};

package/dist/cjs/ide-ux/paired-character-handling.js

@@ -0,0 +1,23 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isCursorBeforeClosingCharacter = exports.isClosingCharacter = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _bracketHandling = require("./bracket-handling");
+var _quoteHandling = require("./quote-handling");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var PAIRED_CHARACTER_MAP = _objectSpread(_objectSpread({}, _bracketHandling.BRACKET_MAP), _quoteHandling.QUOTE_MAP);
+var isCursorBeforeClosingCharacter = exports.isCursorBeforeClosingCharacter = function isCursorBeforeClosingCharacter(after) {
+  return Object.keys(PAIRED_CHARACTER_MAP).some(function (leftCharacter) {
+    return after.startsWith(PAIRED_CHARACTER_MAP[leftCharacter]);
+  });
+};
+var isClosingCharacter = exports.isClosingCharacter = function isClosingCharacter(text) {
+  return Object.keys(PAIRED_CHARACTER_MAP).some(function (leftCharacter) {
+    return text === PAIRED_CHARACTER_MAP[leftCharacter];
+  });
+};

package/dist/cjs/ide-ux/quote-handling.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shouldAutoCloseQuote = exports.getAutoClosingQuoteInfo = exports.QUOTE_MAP = void 0;
+var QUOTE_MAP = exports.QUOTE_MAP = {
+  "'": "'",
+  '"': '"',
+  '`': '`'
+};
+var shouldAutoCloseQuote = exports.shouldAutoCloseQuote = function shouldAutoCloseQuote(before, after) {
+  // when directly before a closing bracket
+  if (/^[}\])]/.test(after)) {
+    return true;
+  }
+
+  // exclusion: when directly before a non-whitespace character
+  if (/^[^\s]/.test(after)) {
+    return false;
+  }
+
+  // exclusion: when directly after a letter or quote
+  if (/[A-Za-z0-9]$/.test(before) || /[\'\"\`]$/.test(before)) {
+    return false;
+  }
+  return true;
+};
+var getAutoClosingQuoteInfo = exports.getAutoClosingQuoteInfo = function getAutoClosingQuoteInfo(before, after) {
+  var left = Object.keys(QUOTE_MAP).find(function (item) {
+    return before.endsWith(item);
+  });
+  var right = left ? QUOTE_MAP[left] : undefined;
+  var hasTrailingMatchingQuote = right ? after.startsWith(right) : false;
+  return {
+    left: left,
+    right: right,
+    hasTrailingMatchingQuote: hasTrailingMatchingQuote
+  };
+};

package/dist/cjs/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "codeBlockPlugin", {
+  enumerable: true,
+  get: function get() {
+    return _plugin.default;
+  }
+});
+var _plugin = _interopRequireDefault(require("./plugin"));

package/dist/cjs/language-list.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_LANGUAGES = void 0;
+exports.createLanguageList = createLanguageList;
+exports.filterSupportedLanguages = filterSupportedLanguages;
+exports.findMatchedLanguage = findMatchedLanguage;
+exports.getLanguageIdentifier = getLanguageIdentifier;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _constants = require("@atlaskit/code/constants");
+// We expect alias[0] to be used for the ADF attribute, see ED-2813
+var DEFAULT_LANGUAGES = exports.DEFAULT_LANGUAGES = [{
+  name: '(None)',
+  alias: ['none'],
+  value: 'none'
+}].concat((0, _toConsumableArray2.default)(_constants.SUPPORTED_LANGUAGES));
+function findMatchedLanguage(supportedLanguages, language) {
+  if (!language) {
+    return undefined;
+  }
+  var matches = supportedLanguages.filter(function (supportedLanguage) {
+    return supportedLanguage.alias.indexOf(language.toLowerCase()) !== -1;
+  });
+  if (matches.length > 0) {
+    return matches[0];
+  }
+  return undefined;
+}
+function filterSupportedLanguages(supportedLanguages) {
+  if (!supportedLanguages || !supportedLanguages.length) {
+    return DEFAULT_LANGUAGES;
+  }
+  return DEFAULT_LANGUAGES.filter(function (language) {
+    var i = language.alias.length;
+    while (i--) {
+      if (supportedLanguages.indexOf(language.alias[i]) > -1) {
+        return true;
+      }
+    }
+    return false;
+  });
+}
+function getLanguageIdentifier(language) {
+  return language.alias[0];
+}
+function createLanguageList(supportedLanguages) {
+  return supportedLanguages.sort(function (left, right) {
+    if (left.alias[0] === 'none') {
+      return -1;
+    }
+    if (left.name.toLowerCase() > right.name.toLowerCase()) {
+      return 1;
+    }
+    if (left.name.toLowerCase() < right.name.toLowerCase()) {
+      return -1;
+    }
+    return 0;
+  });
+}