ranuts 0.2.0-alpha.1 → 0.4.0-alpha.1

package/dist/src/utils/idb.d.ts

@@ -0,0 +1,218 @@
+/**
+ * @description: The uniform result shape of every IndexedDB operation. Every method
+ * resolves and rejects with this shape, so callers only need to check `error` rather than
+ * distinguishing "the request was never created" from "the request failed".
+ */
+export interface IDBResult<T = unknown> {
+    status: 'success' | 'error' | 'pending';
+    code: number;
+    data: T;
+    error: boolean;
+    message?: string;
+    progress?: number;
+}
+/**
+ * @description: Declarative schema for object stores. `openDataBase` creates the missing
+ * stores and indexes inside `onupgradeneeded` — **stores can only be created in a version
+ * upgrade transaction**, so they must be declared up front; createObjectStore cannot be
+ * called after the database is open.
+ */
+export interface IDBStoreSchema {
+    name: string;
+    options?: IDBObjectStoreParameters;
+    indexes?: Array<{
+        name: string;
+        keyPath: string | string[];
+        options?: IDBIndexParameters;
+    }>;
+}
+export interface WebDBOptions {
+    dbName: string;
+    version?: number;
+    /** Declarative store definitions: missing stores / indexes are created on upgrade (existing ones are skipped — idempotent) */
+    stores?: IDBStoreSchema[];
+    /** Escape hatch: migrations the schema cannot express (changing a keyPath, moving data) go here, called after `stores` are created */
+    upgrade?: (db: IDBDatabase, event: IDBVersionChangeEvent, transaction: IDBTransaction | null) => void;
+}
+/**
+ * @description: A Promise wrapper over IndexedDB. The native API is event-callback and
+ * transaction based — every read or write takes five steps (open → transaction →
+ * objectStore → request → onsuccess/onerror); this class collapses that into
+ * `await db.add({ storeName, data })`.
+ *
+ * Three easy traps are handled internally:
+ * 1. **Version downgrade**: opening with a version lower than the one on disk throws a
+ *    VersionError. Here the actual version is parsed out and the database reopened aligned
+ *    to it, instead of surfacing the error to the caller.
+ * 2. **Blocked upgrade**: an upgrade hangs while another tab or worker holds an old
+ *    connection. `onversionchange` on the connection closes it so the upgrading side can
+ *    proceed.
+ * 3. **When stores can be created**: only inside `onupgradeneeded`, hence the declarative
+ *    `stores` configuration.
+ *
+ * @example
+ * ```ts
+ * const db = new WebDB({
+ *   dbName: 'read',
+ *   version: 4,
+ *   stores: [
+ *     { name: 'books', options: { keyPath: 'id' }, indexes: [{ name: 'byAuthor', keyPath: 'author' }] },
+ *     { name: 'notes', options: { keyPath: 'id' } },
+ *   ],
+ * });
+ * await db.openDataBase();
+ * await db.add({ storeName: 'books', data: { id: '1', title: 'Walden' } });
+ * ```
+ */
+export declare class WebDB {
+    database?: IDBDatabase;
+    version: number;
+    dbName: string;
+    private stores;
+    private upgrade?;
+    constructor({ dbName, version, stores, upgrade }: WebDBOptions);
+    /**
+     * @description: Open the database; when the requested version is below the one on disk,
+     * align to it and reopen automatically
+     * @return {Promise<IDBResult<{ db: IDBDatabase }>>}
+     */
+    openDataBase: () => Promise<IDBResult<{
+        db: IDBDatabase;
+    }>>;
+    closeDataBase: () => void;
+    /** @description: Close and reopen (used to restore the connection after aligning versions) */
+    refreshDatabase: () => Promise<IDBResult<{
+        db: IDBDatabase;
+    }>>;
+    deleteDatabase: ({ dbName }?: {
+        dbName?: string;
+    }) => Promise<IDBResult>;
+    /** @description: Get an objectStore (each call opens its own transaction — only suitable for a single read) */
+    getObjectStore: (storeName: string, mode?: IDBTransactionMode) => IDBObjectStore | undefined;
+    /**
+     * @description: Wrap an IDBRequest into a Promise<IDBResult>, shared by every read and
+     * write method. When `store` cannot be obtained (database not open / store missing) the
+     * failure takes the same error path.
+     */
+    private run;
+    /** @description: Insert; fails when the primary key already exists (use `update` to overwrite) */
+    add: <T = unknown>({ storeName, data }: {
+        storeName: string;
+        data: T;
+    }) => Promise<IDBResult<T>>;
+    /** @description: Write with `put` semantics: insert when absent, overwrite when present */
+    update: <T = unknown>({ storeName, data }: {
+        storeName: string;
+        data: T;
+    }) => Promise<IDBResult>;
+    readByKey: <T = unknown>({ storeName, key }: {
+        storeName: string;
+        key: IDBValidKey;
+    }) => Promise<IDBResult<T>>;
+    /** @description: Read a whole store; for large volumes use readByCursor to process record by record instead of holding everything in memory */
+    readAll: <T = unknown>({ storeName, query, count, }: {
+        storeName: string;
+        query?: IDBValidKey | IDBKeyRange;
+        count?: number;
+    }) => Promise<IDBResult<T[]>>;
+    count: ({ storeName, query, }: {
+        storeName: string;
+        query?: IDBValidKey | IDBKeyRange;
+    }) => Promise<IDBResult<number>>;
+    /** @description: Walk a cursor, collecting results per keyRange / direction */
+    readByCursor: <T = unknown>({ storeName, keyRange, direction, }: {
+        storeName: string;
+        keyRange?: IDBKeyRange;
+        direction?: IDBCursorDirection;
+    }) => Promise<IDBResult<T[]>>;
+    delete: ({ storeName, key }: {
+        storeName: string;
+        key: IDBValidKey;
+    }) => Promise<IDBResult>;
+    clear: ({ storeName }: {
+        storeName: string;
+    }) => Promise<IDBResult>;
+    /**
+     * @description: A typed, forgiving handle on one object store. Binds the store name once
+     * instead of repeating it at every call, and returns plain values rather than `IDBResult`.
+     *
+     * **Every method swallows failures** and answers with the empty case (`null` / `[]` /
+     * `false` / `0`). That is the right default for the storage most apps put in IndexedDB —
+     * reading progress, drafts, caches — where a failed read should degrade the feature, not
+     * take down the screen. It is the wrong default when the write *is* the user's action
+     * (saving a document, completing a purchase): there, call the `IDBResult` methods above and
+     * handle the error.
+     *
+     * @param {string} name object store name (must be declared in `stores`)
+     * @return {IDBCollection<T>}
+     * @example
+     * ```ts
+     * const notes = db.collection<BookNote>('books_notes');
+     * await notes.put(note);              // false if it failed
+     * const all = await notes.all();      // [] if it failed
+     * const one = await notes.get(id);    // null if missing or failed
+     * ```
+     */
+    collection: <T = unknown>(name: string) => IDBCollection<T>;
+}
+/** A store name bound once, values unwrapped, failures folded into the empty case */
+export interface IDBCollection<T> {
+    readonly name: string;
+    /** The record, or `null` when missing or unreadable */
+    get: (key: IDBValidKey) => Promise<T | null>;
+    /** Every record, or `[]` on failure */
+    all: () => Promise<T[]>;
+    /** Record count, or `0` on failure */
+    count: () => Promise<number>;
+    /** Insert; `false` if the key already exists or the write failed */
+    add: (value: T) => Promise<boolean>;
+    /** Insert or overwrite; `false` on failure */
+    put: (value: T) => Promise<boolean>;
+    /** Delete one record; `false` on failure */
+    remove: (key: IDBValidKey) => Promise<boolean>;
+    /** Empty the store; `false` on failure */
+    clear: () => Promise<boolean>;
+}
+export interface HandoffOptions {
+    /** Database name. Both sides of the handoff must agree on this. */
+    dbName: string;
+    /** Object store name, created on first open. */
+    storeName?: string;
+    /** Key the single pending value is stored under. */
+    key?: string;
+}
+export interface Handoff<T> {
+    /** Store a value for the next page to take. Resolves false when it could not be stored. */
+    put: (value: T) => Promise<boolean>;
+    /** Take the pending value and delete it. Resolves null when there is nothing pending. */
+    take: () => Promise<T | null>;
+}
+/**
+ * @description: A one-shot value handoff between two pages of the same origin, backed by
+ * IndexedDB.
+ *
+ * The problem it solves: a `File` picked on page A cannot be carried to page B. It does not
+ * survive a URL (too large, and not serialisable), and `sessionStorage` only takes strings.
+ * IndexedDB stores structured-cloneable values as-is — `File`, `Blob`, `ArrayBuffer`,
+ * `Map` — so page A calls `put(file)` and navigates, and page B calls `take()`.
+ *
+ * **Reading is destructive**: `take()` deletes the value in the same transaction that reads
+ * it, so a reload does not re-open the same file and a stale URL flag finds nothing. Both
+ * sides degrade to `null` / `false` rather than throwing — a blocked or unavailable
+ * IndexedDB (private mode, third-party frame) must not break the page that merely *tried*
+ * to hand something over.
+ *
+ * @param {HandoffOptions} options
+ * @return {Handoff<T>}
+ * @example
+ * ```ts
+ * // Landing page
+ * const handoff = createHandoff<File>({ dbName: 'document-handoff' });
+ * await handoff.put(picked);
+ * location.href = '/app?open=local';
+ *
+ * // App
+ * const file = await handoff.take(); // null on a reload — the value is consumed
+ * ```
+ */
+export declare const createHandoff: <T>({ dbName, storeName, key }: HandoffOptions) => Handoff<T>;

