@atlaskit/editor-wikimarkup-transformer 9.5.3

package/dist/esm/encoder/nodes/mention.js

@@ -0,0 +1,19 @@
+var PREFIX = 'accountid:';
+var UNKNOWN_USER = 'UNKNOWN_USER';
+
+var addPrefix = function addPrefix(content) {
+  return content.toLowerCase().startsWith(PREFIX) ? content : "".concat(PREFIX).concat(content);
+};
+
+export var mention = function mention(node) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      context = _ref.context;
+
+  if (node.attrs.id === UNKNOWN_USER) {
+    return "[~".concat(node.attrs.id, "]");
+  }
+
+  var mentionKey = node.attrs.id.toLowerCase();
+  var content = context && context.conversion && context.conversion.mentionConversion && context.conversion.mentionConversion[mentionKey] ? context.conversion.mentionConversion[mentionKey] : addPrefix(node.attrs.id);
+  return "[~".concat(content, "]");
+};

package/dist/esm/encoder/nodes/ordered-list.js

@@ -0,0 +1,11 @@
+import { listItem } from './listItem';
+export var orderedList = function orderedList(node) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      context = _ref.context;
+
+  var result = [];
+  node.forEach(function (item) {
+    result.push(listItem(item, '#', context));
+  });
+  return result.join('\n');
+};

package/dist/esm/encoder/nodes/panel.js

@@ -0,0 +1,18 @@
+import { encode } from '..';
+var panelTypeColorMapping = {
+  info: '#deebff',
+  note: '#eae6ff',
+  success: '#e3fcef',
+  warning: '#fffae6',
+  error: '#ffebe6'
+};
+export var panel = function panel(node) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      context = _ref.context;
+
+  var result = [];
+  node.forEach(function (n) {
+    result.push(encode(n, context));
+  });
+  return "{panel:bgColor=".concat(panelTypeColorMapping[node.attrs.panelType] || '', "}\n").concat(result.join('\n\n'), "\n{panel}");
+};

package/dist/esm/encoder/nodes/paragraph.js

@@ -0,0 +1,13 @@
+import { inlines } from './inlines';
+export var paragraph = function paragraph(node) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      context = _ref.context;
+
+  var result = '';
+  node.forEach(function (n) {
+    result += inlines(n, {
+      context: context
+    });
+  });
+  return result;
+};

package/dist/esm/encoder/nodes/rule.js

@@ -0,0 +1,3 @@
+export var rule = function rule(_node) {
+  return '----';
+};

package/dist/esm/encoder/nodes/status.js

@@ -0,0 +1,29 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+import { textColor } from '../marks/color';
+import { N80, P300, T300, R300, Y400, G300 } from '@atlaskit/theme/colors';
+var color = {
+  grey: N80,
+  purple: P300,
+  blue: T300,
+  red: R300,
+  yellow: Y400,
+  green: G300
+};
+export var status = function status(node) {
+  var text = "*[ ".concat(node.attrs.text.toUpperCase(), " ]*");
+
+  var newAttrs = _objectSpread({}, node.attrs);
+
+  if (color[node.attrs.color]) {
+    newAttrs.color = color[node.attrs.color];
+  } else {
+    newAttrs.color = color['grey'];
+  }
+
+  return textColor(text, newAttrs);
+};

package/dist/esm/encoder/nodes/table.js

@@ -0,0 +1,66 @@
+import { encode } from '..';
+import { unknown } from './unknown';
+export var table = function table(node) {
+  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  try {
+    var result = [];
+    node.forEach(function (n) {
+      result.push(tableRow(n, opts));
+    });
+    return result.join('\n');
+  } catch (err) {
+    return unknown(node);
+  }
+};
+
+var tableRow = function tableRow(node) {
+  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var result = '';
+  var separator = '|';
+  node.forEach(function (n) {
+    if (n.type.name === 'tableHeader') {
+      separator = '||';
+    } else {
+      separator = '|';
+    }
+
+    result = "".concat(result).concat(separator).concat(tableCell(n, opts));
+  });
+  return "".concat(result).concat(separator);
+};
+
+var tableCell = function tableCell(node) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      context = _ref.context;
+
+  if (hasMergedCell(node)) {
+    // This is an advanced table
+    throw new Error('Advanced feature of table is not supported');
+  }
+
+  var result = [];
+  node.forEach(function (n) {
+    result.push(encode(n, context));
+  });
+  var output = result.join('\n').trim(); // Return single whitespace if content of cell is empty
+  // to preserve correct empty cell rendering in wiki
+
+  return output === '' ? ' ' : output;
+};
+
+var hasMergedCell = function hasMergedCell(node) {
+  if (!node.attrs) {
+    return false;
+  }
+
+  if (node.attrs.colspan && node.attrs.colspan !== 1) {
+    return true;
+  }
+
+  if (node.attrs.rowspan && node.attrs.rowspan !== 1) {
+    return true;
+  }
+
+  return false;
+};

