wikiparser-node 1.16.2 → 1.16.3

package/extensions/dist/codejar.js

@@ -0,0 +1,56 @@
+(() => {
+const codejar = (async () => {
+    const { CodeJar } = 'CodeJar' in globalThis
+        ? globalThis
+        : await import('https://testingcf.jsdelivr.net/npm/codejar-async');
+    return (textbox, include, linenums) => {
+        var _a;
+        if (!(textbox instanceof HTMLTextAreaElement)) {
+            throw new TypeError('wikiparse.codejar方法仅可用于textarea元素！');
+        }
+        const preview = document.createElement('div'), root = document.createElement('span'), { offsetHeight, selectionStart: start, selectionEnd: end, style: { height, paddingTop, paddingBottom, paddingLeft, paddingRight }, } = textbox;
+        preview.className = 'wikiparser wikiparse-container';
+        preview.tabIndex = 0;
+        preview.style.height = offsetHeight ? `${offsetHeight}px` : height;
+        preview.style.paddingTop = paddingTop;
+        preview.style.paddingBottom = paddingBottom;
+        root.className = 'wpb-root';
+        root.style.paddingLeft = paddingLeft;
+        root.style.paddingRight = paddingRight;
+        preview.append(root);
+        textbox.after(preview);
+        textbox.style.display = 'none';
+        preview.addEventListener('focus', () => {
+            root.focus();
+        });
+        const id = wikiparse.id++;
+        const highlight = async (e) => (await wikiparse.print(e.textContent, jar.include, undefined, id)).map(([, , printed]) => printed).join('');
+        const jar = {
+            ...CodeJar(root, highlight, {
+                spellcheck: true,
+                autoclose: { open: '', close: '' },
+            }),
+            include: Boolean(include),
+            editor: root,
+        };
+        if (linenums) {
+            jar.onHighlight(e => {
+                var _a;
+                (_a = e.parentNode.querySelector('.wikiparser-line-numbers')) === null || _a === void 0 ? void 0 : _a.remove();
+                wikiparse.lineNumbers(e, 1, paddingTop);
+            });
+        }
+        jar.restore({ start: 0, end: 0 });
+        jar.updateCode(textbox.value);
+        jar.restore({ start, end });
+        (_a = textbox.form) === null || _a === void 0 ? void 0 : _a.addEventListener('submit', () => {
+            textbox.value = jar.toString();
+        });
+        return jar;
+    };
+})();
+wikiparse.codejar = codejar;
+(async () => {
+    wikiparse.codejar = await codejar;
+})();
+})();

package/extensions/dist/editor.js

