@atlaskit/editor-wikimarkup-transformer 9.5.3

package/dist/esm/parser/utils/escape.js

@@ -0,0 +1,28 @@
+/**
+ * In Jira, following characters are escaped
+ * private static final Pattern ESCAPING_PATTERN = Pattern.compile("(^|(?<!\\\\))\\\\([\\-\\#\\*\\_\\+\\?\\^\\~\\|\\%\\{\\}\\[\\]\\(\\)\\!\\@])");
+ * https://stash.atlassian.com/projects/JIRACLOUD/repos/jira/browse/jira-components/jira-renderer/src/main/java/com/atlassian/renderer/v2/components/BackslashEscapeRendererComponent.java
+ */
+var escapedChar = ['-', '#', '*', '_', '+', '?', '^', '~', '|', '%', '{', '}', '[', ']', '(', ')', '!', '@'];
+export function escapeHandler(input, position) {
+  var buffer = [];
+  var char = input.charAt(position);
+  var prevChar = input.charAt(position - 1);
+  var nextChar = input.charAt(position + 1);
+  /**
+   * Ported from Jira:
+   * If previous char is also a backslash, then this is not a valid escape
+   */
+
+  if (escapedChar.indexOf(nextChar) === -1 || prevChar === '\\') {
+    // Insert \ in buffer mode
+    buffer.push(char);
+  }
+
+  buffer.push(nextChar);
+  return {
+    type: 'text',
+    text: buffer.join(''),
+    length: 2
+  };
+}

package/dist/esm/parser/utils/normalize.js

@@ -0,0 +1,195 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+import { createParagraphNodeFromInlineNodes, createEmptyParagraphNode } from '../nodes/paragraph';
+export function normalizePMNodes(nodes, schema) {
+  return [normalizeMediaGroups, normalizeInlineNodes].reduce(function (currentNodes, normFunc) {
+    return normFunc(currentNodes, schema);
+  }, nodes);
+}
+export function normalizeInlineNodes(nodes, schema) {
+  var output = [];
+  var inlineNodeBuffer = [];
+
+  var _iterator = _createForOfIteratorHelper(nodes),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var node = _step.value;
+
+      if (!node.isBlock) {
+        inlineNodeBuffer.push(node);
+        continue;
+      }
+
+      var _trimedInlineNodes = trimInlineNodes(inlineNodeBuffer);
+
+      if (_trimedInlineNodes.length > 0) {
+        output.push.apply(output, _toConsumableArray(createParagraphNodeFromInlineNodes(_trimedInlineNodes, schema)));
+      }
+
+      inlineNodeBuffer = []; // clear buffer
+
+      output.push(node);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  var trimedInlineNodes = trimInlineNodes(inlineNodeBuffer);
+
+  if (trimedInlineNodes.length > 0) {
+    output.push.apply(output, _toConsumableArray(createParagraphNodeFromInlineNodes(trimedInlineNodes, schema)));
+  }
+
+  if (output.length === 0) {
+    return [createEmptyParagraphNode(schema)];
+  }
+
+  return output;
+}
+/**
+ * Normalize the list of the given nodes for media groups.
+ * The rule is: if there are consecutive media group nodes (each with a single child media
+ * node) separated by any space or a single newline, then merge them into one media group
+ * with multiple child media nodes.
+ * @param nodes list of nodes to normalize. Must not be null
+ * @param schema
+ */
+
+function normalizeMediaGroups(nodes, schema) {
+  var output = [];
+  var mediaGroupBuffer = [];
+  var separatorBuffer = [];
+
+  var _iterator2 = _createForOfIteratorHelper(nodes),
+      _step2;
+
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var n = _step2.value;
+
+      if (n.type.name === 'mediaGroup' && n.childCount === 1) {
+        mediaGroupBuffer.push(n); //separator buffer keeps track of the seperator(s) between each mediaGroup nodes,
+        //so needs resetting every time we encounter a new mediaGroup node
+
+        separatorBuffer = [];
+        continue;
+      }
+
+      if (mediaGroupBuffer.length > 0) {
+        if (isSignificantSeparatorNode(n, separatorBuffer)) {
+          output.push(createMergedMediaGroup(mediaGroupBuffer, schema));
+          output.push.apply(output, _toConsumableArray(separatorBuffer));
+          output.push(n);
+          mediaGroupBuffer = [];
+          separatorBuffer = [];
+        } else {
+          separatorBuffer.push(n);
+        }
+
+        continue;
+      }
+
+      output.push(n);
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+
+  if (mediaGroupBuffer.length > 0) {
+    output.push(createMergedMediaGroup(mediaGroupBuffer, schema));
+  } // Dump everything else from separator buffer if anything is left
+
+
+  output.push.apply(output, _toConsumableArray(separatorBuffer));
+  return output;
+}
+/**
+ * Creates a single mediaGroup whose children are the single media elements from the given mediaGroupNodes.
+ * @param mediaGroupNodes list of mediaGroups that have a single child each
+ * @param schema the schema
+ */
+
+
+function createMergedMediaGroup(mediaGroupNodes, schema) {
+  var mediaGroup = schema.nodes.mediaGroup;
+  var mediaNodes = mediaGroupNodes.map(function (v) {
+    return v.child(0);
+  });
+  return mediaGroup.createChecked({}, mediaNodes);
+}
+
+function isSignificantSeparatorNode(n, separatorBuffer) {
+  return isHardBreak(n, separatorBuffer) || !isEmptyTextNode(n) || isMediaGroupWithMultipleChildren(n);
+}
+/**
+ * Existing media groups with more than one child is considered as a significant separator.
+ */
+
+
+function isMediaGroupWithMultipleChildren(n) {
+  return n.type.name === 'mediaGroup' && n.childCount > 1;
+}
+/**
+ * If the current node is a hard break, AND there's already at least
+ * one hard break in the separator buffer, then we want to return true.
+ * @param n the current node to examine
+ * @param separatorBuffer the existing separator buffer.
+ */
+
+
+function isHardBreak(n, separatorBuffer) {
+  return n.type.name === 'hardBreak' && separatorBuffer.map(function (v) {
+    return v.type.name;
+  }).indexOf('hardBreak') !== -1;
+}
+
+function isEmptyTextNode(n) {
+  return n.textContent !== undefined && n.textContent.trim().length === 0;
+}
+/**
+ * Remove leading and trailing hardBreak
+ */
+
+
+function trimInlineNodes(nodes) {
+  var leadingNode = nodes.shift();
+
+  while (leadingNode) {
+    if (leadingNode.type.name !== 'hardBreak') {
+      nodes.unshift(leadingNode);
+      break;
+    }
+
+    leadingNode = nodes.shift();
+  }
+
+  var trailingNode = nodes.pop();
+
+  while (trailingNode) {
+    if (trailingNode.type.name !== 'hardBreak') {
+      nodes.push(trailingNode);
+      break;
+    }
+
+    trailingNode = nodes.pop();
+  }
+
+  return nodes;
+}
+
+export function isNextLineEmpty(input) {
+  // Line with only spaces is considered an empty line
+  return input.trim().length === 0;
+}

