wikiparser-node 1.12.4 → 1.12.5-b

package/extensions/dist/codejar.js

@@ -0,0 +1,52 @@
+(() => {
+const codejar = (async () => {
+    const { CodeJar } = 'CodeJar' in window
+        ? window
+        : 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 }),
+            include: Boolean(include),
+        };
+        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: [rootNode] } = __classPrivateFieldGet(this, _Printer_preview, "f");
+    let text = value, start = 0, end = __classPrivateFieldGet(this, _Printer_root, "f").length;
+    if (scrollHeight > parentHeight) {
+        const childNodes = [...rootNode.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 = window.getSelection();
+            range.selectNodeContents(ele.firstChild);
+            selection.removeAllRanges();
+            selection.addRange(range);
+        }
+    });
+};
+wikiparse.highlight = highlight;
+})();

package/extensions/dist/lint.js

@@ -0,0 +1,72 @@
+(() => {
+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_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);
+        __classPrivateFieldSet(this, _Linter_id, wikiparse.id++, "f");
+        this.include = Boolean(include);
+    }
+    queue(wikitext) {
+        var _a;
+        __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,
+            rule,
+            message: `${message} (${rule})`,
+            actions: [
+                ...fix ? [{ name: 'fix', fix }] : [],
+                ...suggestions.map(suggestion => ({ name: 'suggestion', 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(${rule})`,
+            startLineNumber: startLine + 1,
+            startColumn: startCol + 1,
+            endLineNumber: endLine + 1,
+            endColumn: endCol + 1,
+            severity: severity === 'error' ? 8 : 4,
+            rule,
+            message,
+        }));
+    }
+}
+_Linter_id = new WeakMap(), _Linter_wikitext = new WeakMap(), _Linter_running = new WeakMap(), _Linter_instances = new WeakSet(), _Linter_lint = async function _Linter_lint(wikitext) {
+    const { include } = this, errors = await wikiparse.lint(wikitext, include, __classPrivateFieldGet(this, _Linter_id, "f"));
+    if (this.include === include && __classPrivateFieldGet(this, _Linter_wikitext, "f") === wikitext) {
+        __classPrivateFieldSet(this, _Linter_running, undefined, "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/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/ui.css

@@ -0,0 +1,162 @@
+.wikiparse-container {
+	position: relative;
+	-webkit-text-size-adjust: none;
+}
+.wikiparser {
+	white-space: pre-wrap;
+	overflow-wrap: break-word;
+	word-break: break-all;
+	font-family: monospace;
+	border: 1.5px solid #dedede;
+	background-color: #fff;
+}
+/* wikiparse.highlight或wikiparse.codejar */
+.wikiparser.wikiparse-container {
+	padding: 4px 0;
+	overflow-y: auto;
+}
+.wikiparse-container > .wpb-root {
+	padding: 0 6px;
+	display: block;
+	position: relative;
+	overflow-y: hidden !important;
+}
+
+.wikiparser-line-numbers {
+	position: absolute;
+	top: 0;
+	left: 0;
+	display: inline-block;
+	background-color: #f5f5f5;
+	color: #6c6c6c;
+	border-right: 1px solid #ddd;
+	padding: 4px 0;
+}
+.wikiparser-line-numbers > span {
+	display: inline-block;
+	width: calc(100% - .5ch);
+	text-align: right;
+}
+.wikiparser-sizer {
+	position: absolute;
+	top: 0;
+	left: 0;
+	right: 0;
+	visibility: hidden;
+	z-index: -1;
+	padding: 0 6px;
+}
+.wpb-root[contenteditable] > .wikiparser-sizer {
+	overflow-y: scroll;
+}
+
+.wpb-table-inter {
+	color: #d73333;
+	font-weight: normal;
+	text-decoration: underline wavy 1px;
+}
+
+.wpb-hidden, .wpb-noinclude, .wpb-include, .wpb-comment, .wpb-attr-dirty {
+	color: #7b8c8f;
+	font-weight: normal;
+	font-style: italic;
+}
+
+.wpb-ext, .wpb-html {
+	color: #14866d;
+	font-weight: bold;
+}
+.wpb-ext-attrs, .wpb-html-attrs {
+	font-weight: normal;
+}
+.wpb-ext-attr > .wpb-attr-value, .wpb-html-attr > .wpb-attr-value {
+	color: #179b1c;
+}
+.wpb-ext-inner {
+	color: initial;
+	font-weight: normal;
+	background-color: rgba(0, 0, 0, .03);
+}
+
+.wpb-arg {
+	color: #ac6600;
+	font-weight: bold;
+}
+.wpb-arg-default {
+	color: #ad9300;
+	font-weight: normal;
+}
+
+.wpb-template {
+	color: #80c;
+	font-weight: bold;
+	background-color: rgba(119, 0, 170, .03);
+}
+.wpb-magic-word {
+	color: #a11;
+	font-weight: bold;
+	background-color: rgba(170, 17, 17, .03);
+}
+.wpb-invoke-module, .wpb-invoke-function {
+	color: #bf3e13;
+	font-weight: normal;
+}
+.wpb-parameter {
+	font-weight: normal;
+}
+.wpb-template > .wpb-parameter,
+.wpb-invoke-function ~ .wpb-parameter {
+	color: #b0c;
+}
+.wpb-parameter-value {
+	color: initial;
+}
+
+.wpb-heading, .wpb-image-parameter {
+	color: #0076dd;
+}
+.wpb-heading-title {
+	color: initial;
+	font-weight: bold;
+}
+
+.wpb-table, .wpb-tr, .wpb-td {
+	color: #d08;
+	font-weight: bold;
+}
+.wpb-table-attrs {
+	font-weight: normal;
+}
+.wpb-table-attr > .wpb-attr-value {
+	color: #f500d4;
+}
+.wpb-td-inner {
+	color: initial;
+	font-weight: normal;
+}
+
+.wpb-double-underscore, .wpb-hr, .wpb-quote, .wpb-list, .wpb-dd, .wpb-redirect-syntax {
+	color: #0076dd;
+	font-weight: bold;
+	background-color: #eee;
+}
+
+.wpb-link, .wpb-category, .wpb-file, .wpb-gallery-image, .wpb-imagemap-image, .wpb-redirect-target,
+.wpb-ext-link, .wpb-free-ext-link, .wpb-magic-link {
+	color: #000aaa;
+	background-color: rgba(34, 17, 153, .03);
+}
+.wpb-link-text, .wpb-image-caption, .wpb-ext-link-text {
+	color: initial;
+}
+
+.wpb-converter {
+	color: #b68;
+	font-weight: bold;
+}
+.wpb-converter-rule {
+	font-weight: normal;
+}
+.wpb-converter-rule-from, .wpb-converter-rule-to, .wpb-converter-noconvert {
+	color: initial;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wikiparser-node",
-	"version": "1.12.4",
+	"version": "1.12.5-b",
 	"description": "A Node.js parser for MediaWiki markup with AST",
 	"keywords": [
 		"mediawiki",
@@ -14,43 +14,50 @@
 	"license": "GPL-3.0",
 	"author": "Bhsd",
 	"files": [
-		"/errors/README",
-		"/printed/README",
+		"/bundle/bundle.min.js",
+		"/extensions/dist/",
+		"/extensions/*.css",
+		"!/extensions/dist/gh-page.js",
+		"!/extensions/gh-page.css",
+		"!/extensions/dist/parserTests.js",
+		"!/extensions/test-page.css",
 		"/config/",
 		"/i18n/",
-		"/dist/",
-		"!/dist/[bt]*/"
+		"!/config/.schema.json"
 	],
-	"main": "./dist/index.js",
-	"types": "./dist/index.d.ts",
+	"browser": "/bundle/bundle.min.js",
+	"main": "./bundle/bundle.min.js",
+	"types": "./extensions/typings.d.ts",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/bhsd-harry/wikiparser-node.git"
 	},
 	"scripts": {
-		"toc": "node ./dist/bin/toc.js",
-		"declaration": "grep -rl --include='*.d.ts' '@private' dist/ | xargs bash sed.sh -i -E '/^\\s+\\/\\*\\* @private/,+1d'; grep -rl --include='*.d.ts' '/util/' dist/ | xargs bash sed.sh -i -E '/^import .+\\/util\\//d'; bash sed.sh -i -E 's/abstract (lint|print|text)\\b/\\1/' dist/lib/node.d.ts; node ./dist/bin/declaration.js",
-		"prepublishOnly": "npm run build:core",
-		"build:core": "bash build.sh",
-		"build": "npm run build:core && node ./dist/bin/parserTests.js",
+		"prepublishOnly": "npm run build",
+		"build:core": "esbuild index.ts --bundle --minify --target=es2018 --sourcemap --outfile=bundle/bundle.min.js && eslint --no-eslintrc -c .eslintrc.browser.json bundle/bundle.min.js",
+		"build:ext": "bash build-ext.sh",
+		"build:test": "npm run build:core && tsc --project tsconfig.dist.json",
+		"build": "npm run build:core && npm run build:ext",
 		"diff": "bash diff.sh",
 		"diff:stat": "f() { git diff --stat --ignore-all-space --color=always $1 $2 -- . ':!extensions/' ':!bin/' | grep '\\.ts'; }; f",
-		"lint:ts": "tsc --noEmit && eslint --cache .",
+		"lint:ts": "tsc --noEmit && tsc --noEmit --project extensions/tsconfig.json && tsc --noEmit --project extensions/tsconfig.codejar.json && eslint --cache .",
 		"lint:json": "v8r -s config/.schema.json config/*.json",
-		"lint": "npm run lint:ts && npm run lint:json",
-		"prof": "node dist/test/prof.js",
-		"test": "node dist/test/test.js",
-		"test:parser": "node dist/test/parserTests.js",
+		"lint:css": "stylelint extensions/*.css",
+		"lint": "npm run lint:ts && npm run lint:json && npm run lint:css",
+		"server": "npm run test:end; http-server .. -c-1 --cors &",
+		"test": " node --enable-source-maps dist/test/test.js",
+		"test:parser": "node --enable-source-maps dist/test/parserTests.js",
+		"test:server": "npm run build && bash sed.sh -i 's|importScripts.*|importScripts(\"http://127.0.0.1:8080/wikiparser-node/bundle/bundle.min.js\");|' extensions/dist/base.js; npm run server",
 		"test:end": "pkill -x http-server",
-		"test:real": "node dist/test/real.js"
-	},
-	"dependencies": {
-		"chalk": "^4.1.2"
+		"test:real": "node --enable-source-maps dist/test/real.js"
 	},
 	"devDependencies": {
+		"@bhsd/codemirror-mediawiki": "^2.14.0",
 		"@bhsd/common": "^0.0.0",
 		"@codemirror/lint": "^6.8.0",
 		"@types/node": "^20.11.6",
+		"@types/prismjs": "^1.26.3",
+		"chalk": "^4.1.2",
 		"codejar-async": "^4.2.0",
 		"monaco-editor": "^0.50.0",
 		"v8r": "^3.0.0"