@@ -0,0 +1,159 @@
+(() => {
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Printer_instances, _Printer_id, _Printer_preview, _Printer_textbox, _Printer_root, _Printer_viewportChanged, _Printer_running, _Printer_ticks, _Printer_tick, _Printer_exec, _Printer_paint, _Printer_coarsePrint, _Printer_finePrint;
+class Printer {
+    constructor(preview, textbox, include) {
+        _Printer_instances.add(this);
+        _Printer_id.set(this, void 0);
+        _Printer_preview.set(this, void 0);
+        _Printer_textbox.set(this, void 0);
+        _Printer_root.set(this, void 0);
+        _Printer_viewportChanged.set(this, void 0);
+        _Printer_running.set(this, void 0);
+        _Printer_ticks.set(this, void 0);
+        __classPrivateFieldSet(this, _Printer_id, wikiparse.id++, "f");
+        __classPrivateFieldSet(this, _Printer_preview, preview, "f");
+        __classPrivateFieldSet(this, _Printer_textbox, textbox, "f");
+        __classPrivateFieldSet(this, _Printer_root, [], "f");
+        __classPrivateFieldSet(this, _Printer_viewportChanged, false, "f");
+        this.include = Boolean(include);
+        __classPrivateFieldSet(this, _Printer_ticks, [0, undefined], "f");
+    }
+    queue(delay, method) {
+        const [state] = __classPrivateFieldGet(this, _Printer_ticks, "f");
+        if (delay === 0 || state <= 0 || method === 0 || __classPrivateFieldGet(this, _Printer_ticks, "f")[1] !== 0) {
+            __classPrivateFieldSet(this, _Printer_ticks, [delay, method], "f");
+            if (delay === 0) {
+                __classPrivateFieldGet(this, _Printer_instances, "m", _Printer_exec).call(this, method);
+            }
+            else if (state <= 0) {
+                __classPrivateFieldGet(this, _Printer_instances, "m", _Printer_tick).call(this);
+            }
+        }
+    }
+}
+_Printer_id = new WeakMap(), _Printer_preview = new WeakMap(), _Printer_textbox = new WeakMap(), _Printer_root = new WeakMap(), _Printer_viewportChanged = new WeakMap(), _Printer_running = new WeakMap(), _Printer_ticks = new WeakMap(), _Printer_instances = new WeakSet(), _Printer_tick = function _Printer_tick() {
+    setTimeout(() => {
+        const [t, method] = __classPrivateFieldGet(this, _Printer_ticks, "f");
+        if (t > 0) {
+            __classPrivateFieldGet(this, _Printer_ticks, "f")[0] -= 500;
+            if (t <= 500) {
+                __classPrivateFieldGet(this, _Printer_instances, "m", _Printer_exec).call(this, method);
+            }
+            else {
+                __classPrivateFieldGet(this, _Printer_instances, "m", _Printer_tick).call(this);
+            }
+        }
+    }, 500);
+}, _Printer_exec = function _Printer_exec(method) {
+    if (method === 0) {
+        __classPrivateFieldGet(this, _Printer_instances, "m", _Printer_coarsePrint).call(this);
+    }
+    else {
+        __classPrivateFieldGet(this, _Printer_instances, "m", _Printer_finePrint).call(this);
+    }
+}, _Printer_paint = function _Printer_paint() {
+    __classPrivateFieldGet(this, _Printer_preview, "f").innerHTML = `<span class="wpb-root">${__classPrivateFieldGet(this, _Printer_root, "f").map(([, , printed]) => printed).join('')}</span> `;
+    __classPrivateFieldGet(this, _Printer_preview, "f").scrollTop = __classPrivateFieldGet(this, _Printer_textbox, "f").scrollTop;
+    __classPrivateFieldGet(this, _Printer_preview, "f").classList.remove('active');
+    __classPrivateFieldGet(this, _Printer_textbox, "f").style.color = 'transparent';
+}, _Printer_coarsePrint = async function _Printer_coarsePrint() {
+    if (__classPrivateFieldGet(this, _Printer_running, "f")) {
+        return __classPrivateFieldGet(this, _Printer_running, "f");
+    }
+    const { include } = this, { value } = __classPrivateFieldGet(this, _Printer_textbox, "f"), parsed = await wikiparse.print(value, include, 2, __classPrivateFieldGet(this, _Printer_id, "f"));
+    if (this.include !== include || __classPrivateFieldGet(this, _Printer_textbox, "f").value !== value) {
+        __classPrivateFieldSet(this, _Printer_running, undefined, "f");
+        __classPrivateFieldSet(this, _Printer_running, __classPrivateFieldGet(this, _Printer_instances, "m", _Printer_coarsePrint).call(this), "f");
+        return __classPrivateFieldGet(this, _Printer_running, "f");
+    }
+    __classPrivateFieldSet(this, _Printer_root, parsed, "f");
+    __classPrivateFieldGet(this, _Printer_instances, "m", _Printer_paint).call(this);
+    __classPrivateFieldSet(this, _Printer_running, undefined, "f");
+    __classPrivateFieldSet(this, _Printer_running, __classPrivateFieldGet(this, _Printer_instances, "m", _Printer_finePrint).call(this), "f");
+    return __classPrivateFieldGet(this, _Printer_running, "f");
+}, _Printer_finePrint = async function _Printer_finePrint() {
+    if (__classPrivateFieldGet(this, _Printer_running, "f")) {
+        __classPrivateFieldSet(this, _Printer_viewportChanged, true, "f");
+        return __classPrivateFieldGet(this, _Printer_running, "f");
+    }
+    __classPrivateFieldSet(this, _Printer_viewportChanged, false, "f");
+    const { include } = this, { value } = __classPrivateFieldGet(this, _Printer_textbox, "f"), { scrollHeight, offsetHeight: parentHeight, scrollTop, children } = __classPrivateFieldGet(this, _Printer_preview, "f");
+    let text = value, start = 0, end = __classPrivateFieldGet(this, _Printer_root, "f").length;
+    if (scrollHeight > parentHeight) {
+        const childNodes = [...children[0].childNodes], headings = childNodes.filter(({ className }) => className === 'wpb-heading'), { length } = headings;
+        if (length > 0) {
+            let i = headings.findIndex(({ offsetTop, offsetHeight }) => offsetTop + offsetHeight > scrollTop);
+            i = i === -1 ? length : i;
+            let j = headings.slice(i).findIndex(({ offsetTop }) => offsetTop >= scrollTop + parentHeight);
+            j = j === -1 ? length : i + j;
+            start = i ? childNodes.indexOf(headings[i - 1]) : 0;
+            while (i <= j && __classPrivateFieldGet(this, _Printer_root, "f")[start][0] === Infinity) {
+                start = childNodes.indexOf(headings[i++]);
+            }
+            end = j === length ? end : childNodes.indexOf(headings[j]);
+            while (i <= j && __classPrivateFieldGet(this, _Printer_root, "f")[end - 1][0] === Infinity) {
+                end = childNodes.indexOf(headings[--j]);
+            }
+            text = __classPrivateFieldGet(this, _Printer_root, "f").slice(start, end).map(([, str]) => str).join('');
+        }
+    }
+    if (start === end) {
+        __classPrivateFieldSet(this, _Printer_running, undefined, "f");
+        return undefined;
+    }
+    const parsed = await wikiparse.print(text, include, undefined, __classPrivateFieldGet(this, _Printer_id, "f"));
+    if (this.include === include && __classPrivateFieldGet(this, _Printer_textbox, "f").value === value) {
+        __classPrivateFieldGet(this, _Printer_root, "f").splice(start, end - start, ...parsed);
+        __classPrivateFieldGet(this, _Printer_instances, "m", _Printer_paint).call(this);
+        __classPrivateFieldSet(this, _Printer_running, undefined, "f");
+        if (__classPrivateFieldGet(this, _Printer_viewportChanged, "f")) {
+            __classPrivateFieldSet(this, _Printer_running, __classPrivateFieldGet(this, _Printer_instances, "m", _Printer_finePrint).call(this), "f");
+        }
+    }
+    else {
+        __classPrivateFieldSet(this, _Printer_running, undefined, "f");
+        __classPrivateFieldSet(this, _Printer_running, __classPrivateFieldGet(this, _Printer_instances, "m", _Printer_coarsePrint).call(this), "f");
+    }
+    return __classPrivateFieldGet(this, _Printer_running, "f");
+};
+const edit = (textbox, include) => {
+    if (!(textbox instanceof HTMLTextAreaElement)) {
+        throw new TypeError('wikiparse.edit方法仅可用于textarea元素！');
+    }
+    const preview = document.createElement('div'), container = document.createElement('div'), printer = new Printer(preview, textbox, include);
+    preview.id = 'wikiPretty';
+    preview.classList.add('wikiparser', 'active');
+    container.className = 'wikiparse-container';
+    textbox.replaceWith(container);
+    textbox.classList.add('wikiparsed');
+    container.append(preview, textbox);
+    textbox.addEventListener('input', e => {
+        if (!e.isComposing) {
+            printer.queue(2000, 0);
+        }
+        textbox.style.color = '';
+        preview.classList.add('active');
+    });
+    textbox.addEventListener('scroll', () => {
+        if (preview.scrollHeight > preview.offsetHeight && !preview.classList.contains('active')) {
+            preview.scrollTop = textbox.scrollTop;
+            printer.queue(500, 1);
+        }
+    });
+    printer.queue(0, 0);
+    return printer;
+};
+wikiparse.Printer = Printer;
+wikiparse.edit = edit;
+})();

