@vope/utils 1.6.0-bate.3 → 1.6.0-bate.4

package/dist/index.js

@@ -70,102 +70,15 @@ var clamp = (value, min, max) => {
   return Math.min(max, Math.max(min, value));
 };
 
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_freeGlobal.js
-var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
-var freeGlobal_default = freeGlobal;
-
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_root.js
-var freeSelf = typeof self == "object" && self && self.Object === Object && self;
-var root = freeGlobal_default || freeSelf || Function("return this")();
-var root_default = root;
-
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_Symbol.js
-var Symbol2 = root_default.Symbol;
-var Symbol_default = Symbol2;
-
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getRawTag.js
-var objectProto = Object.prototype;
-var hasOwnProperty = objectProto.hasOwnProperty;
-var nativeObjectToString = objectProto.toString;
-var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
-function getRawTag(value) {
-  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
-  try {
-    value[symToStringTag] = void 0;
-    var unmasked = true;
-  } catch (e) {
-  }
-  var result = nativeObjectToString.call(value);
-  if (unmasked) {
-    if (isOwn) {
-      value[symToStringTag] = tag;
-    } else {
-      delete value[symToStringTag];
-    }
-  }
-  return result;
-}
-var getRawTag_default = getRawTag;
-
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_objectToString.js
-var objectProto2 = Object.prototype;
-var nativeObjectToString2 = objectProto2.toString;
-function objectToString(value) {
-  return nativeObjectToString2.call(value);
-}
-var objectToString_default = objectToString;
-
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseGetTag.js
-var nullTag = "[object Null]";
-var undefinedTag = "[object Undefined]";
-var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
-function baseGetTag(value) {
-  if (value == null) {
-    return value === void 0 ? undefinedTag : nullTag;
-  }
-  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
-}
-var baseGetTag_default = baseGetTag;
-
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isObjectLike.js
-function isObjectLike(value) {
-  return value != null && typeof value == "object";
-}
-var isObjectLike_default = isObjectLike;
-
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isArray.js
-var isArray = Array.isArray;
-var isArray_default = isArray;
-
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isString.js
-var stringTag = "[object String]";
-function isString(value) {
-  return typeof value == "string" || !isArray_default(value) && isObjectLike_default(value) && baseGetTag_default(value) == stringTag;
-}
-var isString_default = isString;
-
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isBoolean.js
-var boolTag = "[object Boolean]";
-function isBoolean(value) {
-  return value === true || value === false || isObjectLike_default(value) && baseGetTag_default(value) == boolTag;
-}
-var isBoolean_default = isBoolean;
-
-// node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isNumber.js
-var numberTag = "[object Number]";
-function isNumber(value) {
-  return typeof value == "number" || isObjectLike_default(value) && baseGetTag_default(value) == numberTag;
-}
-var isNumber_default = isNumber;
-
 // src/classnames.ts