package/dist/src/utils/img.d.ts

@@ -1,15 +1,71 @@
 import type { BaseReturn } from '@/utils/bom';
+/** A bitmap container usable both as a drawImage source and as a render target */
+export type ImgSource = HTMLImageElement | HTMLCanvasElement;
 /**
- * @description: 校验图片尺寸
- * @param {File} file
- * @return {*}
+ * @description: Load an image by path, resolving once it has decoded.
+ *
+ * Note that it rejects with the raw error event rather than an Error: `<img>`'s onerror
+ * carries no reason (the browser deliberately withholds it cross-origin), so wrapping it in
+ * an Error would only invent a message that is not true.
+ *
+ * @param {string} src image path
+ * @return {Promise<ImgSource>}
+ */
+export declare const getImage: (src: string) => Promise<ImgSource>;
+/**
+ * @description: Round an image's corners, returning an offscreen canvas.
+ *
+ * A canvas rather than a dataURL: a canvas feeds straight into the next drawImage, so a
+ * chain of filters does not encode and decode a PNG at every step.
+ *
+ * @param {ImgSource} img image to round
+ * @param {number} radius corner radius
+ * @return {ImgSource} offscreen canvas
+ */
+export declare const cutRound: (img: ImgSource, radius: number) => ImgSource;
+/**
+ * @description: Apply an overall opacity to an image, returning an offscreen canvas.
+ *
+ * `ctx.filter` first (GPU accelerated); where unsupported, fall back to rewriting the alpha
+ * channel pixel by pixel. The fallback skips pixels whose alpha is already 0, so fully
+ * transparent regions do not come out with a non-zero value.
+ *
+ * @param {ImgSource} img image to process
+ * @param {number} opacity opacity, 0–1
+ * @return {ImgSource} offscreen canvas
+ */
+export declare const opacity: (img: ImgSource, opacity: number) => ImgSource;
+/**
+ * @description: Build a 2D Gaussian weight matrix, normalised so the weights sum to 1.
+ *
+ * Normalising is required: without it the convolution shifts the image's overall
+ * brightness. Sigma defaults to `radius / 3`, by which point the Gaussian has decayed to
+ * nearly 0 at the radius, making the truncation error negligible.
+ *
+ * @param {number} radius blur radius
+ * @param {number} sigma standard deviation, defaults to radius / 3
+ * @return {number[]} a flat (2r+1)² matrix in row-major order
+ */
+export declare const getMatrix: (radius: number, sigma?: number) => number[];
+/**
+ * @description: Check an image's dimensions against a given width / height. When both are
+ * passed **both** must match; when neither is, decoding successfully is enough.
+ *
+ * `revokeObjectURL` runs on both paths, otherwise every check leaks a blob URL that lives
+ * until the page unloads. A decode failure (a corrupt file, a non-image) rejects rather than
+ * hanging forever.
+ *
+ * @param {File} file image file to check
+ * @param {number} width expected width in pixels
+ * @param {number} height expected height in pixels
+ * @return {Promise<boolean>}
  */
 export declare const isImageSize: (file: File, width?: number, height?: number) => Promise<boolean>;
 export interface convertImageToBase64Return extends BaseReturn {
     data: string | ArrayBuffer | null;
 }
 /**
- * @description: 图片转 base64
+ * @description: Convert an image to base64
  * @param {File} file
  * @return {*}
  */

