diff --git a/site/assets/css/code.css b/site/assets/css/code.css new file mode 100644 index 0000000..85ab5f7 --- /dev/null +++ b/site/assets/css/code.css @@ -0,0 +1,6 @@ +code { + tab-size: 2; +} +a { + font-size: 1.3em; +} diff --git a/site/assets/css/monokai.min.css b/site/assets/css/monokai.min.css new file mode 100644 index 0000000..448d85d --- /dev/null +++ b/site/assets/css/monokai.min.css @@ -0,0 +1 @@ +pre code.hljs{display:block;overflow-x:auto;padding:1em}code.hljs{padding:3px 5px}.hljs{background:#272822;color:#ddd}.hljs-keyword,.hljs-literal,.hljs-name,.hljs-selector-tag,.hljs-strong,.hljs-tag{color:#f92672}.hljs-code{color:#66d9ef}.hljs-attribute,.hljs-link,.hljs-regexp,.hljs-symbol{color:#bf79db}.hljs-addition,.hljs-built_in,.hljs-bullet,.hljs-emphasis,.hljs-section,.hljs-selector-attr,.hljs-selector-pseudo,.hljs-string,.hljs-subst,.hljs-template-tag,.hljs-template-variable,.hljs-title,.hljs-type,.hljs-variable{color:#a6e22e}.hljs-class .hljs-title,.hljs-title.class_{color:#fff}.hljs-comment,.hljs-deletion,.hljs-meta,.hljs-quote{color:#75715e}.hljs-doctag,.hljs-keyword,.hljs-literal,.hljs-section,.hljs-selector-id,.hljs-selector-tag,.hljs-title,.hljs-type{font-weight:700} \ No newline at end of file diff --git a/site/assets/js/highlight.js b/site/assets/js/highlight.js new file mode 100644 index 0000000..8054578 --- /dev/null +++ b/site/assets/js/highlight.js @@ -0,0 +1,1840 @@ +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getProtoOf = Object.getPrototypeOf; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __toESM = (mod, isNodeMode, target) => { + target = mod != null ? __create(__getProtoOf(mod)) : {}; + const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target; + for (let key of __getOwnPropNames(mod)) + if (!__hasOwnProp.call(to, key)) + __defProp(to, key, { + get: () => mod[key], + enumerable: true + }); + return to; +}; +var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports); + +// node_modules/highlight.js/lib/core.js +var require_core = __commonJS((exports, module) => { + var deepFreeze = function(obj) { + if (obj instanceof Map) { + obj.clear = obj.delete = obj.set = function() { + throw new Error("map is read-only"); + }; + } else if (obj instanceof Set) { + obj.add = obj.clear = obj.delete = function() { + throw new Error("set is read-only"); + }; + } + Object.freeze(obj); + Object.getOwnPropertyNames(obj).forEach((name) => { + const prop = obj[name]; + const type = typeof prop; + if ((type === "object" || type === "function") && !Object.isFrozen(prop)) { + deepFreeze(prop); + } + }); + return obj; + }; + var escapeHTML = function(value) { + return value.replace(/&/g, "&").replace(//g, ">").replace(/"/g, """).replace(/'/g, "'"); + }; + var inherit$1 = function(original, ...objects) { + const result = Object.create(null); + for (const key in original) { + result[key] = original[key]; + } + objects.forEach(function(obj) { + for (const key in obj) { + result[key] = obj[key]; + } + }); + return result; + }; + var source = function(re) { + if (!re) + return null; + if (typeof re === "string") + return re; + return re.source; + }; + var lookahead = function(re) { + return concat("(?=", re, ")"); + }; + var anyNumberOfTimes = function(re) { + return concat("(?:", re, ")*"); + }; + var optional = function(re) { + return concat("(?:", re, ")?"); + }; + var concat = function(...args) { + const joined = args.map((x) => source(x)).join(""); + return joined; + }; + var stripOptionsFromArgs = function(args) { + const opts = args[args.length - 1]; + if (typeof opts === "object" && opts.constructor === Object) { + args.splice(args.length - 1, 1); + return opts; + } else { + return {}; + } + }; + var either = function(...args) { + const opts = stripOptionsFromArgs(args); + const joined = "(" + (opts.capture ? "" : "?:") + args.map((x) => source(x)).join("|") + ")"; + return joined; + }; + var countMatchGroups = function(re) { + return new RegExp(re.toString() + "|").exec("").length - 1; + }; + var startsWith = function(re, lexeme) { + const match = re && re.exec(lexeme); + return match && match.index === 0; + }; + var _rewriteBackreferences = function(regexps, { joinWith }) { + let numCaptures = 0; + return regexps.map((regex) => { + numCaptures += 1; + const offset = numCaptures; + let re = source(regex); + let out = ""; + while (re.length > 0) { + const match = BACKREF_RE.exec(re); + if (!match) { + out += re; + break; + } + out += re.substring(0, match.index); + re = re.substring(match.index + match[0].length); + if (match[0][0] === "\\" && match[1]) { + out += "\\" + String(Number(match[1]) + offset); + } else { + out += match[0]; + if (match[0] === "(") { + numCaptures++; + } + } + } + return out; + }).map((re) => `(${re})`).join(joinWith); + }; + var skipIfHasPrecedingDot = function(match, response) { + const before = match.input[match.index - 1]; + if (before === ".") { + response.ignoreMatch(); + } + }; + var scopeClassName = function(mode, _parent) { + if (mode.className !== undefined) { + mode.scope = mode.className; + delete mode.className; + } + }; + var beginKeywords = function(mode, parent) { + if (!parent) + return; + if (!mode.beginKeywords) + return; + mode.begin = "\\b(" + mode.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)"; + mode.__beforeBegin = skipIfHasPrecedingDot; + mode.keywords = mode.keywords || mode.beginKeywords; + delete mode.beginKeywords; + if (mode.relevance === undefined) + mode.relevance = 0; + }; + var compileIllegal = function(mode, _parent) { + if (!Array.isArray(mode.illegal)) + return; + mode.illegal = either(...mode.illegal); + }; + var compileMatch = function(mode, _parent) { + if (!mode.match) + return; + if (mode.begin || mode.end) + throw new Error("begin & end are not supported with match"); + mode.begin = mode.match; + delete mode.match; + }; + var compileRelevance = function(mode, _parent) { + if (mode.relevance === undefined) + mode.relevance = 1; + }; + var compileKeywords = function(rawKeywords, caseInsensitive, scopeName = DEFAULT_KEYWORD_SCOPE) { + const compiledKeywords = Object.create(null); + if (typeof rawKeywords === "string") { + compileList(scopeName, rawKeywords.split(" ")); + } else if (Array.isArray(rawKeywords)) { + compileList(scopeName, rawKeywords); + } else { + Object.keys(rawKeywords).forEach(function(scopeName2) { + Object.assign(compiledKeywords, compileKeywords(rawKeywords[scopeName2], caseInsensitive, scopeName2)); + }); + } + return compiledKeywords; + function compileList(scopeName2, keywordList) { + if (caseInsensitive) { + keywordList = keywordList.map((x) => x.toLowerCase()); + } + keywordList.forEach(function(keyword) { + const pair = keyword.split("|"); + compiledKeywords[pair[0]] = [scopeName2, scoreForKeyword(pair[0], pair[1])]; + }); + } + }; + var scoreForKeyword = function(keyword, providedScore) { + if (providedScore) { + return Number(providedScore); + } + return commonKeyword(keyword) ? 0 : 1; + }; + var commonKeyword = function(keyword) { + return COMMON_KEYWORDS.includes(keyword.toLowerCase()); + }; + var remapScopeNames = function(mode, regexes, { key }) { + let offset = 0; + const scopeNames = mode[key]; + const emit = {}; + const positions = {}; + for (let i = 1;i <= regexes.length; i++) { + positions[i + offset] = scopeNames[i]; + emit[i + offset] = true; + offset += countMatchGroups(regexes[i - 1]); + } + mode[key] = positions; + mode[key]._emit = emit; + mode[key]._multi = true; + }; + var beginMultiClass = function(mode) { + if (!Array.isArray(mode.begin)) + return; + if (mode.skip || mode.excludeBegin || mode.returnBegin) { + error("skip, excludeBegin, returnBegin not compatible with beginScope: {}"); + throw MultiClassError; + } + if (typeof mode.beginScope !== "object" || mode.beginScope === null) { + error("beginScope must be object"); + throw MultiClassError; + } + remapScopeNames(mode, mode.begin, { key: "beginScope" }); + mode.begin = _rewriteBackreferences(mode.begin, { joinWith: "" }); + }; + var endMultiClass = function(mode) { + if (!Array.isArray(mode.end)) + return; + if (mode.skip || mode.excludeEnd || mode.returnEnd) { + error("skip, excludeEnd, returnEnd not compatible with endScope: {}"); + throw MultiClassError; + } + if (typeof mode.endScope !== "object" || mode.endScope === null) { + error("endScope must be object"); + throw MultiClassError; + } + remapScopeNames(mode, mode.end, { key: "endScope" }); + mode.end = _rewriteBackreferences(mode.end, { joinWith: "" }); + }; + var scopeSugar = function(mode) { + if (mode.scope && typeof mode.scope === "object" && mode.scope !== null) { + mode.beginScope = mode.scope; + delete mode.scope; + } + }; + var MultiClass = function(mode) { + scopeSugar(mode); + if (typeof mode.beginScope === "string") { + mode.beginScope = { _wrap: mode.beginScope }; + } + if (typeof mode.endScope === "string") { + mode.endScope = { _wrap: mode.endScope }; + } + beginMultiClass(mode); + endMultiClass(mode); + }; + var compileLanguage = function(language) { + function langRe(value, global) { + return new RegExp(source(value), "m" + (language.case_insensitive ? "i" : "") + (language.unicodeRegex ? "u" : "") + (global ? "g" : "")); + } + + class MultiRegex { + constructor() { + this.matchIndexes = {}; + this.regexes = []; + this.matchAt = 1; + this.position = 0; + } + addRule(re, opts) { + opts.position = this.position++; + this.matchIndexes[this.matchAt] = opts; + this.regexes.push([opts, re]); + this.matchAt += countMatchGroups(re) + 1; + } + compile() { + if (this.regexes.length === 0) { + this.exec = () => null; + } + const terminators = this.regexes.map((el) => el[1]); + this.matcherRe = langRe(_rewriteBackreferences(terminators, { joinWith: "|" }), true); + this.lastIndex = 0; + } + exec(s) { + this.matcherRe.lastIndex = this.lastIndex; + const match = this.matcherRe.exec(s); + if (!match) { + return null; + } + const i = match.findIndex((el, i2) => i2 > 0 && el !== undefined); + const matchData = this.matchIndexes[i]; + match.splice(0, i); + return Object.assign(match, matchData); + } + } + + class ResumableMultiRegex { + constructor() { + this.rules = []; + this.multiRegexes = []; + this.count = 0; + this.lastIndex = 0; + this.regexIndex = 0; + } + getMatcher(index) { + if (this.multiRegexes[index]) + return this.multiRegexes[index]; + const matcher = new MultiRegex; + this.rules.slice(index).forEach(([re, opts]) => matcher.addRule(re, opts)); + matcher.compile(); + this.multiRegexes[index] = matcher; + return matcher; + } + resumingScanAtSamePosition() { + return this.regexIndex !== 0; + } + considerAll() { + this.regexIndex = 0; + } + addRule(re, opts) { + this.rules.push([re, opts]); + if (opts.type === "begin") + this.count++; + } + exec(s) { + const m = this.getMatcher(this.regexIndex); + m.lastIndex = this.lastIndex; + let result = m.exec(s); + if (this.resumingScanAtSamePosition()) { + if (result && result.index === this.lastIndex) + ; + else { + const m2 = this.getMatcher(0); + m2.lastIndex = this.lastIndex + 1; + result = m2.exec(s); + } + } + if (result) { + this.regexIndex += result.position + 1; + if (this.regexIndex === this.count) { + this.considerAll(); + } + } + return result; + } + } + function buildModeRegex(mode) { + const mm = new ResumableMultiRegex; + mode.contains.forEach((term) => mm.addRule(term.begin, { rule: term, type: "begin" })); + if (mode.terminatorEnd) { + mm.addRule(mode.terminatorEnd, { type: "end" }); + } + if (mode.illegal) { + mm.addRule(mode.illegal, { type: "illegal" }); + } + return mm; + } + function compileMode(mode, parent) { + const cmode = mode; + if (mode.isCompiled) + return cmode; + [ + scopeClassName, + compileMatch, + MultiClass, + beforeMatchExt + ].forEach((ext) => ext(mode, parent)); + language.compilerExtensions.forEach((ext) => ext(mode, parent)); + mode.__beforeBegin = null; + [ + beginKeywords, + compileIllegal, + compileRelevance + ].forEach((ext) => ext(mode, parent)); + mode.isCompiled = true; + let keywordPattern = null; + if (typeof mode.keywords === "object" && mode.keywords.$pattern) { + mode.keywords = Object.assign({}, mode.keywords); + keywordPattern = mode.keywords.$pattern; + delete mode.keywords.$pattern; + } + keywordPattern = keywordPattern || /\w+/; + if (mode.keywords) { + mode.keywords = compileKeywords(mode.keywords, language.case_insensitive); + } + cmode.keywordPatternRe = langRe(keywordPattern, true); + if (parent) { + if (!mode.begin) + mode.begin = /\B|\b/; + cmode.beginRe = langRe(cmode.begin); + if (!mode.end && !mode.endsWithParent) + mode.end = /\B|\b/; + if (mode.end) + cmode.endRe = langRe(cmode.end); + cmode.terminatorEnd = source(cmode.end) || ""; + if (mode.endsWithParent && parent.terminatorEnd) { + cmode.terminatorEnd += (mode.end ? "|" : "") + parent.terminatorEnd; + } + } + if (mode.illegal) + cmode.illegalRe = langRe(mode.illegal); + if (!mode.contains) + mode.contains = []; + mode.contains = [].concat(...mode.contains.map(function(c) { + return expandOrCloneMode(c === "self" ? mode : c); + })); + mode.contains.forEach(function(c) { + compileMode(c, cmode); + }); + if (mode.starts) { + compileMode(mode.starts, parent); + } + cmode.matcher = buildModeRegex(cmode); + return cmode; + } + if (!language.compilerExtensions) + language.compilerExtensions = []; + if (language.contains && language.contains.includes("self")) { + throw new Error("ERR: contains `self` is not supported at the top-level of a language. See documentation."); + } + language.classNameAliases = inherit$1(language.classNameAliases || {}); + return compileMode(language); + }; + var dependencyOnParent = function(mode) { + if (!mode) + return false; + return mode.endsWithParent || dependencyOnParent(mode.starts); + }; + var expandOrCloneMode = function(mode) { + if (mode.variants && !mode.cachedVariants) { + mode.cachedVariants = mode.variants.map(function(variant) { + return inherit$1(mode, { variants: null }, variant); + }); + } + if (mode.cachedVariants) { + return mode.cachedVariants; + } + if (dependencyOnParent(mode)) { + return inherit$1(mode, { starts: mode.starts ? inherit$1(mode.starts) : null }); + } + if (Object.isFrozen(mode)) { + return inherit$1(mode); + } + return mode; + }; + + class Response { + constructor(mode) { + if (mode.data === undefined) + mode.data = {}; + this.data = mode.data; + this.isMatchIgnored = false; + } + ignoreMatch() { + this.isMatchIgnored = true; + } + } + var SPAN_CLOSE = ""; + var emitsWrappingTags = (node) => { + return !!node.scope; + }; + var scopeToCSSClass = (name, { prefix }) => { + if (name.startsWith("language:")) { + return name.replace("language:", "language-"); + } + if (name.includes(".")) { + const pieces = name.split("."); + return [ + `${prefix}${pieces.shift()}`, + ...pieces.map((x, i) => `${x}${"_".repeat(i + 1)}`) + ].join(" "); + } + return `${prefix}${name}`; + }; + + class HTMLRenderer { + constructor(parseTree, options) { + this.buffer = ""; + this.classPrefix = options.classPrefix; + parseTree.walk(this); + } + addText(text) { + this.buffer += escapeHTML(text); + } + openNode(node) { + if (!emitsWrappingTags(node)) + return; + const className = scopeToCSSClass(node.scope, { prefix: this.classPrefix }); + this.span(className); + } + closeNode(node) { + if (!emitsWrappingTags(node)) + return; + this.buffer += SPAN_CLOSE; + } + value() { + return this.buffer; + } + span(className) { + this.buffer += ``; + } + } + var newNode = (opts = {}) => { + const result = { children: [] }; + Object.assign(result, opts); + return result; + }; + + class TokenTree { + constructor() { + this.rootNode = newNode(); + this.stack = [this.rootNode]; + } + get top() { + return this.stack[this.stack.length - 1]; + } + get root() { + return this.rootNode; + } + add(node) { + this.top.children.push(node); + } + openNode(scope) { + const node = newNode({ scope }); + this.add(node); + this.stack.push(node); + } + closeNode() { + if (this.stack.length > 1) { + return this.stack.pop(); + } + return; + } + closeAllNodes() { + while (this.closeNode()) + ; + } + toJSON() { + return JSON.stringify(this.rootNode, null, 4); + } + walk(builder) { + return this.constructor._walk(builder, this.rootNode); + } + static _walk(builder, node) { + if (typeof node === "string") { + builder.addText(node); + } else if (node.children) { + builder.openNode(node); + node.children.forEach((child) => this._walk(builder, child)); + builder.closeNode(node); + } + return builder; + } + static _collapse(node) { + if (typeof node === "string") + return; + if (!node.children) + return; + if (node.children.every((el) => typeof el === "string")) { + node.children = [node.children.join("")]; + } else { + node.children.forEach((child) => { + TokenTree._collapse(child); + }); + } + } + } + + class TokenTreeEmitter extends TokenTree { + constructor(options) { + super(); + this.options = options; + } + addText(text) { + if (text === "") { + return; + } + this.add(text); + } + startScope(scope) { + this.openNode(scope); + } + endScope() { + this.closeNode(); + } + __addSublanguage(emitter, name) { + const node = emitter.root; + if (name) + node.scope = `language:${name}`; + this.add(node); + } + toHTML() { + const renderer = new HTMLRenderer(this, this.options); + return renderer.value(); + } + finalize() { + this.closeAllNodes(); + return true; + } + } + var BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./; + var MATCH_NOTHING_RE = /\b\B/; + var IDENT_RE = "[a-zA-Z]\\w*"; + var UNDERSCORE_IDENT_RE = "[a-zA-Z_]\\w*"; + var NUMBER_RE = "\\b\\d+(\\.\\d+)?"; + var C_NUMBER_RE = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)"; + var BINARY_NUMBER_RE = "\\b(0b[01]+)"; + var RE_STARTERS_RE = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~"; + var SHEBANG = (opts = {}) => { + const beginShebang = /^#![ ]*\//; + if (opts.binary) { + opts.begin = concat(beginShebang, /.*\b/, opts.binary, /\b.*/); + } + return inherit$1({ + scope: "meta", + begin: beginShebang, + end: /$/, + relevance: 0, + "on:begin": (m, resp) => { + if (m.index !== 0) + resp.ignoreMatch(); + } + }, opts); + }; + var BACKSLASH_ESCAPE = { + begin: "\\\\[\\s\\S]", + relevance: 0 + }; + var APOS_STRING_MODE = { + scope: "string", + begin: "\'", + end: "\'", + illegal: "\\n", + contains: [BACKSLASH_ESCAPE] + }; + var QUOTE_STRING_MODE = { + scope: "string", + begin: '"', + end: '"', + illegal: "\\n", + contains: [BACKSLASH_ESCAPE] + }; + var PHRASAL_WORDS_MODE = { + begin: /\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/ + }; + var COMMENT = function(begin, end, modeOptions = {}) { + const mode = inherit$1({ + scope: "comment", + begin, + end, + contains: [] + }, modeOptions); + mode.contains.push({ + scope: "doctag", + begin: "[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)", + end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/, + excludeBegin: true, + relevance: 0 + }); + const ENGLISH_WORD = either("I", "a", "is", "so", "us", "to", "at", "if", "in", "it", "on", /[A-Za-z]+['](d|ve|re|ll|t|s|n)/, /[A-Za-z]+[-][a-z]+/, /[A-Za-z][a-z]{2,}/); + mode.contains.push({ + begin: concat(/[ ]+/, "(", ENGLISH_WORD, /[.]?[:]?([.][ ]|[ ])/, "){3}") + }); + return mode; + }; + var C_LINE_COMMENT_MODE = COMMENT("//", "$"); + var C_BLOCK_COMMENT_MODE = COMMENT("/\\*", "\\*/"); + var HASH_COMMENT_MODE = COMMENT("#", "$"); + var NUMBER_MODE = { + scope: "number", + begin: NUMBER_RE, + relevance: 0 + }; + var C_NUMBER_MODE = { + scope: "number", + begin: C_NUMBER_RE, + relevance: 0 + }; + var BINARY_NUMBER_MODE = { + scope: "number", + begin: BINARY_NUMBER_RE, + relevance: 0 + }; + var REGEXP_MODE = { + scope: "regexp", + begin: /\/(?=[^/\n]*\/)/, + end: /\/[gimuy]*/, + contains: [ + BACKSLASH_ESCAPE, + { + begin: /\[/, + end: /\]/, + relevance: 0, + contains: [BACKSLASH_ESCAPE] + } + ] + }; + var TITLE_MODE = { + scope: "title", + begin: IDENT_RE, + relevance: 0 + }; + var UNDERSCORE_TITLE_MODE = { + scope: "title", + begin: UNDERSCORE_IDENT_RE, + relevance: 0 + }; + var METHOD_GUARD = { + begin: "\\.\\s*" + UNDERSCORE_IDENT_RE, + relevance: 0 + }; + var END_SAME_AS_BEGIN = function(mode) { + return Object.assign(mode, { + "on:begin": (m, resp) => { + resp.data._beginMatch = m[1]; + }, + "on:end": (m, resp) => { + if (resp.data._beginMatch !== m[1]) + resp.ignoreMatch(); + } + }); + }; + var MODES = Object.freeze({ + __proto__: null, + APOS_STRING_MODE, + BACKSLASH_ESCAPE, + BINARY_NUMBER_MODE, + BINARY_NUMBER_RE, + COMMENT, + C_BLOCK_COMMENT_MODE, + C_LINE_COMMENT_MODE, + C_NUMBER_MODE, + C_NUMBER_RE, + END_SAME_AS_BEGIN, + HASH_COMMENT_MODE, + IDENT_RE, + MATCH_NOTHING_RE, + METHOD_GUARD, + NUMBER_MODE, + NUMBER_RE, + PHRASAL_WORDS_MODE, + QUOTE_STRING_MODE, + REGEXP_MODE, + RE_STARTERS_RE, + SHEBANG, + TITLE_MODE, + UNDERSCORE_IDENT_RE, + UNDERSCORE_TITLE_MODE + }); + var beforeMatchExt = (mode, parent) => { + if (!mode.beforeMatch) + return; + if (mode.starts) + throw new Error("beforeMatch cannot be used with starts"); + const originalMode = Object.assign({}, mode); + Object.keys(mode).forEach((key) => { + delete mode[key]; + }); + mode.keywords = originalMode.keywords; + mode.begin = concat(originalMode.beforeMatch, lookahead(originalMode.begin)); + mode.starts = { + relevance: 0, + contains: [ + Object.assign(originalMode, { endsParent: true }) + ] + }; + mode.relevance = 0; + delete originalMode.beforeMatch; + }; + var COMMON_KEYWORDS = [ + "of", + "and", + "for", + "in", + "not", + "or", + "if", + "then", + "parent", + "list", + "value" + ]; + var DEFAULT_KEYWORD_SCOPE = "keyword"; + var seenDeprecations = {}; + var error = (message) => { + console.error(message); + }; + var warn = (message, ...args) => { + console.log(`WARN: ${message}`, ...args); + }; + var deprecated = (version2, message) => { + if (seenDeprecations[`${version2}/${message}`]) + return; + console.log(`Deprecated as of ${version2}. ${message}`); + seenDeprecations[`${version2}/${message}`] = true; + }; + var MultiClassError = new Error; + var version = "11.9.0"; + + class HTMLInjectionError extends Error { + constructor(reason, html) { + super(reason); + this.name = "HTMLInjectionError"; + this.html = html; + } + } + var escape = escapeHTML; + var inherit = inherit$1; + var NO_MATCH = Symbol("nomatch"); + var MAX_KEYWORD_HITS = 7; + var HLJS = function(hljs) { + const languages = Object.create(null); + const aliases = Object.create(null); + const plugins = []; + let SAFE_MODE = true; + const LANGUAGE_NOT_FOUND = "Could not find the language '{}', did you forget to load/include a language module?"; + const PLAINTEXT_LANGUAGE = { disableAutodetect: true, name: "Plain text", contains: [] }; + let options = { + ignoreUnescapedHTML: false, + throwUnescapedHTML: false, + noHighlightRe: /^(no-?highlight)$/i, + languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i, + classPrefix: "hljs-", + cssSelector: "pre code", + languages: null, + __emitter: TokenTreeEmitter + }; + function shouldNotHighlight(languageName) { + return options.noHighlightRe.test(languageName); + } + function blockLanguage(block) { + let classes = block.className + " "; + classes += block.parentNode ? block.parentNode.className : ""; + const match = options.languageDetectRe.exec(classes); + if (match) { + const language = getLanguage(match[1]); + if (!language) { + warn(LANGUAGE_NOT_FOUND.replace("{}", match[1])); + warn("Falling back to no-highlight mode for this block.", block); + } + return language ? match[1] : "no-highlight"; + } + return classes.split(/\s+/).find((_class) => shouldNotHighlight(_class) || getLanguage(_class)); + } + function highlight2(codeOrLanguageName, optionsOrCode, ignoreIllegals) { + let code = ""; + let languageName = ""; + if (typeof optionsOrCode === "object") { + code = codeOrLanguageName; + ignoreIllegals = optionsOrCode.ignoreIllegals; + languageName = optionsOrCode.language; + } else { + deprecated("10.7.0", "highlight(lang, code, ...args) has been deprecated."); + deprecated("10.7.0", "Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277"); + languageName = codeOrLanguageName; + code = optionsOrCode; + } + if (ignoreIllegals === undefined) { + ignoreIllegals = true; + } + const context = { + code, + language: languageName + }; + fire("before:highlight", context); + const result = context.result ? context.result : _highlight(context.language, context.code, ignoreIllegals); + result.code = context.code; + fire("after:highlight", result); + return result; + } + function _highlight(languageName, codeToHighlight, ignoreIllegals, continuation) { + const keywordHits = Object.create(null); + function keywordData(mode, matchText) { + return mode.keywords[matchText]; + } + function processKeywords() { + if (!top.keywords) { + emitter.addText(modeBuffer); + return; + } + let lastIndex = 0; + top.keywordPatternRe.lastIndex = 0; + let match = top.keywordPatternRe.exec(modeBuffer); + let buf = ""; + while (match) { + buf += modeBuffer.substring(lastIndex, match.index); + const word = language.case_insensitive ? match[0].toLowerCase() : match[0]; + const data = keywordData(top, word); + if (data) { + const [kind, keywordRelevance] = data; + emitter.addText(buf); + buf = ""; + keywordHits[word] = (keywordHits[word] || 0) + 1; + if (keywordHits[word] <= MAX_KEYWORD_HITS) + relevance += keywordRelevance; + if (kind.startsWith("_")) { + buf += match[0]; + } else { + const cssClass = language.classNameAliases[kind] || kind; + emitKeyword(match[0], cssClass); + } + } else { + buf += match[0]; + } + lastIndex = top.keywordPatternRe.lastIndex; + match = top.keywordPatternRe.exec(modeBuffer); + } + buf += modeBuffer.substring(lastIndex); + emitter.addText(buf); + } + function processSubLanguage() { + if (modeBuffer === "") + return; + let result2 = null; + if (typeof top.subLanguage === "string") { + if (!languages[top.subLanguage]) { + emitter.addText(modeBuffer); + return; + } + result2 = _highlight(top.subLanguage, modeBuffer, true, continuations[top.subLanguage]); + continuations[top.subLanguage] = result2._top; + } else { + result2 = highlightAuto(modeBuffer, top.subLanguage.length ? top.subLanguage : null); + } + if (top.relevance > 0) { + relevance += result2.relevance; + } + emitter.__addSublanguage(result2._emitter, result2.language); + } + function processBuffer() { + if (top.subLanguage != null) { + processSubLanguage(); + } else { + processKeywords(); + } + modeBuffer = ""; + } + function emitKeyword(keyword, scope) { + if (keyword === "") + return; + emitter.startScope(scope); + emitter.addText(keyword); + emitter.endScope(); + } + function emitMultiClass(scope, match) { + let i = 1; + const max = match.length - 1; + while (i <= max) { + if (!scope._emit[i]) { + i++; + continue; + } + const klass = language.classNameAliases[scope[i]] || scope[i]; + const text = match[i]; + if (klass) { + emitKeyword(text, klass); + } else { + modeBuffer = text; + processKeywords(); + modeBuffer = ""; + } + i++; + } + } + function startNewMode(mode, match) { + if (mode.scope && typeof mode.scope === "string") { + emitter.openNode(language.classNameAliases[mode.scope] || mode.scope); + } + if (mode.beginScope) { + if (mode.beginScope._wrap) { + emitKeyword(modeBuffer, language.classNameAliases[mode.beginScope._wrap] || mode.beginScope._wrap); + modeBuffer = ""; + } else if (mode.beginScope._multi) { + emitMultiClass(mode.beginScope, match); + modeBuffer = ""; + } + } + top = Object.create(mode, { parent: { value: top } }); + return top; + } + function endOfMode(mode, match, matchPlusRemainder) { + let matched = startsWith(mode.endRe, matchPlusRemainder); + if (matched) { + if (mode["on:end"]) { + const resp = new Response(mode); + mode["on:end"](match, resp); + if (resp.isMatchIgnored) + matched = false; + } + if (matched) { + while (mode.endsParent && mode.parent) { + mode = mode.parent; + } + return mode; + } + } + if (mode.endsWithParent) { + return endOfMode(mode.parent, match, matchPlusRemainder); + } + } + function doIgnore(lexeme) { + if (top.matcher.regexIndex === 0) { + modeBuffer += lexeme[0]; + return 1; + } else { + resumeScanAtSamePosition = true; + return 0; + } + } + function doBeginMatch(match) { + const lexeme = match[0]; + const newMode = match.rule; + const resp = new Response(newMode); + const beforeCallbacks = [newMode.__beforeBegin, newMode["on:begin"]]; + for (const cb of beforeCallbacks) { + if (!cb) + continue; + cb(match, resp); + if (resp.isMatchIgnored) + return doIgnore(lexeme); + } + if (newMode.skip) { + modeBuffer += lexeme; + } else { + if (newMode.excludeBegin) { + modeBuffer += lexeme; + } + processBuffer(); + if (!newMode.returnBegin && !newMode.excludeBegin) { + modeBuffer = lexeme; + } + } + startNewMode(newMode, match); + return newMode.returnBegin ? 0 : lexeme.length; + } + function doEndMatch(match) { + const lexeme = match[0]; + const matchPlusRemainder = codeToHighlight.substring(match.index); + const endMode = endOfMode(top, match, matchPlusRemainder); + if (!endMode) { + return NO_MATCH; + } + const origin = top; + if (top.endScope && top.endScope._wrap) { + processBuffer(); + emitKeyword(lexeme, top.endScope._wrap); + } else if (top.endScope && top.endScope._multi) { + processBuffer(); + emitMultiClass(top.endScope, match); + } else if (origin.skip) { + modeBuffer += lexeme; + } else { + if (!(origin.returnEnd || origin.excludeEnd)) { + modeBuffer += lexeme; + } + processBuffer(); + if (origin.excludeEnd) { + modeBuffer = lexeme; + } + } + do { + if (top.scope) { + emitter.closeNode(); + } + if (!top.skip && !top.subLanguage) { + relevance += top.relevance; + } + top = top.parent; + } while (top !== endMode.parent); + if (endMode.starts) { + startNewMode(endMode.starts, match); + } + return origin.returnEnd ? 0 : lexeme.length; + } + function processContinuations() { + const list = []; + for (let current = top;current !== language; current = current.parent) { + if (current.scope) { + list.unshift(current.scope); + } + } + list.forEach((item) => emitter.openNode(item)); + } + let lastMatch = {}; + function processLexeme(textBeforeMatch, match) { + const lexeme = match && match[0]; + modeBuffer += textBeforeMatch; + if (lexeme == null) { + processBuffer(); + return 0; + } + if (lastMatch.type === "begin" && match.type === "end" && lastMatch.index === match.index && lexeme === "") { + modeBuffer += codeToHighlight.slice(match.index, match.index + 1); + if (!SAFE_MODE) { + const err = new Error(`0 width match regex (${languageName})`); + err.languageName = languageName; + err.badRule = lastMatch.rule; + throw err; + } + return 1; + } + lastMatch = match; + if (match.type === "begin") { + return doBeginMatch(match); + } else if (match.type === "illegal" && !ignoreIllegals) { + const err = new Error('Illegal lexeme "' + lexeme + '" for mode "' + (top.scope || "") + '"'); + err.mode = top; + throw err; + } else if (match.type === "end") { + const processed = doEndMatch(match); + if (processed !== NO_MATCH) { + return processed; + } + } + if (match.type === "illegal" && lexeme === "") { + return 1; + } + if (iterations > 1e5 && iterations > match.index * 3) { + const err = new Error("potential infinite loop, way more iterations than matches"); + throw err; + } + modeBuffer += lexeme; + return lexeme.length; + } + const language = getLanguage(languageName); + if (!language) { + error(LANGUAGE_NOT_FOUND.replace("{}", languageName)); + throw new Error('Unknown language: "' + languageName + '"'); + } + const md = compileLanguage(language); + let result = ""; + let top = continuation || md; + const continuations = {}; + const emitter = new options.__emitter(options); + processContinuations(); + let modeBuffer = ""; + let relevance = 0; + let index = 0; + let iterations = 0; + let resumeScanAtSamePosition = false; + try { + if (!language.__emitTokens) { + top.matcher.considerAll(); + for (;; ) { + iterations++; + if (resumeScanAtSamePosition) { + resumeScanAtSamePosition = false; + } else { + top.matcher.considerAll(); + } + top.matcher.lastIndex = index; + const match = top.matcher.exec(codeToHighlight); + if (!match) + break; + const beforeMatch = codeToHighlight.substring(index, match.index); + const processedCount = processLexeme(beforeMatch, match); + index = match.index + processedCount; + } + processLexeme(codeToHighlight.substring(index)); + } else { + language.__emitTokens(codeToHighlight, emitter); + } + emitter.finalize(); + result = emitter.toHTML(); + return { + language: languageName, + value: result, + relevance, + illegal: false, + _emitter: emitter, + _top: top + }; + } catch (err) { + if (err.message && err.message.includes("Illegal")) { + return { + language: languageName, + value: escape(codeToHighlight), + illegal: true, + relevance: 0, + _illegalBy: { + message: err.message, + index, + context: codeToHighlight.slice(index - 100, index + 100), + mode: err.mode, + resultSoFar: result + }, + _emitter: emitter + }; + } else if (SAFE_MODE) { + return { + language: languageName, + value: escape(codeToHighlight), + illegal: false, + relevance: 0, + errorRaised: err, + _emitter: emitter, + _top: top + }; + } else { + throw err; + } + } + } + function justTextHighlightResult(code) { + const result = { + value: escape(code), + illegal: false, + relevance: 0, + _top: PLAINTEXT_LANGUAGE, + _emitter: new options.__emitter(options) + }; + result._emitter.addText(code); + return result; + } + function highlightAuto(code, languageSubset) { + languageSubset = languageSubset || options.languages || Object.keys(languages); + const plaintext = justTextHighlightResult(code); + const results = languageSubset.filter(getLanguage).filter(autoDetection).map((name) => _highlight(name, code, false)); + results.unshift(plaintext); + const sorted = results.sort((a, b) => { + if (a.relevance !== b.relevance) + return b.relevance - a.relevance; + if (a.language && b.language) { + if (getLanguage(a.language).supersetOf === b.language) { + return 1; + } else if (getLanguage(b.language).supersetOf === a.language) { + return -1; + } + } + return 0; + }); + const [best, secondBest] = sorted; + const result = best; + result.secondBest = secondBest; + return result; + } + function updateClassName(element, currentLang, resultLang) { + const language = currentLang && aliases[currentLang] || resultLang; + element.classList.add("hljs"); + element.classList.add(`language-${language}`); + } + function highlightElement(element) { + let node = null; + const language = blockLanguage(element); + if (shouldNotHighlight(language)) + return; + fire("before:highlightElement", { el: element, language }); + if (element.dataset.highlighted) { + console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", element); + return; + } + if (element.children.length > 0) { + if (!options.ignoreUnescapedHTML) { + console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk."); + console.warn("https://github.com/highlightjs/highlight.js/wiki/security"); + console.warn("The element with unescaped HTML:"); + console.warn(element); + } + if (options.throwUnescapedHTML) { + const err = new HTMLInjectionError("One of your code blocks includes unescaped HTML.", element.innerHTML); + throw err; + } + } + node = element; + const text = node.textContent; + const result = language ? highlight2(text, { language, ignoreIllegals: true }) : highlightAuto(text); + element.innerHTML = result.value; + element.dataset.highlighted = "yes"; + updateClassName(element, language, result.language); + element.result = { + language: result.language, + re: result.relevance, + relevance: result.relevance + }; + if (result.secondBest) { + element.secondBest = { + language: result.secondBest.language, + relevance: result.secondBest.relevance + }; + } + fire("after:highlightElement", { el: element, result, text }); + } + function configure(userOptions) { + options = inherit(options, userOptions); + } + const initHighlighting = () => { + highlightAll(); + deprecated("10.6.0", "initHighlighting() deprecated. Use highlightAll() now."); + }; + function initHighlightingOnLoad() { + highlightAll(); + deprecated("10.6.0", "initHighlightingOnLoad() deprecated. Use highlightAll() now."); + } + let wantsHighlight = false; + function highlightAll() { + if (document.readyState === "loading") { + wantsHighlight = true; + return; + } + const blocks = document.querySelectorAll(options.cssSelector); + blocks.forEach(highlightElement); + } + function boot() { + if (wantsHighlight) + highlightAll(); + } + if (typeof window !== "undefined" && window.addEventListener) { + window.addEventListener("DOMContentLoaded", boot, false); + } + function registerLanguage(languageName, languageDefinition) { + let lang = null; + try { + lang = languageDefinition(hljs); + } catch (error$1) { + error("Language definition for '{}' could not be registered.".replace("{}", languageName)); + if (!SAFE_MODE) { + throw error$1; + } else { + error(error$1); + } + lang = PLAINTEXT_LANGUAGE; + } + if (!lang.name) + lang.name = languageName; + languages[languageName] = lang; + lang.rawDefinition = languageDefinition.bind(null, hljs); + if (lang.aliases) { + registerAliases(lang.aliases, { languageName }); + } + } + function unregisterLanguage(languageName) { + delete languages[languageName]; + for (const alias of Object.keys(aliases)) { + if (aliases[alias] === languageName) { + delete aliases[alias]; + } + } + } + function listLanguages() { + return Object.keys(languages); + } + function getLanguage(name) { + name = (name || "").toLowerCase(); + return languages[name] || languages[aliases[name]]; + } + function registerAliases(aliasList, { languageName }) { + if (typeof aliasList === "string") { + aliasList = [aliasList]; + } + aliasList.forEach((alias) => { + aliases[alias.toLowerCase()] = languageName; + }); + } + function autoDetection(name) { + const lang = getLanguage(name); + return lang && !lang.disableAutodetect; + } + function upgradePluginAPI(plugin) { + if (plugin["before:highlightBlock"] && !plugin["before:highlightElement"]) { + plugin["before:highlightElement"] = (data) => { + plugin["before:highlightBlock"](Object.assign({ block: data.el }, data)); + }; + } + if (plugin["after:highlightBlock"] && !plugin["after:highlightElement"]) { + plugin["after:highlightElement"] = (data) => { + plugin["after:highlightBlock"](Object.assign({ block: data.el }, data)); + }; + } + } + function addPlugin(plugin) { + upgradePluginAPI(plugin); + plugins.push(plugin); + } + function removePlugin(plugin) { + const index = plugins.indexOf(plugin); + if (index !== -1) { + plugins.splice(index, 1); + } + } + function fire(event, args) { + const cb = event; + plugins.forEach(function(plugin) { + if (plugin[cb]) { + plugin[cb](args); + } + }); + } + function deprecateHighlightBlock(el) { + deprecated("10.7.0", "highlightBlock will be removed entirely in v12.0"); + deprecated("10.7.0", "Please use highlightElement now."); + return highlightElement(el); + } + Object.assign(hljs, { + highlight: highlight2, + highlightAuto, + highlightAll, + highlightElement, + highlightBlock: deprecateHighlightBlock, + configure, + initHighlighting, + initHighlightingOnLoad, + registerLanguage, + unregisterLanguage, + listLanguages, + getLanguage, + registerAliases, + autoDetection, + inherit, + addPlugin, + removePlugin + }); + hljs.debugMode = function() { + SAFE_MODE = false; + }; + hljs.safeMode = function() { + SAFE_MODE = true; + }; + hljs.versionString = version; + hljs.regex = { + concat, + lookahead, + either, + optional, + anyNumberOfTimes + }; + for (const key in MODES) { + if (typeof MODES[key] === "object") { + deepFreeze(MODES[key]); + } + } + Object.assign(hljs, MODES); + return hljs; + }; + var highlight = HLJS({}); + highlight.newInstance = () => HLJS({}); + module.exports = highlight; + highlight.HighlightJS = highlight; + highlight.default = highlight; +}); + +// node_modules/highlight.js/es/core.js +var core = __toESM(require_core(), 1); +var core_default = core.default; + +// node_modules/highlight.js/es/languages/bash.js +var bash = function(hljs) { + const regex = hljs.regex; + const VAR = {}; + const BRACED_VAR = { + begin: /\$\{/, + end: /\}/, + contains: [ + "self", + { + begin: /:-/, + contains: [VAR] + } + ] + }; + Object.assign(VAR, { + className: "variable", + variants: [ + { begin: regex.concat(/\$[\w\d#@][\w\d_]*/, `(?![\\w\\d])(?![\$])`) }, + BRACED_VAR + ] + }); + const SUBST = { + className: "subst", + begin: /\$\(/, + end: /\)/, + contains: [hljs.BACKSLASH_ESCAPE] + }; + const HERE_DOC = { + begin: /<<-?\s*(?=\w+)/, + starts: { contains: [ + hljs.END_SAME_AS_BEGIN({ + begin: /(\w+)/, + end: /(\w+)/, + className: "string" + }) + ] } + }; + const QUOTE_STRING = { + className: "string", + begin: /"/, + end: /"/, + contains: [ + hljs.BACKSLASH_ESCAPE, + VAR, + SUBST + ] + }; + SUBST.contains.push(QUOTE_STRING); + const ESCAPED_QUOTE = { + match: /\\"/ + }; + const APOS_STRING = { + className: "string", + begin: /'/, + end: /'/ + }; + const ESCAPED_APOS = { + match: /\\'/ + }; + const ARITHMETIC = { + begin: /\$?\(\(/, + end: /\)\)/, + contains: [ + { + begin: /\d+#[0-9a-f]+/, + className: "number" + }, + hljs.NUMBER_MODE, + VAR + ] + }; + const SH_LIKE_SHELLS = [ + "fish", + "bash", + "zsh", + "sh", + "csh", + "ksh", + "tcsh", + "dash", + "scsh" + ]; + const KNOWN_SHEBANG = hljs.SHEBANG({ + binary: `(${SH_LIKE_SHELLS.join("|")})`, + relevance: 10 + }); + const FUNCTION = { + className: "function", + begin: /\w[\w\d_]*\s*\(\s*\)\s*\{/, + returnBegin: true, + contains: [hljs.inherit(hljs.TITLE_MODE, { begin: /\w[\w\d_]*/ })], + relevance: 0 + }; + const KEYWORDS = [ + "if", + "then", + "else", + "elif", + "fi", + "for", + "while", + "until", + "in", + "do", + "done", + "case", + "esac", + "function", + "select" + ]; + const LITERALS = [ + "true", + "false" + ]; + const PATH_MODE = { match: /(\/[a-z._-]+)+/ }; + const SHELL_BUILT_INS = [ + "break", + "cd", + "continue", + "eval", + "exec", + "exit", + "export", + "getopts", + "hash", + "pwd", + "readonly", + "return", + "shift", + "test", + "times", + "trap", + "umask", + "unset" + ]; + const BASH_BUILT_INS = [ + "alias", + "bind", + "builtin", + "caller", + "command", + "declare", + "echo", + "enable", + "help", + "let", + "local", + "logout", + "mapfile", + "printf", + "read", + "readarray", + "source", + "type", + "typeset", + "ulimit", + "unalias" + ]; + const ZSH_BUILT_INS = [ + "autoload", + "bg", + "bindkey", + "bye", + "cap", + "chdir", + "clone", + "comparguments", + "compcall", + "compctl", + "compdescribe", + "compfiles", + "compgroups", + "compquote", + "comptags", + "comptry", + "compvalues", + "dirs", + "disable", + "disown", + "echotc", + "echoti", + "emulate", + "fc", + "fg", + "float", + "functions", + "getcap", + "getln", + "history", + "integer", + "jobs", + "kill", + "limit", + "log", + "noglob", + "popd", + "print", + "pushd", + "pushln", + "rehash", + "sched", + "setcap", + "setopt", + "stat", + "suspend", + "ttyctl", + "unfunction", + "unhash", + "unlimit", + "unsetopt", + "vared", + "wait", + "whence", + "where", + "which", + "zcompile", + "zformat", + "zftp", + "zle", + "zmodload", + "zparseopts", + "zprof", + "zpty", + "zregexparse", + "zsocket", + "zstyle", + "ztcp" + ]; + const GNU_CORE_UTILS = [ + "chcon", + "chgrp", + "chown", + "chmod", + "cp", + "dd", + "df", + "dir", + "dircolors", + "ln", + "ls", + "mkdir", + "mkfifo", + "mknod", + "mktemp", + "mv", + "realpath", + "rm", + "rmdir", + "shred", + "sync", + "touch", + "truncate", + "vdir", + "b2sum", + "base32", + "base64", + "cat", + "cksum", + "comm", + "csplit", + "cut", + "expand", + "fmt", + "fold", + "head", + "join", + "md5sum", + "nl", + "numfmt", + "od", + "paste", + "ptx", + "pr", + "sha1sum", + "sha224sum", + "sha256sum", + "sha384sum", + "sha512sum", + "shuf", + "sort", + "split", + "sum", + "tac", + "tail", + "tr", + "tsort", + "unexpand", + "uniq", + "wc", + "arch", + "basename", + "chroot", + "date", + "dirname", + "du", + "echo", + "env", + "expr", + "factor", + "groups", + "hostid", + "id", + "link", + "logname", + "nice", + "nohup", + "nproc", + "pathchk", + "pinky", + "printenv", + "printf", + "pwd", + "readlink", + "runcon", + "seq", + "sleep", + "stat", + "stdbuf", + "stty", + "tee", + "test", + "timeout", + "tty", + "uname", + "unlink", + "uptime", + "users", + "who", + "whoami", + "yes" + ]; + return { + name: "Bash", + aliases: ["sh"], + keywords: { + $pattern: /\b[a-z][a-z0-9._-]+\b/, + keyword: KEYWORDS, + literal: LITERALS, + built_in: [ + ...SHELL_BUILT_INS, + ...BASH_BUILT_INS, + "set", + "shopt", + ...ZSH_BUILT_INS, + ...GNU_CORE_UTILS + ] + }, + contains: [ + KNOWN_SHEBANG, + hljs.SHEBANG(), + FUNCTION, + ARITHMETIC, + hljs.HASH_COMMENT_MODE, + HERE_DOC, + PATH_MODE, + QUOTE_STRING, + ESCAPED_QUOTE, + APOS_STRING, + ESCAPED_APOS, + VAR + ] + }; +}; + +// assets/js/highlight.ts +core_default.registerLanguage("bash", bash); +var addStylesheet = function(url) { + const link = document.createElement("link"); + link.rel = "stylesheet"; + link.href = url; + document.head.appendChild(link); +}; +var wrapAsCode = function(container, language) { + const code = container.innerHTML.split("\n"); + code.pop(); + const codeElement = document.createElement("code"); + codeElement.className = `language-${language}`; + codeElement.innerHTML = code.join("\n"); + const pre = document.createElement("pre"); + pre.appendChild(codeElement); + container.replaceChildren(pre); + return codeElement; +}; +var addReadmeLink = function(codeblock) { + const span = document.createElement("span"); + span.className = "hljs-comment"; + const readme = document.createElement("a"); + readme.innerText = "WHAT IS THIS"; + readme.href = "https://dots.00dani.me/README"; + span.append("# ", readme); + codeblock.querySelector("span.hljs-meta + span.hljs-comment")?.replaceWith(span); +}; +addStylesheet("/assets/css/style.css"); +addStylesheet("/assets/css/code.css"); +addStylesheet("/assets/css/monokai.min.css"); +var codeblock = wrapAsCode(document.body, "bash"); +core_default.highlightElement(codeblock); +addReadmeLink(codeblock); diff --git a/site/assets/js/highlight.ts b/site/assets/js/highlight.ts new file mode 100644 index 0000000..3d4559a --- /dev/null +++ b/site/assets/js/highlight.ts @@ -0,0 +1,45 @@ +import hljs from 'highlight.js/lib/core'; +import bash from 'highlight.js/lib/languages/bash'; + +hljs.registerLanguage('bash', bash); + +const addStylesheet = function(url: string): void { + const link = document.createElement('link'); + link.rel = 'stylesheet'; + link.href = url; + document.head.appendChild(link); +}; + +const wrapAsCode = function(container: HTMLElement, language: string): HTMLElement { + const code = container.innerHTML.split('\n'); + code.pop(); // Drop the line that actually runs this script, we don't need it now. + + const codeElement = document.createElement('code'); + codeElement.className = `language-${language}`; + codeElement.innerHTML = code.join('\n'); + + const pre = document.createElement('pre'); + pre.appendChild(codeElement); + + container.replaceChildren(pre); + return codeElement; +}; + +const addReadmeLink = function(codeblock: HTMLElement): void { + const span = document.createElement('span'); + span.className = 'hljs-comment'; + const readme = document.createElement('a'); + readme.innerText = 'WHAT IS THIS'; + readme.href = 'https://dots.00dani.me/README'; + span.append('# ', readme); + + codeblock.querySelector('span.hljs-meta + span.hljs-comment')?.replaceWith(span); +}; + +addStylesheet('/assets/css/style.css'); +addStylesheet('/assets/css/code.css'); +addStylesheet('/assets/css/monokai.min.css'); + +const codeblock = wrapAsCode(document.body, 'bash'); +hljs.highlightElement(codeblock); +addReadmeLink(codeblock); diff --git a/site/index.html b/site/index.html index 9d07e1b..d1dcef3 100644 --- a/site/index.html +++ b/site/index.html @@ -1,4 +1,4 @@ --- --- {% include_relative local/bin/dots %} -# +#