wikiparser-node 1.1.0 → 1.1.1-b

package/extensions/dist/editor.js

@@ -0,0 +1,172 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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_tick, _Printer_paint;
+    const { wikiparse } = window, { MAX_STAGE } = wikiparse;
+    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);
+            __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);
+            this.running = undefined;
+            this.ticks = [0, undefined];
+        }
+        queue(delay, method) {
+            const { ticks } = this, [state] = ticks;
+            if (state <= 0 || method === 'coarsePrint' || ticks[1] !== 'coarsePrint') {
+                ticks[0] = delay;
+                ticks[1] = method;
+                if (state <= 0) {
+                    __classPrivateFieldGet(this, _Printer_instances, "m", _Printer_tick).call(this);
+                }
+            }
+        }
+        coarsePrint() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.running) {
+                    return undefined;
+                }
+                const { include } = this, { value } = __classPrivateFieldGet(this, _Printer_textbox, "f"), parsed = yield wikiparse.print(value, include, 2, __classPrivateFieldGet(this, _Printer_id, "f"));
+                if (this.include !== include || __classPrivateFieldGet(this, _Printer_textbox, "f").value !== value) {
+                    this.running = undefined;
+                    this.running = this.coarsePrint();
+                    return this.running;
+                }
+                __classPrivateFieldSet(this, _Printer_root, parsed, "f");
+                __classPrivateFieldGet(this, _Printer_instances, "m", _Printer_paint).call(this);
+                this.running = undefined;
+                this.running = this.finePrint();
+                return this.running;
+            });
+        }
+        finePrint() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.running) {
+                    __classPrivateFieldSet(this, _Printer_viewportChanged, true, "f");
+                    return undefined;
+                }
+                __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, { length: end } = __classPrivateFieldGet(this, _Printer_root, "f");
+                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] === MAX_STAGE) {
+                            start = childNodes.indexOf(headings[i++]);
+                        }
+                        end = j === length ? end : childNodes.indexOf(headings[j]);
+                        while (i <= j && __classPrivateFieldGet(this, _Printer_root, "f")[end - 1][0] === MAX_STAGE) {
+                            end = childNodes.indexOf(headings[--j]);
+                        }
+                        text = __classPrivateFieldGet(this, _Printer_root, "f").slice(start, end).map(([, str]) => str).join('');
+                    }
+                }
+                if (start === end) {
+                    this.running = undefined;
+                    return undefined;
+                }
+                const parsed = yield wikiparse.print(text, include, MAX_STAGE, __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);
+                    this.running = undefined;
+                    if (__classPrivateFieldGet(this, _Printer_viewportChanged, "f")) {
+                        this.running = this.finePrint();
+                    }
+                }
+                else {
+                    this.running = undefined;
+                    this.running = this.coarsePrint();
+                }
+                return this.running;
+            });
+        }
+    }
+    _Printer_id = new WeakMap(), _Printer_preview = new WeakMap(), _Printer_textbox = new WeakMap(), _Printer_root = new WeakMap(), _Printer_viewportChanged = new WeakMap(), _Printer_instances = new WeakSet(), _Printer_tick = function _Printer_tick() {
+        setTimeout(() => {
+            const { ticks } = this, [t, method] = ticks;
+            if (t > 0) {
+                ticks[0] -= 500;
+                if (t <= 500) {
+                    this[method]();
+                }
+                else {
+                    __classPrivateFieldGet(this, _Printer_instances, "m", _Printer_tick).call(this);
+                }
+            }
+        }, 500);
+    }, _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';
+    };
+    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.classList.add('wikiparse-container');
+        textbox.replaceWith(container);
+        textbox.classList.add('wikiparsed');
+        container.append(preview, textbox);
+        textbox.addEventListener('input', e => {
+            if (!e.isComposing) {
+                printer.queue(2000, 'coarsePrint');
+            }
+            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, 'finePrint');
+            }
+        });
+        textbox.addEventListener('keydown', e => {
+            if ((e.ctrlKey || e.metaKey) && e.key === 'k') {
+                e.preventDefault();
+                printer.ticks[0] = 0;
+                printer.running = printer.coarsePrint();
+            }
+        });
+        printer.running = printer.coarsePrint();
+        return printer;
+    };
+    wikiparse.Printer = Printer;
+    wikiparse.edit = edit;
+})();

