@scml/sc2-modloader 1.0.0

package/type-dist/ModZipReader.d.ts

@@ -0,0 +1,179 @@
+import { JSZipLikeReadOnlyInterface } from "./JSZipLikeReadOnlyInterface.js";
+import { LogWrapper, ModLoadControllerCallback } from "./ModLoadController.js";
+import { ModBootJson, ModInfo } from "./ModLoader.js";
+import * as xxhash_wasm0 from "xxhash-wasm";
+import { UseStore } from "idb-keyval";
+
+//#region remote/BeforeSC2/ModZipReader.d.ts
+declare function getXxHash(): Promise<xxhash_wasm0.XXHashAPI>;
+interface Twee2PassageR {
+  name: string;
+  tags: string[];
+  content: string;
+}
+declare function Twee2Passage2(s: string): Twee2PassageR[];
+declare function Twee2Passage(s: string): Twee2PassageR[];
+declare function imgWrapBase64Url(fileName: string, base64: string): string;
+declare function blobToBase64(blob: Blob): Promise<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 Base64ZipStringLoader extends LoaderBase {
+  modLoadControllerCallback: ModLoadControllerCallback;
+  loaderKeyConfig: LoaderKeyConfig;
+  base64ZipStringList: string[];
+  constructor(modLoadControllerCallback: ModLoadControllerCallback, loaderKeyConfig: LoaderKeyConfig, base64ZipStringList: string[]);
+  load(): Promise<boolean>;
+}
+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 const getModZipReaderStaticClassRef: () => {
+  LocalStorageLoader: typeof LocalStorageLoader;
+  IndexDBLoader: typeof IndexDBLoader;
+  LocalLoader: typeof LocalLoader;
+  RemoteLoader: typeof RemoteLoader;
+};
+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
+export { Base64ZipStringLoader, IndexDBLoader, LazyLoader, LoaderBase, LoaderKeyConfig, LocalLoader, LocalStorageLoader, ModZipReader, ModZipReaderHash, RemoteLoader, Twee2Passage, Twee2Passage2, Twee2PassageR, blobToBase64, getModZipReaderStaticClassRef, getXxHash, imgWrapBase64Url };

package/type-dist/PassageTracer.d.ts

@@ -0,0 +1,12 @@
+//#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
+export { PassageTracer };

package/type-dist/ReplacePatcher.d.ts

@@ -0,0 +1,33 @@
+import { LogWrapper } from "./ModLoadController.js";
+import { SC2DataInfo } from "./SC2DataInfoCache.js";
+
+//#region remote/BeforeSC2/ReplacePatcher.d.ts
+interface PatchInfo {
+  js?: PatchInfoItem[];
+  css?: PatchInfoItem[];
+  twee?: PatchInfoItem[];
+}
+interface PatchInfoItem {
+  from: string;
+  to: string;
+  fileName: string;
+  passageName?: string;
+}
+declare function checkPatchInfo(o: any): o is PatchInfo;
+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
+export { PatchInfo, PatchInfoItem, ReplacePatcher, checkPatchInfo };

package/type-dist/SC2ApiRef.d.ts

