} group the nodes of this group,
* list will be moified in place
*/
Parser$1.prototype.formLigatures = function(group) {
var i;
var n = group.length - 1;
for (i = 0; i < n; ++i) {
var a = group[i];
var v = a.value;
if (v === "-" && group[i + 1].value === "-") {
if (i + 1 < n && group[i + 2].value === "-") {
group.splice(i, 3, new ParseNode(
"textord", "---", "text", a, group[i + 2]));
n -= 2;
} else {
group.splice(i, 2, new ParseNode(
"textord", "--", "text", a, group[i + 1]));
n -= 1;
}
}
if ((v === "'" || v === "`") && group[i + 1].value === v) {
group.splice(i, 2, new ParseNode(
"textord", v + v, "text", a, group[i + 1]));
n -= 1;
}
}
};
/**
* Parse a single symbol out of the string. Here, we handle both the functions
* we have defined, as well as the single character symbols
*
* @return {?ParseFuncOrArgument}
*/
Parser$1.prototype.parseSymbol = function() {
var nucleus = this.nextToken;
if (functions[nucleus.text]) {
this.consume();
// If there exists a function with this name, we return the function and
// say that it is a function.
return new ParseFuncOrArgument(
nucleus.text,
true, nucleus);
} else if (symbols$5[this.mode][nucleus.text]) {
this.consume();
// Otherwise if this is a no-argument function, find the type it
// corresponds to in the symbols map
return new ParseFuncOrArgument(
new ParseNode(symbols$5[this.mode][nucleus.text].group,
nucleus.text, this.mode, nucleus),
false, nucleus);
} else if (this.mode === "text" && cjkRegex$2.test(nucleus.text)) {
this.consume();
return new ParseFuncOrArgument(
new ParseNode("textord", nucleus.text, this.mode, nucleus),
false, nucleus);
} else {
return null;
}
};
Parser$1.prototype.ParseNode = ParseNode;
var Parser_1 = Parser$1;
var Parser = Parser_1;
/**
* Parses an expression using a Parser, then returns the parsed result.
*/
var parseTree$1 = function(toParse, settings) {
if (!(typeof toParse === 'string' || toParse instanceof String)) {
throw new TypeError('KaTeX can only parse string typed expression');
}
var parser = new Parser(toParse, settings);
return parser.parse();
};
var parseTree_1 = parseTree$1;
var ParseError = ParseError_1;
var Settings = Settings_1;
var buildTree = buildTree_1;
var parseTree = parseTree_1;
var utils = utils$4;
/**
* Parse and build an expression, and place that expression in the DOM node
* given.
*/
var render = function(expression, baseNode, options) {
utils.clearNode(baseNode);
var settings = new Settings(options);
var tree = parseTree(expression, settings);
var node = buildTree(tree, expression, settings).toNode();
baseNode.appendChild(node);
};
// KaTeX's styles don't work properly in quirks mode. Print out an error, and
// disable rendering.
if (typeof document !== "undefined") {
if (document.compatMode !== "CSS1Compat") {
typeof console !== "undefined" && console.warn(
"Warning: KaTeX doesn't work in quirks mode. Make sure your " +
"website has a suitable doctype.");
render = function() {
throw new ParseError("KaTeX doesn't work in quirks mode.");
};
}
}
/**
* Parse and build an expression, and return the markup for that.
*/
var renderToString = function(expression, options) {
var settings = new Settings(options);
var tree = parseTree(expression, settings);
return buildTree(tree, expression, settings).toMarkup();
};
/**
* Parse an expression and return the parse tree.
*/
var generateParseTree = function(expression, options) {
var settings = new Settings(options);
return parseTree(expression, settings);
};
var katex = {
render: render,
renderToString: renderToString,
/**
* NOTE: This method is not currently recommended for public use.
* The internal tree representation is unstable and is very likely
* to change. Use at your own risk.
*/
__parse: generateParseTree,
ParseError: ParseError
};
const T$10 = Template('d-math', `
`);
class DMath extends Mutating(T$10(HTMLElement)) {
renderContent() {
const options = { displayMode: this.hasAttribute('block') };
const container = this.root.querySelector('#katex-container');
katex.render(this.textContent, container, options);
}
}
const T$12 = Template('d-references', `
`, false);
class References extends T$12(HTMLElement) {
}
const T$13 = Template('d-title', `
`);
class Title extends T$13(HTMLElement) {
}
const T$14 = Template('d-toc', `
`, false);
class TOC extends T$14(HTMLElement) {
}
var logo = "\n";
const T$15 = Template('distill-header', `
`);
//
class DistillHeader extends T$15(HTMLElement) {
}
const styles$1 = `
`;
function appendixTemplate(frontMatter) {
return `
${styles$1}
Updates and Corrections
View all changes to this article since it was first published. If you see mistakes or want to suggest changes, please create an issue on GitHub.
Reuse
Diagrams and text are licensed under Creative Commons Attribution CC-BY 2.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 …”.
Citation
For attribution in academic contexts, please cite this work as
${frontMatter.concatenatedAuthors}, "${frontMatter.title}", Distill, ${frontMatter.publishedYear}.
BibTeX citation
${serializeFrontmatterToBibtex(frontMatter)}
`;
}
class DistillAppendix extends HTMLElement {
static get is() { return 'distill-appendix'; }
set frontMatter(frontMatter) {
this.innerHTML = appendixTemplate(frontMatter);
}
}
const T$16 = Template('distill-footer', `
`);
class DistillFooter extends T$16(HTMLElement) {
}
/* Static styles and other modules */
const components = [
Abstract, Acknowledgements, Appendix, Article, Bibliography,
Byline, Cite, Code, Footnote, FootnoteList, FrontMatter$1, DMath,
References, Title, TOC,
];
/* Distill website specific components */
const distillComponents = [
DistillHeader, DistillAppendix, DistillFooter,
];
function defineComponents() {
const allComponents = components.concat(distillComponents);
for (const component of allComponents) {
customElements.define(component.is, component);
}
}
defineComponents();
})));
//# sourceMappingURL=components.js.map