From 2387804b9eabca1a4a05c6ffcc9eb038ea66a675 Mon Sep 17 00:00:00 2001 From: Patrick Mayr Date: Wed, 5 Jan 2022 23:23:55 +0000 Subject: [PATCH] Update Redesign to v0.4.1-beta --- fet2020/static/js/prism-autoloader@1.25.0.js | 515 +++++ fet2020/static/js/prism-core@1.25.0.js | 1221 ++++++++++ fet2020/static/styles.css | 2167 +++++++++--------- fet2020/templates/base.html | 21 +- fet2020/templates/posts/show.html | 4 +- 5 files changed, 2854 insertions(+), 1074 deletions(-) create mode 100644 fet2020/static/js/prism-autoloader@1.25.0.js create mode 100644 fet2020/static/js/prism-core@1.25.0.js diff --git a/fet2020/static/js/prism-autoloader@1.25.0.js b/fet2020/static/js/prism-autoloader@1.25.0.js new file mode 100644 index 00000000..ae93dc13 --- /dev/null +++ b/fet2020/static/js/prism-autoloader@1.25.0.js @@ -0,0 +1,515 @@ +(function () { + + if (typeof Prism === 'undefined' || typeof document === 'undefined') { + return; + } + + /* eslint-disable */ + + /** + * The dependencies map is built automatically with gulp. + * + * @type {Object} + */ + var lang_dependencies = /*dependencies_placeholder[*/{ + "javascript": "clike", + "actionscript": "javascript", + "apex": [ + "clike", + "sql" + ], + "arduino": "cpp", + "aspnet": [ + "markup", + "csharp" + ], + "birb": "clike", + "bison": "c", + "c": "clike", + "csharp": "clike", + "cpp": "c", + "cfscript": "clike", + "chaiscript": [ + "clike", + "cpp" + ], + "coffeescript": "javascript", + "crystal": "ruby", + "css-extras": "css", + "d": "clike", + "dart": "clike", + "django": "markup-templating", + "ejs": [ + "javascript", + "markup-templating" + ], + "etlua": [ + "lua", + "markup-templating" + ], + "erb": [ + "ruby", + "markup-templating" + ], + "fsharp": "clike", + "firestore-security-rules": "clike", + "flow": "javascript", + "ftl": "markup-templating", + "gml": "clike", + "glsl": "c", + "go": "clike", + "groovy": "clike", + "haml": "ruby", + "handlebars": "markup-templating", + "haxe": "clike", + "hlsl": "c", + "idris": "haskell", + "java": "clike", + "javadoc": [ + "markup", + "java", + "javadoclike" + ], + "jolie": "clike", + "jsdoc": [ + "javascript", + "javadoclike", + "typescript" + ], + "js-extras": "javascript", + "json5": "json", + "jsonp": "json", + "js-templates": "javascript", + "kotlin": "clike", + "latte": [ + "clike", + "markup-templating", + "php" + ], + "less": "css", + "lilypond": "scheme", + "liquid": "markup-templating", + "markdown": "markup", + "markup-templating": "markup", + "mongodb": "javascript", + "n4js": "javascript", + "objectivec": "c", + "opencl": "c", + "parser": "markup", + "php": "markup-templating", + "phpdoc": [ + "php", + "javadoclike" + ], + "php-extras": "php", + "plsql": "sql", + "processing": "clike", + "protobuf": "clike", + "pug": [ + "markup", + "javascript" + ], + "purebasic": "clike", + "purescript": "haskell", + "qsharp": "clike", + "qml": "javascript", + "qore": "clike", + "racket": "scheme", + "cshtml": [ + "markup", + "csharp" + ], + "jsx": [ + "markup", + "javascript" + ], + "tsx": [ + "jsx", + "typescript" + ], + "reason": "clike", + "ruby": "clike", + "sass": "css", + "scss": "css", + "scala": "java", + "shell-session": "bash", + "smarty": "markup-templating", + "solidity": "clike", + "soy": "markup-templating", + "sparql": "turtle", + "sqf": "clike", + "squirrel": "clike", + "t4-cs": [ + "t4-templating", + "csharp" + ], + "t4-vb": [ + "t4-templating", + "vbnet" + ], + "tap": "yaml", + "tt2": [ + "clike", + "markup-templating" + ], + "textile": "markup", + "twig": "markup", + "typescript": "javascript", + "v": "clike", + "vala": "clike", + "vbnet": "basic", + "velocity": "markup", + "wiki": "markup", + "xeora": "markup", + "xml-doc": "markup", + "xquery": "markup" + }/*]*/; + + var lang_aliases = /*aliases_placeholder[*/{ + "html": "markup", + "xml": "markup", + "svg": "markup", + "mathml": "markup", + "ssml": "markup", + "atom": "markup", + "rss": "markup", + "js": "javascript", + "g4": "antlr4", + "adoc": "asciidoc", + "avs": "avisynth", + "avdl": "avro-idl", + "shell": "bash", + "shortcode": "bbcode", + "rbnf": "bnf", + "oscript": "bsl", + "cs": "csharp", + "dotnet": "csharp", + "cfc": "cfscript", + "coffee": "coffeescript", + "conc": "concurnas", + "jinja2": "django", + "dns-zone": "dns-zone-file", + "dockerfile": "docker", + "gv": "dot", + "eta": "ejs", + "xlsx": "excel-formula", + "xls": "excel-formula", + "gamemakerlanguage": "gml", + "gni": "gn", + "hbs": "handlebars", + "hs": "haskell", + "idr": "idris", + "gitignore": "ignore", + "hgignore": "ignore", + "npmignore": "ignore", + "webmanifest": "json", + "kt": "kotlin", + "kts": "kotlin", + "kum": "kumir", + "tex": "latex", + "context": "latex", + "ly": "lilypond", + "emacs": "lisp", + "elisp": "lisp", + "emacs-lisp": "lisp", + "md": "markdown", + "moon": "moonscript", + "n4jsd": "n4js", + "nani": "naniscript", + "objc": "objectivec", + "qasm": "openqasm", + "objectpascal": "pascal", + "px": "pcaxis", + "pcode": "peoplecode", + "pq": "powerquery", + "mscript": "powerquery", + "pbfasm": "purebasic", + "purs": "purescript", + "py": "python", + "qs": "qsharp", + "rkt": "racket", + "razor": "cshtml", + "rpy": "renpy", + "robot": "robotframework", + "rb": "ruby", + "sh-session": "shell-session", + "shellsession": "shell-session", + "smlnj": "sml", + "sol": "solidity", + "sln": "solution-file", + "rq": "sparql", + "t4": "t4-cs", + "trig": "turtle", + "ts": "typescript", + "tsconfig": "typoscript", + "uscript": "unrealscript", + "uc": "unrealscript", + "url": "uri", + "vb": "visual-basic", + "vba": "visual-basic", + "mathematica": "wolfram", + "nb": "wolfram", + "wl": "wolfram", + "xeoracube": "xeora", + "yml": "yaml" + }/*]*/; + + /* eslint-enable */ + + /** + * @typedef LangDataItem + * @property {{ success?: () => void, error?: () => void }[]} callbacks + * @property {boolean} [error] + * @property {boolean} [loading] + */ + /** @type {Object} */ + var lang_data = {}; + + var ignored_language = 'none'; + var languages_path = 'components/'; + + var script = Prism.util.currentScript(); + if (script) { + var autoloaderFile = /\bplugins\/autoloader\/prism-autoloader\.(?:min\.)?js(?:\?[^\r\n/]*)?$/i; + var prismFile = /(^|\/)[\w-]+\.(?:min\.)?js(?:\?[^\r\n/]*)?$/i; + + var autoloaderPath = script.getAttribute('data-autoloader-path'); + if (autoloaderPath != null) { + // data-autoloader-path is set, so just use it + languages_path = autoloaderPath.trim().replace(/\/?$/, '/'); + } else { + var src = script.src; + if (autoloaderFile.test(src)) { + // the script is the original autoloader script in the usual Prism project structure + languages_path = src.replace(autoloaderFile, 'components/'); + } else if (prismFile.test(src)) { + // the script is part of a bundle like a custom prism.js from the download page + languages_path = src.replace(prismFile, '$1components/'); + } + } + } + + var config = Prism.plugins.autoloader = { + languages_path: languages_path, + use_minified: true, + loadLanguages: loadLanguages + }; + + + /** + * Lazily loads an external script. + * + * @param {string} src + * @param {() => void} [success] + * @param {() => void} [error] + */ + function addScript(src, success, error) { + var s = document.createElement('script'); + s.src = src; + s.async = true; + s.onload = function () { + document.body.removeChild(s); + success && success(); + }; + s.onerror = function () { + document.body.removeChild(s); + error && error(); + }; + document.body.appendChild(s); + } + + /** + * Returns all additional dependencies of the given element defined by the `data-dependencies` attribute. + * + * @param {Element} element + * @returns {string[]} + */ + function getDependencies(element) { + var deps = (element.getAttribute('data-dependencies') || '').trim(); + if (!deps) { + var parent = element.parentElement; + if (parent && parent.tagName.toLowerCase() === 'pre') { + deps = (parent.getAttribute('data-dependencies') || '').trim(); + } + } + return deps ? deps.split(/\s*,\s*/g) : []; + } + + /** + * Returns whether the given language is currently loaded. + * + * @param {string} lang + * @returns {boolean} + */ + function isLoaded(lang) { + if (lang.indexOf('!') >= 0) { + // forced reload + return false; + } + + lang = lang_aliases[lang] || lang; // resolve alias + + if (lang in Prism.languages) { + // the given language is already loaded + return true; + } + + // this will catch extensions like CSS extras that don't add a grammar to Prism.languages + var data = lang_data[lang]; + return data && !data.error && data.loading === false; + } + + /** + * Returns the path to a grammar, using the language_path and use_minified config keys. + * + * @param {string} lang + * @returns {string} + */ + function getLanguagePath(lang) { + return config.languages_path + 'prism-' + lang + (config.use_minified ? '.min' : '') + '.js'; + } + + /** + * Loads all given grammars concurrently. + * + * @param {string[]|string} languages + * @param {(languages: string[]) => void} [success] + * @param {(language: string) => void} [error] This callback will be invoked on the first language to fail. + */ + function loadLanguages(languages, success, error) { + if (typeof languages === 'string') { + languages = [languages]; + } + + var total = languages.length; + var completed = 0; + var failed = false; + + if (total === 0) { + if (success) { + setTimeout(success, 0); + } + return; + } + + function successCallback() { + if (failed) { + return; + } + completed++; + if (completed === total) { + success && success(languages); + } + } + + languages.forEach(function (lang) { + loadLanguage(lang, successCallback, function () { + if (failed) { + return; + } + failed = true; + error && error(lang); + }); + }); + } + + /** + * Loads a grammar with its dependencies. + * + * @param {string} lang + * @param {() => void} [success] + * @param {() => void} [error] + */ + function loadLanguage(lang, success, error) { + var force = lang.indexOf('!') >= 0; + + lang = lang.replace('!', ''); + lang = lang_aliases[lang] || lang; + + function load() { + var data = lang_data[lang]; + if (!data) { + data = lang_data[lang] = { + callbacks: [] + }; + } + data.callbacks.push({ + success: success, + error: error + }); + + if (!force && isLoaded(lang)) { + // the language is already loaded and we aren't forced to reload + languageCallback(lang, 'success'); + } else if (!force && data.error) { + // the language failed to load before and we don't reload + languageCallback(lang, 'error'); + } else if (force || !data.loading) { + // the language isn't currently loading and/or we are forced to reload + data.loading = true; + data.error = false; + + addScript(getLanguagePath(lang), function () { + data.loading = false; + languageCallback(lang, 'success'); + + }, function () { + data.loading = false; + data.error = true; + languageCallback(lang, 'error'); + }); + } + } + + var dependencies = lang_dependencies[lang]; + if (dependencies && dependencies.length) { + loadLanguages(dependencies, load, error); + } else { + load(); + } + } + + /** + * Runs all callbacks of the given type for the given language. + * + * @param {string} lang + * @param {"success" | "error"} type + */ + function languageCallback(lang, type) { + if (lang_data[lang]) { + var callbacks = lang_data[lang].callbacks; + for (var i = 0, l = callbacks.length; i < l; i++) { + var callback = callbacks[i][type]; + if (callback) { + setTimeout(callback, 0); + } + } + callbacks.length = 0; + } + } + + Prism.hooks.add('complete', function (env) { + var element = env.element; + var language = env.language; + if (!element || !language || language === ignored_language) { + return; + } + + var deps = getDependencies(element); + if (/^diff-./i.test(language)) { + // the "diff-xxxx" format is used by the Diff Highlight plugin + deps.push('diff'); + deps.push(language.substr('diff-'.length)); + } else { + deps.push(language); + } + + if (!deps.every(isLoaded)) { + // the language or some dependencies aren't loaded + loadLanguages(deps, function () { + Prism.highlightElement(element); + }); + } + }); + +}()); diff --git a/fet2020/static/js/prism-core@1.25.0.js b/fet2020/static/js/prism-core@1.25.0.js new file mode 100644 index 00000000..cf77da51 --- /dev/null +++ b/fet2020/static/js/prism-core@1.25.0.js @@ -0,0 +1,1221 @@ +/// + +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 + * + * @license MIT + * @author Lea Verou + * @namespace + * @public + */ +var Prism = (function (_self) { + + // Private helper vars + var lang = /\blang(?:uage)?-([\w-]+)\b/i; + var uniqueId = 0; + + // The grammar object for plaintext + var plainTextGrammar = {}; + + + var _ = { + /** + * By default, Prism will attempt to highlight all code elements (by calling {@link Prism.highlightAll}) on the + * current page after the page finished loading. This might be a problem if e.g. you wanted to asynchronously load + * additional languages or plugins yourself. + * + * By setting this value to `true`, Prism will not automatically highlight all code elements on the page. + * + * You obviously have to change this value before the automatic highlighting started. To do this, you can add an + * empty Prism object into the global scope before loading the Prism script like this: + * + * ```js + * window.Prism = window.Prism || {}; + * Prism.manual = true; + * // add a new + - + + + + + + -