@@ -0,0 +1,136 @@
+import { SC2DataManager } from "./SC2DataManager.js";
+
+//#region remote/BeforeSC2/SC2ApiRef.d.ts
+type throwErrorType = (place: Node, message: string, source?: string) => boolean;
+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;
+}
+interface SC2Story {
+  load: () => void;
+  init: () => void;
+  readonly title: string;
+  readonly domId: string;
+  readonly ifId: string;
+  add: (passage: SC2Passage) => boolean;
+  has: (title: string) => boolean;
+  get: CallableFunction;
+  getAllInit: () => any[];
+  getAllRegular: () => any;
+  getAllScript: () => any[];
+  getAllStylesheet: () => any[];
+  getAllWidget: () => any[];
+  lookup: CallableFunction;
+  lookupWith: CallableFunction;
+}
+interface SC2MacroContext {
+  self: SC2MacroContext;
+  parent: SC2MacroContext;
+  passageObj: SC2Passage;
+  name: string;
+  displayName: string;
+  args: string[];
+  payload: string | any;
+  source: string;
+  parser: any;
+  readonly output: string;
+  readonly shadows: any[];
+  readonly shadowView: any[];
+  readonly debugView: any;
+  contextHas: (filter: any) => boolean;
+  contextSelect: (filter: any) => SC2MacroContext | undefined;
+  contextSelectAll: () => SC2MacroContext[];
+  addShadow: (...names: string[]) => void;
+  createShadowWrapper: (callback: Function, doneCallback: Function, startCallback: Function) => ((...args: any[]) => void);
+  createDebugView: (name: string, title: string) => any;
+  removeDebugView: () => void;
+  error: (message: string, source?: string) => ReturnType<throwErrorType>;
+}
+interface SC2MacroObject {
+  isWidget: boolean | undefined;
+  tags: string[] | undefined;
+  handler: (this: SC2MacroContext) => any;
+}
+interface SC2MacroTags {
+  register: (parent: string, bodyTags: string | string[]) => void;
+  unregister: (parent: string) => void;
+  has: (parent: string) => boolean;
+  get: (parent: string) => string[];
+}
+interface SC2Macro {
+  add: (name: string | string[], def: SC2MacroContext) => void;
+  delete: (name: string | string[]) => void;
+  isEmpty: () => boolean;
+  has: (name: string) => boolean;
+  get: (name: string) => undefined | SC2MacroContext;
+  init: (handler: string) => void;
+  tags: SC2MacroTags;
+}
+interface SC2Scripting {
+  parse: (rawCodeString: string) => string;
+  evalJavaScript: (code: string, output?: any, data?: any) => string;
+  evalTwineScript: (code: string, output?: any, data?: any) => string;
+}
+interface SC2Wikifier {
+  passageObj: SC2Passage;
+  source: string;
+  options: any;
+  nextMatch: number;
+  output: any;
+  subWikify: (output: Node, terminator: string | RegExp, options: any, passageObj: SC2Passage) => void;
+  outputText: (destination: Node, startPos: number, endPos: number) => void;
+  _callDepth: number;
+  _passageTitleLast: string;
+  _passageObjLast: SC2Passage | undefined;
+  _lastPassageQ: {
+    passageObj: SC2Passage;
+    passageTitle: string;
+  }[];
+}
+declare namespace SC2Wikifier {
+  function lastPassageQPush(passageObj: SC2Passage, passageTitle: string): number;
+  function lastPassageQPop(): number;
+  function lastPassageQSize(): number;
+  function lastPassageQFront(): [number, SC2Passage];
+  function lastPassageQBack(): [number, SC2Passage];
+  function getLastPossiblePassageTitle(): string;
+  function getPassageTitleLast(): string;
+  function getPassageObjLast(): SC2Passage;
+  function wikifyEval(text: string, passageObj?: SC2Passage, passageTitle?: string): DocumentFragment;
+  function createInternalLink(destination: DocumentFragment, passage: SC2Passage, text: string, callback: Function): DocumentFragment;
+  function createExternalLink(destination: DocumentFragment, url: string, text: string): DocumentFragment;
+  function isExternalLink(link: string): boolean;
+}
+interface SC2ApiType {
+  State: any;
+  Story: SC2Story;
+  Util: any;
+  Wikifier: SC2Wikifier;
+  Config: any;
+  Engine: any;
+  Macro: SC2Macro;
+  Scripting: SC2Scripting;
+  Setting: any;
+  Save: any;
+  Passage: SC2Passage;
+}
+declare class SC2ApiRef {
+  gSC2DataManager: SC2DataManager;
+  constructor(gSC2DataManager: SC2DataManager);
+  isInit: boolean;
+  init(): void;
+}
+//#endregion
+export { SC2ApiRef, SC2ApiType, SC2Macro, SC2MacroContext, SC2MacroObject, SC2MacroTags, SC2Passage, SC2Scripting, SC2Story, SC2Wikifier, throwErrorType };

package/type-dist/SC2DataInfoCache.d.ts

@@ -0,0 +1,67 @@
+import { LogWrapper } from "./ModLoadController.js";
+
+//#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
+export { CacheRecord, PassageDataItem, SC2DataInfo, SC2DataInfoCache, ScriptTextFileItem, StyleTextFileItem };

package/type-dist/SC2DataManager.d.ts

@@ -0,0 +1,86 @@
+import { SimulateMergeResult } from "./SimulateMerge.js";
+import { LanguageManager } from "./LanguageManager.js";
+import { DependenceChecker } from "./DependenceChecker.js";
+import { PassageTracer } from "./PassageTracer.js";
+import { Sc2EventTracer } from "./Sc2EventTracer.js";
+import { SC2JsEvalContext } from "./SC2JsEvalContext.js";
+import { JsPreloader } from "./JsPreloader.js";
+import { HtmlTagSrcHook } from "./HtmlTagSrcHook.js";
+import { WikifyTracer } from "./WikifyTracer.js";
+import { ModLoadController } from "./ModLoadController.js";
+import { PassageDataItem, SC2DataInfo, SC2DataInfoCache } from "./SC2DataInfoCache.js";
+import { ModLoader } from "./ModLoader.js";
+import { AddonPluginManager } from "./AddonPlugin.js";
+
+//#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
+export { SC2DataManager };

