@tachybase/plugin-print-template 0.23.8

package/dist/node_modules/docxtemplater/js/tests/xml-prettify.js

@@ -0,0 +1,219 @@
+"use strict";
+
+var repeat = require("./string-repeat.js");
+function getIndent(indent) {
+  return repeat("    ", indent);
+}
+var attributeRegex = /<[A-Za-z0-9:]+ (.*?)([/ ]*)>/;
+function normalizeValue(value) {
+  return value.replace(/&#([0-9]+);/g, function (_, _int) {
+    return "&#x".concat(parseInt(_int, 10).toString(16).toUpperCase(), ";");
+  });
+}
+function attributeSorter(ln, namespaces) {
+  var rest;
+  if (attributeRegex.test(ln)) {
+    rest = ln.replace(attributeRegex, "$1");
+  }
+  var attrRegex = / *([a-zA-Z0-9:]+)="([^"]+)"/g;
+  var match = attrRegex.exec(rest);
+  var attributes = [];
+  while (match != null) {
+    // matched text: match[0]
+    // match start: match.index
+    // capturing group n: match[n]
+    var key = match[1];
+    var value = match[2];
+    value = normalizeValue(value);
+    var found = false;
+    for (var _i2 = 0; _i2 < namespaces.length; _i2++) {
+      var ns = namespaces[_i2];
+      if (ns) {
+        for (var _i4 = 0; _i4 < ns.length; _i4++) {
+          var n = ns[_i4];
+          if (n.key === key && n.value === value) {
+            found = true;
+          }
+        }
+      }
+    }
+    if (!found) {
+      attributes.push({
+        key: key,
+        value: value
+      });
+    }
+    match = attrRegex.exec(rest);
+  }
+  attributes.sort(function (a1, a2) {
+    if (a1.key === a2.key) {
+      return 0;
+    }
+    return a1.key > a2.key ? 1 : -1;
+  });
+  var stringifiedAttrs = attributes.map(function (attribute) {
+    return "".concat(attribute.key, "=\"").concat(attribute.value, "\"");
+  }).join(" ");
+  if (rest != null) {
+    ln = ln.replace(rest, stringifiedAttrs).replace(/ +>/, ">");
+  }
+  return {
+    replacement: ln,
+    attributes: attributes
+  };
+}
+
+/* eslint-disable-next-line complexity */
+function xmlprettify(xml) {
+  var result = "",
+    skip = 0,
+    indent = 0;
+  var parsed = miniparser(xml);
+  for (var i = 0, len = parsed.length; i < len; i++) {
+    var _parsed$i = parsed[i],
+      type = _parsed$i.type,
+      value = _parsed$i.value;
+    if (skip > 0) {
+      skip--;
+      continue;
+    }
+    var nextType = i < parsed.length - 1 ? parsed[i + 1].type : "";
+    var nnextType = i < parsed.length - 2 ? parsed[i + 2].type : "";
+    if (type === "processing-instruction") {
+      result += value + "\n";
+    }
+    if (type === "opening" && nextType === "content" && nnextType === "closing") {
+      result += getIndent(indent) + value + parsed[i + 1].value + parsed[i + 2].value + "\n";
+      skip = 2;
+      continue;
+    }
+    if (type === "opening") {
+      result += getIndent(indent) + value + "\n";
+      indent++;
+    }
+    if (type === "closing") {
+      indent--;
+      if (indent < 0) {
+        throw new Error("Malformed xml near ".concat(result.substr(result.length - 30), "**").concat(value, "** : ").concat(xml));
+      }
+      result += getIndent(indent) + value + "\n";
+    }
+    if (type === "single") {
+      result += getIndent(indent) + value + "\n";
+    }
+    if (type === "content" && !/^[ \n\r\t]+$/.test(value)) {
+      result += getIndent(indent) + value.trim() + "\n";
+    }
+  }
+  if (indent !== 0) {
+    throw new Error("Malformed xml indent at the end : ".concat(indent, " : ").concat(xml));
+  }
+  return result;
+}
+function getNamespaces(attributes) {
+  return attributes.filter(function (_ref) {
+    var key = _ref.key;
+    return key.indexOf("xmlns") !== -1;
+  });
+}
+function miniparser(xml) {
+  var cursor = 0;
+  var state = "outside";
+  var currentType = "";
+  var content = "";
+  var renderedArray = [];
+  var level = 0;
+  var namespaces = [];
+  while (cursor < xml.length) {
+    if (state === "outside") {
+      var opening = xml.indexOf("<", cursor);
+      if (opening !== -1) {
+        if (opening !== cursor) {
+          content = xml.substr(cursor, opening - cursor);
+          content = content.replace(/>/g, "&gt;");
+          renderedArray.push({
+            type: "content",
+            value: content
+          });
+        }
+        state = "inside";
+        cursor = opening;
+      } else {
+        var _content = xml.substr(cursor);
+        renderedArray.push({
+          type: "content",
+          value: _content
+        });
+        return renderedArray;
+      }
+    }
+    if (state === "inside") {
+      var closing = xml.indexOf(">", cursor);
+      if (closing !== -1) {
+        var inAttr = false;
+        var i = cursor;
+        while (inAttr || xml[i] !== ">") {
+          i++;
+          if (xml[i] === '"') {
+            inAttr = !inAttr;
+          }
+        }
+        closing = i;
+        var tag = xml.substr(cursor, closing - cursor + 1);
+        var isSingle = Boolean(tag.match(/^<.+\/>/)); // is this line a single tag? ex. <br />
+        var isClosing = Boolean(tag.match(/^<\/.+>/)); // is this a closing tag? ex. </a>
+        var isProcessingInstruction = Boolean(tag.match(/^<\?.*\?>$/)); // is this an xml declaration tag? ex. <?xml version="1.0" encoding="UTF-8" standalone="yes"?> or <?mso-contentType?>
+
+        state = "outside";
+        cursor = closing + 1;
+        if (isProcessingInstruction) {
+          var encodingRegex = / encoding="([^"]+)"/;
+          if (encodingRegex.test(tag)) {
+            tag = tag.replace(encodingRegex, function (x, encoding) {
+              encoding = encoding.toUpperCase();
+              if (encoding === "UTF-8") {
+                return "";
+              }
+              return " encoding=\"".concat(encoding, "\"");
+            });
+          }
+          tag = tag.replace(/^(<\?.*?) *(\?>$)/, "$1$2"); // Drop all spaces before ?>
+          currentType = "processing-instruction";
+        } else if (isSingle) {
+          // drop whitespace at the end
+          tag = tag.replace(/\s*\/\s*>$/g, "/>");
+          var sorted = attributeSorter(tag, namespaces);
+          tag = sorted.replacement;
+          currentType = "single";
+        } else if (isClosing) {
+          // drop whitespace at the end
+          tag = tag.replace(/\s+>$/g, ">");
+          currentType = "closing";
+          namespaces.pop();
+          level--;
+        } else {
+          // drop whitespace at the end
+          tag = tag.replace(/\s+>$/g, ">");
+          var _sorted = attributeSorter(tag, namespaces);
+          tag = _sorted.replacement;
+          namespaces[level] = getNamespaces(_sorted.attributes);
+          currentType = "opening";
+          level++;
+        }
+        renderedArray.push({
+          type: currentType,
+          value: tag
+        });
+      } else {
+        var _content2 = xml.substr(cursor);
+        renderedArray.push({
+          type: "content",
+          value: _content2
+        });
+        return renderedArray;
+      }
+    }
+  }
+  return renderedArray;
+}
+module.exports = xmlprettify;