package/extensions/dist/highlight.js

@@ -0,0 +1,39 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(() => {
+    const { wikiparse } = window;
+    const highlight = (ele, linenums, start = 1) => __awaiter(void 0, void 0, void 0, function* () {
+        if (ele.classList.contains('highlighted')) {
+            return;
+        }
+        const html = (yield wikiparse.print(ele.innerText)).map(([, , printed]) => printed).join('');
+        ele.classList.add('highlighted');
+        if (linenums) {
+            const lines = html.split('\n').map((line, i) => {
+                const li = document.createElement('li');
+                li.id = `L${i + start}`;
+                li.innerHTML = line;
+                return li;
+            });
+            if (!lines[lines.length - 1].textContent) {
+                lines.pop();
+            }
+            const ol = document.createElement('ol');
+            ol.start = start;
+            ol.style.paddingLeft = `${String(lines.length + start - 1).length + 2.5}ch`;
+            ol.append(...lines);
+            ele.replaceChildren(ol);
+        }
+        else {
+            ele.innerHTML = html;
+        }
+    });
+    wikiparse.highlight = highlight;
+})();

package/extensions/dist/lint.js

@@ -0,0 +1,48 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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;
+    const { wikiparse } = window;
+    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");
+            __classPrivateFieldSet(this, _Linter_wikitext, undefined, "f");
+            __classPrivateFieldSet(this, _Linter_running, undefined, "f");
+            this.include = Boolean(include);
+        }
+        queue(wikitext) {
+            __classPrivateFieldSet(this, _Linter_wikitext, wikitext, "f");
+            __classPrivateFieldSet(this, _Linter_running, __classPrivateFieldGet(this, _Linter_instances, "m", _Linter_lint).call(this, wikitext), "f");
+            return __classPrivateFieldGet(this, _Linter_running, "f");
+        }
+    }
+    _Linter_id = new WeakMap(), _Linter_wikitext = new WeakMap(), _Linter_running = new WeakMap(), _Linter_instances = new WeakSet(), _Linter_lint = function _Linter_lint(wikitext) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { include } = this, errors = yield wikiparse.lint(wikitext, include, __classPrivateFieldGet(this, _Linter_id, "f"));
+            return this.include === include && __classPrivateFieldGet(this, _Linter_wikitext, "f") === wikitext ? errors : __classPrivateFieldGet(this, _Linter_running, "f");
+        });
+    };
+    wikiparse.Linter = Linter;
+})();

package/extensions/editor.css

@@ -0,0 +1,63 @@
+.wikiparse-container {
+	position: relative;
+	-webkit-text-size-adjust: none;
+}
+.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;
+	background-color: #fff;
+	-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-converter {
+	-webkit-text-stroke-width: .1ex;
+}
+.wpb-hidden, .wpb-table-inter, .wpb-table-inter span,
+.wpb-noinclude, .wpb-include, .wpb-comment,
+.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,119 @@
+.wikiparser {
+	white-space: pre-wrap;
+	overflow-wrap: break-word;
+	font-family: monospace;
+}
+
+.wpb-error {
+	text-decoration: underline wavy #f00 1px;
+}
+.wpb-hidden, .wpb-table-inter, .wpb-table-inter span {
+	color: #f00;
+	font-weight: normal;
+	text-decoration: underline wavy 1px;
+}
+
+.wpb-noinclude, .wpb-include, .wpb-comment {
+	color: #72777d;
+	font-weight: normal;
+}
+.wpb-comment {
+	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: #d33;
+	font-weight: bold;
+	background-color: rgba(170, 17, 17, .03);
+}
+.wpb-invoke-module, .wpb-invoke-function {
+	color: #dd5d33;
+	font-weight: normal;
+}
+.wpb-parameter {
+	color: initial;
+	font-weight: normal;
+}
+.wpb-template > .wpb-parameter > .wpb-parameter-key,
+.wpb-invoke-function ~ .wpb-parameter > .wpb-parameter-key {
+	color: #b0c;
+}
+
+.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 {
+	color: #0076dd;
+	font-weight: bold;
+	background-color: #eee;
+}
+
+.wpb-link, .wpb-category, .wpb-file, .wpb-gallery-image, .wpb-imagemap-image,
+.wpb-ext-link, .wpb-free-ext-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.1.0",
+	"version": "1.1.1-b",
 	"description": "A Node.js parser for MediaWiki markup with AST",
 	"keywords": [
 		"mediawiki",
@@ -14,28 +14,34 @@
 	"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",
 		"/config/",
 		"/i18n/",
-		"/dist/"
+		"!/config/.schema.json"
 	],