package/dist/esm/parser/utils/panel-type.js

@@ -0,0 +1,109 @@
+import colorNameMapping from './color-name-mapping';
+var COLOR_TYPE_REGEX = {
+  hexShort: /^#?([a-f\d])([a-f\d])([a-f\d])$/i,
+  hexLong: /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i,
+  rgb: /^#?rgb\((\d+),\s*(\d+),\s*(\d+)\)$/,
+  prgb: /^#?rgb\((\d+)%,\s*(\d+)%,\s*(\d+)%\)$/
+};
+var PANEL_TYPE_TO_RGB = {
+  info: {
+    r: 222,
+    g: 235,
+    b: 255
+  },
+  note: {
+    r: 234,
+    g: 230,
+    b: 255
+  },
+  success: {
+    r: 227,
+    g: 252,
+    b: 239
+  },
+  warning: {
+    r: 255,
+    g: 250,
+    b: 230
+  },
+  error: {
+    r: 255,
+    g: 235,
+    b: 230
+  }
+};
+export function getPanelType(attrs) {
+  var rgb = generateRgb(attrs.bgColor);
+
+  if (!rgb) {
+    return 'info';
+  }
+
+  var mapTo = 'info';
+  var smallestDistance = Infinity;
+  Object.keys(PANEL_TYPE_TO_RGB).forEach(function (panelType) {
+    var distance = distanceOfRgb(PANEL_TYPE_TO_RGB[panelType], rgb);
+
+    if (distance < smallestDistance) {
+      smallestDistance = distance;
+      mapTo = panelType;
+    }
+  });
+  return mapTo;
+}
+
+function distanceOfRgb(a, b) {
+  // https://en.wikipedia.org/wiki/Color_difference
+  return Math.pow(a.r - b.r, 2) + Math.pow(a.g - b.g, 2) + Math.pow(a.b - b.b, 2);
+}
+
+function generateRgb(color) {
+  switch (true) {
+    case COLOR_TYPE_REGEX.hexShort.test(color) || COLOR_TYPE_REGEX.hexLong.test(color):
+      return parseHex(color);
+
+    case COLOR_TYPE_REGEX.rgb.test(color):
+      return parseRgb(color);
+
+    case COLOR_TYPE_REGEX.prgb.test(color):
+      return parsePrgb(color);
+
+    default:
+      return parseColorName(color);
+  }
+}
+
+function parseHex(hex) {
+  // Expand shorthand form (e.g. "03F") to full form (e.g. "0033FF")
+  hex = hex.replace(COLOR_TYPE_REGEX.hexShort, function (_m, r, g, b) {
+    return r + r + g + g + b + b;
+  });
+  var result = COLOR_TYPE_REGEX.hexLong.exec(hex);
+  return result ? {
+    r: parseInt(result[1], 16),
+    g: parseInt(result[2], 16),
+    b: parseInt(result[3], 16)
+  } : null;
+}
+
+function parseRgb(rgb) {
+  var result = rgb.match(COLOR_TYPE_REGEX.rgb);
+  return result ? {
+    r: parseInt(result[1], 10),
+    g: parseInt(result[2], 10),
+    b: parseInt(result[3], 10)
+  } : null;
+}
+
+function parsePrgb(prgb) {
+  var result = prgb.match(COLOR_TYPE_REGEX.prgb);
+  return result ? {
+    r: Math.floor(255 * parseInt(result[1], 10) / 100),
+    g: Math.floor(255 * parseInt(result[2], 10) / 100),
+    b: Math.floor(255 * parseInt(result[4], 10) / 100)
+  } : null;
+}
+
+function parseColorName(color) {
+  return colorNameMapping[color];
+}