package/extensions/dist/highlight.js

@@ -0,0 +1,30 @@
+(() => {
+"use strict";
+const highlight = async (ele, include, linenums, start) => {
+    if (ele.classList.contains('wikiparser')) {
+        return;
+    }
+    let { innerText } = ele;
+    if (innerText.endsWith('\n')) {
+        innerText = innerText.slice(0, -1);
+    }
+    innerText || (innerText = ' ');
+    const html = `<span class="wpb-root">${(await wikiparse.print(innerText, include)).map(([, , printed]) => printed).join('')}</span>`;
+    ele.classList.add('wikiparser');
+    ele.tabIndex = 0;
+    ele.innerHTML = html;
+    if (linenums) {
+        wikiparse.lineNumbers(ele.firstChild, start);
+    }
+    ele.addEventListener('keydown', e => {
+        if ((e.metaKey || e.ctrlKey) && e.key === 'a') {
+            e.preventDefault();
+            const range = document.createRange(), selection = getSelection();
+            range.selectNodeContents(ele.firstChild);
+            selection.removeAllRanges();
+            selection.addRange(range);
+        }
+    });
+};
+wikiparse.highlight = highlight;
+})();

package/extensions/dist/lint.js

@@ -0,0 +1,79 @@
+(() => {
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Linter_instances, _Linter_id, _Linter_wikitext, _Linter_running, _Linter_done, _Linter_config, _Linter_lint;
+class Linter {
+    constructor(include) {
+        _Linter_instances.add(this);
+        _Linter_id.set(this, void 0);
+        _Linter_wikitext.set(this, void 0);
+        _Linter_running.set(this, void 0);
+        _Linter_done.set(this, void 0);
+        _Linter_config.set(this, void 0);
+        __classPrivateFieldSet(this, _Linter_id, wikiparse.id++, "f");
+        this.include = Boolean(include);
+    }
+    async queue(wikitext) {
+        var _a;
+        if (__classPrivateFieldGet(this, _Linter_wikitext, "f") === wikitext && __classPrivateFieldGet(this, _Linter_config, "f") === wikiparse.config && !__classPrivateFieldGet(this, _Linter_running, "f")) {
+            return __classPrivateFieldGet(this, _Linter_done, "f");
+        }
+        __classPrivateFieldSet(this, _Linter_wikitext, wikitext, "f");
+        __classPrivateFieldSet(this, _Linter_running, (_a = __classPrivateFieldGet(this, _Linter_running, "f")) !== null && _a !== void 0 ? _a : __classPrivateFieldGet(this, _Linter_instances, "m", _Linter_lint).call(this, wikitext), "f");
+        return __classPrivateFieldGet(this, _Linter_running, "f");
+    }
+    async codemirror(wikitext) {
+        return (await this.queue(wikitext))
+            .map(({ startIndex, endIndex, severity, message, rule, fix, suggestions = [] }) => ({
+            source: 'WikiLint',
+            from: startIndex,
+            to: endIndex,
+            severity,
+            message: `${message} (${rule})`,
+            actions: [
+                ...fix ? [{ name: `Fix: ${fix.desc}`, fix }] : [],
+                ...suggestions.map(suggestion => ({ name: `Suggestion: ${suggestion.desc}`, fix: suggestion })),
+            ].map(({ name, fix: { range: [from, to], text } }) => ({
+                name,
+                apply(view) {
+                    view.dispatch({ changes: { from, to, insert: text } });
+                },
+            })),
+        }));
+    }
+    async monaco(wikitext) {
+        return (await this.queue(wikitext))
+            .map(({ startLine, startCol, endLine, endCol, severity, message, rule }) => ({
+            source: `WikiLint`,
+            startLineNumber: startLine + 1,
+            startColumn: startCol + 1,
+            endLineNumber: endLine + 1,
+            endColumn: endCol + 1,
+            severity: severity === 'error' ? 8 : 4,
+            code: rule,
+            message,
+        }));
+    }
+}
+_Linter_id = new WeakMap(), _Linter_wikitext = new WeakMap(), _Linter_running = new WeakMap(), _Linter_done = new WeakMap(), _Linter_config = new WeakMap(), _Linter_instances = new WeakSet(), _Linter_lint = async function _Linter_lint(wikitext) {
+    __classPrivateFieldSet(this, _Linter_config, wikiparse.config, "f");
+    const { include } = this, errors = await wikiparse.lint(wikitext, include, __classPrivateFieldGet(this, _Linter_id, "f"));
+    if (this.include === include && __classPrivateFieldGet(this, _Linter_wikitext, "f") === wikitext && __classPrivateFieldGet(this, _Linter_config, "f") === wikiparse.config) {
+        __classPrivateFieldSet(this, _Linter_running, undefined, "f");
+        __classPrivateFieldSet(this, _Linter_done, errors, "f");
+        return errors;
+    }
+    __classPrivateFieldSet(this, _Linter_running, __classPrivateFieldGet(this, _Linter_instances, "m", _Linter_lint).call(this, __classPrivateFieldGet(this, _Linter_wikitext, "f")), "f");
+    return __classPrivateFieldGet(this, _Linter_running, "f");
+};
+wikiparse.Linter = Linter;
+})();

