@scml/addon-modded-feats 1.0.0

package/type-dist/SC2DataManager-B_DJOxR6.d.ts

@@ -0,0 +1,1514 @@
+/// <reference path="./common/common.d.ts" />
+/// <reference path="./common/array.d.ts" />
+/// <reference path="./common/collection.d.ts" />
+/// <reference path="./common/date.d.ts" />
+/// <reference path="./common/function.d.ts" />
+/// <reference path="./common/lang.d.ts" />
+/// <reference path="./common/math.d.ts" />
+/// <reference path="./common/number.d.ts" />
+/// <reference path="./common/object.d.ts" />
+/// <reference path="./common/seq.d.ts" />
+/// <reference path="./common/string.d.ts" />
+/// <reference path="./common/util.d.ts" />
+import JSZip from "jszip";
+import { UseStore, clear, createStore, del, entries, get, keys, set, setMany, values } from "idb-keyval";
+import moment from "moment/moment";
+import * as idbInstance from "idb";
+import { deleteDB, openDB } from "idb";
+
+//#region ../sugarcube-2-ModLoader/type-dist/ModPack/ModMeta.d.ts
+//#region remote/BeforeSC2/ModPack/ModMeta.d.ts
+interface FileMeta {
+  b: number;
+  e: number;
+  l: number;
+}
+interface CryptoInfo {
+  Xchacha20NonceBase64: string;
+  PwhashSaltBase64: string;
+}
+interface ModMeta {
+  magicNumber: string;
+  name: string;
+  protocolVersion: number;
+  blockSize: number;
+  cryptoInfo?: CryptoInfo;
+  fileTreeBlock: FileMeta;
+  bootJsonFile: FileMeta;
+  fileMeta: Record<string, FileMeta>;
+} //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/JSZipLikeReadOnlyInterface.d.ts
+//#region remote/BeforeSC2/JSZipLikeReadOnlyInterface.d.ts
+interface JSZipObjectLikeReadOnlyInterface {
+  async<T extends OutputType>(type: T, onUpdate?: any): Promise<OutputByType[T]>;
+  get name(): string;
+  get dir(): boolean;
+}
+interface InputByType {
+  base64: string;
+  string: string;
+  text: string;
+  binarystring: string;
+  array: number[];
+  uint8array: Uint8Array;
+  arraybuffer: ArrayBuffer;
+  blob: Blob;
+}
+interface OutputByType {
+  base64: string;
+  string: string;
+  uint8array: Uint8Array;
+  blob: Blob;
+}
+type InputFileFormat = InputByType[keyof InputByType] | Promise<InputByType[keyof InputByType]>;
+type OutputType = keyof OutputByType;
+interface JSZipLikeReadOnlyInterface {
+  file(path: string): JSZipObjectLikeReadOnlyInterface | null;
+  file(path: RegExp): JSZipObjectLikeReadOnlyInterface[] | null;
+  forEach(callback: (relativePath: string, file: JSZipObjectLikeReadOnlyInterface) => void): void;
+  filter(predicate: (relativePath: string, file: JSZipObjectLikeReadOnlyInterface) => boolean): JSZipObjectLikeReadOnlyInterface[];
+  loadAsync(data: InputFileFormat, options?: any): Promise<JSZipLikeReadOnlyInterface | undefined>;
+  is_JeremieModLoader_ModPack?: boolean;
+  hashString?: string;
+  generateAsync?: typeof JSZip['generateAsync'];
+  get files(): Record<string, JSZipObjectLikeReadOnlyInterface>;
+}
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/ModZipReader.d.ts
+interface Twee2PassageR {
+  name: string;
+  tags: string[];
+  content: string;
+}
+declare class ModZipReaderHash {
+  _hash: string | undefined;
+  _zipBase64String: string | undefined;
+  constructor(zipBase64String: string | undefined, hash?: string | undefined);
+  protected digestMessage(message: string): Promise<string>;
+  protected XxHashH64Bigint2String(h64: bigint): string;
+  protected XxHashH32Number2String(h32: bigint): string;
+  init(): Promise<void>;
+  compare(h: ModZipReaderHash): boolean;
+  compareWithString(h: string): boolean;
+  toString(): string;
+  fromString(hash: string): (typeof this._hash);
+}
+declare class ModZipReader {
+  loaderBase: LoaderBase;
+  modLoadControllerCallback: ModLoadControllerCallback;
+  log: LogWrapper;
+  private gcFinalizationRegistry;
+  private _zip;
+  private _zipIsExist;
+  get zip(): JSZipLikeReadOnlyInterface;
+  modZipReaderHash: ModZipReaderHash;
+  constructor(zip: JSZipLikeReadOnlyInterface, zipBase64String: string, loaderBase: LoaderBase, modLoadControllerCallback: ModLoadControllerCallback);
+  get isModPack(): boolean;
+  get isJsZip(): boolean;
+  modInfo?: ModInfo;
+  getModInfo(): ModInfo | undefined;
+  getZipFile(): JSZipLikeReadOnlyInterface | undefined;
+  /**
+   * use this to release zip object ref, try to remove the object from memory.
+   */
+  gcReleaseZip(): void;
+  /**
+   * use this to debug check if the zip object is really released.
+   * @return [isRefExist(true), isWeakRefExist(false), isWeakRefCleanBeCall(true/(null if not support))]
+   *       only when the return is [true, false, true] the zip object is really released.
+   */
+  gcCheckReleased(): [boolean,
+  /* boolean,*/
+  /* boolean,*/
+  boolean | null];
+  gcIsReleased(): boolean;
+  static validateBootJson(bootJ: any, log?: LogWrapper): bootJ is ModBootJson;
+  static modBootFilePath: string;
+  init(): Promise<boolean>;
+  refillCacheStyleFileItems(styleFileList: string[], keepOld: boolean): Promise<void>;
+  refillCachePassageDataItems(tweeFileList: string[], keepOld: boolean): Promise<void>;
+  refillCacheScriptFileItems(scriptFileList: string[], keepOld: boolean): Promise<void>;
+  constructModInfoCache(bootJ: ModBootJson, keepOld: boolean): Promise<void>;
+}
+declare class LoaderBase {
+  log: ModLoadControllerCallback;
+  loaderKeyConfig: LoaderKeyConfig;
+  modList: ModZipReader[];
+  modZipList: Map<string, ModZipReader[]>;
+  logger: Record<'log' | 'warn' | 'error', ((s: string) => void)>;
+  constructor(log: ModLoadControllerCallback, loaderKeyConfig: LoaderKeyConfig);
+  init(): void;
+  getZipFile(name: string): ModZipReader[] | undefined;
+  addZipFile(name: string, zip: ModZipReader): void;
+  load(): Promise<boolean>;
+}
+declare class LocalStorageLoader extends LoaderBase {
+  static modDataLocalStorageZipList: string;
+  static modDataLocalStorageZipPrefix: string;
+  init(): void;
+  load(): Promise<boolean>;
+  static listMod(): string[] | undefined;
+  static calcModNameKey(name: string): string;
+  static addMod(name: string, modBase64String: string): void;
+  static removeMod(name: string): void;
+  static checkModZipFile(modBase64String: string): Promise<string | ModBootJson>;
+  setConfigKey(modDataLocalStorageZipListKey?: string, modDataLocalStorageZipPrefix?: string): void;
+}
+declare class IndexDBLoader extends LoaderBase {
+  modLoadControllerCallback: ModLoadControllerCallback;
+  loaderKeyConfig: LoaderKeyConfig;
+  static dbName: string;
+  static storeName: string;
+  static modDataIndexDBZipListHidden: string;
+  static modDataIndexDBZipList: string;
+  static modDataIndexDBZipPrefix: string;
+  init(): void;
+  customStore: UseStore;
+  constructor(modLoadControllerCallback: ModLoadControllerCallback, loaderKeyConfig: LoaderKeyConfig);
+  load(): Promise<boolean>;
+  /**
+   * @param modeList must have same items as the list in listMod()
+   */
+  static reorderModList(modeList: string[]): Promise<void>;
+  static setModList(modeList: string[]): Promise<void>;
+  static setHiddenModList(modeList: string[]): Promise<void>;
+  static loadHiddenModList(): Promise<string[] | undefined>;
+  static listMod(): Promise<string[] | undefined>;
+  static calcModNameKey(name: string): string;
+  static addMod(name: string, modBase64String: string | Uint8Array): Promise<void>;
+  static removeMod(name: string): Promise<void>;
+  static checkModZipFile(modBase64String: string | Uint8Array): Promise<string | ModBootJson>;
+  setConfigKey(dbName?: string, storeName?: string, modDataIndexDBZipList?: string, modDataIndexDBZipListHidden?: string): void;
+}
+declare class LocalLoader extends LoaderBase {
+  modLoadControllerCallback: ModLoadControllerCallback;
+  loaderKeyConfig: LoaderKeyConfig;
+  thisWin: Window;
+  modDataValueZipListPath: string;
+  init(): void;
+  constructor(modLoadControllerCallback: ModLoadControllerCallback, loaderKeyConfig: LoaderKeyConfig, thisWin: Window);
+  load(): Promise<boolean>;
+  setConfigKey(modDataValueZipListPath?: string): void;
+}
+declare class RemoteLoader extends LoaderBase {
+  modDataRemoteListPath: string;
+  init(): void;
+  load(): Promise<boolean>;
+  setConfigKey(modDataRemoteListPath: string): void;
+}
+declare class LazyLoader extends LoaderBase {
+  add(modeZip: JSZipLikeReadOnlyInterface): Promise<ModZipReader>;
+  load(): Promise<boolean>;
+}
+declare class LoaderKeyConfig {
+  log: ModLoadControllerCallback;
+  modLoaderKeyConfigWinHookFunctionName: string;
+  logger: Record<'log' | 'warn' | 'error', ((s: string) => void)>;
+  constructor(log: ModLoadControllerCallback);
+  config: Map<string, string>;
+  getLoaderKey(k: string, d: string): string;
+  protected isInit: boolean;
+  protected init(): void;
+  /**
+   * @example
+   * @code
+   * ```
+   * window.modLoaderKeyConfigWinHookFunction = (loaderKeyConfig: LoaderKeyConfig) => {
+   *    loaderKeyConfig.config.set('modDataIndexDBZipList', 'modDataIndexDBZipList123456789');
+   * };
+   * ```
+   *
+   * @protected
+   */
+  protected callWinHookFunction(): void;
+  /**
+   * @example   URL:  ./Degrees of Lewdity VERSION.html.mod.html?modDataIndexDBZipList=modDataIndexDBZipList123456789
+   * @protected
+   */
+  protected getConfigFromUrlHash(): void;
+} //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/ModOrderContainer.d.ts
+//#region remote/BeforeSC2/ModOrderContainer.d.ts
+declare enum ModLoadFromSourceType {
+  'Remote' = "Remote",
+  'Local' = "Local",
+  'LocalStorage' = "LocalStorage",
+  'IndexDB' = "IndexDB",
+  'SideLazy' = "SideLazy"
+}
+interface ModOrderItem {
+  name: string;
+  from: ModLoadFromSourceType;
+  mod: ModInfo;
+  zip: ModZipReader;
+}
+declare abstract class CustomReadonlyMapHelper<K, V> implements ReadonlyMap<K, V> {
+  abstract get size(): number;
+  abstract get(key: K): V | undefined;
+  abstract has(key: K): boolean;
+  abstract entries(): IterableIterator<[K, V]>;
+  [Symbol.iterator](): IterableIterator<[K, V]>;
+  forEach(callback: (value: V, key: K, map: ReadonlyMap<K, V>) => void, thisArg?: any): void;
+  keys(): IterableIterator<K>;
+  values(): IterableIterator<V>;
+}
+declare class ModOrderContainer_One_ReadonlyMap extends CustomReadonlyMapHelper<string, ModOrderItem> {
+  parent: ModOrderContainer;
+  constructor(parent: ModOrderContainer);
+  get size(): number;
+  entries(): IterableIterator<[string, ModOrderItem]>;
+  get(key: string): ModOrderItem | undefined;
+  has(key: string): boolean;
+}
+declare class ModOrderContainer_OneAlias_ReadonlyMap extends CustomReadonlyMapHelper<string, ModOrderItem> {
+  parent: ModOrderContainer;
+  constructor(parent: ModOrderContainer);
+  get size(): number;
+  entries(): IterableIterator<[string, ModOrderItem]>;
+  get(key: string): ModOrderItem | undefined;
+  has(key: string): boolean;
+}
+/**
+ * a multi-index container designed for mod load cache list. work like a C++ Boost.MultiIndexContainer
+ * can keep mod `order` , optional keep mod `unique` , remember mod load `from source`
+ */
+declare class ModOrderContainer {
+  container: Map<string, Map<ModLoadFromSourceType, ModOrderItem>>;
+  order: ModOrderItem[];
+  nameRefWithAlias: Map<string, string>;
+  constructor();
+  /**
+   * O(1)
+   *
+   * add addition limit that keep mod name unique
+   */
+  get_One_Map(): ModOrderContainer_One_ReadonlyMap;
+  get_One_Map_WithAlias(): ModOrderContainer_OneAlias_ReadonlyMap;
+  /**
+   * O(2n)
+   *
+   * add addition limit that keep mod name unique
+   */
+  get_One_Array(): ModOrderItem[];
+  /**
+   * O(n)
+   */
+  get_Array(): ModOrderItem[];
+  /**
+   * O(n)
+   */
+  getAllName(): string[];
+  /**
+   * O(1)
+   */
+  getHasByName(name: string): boolean;
+  /**
+   * O(1)
+   */
+  getHasByNameWithAlias(name: string): boolean;
+  /**
+   * O(1)
+   */
+  getHasByNameFrom(name: string, from: ModLoadFromSourceType): boolean;
+  /**
+   * O(1)
+   */
+  getByName(name: string): Map<ModLoadFromSourceType, ModOrderItem> | undefined;
+  /**
+   * O(1)
+   */
+  getModOrderItemByNameWithAlias(name: string): Map<ModLoadFromSourceType, ModOrderItem> | undefined;
+  /**
+   * O(1)
+   */
+  getByNameOne(name: string, noError?: boolean): ModOrderItem | undefined;
+  /**
+   * O(1)
+   */
+  getByNameOneWithAlias(name: string, noError?: boolean): ModOrderItem | undefined;
+  /**
+   * O(n)
+   */
+  getByFromTypeByOrder(from: ModLoadFromSourceType): ModOrderItem[];
+  /**
+   * O(n)
+   */
+  getByOrder(name: string): ModOrderItem[];
+  /**
+   * O(n)
+   */
+  checkNameUniq(): boolean;
+  /**
+   * O(n)
+   */
+  checkAlias(): boolean;
+  /**
+   * O(n+2log(n))
+   */
+  checkData(): boolean;
+  /**
+   * O(n)
+   */
+  delete(name: string, from: ModLoadFromSourceType): boolean;
+  /**
+   * O(n)
+   */
+  deleteAll(name: string): boolean;
+  /**
+   * O(1)
+   */
+  createModOrderItem(zip: ModZipReader, from: ModLoadFromSourceType): ModOrderItem | undefined;
+  /**
+   * O(2n)
+   */
+  pushFront(zip: ModZipReader, from: ModLoadFromSourceType): boolean;
+  /**
+   * O(2n)
+   */
+  pushBack(zip: ModZipReader, from: ModLoadFromSourceType): boolean;
+  /**
+   * O(2n)
+   */
+  insertReplace(zip: ModZipReader, from: ModLoadFromSourceType): boolean;
+  /**
+   * O(n)
+   */
+  popOut(name: string, from: ModLoadFromSourceType): ModOrderItem | undefined;
+  /**
+   * O(n)
+   */
+  popOutAll(name: string): ModOrderItem[] | undefined;
+  /**
+   * O(1)
+   */
+  popFront(): ModOrderItem | undefined;
+  /**
+   * O(1)
+   */
+  clear(): void;
+  /**
+   * O(1)
+   */
+  get size(): number;
+  /**
+   * O(2n)
+   */
+  clone(): ModOrderContainer;
+  private rebuildNameRefWithAlias;
+  private addModNameRefWithAlias;
+  private removeModNameRefWithAlias;
+  /**
+   * O(n)
+   */
+  private rebuildContainerFromOrder;
+  /**
+   * O(2n)
+   */
+  splitCloneInArray(name: string, from: ModLoadFromSourceType): {
+    before: ModOrderContainer;
+    current: ModOrderItem;
+    after: ModOrderContainer;
+  } | undefined;
+  static mergeModOrderContainer(nnn: (ModOrderContainer | ModOrderItem)[]): ModOrderContainer;
+} //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/ReplacePatcher.d.ts
+//#region remote/BeforeSC2/ReplacePatcher.d.ts
+interface PatchInfo {
+  js?: PatchInfoItem[];
+  css?: PatchInfoItem[];
+  twee?: PatchInfoItem[];
+}
+interface PatchInfoItem {
+  from: string;
+  to: string;
+  fileName: string;
+  passageName?: string;
+}
+interface PatchInfoMap {
+  js: Map<string, PatchInfoItem[]>;
+  css: Map<string, PatchInfoItem[]>;
+  twee: Map<string, PatchInfoItem[]>;
+}
+declare class ReplacePatcher {
+  logger: LogWrapper;
+  modName: string;
+  patchFileName: string;
+  patchInfo_: any;
+  patchInfo: PatchInfo;
+  patchInfoMap: PatchInfoMap;
+  constructor(logger: LogWrapper, modName: string, patchFileName: string, patchInfo_: any);
+  applyReplacePatcher(modSC2DataInfoCache: SC2DataInfo): void;
+} //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/ModLoader.d.ts
+//#region remote/BeforeSC2/ModLoader.d.ts
+interface IModImgGetter {
+  /**
+   * @return Promise<string>   base64 img string
+   */
+  getBase64Image(): Promise<string | undefined>;
+  imgCache?: string;
+  invalid: boolean;
+  forceCache(): Promise<any>;
+}
+interface ModImg {
+  getter: IModImgGetter;
+  path: string;
+}
+interface ModBootJsonAddonPlugin {
+  modName: string;
+  addonName: string;
+  modVersion: string;
+  params?: any[] | {
+    [key: string]: any;
+  };
+}
+interface DependenceInfo {
+  modName: string;
+  version: string;
+}
+type ModNickName = ({ [key in string]?: string } & {
+  cn?: string;
+  en?: string;
+}) | string | undefined;
+interface ModBootJson {
+  name: string;
+  nickName?: ModNickName;
+  alias?: string[];
+  version: string;
+  styleFileList: string[];
+  scriptFileList: string[];
+  scriptFileList_preload?: string[];
+  scriptFileList_earlyload?: string[];
+  scriptFileList_inject_early?: string[];
+  tweeFileList: string[];
+  imgFileList: string[];
+  replacePatchList?: string[];
+  additionFile: string[];
+  additionBinaryFile?: string[];
+  addonPlugin?: ModBootJsonAddonPlugin[];
+  dependenceInfo?: DependenceInfo[];
+}
+interface ModInfo {
+  name: string;
+  nickName?: ModNickName;
+  alias: string[];
+  version: string;
+  cache: SC2DataInfo;
+  imgs: ModImg[];
+  /**
+   * origin path, replace path
+   *
+   * @deprecated the imgFileReplaceList not work and never implemented, don't use it.
+   *             Please use `ImageLoaderAddon` or `BeautySelectorAddon` instead.
+   * @see `ImageLoaderAddon` https://github.com/Lyoko-Jeremie/DoL_ImgLoaderHooker
+   * @see `BeautySelectorAddon` https://github.com/Lyoko-Jeremie/DoL_BeautySelectorAddonMod
+   */
+  imgFileReplaceList: [string, string][];
+  /**
+   * file name, file content
+   */
+  scriptFileList_preload: [string, string][];
+  /**
+   * file name, file content
+   */
+  scriptFileList_earlyload: [string, string][];
+  /**
+   * file name, file content
+   */
+  scriptFileList_inject_early: [string, string][];
+  replacePatcher: ReplacePatcher[];
+  bootJson: ModBootJson;
+  modRef: {
+    [key: string]: any;
+  } | undefined;
+}
+declare enum ModDataLoadType {
+  'Remote' = "Remote",
+  'Local' = "Local",
+  'LocalStorage' = "LocalStorage",
+  'IndexDB' = "IndexDB"
+}
+declare class ModLoader {
+  gSC2DataManager: SC2DataManager;
+  modLoadControllerCallback: ModLoadControllerCallback;
+  thisWin: Window;
+  logger: LogWrapper;
+  constructor(gSC2DataManager: SC2DataManager, modLoadControllerCallback: ModLoadControllerCallback, thisWin: Window);
+  /**
+   * 已读取的mod列表（加载但没有初始化）
+   * The mod list that already read (load but not init)
+   */
+  private modReadCache;
+  /**
+   * 已加载的mod列表（加载并完成初始化）
+   * The mod list that already loaded (load and init)
+   */
+  private modCache;
+  /**
+   * 已加载的Lazy mod列表（使用 `lazyRegisterNewMod` 加载但未完成初始化）
+   * The Lazy mod list that already loaded (load use `lazyRegisterNewMod` but not init)
+   */
+  private modLazyCache;
+  modLoadRecord: ModOrderItem[];
+  /**
+   * O(2n)
+   */
+  getModCacheOneArray(): ModOrderItem[];
+  /**
+   O(n)
+   */
+  getModCacheArray(): ModOrderItem[];
+  getModAllName(): string[];
+  /**
+   O(1)
+   */
+  getModCacheMap(): ModOrderContainer_One_ReadonlyMap;
+  getModCacheMapWithAlias(): ModOrderContainer_OneAlias_ReadonlyMap;
+  /**
+   * O(n+2log(n))
+   */
+  checkModCacheData(): boolean;
+  /**
+   O(n)
+   */
+  checkModCacheUniq(): boolean;
+  /**
+   O(1)
+   */
+  getModCacheByNameOne(modName: string): ModOrderItem | undefined;
+  getModCacheByAliseOne(modName: string): ModOrderItem | undefined;
+  getModCacheByFromType(from: ModLoadFromSourceType): ModOrderItem[];
+  getModReadCache(): ModOrderContainer;
+  checkModConflictList(): {
+    mod: SC2DataInfo;
+    result: SimulateMergeResult;
+  }[];
+  private modLoaderKeyConfig?;
+  private modIndexDBLoader?;
+  private modLocalStorageLoader?;
+  private modLocalLoader?;
+  private modRemoteLoader?;
+  private modLazyLoader?;
+  getLoaderKeyConfig(): LoaderKeyConfig;
+  getIndexDBLoader(): IndexDBLoader;
+  getLocalStorageLoader(): LocalStorageLoader;
+  getLocalLoader(): LocalLoader;
+  getRemoteLoader(): RemoteLoader;
+  getLazyLoader(): LazyLoader;
+  loadOrder: ModDataLoadType[];
+  private addModReadZip;
+  loadMod(loadOrder: ModDataLoadType[]): Promise<boolean>;
+  private registerMod2Addon;
+  protected triggerAfterModLoad(): Promise<void>;
+  protected filterModCanLoad(modeC: ModOrderContainer): Promise<ModOrderContainer>;
+  lazyRegisterNewMod(modeZip: JSZipLikeReadOnlyInterface): Promise<boolean>;
+  private do_initModInjectEarlyLoadInDomScript;
+  private initModInjectEarlyLoadInDomScript;
+  private do_initModEarlyLoadScript;
+  private initModEarlyLoadScript;
+  getModEarlyLoadCache(): ModOrderContainer;
+  getModByNameOne(modName: string): ModOrderItem | undefined;
+  getModZip(modName: string): ModZipReader | undefined;
+  private loadEndModList?;
+  private toLoadModList?;
+  private nowLoadedMod?;
+  private newNowMod?;
+  private replacedNowMod?;
+  private tryInitWaitingLazyLoadMod;
+} //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/ModLoadController.d.ts
+//#region remote/BeforeSC2/ModLoadController.d.ts
+interface LogWrapper {
+  log: (s: string) => void;
+  warn: (s: string) => void;
+  error: (s: string) => void;
+}
+interface LifeTimeCircleHook extends Partial<ModLoadControllerCallback> {}
+interface ModLoadControllerCallback {
+  /**
+   * ban a mod use this, need register this hook in `InjectEarlyLoad`
+   * @param bootJson
+   * @param zip
+   */
+  canLoadThisMod(bootJson: ModBootJson, zip: JSZipLikeReadOnlyInterface): Promise<boolean>;
+  /**
+   * use this to modify a mod, like i18n a mod
+   * @param bootJson
+   * @param zip       carefully modify zip file
+   * @param modInfo   you can modify the all info in there. read: [ModZipReader.init()]
+   */
+  afterModLoad(bootJson: ModBootJson, zip: JSZipLikeReadOnlyInterface, modInfo: ModInfo): Promise<any>;
+  InjectEarlyLoad_start(modName: string, fileName: string): Promise<any>;
+  InjectEarlyLoad_end(modName: string, fileName: string): Promise<any>;
+  EarlyLoad_start(modName: string, fileName: string): Promise<any>;
+  EarlyLoad_end(modName: string, fileName: string): Promise<any>;
+  LazyLoad_start(modName: string): Promise<any>;
+  LazyLoad_end(modName: string): Promise<any>;
+  Load_start(modName: string, fileName: string): Promise<any>;
+  Load_end(modName: string, fileName: string): Promise<any>;
+  PatchModToGame_start(): Promise<any>;
+  PatchModToGame_end(): Promise<any>;
+  /**
+   * @deprecated
+   */
+  ReplacePatcher_start(modName: string, fileName: string): Promise<any>;
+  /**
+   * @deprecated
+   */
+  ReplacePatcher_end(modName: string, fileName: string): Promise<any>;
+  /**
+   * Latest Hook On ModLoader When ALL Load End
+   */
+  ModLoaderLoadEnd(): Promise<any>;
+  /**
+   * @useless useless for user
+   */
+  logError(s: string): void;
+  /**
+   * @useless useless for user
+   */
+  logInfo(s: string): void;
+  /**
+   * @useless useless for user
+   */
+  logWarning(s: string): void;
+  exportDataZip(zip: JSZip): Promise<JSZip>;
+}
+interface LogRecord {
+  type: 'info' | 'warning' | 'error';
+  time: moment.Moment;
+  message: string;
+}
+/**
+ * ModLoader lifetime circle system,
+ * mod can register hook to this system, to listen to the lifetime circle of MpdLoader and error log.
+ *
+ * ModLoader 生命周期系统，
+ * mod 可以注册 hook 到这个系统，来监听 ModLoader 的生命周期和错误日志。
+ */
+declare class ModLoadController implements ModLoadControllerCallback {
+  gSC2DataManager: SC2DataManager;
+  constructor(gSC2DataManager: SC2DataManager);
+  logRecordBeforeAnyLogHookRegister: LogRecord[];
+  LazyLoad_end: (modName: string) => Promise<any>;
+  LazyLoad_start: (modName: string) => Promise<any>;
+  EarlyLoad_end: (modName: string, fileName: string) => Promise<any>;
+  EarlyLoad_start: (modName: string, fileName: string) => Promise<any>;
+  InjectEarlyLoad_end: (modName: string, fileName: string) => Promise<any>;
+  InjectEarlyLoad_start: (modName: string, fileName: string) => Promise<any>;
+  Load_end: (modName: string, fileName: string) => Promise<any>;
+  Load_start: (modName: string, fileName: string) => Promise<any>;
+  PatchModToGame_end: () => Promise<any>;
+  PatchModToGame_start: () => Promise<any>;
+  ReplacePatcher_end: (modName: string, fileName: string) => Promise<any>;
+  ReplacePatcher_start: (modName: string, fileName: string) => Promise<any>;
+  logError: (s: string) => void;
+  logInfo: (s: string) => void;
+  logWarning: (s: string) => void;
+  ModLoaderLoadEnd: () => Promise<any>;
+  canLoadThisMod(bootJson: ModBootJson, zip: JSZipLikeReadOnlyInterface): Promise<boolean>;
+  afterModLoad(bootJson: ModBootJson, zip: JSZipLikeReadOnlyInterface, modInfo: ModInfo): Promise<any>;
+  /**
+   * call by ModLoaderGui (inner use)
+   * @param zip
+   */
+  exportDataZip(zip: JSZip): Promise<JSZip>;
+  private lifeTimeCircleHookTable;
+  addLifeTimeCircleHook(id: string, hook: LifeTimeCircleHook): void;
+  removeLifeTimeCircleHook(hook: LifeTimeCircleHook): void;
+  clearLifeTimeCircleHook(): void;
+  listModLocalStorage(): string[];
+  addModLocalStorage(name: string, modBase64String: string): void;
+  removeModLocalStorage(name: string): void;
+  checkModZipFileLocalStorage(modBase64String: string): Promise<string | ModBootJson>;
+  overwriteModIndexDBModList(modeList: string[]): Promise<void>;
+  overwriteModIndexDBHiddenModList(modeList: string[]): Promise<void>;
+  listModIndexDB(): Promise<string[]>;
+  loadHiddenModList(): Promise<string[]>;
+  addModIndexDB(name: string, modBase64String: string | Uint8Array): Promise<void>;
+  removeModIndexDB(name: string): Promise<void>;
+  checkModZipFileIndexDB(modBase64String: string | Uint8Array): Promise<string | ModBootJson>;
+  getLog(): LogWrapper;
+} //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/SC2DataInfoCache.d.ts
+//#region remote/BeforeSC2/SC2DataInfoCache.d.ts
+interface StyleTextFileItem {
+  id: number;
+  name: string;
+  content: string;
+}
+interface ScriptTextFileItem {
+  id: number;
+  name: string;
+  content: string;
+}
+interface PassageDataItem {
+  id: number;
+  name: string;
+  tags: string[];
+  content: string;
+  position?: string;
+  size?: string;
+}
+declare class CacheRecord<T extends {
+  name: string;
+  content: string;
+}> {
+  log: LogWrapper;
+  dataSource: string;
+  cacheRecordName: string;
+  needBuildNoPathCache: boolean;
+  constructor(log: LogWrapper, dataSource: string, cacheRecordName: string, needBuildNoPathCache?: boolean);
+  getNoPathNameFromString(s: string): string;
+  noPathCache?: Map<string, string[]>;
+  buildNoPathCache(): void;
+  destroy(): void;
+  clean(): void;
+  items: T[];
+  fillMap(): void;
+  back2Array(): void;
+  map: Map<string, T>;
+  noName: T[];
+  replaceMerge(c: CacheRecord<T>, noWarnning?: boolean): void;
+  concatMerge(c: CacheRecord<T>): void;
+  getByNameWithNoPath(s: string): T | undefined;
+  getByNameWithOrWithoutPath(s: string): T | undefined;
+}
+declare class SC2DataInfo {
+  log: LogWrapper;
+  dataSource: string;
+  styleFileItems: CacheRecord<StyleTextFileItem>;
+  scriptFileItems: CacheRecord<ScriptTextFileItem>;
+  passageDataItems: CacheRecord<PassageDataItem>;
+  constructor(log: LogWrapper, dataSource: string);
+  clean(): void;
+  destroy(): void;
+}
+declare class SC2DataInfoCache extends SC2DataInfo {
+  log: LogWrapper;
+  dataSource: string;
+  scriptNode: HTMLScriptElement[];
+  styleNode: HTMLStyleElement[];
+  passageDataNodes: HTMLElement[];
+  cloneSC2DataInfo(): SC2DataInfo;
+  destroy(): void;
+  constructor(log: LogWrapper, dataSource: string, scriptNode: HTMLScriptElement[], styleNode: HTMLStyleElement[], passageDataNodes: HTMLElement[]);
+} //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/SimulateMerge.d.ts
+//#region remote/BeforeSC2/SimulateMerge.d.ts
+interface SimulateMergeResultItem {
+  ok: Set<string>;
+  conflict: Set<string>;
+}
+interface SimulateMergeResult {
+  styleFileItems: SimulateMergeResultItem;
+  scriptFileItems: SimulateMergeResultItem;
+  passageDataItems: SimulateMergeResultItem;
+  dataSource: string;
+}
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/LanguageManager.d.ts
+//#region remote/BeforeSC2/LanguageManager.d.ts
+declare const MainLanguageTypeEnum: readonly ["en", "zh"];
+declare class LanguageManager {
+  thisWin: Window;
+  gSC2DataManager: SC2DataManager;
+  private logger;
+  constructor(thisWin: Window, gSC2DataManager: SC2DataManager);
+  /**
+   * https://developer.mozilla.org/zh-CN/docs/Web/API/Navigator/language
+   * https://www.rfc-editor.org/rfc/bcp/bcp47.txt
+   * https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes
+   *
+   * @return https://stackoverflow.com/questions/5580876/navigator-language-list-of-all-languages
+   */
+  getLanguage(): string;
+  mainLanguage: typeof MainLanguageTypeEnum[number];
+} //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/SemVer/InfiniteSemVer.d.ts
+//#region remote/BeforeSC2/SemVer/InfiniteSemVer.d.ts
+declare const BoundaryOperatorList: readonly [">=", "<=", ">", "<", "=", "^", undefined];
+type BoundaryOperator = typeof BoundaryOperatorList[number];
+type VersionBoundary = {
+  version: InfiniteSemVer;
+  operator: BoundaryOperator;
+};
+type VersionRange = VersionBoundarySet[];
+type VersionBoundarySet = {
+  lower?: VersionBoundary;
+  upper?: VersionBoundary;
+};
+type InfiniteSemVer = {
+  version: number[];
+  preRelease?: string | undefined;
+  buildMetadata?: string | undefined;
+};
+declare function parseInfiniteSemVer(versionStr: string): VersionBoundary;
+declare function parseVersionRange(rangeStr: string): VersionRange;
+declare function isWithinRange(version: InfiniteSemVer, range: VersionRange, ignorePostfix?: boolean): boolean;
+declare class SemVerToolsType {
+  parseRange: typeof parseVersionRange;
+  parseVersion: typeof parseInfiniteSemVer;
+  satisfies: typeof isWithinRange;
+} //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/IdbKeyValRef.d.ts
+//#region remote/BeforeSC2/IdbKeyValRef.d.ts
+declare class IdbRef {
+  get idb_openDB(): typeof openDB;
+  get idb_deleteDB(): typeof deleteDB;
+  get idbInstance(): typeof idbInstance;
+}
+declare class IdbKeyValRef {
+  get keyval_get(): typeof get;
+  get keyval_set(): typeof set;
+  get keyval_del(): typeof del;
+  get get(): typeof get;
+  get set(): typeof set;
+  get del(): typeof del;
+  get createStore(): typeof createStore;
+  get setMany(): typeof setMany;
+  get clear(): typeof clear;
+  get keys(): typeof keys;
+  get values(): typeof values;
+  get entries(): typeof entries;
+} //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/SugarCube2.d.ts
+//#region remote/BeforeSC2/SugarCube2.d.ts
+declare class Passage {
+  get className(): string;
+  get text(): string | any;
+  get title(): string | any;
+  description(): string | null;
+  processText(): string | null;
+  render(options): DocumentFragment;
+  static getExcerptFromNode(node, count): string;
+  static getExcerptFromText(node, count): string;
+}
+declare global {
+  interface SugarCube {
+    Passage: typeof Passage;
+  }
+} //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/WeakRefPool/WeakRefPool.d.ts
+declare class WeakPoolRef<T> {
+  constructor();
+  get deref(): T | undefined;
+}
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/Sc2EventTracer.d.ts
+//#region remote/BeforeSC2/Sc2EventTracer.d.ts
+interface Sc2EventTracerCallback {
+  whenSC2StoryReady?: () => any;
+  whenSC2PassageInit?: (passage: Passage) => any;
+  whenSC2PassageStart?: (passage: Passage, content: HTMLDivElement) => any;
+  whenSC2PassageRender?: (passage: Passage, content: HTMLDivElement) => any;
+  whenSC2PassageDisplay?: (passage: Passage, content: HTMLDivElement) => any;
+  whenSC2PassageEnd?: (passage: Passage, content: HTMLDivElement) => any;
+}
+declare class Sc2EventTracer {
+  thisWin: Window;
+  gSC2DataManager: SC2DataManager;
+  constructor(thisWin: Window, gSC2DataManager: SC2DataManager);
+  callback: Sc2EventTracerCallback[];
+  callbackLog: [string, WeakPoolRef<Sc2EventTracerCallback>, ...WeakPoolRef<any>[]][];
+  init(): void;
+  addCallback(cb: Sc2EventTracerCallback): void;
+} //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/AddonPlugin.d.ts
+//#region remote/BeforeSC2/AddonPlugin.d.ts
+type AddonPluginHookType = () => Promise<any>;
+interface AddonPluginHookPoint {
+  afterInit?: AddonPluginHookType;
+  afterInjectEarlyLoad?: AddonPluginHookType;
+  afterModLoad?: AddonPluginHookType;
+  afterEarlyLoad?: AddonPluginHookType;
+  afterRegisterMod2Addon?: AddonPluginHookType;
+  beforePatchModToGame?: AddonPluginHookType;
+  afterPatchModToGame?: AddonPluginHookType;
+  afterPreload?: AddonPluginHookType;
+}
+type AddonPluginHookPoint_K = keyof AddonPluginHookPoint;
+type AddonPluginHookPointWhenSC2 = {
+  whenSC2StoryReady?: () => Promise<any>;
+  whenSC2PassageInit?: (passage: Passage) => Promise<any>;
+  whenSC2PassageStart?: (passage: Passage, content: HTMLDivElement) => Promise<any>;
+  whenSC2PassageRender?: (passage: Passage, content: HTMLDivElement) => Promise<any>;
+  whenSC2PassageDisplay?: (passage: Passage, content: HTMLDivElement) => Promise<any>;
+  whenSC2PassageEnd?: (passage: Passage, content: HTMLDivElement) => Promise<any>;
+};
+type AddonPluginHookPointWhenSC2_T = AddonPluginHookPointWhenSC2;
+type AddonPluginHookPointWhenSC2_K = keyof AddonPluginHookPointWhenSC2_T;
+type AddonPluginHookPointExOptional = {
+  /**
+   * registerMod() will be called when export debug data, this is a chance to export addon data for debug, like when addon change data in memory
+   *
+   * registerMod() 会在导出 debug data 时被调用，这是导出 addon 数据的机会，比如当 addon 在内存中改变了数据。
+   * 举个例子，衣服扩展框架可以收集所有衣服mod的数据，统一在文件或内存中修改衣服数据，如果是在文件中修改那么会被默认导出，但如果是在内存中修改，则最好使用这个 hook 来导出数据以便 debug
+   *
+   * @optional
+   * @param zip the zip file to storage debug data
+   * @return   return the same zip file or a new zip file, recommend return the same zip file
+   */
+  exportDataZip?: (zip: JSZip) => Promise<JSZip>;
+};
+type AddonPluginHookPointExMustImplement = {
+  /**
+   * registerMod() will be called when mod loaded and that mod require this addon, addon can read info from mod and do something
+   *
+   * registerMod() 会在 mod 加载完毕并且 mod 需要这个 addon 时被调用，addon 可以从 mod 读取信息并做一些事情。
+   * 举个例子，衣服扩展框架可以在这里读取衣服mod的数据，然后统一修改衣服数据，这样就可以避免多个不同的衣服mod前后修改衣服数组导致意外损坏衣服数组的数据。
+   * @mustImplement
+   * @param addonName the mod require this addon
+   * @param mod       the mod info
+   * @param modZip    the mod zip file reader
+   */
+  registerMod: (addonName: string, mod: ModInfo, modZip: ModZipReader) => Promise<any>;
+};
+/**
+ * AddonPluginHookPointEx is a interface for addon plugin to implement API Hook,
+ * addon plugin can implement any hook, but must implement registerMod(),
+ * addon can impl more API in there, to let mod call it to get more function.
+ *
+ * AddonPluginHookPointEx 是 addon plugin 用来实现 API Hook 的接口，
+ * addon plugin 可以实现任何 hook，但是必须实现 registerMod()，
+ * addon 可以在里面实现更多 API，让 mod 调用它来获得更多功能。
+ */
+interface AddonPluginHookPointEx extends AddonPluginHookPoint, AddonPluginHookPointExOptional, AddonPluginHookPointExMustImplement, AddonPluginHookPointWhenSC2 {}
+declare class AddonPluginManager implements Sc2EventTracerCallback {
+  gSC2DataManager: SC2DataManager;
+  gModLoadController: ModLoadController;
+  private addonPluginTable;
+  private log;
+  private passageTracer;
+  private sc2EventTracer;
+  constructor(gSC2DataManager: SC2DataManager, gModLoadController: ModLoadController);
+  /**
+   * inner use
+   */
+  whenSC2StoryReady(): Promise<any>;
+  /**
+   * inner use
+   */
+  whenSC2PassageInit(passage: Passage): Promise<any>;
+  /**
+   * inner use
+   */
+  whenSC2PassageStart(passage: Passage, content: HTMLDivElement): Promise<any>;
+  /**
+   * inner use
+   */
+  whenSC2PassageRender(passage: Passage, content: HTMLDivElement): Promise<any>;
+  /**
+   * inner use
+   */
+  whenSC2PassageDisplay(passage: Passage, content: HTMLDivElement): Promise<any>;
+  /**
+   * inner use
+   */
+  whenSC2PassageEnd(passage: Passage, content: HTMLDivElement): Promise<any>;
+  /**
+   * call by ModLoader (inner use)
+   *
+   * register a mod to addon plugin, after all mod loaded and after EarlyLoad executed.
+   *
+   * @param mod
+   * @param modZip
+   */
+  registerMod2Addon(mod: ModInfo, modZip: ModZipReader): Promise<void>;
+  /**
+   * call by ModLoaderGui (inner use)
+   * @param zip
+   */
+  exportDataZip(zip: JSZip): Promise<JSZip>;
+  /**
+   * call by ModLoader (inner use)
+   * @param hook
+   */
+  triggerHook(hook: AddonPluginHookPoint_K): Promise<void>;
+  /**
+   * call by ModLoader (inner use)
+   */
+  triggerHookWhenSC2<K extends AddonPluginHookPointWhenSC2_K>(hook: K, ...params: Parameters<NonNullable<AddonPluginHookPointWhenSC2_T[K]>>): Promise<void>;
+  /**
+   * check if a addon plugin is duplicate
+   * @param modName
+   * @param addonName
+   */
+  checkDuplicate(modName: string, addonName: string): boolean;
+  /**
+   * register a addon plugin, call by addon plugin,
+   * this call must be done when InjectEarlyLoad.
+   *
+   * 注册一个 addon plugin，由 addon plugin 调用，必须在 InjectEarlyLoad 时调用此函数注册 Addon。
+   * @param modName    addon plugin's mod name
+   * @param addonName  addon plugin's name
+   * @param hookPoint  addon plugin's hook point
+   */
+  registerAddonPlugin(modName: string, addonName: string, hookPoint: AddonPluginHookPointEx): void;
+  /**
+   * get a addon plugin, call by mod
+   *
+   * 获取一个 addon plugin，由 mod 调用。 mod 可以读取 addon plugin 的 hookPoint 来调用 addon plugin 的 API
+   * @param modName    addon plugin's mod name
+   * @param addonName  addon plugin's name
+   */
+  getAddonPlugin(modName: string, addonName: string): AddonPluginHookPointEx | undefined;
+} //#endregion
+//#endregion
+//#region ../../node_modules/.pnpm/@types+lodash@4.17.23/node_modules/@types/lodash/index.d.ts
+declare const _: _.LoDashStatic;
+declare namespace _ {
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface -- (This will be augmented)
+  interface LoDashStatic {}
+}
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/Utils.d.ts
+//#region remote/BeforeSC2/Utils.d.ts
+declare class ModUtils {
+  pSC2DataManager: SC2DataManager;
+  thisWin: Window;
+  get version(): string;
+  constructor(pSC2DataManager: SC2DataManager, thisWin: Window);
+  getThisWindow(): Window;
+  /**
+   * 获取所有mod的名字
+   * 以mod加载顺序为序
+   */
+  getModListName(): string[];
+  getModListNameNoAlias(): string[];
+  getAnyModByNameNoAlias(name: string): ModInfo | undefined;
+  /**
+   * 获取指定mod的信息
+   * @param name ModName
+   * @return ModInfo | undefined
+   */
+  getMod(name: string): ModInfo | undefined;
+  getModAndFromInfo(name: string): undefined | {
+    name: string;
+    mod: ModInfo;
+    from: ModLoadFromSourceType;
+  };
+  getAllModInfoByFromType(from: ModLoadFromSourceType): {
+    name: string;
+    mod: ModInfo;
+    from: ModLoadFromSourceType;
+  }[];
+  /**
+   * 获取指定mod的Zip
+   * @param modName ModName
+   * @return ModZipReader | undefined
+   */
+  getModZip(modName: string): ModZipReader | undefined;
+  /**
+   * 获取指定Passage的信息
+   * @param name PassageName
+   * @return PassageDataItem | undefined
+   */
+  getPassageData(name: string): PassageDataItem | undefined;
+  /**
+   * 获取所有Passage的信息
+   * @return PassageDataItem[]
+   */
+  getAllPassageData(): PassageDataItem[];
+  /**
+   * 获取当前最新的SC2DataInfo，其中存储了所有SC2引擎的数据，包括js/css/passage
+   * @return SC2DataInfo
+   */
+  createNewSC2DataInfoFromNow(): SC2DataInfoCache;
+  /**
+   * 批量更新passage数据，如果存在则覆盖，如果不存在则创建
+   * @param pd 需要更新的passage列表
+   * @param replaceForce 强制覆盖而不提示警告
+   */
+  updatePassageDataMany(pd: PassageDataItem[], replaceForce?: boolean): void;
+  replaceFollowSC2DataInfo(newSC2Data: SC2DataInfo, oldSC2DataCache: SC2DataInfoCache): void;
+  /**
+   * 更新passage数据，如果存在则覆盖，如果不存在则创建
+   * @param name passageName
+   * @param content passageContent
+   * @param tags passageTags [] OR ['widget']
+   * @param pid passagePid 默认是 0 ， 如果不是故意覆盖已有的passage那么就填 0 即可
+   * @deprecated use `CodeExample/how-to-modify-sc2data.ts` instead
+   */
+  updatePassageData(name: string, content: string, tags?: string[], pid?: undefined | number): void;
+  /**
+   * 从一个twee文件中分离出多个passage，工具函数
+   * @param fileString 文件内容字符串
+   */
+  splitPassageFromTweeFile(fileString: string): Twee2PassageR[];
+  /**
+   * 获取mod冲突及覆盖的计算结果，可获知mod之间是否有互相覆盖的情况，如果没有mod则返回空数组
+   *
+   * 注意，此处只能获取模拟计算mod添加的文件互相的冲突关系，且不包含mod的js动态修改的内容，实际结果可能与这里不一致，
+   *
+   * @return { mod: SC2DataInfo, result: SimulateMergeResult }[]
+   *              mod    mod添加的内容，其中 dataSource 是 modName
+   *              result 覆盖结果，其中的 ResultItem[conflict] (Set<string>) 就是互相覆盖的部分的名字（passageName或js/css文件名）
+   */
+  getModConflictInfo(): {
+    mod: SC2DataInfo;
+    result: SimulateMergeResult;
+  }[];
+  /**
+   * 将字符串对正则表达式转义，用于直接将字符串用在正则表达式匹配前的消毒处理
+   * @param pattern   需要转义的字符串
+   * @return string   转义后的字符串
+   */
+  escapedPatternString(pattern: string): string;
+  /**
+   * 尝试在指定位置附近替换字符串
+   * @param content       原始字符串
+   * @param searchString  需要查找的字符串
+   * @param replaceString     需要替换的字符串
+   * @param positionHint      查找的位置
+   * @param tolerance1        第一阶快速查找容差 见 @ref tryStringSearch
+   * @param tolerance2Negative    第二阶正则查找（负方向）容差 见 @ref tryStringSearch
+   * @param tolerance2Positive    第二阶正则查找（正方向）容差 见 @ref tryStringSearch
+   * @return  string  替换后的字符串
+   */
+  tryStringReplace(content: string, searchString: string, replaceString: string, positionHint: number, tolerance1?: number, tolerance2Negative?: number, tolerance2Positive?: number): string;
+  /**
+   * 尝试在指定位置附近查找字符串
+   * @param content  原始字符串
+   * @param searchString  需要查找的字符串
+   * @param positionHint  查找的位置
+   * @param tolerance1    第一阶快速查找容差，（常数字符串比对），如果为0则不使用。此方法可在正负tolerance1个位置范围下查找
+   * @param tolerance2Negative    第二阶正则查找（负方向）容差，（正则字符串比对）。
+   * @param tolerance2Positive    第二阶正则查找（正方向）容差，（正则字符串比对）。如果正负都为0则不使用。此方法可在正负tolerance2Negative个位置范围下查找。
+   * @return  number  查找到的位置，如果没有找到则返回undefined
+   */
+  tryStringSearch(content: string, searchString: string, positionHint: number, tolerance1?: number, tolerance2Negative?: number, tolerance2Positive?: number): number | undefined;
+  /**
+   * 在指定位置插入字符串
+   * @param content  原始字符串
+   * @param insertString  需要插入的字符串
+   * @param position  插入的位置
+   * @return string   插入后的字符串
+   */
+  insertStringInPosition(content: string, insertString: string, position: number): string;
+  getLodash(): _.LoDashStatic;
+  getModLoadController(): ModLoadController;
+  getModLoader(): ModLoader;
+  getAddonPluginManager(): AddonPluginManager;
+  getLogger(): LogWrapper;
+  lazyRegisterNewModZipData(data: ArgumentTypes<JSZipLikeReadOnlyInterface['loadAsync']>[0], options?: any): Promise<boolean>;
+  parseModPack(modPackBuffer: Uint8Array, password?: string | undefined): Promise<ModMeta>;
+  getNowRunningModName(): string | undefined;
+  getSemVerTools(): SemVerToolsType;
+  getModZipReaderStaticClassRef: () => {
+    LocalStorageLoader: typeof LocalStorageLoader;
+    IndexDBLoader: typeof IndexDBLoader;
+    LocalLoader: typeof LocalLoader;
+    RemoteLoader: typeof RemoteLoader;
+  };
+  getImage(imagePath: string): Promise<string | undefined>;
+  getLanguageManager(): LanguageManager;
+  getNowMainLanguage(): 'en' | 'zh' | string;
+  getIdbKeyValRef(): IdbKeyValRef;
+  getIdbRef(): IdbRef;
+  /**
+   *
+   * const modAddonPluginsParams = window.modUtils.getAddonParamsFromModInfo(modInfo, 'BeautySelectorAddon', 'BeautySelectorAddon');
+   *
+   * @param modInfo   params 2 of registerMod callback
+   * @param addonPluginModName params 1 of registerAddonPlugin
+   * @param addonName  params 2 of registerAddonPlugin
+   */
+  getAddonParamsFromModInfo<P>(modInfo: ModInfo, addonPluginModName: string, addonName: string): P | undefined;
+  getAddonParamsFromModInfo(modInfo: ModInfo, addonPluginModName: string, addonName: string): ModBootJsonAddonPlugin['params'] | undefined;
+}
+type ArgumentTypes<F extends Function> = F extends ((...args: infer A) => any) ? A : never; //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/DependenceChecker.d.ts
+//#region remote/BeforeSC2/DependenceChecker.d.ts
+declare class InfiniteSemVerApi {
+  parseRange: typeof parseVersionRange;
+  parseVersion: typeof parseInfiniteSemVer;
+  satisfies: typeof isWithinRange;
+}
+declare class DependenceChecker {
+  gSC2DataManager: SC2DataManager;
+  gModUtils: ModUtils;
+  log: LogWrapper;
+  constructor(gSC2DataManager: SC2DataManager, gModUtils: ModUtils);
+  getInfiniteSemVerApi(): InfiniteSemVerApi;
+  /**
+   * 检查指定mod是否满足指定mod集合作为前序mod的依赖关系
+   *
+   * check if the mod satisfies the dependencies of the specified mod set as the previous mod
+   *
+   * @param {ModInfo} mod - The mod to check for dependencies.
+   * @param {ModOrderContainer[]} modCaches - An array of mod order containers.
+   * @return {boolean} - Returns true if the mod satisfies its dependencies, false otherwise.
+   */
+  checkFor(mod: ModInfo, modCaches: ModOrderContainer[]): boolean;
+  /**
+   * 检查整个加载完毕的mod列表是否满足依赖约束
+   *
+   * Checks the dependencies of the mod order and verifies if they are satisfied.
+   *
+   * @return {boolean} - Returns true if all dependencies are satisfied, otherwise returns false.
+   */
+  check(): boolean;
+  /**
+   * this called by mod `CheckGameVersion`
+   * because the game version only can get after game loaded
+   * @param gameVersion
+   */
+  checkGameVersion(gameVersion: string): boolean;
+} //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/PassageTracer.d.ts
+//#region remote/BeforeSC2/PassageTracer.d.ts
+type whenPassageCome = (passageName: string) => void;
+declare class PassageTracer {
+  thisWin: Window;
+  constructor(thisWin: Window);
+  init(): void;
+  private whenPassageComeCallback;
+  addCallback(cb: whenPassageCome): void;
+  newPassageCome(): void;
+} //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/SC2JsEvalContext.d.ts
+//#region remote/BeforeSC2/SC2JsEvalContext.d.ts
+interface SC2JsEvalContextInfo {
+  contextThis: object;
+}
+declare class SC2JsEvalContext {
+  gSC2DataManager: SC2DataManager;
+  constructor(gSC2DataManager: SC2DataManager);
+  contextSet: SC2JsEvalContextInfo[];
+  /**
+   * call by SugarCube2 `Story.storyInit()`
+   */
+  newContext(id: string): object;
+} //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/JsPreloader.d.ts
+//#region remote/BeforeSC2/JsPreloader.d.ts
+declare class StackLike<T> {
+  private _data;
+  push(v: T): void;
+  pop(): T | undefined;
+  peek(): T | undefined;
+  get length(): number;
+  get data(): T[];
+  get empty(): boolean;
+  clear(): void;
+}
+declare class JsPreloader {
+  pSC2DataManager: SC2DataManager;
+  modUtils: ModUtils;
+  thisWin: Window;
+  logger: LogWrapper;
+  constructor(pSC2DataManager: SC2DataManager, modUtils: ModUtils, thisWin: Window);
+  startLoadCalled: boolean;
+  startLoad(): Promise<any>;
+  runningMod: StackLike<string>;
+  JsRunner(content: string, name: string, modName: string, stage: string, pSC2DataManager: SC2DataManager, thisWin: Window, logger: LogWrapper): Promise<any>;
+} //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/HtmlTagSrcHook.d.ts
+//#region remote/BeforeSC2/HtmlTagSrcHook.d.ts
+type HtmlTagSrcHookType = (el: HTMLImageElement | HTMLElement, mlSrc: string, field: string) => Promise<boolean>;
+type HtmlTagSrcReturnModeHookType = (mlSrc: string) => Promise<[boolean, string]>;
+type HtmlTagSrcHookCheckModType = (mlSrc: string) => boolean | undefined;
+/**
+ * this class replace html image tag src/href attribute ,
+ * redirect the image request to a mod like `ImgLoaderHooker` to load the image.
+ */
+declare class HtmlTagSrcHook {
+  gSC2DataManager: SC2DataManager;
+  logger: LogWrapper;
+  constructor(gSC2DataManager: SC2DataManager);
+  private hookTable;
+  private hookReturnModeTable;
+  private hookCheckExistTable;
+  addHook(hookKey: string, hook: HtmlTagSrcHookType): void;
+  addReturnModeHook(hookKey: string, hook: HtmlTagSrcReturnModeHookType): void;
+  addCheckExistHook(hookKey: string, hook: HtmlTagSrcHookCheckModType): void;
+  /**
+   * check image exist
+   *
+   * @param src
+   * @return true: exist ; false: not exist ; undefined: not exist but not sure (maybe exist but now not find.);
+   */
+  checkImageExist(src: string): boolean | undefined;
+  /**
+   * get image from mod
+   * @param src  image path
+   * @return image base64 string
+   */
+  requestImageBySrc(src: string): Promise<string | undefined>;
+  /**
+   * 归一化路径为相对路径格式
+   * @param path 待归一化的路径
+   * @returns 归一化后的相对路径（去除前导 / 和 ./）
+   */
+  normalizePath(path: string): string;
+} //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/SC2ApiRef.d.ts
+interface SC2Passage {
+  title: string;
+  tags: string[];
+  element: any | undefined;
+  domId: string;
+  classes: string[];
+  readonly className: string;
+  readonly text: string;
+  description: () => string;
+  processText: () => string;
+  render: (options: any) => DocumentFragment;
+}
+declare namespace SC2Passage {
+  function getExcerptFromNode(node: Node, count: string): string;
+  function getExcerptFromText(text: string, count: string): string;
+}
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/WikifyTracer.d.ts
+//#region remote/BeforeSC2/WikifyTracer.d.ts
+interface WikifyTracerCallback {
+  /**
+   * 可以修改输入文本内容
+   * @param text              原始文本内容
+   * @param passageTitle      passage标题
+   * @param passageObj        passage对象
+   * @return string           返回修改后的文本内容
+   */
+  beforePassage?: (text: string, passageTitle: string, passageObj: SC2Passage) => string;
+  /**
+   * 可以修改输出后的html树，只会在passage结束后调用
+   * @param text          原始文本内容
+   * @param passageTitle  passage标题
+   * @param passageObj    passage对象
+   * @param node          最终输出的html树
+   */
+  afterPassage?: (text: string, passageTitle: string, passageObj: SC2Passage, node: DocumentFragment) => void;
+  beforeWikify?: (text: string) => string;
+  /**
+   * 可以修改输出后的html树，会在每一次wikify后调用，包括passage以及每个text节点
+   * @param text      原始文本内容
+   * @param node      最终输出的html树
+   */
+  afterWikify?: (text: string, node: DocumentFragment) => void;
+  /**
+   * 可以修改输入文本内容
+   * @param text              原始文本内容
+   * @param widgetName        widget名称
+   * @param passageTitle      passage标题
+   * @param passageObj        passage对象
+   */
+  beforeWidget?: (text: string, widgetName: string, passageTitle?: string, passageObj?: SC2Passage) => string;
+  /**
+   * 可以修改输出后的html树，会在每一次widget后调用
+   * @param text              原始文本内容
+   * @param widgetName        widget名称
+   * @param passageTitle      passage标题
+   * @param passageObj        passage对象
+   * @param node              最终输出的html树
+   */
+  afterWidget?: (text: string, widgetName: string, passageTitle: string | undefined, passageObj: SC2Passage | undefined, node: DocumentFragment) => void;
+}
+declare class WikifyTracer {
+  gSC2DataManager: SC2DataManager;
+  private logger;
+  constructor(gSC2DataManager: SC2DataManager);
+  private callbackTable;
+  private callbackOrder;
+  private callbackCount;
+  addCallback(key: string, callback: WikifyTracerCallback): void;
+  beforePassage(text: string, passageTitle: string, passageObj: SC2Passage): string;
+  afterPassage(text: string, passageTitle: string, passageObj: SC2Passage, node: DocumentFragment): void;
+  beforeWikify(text: string): string;
+  afterWikify(text: string, node: DocumentFragment): void;
+  beforeWidget(text: string, widgetName: string, passageTitle?: string, passageObj?: SC2Passage): string;
+  afterWidget(text: string, widgetName: string, passageTitle: string | undefined, passageObj: SC2Passage | undefined, node: DocumentFragment): void;
+} //#endregion
+//#endregion
+//#region ../sugarcube-2-ModLoader/type-dist/SC2DataManager.d.ts
+//#region remote/BeforeSC2/SC2DataManager.d.ts
+declare class SC2DataManager {
+  thisWin: Window;
+  constructor(thisWin: Window);
+  private modUtils;
+  getModUtils(): any;
+  private modLoadController;
+  getModLoadController(): ModLoadController;
+  get rootNode(): Element;
+  get styleNode(): HTMLCollectionOf<HTMLStyleElement>;
+  get scriptNode(): HTMLCollectionOf<HTMLScriptElement>;
+  get passageDataNodeList(): Element[];
+  checkSC2Data(): boolean;
+  createNewSC2DataInfoFromNow(): SC2DataInfo;
+  /**
+   * 用于缓存原始的没有经过任何修改的原始的原版SC2Data
+   * never set it to undefined OR overwrite it
+   * @private
+   */
+  private originSC2DataInfoCache?;
+  earlyResetSC2DataInfoCache(): void;
+  cleanAllCacheAfterModLoadEnd(): void;
+  initSC2DataInfoCache(): void;
+  /**
+   * 读取原始的没有被修改过的SC2Data，
+   * 对于mod来说，如无必要不要使用这里的数据，
+   * 特别是合并时不要使用此处的数据作为数据源，而是使用 getSC2DataInfoAfterPatch()，否则会覆盖之前的mod的修改，导致之前的修改无效
+   */
+  getSC2DataInfoCache(): SC2DataInfoCache;
+  private modLoader?;
+  getModLoader(): ModLoader;
+  private passageTracer;
+  getPassageTracer(): PassageTracer;
+  private languageManager;
+  getLanguageManager(): LanguageManager;
+  private sc2EventTracer;
+  getSc2EventTracer(): Sc2EventTracer;
+  private jsPreloader;
+  getJsPreloader(): JsPreloader;
+  private addonPluginManager;
+  getAddonPluginManager(): AddonPluginManager;
+  private sC2JsEvalContext;
+  getSC2JsEvalContext(): SC2JsEvalContext;
+  private dependenceChecker;
+  getDependenceChecker(): DependenceChecker;
+  private htmlTagSrcHook;
+  getHtmlTagSrcHook(): HtmlTagSrcHook;
+  private wikifyTracer;
+  getWikifyTracer(): WikifyTracer;
+  private conflictResult?;
+  startInitOk: boolean;
+  startInit(): Promise<void>;
+  getConflictResult(): {
+    mod: SC2DataInfo;
+    result: SimulateMergeResult;
+  }[] | undefined;
+  private cSC2DataInfoAfterPatchCache?;
+  /**
+   * 获取最新的SC2Data，此处获得的是之前的mod修改后的最新的SC2Data数据，
+   * 此处使用了缓存，如果修改了SC2Data，请调用 flushAfterPatchCache() 来清除缓存，重新从html中读取最新的SC2Data
+   */
+  getSC2DataInfoAfterPatch(): SC2DataInfoCache;
+  flushAfterPatchCache(): void;
+  applyReplacePatcher(modSC2DataInfoCache: SC2DataInfo): Promise<void>;
+  patchModToGame(): Promise<void>;
+  makePassageNode(T: PassageDataItem): HTMLElement;
+  makeStyleNode(sc: SC2DataInfo): HTMLStyleElement;
+  makeScriptNode(sc: SC2DataInfo): HTMLScriptElement;
+  rePlacePassage(toRemovePassageDataNodeList: Element[], toAddPassageDataNodeList: Element[]): void;
+} //#endregion
+//#endregion
+export { LogWrapper as a, LifeTimeCircleHook as i, ModUtils as n, ModInfo as o, AddonPluginHookPointEx as r, ModZipReader as s, SC2DataManager as t };