package/dist/src/utils/index.d.ts

@@ -1,35 +1,69 @@
 import { SyncHook } from './subscribe';
-import { Mathjs, addNumSym, mathjs, perToNum, range, transformNumber } from './number';
-import { MessageCodec, changeHumpToLowerCase, checkEncoding, clearBr, clearStr, getMatchingSentences, getRandomString, isString, md5, randomString, str2Xml, strParse, toString, transformText } from './str';
+import { Mathjs, addNumSym, mathjs, parseChineseNumber, parseEnglishNumber, parseRomanNumber, perToNum, range, transformNumber } from './number';
+import { MessageCodec, arrayBufferToString, changeHumpToLowerCase, checkEncoding, clearBr, clearStr, getMatchingSentences, getRandomString, isString, md5, randomString, str2Xml, strParse, toFullWidth, toHalfWidth, toString, transformText } from './str';
 import type { TransformText } from './str';
-import { BridgeManager, Client, Platform, PostMessageBridge, acceptPortBridge, createPortBridge, openPortBridge, BRIDGE_MARKER, DEFAULT_CHANNEL, appendUrl, bridgeManager, connection, createObjectURL, durationHandler, encodeUrl, getAllQueryString, getCookie, getCookieByName, getFrame, getHost, getPixelRatio, getQuery, getWindow, imageRequest, isSafari, networkSpeed, removeGhosting, requestUrlToBuffer, retain } from './bom';
-import type { BridgeManagerOptions, BroadcastPayload, CallToPayload, MessageData, MessageHandler, PendingRequest, PortBridge, OpenPortBridgeOptions, AcceptPortBridgeOptions } from './bom';
+import { appendUrl, connection, createObjectURL, durationHandler, encodeUrl, getAllQueryString, getCookie, getCookieByName, getFrame, getPixelRatio, getQuery, getWindow, imageRequest, isInIframe, isSafari, networkSpeed, queryFlag, removeGhosting, requestUrlToBuffer, retain } from './bom';
+import { BRIDGE_MARKER, BridgeManager, Client, DEFAULT_CHANNEL, Platform, PostMessageBridge, acceptPortBridge, bridgeManager, createPortBridge, openPortBridge } from './bridge';
+import type { AcceptPortBridgeOptions, BridgeManagerOptions, BroadcastPayload, CallToPayload, MessageData, MessageHandler, OpenPortBridgeOptions, PendingRequest, PortBridge } from './bridge';
 import { cloneDeep, filterObj, formatJson, isEqual, merge, mergeExports, querystring, replaceOld, setAttributeByGlobal } from './obj';
 import { MimeType, getExtensions, getMime, setMime } from './mimeType';
 import { AudioRecorder } from './audioRecorder';
 import { createSignal, subscribers } from './signal';
 import { audioVendor, canvasVendor, webglVendor } from './behavior';
 import { TOTP } from './totp/totp';
-import { localStorageGetItem, localStorageSetItem } from './storage';
+import { createStore, localStorageGetItem, localStorageRemoveItem, localStorageSetItem } from './storage';
+import type { JsonStore } from './storage';
 import { compose } from './compose';
 import { handleConsole } from './console';
 import { debounce } from './debounce';
+import type { Debounced } from './debounce';
 import { Chain, addClassToElement, create, createDocumentFragment, escapeHtml, removeClassToElement, setFontSize2html } from './dom';
 import { handleError } from './error';
-import { convertImageToBase64, isImageSize } from './img';
-import { memoize } from './memoize';
+import { EventManager } from './event';
+import { circ, cubic, expo, quad, quart, quint, sine } from './tween';
+import type { EasingFn, SpeedType } from './tween';
+import { convertImageToBase64, cutRound, getImage, getMatrix, isImageSize, opacity } from './img';
+import type { ImgSource } from './img';
+import { fanShapedByArc, getAngle, getArcPointerByDeg, getLinearGradient, getTangentByPointer, roundRectByArc } from './canvas';
+import { ADOPTED_SHEET_MARKER, ADOPTED_STYLE_MARKER, adoptSheetText, adoptStyles } from './style';
+import { memoize, once, singleFlight } from './memoize';
+import type { SingleFlight } from './memoize';
+import { WebDB, createHandoff } from './idb';
+import type { Handoff, HandoffOptions, IDBCollection, IDBResult, IDBStoreSchema, WebDBOptions } from './idb';
+import { buildOffsets, indexForOffset, segmentByRanges } from './segment';
+import { paginateText } from './paginate';
+import type { PaginateOptions, PaginateResult, TextBox, TextGridMetrics, TextPage } from './paginate';
+import type { OffsetRange, Segment } from './segment';
+import { detectLanguage, navigatorLanguage, resolveLocale } from './lang';
+import { I18nCore, createI18n, useI18n } from './i18n';
+import type { I18nConfig, LocaleChangeHandler, LocaleMessages, MessageDict, TranslateParams } from './i18n';
+import { createLocalePath } from './localePath';
+import type { LocalePath, LocalePathConfig, LocaleRoute } from './localePath';
+import type { ResolveLocaleOptions, TextLanguage } from './lang';
+import { readFileAsArrayBuffer, readFileAsDataURL, readFileAsText, readFileAsUint8Array } from './file';
+import { WorkerClient, serveWorker } from './worker';
+import type { ServeWorkerOptions, WorkerClientOptions, WorkerHandlerContext, WorkerRequestBase, WorkerResponseBase } from './worker';
+import { isUrlCached, networkAllowsDownload, prefetchUrl, prefetchUrls, prefetchWhenIdle, whenIdle } from './prefetch';
+import type { NetworkAllowanceOptions, PrefetchOptions, WhenIdleOptions } from './prefetch';
+import { TimeoutError, deferred, delay, withTimeout, withTimeoutFallback } from './async';
+import type { Deferred } from './async';
+import { ZIP_DEFLATE, ZIP_STORED, createZip, crc32, inflateRaw, readZipEntries, readZipEntry, rewriteZip, zipHasEntry } from './zip';
+import type { RewriteZipOptions, ZipEntry } from './zip';
 import { Monitor } from './monitor';
 import { getStatus, status } from './network';
 import { noop } from './noop';
 import { getPerformance } from './performance';
 import { QuestQueue } from './queue';