package/extensions/dist/lsp.js

@@ -0,0 +1,74 @@
+(() => {
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _LanguageService_id;
+let data;
+class LanguageService {
+    constructor() {
+        _LanguageService_id.set(this, void 0);
+        __classPrivateFieldSet(this, _LanguageService_id, wikiparse.id++, "f");
+        data !== null && data !== void 0 ? data : (data = (async () => (await fetch(`${wikiparse.CDN}/data/signatures.json`)).json())());
+        (async () => {
+            wikiparse.provide('data', __classPrivateFieldGet(this, _LanguageService_id, "f"), await data);
+        })();
+    }
+    destroy() {
+        wikiparse.provide('destroy', __classPrivateFieldGet(this, _LanguageService_id, "f"));
+    }
+    provideColorPresentations(color) {
+        return wikiparse.provide('colorPresentations', __classPrivateFieldGet(this, _LanguageService_id, "f"), color);
+    }
+    provideDocumentColors(text) {
+        return wikiparse.provide('documentColors', __classPrivateFieldGet(this, _LanguageService_id, "f") + 0.1, text);
+    }
+    provideFoldingRanges(text) {
+        return wikiparse.provide('foldingRanges', __classPrivateFieldGet(this, _LanguageService_id, "f") + 0.2, text);
+    }
+    provideLinks(text) {
+        return wikiparse.provide('links', __classPrivateFieldGet(this, _LanguageService_id, "f") + 0.3, text);
+    }
+    provideCompletionItems(text, position) {
+        return wikiparse
+            .provide('completionItems', __classPrivateFieldGet(this, _LanguageService_id, "f") + 0.4, text, position);
+    }
+    provideReferences(text, position) {
+        return wikiparse
+            .provide('references', __classPrivateFieldGet(this, _LanguageService_id, "f") + 0.5, text, position);
+    }
+    provideDefinition(text, position) {
+        return wikiparse
+            .provide('definition', __classPrivateFieldGet(this, _LanguageService_id, "f") + 0.6, text, position);
+    }
+    resolveRenameLocation(text, position) {
+        return wikiparse.provide('renameLocation', __classPrivateFieldGet(this, _LanguageService_id, "f") + 0.7, text, position);
+    }
+    provideRenameEdits(text, position, newName) {
+        return wikiparse
+            .provide('renameEdits', __classPrivateFieldGet(this, _LanguageService_id, "f") + 0.8, text, position, newName);
+    }
+    provideDiagnostics(wikitext, warning) {
+        return wikiparse.provide('diagnostics', __classPrivateFieldGet(this, _LanguageService_id, "f") + 0.9, wikitext, warning);
+    }
+    provideHover(text, position) {
+        return wikiparse.provide('hover', __classPrivateFieldGet(this, _LanguageService_id, "f") + 0.05, text, position);
+    }
+    provideSignatureHelp(text, position) {
+        return wikiparse
+            .provide('signatureHelp', __classPrivateFieldGet(this, _LanguageService_id, "f") + 0.15, text, position);
+    }
+    provideInlayHints(text) {
+        return wikiparse.provide('inlayHints', __classPrivateFieldGet(this, _LanguageService_id, "f") + 0.25, text);
+    }
+}
+_LanguageService_id = new WeakMap();
+wikiparse.LanguageService = LanguageService;
+})();