package/dist/node_modules/docxtemplater/js/text.d.ts

@@ -0,0 +1,16 @@
+import { DXT } from "./docxtemplater";
+
+declare class TxtTemplater {
+  static default: typeof TxtTemplater;
+  /**
+   * Create TxtTemplater instance (and compile it on the fly)
+   *
+   * @param content the template that you want to use
+   * @param options `modules` and other options
+   */
+  constructor(content: string, options?: DXT.ConstructorOptions);
+
+  render(data?: any): string;
+}
+
+export = TxtTemplater;

package/dist/node_modules/docxtemplater/js/text.js

@@ -0,0 +1,88 @@
+"use strict";
+
+var Lexer = require("./lexer.js");
+var Parser = require("./parser.js");
+var createScope = require("./scope-manager.js");
+var utf8decode = require("./uintarray-to-string.js");
+var _require = require("./doc-utils.js"),
+  getDefaults = _require.getDefaults,
+  pushArray = _require.pushArray;
+var _require2 = require("./errors.js"),
+  throwMultiError = _require2.throwMultiError;
+var renderModule = require("./modules/render.js");
+var loopModule = require("./modules/loop.js");
+var expandPairTrait = require("./modules/expand-pair-trait.js");
+var XmlTemplater = require("./xml-templater.js");
+function TxtTemplater(text) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var filePath = "text";
+  var xmlt = new XmlTemplater(text, {
+    modules: []
+  });
+  xmlt.fileType = "text";
+  this.fileTypeConfig = xmlt.fileTypeConfig = options.fileTypeConfig = {
+    droppedTagsInsidePlaceholder: [],
+    expandTags: []
+  };
+  var defaults = getDefaults();
+  for (var key in defaults) {
+    var defaultValue = defaults[key];
+    xmlt[key] = options[key] = options[key] != null ? options[key] : defaultValue;
+  }
+  xmlt.modules = [loopModule(), expandPairTrait(), renderModule()];
+  for (var _i2 = 0, _xmlt$modules2 = xmlt.modules; _i2 < _xmlt$modules2.length; _i2++) {
+    var _module = _xmlt$modules2[_i2];
+    _module.optionsTransformer(options, {
+      fileTypeConfig: xmlt.fileTypeConfig,
+      parser: xmlt.parser,
+      options: xmlt
+    });
+  }
+  xmlt.allErrors = [];
+  // Fake XML parsing : surround the text with an empty tag of type text: true
+  xmlt.xmllexed = [{
+    type: "tag",
+    position: "start",
+    value: "",
+    text: true
+  }, {
+    type: "content",
+    value: text
+  }, {
+    type: "tag",
+    position: "end",
+    value: ""
+  }];
+  xmlt.setModules({
+    inspect: {
+      filePath: filePath,
+      xmllexed: xmlt.xmllexed
+    }
+  });
+  var _Lexer$parse = Lexer.parse(xmlt.xmllexed, xmlt.delimiters, xmlt.syntax, xmlt.fileType),
+    lexed = _Lexer$parse.lexed,
+    lexerErrors = _Lexer$parse.errors;
+  pushArray(xmlt.allErrors, lexerErrors);
+  xmlt.lexed = lexed;
+  xmlt.setModules({
+    inspect: {
+      filePath: filePath,
+      lexed: xmlt.lexed
+    }
+  });
+  Parser.preparse(xmlt.lexed, xmlt.modules, xmlt.getOptions());
+  xmlt.parse();
+  if (xmlt.allErrors.length > 0) {
+    throwMultiError(xmlt.allErrors);
+  }
+  this.render = function (tags) {
+    xmlt.scopeManager = createScope({
+      tags: tags,
+      parser: xmlt.parser
+    });
+    return utf8decode(xmlt.render().content);
+  };
+  return this;
+}
+module.exports = TxtTemplater;
+module.exports["default"] = TxtTemplater;