-import { createData, report } from './report';
-import { handleFetchHook } from './request';
-import { scriptOnLoad } from './script';
-import { generateThrottle, throttle } from './throttle';
-import { performanceTime, timeFormat, timestampToTime } from './time';
+import { createData, getReportUrl, report, setReportUrl } from './report';
+import type { BeaconPayload, ReportConfig } from './report';
+import { handleFetchHook, handleXhrHook } from './request';
+import { loadScript, scriptOnLoad } from './script';
+import type { LoadScriptOptions } from './script';
+import { throttle } from './throttle';
+import type { Throttled } from './throttle';
+import { formatDate, performanceTime, timeFormat, timestampToTime } from './time';
 import type { CurrentDevice } from './device';
-import { currentDevice, isBangDevice, isClient, isMobile, isWeiXin } from './device';
-import { Color, ColorScheme, FMT, Hsl, Hsla, Rgb, Rgba, componentToHex, hexToRgb, hsbToRgb, hslToRgb, hsvToHsl, hsvToRgb, hue2rgb, randomColor, rgbToHex, rgbToHsb, rgbToHsl } from '@/utils/color';
-export { performanceTime, timeFormat, timestampToTime, generateThrottle, throttle, SyncHook, changeHumpToLowerCase, clearBr, clearStr, isString, randomString, str2Xml, strParse, scriptOnLoad, handleFetchHook, createData, report, QuestQueue, noop, getPerformance, querystring, formatJson, filterObj, merge, replaceOld, mergeExports, perToNum, range, Mathjs, mathjs, getStatus, status, Monitor, MimeType, getExtensions, setMime, getMime, memoize, isImageSize, convertImageToBase64, handleError, addClassToElement, removeClassToElement, createDocumentFragment, escapeHtml, isClient, isWeiXin, isMobile, debounce, currentDevice, handleConsole, compose, Color, FMT, Hsl, Hsla, Rgb, Rgba, randomColor, hexToRgb, componentToHex, rgbToHex, rgbToHsl, hue2rgb, hslToRgb, rgbToHsb, hsbToRgb, hsvToRgb, hsvToHsl, ColorScheme, AudioRecorder, webglVendor, canvasVendor, audioVendor, retain, getCookie, requestUrlToBuffer, getPixelRatio, createObjectURL, getFrame, getHost, getAllQueryString, appendUrl, removeGhosting, getCookieByName, getWindow, connection, encodeUrl, imageRequest, durationHandler, networkSpeed, TOTP, isBangDevice, localStorageGetItem, localStorageSetItem, setAttributeByGlobal, setFontSize2html, Chain, create, isEqual, cloneDeep, createSignal, subscribers, getMatchingSentences, transformNumber, toString, addNumSym, getQuery, checkEncoding, transformText, isSafari, md5, getRandomString, bridgeManager, Client, BridgeManager, PostMessageBridge, MessageCodec, Platform, openPortBridge, acceptPortBridge, createPortBridge, BRIDGE_MARKER, DEFAULT_CHANNEL, };
-export type { CurrentDevice, TransformText, MessageHandler, MessageData, PendingRequest, BridgeManagerOptions, BroadcastPayload, CallToPayload, PortBridge, OpenPortBridgeOptions, AcceptPortBridgeOptions, };
+import { MOBILE_MEDIA_QUERY, currentDevice, isBangDevice, isClient, isMobile, isWeiXin, matchMediaQuery, watchMediaQuery } from './device';
+import { Color, ColorScheme, FMT, HEX_COLOR_REGEX, Hsl, Hsla, RGBA_REGEX, RGB_REGEX, Rgb, Rgba, componentToHex, hexToAlpha, hexToHsb, hexToHsv, hexToRgb, hsbToHsl, hsbToRgb, hslToHsb, hslToHsv, hslToRgb, hsvToHsl, hsvToRgb, hue2rgb, randomColor, rgbToHex, rgbToHsb, rgbToHsl, rgbToHsv, rgbaString, rgbaToHex, rgbaToRgb } from '@/utils/color';
+export { performanceTime, timeFormat, timestampToTime, throttle, SyncHook, changeHumpToLowerCase, clearBr, clearStr, isString, randomString, str2Xml, strParse, scriptOnLoad, handleFetchHook, createData, report, QuestQueue, noop, getPerformance, querystring, formatJson, filterObj, merge, replaceOld, mergeExports, perToNum, range, Mathjs, mathjs, getStatus, status, Monitor, MimeType, getExtensions, setMime, getMime, memoize, once, isImageSize, convertImageToBase64, handleError, addClassToElement, removeClassToElement, createDocumentFragment, escapeHtml, isClient, isWeiXin, isMobile, debounce, currentDevice, handleConsole, compose, Color, FMT, Hsl, Hsla, Rgb, Rgba, randomColor, hexToRgb, componentToHex, rgbToHex, rgbToHsl, hue2rgb, hslToRgb, rgbToHsb, hsbToRgb, hsvToRgb, hsvToHsl, ColorScheme, AudioRecorder, webglVendor, canvasVendor, audioVendor, retain, getCookie, requestUrlToBuffer, getPixelRatio, createObjectURL, getFrame, getAllQueryString, queryFlag, isInIframe, appendUrl, removeGhosting, getCookieByName, getWindow, connection, encodeUrl, imageRequest, durationHandler, networkSpeed, TOTP, isBangDevice, localStorageGetItem, localStorageSetItem, localStorageRemoveItem, createStore, setAttributeByGlobal, setFontSize2html, Chain, create, isEqual, cloneDeep, createSignal, subscribers, getMatchingSentences, transformNumber, toString, addNumSym, getQuery, checkEncoding, transformText, isSafari, md5, getRandomString, bridgeManager, Client, BridgeManager, PostMessageBridge, MessageCodec, Platform, openPortBridge, acceptPortBridge, createPortBridge, BRIDGE_MARKER, DEFAULT_CHANNEL, singleFlight, WebDB, createHandoff, buildOffsets, paginateText, indexForOffset, segmentByRanges, detectLanguage, navigatorLanguage, resolveLocale, readFileAsArrayBuffer, readFileAsUint8Array, readFileAsText, readFileAsDataURL, WorkerClient, serveWorker, whenIdle, networkAllowsDownload, isUrlCached, prefetchUrl, prefetchUrls, prefetchWhenIdle, deferred, withTimeout, withTimeoutFallback, delay, TimeoutError, crc32, inflateRaw, readZipEntries, readZipEntry, zipHasEntry, rewriteZip, createZip, ZIP_STORED, ZIP_DEFLATE, arrayBufferToString, toHalfWidth, toFullWidth, parseChineseNumber, parseRomanNumber, parseEnglishNumber, MOBILE_MEDIA_QUERY, matchMediaQuery, watchMediaQuery, createLocalePath, setReportUrl, getReportUrl, formatDate, handleXhrHook, EventManager, quad, cubic, quart, quint, sine, expo, circ, getImage, cutRound, opacity, getMatrix, getAngle, getArcPointerByDeg, getTangentByPointer, fanShapedByArc, roundRectByArc, getLinearGradient, adoptStyles, adoptSheetText, ADOPTED_STYLE_MARKER, ADOPTED_SHEET_MARKER, rgbToHsv, hexToHsb, hexToHsv, hsbToHsl, hslToHsb, hslToHsv, hexToAlpha, rgbaString, rgbaToRgb, rgbaToHex, HEX_COLOR_REGEX, RGB_REGEX, RGBA_REGEX, loadScript, I18nCore, createI18n, useI18n, };
+export type { EasingFn, SpeedType, ImgSource, LoadScriptOptions, I18nConfig, MessageDict, LocaleMessages, TranslateParams, LocaleChangeHandler, Debounced, Throttled, BeaconPayload, ReportConfig, LocalePath, LocalePathConfig, LocaleRoute, SingleFlight, IDBCollection, IDBResult, IDBStoreSchema, WebDBOptions, Handoff, HandoffOptions, JsonStore, Deferred, ZipEntry, RewriteZipOptions, ResolveLocaleOptions, OffsetRange, PaginateOptions, PaginateResult, TextBox, TextGridMetrics, TextPage, Segment, TextLanguage, ServeWorkerOptions, WorkerClientOptions, WorkerHandlerContext, WorkerRequestBase, WorkerResponseBase, WhenIdleOptions, NetworkAllowanceOptions, PrefetchOptions, CurrentDevice, TransformText, MessageHandler, MessageData, PendingRequest, BridgeManagerOptions, BroadcastPayload, CallToPayload, PortBridge, OpenPortBridgeOptions, AcceptPortBridgeOptions, };

