gs-idb-pro 0.1.0 → 0.1.2

package/lib/index.web.js

@@ -1 +1,1555 @@
-const e=Symbol("save"),t=Symbol("delete"),r=Object.freeze({key:({primaryKey:e})=>({value:e}),value:({value:e})=>({value:e}),keyValue:({primaryKey:e,value:t})=>({value:[e,t]})});function n(e){if(Array.isArray(e))return{key:e[1],value:e[0]};if("value"in e){const{key:t,value:r}=e;return{key:t,value:r}}throw new Error(`not include value in invalid DBRecord：${JSON.stringify(e)}`)}const a=Symbol("break"),i=Symbol("finished"),s=Symbol("continue"),o=Symbol("continue key"),c=Symbol("next key"),u=Symbol("continue primary key"),h=Symbol("next primary key");function d(e){return e instanceof IDBObjectStore||e instanceof IDBIndex}const f=Object.freeze({keyPath:"id",autoIncrement:!0,addedTimeField:!0,updatedTimeField:!0}),l=Object.freeze({addedTimeField:"added_at",softDeletedField:"deleted",updatedCountField:"updated_count",updatedTimeField:"updated_at"});function y(e){return e instanceof Function||"function"==typeof e}function m(e){return!0===e||!1===e||e instanceof Boolean||"boolean"==typeof e}function p(e){return"number"==typeof e||e instanceof Number}function g(e){return"string"==typeof e||e instanceof String}function w(e){return e&&(t=e,!(Array.isArray(t)||t instanceof Array||t?.constructor===Array))&&!y(e)&&(e instanceof Object||"object"==typeof e);var t}function b(e){return null!=e&&y(e[Symbol.iterator])}function S(e){return null!=e&&y(e[Symbol.asyncIterator])}function x(e){return null!=e&&"function"==typeof e.next}async function v(e,t){for(let r=0;r<e.length;r++)await t(e[r])}async function k(e,t){const r=await e,n=[];for(let e=0;e<r.length;e++)n.push(await t(r[e],e,r));return n}function D(e){if("object"!=typeof e||null===e||e instanceof Date||e instanceof Function||e instanceof RegExp||typeof Element<"u"&&e instanceof Element)return e;if(e instanceof Set){const t=new Set;for(const r of e)t.add(D(r));return t}if(e instanceof Map){const t=new Map;for(const[r,n]of e)t.set(D(r),D(n));return t}if(Array.isArray(e)){const t=[];for(const r of e)t.push(D(r));return t}const t={};for(const[r,n]of Object.entries(e))t[r]=D(n);return t}function P(e){return Object.freeze(e),Object.getOwnPropertyNames(e).forEach(t=>{const r=e[t];null!==r&&("object"==typeof r||"function"==typeof r)&&!Object.isFrozen(r)&&P(r)}),e}class ${rootData$;space;showFn;spaceEffectiveLength;out;type;ignoreCircularRef;constructor(e){let t=0;w(e[t])&&e[t].rootData$&&Object.assign(this,e[t++]),t<1&&(this.rootData$=e[t++]);const r=e.slice(t),n=r.filter(e=>p(e));void 0===this.out&&(this.out=r.find(e=>y(e))||null),void 0===this.showFn&&(this.showFn=!!r.find(e=>m(e))),void 0===this.spaceEffectiveLength&&(this.spaceEffectiveLength=n[0]||100),void 0===this.space&&(this.space=n[1]||2),void 0===this.type&&(this.type=r.find(e=>g(e))||"js"),void 0===this.ignoreCircularRef&&(this.ignoreCircularRef=!0)}destroy(){this.out=null,this.rootData$=null}}async function O(e,t,r){if("string"==typeof(e=await e)||e instanceof Date)return JSON.stringify(e);if(e instanceof Function)return t.showFn?e.toString():"undefined";if("object"!=typeof e||null===e)return e+"";if(e instanceof RegExp)return e.toString();if(typeof Element<"u"&&e instanceof Element)return"undefined";if(r.has(e)){if(t.ignoreCircularRef)return;throw new Error("circular reference")}r.add(e);try{return"json"===t.type?await async function(e,t,r){const n=[];if(Array.isArray(e)||e instanceof Set||b(e)&&!(e instanceof Map)){for(const a of e)if(void 0!==a&&(!y(a)||t.showFn)){const e=await O(a,t,r);void 0!==e&&n.push(e)}const{spaceStart:a,spaceEnd:i,arrJoin:s}=E(n,t);return n.length?`[${a}${s()}${i}]`:"[]"}if(S(e)||x(e)){for await(const a of e)if(void 0!==a&&(!y(a)||t.showFn)){const e=await O(a,t,r);void 0!==e&&n.push(e)}const{spaceStart:a,spaceEnd:i,arrJoin:s}=E(n,t);return n.length?`[${a}${s()}${i}]`:"[]"}let a=e instanceof Map?e.entries():Object.entries(e);for(const[e,i]of a)if(void 0!==i&&(!y(i)||t.showFn)){const a=await O(i,t,r);void 0!==a&&n.push(`"${e}": ${a}`)}const{spaceStart:i,spaceEnd:s,arrJoin:o}=E(n,t);return n.length?`[${i}${o()}${s}]`:"[]"}(e,t,r):await async function(e,t,r){const n=[];if(e instanceof Set){for(const a of e)(!y(a)||t.showFn)&&n.push(await O(a,t,r));const{spaceStart:a,spaceEnd:i,arrJoin:s}=E(n,t);return n.length?`new Set([${a}${s()}${i}])`:"[]"}if(e instanceof Map){for(const[a,i]of e)(!y(i)||t.showFn)&&n.push(`${I(await O(a,t,r))}: ${await O(i,t,r)}`);const{spaceStart:a,spaceEnd:i,arrJoin:s}=E(n,t);return n.length?`new Map(Object.entries({${a}${s()}${i}})`:"new Map()"}if(Array.isArray(e)||b(e)){for(const a of e)(!y(a)||t.showFn)&&n.push(await O(a,t,r));const{spaceStart:a,spaceEnd:i,arrJoin:s}=E(n,t);return n.length?`[${a}${s()}${i}]`:"[]"}if(x(e)||S(e)){for await(const a of e)(!y(a)||t.showFn)&&n.push(await O(a,t,r));const{spaceStart:a,spaceEnd:i,arrJoin:s}=E(n,t);return n.length?`[${a}${s()}${i}]`:"[]"}for(const[a,i]of Object.entries(e))(!y(i)||t.showFn)&&n.push(`${I(a)}: ${await O(i,t,r)}`);const{spaceStart:a,spaceEnd:i,arrJoin:s}=E(n,t);return n.length?`{${a}${s()}${i}}`:"{}"}(e,t,r)}finally{r.delete(e)}}function E(e,t){let r=t.space;e.reduce((e,t)=>e+t.length,0)<t.spaceEffectiveLength&&(r=0);const n=r?"\n"+"".padStart(r):"",a=r?"\n":"",i=r?"\n".padEnd(r+1):",";return{spaceStart:n,spaceEnd:a,arrJoin:r?()=>e.join(",\n").replace(/\n/g,i):()=>e.join(",")}}function I(e){return/^[a-z_]+\w*$/i.test(e)?e:`"${e}"`}async function j(...e){const t=new $(e),r=new Set;try{const e=await O(t.rootData$,t,r);if(!t.out)return e;t.out(e)}finally{r.clear(),t.destroy()}}function F(e){return e instanceof Function||"function"==typeof e}function M(e){return"string"==typeof e||e instanceof String}var A,q;function R(e){return"string"==typeof(t=e)||"number"==typeof t||t instanceof String||t instanceof Number||e instanceof Date||e instanceof ArrayBuffer||Array.isArray(e)&&e.every(R);var t}function B(e){return null==e||function(e){return e instanceof IDBKeyRange||R(e)}(e)}async function C(e){return(await indexedDB.databases()).find(t=>t.name===e)}async function N(e,t){const r=M(e)?{name:e}:e;F(t)&&(r.onsuccess=t);const{name:n,onsuccess:a,onupgradeneeded:i,version:s}=r;return function(e,t,r){return new Promise(async(n,a)=>{let i=!1;e.onsuccess=async()=>{if(!i)if(t)try{n(await t(e.result))}catch(e){a(e)}finally{e.result?.close?.()}else n(e.result)},e.onblocked=e.onerror=e=>a(e.target.error),r&&(e.onupgradeneeded=async t=>{try{await r(e.result,t,e)}catch(e){i=!0,a(e)}})})}(indexedDB.open(n,s),a,i)}function K(e,t,r){return function(e,t,...r){return new Promise(async(n,a)=>{let i=0;const s=F(r[i])?r[i++]:void 0,o=r[i]?"readwrite":"readonly",c=e instanceof IDBDatabase?e:await N(e),u=Array.isArray(t)?t:[t],h=c.transaction(u.map(e=>M(e)?e:e.store),o),d=u.map(e=>{if(M(e))return h.objectStore(e);const{store:t,index:r}=e;return M(r)?h.objectStore(t).index(r):h.objectStore(t)});if(s)try{n(await s(...d)),o?h.commit():h.abort()}catch(e){h.abort(),a(e)}finally{c.close()}else n(d)})}(e,t,r,!1)}function T(e){return new Promise(async(t,r)=>{e.onsuccess=()=>{try{t(e.result)}catch(e){r(e)}},e.onerror=e=>r(e.target.error)})}(q=A||(A={}))[q.True=1]="True",q[q.False=0]="False";const V=e=>e instanceof Date?e.getTime():e;function W(e){if(B(e))return e;const t=e;if("lt"in t&&"gt"in t){if(V(t.gt)>V(t.lt))throw new Error(`Invalid IDBRange: gt (${t.gt}) cannot be greater than lt (${t.lt})`);return IDBKeyRange.bound(t.gt,t.lt,!0,!0)}if("lt"in t&&"gte"in t){if(V(t.gte)>V(t.lt))throw new Error(`Invalid IDBRange: gte (${t.gte}) cannot be greater than lt (${t.lt})`);return IDBKeyRange.bound(t.gte,t.lt,!1,!0)}if("lte"in t&&"gt"in t){if(V(t.gt)>V(t.lte))throw new Error(`Invalid IDBRange: gt (${t.gt}) cannot be greater than lte (${t.lte})`);return IDBKeyRange.bound(t.gt,t.lte,!0,!1)}if("lte"in t&&"gte"in t){if(V(t.gte)>V(t.lte))throw new Error(`Invalid IDBRange: gte (${t.gte}) cannot be greater than lte (${t.lte})`);return IDBKeyRange.bound(t.gte,t.lte,!1,!1)}return"lt"in t?IDBKeyRange.upperBound(t.lt,!0):"lte"in t?IDBKeyRange.upperBound(t.lte,!1):"gt"in t?IDBKeyRange.lowerBound(t.gt,!0):"gte"in t?IDBKeyRange.lowerBound(t.gte,!1):void 0}function z(e){return null!=W(e)}async function _(e,t,r){const{query:n,direction:a="prev",preSkip:i,startKey:s,startPrimaryKey:o}=t,c=e.openCursor(W(n),a);return i&&(await T(c)).advance(i),s&&(o?(await T(c)).continuePrimaryKey(s,o):(await T(c)).continue(s)),c}function J(e,t,r){return Array.isArray(e)?t=>function(e,t,r){if(r?.length)for(const n of r)t.hasOwnProperty(n)&&(e[n]=t[n]);else Object.assign(e,t);return e}({},t,e):y(e)?e:t?e=>e:r?(e,t)=>[e,t]:(e,t)=>({key:e,value:t})}class U{idbPro;target;#e;constructor(e,t){this.idbPro=t,this.#e=e.storeSchema,this.target=e.target,d(e.target)&&(this.tx=this.#t)}get storeName(){return this.nativeStore?.name||this.target.store}get storeSchema(){if(this.#e)return this.#e;const e=this.idbPro.getStoreSchema(this.storeName);return Object.isFrozen(e)&&(this.#e=e),e}get factory(){return this.idbPro.factory}get nativeStore(){const{target:e}=this;return e instanceof IDBObjectStore?e:e instanceof IDBIndex?e.objectStore:void 0}get keyPath(){const{target:e}=this;if(d(e))return e.keyPath;const{storeSchema:t}=this,{index:r}=e;return r?t.indexSchemas.find(e=>e.name===r)?.keyPath:t.keyPath}async forEach(e,t){return e=y(e)?{fn:e}:e,t?this.cursorResult(e,!1):this.cursorVoid(e,!1)}async tx(e,t,r){let{target:n}=this;const{store:a,index:i}=n,s=await this.idbPro.openNativeDb();let o,c;try{o=s.transaction(a,!0===e?"readwrite":"readonly"),n=c=o.objectStore(a),i&&(n=n.index(i))}catch(e){throw s.close(),e}if(!t)return Object.freeze({db:s,tx:o,nativeStore:c,target:n});try{if(!0===e){const e=await t(n,c);return o.commit(),e}return t(n)}catch(e){throw!1!==r&&o.abort(),e}finally{s.close()}}openCursor(e,t){return this.tx(t,t=>new Promise(async(r,n)=>{const{fn:a}=e,i=await _(t,e);i.onsuccess=async()=>{i.result?!1===await a(i.result)&&r():r()},i.onerror=()=>n(i.error)}))}cursorVoid({query:r,direction:n,preSkip:i,startKey:s,startPrimaryKey:c,fn:h},d){let f=0;return this.openCursor({query:r,direction:n,preSkip:i,startKey:s,startPrimaryKey:c,fn:async r=>{const{value:n,primaryKey:i}=r,s=await h(n,i,f++),{control:c,key:l,primaryKey:y,modify:m,value:p}=w(s)?s:{control:s};switch(d&&(m===e?r.update(p||n):m===t&&r.delete()),c){case a:return!1;case o:r.continue(l);break;case u:r.continuePrimaryKey(l,y);break;default:r.continue()}}},!0)}async cursorResult({query:r,direction:n,preSkip:s,startKey:d,startPrimaryKey:f,fn:l,mapper:y},m){const{keyPath:p,defaultGetMapper:g}=this.storeSchema,w=J(y||g,p),b=[];let S=0;return await this.openCursor({query:r,direction:n,preSkip:s,startKey:d,startPrimaryKey:f,fn:async r=>{const{value:n,primaryKey:s}=r,{control:d,value:f,key:y,primaryKey:p,modify:g}=await(l?.(n,s,S,b))||{};switch(m&&(g===e?r.update(f||n):g===t&&r.delete()),(!d||d===i||d===c||d===h)&&b.push(w(f||n,p||s,S)),d){case a:case i:return!1;case c:case o:r.continue(y);break;case h:case u:r.continuePrimaryKey(y,p);break;default:r.continue()}S++}},m),b}#t(e,t){const{target:r}=this,n=r instanceof IDBObjectStore?r:r.objectStore;return t?t(r,n):Object.freeze({nativeStore:n,target:r})}}class G{idbPro;schemas;#r;constructor(e,t){this.idbPro=e,this.schemas=t}get storeNames(){return this.#r||(this.#r=Array.from(new Set(this.schemas.map(e=>e.target.store))))}read(e){return this.tx("newReader",e)}write(e,t=!0){return this.tx("newWriter",e,!0,t)}export(){return this.tx("newReader",async(...e)=>{const t={};for(const r of e)t[r.storeName]=await r.export();return t})}import(e,t,r){return r||(r="addOrChangeMany"),this.tx("newWriter",async(...n)=>{const a={};n=Array.from(new Map(n.map(e=>[e.storeName,e.asStore(!0)])).values());for(const i of n){const{storeName:n}=i,s=e[n];s&&(a[n]=await i[r](s,t))}if(t)return a},!0)}async tx(e,t,r,n){const{idbPro:a,schemas:i}=this,{factory:s}=a.schema,o=await a.openNativeDb();try{const c=o.transaction(this.storeNames,r?"readwrite":"readonly");try{const n=i.map(({storeSchema:t,target:r})=>{let n=c.objectStore(r.store);return r.index&&(n=n.index(r.index)),s[e]({storeSchema:t,target:n},a)});if(r){const e=await t(...n);return c.commit(),e}return await t(...n)}catch(e){throw!1!==n&&c.abort(),e}}finally{o.close()}}}class L extends U{direction;query;writable;parser;endsWithNull;preSkip;startKey;startPrimaryKey;constructor(e,t,n){if(super(e,t),!n)return;const{parser:a}=n;this.direction=n.direction,this.query=n.query,this.writable=!!n.writable,this.endsWithNull=!!n.endsWithNull,this.preSkip=n.preSkip,this.startKey=n.startKey,this.startPrimaryKey=n.startPrimaryKey,a&&(this.parser=y(a)?a:r[a])}async*[Symbol.asyncIterator](){const{parser:e,writable:t,endsWithNull:r}=this,{db:n,tx:i,target:s}=await this.tx(t);try{const n=await _(s,this);let o;if(e)for(;o=await T(n);){const{control:t,value:r}=await e(o);if(t||(yield r),t===a)break;o.continue()}else{let e=!1;const t=()=>{e=!0};for(;!e&&(o=await T(n));)yield{cursor:o,end:t}}t&&i?.commit(),r&&!o&&(yield null)}finally{n?.close()}}}function X(e,t,r,n){const a=w(e)?e:{};return y(e)?a.fn=e:z(e)&&(a.query=e),y(t)?a.fn=t:t&&(a.direction=t),r&&(a.direction=r),n?a.limit=n:a.limit||(a.limit=1e3),a.maxEmptyChecks||(a.maxEmptyChecks=2e4),a}async function H(e,t,r){t.size||(t.size=100),t.nextSkip||(t.nextSkip=0);const{query:n,direction:a,total:i,maxEmptyChecks:s,fn:o}=t;return await e.batchRead(async e=>(i||(t.total=await e.count({query:n,direction:a,maxEmptyChecks:s,fn:o}),t.pages=Math.ceil(t.total/t.size)),t.total<1?{info:P(t),rows:[]}:o?await async function(e,t,r){t.maxEmptyChecks||(t.maxEmptyChecks=2e4);const{page:n,query:a,direction:i,nextSkip:s}=t,{keyPath:o}=e.storeSchema;return 1===n?await Q(e,await _(e.target,{query:a,direction:i}),t,o):r&&s&&n-r.page===1?await Q(e,await _(e.target,{query:a,direction:i,preSkip:s}),t,o):await Q(e,await _(e.target,{query:a,direction:i}),t,o,!0)}(e,t,r):await async function(e,t){const{keyPath:r}=e.storeSchema,{page:n,query:a,direction:i,size:s,mapper:o}=t,c=(n-1)*s,u=await e.filter({query:a,preSkip:c,direction:i,limit:s,mapper:J(o,r,!0)});return t.nextSkip=c+u.length,{info:P(t),rows:u}}(e,t)))}async function Q({storeSchema:{defaultGetMapper:e}},t,r,n,a){const{page:i,size:s,total:o,maxEmptyChecks:c,fn:u}=r,h=J(r.mapper||e,n,!0),d=[],f=(i-1)*r.size;if(f>=o)return{info:P(r),rows:[]};let l=0;return await new Promise(async(e,r)=>{let n=0,i=0;const o=async()=>{const{result:r}=t;if(!r)return e();let{value:a,primaryKey:i}=r;if(await u(a,i,l)?(n=0,d.push(h(a,i,l))):n++,d.length>=s||n>=c)return e();l++,r.continue()};t.onerror=()=>r(t.error),t.onsuccess=a?async()=>{const{result:r}=t;if(!r)return e();let{value:a,primaryKey:s}=r;if(await u(a,s,l)?(n=0,i++):n++,i>=f||n>=c)return l=n=0,t.onsuccess=o,void r.continue();r.continue(),l++}:o}),l&&(r.nextSkip+=l+1),{info:P(r),rows:d}}class Y extends U{all(e,t){const r={};return p(t)&&(r.limit=t),z(e)?r.query=e:w(e)&&Object.assign(r,e),this.tx(!1,e=>T(e.getAll(W(r.query),r.limit||1e3)))}async count(e,t,r){const n=X(e,t,r),{query:a,direction:i,fn:s}=n;if(!s)return await this.tx(!1,e=>T(e.count(W(a))));const{maxEmptyChecks:o}=n,c=s;let u=0,h=0,d=0;return await this.openCursor({query:a,direction:i,fn:e=>{if(c(e.value,e.primaryKey,d++))u++,h=0;else if(++h>=o)return!1;e.continue()}}),u}get(e){return this.tx(!1,t=>T(t.get(W(e))))}getMany(e,t){return this.batchRead(async r=>{const n=await k(e,e=>r.get(e));return t?n.filter(e=>e):n})}getRange(e,t){return this.forEach({query:e,direction:t},!0)}async getRangeMany(e,t,r){return(await this.batchRead(r=>k(e,e=>r.getRange(e,t)))).flat()}index(e,t){let{target:r}=this;return r instanceof IDBIndex&&(r=r.objectStore),r instanceof IDBObjectStore?(r=r.index(e),this.createOperator(r,t)):this.idbPro.store(r.store,e)}asStore(e){let{target:t}=this;if(t instanceof IDBObjectStore)return this;if(t instanceof IDBIndex)t=t.objectStore;else{if(!("index"in t))return this;t={store:t.store}}return this.createOperator(t,e)}batchRead(e){return d(this.target)?e(this):this.tx(!1,t=>e(this.idbPro.schema.factory.newReader({storeSchema:this.storeSchema,target:t},this.idbPro)))}iterator(e,t){const r={};return g(t)&&(r.direction=t),z(e)?r.query=e:w(e)&&Object.assign(r,e),new L({storeSchema:this.storeSchema,target:this.target},this.idbPro,{...r,parser:"value"})}async filter(e,t,r,n){const o=X(e,t,r,n),{maxEmptyChecks:c,limit:u,fn:h}=o,{keyPath:d,defaultGetMapper:f}=this.storeSchema,l=J(o.mapper||f,d,!0);if(!h)return await this.forEach({...o,mapper:l,fn:(e,t,r)=>{if(r>=u-1)return{control:i}}},!0);let y=0;return this.forEach({...o,mapper:l,fn:(e,t,r,n)=>(e=l(e,t,r),h(e,t,r)?(y=0,n.length>=u-1?{control:i}:void 0):++y>=c?{control:a}:{control:s})},!0)}async find(e,t,r){const[n]=await this.filter(e,t,r,1);return n}async page(e,t){const r={...e};return r.page=t||e?.page||1,H(this,r,e)}nextPage(e){return this.page(e,e.page+1)}export(e,t){const r=X(e,t),{keyPath:n,exportMapper:a,name:i,defaultGetMapper:s}=this.storeSchema;if(!n&&Array.isArray(a))throw new Error(`When store [ ${i} ] keyPath does not exist, exportMapper does not support string[].`);return r.direction="next",r.mapper=J(a||s,n,!0),r.limit=r.maxEmptyChecks=Number.MAX_SAFE_INTEGER,this.filter(r)}asMap(){let{target:e}=this;return e instanceof IDBIndex?e=e.objectStore:e instanceof IDBObjectStore||(e={store:e.store}),this.factory.newDbMap({target:e},this.idbPro)}createOperator(e,t){const{idbPro:r}=this,n=this.storeSchema,a={storeSchema:Object.isFrozen(n)?n:void 0,target:e};return t?this.factory.newWriter(a,r):this.factory.newReader(a,r)}}function Z(e,t){if(!Array.isArray(e))return{[e]:t};const r={},n=e;for(let e=0;e<n.length;e++)r[n[e]]=t[e];return r}function ee(e,t){if(!Array.isArray(e))return t[e];const r=[];for(const n of e){if(!t[n])return;r.push(t[n])}return r}function te(e,t){if(!t||!(t instanceof Object)||Array.isArray(t))return t;const{addedTimeField:r,updatedTimeField:n,updatedCountField:a,softDeletedField:i}=e;return t={...t},r?.name&&!p(t[r.name])&&(t[r.name]=Date.now()),n?.name&&!p(t[n.name])&&(t[n.name]=Date.now()),i?.name&&!p(t[i.name])&&(t[i.name]=0),a?.name&&(t[a.name]=0),t}function re(e,t,r){if(!t||!(t instanceof Object)||Array.isArray(t))return t;const{updatedTimeField:n,updatedCountField:a}=e;return t={...r,...t},n.name&&(t[n.name]=Date.now()),a.name&&(t[a.name]=(t[a.name]||0)+1),t}class ne extends Y{add(e){return this.changeByPk({record:e,fn:async(e,t,r,n,a)=>{const{storeSchema:i}=this;return r=te(i,r),a?[{...r,...Z(a,await T(e.add(r)))},t]:[r,await T(e.add(r,t))]}})}addMany(e,t){return this.batchWrite(r=>t?k(e,e=>r.add(e)):v(e,e=>r.add(e)),!0)}addOrSkip(e){return this.batchWrite(async t=>{const{keyPath:r,defaultGetMapper:a}=t.storeSchema,{key:i,value:s}=r?{key:ee(r,e),value:e}:n(e);if(i){const e=await T(t.nativeStore.get(i));if(e)return J(a,r)?.(e,i)}if(t.target instanceof IDBIndex){const{keyPath:r}=t,n=ee(r,s);if(!n)return t.add(e);let a=await t.find(n);if(a)return a}return t.add(e)})}addOrSkipMany(e,t){return this.batchWrite(r=>t?k(e,e=>r.addOrSkip(e)):v(e,e=>r.addOrSkip(e)),!0)}replace(e){return this.changeByPk({record:e,getOld:!0,fn:async(e,t,r,n,a)=>{const{storeSchema:i}=this,{updatedTimeField:s,updatedCountField:o,addedTimeField:c}=i;return r=n?re(i,r,{[s.name]:n[s.name],[o.name]:n[o.name],[c.name]:n[c.name]}):te(i,r),a?[{...r,...Z(a,await T(e.put(r)))},t]:[r,await T(e.put(r,t))]}})}replaceMany(e,t){return this.batchWrite(r=>t?k(e,e=>r.replace(e)):v(e,e=>r.replace(e)),!0)}change(e,t){return this.changeByPk({record:e,getOld:!0,requiredOld:t,requiredPk:t,fn:async(e,t,r,n,a)=>{const{storeSchema:i}=this;if(n)return r=re(i,r,n),a?[{...r,...Z(a,await T(e.put(r)))},t]:[r,await T(e.put(r,t))]}})}changeMany(e,t){const{returns:r,throwIfMissing:n}=m(t)?{returns:t}:t||{};return this.batchWrite(t=>r?k(e,e=>t.change(e,n)):v(e,e=>t.change(e,n)),!0)}addOrChange(e){return this.changeByPk({record:e,getOld:!0,fn:async(e,t,r,n,a)=>{const{storeSchema:i}=this;return n?(r=re(i,r,n),a?[{...r,...Z(a,await T(e.put(r)))},t]:[r,await T(e.put(r,t))]):(r=te(i,r),a?[{...r,...Z(a,await T(e.add(r)))},t]:[r,await T(e.add(r,t))])}})}addOrChangeMany(e,t){return this.batchWrite(r=>t?k(e,e=>r.addOrChange(e)):v(e,e=>r.addOrChange(e)),!0)}delete(e,t){return this.changeByPk({pk:e,getOld:t,fn:(e,r,n,a)=>{if(e.delete(r),t)return[a,r]}})}deleteMany(e,t){return this.batchWrite(r=>t?k(e,e=>r.delete(e,!0)):v(e,e=>r.delete(e)),!0)}deleteRange(r,n){const{returns:a,physical:i,direction:s}=m(n)?{returns:n}:n||{},{name:o}=this.storeSchema.softDeletedField||{};return this.cursor({query:r,direction:s,fn:r=>i||!o?{modify:t}:(r[o]=1,{modify:e})},a)}deleteRangeMany(e,t){const r=m(t)?{returns:t}:t;return this.batchWrite(t=>r?.returns?k(e,e=>t.deleteRange(e,r)):v(e,e=>t.deleteRange(e,r)),!0)}changeRange(t,r){let{direction:n="next",query:a,newValue:i}="newValue"in t?t:{newValue:t};if(a||(a=ee(this.keyPath,i)),!a)throw new Error(`query is required：${JSON.stringify(t)}`);return this.cursor({query:a,direction:n,fn:t=>t instanceof Object?{modify:e,value:{...t,...i}}:{modify:e,value:i}},r)}changeRangeMany(e,t){return this.batchWrite(r=>t?k(e,e=>r.changeRange(e,t)):v(e,e=>r.changeRange(e,t)),!0)}cursor(e,t){return(e=y(e)?{fn:e}:e||{}).fn?t?this.cursorResult(e,!0):this.cursorVoid(e,!0):new L(this,this.idbPro)}batchWrite(e,t){const{target:r}=this;if(d(r))try{return e(this)}catch(e){throw!1!==t&&(r instanceof IDBIndex?r.objectStore:r).transaction.abort(),e}return this.tx(!0,t=>e(this.idbPro.schema.factory.newWriter({storeSchema:this.storeSchema,target:t},this.idbPro)),t)}changeByPk({pk:e,record:t,fn:r,requiredPk:a,getOld:i,requiredOld:s,saveMapper:o,getMapper:c}){const{storeSchema:u}=this,{keyPath:h,defaultSaveMapper:d,defaultGetMapper:f}=u;return t&&(o||d)&&(t=J(o||d,h)?.(t)),this.batchWrite(async o=>{let u,d=t;if(e)u=W(e);else if(h)u=ee(h,t);else{const{key:e,value:r}=n(t);u=e,d=r}if(a&&!u)throw new Error(`key is required: ${JSON.stringify(t)}`);const l=u&&(i||s)?await T(o.nativeStore.get(u)):void 0;if(s&&!l)throw new Error(`record not found: ${JSON.stringify(t)}`);const y=await r(o.nativeStore,u,d,l,h);if(y)return J(c||f,h)?.(y[0],y[1])})}}class ae extends U{get size(){return this.tx(!1,e=>T(e.count()))}delete(e){return this.tx(!0,async(t,r)=>{r.delete(e)})}batch(e){const{idbPro:t,storeSchema:r,factory:n}=this;return this.tx(!0,async(a,i)=>await e(n.newDbMap({storeSchema:r,target:i},t)))}asStore(e){const{factory:t}=this.idbPro.schema;return e?t.newWriter(this,this.idbPro):t.newReader({target:this.target},this.idbPro)}entries(){return new L({target:this.target},this.idbPro,{parser:"keyValue"})}async get(e,t){return await this.tx(!1,t=>T(t.get(e)))||t}getMany(e){return this.tx(!1,async t=>{const r=[];for(const n of e)r.push(await T(t.get(n)));return r})}async has(e){return!!await this.get(e)}keys(){return new L({storeSchema:this.storeSchema,target:this.target},this.idbPro,{parser:"key"})}set(e,t){return this.tx(!0,async(r,n)=>{await T(n.put(t,e))})}setMany(e){return this.tx(!0,async(t,r)=>{for(const[t,n]of e)r.put(n,t)})}values(){return new L({storeSchema:this.storeSchema,target:this.target},this.idbPro,{parser:"value"})}}function ie(e,t){if(e==t)return!0;if(typeof e!=typeof t)return!1;if(Array.isArray(e)&&Array.isArray(t)){if(e.length!==t.length)return!1;for(let r=0;r<e.length;r++)if(e[r]!==t[r])return!1;return!0}return!1}const se=({stores:e,schema:t})=>{const r=t.storeSchemas;let n="";for(const t of e){const e=r.find(e=>e.name===t.name);if(e){if(!ie(t.keyPath,e.keyPath)){n=`store [ ${t.name} ] keyPath not equal,schema.keyPath:${e.keyPath},store.keyPath:${t.keyPath}[]`;break}if(!t.autoIncrement!=!e.autoIncrement){n=`store [ ${t.name} ] autoIncrement not equal`;break}}}return!n||`The existing database is inconsistent with the definition and cannot be corrected： ${n}`},oe=async e=>{let t=se(e);return g(t)||(t=ce(e)),t},ce=({stores:e,schema:t})=>{const r=t.storeSchemas,n=e.map(e=>e.name);let a="";const i=r.map(e=>e.name).filter(e=>!n.includes(e));if(i.length)a=`store [ ${i.join(",")} ] not exist`;else for(const t of e){const e=r.find(e=>e.name===t.name);if(e&&(a=ue(t,Array.from(t.indexNames),e.indexSchemas),a))break}return!a||`The existing database Store index is inconsistent with the definition and requires a database version upgrade to be fixed： ${a}`};function ue(e,t,r){if(t.length!==r.length)return`store [ ${e.name} ] index count not equal`;for(const n of t){const t=r.find(e=>e.name===n);if(!t)return`store [ ${e.name} ] index [ ${n} ] not exist`;const a=e.index(n);if(!t.unique!=!a.unique)return`store [ ${e.name} ] index [ ${n} ] unique not equal`;if(!t.multiEntry!=!a.multiEntry)return`store [ ${e.name} ] index [ ${n} ] multiEntry not equal`;if(!ie(t.keyPath,a.keyPath))return`store [ ${e.name} ] index [ ${n} ] keyPath not equal`}return""}class he{upgradeContext;storeSchema;nativeStore;#n;constructor(e,t,r){this.upgradeContext=e,this.storeSchema=t,this.nativeStore=r}get writer(){return this.#n||(this.#n=this.upgradeContext.dbSchema.factory?.newWriter({target:this.nativeStore,storeSchema:this.storeSchema}))}add(e,t,r){return this.upgradeContext.versionIn(e)?this.writer.addMany(t,r):Promise.resolve()}addOrChange(e,t,r){return this.upgradeContext.versionIn(e)?this.writer.addOrChangeMany(t,r):Promise.resolve()}async call(e,t){if(this.upgradeContext.versionIn(e))return await t(this.writer,this.upgradeContext)}replace(e,t,r){return this.upgradeContext.versionIn(e)?this.writer.replaceMany(t,r):Promise.resolve()}}const de=Object.freeze({newDataOperators:(e,t)=>new G(t,e),newDbMap:(e,t)=>new ae(e,t),newReader:(e,t)=>new Y(e,t),newStoreUpgradeable:(e,t,r)=>new he(r,t,e),newWriter:(e,t)=>new ne(e,t)});function fe(e,t,r,n){const a=function(e,t,r){if(!1===e)return!1;if(g(e))return{name:e};if(w(e)){const r=e;return m(r.name)&&(r.name=t),e}if(!0===e||r)return{name:t};return!1}(t,r,n);if(!a)return a;const i=a;if(!1!==i.isIndexed){i.isIndexed||(i.isIndexed=!0);const{name:t}=i,r=e.indexSchemas;r.some(e=>e===t||e.name===t)||r.push(t)}return i}function le(e,t){let r=g(e)?{name:e}:e;return t&&(r={...t,...r}),r.indexSchemas||(r.indexSchemas=[]),function(e){Object.isFrozen(e)||(e.addedTimeField=fe(e,e.addedTimeField,"added_at",!0),e.updatedTimeField=fe(e,e.updatedTimeField,"updated_at",!0),e.updatedCountField=fe(e,e.updatedCountField,"updated_count",!1),e.softDeletedField=fe(e,e.softDeletedField,"deleted",!1))}(r),Object.isFrozen(r)||(r.indexSchemas=r.indexSchemas.map(ye)),function(e){if(!e.keyPath&&e.defaultData?.length)for(const t of e.defaultData)if(!Array.isArray(t)&&!("value"in t))throw new Error(`When \`defaultData\` must contain \`value\` fields or be an array：${JSON.stringify(t)}`)}(r),r}function ye(e){const t=g(e)?{name:e}:e;return t.keyPath||(t.keyPath=t.name),t}const me=e=>{const{versionDiffValidate:t,versionSameValidate:r,factory:n}=e;return e.storeSchemas||(e.storeSchemas=[]),e.storeTemplate||(e.storeTemplate={...f}),!t&&!1!==t&&(e.versionDiffValidate=se),!r&&!1!==r&&(e.versionSameValidate=oe),n?n!==de&&(e.factory={...de,...n}):e.factory=de,e.storeSchemas=e.storeSchemas.map(t=>le(t,e.storeTemplate)),e};function pe(e,t){(function(e,t){return e.unique===t.unique&&e.multiEntry===t.multiEntry&&ie(t.keyPath,e.keyPath)})(e.index(t.name),t)||(e.deleteIndex(t.name),ge(e,t))}function ge(e,t){try{e.createIndex(t.name,t.keyPath,{unique:t.unique,multiEntry:t.multiEntry})}catch{throw new Error(`store [ ${e.name} ] index [ ${t.name} ] create error: ${JSON.stringify(t)}`)}}function we(e,t){return e.database.objectStoreNames.contains(t.name)?function(e,t){const{indexSchemas:r}=e,n=t.indexNames,a=r.map(e=>e.name);for(const e of Array.from(n))a.includes(e)||t.deleteIndex(e);for(const e of r)n.contains(e.name)?pe(t,e):ge(t,e);return t}(t,e.transaction?.objectStore(t.name)):function(e,t){const r=t.createObjectStore(e.name,{keyPath:e.keyPath,autoIncrement:e.autoIncrement});for(const t of e.indexSchemas)ge(r,t);return r}(t,e.database)}class be{database;newVersion;oldVersion;dbSchema;transaction;#a={};constructor(e){this.database=e.database,this.newVersion=e.newVersion,this.oldVersion=e.oldVersion,this.dbSchema=e.dbSchema,this.transaction=e.transaction}deleteStoreIfExists(e){const t=this.database;t.objectStoreNames.contains(e)&&t.deleteObjectStore(e)}destroy(){try{!function(...e){for(const t of e)if(t)for(const e of Object.keys(t))try{t[e]?.destroy?.()}catch{}finally{delete t[e]}}(this.#a)}finally{for(const e of Object.keys(this.#a))delete this.#a[e]}}store(e){if(e in this.#a)return this.#a[e];const{factory:t}=this.dbSchema,{storeSchemas:r}=this.dbSchema,n=r.find(t=>t.name===e),a=we(this,n);return this.#a[e]=t.newStoreUpgradeable(a,n,this)}versionIn({oldMin:e,oldMax:t,newMax:r,newMin:n}){if(void 0===t&&void 0===r&&void 0===e&&void 0===n)throw new Error(`versionIn bounds must not be empty ${JSON.stringify({oldMax:t,newMax:r,oldMin:e,newMin:n})}`);if(t<e)throw new Error(`oldMax (${t}) cannot be less than oldMin (${e})`);if(r<n)throw new Error(`newMax (${r}) cannot be less than newMin (${n})`);const{oldVersion:a,newVersion:i}=this;return!(void 0!==e&&a<e||void 0!==t&&a>t||void 0!==n&&i<n)&&!(void 0!==r&&i>r)}}function Se(e,t){let{store:r,index:n}=e;const{storeTemplate:a}=t,{storeSchemas:i=[]}=t,s=g(r)?r:r.name,o=i.findIndex(e=>e===s||e.name===s),c=o>-1&&i[o];let u;u=g(r)?c||s:!c||g(c)||r===c?r:{...c,...r},(n||c?.indexSchemas?.length||r?.indexSchemas?.length)&&(g(u)&&(u={name:u}),u.indexSchemas=function(e,t,r){r&&t.push(r);for(const r of t){const t=g(r)?r:r.name,n=e.findIndex(e=>e===t||e.name===t);if(n>-1){const t=e[n];g(t)?e[n]=r:g(r)||(e[n]=Object.assign(t,r))}else e.push(r)}return e}(c.indexSchemas||[],r.indexSchemas||[],n));const h=le(u,a);o>-1?i[o]=h:i.push(h),t.storeSchemas=i;const d={store:s};return n&&(d.index=g(n)?n:n.name),{target:d}}const xe=Object.assign({name:"",addedTimeField:!1,autoIncrement:!1,indexSchemas:[],keyPath:void 0,softDeletedField:!1,updatedCountField:!1,updatedTimeField:!1});class ve{static#i;#s;#o;#c={};constructor(e,t){this.#s=e=g(e)?{name:e}:e,Array.isArray(e.storeSchemas)||(e.storeSchemas=[]),w(e.storeTemplate)||(e.storeTemplate=f),t&&(this.#o=!0)}static get defaultDb(){return this.#i||(this.#i=new ve("gs-idb"))}get initialized(){return Object.isFrozen(this.#s)}get schema(){return this.#s}get storeNames(){return Array.from(new Set(this.#s.storeSchemas.map(e=>g(e)?e:e.name)))}get factory(){return this.#s.factory||(this.#s.factory=de)}static releaseDefaultDB(){this.#i=void 0}static async openExistDb(e){const{generateDbSchema:t}=await Promise.resolve().then(function(){return je});return new ve(await t(e))}static store(e,t){return ve.defaultDb.store(e,t)}static stores(e){return ve.defaultDb.stores(e)}static map(e,t){return ve.defaultDb.map(e,t)}async openNativeDb(){const e=this.#s=P(this.initSchema());await this.#u();const{name:t,version:r}=e;return await N({name:t,version:r,onupgradeneeded:(t,r,n)=>async function(e,t,r,n){const{storeSchemas:a,beforeUpgrade:i,afterUpgrade:s,version:o}=e,{newVersion:c=o,oldVersion:u}=r,{transaction:h}=n,d=new be({database:t,newVersion:c,oldVersion:u,dbSchema:e,transaction:h});try{const e=[];if(y(i))try{await i(d)}catch(t){e.push(t)}for(const t of a.map(e=>e.name))try{d.store(t)}catch(t){e.push(t)}for(const{name:t,defaultData:r}of a)if(r)try{await d.store(t).add({oldMax:0},r)}catch(t){e.push(t)}for(const{name:t,versionData:r}of a)if(r)for(const{version:n,data:a,use:i="addOrChange"}of r)try{await d.store(t)[i](n,a)}catch(t){e.push(t)}for(const{name:t,storeDefined:r}of a)try{await(r?.(d.store(t)))}catch(t){e.push(t)}if(y(s))try{await s(d)}catch(t){e.push(t)}if(!e.length)return;throw 1===e.length?e[0]:new AggregateError(e,"Database upgrade error")}finally{!function(e){try{e?.destroy?.()}catch{}}(d)}}(e,t,r,n)})}store(e,t){const r=e.store?e:{store:e};return r.store||(r.store=e),r.index||(r.index=t),this.factory.newWriter(Se(r,this.schema),this)}stores(e){const{schema:t}=this,r=e.map(e=>Se(g(e)?{store:e}:e,t));return this.factory.newDataOperators(r,this)}initSchema(){if(this.initialized)return this.#s;const{validateSchemaWithDefaults:e=me}=this.#s;return this.#s=e(this.#s)}async traceSchema(e){await async function(...e){const t=globalThis.top?.console?.log||console.log;e.push(t),await j(...e)}(this.schema,e)}map(e,t){const r=g(e)?e:g(t)?t:"gs-storage-map";Array.isArray(e)&&(t=e);const{storeSchemas:n}=this.schema;return n.find(e=>e.name===r||e===r)||n.push({...xe,name:r,defaultData:t}),this.factory.newDbMap({target:{store:r}},this)}export(){return this.stores(this.storeNames).export()}import(e,t,r){return this.stores(this.storeNames).import(e,t,r)}getStoreSchema(e){if(e in this.#c)return this.#c[e];const t=this.schema.storeSchemas.findIndex(t=>t===e||t.name===e);let r=this.schema.storeSchemas[t];return this.initialized?this.#c[e]=r:g(r)&&(this.schema.storeSchemas[t]=r={name:r}),r}async#u(){let e=this.#o;if(void 0===e&&(e=this.#o=await async function(e){const{name:t,version:r}=e,n=await C(t);if(!n)return!0;const{versionDiffValidate:a,versionSameValidate:i}=e,s=await N(t);try{if(e.version<s.version)return"The existing database version is greater than the current version";const o=void 0===e.version||s.version===e.version?i:a;if(!o)return!0;const c=Array.from(s.objectStoreNames);if(c.length<1)return`The existing database [ ${t} ] is empty`;const u=await K(s,c),h=await o({schema:e,db:s,stores:u});if(g(h)||r!==n.version)return h}finally{s?.close()}return!0}(this.#s)),!0===e)return!0;if(g(e))throw new Error(e)}}function ke(e,t){return ve.defaultDb.store(e,t)}function De(e,t){return ve.defaultDb.map(e,t)}function Pe(e){return ve.defaultDb.stores(e)}function $e(){ve.releaseDefaultDB()}function Oe(e,t){const r=Array.from(e.indexNames).map(t=>e.index(t)),n=[],a=[];for(const{name:e,keyPath:t,unique:i,multiEntry:s}of r)Array.isArray(t)?a.push(...t):a.push(t),n.push({name:e,keyPath:t,unique:i,multiEntry:s});const i=new Set(a);return{indexSchemas:n,addedTimeField:Ee(t.addedTimeField,i),updatedTimeField:Ee(t.updatedTimeField,i),updatedCountField:Ee(t.updatedCountField,i),softDeletedField:Ee(t.softDeletedField,i)}}function Ee(e,t){return!!t.has(e)&&{name:e,isIndexed:!1}}async function Ie(e,t){if(!await C(e))throw new Error(`db [ ${e} ] not exist`);let{asString:r,specialFields:n=l,dataExportTarget:a}=t||{};!0===r&&(r=160),isNaN(r)||r<1&&(r=1);let i=await function(e,t){return N(e,async function(e){const r=Array.from(e.objectStoreNames),n=e.transaction(r,"readonly");try{return{name:e.name,version:e.version,storeSchemas:r.map(e=>function(e,t){const{name:r,keyPath:n,autoIncrement:a}=e;return{name:r,keyPath:n,autoIncrement:a,...Oe(e,t)}}(n.objectStore(e),t))}}finally{n.abort()}})}(e,n);return a&&await async function(e,t){const r=await new ve(D(e),!0).export();for(const n of e.storeSchemas){const a=r[n.name];a?.length&&("defaultData"===t?n.defaultData=a:"versionData"===t&&(n.versionData||(n.versionData=[]),n.versionData.push({version:{oldMax:e.version},data:a})))}return e}(i,a),r?await j({rootData$:i,spaceEffectiveLength:r}):i}var je=Object.freeze({__proto__:null,generateDbSchema:Ie});export{a as Break,s as Continue,o as ContinueKey,u as ContinuePrimaryKey,U as DataOperationBase,G as DataOperators,Y as DataReader,ne as DataWriter,L as DbIterator,r as DbIteratorParsers,ae as DbMap,t as Delete,i as Finished,ve as IDbPro,c as NextKey,h as NextPrimaryKey,e as Save,he as StoreUpgradeable,be as UpgradeContext,De as dbMap,ke as dbStore,Pe as dbStores,l as defaultSpecialFields,f as defaultStoreSchemaTemplate,Ie as generateDbSchema,z as isIDbQuery,d as isNativeTarget,n as parseDbNoneKeyPathRecord,W as parseIDbQuery,$e as releaseDefaultDB,me as validateSchemaWithDefaults,se as versionDiffValidate,oe as versionSameValidate};
+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\uFF1A${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 t$1(t2) {
+  return t2 instanceof Function || typeof t2 == "function";
+}
+function n(t2) {
+  return Array.isArray(t2) || t2 instanceof Array || t2?.constructor === Array;
+}
+function r(t2) {
+  return t2 === !0 || t2 === !1 || t2 instanceof Boolean || typeof t2 == "boolean";
+}
+function i(t2) {
+  return typeof t2 == "number" || t2 instanceof Number;
+}
+function o$2(t2) {
+  return typeof t2 == "string" || t2 instanceof String;
+}
+function c(e) {
+  return e && !n(e) && !t$1(e) && (e instanceof Object || typeof e == "object");
+}
+function f(e) {
+  return e != null && t$1(e[Symbol.iterator]);
+}
+function l$1(e) {
+  return e != null && t$1(e[Symbol.asyncIterator]);
+}
+function h(t2) {
+  return t2 != null && typeof t2.next == "function";
+}
+async function v(t2, e) {
+  for (let n2 = 0; n2 < t2.length; n2++) await e(t2[n2]);
+}
+async function O(t2, e) {
+  const n2 = await t2, r2 = [];
+  for (let t3 = 0; t3 < n2.length; t3++) r2.push(await e(n2[t3], t3, n2));
+  return r2;
+}
+function x(t2) {
+  try {
+    t2?.destroy?.();
+  } catch {
+  }
+}
+function C(...t2) {
+  for (const e of t2) if (e) for (const t3 of Object.keys(e)) try {
+    e[t3]?.destroy?.();
+  } catch {
+  } finally {
+    delete e[t3];
+  }
+}
+function L(t2) {
+  if (typeof t2 != "object" || t2 === null || t2 instanceof Date || t2 instanceof Function || t2 instanceof RegExp || typeof Element < "u" && t2 instanceof Element) return t2;
+  if (t2 instanceof Set) {
+    const e2 = /* @__PURE__ */ new Set();
+    for (const n2 of t2) e2.add(L(n2));
+    return e2;
+  }
+  if (t2 instanceof Map) {
+    const e2 = /* @__PURE__ */ new Map();
+    for (const [n2, r2] of t2) e2.set(L(n2), L(r2));
+    return e2;
+  }
+  if (Array.isArray(t2)) {
+    const e2 = [];
+    for (const n2 of t2) e2.push(L(n2));
+    return e2;
+  }
+  const e = {};
+  for (const [n2, r2] of Object.entries(t2)) e[n2] = L(r2);
+  return e;
+}
+function P$1(t2, e, n2) {
+  if (n2?.length) for (const r2 of n2) e.hasOwnProperty(r2) && (t2[r2] = e[r2]);
+  else Object.assign(t2, e);
+  return t2;
+}
+function R(t2) {
+  return Object.freeze(t2), Object.getOwnPropertyNames(t2).forEach(((e) => {
+    const n2 = t2[e];
+    n2 !== null && (typeof n2 == "object" || typeof n2 == "function") && !Object.isFrozen(n2) && R(n2);
+  })), t2;
+}
+class et {
+  rootData$;
+  space;
+  showFn;
+  spaceEffectiveLength;
+  out;
+  type;
+  ignoreCircularRef;
+  constructor(e) {
+    let n2 = 0;
+    c(e[n2]) && e[n2].rootData$ && Object.assign(this, e[n2++]), n2 < 1 && (this.rootData$ = e[n2++]);
+    const s2 = e.slice(n2), a = s2.filter(((t2) => i(t2)));
+    this.out === void 0 && (this.out = s2.find(((e2) => t$1(e2))) || null), this.showFn === void 0 && (this.showFn = !!s2.find(((t2) => r(t2)))), this.spaceEffectiveLength === void 0 && (this.spaceEffectiveLength = a[0] || 100), this.space === void 0 && (this.space = a[1] || 2), this.type === void 0 && (this.type = s2.find(((t2) => o$2(t2))) || "js"), this.ignoreCircularRef === void 0 && (this.ignoreCircularRef = !0);
+  }
+  destroy() {
+    this.out = null, this.rootData$ = null;
+  }
+}
+async function nt(e, n2, r2) {
+  if (typeof (e = await e) == "string" || e instanceof Date) return JSON.stringify(e);
+  if (e instanceof Function) return n2.showFn ? e.toString() : "undefined";
+  if (typeof e != "object" || e === null) return e + "";
+  if (e instanceof RegExp) return e.toString();
+  if (typeof Element < "u" && e instanceof Element) return "undefined";
+  if (r2.has(e)) {
+    if (n2.ignoreCircularRef) return;
+    throw new Error("circular reference");
+  }
+  r2.add(e);
+  try {
+    return n2.type === "json" ? await (async function(e2, n3, r3) {
+      const i2 = [];
+      if (Array.isArray(e2) || e2 instanceof Set || f(e2) && !(e2 instanceof Map)) {
+        for (const o4 of e2) if (o4 !== void 0 && (!t$1(o4) || n3.showFn)) {
+          const t2 = await nt(o4, n3, r3);
+          t2 !== void 0 && i2.push(t2);
+        }
+        const { spaceStart: o3, spaceEnd: s3, arrJoin: a2 } = rt(i2, n3);
+        return i2.length ? `[${o3}${a2()}${s3}]` : "[]";
+      }
+      if (l$1(e2) || h(e2)) {
+        for await (const o4 of e2) if (o4 !== void 0 && (!t$1(o4) || n3.showFn)) {
+          const t2 = await nt(o4, n3, r3);
+          t2 !== void 0 && i2.push(t2);
+        }
+        const { spaceStart: o3, spaceEnd: s3, arrJoin: a2 } = rt(i2, n3);
+        return i2.length ? `[${o3}${a2()}${s3}]` : "[]";
+      }
+      let o2 = e2 instanceof Map ? e2.entries() : Object.entries(e2);
+      for (const [e3, s3] of o2) if (s3 !== void 0 && (!t$1(s3) || n3.showFn)) {
+        const t2 = await nt(s3, n3, r3);
+        t2 !== void 0 && i2.push(`"${e3}": ${t2}`);
+      }
+      const { spaceStart: s2, spaceEnd: a, arrJoin: c2 } = rt(i2, n3);
+      return i2.length ? `[${s2}${c2()}${a}]` : "[]";
+    })(e, n2, r2) : await (async function(e2, n3, r3) {
+      const i2 = [];
+      if (e2 instanceof Set) {
+        for (const o4 of e2) (!t$1(o4) || n3.showFn) && i2.push(await nt(o4, n3, r3));
+        const { spaceStart: o3, spaceEnd: s3, arrJoin: a2 } = rt(i2, n3);
+        return i2.length ? `new Set([${o3}${a2()}${s3}])` : "[]";
+      }
+      if (e2 instanceof Map) {
+        for (const [o4, s4] of e2) (!t$1(s4) || n3.showFn) && i2.push(`${it(await nt(o4, n3, r3))}: ${await nt(s4, n3, r3)}`);
+        const { spaceStart: o3, spaceEnd: s3, arrJoin: a2 } = rt(i2, n3);
+        return i2.length ? `new Map(Object.entries({${o3}${a2()}${s3}})` : "new Map()";
+      }
+      if (Array.isArray(e2) || f(e2)) {
+        for (const o4 of e2) (!t$1(o4) || n3.showFn) && i2.push(await nt(o4, n3, r3));
+        const { spaceStart: o3, spaceEnd: s3, arrJoin: a2 } = rt(i2, n3);
+        return i2.length ? `[${o3}${a2()}${s3}]` : "[]";
+      }
+      if (h(e2) || l$1(e2)) {
+        for await (const o4 of e2) (!t$1(o4) || n3.showFn) && i2.push(await nt(o4, n3, r3));
+        const { spaceStart: o3, spaceEnd: s3, arrJoin: a2 } = rt(i2, n3);
+        return i2.length ? `[${o3}${a2()}${s3}]` : "[]";
+      }
+      for (const [o3, s3] of Object.entries(e2)) (!t$1(s3) || n3.showFn) && i2.push(`${it(o3)}: ${await nt(s3, n3, r3)}`);
+      const { spaceStart: o2, spaceEnd: s2, arrJoin: a } = rt(i2, n3);
+      return i2.length ? `{${o2}${a()}${s2}}` : "{}";
+    })(e, n2, r2);
+  } finally {
+    r2.delete(e);
+  }
+}
+function rt(t2, e) {
+  let n2 = e.space;
+  t2.reduce(((t3, e2) => t3 + e2.length), 0) < e.spaceEffectiveLength && (n2 = 0);
+  const r2 = n2 ? `
+` + "".padStart(n2) : "", i2 = n2 ? `
+` : "", o2 = n2 ? `
+`.padEnd(n2 + 1) : ",";
+  return { spaceStart: r2, spaceEnd: i2, arrJoin: n2 ? () => t2.join(`,
+`).replace(/\n/g, o2) : () => t2.join(",") };
+}
+function it(t2) {
+  return /^[a-z_]+\w*$/i.test(t2) ? t2 : `"${t2}"`;
+}
+async function ot(...t2) {
+  const e = new et(t2), n2 = /* @__PURE__ */ new Set();
+  try {
+    const t3 = await nt(e.rootData$, e, n2);
+    if (!e.out) return t3;
+    e.out(t3);
+  } finally {
+    n2.clear(), e.destroy();
+  }
+}
+async function st(...t2) {
+  const e = globalThis.top?.console?.log || console.log;
+  t2.push(e), await ot(...t2);
+}
+function t(t2) {
+  return t2 instanceof Function || typeof t2 == "function";
+}
+function o$1(t2) {
+  return typeof t2 == "string" || t2 instanceof String;
+}
+function s$1(t2) {
+  return typeof t2 == "string" || typeof t2 == "number" || t2 instanceof String || t2 instanceof Number;
+}
+var o, s;
+function d(n2) {
+  return s$1(n2) || n2 instanceof Date || n2 instanceof ArrayBuffer || Array.isArray(n2) && n2.every(d);
+}
+function y(e) {
+  return e instanceof IDBKeyRange || d(e);
+}
+function l(e) {
+  return e == null || y(e);
+}
+async function b(e) {
+  return (await indexedDB.databases()).find(((n2) => n2.name === e));
+}
+function g(e, n2, t2) {
+  return new Promise((async (r2, o2) => {
+    let s2 = !1;
+    e.onsuccess = async () => {
+      if (!s2) if (n2) try {
+        r2(await n2(e.result));
+      } catch (e2) {
+        o2(e2);
+      } finally {
+        e.result?.close?.();
+      }
+      else r2(e.result);
+    }, e.onblocked = e.onerror = (e2) => o2(e2.target.error), t2 && (e.onupgradeneeded = async (n3) => {
+      try {
+        await t2(e.result, n3, e);
+      } catch (e2) {
+        s2 = !0, o2(e2);
+      }
+    });
+  }));
+}
+async function B(e, r2) {
+  const o2 = o$1(e) ? { name: e } : e;
+  t(r2) && (o2.onsuccess = r2);
+  const { name: s2, onsuccess: a, onupgradeneeded: c2, version: i2 } = o2;
+  return g(indexedDB.open(s2, i2), a, c2);
+}
+function m(e, r2, ...o2) {
+  return new Promise((async (s2, a) => {
+    let c2 = 0;
+    const i2 = t(o2[c2]) ? o2[c2++] : void 0, u = o2[c2] ? "readwrite" : "readonly", f2 = e instanceof IDBDatabase ? e : await B(e), d2 = Array.isArray(r2) ? r2 : [r2], y2 = f2.transaction(d2.map(((e2) => o$1(e2) ? e2 : e2.store)), u), l2 = d2.map(((e2) => {
+      if (o$1(e2)) return y2.objectStore(e2);
+      const { store: t2, index: r3 } = e2;
+      return o$1(r3) ? y2.objectStore(t2).index(r3) : y2.objectStore(t2);
+    }));
+    if (i2) try {
+      s2(await i2(...l2)), u ? y2.commit() : y2.abort();
+    } catch (e2) {
+      y2.abort(), a(e2);
+    } finally {
+      f2.close();
+    }
+    else s2(l2);
+  }));
+}
+function p(e, n2, t2) {
+  return m(e, n2, t2, !1);
+}
+function D(e) {
+  return new Promise((async (n2, t2) => {
+    e.onsuccess = () => {
+      try {
+        n2(e.result);
+      } catch (e2) {
+        t2(e2);
+      }
+    }, e.onerror = (e2) => t2(e2.target.error);
+  }));
+}
+(s = o || (o = {}))[s.True = 1] = "True", s[s.False = 0] = "False";
+const P = "gs-idb", W = "gs-storage-map", toNum = (v2) => v2 instanceof Date ? v2.getTime() : v2;
+function parseIDbQuery(query) {
+  if (l(query))
+    return query;
+  const range = query;
+  if ("lt" in range && "gt" in range) {
+    if (toNum(range.gt) > toNum(range.lt))
+      throw new Error(`Invalid IDBRange: gt (${range.gt}) cannot be greater than lt (${range.lt})`);
+    return IDBKeyRange.bound(range.gt, range.lt, !0, !0);
+  }
+  if ("lt" in range && "gte" in range) {
+    if (toNum(range.gte) > toNum(range.lt))
+      throw new Error(`Invalid IDBRange: gte (${range.gte}) cannot be greater than lt (${range.lt})`);
+    return IDBKeyRange.bound(range.gte, range.lt, !1, !0);
+  }
+  if ("lte" in range && "gt" in range) {
+    if (toNum(range.gt) > toNum(range.lte))
+      throw new Error(`Invalid IDBRange: gt (${range.gt}) cannot be greater than lte (${range.lte})`);
+    return IDBKeyRange.bound(range.gt, range.lte, !0, !1);
+  }
+  if ("lte" in range && "gte" in range) {
+    if (toNum(range.gte) > toNum(range.lte))
+      throw new Error(`Invalid IDBRange: gte (${range.gte}) cannot be greater than lte (${range.lte})`);
+    return IDBKeyRange.bound(range.gte, range.lte, !1, !1);
+  }
+  if ("lt" in range)
+    return IDBKeyRange.upperBound(range.lt, !0);
+  if ("lte" in range)
+    return IDBKeyRange.upperBound(range.lte, !1);
+  if ("gt" in range)
+    return IDBKeyRange.lowerBound(range.gt, !0);
+  if ("gte" in range)
+    return IDBKeyRange.lowerBound(range.gte, !1);
+}
+function isIDbQuery(query) {
+  return parseIDbQuery(query) != null;
+}
+async function openCursor(target, arg, fn) {
+  const { query, direction = "prev", preSkip, startKey, startPrimaryKey } = arg, request = target.openCursor(parseIDbQuery(query), direction);
+  return preSkip && (await D(request)).advance(preSkip), startKey && (startPrimaryKey ? (await D(request)).continuePrimaryKey(startKey, startPrimaryKey) : (await D(request)).continue(startKey)), request;
+}
+function getMapperFn(mapper, keyPath, useArrayRecord) {
+  return Array.isArray(mapper) ? (v2) => P$1({}, v2, mapper) : t$1(mapper) ? mapper : keyPath ? (v2) => v2 : useArrayRecord ? (v2, k) => [v2, 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);
+  }
+  get storeName() {
+    return this.nativeStore?.name || this.target.store;
+  }
+  get storeSchema() {
+    if (this.#storeSchema)
+      return this.#storeSchema;
+    const storeSchema = this.idbPro.getStoreSchema(this.storeName);
+    return Object.isFrozen(storeSchema) && (this.#storeSchema = storeSchema), storeSchema;
+  }
+  get factory() {
+    return this.idbPro.factory;
+  }
+  get nativeStore() {
+    const { target } = this;
+    if (target instanceof IDBObjectStore)
+      return target;
+    if (target instanceof IDBIndex)
+      return target.objectStore;
+  }
+  get keyPath() {
+    const { target } = this;
+    if (isNativeTarget(target))
+      return target.keyPath;
+    const { storeSchema } = this, { index } = target;
+    return index ? storeSchema.indexSchemas.find((i2) => i2.name === index)?.keyPath : storeSchema.keyPath;
+  }
+  async forEach(arg, returns) {
+    return arg = t$1(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;
+    try {
+      tx = db.transaction(store, writable === !0 ? "readwrite" : "readonly"), target = nativeStore = tx.objectStore(store), index && (target = target.index(index));
+    } catch (e) {
+      throw db.close(), e;
+    }
+    if (!fn)
+      return Object.freeze({ db, tx, nativeStore, target });
+    try {
+      if (writable === !0) {
+        const result = await fn(target, nativeStore);
+        return tx.commit(), result;
+      }
+      return fn(target);
+    } catch (e) {
+      throw rollbackOnError !== !1 && tx.abort(), e;
+    } finally {
+      db.close();
+    }
+  }
+  openCursor(arg, writable) {
+    return this.tx(writable, (store) => new Promise(async (resolve, reject) => {
+      const { fn } = arg, request = await openCursor(store, arg);
+      request.onsuccess = async () => {
+        request.result ? await fn(request.result) === !1 && resolve() : resolve();
+      }, request.onerror = () => reject(request.error);
+    }));
+  }
+  cursorVoid({ query, direction, preSkip, startKey, startPrimaryKey, fn }, writable) {
+    let i2 = 0;
+    return this.openCursor({
+      query,
+      direction,
+      preSkip,
+      startKey,
+      startPrimaryKey,
+      fn: async (cursor) => {
+        const { value: ov, primaryKey: op } = cursor, result = await fn(ov, op, i2++), { control, key, primaryKey, modify, value } = c(result) ? result : { control: result };
+        switch (writable && (modify === Save ? cursor.update(value || ov) : modify === Delete && cursor.delete()), control) {
+          case Break:
+            return !1;
+          case ContinueKey:
+            cursor.continue(key);
+            break;
+          case ContinuePrimaryKey:
+            cursor.continuePrimaryKey(key, primaryKey);
+            break;
+          default:
+            cursor.continue();
+        }
+      }
+    }, !0);
+  }
+  async cursorResult({ query, direction, preSkip, startKey, startPrimaryKey, fn, mapper: mpr }, writable) {
+    const { keyPath, defaultGetMapper } = this.storeSchema, mapper = getMapperFn(mpr || defaultGetMapper, keyPath), results = [];
+    let i2 = 0;
+    return await this.openCursor({
+      query,
+      direction,
+      preSkip,
+      startKey,
+      startPrimaryKey,
+      fn: async (cursor) => {
+        const { value: ov, primaryKey: op } = cursor, { control, value, key, primaryKey, modify } = await fn?.(ov, op, i2, 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, i2)), control) {
+          case Break:
+          case Finished:
+            return !1;
+          case NextKey:
+          case ContinueKey:
+            cursor.continue(key);
+            break;
+          case NextPrimaryKey:
+          case ContinuePrimaryKey:
+            cursor.continuePrimaryKey(key, primaryKey);
+            break;
+          default:
+            cursor.continue();
+        }
+        i2++;
+      }
+    }, writable), results;
+  }
+  // noinspection JSUnusedLocalSymbols
+  #nativeOperation(writable, fn) {
+    const { target } = this, nativeStore = target instanceof IDBObjectStore ? target : target.objectStore;
+    return fn ? fn(target, nativeStore) : Object.freeze({ nativeStore, target });
+  }
+}
+class DataOperators {
+  idbPro;
+  schemas;
+  #_storeNames;
+  constructor(idbPro, schemas) {
+    this.idbPro = idbPro, this.schemas = schemas;
+  }
+  get storeNames() {
+    return this.#_storeNames || (this.#_storeNames = Array.from(new Set(this.schemas.map((s2) => s2.target.store))));
+  }
+  read(fn) {
+    return this.tx("newReader", fn);
+  }
+  write(fn, rollbackOnError = !0) {
+    return this.tx("newWriter", fn, !0, rollbackOnError);
+  }
+  export() {
+    return this.tx("newReader", async (...stores) => {
+      const result = {};
+      for (const store of stores)
+        result[store.storeName] = await store.export();
+      return result;
+    });
+  }
+  import(data, returns, use) {
+    return use || (use = "addOrChangeMany"), this.tx("newWriter", async (...stores) => {
+      const result = {};
+      stores = Array.from(new Map(stores.map((s2) => [s2.storeName, s2.asStore(!0)])).values());
+      for (const store of stores) {
+        const { storeName } = store, rows = data[storeName];
+        rows && (result[storeName] = await store[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();
+    try {
+      const tx = db.transaction(this.storeNames, writable ? "readwrite" : "readonly");
+      try {
+        const stores = schemas.map(({ storeSchema, target: info }) => {
+          let target = tx.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;
+      }
+    } finally {
+      db.close();
+    }
+  }
+}
+class DbIterator extends DataOperationBase {
+  direction;
+  query;
+  writable;
+  parser;
+  endsWithNull;
+  preSkip;
+  startKey;
+  startPrimaryKey;
+  constructor(schema, db, option) {
+    if (super(schema, db), !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 = t$1(parser) ? parser : DbIteratorParsers[parser]);
+  }
+  async *[Symbol.asyncIterator]() {
+    const { parser, writable, endsWithNull } = this, { db, tx, target } = await this.tx(writable);
+    try {
+      const request = await openCursor(target, this);
+      let cursor;
+      if (parser)
+        for (; cursor = await D(request); ) {
+          const { control, value } = await parser(cursor);
+          if (control || (yield value), control === Break)
+            break;
+          cursor.continue();
+        }
+      else {
+        let ended = !1;
+        const end = () => {
+          ended = !0;
+        };
+        for (; !ended && (cursor = await D(request)); )
+          yield { cursor, end };
+      }
+      writable && tx?.commit(), endsWithNull && !cursor && (yield null);
+    } finally {
+      db?.close();
+    }
+  }
+}
+function parseFilterArg(arg1, arg2, arg3, limit) {
+  const args = c(arg1) ? arg1 : {};
+  return t$1(arg1) ? args.fn = arg1 : isIDbQuery(arg1) && (args.query = arg1), t$1(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: R(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({
+    query,
+    preSkip,
+    direction,
+    limit: size,
+    mapper: getMapperFn(mapper, keyPath, !0)
+  });
+  return info.nextSkip = preSkip + rows.length, {
+    info: R(info),
+    rows
+  };
+}
+async function queryFnPage(reader, info, arg) {
+  info.maxEmptyChecks || (info.maxEmptyChecks = 2e4);
+  const { page, query, direction, nextSkip } = info, { keyPath } = reader.storeSchema;
+  return page === 1 ? await queryFnRow(reader, await openCursor(reader.target, { query, direction }), info, keyPath) : arg && nextSkip && page - arg.page === 1 ? await queryFnRow(reader, await openCursor(reader.target, {
+    query,
+    direction,
+    preSkip: nextSkip
+  }), info, keyPath) : await queryFnRow(reader, await openCursor(reader.target, { query, direction }), info, keyPath, !0);
+}
+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: R(info), rows: [] };
+  let i2 = 0;
+  return await new Promise(async (resolve, reject) => {
+    let ept = 0, skipped = 0;
+    const rowFn = async () => {
+      const { result: cursor } = request;
+      if (!cursor)
+        return resolve();
+      let { value, primaryKey } = cursor;
+      if (await fn(value, primaryKey, i2) ? (ept = 0, rows.push(mapper(value, primaryKey, i2))) : ept++, rows.length >= size || ept >= maxEmptyChecks)
+        return resolve();
+      i2++, cursor.continue();
+    };
+    request.onerror = () => reject(request.error), hasSkip ? request.onsuccess = async () => {
+      const { result: cursor } = request;
+      if (!cursor)
+        return resolve();
+      let { value, primaryKey } = cursor;
+      if (await fn(value, primaryKey, i2) ? (ept = 0, skipped++) : ept++, skipped >= preSkip || ept >= maxEmptyChecks) {
+        i2 = ept = 0, request.onsuccess = rowFn, cursor.continue();
+        return;
+      }
+      cursor.continue(), i2++;
+    } : request.onsuccess = rowFn;
+  }), i2 && (info.nextSkip += i2 + 1), {
+    info: R(info),
+    rows
+  };
+}
+class DataReader extends DataOperationBase {
+  all(query, limit) {
+    const param = {};
+    return i(limit) && (param.limit = limit), isIDbQuery(query) ? param.query = query : c(query) && Object.assign(param, query), this.tx(!1, (store) => D(store.getAll(parseIDbQuery(param.query), param.limit || 1e3)));
+  }
+  async count(arg1, arg2, arg3) {
+    const args = parseFilterArg(arg1, arg2, arg3), { query, direction, fn } = args;
+    if (!fn)
+      return await this.tx(!1, (store) => D(store.count(parseIDbQuery(query))));
+    const { maxEmptyChecks } = args, findFn = fn;
+    let count = 0, ept = 0, i2 = 0;
+    return await this.openCursor({
+      query,
+      direction,
+      fn: (cursor) => {
+        if (findFn(cursor.value, cursor.primaryKey, i2++))
+          count++, ept = 0;
+        else if (++ept >= maxEmptyChecks)
+          return !1;
+        cursor.continue();
+      }
+    }), count;
+  }
+  get(key) {
+    return this.tx(!1, (store) => D(store.get(parseIDbQuery(key))));
+  }
+  getMany(keys, excludeEmpty) {
+    return this.batchRead(async (reader) => {
+      const rows = await O(keys, (k) => reader.get(k));
+      return excludeEmpty ? rows.filter((v2) => v2) : rows;
+    });
+  }
+  getRange(query, direction) {
+    return this.forEach({ query, direction }, !0);
+  }
+  async getRangeMany(keys, direction, excludeEmpty) {
+    return (await this.batchRead((w) => O(keys, (v2) => w.getRange(v2, direction)))).flat();
+  }
+  index(name, writable) {
+    let { target } = this;
+    return target instanceof IDBIndex && (target = target.objectStore), target instanceof IDBObjectStore ? (target = target.index(name), this.createOperator(target, writable)) : this.idbPro.store(target.store, name);
+  }
+  asStore(writable) {
+    let { target } = this;
+    if (target instanceof IDBObjectStore)
+      return this;
+    if (target instanceof IDBIndex)
+      target = target.objectStore;
+    else {
+      if (!("index" in target))
+        return this;
+      target = { store: target.store };
+    }
+    return this.createOperator(target, writable);
+  }
+  batchRead(fn) {
+    return isNativeTarget(this.target) ? fn(this) : this.tx(!1, (store) => fn(this.idbPro.schema.factory.newReader({
+      storeSchema: this.storeSchema,
+      target: store
+    }, this.idbPro)));
+  }
+  iterator(query, direction) {
+    const arg = {};
+    return o$2(direction) && (arg.direction = direction), isIDbQuery(query) ? arg.query = query : c(query) && Object.assign(arg, query), new DbIterator({ storeSchema: this.storeSchema, target: this.target }, this.idbPro, {
+      ...arg,
+      parser: "value"
+    });
+  }
+  async filter(arg1, arg2, arg3, arg4) {
+    const args = parseFilterArg(arg1, arg2, arg3, arg4), { maxEmptyChecks, limit, fn } = args, { keyPath, defaultGetMapper } = this.storeSchema, mapper = getMapperFn(args.mapper || defaultGetMapper, keyPath, !0);
+    if (!fn)
+      return await this.forEach({
+        ...args,
+        mapper,
+        fn: (value, k, i2) => {
+          if (i2 >= limit - 1)
+            return { control: Finished };
+        }
+      }, !0);
+    let ept = 0;
+    return this.forEach({
+      ...args,
+      mapper,
+      fn: (value, k, i2, results) => {
+        if (fn(value, k, i2))
+          ept = 0;
+        else
+          return ++ept >= maxEmptyChecks ? { control: Break } : { control: Continue };
+        if (results.length >= limit - 1)
+          return { control: Finished };
+      }
+    }, !0);
+  }
+  async find(query, fn, direction) {
+    const [value] = await this.filter(query, fn, direction, 1);
+    return value;
+  }
+  async page(arg, page) {
+    const info = { ...arg };
+    return info.page = page || arg?.page || 1, queryPage(this, info, arg);
+  }
+  nextPage(info) {
+    return this.page(info, info.page + 1);
+  }
+  export(arg1, arg2) {
+    const args = parseFilterArg(arg1, arg2), { keyPath, exportMapper, name, defaultGetMapper } = this.storeSchema;
+    if (!keyPath && Array.isArray(exportMapper))
+      throw new Error(`When store [ ${name} ] keyPath does not exist, exportMapper does not support string[].`);
+    return args.direction = "next", args.mapper = getMapperFn(exportMapper || defaultGetMapper, keyPath, !0), args.limit = args.maxEmptyChecks = Number.MAX_SAFE_INTEGER, this.filter(args);
+  }
+  asMap() {
+    let { target } = this;
+    return target instanceof IDBIndex ? target = target.objectStore : target instanceof IDBObjectStore || (target = { store: target.store }), this.factory.newDbMap({ target }, this.idbPro);
+  }
+  createOperator(target, writable) {
+    const { idbPro } = this, tmp = this.storeSchema, schema = { storeSchema: Object.isFrozen(tmp) ? tmp : void 0, target };
+    return writable ? this.factory.newWriter(schema, idbPro) : this.factory.newReader(schema, idbPro);
+  }
+}
+function getKeyValueToObject(keyPath, value) {
+  if (!Array.isArray(keyPath))
+    return { [keyPath]: value };
+  const rv = {}, arrayKeyPath = keyPath;
+  for (let i2 = 0; i2 < arrayKeyPath.length; i2++)
+    rv[arrayKeyPath[i2]] = value[i2];
+  return rv;
+}
+function getValidKeyValue(keyPath, value) {
+  if (!Array.isArray(keyPath))
+    return value[keyPath];
+  const rv = [];
+  for (const k of keyPath) {
+    if (!value[k])
+      return;
+    rv.push(value[k]);
+  }
+  return rv;
+}
+function checkAddValue(storeSchema, value) {
+  if (!value || !(value instanceof Object) || Array.isArray(value))
+    return value;
+  const { addedTimeField, updatedTimeField, updatedCountField, softDeletedField } = storeSchema;
+  return value = { ...value }, addedTimeField?.name && !i(value[addedTimeField.name]) && (value[addedTimeField.name] = Date.now()), updatedTimeField?.name && !i(value[updatedTimeField.name]) && (value[updatedTimeField.name] = Date.now()), softDeletedField?.name && !i(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;
+  const { updatedTimeField, updatedCountField } = storeSchema;
+  return newValue = { ...oldValue, ...newValue }, updatedTimeField.name && (newValue[updatedTimeField.name] = Date.now()), updatedCountField.name && (newValue[updatedCountField.name] = (newValue[updatedCountField.name] || 0) + 1), newValue;
+}
+class DataWriter extends DataReader {
+  add(record) {
+    return this.changeByPk({
+      record,
+      fn: async (store, pk, newValue, oldValue, keyPath) => {
+        const { storeSchema } = this;
+        return newValue = checkAddValue(storeSchema, newValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await D(store.add(newValue))) }, pk] : [newValue, await D(store.add(newValue, pk))];
+      }
+    });
+  }
+  addMany(records, returns) {
+    return this.batchWrite((w) => returns ? O(records, (v2) => w.add(v2)) : v(records, (v2) => w.add(v2)), !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);
+      if (pk) {
+        const item = await D(w.nativeStore.get(pk));
+        if (item)
+          return getMapperFn(defaultGetMapper, storeKeyPath)?.(item, pk);
+      }
+      if (w.target instanceof IDBIndex) {
+        const { keyPath } = w, keyValue = getValidKeyValue(keyPath, value);
+        if (!keyValue)
+          return w.add(record);
+        let oldValue = await w.find(keyValue);
+        if (oldValue)
+          return oldValue;
+      }
+      return w.add(record);
+    });
+  }
+  addOrSkipMany(records, returns) {
+    return this.batchWrite((w) => returns ? O(records, (v2) => w.addOrSkip(v2)) : v(records, (v2) => w.addOrSkip(v2)), !0);
+  }
+  replace(record) {
+    return this.changeByPk({
+      record,
+      getOld: !0,
+      fn: async (store, 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 D(store.put(newValue))) }, pk] : [newValue, await D(store.put(newValue, pk))];
+      }
+    });
+  }
+  replaceMany(records, returns) {
+    return this.batchWrite((w) => returns ? O(records, (v2) => w.replace(v2)) : v(records, (v2) => w.replace(v2)), !0);
+  }
+  change(record, throwIfMissing) {
+    return this.changeByPk({
+      record,
+      getOld: !0,
+      requiredOld: throwIfMissing,
+      requiredPk: throwIfMissing,
+      fn: async (store, pk, newValue, oldValue, keyPath) => {
+        const { storeSchema } = this;
+        if (oldValue)
+          return newValue = checkUpdateValue(storeSchema, newValue, oldValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await D(store.put(newValue))) }, pk] : [newValue, await D(store.put(newValue, pk))];
+      }
+    });
+  }
+  changeMany(records, option) {
+    const { returns, throwIfMissing } = r(option) ? { returns: option } : option || {};
+    return this.batchWrite((w) => returns ? O(records, (v2) => w.change(v2, throwIfMissing)) : v(records, (v2) => w.change(v2, throwIfMissing)), !0);
+  }
+  addOrChange(record) {
+    return this.changeByPk({
+      record,
+      getOld: !0,
+      fn: async (store, pk, newValue, oldValue, keyPath) => {
+        const { storeSchema } = this;
+        return oldValue ? (newValue = checkUpdateValue(storeSchema, newValue, oldValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await D(store.put(newValue))) }, pk] : [newValue, await D(store.put(newValue, pk))]) : (newValue = checkAddValue(storeSchema, newValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await D(store.add(newValue))) }, pk] : [newValue, await D(store.add(newValue, pk))]);
+      }
+    });
+  }
+  addOrChangeMany(records, returns) {
+    return this.batchWrite((w) => returns ? O(records, (v2) => w.addOrChange(v2)) : v(records, (v2) => w.addOrChange(v2)), !0);
+  }
+  delete(pk, returns) {
+    return this.changeByPk({
+      pk,
+      getOld: returns,
+      fn: (store, pk2, newValue, oldValue) => {
+        if (store.delete(pk2), !!returns)
+          return [oldValue, pk2];
+      }
+    });
+  }
+  deleteMany(keys, returns) {
+    return this.batchWrite((w) => returns ? O(keys, (v2) => w.delete(v2, !0)) : v(keys, (v2) => w.delete(v2)), !0);
+  }
+  deleteRange(query, returns) {
+    const { returns: hasRtn, physical, direction } = r(returns) ? { returns } : returns || {}, { name } = this.storeSchema.softDeletedField || {};
+    return this.cursor({
+      query,
+      direction,
+      fn: (value) => physical || !name ? { modify: Delete } : (value[name] = 1, { modify: Save })
+    }, hasRtn);
+  }
+  deleteRangeMany(keys, returns) {
+    const option = r(returns) ? { returns } : returns;
+    return this.batchWrite((w) => option?.returns ? O(keys, (v2) => w.deleteRange(v2, option)) : v(keys, (v2) => w.deleteRange(v2, option)), !0);
+  }
+  changeRange(arg, returns) {
+    let { direction = "next", query, newValue } = "newValue" in arg ? arg : { newValue: arg };
+    if (query || (query = getValidKeyValue(this.keyPath, newValue)), !query)
+      throw new Error(`query is required\uFF1A${JSON.stringify(arg)}`);
+    return this.cursor({
+      query,
+      direction,
+      fn: (value) => value instanceof Object ? { modify: Save, value: { ...value, ...newValue } } : { modify: Save, value: newValue }
+    }, returns);
+  }
+  changeRangeMany(args, returns) {
+    return this.batchWrite((w) => returns ? O(args, (v2) => w.changeRange(v2, returns)) : v(args, (v2) => w.changeRange(v2, returns)), !0);
+  }
+  cursor(arg, returns) {
+    return arg = t$1(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))
+      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({
+      storeSchema: this.storeSchema,
+      target: store
+    }, this.idbPro)), rollbackOnError);
+  }
+  changeByPk({ pk, record, fn, requiredPk, getOld, requiredOld, saveMapper, getMapper }) {
+    const { storeSchema } = this, { keyPath, defaultSaveMapper, defaultGetMapper } = storeSchema;
+    return record && (saveMapper || defaultSaveMapper) && (record = getMapperFn(saveMapper || defaultSaveMapper, keyPath)?.(record)), this.batchWrite(async (w) => {
+      let query, newValue = record;
+      if (pk)
+        query = parseIDbQuery(pk);
+      else if (keyPath)
+        query = getValidKeyValue(keyPath, record);
+      else {
+        const { key, value } = parseDbNoneKeyPathRecord(record);
+        query = key, newValue = value;
+      }
+      if (requiredPk && !query)
+        throw new Error(`key is required: ${JSON.stringify(record)}`);
+      const oldValue = query && (getOld || requiredOld) ? await D(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);
+      if (result)
+        return getMapperFn(getMapper || defaultGetMapper, keyPath)?.(result[0], result[1]);
+    });
+  }
+}
+class DbMap extends DataOperationBase {
+  get size() {
+    return this.tx(!1, (store) => D(store.count()));
+  }
+  delete(key) {
+    return this.tx(!0, async (t2, store) => {
+      store.delete(key);
+    });
+  }
+  batch(fn) {
+    const { idbPro, storeSchema, factory } = this;
+    return this.tx(!0, async (t2, store) => await fn(factory.newDbMap({ storeSchema, target: store }, idbPro)));
+  }
+  asStore(writable) {
+    const { factory } = this.idbPro.schema;
+    return writable ? factory.newWriter(this, this.idbPro) : factory.newReader({ target: this.target }, this.idbPro);
+  }
+  entries() {
+    return new DbIterator({
+      target: this.target
+    }, this.idbPro, { parser: "keyValue" });
+  }
+  async get(key, defaultValue) {
+    return await this.tx(!1, (store) => D(store.get(key))) || defaultValue;
+  }
+  getMany(keys) {
+    return this.tx(!1, async (store) => {
+      const result = [];
+      for (const k of keys)
+        result.push(await D(store.get(k)));
+      return result;
+    });
+  }
+  async has(key) {
+    return !!await this.get(key);
+  }
+  keys() {
+    return new DbIterator({ storeSchema: this.storeSchema, target: this.target }, this.idbPro, { parser: "key" });
+  }
+  set(key, value) {
+    return this.tx(!0, async (t2, store) => {
+      await D(store.put(value, key));
+    });
+  }
+  setMany(values) {
+    return this.tx(!0, async (t2, store) => {
+      for (const [k, v2] of values)
+        store.put(v2, k);
+    });
+  }
+  values() {
+    return new DbIterator({ storeSchema: this.storeSchema, target: this.target }, this.idbPro, { parser: "value" });
+  }
+}
+function equalKeyPath(p1, p2) {
+  if (p1 == p2)
+    return !0;
+  if (typeof p1 != typeof p2)
+    return !1;
+  if (Array.isArray(p1) && Array.isArray(p2)) {
+    if (p1.length !== p2.length)
+      return !1;
+    for (let i2 = 0; i2 < p1.length; i2++)
+      if (p1[i2] !== p2[i2])
+        return !1;
+    return !0;
+  }
+  return !1;
+}
+const versionDiffValidate = ({ stores, schema }) => {
+  const storeSchemas = schema.storeSchemas;
+  let info = "";
+  for (const store of stores) {
+    const ss = storeSchemas.find((s2) => s2.name === store.name);
+    if (ss) {
+      if (!equalKeyPath(store.keyPath, ss.keyPath)) {
+        info = `store [ ${store.name} ] keyPath not equal,schema.keyPath:${ss.keyPath},store.keyPath:${store.keyPath}[]`;
+        break;
+      }
+      if (!store.autoIncrement != !ss.autoIncrement) {
+        info = `store [ ${store.name} ] autoIncrement not equal`;
+        break;
+      }
+    }
+  }
+  return info ? `The existing database is inconsistent with the definition and cannot be corrected\uFF1A ${info}` : !0;
+}, versionSameValidate = async (context) => {
+  let result = versionDiffValidate(context);
+  return o$2(result) || (result = validateStoreAndIndexes(context)), result;
+}, validateStoreAndIndexes = ({ stores, schema }) => {
+  const storeSchemas = schema.storeSchemas, dbStoreNames = stores.map((s2) => s2.name);
+  let info = "";
+  const missingStoreNames = storeSchemas.map((s2) => s2.name).filter((s2) => !dbStoreNames.includes(s2));
+  if (missingStoreNames.length)
+    info = `store [ ${missingStoreNames.join(",")} ] not exist`;
+  else
+    for (const store of stores) {
+      const ss = storeSchemas.find((s2) => s2.name === store.name);
+      if (ss && (info = validateIndexes$1(store, Array.from(store.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\uFF1A ${info}` : !0;
+};
+function validateIndexes$1(store, indexNames, schemas) {
+  if (indexNames.length !== schemas.length)
+    return `store [ ${store.name} ] index count not equal`;
+  for (const name of indexNames) {
+    const schema = schemas.find((s2) => s2.name === name);
+    if (!schema)
+      return `store [ ${store.name} ] index [ ${name} ] not exist`;
+    const index = store.index(name);
+    if (!schema.unique != !index.unique)
+      return `store [ ${store.name} ] index [ ${name} ] unique not equal`;
+    if (!schema.multiEntry != !index.multiEntry)
+      return `store [ ${store.name} ] index [ ${name} ] multiEntry not equal`;
+    if (!equalKeyPath(schema.keyPath, index.keyPath))
+      return `store [ ${store.name} ] index [ ${name} ] keyPath not equal`;
+  }
+  return "";
+}
+class StoreUpgradeable {
+  upgradeContext;
+  storeSchema;
+  nativeStore;
+  #writer;
+  constructor(upgradeContext, storeSchema, nativeStore) {
+    this.upgradeContext = upgradeContext, this.storeSchema = storeSchema, this.nativeStore = nativeStore;
+  }
+  get writer() {
+    return this.#writer || (this.#writer = this.upgradeContext.dbSchema.factory?.newWriter({
+      target: this.nativeStore,
+      storeSchema: this.storeSchema
+    }));
+  }
+  add(versionBounds, values, returns) {
+    return this.upgradeContext.versionIn(versionBounds) ? this.writer.addMany(values, returns) : Promise.resolve();
+  }
+  addOrChange(versionBounds, values, returns) {
+    return this.upgradeContext.versionIn(versionBounds) ? this.writer.addOrChangeMany(values, returns) : Promise.resolve();
+  }
+  async call(versionBounds, fn) {
+    if (this.upgradeContext.versionIn(versionBounds))
+      return await fn(this.writer, this.upgradeContext);
+  }
+  replace(versionBounds, values, returns) {
+    return this.upgradeContext.versionIn(versionBounds) ? this.writer.replaceMany(values, returns) : Promise.resolve();
+  }
+}
+const DataOperatorFactory = Object.freeze({
+  newDataOperators(schemas, db) {
+    return new DataOperators(db, schemas);
+  },
+  newDbMap(schema, db) {
+    return new DbMap(schema, db);
+  },
+  newReader(schema, db) {
+    return new DataReader(schema, db);
+  },
+  newStoreUpgradeable(nativeStore, storeSchema, upgradeContext) {
+    return new StoreUpgradeable(upgradeContext, storeSchema, nativeStore);
+  },
+  newWriter(schema, db) {
+    return new DataWriter(schema, db);
+  }
+});
+function validateSpecialFields(schema) {
+  Object.isFrozen(schema) || (schema.addedTimeField = validateSpecialField(schema, schema.addedTimeField, "added_at", !0), schema.updatedTimeField = validateSpecialField(schema, schema.updatedTimeField, "updated_at", !0), schema.updatedCountField = validateSpecialField(schema, schema.updatedCountField, "updated_count", !1), schema.softDeletedField = validateSpecialField(schema, schema.softDeletedField, "deleted", !1));
+}
+function validateSpecialField(schema, field, defaultName, useDefault) {
+  const validField = validateSpecialFieldBase(field, defaultName, useDefault);
+  if (!validField)
+    return validField;
+  const schemaField = validField;
+  if (schemaField.isIndexed !== !1) {
+    schemaField.isIndexed || (schemaField.isIndexed = !0);
+    const { name } = schemaField, indexSchemas = schema.indexSchemas;
+    indexSchemas.some((i2) => i2 === name || i2.name === name) || indexSchemas.push(name);
+  }
+  return schemaField;
+}
+function validateSpecialFieldBase(field, defaultName, useDefault) {
+  if (field === !1)
+    return !1;
+  if (o$2(field))
+    return { name: field };
+  if (c(field)) {
+    const r$1 = field;
+    return r(r$1.name) && (r$1.name = defaultName), field;
+  } else if (field === !0 || useDefault)
+    return { name: defaultName };
+  return !1;
+}
+function validateStoreSchema(schema, storeTemplate) {
+  let validSchema = o$2(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 = o$2(index) ? { name: index } : index;
+  return schema.keyPath || (schema.keyPath = schema.name), schema;
+}
+function validateDefaultData(schema) {
+  if (!(schema.keyPath || !schema.defaultData?.length)) {
+    for (const row of schema.defaultData)
+      if (!Array.isArray(row) && !("value" in row))
+        throw new Error(`When \`defaultData\` must contain \`value\` fields or be an array\uFF1A${JSON.stringify(row)}`);
+  }
+}
+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((s2) => validateStoreSchema(s2, schema.storeTemplate)), schema;
+};
+async function validateBeforeOpen(schema) {
+  const { name, version } = schema, existDb = await b(name);
+  if (!existDb)
+    return !0;
+  const { versionDiffValidate: versionDiffValidate2, versionSameValidate: versionSameValidate2 } = schema, db = await B(name);
+  try {
+    if (schema.version < db.version)
+      return "The existing database version is greater than the current version";
+    const validate = schema.version === void 0 || db.version === schema.version ? versionSameValidate2 : versionDiffValidate2;
+    if (!validate)
+      return !0;
+    const storeNames = Array.from(db.objectStoreNames);
+    if (storeNames.length < 1)
+      return `The existing database [ ${name} ] is empty`;
+    const stores = await p(db, storeNames), diffResult = await validate({ schema, db, stores });
+    if (o$2(diffResult) || version !== existDb.version)
+      return diffResult;
+  } finally {
+    db?.close();
+  }
+  return !0;
+}
+function validateIndexes(storeSchema, store) {
+  const { indexSchemas } = storeSchema, existNames = store.indexNames, schemaNames = indexSchemas.map((option) => option.name);
+  for (const name of Array.from(existNames))
+    schemaNames.includes(name) || store.deleteIndex(name);
+  for (const indexSchema of indexSchemas)
+    existNames.contains(indexSchema.name) ? validateIndex(store, indexSchema) : createIndex(store, indexSchema);
+  return store;
+}
+function validateIndex(store, indexOption) {
+  const index = store.index(indexOption.name);
+  checkIndex(index, indexOption) || (store.deleteIndex(indexOption.name), createIndex(store, indexOption));
+}
+function checkIndex(index, indexOption) {
+  return index.unique !== indexOption.unique || index.multiEntry !== indexOption.multiEntry ? !1 : equalKeyPath(indexOption.keyPath, index.keyPath);
+}
+function createIndex(store, schema) {
+  try {
+    store.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)}`);
+  }
+}
+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, {
+    keyPath: schema.keyPath,
+    autoIncrement: schema.autoIncrement
+  });
+  for (const option of schema.indexSchemas)
+    createIndex(store, option);
+  return store;
+}
+class UpgradeContext {
+  database;
+  newVersion;
+  oldVersion;
+  dbSchema;
+  transaction;
+  #stores = {};
+  constructor(args) {
+    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);
+  }
+  destroy() {
+    try {
+      C(this.#stores);
+    } finally {
+      for (const k of Object.keys(this.#stores))
+        delete this.#stores[k];
+    }
+  }
+  store(storeName) {
+    if (storeName in this.#stores)
+      return this.#stores[storeName];
+    const { factory } = this.dbSchema, { storeSchemas } = this.dbSchema, storeSchema = storeSchemas.find((s2) => s2.name === storeName), nativeStore = validateStoreDefine(this, storeSchema);
+    return this.#stores[storeName] = factory.newStoreUpgradeable(nativeStore, storeSchema, this);
+  }
+  versionIn({ oldMin, oldMax, newMax, newMin }) {
+    if (oldMax === void 0 && newMax === void 0 && oldMin === void 0 && newMin === void 0)
+      throw new Error(`versionIn bounds must not be empty ${JSON.stringify({ oldMax, newMax, oldMin, newMin })}`);
+    if (oldMax < oldMin)
+      throw new Error(`oldMax (${oldMax}) cannot be less than oldMin (${oldMin})`);
+    if (newMax < newMin)
+      throw new Error(`newMax (${newMax}) cannot be less than newMin (${newMin})`);
+    const { oldVersion, newVersion } = this;
+    return oldMin !== void 0 && oldVersion < oldMin || oldMax !== void 0 && oldVersion > oldMax || newMin !== void 0 && newVersion < newMin ? !1 : !(newMax !== void 0 && newVersion > newMax);
+  }
+}
+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 (t$1(beforeUpgrade))
+      try {
+        await beforeUpgrade(context);
+      } catch (e2) {
+        errors.push(e2);
+      }
+    for (const storeName of storeSchemas.map((s2) => s2.name))
+      try {
+        context.store(storeName);
+      } catch (e2) {
+        errors.push(e2);
+      }
+    for (const { name, defaultData } of storeSchemas)
+      if (defaultData)
+        try {
+          await context.store(name).add({ oldMax: 0 }, defaultData);
+        } catch (e2) {
+          errors.push(e2);
+        }
+    for (const { name, versionData } of storeSchemas)
+      if (versionData)
+        for (const { version: version2, data, use = "addOrChange" } of versionData)
+          try {
+            await context.store(name)[use](version2, data);
+          } catch (e2) {
+            errors.push(e2);
+          }
+    for (const { name, storeDefined } of storeSchemas)
+      try {
+        await storeDefined?.(context.store(name));
+      } catch (e2) {
+        errors.push(e2);
+      }
+    if (t$1(afterUpgrade))
+      try {
+        await afterUpgrade(context);
+      } catch (e2) {
+        errors.push(e2);
+      }
+    if (!errors.length)
+      return;
+    throw errors.length === 1 ? errors[0] : new AggregateError(errors, "Database upgrade error");
+  } finally {
+    x(context);
+  }
+}
+function validateDataOperationSchema(schema, dbSchema) {
+  let { store, index } = schema;
+  const { storeTemplate } = dbSchema, { storeSchemas = [] } = dbSchema, storeName = o$2(store) ? store : store.name, storeIndex = storeSchemas.findIndex((s2) => s2 === storeName || s2.name === storeName), existStore = storeIndex > -1 && storeSchemas[storeIndex];
+  let tmp;
+  o$2(store) ? tmp = existStore || storeName : !existStore || o$2(existStore) || store === existStore ? tmp = store : tmp = { ...existStore, ...store }, (index || existStore?.indexSchemas?.length || store?.indexSchemas?.length) && (o$2(tmp) && (tmp = { name: tmp }), tmp.indexSchemas = mergeIndexes(existStore.indexSchemas || [], store.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 = o$2(index) ? index : index.name), {
+    target
+  };
+}
+function mergeIndexes(existIndexes, newIndexes, index) {
+  index && newIndexes.push(index);
+  for (const index2 of newIndexes) {
+    const indexName = o$2(index2) ? index2 : index2.name, existIndex = existIndexes.findIndex((i2) => i2 === indexName || i2.name === indexName);
+    if (existIndex > -1) {
+      const old = existIndexes[existIndex];
+      o$2(old) ? existIndexes[existIndex] = index2 : o$2(index2) || (existIndexes[existIndex] = Object.assign(old, index2));
+    } else
+      existIndexes.push(index2);
+  }
+  return existIndexes;
+}
+const mapStoreSchema = Object.assign({
+  name: "",
+  addedTimeField: !1,
+  autoIncrement: !1,
+  indexSchemas: [],
+  keyPath: void 0,
+  softDeletedField: !1,
+  updatedCountField: !1,
+  updatedTimeField: !1
+});
+class IDbPro {
+  static #_db;
+  #schema;
+  #beforeUseValid;
+  #storeSchemaRecord = {};
+  constructor(schema, skipPreOpenValidation) {
+    this.#schema = schema = o$2(schema) ? { name: schema } : schema, Array.isArray(schema.storeSchemas) || (schema.storeSchemas = []), c(schema.storeTemplate) || (schema.storeTemplate = defaultStoreSchemaTemplate), skipPreOpenValidation && (this.#beforeUseValid = !0);
+  }
+  /**
+   * 默认实例
+   */
+  static get defaultDb() {
+    return this.#_db || (this.#_db = new IDbPro(P));
+  }
+  get initialized() {
+    return Object.isFrozen(this.#schema);
+  }
+  get schema() {
+    return this.#schema;
+  }
+  get storeNames() {
+    return Array.from(new Set(this.#schema.storeSchemas.map((s2) => o$2(s2) ? s2 : s2.name)));
+  }
+  get factory() {
+    return this.#schema.factory || (this.#schema.factory = DataOperatorFactory);
+  }
+  /**
+   * 释放默认数据库实例（如果存在）
+   */
+  static releaseDefaultDB() {
+    this.#_db = void 0;
+  }
+  /**
+   * 从已经存在的`name`数据库中打开
+   * @warning 该方法仅用于不需要修改原有数据库结构的场景
+   * - 如果需要修改，请使用 `generateDbSchema()` 从现有数据库生成配置，且适当修改后重新打开
+   * @param name
+   */
+  static async openExistDb(name) {
+    const { generateDbSchema: generateDbSchema2 } = await Promise.resolve().then(function() {
+      return generateDbSchema$1;
+    });
+    return new IDbPro(await generateDbSchema2(name));
+  }
+  static store(arg1, index) {
+    return IDbPro.defaultDb.store(arg1, index);
+  }
+  static stores(schemas) {
+    return IDbPro.defaultDb.stores(schemas);
+  }
+  static map(storeName, defaultData) {
+    return IDbPro.defaultDb.map(storeName, defaultData);
+  }
+  async openNativeDb() {
+    const schema = this.#schema = R(this.initSchema());
+    await this.#isBeforeUseValidate();
+    const { name, version } = schema;
+    return await B({
+      name,
+      version,
+      onupgradeneeded: (db, e, request) => upgradeDb(schema, db, e, request)
+    });
+  }
+  store(arg1, index) {
+    const operation = arg1.store ? arg1 : { store: arg1 };
+    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(o$2(store) ? { store } : store, schema));
+    return this.factory.newDataOperators(results, this);
+  }
+  initSchema() {
+    if (this.initialized)
+      return this.#schema;
+    const { validateSchemaWithDefaults: validate = validateSchemaWithDefaults } = this.#schema;
+    return this.#schema = validate(this.#schema);
+  }
+  async traceSchema(showFn) {
+    await st(this.schema, showFn);
+  }
+  map(storeName, defaultData) {
+    const name = o$2(storeName) ? storeName : o$2(defaultData) ? defaultData : W;
+    Array.isArray(storeName) && (defaultData = storeName);
+    const { storeSchemas } = this.schema;
+    return storeSchemas.find((s2) => s2.name === name || s2 === name) || storeSchemas.push({ ...mapStoreSchema, name, defaultData }), this.factory.newDbMap({ target: { store: name } }, this);
+  }
+  export() {
+    return this.stores(this.storeNames).export();
+  }
+  import(data, returns, use) {
+    return this.stores(this.storeNames).import(data, returns, use);
+  }
+  getStoreSchema(name) {
+    if (name in this.#storeSchemaRecord)
+      return this.#storeSchemaRecord[name];
+    const index = this.schema.storeSchemas.findIndex((s2) => s2 === name || s2.name === name);
+    let storeSchema = this.schema.storeSchemas[index];
+    return this.initialized ? this.#storeSchemaRecord[name] = storeSchema : o$2(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 (o$2(valid))
+      throw new Error(valid);
+  }
+}
+function dbStore(arg1, index) {
+  return IDbPro.defaultDb.store(arg1, index);
+}
+function dbMap(storeName, defaultData) {
+  return IDbPro.defaultDb.map(storeName, defaultData);
+}
+function dbStores(schemas) {
+  return IDbPro.defaultDb.stores(schemas);
+}
+function releaseDefaultDB() {
+  IDbPro.releaseDefaultDB();
+}
+function generateStoreSchema(store, fields) {
+  const { name, keyPath, autoIncrement } = store;
+  return {
+    name,
+    keyPath,
+    autoIncrement,
+    ...parseIndexes(store, fields)
+  };
+}
+function parseIndexes(store, fields) {
+  const indexes = Array.from(store.indexNames).map((n2) => store.index(n2)), 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);
+  return {
+    indexSchemas,
+    addedTimeField: convertSpecialField(fields.addedTimeField, keySet),
+    updatedTimeField: convertSpecialField(fields.updatedTimeField, keySet),
+    updatedCountField: convertSpecialField(fields.updatedCountField, keySet),
+    softDeletedField: convertSpecialField(fields.softDeletedField, keySet)
+  };
+}
+function convertSpecialField(field, keySet) {
+  return keySet.has(field) ? { name: field, isIndexed: !1 } : !1;
+}
+async function generateDbSchema(db, option) {
+  if (!await b(db))
+    throw new Error(`db [ ${db} ] not exist`);
+  let { asString, specialFields = 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 ot({
+    rootData$: dbSchema,
+    spaceEffectiveLength: asString
+  }) : dbSchema;
+}
+async function generateData(dbSchema, dataExportTarget) {
+  const data = await new IDbPro(L(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({
+      version: { oldMax: dbSchema.version },
+      data: rows
+    })));
+  }
+  return dbSchema;
+}
+function generateRoot(db, specialFields) {
+  return B(db, async function(existDb) {
+    const names = Array.from(existDb.objectStoreNames), tx = existDb.transaction(names, "readonly");
+    try {
+      return {
+        name: existDb.name,
+        version: existDb.version,
+        storeSchemas: names.map((name) => generateStoreSchema(tx.objectStore(name), specialFields))
+      };
+    } finally {
+      tx.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
+};