package/type-dist/SC2JsEvalContext.d.ts

@@ -0,0 +1,17 @@
+import { SC2DataManager } from "./SC2DataManager.js";
+
+//#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
+export { SC2JsEvalContext, SC2JsEvalContextInfo };

package/type-dist/Sc2EventTracer.d.ts

@@ -0,0 +1,24 @@
+import { Passage } from "./SugarCube2.js";
+import { WeakPoolRef } from "./WeakRefPool/WeakRefPool.js";
+import { SC2DataManager } from "./SC2DataManager.js";
+
+//#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
+export { Sc2EventTracer, Sc2EventTracerCallback };

package/type-dist/SemVer/InfiniteSemVer.d.ts

@@ -0,0 +1,32 @@
+//#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 compareString(a: string, b: string): number;
+declare function compareInfiniteVersions(a: InfiniteSemVer, b: InfiniteSemVer, ignorePostfix?: boolean): number;
+declare function parseVersionRange(rangeStr: string): VersionRange;
+declare function isWithinRange(version: InfiniteSemVer, range: VersionRange, ignorePostfix?: boolean): boolean;
+declare const parseRange: typeof parseVersionRange;
+declare const parseVersion: typeof parseInfiniteSemVer;
+declare const satisfies: typeof isWithinRange;
+declare class SemVerToolsType {
+  parseRange: typeof parseVersionRange;
+  parseVersion: typeof parseInfiniteSemVer;
+  satisfies: typeof isWithinRange;
+}
+//#endregion
+export { BoundaryOperator, BoundaryOperatorList, InfiniteSemVer, SemVerToolsType, VersionBoundary, VersionBoundarySet, VersionRange, compareInfiniteVersions, compareString, isWithinRange, parseInfiniteSemVer, parseRange, parseVersion, parseVersionRange, satisfies };

package/type-dist/SimulateMerge.d.ts

@@ -0,0 +1,17 @@
+import { SC2DataInfo } from "./SC2DataInfoCache.js";
+
+//#region remote/BeforeSC2/SimulateMerge.d.ts
+interface SimulateMergeResultItem {
+  ok: Set<string>;
+  conflict: Set<string>;
+}
+interface SimulateMergeResult {
+  styleFileItems: SimulateMergeResultItem;
+  scriptFileItems: SimulateMergeResultItem;
+  passageDataItems: SimulateMergeResultItem;
+  dataSource: string;
+}
+declare function simulateMergeStep(a: Set<string>, b: Set<string>): SimulateMergeResultItem;
+declare function simulateMergeSC2DataInfoCache(...ic: SC2DataInfo[]): SimulateMergeResult[];
+//#endregion
+export { SimulateMergeResult, SimulateMergeResultItem, simulateMergeSC2DataInfoCache, simulateMergeStep };

package/type-dist/SugarCube2.d.ts

@@ -0,0 +1,18 @@
+//#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
+export { Passage };

package/type-dist/Utils/LazyIteratorAdaptor.d.ts

@@ -0,0 +1,14 @@
+//#region remote/BeforeSC2/Utils/LazyIteratorAdaptor.d.ts
+declare class LazyIteratorAdaptor {
+  static find<T>(iterator: Iterator<T>, predicate: (value: T, index: number) => boolean): T | undefined;
+  static findIndex<T>(iterator: Iterator<T>, predicate: (value: T, index: number) => boolean): number;
+  static some<T>(iterator: Iterator<T>, predicate: (value: T, index: number) => boolean): boolean;
+  static every<T>(iterator: Iterator<T>, predicate: (value: T, index: number) => boolean): boolean;
+  static filter<T>(iterator: Iterator<T>, predicate: (value: T, index: number) => boolean): T[];
+  static filterLazy<T>(iterator: Iterator<T>, predicate: (value: T, index: number) => boolean): Generator<T>;
+  static map<T, U>(iterator: Iterator<T>, mapper: (value: T, index: number) => U): U[];
+  static mapLazy<T, U>(iterator: Iterator<T>, callback: (value: T, index: number) => U): Generator<U>;
+  static reduce<T, U>(iterator: Iterator<T>, reducer: (accumulator: U, value: T, index: number) => U, initialValue: U): U;
+}
+//#endregion
+export { LazyIteratorAdaptor };