gs-idb-pro 0.1.4 → 1.0.0

package/lib/{index.web.js → impl.cjs}

@@ -1,335 +1,8 @@
-const Save = Symbol("save"), Delete = Symbol("delete"), DbIteratorParsers = Object.freeze({
-  key: ({ primaryKey: value }) => ({ value }),
-  value: ({ value }) => ({ value }),
-  keyValue: ({ primaryKey: key, value }) => ({ value: [key, value] })
-});
-function parseDbNoneKeyPathRecord(record) {
-  if (Array.isArray(record))
-    return { key: record[1], value: record[0] };
-  if ("value" in record) {
-    const { key, value } = record;
-    return { key, value };
-  }
-  throw new Error(`not include value in invalid DBRecord：${JSON.stringify(record)}`);
-}
-const Break = Symbol("break"), Finished = Symbol("finished"), Continue = Symbol("continue"), ContinueKey = Symbol("continue key"), NextKey = Symbol("next key"), ContinuePrimaryKey = Symbol("continue primary key"), NextPrimaryKey = Symbol("next primary key");
-function isNativeTarget(target) {
-  return target instanceof IDBObjectStore || target instanceof IDBIndex;
-}
-const defaultStoreSchemaTemplate = Object.freeze({
-  keyPath: "id",
-  autoIncrement: !0,
-  addedTimeField: !0,
-  updatedTimeField: !0
-}), defaultSpecialFields = Object.freeze({
-  addedTimeField: "added_at",
-  softDeletedField: "deleted",
-  updatedCountField: "updated_count",
-  updatedTimeField: "updated_at"
-});
-function isFunction(value) {
-  return value instanceof Function || typeof value == "function";
-}
-function isArray(value) {
-  return Array.isArray(value) || value instanceof Array || value?.constructor === Array;
-}
-function isBoolean(value) {
-  return value === !0 || value === !1 || value instanceof Boolean || typeof value == "boolean";
-}
-function isNumber(value) {
-  return typeof value == "number" || value instanceof Number;
-}
-function isString(value) {
-  return typeof value == "string" || value instanceof String;
-}
-function isStrOrNum(value) {
-  return typeof value == "string" || typeof value == "number" || value instanceof String || value instanceof Number;
-}
-function isObject(value) {
-  return value && !isArray(value) && !isFunction(value) && (value instanceof Object || typeof value == "object");
-}
-function isIterable(obj) {
-  return obj != null && isFunction(obj[Symbol.iterator]);
-}
-function isAsyncIterable(obj) {
-  return obj != null && isFunction(obj[Symbol.asyncIterator]);
-}
-function isIterator(obj) {
-  return obj != null && typeof obj.next == "function";
-}
-async function asyncForEach(values, fn) {
-  for (let i = 0; i < values.length; i++)
-    await fn(values[i]);
-}
-async function asyncMap(data, fn) {
-  const arr = await data, result = [];
-  for (let i = 0; i < arr.length; i++)
-    result.push(await fn(arr[i], i, arr));
-  return result;
-}
-function destroy(obj) {
-  try {
-    obj?.destroy?.();
-  } catch {
-  }
-}
-function destroyRecords(...disposables) {
-  for (const disposable of disposables)
-    if (disposable)
-      for (const key of Object.keys(disposable))
-        try {
-          disposable[key]?.destroy?.();
-        } catch {
-        } finally {
-          delete disposable[key];
-        }
-}
-function copyObject(value) {
-  if (typeof value != "object" || value === null || value instanceof Date || value instanceof Function || value instanceof RegExp || typeof Element < "u" && value instanceof Element)
-    return value;
-  if (value instanceof Set) {
-    const set = /* @__PURE__ */ new Set();
-    for (const v of value)
-      set.add(copyObject(v));
-    return set;
-  }
-  if (value instanceof Map) {
-    const map = /* @__PURE__ */ new Map();
-    for (const [k2, v] of value)
-      map.set(copyObject(k2), copyObject(v));
-    return map;
-  }
-  if (Array.isArray(value)) {
-    const arr = [];
-    for (const v of value)
-      arr.push(copyObject(v));
-    return arr;
-  }
-  const obj = {};
-  for (const [k2, v] of Object.entries(value))
-    obj[k2] = copyObject(v);
-  return obj;
-}
-function copyFields(dist, src, fields) {
-  if (fields?.length)
-    for (const field of fields)
-      src.hasOwnProperty(field) && (dist[field] = src[field]);
-  else
-    Object.assign(dist, src);
-  return dist;
-}
-function deepFreeze(o) {
-  return Object.freeze(o), Object.getOwnPropertyNames(o).forEach((prop) => {
-    const value = o[prop];
-    value !== null && (typeof value == "object" || typeof value == "function") && !Object.isFrozen(value) && deepFreeze(value);
-  }), o;
-}
-class ToJsonContext {
-  rootData$;
-  space;
-  showFn;
-  spaceEffectiveLength;
-  out;
-  type;
-  ignoreCircularRef;
-  constructor(args) {
-    let i = 0;
-    isObject(args[i]) && args[i].rootData$ && Object.assign(this, args[i++]), i < 1 && (this.rootData$ = args[i++]);
-    const lastArgs = args.slice(i), numbers = lastArgs.filter((n) => isNumber(n));
-    this.out === void 0 && (this.out = lastArgs.find((f) => isFunction(f)) || null), this.showFn === void 0 && (this.showFn = !!lastArgs.find((s) => isBoolean(s))), this.spaceEffectiveLength === void 0 && (this.spaceEffectiveLength = numbers[0] || 100), this.space === void 0 && (this.space = numbers[1] || 2), this.type === void 0 && (this.type = lastArgs.find((s) => isString(s)) || "js"), this.ignoreCircularRef === void 0 && (this.ignoreCircularRef = !0);
-  }
-  destroy() {
-    this.out = null, this.rootData$ = null;
-  }
-}
-async function createJson(value, cfg, refSet) {
-  if (value = await value, typeof value == "string" || value instanceof Date)
-    return JSON.stringify(value);
-  if (value instanceof Function)
-    return cfg.showFn ? value.toString() : "undefined";
-  if (typeof value != "object" || value === null)
-    return value + "";
-  if (value instanceof RegExp)
-    return value.toString();
-  if (typeof Element < "u" && value instanceof Element)
-    return "undefined";
-  if (refSet.has(value)) {
-    if (cfg.ignoreCircularRef) return;
-    throw new Error("circular reference");
-  }
-  refSet.add(value);
-  try {
-    return cfg.type === "json" ? await toJsonTail(value, cfg, refSet) : await toJsJsonTail(value, cfg, refSet);
-  } finally {
-    refSet.delete(value);
-  }
-}
-async function toJsJsonTail(value, cfg, refSet) {
-  const arr = [];
-  if (value instanceof Set) {
-    for (const v of value)
-      (!isFunction(v) || cfg.showFn) && arr.push(await createJson(v, cfg, refSet));
-    const { spaceStart: spaceStart2, spaceEnd: spaceEnd2, arrJoin: arrJoin2 } = toJsJsonStringArgs(arr, cfg);
-    return arr.length ? `new Set([${spaceStart2}${arrJoin2()}${spaceEnd2}])` : "[]";
-  }
-  if (value instanceof Map) {
-    for (const [k2, v] of value)
-      (!isFunction(v) || cfg.showFn) && arr.push(`${objectKey(await createJson(k2, cfg, refSet))}: ${await createJson(v, cfg, refSet)}`);
-    const { spaceStart: spaceStart2, spaceEnd: spaceEnd2, arrJoin: arrJoin2 } = toJsJsonStringArgs(arr, cfg);
-    return arr.length ? `new Map(Object.entries({${spaceStart2}${arrJoin2()}${spaceEnd2}})` : "new Map()";
-  }
-  if (Array.isArray(value) || isIterable(value)) {
-    for (const v of value)
-      (!isFunction(v) || cfg.showFn) && arr.push(await createJson(v, cfg, refSet));
-    const { spaceStart: spaceStart2, spaceEnd: spaceEnd2, arrJoin: arrJoin2 } = toJsJsonStringArgs(arr, cfg);
-    return arr.length ? `[${spaceStart2}${arrJoin2()}${spaceEnd2}]` : "[]";
-  }
-  if (isIterator(value) || isAsyncIterable(value)) {
-    for await (const v of value)
-      (!isFunction(v) || cfg.showFn) && arr.push(await createJson(v, cfg, refSet));
-    const { spaceStart: spaceStart2, spaceEnd: spaceEnd2, arrJoin: arrJoin2 } = toJsJsonStringArgs(arr, cfg);
-    return arr.length ? `[${spaceStart2}${arrJoin2()}${spaceEnd2}]` : "[]";
-  }
-  for (const [k2, v] of Object.entries(value))
-    (!isFunction(v) || cfg.showFn) && arr.push(`${objectKey(k2)}: ${await createJson(v, cfg, refSet)}`);
-  const { spaceStart, spaceEnd, arrJoin } = toJsJsonStringArgs(arr, cfg);
-  return arr.length ? `{${spaceStart}${arrJoin()}${spaceEnd}}` : "{}";
-}
-async function toJsonTail(value, cfg, refSet) {
-  const arr = [];
-  if (Array.isArray(value) || value instanceof Set || isIterable(value) && !(value instanceof Map)) {
-    for (const v of value)
-      if (v !== void 0 && (!isFunction(v) || cfg.showFn)) {
-        const r = await createJson(v, cfg, refSet);
-        r !== void 0 && arr.push(r);
-      }
-    const { spaceStart: spaceStart2, spaceEnd: spaceEnd2, arrJoin: arrJoin2 } = toJsJsonStringArgs(arr, cfg);
-    return arr.length ? `[${spaceStart2}${arrJoin2()}${spaceEnd2}]` : "[]";
-  }
-  if (isAsyncIterable(value) || isIterator(value)) {
-    for await (const v of value)
-      if (v !== void 0 && (!isFunction(v) || cfg.showFn)) {
-        const r = await createJson(v, cfg, refSet);
-        r !== void 0 && arr.push(r);
-      }
-    const { spaceStart: spaceStart2, spaceEnd: spaceEnd2, arrJoin: arrJoin2 } = toJsJsonStringArgs(arr, cfg);
-    return arr.length ? `[${spaceStart2}${arrJoin2()}${spaceEnd2}]` : "[]";
-  }
-  let entries = value instanceof Map ? value.entries() : Object.entries(value);
-  for (const [k2, v] of entries)
-    if (v !== void 0 && (!isFunction(v) || cfg.showFn)) {
-      const r = await createJson(v, cfg, refSet);
-      r !== void 0 && arr.push(`"${k2}": ${r}`);
-    }
-  const { spaceStart, spaceEnd, arrJoin } = toJsJsonStringArgs(arr, cfg);
-  return arr.length ? `[${spaceStart}${arrJoin()}${spaceEnd}]` : "[]";
-}
-function toJsJsonStringArgs(arr, cfg) {
-  let space = cfg.space;
-  arr.reduce((acc, v) => acc + v.length, 0) < cfg.spaceEffectiveLength && (space = 0);
-  const spaceStart = space ? `
-` + "".padStart(space) : "", spaceEnd = space ? `
-` : "", separator = space ? `
-`.padEnd(space + 1) : ",";
-  return { spaceStart, spaceEnd, arrJoin: space ? () => arr.join(`,
-`).replace(/\n/g, separator) : () => arr.join(",") };
-}
-function objectKey(key) {
-  return /^[a-z_]+\w*$/i.test(key) ? key : `"${key}"`;
-}
-async function toJson(...args) {
-  const arg = new ToJsonContext(args), refSet = /* @__PURE__ */ new Set();
-  try {
-    const result = await createJson(arg.rootData$, arg, refSet);
-    if (!arg.out) return result;
-    arg.out(result);
-  } finally {
-    refSet.clear(), arg.destroy();
-  }
-}
-async function logJson(...args) {
-  const out = globalThis.top?.console?.log || console.log;
-  args.push(out), await toJson(...args);
-}
-var Bool = /* @__PURE__ */ ((Bool2) => (Bool2[Bool2.True = 1] = "True", Bool2[Bool2.False = 0] = "False", Bool2))(Bool || {});
-function isDbKey(key) {
-  return isStrOrNum(key) || key instanceof Date || key instanceof ArrayBuffer || Array.isArray(key) && key.every(isDbKey);
-}
-function isDbQuery(value) {
-  return value instanceof IDBKeyRange || isDbKey(value);
-}
-function isDbQueryOrNull(value) {
-  return value == null || isDbQuery(value);
-}
-async function findExistDb(dbName) {
-  return (await indexedDB.databases()).find((info) => info.name === dbName);
-}
-function requestDb(request, onsuccess, onupgradeneeded2) {
-  return new Promise(async (resolve, reject) => {
-    let hasError = !1;
-    request.onsuccess = async () => {
-      if (!hasError)
-        if (onsuccess)
-          try {
-            resolve(await onsuccess(request.result));
-          } catch (e) {
-            reject(e);
-          } finally {
-            request.result?.close?.();
-          }
-        else resolve(request.result);
-    }, request.onblocked = request.onerror = (e) => reject(e.target.error), onupgradeneeded2 && (request.onupgradeneeded = async (ev) => {
-      try {
-        await onupgradeneeded2(request.result, ev, request);
-      } catch (e) {
-        hasError = !0, reject(e);
-      }
-    });
-  });
-}
-async function openDb(nameOrArg, fn) {
-  const arg = isString(nameOrArg) ? { name: nameOrArg } : nameOrArg;
-  isFunction(fn) && (arg.onsuccess = fn);
-  const { name, onsuccess, onupgradeneeded: onupgradeneeded2, version } = arg;
-  return requestDb(indexedDB.open(name, version), onsuccess, onupgradeneeded2);
-}
-function openTx(db, storeName2, ...args) {
-  return new Promise(async (resolve, reject) => {
-    let i = 0;
-    const fn = isFunction(args[i]) ? args[i++] : void 0, writeable = args[i] ? "readwrite" : "readonly", nativeDb = db instanceof IDBDatabase ? db : await openDb(db), storeNames = Array.isArray(storeName2) ? storeName2 : [storeName2], tx = nativeDb.transaction(storeNames.map((s) => isString(s) ? s : s.store), writeable), storeOrIndexes = storeNames.map((n) => {
-      if (isString(n)) return tx.objectStore(n);
-      const { store, index } = n;
-      return isString(index) ? tx.objectStore(store).index(index) : tx.objectStore(store);
-    });
-    if (fn)
-      try {
-        resolve(await fn(...storeOrIndexes)), writeable ? tx.commit() : tx.abort();
-      } catch (e) {
-        tx.abort(), reject(e);
-      } finally {
-        nativeDb.close();
-      }
-    else
-      resolve(storeOrIndexes);
-  });
-}
-function readTx(db, storeName2, fn) {
-  return openTx(db, storeName2, fn, !1);
-}
-function requestDbResult(request) {
-  return new Promise(async (resolve, reject) => {
-    request.onsuccess = () => {
-      try {
-        resolve(request.result);
-      } catch (e) {
-        reject(e);
-      }
-    }, request.onerror = (e) => reject(e.target.error);
-  });
-}
-const DefaultDbName = "gs-idb", DefaultStorageStoreName = "gs-storage-map", toNum = (v) => v instanceof Date ? v.getTime() : v;
+"use strict";
+var type$1 = require('./type.cjs'), types = require('gs-base/types'), store = require('gs-idb-basic/store'), type = require('gs-idb-basic/type'), basic = require('gs-base/basic'), json = require('gs-base/json'), tx = require('gs-idb-basic/tx'), db = require('gs-idb-basic/db'), storage = require('gs-idb-basic/storage');
+const toNum = (v) => v instanceof Date ? v.getTime() : v;
 function parseIDbQuery(query) {
-  if (isDbQueryOrNull(query) || !isObject(query))
+  if (type.isDbQueryOrNull(query) || !types.isObject(query))
     return query;
   const range = query;
   if ("lt" in range && "gt" in range) {
@@ -362,17 +35,17 @@ function isIDbQuery(query) {
 }
 async function openCursor(target, arg, fn) {
   const { query, direction = "prev", preSkip, startKey, startPrimaryKey } = arg, request = target.openCursor(parseIDbQuery(query), direction);
-  return preSkip && (await requestDbResult(request)).advance(preSkip), startKey && (startPrimaryKey ? (await requestDbResult(request)).continuePrimaryKey(startKey, startPrimaryKey) : (await requestDbResult(request)).continue(startKey)), request;
+  return preSkip && (await store.requestDbResult(request)).advance(preSkip), startKey && (startPrimaryKey ? (await store.requestDbResult(request)).continuePrimaryKey(startKey, startPrimaryKey) : (await store.requestDbResult(request)).continue(startKey)), request;
 }
 function getMapperFn(mapper, keyPath, useArrayRecord) {
-  return Array.isArray(mapper) ? (v) => copyFields({}, v, mapper) : isFunction(mapper) ? mapper : keyPath ? (v) => v : useArrayRecord ? (v, k) => [v, k] : (key, value) => ({ key, value });
+  return Array.isArray(mapper) ? (v) => basic.copyFields({}, v, mapper) : types.isFunction(mapper) ? mapper : keyPath ? (v) => v : useArrayRecord ? (v, k) => [v, k] : (key, value) => ({ key, value });
 }
 class DataOperationBase {
   idbPro;
   target;
   #storeSchema;
-  constructor(schema, db) {
-    this.idbPro = db, this.#storeSchema = schema.storeSchema, this.target = schema.target, isNativeTarget(schema.target) && (this.tx = this.#nativeOperation);
+  constructor(schema, db2) {
+    this.idbPro = db2, this.#storeSchema = schema.storeSchema, this.target = schema.target, type$1.isNativeTarget(schema.target) && (this.tx = this.#nativeOperation);
   }
   get storeName() {
     return this.nativeStore?.name || this.target.store;
@@ -392,40 +65,40 @@ class DataOperationBase {
   }
   get keyPath() {
     const { target } = this;
-    if (isNativeTarget(target))
+    if (type$1.isNativeTarget(target))
       return target.keyPath;
     const { storeSchema } = this, { index } = target;
     return index ? storeSchema.indexSchemas.find((i) => i.name === index)?.keyPath : storeSchema.keyPath;
   }
   async forEach(arg, returns) {
-    return arg = isFunction(arg) ? { fn: arg } : arg, returns ? this.cursorResult(arg, !1) : this.cursorVoid(arg, !1);
+    return arg = types.isFunction(arg) ? { fn: arg } : arg, returns ? this.cursorResult(arg, !1) : this.cursorVoid(arg, !1);
   }
   async tx(writable, fn, rollbackOnError) {
     let { target } = this;
-    const { store, index } = target, db = await this.idbPro.openNativeDb();
-    let tx, nativeStore;
+    const { store: store2, index } = target, db2 = await this.idbPro.openNativeDb();
+    let tx2, nativeStore;
     try {
-      tx = db.transaction(store, writable === !0 ? "readwrite" : "readonly"), target = nativeStore = tx.objectStore(store), index && (target = target.index(index));
+      tx2 = db2.transaction(store2, writable === !0 ? "readwrite" : "readonly"), target = nativeStore = tx2.objectStore(store2), index && (target = target.index(index));
     } catch (e) {
-      throw db.close(), e;
+      throw db2.close(), e;
     }
     if (!fn)
-      return Object.freeze({ db, tx, nativeStore, target });
+      return Object.freeze({ db: db2, tx: tx2, nativeStore, target });
     try {
       if (writable === !0) {
         const result = await fn(target, nativeStore);
-        return tx.commit(), result;
+        return tx2.commit(), result;
       }
       return fn(target);
     } catch (e) {
-      throw rollbackOnError !== !1 && tx.abort(), e;
+      throw rollbackOnError !== !1 && tx2.abort(), e;
     } finally {
-      db.close();
+      db2.close();
     }
   }
   openCursor(arg, writable) {
-    return this.tx(writable, (store) => new Promise(async (resolve, reject) => {
-      const { fn } = arg, request = await openCursor(store, arg);
+    return this.tx(writable, (store2) => new Promise(async (resolve, reject) => {
+      const { fn } = arg, request = await openCursor(store2, arg);
       request.onsuccess = async () => {
         request.result ? await fn(request.result) === !1 && resolve() : resolve();
       }, request.onerror = () => reject(request.error);
@@ -446,14 +119,14 @@ class DataOperationBase {
           primaryKey,
           modify,
           value
-        } = isObject(result) ? result : { control: result };
-        switch (writable && (modify === Save ? cursor.update(value || ov) : modify === Delete && cursor.delete()), control) {
-          case Break:
+        } = types.isObject(result) ? result : { control: result };
+        switch (writable && (modify === type$1.Save ? cursor.update(value || ov) : modify === type$1.Delete && cursor.delete()), control) {
+          case type$1.Break:
             return !1;
-          case ContinueKey:
+          case type$1.ContinueKey:
             cursor.continue(key);
             break;
-          case ContinuePrimaryKey:
+          case type$1.ContinuePrimaryKey:
             cursor.continuePrimaryKey(key, primaryKey);
             break;
           default:
@@ -487,16 +160,16 @@ class DataOperationBase {
           primaryKey,
           modify
         } = await fn?.(ov, op, i, results) || {};
-        switch (writable && (modify === Save ? cursor.update(value || ov) : modify === Delete && cursor.delete()), (!control || control === Finished || control === NextKey || control === NextPrimaryKey) && results.push(mapper(value || ov, primaryKey || op, i)), control) {
-          case Break:
-          case Finished:
+        switch (writable && (modify === type$1.Save ? cursor.update(value || ov) : modify === type$1.Delete && cursor.delete()), (!control || control === type$1.Finished || control === type$1.NextKey || control === type$1.NextPrimaryKey) && results.push(mapper(value || ov, primaryKey || op, i)), control) {
+          case type$1.Break:
+          case type$1.Finished:
             return !1;
-          case NextKey:
-          case ContinueKey:
+          case type$1.NextKey:
+          case type$1.ContinueKey:
             cursor.continue(key);
             break;
-          case NextPrimaryKey:
-          case ContinuePrimaryKey:
+          case type$1.NextPrimaryKey:
+          case type$1.ContinuePrimaryKey:
             cursor.continuePrimaryKey(key, primaryKey);
             break;
           default:
@@ -531,8 +204,8 @@ class DataOperators {
   export() {
     return this.tx("newReader", async (...stores) => {
       const result = {};
-      for (const store of stores)
-        result[store.storeName] = await store.export();
+      for (const store2 of stores)
+        result[store2.storeName] = await store2.export();
       return result;
     });
   }
@@ -540,28 +213,28 @@ class DataOperators {
     return use || (use = "addOrChangeMany"), this.tx("newWriter", async (...stores) => {
       const result = {};
       stores = Array.from(new Map(stores.map((s) => [s.storeName, s.asStore(!0)])).values());
-      for (const store of stores) {
-        const { storeName } = store, rows = data[storeName];
-        rows && (result[storeName] = await store[use](rows, returns));
+      for (const store2 of stores) {
+        const { storeName } = store2, rows = data[storeName];
+        rows && (result[storeName] = await store2[use](rows, returns));
       }
       if (returns) return result;
     }, !0);
   }
   async tx(method, fn, writable, rollbackOnError) {
-    const { idbPro, schemas } = this, { factory } = idbPro.schema, db = await idbPro.openNativeDb();
+    const { idbPro, schemas } = this, { factory } = idbPro.schema, db2 = await idbPro.openNativeDb();
     try {
-      const tx = db.transaction(this.storeNames, writable ? "readwrite" : "readonly");
+      const tx2 = db2.transaction(this.storeNames, writable ? "readwrite" : "readonly");
       try {
         const stores = schemas.map(({ storeSchema, target: info }) => {
-          let target = tx.objectStore(info.store);
+          let target = tx2.objectStore(info.store);
           return info.index && (target = target.index(info.index)), factory[method]({ storeSchema, target }, idbPro);
         });
         return await fn(...stores);
       } catch (e) {
-        throw rollbackOnError !== !1 && tx.abort(), e;
+        throw rollbackOnError !== !1 && tx2.abort(), e;
       }
     } finally {
-      db.close();
+      db2.close();
     }
   }
 }
@@ -574,20 +247,20 @@ class DbIterator extends DataOperationBase {
   preSkip;
   startKey;
   startPrimaryKey;
-  constructor(schema, db, option) {
-    if (super(schema, db), !option) return;
+  constructor(schema, db2, option) {
+    if (super(schema, db2), !option) return;
     const { parser } = option;
-    this.direction = option.direction, this.query = option.query, this.writable = !!option.writable, this.endsWithNull = !!option.endsWithNull, this.preSkip = option.preSkip, this.startKey = option.startKey, this.startPrimaryKey = option.startPrimaryKey, parser && (this.parser = isFunction(parser) ? parser : DbIteratorParsers[parser]);
+    this.direction = option.direction, this.query = option.query, this.writable = !!option.writable, this.endsWithNull = !!option.endsWithNull, this.preSkip = option.preSkip, this.startKey = option.startKey, this.startPrimaryKey = option.startPrimaryKey, parser && (this.parser = types.isFunction(parser) ? parser : type$1.DbIteratorParsers[parser]);
   }
   async *[Symbol.asyncIterator]() {
-    const { parser, writable, endsWithNull } = this, { db, tx, target } = await this.tx(writable);
+    const { parser, writable, endsWithNull } = this, { db: db2, tx: tx2, target } = await this.tx(writable);
     try {
       const request = await openCursor(target, this);
       let cursor;
       if (parser)
-        for (; cursor = await requestDbResult(request); ) {
+        for (; cursor = await store.requestDbResult(request); ) {
           const { control, value } = await parser(cursor);
-          if (control || (yield value), control === Break) break;
+          if (control || (yield value), control === type$1.Break) break;
           cursor.continue();
         }
       else {
@@ -595,23 +268,23 @@ class DbIterator extends DataOperationBase {
         const end = () => {
           ended = !0;
         };
-        for (; !ended && (cursor = await requestDbResult(request)); )
+        for (; !ended && (cursor = await store.requestDbResult(request)); )
           yield { cursor, end };
       }
-      writable && tx?.commit(), endsWithNull && !cursor && (yield null);
+      writable && tx2?.commit(), endsWithNull && !cursor && (yield null);
     } finally {
-      db?.close();
+      db2?.close();
     }
   }
 }
 function parseFilterArg(arg1, arg2, arg3, limit) {
-  const args = isObject(arg1) ? arg1 : {};
-  return isFunction(arg1) ? args.fn = arg1 : isIDbQuery(arg1) && (args.query = arg1), isFunction(arg2) ? args.fn = arg2 : arg2 && (args.direction = arg2), arg3 && (args.direction = arg3), limit ? args.limit = limit : args.limit || (args.limit = 1e3), args.maxEmptyChecks || (args.maxEmptyChecks = 2e4), args;
+  const args = types.isObject(arg1) ? arg1 : {};
+  return types.isFunction(arg1) ? args.fn = arg1 : isIDbQuery(arg1) && (args.query = arg1), types.isFunction(arg2) ? args.fn = arg2 : arg2 && (args.direction = arg2), arg3 && (args.direction = arg3), limit ? args.limit = limit : args.limit || (args.limit = 1e3), args.maxEmptyChecks || (args.maxEmptyChecks = 2e4), args;
 }
 async function queryPage(anyReader, info, arg) {
   info.size || (info.size = 100), info.nextSkip || (info.nextSkip = 0);
   const { query, direction, total, maxEmptyChecks, fn } = info;
-  return await anyReader.batchRead(async (nativeReader) => (total || (info.total = await nativeReader.count({ query, direction, maxEmptyChecks, fn }), info.pages = Math.ceil(info.total / info.size)), info.total < 1 ? { info: deepFreeze(info), rows: [] } : fn ? await queryFnPage(nativeReader, info, arg) : await queryNoneFnPage(nativeReader, info)));
+  return await anyReader.batchRead(async (nativeReader) => (total || (info.total = await nativeReader.count({ query, direction, maxEmptyChecks, fn }), info.pages = Math.ceil(info.total / info.size)), info.total < 1 ? { info: basic.deepFreeze(info), rows: [] } : fn ? await queryFnPage(nativeReader, info, arg) : await queryNoneFnPage(nativeReader, info)));
 }
 async function queryNoneFnPage(nativeReader, info) {
   const { keyPath } = nativeReader.storeSchema, { page, query, direction, size, mapper } = info, preSkip = (page - 1) * size, rows = await nativeReader.filter({
@@ -622,7 +295,7 @@ async function queryNoneFnPage(nativeReader, info) {
     mapper: getMapperFn(mapper, keyPath, !0)
   });
   return info.nextSkip = preSkip + rows.length, {
-    info: deepFreeze(info),
+    info: basic.deepFreeze(info),
     rows
   };
 }
@@ -637,7 +310,7 @@ async function queryFnPage(reader, info, arg) {
 }
 async function queryFnRow({ storeSchema: { defaultGetMapper } }, request, info, keyPath, hasSkip) {
   const { page, size, total, maxEmptyChecks, fn } = info, mapper = getMapperFn(info.mapper || defaultGetMapper, keyPath, !0), rows = [], preSkip = (page - 1) * info.size;
-  if (preSkip >= total) return { info: deepFreeze(info), rows: [] };
+  if (preSkip >= total) return { info: basic.deepFreeze(info), rows: [] };
   let i = 0;
   return await new Promise(async (resolve, reject) => {
     let ept = 0, skipped = 0;
@@ -660,19 +333,19 @@ async function queryFnRow({ storeSchema: { defaultGetMapper } }, request, info,
       cursor.continue(), i++;
     } : request.onsuccess = rowFn;
   }), i && (info.nextSkip += i + 1), {
-    info: deepFreeze(info),
+    info: basic.deepFreeze(info),
     rows
   };
 }
 class DataReader extends DataOperationBase {
   all(query, limit) {
     const param = isIDbQuery(query) ? { query } : query || {};
-    return isNumber(limit) && (param.count = limit), isNumber(param.count) || (param.count = 1e3), param.query = parseIDbQuery(param.query), this.tx(!1, (store) => requestDbResult(store.getAll(param)));
+    return types.isNumber(limit) && (param.count = limit), types.isNumber(param.count) || (param.count = 1e3), param.query = parseIDbQuery(param.query), this.tx(!1, (store$1) => store.requestDbResult(store$1.getAll(param)));
   }
   async count(arg1, arg2, arg3) {
     const args = parseFilterArg(arg1, arg2, arg3), { query, direction, fn } = args;
     if (!fn)
-      return await this.tx(!1, (store) => requestDbResult(store.count(parseIDbQuery(query))));
+      return await this.tx(!1, (store$1) => store.requestDbResult(store$1.count(parseIDbQuery(query))));
     const { maxEmptyChecks } = args, findFn = fn;
     let count = 0, ept = 0, i = 0;
     return await this.openCursor({
@@ -688,11 +361,11 @@ class DataReader extends DataOperationBase {
     }), count;
   }
   get(key) {
-    return this.tx(!1, (store) => requestDbResult(store.get(parseIDbQuery(key))));
+    return this.tx(!1, (store$1) => store.requestDbResult(store$1.get(parseIDbQuery(key))));
   }
   getMany(keys, excludeEmpty) {
     return this.batchRead(async (reader) => {
-      const rows = await asyncMap(keys, (k) => reader.get(k));
+      const rows = await basic.asyncMap(keys, (k) => reader.get(k));
       return excludeEmpty ? rows.filter((v) => v) : rows;
     });
   }
@@ -700,7 +373,7 @@ class DataReader extends DataOperationBase {
     return this.forEach({ query, direction }, !0);
   }
   async getRangeMany(keys, direction, excludeEmpty) {
-    return (await this.batchRead((w) => asyncMap(keys, (v) => w.getRange(v, direction)))).flat();
+    return (await this.batchRead((w) => basic.asyncMap(keys, (v) => w.getRange(v, direction)))).flat();
   }
   index(name, writable) {
     let { target } = this;
@@ -720,14 +393,14 @@ class DataReader extends DataOperationBase {
     return this.createOperator(target, writable);
   }
   batchRead(fn) {
-    return isNativeTarget(this.target) ? fn(this) : this.tx(!1, (store) => fn(this.idbPro.schema.factory.newReader({
+    return type$1.isNativeTarget(this.target) ? fn(this) : this.tx(!1, (store2) => fn(this.idbPro.schema.factory.newReader({
       storeSchema: this.storeSchema,
-      target: store
+      target: store2
     }, this.idbPro)));
   }
   iterator(query, direction) {
     const arg = {};
-    return isString(direction) && (arg.direction = direction), isIDbQuery(query) ? arg.query = query : isObject(query) && Object.assign(arg, query), new DbIterator({ storeSchema: this.storeSchema, target: this.target }, this.idbPro, {
+    return types.isString(direction) && (arg.direction = direction), isIDbQuery(query) ? arg.query = query : types.isObject(query) && Object.assign(arg, query), new DbIterator({ storeSchema: this.storeSchema, target: this.target }, this.idbPro, {
       ...arg,
       parser: "value"
     });
@@ -740,7 +413,7 @@ class DataReader extends DataOperationBase {
         mapper,
         fn: (value, k, i) => {
           if (i >= limit - 1)
-            return { control: Finished };
+            return { control: type$1.Finished };
         }
       }, !0);
     let ept = 0;
@@ -751,9 +424,9 @@ class DataReader extends DataOperationBase {
         if (fn(value, k, i))
           ept = 0;
         else
-          return ++ept >= maxEmptyChecks ? { control: Break } : { control: Continue };
+          return ++ept >= maxEmptyChecks ? { control: type$1.Break } : { control: type$1.Continue };
         if (results.length >= limit - 1)
-          return { control: Finished };
+          return { control: type$1.Finished };
       }
     }, !0);
   }
@@ -809,7 +482,7 @@ function checkAddValue(storeSchema, value) {
     updatedCountField,
     softDeletedField
   } = storeSchema;
-  return value = { ...value }, addedTimeField?.name && !isNumber(value[addedTimeField.name]) && (value[addedTimeField.name] = Date.now()), updatedTimeField?.name && !isNumber(value[updatedTimeField.name]) && (value[updatedTimeField.name] = Date.now()), softDeletedField?.name && !isNumber(value[softDeletedField.name]) && (value[softDeletedField.name] = 0), updatedCountField?.name && (value[updatedCountField.name] = 0), value;
+  return value = { ...value }, addedTimeField?.name && !types.isNumber(value[addedTimeField.name]) && (value[addedTimeField.name] = Date.now()), updatedTimeField?.name && !types.isNumber(value[updatedTimeField.name]) && (value[updatedTimeField.name] = Date.now()), softDeletedField?.name && !types.isNumber(value[softDeletedField.name]) && (value[softDeletedField.name] = 0), updatedCountField?.name && (value[updatedCountField.name] = 0), value;
 }
 function checkUpdateValue(storeSchema, newValue, oldValue) {
   if (!newValue || !(newValue instanceof Object) || Array.isArray(newValue)) return newValue;
@@ -823,23 +496,23 @@ class DataWriter extends DataReader {
   add(record) {
     return this.changeByPk({
       record,
-      fn: async (store, pk, newValue, oldValue, keyPath) => {
+      fn: async (store$1, pk, newValue, oldValue, keyPath) => {
         const { storeSchema } = this;
-        return newValue = checkAddValue(storeSchema, newValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await requestDbResult(store.add(newValue))) }, pk] : [newValue, await requestDbResult(store.add(newValue, pk))];
+        return newValue = checkAddValue(storeSchema, newValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await store.requestDbResult(store$1.add(newValue))) }, pk] : [newValue, await store.requestDbResult(store$1.add(newValue, pk))];
       }
     });
   }
   addMany(records, returns) {
-    return this.batchWrite((w) => returns ? asyncMap(records, (v) => w.add(v)) : asyncForEach(records, (v) => w.add(v)), !0);
+    return this.batchWrite((w) => returns ? basic.asyncMap(records, (v) => w.add(v)) : basic.asyncForEach(records, (v) => w.add(v)), !0);
   }
   addOrSkip(record) {
     return this.batchWrite(async (w) => {
       const { keyPath: storeKeyPath, defaultGetMapper } = w.storeSchema, { key: pk, value } = storeKeyPath ? {
         key: getValidKeyValue(storeKeyPath, record),
         value: record
-      } : parseDbNoneKeyPathRecord(record);
+      } : type$1.parseDbNoneKeyPathRecord(record);
       if (pk) {
-        const item = await requestDbResult(w.nativeStore.get(pk));
+        const item = await store.requestDbResult(w.nativeStore.get(pk));
         if (item)
           return getMapperFn(defaultGetMapper, storeKeyPath)?.(item, pk);
       }
@@ -853,24 +526,24 @@ class DataWriter extends DataReader {
     });
   }
   addOrSkipMany(records, returns) {
-    return this.batchWrite((w) => returns ? asyncMap(records, (v) => w.addOrSkip(v)) : asyncForEach(records, (v) => w.addOrSkip(v)), !0);
+    return this.batchWrite((w) => returns ? basic.asyncMap(records, (v) => w.addOrSkip(v)) : basic.asyncForEach(records, (v) => w.addOrSkip(v)), !0);
   }
   replace(record) {
     return this.changeByPk({
       record,
       getOld: !0,
-      fn: async (store, pk, newValue, oldValue, keyPath) => {
+      fn: async (store$1, pk, newValue, oldValue, keyPath) => {
         const { storeSchema } = this, { updatedTimeField, updatedCountField, addedTimeField } = storeSchema;
         return oldValue ? newValue = checkUpdateValue(storeSchema, newValue, {
           [updatedTimeField.name]: oldValue[updatedTimeField.name],
           [updatedCountField.name]: oldValue[updatedCountField.name],
           [addedTimeField.name]: oldValue[addedTimeField.name]
-        }) : newValue = checkAddValue(storeSchema, newValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await requestDbResult(store.put(newValue))) }, pk] : [newValue, await requestDbResult(store.put(newValue, pk))];
+        }) : newValue = checkAddValue(storeSchema, newValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await store.requestDbResult(store$1.put(newValue))) }, pk] : [newValue, await store.requestDbResult(store$1.put(newValue, pk))];
       }
     });
   }
   replaceMany(records, returns) {
-    return this.batchWrite((w) => returns ? asyncMap(records, (v) => w.replace(v)) : asyncForEach(records, (v) => w.replace(v)), !0);
+    return this.batchWrite((w) => returns ? basic.asyncMap(records, (v) => w.replace(v)) : basic.asyncForEach(records, (v) => w.replace(v)), !0);
   }
   change(record, throwIfMissing) {
     return this.changeByPk({
@@ -878,10 +551,10 @@ class DataWriter extends DataReader {
       getOld: !0,
       requiredOld: throwIfMissing,
       requiredPk: throwIfMissing,
-      fn: async (store, pk, newValue, oldValue, keyPath) => {
+      fn: async (store$1, pk, newValue, oldValue, keyPath) => {
         const { storeSchema } = this;
         if (oldValue)
-          return newValue = checkUpdateValue(storeSchema, newValue, oldValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await requestDbResult(store.put(newValue))) }, pk] : [newValue, await requestDbResult(store.put(newValue, pk))];
+          return newValue = checkUpdateValue(storeSchema, newValue, oldValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await store.requestDbResult(store$1.put(newValue))) }, pk] : [newValue, await store.requestDbResult(store$1.put(newValue, pk))];
       }
     });
   }
@@ -889,55 +562,55 @@ class DataWriter extends DataReader {
     const {
       returns,
       throwIfMissing
-    } = isBoolean(option) ? { returns: option } : option || {};
-    return this.batchWrite((w) => returns ? asyncMap(records, (v) => w.change(v, throwIfMissing)) : asyncForEach(records, (v) => w.change(v, throwIfMissing)), !0);
+    } = types.isBoolean(option) ? { returns: option } : option || {};
+    return this.batchWrite((w) => returns ? basic.asyncMap(records, (v) => w.change(v, throwIfMissing)) : basic.asyncForEach(records, (v) => w.change(v, throwIfMissing)), !0);
   }
   addOrChange(record) {
     return this.changeByPk({
       record,
       getOld: !0,
-      fn: async (store, pk, newValue, oldValue, keyPath) => {
+      fn: async (store$1, pk, newValue, oldValue, keyPath) => {
         const { storeSchema } = this;
-        return oldValue ? (newValue = checkUpdateValue(storeSchema, newValue, oldValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await requestDbResult(store.put(newValue))) }, pk] : [newValue, await requestDbResult(store.put(newValue, pk))]) : (newValue = checkAddValue(storeSchema, newValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await requestDbResult(store.add(newValue))) }, pk] : [newValue, await requestDbResult(store.add(newValue, pk))]);
+        return oldValue ? (newValue = checkUpdateValue(storeSchema, newValue, oldValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await store.requestDbResult(store$1.put(newValue))) }, pk] : [newValue, await store.requestDbResult(store$1.put(newValue, pk))]) : (newValue = checkAddValue(storeSchema, newValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await store.requestDbResult(store$1.add(newValue))) }, pk] : [newValue, await store.requestDbResult(store$1.add(newValue, pk))]);
       }
     });
   }
   addOrChangeMany(records, returns) {
-    return this.batchWrite((w) => returns ? asyncMap(records, (v) => w.addOrChange(v)) : asyncForEach(records, (v) => w.addOrChange(v)), !0);
+    return this.batchWrite((w) => returns ? basic.asyncMap(records, (v) => w.addOrChange(v)) : basic.asyncForEach(records, (v) => w.addOrChange(v)), !0);
   }
   delete(pk, returns) {
     const {
       returns: getOld,
       physical
-    } = isBoolean(returns) ? { returns } : returns || {}, { storeSchema } = this, softDeletedField = storeSchema.softDeletedField, requiredOld = !!(!physical && softDeletedField?.name);
+    } = types.isBoolean(returns) ? { returns } : returns || {}, { storeSchema } = this, softDeletedField = storeSchema.softDeletedField, requiredOld = !!(!physical && softDeletedField?.name);
     return this.changeByPk({
       pk,
       getOld: requiredOld || getOld,
-      fn: (store, pk2, newValue, oldValue) => {
-        if (requiredOld ? oldValue && (oldValue = checkUpdateValue(storeSchema, { [softDeletedField.name]: Bool.True }, oldValue), store.put(oldValue)) : store.delete(pk2), !!getOld)
+      fn: (store2, pk2, newValue, oldValue) => {
+        if (requiredOld ? oldValue && (oldValue = checkUpdateValue(storeSchema, { [softDeletedField.name]: type.Bool.True }, oldValue), store2.put(oldValue)) : store2.delete(pk2), !!getOld)
           return [oldValue, pk2];
       }
     });
   }
   deleteMany(keys, returns) {
-    const { returns: hasRtn } = isBoolean(returns) ? { returns } : returns || {};
-    return this.batchWrite((w) => hasRtn ? asyncMap(keys, (v) => w.delete(v, !0)) : asyncForEach(keys, (v) => w.delete(v)), !0);
+    const { returns: hasRtn } = types.isBoolean(returns) ? { returns } : returns || {};
+    return this.batchWrite((w) => hasRtn ? basic.asyncMap(keys, (v) => w.delete(v, !0)) : basic.asyncForEach(keys, (v) => w.delete(v)), !0);
   }
   deleteRange(query, returns) {
     const {
       returns: hasRtn,
       physical,
       direction
-    } = isBoolean(returns) ? { returns } : returns || {}, { name } = this.storeSchema.softDeletedField || {};
+    } = types.isBoolean(returns) ? { returns } : returns || {}, { name } = this.storeSchema.softDeletedField || {};
     return this.cursor({
       query,
       direction,
-      fn: (value) => physical || !name ? { modify: Delete } : (value[name] = Bool.True, { modify: Save })
+      fn: (value) => physical || !name ? { modify: type$1.Delete } : (value[name] = type.Bool.True, { modify: type$1.Save })
     }, hasRtn);
   }
   deleteRangeMany(keys, returns) {
-    const option = isBoolean(returns) ? { returns } : returns;
-    return this.batchWrite((w) => option?.returns ? asyncMap(keys, (v) => w.deleteRange(v, option)) : asyncForEach(keys, (v) => w.deleteRange(v, option)), !0);
+    const option = types.isBoolean(returns) ? { returns } : returns;
+    return this.batchWrite((w) => option?.returns ? basic.asyncMap(keys, (v) => w.deleteRange(v, option)) : basic.asyncForEach(keys, (v) => w.deleteRange(v, option)), !0);
   }
   changeRange(arg, returns) {
     let {
@@ -950,26 +623,26 @@ class DataWriter extends DataReader {
     return this.cursor({
       query,
       direction,
-      fn: (value) => value instanceof Object ? { modify: Save, value: { ...value, ...newValue } } : { modify: Save, value: newValue }
+      fn: (value) => value instanceof Object ? { modify: type$1.Save, value: { ...value, ...newValue } } : { modify: type$1.Save, value: newValue }
     }, returns);
   }
   changeRangeMany(args, returns) {
-    return this.batchWrite((w) => returns ? asyncMap(args, (v) => w.changeRange(v, returns)) : asyncForEach(args, (v) => w.changeRange(v, returns)), !0);
+    return this.batchWrite((w) => returns ? basic.asyncMap(args, (v) => w.changeRange(v, returns)) : basic.asyncForEach(args, (v) => w.changeRange(v, returns)), !0);
   }
   cursor(arg, returns) {
-    return arg = isFunction(arg) ? { fn: arg } : arg || {}, arg.fn ? returns ? this.cursorResult(arg, !0) : this.cursorVoid(arg, !0) : new DbIterator(this, this.idbPro);
+    return arg = types.isFunction(arg) ? { fn: arg } : arg || {}, arg.fn ? returns ? this.cursorResult(arg, !0) : this.cursorVoid(arg, !0) : new DbIterator(this, this.idbPro);
   }
   batchWrite(fn, rollbackOnError) {
     const { target } = this;
-    if (isNativeTarget(target))
+    if (type$1.isNativeTarget(target))
       try {
         return fn(this);
       } catch (e) {
         throw rollbackOnError !== !1 && (target instanceof IDBIndex ? target.objectStore : target).transaction.abort(), e;
       }
-    return this.tx(!0, (store) => fn(this.idbPro.schema.factory.newWriter({
+    return this.tx(!0, (store2) => fn(this.idbPro.schema.factory.newWriter({
       storeSchema: this.storeSchema,
-      target: store
+      target: store2
     }, this.idbPro)), rollbackOnError);
   }
   changeByPk({ pk, record, fn, requiredPk, getOld, requiredOld, saveMapper, getMapper }) {
@@ -981,12 +654,12 @@ class DataWriter extends DataReader {
       else if (keyPath)
         query = getValidKeyValue(keyPath, record);
       else {
-        const { key, value } = parseDbNoneKeyPathRecord(record);
+        const { key, value } = type$1.parseDbNoneKeyPathRecord(record);
         query = key, newValue = value;
       }
       if (requiredPk && !query)
         throw new Error(`key is required: ${JSON.stringify(record)}`);
-      const oldValue = query && (getOld || requiredOld) ? await requestDbResult(w.nativeStore.get(query)) : void 0;
+      const oldValue = query && (getOld || requiredOld) ? await store.requestDbResult(w.nativeStore.get(query)) : void 0;
       if (requiredOld && !oldValue)
         throw new Error(`record not found: ${JSON.stringify(record)}`);
       const result = await fn(w.nativeStore, query, newValue, oldValue, keyPath);
@@ -997,16 +670,16 @@ class DataWriter extends DataReader {
 }
 class DbMap extends DataOperationBase {
   get size() {
-    return this.tx(!1, (store) => requestDbResult(store.count()));
+    return this.tx(!1, (store$1) => store.requestDbResult(store$1.count()));
   }
   delete(key) {
-    return this.tx(!0, async (t, store) => {
-      store.delete(key);
+    return this.tx(!0, async (t, store2) => {
+      store2.delete(key);
     });
   }
   batch(fn) {
     const { idbPro, storeSchema, factory } = this;
-    return this.tx(!0, async (t, store) => await fn(factory.newDbMap({ storeSchema, target: store }, idbPro)));
+    return this.tx(!0, async (t, store2) => await fn(factory.newDbMap({ storeSchema, target: store2 }, idbPro)));
   }
   asStore(writable) {
     const { factory } = this.idbPro.schema;
@@ -1018,13 +691,13 @@ class DbMap extends DataOperationBase {
     }, this.idbPro, { parser: "keyValue" });
   }
   async get(key, defaultValue) {
-    return await this.tx(!1, (store) => requestDbResult(store.get(key))) || defaultValue;
+    return await this.tx(!1, (store$1) => store.requestDbResult(store$1.get(key))) || defaultValue;
   }
   getMany(keys) {
-    return this.tx(!1, async (store) => {
+    return this.tx(!1, async (store$1) => {
       const result = [];
       for (const k of keys)
-        result.push(await requestDbResult(store.get(k)));
+        result.push(await store.requestDbResult(store$1.get(k)));
       return result;
     });
   }
@@ -1035,14 +708,14 @@ class DbMap extends DataOperationBase {
     return new DbIterator({ storeSchema: this.storeSchema, target: this.target }, this.idbPro, { parser: "key" });
   }
   set(key, value) {
-    return this.tx(!0, async (t, store) => {
-      await requestDbResult(store.put(value, key));
+    return this.tx(!0, async (t, store$1) => {
+      await store.requestDbResult(store$1.put(value, key));
     });
   }
   setMany(values) {
-    return this.tx(!0, async (t, store) => {
+    return this.tx(!0, async (t, store2) => {
       for (const [k, v] of values)
-        store.put(v, k);
+        store2.put(v, k);
     });
   }
   values() {
@@ -1063,15 +736,15 @@ function equalKeyPath(p1, p2) {
 const versionDiffValidate = ({ stores, schema }) => {
   const storeSchemas = schema.storeSchemas;
   let info = "";
-  for (const store of stores) {
-    const ss = storeSchemas.find((s) => s.name === store.name);
+  for (const store2 of stores) {
+    const ss = storeSchemas.find((s) => s.name === store2.name);
     if (ss) {
-      if (!equalKeyPath(store.keyPath, ss.keyPath)) {
-        info = `store [ ${store.name} ] keyPath not equal,schema.keyPath:${ss.keyPath},store.keyPath:${store.keyPath}[]`;
+      if (!equalKeyPath(store2.keyPath, ss.keyPath)) {
+        info = `store [ ${store2.name} ] keyPath not equal,schema.keyPath:${ss.keyPath},store.keyPath:${store2.keyPath}[]`;
         break;
       }
-      if (!store.autoIncrement != !ss.autoIncrement) {
-        info = `store [ ${store.name} ] autoIncrement not equal`;
+      if (!store2.autoIncrement != !ss.autoIncrement) {
+        info = `store [ ${store2.name} ] autoIncrement not equal`;
         break;
       }
     }
@@ -1079,34 +752,34 @@ const versionDiffValidate = ({ stores, schema }) => {
   return info ? `The existing database is inconsistent with the definition and cannot be corrected： ${info}` : !0;
 }, versionSameValidate = async (context) => {
   let result = versionDiffValidate(context);
-  return isString(result) || (result = validateStoreAndIndexes(context)), result;
+  return types.isString(result) || (result = validateStoreAndIndexes(context)), result;
 }, validateStoreAndIndexes = ({ stores, schema }) => {
   const storeSchemas = schema.storeSchemas, dbStoreNames = stores.map((s) => s.name);
   let info = "";
   const missingStoreNames = storeSchemas.map((s) => s.name).filter((s) => !dbStoreNames.includes(s));
   if (missingStoreNames.length)
     info = `store [ ${missingStoreNames.join(",")} ] not exist`;
-  else for (const store of stores) {
-    const ss = storeSchemas.find((s) => s.name === store.name);
-    if (ss && (info = validateIndexes$1(store, Array.from(store.indexNames), ss.indexSchemas), info))
+  else for (const store2 of stores) {
+    const ss = storeSchemas.find((s) => s.name === store2.name);
+    if (ss && (info = validateIndexes$1(store2, Array.from(store2.indexNames), ss.indexSchemas), info))
       break;
   }
   return info ? `The existing database Store index is inconsistent with the definition and requires a database version upgrade to be fixed： ${info}` : !0;
 };
-function validateIndexes$1(store, indexNames, schemas) {
+function validateIndexes$1(store2, indexNames, schemas) {
   if (indexNames.length !== schemas.length)
-    return `store [ ${store.name} ] index count not equal`;
+    return `store [ ${store2.name} ] index count not equal`;
   for (const name of indexNames) {
     const schema = schemas.find((s) => s.name === name);
     if (!schema)
-      return `store [ ${store.name} ] index [ ${name} ] not exist`;
-    const index = store.index(name);
+      return `store [ ${store2.name} ] index [ ${name} ] not exist`;
+    const index = store2.index(name);
     if (!schema.unique != !index.unique)
-      return `store [ ${store.name} ] index [ ${name} ] unique not equal`;
+      return `store [ ${store2.name} ] index [ ${name} ] unique not equal`;
     if (!schema.multiEntry != !index.multiEntry)
-      return `store [ ${store.name} ] index [ ${name} ] multiEntry not equal`;
+      return `store [ ${store2.name} ] index [ ${name} ] multiEntry not equal`;
     if (!equalKeyPath(schema.keyPath, index.keyPath))
-      return `store [ ${store.name} ] index [ ${name} ] keyPath not equal`;
+      return `store [ ${store2.name} ] index [ ${name} ] keyPath not equal`;
   }
   return "";
 }
@@ -1139,20 +812,20 @@ class StoreUpgradeable {
   }
 }
 const DataOperatorFactory = Object.freeze({
-  newDataOperators(schemas, db) {
-    return new DataOperators(db, schemas);
+  newDataOperators(schemas, db2) {
+    return new DataOperators(db2, schemas);
   },
-  newDbMap(schema, db) {
-    return new DbMap(schema, db);
+  newDbMap(schema, db2) {
+    return new DbMap(schema, db2);
   },
-  newReader(schema, db) {
-    return new DataReader(schema, db);
+  newReader(schema, db2) {
+    return new DataReader(schema, db2);
   },
   newStoreUpgradeable(nativeStore, storeSchema, upgradeContext) {
     return new StoreUpgradeable(upgradeContext, storeSchema, nativeStore);
   },
-  newWriter(schema, db) {
-    return new DataWriter(schema, db);
+  newWriter(schema, db2) {
+    return new DataWriter(schema, db2);
   }
 });
 function validateSpecialFields(schema) {
@@ -1173,21 +846,21 @@ function validateSpecialField(schema, field, defaultName, useDefault) {
 function validateSpecialFieldBase(field, defaultName, useDefault) {
   if (field === !1)
     return !1;
-  if (isString(field))
+  if (types.isString(field))
     return { name: field };
-  if (isObject(field)) {
+  if (types.isObject(field)) {
     const r = field;
-    return isBoolean(r.name) && (r.name = defaultName), field;
+    return types.isBoolean(r.name) && (r.name = defaultName), field;
   } else if (field === !0 || useDefault)
     return { name: defaultName };
   return !1;
 }
 function validateStoreSchema(schema, storeTemplate) {
-  let validSchema = isString(schema) ? { name: schema } : schema;
+  let validSchema = types.isString(schema) ? { name: schema } : schema;
   return storeTemplate && (validSchema = { ...storeTemplate, ...validSchema }), validSchema.indexSchemas || (validSchema.indexSchemas = []), validateSpecialFields(validSchema), Object.isFrozen(validSchema) || (validSchema.indexSchemas = validSchema.indexSchemas.map(indexMapper)), validateDefaultData(validSchema), validSchema;
 }
 function indexMapper(index) {
-  const schema = isString(index) ? { name: index } : index;
+  const schema = types.isString(index) ? { name: index } : index;
   return schema.keyPath || (schema.keyPath = schema.name), schema;
 }
 function validateDefaultData(schema) {
@@ -1199,66 +872,66 @@ function validateDefaultData(schema) {
 }
 const validateSchemaWithDefaults = (schema) => {
   const { versionDiffValidate: vdf, versionSameValidate: vsf, factory: dof } = schema;
-  return schema.storeSchemas || (schema.storeSchemas = []), schema.storeTemplate || (schema.storeTemplate = { ...defaultStoreSchemaTemplate }), !vdf && vdf !== !1 && (schema.versionDiffValidate = versionDiffValidate), !vsf && vsf !== !1 && (schema.versionSameValidate = versionSameValidate), dof ? dof !== DataOperatorFactory && (schema.factory = { ...DataOperatorFactory, ...dof }) : schema.factory = DataOperatorFactory, schema.storeSchemas = schema.storeSchemas.map((s) => validateStoreSchema(s, schema.storeTemplate)), schema;
+  return schema.storeSchemas || (schema.storeSchemas = []), schema.storeTemplate || (schema.storeTemplate = { ...type$1.defaultStoreSchemaTemplate }), !vdf && vdf !== !1 && (schema.versionDiffValidate = versionDiffValidate), !vsf && vsf !== !1 && (schema.versionSameValidate = versionSameValidate), dof ? dof !== DataOperatorFactory && (schema.factory = { ...DataOperatorFactory, ...dof }) : schema.factory = DataOperatorFactory, schema.storeSchemas = schema.storeSchemas.map((s) => validateStoreSchema(s, schema.storeTemplate)), schema;
 };
 async function validateBeforeOpen(schema) {
-  const { name, version } = schema, existDb = await findExistDb(name);
+  const { name, version } = schema, existDb = await db.findExistDb(name);
   if (!existDb)
     return !0;
-  const { versionDiffValidate: versionDiffValidate2, versionSameValidate: versionSameValidate2 } = schema, db = await openDb(name);
+  const { versionDiffValidate: versionDiffValidate2, versionSameValidate: versionSameValidate2 } = schema, db$1 = await db.openDb(name);
   try {
-    if (schema.version < db.version)
+    if (schema.version < db$1.version)
       return "The existing database version is greater than the current version";
-    const validate = schema.version === void 0 || db.version === schema.version ? versionSameValidate2 : versionDiffValidate2;
+    const validate = schema.version === void 0 || db$1.version === schema.version ? versionSameValidate2 : versionDiffValidate2;
     if (!validate)
       return !0;
-    const storeNames = Array.from(db.objectStoreNames);
+    const storeNames = Array.from(db$1.objectStoreNames);
     if (storeNames.length < 1)
       return `The existing database [ ${name} ] is empty`;
-    const stores = await readTx(db, storeNames), diffResult = await validate({ schema, db, stores });
-    if (isString(diffResult) || version !== existDb.version)
+    const stores = await tx.readTx(db$1, storeNames), diffResult = await validate({ schema, db: db$1, stores });
+    if (types.isString(diffResult) || version !== existDb.version)
       return diffResult;
   } finally {
-    db?.close();
+    db$1?.close();
   }
   return !0;
 }
-function validateIndexes(storeSchema, store) {
-  const { indexSchemas } = storeSchema, existNames = store.indexNames, schemaNames = indexSchemas.map((option) => option.name);
+function validateIndexes(storeSchema, store2) {
+  const { indexSchemas } = storeSchema, existNames = store2.indexNames, schemaNames = indexSchemas.map((option) => option.name);
   for (const name of Array.from(existNames))
-    schemaNames.includes(name) || store.deleteIndex(name);
+    schemaNames.includes(name) || store2.deleteIndex(name);
   for (const indexSchema of indexSchemas)
-    existNames.contains(indexSchema.name) ? validateIndex(store, indexSchema) : createIndex(store, indexSchema);
-  return store;
+    existNames.contains(indexSchema.name) ? validateIndex(store2, indexSchema) : createIndex(store2, indexSchema);
+  return store2;
 }
-function validateIndex(store, indexOption) {
-  const index = store.index(indexOption.name);
-  checkIndex(index, indexOption) || (store.deleteIndex(indexOption.name), createIndex(store, indexOption));
+function validateIndex(store2, indexOption) {
+  const index = store2.index(indexOption.name);
+  checkIndex(index, indexOption) || (store2.deleteIndex(indexOption.name), createIndex(store2, indexOption));
 }
 function checkIndex(index, indexOption) {
   return index.unique !== indexOption.unique || index.multiEntry !== indexOption.multiEntry ? !1 : equalKeyPath(indexOption.keyPath, index.keyPath);
 }
-function createIndex(store, schema) {
+function createIndex(store2, schema) {
   try {
-    store.createIndex(schema.name, schema.keyPath, {
+    store2.createIndex(schema.name, schema.keyPath, {
       unique: schema.unique,
       multiEntry: schema.multiEntry
     });
   } catch {
-    throw new Error(`store [ ${store.name} ] index [ ${schema.name} ] create error: ${JSON.stringify(schema)}`);
+    throw new Error(`store [ ${store2.name} ] index [ ${schema.name} ] create error: ${JSON.stringify(schema)}`);
   }
 }
 function validateStoreDefine(context, schema) {
   return context.database.objectStoreNames.contains(schema.name) ? validateIndexes(schema, context.transaction?.objectStore(schema.name)) : defineStore(schema, context.database);
 }
-function defineStore(schema, db) {
-  const store = db.createObjectStore(schema.name, {
+function defineStore(schema, db2) {
+  const store2 = db2.createObjectStore(schema.name, {
     keyPath: schema.keyPath,
     autoIncrement: schema.autoIncrement
   });
   for (const option of schema.indexSchemas)
-    createIndex(store, option);
-  return store;
+    createIndex(store2, option);
+  return store2;
 }
 class UpgradeContext {
   database;
@@ -1271,12 +944,12 @@ class UpgradeContext {
     this.database = args.database, this.newVersion = args.newVersion, this.oldVersion = args.oldVersion, this.dbSchema = args.dbSchema, this.transaction = args.transaction;
   }
   deleteStoreIfExists(storeName) {
-    const db = this.database;
-    db.objectStoreNames.contains(storeName) && db.deleteObjectStore(storeName);
+    const db2 = this.database;
+    db2.objectStoreNames.contains(storeName) && db2.deleteObjectStore(storeName);
   }
   destroy() {
     try {
-      destroyRecords(this.#stores);
+      basic.destroyRecords(this.#stores);
     } finally {
       for (const k of Object.keys(this.#stores))
         delete this.#stores[k];
@@ -1303,7 +976,7 @@ async function upgradeDb(dbSchema, database, e, request) {
   const { storeSchemas, beforeUpgrade, afterUpgrade, version } = dbSchema, { newVersion = version, oldVersion } = e, { transaction } = request, context = new UpgradeContext({ database, newVersion, oldVersion, dbSchema, transaction });
   try {
     const errors = [];
-    if (isFunction(beforeUpgrade)) try {
+    if (types.isFunction(beforeUpgrade)) try {
       await beforeUpgrade(context);
     } catch (e2) {
       errors.push(e2);
@@ -1333,7 +1006,7 @@ async function upgradeDb(dbSchema, database, e, request) {
       } catch (e2) {
         errors.push(e2);
       }
-    if (isFunction(afterUpgrade)) try {
+    if (types.isFunction(afterUpgrade)) try {
       await afterUpgrade(context);
     } catch (e2) {
       errors.push(e2);
@@ -1341,38 +1014,38 @@ async function upgradeDb(dbSchema, database, e, request) {
     if (!errors.length) return;
     throw errors.length === 1 ? errors[0] : new AggregateError(errors, "Database upgrade error");
   } finally {
-    destroy(context);
+    basic.destroy(context);
   }
 }
 function validateDataOperationSchema(schema, dbSchema) {
   return Object.isFrozen(dbSchema) ? frozenValidate(schema) : initValidate(schema, dbSchema);
 }
-function frozenValidate(schema, dbSchema) {
-  let { store, index } = schema;
-  const target = { store: isString(store) ? store : store.name };
-  return index && (target.index = isString(index) ? index : index.name), {
+function frozenValidate(schema) {
+  let { store: store2, index } = schema;
+  const target = { store: types.isString(store2) ? store2 : store2.name };
+  return index && (target.index = types.isString(index) ? index : index.name), {
     target
   };
 }
 function initValidate(schema, dbSchema) {
-  let { store, index } = schema;
-  const { storeTemplate } = dbSchema, { storeSchemas = [] } = dbSchema, storeName = isString(store) ? store : store.name, storeIndex = storeSchemas.findIndex((s) => s === storeName || s.name === storeName), existStore = storeIndex > -1 && storeSchemas[storeIndex];
+  let { store: store2, index } = schema;
+  const { storeTemplate } = dbSchema, { storeSchemas = [] } = dbSchema, storeName = types.isString(store2) ? store2 : store2.name, storeIndex = storeSchemas.findIndex((s) => s === storeName || s.name === storeName), existStore = storeIndex > -1 && storeSchemas[storeIndex];
   let tmp;
-  isString(store) ? tmp = existStore || storeName : !existStore || isString(existStore) || store === existStore ? tmp = store : tmp = { ...existStore, ...store }, (index || existStore?.indexSchemas?.length || store?.indexSchemas?.length) && (isString(tmp) && (tmp = { name: tmp }), tmp.indexSchemas = mergeIndexes(existStore.indexSchemas || [], store.indexSchemas || [], index));
+  types.isString(store2) ? tmp = existStore || storeName : !existStore || types.isString(existStore) || store2 === existStore ? tmp = store2 : tmp = { ...existStore, ...store2 }, (index || existStore?.indexSchemas?.length || store2?.indexSchemas?.length) && (types.isString(tmp) && (tmp = { name: tmp }), tmp.indexSchemas = mergeIndexes(existStore.indexSchemas || [], store2.indexSchemas || [], index));
   const validSchema = validateStoreSchema(tmp, storeTemplate);
   storeIndex > -1 ? storeSchemas[storeIndex] = validSchema : storeSchemas.push(validSchema), dbSchema.storeSchemas = storeSchemas;
   const target = { store: storeName };
-  return index && (target.index = isString(index) ? index : index.name), {
+  return index && (target.index = types.isString(index) ? index : index.name), {
     target
   };
 }
 function mergeIndexes(existIndexes, newIndexes, index) {
   index && newIndexes.push(index);
   for (const index2 of newIndexes) {
-    const indexName = isString(index2) ? index2 : index2.name, existIndex = existIndexes.findIndex((i) => i === indexName || i.name === indexName);
+    const indexName = types.isString(index2) ? index2 : index2.name, existIndex = existIndexes.findIndex((i) => i === indexName || i.name === indexName);
     if (existIndex > -1) {
       const old = existIndexes[existIndex];
-      isString(old) ? existIndexes[existIndex] = index2 : isString(index2) || (existIndexes[existIndex] = Object.assign(old, index2));
+      types.isString(old) ? existIndexes[existIndex] = index2 : types.isString(index2) || (existIndexes[existIndex] = Object.assign(old, index2));
     } else
       existIndexes.push(index2);
   }
@@ -1394,13 +1067,13 @@ class IDbPro {
   #beforeUseValid;
   #storeSchemaRecord = {};
   constructor(schema, skipPreOpenValidation) {
-    this.#schema = schema = isString(schema) ? { name: schema } : schema, Array.isArray(schema.storeSchemas) || (schema.storeSchemas = []), isObject(schema.storeTemplate) || (schema.storeTemplate = defaultStoreSchemaTemplate), skipPreOpenValidation && (this.#beforeUseValid = !0);
+    this.#schema = schema = types.isString(schema) ? { name: schema } : schema, Array.isArray(schema.storeSchemas) || (schema.storeSchemas = []), types.isObject(schema.storeTemplate) || (schema.storeTemplate = type$1.defaultStoreSchemaTemplate), skipPreOpenValidation && (this.#beforeUseValid = !0);
   }
   /**
    * 默认实例
    */
   static get defaultDb() {
-    return this.#_db || (this.#_db = new IDbPro(DefaultDbName));
+    return this.#_db || (this.#_db = new IDbPro(storage.DefaultDbName));
   }
   get initialized() {
     return Object.isFrozen(this.#schema);
@@ -1409,7 +1082,7 @@ class IDbPro {
     return this.#schema;
   }
   get storeNames() {
-    return Array.from(new Set(this.#schema.storeSchemas.map((s) => isString(s) ? s : s.name)));
+    return Array.from(new Set(this.#schema.storeSchemas.map((s) => types.isString(s) ? s : s.name)));
   }
   get factory() {
     return this.#schema.factory || (this.#schema.factory = DataOperatorFactory);
@@ -1442,13 +1115,13 @@ class IDbPro {
     return IDbPro.defaultDb.map(storeName, defaultData);
   }
   async openNativeDb() {
-    const schema = this.#schema = deepFreeze(this.initSchema());
+    const schema = this.#schema = basic.deepFreeze(this.initSchema());
     await this.#isBeforeUseValidate();
     const { name, version } = schema;
-    return await openDb({
+    return await db.openDb({
       name,
       version,
-      onupgradeneeded: (db, e, request) => upgradeDb(schema, db, e, request)
+      onupgradeneeded: (db2, e, request) => upgradeDb(schema, db2, e, request)
     });
   }
   store(arg1, index) {
@@ -1456,7 +1129,7 @@ class IDbPro {
     return operation.store || (operation.store = arg1), operation.index || (operation.index = index), this.factory.newWriter(validateDataOperationSchema(operation, this.schema), this);
   }
   stores(schemas) {
-    const { schema } = this, results = schemas.map((store) => validateDataOperationSchema(isString(store) ? { store } : store, schema));
+    const { schema } = this, results = schemas.map((store2) => validateDataOperationSchema(types.isString(store2) ? { store: store2 } : store2, schema));
     return this.factory.newDataOperators(results, this);
   }
   initSchema() {
@@ -1465,10 +1138,10 @@ class IDbPro {
     return this.#schema = validate(this.#schema);
   }
   async traceSchema(showFn) {
-    await logJson(this.schema, showFn);
+    await json.logJson(this.schema, showFn);
   }
   map(storeName, defaultData) {
-    const name = isString(storeName) ? storeName : isString(defaultData) ? defaultData : DefaultStorageStoreName;
+    const name = types.isString(storeName) ? storeName : types.isString(defaultData) ? defaultData : storage.DefaultStorageStoreName;
     Array.isArray(storeName) && (defaultData = storeName);
     const { storeSchemas } = this.schema;
     return storeSchemas.find((s) => s.name === name || s === name) || storeSchemas.push({ ...mapStoreSchema, name, defaultData }), this.factory.newDbMap({ target: { store: name } }, this);
@@ -1484,13 +1157,13 @@ class IDbPro {
       return this.#storeSchemaRecord[name];
     const index = this.schema.storeSchemas.findIndex((s) => s === name || s.name === name);
     let storeSchema = this.schema.storeSchemas[index];
-    return this.initialized ? this.#storeSchemaRecord[name] = storeSchema : isString(storeSchema) && (this.schema.storeSchemas[index] = storeSchema = { name: storeSchema }), storeSchema;
+    return this.initialized ? this.#storeSchemaRecord[name] = storeSchema : types.isString(storeSchema) && (this.schema.storeSchemas[index] = storeSchema = { name: storeSchema }), storeSchema;
   }
   async #isBeforeUseValidate() {
     let valid = this.#beforeUseValid;
     if (valid === void 0 && (valid = this.#beforeUseValid = await validateBeforeOpen(this.#schema)), valid === !0)
       return !0;
-    if (isString(valid))
+    if (types.isString(valid))
       throw new Error(valid);
   }
 }
@@ -1506,17 +1179,17 @@ function dbStores(schemas) {
 function releaseDefaultDB() {
   IDbPro.releaseDefaultDB();
 }
-function generateStoreSchema(store, fields) {
-  const { name, keyPath, autoIncrement } = store;
+function generateStoreSchema(store2, fields) {
+  const { name, keyPath, autoIncrement } = store2;
   return {
     name,
     keyPath,
     autoIncrement,
-    ...parseIndexes(store, fields)
+    ...parseIndexes(store2, fields)
   };
 }
-function parseIndexes(store, fields) {
-  const indexes = Array.from(store.indexNames).map((n) => store.index(n)), indexSchemas = [], paths = [];
+function parseIndexes(store2, fields) {
+  const indexes = Array.from(store2.indexNames).map((n) => store2.index(n)), indexSchemas = [], paths = [];
   for (const { name, keyPath, unique, multiEntry } of indexes)
     Array.isArray(keyPath) ? paths.push(...keyPath) : paths.push(keyPath), indexSchemas.push({ name, keyPath, unique, multiEntry });
   const keySet = new Set(paths);
@@ -1531,19 +1204,19 @@ function parseIndexes(store, fields) {
 function convertSpecialField(field, keySet) {
   return keySet.has(field) ? { name: field, isIndexed: !1 } : !1;
 }
-async function generateDbSchema(db, option) {
-  if (!await findExistDb(db))
-    throw new Error(`db [ ${db} ] not exist`);
-  let { asString, specialFields = defaultSpecialFields, dataExportTarget } = option || {};
+async function generateDbSchema(db$1, option) {
+  if (!await db.findExistDb(db$1))
+    throw new Error(`db [ ${db$1} ] not exist`);
+  let { asString, specialFields = type$1.defaultSpecialFields, dataExportTarget } = option || {};
   asString === !0 && (asString = 160), isNaN(asString) || asString < 1 && (asString = 1);
-  let dbSchema = await generateRoot(db, specialFields);
-  return dataExportTarget && await generateData(dbSchema, dataExportTarget), asString ? await toJson({
+  let dbSchema = await generateRoot(db$1, specialFields);
+  return dataExportTarget && await generateData(dbSchema, dataExportTarget), asString ? await json.toJson({
     rootData$: dbSchema,
     spaceEffectiveLength: asString
   }) : dbSchema;
 }
 async function generateData(dbSchema, dataExportTarget) {
-  const data = await new IDbPro(copyObject(dbSchema), !0).export();
+  const data = await new IDbPro(basic.copyObject(dbSchema), !0).export();
   for (const schema of dbSchema.storeSchemas) {
     const rows = data[schema.name];
     rows?.length && (dataExportTarget === "defaultData" ? schema.defaultData = rows : dataExportTarget === "versionData" && (schema.versionData || (schema.versionData = []), schema.versionData.push({
@@ -1553,53 +1226,22 @@ async function generateData(dbSchema, dataExportTarget) {
   }
   return dbSchema;
 }
-function generateRoot(db, specialFields) {
-  return openDb(db, async function(existDb) {
-    const names = Array.from(existDb.objectStoreNames), tx = existDb.transaction(names, "readonly");
+function generateRoot(db$1, specialFields) {
+  return db.openDb(db$1, async function(existDb) {
+    const names = Array.from(existDb.objectStoreNames), tx2 = existDb.transaction(names, "readonly");
     try {
       return {
         name: existDb.name,
         version: existDb.version,
-        storeSchemas: names.map((name) => generateStoreSchema(tx.objectStore(name), specialFields))
+        storeSchemas: names.map((name) => generateStoreSchema(tx2.objectStore(name), specialFields))
       };
     } finally {
-      tx.abort();
+      tx2.abort();
     }
   });
 }
-var generateDbSchema$1 = /* @__PURE__ */ Object.freeze({ __proto__: null, generateDbSchema });
-export {
-  Break,
-  Continue,
-  ContinueKey,
-  ContinuePrimaryKey,
-  DataOperationBase,
-  DataOperators,
-  DataReader,
-  DataWriter,
-  DbIterator,
-  DbIteratorParsers,
-  DbMap,
-  Delete,
-  Finished,
-  IDbPro,
-  NextKey,
-  NextPrimaryKey,
-  Save,
-  StoreUpgradeable,
-  UpgradeContext,
-  dbMap,
-  dbStore,
-  dbStores,
-  defaultSpecialFields,
-  defaultStoreSchemaTemplate,
-  generateDbSchema,
-  isIDbQuery,
-  isNativeTarget,
-  parseDbNoneKeyPathRecord,
-  parseIDbQuery,
-  releaseDefaultDB,
-  validateSchemaWithDefaults,
-  versionDiffValidate,
-  versionSameValidate
-};
+var generateDbSchema$1 = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  generateDbSchema
+});
+exports.DataOperationBase = DataOperationBase, exports.DataOperators = DataOperators, exports.DataReader = DataReader, exports.DataWriter = DataWriter, exports.DbIterator = DbIterator, exports.DbMap = DbMap, exports.IDbPro = IDbPro, exports.StoreUpgradeable = StoreUpgradeable, exports.UpgradeContext = UpgradeContext, exports.dbMap = dbMap, exports.dbStore = dbStore, exports.dbStores = dbStores, exports.generateDbSchema = generateDbSchema, exports.isIDbQuery = isIDbQuery, exports.parseIDbQuery = parseIDbQuery, exports.releaseDefaultDB = releaseDefaultDB, exports.validateSchemaWithDefaults = validateSchemaWithDefaults, exports.versionDiffValidate = versionDiffValidate, exports.versionSameValidate = versionSameValidate;