@bhsd/codemirror-mediawiki 3.12.1 → 3.12.3

package/dist/lilypond.d.ts

@@ -0,0 +1,14 @@
+import type { StreamParser, StringStream } from '@codemirror/language';
+declare interface State {
+    tokenize: Tokenizer;
+    /** 只用于Scheme */
+    parens: number;
+    /** 只用于歌词 */
+    braces: number;
+    /** 只用于歌词 */
+    spaced: boolean;
+    lyrics: boolean;
+}
+declare type Tokenizer = (stream: StringStream, state: State) => string;
+export declare const lilypond: StreamParser<State>;
+export {};

package/dist/lilypond.js

@@ -0,0 +1,240 @@
+import { inComment, getCompletions } from './util.js';
+import { extData, extCompletion } from './constants.js';
+let scoreFetch;
+const inString = (parent) => (stream, state) => {
+    let escaped = false, next = stream.next();
+    while (next) {
+        if (!escaped && next === '"') {
+            state.tokenize = parent;
+            return /* #a11 */ 'string';
+        }
+        escaped = !escaped && next === '\\';
+        next = stream.next();
+    }
+    return /* #a11 */ 'string';
+};
+const inScheme = (parent) => {
+    const style = 'mw-tag-score-scheme';
+    const tokenizer = (stream, state) => {
+        if (stream.eatSpace()) {
+            return style;
+        }
+        const ch = stream.next();
+        switch (ch) {
+            case '(':
+                state.parens++;
+                return style;
+            case ')':
+                state.parens--;
+                if (state.parens === 0) {
+                    state.tokenize = parent;
+                    return 'separator';
+                }
+                return style;
+            case '"':
+                state.tokenize = inString(tokenizer);
+                return /* #a11 */ `string ${style}`;
+            case ';':
+                stream.skipToEnd();
+                return /* #940 */ `comment ${style}`;
+            case '#':
+                if (stream.eat('!')) {
+                    state.tokenize = inComment(tokenizer, '!#');
+                    return /* #940 */ `comment ${style}`;
+                }
+            // fall through
+            default:
+                return style;
+        }
+    };
+    return tokenizer;
+};
+const eatHash = (stream, state, ch, parent) => {
+    if (stream.match(/^#[tf]/u)) {
+        return /* #219 */ 'bool';
+    }
+    else if (ch === '#' && stream.match(/^(?:\d+|#x[\da-f]*)/iu)) {
+        return /* #a11 */ 'character';
+    }
+    else if (stream.eat('(')) {
+        state.tokenize = inScheme(parent);
+        state.parens = 1;
+        return 'separator';
+    }
+    return stream.match(/^\s*[-_a-z][-\w]*/iu) ? 'variableName.local' : 'operator';
+};
+const eatQuote = (state, parent) => {
+    state.tokenize = inString(parent);
+    return /* #a11 */ 'string';
+};
+const eatPercent = (stream, state, parent) => {
+    if (stream.eat('{')) {
+        state.tokenize = inComment(parent, '%}');
+        return /* #940 */ 'comment';
+    }
+    stream.skipToEnd();
+    return /* #940 */ 'comment';
+};
+const lyricsCommands = new Set(['addlyrics', 'lyricmode', 'lyrics', 'lyricsto']), setCommands = new Set(['set', 'override']), unsetCommands = new Set(['unset', 'revert', 'tweak']), newCommands = new Set(['new', 'context']);
+const eatCommand = (stream, state, parent, base) => {
+    const mt = stream.match(/^[a-z](?:[a-z]|-+(?=[a-z]))*/iu), cmd = mt?.[0], isUnset = unsetCommands.has(cmd), isNew = newCommands.has(cmd);
+    if (base && lyricsCommands.has(cmd)) {
+        state.lyrics = true;
+    }
+    else if (isUnset || isNew || setCommands.has(cmd)) {
+        state.tokenize = inAssignment(parent, isUnset ? -1 : 1, isNew);
+    }
+    return mt && extData['score']?.has(`\\${cmd}`) !== false ? /* #708 */ 'keyword' : '';
+};
+const inAssignment = (parent, step, cls) => (stream, state) => {
+    if (stream.eatSpace()) {
+        return '';
+    }
+    else if (step === 0) {
+        stream.eat('=');
+        state.tokenize = parent;
+        return 'operator';
+    }
+    stream.match(/^[a-z][-\w.]*/iu);
+    state.tokenize = step === 1 ? inAssignment(parent, 0) : parent;
+    return cls ? /* #167 */ 'className' : /* #00f */ 'variableName.definition';
+};
+const inBase = (stream, state) => {
+    if (stream.eatSpace()) {
+        return '';
+    }
+    const ch = stream.next();
+    switch (ch) {
+        case '-':
+            return stream.eat(/[->.+_!^]/u) ? 'operator' : 'punctuation';
+        case '#':
+        case '$':
+            return eatHash(stream, state, ch, inBase);
+        case '"':
+            return eatQuote(state, inBase);
+        case '%':
+            return eatPercent(stream, state, inBase);
+        case '/':
+            stream.eat('+');
+            return 'punctuation';
+        case '\\':
+            if (stream.eat(/[-<>!]/u)) {
+                return 'operator';
+            }
+            else if (stream.eat(/[()[\]]/u)) {
+                return 'squareBracket';
+            }
+            return stream.eat(/[\\=]/u) ? 'punctuation' : eatCommand(stream, state, inBase, true);
+        case '}':
+            state.lyrics = false;
+            return 'squareBracket';
+        case '{':
+            if (state.lyrics) {
+                state.lyrics = false;
+                state.braces = 1;
+                state.spaced = true;
+                state.tokenize = inLyrics;
+            }
+            return 'squareBracket';
+        default:
+            if (/[<>()[\]]/u.test(ch)) {
+                return 'squareBracket';
+            }
+            else if (/[:|~^_=]/u.test(ch)) {
+                return 'punctuation';
+            }
+            else if (/[',.!?]/u.test(ch)) {
+                return 'operator';
+            }
+            else if (/\d/u.test(ch)) {
+                stream.match(/^\d*(?:[./]\d+)?/u);
+                return /* #164 */ 'number';
+            }
+            else if (/[a-z]/iu.test(ch)) {
+                stream.match(/^(?:[a-z]|[-_\d]+(?=[a-z]))+/iu);
+                return /^(?:[rs]|[a-g](?:is)*(?:ih)*|[a-g]?(?:es)*(?:eh)*)$/u.test(stream.current())
+                    ? ''
+                    : /* #219 */ 'atom';
+            }
+            return '';
+    }
+};
+const inLyrics = (stream, state) => {
+    if (stream.eatSpace()) {
+        state.spaced = true;
+        return '';
+    }
+    else if (stream.sol()) {
+        state.spaced = true;
+    }
+    const ch = stream.next();
+    switch (ch) {
+        case '-':
+            if (state.spaced && stream.match(/^-(?=\s)/u)) {
+                return 'punctuation';
+            }
+            state.spaced = false;
+            return 'string';
+        case '_':
+        case '~':
+        case '|':
+            state.spaced = false;
+            return 'punctuation';
+        case '#':
+        case '$':
+            state.spaced = false;
+            return eatHash(stream, state, ch, inLyrics);
+        case '"':
+            state.spaced = true;
+            return eatQuote(state, inLyrics);
+        case '%':
+            state.spaced = true;
+            return eatPercent(stream, state, inLyrics);
+        case '\\':
+            if (stream.eat(/[<>!\\]/u)) {
+                state.spaced = true;
+                return '';
+            }
+            state.spaced = false;
+            return eatCommand(stream, state, inLyrics);
+        case '{':
+        case '}':
+            state.braces += ch === '{' ? 1 : -1;
+            if (state.braces) {
+                state.spaced = true;
+            }
+            else {
+                state.tokenize = inBase;
+            }
+            return 'squareBracket';
+        default:
+            state.spaced = false;
+            if (/\d/u.test(ch)) {
+                stream.eatWhile(/\d/u);
+                return /* #164 */ 'number';
+            }
+            stream.eatWhile(/[^\s\d_~{}#$"%\\]/u);
+            return /* #a11 */ 'string';
+    }
+};
+export const lilypond = {
+    startState() {
+        if (typeof wikiparse === 'object') {
+            scoreFetch ??= (async () => {
+                const data = await (await fetch(`${wikiparse.CDN}/data/ext/score.json`)).json();
+                extData['score'] = new Set(data.flatMap(item => item.split('.')));
+                extCompletion['score'] = getCompletions(data.filter(s => s.startsWith('\\')), 'keyword');
+            })();
+        }
+        return {
+            tokenize: inBase,
+            parens: 0,
+            braces: 0,
+            lyrics: false,
+            spaced: false,
+        };
+    },
+    token(stream, state) {
+        return state.tokenize(stream, state);
+    },
+};

package/dist/lint.js

@@ -1,4 +1,4 @@
-const findDiagnostic = (deco, head, anchor = head) => {
+const myFindDiagnostic = (deco, head, anchor = head) => {
     let found;
     deco.between(head, Infinity, (_, __, { spec: { diagnostics } }) => {
         const next = diagnostics.sort((a, b) => a.from - b.from || a.to - b.to)
@@ -16,7 +16,7 @@ const findDiagnostic = (deco, head, anchor = head) => {
  * @param cm CodeMirror6 实例
  */
 export const nextDiagnostic = (cm) => {
-    const view = cm.view, { state } = view, { diagnostics } = state.field(cm.getLintExtension()[2][0]), { from, to } = state.selection.main, next = findDiagnostic(diagnostics, from, to) ?? findDiagnostic(diagnostics, 0);
+    const view = cm.view, { state } = view, { diagnostics } = state.field(cm.getLintExtension()[2][0]), { from, to } = state.selection.main, next = myFindDiagnostic(diagnostics, from, to) ?? myFindDiagnostic(diagnostics, 0);
     if (!next || next.from === from && next.to === to) {
         return false;
     }

package/dist/lintsource.d.ts

@@ -3,7 +3,7 @@ import type { Text, EditorState } from '@codemirror/state';
 import type { Language } from '@codemirror/language';
 import type { Diagnostic, Action } from '@codemirror/lint';
 import type { Option, LiveOption } from './linter';
-import type { DocRange } from './fold';
+import type { DocRange } from './util';
 export type LintSource<T = unknown> = ((state: EditorState) => readonly Diagnostic[] | Promise<readonly Diagnostic[]>) & {
     config?: T;
     fixer?: (doc: Text, rule?: string) => string | Promise<string>;

package/dist/lintsource.js

@@ -4,7 +4,7 @@ import { javascriptLanguage } from '@codemirror/lang-javascript';
 import { sanitizeInlineStyle, lintJSON } from '@bhsd/common';
 import { getWikiLinter, getJsLinter, getCssLinter, getLuaLinter, stylelintRepo, eslintRepo, luacheckRepo, isStylelintConfig, } from './linter.js';
 import { posToIndex, toConfigGetter, } from './util.js';
-import { base } from './constants.js';
+import { baseData } from './constants.js';
 import { vue } from './javascript-globals.js';
 /**
  * 获取Linter选项
@@ -67,7 +67,7 @@ const wikiLintSource = async (wikiLint, text, opt, doc, f = 0, t) => (await wiki
  * @test
  */
 export const getWikiLintSource = (articlePath) => async (opt, v) => {
-    const options = { ...await getOpt(opt), cdn: base.CDN };
+    const options = { ...await getOpt(opt), cdn: baseData.CDN };
     if (articlePath) {
         options.getConfig = toConfigGetter(options.getConfig, articlePath);
     }
@@ -113,7 +113,7 @@ const jsLintSource = (esLint, code, opt, doc, f = 0, t) => esLint(code, opt)
  * @test
  */
 export const getJsLintSource = async (opt) => {
-    const { CDN } = base, esLint = await getJsLinter(CDN && `${CDN}/${eslintRepo}`);
+    const { CDN } = baseData, esLint = await getJsLinter(CDN && `${CDN}/${eslintRepo}`);
     const lintSource = async ({ doc }) => jsLintSource(esLint, doc.toString(), await getOpt(opt), doc);
     lintSource.fixer = (doc, rule) => esLint.fixer(doc.toString(), rule);
     Object.defineProperty(lintSource, 'config', {
@@ -156,7 +156,7 @@ const cssLintSource = async (styleLint, code, opt, doc, f = 0, t) => {
  * @test
  */
 export const getCssLintSource = async (opt) => {
-    const { CDN } = base, styleLint = await getCssLinter(CDN && `${CDN}/${stylelintRepo}`);
+    const { CDN } = baseData, styleLint = await getCssLinter(CDN && `${CDN}/${stylelintRepo}`);
     const lintSource = async ({ doc }) => cssLintSource(styleLint, doc.toString(), await getOpt(opt), doc);
     lintSource.fixer = async (doc, rule) => styleLint.fixer(doc.toString(), rule);
     Object.defineProperty(lintSource, 'config', {
@@ -180,7 +180,7 @@ const stylelintConfigVue = /* #__PURE__ */ (() => ({
 }))();
 /** @implements */
 const getVueOrHtmlLintSource = (rules, globals) => async (opt) => {
-    const { CDN } = base, styleLint = await getCssLinter(CDN && `${CDN}/${stylelintRepo}`), esLint = await getJsLinter(CDN && `${CDN}/${eslintRepo}`);
+    const { CDN } = baseData, styleLint = await getCssLinter(CDN && `${CDN}/${stylelintRepo}`), esLint = await getJsLinter(CDN && `${CDN}/${eslintRepo}`);
     const lintSource = async (state) => {
         const { doc } = state, option = await getOpt(opt, true) ?? {};
         let js = option['js'], css = option['css'];
@@ -228,7 +228,7 @@ export const getVueLintSource = /* #__PURE__ */ getVueOrHtmlLintSource(stylelint
  * @test
  */
 export const getHTMLLintSource = async (opt, view, language) => {
-    const vueLintSource = await getVueOrHtmlLintSource()(opt), wikiLint = await getWikiLinter({ include: false, ...await getOpt(opt), cdn: base.CDN }, view);
+    const vueLintSource = await getVueOrHtmlLintSource()(opt), wikiLint = await getWikiLinter({ include: false, ...await getOpt(opt), cdn: baseData.CDN }, view);
     const lintSource = async (state) => {
         const { doc } = state, option = await getOpt(opt, true) ?? {}, wiki = option['wiki'];
         return [
@@ -255,7 +255,7 @@ export const getJsonLintSource = () => ({ doc }) => lintJSON(doc.toString())
  * @test
  */
 export const getLuaLintSource = async () => {
-    const { CDN } = base, luaLint = await getLuaLinter(CDN && `${CDN}/${luacheckRepo}`);
+    const { CDN } = baseData, luaLint = await getLuaLinter(CDN && `${CDN}/${luacheckRepo}`);
     return async ({ doc }) => (await luaLint(doc.toString()))
         .map(({ line, column, end_column, msg: message, severity }) => ({
         source: 'Luacheck',

package/dist/lua.d.ts

@@ -3,7 +3,7 @@ import { LanguageSupport } from '@codemirror/language';
 import type { ViewUpdate, DecorationSet } from '@codemirror/view';
 import type { EditorState } from '@codemirror/state';
 import type { Tree } from '@lezer/common';
-import type { DocRange } from './fold';
+import type { DocRange } from './util';
 /**
  * 高亮显示LDoc标签
  * @ignore

package/dist/lua.js

@@ -4,7 +4,7 @@ import { ViewPlugin, Decoration } from '@codemirror/view';
 import { syntaxTree, LanguageSupport, StreamLanguage, foldService, HighlightStyle, syntaxHighlighting, } from '@codemirror/language';
 import { snippetCompletion } from '@codemirror/autocomplete';
 import { tags } from '@lezer/highlight';
-import { leadingSpaces, sliceDoc, markDocTagType } from './util.js';
+import { leadingSpaces, sliceDoc, markDocTagType, getCompletions } from './util.js';
 import { lightHighlightStyle } from './theme.js';
 const map = {
     1: 'constant',
@@ -218,12 +218,9 @@ const map = {
         },
         ext: 4,
     },
-}, builtin = ['false', 'nil', 'true'], builtins = builtin.map(label => ({ label, type: 'constant' })), tables = [
-    '_G',
-    ...Object.keys(globals),
-].map(label => ({ label, type: 'namespace' })), constants = [
+}, luaBuiltin = ['false', 'nil', 'true'], luaBuiltins = getCompletions(luaBuiltin, 'constant'), tables = getCompletions(['_G', ...Object.keys(globals)], 'namespace'), constants = [
     { label: '_VERSION', type: 'constant' },
-    ...[
+    ...getCompletions([
         'assert',
         'error',
         'getfenv',
@@ -243,22 +240,15 @@ const map = {
         'unpack',
         'xpcall',
         'require',
-    ].map(label => ({ label, type: 'function' })),
-], binary = [
-    'and',
-    'or',
-    'in',
-].map(label => ({ label, type: 'keyword' })), unary = [
-    ...[
-        'not',
-        'function',
-    ].map(label => ({ label, type: 'keyword' })),
+    ], 'function'),
+], binary = getCompletions(['and', 'or', 'in']), unary = [
+    ...getCompletions(['not', 'function']),
     snippetCompletion('function ${name}(${})\n\t${}\nend', {
         label: 'function',
         detail: 'definition',
         type: 'keyword',
     }),
-], blocks = [
+], blocks = getCompletions([
     'break',
     'elseif',
     'return',
@@ -268,14 +258,14 @@ const map = {
     'do',
     'until',
     'goto',
-].map(label => ({ label, type: 'keyword' })), keywords = [
-    ...[
+]), luaKeywords = [
+    ...getCompletions([
         'if',
         'while',
         'repeat',
         'for',
         'local',
-    ].map(label => ({ label, type: 'keyword' })),
+    ]),
     snippetCompletion('if ${condition} then\n\t${}\nend', {
         label: 'if',
         detail: 'block',
@@ -306,14 +296,14 @@ const map = {
         detail: 'in loop',
         type: 'keyword',
     }),
-], types = new Set(['variableName', 'variableName.standard', 'keyword']), lang = StreamLanguage.define(lua);
+], excludedTypes = new Set(['variableName', 'variableName.standard', 'keyword']), lang = StreamLanguage.define(lua);
 /**
  * @implements
  * @test
  */
 const source = context => {
     const { state, pos } = context, node = syntaxTree(state).resolveInner(pos, -1);
-    if (!types.has(node.name)) {
+    if (!excludedTypes.has(node.name)) {
         return null;
     }
     const match = context.matchBefore(/(?:(?:^|\S|\.\.)\s+|^|[^\w\s]|\.\.)\w+$|\.{1,2}$/u);
@@ -358,57 +348,43 @@ const source = context => {
                 };
             }
             break;
-        case '..':
-        case '+':
-        case '-':
-        case '*':
-        case '/':
-        case '%':
-        case '^':
-        case '&':
-        case '|':
-        case '~':
-        case '<':
-        case '>':
-        case '[':
-            return {
-                from,
-                options: [...constants, ...tables],
-                validFor,
-            };
-        case '=':
-        case '{':
-        case '(':
-        case ',':
-            return {
-                from,
-                options: [...builtins, ...constants, ...tables, ...unary],
-                validFor,
-            };
-        case '}':
-        case ']':
-        case ')':
-            return {
-                from,
-                options: [...binary, ...blocks],
-                validFor,
-            };
         case ';':
         case '':
             return {
                 from,
-                options: [...keywords, ...blocks, ...unary, ...constants, ...tables, ...builtins],
+                options: [...luaKeywords, ...blocks, ...unary, ...constants, ...tables, ...luaBuiltins],
                 validFor,
             };
         default:
-            if (pre !== char) {
+            if (/\.\.|[-+*/%^&|~<>[]/u.test(char)) {
+                return {
+                    from,
+                    options: [...constants, ...tables],
+                    validFor,
+                };
+            }
+            else if (/[={(,]/u.test(char)) {
+                return {
+                    from,
+                    options: [...luaBuiltins, ...constants, ...tables, ...unary],
+                    validFor,
+                };
+            }
+            else if (/[}\])]/u.test(char)) {
+                return {
+                    from,
+                    options: [...binary, ...blocks],
+                    validFor,
+                };
+            }
+            else if (pre !== char) {
                 const { prevSibling } = node;
                 return {
                     from,
                     options: prevSibling?.name !== 'keyword'
-                        || builtin.includes(sliceDoc(state, prevSibling))
+                        || luaBuiltin.includes(sliceDoc(state, prevSibling))
                         ? [...binary, ...blocks]
-                        : [...builtins, ...constants, ...tables, ...unary, ...blocks],
+                        : [...luaBuiltins, ...constants, ...tables, ...unary, ...blocks],
                     validFor,
                 };
             }
@@ -455,9 +431,9 @@ export const markDocTag = (tree, visibleRanges, state) => {
                     || firstLine.startsWith('---')
                         && !(firstLine.endsWith('--') && /[^-]/u.test(firstLine))) {
                     while (node.name === 'comment') {
-                        const comment = sliceDoc(state, node), mt = /^\s*(?:-{2,}\s*)?(@[a-z]+)(\s+\{(?!\}))?/diu.exec(comment);
+                        const comment = sliceDoc(state, node), mt = /^\s*(?:-{2,}\s*)?(@[a-z]+)(\s+\{)?/diu.exec(comment);
                         if (mt) {
-                            markDocTagType(decorations, node.from, mt);
+                            markDocTagType(decorations, node.from, mt, 1);
                         }
                         // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
                         const { nextSibling } = node;