package/dist/src/utils/index.js

@@ -1 +1 @@
-import{t as s}from"../../subscribe-CINWsor3.js";import{A as a,C as t,D as o,E as r,F as m,I as i,M as p,N as f,O as j,P as b,S as c,T as l,_ as u,a as x,b as d,c as e,d as g,f as h,g as k,h as n,i as v,j as w,k as y,l as A,m as C,n as D,o as E,p as M,r as N,s as O,t as S,u as T,v as _,w as F,x as I,y as P}from"../../color-CRdlaDqQ.js";import{$ as q,A as z,At as B,B as G,C as H,Ct as J,D as K,Dt as L,E as Q,Et as R,F as U,G as V,H as W,I as X,J as Y,K as Z,L as $,M as ss,Mt as as,N as ts,Nt as os,O as rs,Ot as ms,P as is,Q as ps,R as fs,S as js,St as bs,T as cs,Tt as ls,U as us,V as xs,W as ds,X as es,Y as gs,Z as hs,_ as ks,_t as ns,a as vs,at as ws,b as ys,bt as As,c as Cs,ct as Ds,d as Es,dt as Ms,et as Ns,f as Os,ft as Ss,g as Ts,gt as _s,h as Fs,ht as Is,i as Ps,it as qs,j as zs,jt as Bs,k as Gs,kt as Hs,l as Js,lt as Ks,m as Ls,mt as Qs,n as Rs,nt as Us,o as Vs,ot as Ws,p as Xs,pt as Ys,q as Zs,r as $s,rt as sa,s as aa,st as ta,t as oa,tt as ra,u as ma,ut as ia,v as pa,vt as fa,w as ja,wt as ba,x as ca,xt as la,y as ua,yt as xa,z as da}from"../../utils-_OxsVZmz.js";export{ts as AudioRecorder,ds as BRIDGE_MARKER,V as BridgeManager,Fs as Chain,Z as Client,S as Color,D as ColorScheme,Zs as DEFAULT_CHANNEL,N as FMT,v as Hsl,x as Hsla,ms as Mathjs,t as MessageCodec,P as MimeType,vs as Monitor,Y as Platform,gs as PostMessageBridge,Rs as QuestQueue,E as Rgb,O as Rgba,s as SyncHook,K as TOTP,es as acceptPortBridge,Ts as addClassToElement,Hs as addNumSym,hs as appendUrl,rs as audioVendor,ps as bridgeManager,Gs as canvasVendor,F as changeHumpToLowerCase,l as checkEncoding,r as clearBr,o as clearStr,is as cloneDeep,e as componentToHex,ja as compose,q as connection,Os as convertImageToBase64,ks as create,Js as createData,pa as createDocumentFragment,Ns as createObjectURL,ra as createPortBridge,zs as createSignal,xa as currentDevice,js as debounce,Us as durationHandler,sa as encodeUrl,ua as escapeHtml,U as filterObj,X as formatJson,Vs as generateThrottle,qs as getAllQueryString,ws as getCookie,Ws as getCookieByName,d as getExtensions,ta as getFrame,Ds as getHost,j as getMatchingSentences,I as getMime,Es as getPerformance,Ks as getPixelRatio,ia as getQuery,y as getRandomString,$s as getStatus,Ms as getWindow,H as handleConsole,Ls as handleError,Cs as handleFetchHook,A as hexToRgb,T as hsbToRgb,g as hslToRgb,h as hsvToHsl,M as hsvToRgb,C as hue2rgb,Ss as imageRequest,As as isBangDevice,la as isClient,$ as isEqual,Xs as isImageSize,bs as isMobile,Ys as isSafari,a as isString,J as isWeiXin,cs as localStorageGetItem,Q as localStorageSetItem,B as mathjs,w as md5,us as memoize,fs as merge,da as mergeExports,Qs as networkSpeed,L as noop,Is as openPortBridge,Bs as perToNum,ba as performanceTime,G as querystring,n as randomColor,p as randomString,as as range,ys as removeClassToElement,_s as removeGhosting,xs as replaceOld,ma as report,ns as requestUrlToBuffer,fa as retain,k as rgbToHex,u as rgbToHsb,_ as rgbToHsl,oa as scriptOnLoad,W as setAttributeByGlobal,ca as setFontSize2html,c as setMime,Ps as status,f as str2Xml,b as strParse,ss as subscribers,aa as throttle,ls as timeFormat,R as timestampToTime,m as toString,os as transformNumber,i as transformText,z as webglVendor};
+import{i as s}from"../../enums-BAgbyGdH.js";import{A as a,B as t,C as n,D as o,E as r,F as m,G as i,H as p,I as f,J as j,K as c,L as l,M as u,N as h,O as x,P as b,Q as d,R as e,S as g,T as k,U as v,V as w,W as y,X as z,Y as A,Z as B,_ as C,a as D,b as E,c as F,d as H,f as I,g as L,h as M,i as N,j as O,k as P,l as R,m as S,n as T,o as U,p as V,q as W,r as _,s as q,t as G,u as J,v as K,w as Q,x as X,y as Y,z as Z}from"../../color-Dohr9BXX.js";import{$,$t as ss,A as as,At as ts,B as ns,Bt as os,C as rs,Ct as ms,D as is,Dt as ps,E as fs,Et as js,F as cs,Ft as ls,G as us,Gt as hs,H as xs,Ht as bs,I as ds,It as es,J as gs,Jt as ks,K as vs,Kt as ws,L as ys,Lt as zs,M as As,Mt as Bs,N as Cs,Nt as Ds,O as Es,Ot as Fs,P as Hs,Pt as Is,Q as Ls,Qt as Ms,R as Ns,Rt as Os,S as Ps,St as Rs,T as Ss,Tt as Ts,U as Us,Ut as Vs,V as Ws,Vt as _s,W as qs,Wt as Gs,X as Js,Xt as Ks,Y as Qs,Yt as Xs,Z as Ys,Zt as Zs,_ as $s,_t as sa,a as aa,an as ta,at as na,b as oa,bt as ra,c as ma,cn as ia,ct as pa,d as fa,dt as ja,en as ca,et as la,f as ua,ft as ha,g as xa,gt as ba,h as da,ht as ea,i as ga,in as ka,it as va,j as wa,jt as ya,k as za,kt as Aa,l as Ba,ln as Ca,lt as Da,m as Ea,mt as Fa,n as Ha,nn as Ia,nt as La,o as Ma,on as Na,ot as Oa,p as Pa,pt as Ra,q as Sa,qt as Ta,r as Ua,rn as Va,rt as Wa,s as _a,sn as qa,st as Ga,t as Ja,tn as Ka,tt as Qa,u as Xa,un as Ya,ut as Za,v as $a,vt as st,w as at,wt as tt,x as nt,xt as ot,y as rt,yt as mt,z as it,zt as pt}from"../../utils-8TVtLBjA.js";import{A as ft,B as jt,C as ct,D as lt,E as ut,F as ht,H as xt,I as bt,L as dt,M as et,N as gt,O as kt,P as vt,R as wt,S as yt,T as zt,U as At,V as Bt,W as Ct,_ as Dt,a as Et,b as Ft,c as Ht,d as It,f as Lt,g as Mt,h as Nt,i as Ot,k as Pt,l as Rt,m as St,n as Tt,o as Ut,p as Vt,r as Wt,s as _t,t as qt,u as Gt,v as Jt,w as Kt,x as Qt,y as Xt,z as Yt}from"../../i18n-Cf5TtRb4.js";import{n as Zt,t as $t}from"../../chain-CTywmh_H.js";export{gs as ADOPTED_SHEET_MARKER,Qs as ADOPTED_STYLE_MARKER,Ds as AudioRecorder,ws as BRIDGE_MARKER,Ta as BridgeManager,$t as Chain,ks as Client,G as Color,T as ColorScheme,Xs as DEFAULT_CHANNEL,sa as EventManager,_ as FMT,N as HEX_COLOR_REGEX,D as Hsl,U as Hsla,qt as I18nCore,et as MOBILE_MEDIA_QUERY,Ia as Mathjs,f as MessageCodec,u as MimeType,Ma as Monitor,Ks as Platform,Zs as PostMessageBridge,Ua as QuestQueue,q as RGBA_REGEX,F as RGB_REGEX,R as Rgb,J as Rgba,s as SyncHook,ps as TOTP,at as TimeoutError,vs as WebDB,cs as WorkerClient,da as ZIP_DEFLATE,xa as ZIP_STORED,Ms as acceptPortBridge,mt as addClassToElement,Va as addNumSym,Js as adoptSheetText,Ys as adoptStyles,It as appendUrl,l as arrayBufferToString,Fs as audioVendor,ss as bridgeManager,Us as buildOffsets,Aa as canvasVendor,e as changeHumpToLowerCase,Z as checkEncoding,Za as circ,t as clearBr,w as clearStr,Is as cloneDeep,H as componentToHex,js as compose,Lt as connection,Ls as convertImageToBase64,$s as crc32,Zt as create,Xa as createData,ra as createDocumentFragment,Sa as createHandoff,Tt as createI18n,Ws as createLocalePath,Vt as createObjectURL,ca as createPortBridge,ya as createSignal,_t as createStore,$a as createZip,ja as cubic,gt as currentDevice,$ as cutRound,tt as debounce,Ss as deferred,fs as delay,Ot as detectLanguage,St as durationHandler,Nt as encodeUrl,ot as escapeHtml,ha as expo,va as fanShapedByArc,ls as filterObj,jt as formatDate,es as formatJson,Mt as getAllQueryString,na as getAngle,Oa as getArcPointerByDeg,Dt as getCookie,Jt as getCookieByName,h as getExtensions,Xt as getFrame,la as getImage,Ga as getLinearGradient,p as getMatchingSentences,Qa as getMatrix,b as getMime,Ea as getPerformance,Ft as getPixelRatio,Qt as getQuery,v as getRandomString,fa as getReportUrl,ga as getStatus,pa as getTangentByPointer,yt as getWindow,Ts as handleConsole,st as handleError,ma as handleFetchHook,Ba as handleXhrHook,I as hexToAlpha,V as hexToHsb,S as hexToHsv,M as hexToRgb,L as hsbToHsl,C as hsbToRgb,K as hslToHsb,Y as hslToHsv,E as hslToRgb,X as hsvToHsl,g as hsvToRgb,n as hue2rgb,ct as imageRequest,qs as indexForOffset,rt as inflateRaw,vt as isBangDevice,ht as isClient,zs as isEqual,La as isImageSize,Kt as isInIframe,bt as isMobile,zt as isSafari,y as isString,za as isUrlCached,dt as isWeiXin,Ja as loadScript,Ht as localStorageGetItem,Rt as localStorageRemoveItem,Gt as localStorageSetItem,wt as matchMediaQuery,ka as mathjs,i as md5,Vs as memoize,Os as merge,pt as mergeExports,Et as navigatorLanguage,as as networkAllowsDownload,ut as networkSpeed,Ct as noop,Gs as once,Wa as opacity,Ka as openPortBridge,xs as paginateText,ta as parseChineseNumber,Na as parseEnglishNumber,qa as parseRomanNumber,ia as perToNum,Bt as performanceTime,wa as prefetchUrl,As as prefetchUrls,Cs as prefetchWhenIdle,Ra as quad,Fa as quart,lt as queryFlag,os as querystring,ea as quint,Q as randomColor,c as randomString,Ca as range,ys as readFileAsArrayBuffer,Ns as readFileAsDataURL,it as readFileAsText,ns as readFileAsUint8Array,oa as readZipEntries,nt as readZipEntry,Rs as removeClassToElement,kt as removeGhosting,_s as replaceOld,ua as report,Pt as requestUrlToBuffer,Ut as resolveLocale,ft as retain,Ps as rewriteZip,k as rgbToHex,r as rgbToHsb,o as rgbToHsl,x as rgbToHsv,P as rgbaString,a as rgbaToHex,O as rgbaToRgb,Da as roundRectByArc,Ha as scriptOnLoad,us as segmentByRanges,ds as serveWorker,bs as setAttributeByGlobal,ms as setFontSize2html,m as setMime,Pa as setReportUrl,ba as sine,hs as singleFlight,aa as status,W as str2Xml,j as strParse,Bs as subscribers,_a as throttle,xt as timeFormat,At as timestampToTime,A as toFullWidth,z as toHalfWidth,B as toString,Ya as transformNumber,d as transformText,Wt as useI18n,Yt as watchMediaQuery,ts as webglVendor,Hs as whenIdle,is as withTimeout,Es as withTimeoutFallback,rs as zipHasEntry};