-	"main": "./dist/index.js",
+	"browser": "/bundle/bundle.min.js",
+	"main": "./bundle/bundle.js",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/bhsd-harry/wikiparser-node.git"
 	},
 	"scripts": {
-		"toc": "node ./dist/bin/toc.js",
-		"prepublishOnly": "npm run build; rm dist/internal.js; rm -r dist/test; rm dist/[bmpu]*/*.d.ts; grep -rl --include='*.d.ts' '@private' dist/ | xargs gsed -i '/@private/,+1d'",
-		"build": "rm -rf dist/; tsc; grep -rl --include='*.d.ts' '@private' dist/ | xargs gsed -i '/@private/,+1d'",
+		"prepublishOnly": "webpack build --mode production && npm run build:ext",
+		"build:core": "rm bundle/*.js; webpack build --mode development; webpack build --mode production; eslint --no-eslintrc -c .eslintrc.browser.json bundle/",
+		"build:ext": "rm -rf extensions/dist/; tsc --project extensions/tsconfig.json; ls extensions/dist/*.js | xargs gsed -i '/export {};/d'; eslint --no-eslintrc -c .eslintrc.browser.json extensions/dist/",
+		"build:test": "rm -rf dist/; tsc; gsed -i 's|./config/minimum|../config/minimum|' dist/index.js",
+		"build": "npm run build:core && npm run build:ext",
 		"diff": "git diff --ignore-all-space --color-moved",
 		"lint:ts": "tsc --noEmit && eslint --cache .",
 		"lint:json": "ajv -s config/.schema.json -d 'config/*.json' --strict=true --strict-required=false",
-		"lint": "npm run lint:ts && npm run lint:json",
-		"test": "node dist/test/test.js",
+		"lint:css": "stylelint extensions/*.css",
+		"lint": "npm run lint:ts && npm run lint:json && npm run lint:css",
 		"test:real": "node dist/test/real.js",
-		"test:single": "node dist/test/single.js; node --prof dist/test/single.js && node --prof-process isolate-0x*-v8.log > test/processed.txt && rm isolate-0x*-v8.log"
+		"test:single": "node dist/test/single.js"
 	},
 	"devDependencies": {
 		"@cypress/request": "^3.0.1",
@@ -44,7 +50,9 @@
 		"@typescript-eslint/eslint-plugin": "^6.12.0",
 		"@typescript-eslint/parser": "^6.12.0",
 		"ajv-cli": "^5.0.0",
+		"esbuild-loader": "^4.0.2",
 		"eslint": "^8.53.0",
+		"eslint-plugin-es-x": "^7.3.0",
 		"eslint-plugin-eslint-comments": "^3.2.0",
 		"eslint-plugin-jsdoc": "^46.8.2",
 		"eslint-plugin-json-es": "^1.5.7",
@@ -52,6 +60,10 @@
 		"eslint-plugin-promise": "^6.1.1",
 		"eslint-plugin-regexp": "^2.1.1",
 		"eslint-plugin-unicorn": "^49.0.0",
+		"stylelint": "^15.11.0",
+		"stylelint-config-recommended": "^13.0.0",
+		"webpack-cli": "^5.1.4",
+		"webpack": "^5.89.0",
 		"typescript": "^5.1.6"
 	},
 	"engines": {

package/config/.schema.json

@@ -1,160 +0,0 @@
-{
-	"type": "object",
-	"properties": {
-		"ext": {
-			"description": "extension tags",
-			"type": "array",
-			"items": {
-				"type": "string",
-				"pattern": "^[a-z\\d_]+$"
-			}
-		},
-		"html": {
-			"description": "valid HTML tags",
-			"type": "array",
-			"items": {
-				"type": "array",
-				"items": {
-					"type": "string",
-					"pattern": "^[a-z\\d]+$"
-				}
-			},
-			"minItems": 3,
-			"maxItems": 3
-		},
-		"namespaces": {
-			"description": "formatted namespaces",
-			"type": "object",
-			"patternProperties": {
-				"^-?\\d+$": {
-					"type": "string"
-				}
-			},
-			"required": [
-				"6",
-				"10"
-			],
-			"additionalProperties": false
-		},
-		"nsid": {
-			"description": "namespace IDs",
-			"type": "object",
-			"additionalProperties": {
-				"type": "integer"
-			}
-		},
-		"parserFunction": {
-			"type": "array",
-			"items": [
-				{
-					"description": "case-insensitive parser functions",
-					"type": "object",
-					"additionalProperties": {
-						"type": "string"
-					}
-				},
-				{
-					"description": "case-sensitive parser functions",
-					"type": "array",
-					"items": {
-						"type": "string"
-					}
-				},
-				{
-					"description": "msg and raw",
-					"type": "array",
-					"items": {
-						"type": "string"
-					}
-				},
-				{
-					"description": "subst and safesubst",
-					"type": "array",
-					"items": {
-						"type": "string"
-					}
-				}
-			],
-			"minItems": 4,
-			"maxItems": 4
-		},
-		"doubleUnderscore": {
-			"description": "behavior switches",
-			"type": "array",
-			"items": {
-				"type": "array",
-				"items": {
-					"type": "string"
-				}
-			},
-			"minItems": 2,
-			"maxItems": 2
-		},
-		"protocol": {
-			"description": "external link protocols",
-			"type": "string",
-			"pattern": "^[a-z:/]+(?:\\|[a-z:/]+)*$"
-		},
-		"interwiki": {
-			"type": "array",
-			"items": {
-				"type": "string"
-			}
-		},
-		"img": {
-			"description": "image-related magic words",
-			"type": "object",
-			"additionalProperties": {
-				"type": "string",
-				"pattern": "^[-a-z]+$"
-			}
-		},
-		"variants": {
-			"description": "variants for language conversion",
-			"type": "array",
-			"items": {
-				"type": "string",
-				"pattern": "^[-a-z]+$"
-			}
-		},
-		"conversionTable": {
-			"description": "table of unidirectional conversions",
-			"type": "array",
-			"items": {
-				"type": "array",
-				"items": {
-					"type": "string",
-					"pattern": "^[^ <>[\\]{}|]+$"
-				},
-				"minItems": 2,
-				"maxItems": 2
-			}
-		},
-		"redirects": {
-			"description": "table of redirects",
-			"type": "array",
-			"items": {
-				"type": "array",
-				"items": {
-					"type": "string",
-					"pattern": "^[^ <>[\\]{}|]+$"
-				},
-				"minItems": 2,
-				"maxItems": 2
-			}
-		}
-	},
-	"required": [
-		"ext",
-		"html",
-		"namespaces",
-		"nsid",
-		"parserFunction",
-		"doubleUnderscore",
-		"protocol",
-		"interwiki",
-		"img",
-		"variants"
-	],
-	"additionalProperties": false
-}

package/dist/addon/table.d.ts

@@ -1,6 +0,0 @@
-import type { TableCoords } from '../src/table/trBase';
-/** @extends {Array<TableCoords[]>} */
-export declare class Layout extends Array<TableCoords[]> {
-    /** 打印表格布局 */
-    print(): void;
-}