@bhsd/codemirror-mediawiki 2.19.4 → 2.19.6

package/dist/mwConfig.mjs

@@ -0,0 +1,161 @@
+// ../code-standard/dist/index.mjs
+var CDN = "https://testingcf.jsdelivr.net";
+var span;
+if (typeof document === "object") {
+  span = document.createElement("span");
+}
+var getObject = (key) => JSON.parse(String(localStorage.getItem(key)));
+var setObject = (key, value) => {
+  localStorage.setItem(key, JSON.stringify(value));
+};
+
+// src/static.ts
+var fromEntries = (entries, obj, string) => {
+  for (const entry of entries) {
+    obj[entry] = string ? entry : true;
+  }
+};
+var getStaticMwConfig = ({ parserFunction, protocol, nsid, variants, redirection, ext, doubleUnderscore, img }, modes) => {
+  const mwConfig = {
+    tags: {},
+    tagModes: modes,
+    doubleUnderscore: [{}, {}],
+    functionSynonyms: [parserFunction[0], {}],
+    urlProtocols: `${protocol}|//`,
+    nsid,
+    img: Object.fromEntries(Object.entries(img).map(([key, val]) => [key, `img_${val}`])),
+    variants,
+    redirection
+  }, [insensitive, , obj] = doubleUnderscore;
+  fromEntries(ext, mwConfig.tags);
+  fromEntries(
+    (obj && insensitive.length === 0 ? Object.keys(obj) : insensitive).map((s) => `__${s}__`),
+    mwConfig.doubleUnderscore[0]
+  );
+  fromEntries(doubleUnderscore[1].map((s) => `__${s}__`), mwConfig.doubleUnderscore[1]);
+  fromEntries(parserFunction.slice(2).flat(), mwConfig.functionSynonyms[0], true);
+  fromEntries(parserFunction[1], mwConfig.functionSynonyms[1]);
+  return mwConfig;
+};
+
+// mw/config.ts
+var _a;
+var ALL_SETTINGS_CACHE = (_a = getObject("InPageEditMwConfig")) != null ? _a : {};
+var SITE_ID = typeof mw === "object" ? mw.config.get("wgServerName") + mw.config.get("wgScriptPath") : location.origin;
+var SITE_SETTINGS = ALL_SETTINGS_CACHE[SITE_ID];
+var VALID = Number(SITE_SETTINGS == null ? void 0 : SITE_SETTINGS.time) > Date.now() - 86400 * 1e3 * 30;
+var getConfig = (magicWords, rule, flip) => Object.fromEntries(
+  magicWords.filter(rule).filter(({ "case-sensitive": i }) => i !== flip).flatMap(({ aliases, name, "case-sensitive": i }) => aliases.map((alias) => ({
+    alias: (i ? alias : alias.toLowerCase()).replace(/:$/u, ""),
+    name
+  }))).map(({ alias, name }) => [alias, name])
+);
+var getConfigPair = (magicWords, rule) => [true, false].map((bool) => getConfig(magicWords, rule, bool));
+var setConfig = (config) => {
+  mw.config.set("extCodeMirrorConfig", config);
+};
+var getMwConfig = async (modes) => {
+  if (mw.loader.getState("ext.CodeMirror") !== null && !VALID) {
+    await mw.loader.using(mw.loader.getState("ext.CodeMirror.data") ? "ext.CodeMirror.data" : "ext.CodeMirror");
+  }
+  let config = mw.config.get("extCodeMirrorConfig");
+  if (!config && VALID) {
+    ({ config } = SITE_SETTINGS);
+    setConfig(config);
+  }
+  const isIPE = config && Object.values(config.functionSynonyms[0]).includes(true), nsid = mw.config.get("wgNamespaceIds");
+  if ((config == null ? void 0 : config.img) && config.redirection && config.variants && !isIPE) {
+    config.urlProtocols = config.urlProtocols.replace(/\\:/gu, ":");
+    config.tagModes = modes;
+    return { ...config, nsid };
+  } else if (location.hostname.endsWith(".moegirl.org.cn")) {
+    const parserConfig = await (await fetch(
+      `${CDN}/npm/wikiparser-node@browser/config/moegirl.json`
+    )).json();
+    setObject("wikilintConfig", parserConfig);
+    config = getStaticMwConfig(parserConfig, modes);
+  } else {
+    await mw.loader.using("mediawiki.api");
+    const { query: { general: { variants }, magicwords, extensiontags, functionhooks, variables } } = await new mw.Api().get({
+      meta: "siteinfo",
+      siprop: [
+        "general",
+        "magicwords",
+        ...config && !isIPE ? [] : ["extensiontags", "functionhooks", "variables"]
+      ],
+      formatversion: "2"
+    });
+    const others = /* @__PURE__ */ new Set(["msg", "raw", "msgnw", "subst", "safesubst"]);
+    if (config && !isIPE) {
+      const { functionSynonyms: [insensitive] } = config;
+      if (!("subst" in insensitive)) {
+        Object.assign(insensitive, getConfig(magicwords, ({ name }) => others.has(name)));
+      }
+    } else {
+      const functions = /* @__PURE__ */ new Set([
+        ...functionhooks,
+        ...variables,
+        ...others
+      ]);
+      config = {
+        tags: Object.fromEntries(extensiontags.map((tag) => [tag.slice(1, -1), true])),
+        functionSynonyms: getConfigPair(magicwords, ({ name }) => functions.has(name)),
+        doubleUnderscore: getConfigPair(
+          magicwords,
+          ({ aliases }) => aliases.some((alias) => /^__.+__$/u.test(alias))
+        )
+      };
+    }
+    config.tagModes = modes;
+    config.img = getConfig(magicwords, ({ name }) => name.startsWith("img_"));
+    config.variants = variants ? variants.map(({ code }) => code) : [];
+    config.redirection = magicwords.find(({ name }) => name === "redirect").aliases;
+    config.urlProtocols = mw.config.get("wgUrlProtocols").replace(/\\:/gu, ":");
+  }
+  setConfig(config);
+  ALL_SETTINGS_CACHE[SITE_ID] = { config, time: Date.now() };
+  setObject("InPageEditMwConfig", ALL_SETTINGS_CACHE);
+  return { ...config, nsid };
+};
+var getParserConfig = (minConfig, mwConfig) => {
+  var _a2;
+  let config = getObject("wikilintConfig");
+  if (config) {
+    return config;
+  }
+  config = {
+    ...minConfig,
+    ext: Object.keys(mwConfig.tags),
+    namespaces: mw.config.get("wgFormattedNamespaces"),
+    nsid: mwConfig.nsid,
+    doubleUnderscore: mwConfig.doubleUnderscore.map(
+      (obj) => Object.keys(obj).map((s) => s.slice(2, -2))
+    ),
+    variants: mwConfig.variants,
+    protocol: mwConfig.urlProtocols.replace(/\|\\?\/\\?\//u, ""),
+    redirection: (_a2 = mwConfig.redirection) != null ? _a2 : minConfig.redirection
+  };
+  if (location.hostname.endsWith(".moegirl.org.cn")) {
+    config.html[2].push("img");
+  }
+  [config.parserFunction[0]] = mwConfig.functionSynonyms;
+  if (mw.loader.getState("ext.CodeMirror") === null) {
+    for (const [key, val] of Object.entries(mwConfig.functionSynonyms[0])) {
+      if (!key.startsWith("#")) {
+        config.parserFunction[0][`#${key}`] = val;
+      }
+    }
+  }
+  config.parserFunction[1] = [
+    ...Object.keys(mwConfig.functionSynonyms[1]),
+    "="
+  ];
+  for (const [key, val] of Object.entries(mwConfig.img)) {
+    config.img[key] = val.slice(4);
+  }
+  return config;
+};
+export {
+  getMwConfig,
+  getParserConfig
+};

package/dist/openExtLinks.d.ts

@@ -1,2 +1,2 @@
-export declare const isMac: boolean;
+export declare const isMac: boolean, modKey: string, key: string;
 export declare const openExtLinks: import("@codemirror/state").Extension[];

package/dist/openLinks.d.ts

@@ -0,0 +1,4 @@
+import type { Extension } from '@codemirror/state';
+import type { CodeMirror6 } from './codemirror';
+export declare const isMac: boolean;
+export declare const openLinks: ({ langConfig }: CodeMirror6) => Extension;

package/dist/ref.d.ts

@@ -1,11 +1,6 @@
 import { EditorView } from '@codemirror/view';
-import type { AST } from 'wikiparser-node/base';
 import type { editor } from 'monaco-editor';
 declare type Ranges = [number, number][];
-declare type Tree = Promise<AST> & {
-    docChanged?: boolean;
-};
-export declare const trees: WeakMap<EditorView | editor.ITextModel, Tree>;
 /**
  * 异步查找注释的内容
  * @param view

package/dist/static.d.ts

@@ -24,4 +24,4 @@ export declare const tagModes: {
     maplink: string;
     graph: string;
 };
-export declare const getStaticMwConfig: ({ parserFunction, protocol, nsid, variants, redirection, ext, doubleUnderscore, img }: Config) => MwConfig;
+export declare const getStaticMwConfig: ({ parserFunction, protocol, nsid, variants, redirection, ext, doubleUnderscore, img }: Config, modes: Record<string, string>) => MwConfig;

package/dist/token.d.ts

@@ -5,7 +5,9 @@
  */
 import { Tag } from '@lezer/highlight';
 import { tokens } from './config';
-import type { StreamParser, StringStream } from '@codemirror/language';
+import type { EditorState } from '@codemirror/state';
+import type { StreamParser, StringStream as StringStreamBase } from '@codemirror/language';
+import type { SyntaxNode } from '@lezer/common';
 declare type Style = string | [string];
 declare type Tokenizer<T = Style> = ((stream: StringStream, state: State) => T) & {
     args?: unknown[];
@@ -28,6 +30,7 @@ declare interface State extends Nesting {
         html: number;
     };
     redirect: boolean;
+    imgLink: boolean;
     data: MediaWikiData;
 }
 declare interface Token {
@@ -36,6 +39,10 @@ declare interface Token {
     style: Style;
     readonly state: State;
 }
+declare interface StringStream extends StringStreamBase {
+    match(pattern: string, consume?: boolean, caseInsensitive?: boolean): true | null;
+    match(pattern: RegExp, consume?: boolean): RegExpMatchArray | null;
+}
 export type TagName = keyof typeof tokens;
 export type ApiSuggestions = [string, string?][];
 /**
@@ -47,7 +54,7 @@ export type ApiSuggestions = [string, string?][];
 export type ApiSuggest = (search: string, namespace?: number, subpage?: boolean) => ApiSuggestions | Promise<ApiSuggestions>;
 export interface MwConfig {
     readonly tags: Record<string, true>;
-    readonly tagModes: Record<string, string>;
+    tagModes: Record<string, string>;
     urlProtocols: string;
     functionSynonyms: [Record<string, string>, Record<string, unknown>];
     doubleUnderscore: [Record<string, unknown>, Record<string, unknown>];
@@ -59,6 +66,8 @@ export interface MwConfig {
     implicitlyClosedHtmlTags?: string[];
     linkSuggest?: ApiSuggest;
     paramSuggest?: ApiSuggest;
+    titleParser?: (state: EditorState, node: SyntaxNode, urlProtocols: string) => true | undefined;
+    isbnParser?: (link: string) => true;
 }
 declare class MediaWikiData {
     /** 已解析的节点 */
@@ -92,8 +101,8 @@ export declare class MediaWiki {
     readonly templateRegex: RegExp;
     readonly argumentRegex: RegExp;
     readonly styleRegex: RegExp;
-    readonly convertSemicolon: RegExp;
-    readonly convertLang: RegExp;
+    readonly convertSemicolon: RegExp | undefined;
+    readonly convertLang: RegExp | undefined;
     readonly convertRegex: RegExp;
     readonly wikiRegex: RegExp;
     readonly tableDefinitionRegex: RegExp;
@@ -114,10 +123,11 @@ export declare class MediaWiki {
      * See makeLocalStyle() for how these tokens are used.
      */
     registerGroundTokens(): void;
+    inChars({ length }: string, tag: TagName): Tokenizer;
     inStr(str: string, tag: TagName | false, errorTag?: TagName): Tokenizer;
     eatWikiText(style: string): Tokenizer;
     eatApostrophes(obj: Pick<State, 'bold' | 'italic'>): Tokenizer<string | false>;
-    eatExternalLinkProtocol(chars: string, free?: boolean): Tokenizer;
+    eatExternalLinkProtocol({ length }: string, free?: boolean): Tokenizer;
     inExternalLink(text?: boolean): Tokenizer;
     get eatFreeExternalLink(): Tokenizer;
     inLink(file: boolean, section?: boolean): Tokenizer;
@@ -137,7 +147,7 @@ export declare class MediaWiki {
     eatExtTagArea(name: string): Tokenizer;
     inExtTokens(origString: string): Tokenizer;
     inVariable(pos?: number): Tokenizer;
-    eatTransclusion(stream: StringStream, state: State): string;
+    eatTransclusion(stream: StringStream, state: State, { length }: string): string | undefined;
     inParserFunctionName(invoke?: number, n?: number): Tokenizer;
     inTemplatePageName(haveEaten?: boolean, anchor?: boolean): Tokenizer;
     inParserFunctionArgument(module?: number, n?: number): Tokenizer;
@@ -152,6 +162,7 @@ export declare class MediaWiki {
      * @param tags
      */
     mediawiki(tags?: string[]): StreamParser<State>;
+    'text/mediawiki'(): StreamParser<State>;
     'text/nowiki'(): StreamParser<Record<string, never>>;
     inPre(begin?: boolean): Tokenizer<string>;
     'text/pre'(): StreamParser<State>;