package/dist/src/utils/lang.d.ts

@@ -0,0 +1,69 @@
+/** Coarse language bucket: Chinese / English / other only */
+export type TextLanguage = 'zh' | 'en' | 'other';
+/**
+ * @description: Decide a text's primary language from the ratio of CJK to Latin characters.
+ * Pure statistics, no model or dictionary loaded — good enough to branch on "which
+ * tokenizer / which language-specific model / which typographic metrics".
+ *
+ * Only the first N characters are sampled: the body language is consistent throughout, so
+ * scanning a whole book (millions of characters) is pure waste. Text with a little CJK still
+ * counts as Chinese (Latin has to clearly dominate for English), because English mixed into
+ * Chinese text is common while the reverse is rare.
+ *
+ * @param {string} text text to inspect
+ * @param {number} sampleSize sample length, defaults to 20000
+ * @return {TextLanguage}
+ */
+export declare const detectLanguage: (text: string, sampleSize?: number) => TextLanguage;
+/**
+ * @description: Map the browser UI language into the same buckets (the default when there is
+ * no content to inspect). Returns 'other' under SSR.
+ * @return {TextLanguage}
+ */
+export declare const navigatorLanguage: () => TextLanguage;
+export interface ResolveLocaleOptions {
+    /** Locales the app actually ships, most specific first. The result is always one of these. */
+    supported: readonly string[];
+    /** Returned when no source matches. Defaults to `supported[0]`. */
+    fallback?: string;
+    /** Query parameter carrying an explicit choice, e.g. `lang` in `?lang=zh-CN`. */
+    query?: string;
+    /** Cookie name carrying the choice (a server-rendered preference, typically). */
+    cookie?: string;
+    /** localStorage key carrying the choice the user last picked in-app. */
+    storageKey?: string;
+    /** Consult `navigator.language` / `navigator.languages` before falling back. Defaults to true. */
+    useNavigator?: boolean;
+    /** URL to read the query from; defaults to the current location. */
+    url?: string;
+}
+/**
+ * @description: Resolve which of your supported locales to use, from the usual chain:
+ * **query → cookie → localStorage → navigator → fallback**.
+ *
+ * The order is the point. A `?lang=` in the URL is an explicit, shareable, one-off
+ * instruction and must beat everything; a cookie is a server-visible decision, so it beats
+ * client-only state; localStorage is what the user last chose in-app; `navigator.language`
+ * is only a guess about a first-time visitor. Getting this backwards produces the classic
+ * bug where a shared `?lang=en` link keeps rendering in the recipient's stored language.
+ *
+ * Matching is case-insensitive and falls back from region to base language: with
+ * `supported: ['en', 'zh-CN']`, a `zh-TW` request matches nothing but `zh` matches `zh-CN`,
+ * and `en-GB` matches `en`. Values outside `supported` are ignored rather than returned, so
+ * the result is always safe to index a message catalogue with.
+ *
+ * The catalogue itself is yours — this only picks the key.
+ *
+ * @param {ResolveLocaleOptions} options
+ * @return {string} one of `supported`
+ * @example
+ * ```ts
+ * const locale = resolveLocale({
+ *   supported: ['en', 'zh-CN'],
+ *   query: 'lang',
+ *   cookie: 'lang',
+ *   storageKey: 'app-lang',
+ * });
+ * ```
+ */
+export declare const resolveLocale: (options: ResolveLocaleOptions) => string;

