highmark-markdown 0.0.154 → 0.0.155

package/src/utilities/childNodes.js

@@ -9,124 +9,132 @@ import { contentFromMarkdownNodes } from "./content";
 
 const { clear } = arrayUtilities;
 
-export function domElementsFromChildNodes(childNodes, context) {
-  const domElements = [],
+export function htmlFromChildNodes(childNodes, context, trimmed) {
+  let html;
+
+  const htmls = [],
         plainTextMarkdownNodes = [];
 
   childNodes.forEach((childNode) => {
     const childNodeNonTerminalNode = childNode.isNonTerminalNode();
 
     if (childNodeNonTerminalNode) {
-      const childNodePlainTextMarkdownNode = (childNode instanceof PlainTextMarkdownNode);
+      const nonTerminalNode = childNode,  ///
+            markdownNode = nonTerminalNode, ///
+            markdownNodePlainTextMarkdownNode = (markdownNode instanceof PlainTextMarkdownNode);
 
-      if (childNodePlainTextMarkdownNode) {
-        const plainTextMarkdownNode = childNode; ///
+      if (markdownNodePlainTextMarkdownNode) {
+        const plainTextMarkdownNode = markdownNode; ///
 
         plainTextMarkdownNodes.push(plainTextMarkdownNode);
       } else {
-        const textDOMElement = textDOMElementFromPlainTextMarkdownNodes(plainTextMarkdownNodes, context)
+        html = htmlFromPlainTextMarkdownNodes(plainTextMarkdownNodes, context, trimmed)
 
-        if (textDOMElement !== null) {
-          const domElement = textDOMElement;  ///
+        if (html !== null) {
+          htmls.push(html);
 
-          domElements.push(domElement);
+          trimmed = false;
         }
 
-        const domElement = childNode.createDOMElement(context);
+        const indent = null;
 
-        if (domElement !== null) {
-          domElements.push(domElement);
+        html = markdownNode.asHTML(indent, context);
+
+        if (html !== null) {
+          htmls.push(html);
         }
       }
     }
   });
 
-  const textDOMElement = textDOMElementFromPlainTextMarkdownNodes(plainTextMarkdownNodes, context)
+  html = htmlFromPlainTextMarkdownNodes(plainTextMarkdownNodes, context, trimmed)
 
-  if (textDOMElement !== null) {
-    const domElement = textDOMElement;  ///
-
-    domElements.push(domElement);
+  if (html !== null) {
+    htmls.push(html);
   }
 
-  return domElements;
-}
+  html = htmls.join(EMPTY_STRING);
 
-export function htmlFromChildNodes(childNodes, context) {
-  let html;
+  return html;
+}
 
-  const htmls = [],
+export function domElementsFromChildNodes(childNodes, context, trimmed) {
+  const domElements = [],
         plainTextMarkdownNodes = [];
 
   childNodes.forEach((childNode) => {
     const childNodeNonTerminalNode = childNode.isNonTerminalNode();
 
     if (childNodeNonTerminalNode) {
-      const childNodePlainTextMarkdownNode = (childNode instanceof PlainTextMarkdownNode);
+      const nonTerminalNode = childNode,  ///
+            markdownNode = nonTerminalNode, ///
+            markdownNodePlainTextMarkdownNode = (markdownNode instanceof PlainTextMarkdownNode);
 
-      if (childNodePlainTextMarkdownNode) {
-        const plainTextMarkdownNode = childNode; ///
+      if (markdownNodePlainTextMarkdownNode) {
+        const plainTextMarkdownNode = markdownNode; ///
 
         plainTextMarkdownNodes.push(plainTextMarkdownNode);
       } else {
-        html = htmlFromPlainTextMarkdownNodes(plainTextMarkdownNodes, context)
+        const textDOMElement = textDOMElementFromPlainTextMarkdownNodes(plainTextMarkdownNodes, context, trimmed)
 
-        if (html !== null) {
-          htmls.push(html);
-        }
+        if (textDOMElement !== null) {
+          const domElement = textDOMElement;  ///
 
-        const indent = null;
+          domElements.push(domElement);
 
-        html = childNode.asHTML(indent, context);
+          trimmed = false;
+        }
 
-        if (html !== null) {
-          htmls.push(html);
+        const domElement = markdownNode.createDOMElement(context);
+
+        if (domElement !== null) {
+          domElements.push(domElement);
         }
       }
     }
   });
 
-  html = htmlFromPlainTextMarkdownNodes(plainTextMarkdownNodes, context)
+  const textDOMElement = textDOMElementFromPlainTextMarkdownNodes(plainTextMarkdownNodes, context, trimmed)
 
-  if (html !== null) {
-    htmls.push(html);
-  }
+  if (textDOMElement !== null) {
+    const domElement = textDOMElement;  ///
 
-  html = htmls.join(EMPTY_STRING);
+    domElements.push(domElement);
+  }
 
-  return html;
+  return domElements;
 }
 
-function textDOMElementFromPlainTextMarkdownNodes(plainTextMarkdownNodes, context) {
-  let textDOMElement = null;
+function htmlFromPlainTextMarkdownNodes(plainTextMarkdownNodes, context, trimmed) {
+  let html = null;
 
   const plainTextMarkdownNodesLength = plainTextMarkdownNodes.length;
 
   if (plainTextMarkdownNodesLength > 0) {
     const markdownNodes = plainTextMarkdownNodes,  ///
-          content = contentFromMarkdownNodes(markdownNodes, context);
+          content = contentFromMarkdownNodes(markdownNodes, context, trimmed);
 
-    textDOMElement = document.createTextNode(content);
+    html = content; ///
 
     clear(plainTextMarkdownNodes);
   }
 
-  return textDOMElement;
+  return html;
 }
 
-function htmlFromPlainTextMarkdownNodes(plainTextMarkdownNodes, context) {
-  let html = null;
+function textDOMElementFromPlainTextMarkdownNodes(plainTextMarkdownNodes, context, trimmed) {
+  let textDOMElement = null;
 
   const plainTextMarkdownNodesLength = plainTextMarkdownNodes.length;
 
   if (plainTextMarkdownNodesLength > 0) {
     const markdownNodes = plainTextMarkdownNodes,  ///
-          content = contentFromMarkdownNodes(markdownNodes, context);
+          content = contentFromMarkdownNodes(markdownNodes, context, trimmed);
 
-    html = content;
+    textDOMElement = document.createTextNode(content);
 
     clear(plainTextMarkdownNodes);
   }
 
-  return html;
+  return textDOMElement;
 }

package/src/utilities/{link.js → footnotes.js}

@@ -8,6 +8,14 @@ import { linkMarkdownNodesFromNode } from "../utilities/query";
 
 const { strlen, indexOf } = stringUtilities;
 
+export function appendFootnotesListMarkdownNodeHTML(childNodesHTML, footnotesListMarkdownNode, indent, context) {
+  const footnotesListMarkdownNodeHTML = footnotesListMarkdownNode.asHTML(indent, context);
+
+  childNodesHTML = `${childNodesHTML}${footnotesListMarkdownNodeHTML}`;
+
+  return childNodesHTML;
+}
+
 export function renumberLinkMarkdownNodesHTML(childNodesHTML, divisionMarkdownNode, footnotesListMarkdownNode, context) {
   let number = 1;
 

package/src/utilities/{node.js → nodes.js}

@@ -17,7 +17,3 @@ export function setNonTerminalNodes(parser, nodeMap) {
     rule.setNonTerminalNode(NonTerminalNode);
   });
 }
-
-export default {
-  setNonTerminalNodes
-};

package/src/utilities/query.js

@@ -3,9 +3,11 @@
 import { Query } from "occam-query";
 import { arrayUtilities } from "necessary";
 
-const { push } = arrayUtilities;
+const { first, push } = arrayUtilities;
 
 const linkMarkdownNodesQuery = Query.fromExpression(`//link`),
+      contentMarkdownNodeQuery = Query.fromExpression(`//contents`),
+      headingMarkdownNodesQuery = Query.fromExpression(`//primaryHeading|secondaryHeading|tertiaryHeading|quaternaryHeading`),
       footnoteMarkdownNodesQuery = Query.fromExpression(`//footnote`),
       referenceMarkdownNodesQuery = Query.fromExpression(`//reference`);
 
@@ -15,6 +17,18 @@ export function linkMarkdownNodesFromNode(node, linkMarkdownNodes = []) {
   return linkMarkdownNodes;
 }
 
+export function contentsMarkdownNodeFromNode(node) {
+  const contentsMarkdownNode = nodeFromNodeAndQuery(node, contentMarkdownNodeQuery);
+
+  return contentsMarkdownNode;
+}
+
+export function headingMarkdownNodesFromNode(node, headingMarkdownNodes = []) {
+  nodesFromNodeAndQuery(node, headingMarkdownNodesQuery, headingMarkdownNodes);
+
+  return headingMarkdownNodes;
+}
+
 export function footnoteMarkdownNodesFromNode(node, footnoteMarkdownNodes = []) {
   nodesFromNodeAndQuery(node, footnoteMarkdownNodesQuery, footnoteMarkdownNodes);
 
@@ -29,10 +43,27 @@ export function referenceMarkdownNodesFromNode(node, referenceMarkdownNodes = []
 
 export default {
   linkMarkdownNodesFromNode,
+  contentsMarkdownNodeFromNode,
+  headingMarkdownNodesFromNode,
   footnoteMarkdownNodesFromNode,
   referenceMarkdownNodesFromNode
 };
 
+function nodeFromNodeAndQuery(node, query) {
+  const queryNodes = query.execute(node),
+        queryNodesLength = queryNodes.length;
+
+  if (queryNodesLength === 0) {
+    node = null;
+  } else {
+    const firstQueryNode = first(queryNodes);
+
+    node = firstQueryNode;  ///
+  }
+
+  return node;
+}
+
 function nodesFromNodeAndQuery(node, query, nodes) {
   const queryNodes = query.execute(node);
 

package/src/utilities/string.js

@@ -7,7 +7,7 @@ import { EMPTY_STRING } from "../constants";
 const { substring } = stringUtilities;
 
 export function trim(string) {
-  const shavenString = string.replace(/^.|.$/g, EMPTY_STRING);
+  const shavenString = string.replace(/^["`'\s]+|["`'\s]+$/g, EMPTY_STRING);
 
   return shavenString;
 }
@@ -53,4 +53,3 @@ export function splice(string, start, deleteCount, middleString) {
 
   return string;
 }
-

package/src/utilities/tokens.js

@@ -0,0 +1,14 @@
+"use strict";
+
+export function replaceTokens(replacedChildNode, replacementTokens, context) {
+  const { tokens } = context,
+        nonTerminalNode = replacedChildNode,  ///
+        lastSignificantToken = nonTerminalNode.getLastSignificantToken(),
+        firstSignificantToken = nonTerminalNode.getFirstSignificantToken(),
+        lastSignificantTokenIndex = tokens.indexOf(lastSignificantToken),
+        firstSignificantTokenIndex = tokens.indexOf(firstSignificantToken),
+        start = firstSignificantTokenIndex, ///
+        deleteCount = lastSignificantTokenIndex - firstSignificantTokenIndex; ///
+
+  tokens.splice(start, deleteCount, ...replacementTokens);
+}

package/src/utilities/tree.js

@@ -0,0 +1,139 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+const { first, last } = arrayUtilities;
+
+export function nestNodes(nodes) {
+  const nestedNodesStack = NestedNodeStack.fromNothing();
+
+  nodes.forEach((node) => {
+    const level = node.getLevel();
+
+    let nestedNodesStackLevel = nestedNodesStack.getLevel()
+
+    while (nestedNodesStackLevel < level) {
+      nestedNodesStackLevel = nestedNodesStack.increment();
+    }
+
+    while (nestedNodesStackLevel > level) {
+      nestedNodesStackLevel = nestedNodesStack.decrement();
+    }
+
+    const nestedNode = NestedNode.fromNode(node);
+
+    nestedNodesStack.addNestedNode(nestedNode);
+  });
+
+  const nestedNode = nestedNodesStack.getNestedNode();
+
+  return nestedNode;
+}
+
+class NestedNode {
+  constructor(node, childNestedNodes) {
+    this.node = node;
+    this.childNestedNodes = childNestedNodes;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getChildNestedNodes() {
+    return this.childNestedNodes;
+  }
+
+  addNestedNode(nestedNode) {
+    const childNestedNode = nestedNode; ///
+
+    this.childNestedNodes.push(childNestedNode);
+  }
+
+  static fromNode(node) {
+    const childNestedNodes = [],
+          nestedNode = new NestedNode(node, childNestedNodes);
+
+    return nestedNode;
+  }
+
+  static fromNothing() {
+    const node = null,
+          childNestedNodes = [],
+          nestedNode = new NestedNode(node, childNestedNodes);
+
+    return nestedNode;
+  }
+}
+
+class NestedNodeStack {
+  constructor(nestedNodes) {
+    this.nestedNodes = nestedNodes;
+  }
+
+  getNestedNodes() {
+    return this.nestedNodes;
+  }
+
+  getLastNestedNode() {
+    const lastNestedNode = last(this.nestedNodes);
+
+    return lastNestedNode;
+  }
+
+  getNestedNode() {
+    const firstNestedNode = first(this.nestedNodes),
+          nestedNode = firstNestedNode;  ///
+
+    return nestedNode;
+  }
+
+  getLevel() {
+    const nestedNodesLength = this.nestedNodes.length,
+          level = nestedNodesLength;  ///
+
+    return level;
+  }
+
+  increment() {
+    const nestedNode = NestedNode.fromNothing();
+
+    this.addNestedNode(nestedNode);
+
+    const level = this.getLevel();
+
+    return level;
+  }
+
+  decrement() {
+    this.removeNestedNode();
+
+    const level = this.getLevel();
+
+    return level;
+  }
+
+  addNestedNode(nestedNode) {
+    const lastNestedNode = this.getLastNestedNode();
+
+    lastNestedNode.addNestedNode(nestedNode);
+
+    this.nestedNodes.push(nestedNode);
+  }
+
+  removeNestedNode() {
+    const nestedNode = this.nestedNodes.pop();
+
+    return nestedNode;
+  }
+
+  static fromNothing() {
+    const nestedNode = NestedNode.fromNothing(),
+          nestedNodes = [
+            nestedNode
+          ],
+          nestedNodesStack = new NestedNodeStack(nestedNodes);
+
+    return nestedNodesStack;
+  }
+}

package/lib/node/markdown/primaryHeading.js

@@ -1,167 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return PrimaryHeadingMarkdownNode;
-    }
-});
-var _necessary = require("necessary");
-var _markdown = /*#__PURE__*/ _interop_require_default(require("../../node/markdown"));
-function _assert_this_initialized(self) {
-    if (self === void 0) {
-        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    }
-    return self;
-}
-function _class_call_check(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _create_class(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-function _get(target, property, receiver) {
-    if (typeof Reflect !== "undefined" && Reflect.get) {
-        _get = Reflect.get;
-    } else {
-        _get = function get(target, property, receiver) {
-            var base = _super_prop_base(target, property);
-            if (!base) return;
-            var desc = Object.getOwnPropertyDescriptor(base, property);
-            if (desc.get) {
-                return desc.get.call(receiver || target);
-            }
-            return desc.value;
-        };
-    }
-    return _get(target, property, receiver || target);
-}
-function _get_prototype_of(o) {
-    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
-        return o.__proto__ || Object.getPrototypeOf(o);
-    };
-    return _get_prototype_of(o);
-}
-function _inherits(subClass, superClass) {
-    if (typeof superClass !== "function" && superClass !== null) {
-        throw new TypeError("Super expression must either be null or a function");
-    }
-    subClass.prototype = Object.create(superClass && superClass.prototype, {
-        constructor: {
-            value: subClass,
-            writable: true,
-            configurable: true
-        }
-    });
-    if (superClass) _set_prototype_of(subClass, superClass);
-}
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function _possible_constructor_return(self, call) {
-    if (call && (_type_of(call) === "object" || typeof call === "function")) {
-        return call;
-    }
-    return _assert_this_initialized(self);
-}
-function _set_prototype_of(o, p) {
-    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
-        o.__proto__ = p;
-        return o;
-    };
-    return _set_prototype_of(o, p);
-}
-function _super_prop_base(object, property) {
-    while(!Object.prototype.hasOwnProperty.call(object, property)){
-        object = _get_prototype_of(object);
-        if (object === null) break;
-    }
-    return object;
-}
-function _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-}
-function _is_native_reflect_construct() {
-    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-    if (Reflect.construct.sham) return false;
-    if (typeof Proxy === "function") return true;
-    try {
-        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
-        return true;
-    } catch (e) {
-        return false;
-    }
-}
-function _create_super(Derived) {
-    var hasNativeReflectConstruct = _is_native_reflect_construct();
-    return function _createSuperInternal() {
-        var Super = _get_prototype_of(Derived), result;
-        if (hasNativeReflectConstruct) {
-            var NewTarget = _get_prototype_of(this).constructor;
-            result = Reflect.construct(Super, arguments, NewTarget);
-        } else {
-            result = Super.apply(this, arguments);
-        }
-        return _possible_constructor_return(this, result);
-    };
-}
-var second = _necessary.arrayUtilities.second;
-var PrimaryHeadingMarkdownNode = /*#__PURE__*/ function(MarkdownNode) {
-    _inherits(PrimaryHeadingMarkdownNode, MarkdownNode);
-    var _super = _create_super(PrimaryHeadingMarkdownNode);
-    function PrimaryHeadingMarkdownNode() {
-        _class_call_check(this, PrimaryHeadingMarkdownNode);
-        return _super.apply(this, arguments);
-    }
-    _create_class(PrimaryHeadingMarkdownNode, [
-        {
-            key: "asHTML",
-            value: function asHTML(indent, context) {
-                var title = context.title;
-                if (title === null) {
-                    title = this.title(context);
-                    Object.assign(context, {
-                        title: title
-                    });
-                }
-                var html = _get(_get_prototype_of(PrimaryHeadingMarkdownNode.prototype), "asHTML", this).call(this, indent, context);
-                return html;
-            }
-        },
-        {
-            key: "title",
-            value: function title(context) {
-                var indent = null, childNodes = this.getChildNodes(), secondChildNode = second(childNodes), lineMarkdownNode = secondChildNode, lineMarkdownNodeChildNodesHTML = lineMarkdownNode.childNodesAsHTML(indent, context), title = lineMarkdownNodeChildNodesHTML;
-                return title;
-            }
-        }
-    ], [
-        {
-            key: "fromRuleNameChildNodesAndOpacity",
-            value: function fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) {
-                return _markdown.default.fromRuleNameChildNodesAndOpacity(PrimaryHeadingMarkdownNode, ruleName, childNodes, opacity);
-            }
-        }
-    ]);
-    return PrimaryHeadingMarkdownNode;
-}(_markdown.default);
-
-//# sourceMappingURL=data:application/json;base64,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

package/lib/utilities/link.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    default: function() {
-        return _default;
-    },
-    renumberLinkMarkdownNodes: function() {
-        return renumberLinkMarkdownNodes;
-    },
-    renumberLinkMarkdownNodesHTML: function() {
-        return renumberLinkMarkdownNodesHTML;
-    }
-});
-var _necessary = require("necessary");
-var _constants = require("../constants");
-var _string = require("../utilities/string");
-var _query = require("../utilities/query");
-var strlen = _necessary.stringUtilities.strlen, indexOf = _necessary.stringUtilities.indexOf;
-function renumberLinkMarkdownNodesHTML(childNodesHTML, divisionMarkdownNode, footnotesListMarkdownNode, context) {
-    var number = 1;
-    var identifiers = footnotesListMarkdownNode.identifiers(), linkMarkdownNodes = (0, _query.linkMarkdownNodesFromNode)(divisionMarkdownNode);
-    linkMarkdownNodes.forEach(function(linkMarkdownNode) {
-        var indent = null, identifier = linkMarkdownNode.identifier(context), identifiersIncludesIdentifier = identifiers.includes(identifier), linkMarkdownNodeHTML = linkMarkdownNode.asHTML(indent, context), index = indexOf(childNodesHTML, linkMarkdownNodeHTML), length = strlen(linkMarkdownNodeHTML), start = index, deleteCount = length; ///
-        if (identifiersIncludesIdentifier) {
-            var linkMarkdownNodeHTML1 = linkMarkdownNode.asHTML(indent, context, number);
-            childNodesHTML = (0, _string.splice)(childNodesHTML, start, deleteCount, linkMarkdownNodeHTML1);
-            number++;
-        } else {
-            childNodesHTML = (0, _string.chop)(childNodesHTML, start, deleteCount);
-        }
-    });
-    return childNodesHTML;
-}
-function renumberLinkMarkdownNodes(divisionMarkdownNode, footnotesListMarkdownNode, context) {
-    var number = 1;
-    var identifiers = footnotesListMarkdownNode.identifiers(), linkMarkdownNodes = (0, _query.linkMarkdownNodesFromNode)(divisionMarkdownNode);
-    linkMarkdownNodes.forEach(function(linkMarkdownNode) {
-        var identifier = linkMarkdownNode.identifier(context), linkMarkdownNodeDOMElement = linkMarkdownNode.getDOMElement(), identifiersIncludesIdentifier = identifiers.includes(identifier);
-        var innerHTML;
-        if (identifiersIncludesIdentifier) {
-            innerHTML = "".concat(number);
-            number++;
-        } else {
-            innerHTML = _constants.EMPTY_STRING;
-        }
-        Object.assign(linkMarkdownNodeDOMElement, {
-            innerHTML: innerHTML
-        });
-    });
-}
-var _default = {
-    renumberLinkMarkdownNodes: renumberLinkMarkdownNodes
-};
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsaXRpZXMvbGluay5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuaW1wb3J0IHsgc3RyaW5nVXRpbGl0aWVzIH0gZnJvbSBcIm5lY2Vzc2FyeVwiO1xuXG5pbXBvcnQgeyBFTVBUWV9TVFJJTkcgfSBmcm9tIFwiLi4vY29uc3RhbnRzXCI7XG5pbXBvcnQgeyBjaG9wLCBzcGxpY2UgfSBmcm9tIFwiLi4vdXRpbGl0aWVzL3N0cmluZ1wiO1xuaW1wb3J0IHsgbGlua01hcmtkb3duTm9kZXNGcm9tTm9kZSB9IGZyb20gXCIuLi91dGlsaXRpZXMvcXVlcnlcIjtcblxuY29uc3QgeyBzdHJsZW4sIGluZGV4T2YgfSA9IHN0cmluZ1V0aWxpdGllcztcblxuZXhwb3J0IGZ1bmN0aW9uIHJlbnVtYmVyTGlua01hcmtkb3duTm9kZXNIVE1MKGNoaWxkTm9kZXNIVE1MLCBkaXZpc2lvbk1hcmtkb3duTm9kZSwgZm9vdG5vdGVzTGlzdE1hcmtkb3duTm9kZSwgY29udGV4dCkge1xuICBsZXQgbnVtYmVyID0gMTtcblxuICBjb25zdCBpZGVudGlmaWVycyA9IGZvb3Rub3Rlc0xpc3RNYXJrZG93bk5vZGUuaWRlbnRpZmllcnMoKSxcbiAgICAgICAgbGlua01hcmtkb3duTm9kZXMgPSBsaW5rTWFya2Rvd25Ob2Rlc0Zyb21Ob2RlKGRpdmlzaW9uTWFya2Rvd25Ob2RlKTtcblxuICBsaW5rTWFya2Rvd25Ob2Rlcy5mb3JFYWNoKChsaW5rTWFya2Rvd25Ob2RlKSA9PiB7XG4gICAgY29uc3QgaW5kZW50ID0gbnVsbCxcbiAgICAgICAgICBpZGVudGlmaWVyID0gbGlua01hcmtkb3duTm9kZS5pZGVudGlmaWVyKGNvbnRleHQpLFxuICAgICAgICAgIGlkZW50aWZpZXJzSW5jbHVkZXNJZGVudGlmaWVyID0gaWRlbnRpZmllcnMuaW5jbHVkZXMoaWRlbnRpZmllciksXG4gICAgICAgICAgbGlua01hcmtkb3duTm9kZUhUTUwgPSBsaW5rTWFya2Rvd25Ob2RlLmFzSFRNTChpbmRlbnQsIGNvbnRleHQpLFxuICAgICAgICAgIGluZGV4ID0gaW5kZXhPZihjaGlsZE5vZGVzSFRNTCwgbGlua01hcmtkb3duTm9kZUhUTUwpLFxuICAgICAgICAgIGxlbmd0aCA9IHN0cmxlbihsaW5rTWFya2Rvd25Ob2RlSFRNTCksXG4gICAgICAgICAgc3RhcnQgPSBpbmRleCwgIC8vL1xuICAgICAgICAgIGRlbGV0ZUNvdW50ID0gbGVuZ3RoOyAvLy9cblxuICAgIGlmIChpZGVudGlmaWVyc0luY2x1ZGVzSWRlbnRpZmllcikge1xuICAgICAgY29uc3QgbGlua01hcmtkb3duTm9kZUhUTUwgPSBsaW5rTWFya2Rvd25Ob2RlLmFzSFRNTChpbmRlbnQsIGNvbnRleHQsIG51bWJlcik7XG5cbiAgICAgIGNoaWxkTm9kZXNIVE1MID0gc3BsaWNlKGNoaWxkTm9kZXNIVE1MLCBzdGFydCwgZGVsZXRlQ291bnQsIGxpbmtNYXJrZG93bk5vZGVIVE1MKTtcblxuICAgICAgbnVtYmVyKys7XG4gICAgfSBlbHNlIHtcbiAgICAgIGNoaWxkTm9kZXNIVE1MID0gY2hvcChjaGlsZE5vZGVzSFRNTCwgc3RhcnQsIGRlbGV0ZUNvdW50KTtcbiAgICB9XG4gIH0pO1xuXG4gIHJldHVybiBjaGlsZE5vZGVzSFRNTDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHJlbnVtYmVyTGlua01hcmtkb3duTm9kZXMoZGl2aXNpb25NYXJrZG93bk5vZGUsIGZvb3Rub3Rlc0xpc3RNYXJrZG93bk5vZGUsIGNvbnRleHQpIHtcbiAgbGV0IG51bWJlciA9IDE7XG5cbiAgY29uc3QgaWRlbnRpZmllcnMgPSBmb290bm90ZXNMaXN0TWFya2Rvd25Ob2RlLmlkZW50aWZpZXJzKCksXG4gICAgICAgIGxpbmtNYXJrZG93bk5vZGVzID0gbGlua01hcmtkb3duTm9kZXNGcm9tTm9kZShkaXZpc2lvbk1hcmtkb3duTm9kZSk7XG5cbiAgbGlua01hcmtkb3duTm9kZXMuZm9yRWFjaCgobGlua01hcmtkb3duTm9kZSkgPT4ge1xuICAgIGNvbnN0IGlkZW50aWZpZXIgPSBsaW5rTWFya2Rvd25Ob2RlLmlkZW50aWZpZXIoY29udGV4dCksXG4gICAgICAgICAgbGlua01hcmtkb3duTm9kZURPTUVsZW1lbnQgPSBsaW5rTWFya2Rvd25Ob2RlLmdldERPTUVsZW1lbnQoKSxcbiAgICAgICAgICBpZGVudGlmaWVyc0luY2x1ZGVzSWRlbnRpZmllciA9IGlkZW50aWZpZXJzLmluY2x1ZGVzKGlkZW50aWZpZXIpO1xuXG4gICAgbGV0IGlubmVySFRNTDtcblxuICAgIGlmIChpZGVudGlmaWVyc0luY2x1ZGVzSWRlbnRpZmllcikge1xuICAgICAgaW5uZXJIVE1MID0gYCR7bnVtYmVyfWA7XG5cbiAgICAgIG51bWJlcisrO1xuICAgIH0gZWxzZSB7XG4gICAgICBpbm5lckhUTUwgPSBFTVBUWV9TVFJJTkc7XG4gICAgfVxuXG4gICAgT2JqZWN0LmFzc2lnbihsaW5rTWFya2Rvd25Ob2RlRE9NRWxlbWVudCwge1xuICAgICAgaW5uZXJIVE1MXG4gICAgfSk7XG4gIH0pO1xufVxuXG5leHBvcnQgZGVmYXVsdCB7XG4gIHJlbnVtYmVyTGlua01hcmtkb3duTm9kZXNcbn07XG4iXSwibmFtZXMiOlsicmVudW1iZXJMaW5rTWFya2Rvd25Ob2RlcyIsInJlbnVtYmVyTGlua01hcmtkb3duTm9kZXNIVE1MIiwic3RybGVuIiwic3RyaW5nVXRpbGl0aWVzIiwiaW5kZXhPZiIsImNoaWxkTm9kZXNIVE1MIiwiZGl2aXNpb25NYXJrZG93bk5vZGUiLCJmb290bm90ZXNMaXN0TWFya2Rvd25Ob2RlIiwiY29udGV4dCIsIm51bWJlciIsImlkZW50aWZpZXJzIiwibGlua01hcmtkb3duTm9kZXMiLCJsaW5rTWFya2Rvd25Ob2Rlc0Zyb21Ob2RlIiwiZm9yRWFjaCIsImxpbmtNYXJrZG93bk5vZGUiLCJpbmRlbnQiLCJpZGVudGlmaWVyIiwiaWRlbnRpZmllcnNJbmNsdWRlc0lkZW50aWZpZXIiLCJpbmNsdWRlcyIsImxpbmtNYXJrZG93bk5vZGVIVE1MIiwiYXNIVE1MIiwiaW5kZXgiLCJsZW5ndGgiLCJzdGFydCIsImRlbGV0ZUNvdW50Iiwic3BsaWNlIiwiY2hvcCIsImxpbmtNYXJrZG93bk5vZGVET01FbGVtZW50IiwiZ2V0RE9NRWxlbWVudCIsImlubmVySFRNTCIsIkVNUFRZX1NUUklORyIsIk9iamVjdCIsImFzc2lnbiJdLCJyYW5nZU1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7IiwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7OztJQW1FQSxPQUVFO2VBRkY7O0lBM0JnQkEseUJBQXlCO2VBQXpCQTs7SUE5QkFDLDZCQUE2QjtlQUE3QkE7Ozt5QkFSZ0I7eUJBRUg7c0JBQ0E7cUJBQ2E7QUFFMUMsSUFBUUMsU0FBb0JDLDBCQUFlLENBQW5DRCxRQUFRRSxVQUFZRCwwQkFBZSxDQUEzQkM7QUFFVCxTQUFTSCw4QkFBOEJJLGNBQWMsRUFBRUMsb0JBQW9CLEVBQUVDLHlCQUF5QixFQUFFQyxPQUFPO0lBQ3BILElBQUlDLFNBQVM7SUFFYixJQUFNQyxjQUFjSCwwQkFBMEJHLFdBQVcsSUFDbkRDLG9CQUFvQkMsSUFBQUEsZ0NBQXlCLEVBQUNOO0lBRXBESyxrQkFBa0JFLE9BQU8sQ0FBQyxTQUFDQztRQUN6QixJQUFNQyxTQUFTLE1BQ1RDLGFBQWFGLGlCQUFpQkUsVUFBVSxDQUFDUixVQUN6Q1MsZ0NBQWdDUCxZQUFZUSxRQUFRLENBQUNGLGFBQ3JERyx1QkFBdUJMLGlCQUFpQk0sTUFBTSxDQUFDTCxRQUFRUCxVQUN2RGEsUUFBUWpCLFFBQVFDLGdCQUFnQmMsdUJBQ2hDRyxTQUFTcEIsT0FBT2lCLHVCQUNoQkksUUFBUUYsT0FDUkcsY0FBY0YsUUFBUSxHQUFHO1FBRS9CLElBQUlMLCtCQUErQjtZQUNqQyxJQUFNRSx3QkFBdUJMLGlCQUFpQk0sTUFBTSxDQUFDTCxRQUFRUCxTQUFTQztZQUV0RUosaUJBQWlCb0IsSUFBQUEsY0FBTSxFQUFDcEIsZ0JBQWdCa0IsT0FBT0MsYUFBYUw7WUFFNURWO1FBQ0YsT0FBTztZQUNMSixpQkFBaUJxQixJQUFBQSxZQUFJLEVBQUNyQixnQkFBZ0JrQixPQUFPQztRQUMvQztJQUNGO0lBRUEsT0FBT25CO0FBQ1Q7QUFFTyxTQUFTTCwwQkFBMEJNLG9CQUFvQixFQUFFQyx5QkFBeUIsRUFBRUMsT0FBTztJQUNoRyxJQUFJQyxTQUFTO0lBRWIsSUFBTUMsY0FBY0gsMEJBQTBCRyxXQUFXLElBQ25EQyxvQkFBb0JDLElBQUFBLGdDQUF5QixFQUFDTjtJQUVwREssa0JBQWtCRSxPQUFPLENBQUMsU0FBQ0M7UUFDekIsSUFBTUUsYUFBYUYsaUJBQWlCRSxVQUFVLENBQUNSLFVBQ3pDbUIsNkJBQTZCYixpQkFBaUJjLGFBQWEsSUFDM0RYLGdDQUFnQ1AsWUFBWVEsUUFBUSxDQUFDRjtRQUUzRCxJQUFJYTtRQUVKLElBQUlaLCtCQUErQjtZQUNqQ1ksWUFBWSxBQUFDLEdBQVMsT0FBUHBCO1lBRWZBO1FBQ0YsT0FBTztZQUNMb0IsWUFBWUMsdUJBQVk7UUFDMUI7UUFFQUMsT0FBT0MsTUFBTSxDQUFDTCw0QkFBNEI7WUFDeENFLFdBQUFBO1FBQ0Y7SUFDRjtBQUNGO0lBRUEsV0FBZTtJQUNiN0IsMkJBQUFBO0FBQ0YifQ==