package/dist/esm/encoder/nodes/taskItem.js

@@ -0,0 +1,22 @@
+import { inlines } from './inlines';
+export var taskItem = function taskItem(node, nestedLevel) {
+  var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+      context = _ref.context;
+
+  var result = '';
+  node.forEach(function (n) {
+    // Generate stars based on depth
+    var prefix = Array(nestedLevel).fill('*').join('');
+
+    if (node.attrs.state === 'DONE') {
+      result += "".concat(prefix, " -").concat(inlines(n, {
+        context: context
+      }), "-");
+    } else {
+      result += "".concat(prefix, " ").concat(inlines(n, {
+        context: context
+      }));
+    }
+  });
+  return result;
+};

package/dist/esm/encoder/nodes/taskList.js

@@ -0,0 +1,18 @@
+import { taskItem } from './taskItem';
+
+var nestedNode = function nestedNode(node) {
+  var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  var result = [];
+  node.forEach(function (item) {
+    if (item.type.name === 'taskList') {
+      result.push(nestedNode(item, depth + 1));
+    } else {
+      result.push(taskItem(item, depth));
+    }
+  });
+  return result.join('\n');
+};
+
+export var taskList = function taskList(node) {
+  return nestedNode(node);
+};

package/dist/esm/encoder/nodes/text.js