package/extensions/dist/test-page.js

@@ -0,0 +1,89 @@
+(() => {
+"use strict";
+(async () => {
+    const tests = await (await fetch('./test/parserTests.json')).json(), key = 'wikiparser-node-done', dones = new Set(JSON.parse(localStorage.getItem(key))), isGH = location.hostname.endsWith('.github.io'), isIframe = self !== top, select = document.querySelector('select'), btn = document.querySelector('button'), pre = document.querySelector('pre'), container = document.getElementById('frame'), container1 = document.getElementById('frame1'), container2 = document.getElementById('frame2');
+    Parser.config = await (await fetch('./config/default.json')).json();
+    wikiparse.print = (wikitext, include, stage) => {
+        const printed = Parser.parse(wikitext, include, stage).print();
+        return Promise.resolve([[stage !== null && stage !== void 0 ? stage : Infinity, wikitext, printed]]);
+    };
+    wikiparse.highlight(pre, false, true);
+    btn.disabled = !select.value;
+    if (!isGH) {
+        btn.style.display = '';
+    }
+    let optgroup;
+    for (const [i, { desc, wikitext, html }] of tests.entries()) {
+        if (wikitext === undefined) {
+            optgroup = document.createElement('optgroup');
+            optgroup.label = desc;
+            select.append(optgroup);
+        }
+        else if ((isIframe || html !== undefined) && (isGH || !dones.has(desc))) {
+            const option = document.createElement('option');
+            option.value = String(i);
+            option.textContent = desc;
+            optgroup.append(option);
+        }
+    }
+    select.addEventListener('change', () => {
+        const { wikitext, html, render, desc } = tests[Number(select.value)];
+        pre.textContent = wikitext;
+        pre.classList.remove('wikiparser');
+        container.removeAttribute('data-source');
+        if (html === undefined) {
+            container.style.display = 'none';
+        }
+        else {
+            container.style.display = '';
+            container1.innerHTML = html;
+            container2.innerHTML = render !== null && render !== void 0 ? render : '';
+        }
+        wikiparse.highlight(pre, false, true);
+        select.selectedOptions[0].disabled = true;
+        btn.disabled = false;
+        history.replaceState(null, '', `#${encodeURIComponent(desc)}`);
+        dispatchEvent(new Event('casechange'));
+    });
+    btn.addEventListener('click', () => {
+        dones.add(tests[Number(select.value)].desc);
+        localStorage.setItem(key, JSON.stringify([...dones]));
+        while (select.selectedOptions[0].disabled) {
+            select.selectedIndex++;
+        }
+        select.dispatchEvent(new Event('change'));
+    });
+    container.addEventListener('click', e => {
+        e.preventDefault();
+    }, { capture: true });
+    container.addEventListener('dblclick', e => {
+        e.preventDefault();
+        if (container.dataset['source']) {
+            container.removeAttribute('data-source');
+            container1.innerHTML = container1.textContent;
+            container2.innerHTML = container2.textContent;
+        }
+        else {
+            container.dataset['source'] = '1';
+            const pre1 = document.createElement('pre'), pre2 = document.createElement('pre'), code1 = document.createElement('code'), code2 = document.createElement('code');
+            code1.textContent = container1.innerHTML;
+            code2.textContent = container2.innerHTML;
+            pre1.className = 'language-html';
+            pre2.className = 'language-html';
+            pre1.append(code1);
+            pre2.append(code2);
+            container1.replaceChildren(pre1);
+            container2.replaceChildren(pre2);
+            Prism.highlightAllUnder(container);
+        }
+    });
+    addEventListener('hashchange', () => {
+        const hash = decodeURIComponent(location.hash.slice(1)), i = tests.findIndex(({ desc }) => desc === hash);
+        if (i !== -1) {
+            select.value = String(i);
+            select.dispatchEvent(new Event('change'));
+        }
+    });
+    dispatchEvent(new Event('hashchange'));
+})();
+})();

