or tag. We found the following text: ' + text);
+ const wrapper = document.createElement('span');
+ wrapper.innerHTML = addedNode.nodeValue;
+ addedNode.parentNode.insertBefore(wrapper, addedNode);
+ addedNode.parentNode.removeChild(addedNode);
+ }
+ } break;
+ }
+ }
+ }
+ }).observe(this, {childList: true});
+ }
+
+ }
+
+ var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : 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, (full, x, char) => char)
+ .replace(/{\\([a-zA-Z])}/g, (full, char) => char);
+ }
+
+ function parseBibtex(bibtex) {
+ const bibliography = new Map();
+ const parsedEntries = bibtexParse.toJSON(bibtex);
+ for (const entry of parsedEntries) {
+ // normalize tags; note entryTags is an object, not Map
+ for (const [key, value] of Object.entries(entry.entryTags)) {
+ entry.entryTags[key.toLowerCase()] = normalizeTag(value);
+ }
+ entry.entryTags.type = entry.entryType;
+ // add to bibliography
+ bibliography.set(entry.citationKey, entry.entryTags);
+ }
+ return bibliography;
+ }
+
+ function serializeFrontmatterToBibtex(frontMatter) {
+ return `@article{${frontMatter.slug},
+ author = {${frontMatter.bibtexAuthors}},
+ title = {${frontMatter.title}},
+ journal = {${frontMatter.journal.title}},
+ year = {${frontMatter.publishedYear}},
+ note = {${frontMatter.url}},
+ doi = {${frontMatter.doi}}
+}`;
+ }
+
+ // Copyright 2018 The Distill Template Authors
+
+ class Bibliography extends HTMLElement {
+
+ static get is() { return 'd-bibliography'; }
+
+ constructor() {
+ super();
+
+ // set up mutation observer
+ const options = {childList: true, characterData: true, subtree: true};
+ const observer = new MutationObserver( (entries) => {
+ for (const entry of entries) {
+ if (entry.target.nodeName === 'SCRIPT' || entry.type === 'characterData') {
+ this.parseIfPossible();
+ }
+ }
+ });
+ observer.observe(this, options);
+ }
+
+ connectedCallback() {
+ requestAnimationFrame(() => {
+ this.parseIfPossible();
+ });
+ }
+
+ parseIfPossible() {
+ const scriptTag = this.querySelector('script');
+ if (!scriptTag) return;
+ if (scriptTag.type == 'text/bibtex') {
+ const newBibtex = scriptTag.textContent;
+ if (this.bibtex !== newBibtex) {
+ this.bibtex = newBibtex;
+ const bibliography = parseBibtex(this.bibtex);
+ this.notify(bibliography);
+ }
+ } else if (scriptTag.type == 'text/json') {
+ const bibliography = new Map(JSON.parse(scriptTag.textContent));
+ this.notify(bibliography);
+ } else {
+ console.warn('Unsupported bibliography script tag type: ' + scriptTag.type);
+ }
+ }
+
+ notify(bibliography) {
+ const options = { detail: bibliography, bubbles: true };
+ const event = new CustomEvent('onBibliographyChanged', options);
+ this.dispatchEvent(event);
+ }
+
+ /* observe 'src' attribute */
+
+ static get observedAttributes() {
+ return ['src'];
+ }
+
+ receivedBibtex(event) {
+ const bibliography = parseBibtex(event.target.response);
+ this.notify(bibliography);
+ }
+
+ attributeChangedCallback(name, oldValue, newValue) {
+ var oReq = new XMLHttpRequest();
+ oReq.onload = (e) => this.receivedBibtex(e);
+ oReq.onerror = () => console.warn(`Could not load Bibtex! (tried ${newValue})`);
+ oReq.responseType = 'text';
+ oReq.open('GET', newValue, true);
+ oReq.send();
+ }
+
+
+ }
+
+ // 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 `
+
+
+
+
+
Published
+
May 31, 2024
+
+
+
+`
+ );
+
+ class Cite extends T$3(HTMLElement) {
+ /* Lifecycle */
+ constructor() {
+ super();
+ this._numbers = [];
+ this._entries = [];
+ }
+
+ connectedCallback() {
+ 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(() => {
+ this.hoverBox.listen(this);
+ });
+ // 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 */
+
+ static get observedAttributes() {
+ return ["key", "bibtex-key"];
+ }
+
+ attributeChangedCallback(name, oldValue, newValue) {
+ const eventName = oldValue ? "onCiteKeyChanged" : "onCiteKeyCreated";
+ const keys = newValue.split(",").map(k => k.trim());
+ const options = { detail: [this, keys], bubbles: true };
+ const event = new CustomEvent(eventName, options);
+ document.dispatchEvent(event);
+ }
+
+ set key(value) {
+ this.setAttribute("key", value);
+ }
+
+ get key() {
+ return this.getAttribute("key") || this.getAttribute("bibtex-key");
+ }
+
+ get keys() {
+ const result = this.key.split(",");
+ console.log(result);
+ return result;
+ }
+
+ /* Setters & Rendering */
+
+ set numbers(numbers) {
+ this._numbers = numbers;
+ this.displayNumbers(numbers);
+ }
+
+ get numbers() {
+ return this._numbers;
+ }
+
+ displayNumbers(numbers) {
+ if (!this.innerSpan) return;
+ const numberStrings = numbers.map(index => {
+ return index == -1 ? "?" : index + 1 + "";
+ });
+ const textContent = "[" + numberStrings.join(", ") + "]";
+ this.innerSpan.textContent = textContent;
+ }
+
+ set entries(entries) {
+ this._entries = entries;
+ this.displayEntries(entries);
+ }
+
+ get entries() {
+ return this._entries;
+ }
+
+ displayEntries(entries) {
+ if (!this.hoverBox) return;
+ this.hoverBox.innerHTML = `
+ ${entries
+ .map(hover_cite)
+ .map(html => `${html} `)
+ .join("\n")}
+ `;
+ }
+ }
+
+ // Copyright 2018 The Distill Template Authors
+
+ const styles$1 = `
+d-citation-list {
+ contain: style;
+}
+
+d-citation-list .references {
+ grid-column: text;
+}
+
+d-citation-list .references .title {
+ font-weight: 500;
+}
+`;
+
+ function renderCitationList(element, entries, dom=document) {
+ if (entries.size > 0) {
+ element.style.display = '';
+ let list = element.querySelector('.references');
+ if (list) {
+ list.innerHTML = '';
+ } else {
+ const stylesTag = dom.createElement('style');
+ stylesTag.innerHTML = styles$1;
+ element.appendChild(stylesTag);
+
+ const 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);
+ }
+
+ for (const [key, entry] of entries) {
+ const listItem = dom.createElement('li');
+ listItem.id = key;
+ listItem.innerHTML = bibliography_cite(entry);
+ list.appendChild(listItem);
+ }
+ } else {
+ element.style.display = 'none';
+ }
+ }
+
+ class CitationList extends HTMLElement {
+
+ static get is() { return 'd-citation-list'; }
+
+ connectedCallback() {
+ if (!this.hasAttribute('distill-prerendered')) {
+ this.style.display = 'none';
+ }
+ }
+
+ set citations(citations) {
+ renderCitationList(this, citations);
+ }
+
+ }
+
+ 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 `
+
+ block to let us know how to highlight your code; e.g.:\n zeros = np.zeros(shape) .');
+ return;
+ }
+ const language = prism.languages[this.languageName];
+ if (language == undefined) {
+ console.warn(`Distill does not yet support highlighting your code block in "${this.languageName}'.`);
+ return;
+ }
+
+ let content = this.textContent;
+ const codeTag = this.shadowRoot.querySelector('#code-container');
+
+ if (this.hasAttribute('block')) {
+ // normalize the tab indents
+ content = content.replace(/\n/, '');
+ const 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) {
+ const preTag = document.createElement('pre');
+ this.shadowRoot.removeChild(codeTag);
+ preTag.appendChild(codeTag);
+ this.shadowRoot.appendChild(preTag);
+ }
+
+ }
+
+ codeTag.className = `language-${this.languageName}`;
+ codeTag.innerHTML = prism.highlight(content, language);
+ }
+
+ }
+
+ // Copyright 2018 The Distill Template Authors
+
+ const T$5 = Template('d-footnote', `
+
+
+
+
+
+
+
+
+
+`);
+
+ class Footnote extends T$5(HTMLElement) {
+
+ constructor() {
+ super();
+
+ const options = {childList: true, characterData: true, subtree: true};
+ const observer = new MutationObserver(this.notify);
+ observer.observe(this, options);
+ }
+
+ notify() {
+ const options = { detail: this, bubbles: true };
+ const event = new CustomEvent('onFootnoteChanged', options);
+ document.dispatchEvent(event);
+ }
+
+ connectedCallback() {
+ // 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(() => {
+ this.hoverBox.listen(this);
+ });
+ // create numeric ID
+ Footnote.currentFootnoteId += 1;
+ const IdString = Footnote.currentFootnoteId.toString();
+ this.root.host.id = 'd-footnote-' + IdString;
+
+ // set up hidden hover box
+ const id = 'dt-fn-hover-box-' + IdString;
+ this.hoverBox.id = id;
+
+ // set up visible footnote marker
+ const span = this.root.querySelector('#fn-');
+ span.setAttribute('id', 'fn-' + IdString);
+ span.setAttribute('data-hover-ref', id);
+ span.textContent = IdString;
+ }
+
+ }
+
+ Footnote.currentFootnoteId = 0;
+
+ // Copyright 2018 The Distill Template Authors
+
+ const T$6 = Template('d-footnote-list', `
+
+
+Footnotes
+Table of contents
+ `;
+
+ for (const el of headings) {
+ // should element be included in TOC?
+ const isInTitle = el.parentElement.tagName == 'D-TITLE';
+ const isException = el.getAttribute('no-toc');
+ if (isInTitle || isException) continue;
+ // create TOC entry
+ const title = el.textContent;
+ const link = '#' + el.getAttribute('id');
+
+ let 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
+ //
+
+ class Figure extends HTMLElement {
+
+ static get is() { return 'd-figure'; }
+
+ static get readyQueue() {
+ if (!Figure._readyQueue) {
+ Figure._readyQueue = [];
+ }
+ return Figure._readyQueue;
+ }
+
+ static addToReadyQueue(figure) {
+ if (Figure.readyQueue.indexOf(figure) === -1) {
+ Figure.readyQueue.push(figure);
+ Figure.runReadyQueue();
+ }
+ }
+
+ static runReadyQueue() {
+ // console.log("Checking to run readyQueue, length: " + Figure.readyQueue.length + ", scrolling: " + Figure.isScrolling);
+ // if (Figure.isScrolling) return;
+ // console.log("Running ready Queue");
+ const figure = Figure.readyQueue
+ .sort((a,b) => a._seenOnScreen - b._seenOnScreen )
+ .filter((figure) => !figure._ready)
+ .pop();
+ if (figure) {
+ figure.ready();
+ requestAnimationFrame(Figure.runReadyQueue);
+ }
+
+ }
+
+ constructor() {
+ super();
+ // debugger
+ this._ready = false;
+ this._onscreen = false;
+ this._offscreen = true;
+ }
+
+ connectedCallback() {
+ this.loadsWhileScrolling = this.hasAttribute('loadsWhileScrolling');
+ Figure.marginObserver.observe(this);
+ Figure.directObserver.observe(this);
+ }
+
+ 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
+
+ static get marginObserver() {
+ if (!Figure._marginObserver) {
+ // if (!('IntersectionObserver' in window)) {
+ // throw new Error('no interscetionobbserver!');
+ // }
+ const viewportHeight = window.innerHeight;
+ const margin = Math.floor(2 * viewportHeight);
+ const options = {rootMargin: margin + 'px 0px ' + margin + 'px 0px', threshold: 0.01};
+ const callback = Figure.didObserveMarginIntersection;
+ const observer = new IntersectionObserver(callback, options);
+ Figure._marginObserver = observer;
+ }
+ return Figure._marginObserver;
+ }
+
+ static didObserveMarginIntersection(entries) {
+ for (const entry of entries) {
+ const figure = entry.target;
+ if (entry.isIntersecting && !figure._ready) {
+ Figure.addToReadyQueue(figure);
+ }
+ }
+ }
+
+ static get directObserver() {
+ if (!Figure._directObserver) {
+ Figure._directObserver = new IntersectionObserver(
+ Figure.didObserveDirectIntersection, {
+ rootMargin: '0px', threshold: [0, 1.0],
+ }
+ );
+ }
+ return Figure._directObserver;
+ }
+
+ static didObserveDirectIntersection(entries) {
+ for (const entry of entries) {
+ const 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(); }
+ }
+ }
+ }
+
+ // Notify listeners that registered late, too:
+
+ addEventListener(eventName, callback) {
+ super.addEventListener(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
+
+ ready() {
+ // debugger
+ this._ready = true;
+ Figure.marginObserver.unobserve(this);
+ const event = new CustomEvent('ready');
+ this.dispatchEvent(event);
+ }
+
+ onscreen() {
+ this._onscreen = true;
+ this._offscreen = false;
+ const event = new CustomEvent('onscreen');
+ this.dispatchEvent(event);
+ }
+
+ offscreen() {
+ this._onscreen = false;
+ this._offscreen = true;
+ const event = new CustomEvent('offscreen');
+ this.dispatchEvent(event);
+ }
+
+ }
+
+ if (typeof window !== 'undefined') {
+
+ Figure.isScrolling = false;
+ let timeout;
+ const resetTimer = () => {
+ Figure.isScrolling = true;
+ clearTimeout(timeout);
+ timeout = setTimeout(() => {
+ 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.
+
+ const productionHostname = 'distill.pub';
+ const T$9 = Template('d-interstitial', `
+
+
+
+
+
This article is in review.
+
Do not share this URL or the contents of this article. Thank you!
+
+
Enter the password we shared with you as part of the review process to view the article.
+
+
\n \n \n";
+
+ const headerTemplate = `
+
+
+`;
+
+ // Copyright 2018 The Distill Template Authors
+
+ const T$b = Template('distill-header', headerTemplate, false);
+
+ class DistillHeader extends T$b(HTMLElement) {
+
+ }
+
+ // Copyright 2018 The Distill Template Authors
+
+ const styles$2 = `
+
+`;
+
+ function appendixTemplate(frontMatter) {
+ let html = styles$2;
+
+ if (typeof frontMatter.githubUrl !== 'undefined') {
+ html += `
+ Updates and Corrections
+ `;
+ if (frontMatter.githubCompareUpdatesUrl) {
+ html += `View all changes to this article since it was first published.`;
+ }
+ html += `
+ If you see mistakes or want to suggest changes, please create an issue on GitHub .
+ `;
+ }
+
+ const journal = frontMatter.journal;
+ if (typeof journal !== 'undefined' && journal.title === 'Distill') {
+ html += `
+ Reuse
+ 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’t fall under this license and can be recognized by a note in their caption: “Figure from …”.
+ `;
+ }
+
+ if (typeof frontMatter.publishedDate !== 'undefined') {
+ html += `
+ Citation
+ For attribution in academic contexts, please cite this work as
+ ${frontMatter.concatenatedAuthors}, "${frontMatter.title}", Distill, ${frontMatter.publishedYear}.
+ BibTeX citation
+ ${serializeFrontmatterToBibtex(frontMatter)}
+ `;
+ }
+
+ return html;
+ }
+
+ class DistillAppendix extends HTMLElement {
+
+ static get is() { return 'distill-appendix'; }
+
+ set frontMatter(frontMatter) {
+ this.innerHTML = appendixTemplate(frontMatter);
+ }
+
+ }
+
+ const footerTemplate = `
+
+
+
+
+`;
+
+ // Copyright 2018 The Distill Template Authors
+
+ const T$c = Template('distill-footer', footerTemplate);
+
+ class DistillFooter extends T$c(HTMLElement) {
+
+ }
+
+ // Copyright 2018 The Distill Template Authors
+
+ let templateIsLoading = false;
+ let runlevel = 0;
+ const initialize = function() {
+ 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 (const [functionName, callback] of Object.entries(Controller.listeners)) {
+ 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 */
+ const components = [
+ Abstract, Appendix, Article, Bibliography, Byline, Cite, CitationList, Code,
+ Footnote, FootnoteList, FrontMatter$1, HoverBox, Title, DMath, References, TOC, Figure,
+ Slider, Interstitial
+ ];
+
+ const distillComponents = [DistillHeader, DistillAppendix, DistillFooter];
+
+ if (window.distill.runlevel < 2) {
+ throw new Error("Insufficient Runlevel for adding custom elements!");
+ }
+ const allComponents = components.concat(distillComponents);
+ for (const component of allComponents) {
+ console.debug("Runlevel 2: Registering custom element: " + component.is);
+ customElements.define(component.is, component);
+ }
+
+ 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, initialize, 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);
+ }
+
+})));
+//# sourceMappingURL=template.v2.js.map