wikiparser-node 1.24.0 → 1.24.1

package/extensions/dist/base.js

@@ -0,0 +1,375 @@
+(() => {
+var _a;
+const version = '1.24.1', 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 = () => {
+    importScripts('$CDN/bundle/bundle-lsp.min.js');
+    const entities = { '&': 'amp', '<': 'lt', '>': 'gt' }, lsps = new Map(), last = { include: true };
+    const parse = (wikitext, include = false, stage) => {
+        if (stage === undefined && last.wikitext === wikitext && last.include === include) {
+            return last.root;
+        }
+        const root = Parser.parse(wikitext, include, stage);
+        if (stage === undefined) {
+            last.wikitext = wikitext;
+            last.include = include;
+            last.root = root;
+        }
+        return root;
+    };
+    const getLSP = (id, include = true) => {
+        if (lsps.has(id)) {
+            return lsps.get(id);
+        }
+        const lsp = Parser.createLanguageService();
+        lsp.include = include;
+        lsps.set(id, lsp);
+        return lsp;
+    };
+    const parseColor = (s) => {
+        var _a;
+        if (s.startsWith('#')) {
+            const short = s.length < 7;
+            return [
+                parseInt(short ? s.charAt(1).repeat(2) : s.slice(1, 3), 16),
+                parseInt(short ? s.charAt(2).repeat(2) : s.slice(3, 5), 16),
+                parseInt(short ? s.charAt(3).repeat(2) : s.slice(5, 7), 16),
+                parseInt((short ? s.charAt(4).repeat(2) : s.slice(7, 9)) || 'ff', 16)
+                    / 255,
+            ];
+        }
+        const values = s.slice(s.indexOf('(') + 1, -1).trim()
+            .split(/\s+(?:[,/]\s*)?|[,/]\s*/u)
+            .map(v => parseFloat(v) / (v.endsWith('%') ? 100 : 1));
+        return [
+            values[0],
+            values[1],
+            values[2],
+            (_a = values[3]) !== null && _a !== void 0 ? _a : 1,
+        ];
+    };
+    self.onmessage = ({ data }) => {
+        const [command, qid, wikitext, include, stage, newName] = data;
+        switch (command) {
+            case 'setI18N':
+                Parser.i18n = qid;
+                break;
+            case 'setLintConfig':
+                Parser.lintConfig = qid;
+                break;
+            case 'setConfig':
+                Parser.config = qid;
+                delete last.wikitext;
+                break;
+            case 'getConfig':
+                postMessage([command, qid, Parser.getConfig()]);
+                break;
+            case 'json':
+                postMessage([command, qid, parse(wikitext, include, stage).json()]);
+                break;
+            case 'lint':
+                postMessage([command, qid, parse(wikitext, include).lint(), wikitext]);
+                break;
+            case 'print':
+                postMessage([
+                    command,
+                    qid,
+                    parse(wikitext, include, stage).childNodes.map(child => [
+                        stage !== null && stage !== void 0 ? stage : Infinity,
+                        String(child),
+                        child.type === 'text'
+                            ? String(child).replace(/[&<>]/gu, p => `&${entities[p]};`)
+                            : child.print(),
+                    ]),
+                ]);
+                break;
+            case 'destroy':
+                getLSP(qid).destroy();
+                lsps.delete(qid);
+                break;
+            case 'data':
+                getLSP(qid, include).data = wikitext;
+                break;
+            case 'colorPresentations':
+                postMessage([command, qid, getLSP(qid, include).provideColorPresentations(wikitext)]);
+                break;
+            case 'documentColors':
+                (async () => {
+                    postMessage([
+                        command,
+                        qid,
+                        await getLSP(qid, include).provideDocumentColors(parseColor, wikitext, false),
+                        wikitext,
+                    ]);
+                })();
+                break;
+            case 'foldingRanges':
+                (async () => {
+                    postMessage([command, qid, await getLSP(qid, include).provideFoldingRanges(wikitext), wikitext]);
+                })();
+                break;
+            case 'links':
+                (async () => {
+                    postMessage([command, qid, await getLSP(qid, include).provideLinks(wikitext), wikitext]);
+                })();
+                break;
+            case 'diagnostics':
+                (async () => {
+                    postMessage([
+                        command,
+                        qid,
+                        await getLSP(qid, include).provideDiagnostics(wikitext, stage),
+                        wikitext,
+                    ]);
+                })();
+                break;
+            case 'completionItems':
+                (async () => {
+                    postMessage([
+                        command,
+                        qid,
+                        await getLSP(qid, include).provideCompletionItems(wikitext, stage),
+                        wikitext,
+                    ]);
+                })();
+                break;
+            case 'references':
+                (async () => {
+                    postMessage([
+                        command,
+                        qid,
+                        await getLSP(qid, include).provideReferences(wikitext, stage),
+                        wikitext,
+                    ]);
+                })();
+                break;
+            case 'definition':
+                (async () => {
+                    postMessage([
+                        command,
+                        qid,
+                        await getLSP(qid, include).provideDefinition(wikitext, stage),
+                        wikitext,
+                    ]);
+                })();
+                break;
+            case 'renameLocation':
+                (async () => {
+                    postMessage([
+                        command,
+                        qid,
+                        await getLSP(qid, include).resolveRenameLocation(wikitext, stage),
+                        wikitext,
+                    ]);
+                })();
+                break;
+            case 'renameEdits':
+                (async () => {
+                    postMessage([
+                        command,
+                        qid,
+                        await getLSP(qid, include).provideRenameEdits(wikitext, stage, newName),
+                        wikitext,
+                    ]);
+                })();
+                break;
+            case 'hover':
+                (async () => {
+                    postMessage([command, qid, await getLSP(qid, include).provideHover(wikitext, stage), wikitext]);
+                })();
+                break;
+            case 'signatureHelp':
+                (async () => {
+                    postMessage([
+                        command,
+                        qid,
+                        await getLSP(qid, include).provideSignatureHelp(wikitext, stage),
+                        wikitext,
+                    ]);
+                })();
+                break;
+            case 'inlayHints':
+                (async () => {
+                    postMessage([command, qid, await getLSP(qid, include).provideInlayHints(wikitext), wikitext]);
+                })();
+                break;
+            case 'codeAction':
+                (async () => {
+                    postMessage([
+                        command,
+                        qid,
+                        await getLSP(qid, include).provideRefactoringAction(wikitext, stage),
+                        wikitext,
+                    ]);
+                })();
+                break;
+            case 'resolveCodeAction':
+                postMessage([
+                    command,
+                    qid,
+                    getLSP(qid, include).resolveCodeAction({
+                        title: `Fix all: ${wikitext || 'WikiLint'}`,
+                        kind: 'source.fixAll',
+                        data: { rule: wikitext },
+                    }),
+                    wikitext,
+                ]);
+                break;
+            case 'findStyleTokens':
+                postMessage([command, qid, getLSP(qid).findStyleTokens().map(token => token.json())]);
+        }
+    };
+};
+const blob = new Blob([`(${String(workerJS).replace('$CDN', CDN)})()`], { type: 'text/javascript' }), url = URL.createObjectURL(blob), worker = new Worker(url);
+URL.revokeObjectURL(url);
+const getListener = (command, qid, resolve, raw) => {
+    const listener = ({ data: [cmd, rid, res, resRaw] }) => {
+        if (cmd === command && rid === qid && (raw === undefined || raw === resRaw)) {
+            worker.removeEventListener('message', listener);
+            resolve(res);
+        }
+    };
+    return listener;
+};
+const setI18N = (i18n) => {
+    worker.postMessage(['setI18N', i18n]);
+};
+const setLintConfig = (config) => {
+    worker.postMessage(['setLintConfig', config]);
+};
+const setConfig = (config) => {
+    worker.postMessage(['setConfig', config]);
+    wikiparse.config = config;
+};
+const getFeedback = (command, qid, strict, raw, ...args) => new Promise(resolve => {
+    worker.addEventListener('message', getListener(command, qid, resolve, strict ? raw : undefined));
+    worker.postMessage([command, qid, raw, ...args]);
+});
+const getConfig = () => getFeedback('getConfig', -3);
+const json = (wikitext, include, qid = -4, stage) => getFeedback('json', qid, false, wikitext, include, stage);
+const print = (wikitext, include, stage, qid = -1) => getFeedback('print', qid, false, wikitext, include, stage);
+const lint = (wikitext, include, qid = -2) => getFeedback('lint', qid, true, wikitext, include);
+const provide = (command, qid, wikitext, ...args) => getFeedback(command, qid, typeof wikitext === 'string', wikitext, ...args);
+const append = (parent, text) => {
+    if (text) {
+        parent.append(text);
+    }
+};
+const splitNewLine = (html) => {
+    let cur = html.cloneNode();
+    cur.style.padding = '';
+    const result = [cur];
+    for (const child of html.childNodes) {
+        const { textContent } = child;
+        if (!(textContent === null || textContent === void 0 ? void 0 : textContent.includes('\n'))) {
+            cur.append(child.cloneNode(true));
+            continue;
+        }
+        const lines = child.nodeType === Node.TEXT_NODE
+            ? textContent.split('\n')
+            : splitNewLine(child);
+        append(cur, lines[0]);
+        for (const text of lines.slice(1)) {
+            cur = html.cloneNode();
+            cur.style.padding = '';
+            result.push(cur);
+            append(cur, text);
+        }
+    }
+    return result;
+};
+const getGutter = (container) => container.querySelector('.wikiparser-line-numbers');
+const size = (html) => {
+    const container = html.parentElement, { isContentEditable } = html, { clientHeight } = container, gutter = getGutter(container);
+    if (!gutter) {
+        intersectionObserver.unobserve(html);
+        return;
+    }
+    html.style.marginLeft = '';
+    const start = Number(html.dataset['start'] || 1), lines = splitNewLine(html), width = `${String(lines.length + start - 1).length + 1.5}ch`;
+    html.style.marginLeft = width;
+    gutter.style.width = width;
+    if (isContentEditable) {
+        gutter.style.minHeight = `${clientHeight + 1}px`;
+    }
+    const sizer = document.createElement('span'), { style: { paddingLeft, paddingRight } } = html;
+    sizer.className = 'wikiparser-sizer';
+    sizer.style.paddingLeft = paddingLeft;
+    sizer.style.paddingRight = paddingRight;
+    for (const child of lines) {
+        sizer.append(child, '\n');
+    }
+    html.append(sizer);
+    let line, lastTop;
+    for (let i = 0; i < lines.length; i++) {
+        const child = lines[i], { top } = child.getBoundingClientRect();
+        if (line) {
+            line.style.height = `${top - lastTop}px`;
+        }
+        line = document.createElement('span');
+        line.textContent = String(i + start);
+        gutter.append(line);
+        lastTop = top;
+    }
+    if (line) {
+        if (!isContentEditable && html.offsetHeight <= clientHeight) {
+            line.style.height = `${container.getBoundingClientRect().top + container.scrollHeight - lastTop}px`;
+            container.style.overflowY = 'hidden';
+        }
+        else {
+            line.style.height = `${html.getBoundingClientRect().bottom - lastTop}px`;
+            if (!isContentEditable) {
+                container.style.overflowY = '';
+            }
+        }
+    }
+    sizer.remove();
+    intersectionObserver.unobserve(html);
+};
+const intersectionObserver = new IntersectionObserver(entries => {
+    for (const entry of entries) {
+        if (!entry.isIntersecting) {
+            continue;
+        }
+        size(entry.target);
+    }
+});
+const lineNumbers = (html, start = 1, paddingTop = '', paddingBottom = '') => {
+    const container = html.parentElement, gutter = document.createElement('span');
+    html.dataset['start'] = String(start);
+    gutter.className = 'wikiparser-line-numbers';
+    gutter.style.paddingTop = paddingTop;
+    gutter.style.paddingBottom = paddingBottom;
+    container.classList.add('wikiparse-container');
+    container.append(gutter);
+    if (html.isContentEditable) {
+        html.style.paddingBottom = `${container.clientHeight}px`;
+    }
+    if (getComputedStyle(html).whiteSpace !== 'pre') {
+        html.style.whiteSpace = 'pre-wrap';
+    }
+    if (html.offsetParent) {
+        size(html);
+    }
+    else {
+        intersectionObserver.observe(html);
+    }
+};
+const wikiparse = {
+    version,
+    CDN,
+    id: 0,
+    config: {},
+    setI18N,
+    setLintConfig,
+    setConfig,
+    getConfig,
+    print,
+    lint,
+    json,
+    lineNumbers,
+    provide,
+};
+Object.assign(window, { wikiparse });
+})();

package/extensions/dist/codejar.js

@@ -0,0 +1,57 @@
+(() => {
+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, paddingBottom);
+            });
+        }
+        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;
+})();