@@ -0,0 +1,51 @@
+import { code } from '../marks/code';
+import { textColor } from '../marks/color';
+import { em } from '../marks/em';
+import { link } from '../marks/link';
+import { strike } from '../marks/strike';
+import { strong } from '../marks/strong';
+import { subsup } from '../marks/subsup';
+import { underline } from '../marks/underline';
+/**
+ * The order of the mapping matters.
+ * For example, textColor will be a macro {color} so
+ * we want to process other marks before it.
+ */
+
+var markEncoderMapping = new Map([['em', em], ['strike', strike], ['strong', strong], ['subsup', subsup], ['underline', underline], ['textColor', textColor], ['link', link], ['code', code]]);
+/**
+ * Checks if the node's content needs to be escaped before continuing processing.
+ * Currently, the `code` mark and `codeBlock` nodes handle their own escaping, and
+ * therefore, should not be escaped here.
+ *
+ * @param node the current node to encode
+ * @param parent the parent node, if exist
+ * @returns true if the node should have its text escaped when encoding to wikimarkup.
+ */
+
+var isEscapeNeeded = function isEscapeNeeded(node, parent) {
+  return !(parent && parent.type.name === 'codeBlock' || node.marks.find(function (m) {
+    return m.type.name === 'code';
+  }) !== undefined);
+};
+
+function escapingWikiFormatter(text) {
+  return text.replace(/[{\\![]/g, '\\$&');
+}
+
+export var text = function text(node) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      parent = _ref.parent;
+
+  var result = isEscapeNeeded(node, parent) ? escapingWikiFormatter(node.text) : node.text;
+  markEncoderMapping.forEach(function (encoder, markName) {
+    var mark = node.marks.find(function (m) {
+      return m.type.name === markName;
+    });
+
+    if (mark) {
+      result = encoder(result, mark.attrs);
+    }
+  });
+  return result;
+};

package/dist/esm/encoder/nodes/unknown.js

@@ -0,0 +1,6 @@
+import { JSONTransformer } from '@atlaskit/editor-json-transformer';
+var jsonTransformer = new JSONTransformer();
+export var unknown = function unknown(node) {
+  var content = JSON.stringify(jsonTransformer.encodeNode(node));
+  return node.isBlock ? "{adf:display=block}\n".concat(content, "\n{adf}") : "{adf:display=inline}".concat(content, "{adf}");
+};

package/dist/esm/index.js

@@ -0,0 +1,78 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+import { defaultSchema } from '@atlaskit/adf-schema';
+import { encode as _encode } from './encoder';
+import AbstractTree from './parser/abstract-tree';
+import { buildIssueKeyRegex } from './parser/tokenize/issue-key';
+export var WikiMarkupTransformer = /*#__PURE__*/function () {
+  function WikiMarkupTransformer() {
+    var schema = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultSchema;
+
+    _classCallCheck(this, WikiMarkupTransformer);
+
+    this.schema = schema;
+  } // [ADFS-725] Jira breaks if there are null chars it is easier to remove them here
+  // The following has to be a regex to remove all instances of null instead of the first
+
+
+  _createClass(WikiMarkupTransformer, [{
+    key: "sanitizeWikiMarkup",
+    value: function sanitizeWikiMarkup(wikiMarkup) {
+      return wikiMarkup.replace(/\0/g, '');
+    }
+  }, {
+    key: "encode",
+    value: function encode(node, context) {
+      var wikiMarkup = _encode(node, normalizeContextObject(context)); // [ADFS-725] Jira breaks if there are null chars it is easier to remove them here
+
+
+      var sanitizedWikiMarkup = this.sanitizeWikiMarkup(wikiMarkup);
+      return sanitizedWikiMarkup;
+    }
+  }, {
+    key: "parse",
+    value: function parse(wikiMarkup, context) {
+      // [ADFS-725] Jira breaks if there are null chars it is easier to remove them here
+      var sanitizedWikiMarkup = this.sanitizeWikiMarkup(wikiMarkup);
+      var tree = new AbstractTree(this.schema, sanitizedWikiMarkup);
+      return tree.getProseMirrorModel(this.buildContext(normalizeContextObject(context)));
+    }
+  }, {
+    key: "buildContext",
+    value: function buildContext(context) {
+      return context ? _objectSpread(_objectSpread({}, context), {}, {
+        issueKeyRegex: context.conversion ? buildIssueKeyRegex(context.conversion.inlineCardConversion) : undefined
+      }) : {};
+    }
+  }]);
+
+  return WikiMarkupTransformer;
+}();
+/**
+ * Turns mentionConversion object keys to lowercase for case insensitivity matching
+ * This is okay, because conversion context object contains mapping and that should be case insensitive
+ */
+
+var normalizeContextObject = function normalizeContextObject(context) {
+  if (!context || !context.conversion || !context.conversion.mentionConversion) {
+    // nothing to normalize, return original object
+    return context;
+  }
+
+  var mentionConversion = {};
+
+  for (var key in context.conversion.mentionConversion) {
+    mentionConversion[key.toLowerCase()] = context.conversion.mentionConversion[key];
+  }
+
+  context.conversion.mentionConversion = mentionConversion;
+  return context;
+};
+
+export default WikiMarkupTransformer;

package/dist/esm/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/parser/abstract-tree.js

@@ -0,0 +1,34 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import { parseString } from './text';
+import { normalizePMNodes } from './utils/normalize';
+
+var AbstractTree = /*#__PURE__*/function () {
+  function AbstractTree(schema, wikiMarkup) {
+    _classCallCheck(this, AbstractTree);
+
+    this.schema = schema;
+    this.wikiMarkup = wikiMarkup;
+  }
+  /**
+   * Convert reduced macros tree into prosemirror model tree
+   */
+
+
+  _createClass(AbstractTree, [{
+    key: "getProseMirrorModel",
+    value: function getProseMirrorModel(context) {
+      var content = parseString({
+        context: context,
+        ignoreTokenTypes: [],
+        input: this.wikiMarkup,
+        schema: this.schema
+      });
+      return this.schema.nodes.doc.createChecked({}, normalizePMNodes(content, this.schema));
+    }
+  }]);
+
+  return AbstractTree;
+}();
+
+export { AbstractTree as default };

package/dist/esm/parser/builder/list-builder.js

@@ -0,0 +1,338 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+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; }
+
+var supportedContentType = ['paragraph', 'orderedList', 'bulletList', 'mediaSingle', 'codeBlock'];
+/**
+ * Return the type of a list from the bullets
+ */
+
+export function getType(bullets) {
+  return /#$/.test(bullets) ? 'orderedList' : 'bulletList';
+}
+export var ListBuilder = /*#__PURE__*/function () {
+  function ListBuilder(schema, bullets) {
+    var _this = this;
+
+    _classCallCheck(this, ListBuilder);
+
+    _defineProperty(this, "parseList", function (list) {
+      var listNode = _this.schema.nodes[list.type];
+      var output = [];
+      var listItemsBuffer = [];
+
+      for (var i = 0; i < list.children.length; i++) {
+        var parsedContent = _this.parseListItem(list.children[i]);
+
+        for (var j = 0; j < parsedContent.length; j++) {
+          var parsedNode = parsedContent[j];
+
+          if (parsedNode.type.name === 'listItem') {
+            listItemsBuffer.push(parsedNode);
+            continue;
+          }
+          /**
+           * If the node is not a listItem, then we need to
+           * wrap exisintg list and break out
+           */
+
+
+          if (listItemsBuffer.length) {
+            var _list = listNode.createChecked({}, listItemsBuffer);
+
+            output.push(_list);
+          }
+
+          output.push(parsedNode); // This is the break out node
+
+          listItemsBuffer = [];
+        }
+      }
+
+      if (listItemsBuffer.length) {
+        var _list2 = listNode.createChecked({}, listItemsBuffer);
+
+        output.push(_list2);
+      }
+
+      return output;
+    });
+
+    _defineProperty(this, "parseListItem", function (item) {
+      var _item$content;
+
+      var output = [];
+
+      if (!item.content) {
+        item.content = [];
+      } // Parse nested list
+
+
+      var parsedChildren = item.children.reduce(function (result, list) {
+        var parsedList = _this.parseList(list);
+
+        result.push.apply(result, _toConsumableArray(parsedList));
+        return result;
+      }, []); // Append children to the content
+
+      (_item$content = item.content).push.apply(_item$content, _toConsumableArray(parsedChildren));
+
+      var contentBuffer = [];
+
+      for (var i = 0; i < item.content.length; i++) {
+        var pmNode = item.content[i];
+        /**
+         * Skip empty paragraph
+         */
+
+        if (pmNode.type.name === 'paragraph' && pmNode.childCount === 0) {
+          continue;
+        }
+        /* Skip Empty spaces after rule */
+
+
+        if (_this.isParagraphEmptyTextNode(pmNode)) {
+          continue;
+        }
+
+        if (supportedContentType.indexOf(pmNode.type.name) === -1) {
+          var listItem = _this.createListItem(contentBuffer, _this.schema);
+
+          output.push(listItem);
+          output.push(pmNode);
+          contentBuffer = [];
+          continue;
+        }
+
+        contentBuffer.push(pmNode);
+      }
+
+      if (contentBuffer.length) {
+        var _listItem = _this.createListItem(contentBuffer, _this.schema);
+
+        output.push(_listItem);
+      }
+
+      return output;
+    });
+
+    this.schema = schema;
+    this.root = {
+      children: [],
+      type: getType(bullets)
+    };
+    this.lastDepth = 1;
+    this.lastList = this.root;
+  }
+  /**
+   * Return the type of the base list
+   * @returns {ListType}
+   */
+
+
+  _createClass(ListBuilder, [{
+    key: "type",
+    get: function get() {
+      return this.root.type;
+    }
+    /**
+     * Add a list item to the builder
+     * @param {AddArgs[]} items
+     */
+
+  }, {
+    key: "add",
+    value: function add(items) {
+      var _iterator = _createForOfIteratorHelper(items),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var item = _step.value;
+          var style = item.style,
+              content = item.content; // If there's no style, add to previous list item as multiline
+
+          if (style === null) {
+            this.appendToLastItem(content);
+            continue;
+          }
+
+          var depth = style.length;
+          var type = getType(style);
+
+          if (depth > this.lastDepth) {
+            // Add children starting from last node
+            this.createNest(depth - this.lastDepth, type);
+            this.lastDepth = depth;
+            this.lastList = this.addListItem(type, content);
+          } else if (depth === this.lastDepth) {
+            // Add list item to current node
+            this.lastList = this.addListItem(type, content);
+          } else {
+            // Find node at depth and add list item
+            this.lastList = this.findAncestor(this.lastDepth - depth);
+            this.lastDepth = depth;
+            this.lastList = this.addListItem(type, content);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+    /**
+     * Compile a prosemirror node from the root list
+     * @returns {PMNode[]}
+     */
+
+  }, {
+    key: "buildPMNode",
+    value: function buildPMNode() {
+      return this.parseList(this.root);
+    }
+    /**
+     * Build prosemirror bulletList or orderedList node
+     * @param {List} list
+     * @returns {PMNode}
+     */
+
+  }, {
+    key: "isParagraphEmptyTextNode",
+    value:
+    /* Check if all paragraph's children nodes are text and empty */
+    function isParagraphEmptyTextNode(node) {
+      if (node.type.name !== 'paragraph' || !node.childCount) {
+        return false;
+      }
+
+      for (var i = 0; i < node.childCount; i++) {
+        var n = node.content.child(i);
+
+        if (n.type.name !== 'text') {
+          // Paragraph contains non-text node, so not empty
+          return false;
+        } else if (n.textContent.trim() !== '') {
+          return false;
+        }
+      }
+
+      return true;
+    }
+  }, {
+    key: "createListItem",
+    value: function createListItem(content, schema) {
+      if (content.length === 0 || ['paragraph', 'mediaSingle'].indexOf(content[0].type.name) === -1) {
+        // If the content is empty or the first element is not paragraph or mediaSingle.
+        // this likely to be a nested list where the toplevel list is empty
+        // For example: *# item 1
+        // In this case we create an empty paragraph for the top level listNode
+        content.unshift(this.schema.nodes.paragraph.createChecked());
+      }
+
+      return schema.nodes.listItem.createChecked({}, content);
+    }
+    /**
+     * Add an item at the same level as the current list item
+     * @param {ListType} type
+     * @param {PMNode} content
+     * @returns {PMNode}
+     */
+
+  }, {
+    key: "addListItem",
+    value: function addListItem(type, content) {
+      var list = this.lastList; // If the list is a different type, create a new list and add it to the parent node
+
+      if (list.type !== type) {
+        var parent = list.parent;
+        var newList = {
+          children: [],
+          type: type,
+          parent: parent
+        };
+        parent.children.push(newList);
+        this.lastList = list = newList;
+      }
+
+      var listItem = {
+        content: content,
+        parent: list,
+        children: []
+      };
+      list.children = [].concat(_toConsumableArray(list.children), [listItem]);
+      return list;
+    }
+    /**
+     * Append the past content to the last accessed list node (multiline entries)
+     * @param {PMNode[]} content
+     */
+
+  }, {
+    key: "appendToLastItem",
+    value: function appendToLastItem(content) {
+      var _ref;
+
+      var children = this.lastList.children;
+      var lastItem = children[children.length - 1];
+
+      (_ref = lastItem.content).push.apply(_ref, _toConsumableArray(content));
+    }
+    /**
+     * Created a nested list structure of N depth under the current node
+     * @param {number} depth
+     * @param {ListType} type
+     */
+
+  }, {
+    key: "createNest",
+    value: function createNest(depth, type) {
+      while (depth-- > 0) {
+        if (this.lastList.children.length === 0) {
+          var listItem = {
+            parent: this.lastList,
+            children: []
+          };
+          this.lastList.children = [listItem];
+        }
+
+        var nextItem = this.lastList.children[this.lastList.children.length - 1];
+        nextItem.children = [{
+          children: [],
+          parent: nextItem,
+          type: type
+        }];
+        this.lastList = nextItem.children[0];
+      }
+    }
+    /**
+     * Find the Nth list ancestor of the current list
+     * @param {number} depth
+     */
+
+  }, {
+    key: "findAncestor",
+    value: function findAncestor(depth) {
+      var list = this.lastList;
+
+      while (depth-- > 0 && list.parent) {
+        var listItem = list.parent;
+
+        if (listItem && listItem.parent) {
+          list = listItem.parent;
+        }
+      }
+
+      return list;
+    }
+  }]);
+
+  return ListBuilder;
+}();