gs-idb-pro 0.1.1 → 0.1.2

package/lib/index.cjs

@@ -1 +1,1247 @@
-"use strict";var e=require("gs-base"),t=require("gs-idb-basic");const r=Symbol("save"),a=Symbol("delete"),n=Object.freeze({key:({primaryKey:e})=>({value:e}),value:({value:e})=>({value:e}),keyValue:({primaryKey:e,value:t})=>({value:[e,t]})});function s(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 i=Symbol("break"),o=Symbol("finished"),c=Symbol("continue"),u=Symbol("continue key"),d=Symbol("next key"),h=Symbol("continue primary key"),l=Symbol("next primary key");function m(e){return e instanceof IDBObjectStore||e instanceof IDBIndex}const f=Object.freeze({keyPath:"id",autoIncrement:!0,addedTimeField:!0,updatedTimeField:!0}),y=Object.freeze({addedTimeField:"added_at",softDeletedField:"deleted",updatedCountField:"updated_count",updatedTimeField:"updated_at"}),p=e=>e instanceof Date?e.getTime():e;function g(e){if(t.isDbQueryOrNull(e))return e;const r=e;if("lt"in r&&"gt"in r){if(p(r.gt)>p(r.lt))throw new Error(`Invalid IDBRange: gt (${r.gt}) cannot be greater than lt (${r.lt})`);return IDBKeyRange.bound(r.gt,r.lt,!0,!0)}if("lt"in r&&"gte"in r){if(p(r.gte)>p(r.lt))throw new Error(`Invalid IDBRange: gte (${r.gte}) cannot be greater than lt (${r.lt})`);return IDBKeyRange.bound(r.gte,r.lt,!1,!0)}if("lte"in r&&"gt"in r){if(p(r.gt)>p(r.lte))throw new Error(`Invalid IDBRange: gt (${r.gt}) cannot be greater than lte (${r.lte})`);return IDBKeyRange.bound(r.gt,r.lte,!0,!1)}if("lte"in r&&"gte"in r){if(p(r.gte)>p(r.lte))throw new Error(`Invalid IDBRange: gte (${r.gte}) cannot be greater than lte (${r.lte})`);return IDBKeyRange.bound(r.gte,r.lte,!1,!1)}return"lt"in r?IDBKeyRange.upperBound(r.lt,!0):"lte"in r?IDBKeyRange.upperBound(r.lte,!1):"gt"in r?IDBKeyRange.lowerBound(r.gt,!0):"gte"in r?IDBKeyRange.lowerBound(r.gte,!1):void 0}function b(e){return null!=g(e)}async function S(e,r,a){const{query:n,direction:s="prev",preSkip:i,startKey:o,startPrimaryKey:c}=r,u=e.openCursor(g(n),s);return i&&(await t.requestDbResult(u)).advance(i),o&&(c?(await t.requestDbResult(u)).continuePrimaryKey(o,c):(await t.requestDbResult(u)).continue(o)),u}function w(t,r,a){return Array.isArray(t)?r=>e.copyFields({},r,t):e.isFunction(t)?t:r?e=>e:a?(e,t)=>[e,t]:(e,t)=>({key:e,value:t})}class x{idbPro;target;#e;constructor(e,t){this.idbPro=t,this.#e=e.storeSchema,this.target=e.target,m(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(m(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(t,r){return t=e.isFunction(t)?{fn:t}:t,r?this.cursorResult(t,!1):this.cursorVoid(t,!1)}async tx(e,t,r){let{target:a}=this;const{store:n,index:s}=a,i=await this.idbPro.openNativeDb();let o,c;try{o=i.transaction(n,!0===e?"readwrite":"readonly"),a=c=o.objectStore(n),s&&(a=a.index(s))}catch(e){throw i.close(),e}if(!t)return Object.freeze({db:i,tx:o,nativeStore:c,target:a});try{if(!0===e){const e=await t(a,c);return o.commit(),e}return t(a)}catch(e){throw!1!==r&&o.abort(),e}finally{i.close()}}openCursor(e,t){return this.tx(t,t=>new Promise(async(r,a)=>{const{fn:n}=e,s=await S(t,e);s.onsuccess=async()=>{s.result?!1===await n(s.result)&&r():r()},s.onerror=()=>a(s.error)}))}cursorVoid({query:t,direction:n,preSkip:s,startKey:o,startPrimaryKey:c,fn:d},l){let m=0;return this.openCursor({query:t,direction:n,preSkip:s,startKey:o,startPrimaryKey:c,fn:async t=>{const{value:n,primaryKey:s}=t,o=await d(n,s,m++),{control:c,key:f,primaryKey:y,modify:p,value:g}=e.isObject(o)?o:{control:o};switch(l&&(p===r?t.update(g||n):p===a&&t.delete()),c){case i:return!1;case u:t.continue(f);break;case h:t.continuePrimaryKey(f,y);break;default:t.continue()}}},!0)}async cursorResult({query:e,direction:t,preSkip:n,startKey:s,startPrimaryKey:c,fn:m,mapper:f},y){const{keyPath:p,defaultGetMapper:g}=this.storeSchema,b=w(f||g,p),S=[];let x=0;return await this.openCursor({query:e,direction:t,preSkip:n,startKey:s,startPrimaryKey:c,fn:async e=>{const{value:t,primaryKey:n}=e,{control:s,value:c,key:f,primaryKey:p,modify:g}=await(m?.(t,n,x,S))||{};switch(y&&(g===r?e.update(c||t):g===a&&e.delete()),(!s||s===o||s===d||s===l)&&S.push(b(c||t,p||n,x)),s){case i:case o:return!1;case d:case u:e.continue(f);break;case l:case h:e.continuePrimaryKey(f,p);break;default:e.continue()}x++}},y),S}#t(e,t){const{target:r}=this,a=r instanceof IDBObjectStore?r:r.objectStore;return t?t(r,a):Object.freeze({nativeStore:a,target:r})}}class D{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(...a)=>{const n={};a=Array.from(new Map(a.map(e=>[e.storeName,e.asStore(!0)])).values());for(const s of a){const{storeName:a}=s,i=e[a];i&&(n[a]=await s[r](i,t))}if(t)return n},!0)}async tx(e,t,r,a){const{idbPro:n,schemas:s}=this,{factory:i}=n.schema,o=await n.openNativeDb();try{const c=o.transaction(this.storeNames,r?"readwrite":"readonly");try{const a=s.map(({storeSchema:t,target:r})=>{let a=c.objectStore(r.store);return r.index&&(a=a.index(r.index)),i[e]({storeSchema:t,target:a},n)});if(r){const e=await t(...a);return c.commit(),e}return await t(...a)}catch(e){throw!1!==a&&c.abort(),e}}finally{o.close()}}}class v extends x{direction;query;writable;parser;endsWithNull;preSkip;startKey;startPrimaryKey;constructor(t,r,a){if(super(t,r),!a)return;const{parser:s}=a;this.direction=a.direction,this.query=a.query,this.writable=!!a.writable,this.endsWithNull=!!a.endsWithNull,this.preSkip=a.preSkip,this.startKey=a.startKey,this.startPrimaryKey=a.startPrimaryKey,s&&(this.parser=e.isFunction(s)?s:n[s])}async*[Symbol.asyncIterator](){const{parser:e,writable:r,endsWithNull:a}=this,{db:n,tx:s,target:o}=await this.tx(r);try{const n=await S(o,this);let c;if(e)for(;c=await t.requestDbResult(n);){const{control:t,value:r}=await e(c);if(t||(yield r),t===i)break;c.continue()}else{let e=!1;const r=()=>{e=!0};for(;!e&&(c=await t.requestDbResult(n));)yield{cursor:c,end:r}}r&&s?.commit(),a&&!c&&(yield null)}finally{n?.close()}}}function k(t,r,a,n){const s=e.isObject(t)?t:{};return e.isFunction(t)?s.fn=t:b(t)&&(s.query=t),e.isFunction(r)?s.fn=r:r&&(s.direction=r),a&&(s.direction=a),n?s.limit=n:s.limit||(s.limit=1e3),s.maxEmptyChecks||(s.maxEmptyChecks=2e4),s}async function P(t,r,a){r.size||(r.size=100),r.nextSkip||(r.nextSkip=0);const{query:n,direction:s,total:i,maxEmptyChecks:o,fn:c}=r;return await t.batchRead(async t=>(i||(r.total=await t.count({query:n,direction:s,maxEmptyChecks:o,fn:c}),r.pages=Math.ceil(r.total/r.size)),r.total<1?{info:e.deepFreeze(r),rows:[]}:c?await async function(e,t,r){t.maxEmptyChecks||(t.maxEmptyChecks=2e4);const{page:a,query:n,direction:s,nextSkip:i}=t,{keyPath:o}=e.storeSchema;return 1===a?await q(e,await S(e.target,{query:n,direction:s}),t,o):r&&i&&a-r.page===1?await q(e,await S(e.target,{query:n,direction:s,preSkip:i}),t,o):await q(e,await S(e.target,{query:n,direction:s}),t,o,!0)}(t,r,a):await async function(t,r){const{keyPath:a}=t.storeSchema,{page:n,query:s,direction:i,size:o,mapper:c}=r,u=(n-1)*o,d=await t.filter({query:s,preSkip:u,direction:i,limit:o,mapper:w(c,a,!0)});return r.nextSkip=u+d.length,{info:e.deepFreeze(r),rows:d}}(t,r)))}async function q({storeSchema:{defaultGetMapper:t}},r,a,n,s){const{page:i,size:o,total:c,maxEmptyChecks:u,fn:d}=a,h=w(a.mapper||t,n,!0),l=[],m=(i-1)*a.size;if(m>=c)return{info:e.deepFreeze(a),rows:[]};let f=0;return await new Promise(async(e,t)=>{let a=0,n=0;const i=async()=>{const{result:t}=r;if(!t)return e();let{value:n,primaryKey:s}=t;if(await d(n,s,f)?(a=0,l.push(h(n,s,f))):a++,l.length>=o||a>=u)return e();f++,t.continue()};r.onerror=()=>t(r.error),r.onsuccess=s?async()=>{const{result:t}=r;if(!t)return e();let{value:s,primaryKey:o}=t;if(await d(s,o,f)?(a=0,n++):a++,n>=m||a>=u)return f=a=0,r.onsuccess=i,void t.continue();t.continue(),f++}:i}),f&&(a.nextSkip+=f+1),{info:e.deepFreeze(a),rows:l}}class O extends x{all(r,a){const n={};return e.isNumber(a)&&(n.limit=a),b(r)?n.query=r:e.isObject(r)&&Object.assign(n,r),this.tx(!1,e=>t.requestDbResult(e.getAll(g(n.query),n.limit||1e3)))}async count(e,r,a){const n=k(e,r,a),{query:s,direction:i,fn:o}=n;if(!o)return await this.tx(!1,e=>t.requestDbResult(e.count(g(s))));const{maxEmptyChecks:c}=n,u=o;let d=0,h=0,l=0;return await this.openCursor({query:s,direction:i,fn:e=>{if(u(e.value,e.primaryKey,l++))d++,h=0;else if(++h>=c)return!1;e.continue()}}),d}get(e){return this.tx(!1,r=>t.requestDbResult(r.get(g(e))))}getMany(t,r){return this.batchRead(async a=>{const n=await e.asyncMap(t,e=>a.get(e));return r?n.filter(e=>e):n})}getRange(e,t){return this.forEach({query:e,direction:t},!0)}async getRangeMany(t,r,a){return(await this.batchRead(a=>e.asyncMap(t,e=>a.getRange(e,r)))).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 m(this.target)?e(this):this.tx(!1,t=>e(this.idbPro.schema.factory.newReader({storeSchema:this.storeSchema,target:t},this.idbPro)))}iterator(t,r){const a={};return e.isString(r)&&(a.direction=r),b(t)?a.query=t:e.isObject(t)&&Object.assign(a,t),new v({storeSchema:this.storeSchema,target:this.target},this.idbPro,{...a,parser:"value"})}async filter(e,t,r,a){const n=k(e,t,r,a),{maxEmptyChecks:s,limit:u,fn:d}=n,{keyPath:h,defaultGetMapper:l}=this.storeSchema,m=w(n.mapper||l,h,!0);if(!d)return await this.forEach({...n,mapper:m,fn:(e,t,r)=>{if(r>=u-1)return{control:o}}},!0);let f=0;return this.forEach({...n,mapper:m,fn:(e,t,r,a)=>d(e,t,r)?(f=0,a.length>=u-1?{control:o}:void 0):++f>=s?{control:i}:{control:c}},!0)}async find(e,t,r){const[a]=await this.filter(e,t,r,1);return a}async page(e,t){const r={...e};return r.page=t||e?.page||1,P(this,r,e)}nextPage(e){return this.page(e,e.page+1)}export(e,t){const r=k(e,t),{keyPath:a,exportMapper:n,name:s,defaultGetMapper:i}=this.storeSchema;if(!a&&Array.isArray(n))throw new Error(`When store [ ${s} ] keyPath does not exist, exportMapper does not support string[].`);return r.direction="next",r.mapper=w(n||i,a,!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,a=this.storeSchema,n={storeSchema:Object.isFrozen(a)?a:void 0,target:e};return t?this.factory.newWriter(n,r):this.factory.newReader(n,r)}}function I(e,t){if(!Array.isArray(e))return{[e]:t};const r={},a=e;for(let e=0;e<a.length;e++)r[a[e]]=t[e];return r}function R(e,t){if(!Array.isArray(e))return t[e];const r=[];for(const a of e){if(!t[a])return;r.push(t[a])}return r}function F(t,r){if(!r||!(r instanceof Object)||Array.isArray(r))return r;const{addedTimeField:a,updatedTimeField:n,updatedCountField:s,softDeletedField:i}=t;return r={...r},a?.name&&!e.isNumber(r[a.name])&&(r[a.name]=Date.now()),n?.name&&!e.isNumber(r[n.name])&&(r[n.name]=Date.now()),i?.name&&!e.isNumber(r[i.name])&&(r[i.name]=0),s?.name&&(r[s.name]=0),r}function M(e,t,r){if(!t||!(t instanceof Object)||Array.isArray(t))return t;const{updatedTimeField:a,updatedCountField:n}=e;return t={...r,...t},a.name&&(t[a.name]=Date.now()),n.name&&(t[n.name]=(t[n.name]||0)+1),t}class E extends O{add(e){return this.changeByPk({record:e,fn:async(e,r,a,n,s)=>{const{storeSchema:i}=this;return a=F(i,a),s?[{...a,...I(s,await t.requestDbResult(e.add(a)))},r]:[a,await t.requestDbResult(e.add(a,r))]}})}addMany(t,r){return this.batchWrite(a=>r?e.asyncMap(t,e=>a.add(e)):e.asyncForEach(t,e=>a.add(e)),!0)}addOrSkip(e){return this.batchWrite(async r=>{const{keyPath:a,defaultGetMapper:n}=r.storeSchema,{key:i,value:o}=a?{key:R(a,e),value:e}:s(e);if(i){const e=await t.requestDbResult(r.nativeStore.get(i));if(e)return w(n,a)?.(e,i)}if(r.target instanceof IDBIndex){const{keyPath:t}=r,a=R(t,o);if(!a)return r.add(e);let n=await r.find(a);if(n)return n}return r.add(e)})}addOrSkipMany(t,r){return this.batchWrite(a=>r?e.asyncMap(t,e=>a.addOrSkip(e)):e.asyncForEach(t,e=>a.addOrSkip(e)),!0)}replace(e){return this.changeByPk({record:e,getOld:!0,fn:async(e,r,a,n,s)=>{const{storeSchema:i}=this,{updatedTimeField:o,updatedCountField:c,addedTimeField:u}=i;return a=n?M(i,a,{[o.name]:n[o.name],[c.name]:n[c.name],[u.name]:n[u.name]}):F(i,a),s?[{...a,...I(s,await t.requestDbResult(e.put(a)))},r]:[a,await t.requestDbResult(e.put(a,r))]}})}replaceMany(t,r){return this.batchWrite(a=>r?e.asyncMap(t,e=>a.replace(e)):e.asyncForEach(t,e=>a.replace(e)),!0)}change(e,r){return this.changeByPk({record:e,getOld:!0,requiredOld:r,requiredPk:r,fn:async(e,r,a,n,s)=>{const{storeSchema:i}=this;if(n)return a=M(i,a,n),s?[{...a,...I(s,await t.requestDbResult(e.put(a)))},r]:[a,await t.requestDbResult(e.put(a,r))]}})}changeMany(t,r){const{returns:a,throwIfMissing:n}=e.isBoolean(r)?{returns:r}:r||{};return this.batchWrite(r=>a?e.asyncMap(t,e=>r.change(e,n)):e.asyncForEach(t,e=>r.change(e,n)),!0)}addOrChange(e){return this.changeByPk({record:e,getOld:!0,fn:async(e,r,a,n,s)=>{const{storeSchema:i}=this;return n?(a=M(i,a,n),s?[{...a,...I(s,await t.requestDbResult(e.put(a)))},r]:[a,await t.requestDbResult(e.put(a,r))]):(a=F(i,a),s?[{...a,...I(s,await t.requestDbResult(e.add(a)))},r]:[a,await t.requestDbResult(e.add(a,r))])}})}addOrChangeMany(t,r){return this.batchWrite(a=>r?e.asyncMap(t,e=>a.addOrChange(e)):e.asyncForEach(t,e=>a.addOrChange(e)),!0)}delete(e,t){return this.changeByPk({pk:e,getOld:t,fn:(e,r,a,n)=>{if(e.delete(r),t)return[n,r]}})}deleteMany(t,r){return this.batchWrite(a=>r?e.asyncMap(t,e=>a.delete(e,!0)):e.asyncForEach(t,e=>a.delete(e)),!0)}deleteRange(t,n){const{returns:s,physical:i,direction:o}=e.isBoolean(n)?{returns:n}:n||{},{name:c}=this.storeSchema.softDeletedField||{};return this.cursor({query:t,direction:o,fn:e=>i||!c?{modify:a}:(e[c]=1,{modify:r})},s)}deleteRangeMany(t,r){const a=e.isBoolean(r)?{returns:r}:r;return this.batchWrite(r=>a?.returns?e.asyncMap(t,e=>r.deleteRange(e,a)):e.asyncForEach(t,e=>r.deleteRange(e,a)),!0)}changeRange(e,t){let{direction:a="next",query:n,newValue:s}="newValue"in e?e:{newValue:e};if(n||(n=R(this.keyPath,s)),!n)throw new Error(`query is required：${JSON.stringify(e)}`);return this.cursor({query:n,direction:a,fn:e=>e instanceof Object?{modify:r,value:{...e,...s}}:{modify:r,value:s}},t)}changeRangeMany(t,r){return this.batchWrite(a=>r?e.asyncMap(t,e=>a.changeRange(e,r)):e.asyncForEach(t,e=>a.changeRange(e,r)),!0)}cursor(t,r){return(t=e.isFunction(t)?{fn:t}:t||{}).fn?r?this.cursorResult(t,!0):this.cursorVoid(t,!0):new v(this,this.idbPro)}batchWrite(e,t){const{target:r}=this;if(m(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:r,fn:a,requiredPk:n,getOld:i,requiredOld:o,saveMapper:c,getMapper:u}){const{storeSchema:d}=this,{keyPath:h,defaultSaveMapper:l,defaultGetMapper:m}=d;return r&&(c||l)&&(r=w(c||l,h)?.(r)),this.batchWrite(async c=>{let d,l=r;if(e)d=g(e);else if(h)d=R(h,r);else{const{key:e,value:t}=s(r);d=e,l=t}if(n&&!d)throw new Error(`key is required: ${JSON.stringify(r)}`);const f=d&&(i||o)?await t.requestDbResult(c.nativeStore.get(d)):void 0;if(o&&!f)throw new Error(`record not found: ${JSON.stringify(r)}`);const y=await a(c.nativeStore,d,l,f,h);if(y)return w(u||m,h)?.(y[0],y[1])})}}class j extends x{get size(){return this.tx(!1,e=>t.requestDbResult(e.count()))}delete(e){return this.tx(!0,async(t,r)=>{r.delete(e)})}batch(e){const{idbPro:t,storeSchema:r,factory:a}=this;return this.tx(!0,async(n,s)=>await e(a.newDbMap({storeSchema:r,target:s},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 v({target:this.target},this.idbPro,{parser:"keyValue"})}async get(e,r){return await this.tx(!1,r=>t.requestDbResult(r.get(e)))||r}getMany(e){return this.tx(!1,async r=>{const a=[];for(const n of e)a.push(await t.requestDbResult(r.get(n)));return a})}async has(e){return!!await this.get(e)}keys(){return new v({storeSchema:this.storeSchema,target:this.target},this.idbPro,{parser:"key"})}set(e,r){return this.tx(!0,async(a,n)=>{await t.requestDbResult(n.put(r,e))})}setMany(e){return this.tx(!0,async(t,r)=>{for(const[t,a]of e)r.put(a,t)})}values(){return new v({storeSchema:this.storeSchema,target:this.target},this.idbPro,{parser:"value"})}}function N(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 B=({stores:e,schema:t})=>{const r=t.storeSchemas;let a="";for(const t of e){const e=r.find(e=>e.name===t.name);if(e){if(!N(t.keyPath,e.keyPath)){a=`store [ ${t.name} ] keyPath not equal,schema.keyPath:${e.keyPath},store.keyPath:${t.keyPath}[]`;break}if(!t.autoIncrement!=!e.autoIncrement){a=`store [ ${t.name} ] autoIncrement not equal`;break}}}return!a||`The existing database is inconsistent with the definition and cannot be corrected： ${a}`},C=async t=>{let r=B(t);return e.isString(r)||(r=K(t)),r},K=({stores:e,schema:t})=>{const r=t.storeSchemas,a=e.map(e=>e.name);let n="";const s=r.map(e=>e.name).filter(e=>!a.includes(e));if(s.length)n=`store [ ${s.join(",")} ] not exist`;else for(const t of e){const e=r.find(e=>e.name===t.name);if(e&&(n=$(t,Array.from(t.indexNames),e.indexSchemas),n))break}return!n||`The existing database Store index is inconsistent with the definition and requires a database version upgrade to be fixed： ${n}`};function $(e,t,r){if(t.length!==r.length)return`store [ ${e.name} ] index count not equal`;for(const a of t){const t=r.find(e=>e.name===a);if(!t)return`store [ ${e.name} ] index [ ${a} ] not exist`;const n=e.index(a);if(!t.unique!=!n.unique)return`store [ ${e.name} ] index [ ${a} ] unique not equal`;if(!t.multiEntry!=!n.multiEntry)return`store [ ${e.name} ] index [ ${a} ] multiEntry not equal`;if(!N(t.keyPath,n.keyPath))return`store [ ${e.name} ] index [ ${a} ] keyPath not equal`}return""}class A{upgradeContext;storeSchema;nativeStore;#a;constructor(e,t,r){this.upgradeContext=e,this.storeSchema=t,this.nativeStore=r}get writer(){return this.#a||(this.#a=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 T=Object.freeze({newDataOperators:(e,t)=>new D(t,e),newDbMap:(e,t)=>new j(e,t),newReader:(e,t)=>new O(e,t),newStoreUpgradeable:(e,t,r)=>new A(r,t,e),newWriter:(e,t)=>new E(e,t)});function V(t,r,a,n){const s=function(t,r,a){if(!1===t)return!1;if(e.isString(t))return{name:t};if(e.isObject(t)){const a=t;return e.isBoolean(a.name)&&(a.name=r),t}if(!0===t||a)return{name:r};return!1}(r,a,n);if(!s)return s;const i=s;if(!1!==i.isIndexed){i.isIndexed||(i.isIndexed=!0);const{name:e}=i,r=t.indexSchemas;r.some(t=>t===e||t.name===e)||r.push(e)}return i}function W(t,r){let a=e.isString(t)?{name:t}:t;return r&&(a={...r,...a}),a.indexSchemas||(a.indexSchemas=[]),function(e){Object.isFrozen(e)||(e.addedTimeField=V(e,e.addedTimeField,"added_at",!0),e.updatedTimeField=V(e,e.updatedTimeField,"updated_at",!0),e.updatedCountField=V(e,e.updatedCountField,"updated_count",!1),e.softDeletedField=V(e,e.softDeletedField,"deleted",!1))}(a),Object.isFrozen(a)||(a.indexSchemas=a.indexSchemas.map(z)),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)}`)}(a),a}function z(t){const r=e.isString(t)?{name:t}:t;return r.keyPath||(r.keyPath=r.name),r}const _=e=>{const{versionDiffValidate:t,versionSameValidate:r,factory:a}=e;return e.storeSchemas||(e.storeSchemas=[]),e.storeTemplate||(e.storeTemplate={...f}),!t&&!1!==t&&(e.versionDiffValidate=B),!r&&!1!==r&&(e.versionSameValidate=C),a?a!==T&&(e.factory={...T,...a}):e.factory=T,e.storeSchemas=e.storeSchemas.map(t=>W(t,e.storeTemplate)),e};function U(e,t){(function(e,t){return e.unique===t.unique&&e.multiEntry===t.multiEntry&&N(t.keyPath,e.keyPath)})(e.index(t.name),t)||(e.deleteIndex(t.name),J(e,t))}function J(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 G(e,t){return e.database.objectStoreNames.contains(t.name)?function(e,t){const{indexSchemas:r}=e,a=t.indexNames,n=r.map(e=>e.name);for(const e of Array.from(a))n.includes(e)||t.deleteIndex(e);for(const e of r)a.contains(e.name)?U(t,e):J(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)J(r,t);return r}(t,e.database)}class Q{database;newVersion;oldVersion;dbSchema;transaction;#n={};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{e.destroyRecords(this.#n)}finally{for(const e of Object.keys(this.#n))delete this.#n[e]}}store(e){if(e in this.#n)return this.#n[e];const{factory:t}=this.dbSchema,{storeSchemas:r}=this.dbSchema,a=r.find(t=>t.name===e),n=G(this,a);return this.#n[e]=t.newStoreUpgradeable(n,a,this)}versionIn({oldMin:e,oldMax:t,newMax:r,newMin:a}){if(void 0===t&&void 0===r&&void 0===e&&void 0===a)throw new Error(`versionIn bounds must not be empty ${JSON.stringify({oldMax:t,newMax:r,oldMin:e,newMin:a})}`);if(t<e)throw new Error(`oldMax (${t}) cannot be less than oldMin (${e})`);if(r<a)throw new Error(`newMax (${r}) cannot be less than newMin (${a})`);const{oldVersion:n,newVersion:s}=this;return!(void 0!==e&&n<e||void 0!==t&&n>t||void 0!==a&&s<a)&&!(void 0!==r&&s>r)}}function L(t,r){let{store:a,index:n}=t;const{storeTemplate:s}=r,{storeSchemas:i=[]}=r,o=e.isString(a)?a:a.name,c=i.findIndex(e=>e===o||e.name===o),u=c>-1&&i[c];let d;d=e.isString(a)?u||o:!u||e.isString(u)||a===u?a:{...u,...a},(n||u?.indexSchemas?.length||a?.indexSchemas?.length)&&(e.isString(d)&&(d={name:d}),d.indexSchemas=function(t,r,a){a&&r.push(a);for(const a of r){const r=e.isString(a)?a:a.name,n=t.findIndex(e=>e===r||e.name===r);if(n>-1){const r=t[n];e.isString(r)?t[n]=a:e.isString(a)||(t[n]=Object.assign(r,a))}else t.push(a)}return t}(u.indexSchemas||[],a.indexSchemas||[],n));const h=W(d,s);c>-1?i[c]=h:i.push(h),r.storeSchemas=i;const l={store:o};return n&&(l.index=e.isString(n)?n:n.name),{target:l}}const X=Object.assign({name:"",addedTimeField:!1,autoIncrement:!1,indexSchemas:[],keyPath:void 0,softDeletedField:!1,updatedCountField:!1,updatedTimeField:!1});class H{static#s;#i;#o;#c={};constructor(t,r){this.#i=t=e.isString(t)?{name:t}:t,Array.isArray(t.storeSchemas)||(t.storeSchemas=[]),e.isObject(t.storeTemplate)||(t.storeTemplate=f),r&&(this.#o=!0)}static get defaultDb(){return this.#s||(this.#s=new H(t.DefaultDbName))}get initialized(){return Object.isFrozen(this.#i)}get schema(){return this.#i}get storeNames(){return Array.from(new Set(this.#i.storeSchemas.map(t=>e.isString(t)?t:t.name)))}get factory(){return this.#i.factory||(this.#i.factory=T)}static releaseDefaultDB(){this.#s=void 0}static async openExistDb(e){const{generateDbSchema:t}=await Promise.resolve().then(function(){return te});return new H(await t(e))}static store(e,t){return H.defaultDb.store(e,t)}static stores(e){return H.defaultDb.stores(e)}static map(e,t){return H.defaultDb.map(e,t)}async openNativeDb(){const r=this.#i=e.deepFreeze(this.initSchema());await this.#u();const{name:a,version:n}=r;return await t.openDb({name:a,version:n,onupgradeneeded:(t,a,n)=>async function(t,r,a,n){const{storeSchemas:s,beforeUpgrade:i,afterUpgrade:o,version:c}=t,{newVersion:u=c,oldVersion:d}=a,{transaction:h}=n,l=new Q({database:r,newVersion:u,oldVersion:d,dbSchema:t,transaction:h});try{const t=[];if(e.isFunction(i))try{await i(l)}catch(e){t.push(e)}for(const e of s.map(e=>e.name))try{l.store(e)}catch(e){t.push(e)}for(const{name:e,defaultData:r}of s)if(r)try{await l.store(e).add({oldMax:0},r)}catch(e){t.push(e)}for(const{name:e,versionData:r}of s)if(r)for(const{version:a,data:n,use:s="addOrChange"}of r)try{await l.store(e)[s](a,n)}catch(e){t.push(e)}for(const{name:e,storeDefined:r}of s)try{await(r?.(l.store(e)))}catch(e){t.push(e)}if(e.isFunction(o))try{await o(l)}catch(e){t.push(e)}if(!t.length)return;throw 1===t.length?t[0]:new AggregateError(t,"Database upgrade error")}finally{e.destroy(l)}}(r,t,a,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(L(r,this.schema),this)}stores(t){const{schema:r}=this,a=t.map(t=>L(e.isString(t)?{store:t}:t,r));return this.factory.newDataOperators(a,this)}initSchema(){if(this.initialized)return this.#i;const{validateSchemaWithDefaults:e=_}=this.#i;return this.#i=e(this.#i)}async traceSchema(t){await e.logJson(this.schema,t)}map(r,a){const n=e.isString(r)?r:e.isString(a)?a:t.DefaultStorageStoreName;Array.isArray(r)&&(a=r);const{storeSchemas:s}=this.schema;return s.find(e=>e.name===n||e===n)||s.push({...X,name:n,defaultData:a}),this.factory.newDbMap({target:{store:n}},this)}export(){return this.stores(this.storeNames).export()}import(e,t,r){return this.stores(this.storeNames).import(e,t,r)}getStoreSchema(t){if(t in this.#c)return this.#c[t];const r=this.schema.storeSchemas.findIndex(e=>e===t||e.name===t);let a=this.schema.storeSchemas[r];return this.initialized?this.#c[t]=a:e.isString(a)&&(this.schema.storeSchemas[r]=a={name:a}),a}async#u(){let r=this.#o;if(void 0===r&&(r=this.#o=await async function(r){const{name:a,version:n}=r,s=await t.findExistDb(a);if(!s)return!0;const{versionDiffValidate:i,versionSameValidate:o}=r,c=await t.openDb(a);try{if(r.version<c.version)return"The existing database version is greater than the current version";const u=void 0===r.version||c.version===r.version?o:i;if(!u)return!0;const d=Array.from(c.objectStoreNames);if(d.length<1)return`The existing database [ ${a} ] is empty`;const h=await t.readTx(c,d),l=await u({schema:r,db:c,stores:h});if(e.isString(l)||n!==s.version)return l}finally{c?.close()}return!0}(this.#i)),!0===r)return!0;if(e.isString(r))throw new Error(r)}}function Y(e,t){const r=Array.from(e.indexNames).map(t=>e.index(t)),a=[],n=[];for(const{name:e,keyPath:t,unique:s,multiEntry:i}of r)Array.isArray(t)?n.push(...t):n.push(t),a.push({name:e,keyPath:t,unique:s,multiEntry:i});const s=new Set(n);return{indexSchemas:a,addedTimeField:Z(t.addedTimeField,s),updatedTimeField:Z(t.updatedTimeField,s),updatedCountField:Z(t.updatedCountField,s),softDeletedField:Z(t.softDeletedField,s)}}function Z(e,t){return!!t.has(e)&&{name:e,isIndexed:!1}}async function ee(r,a){if(!await t.findExistDb(r))throw new Error(`db [ ${r} ] not exist`);let{asString:n,specialFields:s=y,dataExportTarget:i}=a||{};!0===n&&(n=160),isNaN(n)||n<1&&(n=1);let o=await function(e,r){return t.openDb(e,async function(e){const t=Array.from(e.objectStoreNames),a=e.transaction(t,"readonly");try{return{name:e.name,version:e.version,storeSchemas:t.map(e=>function(e,t){const{name:r,keyPath:a,autoIncrement:n}=e;return{name:r,keyPath:a,autoIncrement:n,...Y(e,t)}}(a.objectStore(e),r))}}finally{a.abort()}})}(r,s);return i&&await async function(t,r){const a=await new H(e.copyObject(t),!0).export();for(const e of t.storeSchemas){const n=a[e.name];n?.length&&("defaultData"===r?e.defaultData=n:"versionData"===r&&(e.versionData||(e.versionData=[]),e.versionData.push({version:{oldMax:t.version},data:n})))}return t}(o,i),n?await e.toJson({rootData$:o,spaceEffectiveLength:n}):o}var te=Object.freeze({__proto__:null,generateDbSchema:ee});exports.Break=i,exports.Continue=c,exports.ContinueKey=u,exports.ContinuePrimaryKey=h,exports.DataOperationBase=x,exports.DataOperators=D,exports.DataReader=O,exports.DataWriter=E,exports.DbIterator=v,exports.DbIteratorParsers=n,exports.DbMap=j,exports.Delete=a,exports.Finished=o,exports.IDbPro=H,exports.NextKey=d,exports.NextPrimaryKey=l,exports.Save=r,exports.StoreUpgradeable=A,exports.UpgradeContext=Q,exports.dbMap=function(e,t){return H.defaultDb.map(e,t)},exports.dbStore=function(e,t){return H.defaultDb.store(e,t)},exports.dbStores=function(e){return H.defaultDb.stores(e)},exports.defaultSpecialFields=y,exports.defaultStoreSchemaTemplate=f,exports.generateDbSchema=ee,exports.isIDbQuery=b,exports.isNativeTarget=m,exports.parseDbNoneKeyPathRecord=s,exports.parseIDbQuery=g,exports.releaseDefaultDB=function(){H.releaseDefaultDB()},exports.validateSchemaWithDefaults=_,exports.versionDiffValidate=B,exports.versionSameValidate=C;
+"use strict";
+var gsBase = require("gs-base"), gsIdbBasic = require("gs-idb-basic");
+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"
+}), toNum = (v) => v instanceof Date ? v.getTime() : v;
+function parseIDbQuery(query) {
+  if (gsIdbBasic.isDbQueryOrNull(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 gsIdbBasic.requestDbResult(request)).advance(preSkip), startKey && (startPrimaryKey ? (await gsIdbBasic.requestDbResult(request)).continuePrimaryKey(startKey, startPrimaryKey) : (await gsIdbBasic.requestDbResult(request)).continue(startKey)), request;
+}
+function getMapperFn(mapper, keyPath, useArrayRecord) {
+  return Array.isArray(mapper) ? (v) => gsBase.copyFields({}, v, mapper) : gsBase.isFunction(mapper) ? mapper : keyPath ? (v) => v : useArrayRecord ? (v, k) => [v, k] : (key, value) => ({ key, value });
+}
+class DataOperationBase {
+  idbPro;
+  target;
+  #storeSchema;
+  constructor(schema, db) {
+    this.idbPro = db, this.#storeSchema = schema.storeSchema, this.target = schema.target, isNativeTarget(schema.target) && (this.tx = this.#nativeOperation);
+  }
+  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((i) => i.name === index)?.keyPath : storeSchema.keyPath;
+  }
+  async forEach(arg, returns) {
+    return arg = gsBase.isFunction(arg) ? { fn: arg } : arg, returns ? this.cursorResult(arg, !1) : this.cursorVoid(arg, !1);
+  }
+  async tx(writable, fn, rollbackOnError) {
+    let { target } = this;
+    const { store, index } = target, db = await this.idbPro.openNativeDb();
+    let tx, nativeStore;
+    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 i = 0;
+    return this.openCursor({
+      query,
+      direction,
+      preSkip,
+      startKey,
+      startPrimaryKey,
+      fn: async (cursor) => {
+        const { value: ov, primaryKey: op } = cursor, result = await fn(ov, op, i++), { control, key, primaryKey, modify, value } = gsBase.isObject(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 i = 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, i, results) || {};
+        switch (writable && (modify === Save ? cursor.update(value || ov) : modify === Delete && cursor.delete()), (!control || control === Finished || control === NextKey || control === NextPrimaryKey) && results.push(mapper(value || ov, primaryKey || op, i)), control) {
+          case Break:
+          case Finished:
+            return !1;
+          case NextKey:
+          case ContinueKey:
+            cursor.continue(key);
+            break;
+          case NextPrimaryKey:
+          case ContinuePrimaryKey:
+            cursor.continuePrimaryKey(key, primaryKey);
+            break;
+          default:
+            cursor.continue();
+        }
+        i++;
+      }
+    }, 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((s) => s.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((s) => [s.storeName, s.asStore(!0)])).values());
+      for (const store of stores) {
+        const { storeName } = store, rows = data[storeName];
+        rows && (result[storeName] = await store[use](rows, returns));
+      }
+      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 = gsBase.isFunction(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 gsIdbBasic.requestDbResult(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 gsIdbBasic.requestDbResult(request)); )
+          yield { cursor, end };
+      }
+      writable && tx?.commit(), endsWithNull && !cursor && (yield null);
+    } finally {
+      db?.close();
+    }
+  }
+}
+function parseFilterArg(arg1, arg2, arg3, limit) {
+  const args = gsBase.isObject(arg1) ? arg1 : {};
+  return gsBase.isFunction(arg1) ? args.fn = arg1 : isIDbQuery(arg1) && (args.query = arg1), gsBase.isFunction(arg2) ? args.fn = arg2 : arg2 && (args.direction = arg2), arg3 && (args.direction = arg3), limit ? args.limit = limit : args.limit || (args.limit = 1e3), args.maxEmptyChecks || (args.maxEmptyChecks = 2e4), args;
+}
+async function queryPage(anyReader, info, arg) {
+  info.size || (info.size = 100), info.nextSkip || (info.nextSkip = 0);
+  const { query, direction, total, maxEmptyChecks, fn } = info;
+  return await anyReader.batchRead(async (nativeReader) => (total || (info.total = await nativeReader.count({ query, direction, maxEmptyChecks, fn }), info.pages = Math.ceil(info.total / info.size)), info.total < 1 ? { info: gsBase.deepFreeze(info), rows: [] } : fn ? await queryFnPage(nativeReader, info, arg) : await queryNoneFnPage(nativeReader, info)));
+}
+async function queryNoneFnPage(nativeReader, info) {
+  const { keyPath } = nativeReader.storeSchema, { page, query, direction, size, mapper } = info, preSkip = (page - 1) * size, rows = await nativeReader.filter({
+    query,
+    preSkip,
+    direction,
+    limit: size,
+    mapper: getMapperFn(mapper, keyPath, !0)
+  });
+  return info.nextSkip = preSkip + rows.length, {
+    info: gsBase.deepFreeze(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: gsBase.deepFreeze(info), rows: [] };
+  let i = 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, i) ? (ept = 0, rows.push(mapper(value, primaryKey, i))) : ept++, rows.length >= size || ept >= maxEmptyChecks)
+        return resolve();
+      i++, 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, i) ? (ept = 0, skipped++) : ept++, skipped >= preSkip || ept >= maxEmptyChecks) {
+        i = ept = 0, request.onsuccess = rowFn, cursor.continue();
+        return;
+      }
+      cursor.continue(), i++;
+    } : request.onsuccess = rowFn;
+  }), i && (info.nextSkip += i + 1), {
+    info: gsBase.deepFreeze(info),
+    rows
+  };
+}
+class DataReader extends DataOperationBase {
+  all(query, limit) {
+    const param = {};
+    return gsBase.isNumber(limit) && (param.limit = limit), isIDbQuery(query) ? param.query = query : gsBase.isObject(query) && Object.assign(param, query), this.tx(!1, (store) => gsIdbBasic.requestDbResult(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) => gsIdbBasic.requestDbResult(store.count(parseIDbQuery(query))));
+    const { maxEmptyChecks } = args, findFn = fn;
+    let count = 0, ept = 0, i = 0;
+    return await this.openCursor({
+      query,
+      direction,
+      fn: (cursor) => {
+        if (findFn(cursor.value, cursor.primaryKey, i++))
+          count++, ept = 0;
+        else if (++ept >= maxEmptyChecks)
+          return !1;
+        cursor.continue();
+      }
+    }), count;
+  }
+  get(key) {
+    return this.tx(!1, (store) => gsIdbBasic.requestDbResult(store.get(parseIDbQuery(key))));
+  }
+  getMany(keys, excludeEmpty) {
+    return this.batchRead(async (reader) => {
+      const rows = await gsBase.asyncMap(keys, (k) => reader.get(k));
+      return excludeEmpty ? rows.filter((v) => v) : rows;
+    });
+  }
+  getRange(query, direction) {
+    return this.forEach({ query, direction }, !0);
+  }
+  async getRangeMany(keys, direction, excludeEmpty) {
+    return (await this.batchRead((w) => gsBase.asyncMap(keys, (v) => w.getRange(v, 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 gsBase.isString(direction) && (arg.direction = direction), isIDbQuery(query) ? arg.query = query : gsBase.isObject(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, i) => {
+          if (i >= limit - 1)
+            return { control: Finished };
+        }
+      }, !0);
+    let ept = 0;
+    return this.forEach({
+      ...args,
+      mapper,
+      fn: (value, k, i, results) => {
+        if (fn(value, k, i))
+          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 i = 0; i < arrayKeyPath.length; i++)
+    rv[arrayKeyPath[i]] = value[i];
+  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 && !gsBase.isNumber(value[addedTimeField.name]) && (value[addedTimeField.name] = Date.now()), updatedTimeField?.name && !gsBase.isNumber(value[updatedTimeField.name]) && (value[updatedTimeField.name] = Date.now()), softDeletedField?.name && !gsBase.isNumber(value[softDeletedField.name]) && (value[softDeletedField.name] = 0), updatedCountField?.name && (value[updatedCountField.name] = 0), value;
+}
+function checkUpdateValue(storeSchema, newValue, oldValue) {
+  if (!newValue || !(newValue instanceof Object) || Array.isArray(newValue))
+    return newValue;
+  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 gsIdbBasic.requestDbResult(store.add(newValue))) }, pk] : [newValue, await gsIdbBasic.requestDbResult(store.add(newValue, pk))];
+      }
+    });
+  }
+  addMany(records, returns) {
+    return this.batchWrite((w) => returns ? gsBase.asyncMap(records, (v) => w.add(v)) : gsBase.asyncForEach(records, (v) => w.add(v)), !0);
+  }
+  addOrSkip(record) {
+    return this.batchWrite(async (w) => {
+      const { keyPath: storeKeyPath, defaultGetMapper } = w.storeSchema, { key: pk, value } = storeKeyPath ? {
+        key: getValidKeyValue(storeKeyPath, record),
+        value: record
+      } : parseDbNoneKeyPathRecord(record);
+      if (pk) {
+        const item = await gsIdbBasic.requestDbResult(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 ? gsBase.asyncMap(records, (v) => w.addOrSkip(v)) : gsBase.asyncForEach(records, (v) => w.addOrSkip(v)), !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 gsIdbBasic.requestDbResult(store.put(newValue))) }, pk] : [newValue, await gsIdbBasic.requestDbResult(store.put(newValue, pk))];
+      }
+    });
+  }
+  replaceMany(records, returns) {
+    return this.batchWrite((w) => returns ? gsBase.asyncMap(records, (v) => w.replace(v)) : gsBase.asyncForEach(records, (v) => w.replace(v)), !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 gsIdbBasic.requestDbResult(store.put(newValue))) }, pk] : [newValue, await gsIdbBasic.requestDbResult(store.put(newValue, pk))];
+      }
+    });
+  }
+  changeMany(records, option) {
+    const { returns, throwIfMissing } = gsBase.isBoolean(option) ? { returns: option } : option || {};
+    return this.batchWrite((w) => returns ? gsBase.asyncMap(records, (v) => w.change(v, throwIfMissing)) : gsBase.asyncForEach(records, (v) => w.change(v, 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 gsIdbBasic.requestDbResult(store.put(newValue))) }, pk] : [newValue, await gsIdbBasic.requestDbResult(store.put(newValue, pk))]) : (newValue = checkAddValue(storeSchema, newValue), keyPath ? [{ ...newValue, ...getKeyValueToObject(keyPath, await gsIdbBasic.requestDbResult(store.add(newValue))) }, pk] : [newValue, await gsIdbBasic.requestDbResult(store.add(newValue, pk))]);
+      }
+    });
+  }
+  addOrChangeMany(records, returns) {
+    return this.batchWrite((w) => returns ? gsBase.asyncMap(records, (v) => w.addOrChange(v)) : gsBase.asyncForEach(records, (v) => w.addOrChange(v)), !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 ? gsBase.asyncMap(keys, (v) => w.delete(v, !0)) : gsBase.asyncForEach(keys, (v) => w.delete(v)), !0);
+  }
+  deleteRange(query, returns) {
+    const { returns: hasRtn, physical, direction } = gsBase.isBoolean(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 = gsBase.isBoolean(returns) ? { returns } : returns;
+    return this.batchWrite((w) => option?.returns ? gsBase.asyncMap(keys, (v) => w.deleteRange(v, option)) : gsBase.asyncForEach(keys, (v) => w.deleteRange(v, 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 ? gsBase.asyncMap(args, (v) => w.changeRange(v, returns)) : gsBase.asyncForEach(args, (v) => w.changeRange(v, returns)), !0);
+  }
+  cursor(arg, returns) {
+    return arg = gsBase.isFunction(arg) ? { fn: arg } : arg || {}, arg.fn ? returns ? this.cursorResult(arg, !0) : this.cursorVoid(arg, !0) : new DbIterator(this, this.idbPro);
+  }
+  batchWrite(fn, rollbackOnError) {
+    const { target } = this;
+    if (isNativeTarget(target))
+      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 gsIdbBasic.requestDbResult(w.nativeStore.get(query)) : void 0;
+      if (requiredOld && !oldValue)
+        throw new Error(`record not found: ${JSON.stringify(record)}`);
+      const result = await fn(w.nativeStore, query, newValue, oldValue, keyPath);
+      if (result)
+        return getMapperFn(getMapper || defaultGetMapper, keyPath)?.(result[0], result[1]);
+    });
+  }
+}
+class DbMap extends DataOperationBase {
+  get size() {
+    return this.tx(!1, (store) => gsIdbBasic.requestDbResult(store.count()));
+  }
+  delete(key) {
+    return this.tx(!0, async (t, store) => {
+      store.delete(key);
+    });
+  }
+  batch(fn) {
+    const { idbPro, storeSchema, factory } = this;
+    return this.tx(!0, async (t, 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) => gsIdbBasic.requestDbResult(store.get(key))) || defaultValue;
+  }
+  getMany(keys) {
+    return this.tx(!1, async (store) => {
+      const result = [];
+      for (const k of keys)
+        result.push(await gsIdbBasic.requestDbResult(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 (t, store) => {
+      await gsIdbBasic.requestDbResult(store.put(value, key));
+    });
+  }
+  setMany(values) {
+    return this.tx(!0, async (t, store) => {
+      for (const [k, v] of values)
+        store.put(v, 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 i = 0; i < p1.length; i++)
+      if (p1[i] !== p2[i])
+        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((s) => s.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 gsBase.isString(result) || (result = validateStoreAndIndexes(context)), result;
+}, validateStoreAndIndexes = ({ stores, schema }) => {
+  const storeSchemas = schema.storeSchemas, dbStoreNames = stores.map((s) => s.name);
+  let info = "";
+  const missingStoreNames = storeSchemas.map((s) => s.name).filter((s) => !dbStoreNames.includes(s));
+  if (missingStoreNames.length)
+    info = `store [ ${missingStoreNames.join(",")} ] not exist`;
+  else
+    for (const store of stores) {
+      const ss = storeSchemas.find((s) => s.name === store.name);
+      if (ss && (info = validateIndexes$1(store, Array.from(store.indexNames), ss.indexSchemas), info))
+        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((s) => s.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((i) => i === name || i.name === name) || indexSchemas.push(name);
+  }
+  return schemaField;
+}
+function validateSpecialFieldBase(field, defaultName, useDefault) {
+  if (field === !1)
+    return !1;
+  if (gsBase.isString(field))
+    return { name: field };
+  if (gsBase.isObject(field)) {
+    const r = field;
+    return gsBase.isBoolean(r.name) && (r.name = defaultName), field;
+  } else if (field === !0 || useDefault)
+    return { name: defaultName };
+  return !1;
+}
+function validateStoreSchema(schema, storeTemplate) {
+  let validSchema = gsBase.isString(schema) ? { name: schema } : schema;
+  return storeTemplate && (validSchema = { ...storeTemplate, ...validSchema }), validSchema.indexSchemas || (validSchema.indexSchemas = []), validateSpecialFields(validSchema), Object.isFrozen(validSchema) || (validSchema.indexSchemas = validSchema.indexSchemas.map(indexMapper)), validateDefaultData(validSchema), validSchema;
+}
+function indexMapper(index) {
+  const schema = gsBase.isString(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((s) => validateStoreSchema(s, schema.storeTemplate)), schema;
+};
+async function validateBeforeOpen(schema) {
+  const { name, version } = schema, existDb = await gsIdbBasic.findExistDb(name);
+  if (!existDb)
+    return !0;
+  const { versionDiffValidate: versionDiffValidate2, versionSameValidate: versionSameValidate2 } = schema, db = await gsIdbBasic.openDb(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 gsIdbBasic.readTx(db, storeNames), diffResult = await validate({ schema, db, stores });
+    if (gsBase.isString(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 {
+      gsBase.destroyRecords(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((s) => s.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 (gsBase.isFunction(beforeUpgrade))
+      try {
+        await beforeUpgrade(context);
+      } catch (e2) {
+        errors.push(e2);
+      }
+    for (const storeName of storeSchemas.map((s) => s.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 (gsBase.isFunction(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 {
+    gsBase.destroy(context);
+  }
+}
+function validateDataOperationSchema(schema, dbSchema) {
+  let { store, index } = schema;
+  const { storeTemplate } = dbSchema, { storeSchemas = [] } = dbSchema, storeName = gsBase.isString(store) ? store : store.name, storeIndex = storeSchemas.findIndex((s) => s === storeName || s.name === storeName), existStore = storeIndex > -1 && storeSchemas[storeIndex];
+  let tmp;
+  gsBase.isString(store) ? tmp = existStore || storeName : !existStore || gsBase.isString(existStore) || store === existStore ? tmp = store : tmp = { ...existStore, ...store }, (index || existStore?.indexSchemas?.length || store?.indexSchemas?.length) && (gsBase.isString(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 = gsBase.isString(index) ? index : index.name), {
+    target
+  };
+}
+function mergeIndexes(existIndexes, newIndexes, index) {
+  index && newIndexes.push(index);
+  for (const index2 of newIndexes) {
+    const indexName = gsBase.isString(index2) ? index2 : index2.name, existIndex = existIndexes.findIndex((i) => i === indexName || i.name === indexName);
+    if (existIndex > -1) {
+      const old = existIndexes[existIndex];
+      gsBase.isString(old) ? existIndexes[existIndex] = index2 : gsBase.isString(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 = gsBase.isString(schema) ? { name: schema } : schema, Array.isArray(schema.storeSchemas) || (schema.storeSchemas = []), gsBase.isObject(schema.storeTemplate) || (schema.storeTemplate = defaultStoreSchemaTemplate), skipPreOpenValidation && (this.#beforeUseValid = !0);
+  }
+  /**
+   * 默认实例
+   */
+  static get defaultDb() {
+    return this.#_db || (this.#_db = new IDbPro(gsIdbBasic.DefaultDbName));
+  }
+  get initialized() {
+    return Object.isFrozen(this.#schema);
+  }
+  get schema() {
+    return this.#schema;
+  }
+  get storeNames() {
+    return Array.from(new Set(this.#schema.storeSchemas.map((s) => gsBase.isString(s) ? s : s.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 = gsBase.deepFreeze(this.initSchema());
+    await this.#isBeforeUseValidate();
+    const { name, version } = schema;
+    return await gsIdbBasic.openDb({
+      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(gsBase.isString(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 gsBase.logJson(this.schema, showFn);
+  }
+  map(storeName, defaultData) {
+    const name = gsBase.isString(storeName) ? storeName : gsBase.isString(defaultData) ? defaultData : gsIdbBasic.DefaultStorageStoreName;
+    Array.isArray(storeName) && (defaultData = storeName);
+    const { storeSchemas } = this.schema;
+    return storeSchemas.find((s) => s.name === name || s === name) || storeSchemas.push({ ...mapStoreSchema, name, defaultData }), this.factory.newDbMap({ target: { store: name } }, this);
+  }
+  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((s) => s === name || s.name === name);
+    let storeSchema = this.schema.storeSchemas[index];
+    return this.initialized ? this.#storeSchemaRecord[name] = storeSchema : gsBase.isString(storeSchema) && (this.schema.storeSchemas[index] = storeSchema = { name: storeSchema }), storeSchema;
+  }
+  async #isBeforeUseValidate() {
+    let valid = this.#beforeUseValid;
+    if (valid === void 0 && (valid = this.#beforeUseValid = await validateBeforeOpen(this.#schema)), valid === !0)
+      return !0;
+    if (gsBase.isString(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((n) => store.index(n)), indexSchemas = [], paths = [];
+  for (const { name, keyPath, unique, multiEntry } of indexes)
+    Array.isArray(keyPath) ? paths.push(...keyPath) : paths.push(keyPath), indexSchemas.push({ name, keyPath, unique, multiEntry });
+  const keySet = new Set(paths);
+  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 gsIdbBasic.findExistDb(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 gsBase.toJson({
+    rootData$: dbSchema,
+    spaceEffectiveLength: asString
+  }) : dbSchema;
+}
+async function generateData(dbSchema, dataExportTarget) {
+  const data = await new IDbPro(gsBase.copyObject(dbSchema), !0).export();
+  for (const schema of dbSchema.storeSchemas) {
+    const rows = data[schema.name];
+    rows?.length && (dataExportTarget === "defaultData" ? schema.defaultData = rows : dataExportTarget === "versionData" && (schema.versionData || (schema.versionData = []), schema.versionData.push({
+      version: { oldMax: dbSchema.version },
+      data: rows
+    })));
+  }
+  return dbSchema;
+}
+function generateRoot(db, specialFields) {
+  return gsIdbBasic.openDb(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 });
+exports.Break = Break, exports.Continue = Continue, exports.ContinueKey = ContinueKey, exports.ContinuePrimaryKey = ContinuePrimaryKey, exports.DataOperationBase = DataOperationBase, exports.DataOperators = DataOperators, exports.DataReader = DataReader, exports.DataWriter = DataWriter, exports.DbIterator = DbIterator, exports.DbIteratorParsers = DbIteratorParsers, exports.DbMap = DbMap, exports.Delete = Delete, exports.Finished = Finished, exports.IDbPro = IDbPro, exports.NextKey = NextKey, exports.NextPrimaryKey = NextPrimaryKey, exports.Save = Save, exports.StoreUpgradeable = StoreUpgradeable, exports.UpgradeContext = UpgradeContext, exports.dbMap = dbMap, exports.dbStore = dbStore, exports.dbStores = dbStores, exports.defaultSpecialFields = defaultSpecialFields, exports.defaultStoreSchemaTemplate = defaultStoreSchemaTemplate, exports.generateDbSchema = generateDbSchema, exports.isIDbQuery = isIDbQuery, exports.isNativeTarget = isNativeTarget, exports.parseDbNoneKeyPathRecord = parseDbNoneKeyPathRecord, exports.parseIDbQuery = parseIDbQuery, exports.releaseDefaultDB = releaseDefaultDB, exports.validateSchemaWithDefaults = validateSchemaWithDefaults, exports.versionDiffValidate = versionDiffValidate, exports.versionSameValidate = versionSameValidate;