package/dist/esm/parser/utils/text.js

@@ -0,0 +1,81 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+
+/**
+ * Check if the node has certain marks
+ */
+export function hasAnyOfMarks(node, types) {
+  return node.marks.findIndex(function (m) {
+    return types.findIndex(function (t) {
+      return m.type.name === t;
+    }) !== -1;
+  }) !== -1;
+}
+export function isDigit(value) {
+  return !!value.match(/^\d$/);
+}
+export function isBlank(value) {
+  return value === null || value.trim() === '';
+}
+export function isNotBlank(value) {
+  return !isBlank(value);
+} // TODO This is using strings which makes it potentially a performance bottleneck
+
+export var StringBuffer = /*#__PURE__*/function () {
+  function StringBuffer() {
+    var buffer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+
+    _classCallCheck(this, StringBuffer);
+
+    this.buffer = buffer;
+  }
+
+  _createClass(StringBuffer, [{
+    key: "indexOf",
+    value: function indexOf(value) {
+      return this.buffer.indexOf(value);
+    }
+  }, {
+    key: "lastIndexOf",
+    value: function lastIndexOf(value) {
+      return this.buffer.lastIndexOf(value);
+    }
+  }, {
+    key: "charAt",
+    value: function charAt(index) {
+      return this.buffer.charAt(index);
+    }
+  }, {
+    key: "length",
+    value: function length() {
+      return this.buffer.length;
+    }
+  }, {
+    key: "delete",
+    value: function _delete(start, end) {
+      this.buffer = this.buffer.substring(0, start) + this.buffer.substring(end);
+    }
+  }, {
+    key: "append",
+    value: function append(value) {
+      this.buffer += value;
+    }
+  }, {
+    key: "substring",
+    value: function substring(start, end) {
+      return this.buffer.substring(start, end);
+    }
+  }, {
+    key: "deleteCharAt",
+    value: function deleteCharAt(index) {
+      this.delete(index, index + 1);
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return this.buffer;
+    }
+  }]);
+
+  return StringBuffer;
+}();

package/dist/esm/parser/utils/title.js

@@ -0,0 +1,10 @@
+/**
+ * This will return ADF to replace the titles in some macro
+ * For example
+ * {panel:title}aaa{panel}
+ */
+export function title(text, schema) {
+  var mark = schema.marks.strong.create();
+  var title = schema.text(text, [mark]);
+  return schema.nodes.paragraph.createChecked({}, [title]);
+}

package/dist/esm/parser/utils/url.js

@@ -0,0 +1,24 @@
+/**
+ * returns a correctly percent-encoded & sanitized url.
+ * Will fallback to using a DOM based implementation if the `URL` class
+ * doesn't exist.
+ *
+ * @param raw a 'raw' url (possibly mixed percent-encoded).
+ */
+export function decode(raw) {
+  if (typeof URL === 'function') {
+    var decoded = new URL(raw); // IE11 doesn't support the `href` property in the `URL` class.
+    // Fallback to the DOM below if it doesn't exist.
+
+    if (decoded.href) {
+      return decoded.href;
+    }
+  } // no `URL` class - pollyfill using the dom to parse and
+  // decode. This should only be needed for IE11 or lower...
+
+
+  var anchor = document.createElement('a');
+  anchor.href = raw; // The DOM will parses even mixed %-encoded segments of a url when set.
+
+  return anchor.href;
+}