or tag. We found the following text: ' + text);
+ var wrapper = document.createElement('span');
+ wrapper.innerHTML = addedNode.nodeValue;
+ addedNode.parentNode.insertBefore(wrapper, addedNode);
+ addedNode.parentNode.removeChild(addedNode);
+ }
+ }
+ break;
+ }
+ }
+ } catch (err) {
+ _iterator13.e(err);
+ } finally {
+ _iterator13.f();
+ }
+ }
+ } catch (err) {
+ _iterator12.e(err);
+ } finally {
+ _iterator12.f();
+ }
+ }).observe(_this5, {
+ childList: true
+ });
+ return _this5;
+ }
+ _inherits(Article, _HTMLElement2);
+ return _createClass(Article, null, [{
+ key: "is",
+ get: function get() {
+ return 'd-article';
+ }
+ }]);
+ }(/*#__PURE__*/_wrapNativeSuper(HTMLElement));
+ var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof __webpack_require__.g !== 'undefined' ? __webpack_require__.g : typeof self !== 'undefined' ? self : {};
+ function createCommonjsModule(fn, module) {
+ return module = {
+ exports: {}
+ }, fn(module, module.exports), module.exports;
+ }
+ var bibtexParse = createCommonjsModule(function (module, exports) {
+ /* start bibtexParse 0.0.22 */
+
+ //Original work by Henrik Muehe (c) 2010
+ //
+ //CommonJS port by Mikola Lysenko 2013
+ //
+ //Port to Browser lib by ORCID / RCPETERS
+ //
+ //Issues:
+ //no comment handling within strings
+ //no string concatenation
+ //no variable values yet
+ //Grammar implemented here:
+ //bibtex -> (string | preamble | comment | entry)*;
+ //string -> '@STRING' '{' key_equals_value '}';
+ //preamble -> '@PREAMBLE' '{' value '}';
+ //comment -> '@COMMENT' '{' value '}';
+ //entry -> '@' key '{' key ',' key_value_list '}';
+ //key_value_list -> key_equals_value (',' key_equals_value)*;
+ //key_equals_value -> key '=' value;
+ //value -> value_quotes | value_braces | key;
+ //value_quotes -> '"' .*? '"'; // not quite
+ //value_braces -> '{' .*? '"'; // not quite
+ (function (exports) {
+ function BibtexParser() {
+ this.months = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+ this.notKey = [',', '{', '}', ' ', '='];
+ this.pos = 0;
+ this.input = "";
+ this.entries = new Array();
+ this.currentEntry = "";
+ this.setInput = function (t) {
+ this.input = t;
+ };
+ this.getEntries = function () {
+ return this.entries;
+ };
+ this.isWhitespace = function (s) {
+ return s == ' ' || s == '\r' || s == '\t' || s == '\n';
+ };
+ this.match = function (s, canCommentOut) {
+ if (canCommentOut == undefined || canCommentOut == null) canCommentOut = true;
+ this.skipWhitespace(canCommentOut);
+ if (this.input.substring(this.pos, this.pos + s.length) == s) {
+ this.pos += s.length;
+ } else {
+ throw "Token mismatch, expected " + s + ", found " + this.input.substring(this.pos);
+ }
+ this.skipWhitespace(canCommentOut);
+ };
+ this.tryMatch = function (s, canCommentOut) {
+ if (canCommentOut == undefined || canCommentOut == null) canCommentOut = true;
+ this.skipWhitespace(canCommentOut);
+ if (this.input.substring(this.pos, this.pos + s.length) == s) {
+ return true;
+ } else {
+ return false;
+ }
+ };
+
+ /* when search for a match all text can be ignored, not just white space */
+ this.matchAt = function () {
+ while (this.input.length > this.pos && this.input[this.pos] != '@') {
+ this.pos++;
+ }
+ if (this.input[this.pos] == '@') {
+ return true;
+ }
+ return false;
+ };
+ this.skipWhitespace = function (canCommentOut) {
+ while (this.isWhitespace(this.input[this.pos])) {
+ this.pos++;
+ }
+ if (this.input[this.pos] == "%" && canCommentOut == true) {
+ while (this.input[this.pos] != "\n") {
+ this.pos++;
+ }
+ this.skipWhitespace(canCommentOut);
+ }
+ };
+ this.value_braces = function () {
+ var bracecount = 0;
+ this.match("{", false);
+ var start = this.pos;
+ var escaped = false;
+ while (true) {
+ if (!escaped) {
+ if (this.input[this.pos] == '}') {
+ if (bracecount > 0) {
+ bracecount--;
+ } else {
+ var end = this.pos;
+ this.match("}", false);
+ return this.input.substring(start, end);
+ }
+ } else if (this.input[this.pos] == '{') {
+ bracecount++;
+ } else if (this.pos >= this.input.length - 1) {
+ throw "Unterminated value";
+ }
+ }
+ if (this.input[this.pos] == '\\' && escaped == false) escaped = true;else escaped = false;
+ this.pos++;
+ }
+ };
+ this.value_comment = function () {
+ var str = '';
+ var brcktCnt = 0;
+ while (!(this.tryMatch("}", false) && brcktCnt == 0)) {
+ str = str + this.input[this.pos];
+ if (this.input[this.pos] == '{') brcktCnt++;
+ if (this.input[this.pos] == '}') brcktCnt--;
+ if (this.pos >= this.input.length - 1) {
+ throw "Unterminated value:" + this.input.substring(start);
+ }
+ this.pos++;
+ }
+ return str;
+ };
+ this.value_quotes = function () {
+ this.match('"', false);
+ var start = this.pos;
+ var escaped = false;
+ while (true) {
+ if (!escaped) {
+ if (this.input[this.pos] == '"') {
+ var end = this.pos;
+ this.match('"', false);
+ return this.input.substring(start, end);
+ } else if (this.pos >= this.input.length - 1) {
+ throw "Unterminated value:" + this.input.substring(start);
+ }
+ }
+ if (this.input[this.pos] == '\\' && escaped == false) escaped = true;else escaped = false;
+ this.pos++;
+ }
+ };
+ this.single_value = function () {
+ var start = this.pos;
+ if (this.tryMatch("{")) {
+ return this.value_braces();
+ } else if (this.tryMatch('"')) {
+ return this.value_quotes();
+ } else {
+ var k = this.key();
+ if (k.match("^[0-9]+$")) return k;else if (this.months.indexOf(k.toLowerCase()) >= 0) return k.toLowerCase();else throw "Value expected:" + this.input.substring(start) + ' for key: ' + k;
+ }
+ };
+ this.value = function () {
+ var values = [];
+ values.push(this.single_value());
+ while (this.tryMatch("#")) {
+ this.match("#");
+ values.push(this.single_value());
+ }
+ return values.join("");
+ };
+ this.key = function () {
+ var start = this.pos;
+ while (true) {
+ if (this.pos >= this.input.length) {
+ throw "Runaway key";
+ } // а-яА-Я is Cyrillic
+ //console.log(this.input[this.pos]);
+ if (this.notKey.indexOf(this.input[this.pos]) >= 0) {
+ return this.input.substring(start, this.pos);
+ } else {
+ this.pos++;
+ }
+ }
+ };
+ this.key_equals_value = function () {
+ var key = this.key();
+ if (this.tryMatch("=")) {
+ this.match("=");
+ var val = this.value();
+ return [key, val];
+ } else {
+ throw "... = value expected, equals sign missing:" + this.input.substring(this.pos);
+ }
+ };
+ this.key_value_list = function () {
+ var kv = this.key_equals_value();
+ this.currentEntry['entryTags'] = {};
+ this.currentEntry['entryTags'][kv[0]] = kv[1];
+ while (this.tryMatch(",")) {
+ this.match(",");
+ // fixes problems with commas at the end of a list
+ if (this.tryMatch("}")) {
+ break;
+ }
+ kv = this.key_equals_value();
+ this.currentEntry['entryTags'][kv[0]] = kv[1];
+ }
+ };
+ this.entry_body = function (d) {
+ this.currentEntry = {};
+ this.currentEntry['citationKey'] = this.key();
+ this.currentEntry['entryType'] = d.substring(1);
+ this.match(",");
+ this.key_value_list();
+ this.entries.push(this.currentEntry);
+ };
+ this.directive = function () {
+ this.match("@");
+ return "@" + this.key();
+ };
+ this.preamble = function () {
+ this.currentEntry = {};
+ this.currentEntry['entryType'] = 'PREAMBLE';
+ this.currentEntry['entry'] = this.value_comment();
+ this.entries.push(this.currentEntry);
+ };
+ this.comment = function () {
+ this.currentEntry = {};
+ this.currentEntry['entryType'] = 'COMMENT';
+ this.currentEntry['entry'] = this.value_comment();
+ this.entries.push(this.currentEntry);
+ };
+ this.entry = function (d) {
+ this.entry_body(d);
+ };
+ this.bibtex = function () {
+ while (this.matchAt()) {
+ var d = this.directive();
+ this.match("{");
+ if (d == "@STRING") {
+ this.string();
+ } else if (d == "@PREAMBLE") {
+ this.preamble();
+ } else if (d == "@COMMENT") {
+ this.comment();
+ } else {
+ this.entry(d);
+ }
+ this.match("}");
+ }
+ };
+ }
+ exports.toJSON = function (bibtex) {
+ var b = new BibtexParser();
+ b.setInput(bibtex);
+ b.bibtex();
+ return b.entries;
+ };
+
+ /* added during hackathon don't hate on me */
+ exports.toBibtex = function (json) {
+ var out = '';
+ for (var i in json) {
+ out += "@" + json[i].entryType;
+ out += '{';
+ if (json[i].citationKey) out += json[i].citationKey + ', ';
+ if (json[i].entry) out += json[i].entry;
+ if (json[i].entryTags) {
+ var tags = '';
+ for (var jdx in json[i].entryTags) {
+ if (tags.length != 0) tags += ', ';
+ tags += jdx + '= {' + json[i].entryTags[jdx] + '}';
+ }
+ out += tags;
+ }
+ out += '}\n\n';
+ }
+ return out;
+ };
+ })(exports);
+
+ /* end bibtexParse */
+ });
+
+ // Copyright 2018 The Distill Template Authors
+
+ function normalizeTag(string) {
+ return string.replace(/[\t\n ]+/g, ' ').replace(/{\\["^`.'acu~Hvs]( )?([a-zA-Z])}/g, function (full, x, _char) {
+ return _char;
+ }).replace(/{\\([a-zA-Z])}/g, function (full, _char2) {
+ return _char2;
+ });
+ }
+ function parseBibtex(bibtex) {
+ var bibliography = new Map();
+ var parsedEntries = bibtexParse.toJSON(bibtex);
+ var _iterator14 = _createForOfIteratorHelper(parsedEntries),
+ _step14;
+ try {
+ for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+ var entry = _step14.value;
+ // normalize tags; note entryTags is an object, not Map
+ for (var _i = 0, _Object$entries = Object.entries(entry.entryTags); _i < _Object$entries.length; _i++) {
+ var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+ key = _Object$entries$_i[0],
+ value = _Object$entries$_i[1];
+ entry.entryTags[key.toLowerCase()] = normalizeTag(value);
+ }
+ entry.entryTags.type = entry.entryType;
+ // add to bibliography
+ bibliography.set(entry.citationKey, entry.entryTags);
+ }
+ } catch (err) {
+ _iterator14.e(err);
+ } finally {
+ _iterator14.f();
+ }
+ return bibliography;
+ }
+ function serializeFrontmatterToBibtex(frontMatter) {
+ return "@article{".concat(frontMatter.slug, ",\n author = {").concat(frontMatter.bibtexAuthors, "},\n title = {").concat(frontMatter.title, "},\n journal = {").concat(frontMatter.journal.title, "},\n year = {").concat(frontMatter.publishedYear, "},\n note = {").concat(frontMatter.url, "},\n doi = {").concat(frontMatter.doi, "}\n}");
+ }
+
+ // Copyright 2018 The Distill Template Authors
+ var Bibliography = /*#__PURE__*/function (_HTMLElement3) {
+ function Bibliography() {
+ var _this6;
+ _classCallCheck(this, Bibliography);
+ _this6 = _callSuper(this, Bibliography);
+
+ // set up mutation observer
+ var options = {
+ childList: true,
+ characterData: true,
+ subtree: true
+ };
+ var observer = new MutationObserver(function (entries) {
+ var _iterator15 = _createForOfIteratorHelper(entries),
+ _step15;
+ try {
+ for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
+ var entry = _step15.value;
+ if (entry.target.nodeName === 'SCRIPT' || entry.type === 'characterData') {
+ _this6.parseIfPossible();
+ }
+ }
+ } catch (err) {
+ _iterator15.e(err);
+ } finally {
+ _iterator15.f();
+ }
+ });
+ observer.observe(_this6, options);
+ return _this6;
+ }
+ _inherits(Bibliography, _HTMLElement3);
+ return _createClass(Bibliography, [{
+ key: "connectedCallback",
+ value: function connectedCallback() {
+ var _this7 = this;
+ requestAnimationFrame(function () {
+ _this7.parseIfPossible();
+ });
+ }
+ }, {
+ key: "parseIfPossible",
+ value: function parseIfPossible() {
+ var scriptTag = this.querySelector('script');
+ if (!scriptTag) return;
+ if (scriptTag.type == 'text/bibtex') {
+ var newBibtex = scriptTag.textContent;
+ if (this.bibtex !== newBibtex) {
+ this.bibtex = newBibtex;
+ var bibliography = parseBibtex(this.bibtex);
+ this.notify(bibliography);
+ }
+ } else if (scriptTag.type == 'text/json') {
+ var _bibliography = new Map(JSON.parse(scriptTag.textContent));
+ this.notify(_bibliography);
+ } else {
+ console.warn('Unsupported bibliography script tag type: ' + scriptTag.type);
+ }
+ }
+ }, {
+ key: "notify",
+ value: function notify(bibliography) {
+ var options = {
+ detail: bibliography,
+ bubbles: true
+ };
+ var event = new CustomEvent('onBibliographyChanged', options);
+ this.dispatchEvent(event);
+ }
+
+ /* observe 'src' attribute */
+ }, {
+ key: "receivedBibtex",
+ value: function receivedBibtex(event) {
+ var bibliography = parseBibtex(event.target.response);
+ this.notify(bibliography);
+ }
+ }, {
+ key: "attributeChangedCallback",
+ value: function attributeChangedCallback(name, oldValue, newValue) {
+ var _this8 = this;
+ var oReq = new XMLHttpRequest();
+ oReq.onload = function (e) {
+ return _this8.receivedBibtex(e);
+ };
+ oReq.onerror = function () {
+ return console.warn("Could not load Bibtex! (tried ".concat(newValue, ")"));
+ };
+ oReq.responseType = 'text';
+ oReq.open('GET', newValue, true);
+ oReq.send();
+ }
+ }], [{
+ key: "is",
+ get: function get() {
+ return 'd-bibliography';
+ }
+ }, {
+ key: "observedAttributes",
+ get: function get() {
+ return ['src'];
+ }
+ }]);
+ }(/*#__PURE__*/_wrapNativeSuper(HTMLElement)); // Copyright 2018 The Distill Template Authors
+ //
+ // 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.
+ // import style from '../styles/d-byline.css';
+ function bylineTemplate(frontMatter) {
+ return "\n
\n
\n
\n
\n
Published \n
Apr 8, 2025
\n
\n
\n
Download \n
\n \n
\n
\n");
+ var Cite = /*#__PURE__*/function (_T$3) {
+ /* Lifecycle */
+ function Cite() {
+ var _this9;
+ _classCallCheck(this, Cite);
+ _this9 = _callSuper(this, Cite);
+ _this9._numbers = [];
+ _this9._entries = [];
+ return _this9;
+ }
+ _inherits(Cite, _T$3);
+ return _createClass(Cite, [{
+ key: "connectedCallback",
+ value: function connectedCallback() {
+ var _this10 = this;
+ this.outerSpan = this.root.querySelector("#citation-");
+ this.innerSpan = this.root.querySelector(".citation-number");
+ this.hoverBox = this.root.querySelector("d-hover-box");
+ window.customElements.whenDefined("d-hover-box").then(function () {
+ _this10.hoverBox.listen(_this10);
+ });
+ // in case this component got connected after values were set
+ if (this.numbers) {
+ this.displayNumbers(this.numbers);
+ }
+ if (this.entries) {
+ this.displayEntries(this.entries);
+ }
+ }
+
+ //TODO This causes an infinite loop on firefox with polyfills.
+ // This is only needed for interactive editing so no priority.
+ // disconnectedCallback() {
+ // const options = { detail: [this, this.keys], bubbles: true };
+ // const event = new CustomEvent('onCiteKeyRemoved', options);
+ // document.dispatchEvent(event);
+ // }
+
+ /* observe 'key' attribute */
+ }, {
+ key: "attributeChangedCallback",
+ value: function attributeChangedCallback(name, oldValue, newValue) {
+ var eventName = oldValue ? "onCiteKeyChanged" : "onCiteKeyCreated";
+ var keys = newValue.split(",").map(function (k) {
+ return k.trim();
+ });
+ var options = {
+ detail: [this, keys],
+ bubbles: true
+ };
+ var event = new CustomEvent(eventName, options);
+ document.dispatchEvent(event);
+ }
+ }, {
+ key: "key",
+ get: function get() {
+ return this.getAttribute("key") || this.getAttribute("bibtex-key");
+ },
+ set: function set(value) {
+ this.setAttribute("key", value);
+ }
+ }, {
+ key: "keys",
+ get: function get() {
+ var result = this.key.split(",");
+ console.log(result);
+ return result;
+ }
+
+ /* Setters & Rendering */
+ }, {
+ key: "numbers",
+ get: function get() {
+ return this._numbers;
+ },
+ set: function set(numbers) {
+ this._numbers = numbers;
+ this.displayNumbers(numbers);
+ }
+ }, {
+ key: "displayNumbers",
+ value: function displayNumbers(numbers) {
+ if (!this.innerSpan) return;
+ var numberStrings = numbers.map(function (index) {
+ return index == -1 ? "?" : index + 1 + "";
+ });
+ var textContent = "[" + numberStrings.join(", ") + "]";
+ this.innerSpan.textContent = textContent;
+ }
+ }, {
+ key: "entries",
+ get: function get() {
+ return this._entries;
+ },
+ set: function set(entries) {
+ this._entries = entries;
+ this.displayEntries(entries);
+ }
+ }, {
+ key: "displayEntries",
+ value: function displayEntries(entries) {
+ if (!this.hoverBox) return;
+ this.hoverBox.innerHTML = "\n ".concat(entries.map(hover_cite).map(function (html) {
+ return "".concat(html, " ");
+ }).join("\n"), "\n ");
+ }
+ }], [{
+ key: "observedAttributes",
+ get: function get() {
+ return ["key", "bibtex-key"];
+ }
+ }]);
+ }(T$3(HTMLElement)); // Copyright 2018 The Distill Template Authors
+ var styles$1 = "\nd-citation-list {\n contain: style;\n}\n\nd-citation-list .references {\n grid-column: text;\n}\n\nd-citation-list .references .title {\n font-weight: 500;\n}\n";
+ function renderCitationList(element, entries) {
+ var dom = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : document;
+ if (entries.size > 0) {
+ element.style.display = '';
+ var list = element.querySelector('.references');
+ if (list) {
+ list.innerHTML = '';
+ } else {
+ var stylesTag = dom.createElement('style');
+ stylesTag.innerHTML = styles$1;
+ element.appendChild(stylesTag);
+ var heading = dom.createElement('h3');
+ heading.id = 'references';
+ heading.textContent = 'References';
+ element.appendChild(heading);
+ list = dom.createElement('ol');
+ list.id = 'references-list';
+ list.className = 'references';
+ element.appendChild(list);
+ }
+ var _iterator16 = _createForOfIteratorHelper(entries),
+ _step16;
+ try {
+ for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
+ var _step16$value = _slicedToArray(_step16.value, 2),
+ key = _step16$value[0],
+ entry = _step16$value[1];
+ var listItem = dom.createElement('li');
+ listItem.id = key;
+ listItem.innerHTML = bibliography_cite(entry);
+ list.appendChild(listItem);
+ }
+ } catch (err) {
+ _iterator16.e(err);
+ } finally {
+ _iterator16.f();
+ }
+ } else {
+ element.style.display = 'none';
+ }
+ }
+ var CitationList = /*#__PURE__*/function (_HTMLElement5) {
+ function CitationList() {
+ _classCallCheck(this, CitationList);
+ return _callSuper(this, CitationList, arguments);
+ }
+ _inherits(CitationList, _HTMLElement5);
+ return _createClass(CitationList, [{
+ key: "connectedCallback",
+ value: function connectedCallback() {
+ if (!this.hasAttribute('distill-prerendered')) {
+ this.style.display = 'none';
+ }
+ }
+ }, {
+ key: "citations",
+ set: function set(citations) {
+ renderCitationList(this, citations);
+ }
+ }], [{
+ key: "is",
+ get: function get() {
+ return 'd-citation-list';
+ }
+ }]);
+ }(/*#__PURE__*/_wrapNativeSuper(HTMLElement));
+ var prism = createCommonjsModule(function (module) {
+ /* **********************************************
+ Begin prism-core.js
+ ********************************************** */
+
+ var _self = typeof window !== 'undefined' ? window // if in browser
+ : typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope ? self // if in worker
+ : {} // if in node js
+ ;
+
+ /**
+ * Prism: Lightweight, robust, elegant syntax highlighting
+ * MIT license http://www.opensource.org/licenses/mit-license.php/
+ * @author Lea Verou http://lea.verou.me
+ */
+
+ var Prism = function (_self) {
+ // Private helper vars
+ var lang = /\blang(?:uage)?-([\w-]+)\b/i;
+ var uniqueId = 0;
+ var _ = {
+ manual: _self.Prism && _self.Prism.manual,
+ disableWorkerMessageHandler: _self.Prism && _self.Prism.disableWorkerMessageHandler,
+ util: {
+ encode: function encode(tokens) {
+ if (tokens instanceof Token) {
+ return new Token(tokens.type, encode(tokens.content), tokens.alias);
+ } else if (Array.isArray(tokens)) {
+ return tokens.map(encode);
+ } else {
+ return tokens.replace(/&/g, '&').replace(/' + env.content + '';
+ };
+
+ /**
+ * @param {string} text
+ * @param {LinkedList} tokenList
+ * @param {any} grammar
+ * @param {LinkedListNode} startNode
+ * @param {number} startPos
+ * @param {boolean} [oneshot=false]
+ * @param {string} [target]
+ */
+ function matchGrammar(text, tokenList, grammar, startNode, startPos, oneshot, target) {
+ for (var token in grammar) {
+ if (!grammar.hasOwnProperty(token) || !grammar[token]) {
+ continue;
+ }
+ var patterns = grammar[token];
+ patterns = Array.isArray(patterns) ? patterns : [patterns];
+ for (var j = 0; j < patterns.length; ++j) {
+ if (target && target == token + ',' + j) {
+ return;
+ }
+ var pattern = patterns[j],
+ inside = pattern.inside,
+ lookbehind = !!pattern.lookbehind,
+ greedy = !!pattern.greedy,
+ lookbehindLength = 0,
+ alias = pattern.alias;
+ if (greedy && !pattern.pattern.global) {
+ // Without the global flag, lastIndex won't work
+ var flags = pattern.pattern.toString().match(/[imsuy]*$/)[0];
+ pattern.pattern = RegExp(pattern.pattern.source, flags + 'g');
+ }
+ pattern = pattern.pattern || pattern;
+ for (
+ // iterate the token list and keep track of the current token/string position
+ var currentNode = startNode.next, pos = startPos; currentNode !== tokenList.tail; pos += currentNode.value.length, currentNode = currentNode.next) {
+ var str = currentNode.value;
+ if (tokenList.length > text.length) {
+ // Something went terribly wrong, ABORT, ABORT!
+ return;
+ }
+ if (str instanceof Token) {
+ continue;
+ }
+ var removeCount = 1; // this is the to parameter of removeBetween
+
+ if (greedy && currentNode != tokenList.tail.prev) {
+ pattern.lastIndex = pos;
+ var match = pattern.exec(text);
+ if (!match) {
+ break;
+ }
+ var from = match.index + (lookbehind && match[1] ? match[1].length : 0);
+ var to = match.index + match[0].length;
+ var p = pos;
+
+ // find the node that contains the match
+ p += currentNode.value.length;
+ while (from >= p) {
+ currentNode = currentNode.next;
+ p += currentNode.value.length;
+ }
+ // adjust pos (and p)
+ p -= currentNode.value.length;
+ pos = p;
+
+ // the current node is a Token, then the match starts inside another Token, which is invalid
+ if (currentNode.value instanceof Token) {
+ continue;
+ }
+
+ // find the last node which is affected by this match
+ for (var k = currentNode; k !== tokenList.tail && (p < to || typeof k.value === 'string' && !k.prev.value.greedy); k = k.next) {
+ removeCount++;
+ p += k.value.length;
+ }
+ removeCount--;
+
+ // replace with the new match
+ str = text.slice(pos, p);
+ match.index -= pos;
+ } else {
+ pattern.lastIndex = 0;
+ var match = pattern.exec(str);
+ }
+ if (!match) {
+ if (oneshot) {
+ break;
+ }
+ continue;
+ }
+ if (lookbehind) {
+ lookbehindLength = match[1] ? match[1].length : 0;
+ }
+ var from = match.index + lookbehindLength,
+ match = match[0].slice(lookbehindLength),
+ to = from + match.length,
+ before = str.slice(0, from),
+ after = str.slice(to);
+ var removeFrom = currentNode.prev;
+ if (before) {
+ removeFrom = addAfter(tokenList, removeFrom, before);
+ pos += before.length;
+ }
+ removeRange(tokenList, removeFrom, removeCount);
+ var wrapped = new Token(token, inside ? _.tokenize(match, inside) : match, alias, match, greedy);
+ currentNode = addAfter(tokenList, removeFrom, wrapped);
+ if (after) {
+ addAfter(tokenList, currentNode, after);
+ }
+ if (removeCount > 1) matchGrammar(text, tokenList, grammar, currentNode.prev, pos, true, token + ',' + j);
+ if (oneshot) break;
+ }
+ }
+ }
+ }
+
+ /**
+ * @typedef LinkedListNode
+ * @property {T} value
+ * @property {LinkedListNode | null} prev The previous node.
+ * @property {LinkedListNode | null} next The next node.
+ * @template T
+ */
+
+ /**
+ * @template T
+ */
+ function LinkedList() {
+ /** @type {LinkedListNode} */
+ var head = {
+ value: null,
+ prev: null,
+ next: null
+ };
+ /** @type {LinkedListNode} */
+ var tail = {
+ value: null,
+ prev: head,
+ next: null
+ };
+ head.next = tail;
+
+ /** @type {LinkedListNode} */
+ this.head = head;
+ /** @type {LinkedListNode} */
+ this.tail = tail;
+ this.length = 0;
+ }
+
+ /**
+ * Adds a new node with the given value to the list.
+ * @param {LinkedList} list
+ * @param {LinkedListNode} node
+ * @param {T} value
+ * @returns {LinkedListNode} The added node.
+ * @template T
+ */
+ function addAfter(list, node, value) {
+ // assumes that node != list.tail && values.length >= 0
+ var next = node.next;
+ var newNode = {
+ value: value,
+ prev: node,
+ next: next
+ };
+ node.next = newNode;
+ next.prev = newNode;
+ list.length++;
+ return newNode;
+ }
+ /**
+ * Removes `count` nodes after the given node. The given node will not be removed.
+ * @param {LinkedList} list
+ * @param {LinkedListNode} node
+ * @param {number} count
+ * @template T
+ */
+ function removeRange(list, node, count) {
+ var next = node.next;
+ for (var i = 0; i < count && next !== list.tail; i++) {
+ next = next.next;
+ }
+ node.next = next;
+ next.prev = node;
+ list.length -= i;
+ }
+ /**
+ * @param {LinkedList} list
+ * @returns {T[]}
+ * @template T
+ */
+ function toArray(list) {
+ var array = [];
+ var node = list.head.next;
+ while (node !== list.tail) {
+ array.push(node.value);
+ node = node.next;
+ }
+ return array;
+ }
+ if (!_self.document) {
+ if (!_self.addEventListener) {
+ // in Node.js
+ return _;
+ }
+ if (!_.disableWorkerMessageHandler) {
+ // In worker
+ _self.addEventListener('message', function (evt) {
+ var message = JSON.parse(evt.data),
+ lang = message.language,
+ code = message.code,
+ immediateClose = message.immediateClose;
+ _self.postMessage(_.highlight(code, _.languages[lang], lang));
+ if (immediateClose) {
+ _self.close();
+ }
+ }, false);
+ }
+ return _;
+ }
+
+ //Get current script and highlight
+ var script = _.util.currentScript();
+ if (script) {
+ _.filename = script.src;
+ if (script.hasAttribute('data-manual')) {
+ _.manual = true;
+ }
+ }
+ function highlightAutomaticallyCallback() {
+ if (!_.manual) {
+ _.highlightAll();
+ }
+ }
+ if (!_.manual) {
+ // If the document state is "loading", then we'll use DOMContentLoaded.
+ // If the document state is "interactive" and the prism.js script is deferred, then we'll also use the
+ // DOMContentLoaded event because there might be some plugins or languages which have also been deferred and they
+ // might take longer one animation frame to execute which can create a race condition where only some plugins have
+ // been loaded when Prism.highlightAll() is executed, depending on how fast resources are loaded.
+ // See https://github.com/PrismJS/prism/issues/2102
+ var readyState = document.readyState;
+ if (readyState === 'loading' || readyState === 'interactive' && script && script.defer) {
+ document.addEventListener('DOMContentLoaded', highlightAutomaticallyCallback);
+ } else {
+ if (window.requestAnimationFrame) {
+ window.requestAnimationFrame(highlightAutomaticallyCallback);
+ } else {
+ window.setTimeout(highlightAutomaticallyCallback, 16);
+ }
+ }
+ }
+ return _;
+ }(_self);
+ if (module.exports) {
+ module.exports = Prism;
+ }
+
+ // hack for components to work correctly in node.js
+ if (typeof commonjsGlobal !== 'undefined') {
+ commonjsGlobal.Prism = Prism;
+ }
+
+ /* **********************************************
+ Begin prism-markup.js
+ ********************************************** */
+
+ Prism.languages.markup = {
+ 'comment': //,
+ 'prolog': /<\?[\s\S]+?\?>/,
+ 'doctype': {
+ pattern: /"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:(?!)*\]\s*)?>/i,
+ greedy: true
+ },
+ 'cdata': //i,
+ 'tag': {
+ pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/i,
+ greedy: true,
+ inside: {
+ 'tag': {
+ pattern: /^<\/?[^\s>\/]+/i,
+ inside: {
+ 'punctuation': /^<\/?/,
+ 'namespace': /^[^\s>\/:]+:/
+ }
+ },
+ 'attr-value': {
+ pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/i,
+ inside: {
+ 'punctuation': [/^=/, {
+ pattern: /^(\s*)["']|["']$/,
+ lookbehind: true
+ }]
+ }
+ },
+ 'punctuation': /\/?>/,
+ 'attr-name': {
+ pattern: /[^\s>\/]+/,
+ inside: {
+ 'namespace': /^[^\s>\/:]+:/
+ }
+ }
+ }
+ },
+ 'entity': /&#?[\da-z]{1,8};/i
+ };
+ Prism.languages.markup['tag'].inside['attr-value'].inside['entity'] = Prism.languages.markup['entity'];
+
+ // Plugin to make entity title show the real entity, idea by Roman Komarov
+ Prism.hooks.add('wrap', function (env) {
+ if (env.type === 'entity') {
+ env.attributes['title'] = env.content.replace(/&/, '&');
+ }
+ });
+ Object.defineProperty(Prism.languages.markup.tag, 'addInlined', {
+ /**
+ * Adds an inlined language to markup.
+ *
+ * An example of an inlined language is CSS with `\n\n block to let us know how to highlight your code; e.g.:\n zeros = np.zeros(shape) .');
+ return;
+ }
+ var language = prism.languages[this.languageName];
+ if (language == undefined) {
+ console.warn("Distill does not yet support highlighting your code block in \"".concat(this.languageName, "'."));
+ return;
+ }
+ var content = this.textContent;
+ var codeTag = this.shadowRoot.querySelector('#code-container');
+ if (this.hasAttribute('block')) {
+ // normalize the tab indents
+ content = content.replace(/\n/, '');
+ var tabs = content.match(/\s*/);
+ content = content.replace(new RegExp('\n' + tabs, 'g'), '\n');
+ content = content.trim();
+ // wrap code block in pre tag if needed
+ if (codeTag.parentNode instanceof ShadowRoot) {
+ var preTag = document.createElement('pre');
+ this.shadowRoot.removeChild(codeTag);
+ preTag.appendChild(codeTag);
+ this.shadowRoot.appendChild(preTag);
+ }
+ }
+ codeTag.className = "language-".concat(this.languageName);
+ codeTag.innerHTML = prism.highlight(content, language);
+ }
+ }]);
+ }(Mutating(T$4(HTMLElement))); // Copyright 2018 The Distill Template Authors
+ var T$5 = Template('d-footnote', "\n\n\n\n \n \n\n\n \n\n");
+ var Footnote = /*#__PURE__*/function (_T$4) {
+ function Footnote() {
+ var _this11;
+ _classCallCheck(this, Footnote);
+ _this11 = _callSuper(this, Footnote);
+ var options = {
+ childList: true,
+ characterData: true,
+ subtree: true
+ };
+ var observer = new MutationObserver(_this11.notify);
+ observer.observe(_this11, options);
+ return _this11;
+ }
+ _inherits(Footnote, _T$4);
+ return _createClass(Footnote, [{
+ key: "notify",
+ value: function notify() {
+ var options = {
+ detail: this,
+ bubbles: true
+ };
+ var event = new CustomEvent('onFootnoteChanged', options);
+ document.dispatchEvent(event);
+ }
+ }, {
+ key: "connectedCallback",
+ value: function connectedCallback() {
+ var _this12 = this;
+ // listen and notify about changes to slotted content
+ // const slot = this.shadowRoot.querySelector('#slot');
+ // console.warn(slot.textContent);
+ // slot.addEventListener('slotchange', this.notify);
+ this.hoverBox = this.root.querySelector('d-hover-box');
+ window.customElements.whenDefined('d-hover-box').then(function () {
+ _this12.hoverBox.listen(_this12);
+ });
+ // create numeric ID
+ Footnote.currentFootnoteId += 1;
+ var IdString = Footnote.currentFootnoteId.toString();
+ this.root.host.id = 'd-footnote-' + IdString;
+
+ // set up hidden hover box
+ var id = 'dt-fn-hover-box-' + IdString;
+ this.hoverBox.id = id;
+
+ // set up visible footnote marker
+ var span = this.root.querySelector('#fn-');
+ span.setAttribute('id', 'fn-' + IdString);
+ span.setAttribute('data-hover-ref', id);
+ span.textContent = IdString;
+ }
+ }]);
+ }(T$5(HTMLElement));
+ Footnote.currentFootnoteId = 0;
+
+ // Copyright 2018 The Distill Template Authors
+
+ var T$6 = Template('d-footnote-list', "\n\n\nFootnotes \nTable of contents \n ";
+ var _iterator18 = _createForOfIteratorHelper(headings),
+ _step18;
+ try {
+ for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
+ var el = _step18.value;
+ // should element be included in TOC?
+ var isInTitle = el.parentElement.tagName == 'D-TITLE';
+ var isException = el.getAttribute('no-toc');
+ if (isInTitle || isException) continue;
+ // create TOC entry
+ var _title = el.textContent;
+ var link = '#' + el.getAttribute('id');
+ var newLine = '' + '' + _title + ' ' + ' ';
+ if (el.tagName == 'H3') {
+ newLine = '';
+ } else {
+ newLine += ' ';
+ element.innerHTML = ToC;
+ }
+
+ // Copyright 2018 The Distill Template Authors
+ //
+ // 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.
+
+ // Figure
+ //
+ // d-figure provides a state-machine of visibility events:
+ //
+ // scroll out of view
+ // +----------------+
+ // *do work here* | |
+ // +----------------+ +-+---------+ +-v---------+
+ // | ready +----> onscreen | | offscreen |
+ // +----------------+ +---------^-+ +---------+-+
+ // | |
+ // +----------------+
+ // scroll into view
+ //
+ var Figure = /*#__PURE__*/function (_HTMLElement8) {
+ function Figure() {
+ var _this17;
+ _classCallCheck(this, Figure);
+ _this17 = _callSuper(this, Figure);
+ // debugger
+ _this17._ready = false;
+ _this17._onscreen = false;
+ _this17._offscreen = true;
+ return _this17;
+ }
+ _inherits(Figure, _HTMLElement8);
+ return _createClass(Figure, [{
+ key: "connectedCallback",
+ value: function connectedCallback() {
+ this.loadsWhileScrolling = this.hasAttribute('loadsWhileScrolling');
+ Figure.marginObserver.observe(this);
+ Figure.directObserver.observe(this);
+ }
+ }, {
+ key: "disconnectedCallback",
+ value: function disconnectedCallback() {
+ Figure.marginObserver.unobserve(this);
+ Figure.directObserver.unobserve(this);
+ }
+
+ // We use two separate observers:
+ // One with an extra 1000px margin to warn if the viewpoint gets close,
+ // And one for the actual on/off screen events
+ }, {
+ key: "addEventListener",
+ value:
+ // Notify listeners that registered late, too:
+
+ function addEventListener(eventName, callback) {
+ _superPropGet(Figure, "addEventListener", this, 3)([eventName, callback]);
+ // if we had already dispatched something while presumingly no one was listening, we do so again
+ // debugger
+ if (eventName === 'ready') {
+ if (Figure.readyQueue.indexOf(this) !== -1) {
+ this._ready = false;
+ Figure.runReadyQueue();
+ }
+ }
+ if (eventName === 'onscreen') {
+ this.onscreen();
+ }
+ }
+
+ // Custom Events
+ }, {
+ key: "ready",
+ value: function ready() {
+ // debugger
+ this._ready = true;
+ Figure.marginObserver.unobserve(this);
+ var event = new CustomEvent('ready');
+ this.dispatchEvent(event);
+ }
+ }, {
+ key: "onscreen",
+ value: function onscreen() {
+ this._onscreen = true;
+ this._offscreen = false;
+ var event = new CustomEvent('onscreen');
+ this.dispatchEvent(event);
+ }
+ }, {
+ key: "offscreen",
+ value: function offscreen() {
+ this._onscreen = false;
+ this._offscreen = true;
+ var event = new CustomEvent('offscreen');
+ this.dispatchEvent(event);
+ }
+ }], [{
+ key: "is",
+ get: function get() {
+ return 'd-figure';
+ }
+ }, {
+ key: "readyQueue",
+ get: function get() {
+ if (!Figure._readyQueue) {
+ Figure._readyQueue = [];
+ }
+ return Figure._readyQueue;
+ }
+ }, {
+ key: "addToReadyQueue",
+ value: function addToReadyQueue(figure) {
+ if (Figure.readyQueue.indexOf(figure) === -1) {
+ Figure.readyQueue.push(figure);
+ Figure.runReadyQueue();
+ }
+ }
+ }, {
+ key: "runReadyQueue",
+ value: function runReadyQueue() {
+ // console.log("Checking to run readyQueue, length: " + Figure.readyQueue.length + ", scrolling: " + Figure.isScrolling);
+ // if (Figure.isScrolling) return;
+ // console.log("Running ready Queue");
+ var figure = Figure.readyQueue.sort(function (a, b) {
+ return a._seenOnScreen - b._seenOnScreen;
+ }).filter(function (figure) {
+ return !figure._ready;
+ }).pop();
+ if (figure) {
+ figure.ready();
+ requestAnimationFrame(Figure.runReadyQueue);
+ }
+ }
+ }, {
+ key: "marginObserver",
+ get: function get() {
+ if (!Figure._marginObserver) {
+ // if (!('IntersectionObserver' in window)) {
+ // throw new Error('no interscetionobbserver!');
+ // }
+ var viewportHeight = window.innerHeight;
+ var margin = Math.floor(2 * viewportHeight);
+ var options = {
+ rootMargin: margin + 'px 0px ' + margin + 'px 0px',
+ threshold: 0.01
+ };
+ var callback = Figure.didObserveMarginIntersection;
+ var observer = new IntersectionObserver(callback, options);
+ Figure._marginObserver = observer;
+ }
+ return Figure._marginObserver;
+ }
+ }, {
+ key: "didObserveMarginIntersection",
+ value: function didObserveMarginIntersection(entries) {
+ var _iterator19 = _createForOfIteratorHelper(entries),
+ _step19;
+ try {
+ for (_iterator19.s(); !(_step19 = _iterator19.n()).done;) {
+ var entry = _step19.value;
+ var figure = entry.target;
+ if (entry.isIntersecting && !figure._ready) {
+ Figure.addToReadyQueue(figure);
+ }
+ }
+ } catch (err) {
+ _iterator19.e(err);
+ } finally {
+ _iterator19.f();
+ }
+ }
+ }, {
+ key: "directObserver",
+ get: function get() {
+ if (!Figure._directObserver) {
+ Figure._directObserver = new IntersectionObserver(Figure.didObserveDirectIntersection, {
+ rootMargin: '0px',
+ threshold: [0, 1.0]
+ });
+ }
+ return Figure._directObserver;
+ }
+ }, {
+ key: "didObserveDirectIntersection",
+ value: function didObserveDirectIntersection(entries) {
+ var _iterator20 = _createForOfIteratorHelper(entries),
+ _step20;
+ try {
+ for (_iterator20.s(); !(_step20 = _iterator20.n()).done;) {
+ var entry = _step20.value;
+ var figure = entry.target;
+ if (entry.isIntersecting) {
+ figure._seenOnScreen = new Date();
+ // if (!figure._ready) { figure.ready(); }
+ if (figure._offscreen) {
+ figure.onscreen();
+ }
+ } else {
+ if (figure._onscreen) {
+ figure.offscreen();
+ }
+ }
+ }
+ } catch (err) {
+ _iterator20.e(err);
+ } finally {
+ _iterator20.f();
+ }
+ }
+ }]);
+ }(/*#__PURE__*/_wrapNativeSuper(HTMLElement));
+ if (typeof window !== 'undefined') {
+ Figure.isScrolling = false;
+ var timeout;
+ var resetTimer = function resetTimer() {
+ Figure.isScrolling = true;
+ clearTimeout(timeout);
+ timeout = setTimeout(function () {
+ Figure.isScrolling = false;
+ Figure.runReadyQueue();
+ }, 500);
+ };
+ window.addEventListener('scroll', resetTimer, true);
+ }
+
+ // Copyright 2018 The Distill Template Authors
+
+ // This overlay is not secure.
+ // It is only meant as a social deterrent.
+
+ var productionHostname = 'distill.pub';
+ var T$9 = Template('d-interstitial', "\n\n\n\n
\n
This article is in review. \n
Do not share this URL or the contents of this article. Thank you!
\n
\n
Enter the password we shared with you as part of the review process to view the article.
\n
\n
\n \n \n";
+ var headerTemplate = "\n\n\n");
+
+ // Copyright 2018 The Distill Template Authors
+
+ var T$b = Template('distill-header', headerTemplate, false);
+ var DistillHeader = /*#__PURE__*/function (_T$b) {
+ function DistillHeader() {
+ _classCallCheck(this, DistillHeader);
+ return _callSuper(this, DistillHeader, arguments);
+ }
+ _inherits(DistillHeader, _T$b);
+ return _createClass(DistillHeader);
+ }(T$b(HTMLElement)); // Copyright 2018 The Distill Template Authors
+ var styles$2 = "\n\n";
+ function appendixTemplate(frontMatter) {
+ var html = styles$2;
+ if (typeof frontMatter.githubUrl !== 'undefined') {
+ html += "\n Updates and Corrections \n ";
+ if (frontMatter.githubCompareUpdatesUrl) {
+ html += "View all changes to this article since it was first published.");
+ }
+ html += "\n If you see mistakes or want to suggest changes, please create an issue on GitHub .
\n ");
+ }
+ var journal = frontMatter.journal;
+ if (typeof journal !== 'undefined' && journal.title === 'Distill') {
+ html += "\n Reuse \n Diagrams and text are licensed under Creative Commons Attribution CC-BY 4.0 with the source available on GitHub , unless noted otherwise. The figures that have been reused from other sources don\u2019t fall under this license and can be recognized by a note in their caption: \u201CFigure from \u2026\u201D.
\n ");
+ }
+ if (typeof frontMatter.publishedDate !== 'undefined') {
+ html += "\n Citation \n For attribution in academic contexts, please cite this work as
\n ".concat(frontMatter.concatenatedAuthors, ", \"").concat(frontMatter.title, "\", Distill, ").concat(frontMatter.publishedYear, ". \n BibTeX citation
\n ").concat(serializeFrontmatterToBibtex(frontMatter), " \n ");
+ }
+ return html;
+ }
+ var DistillAppendix = /*#__PURE__*/function (_HTMLElement9) {
+ function DistillAppendix() {
+ _classCallCheck(this, DistillAppendix);
+ return _callSuper(this, DistillAppendix, arguments);
+ }
+ _inherits(DistillAppendix, _HTMLElement9);
+ return _createClass(DistillAppendix, [{
+ key: "frontMatter",
+ set: function set(frontMatter) {
+ this.innerHTML = appendixTemplate(frontMatter);
+ }
+ }], [{
+ key: "is",
+ get: function get() {
+ return 'distill-appendix';
+ }
+ }]);
+ }(/*#__PURE__*/_wrapNativeSuper(HTMLElement));
+ var footerTemplate = "\n\n\n\n\n");
+
+ // Copyright 2018 The Distill Template Authors
+
+ var T$c = Template('distill-footer', footerTemplate);
+ var DistillFooter = /*#__PURE__*/function (_T$c) {
+ function DistillFooter() {
+ _classCallCheck(this, DistillFooter);
+ return _callSuper(this, DistillFooter, arguments);
+ }
+ _inherits(DistillFooter, _T$c);
+ return _createClass(DistillFooter);
+ }(T$c(HTMLElement)); // Copyright 2018 The Distill Template Authors
+ var templateIsLoading = false;
+ var runlevel = 0;
+ var initialize = function initialize() {
+ if (window.distill.runlevel < 1) {
+ throw new Error("Insufficient Runlevel for Distill Template!");
+ }
+
+ /* 1. Flag that we're being loaded */
+ if ("distill" in window && window.distill.templateIsLoading) {
+ throw new Error("Runlevel 1: Distill Template is getting loaded more than once, aborting!");
+ } else {
+ window.distill.templateIsLoading = true;
+ console.debug("Runlevel 1: Distill Template has started loading.");
+ }
+
+ /* 2. Add styles if they weren't added during prerendering */
+ makeStyleTag(document);
+ console.debug("Runlevel 1: Static Distill styles have been added.");
+ console.debug("Runlevel 1->2.");
+ window.distill.runlevel += 1;
+
+ /* 3. Register Controller listener functions */
+ /* Needs to happen before components to their connected callbacks have a controller to talk to. */
+ for (var _i2 = 0, _Object$entries2 = Object.entries(Controller.listeners); _i2 < _Object$entries2.length; _i2++) {
+ var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+ functionName = _Object$entries2$_i[0],
+ callback = _Object$entries2$_i[1];
+ if (typeof callback === "function") {
+ document.addEventListener(functionName, callback);
+ } else {
+ console.error("Runlevel 2: Controller listeners need to be functions!");
+ }
+ }
+ console.debug("Runlevel 2: We can now listen to controller events.");
+ console.debug("Runlevel 2->3.");
+ window.distill.runlevel += 1;
+
+ /* 4. Register components */
+ var components = [Abstract, Appendix, Article, Bibliography, Byline, Cite, CitationList, Code, Footnote, FootnoteList, FrontMatter$1, HoverBox, Title, DMath, References, TOC, Figure, Slider, Interstitial];
+ var distillComponents = [DistillHeader, DistillAppendix, DistillFooter];
+ if (window.distill.runlevel < 2) {
+ throw new Error("Insufficient Runlevel for adding custom elements!");
+ }
+ var allComponents = components.concat(distillComponents);
+ var _iterator21 = _createForOfIteratorHelper(allComponents),
+ _step21;
+ try {
+ for (_iterator21.s(); !(_step21 = _iterator21.n()).done;) {
+ var component = _step21.value;
+ console.debug("Runlevel 2: Registering custom element: " + component.is);
+ customElements.define(component.is, component);
+ }
+ } catch (err) {
+ _iterator21.e(err);
+ } finally {
+ _iterator21.f();
+ }
+ console.debug("Runlevel 3: Distill Template finished registering custom elements.");
+ console.debug("Runlevel 3->4.");
+ window.distill.runlevel += 1;
+
+ // If template was added after DOMContentLoaded we may have missed that event.
+ // Controller will check for that case, so trigger the event explicitly:
+ if (domContentLoaded()) {
+ Controller.listeners.DOMContentLoaded();
+ }
+ console.debug("Runlevel 4: Distill Template initialisation complete.");
+ window.distill.templateIsLoading = false;
+ window.distill.templateHasLoaded = true;
+ };
+ window.distill = {
+ runlevel: runlevel,
+ initialize: initialize,
+ templateIsLoading: templateIsLoading
+ };
+
+ /* 0. Check browser feature support; synchronously polyfill if needed */
+ if (Polyfills.browserSupportsAllFeatures()) {
+ console.debug("Runlevel 0: No need for polyfills.");
+ console.debug("Runlevel 0->1.");
+ window.distill.runlevel += 1;
+ window.distill.initialize();
+ } else {
+ console.debug("Runlevel 0: Distill Template is loading polyfills.");
+ Polyfills.load(window.distill.initialize);
+ }
+});
+
+/***/ })
+
+/******/ });
+/************************************************************************/
+/******/ // The module cache
+/******/ var __webpack_module_cache__ = {};
+/******/
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/ // Check if module is in cache
+/******/ var cachedModule = __webpack_module_cache__[moduleId];
+/******/ if (cachedModule !== undefined) {
+/******/ return cachedModule.exports;
+/******/ }
+/******/ // Create a new module (and put it into the cache)
+/******/ var module = __webpack_module_cache__[moduleId] = {
+/******/ // no module.id needed
+/******/ // no module.loaded needed
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/
+/******/ // Return the exports of the module
+/******/ return module.exports;
+/******/ }
+/******/
+/************************************************************************/
+/******/ /* webpack/runtime/global */
+/******/ (() => {
+/******/ __webpack_require__.g = (function() {
+/******/ if (typeof globalThis === 'object') return globalThis;
+/******/ try {
+/******/ return this || new Function('return this')();
+/******/ } catch (e) {
+/******/ if (typeof window === 'object') return window;
+/******/ }
+/******/ })();
+/******/ })();
+/******/
+/************************************************************************/
+/******/
+/******/ // startup
+/******/ // Load entry module and return exports
+/******/ // This entry module used 'module' so it can't be inlined
+/******/ var __webpack_exports__ = __webpack_require__(792);
+/******/
+/******/ })()
+;
+//# sourceMappingURL=distill.bundle.js.map
\ No newline at end of file
![\"Coming](\"../assets/images/256px-PDF.png\")
\n