reg-cli 0.18.0 → 0.18.2

package/report/ui/dist/worker.js

@@ -1 +1,1568 @@
-(()=>{"use strict";var t={"./node_modules/x-img-diff-js/package.json":t=>{t.exports={i8:"0.3.5"}}},e={};function n(s){if(e[s])return e[s].exports;var i=e[s]={exports:{}};return t[s](i,i.exports,n),i.exports}(()=>{function t(t){return Array.isArray?Array.isArray(t):"[object Array]"===o(t)}function e(t){return"string"==typeof t}function s(t){return"number"==typeof t}function i(t){return"object"==typeof t}function r(t){return null!=t}function c(t){return!t.trim().length}function o(t){return null==t?void 0===t?"[object Undefined]":"[object Null]":Object.prototype.toString.call(t)}const a=Object.prototype.hasOwnProperty;class h{constructor(t){this._keys=[],this._keyMap={};let e=0;t.forEach((t=>{let n=l(t);e+=n.weight,this._keys.push(n),this._keyMap[n.id]=n,e+=n.weight})),this._keys.forEach((t=>{t.weight/=e}))}get(t){return this._keyMap[t]}keys(){return this._keys}toJSON(){return JSON.stringify(this._keys)}}function l(n){let s=null,i=null,r=null,c=1;if(e(n)||t(n))r=n,s=u(n),i=d(n);else{if(!a.call(n,"name"))throw new Error("Missing name property in key");const t=n.name;if(r=t,a.call(n,"weight")&&(c=n.weight,c<=0))throw new Error((t=>`Property 'weight' in key '${t}' must be a positive integer`)(t));s=u(t),i=d(t)}return{path:s,id:i,weight:c,src:r}}function u(e){return t(e)?e:e.split(".")}function d(e){return t(e)?e.join("."):e}var g={isCaseSensitive:!1,includeScore:!1,keys:[],shouldSort:!0,sortFn:(t,e)=>t.score===e.score?t.idx<e.idx?-1:1:t.score<e.score?-1:1,includeMatches:!1,findAllMatches:!1,minMatchCharLength:1,location:0,threshold:.6,distance:100,useExtendedSearch:!1,getFn:function(n,c){let a=[],h=!1;const l=(n,c,u)=>{if(r(n))if(c[u]){const d=n[c[u]];if(!r(d))return;if(u===c.length-1&&(e(d)||s(d)||function(t){return!0===t||!1===t||function(t){return i(t)&&null!==t}(t)&&"[object Boolean]"==o(t)}(d)))a.push(function(t){return null==t?"":function(t){if("string"==typeof t)return t;let e=t+"";return"0"==e&&1/t==-1/0?"-0":e}(t)}(d));else if(t(d)){h=!0;for(let t=0,e=d.length;t<e;t+=1)l(d[t],c,u+1)}else c.length&&l(d,c,u+1)}else a.push(n)};return l(n,e(c)?c.split("."):c,0),h?a:a[0]},ignoreLocation:!1,ignoreFieldNorm:!1};const f=/[^ ]+/g;class p{constructor({getFn:t=g.getFn}={}){this.norm=function(t=3){const e=new Map,n=Math.pow(10,t);return{get(t){const s=t.match(f).length;if(e.has(s))return e.get(s);const i=1/Math.sqrt(s),r=parseFloat(Math.round(i*n)/n);return e.set(s,r),r},clear(){e.clear()}}}(3),this.getFn=t,this.isCreated=!1,this.setIndexRecords()}setSources(t=[]){this.docs=t}setIndexRecords(t=[]){this.records=t}setKeys(t=[]){this.keys=t,this._keysMap={},t.forEach(((t,e)=>{this._keysMap[t.id]=e}))}create(){!this.isCreated&&this.docs.length&&(this.isCreated=!0,e(this.docs[0])?this.docs.forEach(((t,e)=>{this._addString(t,e)})):this.docs.forEach(((t,e)=>{this._addObject(t,e)})),this.norm.clear())}add(t){const n=this.size();e(t)?this._addString(t,n):this._addObject(t,n)}removeAt(t){this.records.splice(t,1);for(let e=t,n=this.size();e<n;e+=1)this.records[e].i-=1}getValueForItemAtKeyId(t,e){return t[this._keysMap[e]]}size(){return this.records.length}_addString(t,e){if(!r(t)||c(t))return;let n={v:t,i:e,n:this.norm.get(t)};this.records.push(n)}_addObject(n,s){let i={i:s,$:{}};this.keys.forEach(((s,o)=>{let a=this.getFn(n,s.path);if(r(a))if(t(a)){let n=[];const s=[{nestedArrIndex:-1,value:a}];for(;s.length;){const{nestedArrIndex:i,value:o}=s.pop();if(r(o))if(e(o)&&!c(o)){let t={v:o,i,n:this.norm.get(o)};n.push(t)}else t(o)&&o.forEach(((t,e)=>{s.push({nestedArrIndex:e,value:t})}))}i.$[o]=n}else if(!c(a)){let t={v:a,n:this.norm.get(a)};i.$[o]=t}})),this.records.push(i)}toJSON(){return{keys:this.keys,records:this.records}}}function m(t,e,{getFn:n=g.getFn}={}){const s=new p({getFn:n});return s.setKeys(t.map(l)),s.setSources(e),s.create(),s}function M(t,{errors:e=0,currentLocation:n=0,expectedLocation:s=0,distance:i=g.distance,ignoreLocation:r=g.ignoreLocation}={}){const c=e/t.length;if(r)return c;const o=Math.abs(s-n);return i?c+o/i:o?1:c}const y=32;function x(t){let e={};for(let n=0,s=t.length;n<s;n+=1){const i=t.charAt(n);e[i]=(e[i]||0)|1<<s-n-1}return e}class w{constructor(t,{location:e=g.location,threshold:n=g.threshold,distance:s=g.distance,includeMatches:i=g.includeMatches,findAllMatches:r=g.findAllMatches,minMatchCharLength:c=g.minMatchCharLength,isCaseSensitive:o=g.isCaseSensitive,ignoreLocation:a=g.ignoreLocation}={}){if(this.options={location:e,threshold:n,distance:s,includeMatches:i,findAllMatches:r,minMatchCharLength:c,isCaseSensitive:o,ignoreLocation:a},this.pattern=o?t:t.toLowerCase(),this.chunks=[],!this.pattern.length)return;const h=(t,e)=>{this.chunks.push({pattern:t,alphabet:x(t),startIndex:e})},l=this.pattern.length;if(l>y){let t=0;const e=l%y,n=l-e;for(;t<n;)h(this.pattern.substr(t,y),t),t+=y;if(e){const t=l-y;h(this.pattern.substr(t),t)}}else h(this.pattern,0)}searchIn(t){const{isCaseSensitive:e,includeMatches:n}=this.options;if(e||(t=t.toLowerCase()),this.pattern===t){let e={isMatch:!0,score:0};return n&&(e.indices=[[0,t.length-1]]),e}const{location:s,distance:i,threshold:r,findAllMatches:c,minMatchCharLength:o,ignoreLocation:a}=this.options;let h=[],l=0,u=!1;this.chunks.forEach((({pattern:e,alphabet:d,startIndex:f})=>{const{isMatch:p,score:m,indices:x}=function(t,e,n,{location:s=g.location,distance:i=g.distance,threshold:r=g.threshold,findAllMatches:c=g.findAllMatches,minMatchCharLength:o=g.minMatchCharLength,includeMatches:a=g.includeMatches,ignoreLocation:h=g.ignoreLocation}={}){if(e.length>y)throw new Error("Pattern length exceeds max of 32.");const l=e.length,u=t.length,d=Math.max(0,Math.min(s,u));let f=r,p=d;const m=o>1||a,x=m?Array(u):[];let w;for(;(w=t.indexOf(e,p))>-1;){let t=M(e,{currentLocation:w,expectedLocation:d,distance:i,ignoreLocation:h});if(f=Math.min(t,f),p=w+l,m){let t=0;for(;t<l;)x[w+t]=1,t+=1}}p=-1;let _=[],L=1,S=l+u;const v=1<<l-1;for(let s=0;s<l;s+=1){let r=0,o=S;for(;r<o;)M(e,{errors:s,currentLocation:d+o,expectedLocation:d,distance:i,ignoreLocation:h})<=f?r=o:S=o,o=Math.floor((S-r)/2+r);S=o;let a=Math.max(1,d-o+1),g=c?u:Math.min(d+o,u)+l,y=Array(g+2);y[g+1]=(1<<s)-1;for(let r=g;r>=a;r-=1){let c=r-1,o=n[t.charAt(c)];if(m&&(x[c]=+!!o),y[r]=(y[r+1]<<1|1)&o,s&&(y[r]|=(_[r+1]|_[r])<<1|1|_[r+1]),y[r]&v&&(L=M(e,{errors:s,currentLocation:c,expectedLocation:d,distance:i,ignoreLocation:h}),L<=f)){if(f=L,p=c,p<=d)break;a=Math.max(1,2*d-p)}}if(M(e,{errors:s+1,currentLocation:d,expectedLocation:d,distance:i,ignoreLocation:h})>f)break;_=y}const I={isMatch:p>=0,score:Math.max(.001,L)};if(m){const t=function(t=[],e=g.minMatchCharLength){let n=[],s=-1,i=-1,r=0;for(let c=t.length;r<c;r+=1){let c=t[r];c&&-1===s?s=r:c||-1===s||(i=r-1,i-s+1>=e&&n.push([s,i]),s=-1)}return t[r-1]&&r-s>=e&&n.push([s,r-1]),n}(x,o);t.length?a&&(I.indices=t):I.isMatch=!1}return I}(t,e,d,{location:s+f,distance:i,threshold:r,findAllMatches:c,minMatchCharLength:o,includeMatches:n,ignoreLocation:a});p&&(u=!0),l+=m,p&&x&&(h=[...h,...x])}));let d={isMatch:u,score:u?l/this.chunks.length:1};return u&&n&&(d.indices=h),d}}class _{constructor(t){this.pattern=t}static isMultiMatch(t){return L(t,this.multiRegex)}static isSingleMatch(t){return L(t,this.singleRegex)}search(){}}function L(t,e){const n=t.match(e);return n?n[1]:null}class S extends _{constructor(t,{location:e=g.location,threshold:n=g.threshold,distance:s=g.distance,includeMatches:i=g.includeMatches,findAllMatches:r=g.findAllMatches,minMatchCharLength:c=g.minMatchCharLength,isCaseSensitive:o=g.isCaseSensitive,ignoreLocation:a=g.ignoreLocation}={}){super(t),this._bitapSearch=new w(t,{location:e,threshold:n,distance:s,includeMatches:i,findAllMatches:r,minMatchCharLength:c,isCaseSensitive:o,ignoreLocation:a})}static get type(){return"fuzzy"}static get multiRegex(){return/^"(.*)"$/}static get singleRegex(){return/^(.*)$/}search(t){return this._bitapSearch.searchIn(t)}}class v extends _{constructor(t){super(t)}static get type(){return"include"}static get multiRegex(){return/^'"(.*)"$/}static get singleRegex(){return/^'(.*)$/}search(t){let e,n=0;const s=[],i=this.pattern.length;for(;(e=t.indexOf(this.pattern,n))>-1;)n=e+i,s.push([e,n-1]);const r=!!s.length;return{isMatch:r,score:r?0:1,indices:s}}}const I=[class extends _{constructor(t){super(t)}static get type(){return"exact"}static get multiRegex(){return/^="(.*)"$/}static get singleRegex(){return/^=(.*)$/}search(t){const e=t===this.pattern;return{isMatch:e,score:e?0:1,indices:[0,this.pattern.length-1]}}},v,class extends _{constructor(t){super(t)}static get type(){return"prefix-exact"}static get multiRegex(){return/^\^"(.*)"$/}static get singleRegex(){return/^\^(.*)$/}search(t){const e=t.startsWith(this.pattern);return{isMatch:e,score:e?0:1,indices:[0,this.pattern.length-1]}}},class extends _{constructor(t){super(t)}static get type(){return"inverse-prefix-exact"}static get multiRegex(){return/^!\^"(.*)"$/}static get singleRegex(){return/^!\^(.*)$/}search(t){const e=!t.startsWith(this.pattern);return{isMatch:e,score:e?0:1,indices:[0,t.length-1]}}},class extends _{constructor(t){super(t)}static get type(){return"inverse-suffix-exact"}static get multiRegex(){return/^!"(.*)"\$$/}static get singleRegex(){return/^!(.*)\$$/}search(t){const e=!t.endsWith(this.pattern);return{isMatch:e,score:e?0:1,indices:[0,t.length-1]}}},class extends _{constructor(t){super(t)}static get type(){return"suffix-exact"}static get multiRegex(){return/^"(.*)"\$$/}static get singleRegex(){return/^(.*)\$$/}search(t){const e=t.endsWith(this.pattern);return{isMatch:e,score:e?0:1,indices:[t.length-this.pattern.length,t.length-1]}}},class extends _{constructor(t){super(t)}static get type(){return"inverse-exact"}static get multiRegex(){return/^!"(.*)"$/}static get singleRegex(){return/^!(.*)$/}search(t){const e=-1===t.indexOf(this.pattern);return{isMatch:e,score:e?0:1,indices:[0,t.length-1]}}},S],k=I.length,C=/ +(?=([^\"]*\"[^\"]*\")*[^\"]*$)/,E=new Set([S.type,v.type]);const b=[];function A(t,e){for(let n=0,s=b.length;n<s;n+=1){let s=b[n];if(s.condition(t,e))return new s(t,e)}return new w(t,e)}const R="$and",$=t=>!(!t.$and&&!t.$or),F=t=>({[R]:Object.keys(t).map((e=>({[e]:t[e]})))});function j(n,s,{auto:r=!0}={}){const c=n=>{let o=Object.keys(n);const a=(t=>!!t.$path)(n);if(!a&&o.length>1&&!$(n))return c(F(n));if((e=>!t(e)&&i(e)&&!$(e))(n)){const t=a?n.$path:o[0],i=a?n.$val:n[t];if(!e(i))throw new Error((t=>`Invalid value for key ${t}`)(t));const c={keyId:d(t),pattern:i};return r&&(c.searcher=A(i,s)),c}let h={children:[],operator:o[0]};return o.forEach((e=>{const s=n[e];t(s)&&s.forEach((t=>{h.children.push(c(t))}))})),h};return $(n)||(n=F(n)),c(n)}function O(t,e){const n=t.matches;e.matches=[],r(n)&&n.forEach((t=>{if(!r(t.indices)||!t.indices.length)return;const{indices:n,value:s}=t;let i={indices:n,value:s};t.key&&(i.key=t.key.src),t.idx>-1&&(i.refIndex=t.idx),e.matches.push(i)}))}function T(t,e){e.score=t.score}class U{constructor(t,e={},n){this.options={...g,...e},this.options.useExtendedSearch,this._keyStore=new h(this.options.keys),this.setCollection(t,n)}setCollection(t,e){if(this._docs=t,e&&!(e instanceof p))throw new Error("Incorrect 'index' type");this._myIndex=e||m(this.options.keys,this._docs,{getFn:this.options.getFn})}add(t){r(t)&&(this._docs.push(t),this._myIndex.add(t))}remove(t=(()=>!1)){const e=[];for(let n=0,s=this._docs.length;n<s;n+=1){const i=this._docs[n];t(i,n)&&(this.removeAt(n),n-=1,s-=1,e.push(i))}return e}removeAt(t){this._docs.splice(t,1),this._myIndex.removeAt(t)}getIndex(){return this._myIndex}search(t,{limit:n=-1}={}){const{includeMatches:i,includeScore:r,shouldSort:c,sortFn:o,ignoreFieldNorm:a}=this.options;let h=e(t)?e(this._docs[0])?this._searchStringList(t):this._searchObjectList(t):this._searchLogical(t);return function(t,{ignoreFieldNorm:e=g.ignoreFieldNorm}){t.forEach((t=>{let n=1;t.matches.forEach((({key:t,norm:s,score:i})=>{const r=t?t.weight:null;n*=Math.pow(0===i&&r?Number.EPSILON:i,(r||1)*(e?1:s))})),t.score=n}))}(h,{ignoreFieldNorm:a}),c&&h.sort(o),s(n)&&n>-1&&(h=h.slice(0,n)),function(t,e,{includeMatches:n=g.includeMatches,includeScore:s=g.includeScore}={}){const i=[];return n&&i.push(O),s&&i.push(T),t.map((t=>{const{idx:n}=t,s={item:e[n],refIndex:n};return i.length&&i.forEach((e=>{e(t,s)})),s}))}(h,this._docs,{includeMatches:i,includeScore:r})}_searchStringList(t){const e=A(t,this.options),{records:n}=this._myIndex,s=[];return n.forEach((({v:t,i:n,n:i})=>{if(!r(t))return;const{isMatch:c,score:o,indices:a}=e.searchIn(t);c&&s.push({item:t,idx:n,matches:[{score:o,value:t,norm:i,indices:a}]})})),s}_searchLogical(t){const e=j(t,this.options),n=(t,e,s)=>{if(!t.children){const{keyId:n,searcher:i}=t,r=this._findMatches({key:this._keyStore.get(n),value:this._myIndex.getValueForItemAtKeyId(e,n),searcher:i});return r&&r.length?[{idx:s,item:e,matches:r}]:[]}switch(t.operator){case R:{const i=[];for(let r=0,c=t.children.length;r<c;r+=1){const c=t.children[r],o=n(c,e,s);if(!o.length)return[];i.push(...o)}return i}case"$or":{const i=[];for(let r=0,c=t.children.length;r<c;r+=1){const c=t.children[r],o=n(c,e,s);if(o.length){i.push(...o);break}}return i}}},s=this._myIndex.records,i={},c=[];return s.forEach((({$:t,i:s})=>{if(r(t)){let r=n(e,t,s);r.length&&(i[s]||(i[s]={idx:s,item:t,matches:[]},c.push(i[s])),r.forEach((({matches:t})=>{i[s].matches.push(...t)})))}})),c}_searchObjectList(t){const e=A(t,this.options),{keys:n,records:s}=this._myIndex,i=[];return s.forEach((({$:t,i:s})=>{if(!r(t))return;let c=[];n.forEach(((n,s)=>{c.push(...this._findMatches({key:n,value:t[s],searcher:e}))})),c.length&&i.push({idx:s,item:t,matches:c})})),i}_findMatches({key:e,value:n,searcher:s}){if(!r(n))return[];let i=[];if(t(n))n.forEach((({v:t,i:n,n:c})=>{if(!r(t))return;const{isMatch:o,score:a,indices:h}=s.searchIn(t);o&&i.push({score:a,key:e,value:t,idx:n,norm:c,indices:h})}));else{const{v:t,n:r}=n,{isMatch:c,score:o,indices:a}=s.searchIn(t);c&&i.push({score:o,key:e,value:t,norm:r,indices:a})}return i}}U.version="6.4.6",U.createIndex=m,U.parseIndex=function(t,{getFn:e=g.getFn}={}){const{keys:n,records:s}=t,i=new p({getFn:e});return i.setKeys(n),i.setIndexRecords(s),i},U.config=g,U.parseQuery=j,function(...t){b.push(...t)}(class{constructor(t,{isCaseSensitive:e=g.isCaseSensitive,includeMatches:n=g.includeMatches,minMatchCharLength:s=g.minMatchCharLength,ignoreLocation:i=g.ignoreLocation,findAllMatches:r=g.findAllMatches,location:c=g.location,threshold:o=g.threshold,distance:a=g.distance}={}){this.query=null,this.options={isCaseSensitive:e,includeMatches:n,minMatchCharLength:s,findAllMatches:r,ignoreLocation:i,location:c,threshold:o,distance:a},this.pattern=e?t:t.toLowerCase(),this.query=function(t,e={}){return t.split("|").map((t=>{let n=t.trim().split(C).filter((t=>t&&!!t.trim())),s=[];for(let t=0,i=n.length;t<i;t+=1){const i=n[t];let r=!1,c=-1;for(;!r&&++c<k;){const t=I[c];let n=t.isMultiMatch(i);n&&(s.push(new t(n,e)),r=!0)}if(!r)for(c=-1;++c<k;){const t=I[c];let n=t.isSingleMatch(i);if(n){s.push(new t(n,e));break}}}return s}))}(this.pattern,this.options)}static condition(t,e){return e.useExtendedSearch}searchIn(t){const e=this.query;if(!e)return{isMatch:!1,score:1};const{includeMatches:n,isCaseSensitive:s}=this.options;t=s?t:t.toLowerCase();let i=0,r=[],c=0;for(let s=0,o=e.length;s<o;s+=1){const o=e[s];r.length=0,i=0;for(let e=0,s=o.length;e<s;e+=1){const s=o[e],{isMatch:a,indices:h,score:l}=s.search(t);if(!a){c=0,i=0,r.length=0;break}if(i+=1,c+=l,n){const t=s.constructor.type;E.has(t)?r=[...r,...h]:r.push(h)}}if(i){let t={isMatch:!0,score:c/i};return n&&(t.indices=r),t}}return{isMatch:!1,score:1}}});const N=U;function q(t,e,n){return e in t?Object.defineProperty(t,e,{value:n,enumerable:!0,configurable:!0,writable:!0}):t[e]=n,t}let P;!function(t){t.INIT_CALC="init",t.REQUEST_CALC="req_calc",t.RESULT_CALC="res_calc",t.REQUEST_FILTER="req_filter",t.RESULT_FILTER="res_filter"}(P||(P={}));const W=n("./node_modules/x-img-diff-js/package.json").i8,z=self;let K=!1,Q=null;const V=({payload:{raw:t,img1:e,img2:n,actualSrc:s,expectedSrc:i,seq:r}})=>{const c=z.Module.detectDiff(z.Module,e,n,{});z.postMessage({type:P.RESULT_CALC,payload:{seq:r,raw:t,actualSrc:s,expectedSrc:i,result:{...c,images:[{width:e.width,height:e.height},{width:n.width,height:n.height}]}}})};z.Module=new class{constructor({init:t,version:e,wasmUrl:n}){q(this,"_init",void 0),q(this,"_version",void 0),q(this,"_wasmUrl",void 0),this._init=t,this._version=e,this._wasmUrl=n}locateFile(t){return self.location.pathname.replace(/\[^\/]*$/,"/")+t}instantiateWasm(t,e){return function(t,e,n){const s="wasm-cache";async function i(){const t=await fetch(e),s=await t.arrayBuffer();return await WebAssembly.instantiate(s,n)}return new Promise(((e,n)=>{const i=indexedDB.open("wasm-cache",t);i.onerror=n.bind(null,"Error opening wasm cache database"),i.onsuccess=()=>{e(i.result)},i.onupgradeneeded=t=>{const e=i.result;e.objectStoreNames.contains(s)&&(console.log("Clearing out version ".concat(t.oldVersion," wasm cache")),e.deleteObjectStore(s)),console.log("Creating version ".concat(t.newVersion," wasm cache")),e.createObjectStore(s)}})).then((t=>function(t){return new Promise(((n,i)=>{const r=t.transaction([s]).objectStore(s).get(e);r.onerror=i.bind(null,"Error getting wasm module ".concat(e)),r.onsuccess=()=>{r.result?n(r.result):i("Module ".concat(e," was not found in wasm cache"))}}))}(t).then((t=>(console.log("Found ".concat(e," in wasm cache")),WebAssembly.instantiate(t,n))),(n=>(console.log(n),i().then((n=>(setTimeout((()=>function(t,n){const i=t.transaction([s],"readwrite").objectStore(s);try{const t=i.put(n,e);t.onerror=t=>{console.log("Failed to store in wasm cache: ".concat(t))},t.onsuccess=()=>{console.log("Successfully stored ".concat(e," in wasm cache"))}}catch(t){console.warn("An error was thrown... in storing wasm cache..."),console.warn(t)}}(t,n.module)),0),n.instance))))))),(t=>(console.log(t),i().then((t=>t.instance)))))}(this._version,this._wasmUrl,t).then((t=>e(t))),{}}onInit(t){this._init=t}onRuntimeInitialized(){if(this._init)return this._init(this)}}({version:function(t){const[,e,n,s]=t.match(/^(\d*)\.(\d*)\.(\d*)/);return 1e4*+e+100*+n+ +s}(W),wasmUrl:z.wasmUrl,init:()=>{K=!0,null!=Q&&V(Q),z.postMessage({type:P.INIT_CALC})}}),z.addEventListener("message",(({data:t})=>{switch(console.log("Received: ",t),t.type){case P.REQUEST_CALC:K?V(t):Q=t;break;case P.REQUEST_FILTER:(({payload:{input:t,newItems:e,passedItems:n,failedItems:s,deletedItems:i}})=>{if(!t)return z.postMessage({type:P.RESULT_FILTER,payload:{newItems:e,passedItems:n,failedItems:s,deletedItems:i}});const r=e=>new N(e,{isCaseSensitive:!1,keys:["name"],threshold:.3}).search(t).map((({item:t})=>t));z.postMessage({type:P.RESULT_FILTER,payload:{newItems:r(e),passedItems:r(n),failedItems:r(s),deletedItems:r(i)}})})(t)}}))})()})();
+(function() {
+  "use strict";
+  function isArray(value) {
+    return !Array.isArray ? getTag(value) === "[object Array]" : Array.isArray(value);
+  }
+  const INFINITY = 1 / 0;
+  function baseToString(value) {
+    if (typeof value == "string") {
+      return value;
+    }
+    let result = value + "";
+    return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+  }
+  function toString(value) {
+    return value == null ? "" : baseToString(value);
+  }
+  function isString(value) {
+    return typeof value === "string";
+  }
+  function isNumber(value) {
+    return typeof value === "number";
+  }
+  function isBoolean(value) {
+    return value === true || value === false || isObjectLike(value) && getTag(value) == "[object Boolean]";
+  }
+  function isObject(value) {
+    return typeof value === "object";
+  }
+  function isObjectLike(value) {
+    return isObject(value) && value !== null;
+  }
+  function isDefined(value) {
+    return value !== void 0 && value !== null;
+  }
+  function isBlank(value) {
+    return !value.trim().length;
+  }
+  function getTag(value) {
+    return value == null ? value === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(value);
+  }
+  const EXTENDED_SEARCH_UNAVAILABLE = "Extended search is not available";
+  const INCORRECT_INDEX_TYPE = "Incorrect 'index' type";
+  const LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = (key) => `Invalid value for key ${key}`;
+  const PATTERN_LENGTH_TOO_LARGE = (max) => `Pattern length exceeds max of ${max}.`;
+  const MISSING_KEY_PROPERTY = (name2) => `Missing ${name2} property in key`;
+  const INVALID_KEY_WEIGHT_VALUE = (key) => `Property 'weight' in key '${key}' must be a positive integer`;
+  const hasOwn = Object.prototype.hasOwnProperty;
+  class KeyStore {
+    constructor(keys) {
+      this._keys = [];
+      this._keyMap = {};
+      let totalWeight = 0;
+      keys.forEach((key) => {
+        let obj = createKey(key);
+        this._keys.push(obj);
+        this._keyMap[obj.id] = obj;
+        totalWeight += obj.weight;
+      });
+      this._keys.forEach((key) => {
+        key.weight /= totalWeight;
+      });
+    }
+    get(keyId) {
+      return this._keyMap[keyId];
+    }
+    keys() {
+      return this._keys;
+    }
+    toJSON() {
+      return JSON.stringify(this._keys);
+    }
+  }
+  function createKey(key) {
+    let path = null;
+    let id = null;
+    let src = null;
+    let weight = 1;
+    let getFn = null;
+    if (isString(key) || isArray(key)) {
+      src = key;
+      path = createKeyPath(key);
+      id = createKeyId(key);
+    } else {
+      if (!hasOwn.call(key, "name")) {
+        throw new Error(MISSING_KEY_PROPERTY("name"));
+      }
+      const name2 = key.name;
+      src = name2;
+      if (hasOwn.call(key, "weight")) {
+        weight = key.weight;
+        if (weight <= 0) {
+          throw new Error(INVALID_KEY_WEIGHT_VALUE(name2));
+        }
+      }
+      path = createKeyPath(name2);
+      id = createKeyId(name2);
+      getFn = key.getFn;
+    }
+    return { path, id, weight, src, getFn };
+  }
+  function createKeyPath(key) {
+    return isArray(key) ? key : key.split(".");
+  }
+  function createKeyId(key) {
+    return isArray(key) ? key.join(".") : key;
+  }
+  function get(obj, path) {
+    let list = [];
+    let arr = false;
+    const deepGet = (obj2, path2, index) => {
+      if (!isDefined(obj2)) {
+        return;
+      }
+      if (!path2[index]) {
+        list.push(obj2);
+      } else {
+        let key = path2[index];
+        const value = obj2[key];
+        if (!isDefined(value)) {
+          return;
+        }
+        if (index === path2.length - 1 && (isString(value) || isNumber(value) || isBoolean(value))) {
+          list.push(toString(value));
+        } else if (isArray(value)) {
+          arr = true;
+          for (let i = 0, len = value.length; i < len; i += 1) {
+            deepGet(value[i], path2, index + 1);
+          }
+        } else if (path2.length) {
+          deepGet(value, path2, index + 1);
+        }
+      }
+    };
+    deepGet(obj, isString(path) ? path.split(".") : path, 0);
+    return arr ? list : list[0];
+  }
+  const MatchOptions = {
+    // Whether the matches should be included in the result set. When `true`, each record in the result
+    // set will include the indices of the matched characters.
+    // These can consequently be used for highlighting purposes.
+    includeMatches: false,
+    // When `true`, the matching function will continue to the end of a search pattern even if
+    // a perfect match has already been located in the string.
+    findAllMatches: false,
+    // Minimum number of characters that must be matched before a result is considered a match
+    minMatchCharLength: 1
+  };
+  const BasicOptions = {
+    // When `true`, the algorithm continues searching to the end of the input even if a perfect
+    // match is found before the end of the same input.
+    isCaseSensitive: false,
+    // When true, the matching function will continue to the end of a search pattern even if
+    includeScore: false,
+    // List of properties that will be searched. This also supports nested properties.
+    keys: [],
+    // Whether to sort the result list, by score
+    shouldSort: true,
+    // Default sort function: sort by ascending score, ascending index
+    sortFn: (a, b) => a.score === b.score ? a.idx < b.idx ? -1 : 1 : a.score < b.score ? -1 : 1
+  };
+  const FuzzyOptions = {
+    // Approximately where in the text is the pattern expected to be found?
+    location: 0,
+    // At what point does the match algorithm give up. A threshold of '0.0' requires a perfect match
+    // (of both letters and location), a threshold of '1.0' would match anything.
+    threshold: 0.6,
+    // Determines how close the match must be to the fuzzy location (specified above).
+    // An exact letter match which is 'distance' characters away from the fuzzy location
+    // would score as a complete mismatch. A distance of '0' requires the match be at
+    // the exact location specified, a threshold of '1000' would require a perfect match
+    // to be within 800 characters of the fuzzy location to be found using a 0.8 threshold.
+    distance: 100
+  };
+  const AdvancedOptions = {
+    // When `true`, it enables the use of unix-like search commands
+    useExtendedSearch: false,
+    // The get function to use when fetching an object's properties.
+    // The default will search nested paths *ie foo.bar.baz*
+    getFn: get,
+    // When `true`, search will ignore `location` and `distance`, so it won't matter
+    // where in the string the pattern appears.
+    // More info: https://fusejs.io/concepts/scoring-theory.html#fuzziness-score
+    ignoreLocation: false,
+    // When `true`, the calculation for the relevance score (used for sorting) will
+    // ignore the field-length norm.
+    // More info: https://fusejs.io/concepts/scoring-theory.html#field-length-norm
+    ignoreFieldNorm: false,
+    // The weight to determine how much field length norm effects scoring.
+    fieldNormWeight: 1
+  };
+  var Config = {
+    ...BasicOptions,
+    ...MatchOptions,
+    ...FuzzyOptions,
+    ...AdvancedOptions
+  };
+  const SPACE = /[^ ]+/g;
+  function norm(weight = 1, mantissa = 3) {
+    const cache = /* @__PURE__ */ new Map();
+    const m = Math.pow(10, mantissa);
+    return {
+      get(value) {
+        const numTokens = value.match(SPACE).length;
+        if (cache.has(numTokens)) {
+          return cache.get(numTokens);
+        }
+        const norm2 = 1 / Math.pow(numTokens, 0.5 * weight);
+        const n = parseFloat(Math.round(norm2 * m) / m);
+        cache.set(numTokens, n);
+        return n;
+      },
+      clear() {
+        cache.clear();
+      }
+    };
+  }
+  class FuseIndex {
+    constructor({
+      getFn = Config.getFn,
+      fieldNormWeight = Config.fieldNormWeight
+    } = {}) {
+      this.norm = norm(fieldNormWeight, 3);
+      this.getFn = getFn;
+      this.isCreated = false;
+      this.setIndexRecords();
+    }
+    setSources(docs = []) {
+      this.docs = docs;
+    }
+    setIndexRecords(records = []) {
+      this.records = records;
+    }
+    setKeys(keys = []) {
+      this.keys = keys;
+      this._keysMap = {};
+      keys.forEach((key, idx) => {
+        this._keysMap[key.id] = idx;
+      });
+    }
+    create() {
+      if (this.isCreated || !this.docs.length) {
+        return;
+      }
+      this.isCreated = true;
+      if (isString(this.docs[0])) {
+        this.docs.forEach((doc, docIndex) => {
+          this._addString(doc, docIndex);
+        });
+      } else {
+        this.docs.forEach((doc, docIndex) => {
+          this._addObject(doc, docIndex);
+        });
+      }
+      this.norm.clear();
+    }
+    // Adds a doc to the end of the index
+    add(doc) {
+      const idx = this.size();
+      if (isString(doc)) {
+        this._addString(doc, idx);
+      } else {
+        this._addObject(doc, idx);
+      }
+    }
+    // Removes the doc at the specified index of the index
+    removeAt(idx) {
+      this.records.splice(idx, 1);
+      for (let i = idx, len = this.size(); i < len; i += 1) {
+        this.records[i].i -= 1;
+      }
+    }
+    getValueForItemAtKeyId(item, keyId) {
+      return item[this._keysMap[keyId]];
+    }
+    size() {
+      return this.records.length;
+    }
+    _addString(doc, docIndex) {
+      if (!isDefined(doc) || isBlank(doc)) {
+        return;
+      }
+      let record = {
+        v: doc,
+        i: docIndex,
+        n: this.norm.get(doc)
+      };
+      this.records.push(record);
+    }
+    _addObject(doc, docIndex) {
+      let record = { i: docIndex, $: {} };
+      this.keys.forEach((key, keyIndex) => {
+        let value = key.getFn ? key.getFn(doc) : this.getFn(doc, key.path);
+        if (!isDefined(value)) {
+          return;
+        }
+        if (isArray(value)) {
+          let subRecords = [];
+          const stack = [{ nestedArrIndex: -1, value }];
+          while (stack.length) {
+            const { nestedArrIndex, value: value2 } = stack.pop();
+            if (!isDefined(value2)) {
+              continue;
+            }
+            if (isString(value2) && !isBlank(value2)) {
+              let subRecord = {
+                v: value2,
+                i: nestedArrIndex,
+                n: this.norm.get(value2)
+              };
+              subRecords.push(subRecord);
+            } else if (isArray(value2)) {
+              value2.forEach((item, k) => {
+                stack.push({
+                  nestedArrIndex: k,
+                  value: item
+                });
+              });
+            } else
+              ;
+          }
+          record.$[keyIndex] = subRecords;
+        } else if (isString(value) && !isBlank(value)) {
+          let subRecord = {
+            v: value,
+            n: this.norm.get(value)
+          };
+          record.$[keyIndex] = subRecord;
+        }
+      });
+      this.records.push(record);
+    }
+    toJSON() {
+      return {
+        keys: this.keys,
+        records: this.records
+      };
+    }
+  }
+  function createIndex(keys, docs, { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) {
+    const myIndex = new FuseIndex({ getFn, fieldNormWeight });
+    myIndex.setKeys(keys.map(createKey));
+    myIndex.setSources(docs);
+    myIndex.create();
+    return myIndex;
+  }
+  function parseIndex(data, { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) {
+    const { keys, records } = data;
+    const myIndex = new FuseIndex({ getFn, fieldNormWeight });
+    myIndex.setKeys(keys);
+    myIndex.setIndexRecords(records);
+    return myIndex;
+  }
+  function computeScore$1(pattern, {
+    errors = 0,
+    currentLocation = 0,
+    expectedLocation = 0,
+    distance = Config.distance,
+    ignoreLocation = Config.ignoreLocation
+  } = {}) {
+    const accuracy = errors / pattern.length;
+    if (ignoreLocation) {
+      return accuracy;
+    }
+    const proximity = Math.abs(expectedLocation - currentLocation);
+    if (!distance) {
+      return proximity ? 1 : accuracy;
+    }
+    return accuracy + proximity / distance;
+  }
+  function convertMaskToIndices(matchmask = [], minMatchCharLength = Config.minMatchCharLength) {
+    let indices = [];
+    let start = -1;
+    let end = -1;
+    let i = 0;
+    for (let len = matchmask.length; i < len; i += 1) {
+      let match = matchmask[i];
+      if (match && start === -1) {
+        start = i;
+      } else if (!match && start !== -1) {
+        end = i - 1;
+        if (end - start + 1 >= minMatchCharLength) {
+          indices.push([start, end]);
+        }
+        start = -1;
+      }
+    }
+    if (matchmask[i - 1] && i - start >= minMatchCharLength) {
+      indices.push([start, i - 1]);
+    }
+    return indices;
+  }
+  const MAX_BITS = 32;
+  function search(text, pattern, patternAlphabet, {
+    location = Config.location,
+    distance = Config.distance,
+    threshold = Config.threshold,
+    findAllMatches = Config.findAllMatches,
+    minMatchCharLength = Config.minMatchCharLength,
+    includeMatches = Config.includeMatches,
+    ignoreLocation = Config.ignoreLocation
+  } = {}) {
+    if (pattern.length > MAX_BITS) {
+      throw new Error(PATTERN_LENGTH_TOO_LARGE(MAX_BITS));
+    }
+    const patternLen = pattern.length;
+    const textLen = text.length;
+    const expectedLocation = Math.max(0, Math.min(location, textLen));
+    let currentThreshold = threshold;
+    let bestLocation = expectedLocation;
+    const computeMatches = minMatchCharLength > 1 || includeMatches;
+    const matchMask = computeMatches ? Array(textLen) : [];
+    let index;
+    while ((index = text.indexOf(pattern, bestLocation)) > -1) {
+      let score = computeScore$1(pattern, {
+        currentLocation: index,
+        expectedLocation,
+        distance,
+        ignoreLocation
+      });
+      currentThreshold = Math.min(score, currentThreshold);
+      bestLocation = index + patternLen;
+      if (computeMatches) {
+        let i = 0;
+        while (i < patternLen) {
+          matchMask[index + i] = 1;
+          i += 1;
+        }
+      }
+    }
+    bestLocation = -1;
+    let lastBitArr = [];
+    let finalScore = 1;
+    let binMax = patternLen + textLen;
+    const mask = 1 << patternLen - 1;
+    for (let i = 0; i < patternLen; i += 1) {
+      let binMin = 0;
+      let binMid = binMax;
+      while (binMin < binMid) {
+        const score2 = computeScore$1(pattern, {
+          errors: i,
+          currentLocation: expectedLocation + binMid,
+          expectedLocation,
+          distance,
+          ignoreLocation
+        });
+        if (score2 <= currentThreshold) {
+          binMin = binMid;
+        } else {
+          binMax = binMid;
+        }
+        binMid = Math.floor((binMax - binMin) / 2 + binMin);
+      }
+      binMax = binMid;
+      let start = Math.max(1, expectedLocation - binMid + 1);
+      let finish = findAllMatches ? textLen : Math.min(expectedLocation + binMid, textLen) + patternLen;
+      let bitArr = Array(finish + 2);
+      bitArr[finish + 1] = (1 << i) - 1;
+      for (let j = finish; j >= start; j -= 1) {
+        let currentLocation = j - 1;
+        let charMatch = patternAlphabet[text.charAt(currentLocation)];
+        if (computeMatches) {
+          matchMask[currentLocation] = +!!charMatch;
+        }
+        bitArr[j] = (bitArr[j + 1] << 1 | 1) & charMatch;
+        if (i) {
+          bitArr[j] |= (lastBitArr[j + 1] | lastBitArr[j]) << 1 | 1 | lastBitArr[j + 1];
+        }
+        if (bitArr[j] & mask) {
+          finalScore = computeScore$1(pattern, {
+            errors: i,
+            currentLocation,
+            expectedLocation,
+            distance,
+            ignoreLocation
+          });
+          if (finalScore <= currentThreshold) {
+            currentThreshold = finalScore;
+            bestLocation = currentLocation;
+            if (bestLocation <= expectedLocation) {
+              break;
+            }
+            start = Math.max(1, 2 * expectedLocation - bestLocation);
+          }
+        }
+      }
+      const score = computeScore$1(pattern, {
+        errors: i + 1,
+        currentLocation: expectedLocation,
+        expectedLocation,
+        distance,
+        ignoreLocation
+      });
+      if (score > currentThreshold) {
+        break;
+      }
+      lastBitArr = bitArr;
+    }
+    const result = {
+      isMatch: bestLocation >= 0,
+      // Count exact matches (those with a score of 0) to be "almost" exact
+      score: Math.max(1e-3, finalScore)
+    };
+    if (computeMatches) {
+      const indices = convertMaskToIndices(matchMask, minMatchCharLength);
+      if (!indices.length) {
+        result.isMatch = false;
+      } else if (includeMatches) {
+        result.indices = indices;
+      }
+    }
+    return result;
+  }
+  function createPatternAlphabet(pattern) {
+    let mask = {};
+    for (let i = 0, len = pattern.length; i < len; i += 1) {
+      const char = pattern.charAt(i);
+      mask[char] = (mask[char] || 0) | 1 << len - i - 1;
+    }
+    return mask;
+  }
+  class BitapSearch {
+    constructor(pattern, {
+      location = Config.location,
+      threshold = Config.threshold,
+      distance = Config.distance,
+      includeMatches = Config.includeMatches,
+      findAllMatches = Config.findAllMatches,
+      minMatchCharLength = Config.minMatchCharLength,
+      isCaseSensitive = Config.isCaseSensitive,
+      ignoreLocation = Config.ignoreLocation
+    } = {}) {
+      this.options = {
+        location,
+        threshold,
+        distance,
+        includeMatches,
+        findAllMatches,
+        minMatchCharLength,
+        isCaseSensitive,
+        ignoreLocation
+      };
+      this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
+      this.chunks = [];
+      if (!this.pattern.length) {
+        return;
+      }
+      const addChunk = (pattern2, startIndex) => {
+        this.chunks.push({
+          pattern: pattern2,
+          alphabet: createPatternAlphabet(pattern2),
+          startIndex
+        });
+      };
+      const len = this.pattern.length;
+      if (len > MAX_BITS) {
+        let i = 0;
+        const remainder = len % MAX_BITS;
+        const end = len - remainder;
+        while (i < end) {
+          addChunk(this.pattern.substr(i, MAX_BITS), i);
+          i += MAX_BITS;
+        }
+        if (remainder) {
+          const startIndex = len - MAX_BITS;
+          addChunk(this.pattern.substr(startIndex), startIndex);
+        }
+      } else {
+        addChunk(this.pattern, 0);
+      }
+    }
+    searchIn(text) {
+      const { isCaseSensitive, includeMatches } = this.options;
+      if (!isCaseSensitive) {
+        text = text.toLowerCase();
+      }
+      if (this.pattern === text) {
+        let result2 = {
+          isMatch: true,
+          score: 0
+        };
+        if (includeMatches) {
+          result2.indices = [[0, text.length - 1]];
+        }
+        return result2;
+      }
+      const {
+        location,
+        distance,
+        threshold,
+        findAllMatches,
+        minMatchCharLength,
+        ignoreLocation
+      } = this.options;
+      let allIndices = [];
+      let totalScore = 0;
+      let hasMatches = false;
+      this.chunks.forEach(({ pattern, alphabet, startIndex }) => {
+        const { isMatch, score, indices } = search(text, pattern, alphabet, {
+          location: location + startIndex,
+          distance,
+          threshold,
+          findAllMatches,
+          minMatchCharLength,
+          includeMatches,
+          ignoreLocation
+        });
+        if (isMatch) {
+          hasMatches = true;
+        }
+        totalScore += score;
+        if (isMatch && indices) {
+          allIndices = [...allIndices, ...indices];
+        }
+      });
+      let result = {
+        isMatch: hasMatches,
+        score: hasMatches ? totalScore / this.chunks.length : 1
+      };
+      if (hasMatches && includeMatches) {
+        result.indices = allIndices;
+      }
+      return result;
+    }
+  }
+  class BaseMatch {
+    constructor(pattern) {
+      this.pattern = pattern;
+    }
+    static isMultiMatch(pattern) {
+      return getMatch(pattern, this.multiRegex);
+    }
+    static isSingleMatch(pattern) {
+      return getMatch(pattern, this.singleRegex);
+    }
+    search() {
+    }
+  }
+  function getMatch(pattern, exp) {
+    const matches = pattern.match(exp);
+    return matches ? matches[1] : null;
+  }
+  class ExactMatch extends BaseMatch {
+    constructor(pattern) {
+      super(pattern);
+    }
+    static get type() {
+      return "exact";
+    }
+    static get multiRegex() {
+      return /^="(.*)"$/;
+    }
+    static get singleRegex() {
+      return /^=(.*)$/;
+    }
+    search(text) {
+      const isMatch = text === this.pattern;
+      return {
+        isMatch,
+        score: isMatch ? 0 : 1,
+        indices: [0, this.pattern.length - 1]
+      };
+    }
+  }
+  class InverseExactMatch extends BaseMatch {
+    constructor(pattern) {
+      super(pattern);
+    }
+    static get type() {
+      return "inverse-exact";
+    }
+    static get multiRegex() {
+      return /^!"(.*)"$/;
+    }
+    static get singleRegex() {
+      return /^!(.*)$/;
+    }
+    search(text) {
+      const index = text.indexOf(this.pattern);
+      const isMatch = index === -1;
+      return {
+        isMatch,
+        score: isMatch ? 0 : 1,
+        indices: [0, text.length - 1]
+      };
+    }
+  }
+  class PrefixExactMatch extends BaseMatch {
+    constructor(pattern) {
+      super(pattern);
+    }
+    static get type() {
+      return "prefix-exact";
+    }
+    static get multiRegex() {
+      return /^\^"(.*)"$/;
+    }
+    static get singleRegex() {
+      return /^\^(.*)$/;
+    }
+    search(text) {
+      const isMatch = text.startsWith(this.pattern);
+      return {
+        isMatch,
+        score: isMatch ? 0 : 1,
+        indices: [0, this.pattern.length - 1]
+      };
+    }
+  }
+  class InversePrefixExactMatch extends BaseMatch {
+    constructor(pattern) {
+      super(pattern);
+    }
+    static get type() {
+      return "inverse-prefix-exact";
+    }
+    static get multiRegex() {
+      return /^!\^"(.*)"$/;
+    }
+    static get singleRegex() {
+      return /^!\^(.*)$/;
+    }
+    search(text) {
+      const isMatch = !text.startsWith(this.pattern);
+      return {
+        isMatch,
+        score: isMatch ? 0 : 1,
+        indices: [0, text.length - 1]
+      };
+    }
+  }
+  class SuffixExactMatch extends BaseMatch {
+    constructor(pattern) {
+      super(pattern);
+    }
+    static get type() {
+      return "suffix-exact";
+    }
+    static get multiRegex() {
+      return /^"(.*)"\$$/;
+    }
+    static get singleRegex() {
+      return /^(.*)\$$/;
+    }
+    search(text) {
+      const isMatch = text.endsWith(this.pattern);
+      return {
+        isMatch,
+        score: isMatch ? 0 : 1,
+        indices: [text.length - this.pattern.length, text.length - 1]
+      };
+    }
+  }
+  class InverseSuffixExactMatch extends BaseMatch {
+    constructor(pattern) {
+      super(pattern);
+    }
+    static get type() {
+      return "inverse-suffix-exact";
+    }
+    static get multiRegex() {
+      return /^!"(.*)"\$$/;
+    }
+    static get singleRegex() {
+      return /^!(.*)\$$/;
+    }
+    search(text) {
+      const isMatch = !text.endsWith(this.pattern);
+      return {
+        isMatch,
+        score: isMatch ? 0 : 1,
+        indices: [0, text.length - 1]
+      };
+    }
+  }
+  class FuzzyMatch extends BaseMatch {
+    constructor(pattern, {
+      location = Config.location,
+      threshold = Config.threshold,
+      distance = Config.distance,
+      includeMatches = Config.includeMatches,
+      findAllMatches = Config.findAllMatches,
+      minMatchCharLength = Config.minMatchCharLength,
+      isCaseSensitive = Config.isCaseSensitive,
+      ignoreLocation = Config.ignoreLocation
+    } = {}) {
+      super(pattern);
+      this._bitapSearch = new BitapSearch(pattern, {
+        location,
+        threshold,
+        distance,
+        includeMatches,
+        findAllMatches,
+        minMatchCharLength,
+        isCaseSensitive,
+        ignoreLocation
+      });
+    }
+    static get type() {
+      return "fuzzy";
+    }
+    static get multiRegex() {
+      return /^"(.*)"$/;
+    }
+    static get singleRegex() {
+      return /^(.*)$/;
+    }
+    search(text) {
+      return this._bitapSearch.searchIn(text);
+    }
+  }
+  class IncludeMatch extends BaseMatch {
+    constructor(pattern) {
+      super(pattern);
+    }
+    static get type() {
+      return "include";
+    }
+    static get multiRegex() {
+      return /^'"(.*)"$/;
+    }
+    static get singleRegex() {
+      return /^'(.*)$/;
+    }
+    search(text) {
+      let location = 0;
+      let index;
+      const indices = [];
+      const patternLen = this.pattern.length;
+      while ((index = text.indexOf(this.pattern, location)) > -1) {
+        location = index + patternLen;
+        indices.push([index, location - 1]);
+      }
+      const isMatch = !!indices.length;
+      return {
+        isMatch,
+        score: isMatch ? 0 : 1,
+        indices
+      };
+    }
+  }
+  const searchers = [
+    ExactMatch,
+    IncludeMatch,
+    PrefixExactMatch,
+    InversePrefixExactMatch,
+    InverseSuffixExactMatch,
+    SuffixExactMatch,
+    InverseExactMatch,
+    FuzzyMatch
+  ];
+  const searchersLen = searchers.length;
+  const SPACE_RE = / +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/;
+  const OR_TOKEN = "|";
+  function parseQuery(pattern, options = {}) {
+    return pattern.split(OR_TOKEN).map((item) => {
+      let query = item.trim().split(SPACE_RE).filter((item2) => item2 && !!item2.trim());
+      let results = [];
+      for (let i = 0, len = query.length; i < len; i += 1) {
+        const queryItem = query[i];
+        let found = false;
+        let idx = -1;
+        while (!found && ++idx < searchersLen) {
+          const searcher = searchers[idx];
+          let token = searcher.isMultiMatch(queryItem);
+          if (token) {
+            results.push(new searcher(token, options));
+            found = true;
+          }
+        }
+        if (found) {
+          continue;
+        }
+        idx = -1;
+        while (++idx < searchersLen) {
+          const searcher = searchers[idx];
+          let token = searcher.isSingleMatch(queryItem);
+          if (token) {
+            results.push(new searcher(token, options));
+            break;
+          }
+        }
+      }
+      return results;
+    });
+  }
+  const MultiMatchSet = /* @__PURE__ */ new Set([FuzzyMatch.type, IncludeMatch.type]);
+  class ExtendedSearch {
+    constructor(pattern, {
+      isCaseSensitive = Config.isCaseSensitive,
+      includeMatches = Config.includeMatches,
+      minMatchCharLength = Config.minMatchCharLength,
+      ignoreLocation = Config.ignoreLocation,
+      findAllMatches = Config.findAllMatches,
+      location = Config.location,
+      threshold = Config.threshold,
+      distance = Config.distance
+    } = {}) {
+      this.query = null;
+      this.options = {
+        isCaseSensitive,
+        includeMatches,
+        minMatchCharLength,
+        findAllMatches,
+        ignoreLocation,
+        location,
+        threshold,
+        distance
+      };
+      this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
+      this.query = parseQuery(this.pattern, this.options);
+    }
+    static condition(_, options) {
+      return options.useExtendedSearch;
+    }
+    searchIn(text) {
+      const query = this.query;
+      if (!query) {
+        return {
+          isMatch: false,
+          score: 1
+        };
+      }
+      const { includeMatches, isCaseSensitive } = this.options;
+      text = isCaseSensitive ? text : text.toLowerCase();
+      let numMatches = 0;
+      let allIndices = [];
+      let totalScore = 0;
+      for (let i = 0, qLen = query.length; i < qLen; i += 1) {
+        const searchers2 = query[i];
+        allIndices.length = 0;
+        numMatches = 0;
+        for (let j = 0, pLen = searchers2.length; j < pLen; j += 1) {
+          const searcher = searchers2[j];
+          const { isMatch, indices, score } = searcher.search(text);
+          if (isMatch) {
+            numMatches += 1;
+            totalScore += score;
+            if (includeMatches) {
+              const type = searcher.constructor.type;
+              if (MultiMatchSet.has(type)) {
+                allIndices = [...allIndices, ...indices];
+              } else {
+                allIndices.push(indices);
+              }
+            }
+          } else {
+            totalScore = 0;
+            numMatches = 0;
+            allIndices.length = 0;
+            break;
+          }
+        }
+        if (numMatches) {
+          let result = {
+            isMatch: true,
+            score: totalScore / numMatches
+          };
+          if (includeMatches) {
+            result.indices = allIndices;
+          }
+          return result;
+        }
+      }
+      return {
+        isMatch: false,
+        score: 1
+      };
+    }
+  }
+  const registeredSearchers = [];
+  function register(...args) {
+    registeredSearchers.push(...args);
+  }
+  function createSearcher(pattern, options) {
+    for (let i = 0, len = registeredSearchers.length; i < len; i += 1) {
+      let searcherClass = registeredSearchers[i];
+      if (searcherClass.condition(pattern, options)) {
+        return new searcherClass(pattern, options);
+      }
+    }
+    return new BitapSearch(pattern, options);
+  }
+  const LogicalOperator = {
+    AND: "$and",
+    OR: "$or"
+  };
+  const KeyType = {
+    PATH: "$path",
+    PATTERN: "$val"
+  };
+  const isExpression = (query) => !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);
+  const isPath = (query) => !!query[KeyType.PATH];
+  const isLeaf = (query) => !isArray(query) && isObject(query) && !isExpression(query);
+  const convertToExplicit = (query) => ({
+    [LogicalOperator.AND]: Object.keys(query).map((key) => ({
+      [key]: query[key]
+    }))
+  });
+  function parse(query, options, { auto = true } = {}) {
+    const next = (query2) => {
+      let keys = Object.keys(query2);
+      const isQueryPath = isPath(query2);
+      if (!isQueryPath && keys.length > 1 && !isExpression(query2)) {
+        return next(convertToExplicit(query2));
+      }
+      if (isLeaf(query2)) {
+        const key = isQueryPath ? query2[KeyType.PATH] : keys[0];
+        const pattern = isQueryPath ? query2[KeyType.PATTERN] : query2[key];
+        if (!isString(pattern)) {
+          throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key));
+        }
+        const obj = {
+          keyId: createKeyId(key),
+          pattern
+        };
+        if (auto) {
+          obj.searcher = createSearcher(pattern, options);
+        }
+        return obj;
+      }
+      let node = {
+        children: [],
+        operator: keys[0]
+      };
+      keys.forEach((key) => {
+        const value = query2[key];
+        if (isArray(value)) {
+          value.forEach((item) => {
+            node.children.push(next(item));
+          });
+        }
+      });
+      return node;
+    };
+    if (!isExpression(query)) {
+      query = convertToExplicit(query);
+    }
+    return next(query);
+  }
+  function computeScore(results, { ignoreFieldNorm = Config.ignoreFieldNorm }) {
+    results.forEach((result) => {
+      let totalScore = 1;
+      result.matches.forEach(({ key, norm: norm2, score }) => {
+        const weight = key ? key.weight : null;
+        totalScore *= Math.pow(
+          score === 0 && weight ? Number.EPSILON : score,
+          (weight || 1) * (ignoreFieldNorm ? 1 : norm2)
+        );
+      });
+      result.score = totalScore;
+    });
+  }
+  function transformMatches(result, data) {
+    const matches = result.matches;
+    data.matches = [];
+    if (!isDefined(matches)) {
+      return;
+    }
+    matches.forEach((match) => {
+      if (!isDefined(match.indices) || !match.indices.length) {
+        return;
+      }
+      const { indices, value } = match;
+      let obj = {
+        indices,
+        value
+      };
+      if (match.key) {
+        obj.key = match.key.src;
+      }
+      if (match.idx > -1) {
+        obj.refIndex = match.idx;
+      }
+      data.matches.push(obj);
+    });
+  }
+  function transformScore(result, data) {
+    data.score = result.score;
+  }
+  function format(results, docs, {
+    includeMatches = Config.includeMatches,
+    includeScore = Config.includeScore
+  } = {}) {
+    const transformers = [];
+    if (includeMatches)
+      transformers.push(transformMatches);
+    if (includeScore)
+      transformers.push(transformScore);
+    return results.map((result) => {
+      const { idx } = result;
+      const data = {
+        item: docs[idx],
+        refIndex: idx
+      };
+      if (transformers.length) {
+        transformers.forEach((transformer) => {
+          transformer(result, data);
+        });
+      }
+      return data;
+    });
+  }
+  class Fuse {
+    constructor(docs, options = {}, index) {
+      this.options = { ...Config, ...options };
+      if (this.options.useExtendedSearch && false) {
+        throw new Error(EXTENDED_SEARCH_UNAVAILABLE);
+      }
+      this._keyStore = new KeyStore(this.options.keys);
+      this.setCollection(docs, index);
+    }
+    setCollection(docs, index) {
+      this._docs = docs;
+      if (index && !(index instanceof FuseIndex)) {
+        throw new Error(INCORRECT_INDEX_TYPE);
+      }
+      this._myIndex = index || createIndex(this.options.keys, this._docs, {
+        getFn: this.options.getFn,
+        fieldNormWeight: this.options.fieldNormWeight
+      });
+    }
+    add(doc) {
+      if (!isDefined(doc)) {
+        return;
+      }
+      this._docs.push(doc);
+      this._myIndex.add(doc);
+    }
+    remove(predicate = () => false) {
+      const results = [];
+      for (let i = 0, len = this._docs.length; i < len; i += 1) {
+        const doc = this._docs[i];
+        if (predicate(doc, i)) {
+          this.removeAt(i);
+          i -= 1;
+          len -= 1;
+          results.push(doc);
+        }
+      }
+      return results;
+    }
+    removeAt(idx) {
+      this._docs.splice(idx, 1);
+      this._myIndex.removeAt(idx);
+    }
+    getIndex() {
+      return this._myIndex;
+    }
+    search(query, { limit = -1 } = {}) {
+      const {
+        includeMatches,
+        includeScore,
+        shouldSort,
+        sortFn,
+        ignoreFieldNorm
+      } = this.options;
+      let results = isString(query) ? isString(this._docs[0]) ? this._searchStringList(query) : this._searchObjectList(query) : this._searchLogical(query);
+      computeScore(results, { ignoreFieldNorm });
+      if (shouldSort) {
+        results.sort(sortFn);
+      }
+      if (isNumber(limit) && limit > -1) {
+        results = results.slice(0, limit);
+      }
+      return format(results, this._docs, {
+        includeMatches,
+        includeScore
+      });
+    }
+    _searchStringList(query) {
+      const searcher = createSearcher(query, this.options);
+      const { records } = this._myIndex;
+      const results = [];
+      records.forEach(({ v: text, i: idx, n: norm2 }) => {
+        if (!isDefined(text)) {
+          return;
+        }
+        const { isMatch, score, indices } = searcher.searchIn(text);
+        if (isMatch) {
+          results.push({
+            item: text,
+            idx,
+            matches: [{ score, value: text, norm: norm2, indices }]
+          });
+        }
+      });
+      return results;
+    }
+    _searchLogical(query) {
+      const expression = parse(query, this.options);
+      const evaluate = (node, item, idx) => {
+        if (!node.children) {
+          const { keyId, searcher } = node;
+          const matches = this._findMatches({
+            key: this._keyStore.get(keyId),
+            value: this._myIndex.getValueForItemAtKeyId(item, keyId),
+            searcher
+          });
+          if (matches && matches.length) {
+            return [
+              {
+                idx,
+                item,
+                matches
+              }
+            ];
+          }
+          return [];
+        }
+        const res = [];
+        for (let i = 0, len = node.children.length; i < len; i += 1) {
+          const child = node.children[i];
+          const result = evaluate(child, item, idx);
+          if (result.length) {
+            res.push(...result);
+          } else if (node.operator === LogicalOperator.AND) {
+            return [];
+          }
+        }
+        return res;
+      };
+      const records = this._myIndex.records;
+      const resultMap = {};
+      const results = [];
+      records.forEach(({ $: item, i: idx }) => {
+        if (isDefined(item)) {
+          let expResults = evaluate(expression, item, idx);
+          if (expResults.length) {
+            if (!resultMap[idx]) {
+              resultMap[idx] = { idx, item, matches: [] };
+              results.push(resultMap[idx]);
+            }
+            expResults.forEach(({ matches }) => {
+              resultMap[idx].matches.push(...matches);
+            });
+          }
+        }
+      });
+      return results;
+    }
+    _searchObjectList(query) {
+      const searcher = createSearcher(query, this.options);
+      const { keys, records } = this._myIndex;
+      const results = [];
+      records.forEach(({ $: item, i: idx }) => {
+        if (!isDefined(item)) {
+          return;
+        }
+        let matches = [];
+        keys.forEach((key, keyIndex) => {
+          matches.push(
+            ...this._findMatches({
+              key,
+              value: item[keyIndex],
+              searcher
+            })
+          );
+        });
+        if (matches.length) {
+          results.push({
+            idx,
+            item,
+            matches
+          });
+        }
+      });
+      return results;
+    }
+    _findMatches({ key, value, searcher }) {
+      if (!isDefined(value)) {
+        return [];
+      }
+      let matches = [];
+      if (isArray(value)) {
+        value.forEach(({ v: text, i: idx, n: norm2 }) => {
+          if (!isDefined(text)) {
+            return;
+          }
+          const { isMatch, score, indices } = searcher.searchIn(text);
+          if (isMatch) {
+            matches.push({
+              score,
+              key,
+              value: text,
+              idx,
+              norm: norm2,
+              indices
+            });
+          }
+        });
+      } else {
+        const { v: text, n: norm2 } = value;
+        const { isMatch, score, indices } = searcher.searchIn(text);
+        if (isMatch) {
+          matches.push({ score, key, value: text, norm: norm2, indices });
+        }
+      }
+      return matches;
+    }
+  }
+  Fuse.version = "7.0.0";
+  Fuse.createIndex = createIndex;
+  Fuse.parseIndex = parseIndex;
+  Fuse.config = Config;
+  {
+    Fuse.parseQuery = parse;
+  }
+  {
+    register(ExtendedSearch);
+  }
+  const name = "x-img-diff-js";
+  const version = "0.3.5";
+  const main = "src/index.js";
+  const description = "compare 2 images considering into translation";
+  const scripts = {
+    build: "docker-compose run --rm emcc && npm run build:demo",
+    test: "node test/test_node.js",
+    "build:demo": "cp -rf build demo",
+    start: "cd demo; http-server -p 8000",
+    "gen:postjs": "babel binding-gen/post.js > bindings/post.js",
+    deploy: "npm run build:demo && gh-pages -d demo"
+  };
+  const repository = {
+    type: "git",
+    url: "git+https://github.com/reg-viz/x-img-diff-js.git"
+  };
+  const author = "Quramy";
+  const license = "MIT";
+  const bugs = {
+    url: "https://github.com/reg-viz/x-img-diff-js/issues"
+  };
+  const homepage = "https://github.com/reg-viz/x-img-diff-js#readme";
+  const devDependencies = {
+    "babel-cli": "^6.26.0",
+    "babel-core": "^6.26.0",
+    "babel-preset-es2015": "^6.24.1",
+    "gh-pages": "^1.0.0",
+    "http-server": "^0.10.0",
+    pngjs: "^3.3.0"
+  };
+  const packageJson = {
+    name,
+    version,
+    main,
+    description,
+    scripts,
+    repository,
+    author,
+    license,
+    bugs,
+    homepage,
+    devDependencies
+  };
+  function instantiateCachedURL(dbVersion, url, importObject) {
+    const dbName = "wasm-cache";
+    const storeName = "wasm-cache";
+    function openDatabase() {
+      return new Promise((resolve, reject) => {
+        const request = indexedDB.open(dbName, dbVersion);
+        request.onerror = reject.bind(null, "Error opening wasm cache database");
+        request.onsuccess = () => {
+          resolve(request.result);
+        };
+        request.onupgradeneeded = (event) => {
+          const db = request.result;
+          if (db.objectStoreNames.contains(storeName)) {
+            console.log(`Clearing out version ${event.oldVersion} wasm cache`);
+            db.deleteObjectStore(storeName);
+          }
+          console.log(`Creating version ${event.newVersion} wasm cache`);
+          db.createObjectStore(storeName);
+        };
+      });
+    }
+    function lookupInDatabase(db) {
+      return new Promise((resolve, reject) => {
+        const store = db.transaction([storeName]).objectStore(storeName);
+        const request = store.get(url);
+        request.onerror = reject.bind(null, `Error getting wasm module ${url}`);
+        request.onsuccess = () => {
+          if (request.result) {
+            resolve(request.result);
+          } else {
+            reject(`Module ${url} was not found in wasm cache`);
+          }
+        };
+      });
+    }
+    function storeInDatabase(db, module) {
+      const store = db.transaction([storeName], "readwrite").objectStore(storeName);
+      try {
+        const request = store.put(module, url);
+        request.onerror = (err) => {
+          console.log(`Failed to store in wasm cache: ${err}`);
+        };
+        request.onsuccess = () => {
+          console.log(`Successfully stored ${url} in wasm cache`);
+        };
+      } catch (e) {
+        console.warn("An error was thrown... in storing wasm cache...");
+        console.warn(e);
+      }
+    }
+    async function fetchAndInstantiate() {
+      const response = await fetch(url);
+      const buffer = await response.arrayBuffer();
+      return await WebAssembly.instantiate(buffer, importObject);
+    }
+    return openDatabase().then(
+      (db) => {
+        return lookupInDatabase(db).then(
+          (module) => {
+            console.log(`Found ${url} in wasm cache`);
+            return WebAssembly.instantiate(module, importObject);
+          },
+          (errMsg) => {
+            console.log(errMsg);
+            return fetchAndInstantiate().then((results) => {
+              setTimeout(() => storeInDatabase(db, results.module), 0);
+              return results.instance;
+            });
+          }
+        );
+      },
+      (errMsg) => {
+        console.log(errMsg);
+        return fetchAndInstantiate().then((results) => results.instance);
+      }
+    );
+  }
+  class ModuleClass {
+    constructor({ init, version: version2, wasmUrl }) {
+      this._init = init;
+      this._version = version2;
+      this._wasmUrl = wasmUrl;
+    }
+    locateFile(baseName) {
+      return self.location.pathname.replace(/\[^\/]*$/, "/") + baseName;
+    }
+    instantiateWasm(imports, callback) {
+      instantiateCachedURL(this._version, this._wasmUrl, imports).then(
+        (instance) => callback(instance)
+      );
+      return {};
+    }
+    onInit(callback) {
+      this._init = callback;
+    }
+    onRuntimeInitialized() {
+      if (this._init) {
+        return this._init(this);
+      }
+    }
+  }
+  var WorkerEventType = /* @__PURE__ */ ((WorkerEventType2) => {
+    WorkerEventType2["INIT_CALC"] = "init";
+    WorkerEventType2["REQUEST_CALC"] = "req_calc";
+    WorkerEventType2["RESULT_CALC"] = "res_calc";
+    WorkerEventType2["INIT_FILTER"] = "init_filter";
+    WorkerEventType2["REQUEST_FILTER"] = "req_filter";
+    WorkerEventType2["RESULT_FILTER"] = "res_filter";
+    return WorkerEventType2;
+  })(WorkerEventType || {});
+  const ximgdiffVersionString = packageJson.version;
+  const _self = self;
+  function version2number(version2) {
+    const [, major, minor, patch] = version2.match(/^(\d*)\.(\d*)\.(\d*)/);
+    return +major * 1e4 + +minor * 100 + +patch;
+  }
+  let loaded = false;
+  let lastCalcData = null;
+  const cachedEntity = {
+    new: [],
+    passed: [],
+    failed: [],
+    deleted: []
+  };
+  const calc = ({
+    payload: { raw, img1, img2, actualSrc, expectedSrc, seq }
+  }) => {
+    const diffResult = _self.Module.detectDiff(_self.Module, img1, img2, {});
+    _self.postMessage({
+      type: WorkerEventType.RESULT_CALC,
+      payload: {
+        seq,
+        raw,
+        actualSrc,
+        expectedSrc,
+        result: {
+          ...diffResult,
+          images: [
+            { width: img1.width, height: img1.height },
+            { width: img2.width, height: img2.height }
+          ]
+        }
+      }
+    });
+  };
+  const filter = ({
+    payload: { input }
+  }) => {
+    if (!input) {
+      return _self.postMessage({
+        type: WorkerEventType.RESULT_FILTER,
+        payload: {
+          newItems: cachedEntity.new,
+          passedItems: cachedEntity.passed,
+          failedItems: cachedEntity.failed,
+          deletedItems: cachedEntity.deleted
+        }
+      });
+    }
+    const search2 = (entities) => {
+      const fuse = new Fuse(entities, {
+        shouldSort: false,
+        isCaseSensitive: false,
+        findAllMatches: true,
+        location: 0,
+        distance: 100,
+        minMatchCharLength: 1,
+        threshold: 0.2,
+        keys: ["name"]
+      });
+      return fuse.search(input).map(({ item }) => item);
+    };
+    _self.postMessage({
+      type: WorkerEventType.RESULT_FILTER,
+      payload: {
+        newItems: search2(cachedEntity.new),
+        passedItems: search2(cachedEntity.passed),
+        failedItems: search2(cachedEntity.failed),
+        deletedItems: search2(cachedEntity.deleted)
+      }
+    });
+  };
+  _self.Module = new ModuleClass({
+    version: version2number(ximgdiffVersionString),
+    wasmUrl: _self.wasmUrl,
+    init: () => {
+      loaded = true;
+      if (lastCalcData != null) {
+        calc(lastCalcData);
+      }
+      _self.postMessage({ type: WorkerEventType.INIT_CALC });
+    }
+  });
+  _self.addEventListener("message", ({ data }) => {
+    console.log("Received: ", data);
+    switch (data.type) {
+      case WorkerEventType.REQUEST_CALC:
+        if (loaded) {
+          calc(data);
+        } else {
+          lastCalcData = data;
+        }
+        break;
+      case WorkerEventType.INIT_FILTER:
+        cachedEntity.new = data.payload.newItems;
+        cachedEntity.passed = data.payload.passedItems;
+        cachedEntity.failed = data.payload.failedItems;
+        cachedEntity.deleted = data.payload.deletedItems;
+        break;
+      case WorkerEventType.REQUEST_FILTER:
+        filter(data);
+        break;
+    }
+  });
+})();