package/dist/node_modules/docxtemplater/js/traits.js

@@ -0,0 +1,347 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+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) { _defineProperty(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; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var _require = require("./doc-utils.js"),
+  getRightOrNull = _require.getRightOrNull,
+  getRight = _require.getRight,
+  getLeft = _require.getLeft,
+  getLeftOrNull = _require.getLeftOrNull,
+  chunkBy = _require.chunkBy,
+  isTagStart = _require.isTagStart,
+  isTagEnd = _require.isTagEnd,
+  isContent = _require.isContent,
+  last = _require.last,
+  first = _require.first;
+var _require2 = require("./errors.js"),
+  XTTemplateError = _require2.XTTemplateError,
+  throwExpandNotFound = _require2.throwExpandNotFound,
+  getLoopPositionProducesInvalidXMLError = _require2.getLoopPositionProducesInvalidXMLError;
+function lastTagIsOpenTag(tags, tag) {
+  if (tags.length === 0) {
+    return false;
+  }
+  var innerLastTag = last(tags).substr(1);
+  return innerLastTag.indexOf(tag) === 0;
+}
+function getListXmlElements(parts) {
+  /*
+  Gets the list of closing and opening tags between two texts. It doesn't take
+  into account tags that are opened then closed. Those that are closed then
+  opened are kept
+  	Example input :
+  	[
+  	{
+  		"type": "placeholder",
+  		"value": "table1",
+  		...
+  	},
+  	{
+  		"type": "placeholder",
+  		"value": "t1data1",
+  	},
+  	{
+  		"type": "tag",
+  		"position": "end",
+  		"text": true,
+  		"value": "</w:t>",
+  		"tag": "w:t",
+  		"lIndex": 112
+  	},
+  	{
+  		"type": "tag",
+  		"value": "</w:r>",
+  	},
+  	{
+  		"type": "tag",
+  		"value": "</w:p>",
+  	},
+  	{
+  		"type": "tag",
+  		"value": "</w:tc>",
+  	},
+  	{
+  		"type": "tag",
+  		"value": "<w:tc>",
+  	},
+  	{
+  		"type": "content",
+  		"value": "<w:tcPr><w:tcW w:w="2444" w:type="dxa"/><w:tcBorders><w:top w:val="nil"/><w:left w:val="nil"/><w:bottom w:val="nil"/><w:right w:val="nil"/></w:tcBorders><w:shd w:val="clear" w:color="auto" w:fill="FFFFFF"/></w:tcPr>",
+  	},
+  	...
+  	{
+  		"type": "tag",
+  		"value": "<w:r>",
+  	},
+  	{
+  		"type": "tag",
+  		"value": "<w:t xml:space="preserve">",
+  	},
+  	{
+  		"type": "placeholder",
+  		"value": "t1data4",
+  	}
+  ]
+  	returns
+  	[
+  		{
+  			"tag": "</w:t>",
+  		},
+  		{
+  			"tag": "</w:r>",
+  		},
+  		{
+  			"tag": "</w:p>",
+  		},
+  		{
+  			"tag": "</w:tc>",
+  		},
+  		{
+  			"tag": "<w:tc>",
+  		},
+  		{
+  			"tag": "<w:p>",
+  		},
+  		{
+  			"tag": "<w:r>",
+  		},
+  		{
+  			"tag": "<w:t>",
+  		},
+  	]
+  */
+
+  var result = [];
+  for (var _i2 = 0; _i2 < parts.length; _i2++) {
+    var _parts$_i = parts[_i2],
+      position = _parts$_i.position,
+      value = _parts$_i.value,
+      tag = _parts$_i.tag;
+    // Stryker disable all : because removing this condition would also work but we want to make the API future proof
+    if (!tag) {
+      continue;
+    }
+    // Stryker restore all
+    if (position === "end") {
+      if (lastTagIsOpenTag(result, tag)) {
+        result.pop();
+      } else {
+        result.push(value);
+      }
+    } else if (position === "start") {
+      result.push(value);
+    }
+    // ignore position === "selfclosing"
+  }
+  return result;
+}
+function has(name, xmlElements) {
+  for (var _i4 = 0; _i4 < xmlElements.length; _i4++) {
+    var xmlElement = xmlElements[_i4];
+    if (xmlElement.indexOf("<".concat(name)) === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function getExpandToDefault(postparsed, pair, expandTags) {
+  var parts = postparsed.slice(pair[0].offset, pair[1].offset);
+  var xmlElements = getListXmlElements(parts);
+  var closingTagCount = xmlElements.filter(function (tag) {
+    return tag[1] === "/";
+  }).length;
+  var startingTagCount = xmlElements.filter(function (tag) {
+    return tag[1] !== "/" && tag[tag.length - 2] !== "/";
+  }).length;
+  if (closingTagCount !== startingTagCount) {
+    return {
+      error: getLoopPositionProducesInvalidXMLError({
+        tag: first(pair).part.value,
+        offset: [first(pair).part.offset, last(pair).part.offset]
+      })
+    };
+  }
+  var _loop = function _loop() {
+      var _expandTags$_i = expandTags[_i6],
+        contains = _expandTags$_i.contains,
+        expand = _expandTags$_i.expand,
+        onlyTextInTag = _expandTags$_i.onlyTextInTag;
+      if (has(contains, xmlElements)) {
+        if (onlyTextInTag) {
+          var left = getLeftOrNull(postparsed, contains, pair[0].offset);
+          var right = getRightOrNull(postparsed, contains, pair[1].offset);
+          if (left === null || right === null) {
+            return 0; // continue
+          }
+          var chunks = chunkBy(postparsed.slice(left, right), function (p) {
+            return isTagStart(contains, p) ? "start" : isTagEnd(contains, p) ? "end" : null;
+          });
+          var firstChunk = first(chunks);
+          var lastChunk = last(chunks);
+          var firstContent = firstChunk.filter(isContent);
+          var lastContent = lastChunk.filter(isContent);
+          if (firstContent.length !== 1 || lastContent.length !== 1) {
+            return 0; // continue
+          }
+        }
+        return {
+          v: {
+            value: expand
+          }
+        };
+      }
+    },
+    _ret;
+  for (var _i6 = 0; _i6 < expandTags.length; _i6++) {
+    _ret = _loop();
+    if (_ret === 0) continue;
+    if (_ret) return _ret.v;
+  }
+  return {};
+}
+function getExpandLimit(part, index, postparsed, options) {
+  var expandTo = part.expandTo || options.expandTo;
+  // Stryker disable all : because this condition can be removed in v4 (the only usage was the image module before version 3.12.3 of the image module
+  if (!expandTo) {
+    return;
+  }
+  // Stryker restore all
+  var right, left;
+  try {
+    left = getLeft(postparsed, expandTo, index);
+    right = getRight(postparsed, expandTo, index);
+  } catch (rootError) {
+    if (rootError instanceof XTTemplateError) {
+      throwExpandNotFound(_objectSpread({
+        part: part,
+        rootError: rootError,
+        postparsed: postparsed,
+        expandTo: expandTo,
+        index: index
+      }, options.error));
+    }
+    throw rootError;
+  }
+  return [left, right];
+}
+function expandOne(_ref, part, postparsed, options) {
+  var _ref2 = _slicedToArray(_ref, 2),
+    left = _ref2[0],
+    right = _ref2[1];
+  var index = postparsed.indexOf(part);
+  var leftParts = postparsed.slice(left, index);
+  var rightParts = postparsed.slice(index + 1, right + 1);
+  var inner = options.getInner({
+    postparse: options.postparse,
+    index: index,
+    part: part,
+    leftParts: leftParts,
+    rightParts: rightParts,
+    left: left,
+    right: right,
+    postparsed: postparsed
+  });
+  if (!inner.length) {
+    inner.expanded = [leftParts, rightParts];
+    inner = [inner];
+  }
+  return {
+    left: left,
+    right: right,
+    inner: inner
+  };
+}
+
+/* eslint-disable-next-line complexity */
+function expandToOne(postparsed, options) {
+  var errors = [];
+  if (postparsed.errors) {
+    errors = postparsed.errors;
+    postparsed = postparsed.postparsed;
+  }
+  var limits = [];
+  for (var i = 0, len = postparsed.length; i < len; i++) {
+    var part = postparsed[i];
+    if (part.type === "placeholder" && part.module === options.moduleName &&
+    // The part.subparsed check is used to fix this github issue :
+    // https://github.com/open-xml-templating/docxtemplater/issues/671
+    !part.subparsed && !part.expanded) {
+      try {
+        var limit = getExpandLimit(part, i, postparsed, options);
+        if (!limit) {
+          continue;
+        }
+        var _limit = _slicedToArray(limit, 2),
+          left = _limit[0],
+          right = _limit[1];
+        limits.push({
+          left: left,
+          right: right,
+          part: part,
+          i: i,
+          leftPart: postparsed[left],
+          rightPart: postparsed[right]
+        });
+      } catch (error) {
+        if (error instanceof XTTemplateError) {
+          errors.push(error);
+        } else {
+          throw error;
+        }
+      }
+    }
+  }
+  limits.sort(function (l1, l2) {
+    if (l1.left === l2.left) {
+      return l2.part.lIndex < l1.part.lIndex ? 1 : -1;
+    }
+    return l2.left < l1.left ? 1 : -1;
+  });
+  var maxRight = -1;
+  var offset = 0;
+  for (var _i7 = 0, _len = limits.length; _i7 < _len; _i7++) {
+    var _postparsed;
+    var _limit2 = limits[_i7];
+    maxRight = Math.max(maxRight, _i7 > 0 ? limits[_i7 - 1].right : 0);
+    if (_limit2.left < maxRight) {
+      continue;
+    }
+    var result = void 0;
+    try {
+      result = expandOne([_limit2.left + offset, _limit2.right + offset], _limit2.part, postparsed, options);
+    } catch (error) {
+      if (error instanceof XTTemplateError) {
+        errors.push(error);
+      } else {
+        throw error;
+      }
+    }
+    if (!result) {
+      continue;
+    }
+    offset += result.inner.length - (result.right + 1 - result.left);
+    (_postparsed = postparsed).splice.apply(_postparsed, [result.left, result.right + 1 - result.left].concat(_toConsumableArray(result.inner)));
+  }
+  return {
+    postparsed: postparsed,
+    errors: errors
+  };
+}
+module.exports = {
+  expandToOne: expandToOne,
+  getExpandToDefault: getExpandToDefault
+};