package/dist/src/utils/localePath.d.ts

@@ -0,0 +1,62 @@
+/**
+ * URL maths for a multi-language site (pure functions, no global state, no DOM).
+ *
+ * Uses **sub-directories** rather than sub-domains (`/zh/book/`, not `zh.example.com/book/`):
+ * search engines treat a sub-domain as a separate site that starts from zero authority,
+ * while a sub-directory inherits the main site's. The default language lives at the root
+ * (`/book/`); every other language carries a prefix.
+ *
+ * Decoupled from "what is the current language" — this module only converts paths, the
+ * language state belongs to the caller (the i18n runtime). That is why it runs both in
+ * build-time scripts (sitemap / hreflang generation) and in the browser.
+ */
+export interface LocaleRoute {
+    /** Language code, e.g. `zh-CN`; the public identifier (hreflang, i18n dictionary key) */
+    code: string;
+    /** URL prefix, e.g. `zh`. Empty = the default language, served from the root */
+    prefix?: string;
+}
+export interface LocalePathConfig {
+    locales: readonly LocaleRoute[];
+    /** Default language code; when omitted, the first locale without a prefix, else `locales[0]` */
+    defaultLocale?: string;
+    /** Deployment sub-path, e.g. `/weread`; empty for a root deployment. A trailing slash is ignored */
+    base?: string;
+}
+export interface LocalePath {
+    /** Normalised base (no trailing slash; empty string for a root deployment) */
+    readonly base: string;
+    readonly defaultLocale: string;
+    /** Detect the language from a pathname, falling back to the default language */
+    localeFromPath: (pathname: string) => string;
+    /** Drop the language prefix to get the language-independent path (for route matching) */
+    stripLocale: (pathname: string) => string;
+    /** Build a link for a language; an already-prefixed path is stripped first, so repeated calls are idempotent */
+    href: (path: string, code?: string) => string;
+    /** Convert a path in any language to its counterpart in another language (for a language switcher) */
+    hrefForLocale: (pathname: string, code: string) => string;
+    /** This path in every language, for `<link rel="alternate" hreflang>` */
+    alternates: (pathname: string) => Array<{
+        code: string;
+        href: string;
+    }>;
+}
+/**
+ * @description: Create the set of locale path conversion functions.
+ *
+ * @param {LocalePathConfig} config
+ * @return {LocalePath}
+ * @example
+ * ```ts
+ * const paths = createLocalePath({
+ *   locales: [{ code: 'en' }, { code: 'zh-CN', prefix: 'zh' }, { code: 'zh-HK', prefix: 'zh-hant' }],
+ *   base: '/docs',
+ * });
+ * paths.href('/book/walden/');                 // '/docs/book/walden/'
+ * paths.href('/book/walden/', 'zh-CN');        // '/docs/zh/book/walden/'
+ * paths.localeFromPath('/docs/zh/book/');      // 'zh-CN'
+ * paths.stripLocale('/docs/zh/book/');         // '/docs/book/'
+ * paths.hrefForLocale('/docs/zh/book/', 'zh-HK'); // '/docs/zh-hant/book/'
+ * ```
+ */
+export declare const createLocalePath: (config: LocalePathConfig) => LocalePath;