+var import_lodash_es = require("lodash-es");
 var add = (a, b) => a ? a + " " + b : b;
 var classnames = (...list) => list.reduce((caches, data) => {
-  if (isString_default(data)) {
+  if ((0, import_lodash_es.isString)(data)) {
     data && (caches = add(caches, data));
   } else if (Array.isArray(data)) {
-    data.forEach((value) => value && isString_default(value) && (caches = add(caches, value)));
-  } else if (!isBoolean_default(data)) {
+    data.forEach((value) => value && (0, import_lodash_es.isString)(value) && (caches = add(caches, value)));
+  } else if (!(0, import_lodash_es.isBoolean)(data)) {
     for (const key in data) {
       key && data[key] && (caches = add(caches, key));
     }
@@ -237,6 +150,7 @@ var hash8object = (list, key) => list.reduce((caches, data) => {
 }, /* @__PURE__ */ new Map());
 
 // src/desens.ts
+var import_lodash_es2 = require("lodash-es");
 var desensEncrypt = (plaintext, encrypt) => {
   const rules = [];
   let point = -1;
@@ -275,7 +189,7 @@ var desensReplace = (ciphertext, rules, replacer = "*") => {
   return rules.reduce((cache, { range: [start, stop], modify }) => {
     const part = ciphertext.slice(start + offset, start + offset + modify);
     const size = stop + 1 - start;
-    const replaceValue = isString_default(replacer) ? replacer.repeat(size) : replacer[Symbol.replace](part, size);
+    const replaceValue = (0, import_lodash_es2.isString)(replacer) ? replacer.repeat(size) : replacer[Symbol.replace](part, size);
     cache += ciphertext.slice(from, start + offset) + replaceValue;
     from = start + offset + modify;
     offset += modify - size;
@@ -1025,10 +939,11 @@ var once = (func, thisArg) => {
 };
 
 // src/parse/num.ts
+var import_lodash_es3 = require("lodash-es");
 var pow = Math.floor(Math.log10(Number.MAX_SAFE_INTEGER));
 var re_num = /^([-+]?)0*(\d+)(?:(n)|(?:\.(\d+))?(?:[Ee]([-+]?)(\d+))?)$/;
 var parseNum = (num) => {
-  if (isNumber_default(num) || typeof num === "bigint") return num;
+  if ((0, import_lodash_es3.isNumber)(num) || typeof num === "bigint") return num;
   const match = num.match(re_num);
   if (!match) return Number.NaN;
   const [, valueSymbol, integer, bigint, decimal, powSymbol, powValue] = match;
@@ -1057,6 +972,7 @@ var parseNum = (num) => {
 var rotateAngle = (from, angle, visit) => rotateRad(from, angle / 180 * Math.PI, visit);
 
 // src/serialize/url-params.ts
+var import_lodash_es4 = require("lodash-es");
 var cubes = {
   string: (text) => text,
   boolean: (text) => text === "true",
@@ -1081,7 +997,7 @@ var cubeURLParams = (text, serializes) => {
   for (const [key, value] of params) {
     const serialize = serializes[key];
     if (!serialize) continue;
-    if (isString_default(serialize) && isKey(serialize, cubes)) {
+    if ((0, import_lodash_es4.isString)(serialize) && isKey(serialize, cubes)) {
       result[key] = cubes[serialize](value);
     } else {
       result[key] = serialize.cube(value);
@@ -1099,20 +1015,21 @@ var flatURLParams = (data, serializes) => {
     if (!serialize) continue;
     params.append(
       key,
-      isString_default(serialize) && isKey(serialize, flats) ? flats[serialize](value) : serialize.flat(value)
+      (0, import_lodash_es4.isString)(serialize) && isKey(serialize, flats) ? flats[serialize](value) : serialize.flat(value)
     );
   }
   return params.toString();
 };
 
 // src/style/css.ts
+var import_lodash_es5 = require("lodash-es");
 var hump = /[A-Z]/g;
 var css = (...args) => {
   const list = [];
   for (let i = 0; i < args.length; i++) {
     const data = args[i];
     if (!data) continue;
-    if (isString_default(data)) {
+    if ((0, import_lodash_es5.isString)(data)) {
       list.push(data);
     } else if (Array.isArray(data)) {
       const result = css(...data);
@@ -1346,16 +1263,3 @@ var connectURLParams = (url, params, serializes) => {
 
 // src/wait.ts
 var wait = (delay = 0) => new Promise((resolve) => setTimeout(resolve, delay));
-/*! Bundled license information:
-
-lodash-es/lodash.js:
-  (**
-   * @license
-   * Lodash (Custom Build) <https://lodash.com/>
-   * Build: `lodash modularize exports="es" -o ./`
-   * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
-   * Released under MIT license <https://lodash.com/license>
-   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
-   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
-   *)
-*/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vope/utils",
-  "version": "1.6.0-bate.3",
+  "version": "1.6.0-bate.4",
   "description": "",
   "type": "module",
   "publishConfig": {
@@ -37,7 +37,7 @@
   "license": "ISC",
   "files": [
     "dist",
-    "sub_*"
+    "sub_storage"
   ],
   "devDependencies": {
     "@babel/parser": "^7.26.9",

package/sub_storage/offline.d.ts

@@ -0,0 +1,51 @@
+export interface ICrypto<From, To> {
+    encrypt(plain: From): To | Promise<To>;
+    decrypt(cipher: To): From | Promise<From>;
+}
+interface Options<From, To> {
+    /** 存储名称 */
+    name: string;
+    /** 存储认证 */
+    token?: string;
+    /** 存储期限 */
+    expire?: number;
+    /** 存储加密 */
+    crypto: ICrypto<From, To>;
+}
+/**
+ * 离线存储
+ */
+export declare class OfflineStorage<From, To> {
+    #private;
+    get size(): number;
+    get mounted(): boolean;
+    constructor({ name, expire: newExpire, token: newToken, crypto, }: Options<From, To>);
+    ready(): Promise<this>;
+    /**
+     * 校验存储是否过期
+     */
+    validateExpire(): boolean;
+    /**
+     * 校验
+     */
+    validate(callback: (error?: Error) => void, expireMessage?: string): void;
+    /**
+     * 插入数据
+     */
+    push(data: From): Promise<number>;
+    /**
+     * 修改数据
+     */
+    update(index: number, data: From): Promise<boolean>;
+    /**
+     * 获取数据
+     */
+    get(index: number): Promise<From | null>;
+    /**
+     * 清理存储
+     */
+    clear(): Promise<void>;
+    static default<T>(options: string | Omit<Options<T, T>, 'crypto'>): OfflineStorage<T, T>;
+    static clear(token?: string, callback?: (name: string) => boolean): Promise<void>;
+}
+export {};

package/sub_storage/offline.js

@@ -0,0 +1,255 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/storage/offline.ts
+var offline_exports = {};
+__export(offline_exports, {
+  OfflineStorage: () => OfflineStorage
+});
+module.exports = __toCommonJS(offline_exports);
+var import_localforage = __toESM(require("localforage"), 1);
+var import_lodash_es = require("lodash-es");
+var import_sm_crypto = require("sm-crypto");
+var NAME = "@vope/utils";
+var PREFIX = NAME + "_";
+var key = [25, 144, 1, 32, 25, 135, 6, 40, 32, 23, 18, 19, 32, 36, 9, 5];
+var iv = [182, 59, 9, 29, 86, 64, 118, 111, 112, 101, 47, 117, 116, 105, 108, 115];
+var config = {
+  output: "string",
+  mode: "cbc",
+  iv
+};
+var HEADER = "." + import_sm_crypto.sm4.encrypt(NAME, key, config);
+var encrypt = (data) => {
+  let text = "";
+  for (const key2 in data) {
+    const value = data[key2];
+    if (value === void 0) continue;
+    text && (text += "&");
+    text += key2 + ":" + value;
+  }
+  return import_sm_crypto.sm4.encrypt(text, key, config);
+};
+var decrypt = (text) => {
+  const data = {};
+  let value;
+  try {
+    value = import_sm_crypto.sm4.decrypt(text, key, config);
+  } catch {
+    value = "";
+  }
+  value.split("&").forEach((pair) => {
+    const [key2, value2] = pair.split(":");
+    if (key2 === "expire") {
+      data[key2] = +value2;
+    } else {
+      data[key2] = value2;
+    }
+  });
+  return data;
+};
+var structKey = (index) => index.toString(16).padStart(8, "0");
+var reductKey = (key2) => parseInt(key2, 16);
+var MESSAGES = {
+  mount: "Please wait for the mounting to complete",
+  auth: "Unauthorized operation",
+  push: "Cannot add data to expired databases",
+  update: "Cannot update data to expired databases",
+  get: "Cannot get data from expired databases"
+};
+var createInstance = (name, version = 2) => import_localforage.default.createInstance({
+  driver: import_localforage.default.INDEXEDDB,
+  name,
+  version
+});
+var OfflineStorage = class _OfflineStorage {
+  #forage;
+  #expire;
+  #auth = false;
+  #crypto;
+  #size = 0;
+  #mount;
+  #mounted = false;
+  get size() {
+    return this.#size;
+  }
+  get mounted() {
+    return this.#mounted;
+  }
+  constructor({
+    name,
+    expire: newExpire,
+    token: newToken,
+    crypto
+  }) {
+    const forage = this.#forage = createInstance(import_sm_crypto.sm4.encrypt(PREFIX + name, key, config));
+    this.#mount = new Promise(async (resolve) => {
+      const keys = await forage.keys().then((keys2) => keys2).catch(() => []);
+      let size = 0;
+      let expire = newExpire;
+      let token = newToken;
+      let auth = true;
+      for (const key2 of keys) {
+        if (key2 === HEADER) {
+          const {
+            expire: oldExpire,
+            token: oldToken
+          } = decrypt(await forage.getItem(key2));
+          expire = oldExpire === void 0 ? newExpire : Date.now() < oldExpire ? newExpire : oldExpire;
+          auth = oldToken ? oldToken === newToken : true;
+          token = oldToken || newToken;
+        } else {
+          const value = reductKey(key2) + 1;
+          value > size && (size = value);
+        }
+      }
+      this.#size = size;
+      this.#expire = expire;
+      this.#auth = auth;
+      this.#crypto = crypto;
+      await forage.setItem(HEADER, encrypt({
+        expire,
+        token
+      }));
+      this.#mounted = true;
+      resolve(this);
+    });
+  }
+  ready() {
+    return this.#mount;
+  }
+  /**
+   * 校验存储是否过期
+   */
+  validateExpire() {
+    const expire = this.#expire;
+    return expire === void 0 || Date.now() < expire;
+  }
+  /**
+   * 校验
+   */
+  validate(callback, expireMessage) {
+    if (!this.#mounted) {
+      callback(new Error(MESSAGES.mount));
+    } else if (!this.#auth) {
+      callback(new Error(MESSAGES.auth));
+    } else if (expireMessage && !this.validateExpire()) {
+      callback(new Error(expireMessage));
+    } else {
+      callback();
+    }
+  }
+  /**
+   * 插入数据
+   */
+  async push(data) {
+    this.validate((e) => {
+      if (e) throw e;
+    }, MESSAGES.push);
+    const size = this.#size;
+    const key2 = structKey(size);
+    await this.#forage.setItem(key2, await this.#crypto.encrypt(data));
+    return this.#size = size + 1;
+  }
+  /**
+   * 修改数据
+   */
+  async update(index, data) {
+    this.validate((e) => {
+      if (e) throw e;
+    }, MESSAGES.update);
+    const forage = this.#forage;
+    const key2 = structKey(index);
+    const value = await forage.getItem(key2);
+    if (value === null) return false;
+    await forage.setItem(key2, await this.#crypto.encrypt(data));
+    return true;
+  }
+  /**
+   * 获取数据
+   */
+  async get(index) {
+    this.validate((e) => {
+      if (e) throw e;
+    }, MESSAGES.get);
+    const key2 = structKey(index);
+    const value = await this.#forage.getItem(key2);
+    return value === null ? null : await this.#crypto.decrypt(value);
+  }
+  /**
+   * 清理存储
+   */
+  async clear() {
+    this.validate((e) => {
+      if (e) throw e;
+    });
+    this.#size = 0;
+    await import_localforage.default.dropInstance({
+      name: this.#forage.config().name
+    });
+  }
+  static default(options) {
+    (0, import_lodash_es.isString)(options) && (options = { name: options });
+    return new _OfflineStorage({
+      ...options,
+      crypto: {
+        encrypt(plain) {
+          return plain;
+        },
+        decrypt(cipher) {
+          return cipher;
+        }
+      }
+    });
+  }
+  static async clear(token, callback) {
+    const size = PREFIX.length;
+    const databases = await indexedDB.databases();
+    const tasks = [];
+    for (const { name, version } of databases) {
+      if (name === void 0) continue;
+      let text;
+      try {
+        text = import_sm_crypto.sm4.decrypt(name, key, config);
+      } catch {
+        continue;
+      }
+      if (text.slice(0, size) !== PREFIX) continue;
+      const forage = createInstance(name, version);
+      const value = await forage.getItem(HEADER);
+      if (value === null || decrypt(value).token !== token || callback && callback(text.slice(size))) continue;
+      const idb = indexedDB.deleteDatabase(text);
+      tasks.push(new Promise((resolve) => {
+        idb.onerror = () => resolve();
+        idb.onsuccess = () => resolve();
+      }));
+    }
+    await Promise.all(tasks);
+  }
+};

package/sub_storage/offline.mjs

@@ -0,0 +1,223 @@
+import localforage from "localforage";
+import { isString } from "lodash-es";
+import { sm4 } from "sm-crypto";
+const NAME = "@vope/utils";
+const PREFIX = NAME + "_";
+const key = [25, 144, 1, 32, 25, 135, 6, 40, 32, 23, 18, 19, 32, 36, 9, 5];
+const iv = [182, 59, 9, 29, 86, 64, 118, 111, 112, 101, 47, 117, 116, 105, 108, 115];
+const config = {
+  output: "string",
+  mode: "cbc",
+  iv
+};
+const HEADER = "." + sm4.encrypt(NAME, key, config);
+const encrypt = (data) => {
+  let text = "";
+  for (const key2 in data) {
+    const value = data[key2];
+    if (value === void 0) continue;
+    text && (text += "&");
+    text += key2 + ":" + value;
+  }
+  return sm4.encrypt(text, key, config);
+};
+const decrypt = (text) => {
+  const data = {};
+  let value;
+  try {
+    value = sm4.decrypt(text, key, config);
+  } catch {
+    value = "";
+  }
+  value.split("&").forEach((pair) => {
+    const [key2, value2] = pair.split(":");
+    if (key2 === "expire") {
+      data[key2] = +value2;
+    } else {
+      data[key2] = value2;
+    }
+  });
+  return data;
+};
+const structKey = (index) => index.toString(16).padStart(8, "0");
+const reductKey = (key2) => parseInt(key2, 16);
+const MESSAGES = {
+  mount: "Please wait for the mounting to complete",
+  auth: "Unauthorized operation",
+  push: "Cannot add data to expired databases",
+  update: "Cannot update data to expired databases",
+  get: "Cannot get data from expired databases"
+};
+const createInstance = (name, version = 2) => localforage.createInstance({
+  driver: localforage.INDEXEDDB,
+  name,
+  version
+});
+class OfflineStorage {
+  #forage;
+  #expire;
+  #auth = false;
+  #crypto;
+  #size = 0;
+  #mount;
+  #mounted = false;
+  get size() {
+    return this.#size;
+  }
+  get mounted() {
+    return this.#mounted;
+  }
+  constructor({
+    name,
+    expire: newExpire,
+    token: newToken,
+    crypto
+  }) {
+    const forage = this.#forage = createInstance(sm4.encrypt(PREFIX + name, key, config));
+    this.#mount = new Promise(async (resolve) => {
+      const keys = await forage.keys().then((keys2) => keys2).catch(() => []);
+      let size = 0;
+      let expire = newExpire;
+      let token = newToken;
+      let auth = true;
+      for (const key2 of keys) {
+        if (key2 === HEADER) {
+          const {
+            expire: oldExpire,
+            token: oldToken
+          } = decrypt(await forage.getItem(key2));
+          expire = oldExpire === void 0 ? newExpire : Date.now() < oldExpire ? newExpire : oldExpire;
+          auth = oldToken ? oldToken === newToken : true;
+          token = oldToken || newToken;
+        } else {
+          const value = reductKey(key2) + 1;
+          value > size && (size = value);
+        }
+      }
+      this.#size = size;
+      this.#expire = expire;
+      this.#auth = auth;
+      this.#crypto = crypto;
+      await forage.setItem(HEADER, encrypt({
+        expire,
+        token
+      }));
+      this.#mounted = true;
+      resolve(this);
+    });
+  }
+  ready() {
+    return this.#mount;
+  }
+  /**
+   * 校验存储是否过期
+   */
+  validateExpire() {
+    const expire = this.#expire;
+    return expire === void 0 || Date.now() < expire;
+  }
+  /**
+   * 校验
+   */
+  validate(callback, expireMessage) {
+    if (!this.#mounted) {
+      callback(new Error(MESSAGES.mount));
+    } else if (!this.#auth) {
+      callback(new Error(MESSAGES.auth));
+    } else if (expireMessage && !this.validateExpire()) {
+      callback(new Error(expireMessage));
+    } else {
+      callback();
+    }
+  }
+  /**
+   * 插入数据
+   */
+  async push(data) {
+    this.validate((e) => {
+      if (e) throw e;
+    }, MESSAGES.push);
+    const size = this.#size;
+    const key2 = structKey(size);
+    await this.#forage.setItem(key2, await this.#crypto.encrypt(data));
+    return this.#size = size + 1;
+  }
+  /**
+   * 修改数据
+   */
+  async update(index, data) {
+    this.validate((e) => {
+      if (e) throw e;
+    }, MESSAGES.update);
+    const forage = this.#forage;
+    const key2 = structKey(index);
+    const value = await forage.getItem(key2);
+    if (value === null) return false;
+    await forage.setItem(key2, await this.#crypto.encrypt(data));
+    return true;
+  }
+  /**
+   * 获取数据
+   */
+  async get(index) {
+    this.validate((e) => {
+      if (e) throw e;
+    }, MESSAGES.get);
+    const key2 = structKey(index);
+    const value = await this.#forage.getItem(key2);
+    return value === null ? null : await this.#crypto.decrypt(value);
+  }
+  /**
+   * 清理存储
+   */
+  async clear() {
+    this.validate((e) => {
+      if (e) throw e;
+    });
+    this.#size = 0;
+    await localforage.dropInstance({
+      name: this.#forage.config().name
+    });
+  }
+  static default(options) {
+    isString(options) && (options = { name: options });
+    return new OfflineStorage({
+      ...options,
+      crypto: {
+        encrypt(plain) {
+          return plain;
+        },
+        decrypt(cipher) {
+          return cipher;
+        }
+      }
+    });
+  }
+  static async clear(token, callback) {
+    const size = PREFIX.length;
+    const databases = await indexedDB.databases();
+    const tasks = [];
+    for (const { name, version } of databases) {
+      if (name === void 0) continue;
+      let text;
+      try {
+        text = sm4.decrypt(name, key, config);
+      } catch {
+        continue;
+      }
+      if (text.slice(0, size) !== PREFIX) continue;
+      const forage = createInstance(name, version);
+      const value = await forage.getItem(HEADER);
+      if (value === null || decrypt(value).token !== token || callback && callback(text.slice(size))) continue;
+      const idb = indexedDB.deleteDatabase(text);
+      tasks.push(new Promise((resolve) => {
+        idb.onerror = () => resolve();
+        idb.onsuccess = () => resolve();
+      }));
+    }
+    await Promise.all(tasks);
+  }
+}
+export {
+  OfflineStorage
+};