@inpageedit/core 0.12.1 → 0.13.0-alpha.0

package/dist/index.d.ts

@@ -1,38 +1,1730 @@
-import { InPageEdit as IPECore } from './InPageEdit';
-export * from './InPageEdit';
-export { default as BasePlugin } from './plugins/BasePlugin';
+import { Context, Events as Events$1, ForkScope, Inject, Inject as Inject$1, Service } from "@cordisjs/core";
+import * as _inpageedit_logger0 from "@inpageedit/logger";
+import { Logger } from "@inpageedit/logger";
+import * as wiki_saikou0 from "wiki-saikou";
+import { FexiosConfigs, MwApiParams } from "wiki-saikou";
+import { FexiosFinalContext, MediaWikiApi, MwApi, MwApiParams as MwApiParams$1, MwApiResponse } from "wiki-saikou/browser";
+import { IPEModal, IPEModalEvent, IPEModalOptions } from "@inpageedit/modal";
+import "@inpageedit/modal/style.css";
+import { IDBPlus } from "idb-plus";
+import "@/styles/index.scss";
+import Schema, { default as Schema$1 } from "schemastery";
+import * as jsx_dom0 from "jsx-dom";
+import { JSX, ReactElement, ReactNode } from "jsx-dom";
+import { JSX as JSX$1 } from "jsx-dom/jsx-runtime";
+import { JSX as JSX$2 } from "vue/jsx-runtime";
+import PreferencesApp from "./plugins/preferences-ui/components/PreferencesApp.vue";
+import { App } from "vue";
+import "./plugins/toolbox/styles.scss";
+export * from "@inpageedit/logger";
+export * from "wiki-saikou/browser";
+export * from "@inpageedit/modal";
+
+//#region rolldown:runtime
+//#endregion
+//#region src/services/ApiService.d.ts
+declare module '@/InPageEdit' {
+  interface InPageEdit {
+    api: MwApi;
+  }
+}
+interface ApiServiceOptions extends Partial<FexiosConfigs> {}
+declare class ApiService {
+  ctx: InPageEdit;
+  constructor(ctx: InPageEdit, options?: Partial<ApiServiceOptions>);
+}
+//#endregion
+//#region src/types/WikiMetadata.d.ts
+interface WikiSiteInfo {
+  general: WikiSiteGeneralInfo;
+  specialpagealiases: WikiSpecialPageAlias[];
+  namespacealiases: WikiNameSpaceAlias[];
+  magicwords: WikiMagicWord[];
+  namespaces: Record<string, WikiNamespace>;
+}
+interface WikiSiteGeneralInfo {
+  mainpage: string;
+  base: string;
+  sitename: string;
+  mainpageisdomainroot: boolean;
+  logo: string;
+  generator: string;
+  phpversion: string;
+  phpsapi: string;
+  dbtype: string;
+  dbversion: string;
+  imagewhitelistenabled: boolean;
+  langconversion: boolean;
+  titleconversion: boolean;
+  linkprefixcharset: string;
+  linkprefix: string;
+  linktrail: string;
+  legaltitlechars: string;
+  invalidusernamechars: string;
+  allunicodefixes: boolean;
+  fixarabicunicode: boolean;
+  fixmalayalamunicode: boolean;
+  'git-hash'?: string;
+  'git-branch'?: string;
+  case: 'first-letter' | string;
+  lang: string;
+  fallback?: {
+    code: string;
+  }[];
+  variants: {
+    code: string;
+    name: string;
+  }[];
+  rtl: boolean;
+  fallback8bitEncoding: string;
+  readonly: boolean;
+  writeapi: boolean;
+  maxarticlesize: number;
+  timezone: string;
+  timeoffset: number;
+  articlepath: string;
+  scriptpath: string;
+  script: string;
+  variantarticlepath: string | false;
+  server: string;
+  servername: string;
+  wikiid: string;
+  time: string;
+  misermode: boolean;
+  uploadsenabled: boolean;
+  maxuploadsize: number;
+  minuploadchunksize: number;
+  galleryoptions: {
+    imagesPerRow: number;
+    imageWidth: number;
+    imageHeight: number;
+    captionLength: boolean;
+    showBytes: boolean;
+    showDimensions: boolean;
+    mode: 'traditional' | string;
+  };
+  thumblimits: Record<`${number}`, number>;
+  imagelimits: Record<`${number}`, {
+    width: number;
+    height: number;
+  }>;
+  favicon: string;
+  centralidlookupprovider: string;
+  allcentralidlookupproviders: string[];
+  interwikimagic: boolean;
+  magiclinks: Record<string, boolean>;
+  categorycollation: 'uppercase' | string;
+  citeresponsivereferences: boolean;
+}
+interface WikiSpecialPageAlias {
+  realname: string;
+  aliases: string[];
+}
+interface WikiNameSpaceAlias {
+  id: number;
+  alias: string;
+}
+interface WikiNamespace {
+  canonical?: string;
+  case: 'first-letter' | string;
+  content: boolean;
+  id: number;
+  name: string;
+  namespaceprotection?: string;
+  nonincludable: boolean;
+  subpages: boolean;
+}
+interface WikiMagicWord {
+  name: string;
+  aliases: string[];
+  'case-sensitive': boolean;
+}
+interface WikiUserInfo extends Partial<WikiUserBlockInfo> {
+  id: number;
+  name: string;
+  groups: string[];
+  rights: string[];
+  options: WikiUserOptions;
+}
+interface WikiUserBlockInfo {
+  blockid: number;
+  blockedby: string;
+  blockedbyid: string;
+  blockreason: string;
+  blockedtimestamp: string;
+  blockexpiry: string;
+}
+type IntBool = 0 | 1;
+interface WikiUserOptions {
+  minordefault: IntBool;
+  watchcreations: IntBool;
+  watchdefault: IntBool;
+  watchdeletion: IntBool;
+  watchuploads: IntBool;
+  watchmoves: IntBool;
+  language: string;
+  [key: string]: unknown;
+}
+//#endregion
+//#region src/models/WikiTitle/index.d.ts
+interface IWikiTitle {
+  /**
+   * Get db key without namespace prefix
+   * e.g. "template:hello world" -> "Hello_world"
+   */
+  getMainDBKey(): string;
+  /**
+   * Get page name without namespace prefix
+   * e.g. "template:hello world" -> "Hello world"
+   */
+  getMainText(): string;
+  /**
+   * Get db key with namespace prefix
+   * e.g. "template:hello world" -> "Template:Hello_world"
+   */
+  getPrefixedDBKey(): string;
+  /**
+   * Get page name with namespace prefix
+   * e.g. "template:hello world" -> "Template:Hello world"
+   */
+  getPrefixedText(): string;
+  toText: () => string;
+  toString: () => string;
+  /**
+   * Get namespace ID
+   * e.g. "template:hello world" -> 10
+   */
+  getNamespaceId(): number;
+  /**
+   * Get namespace text
+   * e.g. "template:hello world" -> "Template"
+   */
+  getNamespaceText(): string;
+  /**
+   * Get namespace db key
+   * e.g. "template talk:hello world" -> "Template_talk"
+   */
+  getNamespaceDBKey(): string;
+  /**
+   * Get subject page
+   * If current page is subject page, return itself
+   * e.g. "template talk:hello world" -> new WikiTitle("Template:Hello world")
+   */
+  getSubjectPage(): IWikiTitle;
+  /**
+   * Get talk page
+   * If current page is talk page, return itself
+   * If current page cannot have talk page, return null
+   * e.g. "template:hello world" -> new WikiTitle("Template talk:Hello world")
+   */
+  getTalkPage(): IWikiTitle | null;
+  /**
+   * Get URL of the page
+   * e.g. "template:hello world" -> "https://example.com/wiki/Template:Hello_world"
+   */
+  getURL(params?: Record<string, string> | URLSearchParams): URL;
+  /**
+   * Reset current title with given title string
+   */
+  setTitle(title: string): IWikiTitle;
+  /**
+   * Set main title, keep current ns, update dbkey
+   */
+  setMainText(mainTitle: string): IWikiTitle;
+  /**
+   * Set namespace by text
+   */
+  setNamespaceText(namespaceText: string): IWikiTitle;
+  /**
+   * Set namespace by ID
+   */
+  setNamespaceId(namespaceId: number): IWikiTitle;
+  /**
+   * Check if the title is equal to another title
+   */
+  equals(other: IWikiTitle | string): boolean;
+  /**
+   * Check if the title is specific special page
+   * e.g. "Special:Diff" is "差异" or "diff" -> true
+   */
+  isSpecial(alia: string): boolean;
+  newTitle(title: string, namespace?: number): IWikiTitle;
+}
+interface WikiTitleConstructor {
+  new (title: string, namespace?: number): IWikiTitle;
+  create(title: string, namespace?: number): IWikiTitle;
+}
+declare function createWikiTitleModel(metadata: WikiSiteInfo): WikiTitleConstructor;
+//#endregion
+//#region src/services/CurrentPageService.d.ts
+declare module '@/InPageEdit.js' {
+  interface InPageEdit {
+    /**
+     * Basic information of the current web page
+     */
+    currentPage: CurrentPageService;
+  }
+}
+declare class CurrentPageService extends Service {
+  #private;
+  readonly ctx: InPageEdit;
+  constructor(ctx: InPageEdit);
+  private get logger();
+  protected start(): Promise<void>;
+  protected stop(): void | Promise<void>;
+  url: URL;
+  get params(): URLSearchParams;
+  get canonicalUrl(): URL | null;
+  readonly isMainPage: boolean;
+  /**
+   * Get the title of the current page by location URL
+   * @returns IWikiTitle or null if cannot be determined
+   */
+  wikiTitle: IWikiTitle | null;
+  get wikiAction(): string;
+}
+//#endregion
+//#region src/services/ResourceLoaderService.d.ts
+declare module '@/InPageEdit' {
+  interface InPageEdit {
+    resourceLoader: ResourceLoaderService;
+  }
+}
+declare class ResourceLoaderService extends Service {
+  ctx: InPageEdit;
+  constructor(ctx: InPageEdit);
+  protected stop(): void | Promise<void>;
+  loadScript(src: string, attrs?: Record<string, any>): Promise<HTMLScriptElement | null>;
+  loadStyle(href: string, attrs?: Record<string, any>): Promise<HTMLLinkElement | null>;
+  removeStyle(href: string): void;
+  removeScript(src: string): void;
+  removeAll(): void;
+  resolveImportPath(path: string): string;
+}
+//#endregion
+//#region src/services/ModalService.d.ts
+declare module '@/InPageEdit' {
+  interface InPageEdit {
+    modal: ModalService;
+  }
+}
+declare class CustomIPEModal extends IPEModal {
+  constructor(options?: Partial<IPEModalOptions>);
+  private _tmpDisabledActiveInputs?;
+  setLoadingState(state: boolean): void;
+}
+declare class ModalService {
+  ctx: InPageEdit;
+  constructor(ctx: InPageEdit);
+  IPEModal: typeof CustomIPEModal;
+  IPEModalEvent: typeof IPEModalEvent;
+  show: (...args: Parameters<typeof CustomIPEModal.show>) => CustomIPEModal;
+  createObject: (...args: Parameters<typeof CustomIPEModal.createObject>) => CustomIPEModal;
+  close: typeof IPEModal.close;
+  closeAll: typeof IPEModal.closeAll;
+  removeAll: typeof IPEModal.removeAll;
+  dialog: (...args: Parameters<typeof CustomIPEModal.dialog>) => CustomIPEModal;
+  confirm: (...args: Parameters<typeof CustomIPEModal.confirm>) => CustomIPEModal;
+  notify: (...args: Parameters<typeof CustomIPEModal.notify>) => CustomIPEModal;
+}
+//#endregion
+//#region src/services/storage/managers/LocalStorageManager.d.ts
+declare class LocalStorageManager<T = unknown> implements AbstractIPEStorageManager<T> {
+  dbName?: string | undefined;
+  readonly storeName?: string | undefined;
+  ttl: number;
+  version?: number | undefined;
+  engine: 'localStorage' | 'sessionStorage' | 'memory';
+  private db;
+  constructor(dbName?: string | undefined, storeName?: string | undefined, ttl?: number, version?: number | undefined, engine?: 'localStorage' | 'sessionStorage' | 'memory');
+  private makeKey;
+  private load;
+  private getRaw;
+  private setRaw;
+  private deleteSync;
+  private isExpired;
+  get(key: string, ttl?: number, setter?: () => Promise<T> | T): Promise<T | null>;
+  set(key: string, value: null | undefined): Promise<void>;
+  set(key: string, value: T): Promise<TypedStorageEntry<T>>;
+  set(record: Record<string, T | null | undefined>): Promise<Record<string, TypedStorageEntry<T> | void>>;
+  has(key: string, ttl?: number): Promise<boolean>;
+  delete(key: string): Promise<void>;
+  updatedAt(key: string): Promise<number>;
+  clear(): Promise<this>;
+  keys(): AsyncIterable<string>;
+  values(): AsyncIterable<TypedStorageEntry<T>>;
+  entries(): AsyncIterable<[string, TypedStorageEntry<T>]>;
+}
+//#endregion
+//#region src/services/storage/managers/IDBStorageManager.d.ts
+declare class IDBStorageManager<T = unknown> implements AbstractIPEStorageManager<T> {
+  readonly dbName: string;
+  readonly storeName: string;
+  ttl: number;
+  version?: number | undefined;
+  readonly db: IDBPlus<string, TypedStorageEntry<T>>;
+  keys: () => AsyncIterable<string>;
+  values: () => AsyncIterable<TypedStorageEntry<T>>;
+  entries: () => AsyncIterable<[string, TypedStorageEntry<T>]>;
+  constructor(dbName: string, storeName: string, ttl?: number, version?: number | undefined);
+  private _clearExpiredEntries;
+  get(key: string, ttl?: number, setter?: () => Promise<T> | T): Promise<T | null>;
+  set(key: string, value: null | undefined): Promise<void>;
+  set(key: string, value: T): Promise<TypedStorageEntry<T>>;
+  set(record: Record<string, T | null | undefined>): Promise<Record<string, TypedStorageEntry<T> | void>>;
+  has(key: string, ttl?: number): Promise<boolean>;
+  delete(key: string): Promise<void>;
+  updatedAt(key: string): Promise<number>;
+  private loadFromDB;
+  private checkIfExpired;
+  /**
+   * [DANGER] Use with caution!
+   * Delete all data from the database.
+   */
+  clear(): Promise<this>;
+}
+//#endregion
+//#region src/services/storage/index.d.ts
+declare module '@/InPageEdit' {
+  interface InPageEdit {
+    storage: StorageService;
+  }
+}
+interface StorageServiceConfig {
+  dbName: string;
+}
+declare class StorageService extends Service<StorageServiceConfig> {
+  config: StorageServiceConfig;
+  readonly kv: IDBStorageManager<any>;
+  readonly simpleKV: LocalStorageManager<any>;
+  readonly memoryKV: LocalStorageManager<any>;
+  constructor(ctx: InPageEdit, config: StorageServiceConfig);
+  createDatabase<T = any>(storeName: string, ttl?: number, version?: number, engine?: 'indexedDB' | 'localStorage' | 'sessionStorage' | 'memory'): AbstractIPEStorageManager<T>;
+}
+interface TypedStorageEntry<T = any> {
+  /** last update time */
+  time: number;
+  /** stored value */
+  value: T;
+  /** version */
+  version?: number;
+}
+interface AbstractIPEStorageManager<T = unknown> {
+  get(key: string, ttl?: number, setter?: () => Promise<any> | any): Promise<T | null>;
+  set(key: string, value: null | undefined): Promise<void>;
+  set(record: Record<string, T | null | undefined>): Promise<Record<string, TypedStorageEntry<T> | void>>;
+  set(key: string, value: T): Promise<TypedStorageEntry<T>>;
+  has(key: string, ttl?: number): Promise<boolean>;
+  delete(key: string): Promise<void>;
+  keys(): AsyncIterable<string>;
+  values(): AsyncIterable<TypedStorageEntry<T>>;
+  entries(): AsyncIterable<[string, TypedStorageEntry<T>]>;
+  updatedAt(key: string): Promise<number>;
+  clear(): Promise<this>;
+}
+//#endregion
+//#region src/services/WikiMetadataService.d.ts
+declare module '@/InPageEdit' {
+  interface InPageEdit {
+    wiki: WikiMetadataService;
+    getUrl: WikiMetadataService['getUrl'];
+    getSciprtUrl: WikiMetadataService['getSciprtUrl'];
+    getMainpageUrl: WikiMetadataService['getMainpageUrl'];
+  }
+}
+interface WikiMetadataKindMap {
+  siteinfo: WikiSiteInfo;
+  userinfo: WikiUserInfo;
+}
+declare class WikiMetadataService extends Service {
+  ctx: InPageEdit;
+  private readonly _data;
+  private readonly CACHE_VERSION;
+  private readonly CACHE_TTL;
+  private readonly QUERY_DATA;
+  private readonly CACHE_DB;
+  constructor(ctx: InPageEdit);
+  private get logger();
+  private get api();
+  readonly mwConfig: {
+    get: typeof mw.config.get;
+    has: typeof mw.config.exists;
+    readonly values: ReturnType<typeof mw.config.get>;
+  };
+  protected start(): Promise<void>;
+  initData<T extends keyof WikiMetadataKindMap>(kind: T, noCache?: boolean): Promise<WikiMetadataKindMap[T]>;
+  private getCacheKey;
+  fetchFromApi<T extends keyof WikiMetadataKindMap>(kind: T): Promise<WikiMetadataKindMap[T]>;
+  fetchFromCache<T extends keyof WikiMetadataKindMap>(kind: T): Promise<WikiMetadataKindMap[T] | null>;
+  saveToCache<T extends keyof WikiMetadataKindMap>(kind: T, data: WikiMetadataKindMap[T]): Promise<TypedStorageEntry<WikiSiteInfo | WikiUserInfo>>;
+  invalidateCache<T extends keyof WikiMetadataKindMap>(kind: T): Promise<void>;
+  get _raw(): WikiMetadataKindMap;
+  get siteInfo(): WikiSiteInfo;
+  get general(): WikiSiteGeneralInfo;
+  get specialPageAliases(): WikiSpecialPageAlias[];
+  get namespaceAliases(): WikiNameSpaceAlias[];
+  get namespaces(): Record<string, WikiNamespace>;
+  get namespaceMap(): {
+    id: number;
+    canonical: string | undefined;
+    aliases: string[];
+  }[];
+  get magicWords(): WikiMagicWord[];
+  get userInfo(): WikiUserInfo;
+  get userOptions(): WikiUserOptions;
+  get isUserBlocked(): boolean | "" | undefined;
+  get userGroups(): string[];
+  get userRights(): string[];
+  /**
+   * Base URL, without trailing slash
+   * @example "https://mediawiki.org"
+   */
+  get baseUrl(): string;
+  /**
+   * Home page URL of this wiki
+   * @description Generally same as the Mainpage URL,
+   *              but after MediaWiki 1.34,
+   *              it can be set to the website root directory.
+   * @example "https://mediawiki.org/wiki/Main_Page" (In most cases)
+   * @example "https://mediawiki.org/" ($wgMainPageIsDomainRoot = true)
+   */
+  get landingPageUrl(): string;
+  get mainPageName(): string;
+  /**
+   * Exact Mainpage URL of this wiki
+   * @example "https://mediawiki.org/wiki/Main_Page"
+   */
+  get mainPageUrl(): string;
+  /**
+   * Article path, with the $1 placeholder
+   * @example "/wiki/$1"
+   */
+  get articlePath(): string;
+  /**
+   * Script path, without trailing slash
+   * @example "/w"
+   */
+  get scriptPath(): string;
+  /**
+   * Article base URL, with the $1 placeholder
+   * @example "https://mediawiki.org/wiki/$1"
+   */
+  get articleBaseUrl(): string;
+  /**
+   * Script base URL, without trailing slash
+   * @example "https://mediawiki.org/w"
+   */
+  get scriptBaseUrl(): string;
+  getSciprtUrl(name?: string): string;
+  /** Get mainpage URL */
+  getMainpageUrl(params?: Record<string, any>): string;
+  /** Get page URL by title */
+  getUrl(title: string, params?: Record<string, any>): string;
+  /** Get page URL by page ID */
+  getUrl(pageId: number, params?: Record<string, any>): string;
+  hasRight(right: string): boolean;
+  hasAnyRight(...rights: string[]): boolean;
+  hasEveryRights(...rights: string[]): boolean;
+  inGroup(name: string): boolean;
+  inAnyGroup(...names: string[]): boolean;
+  getBlockInfo(): WikiUserBlockInfo | null;
+}
+//#endregion
+//#region src/models/WikiPage/types/PageInfo.d.ts
+/**
+ * @url https://www.mediawiki.org/wiki/Content_handlers
+ */
+type ContentModelMap = {
+  css: 'text/css';
+  javascript: 'text/javascript';
+  json: 'application/json';
+  text: 'text/plain';
+  wikitext: 'text/x-wiki';
+  GeoJson: 'application/json';
+  'sanitized-css': 'text/css';
+  Scribunto: 'text/plain';
+  'smw/schema': 'application/json';
+};
+interface PageInfo {
+  pageid: number;
+  ns: number;
+  title: string;
+  contentmodel: keyof ContentModelMap;
+  pagelanguage: string;
+  pagelanguagehtmlcode: string;
+  pagelanguagedir: 'ltr' | 'rtl';
+  touched: string;
+  lastrevid: number;
+  length: number;
+  protection: [];
+  restrictiontypes: string[];
+  fullurl: string;
+  canonicalurl: string;
+  editurl?: string;
+  varianttitles?: Record<string, string>;
+  actions: {
+    edit: boolean;
+    move: boolean;
+    delete: boolean;
+  };
+  revisions?: {
+    revid: number;
+    parentid: number;
+    minor: boolean;
+    user: string;
+    timestamp: string;
+    comment: string;
+    contentformat: ContentModelMap[keyof ContentModelMap];
+    contentmodel: keyof ContentModelMap;
+    content: string;
+  }[];
+  templates: {
+    ns: number;
+    title: string;
+  }[];
+  images: {
+    ns: number;
+    title: string;
+  }[];
+  missing?: boolean;
+  special?: boolean;
+}
+//#endregion
+//#region src/models/WikiPage/types/PageParseData.d.ts
+interface PageParseData {
+  title: string;
+  pageid: number;
+  text: string;
+  langlinks: any[];
+  categories: any[];
+  links: any[];
+  templates: any[];
+  images: any[];
+  externallinks: string[];
+  sections: any[];
+  showtoc: boolean;
+  parsewarnings: any[];
+  displaytitle: string;
+  iwlinks: any[];
+  properties: any;
+}
+//#endregion
+//#region src/models/WikiPage/types/WatchlistAction.d.ts
+declare enum WatchlistAction {
+  preferences = "preferences",
+  watch = "watch",
+  unwatch = "unwatch",
+  nochange = "nochange",
+}
+//#endregion
+//#region src/models/WikiPage/index.d.ts
+interface WikiPageEditPayload {
+  text?: string;
+  prependtext?: string;
+  appendtext?: string;
+  summary?: string;
+  watchlist?: WatchlistAction;
+  section?: number | 'new' | undefined;
+}
+interface IWikiPage {
+  pageInfo: PageInfo;
+  parse(params?: MwApiParams$1): Promise<FexiosFinalContext<MwApiResponse<{
+    parse: PageParseData;
+  }>>>;
+  preview(text: string, params?: MwApiParams$1): Promise<FexiosFinalContext<MwApiResponse<{
+    parse: PageParseData;
+  }>>>;
+  edit(payload: WikiPageEditPayload, params?: MwApiParams$1): Promise<FexiosFinalContext<MwApiResponse<{
+    success: boolean;
+  }>>>;
+  createOnly(payload: {
+    text: string;
+  } & Pick<WikiPageEditPayload, 'summary' | 'watchlist'>, params?: MwApiParams$1): Promise<FexiosFinalContext<MwApiResponse<{
+    success: boolean;
+  }>>>;
+  delete(reason?: string, params?: MwApiParams$1): Promise<FexiosFinalContext<MwApiResponse<{
+    delete: {
+      title: string;
+      reason: string;
+      logid: boolean;
+    };
+  }>>>;
+  moveTo(title: string, reason?: string, params?: Partial<MwApiParams$1 & {
+    movetalk: boolean;
+    movesubpages: boolean;
+  }>): Promise<FexiosFinalContext<MwApiResponse<{
+    success: boolean;
+  }>>>;
+  userCan(action: keyof PageInfo['actions']): boolean;
+  userCanEdit(): boolean;
+  reloadSelfInfo(): Promise<this>;
+  readonly pageid: PageInfo['pageid'];
+  readonly title: PageInfo['title'];
+  readonly ns: PageInfo['ns'];
+  readonly contentmodel: PageInfo['contentmodel'];
+  readonly fullurl: PageInfo['fullurl'];
+  readonly canonicalurl: PageInfo['canonicalurl'];
+  readonly editurl: PageInfo['editurl'];
+  readonly revisions: NonNullable<PageInfo['revisions']>;
+  readonly lastrevid: PageInfo['lastrevid'];
+  readonly templates: NonNullable<PageInfo['templates']>;
+  readonly images: NonNullable<PageInfo['images']>;
+}
+interface WikiPageConstructor {
+  new (pageInfo: Partial<PageInfo>, loaded?: boolean): IWikiPage;
+  newFromApi(payload: MwApiParams$1): Promise<IWikiPage>;
+  newBlankPage(init?: Partial<PageInfo>): IWikiPage;
+  /**
+   * Create a new WikiPage instance from any kind of identifier
+   * priority: revid > pageid > title
+   */
+  newFromAnyKind(payload: {
+    title?: string;
+    pageid?: number;
+    revid?: number;
+  }): Promise<IWikiPage | null>;
+  newBatchFromApi(params: MwApiParams$1 & {
+    titles?: string[];
+    pageids?: number[];
+    revids?: number[];
+  }): Promise<IWikiPage[]>;
+}
+declare function createWikiPageModel(api: MediaWikiApi): WikiPageConstructor;
+//#endregion
+//#region src/services/WikiPageService.d.ts
+declare module '@/InPageEdit' {
+  interface InPageEdit {
+    wikiPage: WikiPageService;
+  }
+}
+declare class WikiPageService extends Service {
+  ctx: InPageEdit;
+  static readonly inject: Inject;
+  WikiPage: WikiPageConstructor;
+  constructor(ctx: InPageEdit);
+  createInstance(payload: Record<string, any>, noCache?: boolean): Promise<IWikiPage>;
+  newFromTitle(title: string | IWikiTitle, converttitles?: boolean, rvsection?: number | string, noCache?: boolean): Promise<IWikiPage>;
+  newFromPageId(pageid: number, rvsection?: number | string, noCache?: boolean): Promise<IWikiPage>;
+  newFromRevision(revid: number, rvsection?: number | string, noCache?: boolean): Promise<IWikiPage>;
+  newBlankPage(init?: Partial<PageInfo>): IWikiPage;
+}
+//#endregion
+//#region src/services/WikiTitleService.d.ts
+declare module '@/InPageEdit' {
+  interface InPageEdit {
+    wikiTitle: WikiTitleService;
+  }
+}
+interface WikiLinkMetadata {
+  title?: IWikiTitle;
+  pageId?: number;
+  revId?: number;
+  url: URL;
+  params: URLSearchParams;
+  hash: string;
+  action: 'view' | 'edit' | 'create' | 'diff' | string;
+}
+declare class WikiTitleService extends Service {
+  ctx: InPageEdit;
+  static readonly inject: Inject;
+  readonly Title: WikiTitleConstructor;
+  constructor(ctx: InPageEdit);
+  private readonly logger;
+  newTitle(title: string, namespace?: number): IWikiTitle;
+  newMainPageTitle(): IWikiTitle;
+  newTitleFromUrl(url: string | URL): Promise<any>;
+  private _cachedTitles;
+  private newTitleFromAnyId;
+  newTitleFromPageId(pageId: number): Promise<any>;
+  newTitleFromRevision(revId: number): Promise<any>;
+  /**
+   * Resolve **special** special pages to it's real target
+   *
+   * If target is self or cannot be resolved, return null
+   * @example
+   * ```
+   * Special:MyPage -> User:<username>
+   * Special:Edit/Page_Title -> Page_Title
+   * Special:NewSection/Page_Title -> Page_Title (section=new)
+   * ```
+   */
+  resolveSpecialPageTarget(input: IWikiTitle | string): {
+    title: IWikiTitle;
+    action?: string | undefined;
+    section?: number | 'new' | undefined;
+  } | null;
+  private readonly wiki;
+  /**
+   * @example "https://example.com"
+   */
+  private readonly wikiBaseUrl;
+  /**
+   * Article path, with trailing slash
+   * @example "/wiki/" (if wgArticlePath is "/wiki/$1")
+   */
+  private readonly wikiArticlePath;
+  /**
+   * Article base URL, with trailing slash
+   * @example "https://example.com/wiki/" (if wgArticlePath is "/wiki/$1")
+   */
+  private readonly wikiArticleBaseUrl;
+  /**
+   * Script base URL, **without** trailing slash
+   * @example "https://example.com/w" (if wgScriptPath is "/w")
+   */
+  private readonly wikiIndexPhpUrl;
+  isWikiLink(url: string): boolean;
+  static readonly REG_SKIPPED_HREF: RegExp;
+  validateHrefAttr(href: string | null): boolean;
+  parseWikiLink(link: string | URL): WikiLinkMetadata | null;
+}
+//#endregion
+//#region src/utils/computeable.d.ts
+type ComputeAble<T> = (() => T | Promise<T>) | T;
+//#endregion
+//#region src/services/PreferencesService.d.ts
+declare module '@/InPageEdit' {
+  interface InPageEdit {
+    preferences: PreferencesService;
+    prefs: PreferencesService;
+  }
+  interface Events {
+    'preferences/changed'(payload: {
+      ctx: InPageEdit;
+      /** original input */
+      input: Record<string, unknown>;
+      /** changed settings */
+      changes: Record<string, unknown>;
+    }): void;
+  }
+}
+interface InPageEditPreferenceUICategory {
+  name: string;
+  label: string;
+  description?: string;
+  index?: number;
+  /**
+   * 自定义渲染函数
+   * @param ctx - InPageEdit 上下文
+   * @param onUnmount - 卸载回调，当偏好设置 UI 被卸载时会被调用
+   */
+  customRenderer?: (payload: {
+    ctx: InPageEdit;
+    onMounted: (callback: (container: HTMLElement) => void) => void;
+    onUnmount: (callback: () => void) => void;
+  }) => Promise<Node> | Node;
+  /**
+   * 是否自动生成该分类下的表单
+   * @default true
+   */
+  autoGenerateForm?: boolean;
+}
+interface InPageEditPreferenceUIRegistryItem {
+  name: string;
+  schema: Schema;
+  category: string;
+}
+declare class PreferencesService extends Service {
+  ctx: InPageEdit;
+  private db;
+  customRegistries: InPageEditPreferenceUIRegistryItem[];
+  categoryDefinitions: InPageEditPreferenceUICategory[];
+  private _defaultPreferences;
+  constructor(ctx: InPageEdit);
+  get logger(): _inpageedit_logger0.Logger;
+  start(): Promise<void>;
+  /**
+   * 获取配置项的值
+   * @param key 配置项的键名
+   * @param fallback 当配置项不存在时的回退值
+   * @returns
+   * - 未提供 key 时，返回所有配置项的键值对
+   * - 提供 key 时，返回对应配置项的值，若不存在则返回回退值或 null
+   * @tips 你可以通过重载 PreferencesMap 来定义你的配置项类型，以自动获得类型推导
+   */
+  get(): Promise<PreferencesMap>;
+  get<K extends keyof PreferencesMap>(key: K, fallback?: ComputeAble<PreferencesMap[K]>): Promise<PreferencesMap[K] | null>;
+  get<U = unknown>(key: string, fallback?: ComputeAble<U>): Promise<U | null>;
+  /**
+   * 获取全部注册的配置项以及最终生效的值
+   * 未保存的配置项将使用默认值
+   */
+  getAll(): Promise<PreferencesMap>;
+  set<K extends keyof PreferencesMap>(key: K, value: PreferencesMap[K] | undefined | null): Promise<PreferencesMap[K] | void>;
+  set<U = unknown>(key: string, value: U | undefined | null): Promise<U | void>;
+  setMany(input: { [K in keyof PreferencesMap]?: PreferencesMap[K] | undefined | null }): Promise<{ [K in keyof PreferencesMap]?: PreferencesMap[K] | undefined | null }>;
+  setMany<U = unknown>(input: Record<string, U | undefined | null>): Promise<Record<string, U | undefined | null>>;
+  defaultOf<T extends keyof PreferencesMap>(key: T): PreferencesMap[T] | undefined;
+  defaultOf<U = unknown>(key: string): U | undefined;
+  /**
+   * Get exportable configurations
+   * - exclude values that are the same as the default value
+   * - exclude invalid or undefined values
+   * - sort by keys
+   */
+  getExportableRecord(configs?: Record<string, unknown>): Promise<Record<string, any>>;
+  private loadDefaultConfigs;
+  registerCustomConfig(id: string, schema: Schema, category?: string): this;
+  getConfigRegistries(category?: string): InPageEditPreferenceUIRegistryItem[];
+  getAllSchema(): Schema<PreferencesMap, PreferencesMap>;
+  defineCategory(category: InPageEditPreferenceUICategory): this;
+  getConfigCategories(): InPageEditPreferenceUICategory[];
+  private _migrageFromLegacyMasterDB;
+}
+//#endregion
+//#region src/InPageEdit.d.ts
+interface InPageEditCoreConfig {
+  apiConfigs: Partial<FexiosConfigs>;
+  legacyPreferences: Record<string, any>;
+  logLevel: number;
+  storageNamespace: string;
+  autoloadStyles: boolean;
+  autoInstallCorePlugins: boolean;
+}
+/**
+ * ✏️ InPageEdit NEXT
+ *
+ * 🚀 Modular, Extensible Supercharged Plugin for MediaWiki
+ *
+ * @author dragon-fish <dragon-fish@qq.com>
+ * @license MIT
+ * @see https://github.com/inpageedit/inpageedit-next
+ * @see https://www.ipe.wiki/
+ */
+declare class InPageEdit extends Context {
+  #private;
+  readonly version: string;
+  config: InPageEditCoreConfig;
+  static DEFAULT_CONFIG: InPageEditCoreConfig;
+  Endpoints: any;
+  readonly schema: Schemastery.Static;
+  readonly logger: Logger;
+  constructor(config?: Partial<InPageEditCoreConfig>);
+  withInject(inject: Inject$1): Promise<any>;
+}
+interface PreferencesMap {}
+interface Events<C extends InPageEdit = InPageEdit> extends Events$1<C> {}
+interface InPageEdit {
+  [InPageEdit.events]: Events<this>;
+}
+//#endregion
+//#region src/constants/endpoints.d.ts
+declare enum Endpoints {
+  ANALYTICS_API_BASE = "https://analytics.ipe.wiki/api/v6",
+  ANALYTICS_DASH_URL = "https://analytics.ipe.wiki",
+  GITHUB_URL = "https://github.com/inpageedit/inpageedit-next",
+  HOME_URL = "https://www.ipe.wiki/",
+  UPDATE_LOGS_URL = "https://www.ipe.wiki/changelogs/",
+  PLUGIN_REGISTRY_URL = "https://registry.ipe.wiki/registry.v1.json",
+}
+//#endregion
+//#region src/plugins/BasePlugin.d.ts
+interface DisposeHandler {
+  (ctx: InPageEdit): Promise<void> | void;
+}
+declare class BasePlugin$1<ConfigType extends unknown = any> {
+  #private;
+  ctx: InPageEdit;
+  config: ConfigType;
+  private disposeHandlers;
+  /** 依赖注入 */
+  static inject?: Inject;
+  /** 可重用？ */
+  static reusable: boolean;
+  /** 插件的偏好设置模式 */
+  static PreferencesSchema?: Schema;
+  constructor(ctx: InPageEdit, config?: ConfigType, name?: string);
+  protected start(): Promise<void> | void;
+  protected stop(): Promise<void> | void;
+  protected addDisposeHandler(fn: DisposeHandler): void;
+  protected removeDisposeHandler(fn: DisposeHandler): void;
+  set name(name: string);
+  get name(): string;
+  get logger(): Logger;
+}
+//#endregion
+//#region src/decorators/Preferences.d.ts
+type AnyConstructor<T = any> = new (...args: any[]) => T;
+type PreferenceAugmented<D, C extends AnyConstructor> = C & {
+  PreferencesSchema: Schema$1<D>;
+};
+/**
+ * Decorator for registering preferences
+ *
+ * ```ts
+ * @RegisterPreferences(
+ *   Schema.object({
+ *     foo: Schema.string().description('Foo description'),
+ *   }),
+ *   {
+ *     foo: 'default foo value',
+ *   }
+ * )
+ * class Foo {}
+ * ```
+ *
+ * same as:
+ *
+ * ```ts
+ * class Foo {
+ *    static ConfigSchema = Schema.object({
+ *      foo: Schema.string().description('Foo description')
+ *    })
+ *    static ConfigDefaults = {
+ *      foo: 'default foo value'
+ *    }
+ * }
+ * ```
+ */
+declare function RegisterPreferences<D extends Record<string, any>>(schema: Schema$1<D>): <T extends AnyConstructor>(target: T) => PreferenceAugmented<D, T>;
+//#endregion
+//#region src/components/MBox/index.d.ts
+type MBoxProps = {
+  type?: '' | 'default' | 'note' | 'info' | 'tip' | 'success' | 'important' | 'done' | 'warning' | 'caution' | 'error';
+  title?: ReactNode;
+  content?: ReactNode;
+  closeable?: boolean;
+  titleProps?: JSX$1.IntrinsicElements['div'];
+  contentProps?: JSX$1.IntrinsicElements['div'];
+} & JSX$1.IntrinsicElements['div'];
+type MBoxElement = HTMLElement & {
+  close: () => Promise<void>;
+};
+declare const MBox: (props: MBoxProps) => MBoxElement;
+//#endregion
+//#region src/components/ProgressBar/index.d.ts
+declare const ProgressBar: (attrs: JSX$2.IntrinsicElements["div"] & {
+  indeterminate?: boolean;
+  progress?: number;
+}) => HTMLElement & {
+  setProgress: (progress: number) => void;
+};
+//#endregion
+//#region src/components/TabView/index.d.ts
+interface TabViewLabelOptions {
+  name: string;
+  children: ReactNode;
+}
+declare function TabView({
+  tabs,
+  defaultActiveIndex
+}: {
+  tabs: (TabViewLabelOptions & {
+    content: ReactNode;
+  })[];
+  defaultActiveIndex?: number;
+}): jsx_dom0.ReactElement;
+declare function TabLabel({
+  name,
+  children
+}: {
+  name: string;
+  children: ReactNode;
+}): jsx_dom0.ReactElement;
+declare function TabContent({
+  name,
+  children
+}: {
+  name: string;
+  children: ReactNode;
+}): jsx_dom0.ReactElement;
+//#endregion
+//#region src/components/TwinSwapInput/index.d.ts
+type TwinSwapInputProps = {
+  inputs: [TwinSwapInputInput, TwinSwapInputInput];
+  enableSwap?: boolean;
+} & JSX$1.IntrinsicElements['div'];
+interface TwinSwapInputInput {
+  label?: string;
+  id?: string;
+  name: string;
+  value?: string;
+  disabled?: boolean;
+  required?: boolean;
+  inputProps?: Omit<JSX$1.IntrinsicElements['input'], 'name' | 'value'>;
+}
+type TwinSwapElement = HTMLDivElement & {
+  swap: () => void;
+  toggleEnableSwap: (enable?: boolean) => void;
+};
+declare const TwinSwapInput: (props: TwinSwapInputProps) => TwinSwapElement;
+//#endregion
+//#region src/components/ActionButton.d.ts
+interface ActionButtonProps {
+  type?: 'primary' | 'secondary' | 'danger' | 'default';
+  tag?: 'a' | 'button' | 'div';
+}
+declare const ActionButton: ({
+  type,
+  tag,
+  href,
+  target,
+  children,
+  ...rest
+}: ActionButtonProps & Omit<JSX.IntrinsicElements["button"], "type"> & JSX.IntrinsicElements["a"]) => HTMLAnchorElement;
+//#endregion
+//#region src/components/CheckBox.d.ts
+type CheckBoxProps = {
+  id?: string;
+  name: string;
+  label?: string | HTMLElement;
+  checked?: boolean;
+  inputProps?: JSX.IntrinsicElements['input'];
+  labelProps?: JSX.IntrinsicElements['span'];
+} & JSX.IntrinsicElements['label'];
+declare const CheckBox: (props: CheckBoxProps) => jsx_dom0.ReactElement;
+//#endregion
+//#region src/components/InputBox.d.ts
+type InputBoxProps = {
+  label: string;
+  id?: string;
+  name: string;
+  value?: string;
+  disabled?: boolean;
+  labelProps?: JSX.IntrinsicElements['label'];
+  inputProps?: JSX.IntrinsicElements['input'];
+} & JSX.IntrinsicElements['div'];
+declare const InputBox: (props: InputBoxProps) => jsx_dom0.ReactElement;
+//#endregion
+//#region src/components/RadioBox.d.ts
+type RadioBoxProps = {
+  id?: string;
+  name: string;
+  value: string;
+  label?: string | HTMLElement;
+  inputProps?: JSX.IntrinsicElements['input'];
+  labelProps?: JSX.IntrinsicElements['span'];
+} & JSX.IntrinsicElements['label'];
+declare const RadioBox: (props: RadioBoxProps) => jsx_dom0.ReactElement;
+//#endregion
+//#region src/models/MemoryStorage.d.ts
+declare class MemoryStorage implements Storage {
+  private values;
+  get length(): number;
+  clear(): void;
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+  key(index: number): string | null;
+}
+declare const useMemoryStorage: () => MemoryStorage;
+//#endregion
+//#region src/plugins/analytics/index.d.ts
+declare module '@/InPageEdit' {
+  interface InPageEdit {
+    analytics: PluginAnalytics;
+  }
+}
+interface IPEBeaconPayload {
+  siteApi: string;
+  siteName?: string;
+  userId: number;
+  userName: string;
+  version?: string;
+  usages: IPEBeaconUsage[];
+}
+interface IPEBeaconUsage {
+  ts: number;
+  feature: string;
+  subtype?: string;
+  page?: string;
+}
+declare class PluginAnalytics extends BasePlugin {
+  ctx: InPageEdit;
+  private _usages;
+  private _timer;
+  private readonly MAX_QUEUE_SIZE;
+  private readonly INTERVAL_MS;
+  constructor(ctx: InPageEdit);
+  protected start(): Promise<void> | void;
+  private get analyticsDashUrl();
+  private get analyticsApiBase();
+  private _setupTimer;
+  private _registerUnloadHandler;
+  private _showConfirmNotify;
+  private _initPluginListeners;
+  addEvent(feature: string, subtype?: string, page?: string): this;
+  private sendBeacon;
+  /**
+   * 清理资源
+   */
+  protected stop(): void;
+}
+//#endregion
+//#region src/plugins/in-article-links/index.d.ts
+declare module '@/InPageEdit' {
+  interface InPageEdit {
+    inArticleLinks: PluginInArticleLinks;
+  }
+  interface Events {
+    'in-article-links/anchor-parsed'(payload: {
+      ctx: InPageEdit;
+      anchor: HTMLAnchorElement;
+      info: InArticleWikiAnchorMetadata;
+    }): void;
+    'in-article-links/anchor-clicked'(payload: {
+      ctx: InPageEdit;
+      anchor: HTMLAnchorElement;
+      info: InArticleWikiAnchorMetadata;
+      event: MouseEvent;
+      action: 'quickEdit' | 'quickDiff';
+    }): void;
+  }
+  interface PreferencesMap {
+    'inArticleLinks.quickEdit.enable': boolean;
+    'inArticleLinks.quickDiff.enable': boolean;
+    'inArticleLinks.quickEdit.redlinks': boolean;
+  }
+}
+interface InArticleWikiAnchorMetadata extends WikiLinkMetadata {
+  $el: HTMLAnchorElement;
+  kind: 'normal' | 'mw:File';
+  external: boolean;
+  redlink: boolean;
+}
+declare class PluginInArticleLinks extends BasePlugin<{
+  linkClassName: string;
+}> {
+  constructor(ctx: InPageEdit);
+  protected start(): Promise<void>;
+  protected stop(): Promise<void>;
+  private _cachedAnchorInfo;
+  parseAnchor(anchor: HTMLAnchorElement): InArticleWikiAnchorMetadata | null;
+  scanAnchors(parent: HTMLElement, filter?: (info: InArticleWikiAnchorMetadata) => boolean): InArticleWikiAnchorMetadata[];
+  handleQuickEdit(): Promise<void>;
+  handleQuickDiff(): void;
+}
+//#endregion
+//#region src/plugins/plugin-store/schema.d.ts
+interface PluginStoreRegistry {
+  manifest_version: number;
+  name: string;
+  base_url: string;
+  homepage?: string;
+  maintainers?: PluginStoreRegistryMaintainer[];
+  repository?: PluginStoreRegistryRepository;
+  packages: PluginStorePackage[];
+}
+interface PluginStoreRegistryMaintainer {
+  name: string;
+  email?: string;
+}
+interface PluginStoreRegistryRepository {
+  type: 'git';
+  url: string;
+}
+interface PluginStorePackage {
+  id: string;
+  name: string;
+  version: string;
+  description?: string;
+  author?: string;
+  license?: string;
+  loader: PluginStorePackageLoader;
+}
+interface PluginStorePackageLoader {
+  kind: 'autoload' | 'module' | 'umd' | 'styles';
+  entry?: string;
+  styles?: string[];
+  main_export?: string;
+}
+declare namespace PluginStoreSchemas {
+  const PackageLoader: Schema$1<PluginStorePackageLoader, PluginStorePackageLoader>;
+  const Package: Schema$1<PluginStorePackage, PluginStorePackage>;
+  const RegistryMaintainer: Schema$1<PluginStoreRegistryMaintainer, PluginStoreRegistryMaintainer>;
+  const RegistryRepository: Schema$1<PluginStoreRegistryRepository, PluginStoreRegistryRepository>;
+  const Registry: Schema$1<PluginStoreRegistry, PluginStoreRegistry>;
+}
+//#endregion
+//#region src/plugins/plugin-store/index.d.ts
+declare module '@/InPageEdit' {
+  interface InPageEdit {
+    store: PluginPluginStore;
+  }
+  interface PreferencesMap {
+    'pluginStore.registries': string[];
+    'pluginStore.plugins': {
+      source?: 'online_manifest' | 'npm';
+      registry: string;
+      id: string;
+    }[];
+    'pluginStore.cdnForNpm': string;
+  }
+}
+type PluginStoreRegistrySource = 'online_manifest' | 'npm';
+declare class PluginPluginStore extends BasePlugin {
+  ctx: InPageEdit;
+  static readonly PluginStoreSchemas: typeof PluginStoreSchemas;
+  static REGISTRY_INFO_CACHE_TTL: number;
+  static REGISTRY_INFO_STORAGE_NAME: string;
+  static REGISTRY_ETAG_STORAGE_NAME: string;
+  private regInfoDB;
+  constructor(ctx: InPageEdit);
+  protected start(): Promise<void>;
+  private _installUserPlugins;
+  private _createManagementApp;
+  private _injectPreferenceUI;
+  showModal(): Promise<CustomIPEModal>;
+  private _installedPlugins;
+  install(registry: string, id: string, source?: PluginStoreRegistrySource): Promise<ForkScope<InPageEdit> | null>;
+  uninstall(registry: string, id: string): Promise<boolean>;
+  addToPreferences(registry: string, id: string): Promise<boolean>;
+  removeFromPreferences(registry: string, id: string): Promise<boolean>;
+  installAndSetPreference(registry: string, id: string): Promise<ForkScope<InPageEdit> | null>;
+  uninstallAndRemovePreference(registry: string, id: string): Promise<boolean>;
+  private _installOneByRegistryInfo;
+  validateRegistry(data: any): PluginStoreRegistry;
+  getRegistryInfo(registry: string, source?: PluginStoreRegistrySource, noCache?: boolean): Promise<PluginStoreRegistry>;
+  private _onlineRegistryQueries;
+  private _fetchOnlineRegistryInfo;
+  private getRegistryCache;
+  private setRegistryCache;
+  private deleteRegistryCache;
+  clearAllRegistryCaches(): Promise<void>;
+  /**
+   * 刷新指定 registry 的缓存（重新从网络获取）
+   */
+  refreshRegistryCache(registry: string): Promise<PluginStoreRegistry>;
+  /**
+   * 刷新所有已配置的 registry 缓存
+   */
+  refreshAllRegistryCaches(): Promise<Record<string, PluginStoreRegistry | null>>;
+}
+//#endregion
+//#region src/plugins/preferences-ui/index.d.ts
+declare module '@/InPageEdit' {
+  interface InPageEdit {
+    preferencesUI: PluginPreferencesUI;
+  }
+  interface Events {
+    'preferences-ui/modal-shown'(payload: {
+      ctx: InPageEdit;
+      modal: CustomIPEModal;
+    }): void;
+    'preferences-ui/vue-app-mounted'(payload: {
+      ctx: InPageEdit;
+      app: App;
+      form: InstanceType<typeof PreferencesApp>;
+    }): void;
+    'preferences-ui/modal-tab-changed'(payload: {
+      ctx: InPageEdit;
+      category: string;
+      $tabContent: HTMLElement;
+    }): void;
+    'preferences-ui/form-data-saved'(payload: {
+      ctx: InPageEdit;
+      data: Record<string, unknown>;
+    }): void;
+    'preferences-ui/modal-closed'(payload: {
+      ctx: InPageEdit;
+      modal: CustomIPEModal;
+    }): void;
+  }
+}
+declare class PluginPreferencesUI extends BasePlugin {
+  ctx: InPageEdit;
+  constructor(ctx: InPageEdit);
+  protected start(): Promise<void>;
+  protected stop(): Promise<void> | void;
+  _modal: CustomIPEModal | null;
+  _form: InstanceType<typeof PreferencesApp> | null;
+  showModal(): CustomIPEModal;
+  getCurrentModal(): CustomIPEModal | null;
+  closeCurrentModal(): CustomIPEModal | undefined;
+  dispatchFormSave(form?: InstanceType<typeof PreferencesApp>): Promise<boolean>;
+  getCurrentFormValue(): any;
+  mergeFormValue(value: Record<string, unknown>): boolean;
+  createPreferencesUIApp(): any;
+}
+//#endregion
+//#region src/plugins/quick-diff/index.d.ts
+declare module '@/InPageEdit' {
+  interface InPageEdit {
+    quickDiff: PluginQuickDiff;
+  }
+  interface Events {
+    'quick-diff/init-options'(payload: {
+      ctx: InPageEdit;
+      options: Partial<CompareApiRequestOptions>;
+    }): void;
+    'quick-diff/loaded'(payload: {
+      ctx: InPageEdit;
+      modal: IPEModal;
+      compare: CompareApiResponse['compare'];
+    }): void;
+    'quick-diff/quick-edit-modal'(payload: {
+      ctx: InPageEdit;
+      modal: IPEModal;
+      wikiPage: IWikiPage;
+    }): void;
+  }
+  interface PreferencesMap {
+    'quickDiff.keyshortcut': string;
+  }
+}
+interface CompareApiRequestOptions {
+  fromtitle: string;
+  fromid: number;
+  fromrev: number;
+  frompst: boolean;
+  totitle: string;
+  toid: number;
+  torev: number;
+  torelative?: 'cur' | 'prev' | 'next';
+  topst: boolean;
+  prop: string;
+  difftype: 'table' | 'unified';
+  fromtext: string;
+  fromsection: string | number;
+  fromcontentmodel: string;
+  totext: string;
+  tosection: string | number;
+  tocontentmodel: string;
+}
+interface CompareApiResponse {
+  compare: Partial<{
+    fromid: number;
+    fromrevid: number;
+    fromns: number;
+    fromtitle: string;
+    fromsize: number;
+    fromtimestamp: string;
+    fromuser: string;
+    fromuserid: number;
+    fromcomment: string;
+    fromparsedcomment?: string;
+    toid: number;
+    torevid: number;
+    tons: number;
+    totitle: string;
+    tosize: number;
+    totimestamp: string;
+    touser: string;
+    touserid: number;
+    tocomment: string;
+    toparsedcomment: string;
+    diffsize: number;
+    prev: number;
+    next: number;
+  }> & {
+    body: string;
+  };
+}
+declare class PluginQuickDiff extends BasePlugin {
+  ctx: InPageEdit;
+  constructor(ctx: InPageEdit);
+  protected start(): Promise<void> | void;
+  protected stop(): Promise<void> | void;
+  private injectHistoryPage;
+  private injectQuickEdit;
+  readonly COMPARE_API_DEFAULT_OPTIONS: Partial<CompareApiRequestOptions>;
+  comparePages(options: Partial<CompareApiRequestOptions>, modal?: IPEModal, modalOptions?: Partial<IPEModalOptions>): IPEModal;
+}
+//#endregion
+//#region src/plugins/quick-edit/index.d.ts
+declare module '@/InPageEdit' {
+  interface InPageEdit {
+    quickEdit: PluginQuickEdit & {
+      (...args: Parameters<PluginQuickEdit['showModal']>): ReturnType<PluginQuickEdit['showModal']>;
+    };
+  }
+  interface Events {
+    'quick-edit/init-options'(payload: Omit<QuickEditEventPayload, 'modal' | 'wikiPage'>): void;
+    'quick-edit/show-modal'(payload: Omit<QuickEditEventPayload, 'wikiPage'>): void;
+    'quick-edit/wiki-page'(payload: QuickEditEventPayload): void;
+    'quick-edit/edit-notice'(payload: QuickEditEventPayload & {
+      editNotices: ReactNode[];
+    }): void;
+    'quick-edit/submit'(payload: QuickEditSubmitPayload & {
+      ctx: InPageEdit;
+    }): void;
+  }
+  interface PreferencesMap {
+    'quickEdit.editSummary': string;
+    'quickEdit.editMinor': boolean;
+    'quickEdit.outSideClose': boolean;
+    'quickEdit.watchList': WatchlistAction;
+    'quickEdit.keyshortcut.save': string;
+    'quickEdit.editFont': string;
+  }
+}
+interface QuickEditOptions {
+  title: string;
+  pageId: number;
+  revision: number;
+  /**
+   * - `undefined` for full article edit
+   * - `0` for the first section
+   * - `"new"` for a new section
+   */
+  section: number | 'new' | undefined;
+  editMinor: boolean;
+  editSummary: string;
+  createOnly: boolean;
+  reloadAfterSave: boolean;
+}
+interface QuickEditEventPayload {
+  ctx: InPageEdit;
+  options: QuickEditOptions;
+  modal: IPEModal;
+  wikiPage: IWikiPage;
+}
+interface QuickEditSubmitPayload {
+  wikiPage: IWikiPage;
+  text?: string;
+  summary?: string;
+  section?: number | 'new' | undefined;
+  minor?: boolean;
+  createonly?: boolean;
+  watchlist?: WatchlistAction;
+}
+declare class PluginQuickEdit extends BasePlugin {
+  ctx: InPageEdit;
+  private readonly DEFAULT_OPTIONS;
+  constructor(ctx: InPageEdit);
+  protected start(): Promise<void> | void;
+  showModal(payload?: string | Partial<QuickEditOptions>): Promise<void>;
+  handleSubmit(payload: QuickEditSubmitPayload): Promise<Required<wiki_saikou0.FexiosContext<wiki_saikou0.MwApiResponse<{
+    success: boolean;
+  }>>>>;
+  static readonly BUILT_IN_FONT_OPTIONS: string[];
+  getEditFontOptions(): Promise<{
+    className: string;
+    fontFamily: string;
+  }>;
+  getWikiPageFromPayload(payload: Partial<QuickEditOptions>): Promise<IWikiPage>;
+  private injectToolbox;
+  protected removeToolbox(ctx: InPageEdit): void;
+}
+//#endregion
+//#region src/plugins/quick-move/index.d.ts
+declare module '@/InPageEdit' {
+  interface InPageEdit {
+    quickMove: PluginQuickMove;
+  }
+  interface Events {
+    'quick-move/init-options'(payload: {
+      ctx: InPageEdit;
+      options: Partial<QuickMoveOptions>;
+    }): void;
+    'quick-move/show-modal'(payload: {
+      ctx: InPageEdit;
+      modal: IPEModal;
+    }): void;
+    'quick-move/submit'(payload: {
+      ctx: InPageEdit;
+      modal: IPEModal;
+      payload: MovePageOptions;
+    }): void;
+  }
+  interface PreferencesMap {
+    'quickMove.reason': string;
+  }
+}
+interface MovePageOptions {
+  from: string;
+  to: string;
+  reason?: string;
+  movetalk?: boolean;
+  movesubpages?: boolean;
+  noredirect?: boolean;
+}
+interface QuickMoveOptions extends Partial<MovePageOptions> {
+  lockFromField?: boolean;
+  lockToField?: boolean;
+}
+declare class PluginQuickMove extends BasePlugin {
+  ctx: InPageEdit;
+  constructor(ctx: InPageEdit);
+  protected start(): Promise<void> | void;
+  private injectToolbox;
+  showModal(options?: Partial<QuickMoveOptions>): Promise<CustomIPEModal>;
+  movePage(options: MovePageOptions): Promise<Required<wiki_saikou0.FexiosContext<wiki_saikou0.MwApiResponse<{
+    success: boolean;
+  }>>>>;
+}
+//#endregion
+//#region src/plugins/quick-preview/index.d.ts
+interface QuickPreviewEventPayload {
+  ctx: InPageEdit;
+  modal: IPEModal;
+  wikiPage: IWikiPage;
+  text: string;
+  parseData: PageParseData;
+}
+declare module '@/InPageEdit' {
+  interface InPageEdit {
+    quickPreview: PluginQuickPreview & {
+      (...args: Parameters<PluginQuickPreview['previewWikitext']>): ReturnType<PluginQuickPreview['previewWikitext']>;
+    };
+  }
+  interface Events {
+    'quick-preview/show-modal'(payload: Omit<QuickPreviewEventPayload, 'parseData'>): void;
+    'quick-preview/loaded'(payload: QuickPreviewEventPayload): void;
+  }
+  interface PreferencesMap {
+    'quickPreview.keyshortcut.quickEdit': string;
+    'quickPreview.keyshortcut.quickDelete': string;
+  }
+}
+declare class PluginQuickPreview extends BasePlugin {
+  ctx: InPageEdit;
+  constructor(ctx: InPageEdit);
+  protected start(): Promise<void> | void;
+  protected stop(): Promise<void> | void;
+  previewWikitext(text: string, params?: MwApiParams, wikiPage?: IWikiPage, modal?: IPEModal, modalOptions?: Partial<IPEModalOptions>): IPEModal;
+  private injectQuickEdit;
+}
+//#endregion
+//#region src/plugins/quick-redirect/index.d.ts
+declare module '@/InPageEdit' {
+  interface InPageEdit {
+    quickRedirect: PluginQuickRedirect;
+  }
+  interface Events {
+    'quick-redirect/init-options'(payload: {
+      ctx: InPageEdit;
+      options: Partial<QuickRedirectOptions>;
+    }): void;
+    'quick-redirect/show-modal'(payload: {
+      ctx: InPageEdit;
+      modal: IPEModal;
+    }): void;
+    'quick-redirect/submit'(payload: {
+      ctx: InPageEdit;
+      payload: RedirectPageOptions;
+    }): void;
+  }
+  interface PreferencesMap {
+    'quickRedirect.reason': string;
+  }
+}
+interface RedirectPageOptions {
+  from: string;
+  to: string;
+  reason?: string;
+  overwrite?: boolean;
+}
+interface QuickRedirectOptions extends Partial<RedirectPageOptions> {}
+declare class PluginQuickRedirect extends BasePlugin {
+  ctx: InPageEdit;
+  static readonly inject: string[];
+  static readonly PreferencesSchema: Schema<Schemastery.ObjectS<{
+    'quickRedirect.reason': Schema<string, string>;
+  }>, Schemastery.ObjectT<{
+    'quickRedirect.reason': Schema<string, string>;
+  }>>;
+  constructor(ctx: InPageEdit);
+  protected start(): Promise<void> | void;
+  protected stop(): Promise<void> | void;
+  showModal(options?: Partial<QuickRedirectOptions>): Promise<CustomIPEModal>;
+  redirectPage(options: RedirectPageOptions): Promise<Required<wiki_saikou0.FexiosContext<wiki_saikou0.MwApiResponse<{
+    success: boolean;
+  }>>>>;
+}
+//#endregion
+//#region src/plugins/toolbox/index.d.ts
+declare module '@/InPageEdit' {
+  interface InPageEdit {
+    toolbox: PluginToolbox;
+  }
+  interface Events {
+    'toolbox/button-added'(payload: {
+      ctx: InPageEdit;
+      button: HTMLElement;
+    }): void;
+    'toolbox/button-removed'(payload: {
+      ctx: InPageEdit;
+      id: string;
+    }): void;
+    'toolbox/button-clicked'(payload: {
+      ctx: InPageEdit;
+      button: HTMLElement;
+      id: string;
+    }): void;
+    'toolbox/toggle'(payload: {
+      ctx: InPageEdit;
+      opened: boolean;
+    }): void;
+  }
+  interface PreferencesMap {
+    toolboxAlwaysShow: boolean;
+  }
+}
+declare class PluginToolbox extends Service {
+  ctx: InPageEdit;
+  container: HTMLElement;
+  constructor(ctx: InPageEdit);
+  protected start(): Promise<void>;
+  protected stop(): void | Promise<void>;
+  private get isPersistent();
+  private setupHoverLogic;
+  /**
+   * 计算按钮动画延迟
+   * @param index 按钮索引（从0开始）
+   * @param totalCount 总按钮数量
+   * @returns 延迟时间（秒）
+   */
+  private calculateButtonDelay;
+  /**
+   * 更新按钮组的动画延迟
+   */
+  private updateButtonDelays;
+  private createToolbox;
+  private normalizeButtonId;
+  addButton(payload: {
+    id: string;
+    group?: 'auto' | 'group1' | 'group2';
+    icon: string | HTMLElement | SVGElement | ReactElement;
+    tooltip?: string | HTMLElement;
+    itemProps?: JSX.IntrinsicElements['li'];
+    buttonProps?: JSX.IntrinsicElements['button'];
+    onClick?: (event: MouseEvent) => void;
+    index?: number;
+  }): HTMLElement;
+  removeButton(id: string): void;
+  getContainer(): HTMLElement;
+  get isOpened(): boolean;
+  toggle(force?: boolean): void;
+}
+declare namespace index_d_exports$1 {
+  export { AbstractIPEStorageManager, ApiService, ApiServiceOptions, CurrentPageService, CustomIPEModal, InPageEditPreferenceUICategory, InPageEditPreferenceUIRegistryItem, ModalService, PreferencesService, ResourceLoaderService, StorageService, StorageServiceConfig, TypedStorageEntry, WikiLinkMetadata, WikiMetadataService, WikiPageService, WikiTitleService };
+}
+declare namespace index_d_exports {
+  export { AbstractIPEStorageManager, ActionButton, ActionButtonProps, ApiService, ApiServiceOptions, BasePlugin$1 as BasePlugin, CheckBox, CheckBoxProps, CompareApiRequestOptions, CompareApiResponse, ContentModelMap, CurrentPageService, CustomIPEModal, Endpoints, Events, IPEBeaconPayload, IPEBeaconUsage, IWikiPage, IWikiTitle, InArticleWikiAnchorMetadata, InPageEdit, InPageEditCoreConfig, InPageEditPreferenceUICategory, InPageEditPreferenceUIRegistryItem, Inject, InputBox, InputBoxProps, MBox, MBoxElement, MBoxProps, MemoryStorage, ModalService, MovePageOptions, PageInfo, PageParseData, PluginAnalytics, PluginInArticleLinks, PluginPluginStore, PluginPreferencesUI, PluginQuickDiff, PluginQuickEdit, PluginQuickMove, PluginQuickPreview, PluginQuickRedirect, PluginStoreRegistrySource, PluginToolbox, PreferencesMap, PreferencesService, ProgressBar, QuickEditEventPayload, QuickEditOptions, QuickEditSubmitPayload, QuickMoveOptions, QuickRedirectOptions, RadioBox, RadioBoxProps, RedirectPageOptions, RegisterPreferences, ResourceLoaderService, Schema, Service, StorageService, StorageServiceConfig, TabContent, TabLabel, TabView, TabViewLabelOptions, TwinSwapElement, TwinSwapInput, TwinSwapInputInput, TwinSwapInputProps, TypedStorageEntry, WatchlistAction, WikiLinkMetadata, WikiMagicWord, WikiMetadataService, WikiNameSpaceAlias, WikiNamespace, WikiPageConstructor, WikiPageEditPayload, WikiPageService, WikiSiteGeneralInfo, WikiSiteInfo, WikiSpecialPageAlias, WikiTitleConstructor, WikiTitleService, WikiUserBlockInfo, WikiUserInfo, WikiUserOptions, createWikiPageModel, createWikiTitleModel, useMemoryStorage };
+}
 declare global {
-    const InPageEdit: typeof IPECore;
-    const ipe: IPECore;
-    interface Window {
-        InPageEdit: typeof IPECore;
-        ipe: IPECore;
-        __IPE_MODULES__: {
-            push(payload: (ipe: IPECore) => void): void;
-        };
-    }
+  const ipe: InPageEdit;
+  interface Window {
+    ipe: InPageEdit;
+    __IPE_MODULES__: {
+      push(payload: (ipe: InPageEdit) => void): void;
+    };
+  }
 }
 declare global {
-    interface Window {
-        RLQ: {
-            push(callback: () => void): void;
-            push(depAndCallback: [string, () => void]): void;
-            push(depsAndCallback: [string[], () => void]): void;
-        };
-    }
+  interface Window {
+    RLQ: {
+      push(callback: () => void): void;
+      push(depAndCallback: [string, () => void]): void;
+      push(depsAndCallback: [string[], () => void]): void;
+    };
+  }
 }
 declare global {
-    namespace mw {
-        /**
-         * @see https://doc.wikimedia.org/mediawiki-core/master/js/Hook.html
-         * @see https://github.com/wikimedia-gadgets/types-mediawiki/blob/9b4e7c3b9034d64a44a0667229a6d9585fe09b30/mw/hook.d.ts
-         */
-        interface Hook<T extends any[] = any[]> {
-            add(...handler: Array<(...data: T) => any>): this;
-            deprecate(msg: string): this;
-            fire(...data: T): this;
-            remove(...handler: Array<(...data: T) => any>): this;
-        }
-        function hook(name: 'InPageEdit.ready'): Hook<[IPECore]>;
+  namespace mw {
+    /**
+     * @see https://doc.wikimedia.org/mediawiki-core/master/js/Hook.html
+     * @see https://github.com/wikimedia-gadgets/types-mediawiki/blob/9b4e7c3b9034d64a44a0667229a6d9585fe09b30/mw/hook.d.ts
+     */
+    interface Hook<T extends any[] = any[]> {
+      add(...handler: Array<(...data: T) => any>): this;
+      deprecate(msg: string): this;
+      fire(...data: T): this;
+      remove(...handler: Array<(...data: T) => any>): this;
     }
+    function hook(name: 'InPageEdit.ready'): Hook<[InPageEdit]>;
+  }
 }
+//#endregion
+export { AbstractIPEStorageManager, ActionButton, ActionButtonProps, ApiService, ApiServiceOptions, BasePlugin$1 as BasePlugin, CheckBox, CheckBoxProps, CompareApiRequestOptions, CompareApiResponse, ContentModelMap, CurrentPageService, CustomIPEModal, Endpoints, Events, IPEBeaconPayload, IPEBeaconUsage, IWikiPage, IWikiTitle, InArticleWikiAnchorMetadata, InPageEdit, InPageEditCoreConfig, InPageEditPreferenceUICategory, InPageEditPreferenceUIRegistryItem, Inject, InputBox, InputBoxProps, MBox, MBoxElement, MBoxProps, MemoryStorage, ModalService, MovePageOptions, PageInfo, PageParseData, PluginAnalytics, PluginInArticleLinks, PluginPluginStore, PluginPreferencesUI, PluginQuickDiff, PluginQuickEdit, PluginQuickMove, PluginQuickPreview, PluginQuickRedirect, PluginStoreRegistrySource, PluginToolbox, PreferencesMap, PreferencesService, ProgressBar, QuickEditEventPayload, QuickEditOptions, QuickEditSubmitPayload, QuickMoveOptions, QuickRedirectOptions, RadioBox, RadioBoxProps, RedirectPageOptions, RegisterPreferences, ResourceLoaderService, Schema, Service, StorageService, StorageServiceConfig, TabContent, TabLabel, TabView, TabViewLabelOptions, TwinSwapElement, TwinSwapInput, TwinSwapInputInput, TwinSwapInputProps, TypedStorageEntry, WatchlistAction, WikiLinkMetadata, WikiMagicWord, WikiMetadataService, WikiNameSpaceAlias, WikiNamespace, WikiPageConstructor, WikiPageEditPayload, WikiPageService, WikiSiteGeneralInfo, WikiSiteInfo, WikiSpecialPageAlias, WikiTitleConstructor, WikiTitleService, WikiUserBlockInfo, WikiUserInfo, WikiUserOptions, createWikiPageModel, createWikiTitleModel, useMemoryStorage };