package/dist/src/utils/memoize.d.ts

@@ -1,7 +1,55 @@
-export type Func = () => unknown;
+export type Func = (...args: any[]) => unknown;
 /**
- * @description: 返回缓存的函数，执行一次后，无须执行直接返回结果
- * @param {Func} fn
- * @return {Func}
+ * @description: Run once — evaluate on the first call, cache the result, and return that
+ * same result forever after, whatever arguments come later. For lazy initialisation:
+ * config parsing, an expensive one-off computation, a lazy getter.
+ *
+ * **This is not a per-argument memoize**: only the first call's arguments matter, later
+ * ones are ignored. Use a `Map` if you need keyed caching, or
+ * [`singleFlight`](#singleflight) for the async case. Once evaluated, the reference to
+ * `fn` is released so whatever its closure captured can be collected.
+ *
+ * @param {Function} fn function that should run only once; a non-function value is returned as is
+ * @return {Function} wrapped function
+ * @example
+ * ```ts
+ * const config = once(() => JSON.parse(readFileSync('config.json', 'utf8')));
+ * config(); // parses
+ * config(); // returns the previous result directly
+ * ```
  */
-export declare const memoize: (fn: unknown) => Func;
+export declare const once: <T extends Func>(fn: T | unknown) => ((...args: Parameters<T>) => ReturnType<T>);
+/**
+ * @description: Former name of `once`. The name is misleading — it does not cache per
+ * argument, it simply runs once.
+ * @deprecated Use [`once`](#once) instead; for the async case use [`singleFlight`](#singleflight).
+ */
+export declare const memoize: typeof once;
+export interface SingleFlight<T> {
+    (): Promise<T>;
+    /** Drop the cached result so the next call runs again (connection lost, logout, forced refresh) */
+    reset: () => void;
+    /** Whether a result already exists or a run is in flight */
+    readonly started: boolean;
+}
+/**
+ * @description: The async flavour of "run once": concurrent callers share one in-flight
+ * promise, later callers reuse the resolved result, and **a rejection clears the cache**
+ * so it can be retried (this is where it differs from `memoize` — caching a rejected
+ * promise turns one flaky network blip into a permanent failure).
+ *
+ * The typical use is a resource that is initialised once but awaited by everyone: opening
+ * a database, loading config, registering a service worker. The classic bug is an
+ * initialiser returning void, leaving callers nothing to await, so concurrent writes all
+ * fail before the resource is ready — wrap it in `singleFlight` and any caller can just
+ * `await ready()`.
+ *
+ * @param {Function} fn async function that should run only once
+ * @return {SingleFlight<T>}
+ * @example
+ * ```ts
+ * const ready = singleFlight(() => db.openDataBase());
+ * await ready(); // concurrent callers only open it for real once
+ * ```
+ */
+export declare const singleFlight: <T>(fn: () => Promise<T>) => SingleFlight<T>;