package/extensions/editor.css

@@ -0,0 +1,59 @@
+.wikiparsed {
+	position: relative;
+	display: block;
+	box-sizing: border-box;
+	width: 100%;
+	resize: vertical;
+	font-family: monospace;
+	background: none !important;
+	caret-color: #000;
+}
+#wikiPretty {
+	position: absolute;
+	inset: 0;
+	-webkit-user-select: none;
+	user-select: none;
+}
+#wikiPretty + .wikiparsed, #wikiPretty {
+	outline: none;
+	border: 1.5px solid #dedede !important;
+	border-radius: 0;
+	padding: .4em;
+	line-height: 1.4 !important;
+	font-size: inherit;
+	tab-size: 4;
+	overflow-y: auto;
+	word-break: normal;
+}
+
+/* compromise for font-weight: bold */
+.wpb-ext, .wpb-html,
+.wpb-arg,
+.wpb-template,
+.wpb-magic-word,
+.wpb-heading-title,
+.wpb-table, .wpb-tr, .wpb-td,
+.wpb-double-underscore, .wpb-hr, .wpb-quote, .wpb-list, .wpb-dd, .wpb-redirect-syntax,
+.wpb-converter {
+	-webkit-text-stroke-width: .1ex;
+}
+.wpb-table-inter,
+.wpb-hidden, .wpb-noinclude, .wpb-include, .wpb-comment, .wpb-attr-dirty,
+.wpb-ext-attrs, .wpb-html-attrs,
+.wpb-ext-inner,
+.wpb-arg-default,
+.wpb-invoke-module, .wpb-invoke-function,
+.wpb-parameter,
+.wpb-table-attrs,
+.wpb-td-inner,
+.wpb-converter-rule {
+	-webkit-text-stroke-width: 0;
+}
+#wikiPretty span {
+	font-weight: normal;
+}
+
+#wikiPretty.active span {
+	color: transparent;
+	background: none;
+}

package/extensions/es7/base.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 var _a;
-const version = '1.16.2', src = (_a = document.currentScript) === null || _a === void 0 ? void 0 : _a.src, file = /\/extensions\/dist\/base\.(?:min\.)?js$/u, CDN = src && file.test(src)
+const version = '1.16.3', src = (_a = document.currentScript) === null || _a === void 0 ? void 0 : _a.src, file = /\/extensions\/dist\/base\.(?:min\.)?js$/u, CDN = src && file.test(src)
     ? src.replace(file, '')
     : `https://testingcf.jsdelivr.net/npm/wikiparser-node@${version}`;
 const workerJS = () => {