@next2d/core 3.0.1 → 3.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/package.json +11 -11
  2. package/src/renderer.worker.inline.js +1 -1
package/src/renderer.worker.inline.js CHANGED
@@ -1 +1 @@
1
- export const workerInlineUrl = 'data:application/javascript;base64,var RendererWorker=function(){"use strict";let e=2048;let t=4;let r;let n;let i=!1;const a=()=>{i||(i=!0,r.enable(r.SCISSOR_TEST))},s=()=>{i&&(i=!1,r.disable(r.SCISSOR_TEST))};let o=!1;const l=()=>{o||(o=!0,r.enable(r.STENCIL_TEST))},c=()=>{o&&(o=!1,r.disable(r.STENCIL_TEST))},u=(e,t,r,n=null)=>{const i=+e;return isNaN(i)&&null!==n?n:Math.min(Math.max(t,isNaN(i)?0:i),r)},f=[],d=(...e)=>{const t=f.pop()||[];return e.length&&t.push(...e),t},h=(e=null)=>{e&&(e.length&&(e.length=0),f.push(e))},p=e=>(e--,e|=e>>1,e|=e>>2,e|=e>>4,e|=e>>8,e|=e>>16,++e),m=[],g=(e=0,t=0,r=0,n=0)=>{const i=m.pop()||new Float32Array(4);return i[0]=e,i[1]=t,i[2]=r,i[3]=n,i},b=e=>{m.push(e)},x=[],v=(e=0,t=0,r=0,n=0,i=0,a=0,s=0,o=0,l=0)=>{const c=x.pop()||new Float32Array(9);return c[0]=e,c[1]=t,c[2]=r,c[3]=n,c[4]=i,c[5]=a,c[6]=s,c[7]=o,c[8]=l,c},y=[],_=(e=0,t=0,r=0,n=0,i=0,a=0)=>{const s=y.pop()||new Float32Array(6);return s[0]=e,s[1]=t,s[2]=r,s[3]=n,s[4]=i,s[5]=a,s},w=e=>{y.push(e)},M=e=>{const t=1/(e[0]*e[4]-e[3]*e[1]),r=e[3]*e[7]-e[4]*e[6],n=e[1]*e[6]-e[0]*e[7];return v(e[4]*t,0-e[1]*t,0,0-e[3]*t,e[0]*t,0,r*t,n*t,1)};let P=0,S=0;let F=1;const T=d(),B=d(),O=(e=!1)=>{const t=e?6:9;T.length>=t&&B.push(T.slice(0)),T.length=0;const r=[];for(let e=0;e<B.length;e++){const n=B[e];n.length>=t&&r.push(n)}return B.length=0,r},A=(e,t,r)=>{T.push(e,t,r)},R=(e,t)=>{const r=T.length,n=+T[r-3],i=+T[r-2];return e===n&&t===i},C=(e,t)=>{T.length?R(e,t)||(T.length<3||B.push(T.slice(0)),T.length=0,A(e,t,!1)):A(e,t,!1)},E=(e,t,r,n)=>{T.length||C(0,0),R(r,n)||(A(e,t,!0),A(r,n,!1))};let U=new Float32Array(64),$=0;const G=(e,t,r,n,i,a,s,o)=>{const l=((e,t,r,n,i,a,s,o)=>{const l=3*r-2*e-s,c=3*n-2*t-o,u=3*i-2*s-e,f=3*a-2*o-t;return Math.max(l*l+c*c,u*u+f*f)})(e,t,r,n,i,a,s,o);if(l<.25)return 2;const c=Math.ceil(Math.log2(Math.sqrt(l)/.5)/2);return Math.min(Math.max(c+2,2),8)},k=[];let L=0;const I=()=>{L=0},V=()=>(L>=k.length&&k.push(new Float32Array(8)),k[L++]),z=(e,t,r,n,i,a,s,o,l,c,u)=>{const f=1-l,d=f*e+l*r,h=f*t+l*n,p=f*r+l*i,m=f*n+l*a,g=f*i+l*s,b=f*a+l*o,x=f*d+l*p,v=f*h+l*m,y=f*p+l*g,_=f*m+l*b,w=f*x+l*y,M=f*v+l*_;c[0]=e,c[1]=t,c[2]=d,c[3]=h,c[4]=x,c[5]=v,c[6]=w,c[7]=M,u[0]=w,u[1]=M,u[2]=y,u[3]=_,u[4]=g,u[5]=b,u[6]=s,u[7]=o},j=(e,t,r,n,i,a,s,o,l,c)=>{const u=.25*(3*r+3*i-e-s),f=.25*(3*n+3*a-t-o);l[c]=u,l[c+1]=f,l[c+2]=s,l[c+3]=o},D=new Float32Array(8),N=new Float32Array(8),W=(e,t,r,n,i,a,s,o)=>{const l=G(e,t,r,n,i,a,s,o);var c;c=4*l,U.length<c&&(U=new Float32Array(2*c));let u=0;if(l<=2)z(e,t,r,n,i,a,s,o,.5,D,N),j(D[0],D[1],D[2],D[3],D[4],D[5],D[6],D[7],U,u),u+=4,j(N[0],N[1],N[2],N[3],N[4],N[5],N[6],N[7],U,u),u+=4;else if(l<=4){I();const l=V(),c=V();z(e,t,r,n,i,a,s,o,.5,l,c);const f=V(),d=V(),h=V(),p=V();z(l[0],l[1],l[2],l[3],l[4],l[5],l[6],l[7],.5,f,d),z(c[0],c[1],c[2],c[3],c[4],c[5],c[6],c[7],.5,h,p),j(f[0],f[1],f[2],f[3],f[4],f[5],f[6],f[7],U,u),u+=4,j(d[0],d[1],d[2],d[3],d[4],d[5],d[6],d[7],U,u),u+=4,j(h[0],h[1],h[2],h[3],h[4],h[5],h[6],h[7],U,u),u+=4,j(p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],U,u),u+=4}else{I();const l=V(),c=V();z(e,t,r,n,i,a,s,o,.5,l,c);const f=V(),d=V(),h=V(),p=V();z(l[0],l[1],l[2],l[3],l[4],l[5],l[6],l[7],.5,f,d),z(c[0],c[1],c[2],c[3],c[4],c[5],c[6],c[7],.5,h,p);const m=V(),g=V(),b=V(),x=V(),v=V(),y=V(),_=V(),w=V();z(f[0],f[1],f[2],f[3],f[4],f[5],f[6],f[7],.5,m,g),z(d[0],d[1],d[2],d[3],d[4],d[5],d[6],d[7],.5,b,x),z(h[0],h[1],h[2],h[3],h[4],h[5],h[6],h[7],.5,v,y),z(p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],.5,_,w),j(m[0],m[1],m[2],m[3],m[4],m[5],m[6],m[7],U,u),u+=4,j(g[0],g[1],g[2],g[3],g[4],g[5],g[6],g[7],U,u),u+=4,j(b[0],b[1],b[2],b[3],b[4],b[5],b[6],b[7],U,u),u+=4,j(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],U,u),u+=4,j(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7],U,u),u+=4,j(y[0],y[1],y[2],y[3],y[4],y[5],y[6],y[7],U,u),u+=4,j(_[0],_[1],_[2],_[3],_[4],_[5],_[6],_[7],U,u),u+=4,j(w[0],w[1],w[2],w[3],w[4],w[5],w[6],w[7],U,u),u+=4}return $=u/4,{buffer:U,count:$}},q=(e,t,r,n,i,a)=>{if(T.length||C(0,0),R(i,a))return;const s=T.length,o=+T[s-3],l=+T[s-2],c=W(o,l,e,t,r,n,i,a),u=c.buffer,f=c.count;for(let e=0;e<4*f;)E(u[e++],u[e++],u[e++],u[e++])},X=[],Y=e=>{let t=-1,r=X.length;for(;Math.abs(r-t)>1;){const n=Math.floor((r+t)/2);e<=X[n].area?r=n:t=n}return r},K=e=>{r.deleteTexture(e.resource)},H=[],Q=[];let Z;let J=null;let ee=null;let te=null;const re=e=>{te=e};let ne=!1;const ie=e=>{ne=e};let ae=null,se=null,oe=null,le=null;const ce=(e,t=!0)=>{var n;e.msaa?((e=>{if(X.indexOf(e)>-1)return;const t=Y(e.area);e.dirty=!0,X.splice(t,0,e)})(e.color),e.color=null,e.stencil=null):(t&&K(e.texture),e.texture=null,n=e.stencil,H.indexOf(n)>-1||(H.length>10?r.deleteRenderbuffer(n.resource):(n.dirty=!0,H.push(n))),e.stencil=null),Q.push(e)};let ue=0;const fe=e=>{if(!X.length)return(()=>{const e={id:0,resource:r.createRenderbuffer(),width:0,height:0,area:0,dirty:!1};return{resource:r.createRenderbuffer(),stencil:e,width:0,height:0,area:0,dirty:!1}})();const t=Y(e);if(t<X.length){const e=X[t];return X.splice(t,1),e}const n=X.shift();if(!n)throw new Error("the color buffer is void.");return n};let de=0;const he=(e,t)=>{if(!H.length)return{id:de++,resource:r.createRenderbuffer(),width:0,height:0,area:0,dirty:!1};let n=-1,i=1/0;for(let r=0;r<H.length;++r){const a=H[r];a.width>=e&&a.height>=t&&a.area<i&&(i=a.area,n=r)}if(-1!==n){const e=H[n];return H[n]=H[H.length-1],H.pop(),e}return H.pop()};let pe=0;const me=(e,t)=>({id:pe++,resource:r.createTexture(),width:e,height:t,area:e*t,smooth:!1});let ge=-1;const be=e=>{ge=e},xe=[null,null,null],ve=(e,t,n=!1)=>{const i=me(e,t);return((e,t=!1)=>{ge!==r.TEXTURE0&&(be(r.TEXTURE0),r.activeTexture(r.TEXTURE0)),xe[0]=e,r.bindTexture(r.TEXTURE_2D,e.resource),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,t?r.LINEAR:r.NEAREST),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,t?r.LINEAR:r.NEAREST),r.texStorage2D(r.TEXTURE_2D,1,r.RGBA8,e.width,e.height)})(i,n),i},ye=(e,n,i=!1)=>{const a=Q.length?Q.pop():{id:ue++,width:0,height:0,clipLevel:0,msaa:!1,mask:!1,color:null,texture:null,stencil:null};return a.width=e,a.height=n,i?(a.msaa=!0,a.texture=null,a.color=((e,n)=>{e=Math.max(256,p(e)),n=Math.max(256,p(n));const i=fe(e*n);return(i.width<e||i.height<n)&&(e=Math.max(e,i.width),n=Math.max(n,i.height),i.width=e,i.height=n,i.area=e*n,r.bindRenderbuffer(r.RENDERBUFFER,i.resource),r.renderbufferStorageMultisample(r.RENDERBUFFER,t,r.RGBA8,e,n),r.bindRenderbuffer(r.RENDERBUFFER,i.stencil.resource),r.renderbufferStorageMultisample(r.RENDERBUFFER,t,r.STENCIL_INDEX8,e,n)),i.dirty=!0,i})(e,n),a.stencil=a.color.stencil):(a.msaa=!1,a.texture=ve(e,n),a.color=null,a.stencil=((e,t)=>{const n=he(e,t);return n.width===e&&n.height===t||(n.width=e,n.height=t,n.area=e*t,n.dirty=!1,r.bindRenderbuffer(r.RENDERBUFFER,n.resource),r.renderbufferStorage(r.RENDERBUFFER,r.STENCIL_INDEX8,e,t)),n})(e,n)),a.mask=!1,a.clipLevel=0,a},_e=Number.MAX_VALUE,we=-Number.MAX_VALUE;let Me=0;const Pe=e=>{Me=e},Se=[],Fe=()=>{var t;return Me in Se||(t=ye(e,e,!0),Se[Me]=t),Se[Me]},Te=[];let Be=null;const Oe=()=>(Be||(Be=(()=>{const t=me(e,e);return r.activeTexture(r.TEXTURE3),r.bindTexture(r.TEXTURE_2D,t.resource),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,r.LINEAR),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,r.NEAREST),r.texStorage2D(r.TEXTURE_2D,1,r.RGBA8,t.width,t.height),r.activeTexture(-1!==ge?ge:r.TEXTURE0),t})()),Be),Ae=[],Re=e=>(e in Ae||(Ae[e]=new Float32Array([_e,_e,we,we])),Ae[e]);let Ce=0;const Ee=e=>{Ce=e},Ue=()=>{Te.length=0,Pe(0);const e=Se;for(let t=0;t<e.length;t++)ce(e[t]);e.length=0},$e=(e,t,n,i=!0)=>{if(e.clearArraysInstanced(),e.$stackAttachmentObject.length)for(let t=0;t<e.$stackAttachmentObject.length;++t){const r=e.$stackAttachmentObject[t];r&&ce(r)}else e.$mainAttachmentObject&&ce(e.$mainAttachmentObject);i&&Ue(),re(null),ne&&(ie(!1),r.bindFramebuffer(r.FRAMEBUFFER,null)),e.$mainAttachmentObject=ye(t,n,!0),e.bind(e.$mainAttachmentObject)},Ge=(e,t,n=null,i=!1)=>{-1!==ge&&t===ge||(be(t),r.activeTexture(t));const a=xe[e];null!==a&&null!==n&&a.id===n.id||n===a||(xe[e]=n,r.bindTexture(r.TEXTURE_2D,n?n.resource:null),n&&n.smooth!==i&&(n.smooth=i,r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,i?r.LINEAR:r.NEAREST),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,i?r.LINEAR:r.NEAREST)))},ke=(e,t=!1)=>{Ge(2,r.TEXTURE2,null),Ge(1,r.TEXTURE1,null),Ge(0,r.TEXTURE0,e,t)},Le=()=>{const e=n.currentAttachmentObject;if(!e)return;const t=e.clipLevel;let i=0;for(let e=0;e<t;++e)i|=(1<<t-e)-1;r.stencilMask(255),r.stencilFunc(r.EQUAL,255&i,i),r.stencilOp(r.KEEP,r.KEEP,r.KEEP),r.colorMask(!0,!0,!0,!0),r.disable(r.SAMPLE_ALPHA_TO_COVERAGE),s()};let Ie=!1;const Ve=e=>{Ie=e},ze=()=>Ie,je=new Map,De=new Map,Ne=(e,t)=>{const n=te;if(n&&t.id===n.id)return;var i,a;(e=>{re(e),ne||(ie(!0),r.bindFramebuffer(r.FRAMEBUFFER,Z)),e.msaa?(r.bindRenderbuffer(r.RENDERBUFFER,e.color.resource),r.framebufferRenderbuffer(r.FRAMEBUFFER,r.COLOR_ATTACHMENT0,r.RENDERBUFFER,e.color.resource)):(ke(e.texture),r.framebufferTexture2D(r.FRAMEBUFFER,r.COLOR_ATTACHMENT0,r.TEXTURE_2D,e.texture.resource,0),Ge(0,r.TEXTURE0,null)),r.bindRenderbuffer(r.RENDERBUFFER,e.stencil.resource),r.framebufferRenderbuffer(r.FRAMEBUFFER,r.STENCIL_ATTACHMENT,r.RENDERBUFFER,e.stencil.resource)})(t),n&&n.width===t.width&&n.height===t.height||(i=t.width,a=t.height,P=i,S=a,r.viewport(0,0,t.width,t.height));const o=t.msaa?t.color:t.stencil;var u;o.dirty&&(o.dirty=!1,e.clearRect(0,0,t.width,t.height)),!(u=t.mask)&&ze()?(Ve(!1),c(),s()):u&&!ze()&&(Ve(!0),l(),Le())},We=e=>{if(!e.$stack.length)return;const t=e.$stack.pop();var r;e.$matrix[0]=t[0],e.$matrix[1]=t[1],e.$matrix[3]=t[3],e.$matrix[4]=t[4],e.$matrix[6]=t[6],e.$matrix[7]=t[7],r=t,x.push(r)},qe=(e,t,r,n,i,a,s,o,l,c,u,f,d)=>{const h=e.length-5;for(let p=3;p<h;p+=3){let h=17*r;e[p+2]?(t[h++]=e[p-3],t[h++]=e[p-2],t[h++]=0,t[h++]=0,t[h++]=c,t[h++]=u,t[h++]=f,t[h++]=d,t[h++]=n,t[h++]=i,t[h++]=0,t[h++]=a,t[h++]=s,t[h++]=0,t[h++]=o,t[h++]=l,t[h++]=0,t[h++]=e[p],t[h++]=e[p+1],t[h++]=.5,t[h++]=0,t[h++]=c,t[h++]=u,t[h++]=f,t[h++]=d,t[h++]=n,t[h++]=i,t[h++]=0,t[h++]=a,t[h++]=s,t[h++]=0,t[h++]=o,t[h++]=l,t[h++]=0,t[h++]=e[p+3],t[h++]=e[p+4],t[h++]=1,t[h++]=1,t[h++]=c,t[h++]=u,t[h++]=f,t[h++]=d,t[h++]=n,t[h++]=i,t[h++]=0,t[h++]=a,t[h++]=s,t[h++]=0,t[h++]=o,t[h++]=l,t[h++]=0):e[p+5]?(t[h++]=e[0],t[h++]=e[1],t[h++]=.5,t[h++]=.5,t[h++]=c,t[h++]=u,t[h++]=f,t[h++]=d,t[h++]=n,t[h++]=i,t[h++]=0,t[h++]=a,t[h++]=s,t[h++]=0,t[h++]=o,t[h++]=l,t[h++]=0,t[h++]=e[p],t[h++]=e[p+1],t[h++]=.5,t[h++]=.5,t[h++]=c,t[h++]=u,t[h++]=f,t[h++]=d,t[h++]=n,t[h++]=i,t[h++]=0,t[h++]=a,t[h++]=s,t[h++]=0,t[h++]=o,t[h++]=l,t[h++]=0,t[h++]=e[p+6],t[h++]=e[p+7],t[h++]=.5,t[h++]=.5,t[h++]=c,t[h++]=u,t[h++]=f,t[h++]=d,t[h++]=n,t[h++]=i,t[h++]=0,t[h++]=a,t[h++]=s,t[h++]=0,t[h++]=o,t[h++]=l,t[h++]=0):(t[h++]=e[0],t[h++]=e[1],t[h++]=.5,t[h++]=.5,t[h++]=c,t[h++]=u,t[h++]=f,t[h++]=d,t[h++]=n,t[h++]=i,t[h++]=0,t[h++]=a,t[h++]=s,t[h++]=0,t[h++]=o,t[h++]=l,t[h++]=0,t[h++]=e[p],t[h++]=e[p+1],t[h++]=.5,t[h++]=.5,t[h++]=c,t[h++]=u,t[h++]=f,t[h++]=d,t[h++]=n,t[h++]=i,t[h++]=0,t[h++]=a,t[h++]=s,t[h++]=0,t[h++]=o,t[h++]=l,t[h++]=0,t[h++]=e[p+3],t[h++]=e[p+4],t[h++]=.5,t[h++]=.5,t[h++]=c,t[h++]=u,t[h++]=f,t[h++]=d,t[h++]=n,t[h++]=i,t[h++]=0,t[h++]=a,t[h++]=s,t[h++]=0,t[h++]=o,t[h++]=l,t[h++]=0),r+=3}return r},Xe=e=>(e--,e|=e>>1,e|=e>>2,e|=e>>4,e|=e>>8,e|=e>>16,++e);let Ye=new Float32Array(128),Ke=0;const He=e=>{const t=e.length+Ke;if(t>Ye.length){const r=new Float32Array(Xe(t));r.set(Ye),r.set(e,Ke),Ye=r}else Ye.set(e,Ke);Ke+=e.length},Qe=[],Ze=[],Je=()=>{Ze.length=0,Ke=0,Qe.length=0};let et=new Float32Array(32);const tt=(e,t="fill")=>{const r="fill"===t?n.$fillStyle:n.$strokeStyle,i=r[0],a=r[1],s=r[2],o=r[3],l=n.$matrix,c=P,u=S,f=l[0]/c,d=l[3]/c,h=l[6]/c,p=l[1]/u,m=l[4]/u,g=l[7]/u;let b=0;for(let t=0;t<e.length;++t)b+=51*(e[t].length/3-2);const x=(v=b,et.length<v&&(et=new Float32Array(Xe(v))),et);var v;let y=0;for(let t=0;t<e.length;++t)y=qe(e[t],x,y,f,p,d,m,h,g,i,a,s,o);return{buffer:x.subarray(0,b),indexCount:y}},rt=[],nt=(e,t,r)=>{const n={x:t.x-e.x,y:t.y-e.y},i=((e,t,r)=>{const n=Math.sqrt(e*e+t*t);return{x:-t/n*r,y:e/n*r}})(n.x,n.y,r),a={x:e.x+i.x,y:e.y+i.y},s={x:t.x+i.x,y:t.y+i.y},o={x:e.x-i.x,y:e.y-i.y},l={x:t.x-i.x,y:t.y-i.y};return[a.x,a.y,!1,s.x,s.y,!1,l.x,l.y,!1,o.x,o.y,!1,a.x,a.y,!1]},it=(e,t,r)=>({x:e.x+(t.x-e.x)*r,y:e.y+(t.y-e.y)*r}),at=(e,t,r,n=.5)=>{const i=it(e,t,n),a=it(t,r,n),s=it(i,a,n);return[[e,i,s],[s,a,r]]},st=(e,t,r,n)=>({x:(1-e)**2*t.x+2*(1-e)*e*r.x+e**2*n.x,y:(1-e)**2*t.y+2*(1-e)*e*r.y+e**2*n.y}),ot=(e,t,r,n)=>({x:2*(1-e)*(r.x-t.x)+2*e*(n.x-r.x),y:2*(1-e)*(r.y-t.y)+2*e*(n.y-r.y)}),lt=e=>{const t=Math.sqrt(e.x*e.x+e.y*e.y);return 0===t?{x:0,y:0}:{x:e.x/t,y:e.y/t}},ct=(e,t,r,n)=>{const i=[0,.5,1],a=[];for(let s=0;s<i.length;++s){const o=i[s],l=st(o,e,t,r),c=ot(o,e,t,r),u=lt({x:-c.y,y:c.x});a.push({x:l.x+u.x*n,y:l.y+u.y*n})}return a},ut=(e,t,r,n)=>{const i=((e,t,r,n=4)=>{let i=[[e,t,r]];for(let e=0;e<n;++e){const e=[];for(let t=0;t<i.length;++t){const r=i[t];if(!r)continue;const n=at(r[0],r[1],r[2],.5);e.push(n[0],n[1])}i=e}return i})(e,t,r,5),a=[],s=[];for(let e=0;e<i.length;++e){const[t,r,o]=i[e];a.push(ct(t,r,o,+n)),s.push(ct(t,r,o,-n))}const o=a[0][0],l=[o.x,o.y,!1];for(let e=0;e<a.length;++e){const t=a[e];l.push(t[1].x,t[1].y,!0,t[2].x,t[2].y,!1)}const c=[...s].reverse();for(let e=0;e<c.length;++e){const[t,r,n]=c[e];c[e]=[n,r,t]}const u=c[0][0];l.push(u.x,u.y,!1);for(let e=0;e<c.length;++e){const t=c[e];l.push(t[1].x,t[1].y,!0,t[2].x,t[2].y,!1)}return l},ft=(e,t,r,n)=>{const i=[];for(let a=0;a<n.length;a+=3){if(n[a+2])continue;const s=n[a],o=n[a+1],l=Math.sqrt(Math.pow(s-e,2)+Math.pow(o-t,2));Math.abs(l-r)>1e-4||i.push(s,o)}return i},dt=new OffscreenCanvas(1,1).getContext("2d"),ht=(e,t)=>{dt.beginPath(),dt.moveTo(t[0],t[1]);for(let e=3;e<t.length;e+=3)t[e+2]?(dt.quadraticCurveTo(t[e],t[e+1],t[e+3],t[e+4]),e+=3):dt.lineTo(t[e],t[e+1]);dt.closePath();for(let t=0;t<e.length;t+=2){const r=e[t],n=e[t+1];if(!dt.isPointInPath(r,n))return[r,n]}return null},pt=(e,t,r,n,i=!1)=>{const a=i?0:n.length-1,s=i?n.length-1:n.length-2,o=n[a].length>15,l=n[s].length>15;if(o&&l)return;const c=ft(e,t,r,n[a]),u=ft(e,t,r,n[s]),f=ht(c,n[s]);if(!f)return;const d=ht(u,n[a]);if(!d)return;const h=Math.atan2(f[1]-t,f[0]-e);let p=Math.atan2(d[1]-t,d[0]-e)-h;p>Math.PI?p-=2*Math.PI:p<-Math.PI&&(p+=2*Math.PI);const m=Math.abs(p);if(m<.1||m>Math.PI-.1)return;const g=p/8,b=[e,t,!1];for(let n=0;n<=8;n++){const i=h+n*g,a=e+r*Math.cos(i),s=t+r*Math.sin(i);b.push(a,s,!1)}n.splice(-1,0,b)},mt=(e,t,r,n,i=!1)=>{const a=i?0:n.length-1,s=i?n.length-1:n.length-2,o=n[a].length>15,l=n[s].length>15;if(o&&l)return;const c=ft(e,t,r,n[a]),u=ft(e,t,r,n[s]);if(c[0]===u[0]&&c[1]===u[1]||c[0]===u[2]&&c[1]===u[3])return;const f=ht(c,n[s]);if(!f)return;const d=ht(u,n[a]);d&&n.splice(-1,0,[e,t,!1,f[0],f[1],!1,d[0],d[1],!1,e,t,!1])},gt=(e,t,r,n,i,a=!1)=>{const s=a?0:i.length-1,o=a?i.length-1:i.length-2,l=i[s].length>15,c=i[o].length>15;if(l&&c)return;const u=ft(e.x,e.y,n,i[s]),f=ft(e.x,e.y,n,i[o]);if(u[0]===f[0]&&u[1]===f[1]||u[0]===f[2]&&u[1]===f[3])return;const d=ht(u,i[o]);if(!d)return;const h=ht(f,i[s]);if(!h)return;const p=t.x-e.x,m=t.y-e.y,g=Math.hypot(p,m),b={x:p/g,y:m/g},x=r.x-e.x,v=r.y-e.y,y=Math.hypot(x,v),_={x:x/y,y:v/y},w=b.x,M=b.y,P=_.x,S=_.y,F=w*S-M*P;if(0===F)return void i.splice(-1,0,[e.x,e.y,!1,d[0],d[1],!1,h[0],h[1],!1]);const T=((h[0]-d[0])*S-(h[1]-d[1])*P)/F,B=d[0]+T*w,O=d[1]+T*M;i.splice(-1,0,[e.x,e.y,!1,d[0],d[1],!1,B,O,!1,e.x,e.y,!1,h[0],h[1],!1,B,O,!1])},bt={x:0,y:0},xt={x:0,y:0},vt={x:0,y:0},yt={x:0,y:0},_t=(e,t)=>{const r=bt;r.x=e[0],r.y=e[1];const i=xt;i.x=0,i.y=0;const a=vt;a.x=0,a.y=0;const s=yt;s.x=0,s.y=0;const o=[];for(let l=3;l<e.length;l+=3){const c=e[l],u=e[l+1];if(e[l+2])i.x=c,i.y=u;else{if(a.x=c,a.y=u,e[l-1]?o.push(ut(r,i,a,t)):o.push(nt(r,a,t)),o.length>1)switch(n.joints){case 0:mt(r.x,r.y,t,o);break;case 1:s.x=e[l-6],s.y=e[l-5],gt(r,a,s,t,o);break;case 2:pt(r.x,r.y,t,o)}r.x=a.x,r.y=a.y}}const l=e[0],c=e[1],u=e[e.length-3],f=e[e.length-2],d=1e-4;if(Math.abs(l-u)<d&&Math.abs(c-f)<d&&o.length>1)switch(n.joints){case 0:mt(l,c,t,o,!0);break;case 1:r.x=l,r.y=c,a.x=e[3],a.y=e[4],s.x=e[e.length-6],s.y=e[e.length-5],gt(r,a,s,t,o,!0);break;case 2:pt(l,c,t,o,!0)}else switch(n.caps){case 1:((e,t,r)=>{for(let n=0;n<2;++n){let i=0,a=0,s=0,o=0;0===n?(i=e[0],a=e[1],s=e[3],o=e[4]):(i=e[e.length-3],a=e[e.length-2],s=e[e.length-6],o=e[e.length-5]);const l=s-i,c=o-a,u=Math.atan2(c,l),f=u+Math.PI/2,d=u-Math.PI/2,h=16,p=(d-f)/h,m=[];for(let e=0;e<=h;e++){const r=d+p*e,n=i+t*Math.cos(r),s=a+t*Math.sin(r);m.push(n,s,!1)}0===n?r.unshift(m):r.push(m)}})(e,t,o);break;case 2:((e,t,r)=>{for(let n=0;n<2;++n){let i=0,a=0,s=0,o=0;0===n?(i=e[0],a=e[1],s=e[3],o=e[4]):(i=e[e.length-3],a=e[e.length-2],s=e[e.length-6],o=e[e.length-5]);const l=-(s-i),c=-(o-a),u=Math.sqrt(l*l+c*c);if(0===u)continue;const f=l/u,d=c/u,h=i+t*f,p=a+t*d,m=-d,g=[h+t*f+t*m,p+t*d+t*f,!1,h+t*f-t*m,p+t*d-t*f,!1,h-t*f-t*m,p-t*d-t*f,!1,h+t*f+t*m,p+t*d+t*f,!1,h-t*f-t*m,p-t*d-t*f,!1,h-t*f+t*m,p-t*d+t*f,!1];0===n?r.unshift(g):r.push(g)}})(e,t,o)}return o},wt=e=>{const t=n.thickness/2,r=d();for(let n=0;n<e.length;++n){const i=_t(e[n],t);for(let e=0;e<i.length;++e)r.push(i[e])}const i=tt(r,"stroke");return r.length=0,h(r),i},Mt=new Map,Pt=()=>{Mt.clear()},St=()=>({id:"function"==typeof crypto?.randomUUID?crypto.randomUUID():"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g,e=>{const t=16*Math.random()|0;return("x"===e?t:3&t|8).toString(16)}),resource:r.createVertexArray(),vertexBuffer:r.createBuffer(),vertexLength:0});let Ft;const Tt=e=>{Ft&&Ft.id===e.id||(Ft=e,r.bindVertexArray(e.resource))},Bt=[],Ot=new Float32Array([0,0,0,1,1,0,1,1]);let At;let Rt;let Ct;const Et=()=>(Ct||(Ct=(()=>{const e=St();Tt(e),r.bindBuffer(r.ARRAY_BUFFER,e.vertexBuffer);const t=new Float32Array([0,0,1,0,1,1,0,0,1,1,0,1]);return r.bufferData(r.ARRAY_BUFFER,t,r.STATIC_DRAW),r.enableVertexAttribArray(0),r.vertexAttribPointer(0,2,r.FLOAT,!1,0,0),e})()),Ct),Ut=()=>{const e=(()=>{if(Bt.length)return Bt.pop();const e=St();return Tt(e),r.bindBuffer(r.ARRAY_BUFFER,e.vertexBuffer),r.enableVertexAttribArray(0),r.enableVertexAttribArray(1),r.enableVertexAttribArray(2),r.enableVertexAttribArray(3),r.enableVertexAttribArray(4),r.enableVertexAttribArray(5),r.vertexAttribPointer(0,2,r.FLOAT,!1,68,0),r.vertexAttribPointer(1,2,r.FLOAT,!1,68,8),r.vertexAttribPointer(2,4,r.FLOAT,!1,68,16),r.vertexAttribPointer(3,3,r.FLOAT,!1,68,32),r.vertexAttribPointer(4,3,r.FLOAT,!1,68,44),r.vertexAttribPointer(5,3,r.FLOAT,!1,68,56),e})();Tt(e);const t=Ye,n=Ke;return r.bindBuffer(r.ARRAY_BUFFER,e.vertexBuffer),e.vertexLength<t.length&&(e.vertexLength=p(t.length),r.bufferData(r.ARRAY_BUFFER,4*e.vertexLength,r.STREAM_DRAW)),r.bufferSubData(r.ARRAY_BUFFER,0,t.subarray(0,n)),e},$t=e=>{Bt.indexOf(e)>-1||Bt.push(e)};let Gt=0;let kt=-1;class Lt{constructor(e,t,n=!1){Object.defineProperty(this,"_$programObject",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"_$uniformMap",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"highp",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"mediump",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"textures",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this._$programObject=((e,t)=>{const n=r.createProgram(),i=r.createShader(r.VERTEX_SHADER);r.shaderSource(i,e),r.compileShader(i);const a=r.createShader(r.FRAGMENT_SHADER);return r.shaderSource(a,t),r.compileShader(a),r.attachShader(n,i),r.attachShader(n,a),r.linkProgram(n),r.detachShader(n,i),r.detachShader(n,a),r.deleteShader(i),r.deleteShader(a),{id:Gt++,resource:n}})(e,t),this._$uniformMap=new Map,((e,t,n=!1)=>{const i=r.getProgramParameter(e,r.ACTIVE_UNIFORMS);for(let a=0;a<i;++a){const i=r.getActiveUniform(e,a),s=i.name.endsWith("[0]")?i.name.slice(0,-3):i.name,o=r.getUniformLocation(e,s);if(i.type===r.SAMPLER_2D&&1===i.size&&!n)continue;const l={};switch(i.type){case r.FLOAT_VEC4:l.method=r.uniform4fv.bind(r,o),l.array=new Float32Array(4*i.size),l.assign=-1;break;case r.INT_VEC4:l.method=r.uniform4iv.bind(r,o),l.array=new Int32Array(4*i.size),l.assign=-1;break;case r.SAMPLER_2D:l.method=n?r.uniform1i.bind(r,o,3):r.uniform1iv.bind(r,o),l.array=new Int32Array(i.size),l.assign=1;break;case r.FLOAT:case r.FLOAT_VEC2:case r.FLOAT_VEC3:case r.FLOAT_MAT2:case r.FLOAT_MAT3:case r.FLOAT_MAT4:case r.INT:case r.INT_VEC2:case r.INT_VEC3:default:throw new Error("Use gl.FLOAT_VEC4 or gl.INT_VEC4 instead")}t.set(s,l)}})(this._$programObject.resource,this._$uniformMap,n);const i=new Float32Array(0);this.highp=this._$uniformMap.get("u_highp")?.array??i,this.mediump=this._$uniformMap.get("u_mediump")?.array??i,this.textures=this._$uniformMap.get("u_textures")?.array??i}useProgram(){var e;e=this._$programObject,kt!==e.id&&(kt=e.id,r.useProgram(e.resource))}bindUniform(){(e=>{for(const t of e.values())void 0!==t.method&&void 0!==t.assign&&(t.assign<0?t.method(t.array):t.assign>0&&(t.assign--,t.method(t.array)))})(this._$uniformMap)}}const It=new Map,Vt=(e,t,r,n)=>{const i=r?"layout (location = 1) in vec2 a_bezier;":"",a=r?"out vec2 v_bezier;":t?"out vec2 v_uv;":"",s=r?"v_bezier = a_bezier;":t?"\n    mat3 uv_matrix = mat3(\n        u_highp[0].xyz,\n        u_highp[1].xyz,\n        u_highp[2].xyz\n    );\n    mat3 inverse_matrix = mat3(\n        u_highp[3].xyz,\n        u_highp[4].xyz,\n        vec3(u_highp[2].w, u_highp[3].w, u_highp[4].w)\n    );\n    v_uv = (inverse_matrix * uv_matrix * vec3(a_vertex, 1.0)).xy;":"",o=n?(e=>`\nvec2 applyMatrix(in vec2 vertex) {\n    mat3 parent_matrix = mat3(\n        u_highp[${e}].xyz,\n        u_highp[${e+1}].xyz,\n        u_highp[${e+2}].xyz\n    );\n    mat3 ancestor_matrix = mat3(\n        u_highp[${e+3}].xyz,\n        u_highp[${e+4}].xyz,\n        u_highp[${e+5}].xyz\n    );\n\n    vec2 parent_offset = vec2(u_highp[${e+2}].w, u_highp[${e+3}].w);\n    vec2 parent_size   = vec2(u_highp[${e+4}].w, u_highp[${e+5}].w);\n    vec4 grid_min = u_highp[${e+6}];\n    vec4 grid_max = u_highp[${e+7}];\n\n    vec2 position = (parent_matrix * vec3(vertex, 1.0)).xy;\n    position = (position - parent_offset) / parent_size;\n\n    vec4 ga = grid_min;\n    vec4 gb = grid_max  - grid_min;\n    vec4 gc = vec4(1.0) - grid_max;\n\n    vec2 pa = position;\n    vec2 pb = position - grid_min.st;\n    vec2 pc = position - grid_max.st;\n\n    position = (ga.pq / ga.st) * min(pa, ga.st)\n                + (gb.pq / gb.st) * clamp(pb, vec2(0.0), gb.st)\n                + (gc.pq / gc.st) * max(vec2(0.0), pc);\n\n    position = position * parent_size + parent_offset;\n    position = (ancestor_matrix * vec3(position, 1.0)).xy;\n\n    position = position + vec2(u_highp[${e+8}].x, u_highp[${e+8}].y);\n    return position / vec2(u_highp[0].w, u_highp[1].w);\n}`)(t?5:0):"\nvec2 applyMatrix(in vec2 vertex) {\n    mat3 matrix = mat3(a_matrix0, a_matrix1, a_matrix2);\n    return (matrix * vec3(vertex, 1.0)).xy;\n}";return`#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\n${i}\n${r?"":"layout (location = 2) in vec4 a_color;"}\n${n?"":"layout (location = 3) in vec3 a_matrix0;\nlayout (location = 4) in vec3 a_matrix1;\nlayout (location = 5) in vec3 a_matrix2;"}\n\n${e>1?`uniform vec4 u_highp[${e}];`:""}\n${a}\n${r?"":"out vec4 v_color;"}\n${o}\n\nvoid main() {\n    ${r?"":"v_color = a_color;"}\n    ${s}\n    vec2 pos = applyMatrix(a_vertex);\n    pos = pos * 2.0 - 1.0;\n    gl_Position = vec4(pos.x, -pos.y, 0.0, 1.0);\n}`},zt=e=>{const t="m"+(e?"y":"n");if(It.has(t))return It.get(t);const r=new Lt(Vt(e?9:0,!1,!0,e),"#version 300 es\nprecision mediump float;\n\nin vec2 v_bezier;\nout vec4 o_color;\n\nvoid main() {\n    float f_val = v_bezier.x * v_bezier.x - v_bezier.y;\n\n    float dx = dFdx(f_val);\n    float dy = dFdy(f_val);\n\n    float dist = f_val / length(vec2(dx, dy));\n    float alpha = smoothstep(0.5, -0.5, dist);\n\n    if (alpha > 0.001) {\n        o_color = vec4(min(alpha, 1.0));\n    } else {\n        discard;\n    }\n}");return It.set(t,r),r},jt=(e,t)=>{const r=e.highp;r[0]=t[0],r[1]=t[1],r[2]=0,r[4]=t[2],r[5]=t[3],r[6]=0,r[8]=t[4],r[9]=t[5],r[10]=1,r[12]=t[6],r[13]=t[7],r[14]=0,r[16]=t[8],r[17]=t[9],r[18]=0,r[20]=t[10],r[21]=t[11],r[22]=1,r[3]=P,r[7]=S,r[11]=t[12],r[15]=t[13],r[19]=t[14],r[23]=t[15],r[24]=t[16],r[25]=t[17],r[26]=t[18],r[27]=t[19],r[28]=t[20],r[29]=t[21],r[30]=t[22],r[31]=t[23],r[32]=t[24],r[33]=t[25]};let Dt="normal";const Nt=e=>{Dt=e};let Wt=600;const qt=e=>{Wt=e},Xt=()=>{613!==Wt&&(qt(613),r.blendFunc(r.ONE,r.ONE_MINUS_SRC_ALPHA))},Yt=(e,t,n,i)=>{e.useProgram(),e.bindUniform(),Xt(),Tt(t),r.drawArrays(r.TRIANGLES,n,i)},Kt=()=>{const e="rmnn";if(It.has(e))return It.get(e);const t=new Lt("#version 300 es\nlayout (location = 0) in vec2 a_vertex;\nvoid main() {\n    vec2 pos = a_vertex * 2.0 - 1.0;\n    gl_Position = vec4(pos.x, -pos.y, 0.0, 1.0);\n}","#version 300 es\nprecision mediump float;\nout vec4 o_color;\nvoid main() {\n    o_color = vec4(1.0);\n}");return It.set(e,t),t},Ht=()=>{const e=n.currentAttachmentObject;if(!e)return;const t=1<<e.clipLevel-1;r.stencilMask(~t-1),r.stencilFunc(r.LEQUAL,t,255),r.stencilOp(r.ZERO,r.REPLACE,r.REPLACE),Yt(Kt(),Et(),0,6),r.stencilMask(1<<e.clipLevel),r.stencilFunc(r.ALWAYS,0,255),r.stencilOp(r.REPLACE,r.REPLACE,r.REPLACE),Yt(Kt(),Et(),0,6),r.stencilMask(255),r.stencilOp(r.ZERO,r.INVERT,r.INVERT)},Qt=[];class Zt{constructor(e,t,r,n,i){Object.defineProperty(this,"index",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"x",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"y",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"w",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"h",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"left",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"right",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"used",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.index=e,this.x=t,this.y=r,this.w=n,this.h=i,this.left=null,this.right=null,this.used=!1}insert(e,t){return((e,t,r)=>{if(e.used){const n=e.left?.insert(t,r);return n||e.right?.insert(t,r)||null}if(t>e.w||r>e.h)return null;if(t===e.w&&r===e.h)return e.used=!0,e;const n=t+1,i=r+1,a=e.w-n,s=e.h-i;return a>s?(e.left=e.create(e.index,e.x,e.y,t,e.h),e.right=e.create(e.index,e.x+n,e.y,a,e.h)):(e.left=e.create(e.index,e.x,e.y,e.w,r),e.right=e.create(e.index,e.x,e.y+i,e.w,s)),e.used=!0,e.left.insert(t,r)})(this,e,t)}dispose(e,t,r,n){return((e,t,r,n,i)=>e.left?.dispose(t,r,n,i)?(e.left.used||e.right?.used||(e.left&&e.left.release(),e.right&&e.right.release(),e.left=e.right=null,e.used=!1),!0):e.right?.dispose(t,r,n,i)?(e.right.used||e.left?.used||(e.left&&e.left.release(),e.right&&e.right.release(),e.left=e.right=null,e.used=!1),!0):t===e.x&&r===e.y&&n===e.w&&i===e.h&&(e.used=!1,!0))(this,e,t,r,n)}create(e,t,r,n,i){const a=Qt.length?Qt.pop():new Zt(e,0,0,0,0);return a.index=e,a.x=t,a.y=r,a.w=n,a.h=i,a.left=null,a.right=null,a.used=!1,a}release(){this.left&&(this.left.release(),this.left=null),this.right&&(this.right.release(),this.right=null),this.used=!1,Qt.push(this)}}class Jt{constructor(e,t,r){Object.defineProperty(this,"_$root",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this._$root=new Zt(e,0,0,t,r)}insert(e,t){return this._$root.insert(e,t)}dispose(e,t,r,n){return this._$root.dispose(e,t,r,n)}}const er=(t,r)=>{const n=Me;Te[n]||(Te[n]=new Jt(n,e,e));const i=Te[n].insert(t,r);if(i)return i;for(let e=0;e<10;e++){if(n===e)continue;Pe(e);const i=Te[e];if(!i)return er(t,r);const a=i.insert(t,r);if(a)return a}return er(t,r)},tr=e=>`\n    vec4 mul = u_mediump[${e}];\n    vec4 add = u_mediump[${e+1}];\n\n    if (mul.x != 1.0 || mul.y != 1.0 || mul.z != 1.0 || mul.w != 1.0\n        || add.x != 0.0 || add.y != 0.0 || add.z != 0.0\n    ) {\n        src.rgb /= max(0.0001, src.a);\n        src = clamp(src * mul + add, 0.0, 1.0);\n        src.rgb *= src.a;\n    }\n`,rr=e=>`#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_texture;\n${e?"uniform vec4 u_mediump[2];":""}\n\nin vec2 v_coord;\nout vec4 o_color;\n\nvoid main() {\n    vec4 src = texture(u_texture, v_coord);\n    ${e?tr(0):""}\n    o_color = src;\n}`;const nr=new class{constructor(){Object.defineProperty(this,"buffer",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"offset",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.buffer=new Float32Array(256),this.offset=0}push(...e){this.buffer.length<this.offset+e.length&&this.resize(e.length);for(let t=0;t<e.length;t++)this.buffer[this.offset++]=e[t]}pushDisplayObjectBuffer(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g,b,x,v,y,_){this.buffer.length<this.offset+22&&this.resize(22),this.buffer[this.offset++]=e,this.buffer[this.offset++]=t,this.buffer[this.offset++]=r,this.buffer[this.offset++]=n,this.buffer[this.offset++]=i,this.buffer[this.offset++]=a,this.buffer[this.offset++]=s,this.buffer[this.offset++]=o,this.buffer[this.offset++]=l,this.buffer[this.offset++]=c,this.buffer[this.offset++]=u,this.buffer[this.offset++]=f,this.buffer[this.offset++]=d,this.buffer[this.offset++]=h,this.buffer[this.offset++]=p,this.buffer[this.offset++]=m,this.buffer[this.offset++]=g,this.buffer[this.offset++]=b,this.buffer[this.offset++]=x,this.buffer[this.offset++]=v,this.buffer[this.offset++]=y,this.buffer[this.offset++]=_}pushInstanceBuffer(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g,b,x,v,y,_,w,M){this.buffer.length<this.offset+24&&this.resize(24),this.buffer[this.offset++]=e,this.buffer[this.offset++]=t,this.buffer[this.offset++]=r,this.buffer[this.offset++]=n,this.buffer[this.offset++]=i,this.buffer[this.offset++]=a,this.buffer[this.offset++]=s,this.buffer[this.offset++]=o,this.buffer[this.offset++]=l,this.buffer[this.offset++]=c,this.buffer[this.offset++]=u,this.buffer[this.offset++]=f,this.buffer[this.offset++]=d,this.buffer[this.offset++]=h,this.buffer[this.offset++]=p,this.buffer[this.offset++]=m,this.buffer[this.offset++]=g,this.buffer[this.offset++]=b,this.buffer[this.offset++]=x,this.buffer[this.offset++]=v,this.buffer[this.offset++]=y,this.buffer[this.offset++]=_,this.buffer[this.offset++]=w,this.buffer[this.offset++]=M}pushShapeBuffer(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g,b,x,v,y,_,w,M,P,S,F,T,B,O,A,R){this.buffer.length<this.offset+32&&this.resize(32),this.buffer[this.offset++]=e,this.buffer[this.offset++]=t,this.buffer[this.offset++]=r,this.buffer[this.offset++]=n,this.buffer[this.offset++]=i,this.buffer[this.offset++]=a,this.buffer[this.offset++]=s,this.buffer[this.offset++]=o,this.buffer[this.offset++]=l,this.buffer[this.offset++]=c,this.buffer[this.offset++]=u,this.buffer[this.offset++]=f,this.buffer[this.offset++]=d,this.buffer[this.offset++]=h,this.buffer[this.offset++]=p,this.buffer[this.offset++]=m,this.buffer[this.offset++]=g,this.buffer[this.offset++]=b,this.buffer[this.offset++]=x,this.buffer[this.offset++]=v,this.buffer[this.offset++]=y,this.buffer[this.offset++]=_,this.buffer[this.offset++]=w,this.buffer[this.offset++]=M,this.buffer[this.offset++]=P,this.buffer[this.offset++]=S,this.buffer[this.offset++]=F,this.buffer[this.offset++]=T,this.buffer[this.offset++]=B,this.buffer[this.offset++]=O,this.buffer[this.offset++]=A,this.buffer[this.offset++]=R}pushTextFieldBuffer(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g,b,x,v,y,_,w,M,P,S,F,T,B,O){this.buffer.length<this.offset+30&&this.resize(30),this.buffer[this.offset++]=e,this.buffer[this.offset++]=t,this.buffer[this.offset++]=r,this.buffer[this.offset++]=n,this.buffer[this.offset++]=i,this.buffer[this.offset++]=a,this.buffer[this.offset++]=s,this.buffer[this.offset++]=o,this.buffer[this.offset++]=l,this.buffer[this.offset++]=c,this.buffer[this.offset++]=u,this.buffer[this.offset++]=f,this.buffer[this.offset++]=d,this.buffer[this.offset++]=h,this.buffer[this.offset++]=p,this.buffer[this.offset++]=m,this.buffer[this.offset++]=g,this.buffer[this.offset++]=b,this.buffer[this.offset++]=x,this.buffer[this.offset++]=v,this.buffer[this.offset++]=y,this.buffer[this.offset++]=_,this.buffer[this.offset++]=w,this.buffer[this.offset++]=M,this.buffer[this.offset++]=P,this.buffer[this.offset++]=S,this.buffer[this.offset++]=F,this.buffer[this.offset++]=T,this.buffer[this.offset++]=B,this.buffer[this.offset++]=O}pushVideoBuffer(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g,b,x,v,y,_,w,M,P,S,F){this.buffer.length<this.offset+27&&this.resize(27),this.buffer[this.offset++]=e,this.buffer[this.offset++]=t,this.buffer[this.offset++]=r,this.buffer[this.offset++]=n,this.buffer[this.offset++]=i,this.buffer[this.offset++]=a,this.buffer[this.offset++]=s,this.buffer[this.offset++]=o,this.buffer[this.offset++]=l,this.buffer[this.offset++]=c,this.buffer[this.offset++]=u,this.buffer[this.offset++]=f,this.buffer[this.offset++]=d,this.buffer[this.offset++]=h,this.buffer[this.offset++]=p,this.buffer[this.offset++]=m,this.buffer[this.offset++]=g,this.buffer[this.offset++]=b,this.buffer[this.offset++]=x,this.buffer[this.offset++]=v,this.buffer[this.offset++]=y,this.buffer[this.offset++]=_,this.buffer[this.offset++]=w,this.buffer[this.offset++]=M,this.buffer[this.offset++]=P,this.buffer[this.offset++]=S,this.buffer[this.offset++]=F}set(e){this.buffer.length<this.offset+e.length&&this.resize(e.length),this.buffer.set(e,this.offset),this.offset+=e.length}resize(e){const t=new Float32Array((r=this.offset+e,r--,r|=r>>1,r|=r>>2,r|=r>>4,r|=r>>8,r|=r>>16,++r));var r;this.buffer.length&&t.set(this.buffer),this.buffer=t}};let ir=class extends Lt{constructor(e,t,r=!0){super(e,t,r),Object.defineProperty(this,"count",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.count=0}clear(){this.count=nr.offset=0}};const ar=new Map,sr=()=>{if(ar.has("i"))return ar.get("i");const e=new ir("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\nlayout (location = 1) in vec4 a_rect;\nlayout (location = 2) in vec4 a_size;\nlayout (location = 3) in vec2 a_offset;\nlayout (location = 4) in vec4 a_matrix;\nlayout (location = 5) in vec4 a_mul;\nlayout (location = 6) in vec4 a_add;\n\nout vec2 v_coord;\nout vec4 v_mul;\nout vec4 v_add;\n\nvoid main() {\n    v_coord = a_vertex * a_rect.zw + a_rect.xy;\n    v_mul = a_mul;\n    v_add = a_add;\n\n    vec2 position = vec2(a_vertex.x, 1.0 - a_vertex.y);\n    position = position * a_size.xy;\n\n    mat3 matrix = mat3(\n        a_matrix.x, a_matrix.y, 0.0,\n        a_matrix.z, a_matrix.w, 0.0,\n        a_offset.x, a_offset.y, 1.0\n    );\n\n    position = (matrix * vec3(position, 1.0)).xy;\n    position /= a_size.zw;\n\n    position = position * 2.0 - 1.0;\n    gl_Position = vec4(position.x, -position.y, 0.0, 1.0);\n}","#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_texture;\n\nin vec4 v_mul;\nin vec4 v_add;\nin vec2 v_coord;\nout vec4 o_color;\n\nvoid main() {\n    vec4 src = texture(u_texture, v_coord);\n\n    if (v_mul.x != 1.0 || v_mul.y != 1.0 || v_mul.z != 1.0 || v_mul.w != 1.0\n        || v_add.x != 0.0 || v_add.y != 0.0 || v_add.z != 0.0\n    ) {\n        src.rgb /= max(0.0001, src.a);\n        src = clamp(src * v_mul + v_add, 0.0, 1.0);\n        src.rgb *= src.a;\n    }\n\n    o_color = src;\n}");return ar.set("i",e),e},or=(e,t)=>{const r=`i${e}y`;if(ar.has(r))return ar.get(r);const n=new Lt("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\n\nout vec2 v_coord;\n\nvoid main() {\n    v_coord = a_vertex;\n\n    vec2 position = a_vertex * 2.0 - 1.0;\n    gl_Position = vec4(position, 0.0, 1.0);\n}",(e=>{let t;switch(e){case"subtract":t="\nvec4 blend (in vec4 src, in vec4 dst) {\n    if (src.a == 0.0) { return dst; }\n    if (dst.a == 0.0) { return src; }\n\n    vec4 a = src - src * dst.a;\n    vec4 b = dst - dst * src.a;\n\n    src.rgb /= src.a;\n    dst.rgb /= dst.a;\n\n    vec4 c = vec4(dst.rgb - src.rgb, src.a * dst.a);\n    c.rgb *= c.a;\n\n    return a + b + c;\n}";break;case"multiply":t="\nvec4 blend (in vec4 src, in vec4 dst) {\n    vec4 a = src - src * dst.a;\n    vec4 b = dst - dst * src.a;\n    vec4 c = src * dst;\n\n    return a + b + c;\n}";break;case"lighten":t="\nvec4 blend (in vec4 src, in vec4 dst) {\n    if (src.a == 0.0) { return dst; }\n    if (dst.a == 0.0) { return src; }\n\n    vec4 a = src - src * dst.a;\n    vec4 b = dst - dst * src.a;\n\n    src.rgb /= src.a;\n    dst.rgb /= dst.a;\n\n    vec4 c = vec4(mix(src.rgb, dst.rgb, step(src.rgb, dst.rgb)), src.a * dst.a);\n    c.rgb *= c.a;\n\n    return a + b + c;\n}";break;case"darken":t="\nvec4 blend (in vec4 src, in vec4 dst) {\n    if (src.a == 0.0) { return dst; }\n    if (dst.a == 0.0) { return src; }\n\n    vec4 a = src - src * dst.a;\n    vec4 b = dst - dst * src.a;\n\n    src.rgb /= src.a;\n    dst.rgb /= dst.a;\n\n    vec4 c = vec4(mix(src.rgb, dst.rgb, step(dst.rgb, src.rgb)), src.a * dst.a);\n    c.rgb *= c.a;\n\n    return a + b + c;\n}";break;case"overlay":t="\nvec4 blend (in vec4 src, in vec4 dst) {\n    if (src.a == 0.0) { return dst; }\n    if (dst.a == 0.0) { return src; }\n\n    vec4 a = src - src * dst.a;\n    vec4 b = dst - dst * src.a;\n\n    src.rgb /= src.a;\n    dst.rgb /= dst.a;\n\n    vec4 mul = src * dst;\n    vec3 c1 = 2.0 * mul.rgb;\n    vec3 c2 = 2.0 * (src.rgb + dst.rgb - mul.rgb) - 1.0;\n    vec4 c = vec4(mix(c1, c2, step(vec3(0.5), dst.rgb)), mul.a);\n    c.rgb *= c.a;\n\n    return a + b + c;\n}";break;case"hardlight":t="\nvec4 blend (in vec4 src, in vec4 dst) {\n    if (src.a == 0.0) { return dst; }\n    if (dst.a == 0.0) { return src; }\n\n    vec4 a = src - src * dst.a;\n    vec4 b = dst - dst * src.a;\n\n    src.rgb /= src.a;\n    dst.rgb /= dst.a;\n\n    vec4 mul = src * dst;\n    vec3 c1 = 2.0 * mul.rgb;\n    vec3 c2 = 2.0 * (src.rgb + dst.rgb - mul.rgb) - 1.0;\n    vec4 c = vec4(mix(c1, c2, step(vec3(0.5), src.rgb)), mul.a);\n    c.rgb *= c.a;\n\n    return a + b + c;\n}";break;case"difference":t="\nvec4 blend (in vec4 src, in vec4 dst) {\n    if (src.a == 0.0) { return dst; }\n    if (dst.a == 0.0) { return src; }\n\n    vec4 a = src - src * dst.a;\n    vec4 b = dst - dst * src.a;\n\n    src.rgb /= src.a;\n    dst.rgb /= dst.a;\n\n    vec4 c = vec4(abs(src.rgb - dst.rgb), src.a * dst.a);\n    c.rgb *= c.a;\n\n    return a + b + c;\n}";break;case"invert":t="\nvec4 blend (in vec4 src, in vec4 dst) {\n    if (src.a == 0.0) { return dst; }\n    if (dst.a == 0.0) { return src; }\n\n    vec4 b = dst - dst * src.a;\n    vec4 c = vec4(src.a - dst.rgb * src.a, src.a);\n\n    return b + c;\n}";break;default:t="\nvec4 blend (in vec4 src, in vec4 dst) {\n    return src + dst - dst * src.a;\n}"}return`#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_textures[2];\nuniform vec4 u_mediump[2];\n\nin vec2 v_coord;\nout vec4 o_color;\n\n${t}\n\nvoid main() {\n    vec4 dst = texture(u_textures[0], v_coord);\n    vec4 src = texture(u_textures[1], v_coord);\n    ${tr(0)}\n    o_color = blend(src, dst);\n}`})(e));return ar.set(r,n),n},lr=()=>{if(!n.newDrawState)return;const e=n.currentAttachmentObject,t=n.atlasAttachmentObject;n.bind(t),r.bindFramebuffer(r.DRAW_FRAMEBUFFER,ee),ie(!1);const i=Re(Me);a(),r.scissor(i[0],i[1],i[2]-i[0],i[3]-i[1]),r.blitFramebuffer(0,0,t.width,t.height,0,0,t.width,t.height,r.COLOR_BUFFER_BIT,r.NEAREST),s(),e&&n.bind(e),n.newDrawState=!1},cr=e=>{const t=Me;Pe(e.index),lr(),r.bindFramebuffer(r.FRAMEBUFFER,ae);const n=Oe();r.framebufferTexture2D(r.FRAMEBUFFER,r.COLOR_ATTACHMENT0,r.TEXTURE_2D,n.resource,0),r.bindFramebuffer(r.FRAMEBUFFER,se);const i=ve(e.w,e.h);return r.framebufferTexture2D(r.FRAMEBUFFER,r.COLOR_ATTACHMENT0,r.TEXTURE_2D,i.resource,0),r.bindFramebuffer(r.FRAMEBUFFER,null),r.bindFramebuffer(r.READ_FRAMEBUFFER,ae),r.bindFramebuffer(r.DRAW_FRAMEBUFFER,se),r.blitFramebuffer(e.x,e.y,e.x+e.w,e.y+e.h,0,0,e.w,e.h,r.COLOR_BUFFER_BIT,r.NEAREST),Pe(t),r.bindFramebuffer(r.READ_FRAMEBUFFER,Z),r.bindFramebuffer(r.FRAMEBUFFER,Z),i},ur=(e,t,n=!1)=>{Ge(2,r.TEXTURE2,null,n),Ge(1,r.TEXTURE1,t,n),Ge(0,r.TEXTURE0,e,n)},fr=()=>{if(ar.has("p"))return ar.get("p");const e=new Lt("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\nuniform vec4 u_highp[2];\n\nout vec2 v_coord;\n\nvoid main() {\n    v_coord = a_vertex;\n\n    vec2 offset   = u_highp[0].xy;\n    vec2 size     = u_highp[0].zw;\n    vec2 viewport = vec2(u_highp[1].x, u_highp[1].y);\n\n    vec2 position = vec2(a_vertex.x, 1.0 - a_vertex.y);\n    position = position * size + offset;\n    position /= viewport;\n\n    position = position * 2.0 - 1.0;\n    gl_Position = vec4(position.x, -position.y, 0.0, 1.0);\n}",rr(!1));return ar.set("p",e),e},dr=(e,t,r)=>{const i=e.highp,a=n.$matrix;i[0]=a[6],i[1]=a[7],i[2]=t,i[3]=r,i[4]=P,i[5]=S},hr=e=>{e.useProgram(),e.bindUniform(),Tt(Et()),r.drawArrays(r.TRIANGLES,0,6)};let pr=null;const mr=(e,t,i,o)=>{const l=n.currentAttachmentObject,c=n.$mainAttachmentObject;return n.bind(c),r.bindFramebuffer(r.FRAMEBUFFER,se),pr&&pr.width===c.width&&pr.height===c.height||(pr=ve(c.width,c.height)),ke(pr),r.framebufferTexture2D(r.FRAMEBUFFER,r.COLOR_ATTACHMENT0,r.TEXTURE_2D,pr.resource,0),r.bindFramebuffer(r.FRAMEBUFFER,null),r.bindFramebuffer(r.READ_FRAMEBUFFER,Z),r.bindFramebuffer(r.DRAW_FRAMEBUFFER,se),a(),r.scissor(e,c.height-t-o,i+1,o+1),r.blitFramebuffer(0,0,c.width,c.height,0,0,c.width,c.height,r.COLOR_BUFFER_BIT,r.NEAREST),s(),r.bindFramebuffer(r.FRAMEBUFFER,Z),l&&n.bind(l),pr},gr=(e,t,r,i)=>{const a=n.currentAttachmentObject,s=mr(e,t,r,i),o=ye(r,i,!1);n.bind(o),n.save(),n.setTransform(1,0,0,1,-e,-t);const l=fr();dr(l,s.width,s.height),Xt(),ke(s),hr(l);const c=o.texture;return n.restore(),ce(o,!1),a&&n.bind(a),c},br=()=>{610!==Wt&&(qt(610),r.blendFunc(r.ONE,r.ZERO))},xr=e=>{ke(e),br();const t=fr();dr(t,e.width,e.height),hr(t),Xt()},vr=(e,t,r,n,i,a,s,o,l)=>{const c=e.textures;c[0]=0,c[1]=1;const u=e.mediump;u[0]=t,u[1]=r,u[2]=n,u[3]=i,u[4]=a,u[5]=s,u[6]=o,u[7]=l},yr=(e=!1)=>{const t="m"+(e?"y":"n");if(ar.has(t))return ar.get(t);const r=new Lt("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\nuniform vec4 u_highp[3];\n\nout vec2 v_coord;\n\nvoid main() {\n    v_coord = a_vertex;\n\n    mat3 matrix = mat3(\n        u_highp[0].x, u_highp[0].y, 0.0,\n        u_highp[0].z, u_highp[0].w, 0.0,\n        u_highp[1].x, u_highp[1].y, 1.0\n    );\n\n    vec2 size     = u_highp[1].zw;\n    vec2 viewport = vec2(u_highp[2].x, u_highp[2].y);\n\n    vec2 position = vec2(a_vertex.x, 1.0 - a_vertex.y);\n    position = position * size;\n    position = (matrix * vec3(position, 1.0)).xy;\n    position /= viewport;\n\n    position = position * 2.0 - 1.0;\n    gl_Position = vec4(position.x, -position.y, 0.0, 1.0);\n}",rr(e));return ar.set(t,r),r},_r=(e,t,r)=>{const i=e.highp,a=n.$matrix;i[0]=a[0],i[1]=a[1],i[2]=a[3],i[3]=a[4],i[4]=a[6],i[5]=a[7],i[6]=t,i[7]=r,i[8]=P,i[9]=S};let wr=0;const Mr=e=>{e.useProgram(),e.bindUniform(),Tt(Rt),r.bindBuffer(r.ARRAY_BUFFER,At),nr.buffer.length>wr&&(wr=nr.buffer.length,r.bufferData(r.ARRAY_BUFFER,4*wr,r.STREAM_DRAW)),r.bufferSubData(r.ARRAY_BUFFER,0,nr.buffer,0,nr.offset),r.drawArraysInstanced(r.TRIANGLES,0,6,e.count)},Pr=()=>{603!==Wt&&(qt(603),r.blendFunc(r.ZERO,r.ONE_MINUS_SRC_ALPHA))},Sr=e=>{switch(e){case"add":611!==Wt&&(qt(611),r.blendFunc(r.ONE,r.ONE));break;case"screen":641!==Wt&&(qt(641),r.blendFunc(r.ONE_MINUS_DST_COLOR,r.ONE));break;case"alpha":606!==Wt&&(qt(606),r.blendFunc(r.ZERO,r.SRC_ALPHA));break;case"erase":Pr();break;case"copy":br();break;default:Xt()}},Fr=e=>{var t;(e=>{At=e.createBuffer()})(e),t=(()=>{const e=St();return Tt(e),r.bindBuffer(r.ARRAY_BUFFER,e.vertexBuffer),r.bufferData(r.ARRAY_BUFFER,new Float32Array([0,0,1,0,1,1,0,0,1,1,0,1]),r.STATIC_DRAW),r.enableVertexAttribArray(0),r.vertexAttribPointer(0,2,r.FLOAT,!1,0,0),r.bindBuffer(r.ARRAY_BUFFER,At),r.bufferData(r.ARRAY_BUFFER,nr.buffer.length,r.STREAM_DRAW),r.enableVertexAttribArray(1),r.vertexAttribPointer(1,4,r.FLOAT,!1,88,0),r.vertexAttribDivisor(1,1),r.enableVertexAttribArray(2),r.vertexAttribPointer(2,4,r.FLOAT,!1,88,16),r.vertexAttribDivisor(2,1),r.enableVertexAttribArray(3),r.vertexAttribPointer(3,2,r.FLOAT,!1,88,32),r.vertexAttribDivisor(3,1),r.enableVertexAttribArray(4),r.vertexAttribPointer(4,4,r.FLOAT,!1,88,40),r.vertexAttribDivisor(4,1),r.enableVertexAttribArray(5),r.vertexAttribPointer(5,4,r.FLOAT,!1,88,56),r.vertexAttribDivisor(5,1),r.enableVertexAttribArray(6),r.vertexAttribPointer(6,4,r.FLOAT,!1,88,72),r.vertexAttribDivisor(6,1),e})(),Rt=t},Tr=(e,t,n,i=!1)=>{const a=ve(e,t,i);return r.texSubImage2D(r.TEXTURE_2D,0,0,0,e,t,r.RGBA,r.UNSIGNED_BYTE,n),a},Br=(e,t)=>{const n=((e,t,n,i=!1)=>{const a=ve(e,t,i);return r.texSubImage2D(r.TEXTURE_2D,0,0,0,r.RGBA,r.UNSIGNED_BYTE,n),a})(e.w,e.h,t),i=fr();dr(i,e.w,e.h),Xt(),hr(i),K(n)},Or=[],Ar=new Map,Rr=(e,t,r)=>{ke(e,!0);const n=Math.ceil(.5*r),i=1-(n-.5*r),a=1+r,s=(e=>{const t=`b${e}`;if(Ar.has(t))return Ar.get(t);const r=new Lt("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\n\nout vec2 v_coord;\n\nvoid main() {\n    v_coord = a_vertex;\n\n    vec2 position = a_vertex * 2.0 - 1.0;\n    gl_Position = vec4(position, 0.0, 1.0);\n}",(e=>{const t=e.toFixed(1);return`#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_texture;\nuniform vec4 u_mediump;\n\nin vec2 v_coord;\nout vec4 o_color;\n\nvoid main() {\n    vec2  offset   = u_mediump.xy;\n    float fraction = u_mediump.z;\n    float samples  = u_mediump.w;\n    \n    vec4 color = texture(u_texture, v_coord);\n\n    for (float i = 1.0; i < ${t}; i += 1.0) {\n        color += texture(u_texture, v_coord + offset * i);\n        color += texture(u_texture, v_coord - offset * i);\n    }\n    color += texture(u_texture, v_coord + offset * ${t}) * fraction;\n    color += texture(u_texture, v_coord - offset * ${t}) * fraction;\n    color /= samples;\n\n    o_color = color;\n}`})(e));return Ar.set(t,r),r})(n);((e,t,r,n,i,a)=>{const s=e.mediump;n?(s[0]=1/t,s[1]=0):(s[0]=0,s[1]=1/r),s[2]=i,s[3]=a})(s,e.width,e.height,t,i,a),hr(s)},Cr={x:0,y:0},Er=(e,t,r)=>(e>>16)*(r?t:1)/255,Ur=(e,t,r)=>(e>>8&255)*(r?t:1)/255,$r=(e,t,r)=>(255&e)*(r?t:1)/255,Gr=[.5,1.05,1.4,1.55,1.75,1.9,2,2.15,2.2,2.3,2.5,3,3,3.5,3.5],kr=(e,t,r=4,i=4,a=1,s=!0)=>{const o=n.currentAttachmentObject,l=Math.sqrt(t[0]*t[0]+t[1]*t[1]),c=Math.sqrt(t[2]*t[2]+t[3]*t[3]),u=r*(l/F),f=i*(c/F),d=Gr[a-1],h=Math.round(u*d),p=Math.round(f*d);Cr.x+=h,Cr.y+=p;const m=e.width+2*h,g=e.height+2*p;let b=1,x=1;u>128?b=.0625:u>64?b=.125:u>32?b=.25:u>16&&(b=.5),f>128?x=.0625:f>64?x=.125:f>32?x=.25:f>16&&(x=.5);const v=Math.ceil(m*b),y=Math.ceil(g*x),_=ye(v,y,!1),w=[_,ye(v,y,!1)];n.bind(_),n.reset(),n.setTransform(b,0,0,x,h*b,p*x),ke(e);const M=yr();_r(M,e.width,e.height),hr(M),s&&K(e);const P=u*b,S=f*x;let T=0,B=_.texture;ke(B,!0),br();for(let e=0;e<a;++e){if(r>0){T=(T+1)%2;const e=w[T];n.bind(e),Rr(B,!0,P),B=e.texture}if(i>0){T=(T+1)%2;const e=w[T];n.bind(e),Rr(B,!1,S),B=e.texture}}if(Xt(),1!==b||1!==x){const e=ye(m,g,!1);n.bind(e),n.setTransform(1/b,0,0,1/x,0,0),ke(B,!0),_r(M,B.width,B.height),hr(M),B=e.texture,ce(w[0]),ce(w[1]),ce(e,!1)}else T=(T+1)%2,ce(w[T]),T=(T+1)%2,ce(w[T],!1);return o&&n.bind(o),B},Lr=(e,t)=>{const r=n.currentAttachmentObject,i=ye(e.width,e.height,!1);n.bind(i),n.reset(),n.setTransform(1,0,0,1,0,0),ke(e),Xt();const a=(()=>{if(Ar.has("m"))return Ar.get("m");const e=new Lt("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\n\nout vec2 v_coord;\n\nvoid main() {\n    v_coord = a_vertex;\n\n    vec2 position = a_vertex * 2.0 - 1.0;\n    gl_Position = vec4(position, 0.0, 1.0);\n}","#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_texture;\nuniform vec4 u_mediump[5];\n\nin vec2 v_coord;\nout vec4 o_color;\n\nvoid main() {\n    mat4 mul = mat4(u_mediump[0], u_mediump[1], u_mediump[2], u_mediump[3]);\n    vec4 add = u_mediump[4];\n    \n    vec4 color = texture(u_texture, v_coord);\n\n    color.rgb /= max(0.0001, color.a);\n    color = clamp(color * mul + add, 0.0, 1.0);\n    color.rgb *= color.a;\n\n    o_color = color;\n}");return Ar.set("m",e),e})();((e,t)=>{const r=e.mediump;r[0]=t[0],r[1]=t[1],r[2]=t[2],r[3]=t[3],r[4]=t[5],r[5]=t[6],r[6]=t[7],r[7]=t[8],r[8]=t[10],r[9]=t[11],r[10]=t[12],r[11]=t[13],r[12]=t[15],r[13]=t[16],r[14]=t[17],r[15]=t[18],r[16]=t[4]/255,r[17]=t[9]/255,r[18]=t[14]/255,r[19]=t[19]/255})(a,t),hr(a);const s=i.texture;return K(e),ce(i,!1),r&&n.bind(r),s},Ir=(e,t,r,n,i,a)=>{const s=e?"blur.a = 1.0 - blur.a;":"",o=r?(l=a,`\n    float strength = u_mediump[${Math.floor(l/4)}][${l%4}];\n    blur.a = clamp(blur.a * strength, 0.0, 1.0);\n`):"";var l;const c=n?(e=>`\n    blur = texture(u_textures[${e?2:1}], vec2(blur.a, 0.5));\n`)(t):(e=>`\n    vec4 color = u_mediump[${e}];\n    blur = color * blur.a;\n`)(i);return`\n    ${s}\n    ${o}\n    ${c}\n`},Vr=(e,t,r,n,i,a)=>{const s=t?"\n    vec2 pq = (1.0 - v_coord) * blur_scale - blur_offset;\n    vec4 blur2 = mix(vec4(0.0), texture(u_textures[0], pq), isInside(pq));\n":"\n    vec4 blur2 = texture(u_textures[0], 1.0 - v_coord);\n",o=r?(l=a,`\n    float strength = u_mediump[${Math.floor(l/4)}][${l%4}];\n    highlight_alpha *= strength;\n    shadow_alpha    *= strength;\n`):"";var l;const c=n?(e=>`\n    blur = texture(u_textures[${e?2:1}], vec2(\n        0.5019607843137255 - 0.5019607843137255 * shadow_alpha + 0.4980392156862745 * highlight_alpha,\n        0.5\n    ));\n`)(e):(e=>`\n    vec4 highlight_color = u_mediump[${e}];\n    vec4 shadow_color    = u_mediump[${e+1}];\n    blur = highlight_color * highlight_alpha + shadow_color * shadow_alpha;\n`)(i);return`\n    ${s}\n    float highlight_alpha = blur.a - blur2.a;\n    float shadow_alpha    = blur2.a - blur.a;\n    ${o}\n    highlight_alpha = clamp(highlight_alpha, 0.0, 1.0);\n    shadow_alpha    = clamp(shadow_alpha, 0.0, 1.0);\n    ${c}\n`},zr=(e,t,r,n,i,a,s)=>{const o=`f${e?"y":"n"}${t?"y":"n"}${r?"y":"n"}${n}${i?"y":"n"}${a?"y":"n"}${s?"y":"n"}`;if(Ar.has(o))return Ar.get(o);let l=1;e&&l++,s&&l++;let c=(e?4:0)+(t?4:0)+(a?1:0);s||(c+=r?4:8),c=Math.ceil(c/4);const u=new Lt("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\n\nout vec2 v_coord;\n\nvoid main() {\n    v_coord = a_vertex;\n\n    vec2 position = a_vertex * 2.0 - 1.0;\n    gl_Position = vec4(position, 0.0, 1.0);\n}",((e,t,r,n,i,a,s,o,l)=>{let c=0;const u=r?(e=>`\n    vec2 base_scale  = u_mediump[${e}].xy;\n    vec2 base_offset = u_mediump[${e}].zw;\n\n    vec2 uv = v_coord * base_scale - base_offset;\n    vec4 base = mix(vec4(0.0), texture(u_textures[1], uv), isInside(uv));\n`)(c++):"",f=n?(e=>`\n    vec2 blur_scale  = u_mediump[${e}].xy;\n    vec2 blur_offset = u_mediump[${e}].zw;\n\n    vec2 st = v_coord * blur_scale - blur_offset;\n    vec4 blur = mix(vec4(0.0), texture(u_textures[0], st), isInside(st));\n`)(c++):"\n    vec4 blur = texture(u_textures[0], v_coord);\n",d="inner"===a,h=c;let p,m,g=4*c;switch(l?p=i?Ir(!1,r,o,l,h,g):Vr(r,n,o,l,h,g):i?(g+=4,p=Ir(d,r,o,l,h,g)):(g+=8,p=Vr(r,n,o,l,h,g)),a){case"outer":m=s?"blur - blur * base.a":"base + blur - blur * base.a";break;case"full":m=s?"blur":"base - base * blur.a + blur";break;default:m="blur"}return`#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_textures[${e}];\nuniform vec4 u_mediump[${t}];\n\nin vec2 v_coord;\nout vec4 o_color;\n\n\nfloat isInside(in vec2 uv) {\n    return step(4.0, dot(step(vec4(0.0, uv.x, 0.0, uv.y), vec4(uv.x, 1.0, uv.y, 1.0)), vec4(1.0)));\n}\n\nvoid main() {\n    ${u}\n    ${f}\n    ${p}\n    o_color = ${m};\n}`})(l,c,e,t,r,n,i,a,s));return Ar.set(o,u),u},jr=new Map,Dr=[],Nr=(e,t)=>{const r=`l${("00"+e).slice(-3)}${t?"y":"n"}`,n=(e=>{const t=jr.get(e);if(t){const t=Dr.indexOf(e);-1!==t&&(Dr.splice(t,1),Dr.push(e))}return t})(r);if(n)return n;const i=Math.ceil(5*e/4),a=new Lt("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\n\nout vec2 v_coord;\n\nvoid main() {\n    v_coord = a_vertex;\n\n    vec2 position = a_vertex * 2.0 - 1.0;\n    gl_Position = vec4(position, 0.0, 1.0);\n}",((e,t,r)=>{let n="";for(let e=1;e<t;++e){const r=e-1,i=e,a=`u_mediump[${t+Math.floor(r/4)}][${r%4}]`,s=`u_mediump[${t+Math.floor(i/4)}][${i%4}]`;n+=`\n    if (t <= ${s}) {\n        return mix(u_mediump[${r}], u_mediump[${i}], (t - ${a}) / (${s} - ${a}));\n    }\n`}return`#version 300 es\nprecision mediump float;\n\nuniform vec4 u_mediump[${e}];\n\nin vec2 v_coord;\nout vec4 o_color;\n\nvec4 getGradientColor(in float t) {\n    if (t <= u_mediump[${t}][0]) {\n        return u_mediump[0];\n    }\n    ${n}\n    return u_mediump[${t-1}];\n}\n\nvoid main() {\n    vec4 color = getGradientColor(v_coord.x);\n    ${r?"color = pow(color, vec4(0.45454545));":""}\n    color.rgb *= color.a;\n\n    o_color = color;\n}`})(i,e,t));return((e,t)=>{const r=Dr.indexOf(e);for(-1!==r&&Dr.splice(r,1);jr.size>=16&&Dr.length>0;){const e=Dr.shift();e&&jr.delete(e)}jr.set(e,t),Dr.push(e)})(r,a),a},Wr=(e,t,r,n,i,a)=>{const s=e.mediump;let o=0;for(let e=i;e<a;e++){const t=r[e];s[o++]=(t>>16)/255,s[o++]=(t>>8&255)/255,s[o++]=(255&t)/255,s[o++]=n[e]}for(let e=i;e<a;e++)s[o++]=t[e]/255};let qr;const Xr=(e,t)=>(qr?Ot[0]===e&&Ot[4]===t||(Ot[0]=e,Ot[2]=e,Ot[4]=t,Ot[6]=t,r.bufferSubData(r.ARRAY_BUFFER,0,Ot)):qr=((e,t)=>{const n=St();return Tt(n),r.bindBuffer(r.ARRAY_BUFFER,n.vertexBuffer),Ot[0]=e,Ot[2]=e,Ot[4]=t,Ot[6]=t,r.bufferData(r.ARRAY_BUFFER,Ot,r.STATIC_DRAW),r.enableVertexAttribArray(0),r.vertexAttribPointer(0,2,r.FLOAT,!1,0,0),n})(e,t),qr),Yr=(e,t,n)=>{e.useProgram(),e.bindUniform(),Tt(Xr(t,n)),r.drawArrays(r.TRIANGLE_STRIP,0,4)},Kr=new Map,Hr=e=>{if(!Kr.has(e)){const t=ye(e,1,!1);Kr.set(e,t)}return Kr.get(e)};let Qr=0;const Zr=()=>Qr,Jr=new Float32Array(256),en=new Float32Array(256);for(let e=0;e<256;++e){const t=e/255;Jr[e]=Math.pow(t,2.23333333),en[e]=t}const tn=(e,t,r)=>{const i=n.currentAttachmentObject,a=Hr(512);n.bind(a);const s=e.length;br();const o=Zr();for(let n=0;n<s;n+=o-1){const i=Math.min(n+o,s),a=Nr(i-n,!1);Wr(a,e,t,r,n,i),Yr(a,e[n]/255,e[i-1]/255)}return Xt(),i&&n.bind(i),a.texture},rn=(e,t,i,a,s,o,l,c,u,f,d,h,p,m,g,b,x=null,v=null,y=null,_=0,w=0,M=0,P=0,S=0,F=0,T=0,B=0)=>{const O=n.currentAttachmentObject,A=ye(i,a,!1);n.bind(A);const R="inner"===m,C=null!==x&&null!==v&&null!==y;let E=null;if(C&&(E=tn(x,v,y)),R){n.reset(),n.setTransform(1,0,0,1,0,0),ke(e,!0);const i=fr();dr(i,e.width,e.height),hr(i),C&&E?((e,t,n=!1)=>{Ge(2,r.TEXTURE2,t,n),Ge(1,r.TEXTURE1,null),Ge(0,r.TEXTURE0,e,n)})(t,E,!0):ke(t,!0)}else C&&E?((e,t,n,i=!1)=>{Ge(2,r.TEXTURE2,n,i),Ge(1,r.TEXTURE1,t,i),Ge(0,r.TEXTURE0,e,i)})(t,e,E,!0):ur(t,e,!0);const U=!(R||"full"===m&&g),$=!(i===u&&a===f&&0===d&&0===h),G=!(1===b);R?g?670!==Wt&&(qt(670),r.blendFunc(r.DST_ALPHA,r.ZERO)):673!==Wt&&(qt(673),r.blendFunc(r.DST_ALPHA,r.ONE_MINUS_SRC_ALPHA)):br();const k=zr(U,$,p,m,g,G,C);((e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g,b,x,v,y,_,w,M,P)=>{let S;_?(S=e.textures,S[0]=0,S[1]=1,P&&(S[2]=2)):P&&(S=e.textures,S[0]=0,S[1]=2);const F=e.mediump;let T=0;_&&(F[T++]=t/n,F[T++]=r/i,F[T++]=a/n,F[T++]=(r-i-s)/i),w&&(F[T++]=t/o,F[T++]=r/l,F[T++]=c/o,F[T++]=(r-l-u)/l),P||(f?(F[T++]=h,F[T++]=p,F[T++]=m,F[T++]=g):(F[T++]=h,F[T++]=p,F[T++]=m,F[T++]=g,F[T++]=b,F[T++]=x,F[T++]=v,F[T++]=y)),M&&(F[T]=d)})(k,i,a,s,o,l,c,u,f,d,h,p,b,_,w,M,P,S,F,T,B,U,$,G,C),hr(k);const L=A.texture;return ce(A,!1),Xt(),O&&n.bind(O),L},nn=(e,t,r=0,i=1,a=4,s=4,o=1,l=1,c=!1,u=!1)=>{const f=n.currentAttachmentObject,d=e.width,h=e.height,p=Cr.x,m=Cr.y,g=kr(e,t,a,s,l,!1),b=g.width,x=g.height,v=Cr.x-p,y=Cr.y-m,_=rn(e,g,c?d:b,c?h:x,d,h,c?0:v,c?0:y,b,x,c?-v:0,c?-y:0,!0,c?"inner":"outer",u,o,null,null,null,Er(r,i,!0),Ur(r,i,!0),$r(r,i,!0),i,0,0,0,0);return K(e),K(g),f&&n.bind(f),_},an=Math.PI/180,sn=(e,t,r=4,i=45,a=0,s=1,o=4,l=4,c=1,u=1,f=!1,d=!1,h=!1)=>{const p=n.currentAttachmentObject,m=e.width,g=e.height,b=Cr.x,x=Cr.y,v=kr(e,t,o,l,u,!1),y=v.width,_=v.height,w=Cr.x,M=Cr.y,P=w-b,S=M-x,T=Math.sqrt(t[0]*t[0]+t[1]*t[1]),B=Math.sqrt(t[2]*t[2]+t[3]*t[3]),O=F,A=i*an,R=Math.cos(A)*r*(T/O),C=Math.sin(A)*r*(B/O),E=f?m:y+Math.max(0,Math.abs(R)-P),U=f?g:_+Math.max(0,Math.abs(C)-S),$=Math.ceil(E),G=Math.ceil(U),k=($-E)/2,L=(G-U)/2,I=f?0:Math.max(0,P-R)+k,V=f?0:Math.max(0,S-C)+L,z=f?R-w:(R>0?Math.max(0,R-P):0)+k,j=f?C-M:(C>0?Math.max(0,C-S):0)+L;let D,N="";f?(N="inner",D=d||h):!d&&h?(N="full",D=!0):(N="outer",D=d);const W=rn(e,v,$,G,m,g,I,V,y,_,z,j,!0,N,D,c,null,null,null,Er(a,s,!0),Ur(a,s,!0),$r(a,s,!0),s,0,0,0,0);return K(e),K(v),p&&n.bind(p),W},on=Math.PI/180,ln=(e,t,r=4,i=45,a=16777215,s=1,o=0,l=1,c=4,u=4,f=1,d=1,h=0,p=!1)=>{const m=e.width,g=e.height,b=Cr.x,x=Cr.y,v=Math.sqrt(t[0]*t[0]+t[1]*t[1]),y=Math.sqrt(t[2]*t[2]+t[3]*t[3]),_=F,w=i*on,M=Math.cos(w)*r*(v/_),P=Math.sin(w)*r*(y/_),S=n.currentAttachmentObject,T=ye(m,g,!1);n.bind(T),n.reset(),n.setTransform(1,0,0,1,0,0),ke(e);const B=fr();dr(B,e.width,e.height),hr(B),n.setTransform(1,0,0,1,2*M,2*P),Pr(),dr(B,e.width,e.height),hr(B),Xt();const O=T.texture;S&&n.bind(S);const A=kr(O,t,c,u,d,!1);ce(T);const R=A.width,C=A.height,E=Math.ceil(R+2*Math.abs(M)),U=Math.ceil(C+2*Math.abs(P));let $="";switch(h){case 0:$="full";break;case 1:$="inner";break;case 2:$="outer"}const G="inner"===$,k=G?m:E,L=G?g:U,I=Math.abs(M),V=Math.abs(P),z=(R-m)/2,j=(C-g)/2,D=G?0:I+z,N=G?0:V+j,W=rn(e,A,k,L,m,g,D,N,R,C,G?-z-M:I-M,G?-j-P:V-P,!1,$,p,f,null,null,null,Er(a,s,!0),Ur(a,s,!0),$r(a,s,!0),s,Er(o,l,!0),Ur(o,l,!0),$r(o,l,!0),l);return Cr.x=b+D,Cr.y=x+N,K(e),K(A),W},cn=Math.PI/180,un=(e,t,r=4,i=45,a,s,o,l=4,c=4,u=1,f=1,d=0,h=!1)=>{const p=e.width,m=e.height,g=Cr.x,b=Cr.y,x=Math.sqrt(t[0]*t[0]+t[1]*t[1]),v=Math.sqrt(t[2]*t[2]+t[3]*t[3]),y=F,_=i*cn,w=Math.cos(_)*r*(x/y),M=Math.sin(_)*r*(v/y),P=n.currentAttachmentObject,S=ye(p,m,!1);n.bind(S),n.reset(),n.setTransform(1,0,0,1,0,0),ke(e);const T=fr();dr(T,e.width,e.height),hr(T),n.setTransform(1,0,0,1,2*w,2*M),Pr(),dr(T,e.width,e.height),hr(T),Xt();const B=S.texture;P&&n.bind(P);const O=kr(B,t,l,c,f,!1);ce(S);const A=O.width,R=O.height,C=Math.ceil(A+2*Math.abs(w)),E=Math.ceil(R+2*Math.abs(M));let U="";switch(d){case 0:U="full";break;case 1:U="inner";break;case 2:U="outer"}const $="inner"===U,G=$?p:C,k=$?m:E,L=Math.abs(w),I=Math.abs(M),V=(A-p)/2,z=(R-m)/2,j=$?0:L+V,D=$?0:I+z,N=rn(e,O,G,k,p,m,j,D,A,R,$?-V-w:L-w,$?-z-M:I-M,!1,U,h,u,o,a,s,0,0,0,0,0,0,0,0);return Cr.x=g+j,Cr.y=b+D,K(e),K(O),N},fn=Math.PI/180,dn=(e,t,r=4,n=45,i,a,s,o=4,l=4,c=1,u=1,f=0,d=!1)=>{const h=e.width,p=e.height,m=Cr.x,g=Cr.y,b=kr(e,t,o,l,u,!1),x=b.width,v=b.height,y=Cr.x,_=Cr.y,w=y-m,M=_-g,P=Math.sqrt(t[0]*t[0]+t[1]*t[1]),S=Math.sqrt(t[2]*t[2]+t[3]*t[3]),T=F,B=n*fn,O=Math.cos(B)*r*(P/T),A=Math.sin(B)*r*(S/T),R=1===f,C=R?h:x+Math.max(0,Math.abs(O)-w),E=R?p:v+Math.max(0,Math.abs(A)-M),U=Math.ceil(C),$=Math.ceil(E),G=(U-C)/2,k=($-E)/2,L=R?0:Math.max(0,w-O)+G,I=R?0:Math.max(0,M-A)+k,V=R?O-y:(O>0?Math.max(0,O-w):0)+G,z=R?A-_:(A>0?Math.max(0,A-M):0)+k;let j="";switch(f){case 0:j="full";break;case 1:j="inner";break;case 2:j="outer"}const D=rn(e,b,U,$,h,p,L,I,x,v,V,z,!0,j,d,c,s,i,a,0,0,0,0,0,0,0,0);return Cr.x=m+L,Cr.y=g+I,K(e),K(b),D},hn=(e,t,r,n)=>{const i=`c${("0"+e).slice(-2)}${("0"+t).slice(-2)}${r?"y":"n"}${n?"y":"n"}`;if(Ar.has(i))return Ar.get(i);const a=(n?1:2)+Math.ceil(e*t/4),s=new Lt("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\n\nout vec2 v_coord;\n\nvoid main() {\n    v_coord = a_vertex;\n\n    vec2 position = a_vertex * 2.0 - 1.0;\n    gl_Position = vec4(position, 0.0, 1.0);\n}",((e,t,r,n,i)=>{const a=Math.floor(.5*t),s=Math.floor(.5*r),o=t*r;let l="";const c=i?1:2;for(let e=0;e<o;++e)l+=`\n    result += getWeightedColor(${e}, u_mediump[${c+Math.floor(e/4)}][${e%4}]);\n`;return`#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_texture;\nuniform vec4 u_mediump[${e}];\n\nin vec2 v_coord;\nout vec4 o_color;\n\n\nfloat isInside(in vec2 uv) {\n    return step(4.0, dot(step(vec4(0.0, uv.x, 0.0, uv.y), vec4(uv.x, 1.0, uv.y, 1.0)), vec4(1.0)));\n}\n\nvec4 getWeightedColor (in int i, in float weight) {\n    vec2 rcp_size = u_mediump[0].xy;\n\n    int i_div_x = i / ${t};\n    int i_mod_x = i - ${t} * i_div_x;\n    vec2 offset = vec2(i_mod_x - ${a}, ${s} - i_div_x);\n    vec2 uv = v_coord + offset * rcp_size;\n\n    vec4 color = texture(u_texture, uv);\n    color.rgb /= max(0.0001, color.a);\n    ${i?"":"\n    vec4 substitute_color = u_mediump[1];\n    color = mix(substitute_color, color, isInside(uv));\n"}\n\n    return color * weight;\n}\n\nvoid main() {\n    float rcp_divisor = u_mediump[0].z;\n    float bias        = u_mediump[0].w;\n\n    vec4 result = vec4(0.0);\n    ${l}\n    result = clamp(result * rcp_divisor + bias, 0.0, 1.0);\n    ${n?"result.a = texture(u_texture, v_coord).a;":""}\n\n    result.rgb *= result.a;\n    o_color = result;\n}`})(a,e,t,r,n));return Ar.set(i,s),s},pn=(e,t=0,r=0,i,a=1,s=0,o=!0,l=!0,c=0,u=0)=>{const f=n.currentAttachmentObject,d=e.width,h=e.height,p=ye(d,h,!1);n.bind(p),n.reset(),n.setTransform(1,0,0,1,0,0),ke(e,!0),Xt();const m=hn(t,r,o,l);((e,t,r,n,i,a,s,o,l,c,u)=>{const f=e.mediump;f[0]=1/t,f[1]=1/r,f[2]=1/i,f[3]=a/255;let d=4;s||(f[d++]=o,f[d++]=l,f[d++]=c,f[d++]=u);const h=n.length;for(let e=0;e<h;e++)f[d++]=n[e]})(m,d,h,i,a,s,l,Er(c,u,!1),Ur(c,u,!1),$r(c,u,!1),u),hr(m);const g=p.texture;return K(e),ce(p,!1),f&&n.bind(f),g},mn=(e,t,r=0,i=0,a=0,s=0,o=0,l=0,c=0,u=0,f=2,d=0,h=0)=>{const p=n.currentAttachmentObject,m=e.width,g=e.height,b=ye(m,g,!1);n.bind(b);const x=Tr(r,i,t);ur(e,x);const v=((e,t,r)=>{const n=`d${e}${t}${r}`;if(Ar.has(n))return Ar.get(n);const i=new Lt("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\n\nout vec2 v_coord;\n\nvoid main() {\n    v_coord = a_vertex;\n\n    vec2 position = a_vertex * 2.0 - 1.0;\n    gl_Position = vec4(position, 0.0, 1.0);\n}",((e,t,r,n)=>{let i,a,s;switch(t){case 1:i="map_color.r";break;case 2:i="map_color.g";break;case 4:i="map_color.b";break;case 8:i="map_color.a";break;default:i="0.5"}switch(r){case 1:a="map_color.r";break;case 2:a="map_color.g";break;case 4:a="map_color.b";break;case 8:a="map_color.a";break;default:a="0.5"}switch(n){case 0:s="\n    vec4 source_color = texture(u_textures[0], uv);\n";break;case 3:s="\n    vec4 source_color =texture(u_textures[0], mix(v_coord, uv, step(abs(uv - vec2(0.5)), vec2(0.5))));\n";break;case 1:s="\n    vec4 substitute_color = u_mediump[2];\n    vec4 source_color = mix(substitute_color, texture(u_textures[0], uv), isInside(uv));\n";break;default:s="\n    vec4 source_color = texture(u_textures[0], fract(uv));\n"}return`#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_textures[2];\nuniform vec4 u_mediump[${e}];\n\nin vec2 v_coord;\nout vec4 o_color;\n\n\nfloat isInside(in vec2 uv) {\n    return step(4.0, dot(step(vec4(0.0, uv.x, 0.0, uv.y), vec4(uv.x, 1.0, uv.y, 1.0)), vec4(1.0)));\n}\n\nvoid main() {\n    vec2 uv_to_st_scale  = u_mediump[0].xy;\n    vec2 uv_to_st_offset = u_mediump[0].zw;\n    vec2 scale           = u_mediump[1].xy;\n\n    vec2 st = v_coord * uv_to_st_scale - uv_to_st_offset;\n    vec4 map_color = texture(u_textures[1], st);\n\n    vec2 offset = vec2(${i}, ${a}) - 0.5;\n    vec2 uv = v_coord + offset * scale;\n    ${s}\n\n    o_color = mix(texture(u_textures[0], v_coord), source_color, isInside(st));\n}`})(1===r?3:2,e,t,r));return Ar.set(n,i),i})(o,l,f);((e,t,r,n,i,a,s,o,l,c,u,f,d,h)=>{const p=e.textures;p[0]=0,p[1]=1;const m=e.mediump;m[0]=n/t,m[1]=i/r,m[2]=a/t,m[3]=(i-r-s)/r,m[4]=o/n,m[5]=-l/i,1===c&&(m[8]=u,m[9]=f,m[10]=d,m[11]=h)})(v,r,i,r,i,a,s,c,u,f,Er(d,h,!0),Ur(d,h,!0),$r(d,h,!0),h),Xt(),hr(v);const y=b.texture;return p&&n.bind(p),K(e),K(x),ce(b,!1),y},gn=(e,t,r,i)=>{const a=n.currentAttachmentObject,s=e.width,o=e.height;switch(n.globalCompositeOperation){case"normal":case"layer":case"add":case"screen":case"alpha":case"erase":case"copy":{n.bind(n.$mainAttachmentObject),n.setTransform(1,0,0,1,r,i);const a=yr(!0);((e,t,r,i)=>{const a=e.highp,s=n.$matrix;a[0]=s[0],a[1]=s[1],a[2]=s[3],a[3]=s[4],a[4]=s[6],a[5]=s[7],a[6]=r,a[7]=i,a[8]=P,a[9]=S;const o=e.mediump;o[0]=t[0],o[1]=t[1],o[2]=t[2],o[3]=t[3],o[4]=t[4],o[5]=t[5],o[6]=t[6],o[7]=t[7]})(a,t,s,o),ke(e),Sr(n.globalCompositeOperation),hr(a)}break;default:{const a=gr(r,i,s,o),l=ye(s,o,!1);n.bind(l),ur(a,e);const c=or(n.globalCompositeOperation);vr(c,t[0],t[1],t[2],t[3],t[4],t[5],t[6],t[7]),hr(c),n.bind(n.$mainAttachmentObject),n.reset(),n.setTransform(1,0,0,1,r,i),xr(l.texture),K(a),ce(l)}}a&&n.bind(a),Xt()},bn=[],xn=e=>{e.size&&e.clear(),bn.push(e)},vn=(e,t,r,n,i=null)=>{t.has(r)||t.set(r,bn.pop()||new Map);const a=t.get(r);if(null===i){if(!a.has(n))return;return e.destroy(a.get(n)),a.delete(n),void(a.size||(t.delete(r),xn(a)))}a.set(n,i)};const yn=new class{constructor(){Object.defineProperty(this,"_$pool",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"_$store",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"_$trash",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$timerId",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$removeCache",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$removeIds",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this._$pool=[],this._$store=new Map,this._$trash=new Map,this.$timerId=null,this.$removeIds=[],this.$removeCache=!1}reset(){((e,t,r)=>{r.clear(),null!==e.$timerId&&clearTimeout(e.$timerId);for(const r of t.values()){for(const t of r.values())t&&e.destroy(t);xn(r)}t.clear()})(this,this._$store,this._$trash)}destroy(e=null){((e,t)=>{if(t&&"object"==typeof t&&"canvas"in t){const r=t.canvas,n=r.width,i=r.height;t.clearRect(0,0,n+1,i+1),r.width=r.height=1,e.push(r)}})(this._$pool,e)}getCanvas(){return this._$pool.pop()||document.createElement("canvas")}remove(e,t){((e,t,r)=>{if(!e.has(t))return;const n=e.get(t);n.has(r)&&(n.delete(r),n.size||(xn(n),e.delete(t)))})(this._$store,e,t)}removeTimer(e){((e,t,r,n)=>{if(r.has(n))return;const i=t.get(n);i&&(i.set("trash",!0),r.set(n,i),null!==e.$timerId&&clearTimeout(e.$timerId),e.$removeCache=!1,e.$timerId=setTimeout(()=>{e.$removeCache=!0,e.$timerId=null},1e3))})(this,this._$store,this._$trash,e)}removeTimerScheduledCache(){((e,t)=>{if(t.size){for(const[r,n]of t)n.has("trash")&&(e.removeById(r),e.$removeIds.push(+r));t.clear(),e.$removeCache=!1}})(this,this._$trash)}removeById(e){((e,t,r)=>{if(!t.has(r))return;const n=t.get(r);for(const t of n.values())e.destroy(t);t.delete(r),xn(n)})(this,this._$store,e)}getById(e){return this._$store.get(e)}get(e,t){return((e,t,r)=>{const n=e.get(t)||null;return n?(n.delete("trash"),n.get(r)||null):null})(this._$store,e,t)}set(e,t,r=null){vn(this,this._$store,e,t,r)}has(e,t=""){return((e,t,r="")=>r?!!e.has(t)&&e.get(t).has(r):e.has(t))(this._$store,e,t)}generateKeys(e,t,r){return((e,t,r)=>{let n=2166136261,i=100*e|0;return n^=255&i,n=Math.imul(n,16777619),n^=i>>>8&255,n=Math.imul(n,16777619),n^=i>>>16&255,n=Math.imul(n,16777619),n^=i>>>24,n=Math.imul(n,16777619),i=100*t|0,n^=255&i,n=Math.imul(n,16777619),n^=i>>>8&255,n=Math.imul(n,16777619),n^=i>>>16&255,n=Math.imul(n,16777619),n^=i>>>24,n=Math.imul(n,16777619),r&&(i=100*r|0,n^=255&i,n=Math.imul(n,16777619),n^=i>>>8&255,n=Math.imul(n,16777619),n^=i>>>16&255,n=Math.imul(n,16777619),n^=i>>>24,n=Math.imul(n,16777619)),(n>>>0)%16777216})(e,t,r)}generateFilterKeys(e,t,r,n){return((e,t,r,n)=>{let i=2166136261,a=100*e|0;return i^=255&a,i=Math.imul(i,16777619),i^=a>>>8&255,i=Math.imul(i,16777619),i^=a>>>16&255,i=Math.imul(i,16777619),i^=a>>>24,i=Math.imul(i,16777619),a=100*t|0,i^=255&a,i=Math.imul(i,16777619),i^=a>>>8&255,i=Math.imul(i,16777619),i^=a>>>16&255,i=Math.imul(i,16777619),i^=a>>>24,i=Math.imul(i,16777619),a=100*r|0,i^=255&a,i=Math.imul(i,16777619),i^=a>>>8&255,i=Math.imul(i,16777619),i^=a>>>16&255,i=Math.imul(i,16777619),i^=a>>>24,i=Math.imul(i,16777619),a=100*n|0,i^=255&a,i=Math.imul(i,16777619),i^=a>>>8&255,i=Math.imul(i,16777619),i^=a>>>16&255,i=Math.imul(i,16777619),i^=a>>>24,i=Math.imul(i,16777619),(i>>>0)%16777216})(e,t,r,n)}},_n=new Float32Array(20),wn=(e,t,r,i,a,s,o,l,c,u,f)=>{const d=n.currentAttachmentObject;let h=null;const p=Math.sqrt(o[0]*o[0]+o[1]*o[1]),m=Math.sqrt(o[2]*o[2]+o[3]*o[3]),g=yn.generateFilterKeys(o[0],o[1],o[2],o[3]);let b=!1;if(yn.get(t,"fKey")===g){const e=yn.get(t,"fTexture");r?K(e):(b=!0,h=e)}let x=0,v=0;if(b)x=yn.get(t,"offsetX"),v=yn.get(t,"offsetY");else{h=cr(e);const t=Math.atan2(o[1],o[0]),r=Math.atan2(-o[2],o[3]),l=s?p*Math.cos(t):Math.cos(t),c=s?p*Math.sin(t):Math.sin(t),u=s?-m*Math.sin(r):-Math.sin(r),g=s?m*Math.cos(r):Math.cos(r),b=_(l,c,u,g,i/2,a/2),y=_(1,0,0,1,-e.w/2,-e.h/2),M=((e,t)=>{const r=e[0],n=e[1],i=e[2],a=e[3],s=e[4],o=e[5],l=t[0],c=t[1],u=t[2],f=t[3],d=t[4],h=t[5];return _(r*l+i*c,n*l+a*c,r*u+i*f,n*u+a*f,r*d+i*h+s,n*d+a*h+o)})(b,y);if(w(b),w(y),1!==M[0]||0!==M[1]||0!==M[2]||1!==M[3]){const e=ye(i,a,!1);n.bind(e),n.reset(),n.setTransform(M[0],M[1],M[2],M[3],M[4],M[5]),x=M[4],v=M[5],ke(h);const t=yr();_r(t,h.width,h.height),hr(t),K(h),h=e.texture,ce(e,!1),d&&n.bind(d)}w(M),Cr.x=0,Cr.y=0;for(let e=0;f.length>e;){switch(f[e++]){case 0:h=ln(h,o,f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],Boolean(f[e++]));break;case 1:h=kr(h,o,f[e++],f[e++],f[e++]);break;case 2:for(let t=0;t<20;++t)_n[t]=f[e++];h=Lr(h,_n);break;case 3:{const t=f[e++],r=f[e++],n=t*r,i=f.subarray(e,e+n);e+=n,h=pn(h,t,r,i,f[e++],f[e++],Boolean(f[e++]),Boolean(f[e++]),f[e++],f[e++])}break;case 4:{const t=f[e++],r=new Uint8Array(t);r.set(f.subarray(e,e+t)),e+=t,h=mn(h,r,f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++])}break;case 5:h=sn(h,o,f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],Boolean(f[e++]),Boolean(f[e++]),Boolean(f[e++]));break;case 6:h=nn(h,o,f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],Boolean(f[e++]),Boolean(f[e++]));break;case 7:{const t=f[e++],r=f[e++];let n=f[e++];const i=f.subarray(e,e+n);e+=n,n=f[e++];const a=f.subarray(e,e+n);e+=n,n=f[e++];const s=f.subarray(e,e+n);e+=n,h=un(h,o,t,r,i,a,s,f[e++],f[e++],f[e++],f[e++],f[e++],Boolean(f[e++]))}break;case 8:{const t=f[e++],r=f[e++];let n=f[e++];const i=f.subarray(e,e+n);e+=n,n=f[e++];const a=f.subarray(e,e+n);e+=n,n=f[e++];const s=f.subarray(e,e+n);e+=n,h=dn(h,o,t,r,i,a,s,f[e++],f[e++],f[e++],f[e++],f[e++],Boolean(f[e++]))}}}}if(h){const e=F,t=u[0]*(p/e),r=u[1]*(m/e);n.reset(),n.setTransform(1,0,0,1,0,0),n.globalCompositeOperation=c,gn(h,l,-x+t+o[4],-v+r+o[5])}b||(yn.set(t,"fKey",g),yn.set(t,"fTexture",h),yn.set(t,"offsetX",x),yn.set(t,"offsetY",v)),d&&n.bind(d)},Mn=[],Pn=new Float32Array(20),Sn=e=>{const t=Re(e.index),r=t[0],n=t[1],i=t[2],a=t[3];t[0]=Math.min(e.x,r),t[1]=Math.min(e.y,n),t[2]=Math.max(e.x+e.w+1,i),t[3]=Math.max(e.y+e.h+1,a)};let Fn=0;const Tn=e=>{Fn=e};let Bn=!0;const On=e=>{Bn=e};let An=!1;const Rn=e=>{An=e},Cn=()=>{1!==Fn&&(Tn(1),r.stencilFunc(r.ALWAYS,0,255),r.stencilOpSeparate(r.FRONT,r.KEEP,r.KEEP,r.INCR_WRAP),r.stencilOpSeparate(r.BACK,r.KEEP,r.KEEP,r.DECR_WRAP)),Bn&&(On(!1),r.colorMask(!1,!1,!1,!1))},En=()=>{2!==Fn&&(Tn(2),r.stencilFunc(r.NOTEQUAL,0,255),r.stencilOp(r.KEEP,r.ZERO,r.ZERO)),Bn||(On(!0),r.colorMask(!0,!0,!0,!0))},Un=()=>{An||(Rn(!0),r.enable(r.SAMPLE_ALPHA_TO_COVERAGE))},$n=()=>{An&&(Rn(!1),r.disable(r.SAMPLE_ALPHA_TO_COVERAGE))},Gn=(e,t,r,n)=>{Cn();const i=!!n,a=zt(i);n&&jt(a,n),Un(),Yt(a,e,t,r),$n(),En();const s=(e=>{const t="s"+(e?"y":"n");if(It.has(t))return It.get(t);const r=new Lt(Vt(e?9:0,!1,!1,e),"#version 300 es\nprecision mediump float;\n\nin vec4 v_color;\nout vec4 o_color;\n\nvoid main() {\n    o_color = vec4(v_color.rgb * v_color.a, v_color.a);\n}");return It.set(t,r),r})(i);n&&((e,t)=>{const r=e.highp;r[0]=t[0],r[1]=t[1],r[2]=0,r[4]=t[2],r[5]=t[3],r[6]=0,r[8]=t[4],r[9]=t[5],r[10]=1,r[12]=t[6],r[13]=t[7],r[14]=0,r[16]=t[8],r[17]=t[9],r[18]=0,r[20]=t[10],r[21]=t[11],r[22]=1,r[3]=P,r[7]=S,r[11]=t[12],r[15]=t[13],r[19]=t[14],r[23]=t[15],r[24]=t[16],r[25]=t[17],r[26]=t[18],r[27]=t[19],r[28]=t[20],r[29]=t[21],r[30]=t[22],r[31]=t[23],r[32]=t[24],r[33]=t[25]})(s,n),Yt(s,e,t,r)},kn=(e,t,r,n,i)=>{const a=e.mediump;let s=0;for(let e=r;e<n;++e){const r=5*e;a[s++]=i[t[r+1]],a[s++]=i[t[r+2]],a[s++]=i[t[r+3]],a[s++]=i[t[r+4]]}for(let e=r;e<n;++e)a[s++]=t[5*e]},Ln=(e,t)=>{const i=n.currentAttachmentObject,o=r.getParameter(r.SCISSOR_BOX);s();const l=0===t,c=e.length/5,u=(e=>e<=4?256:e<=8?512:1024)(c),f=Hr(u);n.bind(f);const d=l?Jr:en;br();const h=Zr();for(let t=0;t<c;t+=h-1){const r=Math.min(t+h,c),n=Nr(r-t,l);kn(n,e,t,r,d),Yr(n,e[0],e[e.length-5])}return Xt(),i&&n.bind(i),a(),r.scissor(o[0],o[1],o[2],o[3]),f.texture},In=new Map,Vn=(e,t,r,n)=>{const i=((e,t,r,n)=>`${e?"y":"n"}${t?"y":"n"}${t&&r?"y":"n"}${n}`)(n,e,t,r);if(In.has(i))return In.get(i);const a=1+(n?14:5),s=a-1,o=new Lt(Vt(a,!0,!1,n),((e,t,r,n,i)=>{const a=r?((e,t)=>{const r=t?(e=>`\n    vec2 focal = vec2(u_highp[${e}][1], 0.0);\n\n    vec2 diff = coord - focal;\n    float lenDiff = length(diff);\n    vec2 dir = diff / lenDiff;\n    float b = 2.0 * dot(dir, focal);\n    float c = dot(focal, focal) - 1.0;\n    float x = (-b + sqrt(max(b * b - 4.0 * c, 0.0))) * 0.5;\n\n    float t = lenDiff / abs(x);`)(e):"float t = length(coord);";return`\n    float radius = u_highp[${e}][0];\n    vec2 coord = p / radius;\n    ${r}\n`})(t,n):(e=>`\n    vec2 a = u_highp[${e}].xy;\n    vec2 b = u_highp[${e}].zw;\n\n    vec2 ab = b - a;\n    vec2 ap = p - a;\n\n    float t = dot(ab, ap) / dot(ab, ab);`)(t);let s;switch(i){case 0:s="1.0 - abs(fract(t * 0.5) * 2.0 - 1.0)";break;case 1:s="fract(t)";break;default:s="clamp(t, 0.0, 1.0)"}return`#version 300 es\nprecision highp float;\n\nuniform sampler2D u_texture;\nuniform vec4 u_highp[${e}];\n\nin vec2 v_uv;\nout vec4 o_color;\n\nvoid main() {\n    vec2 p = v_uv;\n    ${a}\n    t = ${s};\n    o_color = texture(u_texture, vec2(t, 0.5));\n}`})(a,s,e,t,r));return In.set(i,o),o},zn=(e,t,r,n,i=0,a=null,s=null)=>{const o=e.highp;o[0]=r[0],o[1]=r[1],o[2]=r[2],o[4]=r[3],o[5]=r[4],o[6]=r[5],o[8]=r[6],o[9]=r[7],o[10]=r[8],o[12]=n[0],o[13]=n[1],o[14]=n[2],o[16]=n[3],o[17]=n[4],o[18]=n[5],o[11]=n[6],o[15]=n[7],o[19]=n[8],o[3]=P,o[7]=S;let l=20;s&&(o[20]=s[0],o[21]=s[1],o[22]=0,o[24]=s[2],o[25]=s[3],o[26]=0,o[28]=s[4],o[29]=s[5],o[30]=1,o[32]=s[6],o[33]=s[7],o[34]=0,o[36]=s[8],o[37]=s[9],o[38]=0,o[40]=s[10],o[41]=s[11],o[42]=1,o[31]=s[12],o[35]=s[13],o[39]=s[14],o[43]=s[15],o[44]=s[16],o[45]=s[17],o[46]=s[18],o[47]=s[19],o[48]=s[20],o[49]=s[21],o[50]=s[22],o[51]=s[23],o[52]=s[24],o[53]=s[25],l=56),0===t?(o[l++]=a[0],o[l++]=a[1],o[l++]=a[2],o[l]=a[3]):(o[l++]=819.2,o[l]=u(i,-.975,.975,0))},jn=()=>{Fn=0,On(!0),Rn(!1)},Dn=(e,t,i,a)=>{const s=rt.shift(),o=rt.shift(),u=rt.shift(),f=rt.shift();jn(),c();const d=Ln(s,f);ke(d),l(),r.stencilMask(255),Cn();const h=!!a,p=zt(h);a&&jt(p,a),Un(),Yt(p,e,t,i),$n(),En();const m=Vn(!1,!1,u,h),x=(e=>{const t=-819.2*e[0]-819.2*e[2]+e[4],r=819.2*e[0]-819.2*e[2]+e[4],n=-819.2*e[0]+819.2*e[2]+e[4],i=-819.2*e[1]-819.2*e[3]+e[5],a=819.2*e[1]-819.2*e[3]+e[5];let s=n-t,o=-819.2*e[1]+819.2*e[3]+e[5]-i;const l=Math.sqrt(s*s+o*o);l?(s/=l,o/=l):(s=0,o=0);const c=(r-t)*s+(a-i)*o;return g(t+c*s,i+c*o,r,a)})(o),v=M(n.$matrix);zn(m,0,n.$matrix,v,0,x,a),b(x),w(v),Yt(m,e,t,i)},Nn=(e,t,i,a)=>{const s=rt.shift(),o=rt.shift(),u=rt.shift(),f=rt.shift(),d=rt.shift();jn(),c();const h=Ln(s,f);ke(h),l(),r.stencilMask(255),Cn();const p=!!a,m=zt(p);a&&jt(m,a),Un(),Yt(m,e,t,i),$n(),En(),n.save(),n.transform(o[0],o[1],o[2],o[3],o[4],o[5]);const g=n.$stack[n.$stack.length-1],b=M(n.$matrix),x=Vn(!0,Boolean(d),u,p);zn(x,1,g,b,d,a),n.restore(),w(b),Yt(x,e,t,i)},Wn=new Map,qn=(e,t,r,i)=>{Cn();const a=!!i,s=zt(a);i&&jt(s,i),Un(),Yt(s,e,t,r),$n();const o=Or.shift(),l=Or.shift(),c=Or.shift(),u=Or.shift(),f=Or.shift(),d=Or.shift(),h=Tr(c,u,o,d);n.save(),n.transform(l[0],l[1],l[2],l[3],l[4],l[5]),En();const p=((e,t)=>{const r=`b${e?"y":"n"}${t?"y":"n"}`;if(Wn.has(r))return Wn.get(r);const n=e?"#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_texture;\nuniform vec4 u_mediump[1];\n\nin vec2 v_uv;\nout vec4 o_color;\n\nvoid main() {\n    vec2 uv = fract(vec2(v_uv.x, -v_uv.y) / u_mediump[0].xy);\n\n    vec4 src = texture(u_texture, uv);\n    o_color = src;\n}":"#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_texture;\nuniform vec4 u_mediump[1];\n\nin vec2 v_uv;\nout vec4 o_color;\n\nvoid main() {\n    vec2 uv = vec2(v_uv.x, u_mediump[0].y - v_uv.y) / u_mediump[0].xy;\n\n    vec4 src = texture(u_texture, uv);\n    o_color = src;\n}",i=new Lt(Vt(t?14:5,!0,!1,t),n);return Wn.set(r,i),i})(f,a);((e,t,r,i)=>{const a=e.highp,s=n.$stack[n.$stack.length-1];a[0]=s[0],a[1]=s[1],a[2]=s[2],a[4]=s[3],a[5]=s[4],a[6]=s[5],a[8]=s[6],a[9]=s[7],a[10]=s[8];const o=M(n.$matrix);a[12]=o[0],a[13]=o[1],a[14]=o[2],a[16]=o[3],a[17]=o[4],a[18]=o[5],a[11]=o[6],a[15]=o[7],a[19]=o[8],a[3]=P,a[7]=S,i&&(a[20]=i[0],a[21]=i[1],a[22]=0,a[24]=i[2],a[25]=i[3],a[26]=0,a[28]=i[4],a[29]=i[5],a[30]=1,a[32]=i[6],a[33]=i[7],a[34]=0,a[36]=i[8],a[37]=i[9],a[38]=0,a[40]=i[10],a[41]=i[11],a[42]=1,a[31]=i[12],a[35]=i[13],a[39]=i[14],a[43]=i[15],a[44]=i[16],a[45]=i[17],a[46]=i[18],a[47]=i[19],a[48]=i[20],a[49]=i[21],a[50]=i[22],a[51]=i[23],a[52]=i[24],a[53]=i[25]);const l=e.mediump;l[0]=t,l[1]=r})(p,c,u,i),Yt(p,e,t,r),n.restore(),K(h)};let Xn=0;const Yn=new Float32Array(256);for(let e=1;e<256;e++)Yn[e]=255/e;let Kn=class{constructor(i,a,s=1){var o;Object.defineProperty(this,"$stack",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$matrix",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$clearColorR",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$clearColorG",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$clearColorB",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$clearColorA",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$mainAttachmentObject",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$stackAttachmentObject",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"globalAlpha",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"globalCompositeOperation",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"imageSmoothingEnabled",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$fillStyle",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$strokeStyle",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"maskBounds",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"thickness",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"caps",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"joints",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"miterLimit",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"newDrawState",{enumerable:!0,configurable:!0,writable:!0,value:!1}),(e=>{r=e})(i),o=i.getParameter(i.MAX_TEXTURE_SIZE),e=Math.max(2048,o/2),(e=>{t=e})(a),(e=>{F=e})(s),this.$stack=d(),this.$stackAttachmentObject=d(),this.$matrix=v(1,0,0,0,1,0,0,0,1),this.$clearColorR=0,this.$clearColorG=0,this.$clearColorB=0,this.$clearColorA=0,this.thickness=1,this.caps=0,this.joints=2,this.miterLimit=0,this.$mainAttachmentObject=null,this.globalAlpha=1,this.globalCompositeOperation="normal",this.imageSmoothingEnabled=!1,this.$fillStyle=new Float32Array([1,1,1,1]),this.$strokeStyle=new Float32Array([1,1,1,1]),this.maskBounds={xMin:0,yMin:0,xMax:0,yMax:0},i.pixelStorei(i.UNPACK_ALIGNMENT,1),i.pixelStorei(i.UNPACK_FLIP_Y_WEBGL,!0),i.clearColor(0,0,0,0),i.frontFace(i.CCW),(e=>{Z=e.createFramebuffer()})(i),(e=>{J=e.createFramebuffer()})(i),((e,t)=>{ee=e.createFramebuffer(),e.bindFramebuffer(e.FRAMEBUFFER,ee),e.framebufferTexture2D(e.FRAMEBUFFER,e.COLOR_ATTACHMENT0,e.TEXTURE_2D,t.resource,0),e.bindFramebuffer(e.FRAMEBUFFER,null),e.bindFramebuffer(e.DRAW_FRAMEBUFFER,ee)})(i,Oe()),(e=>{se=e.createFramebuffer(),ae=e.createFramebuffer(),oe=e.createFramebuffer(),le=e.createBuffer(),e.bindBuffer(e.PIXEL_PACK_BUFFER,le)})(i),Fr(i),r.enable(r.BLEND),Xt(),(e=>{Qr=Math.floor(.75*e.getParameter(e.MAX_FRAGMENT_UNIFORM_VECTORS))})(i),n=this}clearTransferBounds(){(()=>{for(let e=0;e<Ae.length;++e){const t=Ae[e];t&&(t[0]=t[1]=_e,t[2]=t[3]=we)}})()}updateBackgroundColor(e,t,r,n){((e,t,r,n,i)=>{e.$clearColorR=u(t,0,1,0),e.$clearColorG=u(r,0,1,0),e.$clearColorB=u(n,0,1,0),e.$clearColorA=u(i,0,1,0)})(this,e,t,r,n)}fillBackgroundColor(){var e,t,n,i;e=this.$clearColorR,t=this.$clearColorG,n=this.$clearColorB,i=this.$clearColorA,r.clearColor(e,t,n,i),r.clear(r.COLOR_BUFFER_BIT|r.STENCIL_BUFFER_BIT),r.clearColor(0,0,0,0)}resize(e,t,r=!0){$e(this,e,t,r)}clearRect(e,t,n,i){((e,t,n,i)=>{a(),r.scissor(e,t,n,i),r.clear(r.COLOR_BUFFER_BIT|r.STENCIL_BUFFER_BIT),s()})(e,t,n,i)}bind(e){Ne(this,e)}save(){var e;(e=this).$stack.push(v(...e.$matrix))}restore(){We(this)}setTransform(e,t,r,n,i,a){((e,t,r,n,i,a,s)=>{e[0]=t,e[1]=r,e[3]=n,e[4]=i,e[6]=a,e[7]=s})(this.$matrix,e,t,r,n,i,a)}transform(e,t,r,n,i,a){((e,t,r,n,i,a,s)=>{const o=e.$matrix[0],l=e.$matrix[1],c=e.$matrix[3],u=e.$matrix[4],f=e.$matrix[6],d=e.$matrix[7];e.$matrix[0]=t*o+r*c,e.$matrix[1]=t*l+r*u,e.$matrix[3]=n*o+i*c,e.$matrix[4]=n*l+i*u,e.$matrix[6]=a*o+s*c+f,e.$matrix[7]=a*l+s*u+d})(this,e,t,r,n,i,a)}reset(){var e;(e=this).globalAlpha=1,e.globalCompositeOperation="normal",e.imageSmoothingEnabled=!1}beginPath(){var e;(e=this).$fillStyle.fill(1),e.$strokeStyle.fill(1),(()=>{for(T.length=0;B.length;)h(B.pop())})()}moveTo(e,t){C(e,t)}lineTo(e,t){((e,t)=>{T.length||C(e,t),R(e,t)||A(e,t,!1)})(e,t)}quadraticCurveTo(e,t,r,n){E(e,t,r,n)}fillStyle(e,t,r,n){this.$fillStyle[0]=e,this.$fillStyle[1]=t,this.$fillStyle[2]=r,this.$fillStyle[3]=n}strokeStyle(e,t,r,n){this.$strokeStyle[0]=e,this.$strokeStyle[1]=t,this.$strokeStyle[2]=r,this.$strokeStyle[3]=n}closePath(){(()=>{if(T.length<7)return;const e=+T[0],t=+T[1];R(e,t)||A(e,t,!1)})()}arc(e,t,r){((e,t,r)=>{const n=r,i=.5522847498307936*r;q(e+n,t+i,e+i,t+n,e,t+n),q(e-i,t+n,e-n,t+i,e-n,t),q(e-n,t-i,e-i,t-n,e,t-n),q(e+i,t-n,e+n,t-i,e+n,t)})(e,t,r)}bezierCurveTo(e,t,r,n,i,a){q(e,t,r,n,i,a)}fill(){(e=>{const t=O();if(!t.length)return;Ze.push(e);const r=tt(t);He(r.buffer),Qe.push(r.indexCount)})("fill")}gradientFill(e,t,r,n,i,a){((e,t,r,n,i,a)=>{const s=O();if(!s.length)return;Ze.push(0===e?"linear":"radial");const o=tt(s);He(o.buffer),Qe.push(o.indexCount),rt.push(t,r,n,i),1===e&&rt.push(a)})(e,t,r,n,i,a)}bitmapFill(e,t,r,n,i,a){((e,t,r,n,i,a)=>{const s=O();if(!s.length)return;Ze.push("bitmap");const o=tt(s);He(o.buffer),Qe.push(o.indexCount),Or.push(e,t,r,n,i,a)})(e,t,r,n,i,a)}stroke(){(()=>{const e=O(!0);if(!e.length)return;Ze.push("fill");const t=wt(e);He(t.buffer),Qe.push(t.indexCount)})()}gradientStroke(e,t,r,n,i,a){((e,t,r,n,i,a)=>{const s=O(!0);if(!s.length)return;Ze.push(0===e?"linear":"radial");const o=wt(s);He(o.buffer),Qe.push(o.indexCount),rt.push(t,r,n,i),1===e&&rt.push(a)})(e,t,r,n,i,a)}bitmapStroke(e,t,r,n,i,a){((e,t,r,n,i,a)=>{const s=O(!0);if(!s.length)return;Ze.push("bitmap");const o=wt(s);He(o.buffer),Qe.push(o.indexCount),Or.push(e,t,r,n,i,a)})(e,t,r,n,i,a)}clip(){(()=>{const e=n.currentAttachmentObject;if(!e)return;const t=je.get(e.clipLevel),i=t[0],o=t[1],l=t[2],c=t[3],u=Math.ceil(Math.abs(l-i)),f=Math.ceil(Math.abs(c-o));a(),r.scissor(i,e.height-o-f,u,f);const d=Ut();let h=De.get(e.clipLevel),p=0,m=null;const g=Qe.length;for(let t=0;t<g;t++){r.stencilMask(1<<h-1);const n=Qe[t];Mt.has(t)&&(m=Mt.get(t));const i=zt(!!m);m&&jt(i,m),Yt(i,d,p,n),p+=n,++h,h>7&&(Ht(),h=e.clipLevel+1)}De.set(e.clipLevel,h),$t(d),Je(),Pt(),s()})()}get currentAttachmentObject(){return te}get atlasAttachmentObject(){return Fe()}createNode(e,t){return er(e,t)}removeNode(e){(e=>{const t=Te[e.index];t&&t.dispose(e.x,e.y,e.w,e.h)})(e)}beginNodeRendering(e){var t,n,i,s;this.newDrawState=!0,Sn(e),t=e.x,n=e.y,i=e.w,s=e.h,a(),r.scissor(t,n,i+1,s+1),r.clear(r.COLOR_BUFFER_BIT|r.STENCIL_BUFFER_BIT),r.scissor(t,n,i,s)}endNodeRendering(){s()}drawFill(){(()=>{const e=Ut();l(),r.stencilMask(255),jn();let t=0,n=null;for(let r=0;r<Ze.length;r++)switch(Mt.has(r)&&(n=Mt.get(r)),Ze[r]){case"fill":{const r=Qe.shift();Gn(e,t,r,n),t+=r}break;case"linear":{const r=Qe.shift();Dn(e,t,r,n),t+=r}break;case"radial":{const r=Qe.shift();Nn(e,t,r,n),t+=r}break;case"bitmap":{const r=Qe.shift();qn(e,t,r,n),t+=r}}c(),jn(),$t(e),Je(),Pt()})()}drawDisplayObject(t,r,i,a,s,o){Sn(t),((t,r,i,a,s,o)=>{const l=o[0],c=o[1],u=o[2],f=n.globalAlpha,d=o[4]/255,h=o[5]/255,p=o[6]/255,m=n.$matrix;switch(n.globalCompositeOperation){case"normal":case"layer":case"add":case"screen":case"alpha":case"erase":case"copy":{if(Dt!==n.globalCompositeOperation||Ce!==t.index){Pe(Ce);const e=n.globalCompositeOperation;n.globalCompositeOperation=Dt,n.newDrawState=!0,n.drawArraysInstanced(),n.newDrawState=!0,n.globalCompositeOperation=e,Nt(n.globalCompositeOperation),Ee(t.index),Pe(t.index)}const r=sr();nr.pushDisplayObjectBuffer((t.x+.5)/e,(t.y+.5)/e,(t.w-1)/e,(t.h-1)/e,t.w,t.h,P,S,m[6],m[7],m[0],m[1],m[3],m[4],l,c,u,f,d,h,p,0),r.count++}break;default:{const e=n.currentAttachmentObject;n.drawArraysInstanced();const o=Math.ceil(Math.abs(a-r)),g=Math.ceil(Math.abs(s-i));let b=0,x=0,v=cr(t);if(1!==m[0]||0!==m[1]||0!==m[3]||1!==m[4]){const r=ye(o,g,!1),i=_(m[0],m[1],m[3],m[4],o/2,g/2),a=_(1,0,0,1,-t.w/2,-t.h/2),s=_(i[0]*a[0]+i[2]*a[1],i[1]*a[0]+i[3]*a[1],i[0]*a[2]+i[2]*a[3],i[1]*a[2]+i[3]*a[3],i[0]*a[4]+i[2]*a[5]+i[4],i[1]*a[4]+i[3]*a[5]+i[5]);n.save(),n.bind(r),n.setTransform(s[0],s[1],s[2],s[3],s[4],s[5]),b=s[4],x=s[5];const l=yr();_r(l,v.width,v.height),ke(v,!0),hr(l),K(v),v=r.texture,ce(r,!1),e&&n.bind(e),n.restore()}(b||x)&&(m[6]-=b,m[7]-=x);const y=gr(m[6],m[7],o,g),w=ye(o,g,!1);n.bind(w),ur(y,v);const M=or(n.globalCompositeOperation);vr(M,l,c,u,f,d,h,p,0),hr(M),e&&n.bind(e),xr(w.texture),(b||x)&&(m[6]+=b,m[7]+=x),K(v),K(y),ce(w),Nt(n.globalCompositeOperation),Ee(t.index),Pe(t.index)}}})(t,r,i,a,s,o)}drawArraysInstanced(){(()=>{const e=sr();e.count&&(lr(),Sr(Dt),Mr(e),e.clear())})()}clearArraysInstanced(){sr().clear()}transferMainCanvas(){(()=>{const e=n.$mainAttachmentObject;n.bind(e),r.bindFramebuffer(r.READ_FRAMEBUFFER,Z),r.bindFramebuffer(r.DRAW_FRAMEBUFFER,null);const t=e.width,i=e.height;r.blitFramebuffer(0,0,t,i,0,0,t,i,r.COLOR_BUFFER_BIT,r.NEAREST),r.bindFramebuffer(r.DRAW_FRAMEBUFFER,J),r.bindFramebuffer(r.FRAMEBUFFER,Z)})()}drawPixels(e,t){((e,t)=>{const r=Tr(e.w,e.h,t),n=fr();dr(n,e.w,e.h),Xt(),hr(n),K(r)})(e,t)}drawElement(e,t,r=!1){Br(e,t)}beginMask(){(()=>{const e=n.currentAttachmentObject;e&&(e.mask=!0,e.clipLevel++,De.set(e.clipLevel,e.clipLevel),ze()||(Ve(!0),l(),r.enable(r.SAMPLE_ALPHA_TO_COVERAGE),r.stencilFunc(r.ALWAYS,0,255),r.stencilOp(r.ZERO,r.INVERT,r.INVERT),r.colorMask(!1,!1,!1,!1)))})()}setMaskBounds(e,t,i,s){((e,t,i,s)=>{const o=n.currentAttachmentObject;if(!o)return;je.set(o.clipLevel,g(e,t,i,s));const l=Math.ceil(Math.abs(i-e)),c=Math.ceil(Math.abs(s-t));a(),r.scissor(e,o.height-t-c,l,c)})(e,t,i,s)}endMask(){Le()}leaveMask(){this.drawArraysInstanced(),(()=>{const e=n.currentAttachmentObject;if(!e)return;const t=e.clipLevel,i=je.get(t),o=i[0],l=i[1],u=i[2],f=i[3];je.delete(t),De.delete(t),b(i);const d=Math.ceil(Math.abs(u-o)),h=Math.ceil(Math.abs(f-l));if(a(),r.scissor(o,e.height-l-h,d,h),--e.clipLevel,!e.clipLevel)return e.mask=!1,Ve(!1),r.clear(r.STENCIL_BUFFER_BIT),c(),s(),De.clear(),void je.clear();r.stencilMask(1<<e.clipLevel),r.stencilFunc(r.ALWAYS,0,255),r.stencilOp(r.REPLACE,r.REPLACE,r.REPLACE),r.colorMask(!1,!1,!1,!1),Yt(Kt(),Et(),0,6),Le()})()}useGrid(e){(e=>{Mt.set(Qe.length,e)})(e)}applyFilter(e,t,r,n,i,a,s,o,l,c,u){this.drawArraysInstanced(),wn(e,t,r,n,i,a,s,o,l,c,u)}containerBeginLayer(e,t){this.drawArraysInstanced(),((e,t)=>{n.drawArraysInstanced();const r=n.$mainAttachmentObject;Mn.push(r);const i=ye(e,t,!1);n.$mainAttachmentObject=i,n.bind(i)})(e,t)}containerEndLayer(e,t,r,i,a,s,o,l){((e,t,r,i,a,s,o,l)=>{n.drawArraysInstanced();const c=n.$mainAttachmentObject;let u=null;if(i&&a&&s){u=gr(0,0,c.width,c.height),n.$mainAttachmentObject=Mn.pop(),ce(c),n.bind(n.$mainAttachmentObject),Cr.x=0,Cr.y=0;for(let e=0;s.length>e;)switch(s[e++]){case 0:u=ln(u,t,s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],Boolean(s[e++]));break;case 1:u=kr(u,t,s[e++],s[e++],s[e++]);break;case 2:for(let t=0;t<20;++t)Pn[t]=s[e++];u=Lr(u,Pn);break;case 3:{const t=s[e++],r=s[e++],n=t*r,i=s.subarray(e,e+n);e+=n,u=pn(u,t,r,i,s[e++],s[e++],Boolean(s[e++]),Boolean(s[e++]),s[e++],s[e++])}break;case 4:{const t=s[e++],r=new Uint8Array(t);r.set(s.subarray(e,e+t)),e+=t,u=mn(u,r,s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++])}break;case 5:u=sn(u,t,s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],Boolean(s[e++]),Boolean(s[e++]),Boolean(s[e++]));break;case 6:u=nn(u,t,s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],Boolean(s[e++]),Boolean(s[e++]));break;case 7:{const r=s[e++],n=s[e++];let i=s[e++];const a=s.subarray(e,e+i);e+=i,i=s[e++];const o=s.subarray(e,e+i);e+=i,i=s[e++];const l=s.subarray(e,e+i);e+=i,u=un(u,t,r,n,a,o,l,s[e++],s[e++],s[e++],s[e++],s[e++],Boolean(s[e++]))}break;case 8:{const r=s[e++],n=s[e++];let i=s[e++];const a=s.subarray(e,e+i);e+=i,i=s[e++];const o=s.subarray(e,e+i);e+=i,i=s[e++];const l=s.subarray(e,e+i);e+=i,u=dn(u,t,r,n,a,o,l,s[e++],s[e++],s[e++],s[e++],s[e++],Boolean(s[e++]))}}if(o&&(yn.set(o,"fKey",l),yn.set(o,"fTexture",u)),u){const i=Math.sqrt(t[0]*t[0]+t[1]*t[1]),s=Math.sqrt(t[2]*t[2]+t[3]*t[3]),o=F,l=a[0]*(i/o),c=a[1]*(s/o);n.reset(),n.globalCompositeOperation=e,gn(u,r,l+t[4],c+t[5])}}else u=gr(0,0,c.width,c.height),n.$mainAttachmentObject=Mn.pop(),ce(c),n.bind(n.$mainAttachmentObject),u&&(n.reset(),n.globalCompositeOperation=e,gn(u,r,t[4],t[5]),K(u));n.bind(n.$mainAttachmentObject)})(e,t,r,i,a,s,o,l)}containerDrawCachedFilter(e,t,r,i,a,s){((e,t,r,i,a,s)=>{if(yn.get(a,"fKey")!==s)return;const o=yn.get(a,"fTexture");if(!o)return;const l=Math.sqrt(t[0]*t[0]+t[1]*t[1]),c=Math.sqrt(t[2]*t[2]+t[3]*t[3]),u=F,f=i[0]*(l/u),d=i[1]*(c/u);n.drawArraysInstanced(),n.reset(),n.globalCompositeOperation=e,gn(o,r,f+t[4],d+t[5])})(e,t,r,i,a,s)}async createImageBitmap(e,t){return await(async(e,t)=>{const i=mr(0,0,e,t);ke(i),r.bindFramebuffer(r.FRAMEBUFFER,oe),r.framebufferTexture2D(r.FRAMEBUFFER,r.COLOR_ATTACHMENT0,r.TEXTURE_2D,i.resource,0);const a=new Uint8Array(e*t*4),s=n.$mainAttachmentObject;a.byteLength>Xn&&(Xn=p(a.byteLength),r.bufferData(r.PIXEL_PACK_BUFFER,Xn,r.STREAM_READ)),r.readPixels(0,s.height-t,e,t,r.RGBA,r.UNSIGNED_BYTE,0);const o=r.fenceSync(r.SYNC_GPU_COMMANDS_COMPLETE,0);await new Promise(e=>{const t=()=>{if(r.clientWaitSync(o,r.SYNC_FLUSH_COMMANDS_BIT,0)!==r.TIMEOUT_EXPIRED)return r.deleteSync(o),r.getBufferSubData(r.PIXEL_PACK_BUFFER,0,a),e();requestAnimationFrame(t)};t()}),r.bindFramebuffer(r.FRAMEBUFFER,Z);for(let e=0;e<a.length;e+=4){const t=a[e+3];if(0===t||255===t)continue;const r=Yn[t];a[e]=Math.min(255,Math.round(a[e]*r)),a[e+1]=Math.min(255,Math.round(a[e+1]*r)),a[e+2]=Math.min(255,Math.round(a[e+2]*r))}return await createImageBitmap(new ImageData(new Uint8ClampedArray(a),e,t),{imageOrientation:"flipY",premultiplyAlpha:"none",colorSpaceConversion:"none"})})(e,t)}};class Hn{static setDevice(e){Hn.device=e}static getDevice(){if(!Hn.device)throw new Error("GPUDevice is not initialized");return Hn.device}static setDevicePixelRatio(e){Hn.devicePixelRatio=e}static getDevicePixelRatio(){return Hn.devicePixelRatio}static setRenderMaxSize(e){Hn.renderMaxSize=e}static getRenderMaxSize(){return Hn.renderMaxSize}static createFloat32Array(e){return new Float32Array(e)}static createArray(){return[]}static getFloat32Array4(){return Hn.float32Array4Pool.length>0?Hn.float32Array4Pool.pop():new Float32Array(4)}static poolFloat32Array4(e){4===e.length&&Hn.float32Array4Pool.push(e)}}Object.defineProperty(Hn,"device",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(Hn,"devicePixelRatio",{enumerable:!0,configurable:!0,writable:!0,value:1}),Object.defineProperty(Hn,"renderMaxSize",{enumerable:!0,configurable:!0,writable:!0,value:8192}),Object.defineProperty(Hn,"float32Array4Pool",{enumerable:!0,configurable:!0,writable:!0,value:[]});let Qn=null;const Zn=(e,t,r,n,i=.25)=>{const a=[],s=(e,t,r,n,o)=>{const l=((e,t,r,n)=>{const i=n.x-e.x,a=n.y-e.y,s=i*i+a*a;if(s<1e-10){const n=(t.x-e.x)*(t.x-e.x)+(t.y-e.y)*(t.y-e.y),i=(r.x-e.x)*(r.x-e.x)+(r.y-e.y)*(r.y-e.y);return Math.max(n,i)}const o=(t.x-e.x)*a-(t.y-e.y)*i,l=o*o/s,c=(r.x-e.x)*a-(r.y-e.y)*i,u=c*c/s;return Math.max(l,u)})(e,t,r,n);if(l<=i||o>=8){const e={x:.5*(t.x+r.x),y:.5*(t.y+r.y)};return void a.push({ctrl:e,end:n})}const c=((e,t,r,n)=>{const i={x:.5*(e.x+t.x),y:.5*(e.y+t.y)},a=.5*(t.x+r.x),s=.5*(t.y+r.y),o={x:.5*(r.x+n.x),y:.5*(r.y+n.y)},l={x:.5*(i.x+a),y:.5*(i.y+s)},c={x:.5*(a+o.x),y:.5*(s+o.y)},u={x:.5*(l.x+c.x),y:.5*(l.y+c.y)};return{first:[e,i,l,u],second:[u,c,o,n]}})(e,t,r,n);s(c.first[0],c.first[1],c.first[2],c.first[3],o+1),s(c.second[0],c.second[1],c.second[2],c.second[3],o+1)};return s(e,t,r,n,0),a};class Jn{constructor(){Object.defineProperty(this,"$currentPath",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$vertices",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$currentX",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$currentY",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$startX",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$startY",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$flatnessThreshold",{enumerable:!0,configurable:!0,writable:!0,value:.25}),this.$currentPath=[],this.$vertices=[],this.$currentX=0,this.$currentY=0,this.$startX=0,this.$startY=0}beginPath(){this.$currentPath=[],this.$vertices=[],this.$currentX=0,this.$currentY=0,this.$startX=0,this.$startY=0}moveTo(e,t){this.$currentPath.length>=6&&this.$vertices.push(this.$currentPath),this.$currentPath=[e,t,!1],this.$currentX=e,this.$currentY=t,this.$startX=e,this.$startY=t}lineTo(e,t){e===this.$currentX&&t===this.$currentY||(this.$currentPath.push(e,t,!1),this.$currentX=e,this.$currentY=t)}quadraticCurveTo(e,t,r,n){this.$currentPath.push(e,t,!0),this.$currentPath.push(r,n,!1),this.$currentX=r,this.$currentY=n}setScale(e){this.$flatnessThreshold=(e=>{const t=.25/(e*e);return Math.max(.0625,Math.min(4,t))})(e)}bezierCurveTo(e,t,r,n,i,a){const s={x:this.$currentX,y:this.$currentY},o=Zn(s,{x:e,y:t},{x:r,y:n},{x:i,y:a},this.$flatnessThreshold);for(const e of o)this.$currentPath.push(e.ctrl.x,e.ctrl.y,!0),this.$currentPath.push(e.end.x,e.end.y,!1);this.$currentX=i,this.$currentY=a}arc(e,t,r){const n=r,i=.5522847498307936*r;this.bezierCurveTo(e+n,t+i,e+i,t+n,e,t+n),this.bezierCurveTo(e-i,t+n,e-n,t+i,e-n,t),this.bezierCurveTo(e-n,t-i,e-i,t-n,e,t-n),this.bezierCurveTo(e+i,t-n,e+n,t-i,e+n,t);const a=this.$currentPath.length;a>=3&&(this.$currentPath[a-3]=this.$startX,this.$currentPath[a-2]=this.$startY),this.$currentX=this.$startX,this.$currentY=this.$startY}closePath(){this.$currentPath.length>=3&&(this.$currentX===this.$startX&&this.$currentY===this.$startY||this.$currentPath.push(this.$startX,this.$startY,!1))}get $getVertices(){const e=[...this.$vertices];return this.$currentPath.length>=9&&e.push(this.$currentPath),e}generateVertices(){const e=this.$getVertices,t=[];for(const r of e){if(r.length<9)continue;const e=[];for(let t=0;t<r.length;t+=3)e.push({x:r[t],y:r[t+1]});for(let r=1;r<e.length-1;r++)t.push(e[0].x,e[0].y,e[r].x,e[r].y,e[r+1].x,e[r+1].y)}return new Float32Array(t)}getCurrentPath(){const e=[];for(let t=0;t<this.$currentPath.length;t+=3)e.push({x:this.$currentPath[t],y:this.$currentPath[t+1]});return e}getAllPaths(){const e=[];for(const t of this.$vertices){const r=[];for(let e=0;e<t.length;e+=3)r.push({x:t[e],y:t[e+1]});r.length>0&&e.push(r)}if(this.$currentPath.length>=3){const t=[];for(let e=0;e<this.$currentPath.length;e+=3)t.push({x:this.$currentPath[e],y:this.$currentPath[e+1]});t.length>0&&e.push(t)}return e}getVerticesForStroke(){const e=[...this.$vertices];return this.$currentPath.length>=6&&e.push(this.$currentPath),e}reset(){this.$currentPath=[],this.$vertices=[],this.$currentX=0,this.$currentY=0,this.$startX=0,this.$startY=0}}const ei=(e,t)=>{const r=t.size;let n=e.get(r);n||(n=[],e.set(r,n)),n.length>=32?t.destroy():n.push(t)},ti=(e,t)=>{const r=t.size;let n=e.get(r);n||(n=[],e.set(r,n)),n.length>=32?t.destroy():n.push(t)},ri=(e,t,r,n)=>{const i=256*Math.ceil(r/256);let a=null,s=1/0;for(const e of t)if(!e.inUse&&e.size>=i){const t=e.size-i;t<s&&(a=e,s=t)}if(a)return a.inUse=!0,a.lastUsedFrame=n,a.buffer;const o=Math.max(i,16384),l=((e,t)=>e.createBuffer({size:t.size,usage:t.usage|GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_DST|GPUBufferUsage.VERTEX,label:t.label||"storage_buffer"}))(e,{size:o,usage:GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_DST|GPUBufferUsage.VERTEX,label:`storage_buffer_${t.length}`});return t.push({buffer:l,size:o,inUse:!0,lastUsedFrame:n}),l},ni=(e,t,r,n=0,i=0)=>{const a=new Uint32Array([t,r,n,i]),s=e.createBuffer({size:a.byteLength,usage:GPUBufferUsage.INDIRECT|GPUBufferUsage.COPY_DST,mappedAtCreation:!0,label:"indirect_buffer"});return new Uint32Array(s.getMappedRange()).set(a),s.unmap(),s},ii=(e,t,r,n,i=0,a=0)=>{const s=new Uint32Array([r,n,i,a]);e.queue.writeBuffer(t,0,s)};class ai{constructor(e,t=65536){Object.defineProperty(this,"device",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"buffer",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"offset",{enumerable:!0,configurable:!0,writable:!0,value:0}),Object.defineProperty(this,"capacity",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"alignment",{enumerable:!0,configurable:!0,writable:!0,value:256}),Object.defineProperty(this,"pendingDestroyBuffers",{enumerable:!0,configurable:!0,writable:!0,value:[]}),Object.defineProperty(this,"stagingBuffer",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"stagingFloat32",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"dirtyEnd",{enumerable:!0,configurable:!0,writable:!0,value:0}),this.device=e,this.capacity=t,this.stagingBuffer=new ArrayBuffer(t),this.stagingFloat32=new Float32Array(this.stagingBuffer)}resetFrame(){this.offset=0,this.dirtyEnd=0;for(const e of this.pendingDestroyBuffers)e.destroy();this.pendingDestroyBuffers.length=0}getBuffer(){return this.buffer||(this.buffer=this.device.createBuffer({size:this.capacity,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST})),this.buffer}allocate(e){this.buffer||this.getBuffer();const t=this.offset,r=e.byteLength;if(t+r>this.capacity){this.flush(),this.capacity*=2;const e=this.buffer;this.buffer=this.device.createBuffer({size:this.capacity,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST}),e&&this.pendingDestroyBuffers.push(e),this.stagingBuffer=new ArrayBuffer(this.capacity),this.stagingFloat32=new Float32Array(this.stagingBuffer)}this.stagingFloat32.set(e,t/4);const n=t+r;return n>this.dirtyEnd&&(this.dirtyEnd=n),this.offset=t+Math.ceil(r/this.alignment)*this.alignment,t}flush(){this.dirtyEnd>0&&this.buffer&&(this.device.queue.writeBuffer(this.buffer,0,this.stagingBuffer,0,this.dirtyEnd),this.dirtyEnd=0)}dispose(){this.buffer&&(this.buffer.destroy(),this.buffer=null);for(const e of this.pendingDestroyBuffers)e.destroy();this.pendingDestroyBuffers.length=0}}class si{constructor(e){Object.defineProperty(this,"device",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"vertexBuffers",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"uniformBuffers",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"vertexBufferBuckets",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"uniformBufferBuckets",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"storageBufferPool",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"indirectBuffer",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"indirectBufferPool",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"frameIndirectBuffers",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"frameNumber",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"unitRectBuffer",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"frameVertexPoolBuffers",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"frameUniformPoolBuffers",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"dynamicUniform",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.device=e,this.vertexBuffers=new Map,this.uniformBuffers=new Map,this.vertexBufferBuckets=new Map,this.uniformBufferBuckets=new Map,this.storageBufferPool=[],this.indirectBuffer=null,this.indirectBufferPool=[],this.frameIndirectBuffers=[],this.frameNumber=0,this.unitRectBuffer=null,this.frameVertexPoolBuffers=[],this.frameUniformPoolBuffers=[],this.dynamicUniform=new ai(e)}createVertexBuffer(e,t){const r=this.device.createBuffer({size:t.byteLength,usage:GPUBufferUsage.VERTEX|GPUBufferUsage.COPY_DST,mappedAtCreation:!0});return new Float32Array(r.getMappedRange()).set(t),r.unmap(),this.vertexBuffers.set(e,r),r}createUniformBuffer(e,t){const r=this.device.createBuffer({size:t,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});return this.uniformBuffers.set(e,r),r}updateUniformBuffer(e,t){const r=this.uniformBuffers.get(e);r&&this.device.queue.writeBuffer(r,0,t.buffer,t.byteOffset,t.byteLength)}getVertexBuffer(e){return this.vertexBuffers.get(e)}getUniformBuffer(e){return this.uniformBuffers.get(e)}createRectVertices(e,t,r,n){return((e,t,r,n)=>new Float32Array([e,t,0,0,e+r,t,1,0,e,t+n,0,1,e+r,t,1,0,e+r,t+n,1,1,e,t+n,0,1]))(e,t,r,n)}acquireVertexBuffer(e,t){const r=((e,t,r,n)=>{const i=(a=r,a--,a|=a>>1,a|=a>>2,a|=a>>4,a|=a>>8,1+(a|=a>>16));var a;const s=t.get(i);let o;return s&&s.length>0?(o=s.pop(),n&&e.queue.writeBuffer(o,0,n.buffer,n.byteOffset,n.byteLength)):n?(o=e.createBuffer({size:i,usage:GPUBufferUsage.VERTEX|GPUBufferUsage.COPY_DST,mappedAtCreation:!0}),new Float32Array(o.getMappedRange()).set(n),o.unmap()):o=e.createBuffer({size:i,usage:GPUBufferUsage.VERTEX|GPUBufferUsage.COPY_DST}),o})(this.device,this.vertexBufferBuckets,e,t);return this.frameVertexPoolBuffers.push(r),r}releaseVertexBuffer(e){ei(this.vertexBufferBuckets,e)}acquireUniformBuffer(e){const t=((e,t,r)=>{const n=16*Math.ceil(r/16),i=t.get(n);return i&&i.length>0?i.pop():e.createBuffer({size:n,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST})})(this.device,this.uniformBufferBuckets,e);return this.frameUniformPoolBuffers.push(t),t}acquireAndWriteUniformBuffer(e,t){const r=t??e.byteLength,n=this.acquireUniformBuffer(r);return this.device.queue.writeBuffer(n,0,e.buffer,e.byteOffset,r),n}releaseUniformBuffer(e){ti(this.uniformBufferBuckets,e)}destroyBuffer(e){const t=this.vertexBuffers.get(e);t&&(t.destroy(),this.vertexBuffers.delete(e));const r=this.uniformBuffers.get(e);r&&(r.destroy(),this.uniformBuffers.delete(e))}dispose(){for(const e of this.vertexBuffers.values())e.destroy();this.vertexBuffers.clear();for(const e of this.uniformBuffers.values())e.destroy();this.uniformBuffers.clear();for(const e of this.vertexBufferBuckets.values())for(const t of e)t.destroy();this.vertexBufferBuckets.clear();for(const e of this.uniformBufferBuckets.values())for(const t of e)t.destroy();this.uniformBufferBuckets.clear();for(const e of this.storageBufferPool)e.buffer.destroy();this.storageBufferPool=[],this.indirectBuffer&&(this.indirectBuffer.destroy(),this.indirectBuffer=null);for(const e of this.indirectBufferPool)e.destroy();this.indirectBufferPool=[];for(const e of this.frameIndirectBuffers)e.destroy();this.frameIndirectBuffers=[],this.unitRectBuffer&&(this.unitRectBuffer.destroy(),this.unitRectBuffer=null),this.frameVertexPoolBuffers.length=0,this.frameUniformPoolBuffers.length=0,this.dynamicUniform.dispose()}getPoolStats(){let e=0;for(const t of this.vertexBufferBuckets.values())e+=t.length;let t=0;for(const e of this.uniformBufferBuckets.values())t+=e.length;return{vertexPoolSize:e,uniformPoolSize:t}}clearFrameBuffers(){for(const e of this.vertexBuffers.values())e.destroy();this.vertexBuffers.clear();for(const e of this.uniformBuffers.values())e.destroy();this.uniformBuffers.clear();for(const e of this.frameVertexPoolBuffers)ei(this.vertexBufferBuckets,e);this.frameVertexPoolBuffers.length=0;for(const e of this.frameUniformPoolBuffers)ti(this.uniformBufferBuckets,e);this.frameUniformPoolBuffers.length=0;for(const e of this.frameIndirectBuffers)this.indirectBufferPool.push(e);this.frameIndirectBuffers.length=0,this.releaseAllStorageBuffers(),this.dynamicUniform.resetFrame(),this.frameNumber++,this.frameNumber%60==0&&((e,t,r=60)=>{for(let n=e.length-1;n>=0;n--){const i=e[n];!i.inUse&&t-i.lastUsedFrame>r&&(i.buffer.destroy(),e.splice(n,1))}})(this.storageBufferPool,this.frameNumber)}releaseAllStorageBuffers(){for(const e of this.storageBufferPool)e.inUse=!1}acquireStorageBuffer(e){return ri(this.device,this.storageBufferPool,e,this.frameNumber)}releaseStorageBuffer(e){((e,t)=>{for(const r of e)if(r.buffer===t)return void(r.inUse=!1)})(this.storageBufferPool,e)}writeStorageBuffer(e,t){this.device.queue.writeBuffer(e,0,t.buffer,t.byteOffset,t.byteLength)}getOrCreateIndirectBuffer(e,t,r=0,n=0){return this.indirectBuffer?ii(this.device,this.indirectBuffer,e,t,r,n):this.indirectBuffer=ni(this.device,e,t,r,n),this.indirectBuffer}createIndirectBuffer(e,t,r=0,n=0){let i=this.indirectBufferPool.pop();return i?ii(this.device,i,e,t,r,n):i=ni(this.device,e,t,r,n),this.frameIndirectBuffers.push(i),i}getUnitRectBuffer(){if(!this.unitRectBuffer){const e=this.createRectVertices(0,0,1,1);this.unitRectBuffer=this.device.createBuffer({size:e.byteLength,usage:GPUBufferUsage.VERTEX|GPUBufferUsage.COPY_DST,mappedAtCreation:!0}),new Float32Array(this.unitRectBuffer.getMappedRange()).set(e),this.unitRectBuffer.unmap()}return this.unitRectBuffer}getFrameNumber(){return this.frameNumber}getStoragePoolStats(){const e=this.storageBufferPool.filter(e=>e.inUse).length;return{storagePoolSize:this.storageBufferPool.length,storagePoolInUse:e}}}class oi{constructor(e){Object.defineProperty(this,"device",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"textures",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"samplers",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.device=e,this.textures=new Map,this.samplers=new Map,((e,t)=>{const r=e.createSampler({magFilter:"linear",minFilter:"linear",mipmapFilter:"linear",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"});t.set("linear",r);const n=e.createSampler({magFilter:"nearest",minFilter:"nearest",mipmapFilter:"nearest",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"});t.set("nearest",n);const i=e.createSampler({magFilter:"nearest",minFilter:"linear",mipmapFilter:"nearest",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"});t.set("atlas_instanced_sampler",i);const a=e.createSampler({magFilter:"linear",minFilter:"linear",mipmapFilter:"linear",addressModeU:"repeat",addressModeV:"repeat"});t.set("repeat",a)})(e,this.samplers)}createTexture(e,t,r,n="rgba8unorm"){const i=this.device.createTexture({size:{width:t,height:r},format:n,usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.RENDER_ATTACHMENT});return this.textures.set(e,i),i}createTextureFromPixels(e,t,r,n){return((e,t,r,n,i,a)=>{const s=e.createTexture({size:{width:i,height:a},format:"rgba8unorm",usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.RENDER_ATTACHMENT});return e.queue.writeTexture({texture:s},n.buffer,{bytesPerRow:4*i,offset:n.byteOffset},{width:i,height:a}),t.set(r,s),s})(this.device,this.textures,e,t,r,n)}createTextureFromImageBitmap(e,t){return((e,t,r,n)=>{const i=e.createTexture({size:{width:n.width,height:n.height},format:"rgba8unorm",usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.RENDER_ATTACHMENT});return e.queue.copyExternalImageToTexture({source:n,flipY:!0},{texture:i,premultipliedAlpha:!0},{width:n.width,height:n.height}),t.set(r,i),i})(this.device,this.textures,e,t)}updateTexture(e,t,r,n){const i=this.textures.get(e);i&&this.device.queue.writeTexture({texture:i},t.buffer,{bytesPerRow:4*r,offset:t.byteOffset},{width:r,height:n})}getTexture(e){return this.textures.get(e)}getSampler(e){return this.samplers.get(e)}createSampler(e,t=!0){const r=this.samplers.get(e);if(r)return r;const n=this.device.createSampler({magFilter:t?"linear":"nearest",minFilter:t?"linear":"nearest",mipmapFilter:t?"linear":"nearest",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"});return this.samplers.set(e,n),n}destroyTexture(e){const t=this.textures.get(e);t&&(t.destroy(),this.textures.delete(e))}dispose(){for(const e of this.textures.values())e.destroy();this.textures.clear(),this.samplers.clear()}}const li={r:0,g:0,b:0,a:0},ci={view:null,clearValue:li,loadOp:"clear",storeOp:"store"},ui={colorAttachments:[ci]},fi={view:null,clearValue:{r:0,g:0,b:0,a:0},loadOp:"load",storeOp:"store"},di={view:null,stencilClearValue:0,stencilLoadOp:"clear",stencilStoreOp:"store"},hi={colorAttachments:[fi],depthStencilAttachment:di};class pi{constructor(e){Object.defineProperty(this,"device",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"buckets",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"currentFrame",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"totalCount",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.device=e,this.buckets=new Map,this.currentFrame=0,this.totalCount=[0]}beginFrame(){this.currentFrame++,this.currentFrame%60==0&&((e,t,r,n)=>{const i=t-r;for(const[t,r]of e){for(let e=r.length-1;e>=0;e--){const t=r[e];!t.inUse&&t.lastUsedFrame<i&&(t.texture.destroy(),r.splice(e,1),n[0]--)}0===r.length&&e.delete(t)}})(this.buckets,this.currentFrame,180,this.totalCount)}acquire(e,t,r="rgba8unorm",n=GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.RENDER_ATTACHMENT){return((e,t,r,n,i,a,s,o,l)=>{const c=((e,t,r)=>`${e}_${t}_${r}`)(r,n,i),u=t.get(c);if(u)for(let e=0;e<u.length;e++){const t=u[e];if(!t.inUse)return t.inUse=!0,t.lastUsedFrame=s,t.texture}if(l[0]>=o){let e=1/0,r="",n=-1;for(const[i,a]of t)for(let t=0;t<a.length;t++){const s=a[t];!s.inUse&&s.lastUsedFrame<e&&(e=s.lastUsedFrame,r=i,n=t)}if(n>=0){const e=t.get(r);e[n].texture.destroy(),e.splice(n,1),0===e.length&&t.delete(r),l[0]--}}const f=e.createTexture({size:{width:r,height:n},format:i,usage:a}),d={texture:f,width:r,height:n,format:i,lastUsedFrame:s,inUse:!0};return u?u.push(d):t.set(c,[d]),l[0]++,f})(this.device,this.buckets,e,t,r,n,this.currentFrame,32,this.totalCount)}release(e){((e,t,r)=>{for(const n of e.values())for(let e=0;e<n.length;e++)if(n[e].texture===t)return n[e].inUse=!1,void(n[e].lastUsedFrame=r)})(this.buckets,e,this.currentFrame)}getStats(){let e=0,t=0;for(const r of this.buckets.values())for(const n of r)n.inUse?e++:t++;return{total:this.totalCount[0],inUse:e,available:t}}dispose(){for(const e of this.buckets.values())for(const t of e)t.texture.destroy();this.buckets.clear(),this.totalCount[0]=0}}class mi{constructor(e,t){Object.defineProperty(this,"device",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"format",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"attachments",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"currentAttachment",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"idCounter",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"texturePool",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"pendingReleases",{enumerable:!0,configurable:!0,writable:!0,value:[]}),this.device=e,this.format=t,this.attachments=new Map,this.currentAttachment=null,this.idCounter={nextId:1,textureId:1,stencilId:1},this.texturePool=new pi(e)}beginFrame(){this.texturePool.beginFrame()}createAttachment(e,t,r,n=!1,i=!1){return((e,t,r,n,i,a,s,o,l)=>{const c="atlas"===n||n.startsWith("atlas_"),u=c||n.startsWith("temp_")?"rgba8unorm":t,f=s||c&&!0,d=f?4:1,h=e.createTexture({size:{width:i,height:a},format:u,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC|GPUTextureUsage.COPY_DST}),p=h.createView(),m={id:l.textureId++,resource:h,view:p,width:i,height:a,area:i*a,smooth:!0};let g=null;if(f){const t=e.createTexture({size:{width:i,height:a},format:u,sampleCount:d,usage:GPUTextureUsage.RENDER_ATTACHMENT}),r=t.createView();g={id:l.textureId++,resource:t,view:r,width:i,height:a,area:i*a,smooth:!0}}let b=null,x=null;if(c||"main"===n||o){const t=e.createTexture({size:{width:i,height:a},format:"stencil8",usage:GPUTextureUsage.RENDER_ATTACHMENT}),r=t.createView();if(b={id:l.stencilId++,resource:t,view:r,width:i,height:a,area:i*a,dirty:!1},f){const t=e.createTexture({size:{width:i,height:a},format:"stencil8",sampleCount:d,usage:GPUTextureUsage.RENDER_ATTACHMENT}),r=t.createView();x={id:l.stencilId++,resource:t,view:r,width:i,height:a,area:i*a,dirty:!1}}}const v={id:l.nextId++,width:i,height:a,clipLevel:0,msaa:f,mask:o,color:null,texture:m,stencil:b,msaaTexture:g,msaaStencil:x};return r.set(n,v),v})(this.device,this.format,this.attachments,e,t,r,n,i,this.idCounter)}getAttachment(e){return this.attachments.get(e)}setCurrentAttachment(e){this.currentAttachment=e}getCurrentAttachment(){return this.currentAttachment}createRenderPassDescriptor(e,t=0,r=0,n=0,i=0,a="clear",s=null){return((e,t=0,r=0,n=0,i=0,a="clear",s=null)=>(ci.view=e,li.r=t,li.g=r,li.b=n,li.a=i,ci.loadOp=a,ci.resolveTarget=s??void 0,ui))(e,t,r,n,i,a,s)}createStencilRenderPassDescriptor(e,t,r="load",n="clear",i=null){return((e,t,r="load",n="clear",i=null)=>(fi.view=e,fi.loadOp=r,fi.resolveTarget=i??void 0,di.view=t,di.stencilLoadOp=n,hi))(e,t,r,n,i)}destroyAttachment(e){const t=this.attachments.get(e);t&&(t.texture&&t.texture.resource.destroy(),t.stencil&&t.stencil.resource.destroy(),this.attachments.delete(e))}resizeAttachment(e,t,r){return this.destroyAttachment(e),this.createAttachment(e,t,r)}createTemporaryAttachment(e,t){const r=`temp_${this.idCounter.nextId}`,n=GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC|GPUTextureUsage.COPY_DST|GPUTextureUsage.STORAGE_BINDING,i=this.texturePool.acquire(e,t,"rgba8unorm",n),a=i.createView(),s={id:this.idCounter.textureId++,resource:i,view:a,width:e,height:t,area:e*t,smooth:!0},o={id:this.idCounter.nextId++,width:e,height:t,clipLevel:0,msaa:!1,mask:!1,color:null,texture:s,stencil:null,msaaTexture:null,msaaStencil:null};return this.attachments.set(r,o),o}releaseTemporaryAttachment(e){((e,t,r)=>{for(const[n,i]of e.entries())if(i.id===r.id){e.delete(n),t.push(i);break}})(this.attachments,this.pendingReleases,e)}flushPendingReleases(){for(const e of this.pendingReleases)e.texture&&this.texturePool.release(e.texture.resource),e.msaaTexture&&e.msaaTexture.resource.destroy(),e.stencil&&e.stencil.resource.destroy(),e.msaaStencil&&e.msaaStencil.resource.destroy();this.pendingReleases=[]}dispose(){for(const e of this.attachments.values())e.texture&&e.texture.resource.destroy(),e.stencil&&e.stencil.resource.destroy();this.attachments.clear(),this.currentAttachment=null,this.texturePool.dispose()}}const gi=(e,t,r,n,i)=>{for(let e=0;e<t.length;e++){const i=t[e];if(i.width>=r&&i.height>=n)return t.splice(e,1),i.dirty=!1,i}return((e,t,r,n)=>{const i=e.createTexture({size:{width:t,height:r},format:"depth24plus-stencil8",usage:GPUTextureUsage.RENDER_ATTACHMENT});return{id:n.stencilId++,resource:i,view:i.createView(),width:t,height:r,area:t*r,dirty:!1}})(e,r,n,i)},bi=(e,t,r,n,i)=>{for(let e=0;e<t.length;e++){const a=t[e];if(a.width>=r&&a.height>=n)return t.splice(e,1),a.stencil=i,a.dirty=!1,a}return((e,t,r,n)=>{const i=e.createTexture({size:{width:t,height:r},format:"rgba8unorm",usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC|GPUTextureUsage.COPY_DST});return{resource:i,view:i.createView(),stencil:n,width:t,height:r,area:t*r,dirty:!1}})(e,r,n,i)},xi=(e,t,r,n,i,a)=>{const s=`${r}x${n}_smooth`;if(t.has(s)){const e=t.get(s);if(e.length>0)return e.pop()}return((e,t,r,n,i)=>{const a=e.createTexture({size:{width:t,height:r},format:"rgba8unorm",usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC|GPUTextureUsage.COPY_DST}),s=a.createView();return{id:i.textureId++,resource:a,view:s,width:t,height:r,area:t*r,smooth:n}})(e,r,n,i,a)},vi={r:0,g:0,b:0,a:0},yi={view:null,loadOp:"clear",storeOp:"store",clearValue:vi},_i={view:null,depthLoadOp:"clear",depthStoreOp:"store",depthClearValue:1,stencilLoadOp:"clear",stencilStoreOp:"store",stencilClearValue:0},wi={colorAttachments:[yi]};class Mi{constructor(e){Object.defineProperty(this,"device",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"attachmentPool",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"texturePool",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"colorBufferPool",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"stencilBufferPool",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"idCounter",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"currentAttachment",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.device=e,this.attachmentPool=[],this.texturePool=new Map,this.colorBufferPool=[],this.stencilBufferPool=[],this.idCounter={attachmentId:0,textureId:0,stencilId:0},this.currentAttachment=null}getAttachmentObject(e,t,r=!1){return((e,t,r,n,i,a,s,o,l)=>{const c=t.length>0?t.pop():(e=>({id:e.attachmentId++,width:0,height:0,clipLevel:0,msaa:!1,mask:!1,color:null,texture:null,stencil:null,msaaTexture:null,msaaStencil:null}))(l);c.width=a,c.height=s,c.msaa=o,c.mask=!1,c.clipLevel=0;const u=gi(e,i,a,s,l),f=bi(e,n,a,s,u);c.color=f,c.stencil=u;const d=xi(e,r,a,s,!0,l);return c.texture=d,c})(this.device,this.attachmentPool,this.texturePool,this.colorBufferPool,this.stencilBufferPool,e,t,r,this.idCounter)}bindAttachment(e){this.currentAttachment=e}getCurrentAttachment(){return this.currentAttachment}get currentAttachmentObject(){return this.currentAttachment}unbindAttachment(){this.currentAttachment=null}releaseAttachment(e){((e,t,r,n,i)=>{i.texture&&(((e,t)=>{const r=`${t.width}x${t.height}_${t.smooth?"smooth":"nearest"}`;e.has(r)||e.set(r,[]),e.get(r).push(t)})(t,i.texture),i.texture=null),i.color&&(r.push(i.color),i.color=null),i.stencil&&(n.push(i.stencil),i.stencil=null),e.push(i)})(this.attachmentPool,this.texturePool,this.colorBufferPool,this.stencilBufferPool,e)}createRenderPassDescriptor(e,t,r,n,i,a="clear"){return((e,t,r,n,i,a="clear")=>{const s=e.color?.view??e.texture?.view;if(!s)throw new Error("No color view available for render pass");return yi.view=s,yi.loadOp=a,vi.r=t,vi.g=r,vi.b=n,vi.a=i,e.stencil?.view?(_i.view=e.stencil.view,wi.depthStencilAttachment=_i):wi.depthStencilAttachment=void 0,wi})(e,t,r,n,i,a)}dispose(){for(const e of this.texturePool.values())for(const t of e)t.resource.destroy();this.texturePool.clear();for(const e of this.colorBufferPool)e.resource.destroy();this.colorBufferPool=[];for(const e of this.stencilBufferPool)e.resource.destroy();this.stencilBufferPool=[];for(const e of this.attachmentPool)e.texture&&e.texture.resource.destroy(),e.color&&e.color.resource.destroy(),e.stencil&&e.stencil.resource.destroy();this.attachmentPool=[]}}const Pi="\noverride yFlipSign: f32 = 1.0;\n\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) bezier: vec2<f32>,\n    @location(1) color: vec4<f32>,\n}\n\nstruct FillUniforms {\n    color: vec4<f32>,\n    matrix0: vec4<f32>,\n    matrix1: vec4<f32>,\n    matrix2: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: FillUniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let matrix = mat3x3<f32>(uniforms.matrix0.xyz, uniforms.matrix1.xyz, uniforms.matrix2.xyz);\n    let transformed = matrix * vec3<f32>(input.position, 1.0);\n    let ndc = transformed.xy * 2.0 - 1.0;\n    output.position = vec4<f32>(ndc.x, ndc.y * yFlipSign, 0.0, 1.0);\n    output.bezier = input.bezier;\n    output.color = uniforms.color;\n    return output;\n}\n",Si="\noverride yFlipSign: f32 = 1.0;\n\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) bezier: vec2<f32>,\n}\n\nstruct FillUniforms {\n    color: vec4<f32>,\n    matrix0: vec4<f32>,\n    matrix1: vec4<f32>,\n    matrix2: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: FillUniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let matrix = mat3x3<f32>(uniforms.matrix0.xyz, uniforms.matrix1.xyz, uniforms.matrix2.xyz);\n    let transformed = matrix * vec3<f32>(input.position, 1.0);\n    let ndc = transformed.xy * 2.0 - 1.0;\n    output.position = vec4<f32>(ndc.x, ndc.y * yFlipSign, 0.0, 1.0);\n    output.bezier = input.bezier;\n    return output;\n}\n",Fi="\noverride yFlipSign: f32 = 1.0;\n\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) color: vec4<f32>,\n}\n\nstruct FillUniforms {\n    color: vec4<f32>,\n    matrix0: vec4<f32>,\n    matrix1: vec4<f32>,\n    matrix2: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: FillUniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let matrix = mat3x3<f32>(uniforms.matrix0.xyz, uniforms.matrix1.xyz, uniforms.matrix2.xyz);\n    let transformed = matrix * vec3<f32>(input.position, 1.0);\n    let ndc = transformed.xy * 2.0 - 1.0;\n    output.position = vec4<f32>(ndc.x, ndc.y * yFlipSign, 0.0, 1.0);\n    output.color = uniforms.color;\n    return output;\n}\n",Ti="\noverride yFlipSign: f32 = 1.0;\n\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) texCoord: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n    @location(1) color: vec4<f32>,\n}\n\nstruct Uniforms {\n    matrix: mat3x3<f32>,\n    color: vec4<f32>,\n    alpha: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: Uniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let pos = uniforms.matrix * vec3<f32>(input.position, 1.0);\n    let ndc = pos.xy * 2.0 - 1.0;\n    output.position = vec4<f32>(ndc.x, ndc.y * yFlipSign, 0.0, 1.0);\n    output.texCoord = input.texCoord;\n    let premultipliedColor = vec4<f32>(\n        uniforms.color.rgb * uniforms.color.a * uniforms.alpha,\n        uniforms.color.a * uniforms.alpha\n    );\n    output.color = premultipliedColor;\n    return output;\n}\n",Bi="\noverride yFlipSign: f32 = 1.0;\n\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) v_uv: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n    @location(2) color: vec4<f32>,\n}\n\nstruct GradientUniforms {\n    inverseMatrix: mat3x3<f32>,\n    gradientType: f32,\n    focal: f32,\n    spread: f32,\n    radius: f32,\n    linearPoints: vec4<f32>,\n    color: vec4<f32>,\n    contextMatrix0: vec4<f32>,\n    contextMatrix1: vec4<f32>,\n    contextMatrix2: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> gradient: GradientUniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let contextMatrix = mat3x3<f32>(gradient.contextMatrix0.xyz, gradient.contextMatrix1.xyz, gradient.contextMatrix2.xyz);\n    let pos = contextMatrix * vec3<f32>(input.position, 1.0);\n    let ndc = vec2<f32>(pos.x * 2.0 - 1.0, pos.y * 2.0 - 1.0);\n    output.position = vec4<f32>(ndc.x, ndc.y * yFlipSign, 0.0, 1.0);\n    let uvPos = gradient.inverseMatrix * vec3<f32>(input.position, 1.0);\n    output.v_uv = uvPos.xy;\n    output.bezier = input.bezier;\n    output.color = gradient.color;\n    return output;\n}\n",Oi="\noverride yFlipSign: f32 = 1.0;\n\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) bezier: vec2<f32>,\n    @location(1) color: vec4<f32>,\n    @location(2) worldPos: vec2<f32>,\n}\n\nstruct BitmapUniforms {\n    bitmapMatrix: mat3x3<f32>,\n    width: f32,\n    height: f32,\n    repeat: f32,\n    _pad: f32,\n    color: vec4<f32>,\n    contextMatrix0: vec4<f32>,\n    contextMatrix1: vec4<f32>,\n    contextMatrix2: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> bitmap: BitmapUniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let matrix = mat3x3<f32>(bitmap.contextMatrix0.xyz, bitmap.contextMatrix1.xyz, bitmap.contextMatrix2.xyz);\n    let transformedPos = matrix * vec3<f32>(input.position, 1.0);\n    let clipX = transformedPos.x * 2.0 - 1.0;\n    let clipY = (transformedPos.y * 2.0 - 1.0) * yFlipSign;\n    output.position = vec4<f32>(clipX, clipY, 0.0, 1.0);\n    output.bezier = input.bezier;\n    output.color = bitmap.color;\n    output.worldPos = input.position;\n    return output;\n}\n",Ai="\nfn isInside(uv: vec2<f32>) -> f32 {\n    let s = step(vec2<f32>(0.0), uv) * step(uv, vec2<f32>(1.0));\n    return s.x * s.y;\n}",Ri="\n    const vertices = array<vec2<f32>, 6>(\n        vec2<f32>(0.0, 0.0),\n        vec2<f32>(1.0, 0.0),\n        vec2<f32>(0.0, 1.0),\n        vec2<f32>(0.0, 1.0),\n        vec2<f32>(1.0, 0.0),\n        vec2<f32>(1.0, 1.0)\n    );",Ci="\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}",Ei=e=>`\n${Ci}\n\n@vertex\nfn main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {\n    var output: VertexOutput;\n\n    const positions = array<vec2<f32>, 6>(\n        vec2<f32>(-1.0, -1.0),\n        vec2<f32>( 1.0, -1.0),\n        vec2<f32>(-1.0,  1.0),\n        vec2<f32>(-1.0,  1.0),\n        vec2<f32>( 1.0, -1.0),\n        vec2<f32>( 1.0,  1.0)\n    );\n    var texCoords = array<vec2<f32>, 6>(\n        vec2<f32>(0.0, ${e?"1.0":"0.0"}),\n        vec2<f32>(1.0, ${e?"1.0":"0.0"}),\n        vec2<f32>(0.0, ${e?"0.0":"1.0"}),\n        vec2<f32>(0.0, ${e?"0.0":"1.0"}),\n        vec2<f32>(1.0, ${e?"1.0":"0.0"}),\n        vec2<f32>(1.0, ${e?"0.0":"1.0"})\n    );\n    output.position = vec4<f32>(positions[vertexIndex], 0.0, 1.0);\n    output.texCoord = texCoords[vertexIndex];\n    return output;\n}\n`,Ui=Ei(!0),$i=Ei(!1),Gi=Ei(!1),ki=`\nstruct PositionUniforms {\n    offset: vec2<f32>,\n    size: vec2<f32>,\n    viewport: vec2<f32>,\n    padding: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: PositionUniforms;\n\n@vertex\nfn main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {\n    var output: VertexOutput;\n${Ri}\n    let vertex = vertices[vertexIndex];\n    output.texCoord = vec2<f32>(vertex.x, 1.0 - vertex.y);\n    var position = vertex * uniforms.size + uniforms.offset;\n    position = position / uniforms.viewport;\n    position = position * 2.0 - 1.0;\n    output.position = vec4<f32>(position.x, -position.y, 0.0, 1.0);\n    return output;\n}\n`,Li=`\nstruct BitmapSyncUniforms {\n    nodeRect: vec4<f32>,\n    textureSize: vec2<f32>,\n    padding: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: BitmapSyncUniforms;\n\n@vertex\nfn main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {\n    var output: VertexOutput;\n${Ri}\n    let vertex = vertices[vertexIndex];\n    let pixelPos = vec2<f32>(\n        uniforms.nodeRect.x + vertex.x * uniforms.nodeRect.z,\n        uniforms.nodeRect.y + vertex.y * uniforms.nodeRect.w\n    );\n    let ndc = pixelPos / uniforms.textureSize * 2.0 - 1.0;\n    output.position = vec4<f32>(ndc.x, -ndc.y, 0.0, 1.0);\n    output.texCoord = pixelPos / uniforms.textureSize;\n    return output;\n}\n`,Ii=e=>`\n\nstruct ScaleUniforms {\n    matrix: vec4<f32>,\n    translate: vec2<f32>,\n    srcSize: vec2<f32>,\n    dstSize: vec2<f32>,\n    padding: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: ScaleUniforms;\n\n\n@vertex\nfn main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {\n    var output: VertexOutput;\n${Ri}\n    let vertex = vertices[vertexIndex];\n    output.texCoord = ${e?"vec2<f32>(vertex.x, 1.0 - vertex.y)":"vertex"};\n\n    var pos = vertex * uniforms.srcSize;\n    let a = uniforms.matrix.x;\n    let b = uniforms.matrix.y;\n    let c = uniforms.matrix.z;\n    let d = uniforms.matrix.w;\n    let tx = uniforms.translate.x;\n    let ty = uniforms.translate.y;\n    let transformedX = pos.x * a + pos.y * c + tx;\n    let transformedY = pos.x * b + pos.y * d + ty;\n    var position = vec2<f32>(transformedX, transformedY) / uniforms.dstSize;\n    position = position * 2.0 - 1.0;\n    output.position = vec4<f32>(position.x, -position.y, 0.0, 1.0);\n\n    return output;\n}\n`,Vi=Ii(!1),zi=Ii(!0),ji=Ii(!1),Di=e=>`\nstruct PositionUniforms {\n    offset: vec2<f32>,\n    size: vec2<f32>,\n    viewport: vec2<f32>,\n    padding: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: PositionUniforms;\n\n@vertex\nfn main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {\n    var output: VertexOutput;\n${Ri}\n    let vertex = vertices[vertexIndex];\n    output.texCoord = ${e?"vec2<f32>(vertex.x, 1.0 - vertex.y)":"vertex"};\n    var position = vertex * uniforms.size + uniforms.offset;\n    position = position / uniforms.viewport;\n    position = position * 2.0 - 1.0;\n    output.position = vec4<f32>(position.x, -position.y, 0.0, 1.0);\n    return output;\n}\n`,Ni=Di(!1),Wi=Di(!0),qi="\nstruct GradientUniforms {\n    inverseMatrix: mat3x3<f32>,\n    gradientType: f32,\n    focal: f32,\n    spread: f32,\n    radius: f32,\n    linearPoints: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> gradient: GradientUniforms;\n@group(0) @binding(1) var gradientSampler: sampler;\n@group(0) @binding(2) var gradientTexture: texture_2d<f32>;\n\noverride GRADIENT_TYPE: u32 = 0u;\noverride SPREAD_MODE: u32 = 2u;\n\nfn applySpread(t: f32) -> f32 {\n    if (SPREAD_MODE == 0u) {\n        return 1.0 - abs(fract(t * 0.5) * 2.0 - 1.0);\n    } else if (SPREAD_MODE == 1u) {\n        return fract(t);\n    } else {\n        return clamp(t, 0.0, 1.0);\n    }\n}\n",Xi="\n    var t: f32;\n    if (GRADIENT_TYPE == 0u) {\n        let a = gradient.linearPoints.xy;\n        let b = gradient.linearPoints.zw;\n        let ab = b - a;\n        let ap = p - a;\n        let dotAB = dot(ab, ab);\n        if (dotAB < 0.0001) {\n            t = 0.0;\n        } else {\n            t = dot(ab, ap) / dotAB;\n        }\n    } else {\n        let r = gradient.radius;\n        let coord = p / r;\n        let focalRatio = gradient.focal;\n\n        if (abs(focalRatio) < 0.001) {\n            t = length(coord);\n        } else {\n            let focal = vec2<f32>(focalRatio, 0.0);\n            let diff = coord - focal;\n            let lenDiff = length(diff);\n\n            if (lenDiff < 0.0001) {\n                t = 0.0;\n            } else {\n                let dir = diff / lenDiff;\n\n                // Solve quadratic equation for unit circle intersection (a=1 since dir is normalized)\n                let b_coef = 2.0 * dot(dir, focal);\n                let c_coef = dot(focal, focal) - 1.0;\n                let discriminant = b_coef * b_coef - 4.0 * c_coef;\n                let x = (-b_coef + sqrt(max(discriminant, 0.0))) * 0.5;\n                t = lenDiff / abs(x);\n            }\n        }\n    }\n    t = applySpread(t);\n    let gradientColor = textureSampleLevel(gradientTexture, gradientSampler, vec2<f32>(t, 0.5), 0);\n",Yi=`\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) v_uv: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n    @location(2) color: vec4<f32>,\n}\n${qi}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let p = input.v_uv;\n${Xi}\n    let result = gradientColor * input.color;\n    return vec4<f32>(result.rgb * result.a, result.a);\n}\n`,Ki=`\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) v_uv: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n    @location(2) color: vec4<f32>,\n}\n${qi}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let p = input.v_uv;\n${Xi}\n    return vec4<f32>(gradientColor.rgb * gradientColor.a, gradientColor.a);\n}\n`,Hi=`\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n    @location(1) color: vec4<f32>,\n}\n${qi}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let p = input.texCoord;\n${Xi}\n    let result = gradientColor * input.color;\n    return vec4<f32>(result.rgb * result.a, result.a);\n}\n`,Qi=`\n${Ci}\n\nstruct CopyUniforms {\n    scale: vec2<f32>,\n    offset: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: CopyUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let uv = input.texCoord * uniforms.scale + uniforms.offset;\n    return textureSampleLevel(inputTexture, textureSampler, uv, 0);\n}\n`,Zi=`\n${Ci}\n\nstruct CopyUniforms {\n    scale: vec2<f32>,\n    offset: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: CopyUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let uv = (input.texCoord - uniforms.offset) * uniforms.scale;\n    let clampedUv = clamp(uv, vec2<f32>(0.0), vec2<f32>(1.0));\n    let color = textureSampleLevel(inputTexture, textureSampler, clampedUv, 0);\n    let inBounds = uv.x >= 0.0 && uv.x <= 1.0 && uv.y >= 0.0 && uv.y <= 1.0;\n    return select(vec4<f32>(0.0, 0.0, 0.0, 0.0), color, inBounds);\n}\n`,Ji=`\n${Ci}\n\nstruct CopyUniforms {\n    scale: vec2<f32>,\n    offset: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: CopyUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let uv = input.texCoord * uniforms.scale + uniforms.offset;\n    let clampedUv = clamp(uv, vec2<f32>(0.0), vec2<f32>(1.0));\n    let color = textureSampleLevel(inputTexture, textureSampler, clampedUv, 0);\n    let inBounds = uv.x >= 0.0 && uv.x <= 1.0 && uv.y >= 0.0 && uv.y <= 1.0;\n    return select(vec4<f32>(0.0, 0.0, 0.0, 0.0), color, inBounds);\n}\n`,ea=`\n${Ci}\n\nstruct ColorTransformUniforms {\n    mul: vec4<f32>,\n    add: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> ct: ColorTransformUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    var color = textureSampleLevel(inputTexture, textureSampler, input.texCoord, 0);\n\n    color = vec4<f32>(color.rgb / max(vec3<f32>(0.0001), vec3<f32>(color.a)), color.a);\n    color = clamp(color * ct.mul + ct.add, vec4<f32>(0.0), vec4<f32>(1.0));\n    color = vec4<f32>(color.rgb * color.a, color.a);\n\n    return color;\n}\n`,ta=`\n${Ci}\n\nstruct YFlipCTUniforms {\n    scale: vec2<f32>,\n    offset: vec2<f32>,\n    mul: vec4<f32>,\n    add: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: YFlipCTUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let uv = input.texCoord * uniforms.scale + uniforms.offset;\n    var color = textureSampleLevel(inputTexture, textureSampler, uv, 0);\n\n    color = vec4<f32>(color.rgb / max(vec3<f32>(0.0001), vec3<f32>(color.a)), color.a);\n    color = clamp(color * uniforms.mul + uniforms.add, vec4<f32>(0.0), vec4<f32>(1.0));\n    color = vec4<f32>(color.rgb * color.a, color.a);\n\n    return color;\n}\n`,ra=`\n${Ci}\n\nstruct ColorMatrixUniforms {\n    matrix: mat4x4<f32>,\n    offset: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: ColorMatrixUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    var color = textureSampleLevel(inputTexture, textureSampler, input.texCoord, 0);\n\n    color = vec4<f32>(color.rgb / max(vec3<f32>(0.0001), vec3<f32>(color.a)), color.a);\n    var result = uniforms.matrix * color + uniforms.offset;\n    result = clamp(result, vec4<f32>(0.0), vec4<f32>(1.0));\n    result = vec4<f32>(result.rgb * result.a, result.a);\n\n    return result;\n}\n`,na=`\n${Ci}\n\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    return textureSampleLevel(inputTexture, textureSampler, input.texCoord, 0);\n}\n`,ia=`\n${Ci}\n\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    return textureSampleLevel(inputTexture, textureSampler, input.texCoord, 0);\n}\n`,aa=`\n${Ci}\n\noverride IS_INNER: u32 = 0u;\noverride IS_KNOCKOUT: u32 = 0u;\n\nstruct GlowUniforms {\n    color: vec4<f32>,\n    baseScale: vec2<f32>,\n    baseOffset: vec2<f32>,\n    blurScale: vec2<f32>,\n    blurOffset: vec2<f32>,\n    strength: f32,\n    _padding1: f32,\n    _padding2: f32,\n    _padding3: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: GlowUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var blurTexture: texture_2d<f32>;\n@group(0) @binding(3) var baseTexture: texture_2d<f32>;\n${Ai}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;\n    let baseColor = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);\n\n    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;\n    let blurColor = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);\n\n    var rawAlpha = blurColor.a;\n    if (IS_INNER == 1u) {\n        rawAlpha = 1.0 - rawAlpha;\n    }\n    let glowAlpha = clamp(rawAlpha * uniforms.strength, 0.0, 1.0);\n    let glowColor = vec4<f32>(uniforms.color.rgb * glowAlpha, uniforms.color.a * glowAlpha);\n    if (IS_INNER == 1u) {\n        let innerGlow = glowColor * baseColor.a;\n        if (IS_KNOCKOUT == 1u) {\n            return innerGlow;\n        } else {\n            return innerGlow + baseColor * (1.0 - glowColor.a);\n        }\n    } else {\n        if (IS_KNOCKOUT == 1u) {\n            return glowColor * (1.0 - baseColor.a);\n        } else {\n            return baseColor + glowColor * (1.0 - baseColor.a);\n        }\n    }\n}\n`,sa=`\n${Ci}\n\noverride IS_INNER: u32 = 0u;\noverride IS_KNOCKOUT: u32 = 0u;\noverride IS_HIDE_OBJECT: u32 = 0u;\n\nstruct DropShadowUniforms {\n    color: vec4<f32>,\n    baseScale: vec2<f32>,\n    baseOffset: vec2<f32>,\n    blurScale: vec2<f32>,\n    blurOffset: vec2<f32>,\n    strength: f32,\n    _padding1: f32,\n    _padding2: f32,\n    _padding3: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: DropShadowUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var blurTexture: texture_2d<f32>;\n@group(0) @binding(3) var baseTexture: texture_2d<f32>;\n${Ai}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;\n    let baseColor = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);\n\n    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;\n    let blur = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);\n\n    var rawAlpha = blur.a;\n    if (IS_INNER == 1u) {\n        rawAlpha = 1.0 - rawAlpha;\n    }\n    let shadowAlpha = clamp(rawAlpha * uniforms.strength, 0.0, 1.0);\n    let shadowColor = vec4<f32>(uniforms.color.rgb * shadowAlpha, uniforms.color.a * shadowAlpha);\n\n    if (IS_INNER == 1u) {\n        let innerShadow = shadowColor * baseColor.a;\n        if (IS_KNOCKOUT == 1u) {\n            return innerShadow;\n        } else {\n            return innerShadow + baseColor * (1.0 - shadowColor.a);\n        }\n    } else {\n        if (IS_HIDE_OBJECT == 1u) {\n            return shadowColor;\n        } else if (IS_KNOCKOUT == 1u) {\n            return shadowColor * (1.0 - baseColor.a);\n        } else {\n            return shadowColor * (1.0 - baseColor.a) + baseColor;\n        }\n    }\n}\n`,oa=`\n${Ci}\n\noverride GLOW_TYPE: u32 = 0u;\noverride IS_KNOCKOUT: u32 = 0u;\n\nstruct GradientGlowUniforms {\n    strength: f32,\n    _padding1: f32,\n    _padding2: f32,\n    _padding3: f32,\n    baseScale: vec2<f32>,\n    baseOffset: vec2<f32>,\n    blurScale: vec2<f32>,\n    blurOffset: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: GradientGlowUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var blurTexture: texture_2d<f32>;\n@group(0) @binding(3) var baseTexture: texture_2d<f32>;\n@group(0) @binding(4) var gradientLUT: texture_2d<f32>;\n${Ai}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;\n    let base = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);\n\n    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;\n    var blur = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);\n\n    blur.a = clamp(blur.a * uniforms.strength, 0.0, 1.0);\n    let glowColor = textureSampleLevel(gradientLUT, textureSampler, vec2<f32>(blur.a, 0.5), 0);\n    var result: vec4<f32>;\n    if (GLOW_TYPE == 0u) {\n        if (IS_KNOCKOUT == 1u) {\n            result = glowColor;\n        } else {\n            result = base - base * glowColor.a + glowColor;\n        }\n    } else if (GLOW_TYPE == 1u) {\n        if (IS_KNOCKOUT == 1u) {\n            result = glowColor * base.a;\n        } else {\n            result = glowColor * base.a + base * (1.0 - glowColor.a);\n        }\n    } else {\n        if (IS_KNOCKOUT == 1u) {\n            result = glowColor - glowColor * base.a;\n        } else {\n            result = base + glowColor - glowColor * base.a;\n        }\n    }\n    return result;\n}\n`,la=`\n${Ci}\n\noverride BEVEL_TYPE: u32 = 0u;\noverride IS_KNOCKOUT: u32 = 0u;\n\nstruct GradientBevelUniforms {\n    strength: f32,\n    _padding1: f32,\n    _padding2: f32,\n    _padding3: f32,\n    baseScale: vec2<f32>,\n    baseOffset: vec2<f32>,\n    blurScale: vec2<f32>,\n    blurOffset: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: GradientBevelUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var blurTexture: texture_2d<f32>;\n@group(0) @binding(3) var baseTexture: texture_2d<f32>;\n@group(0) @binding(4) var gradientLUT: texture_2d<f32>;\n${Ai}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;\n    let base = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);\n\n    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;\n    let blur1 = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);\n\n    let mirrorUV = (1.0 - input.texCoord) * uniforms.blurScale - uniforms.blurOffset;\n    let blur2 = textureSampleLevel(blurTexture, textureSampler, mirrorUV, 0) * isInside(mirrorUV);\n\n    var highlightAlpha = blur1.a - blur2.a;\n    var shadowAlpha = blur2.a - blur1.a;\n    highlightAlpha = clamp(highlightAlpha * uniforms.strength, 0.0, 1.0);\n    shadowAlpha = clamp(shadowAlpha * uniforms.strength, 0.0, 1.0);\n\n    let lutCoord = 0.5019607843137255 - 0.5019607843137255 * shadowAlpha + 0.4980392156862745 * highlightAlpha;\n    let bevelColor = textureSampleLevel(gradientLUT, textureSampler, vec2<f32>(lutCoord, 0.5), 0);\n\n    var result: vec4<f32>;\n    if (BEVEL_TYPE == 0u) {\n        if (IS_KNOCKOUT == 1u) {\n            result = bevelColor;\n        } else {\n            result = base - base * bevelColor.a + bevelColor;\n        }\n    } else if (BEVEL_TYPE == 1u) {\n        if (IS_KNOCKOUT == 1u) {\n            result = bevelColor * base.a;\n        } else {\n            result = bevelColor * base.a + base * (1.0 - bevelColor.a);\n        }\n    } else {\n        if (IS_KNOCKOUT == 1u) {\n            result = bevelColor - bevelColor * base.a;\n        } else {\n            result = base + bevelColor - bevelColor * base.a;\n        }\n    }\n\n    return result;\n}\n`,ca=`\n${Ci}\n\noverride BEVEL_TYPE: u32 = 0u;\noverride IS_KNOCKOUT: u32 = 0u;\n\nstruct BevelUniforms {\n    highlightColor: vec4<f32>,\n    shadowColor: vec4<f32>,\n    strength: f32,\n    _padding1: f32,\n    _padding2: f32,\n    _padding3: f32,\n    baseScale: vec2<f32>,\n    baseOffset: vec2<f32>,\n    blurScale: vec2<f32>,\n    blurOffset: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: BevelUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var blurTexture: texture_2d<f32>;\n@group(0) @binding(3) var baseTexture: texture_2d<f32>;\n${Ai}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;\n    let base = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);\n\n    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;\n    let blur1 = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);\n\n    let mirrorUV = (1.0 - input.texCoord) * uniforms.blurScale - uniforms.blurOffset;\n    let blur2 = textureSampleLevel(blurTexture, textureSampler, mirrorUV, 0) * isInside(mirrorUV);\n\n    var highlightAlpha = blur1.a - blur2.a;\n    var shadowAlpha = blur2.a - blur1.a;\n    highlightAlpha = clamp(highlightAlpha * uniforms.strength, 0.0, 1.0);\n    shadowAlpha = clamp(shadowAlpha * uniforms.strength, 0.0, 1.0);\n\n    let bevelColor = uniforms.highlightColor * highlightAlpha + uniforms.shadowColor * shadowAlpha;\n    var result: vec4<f32>;\n    if (BEVEL_TYPE == 0u) {\n        if (IS_KNOCKOUT == 1u) {\n            result = bevelColor;\n        } else {\n            result = base - base * bevelColor.a + bevelColor;\n        }\n    } else if (BEVEL_TYPE == 1u) {\n        if (IS_KNOCKOUT == 1u) {\n            result = bevelColor * base.a;\n        } else {\n            result = bevelColor * base.a + base * (1.0 - bevelColor.a);\n        }\n    } else {\n        if (IS_KNOCKOUT == 1u) {\n            result = bevelColor - bevelColor * base.a;\n        } else {\n            result = base + bevelColor - bevelColor * base.a;\n        }\n    }\n\n    return result;\n}\n`,ua=`\n${Ci}\n\nstruct BevelBaseUniforms {\n    offset: vec2<f32>,\n    _padding: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: BevelBaseUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var sourceTexture: texture_2d<f32>;\n${Ai}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let original = textureSampleLevel(sourceTexture, textureSampler, input.texCoord, 0);\n    let shiftedUV = input.texCoord - uniforms.offset;\n    let shifted = textureSampleLevel(sourceTexture, textureSampler, shiftedUV, 0) * isInside(shiftedUV);\n    return original * (1.0 - shifted.a);\n}\n`;class fa{static getFillVertexShader(){return Pi}static getFillMainVertexShader(){return Pi}static getFillFragmentShader(){return"\nstruct FragmentInput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) bezier: vec2<f32>,\n    @location(1) color: vec4<f32>,\n}\n\n@fragment\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\n    let f_val = input.bezier.x * input.bezier.x - input.bezier.y;\n    let dx = dpdx(f_val);\n    let dy = dpdy(f_val);\n\n    if (input.bezier.x == 0.5 && input.bezier.y == 0.5) {\n        return vec4<f32>(input.color.rgb * input.color.a, input.color.a);\n    }\n\n    let dist = f_val * inverseSqrt(dx * dx + dy * dy);\n    let coverage = smoothstep(0.5, -0.5, dist);\n\n    if (coverage <= 0.001) {\n        discard;\n    }\n\n    let finalAlpha = input.color.a * min(coverage, 1.0);\n    return vec4<f32>(input.color.rgb * finalAlpha, finalAlpha);\n}\n"}static getStencilWriteVertexShader(){return Si}static getStencilWriteMainVertexShader(){return Si}static getStencilWriteFragmentShader(){return"\nstruct FragmentInput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) bezier: vec2<f32>,\n}\n\n@fragment\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\n    let f_val = input.bezier.x * input.bezier.x - input.bezier.y;\n    let dx = dpdx(f_val);\n    let dy = dpdy(f_val);\n    let dist = f_val * inverseSqrt(dx * dx + dy * dy);\n    let alpha = smoothstep(0.5, -0.5, dist);\n\n    if (alpha <= 0.001) {\n        discard;\n    }\n\n    return vec4<f32>(0.0, 0.0, 0.0, min(alpha, 1.0));\n}\n"}static getStencilFillVertexShader(){return Fi}static getStencilFillMainVertexShader(){return Fi}static getStencilFillFragmentShader(){return"\nstruct FragmentInput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) color: vec4<f32>,\n}\n\n@fragment\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\n    let a = input.color.a;\n    return vec4<f32>(input.color.r * a, input.color.g * a, input.color.b * a, a);\n}\n"}static getMaskVertexShader(){return"\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) bezier: vec2<f32>,\n}\n\nstruct Uniforms {\n    viewportSize: vec2<f32>,\n    _padding0: vec2<f32>,\n    matrixCol0: vec3<f32>,\n    _padding1: f32,\n    matrixCol1: vec3<f32>,\n    _padding2: f32,\n    matrixCol2: vec3<f32>,\n    _padding3: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: Uniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let matrix = mat3x3<f32>(uniforms.matrixCol0, uniforms.matrixCol1, uniforms.matrixCol2);\n    let transformed = matrix * vec3<f32>(input.position, 1.0);\n    let pos = transformed.xy;\n    let ndc = pos * 2.0 - 1.0;\n    output.position = vec4<f32>(ndc.x, -ndc.y, 0.0, 1.0);\n    output.bezier = input.bezier;\n    return output;\n}\n"}static getMaskFragmentShader(){return"\nstruct FragmentInput {\n    @location(0) bezier: vec2<f32>,\n}\n\n@fragment\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\n    let px = dpdx(input.bezier);\n    let py = dpdy(input.bezier);\n    let f = (2.0 * input.bezier.x) * vec2<f32>(px.x, py.x) - vec2<f32>(px.y, py.y);\n    let alpha = 0.5 - (input.bezier.x * input.bezier.x - input.bezier.y) / length(f);\n    if (alpha <= 0.0) {\n        discard;\n    }\n    return vec4<f32>(min(alpha, 1.0));\n}\n"}static getBasicVertexShader(){return Ti}static getBasicMainVertexShader(){return Ti}static getBasicFragmentShader(){return"\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n    @location(1) color: vec4<f32>,\n}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    return input.color;\n}\n"}static getTextureFragmentShader(){return"\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n    @location(1) color: vec4<f32>,\n}\n\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var textureData: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let textureColor = textureSampleLevel(textureData, textureSampler, input.texCoord, 0);\n    return textureColor * input.color;\n}\n"}static getInstancedVertexShader(){return"\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) texCoord: vec2<f32>,\n}\n\nstruct InstanceInput {\n    @location(2) textureRect: vec4<f32>,\n    @location(3) textureDim: vec4<f32>,\n    @location(4) matrixTx: vec4<f32>,\n    @location(5) matrixScale: vec4<f32>,\n    @location(6) mulColor: vec4<f32>,\n    @location(7) addColor: vec4<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n    @location(1) mulColor: vec4<f32>,\n    @location(2) addColor: vec4<f32>,\n}\n\n@vertex\nfn main(\n    input: VertexInput,\n    instance: InstanceInput,\n    @builtin(instance_index) instanceIdx: u32\n) -> VertexOutput {\n    var output: VertexOutput;\n    let texX = instance.textureRect.x + input.texCoord.x * instance.textureRect.z;\n    let texY = instance.textureRect.y + input.texCoord.y * instance.textureRect.w;\n    output.texCoord = vec2<f32>(texX, texY);\n    var pos = vec2<f32>(input.position.x, 1.0 - input.position.y);\n    pos = pos * vec2<f32>(instance.textureDim.x, instance.textureDim.y);\n    let scale0 = instance.matrixScale.x;\n    let rotate0 = instance.matrixScale.y;\n    let scale1 = instance.matrixScale.z;\n    let rotate1 = instance.matrixScale.w;\n    let transformedX = pos.x * scale0 + pos.y * scale1 + instance.matrixTx.x;\n    let transformedY = pos.x * rotate0 + pos.y * rotate1 + instance.matrixTx.y;\n    var position = vec2<f32>(transformedX, transformedY) / vec2<f32>(instance.textureDim.z, instance.textureDim.w);\n    position = position * 2.0 - 1.0;\n    output.position = vec4<f32>(position.x, -position.y, 0.0, 1.0);\n    output.mulColor = instance.mulColor;\n    output.addColor = instance.addColor;\n    return output;\n}\n"}static getInstancedFragmentShader(){return"\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n    @location(1) mulColor: vec4<f32>,\n    @location(2) addColor: vec4<f32>,\n}\n\n@group(0) @binding(0) var textureSampler: sampler;\n@group(0) @binding(1) var textureData: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    var src = textureSample(textureData, textureSampler, input.texCoord);\n    src = vec4<f32>(src.rgb / max(0.0001, src.a), src.a);\n    src = clamp(src * input.mulColor + input.addColor, vec4<f32>(0.0), vec4<f32>(1.0));\n    src = vec4<f32>(src.rgb * src.a, src.a);\n    return src;\n}\n"}static getGradientFillVertexShader(){return Bi}static getGradientFillMainVertexShader(){return Bi}static getGradientFillFragmentShader(){return Yi}static getGradientFillStencilFragmentShader(){return Ki}static getGradientFragmentShader(){return Hi}static getBitmapFillVertexShader(){return Oi}static getBitmapFillMainVertexShader(){return Oi}static getBitmapFillFragmentShader(){return"\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) bezier: vec2<f32>,\n    @location(1) color: vec4<f32>,\n    @location(2) worldPos: vec2<f32>,\n}\n\nstruct BitmapUniforms {\n    bitmapMatrix: mat3x3<f32>,\n    textureWidth: f32,\n    textureHeight: f32,\n    repeat: f32,\n    _pad: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: BitmapUniforms;\n@group(0) @binding(1) var bitmapSampler: sampler;\n@group(0) @binding(2) var bitmapTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let u = input.bezier.x;\n    let v = input.bezier.y;\n    if (abs(u - 0.5) > 0.001 || abs(v - 0.5) > 0.001) {\n        let d = u * u - v;\n        if (d > 0.0) {\n            discard;\n        }\n    }\n    let transformedPos = uniforms.bitmapMatrix * vec3<f32>(input.worldPos, 1.0);\n    var uv = vec2<f32>(\n        transformedPos.x / uniforms.textureWidth,\n        transformedPos.y / uniforms.textureHeight\n    );\n    if (uniforms.repeat > 0.5) {\n        uv = fract(uv);\n    }\n    let bitmapColor = textureSampleLevel(bitmapTexture, bitmapSampler, uv, 0);\n    let alpha = bitmapColor.a * input.color.a;\n    return vec4<f32>(bitmapColor.rgb * input.color.a, alpha);\n}\n"}static getBlendFragmentShader(){return"\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n    @location(1) color: vec4<f32>,\n}\n\nstruct BlendUniforms {\n    blendMode: f32,\n}\n\n@group(0) @binding(1) var<uniform> blend: BlendUniforms;\n@group(0) @binding(2) var srcSampler: sampler;\n@group(0) @binding(3) var srcTexture: texture_2d<f32>;\n@group(0) @binding(4) var dstSampler: sampler;\n@group(0) @binding(5) var dstTexture: texture_2d<f32>;\n\nfn blendNormal(src: vec4<f32>, dst: vec4<f32>) -> vec4<f32> {\n    return src;\n}\n\nfn blendMultiply(src: vec4<f32>, dst: vec4<f32>) -> vec4<f32> {\n    return src * dst;\n}\n\nfn blendScreen(src: vec4<f32>, dst: vec4<f32>) -> vec4<f32> {\n    return src + dst - src * dst;\n}\n\nfn blendAdd(src: vec4<f32>, dst: vec4<f32>) -> vec4<f32> {\n    return min(src + dst, vec4<f32>(1.0));\n}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let src = textureSampleLevel(srcTexture, srcSampler, input.texCoord, 0);\n    let dst = textureSampleLevel(dstTexture, dstSampler, input.texCoord, 0);\n    var result: vec4<f32>;\n    if (blend.blendMode < 0.5) {\n        result = blendNormal(src, dst);\n    } else if (blend.blendMode < 1.5) {\n        result = blendMultiply(src, dst);\n    } else if (blend.blendMode < 2.5) {\n        result = blendScreen(src, dst);\n    } else {\n        result = blendAdd(src, dst);\n    }\n    return result * input.color;\n}\n"}static getBlurFilterVertexShader(){return Ui}static getBitmapSyncVertexShader(){return Li}static getBitmapSyncFragmentShader(){return ia}static getBlurFilterFragmentShader(e){const t=e.toFixed(1);return`\n${Ci}\n\nstruct BlurUniforms {\n    offset: vec2<f32>,\n    fraction: f32,\n    samples: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: BlurUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let offset = uniforms.offset;\n    let fraction = uniforms.fraction;\n    let samples = uniforms.samples;\n    var color = textureSample(inputTexture, textureSampler, input.texCoord);\n    for (var i: f32 = 1.0; i < ${t}; i += 1.0) {\n        color += textureSample(inputTexture, textureSampler, input.texCoord + offset * i);\n        color += textureSample(inputTexture, textureSampler, input.texCoord - offset * i);\n    }\n    color += textureSample(inputTexture, textureSampler, input.texCoord + offset * ${t}) * fraction;\n    color += textureSample(inputTexture, textureSampler, input.texCoord - offset * ${t}) * fraction;\n    color /= samples;\n    return color;\n}\n`}static getTextureCopyFragmentShader(){return Qi}static getBlurTextureCopyFragmentShader(){return Zi}static getFilterOutputFragmentShader(){return Ji}static getColorTransformFragmentShader(){return ea}static getYFlipColorTransformFragmentShader(){return ta}static getColorMatrixFilterFragmentShader(){return ra}static getGlowFilterFragmentShader(){return aa}static getDropShadowFilterFragmentShader(){return sa}static getGradientGlowFilterFragmentShader(){return oa}static getGradientBevelFilterFragmentShader(){return la}static getBevelFilterFragmentShader(){return ca}static getBevelBaseFragmentShader(){return ua}static getConvolutionFilterFragmentShader(e,t,r=!0,n=!0){const i=Math.floor(.5*e),a=Math.floor(.5*t),s=e*t;let o="";for(let e=0;e<s;e++)o+=`\n    result = result + getWeightedColor(${e}, getMatrixWeight(${e}));`;const l=r?"result.a = textureSample(sourceTexture, sourceSampler, input.texCoord).a;":"",c=n?"":"\n    let substituteColor = uniforms.substituteColor;\n    color = mix(substituteColor, color, isInside(uv));";return`\nstruct ConvolutionUniforms {\n    rcpSize: vec2<f32>,\n    rcpDivisor: f32,\n    bias: f32,\n    substituteColor: vec4<f32>,\n    matrix: array<vec4<f32>, ${Math.ceil(s/4)}>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: ConvolutionUniforms;\n@group(0) @binding(1) var sourceSampler: sampler;\n@group(0) @binding(2) var sourceTexture: texture_2d<f32>;\n\n${Ci}\n\n${Ai}\n\nfn getMatrixWeight(index: i32) -> f32 {\n    let vecIndex = index / 4;\n    let component = index % 4;\n    let vec = uniforms.matrix[vecIndex];\n    if (component == 0) { return vec.x; }\n    else if (component == 1) { return vec.y; }\n    else if (component == 2) { return vec.z; }\n    else { return vec.w; }\n}\n\nfn getWeightedColor(i: i32, weight: f32) -> vec4<f32> {\n    let rcpSize = uniforms.rcpSize;\n    let iDivX = i / ${e};\n    let iModX = i - ${e} * iDivX;\n    let offset = vec2<f32>(f32(iModX - ${i}), f32(${a} - iDivX));\n    var uv = input.texCoord + offset * rcpSize;\n    var color = textureSample(sourceTexture, sourceSampler, uv);\n    color = vec4<f32>(color.rgb / max(0.0001, color.a), color.a);\n    ${c}\n    return color * weight;\n}\n\nvar<private> input: VertexOutput;\n\n@vertex\nfn vs_main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {\n    var positions = array<vec2<f32>, 6>(\n        vec2<f32>(-1.0, -1.0),\n        vec2<f32>(1.0, -1.0),\n        vec2<f32>(-1.0, 1.0),\n        vec2<f32>(-1.0, 1.0),\n        vec2<f32>(1.0, -1.0),\n        vec2<f32>(1.0, 1.0)\n    );\n    var texCoords = array<vec2<f32>, 6>(\n        vec2<f32>(0.0, 1.0),\n        vec2<f32>(1.0, 1.0),\n        vec2<f32>(0.0, 0.0),\n        vec2<f32>(0.0, 0.0),\n        vec2<f32>(1.0, 1.0),\n        vec2<f32>(1.0, 0.0)\n    );\n    var output: VertexOutput;\n    output.position = vec4<f32>(positions[vertexIndex], 0.0, 1.0);\n    output.texCoord = texCoords[vertexIndex];\n    return output;\n}\n\n@fragment\nfn fs_main(fragInput: VertexOutput) -> @location(0) vec4<f32> {\n    input = fragInput;\n    let rcpDivisor = uniforms.rcpDivisor;\n    let bias = uniforms.bias;\n    var result = vec4<f32>(0.0);\n    ${o}\n    result = clamp(result * rcpDivisor + bias, vec4<f32>(0.0), vec4<f32>(1.0));\n    ${l}\n    result = vec4<f32>(result.rgb * result.a, result.a);\n    return result;\n}\n`}static getComplexBlendFragmentShader(){return fa.getUnifiedComplexBlendFragmentShader()}static getBlendModeIndex(e){switch(e){case"subtract":return 0;case"multiply":default:return 1;case"lighten":return 2;case"darken":return 3;case"overlay":return 4;case"hardlight":return 5;case"difference":return 6;case"invert":return 7}}static getUnifiedComplexBlendFragmentShader(){return`\n${Ci}\n\nstruct BlendUniforms {\n    mulColor: vec4<f32>,\n    addColor: vec4<f32>,\n    blendMode: f32,\n    _pad0: f32,\n    _pad1: f32,\n    _pad2: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: BlendUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var dstTexture: texture_2d<f32>;\n@group(0) @binding(3) var srcTexture: texture_2d<f32>;\n\nfn blend(src: vec4<f32>, dst: vec4<f32>, mode: i32) -> vec4<f32> {\n    if (src.a == 0.0) { return dst; }\n    if (dst.a == 0.0) { return src; }\n\n    let a = src - src * dst.a;\n    let b = dst - dst * src.a;\n\n    if (mode == 1) {\n        let c = src * dst;\n        return a + b + c;\n    }\n\n    let srcRgb = src.rgb / src.a;\n    let dstRgb = dst.rgb / dst.a;\n\n    var blended: vec3<f32>;\n\n    switch (mode) {\n        case 0: {\n            blended = dstRgb - srcRgb;\n        }\n        case 2: {\n            blended = mix(srcRgb, dstRgb, step(srcRgb, dstRgb));\n        }\n        case 3: {\n            blended = mix(srcRgb, dstRgb, step(dstRgb, srcRgb));\n        }\n        case 4: {\n            let mul = srcRgb * dstRgb;\n            let c1 = 2.0 * mul;\n            let c2 = 2.0 * (srcRgb + dstRgb - mul) - 1.0;\n            blended = mix(c1, c2, step(vec3<f32>(0.5), dstRgb));\n        }\n        case 5: {\n            let mul = srcRgb * dstRgb;\n            let c1 = 2.0 * mul;\n            let c2 = 2.0 * (srcRgb + dstRgb - mul) - 1.0;\n            blended = mix(c1, c2, step(vec3<f32>(0.5), srcRgb));\n        }\n        case 6: {\n            blended = abs(srcRgb - dstRgb);\n        }\n        case 7: {\n            let ib = dst - dst * src.a;\n            let ic = vec4<f32>(src.a - dst.rgb * src.a, src.a);\n            return ib + ic;\n        }\n        default: {\n            blended = srcRgb;\n        }\n    }\n\n    var c = vec4<f32>(blended, src.a * dst.a);\n    c = vec4<f32>(c.rgb * c.a, c.a);\n    return a + b + c;\n}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    var dst = textureSample(dstTexture, textureSampler, input.texCoord);\n    var src = textureSample(srcTexture, textureSampler, input.texCoord);\n    let mul = uniforms.mulColor;\n    let add = uniforms.addColor;\n    if (mul.x != 1.0 || mul.y != 1.0 || mul.z != 1.0 || mul.w != 1.0\n        || add.x != 0.0 || add.y != 0.0 || add.z != 0.0) {\n        src = vec4<f32>(src.rgb / max(vec3<f32>(0.0001), vec3<f32>(src.a)), src.a);\n        src = clamp(src * mul + add, vec4<f32>(0.0), vec4<f32>(1.0));\n        src = vec4<f32>(src.rgb * src.a, src.a);\n    }\n    return blend(src, dst, i32(uniforms.blendMode));\n}\n`}static getDisplacementMapFilterFragmentShader(e,t,r){let n,i,a;switch(e){case 1:n="mapColor.r";break;case 2:n="mapColor.g";break;case 4:n="mapColor.b";break;case 8:n="mapColor.a";break;default:n="0.5"}switch(t){case 1:i="mapColor.r";break;case 2:i="mapColor.g";break;case 4:i="mapColor.b";break;case 8:i="mapColor.a";break;default:i="0.5"}let s=!1;switch(r){case 0:a="\nsourceColor = textureSample(srcTexture, textureSampler, uv);\n";break;case 1:s=!0,a="\nsourceColor = mix(uniforms.substituteColor, textureSample(srcTexture, textureSampler, uv), isInside(uv));\n";break;case 2:default:a="\nsourceColor = textureSample(srcTexture, textureSampler, fract(uv));\n";break;case 3:a="\nlet insideUV = step(abs(uv - vec2<f32>(0.5)), vec2<f32>(0.5));\nsourceColor = textureSample(srcTexture, textureSampler, mix(input.texCoord, uv, insideUV));\n"}return`\n${Ci}\n\n${s?"struct DisplacementUniforms {\n    uvToStScale: vec2<f32>,\n    uvToStOffset: vec2<f32>,\n    scale: vec2<f32>,\n    padding: vec2<f32>,\n    substituteColor: vec4<f32>,\n}":"struct DisplacementUniforms {\n    uvToStScale: vec2<f32>,\n    uvToStOffset: vec2<f32>,\n    scale: vec2<f32>,\n    padding: vec2<f32>,\n}"}\n\n@group(0) @binding(0) var<uniform> uniforms: DisplacementUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var srcTexture: texture_2d<f32>;\n@group(0) @binding(3) var mapTexture: texture_2d<f32>;\n\n${Ai}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let stCoord = vec2<f32>(input.texCoord.x, 1.0 - input.texCoord.y);\n    let st = stCoord * uniforms.uvToStScale - uniforms.uvToStOffset;\n    let mapColor = textureSample(mapTexture, textureSampler, vec2<f32>(st.x, 1.0 - st.y));\n    let offset = vec2<f32>(${n}, ${i}) - 0.5;\n    let uv = input.texCoord + offset * uniforms.scale;\n    var sourceColor: vec4<f32>;\n    ${a}\n    return mix(textureSample(srcTexture, textureSampler, input.texCoord), sourceColor, isInside(st));\n}\n`}static getNodeClearVertexShader(){return"\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n}\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let ndc = input.position * 2.0 - 1.0;\n    output.position = vec4<f32>(ndc.x, ndc.y, 0.0, 1.0);\n    return output;\n}\n"}static getNodeClearFragmentShader(){return"\n@fragment\nfn main() -> @location(0) vec4<f32> {\n    return vec4<f32>(0.0, 0.0, 0.0, 0.0);\n}\n"}static getPositionedTextureVertexShader(){return ki}static getTextureScaleVertexShader(){return Vi}static getTextureScaleBlendVertexShader(){return zi}static getComplexBlendScaleVertexShader(){return ji}static getComplexBlendVertexShader(){return $i}static getComplexBlendCopyVertexShader(){return Gi}static getComplexBlendOutputVertexShader(){return Ni}static getFilterComplexBlendOutputVertexShader(){return Wi}static getPositionedTextureFragmentShader(){return na}}const da={arrayStride:16,attributes:[{shaderLocation:0,offset:0,format:"float32x2"},{shaderLocation:1,offset:8,format:"float32x2"}]},ha={color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}};class pa{constructor(e,t){Object.defineProperty(this,"device",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"format",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"pipelines",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"bindGroupLayouts",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"sampleCount",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"shaderModuleCache",{enumerable:!0,configurable:!0,writable:!0,value:new Map}),Object.defineProperty(this,"filterBindGroupLayouts",{enumerable:!0,configurable:!0,writable:!0,value:new Map}),Object.defineProperty(this,"lazyInitGroups",{enumerable:!0,configurable:!0,writable:!0,value:new Set}),Object.defineProperty(this,"lazyGroupMap",{enumerable:!0,configurable:!0,writable:!0,value:new Map([...Array.from({length:16},(e,t)=>[`blur_filter_${t+1}`,"blur_filter"]),["blur_filter","blur_filter"],["texture_copy","texture_copy"],["texture_copy_rgba8","texture_copy"],["color_transform","texture_copy"],["y_flip_color_transform","texture_copy"],["texture_erase","texture_copy"],["blur_texture_copy","texture_copy"],["filter_blend","texture_copy"],["texture_copy_bgra","texture_copy"],["filter_output","texture_copy"],["filter_output_add","texture_copy"],["filter_output_screen","texture_copy"],["filter_output_alpha","texture_copy"],["filter_output_erase","texture_copy"],["texture_copy_bgra_msaa","texture_copy"],["filter_output_msaa","texture_copy"],["filter_output_add_msaa","texture_copy"],["filter_output_screen_msaa","texture_copy"],["filter_output_alpha_msaa","texture_copy"],["filter_output_erase_msaa","texture_copy"],["positioned_texture","texture_copy"],["positioned_texture_rgba","texture_copy"],["bitmap_render_msaa","texture_copy"],["bitmap_render","texture_copy"],["texture_scale","texture_copy"],["texture_scale_blend","texture_copy"],["bitmap_sync","bitmap_sync"],["color_matrix_filter","filter"],["bevel_base","filter"],["glow_filter","filter"],["drop_shadow_filter","filter"],["bevel_filter","filter"],["gradient_glow_filter","filter"],["gradient_bevel_filter","filter"],["complex_blend","complex_blend"],["complex_blend_copy","complex_blend"],["complex_blend_scale","complex_blend"],["complex_blend_output","complex_blend"],["complex_blend_output_msaa","complex_blend"],["filter_complex_blend_output","complex_blend"],["filter_complex_blend_output_msaa","complex_blend"]])}),Object.defineProperty(this,"gradientPipelineLayout",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"gradientVertexShaderModule",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"gradientFragmentShaderModule",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"gradientStencilFragmentShaderModule",{enumerable:!0,configurable:!0,writable:!0,value:null}),this.device=e,this.format=t,this.pipelines=new Map,this.bindGroupLayouts=new Map,this.sampleCount=4,this.initialize()}getOrCreateShaderModule(e,t){let r=this.shaderModuleCache.get(e);return r||(r=this.device.createShaderModule({code:t}),this.shaderModuleCache.set(e,r)),r}initialize(){this.createFillPipeline(),this.createStencilFillPipelines(),this.createClipPipeline(),this.createMaskUnionPipelines(),this.createMaskPipeline(),this.createBasicPipeline(),this.createTexturePipeline(),this.createInstancedPipeline(),this.createGradientPipeline(),this.createBitmapFillPipeline(),this.createBlendPipeline(),this.createNodeClearPipeline()}ensureLazyGroup(e){const t=this.lazyGroupMap.get(e);if(t&&!this.lazyInitGroups.has(t))switch(this.lazyInitGroups.add(t),t){case"blur_filter":this.createBlurFilterPipeline();break;case"texture_copy":this.createTextureCopyPipeline();break;case"bitmap_sync":this.createBitmapSyncPipeline();break;case"filter":this.createColorMatrixFilterPipeline();break;case"complex_blend":this.createComplexBlendPipelines()}}preloadLazyGroups(){const e=["blur_filter","texture_copy","bitmap_sync","filter","complex_blend"];for(const t of e)this.ensureLazyGroup(t)}createFillPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,buffer:{type:"uniform",hasDynamicOffset:!0}}]});this.bindGroupLayouts.set("fill_dynamic",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("fillVertex",fa.getFillVertexShader()),n=this.getOrCreateShaderModule("fillFragment",fa.getFillFragmentShader()),i=da,a=ha,s=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[i]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilReadMask:0,stencilWriteMask:0},multisample:{count:this.sampleCount,alphaToCoverageEnabled:!0}}),o=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[i],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:this.sampleCount,alphaToCoverageEnabled:!0}});this.pipelines.set("fill",s),this.pipelines.set("fill_bgra",o);const l=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[i],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilReadMask:255,stencilWriteMask:0},multisample:{count:this.sampleCount,alphaToCoverageEnabled:!0}});this.pipelines.set("fill_bgra_stencil",l)}createStencilFillPipelines(){const e=da,t=this.bindGroupLayouts.get("fill_dynamic"),r=this.device.createPipelineLayout({bindGroupLayouts:[t]}),n=this.device.createRenderPipeline({layout:r,vertex:{module:this.getOrCreateShaderModule("stencilWriteVertex",fa.getStencilWriteVertexShader()),entryPoint:"main",buffers:[e]},fragment:{module:this.getOrCreateShaderModule("stencilWriteFragment",fa.getStencilWriteFragmentShader()),entryPoint:"main",targets:[{format:"rgba8unorm",writeMask:0}]},primitive:{topology:"triangle-list",cullMode:"none",frontFace:"ccw"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"increment-wrap"},stencilBack:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"decrement-wrap"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount,alphaToCoverageEnabled:!0}});this.pipelines.set("stencil_write",n);const i=this.device.createRenderPipeline({layout:r,vertex:{module:this.getOrCreateShaderModule("stencilFillVertex",fa.getStencilFillVertexShader()),entryPoint:"main",buffers:[e]},fragment:{module:this.getOrCreateShaderModule("stencilFillFragment",fa.getStencilFillFragmentShader()),entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount}});this.pipelines.set("stencil_fill",i);const a=this.device.createRenderPipeline({layout:r,vertex:{module:this.getOrCreateShaderModule("stencilWriteVertex",fa.getStencilWriteVertexShader()),entryPoint:"main",buffers:[e]},fragment:{module:this.getOrCreateShaderModule("stencilWriteFragment",fa.getStencilWriteFragmentShader()),entryPoint:"main",targets:[{format:"rgba8unorm",writeMask:0}]},primitive:{topology:"triangle-list",cullMode:"none",frontFace:"ccw"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"increment-wrap"},stencilBack:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"decrement-wrap"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount,alphaToCoverageEnabled:!0}});this.pipelines.set("stencil_write_atlas",a);const s=this.device.createRenderPipeline({layout:r,vertex:{module:this.getOrCreateShaderModule("stencilWriteVertex",fa.getStencilWriteVertexShader()),entryPoint:"main",buffers:[e],constants:{yFlipSign:-1}},fragment:{module:this.getOrCreateShaderModule("stencilWriteFragment",fa.getStencilWriteFragmentShader()),entryPoint:"main",targets:[{format:this.format,writeMask:0}]},primitive:{topology:"triangle-list",cullMode:"none",frontFace:"ccw"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"increment-wrap"},stencilBack:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"decrement-wrap"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount,alphaToCoverageEnabled:!0}});this.pipelines.set("stencil_write_main",s);const o=this.device.createRenderPipeline({layout:r,vertex:{module:this.getOrCreateShaderModule("stencilFillVertex",fa.getStencilFillVertexShader()),entryPoint:"main",buffers:[e]},fragment:{module:this.getOrCreateShaderModule("stencilFillFragment",fa.getStencilFillFragmentShader()),entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one",operation:"max"}}}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount}});this.pipelines.set("stencil_fill_atlas",o);const l=this.device.createRenderPipeline({layout:r,vertex:{module:this.getOrCreateShaderModule("stencilFillVertex",fa.getStencilFillVertexShader()),entryPoint:"main",buffers:[e],constants:{yFlipSign:-1}},fragment:{module:this.getOrCreateShaderModule("stencilFillFragment",fa.getStencilFillFragmentShader()),entryPoint:"main",targets:[{format:this.format,blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one",operation:"max"}}}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount}});this.pipelines.set("stencil_fill_main",l);const c=this.device.createRenderPipeline({layout:r,vertex:{module:this.getOrCreateShaderModule("stencilFillVertex",fa.getStencilFillVertexShader()),entryPoint:"main",buffers:[e]},fragment:{module:this.getOrCreateShaderModule("stencilFillFragment",fa.getStencilFillFragmentShader()),entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"greater",failOp:"keep",depthFailOp:"replace",passOp:"replace"},stencilBack:{compare:"greater",failOp:"keep",depthFailOp:"replace",passOp:"replace"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount}});this.pipelines.set("stencil_fill_masked",c)}createClipPipeline(){const e=da,t=this.bindGroupLayouts.get("fill_dynamic"),r=this.device.createPipelineLayout({bindGroupLayouts:[t]}),n=this.device.createRenderPipeline({layout:r,vertex:{module:this.getOrCreateShaderModule("stencilWriteVertex",fa.getStencilWriteVertexShader()),entryPoint:"main",buffers:[e]},fragment:{module:this.getOrCreateShaderModule("stencilWriteFragment",fa.getStencilWriteFragmentShader()),entryPoint:"main",targets:[{format:"rgba8unorm",writeMask:0}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"zero",depthFailOp:"invert",passOp:"invert"},stencilBack:{compare:"always",failOp:"zero",depthFailOp:"invert",passOp:"invert"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount}});this.pipelines.set("clip_write",n);const i=this.getOrCreateShaderModule("stencilWriteVertex",fa.getStencilWriteVertexShader()),a=this.getOrCreateShaderModule("stencilWriteFragment",fa.getStencilWriteFragmentShader());for(let t=1;t<=8;t++){const n=1<<t-1,s=this.device.createRenderPipeline({layout:r,vertex:{module:i,entryPoint:"main",buffers:[e],constants:{yFlipSign:-1}},fragment:{module:a,entryPoint:"main",targets:[{format:this.format,writeMask:0}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"zero",depthFailOp:"invert",passOp:"invert"},stencilBack:{compare:"always",failOp:"zero",depthFailOp:"invert",passOp:"invert"},stencilReadMask:255,stencilWriteMask:n},multisample:{count:this.sampleCount,alphaToCoverageEnabled:!0}});this.pipelines.set(`clip_write_main_${t}`,s)}this.pipelines.set("clip_write_main",this.pipelines.get("clip_write_main_1"));for(let t=1;t<=8;t++){const n=1<<t-1,s=this.device.createRenderPipeline({layout:r,vertex:{module:i,entryPoint:"main",buffers:[e],constants:{yFlipSign:-1}},fragment:{module:a,entryPoint:"main",targets:[{format:this.format,writeMask:0}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"replace",depthFailOp:"replace",passOp:"replace"},stencilBack:{compare:"always",failOp:"replace",depthFailOp:"replace",passOp:"replace"},stencilReadMask:255,stencilWriteMask:n},multisample:{count:this.sampleCount}});this.pipelines.set(`clip_clear_main_${t}`,s)}}createMaskUnionPipelines(){const e=da,t=this.bindGroupLayouts.get("fill_dynamic"),r=this.device.createPipelineLayout({bindGroupLayouts:[t]}),n=this.getOrCreateShaderModule("stencilWriteVertex",fa.getStencilWriteVertexShader()),i=this.getOrCreateShaderModule("stencilWriteFragment",fa.getStencilWriteFragmentShader());for(let t=1;t<=8;t++){const a=255&~(1<<t-1),s=this.device.createRenderPipeline({layout:r,vertex:{module:n,entryPoint:"main",buffers:[e],constants:{yFlipSign:-1}},fragment:{module:i,entryPoint:"main",targets:[{format:this.format,writeMask:0}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"less-equal",failOp:"zero",depthFailOp:"replace",passOp:"replace"},stencilBack:{compare:"less-equal",failOp:"zero",depthFailOp:"replace",passOp:"replace"},stencilReadMask:255,stencilWriteMask:a}});this.pipelines.set(`mask_union_merge_${t}`,s);const o=this.device.createRenderPipeline({layout:r,vertex:{module:n,entryPoint:"main",buffers:[e],constants:{yFlipSign:-1}},fragment:{module:i,entryPoint:"main",targets:[{format:this.format,writeMask:0}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"replace",depthFailOp:"replace",passOp:"replace"},stencilBack:{compare:"always",failOp:"replace",depthFailOp:"replace",passOp:"replace"},stencilReadMask:255,stencilWriteMask:1<<t}});this.pipelines.set(`mask_union_clear_${t}`,o)}}createMaskPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX,buffer:{type:"uniform"}}]});this.bindGroupLayouts.set("mask",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("maskVertex",fa.getMaskVertexShader()),n=this.getOrCreateShaderModule("maskFragment",fa.getMaskFragmentShader()),i=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[{arrayStride:16,attributes:[{shaderLocation:0,offset:0,format:"float32x2"},{shaderLocation:1,offset:8,format:"float32x2"}]}]},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("mask",i)}createBasicPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}}]});this.bindGroupLayouts.set("basic",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("basicVertex",fa.getBasicVertexShader()),n=this.getOrCreateShaderModule("basicFragment",fa.getBasicFragmentShader()),i={arrayStride:16,attributes:[{shaderLocation:0,offset:0,format:"float32x2"},{shaderLocation:1,offset:8,format:"float32x2"}]},a=ha,s=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[i]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:this.sampleCount}}),o=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[i],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("basic",s),this.pipelines.set("basic_bgra",o)}createTexturePipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("texture",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("basicVertex",fa.getBasicVertexShader()),n=this.getOrCreateShaderModule("textureFragment",fa.getTextureFragmentShader()),i=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[{arrayStride:16,attributes:[{shaderLocation:0,offset:0,format:"float32x2"},{shaderLocation:1,offset:8,format:"float32x2"}]}]},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("texture",i)}createInstancedPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:1,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("instanced",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("instancedVertex",fa.getInstancedVertexShader()),n=this.getOrCreateShaderModule("instancedFragment",fa.getInstancedFragmentShader()),i={arrayStride:96,stepMode:"instance",attributes:[{shaderLocation:2,offset:0,format:"float32x4"},{shaderLocation:3,offset:16,format:"float32x4"},{shaderLocation:4,offset:32,format:"float32x4"},{shaderLocation:5,offset:48,format:"float32x4"},{shaderLocation:6,offset:64,format:"float32x4"},{shaderLocation:7,offset:80,format:"float32x4"}]},a=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[{arrayStride:16,stepMode:"vertex",attributes:[{shaderLocation:0,offset:0,format:"float32x2"},{shaderLocation:1,offset:8,format:"float32x2"}]},i]},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:this.sampleCount}});this.pipelines.set("instanced",a);const s=[{arrayStride:16,stepMode:"vertex",attributes:[{shaderLocation:0,offset:0,format:"float32x2"},{shaderLocation:1,offset:8,format:"float32x2"}]},i],o=[["instanced_add",{color:{srcFactor:"one",dstFactor:"one",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}],["instanced_screen",{color:{srcFactor:"one-minus-dst",dstFactor:"one",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}],["instanced_alpha",{color:{srcFactor:"zero",dstFactor:"src-alpha",operation:"add"},alpha:{srcFactor:"zero",dstFactor:"src-alpha",operation:"add"}}],["instanced_erase",{color:{srcFactor:"zero",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"zero",dstFactor:"one-minus-src-alpha",operation:"add"}}],["instanced_copy",{color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}}]];for(const[e,i]of o){const a=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:s},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:i}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:this.sampleCount}});this.pipelines.set(e,a)}const l=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[{arrayStride:16,stepMode:"vertex",attributes:[{shaderLocation:0,offset:0,format:"float32x2"},{shaderLocation:1,offset:8,format:"float32x2"}]},i]},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilReadMask:255,stencilWriteMask:0},multisample:{count:this.sampleCount}});this.pipelines.set("instanced_masked",l)}createGradientPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("gradient_fill",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]});this.gradientPipelineLayout=t;const r=this.getOrCreateShaderModule("gradientFillVertex",fa.getGradientFillVertexShader());this.gradientVertexShaderModule=r;const n=this.getOrCreateShaderModule("gradientFillFragment",fa.getGradientFillFragmentShader());this.gradientFragmentShaderModule=n;const i=this.getOrCreateShaderModule("gradientFillStencilFragment",fa.getGradientFillStencilFragmentShader());this.gradientStencilFragmentShaderModule=i;const a=da,s=ha,o=this.device.createRenderPipeline({label:"gradient_fill_no_stencil_pipeline",layout:t,vertex:{module:r,entryPoint:"main",buffers:[a]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:s}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:this.sampleCount}}),l=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[a],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:s}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:this.sampleCount}});this.pipelines.set("gradient_fill",o),this.pipelines.set("gradient_fill_no_stencil",o),this.pipelines.set("gradient_fill_bgra",l);const c={format:"stencil8",stencilFront:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilReadMask:0,stencilWriteMask:0},u=this.device.createRenderPipeline({label:"gradient_stroke_atlas_pipeline",layout:t,vertex:{module:r,entryPoint:"main",buffers:[a]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:s}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:c,multisample:{count:this.sampleCount}});this.pipelines.set("gradient_stroke_atlas",u);const f=this.device.createRenderPipeline({label:"gradient_stroke_bgra_pipeline",layout:t,vertex:{module:r,entryPoint:"main",buffers:[a],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:s}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:c,multisample:{count:this.sampleCount}});this.pipelines.set("gradient_stroke_bgra",f);const d=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[a],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:s}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:1}});this.pipelines.set("gradient_fill_bgra_no_msaa",d);const h=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[a]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:s}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount}});this.pipelines.set("gradient_fill_stencil",h);const p=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[a]},fragment:{module:i,entryPoint:"main",targets:[{format:"rgba8unorm",blend:s}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount}});this.pipelines.set("gradient_fill_stencil_atlas",p);const m=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[a],constants:{yFlipSign:-1}},fragment:{module:i,entryPoint:"main",targets:[{format:this.format,blend:s}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:1}});this.pipelines.set("gradient_fill_stencil_main",m);const g=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[a],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:s}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilReadMask:255,stencilWriteMask:0},multisample:{count:this.sampleCount}});this.pipelines.set("gradient_fill_bgra_stencil",g)}createBitmapFillPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("bitmap_fill",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("bitmapFillVertex",fa.getBitmapFillVertexShader()),n=this.getOrCreateShaderModule("bitmapFillFragment",fa.getBitmapFillFragmentShader()),i=da,a=ha,s=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[i]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:this.sampleCount}}),o=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[i],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("bitmap_fill",s),this.pipelines.set("bitmap_fill_bgra",o);const l={format:"stencil8",stencilFront:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilReadMask:0,stencilWriteMask:0},c=this.device.createRenderPipeline({label:"bitmap_stroke_atlas_pipeline",layout:t,vertex:{module:r,entryPoint:"main",buffers:[i]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:l,multisample:{count:this.sampleCount}});this.pipelines.set("bitmap_stroke_atlas",c);const u=this.device.createRenderPipeline({label:"bitmap_stroke_bgra_pipeline",layout:t,vertex:{module:r,entryPoint:"main",buffers:[i],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:l,multisample:{count:this.sampleCount}});this.pipelines.set("bitmap_stroke_bgra",u);const f=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[i]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount}});this.pipelines.set("bitmap_fill_stencil",f);const d=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[i],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilReadMask:255,stencilWriteMask:0}});this.pipelines.set("bitmap_fill_bgra_stencil",d)}createBlendPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:2,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:3,visibility:GPUShaderStage.FRAGMENT,texture:{}},{binding:4,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:5,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("blend",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("basicVertex",fa.getBasicVertexShader()),n=this.getOrCreateShaderModule("blendFragment",fa.getBlendFragmentShader()),i=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[{arrayStride:16,attributes:[{shaderLocation:0,offset:0,format:"float32x2"},{shaderLocation:1,offset:8,format:"float32x2"}]}]},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("blend",i)}createBlurFilterPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("blur_filter",e);const t=this.getOrCreateShaderModule("blurFilterVertex",fa.getBlurFilterVertexShader()),r=this.device.createPipelineLayout({bindGroupLayouts:[e]});for(let e=1;e<=16;e++){const n=this.getOrCreateShaderModule(`blurFilterFragment_${e}`,fa.getBlurFilterFragmentShader(e)),i=this.device.createRenderPipeline({layout:r,vertex:{module:t,entryPoint:"main",buffers:[]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set(`blur_filter_${e}`,i)}}createTextureCopyPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("texture_copy",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("blurFilterVertex",fa.getBlurFilterVertexShader()),n=this.getOrCreateShaderModule("textureCopyFragment",fa.getTextureCopyFragmentShader()),i={color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}},a={color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}};this.pipelines.set("texture_copy",this.createFullscreenQuadPipeline(t,r,n,this.format,i)),this.pipelines.set("texture_copy_rgba8",this.createFullscreenQuadPipeline(t,r,n,"rgba8unorm",i));const s=this.getOrCreateShaderModule("colorTransformFragment",fa.getColorTransformFragmentShader());this.pipelines.set("color_transform",this.createFullscreenQuadPipeline(t,r,s,"rgba8unorm",i));const o=this.getOrCreateShaderModule("yFlipColorTransformFragment",fa.getYFlipColorTransformFragmentShader());this.pipelines.set("y_flip_color_transform",this.createFullscreenQuadPipeline(t,r,o,"rgba8unorm",i));const l=this.getOrCreateShaderModule("blurTextureCopyFragment",fa.getBlurTextureCopyFragmentShader());this.pipelines.set("texture_erase",this.createFullscreenQuadPipeline(t,r,l,"rgba8unorm",{color:{srcFactor:"zero",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"zero",dstFactor:"one-minus-src-alpha",operation:"add"}})),this.pipelines.set("blur_texture_copy",this.createFullscreenQuadPipeline(t,r,l,"rgba8unorm",i)),this.pipelines.set("filter_blend",this.createFullscreenQuadPipeline(t,r,n,this.format,a)),this.pipelines.set("texture_copy_bgra",this.createFullscreenQuadPipeline(t,r,n,this.format,i));const c=this.getOrCreateShaderModule("filterOutputFragment",fa.getFilterOutputFragmentShader());this.pipelines.set("filter_output",this.createFullscreenQuadPipeline(t,r,c,this.format,a));const u=[["filter_output_add",{color:{srcFactor:"one",dstFactor:"one",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one",operation:"add"}}],["filter_output_screen",{color:{srcFactor:"one",dstFactor:"one-minus-src",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}],["filter_output_alpha",{color:{srcFactor:"zero",dstFactor:"src-alpha",operation:"add"},alpha:{srcFactor:"zero",dstFactor:"src-alpha",operation:"add"}}],["filter_output_erase",{color:{srcFactor:"zero",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"zero",dstFactor:"one-minus-src-alpha",operation:"add"}}]];for(const[e,n]of u)this.pipelines.set(e,this.createFullscreenQuadPipeline(t,r,c,this.format,n));if(this.sampleCount>1){const e={color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}};this.pipelines.set("texture_copy_bgra_msaa",this.createFullscreenQuadPipeline(t,r,n,this.format,e,this.sampleCount));const i={color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}};this.pipelines.set("filter_output_msaa",this.createFullscreenQuadPipeline(t,r,c,this.format,i,this.sampleCount));for(const[e,n]of u)this.pipelines.set(`${e}_msaa`,this.createFullscreenQuadPipeline(t,r,c,this.format,n,this.sampleCount))}this.createPositionedTexturePipeline(),this.createTextureScalePipeline()}createPositionedTexturePipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("positioned_texture",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("positionedTextureVertex",fa.getPositionedTextureVertexShader()),n=this.getOrCreateShaderModule("positionedTextureFragment",fa.getPositionedTextureFragmentShader()),i=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[]},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("positioned_texture",i);const a=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("positioned_texture_rgba",a);const s=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:4},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"}}});this.pipelines.set("bitmap_render_msaa",s);const o=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"}}});this.pipelines.set("bitmap_render",o)}createTextureScalePipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("texture_scale",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("textureScaleVertex",fa.getTextureScaleVertexShader()),n=this.getOrCreateShaderModule("positionedTextureFragment",fa.getPositionedTextureFragmentShader()),i=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("texture_scale",i);const a=this.getOrCreateShaderModule("textureScaleBlendVertex",fa.getTextureScaleBlendVertexShader()),s=this.device.createRenderPipeline({layout:t,vertex:{module:a,entryPoint:"main",buffers:[]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("texture_scale_blend",s)}createBitmapSyncPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{type:"filtering"}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}}]});this.bindGroupLayouts.set("bitmap_sync",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("bitmapSyncVertex",fa.getBitmapSyncVertexShader()),n=this.getOrCreateShaderModule("bitmapSyncFragment",fa.getBitmapSyncFragmentShader()),i=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:4}});this.pipelines.set("bitmap_sync",i)}createColorMatrixFilterPipeline(){const e={color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}},t={color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}};this.createFilterPipelineWithLayout("color_matrix_filter",fa.getColorMatrixFilterFragmentShader(),1,e),this.createFilterPipelineWithLayout("bevel_base",fa.getBevelBaseFragmentShader(),1,e),this.createFilterPipelineWithLayout("glow_filter",fa.getGlowFilterFragmentShader(),2,t),this.createFilterPipelineWithLayout("drop_shadow_filter",fa.getDropShadowFilterFragmentShader(),2,t),this.createFilterPipelineWithLayout("bevel_filter",fa.getBevelFilterFragmentShader(),2,t),this.createFilterPipelineWithLayout("gradient_glow_filter",fa.getGradientGlowFilterFragmentShader(),3,t),this.createFilterPipelineWithLayout("gradient_bevel_filter",fa.getGradientBevelFilterFragmentShader(),3,t)}createComplexBlendPipelines(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}},{binding:3,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("complex_blend",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("complexBlendVertex",fa.getComplexBlendVertexShader()),n=this.getOrCreateShaderModule("unifiedComplexBlendFragment",fa.getUnifiedComplexBlendFragmentShader()),i=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("complex_blend",i),this.createComplexBlendCopyPipeline(),this.createComplexBlendOutputPipeline()}createComplexBlendCopyPipeline(){const e={color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}},t=this.bindGroupLayouts.get("texture_copy");if(t){const r=this.device.createPipelineLayout({bindGroupLayouts:[t]}),n=this.getOrCreateShaderModule("complexBlendCopyVertex",fa.getComplexBlendCopyVertexShader()),i=this.getOrCreateShaderModule("textureCopyFragment",fa.getTextureCopyFragmentShader());this.pipelines.set("complex_blend_copy",this.createFullscreenQuadPipeline(r,n,i,"rgba8unorm",e))}const r=this.bindGroupLayouts.get("texture_scale");if(r){const t=this.device.createPipelineLayout({bindGroupLayouts:[r]}),n=this.getOrCreateShaderModule("complexBlendScaleVertex",fa.getComplexBlendScaleVertexShader()),i=this.getOrCreateShaderModule("positionedTextureFragment",fa.getPositionedTextureFragmentShader());this.pipelines.set("complex_blend_scale",this.createFullscreenQuadPipeline(t,n,i,"rgba8unorm",e))}}createComplexBlendOutputPipeline(){const e=this.bindGroupLayouts.get("positioned_texture");if(!e)return;const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("positionedTextureFragment",fa.getPositionedTextureFragmentShader()),n={color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}},i=this.getOrCreateShaderModule("complexBlendOutputVertex",fa.getComplexBlendOutputVertexShader());this.pipelines.set("complex_blend_output",this.createFullscreenQuadPipeline(t,i,r,this.format,n)),this.sampleCount>1&&this.pipelines.set("complex_blend_output_msaa",this.createFullscreenQuadPipeline(t,i,r,this.format,n,this.sampleCount));const a=this.getOrCreateShaderModule("filterComplexBlendOutputVertex",fa.getFilterComplexBlendOutputVertexShader());this.pipelines.set("filter_complex_blend_output",this.createFullscreenQuadPipeline(t,a,r,this.format,n)),this.sampleCount>1&&this.pipelines.set("filter_complex_blend_output_msaa",this.createFullscreenQuadPipeline(t,a,r,this.format,n,this.sampleCount))}createFilterPipelineWithLayout(e,t,r,n){let i=this.filterBindGroupLayouts.get(r);if(!i){const e=[{binding:0,visibility:GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}}];for(let t=0;t<r;t++)e.push({binding:2+t,visibility:GPUShaderStage.FRAGMENT,texture:{}});i=this.device.createBindGroupLayout({entries:e}),this.filterBindGroupLayouts.set(r,i)}this.bindGroupLayouts.set(e,i);const a=this.device.createPipelineLayout({bindGroupLayouts:[i]}),s=this.getOrCreateShaderModule("blurFilterVertex",fa.getBlurFilterVertexShader()),o=this.getOrCreateShaderModule(`filter_${e}`,t);this.pipelines.set(e,this.createFullscreenQuadPipeline(a,s,o,"rgba8unorm",n))}createFullscreenQuadPipeline(e,t,r,n,i,a,s){const o={layout:e,vertex:{module:t,entryPoint:"main",buffers:[]},fragment:{module:r,entryPoint:"main",targets:[{format:n,blend:i}]},primitive:{topology:"triangle-list",cullMode:"none"}};return a&&a>1&&(o.multisample={count:a}),s&&(o.depthStencil=s),this.device.createRenderPipeline(o)}getPipeline(e){let t=this.pipelines.get(e);return t||(this.ensureLazyGroup(e),t=this.pipelines.get(e)),t}getFilterPipeline(e,t){const r=`${e}_${Object.keys(t).sort().map(e=>`${e}${t[e]}`).join("_")}`;let n=this.pipelines.get(r);if(n)return n;this.ensureLazyGroup(e);const i=this.shaderModuleCache.get(`filter_${e}`),a=this.shaderModuleCache.get("blurFilterVertex"),s=this.bindGroupLayouts.get(e);if(!i||!a||!s)return this.pipelines.get(e);const o=this.device.createPipelineLayout({bindGroupLayouts:[s]});return n=this.device.createRenderPipeline({layout:o,vertex:{module:a,entryPoint:"main",buffers:[]},fragment:{module:i,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}],constants:t},primitive:{topology:"triangle-list",cullMode:"none"}}),this.pipelines.set(r,n),n}getGradientPipeline(e,t,r){const n=`${e}_t${t}s${r}`;let i=this.pipelines.get(n);return i||(this.gradientPipelineLayout?(i=this.createGradientVariant(e,t,r),i?(this.pipelines.set(n,i),i):this.getPipeline(e)):this.getPipeline(e))}createGradientVariant(e,t,r){if(!this.gradientPipelineLayout)return;const n={GRADIENT_TYPE:t,SPREAD_MODE:r},i=da,a=ha,s=e.includes("stencil_atlas")||"gradient_fill_stencil_main"===e?this.gradientStencilFragmentShaderModule:this.gradientFragmentShaderModule,o=e.includes("bgra")||"gradient_fill_stencil_main"===e?this.format:"rgba8unorm",l={};let c;(e.includes("bgra")||"gradient_fill_stencil_main"===e)&&(l.yFlipSign=-1);let u=this.sampleCount;e.includes("stroke")?c={format:"stencil8",stencilFront:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilReadMask:0,stencilWriteMask:0}:"gradient_fill_stencil"===e||"gradient_fill_stencil_atlas"===e?c={format:"stencil8",stencilFront:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255}:"gradient_fill_stencil_main"===e?(c={format:"stencil8",stencilFront:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255},u=1):"gradient_fill_bgra_stencil"===e?c={format:"stencil8",stencilFront:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilReadMask:255,stencilWriteMask:0}:"gradient_fill_bgra_no_msaa"===e&&(u=1);const f={layout:this.gradientPipelineLayout,vertex:{module:this.gradientVertexShaderModule,entryPoint:"main",buffers:[i],constants:Object.keys(l).length>0?l:void 0},fragment:{module:s,entryPoint:"main",targets:[{format:o,blend:a}],constants:n},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:u}};return c&&(f.depthStencil=c),this.device.createRenderPipeline(f)}getBindGroupLayout(e){let t=this.bindGroupLayouts.get(e);return t||(this.ensureLazyGroup(e),t=this.bindGroupLayouts.get(e)),t}createNodeClearPipeline(){const e=this.device.createRenderPipeline({layout:"auto",vertex:{module:this.getOrCreateShaderModule("nodeClearVertex",fa.getNodeClearVertexShader()),entryPoint:"main",buffers:[{arrayStride:8,attributes:[{shaderLocation:0,offset:0,format:"float32x2"}]}]},fragment:{module:this.getOrCreateShaderModule("nodeClearFragment",fa.getNodeClearFragmentShader()),entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}},writeMask:GPUColorWrite.ALL}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"zero",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"always",failOp:"zero",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount}});this.pipelines.set("node_clear_atlas",e)}dispose(){this.pipelines.clear(),this.bindGroupLayouts.clear(),this.shaderModuleCache.clear(),this.filterBindGroupLayouts.clear()}}class ma{constructor(e){Object.defineProperty(this,"device",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"pipelines",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"bindGroupLayouts",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.device=e,this.pipelines=new Map,this.bindGroupLayouts=new Map,this.initializeBlurPipelines()}initializeBlurPipelines(){const e=this.device.createBindGroupLayout({label:"blur_compute_bind_group_layout",entries:[{binding:0,visibility:GPUShaderStage.COMPUTE,texture:{sampleType:"float"}},{binding:1,visibility:GPUShaderStage.COMPUTE,storageTexture:{access:"write-only",format:"rgba8unorm"}},{binding:2,visibility:GPUShaderStage.COMPUTE,buffer:{type:"uniform"}}]});this.bindGroupLayouts.set("blur_compute",e),this.createBlurComputePipeline("blur_compute_horizontal"),this.createBlurComputePipeline("blur_compute_vertical"),this.createBlurComputePipeline("blur_compute_shared_horizontal",!0),this.createBlurComputePipeline("blur_compute_shared_vertical",!0)}createBlurComputePipeline(e,t=!1){const r=this.device.createShaderModule({label:`${e}_shader`,code:t?this.getSharedBlurComputeShaderCode():this.getBlurComputeShaderCode()}),n=this.device.createPipelineLayout({label:`${e}_layout`,bindGroupLayouts:[this.bindGroupLayouts.get("blur_compute")]}),i=this.device.createComputePipeline({label:e,layout:n,compute:{module:r,entryPoint:"main"}});this.pipelines.set(e,i)}getBlurComputeShaderCode(){return"\nstruct BlurParams {\n    direction: vec2<f32>,  // (1,0) or (0,1)\n    radius: f32,           // ブラー半径\n    fraction: f32,         // 端ピクセルのブレンド割合\n    texSize: vec2<f32>,    // テクスチャサイズ\n    samples: f32,          // サンプル数\n    padding: f32,          // パディング（16バイトアライメント）\n}\n\n@group(0) @binding(0) var inputTexture: texture_2d<f32>;\n@group(0) @binding(1) var outputTexture: texture_storage_2d<rgba8unorm, write>;\n@group(0) @binding(2) var<uniform> params: BlurParams;\n\nconst WORKGROUP_SIZE: u32 = 16u;\n\n@compute @workgroup_size(16, 16, 1)\nfn main(\n    @builtin(global_invocation_id) globalId: vec3<u32>\n) {\n    let texSize = vec2<u32>(u32(params.texSize.x), u32(params.texSize.y));\n    let radius = i32(params.radius);\n\n    let outCoord = globalId.xy;\n\n    if (outCoord.x >= texSize.x || outCoord.y >= texSize.y) {\n        return;\n    }\n\n    let direction = vec2<i32>(i32(params.direction.x), i32(params.direction.y));\n    let samples = params.samples;\n    let fraction = params.fraction;\n\n    var color = vec4<f32>(0.0);\n\n    for (var i = -radius; i <= radius; i = i + 1) {\n        var sampleCoord = vec2<i32>(outCoord) + direction * i;\n\n        sampleCoord.x = clamp(sampleCoord.x, 0, i32(texSize.x) - 1);\n        sampleCoord.y = clamp(sampleCoord.y, 0, i32(texSize.y) - 1);\n\n        let sample = textureLoad(inputTexture, vec2<u32>(sampleCoord), 0);\n\n        // 端ピクセルにfraction重みを適用（Fragment Shaderと同じロジック）\n        if (i == -radius || i == radius) {\n            color = color + sample * fraction;\n        } else {\n            color = color + sample;\n        }\n    }\n\n    color = color / samples;\n\n    textureStore(outputTexture, outCoord, color);\n}\n"}getSharedBlurComputeShaderCode(){return"\nstruct BlurParams {\n    direction: vec2<f32>,\n    radius: f32,\n    fraction: f32,\n    texSize: vec2<f32>,\n    samples: f32,\n    padding: f32,\n}\n\n@group(0) @binding(0) var inputTexture: texture_2d<f32>;\n@group(0) @binding(1) var outputTexture: texture_storage_2d<rgba8unorm, write>;\n@group(0) @binding(2) var<uniform> params: BlurParams;\n\nconst TILE: u32 = 16u;\nconst MAX_APRON: u32 = 24u;\nconst SHARED_W: u32 = TILE + 2u * MAX_APRON;\n\nvar<workgroup> tile: array<vec4<f32>, 1024>;\n\n@compute @workgroup_size(16, 16, 1)\nfn main(\n    @builtin(global_invocation_id) globalId: vec3<u32>,\n    @builtin(local_invocation_id) localId: vec3<u32>,\n    @builtin(workgroup_id) workgroupId: vec3<u32>\n) {\n    let texSize = vec2<u32>(u32(params.texSize.x), u32(params.texSize.y));\n    let radius = u32(params.radius);\n    let apron = min(radius, MAX_APRON);\n    let isHorizontal = params.direction.x > 0.5;\n    let fraction = params.fraction;\n    let samples = params.samples;\n\n    let threadIdx = localId.x + localId.y * TILE;\n    let totalThreads = TILE * TILE;\n\n    if (isHorizontal) {\n        let sharedWidth = TILE + 2u * apron;\n        let baseX = workgroupId.x * TILE;\n        let y = globalId.y;\n        let clampedY = clamp(y, 0u, max(texSize.y, 1u) - 1u);\n\n        // 全スレッドが協調ロード（範囲外スレッドもclampされた座標でロード）\n        var idx = threadIdx;\n        loop {\n            if (idx >= sharedWidth) { break; }\n            let gx = i32(baseX) + i32(idx) - i32(apron);\n            let cx = u32(clamp(gx, 0, i32(max(texSize.x, 1u)) - 1));\n            tile[localId.y * SHARED_W + idx] = textureLoad(inputTexture, vec2<u32>(cx, clampedY), 0);\n            idx += totalThreads;\n        }\n\n        // 全スレッドがバリアに到達（早期returnなし）\n        workgroupBarrier();\n\n        // 範囲内のスレッドのみ出力\n        let outX = globalId.x;\n        if (outX < texSize.x && y < texSize.y) {\n            let iRadius = i32(radius);\n            var color = vec4<f32>(0.0);\n            for (var i = -iRadius; i <= iRadius; i = i + 1) {\n                let tileIdx = i32(localId.x) + i32(apron) + i;\n                let s = tile[localId.y * SHARED_W + u32(clamp(tileIdx, 0, i32(sharedWidth) - 1))];\n                if (i == -iRadius || i == iRadius) {\n                    color += s * fraction;\n                } else {\n                    color += s;\n                }\n            }\n            textureStore(outputTexture, vec2<u32>(outX, y), color / samples);\n        }\n    } else {\n        let sharedHeight = TILE + 2u * apron;\n        let baseY = workgroupId.y * TILE;\n        let x = globalId.x;\n        let clampedX = clamp(x, 0u, max(texSize.x, 1u) - 1u);\n\n        // 全スレッドが協調ロード（範囲外スレッドもclampされた座標でロード）\n        var idx = threadIdx;\n        loop {\n            if (idx >= sharedHeight) { break; }\n            let gy = i32(baseY) + i32(idx) - i32(apron);\n            let cy = u32(clamp(gy, 0, i32(max(texSize.y, 1u)) - 1));\n            tile[idx * TILE + localId.x] = textureLoad(inputTexture, vec2<u32>(clampedX, cy), 0);\n            idx += totalThreads;\n        }\n\n        // 全スレッドがバリアに到達（早期returnなし）\n        workgroupBarrier();\n\n        // 範囲内のスレッドのみ出力\n        let outY = globalId.y;\n        if (x < texSize.x && outY < texSize.y) {\n            let iRadius = i32(radius);\n            var color = vec4<f32>(0.0);\n            for (var i = -iRadius; i <= iRadius; i = i + 1) {\n                let tileIdx = i32(localId.y) + i32(apron) + i;\n                let s = tile[u32(clamp(tileIdx, 0, i32(sharedHeight) - 1)) * TILE + localId.x];\n                if (i == -iRadius || i == iRadius) {\n                    color += s * fraction;\n                } else {\n                    color += s;\n                }\n            }\n            textureStore(outputTexture, vec2<u32>(x, outY), color / samples);\n        }\n    }\n}\n"}getPipeline(e){return this.pipelines.get(e)}getBindGroupLayout(e){return this.bindGroupLayouts.get(e)}destroy(){this.pipelines.clear(),this.bindGroupLayouts.clear()}}const ga=Number.MAX_VALUE,ba=-Number.MAX_VALUE;let xa=0;const va=e=>{xa=e},ya=[];let _a=null;const wa=()=>{if(!(xa in ya)){if(!_a)return null;{const t=_a(xa);e=t,ya[xa]=e}}var e;return ya[xa]},Ma=e=>e in ya?ya[e]:null,Pa=[],Sa=[],Fa=[];let Ta=0;const Ba=e=>{Ta=e},Oa=()=>Ta,Aa=()=>{Pa.length=0,va(0);for(let e=0;e<ya.length;e++){const t=ya[e];t&&(t.texture&&t.texture.resource.destroy(),t.stencil&&t.stencil.resource.destroy(),t.msaaTexture&&t.msaaTexture.resource.destroy(),t.msaaStencil&&t.msaaStencil.resource.destroy())}ya.length=0,(()=>{for(let e=0;e<Sa.length;++e){const t=Sa[e];t&&(t[0]=t[1]=ga,t[2]=t[3]=ba)}for(let e=0;e<Fa.length;++e){const t=Fa[e];t&&(t[0]=t[1]=ga,t[2]=t[3]=ba)}})(),Ba(0)};class Ra{constructor(){Object.defineProperty(this,"count",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.count=0}clear(){this.count=nr.offset=0}}let Ca="normal";const Ea=e=>{Ca=e},Ua=new Set(["normal","layer","add","screen","alpha","erase","copy"]),$a=[],Ga=[],ka=[],La=()=>{for(let e=0;e<$a.length;e++){const t=$a[e];Ga.push(t.color_transform),ka.push(t.matrix)}$a.length=0},Ia=new Map,Va=()=>{const e="blend_instanced";return Ia.has(e)||Ia.set(e,new Ra),Ia.get(e)};let za=!1;const ja=e=>{za=e},Da=()=>za;let Na=!1,Wa=0;const qa=e=>{Na=e},Xa=()=>Na,Ya=e=>{Wa=e},Ka=()=>Wa,Ha=new Map,Qa=new Map,Za=(e,t,r,n)=>{const i=Qn.currentAttachmentObject;if(!i)return;const a=i.clipLevel;let s=Ha.get(a);s?(s[0]=Math.min(s[0],e),s[1]=Math.min(s[1],t),s[2]=Math.max(s[2],r),s[3]=Math.max(s[3],n)):(s=Hn.getFloat32Array4(),s[0]=e,s[1]=t,s[2]=r,s[3]=n,Ha.set(a,s))},Ja=()=>{const e=Qn.currentAttachmentObject;if(!e)return;const t=(1<<e.clipLevel)-1;qa(!0),Ya(255&t),ja(!1)},es=()=>{const e=Qn.currentAttachmentObject;if(!e)return;const t=e.clipLevel,r=Ha.get(t);var n;if(r&&(Ha.delete(t),n=r,Hn.poolFloat32Array4(n)),Qa.delete(t),--e.clipLevel,!e.clipLevel)return e.mask=!1,ja(!1),qa(!1),Ya(0),e.needsStencilClear=!0,Qa.clear(),void Ha.clear();e.pendingStencilClearLevel=e.clipLevel,Ja()},ts=(e,t,r)=>{const n=e.length-5;for(let i=3;i<n;i+=3){let n=4*r;e[i+2]?(t[n++]=e[i-3],t[n++]=e[i-2],t[n++]=0,t[n++]=0,t[n++]=e[i],t[n++]=e[i+1],t[n++]=.5,t[n++]=0,t[n++]=e[i+3],t[n++]=e[i+4],t[n++]=1,t[n++]=1):e[i+5]?(t[n++]=e[0],t[n++]=e[1],t[n++]=.5,t[n++]=.5,t[n++]=e[i],t[n++]=e[i+1],t[n++]=.5,t[n++]=.5,t[n++]=e[i+6],t[n++]=e[i+7],t[n++]=.5,t[n++]=.5):(t[n++]=e[0],t[n++]=e[1],t[n++]=.5,t[n++]=.5,t[n++]=e[i],t[n++]=e[i+1],t[n++]=.5,t[n++]=.5,t[n++]=e[i+3],t[n++]=e[i+4],t[n++]=.5,t[n++]=.5),r+=3}return r};let rs=new Float32Array(32);const ns=e=>{let t=0;for(const r of e){const e=r.length-5;for(let r=3;r<e;r+=3)t+=3}const r=4*t;var n;rs.length<r&&(rs=new Float32Array((n=r,n--,n|=n>>1,n|=n>>2,n|=n>>4,n|=n>>8,n|=n>>16,++n)));const i=rs;let a=0;for(const t of e)a=ts(t,i,a);return{buffer:i.subarray(0,4*a),indexCount:a}},is=new OffscreenCanvas(1,1).getContext("2d"),as={x:0,y:0},ss={x:0,y:0},os={x:0,y:0},ls={x:0,y:0},cs=(e,t,r)=>({x:e.x+(t.x-e.x)*r,y:e.y+(t.y-e.y)*r}),us=e=>{const t=Math.sqrt(e.x*e.x+e.y*e.y);return 0===t?{x:0,y:0}:{x:e.x/t,y:e.y/t}},fs=(e,t,r,n)=>({x:(1-e)**2*t.x+2*(1-e)*e*r.x+e**2*n.x,y:(1-e)**2*t.y+2*(1-e)*e*r.y+e**2*n.y}),ds=(e,t,r,n)=>({x:2*(1-e)*(r.x-t.x)+2*e*(n.x-r.x),y:2*(1-e)*(r.y-t.y)+2*e*(n.y-r.y)}),hs=(e,t,r,n=.5)=>{const i=cs(e,t,n),a=cs(t,r,n),s=cs(i,a,n);return[[e,i,s],[s,a,r]]},ps=(e,t,r,n)=>{const i=[0,.5,1],a=[];for(const s of i){const i=fs(s,e,t,r),o=ds(s,e,t,r),l=us({x:-o.y,y:o.x});a.push({x:i.x+l.x*n,y:i.y+l.y*n})}return a},ms=(e,t,r,n)=>{const i=((e,t,r,n=4)=>{let i=[[e,t,r]];for(let e=0;e<n;e++){const e=[];for(const t of i){const r=hs(t[0],t[1],t[2],.5);e.push(r[0],r[1])}i=e}return i})(e,t,r,5),a=[],s=[];for(const e of i)a.push(ps(e[0],e[1],e[2],+n)),s.push(ps(e[0],e[1],e[2],-n));for(let e=0;e<a.length-1;++e)a[e+1][0]=a[e][2];for(let e=0;e<s.length-1;++e)s[e+1][0]=s[e][2];const o=a[0][0],l=[o.x,o.y,!1];for(let e=0;e<a.length;++e){const t=a[e];l.push(t[1].x,t[1].y,!0,t[2].x,t[2].y,!1)}const c=[...s].reverse();for(let e=0;e<c.length;++e){const[t,r,n]=c[e];c[e]=[n,r,t]}const u=c[0][0];l.push(u.x,u.y,!1);for(let e=0;e<c.length;++e){const t=c[e];l.push(t[1].x,t[1].y,!0,t[2].x,t[2].y,!1)}return l},gs=(e,t,r)=>{const n={x:t.x-e.x,y:t.y-e.y},i=((e,t,r)=>{const n=Math.sqrt(e*e+t*t);return 0===n?{x:0,y:0}:{x:-t/n*r,y:e/n*r}})(n.x,n.y,r),a={x:e.x+i.x,y:e.y+i.y},s={x:t.x+i.x,y:t.y+i.y},o={x:t.x-i.x,y:t.y-i.y},l={x:e.x-i.x,y:e.y-i.y};return[a.x,a.y,!1,s.x,s.y,!1,o.x,o.y,!1,l.x,l.y,!1,a.x,a.y,!1]},bs=(e,t,r,n)=>{const i=[];for(let a=0;a<n.length;a+=3){if(n[a+2])continue;const s=n[a],o=n[a+1],l=Math.sqrt(Math.pow(s-e,2)+Math.pow(o-t,2));Math.abs(l-r)>1e-4||i.push(s,o)}return i},xs=(e,t)=>{is.beginPath(),is.moveTo(t[0],t[1]);for(let e=3;e<t.length;e+=3)t[e+2]?(is.quadraticCurveTo(t[e],t[e+1],t[e+3],t[e+4]),e+=3):is.lineTo(t[e],t[e+1]);is.closePath();for(let t=0;t<e.length;t+=2){const r=e[t],n=e[t+1];if(!is.isPointInPath(r,n))return[r,n]}return null},vs=(e,t,r,n,i=!1)=>{const a=i?0:n.length-1,s=i?n.length-1:n.length-2,o=bs(e,t,r,n[a]),l=bs(e,t,r,n[s]);if(o[0]===l[0]&&o[1]===l[1]||o[0]===l[2]&&o[1]===l[3])return;const c=xs(o,n[s]);if(!c)return;const u=xs(l,n[a]);u&&n.splice(-1,0,[e,t,!1,c[0],c[1],!1,u[0],u[1],!1,e,t,!1])},ys=(e,t,r,n,i=!1)=>{const a=i?0:n.length-1,s=i?n.length-1:n.length-2,o=bs(e,t,r,n[a]),l=bs(e,t,r,n[s]),c=xs(o,n[s]);if(!c)return;const u=xs(l,n[a]);if(!u)return;const f=Math.atan2(c[1]-t,c[0]-e);let d=Math.atan2(u[1]-t,u[0]-e)-f;d>Math.PI?d-=2*Math.PI:d<-Math.PI&&(d+=2*Math.PI);const h=d/8,p=[e,t,!1];for(let n=0;n<=8;n++){const i=f+n*h,a=e+r*Math.cos(i),s=t+r*Math.sin(i);p.push(a,s,!1)}n.splice(-1,0,p)},_s=(e,t,r,n,i,a=!1)=>{const s=a?0:i.length-1,o=a?i.length-1:i.length-2,l=bs(e.x,e.y,n,i[s]),c=bs(e.x,e.y,n,i[o]);if(l[0]===c[0]&&l[1]===c[1]||l[0]===c[2]&&l[1]===c[3])return;const u=xs(l,i[o]);if(!u)return;const f=xs(c,i[s]);if(!f)return;const d=t.x-e.x,h=t.y-e.y,p=Math.hypot(d,h),m={x:d/p,y:h/p},g=r.x-e.x,b=r.y-e.y,x=Math.hypot(g,b),v={x:g/x,y:b/x},y=m.x,_=m.y,w=v.x,M=v.y,P=y*M-_*w;if(0===P)return void i.splice(-1,0,[e.x,e.y,!1,u[0],u[1],!1,f[0],f[1],!1]);const S=((f[0]-u[0])*M-(f[1]-u[1])*w)/P,F=u[0]+S*y,T=u[1]+S*_;i.splice(-1,0,[e.x,e.y,!1,u[0],u[1],!1,F,T,!1,e.x,e.y,!1,f[0],f[1],!1,F,T,!1])},ws=(e,t)=>{const r=as;r.x=e[0],r.y=e[1];const n=ss;n.x=0,n.y=0;const i=os;i.x=0,i.y=0;const a=ls;a.x=0,a.y=0;const s=[];for(let o=3;o<e.length;o+=3){const l=e[o],c=e[o+1];if(e[o+2])n.x=l,n.y=c;else{if(i.x=l,i.y=c,e[o-1]?s.push(ms(r,n,i,t)):s.push(gs(r,i,t)),s.length>1)switch(Qn.joints){case 0:vs(r.x,r.y,t,s);break;case 1:a.x=e[o-6],a.y=e[o-5],_s(r,i,a,t,s);break;case 2:ys(r.x,r.y,t,s)}r.x=i.x,r.y=i.y}}const o=e[0],l=e[1],c=e[e.length-3],u=e[e.length-2],f=1e-4;if(Math.abs(o-c)<f&&Math.abs(l-u)<f&&s.length>1)switch(Qn.joints){case 0:vs(o,l,t,s,!0);break;case 1:r.x=o,r.y=l,i.x=e[3],i.y=e[4],a.x=e[e.length-6],a.y=e[e.length-5],_s(r,i,a,t,s,!0);break;case 2:ys(o,l,t,s,!0)}else if(s.length>0)switch(Qn.caps){case 1:((e,t,r)=>{const n=e[0],i=e[1],a=e[3],s=e[4],o=Math.atan2(i-s,n-a),l=[n,i,!1];for(let e=0;e<=8;e++){const r=o-Math.PI/2+e*Math.PI/8;l.push(n+t*Math.cos(r),i+t*Math.sin(r),!1)}r.unshift(l);const c=e[e.length-3],u=e[e.length-2],f=e[e.length-6],d=e[e.length-5],h=Math.atan2(u-d,c-f),p=[c,u,!1];for(let e=0;e<=8;e++){const r=h-Math.PI/2+e*Math.PI/8;p.push(c+t*Math.cos(r),u+t*Math.sin(r),!1)}r.push(p)})(e,t,s);break;case 2:((e,t,r)=>{const n=e[0],i=e[1],a=n-e[3],s=i-e[4],o=Math.hypot(a,s);if(o>0){const e=a/o,l=s/o,c=n+e*t,u=i+l*t,f=[n-l*t,i+e*t,!1,c-l*t,u+e*t,!1,c+l*t,u-e*t,!1,n+l*t,i-e*t,!1,n-l*t,i+e*t,!1];r.unshift(f)}const l=e[e.length-3],c=e[e.length-2],u=l-e[e.length-6],f=c-e[e.length-5],d=Math.hypot(u,f);if(d>0){const e=u/d,n=f/d,i=l+e*t,a=c+n*t,s=[l-n*t,c+e*t,!1,i-n*t,a+e*t,!1,i+n*t,a-e*t,!1,l+n*t,c-e*t,!1,l-n*t,c+e*t,!1];r.push(s)}})(e,t,s)}return s},Ms=new Map;let Ps=0;const Ss=new WeakMap,Fs=e=>{let t=Ss.get(e);return t||(t=e.createView(),Ss.set(e,t)),t},Ts=new Map,Bs=new Map,Os=(e,t,r)=>{const n=`${t}_${r}`,i=Ts.get(n);return i&&i.length>0?i.pop():e.createTexture({size:{width:t,height:r},format:"rgba8unorm",usage:6})},As=e=>{const t=`${e.width}_${e.height}`;let r=Ts.get(t);r||(r=[],Ts.set(t,r)),r.push(e)},Rs=(e,t,r)=>{const n=`${t}_${r}`,i=Bs.get(n);return i&&i.length>0?i.pop():e.createTexture({size:{width:t,height:r},format:"rgba8unorm",usage:22})},Cs=e=>{const t=`${e.width}_${e.height}`;let r=Bs.get(t);r||(r=[],Bs.set(t,r)),r.push(e)},Es=new Map,Us=new Map;let $s=0;const Gs=(e,t,r)=>`${t}_${r}_${e.join(",")}`,ks=(e,t,r)=>{const n=Gs(e,t,r),i=Us.get(n);return i?(i.lastUsedFrame=$s,i):null},Ls=(e,t,r,n,i)=>{const a=Gs(e,t,r);Us.set(a,{texture:n,view:i,lastUsedFrame:$s})};let Is=null;const Vs=e=>e<=4?256:e<=8?512:1024,zs=(e,t,r)=>{const n=e.length/5,i=Vs(n),a=new Uint8Array(4*i);for(let t=0;t<i;t++){const n=js(e,t/(i-1),r),s=4*t;a[s+0]=Math.round(Math.max(0,Math.min(255,n.r))),a[s+1]=Math.round(Math.max(0,Math.min(255,n.g))),a[s+2]=Math.round(Math.max(0,Math.min(255,n.b))),a[s+3]=Math.round(Math.max(0,Math.min(255,n.a)))}return a},js=(e,t,r)=>{const n=e.length/5;let i=0,a=0;for(let r=0;r<n;r++){const n=e[5*r];if(n<=t&&(i=r),n>=t&&0===a){a=r;break}}if(0===a&&(a=n-1),i===a){const t=5*i;return{r:e[t+1],g:e[t+2],b:e[t+3],a:e[t+4]}}const s=e[5*i],o=(t-s)/(e[5*a]-s),l=e[5*i+1],c=e[5*i+2],u=e[5*i+3],f=e[5*i+4],d=e[5*a+1],h=e[5*a+2],p=e[5*a+3],m=e[5*a+4];return 0===r?{r:255*Ws(Ds(Ns(l/255),Ns(d/255),o)),g:255*Ws(Ds(Ns(c/255),Ns(h/255),o)),b:255*Ws(Ds(Ns(u/255),Ns(p/255),o)),a:Ds(f,m,o)}:{r:Ds(l,d,o),g:Ds(c,h,o),b:Ds(u,p,o),a:Ds(f,m,o)}},Ds=(e,t,r)=>e+(t-e)*r,Ns=e=>Math.pow(e,2.23333333),Ws=e=>Math.pow(e,.45454545),qs=(e,t,r)=>{const n=new Uint8Array(1024),i=e.length,a=[];for(let n=0;n<i;n++){const i=t[n];a.push({offset:e[n]/255,r:(i>>16&255)/255,g:(i>>8&255)/255,b:(255&i)/255,a:r[n]})}for(let e=0;e<256;e++){const t=e/255;let r=0,s=i-1;for(let e=0;e<i-1;e++)if(a[e].offset<=t&&a[e+1].offset>=t){r=e,s=e+1;break}const o=a[r],l=a[s];let c=0;l.offset!==o.offset&&(c=(t-o.offset)/(l.offset-o.offset));const u=Ds(o.r,l.r,c),f=Ds(o.g,l.g,c),d=Ds(o.b,l.b,c),h=Ds(o.a,l.a,c),p=4*e;n[p+0]=Math.round(u*h*255),n[p+1]=Math.round(f*h*255),n[p+2]=Math.round(d*h*255),n[p+3]=Math.round(255*h)}return n},Xs=(e,t,r)=>{const n=e[0],i=e[1],a=e[2],s=e[3],o=e[4],l=e[5];if(0===r){const e=-819.2*n-819.2*a+o,t=819.2*n-819.2*a+o,r=-819.2*i-819.2*s+l,c=819.2*i-819.2*s+l;let u=-819.2*n+819.2*a+o-e,f=-819.2*i+819.2*s+l-r;const d=Math.sqrt(u*u+f*f);d?(u/=d,f/=d):(u=0,f=0);const h=(t-e)*u+(c-r)*f,p=new Float32Array([e+h*u,r+h*f,t,c]);return{inverseMatrix:new Float32Array([1,0,0,0,1,0,0,0,1]),linearPoints:p}}const c=n*s-i*a;if(Math.abs(c)<1e-10)return{inverseMatrix:new Float32Array([1,0,0,0,1,0,0,0,1]),linearPoints:null};const u=1/c;return{inverseMatrix:new Float32Array([s*u,-i*u,0,-a*u,n*u,0,(a*l-s*o)*u,(i*o-n*l)*u,1]),linearPoints:null}};let Ys=null;const Ks=new Float32Array(36),Hs=new Float32Array(16);let Qs=null,Zs=null;const Js=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],eo=(e,t)=>{const r=e[0],n=e[1],i=e[2],a=e[3],s=e[4],o=e[5],l=t[0],c=t[1],u=t[3],f=t[4],d=t[6],h=t[7],p=l*r+u*n,m=l*i+u*a,g=c*r+f*n,b=c*i+f*a,x=l*s+u*o+d,v=c*s+f*o+h,y=p*b-m*g;if(Math.abs(y)<1e-10)return new Float32Array([1,0,0,0,1,0,0,0,1]);const _=1/y,w=b*_,M=-m*_,P=-g*_,S=p*_;return new Float32Array([w*l+M*c,P*l+S*c,0,w*u+M*f,P*u+S*f,0,w*d+M*h+(m*v-b*x)*_,P*d+S*h+(g*x-p*v)*_,1])},to=new Map,ro=new Float32Array(32),no=new Float32Array(16);let io=null,ao=null;const so=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],oo=(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g=!1,b=1)=>{const x=ns(i);if(0===x.indexCount)return null;const v=r.acquireVertexBuffer(x.buffer.byteLength,x.buffer),y=Os(e,c,u);e.queue.writeTexture({texture:y},o.buffer,{bytesPerRow:4*c,rowsPerImage:u,offset:o.byteOffset},{width:c,height:u});const _=eo(l,a),w=s[0],M=s[1],P=s[2],S=s[3],F=a[0],T=a[1],B=a[3],O=a[4],A=a[6],R=a[7];ro[0]=_[0],ro[1]=_[1],ro[2]=_[2],ro[3]=0,ro[4]=_[3],ro[5]=_[4],ro[6]=_[5],ro[7]=0,ro[8]=_[6],ro[9]=_[7],ro[10]=_[8],ro[11]=0,ro[12]=c,ro[13]=u,ro[14]=f?1:0,ro[15]=0,ro[16]=w,ro[17]=M,ro[18]=P,ro[19]=S,ro[20]=F/h,ro[21]=T/p,ro[22]=0,ro[23]=0,ro[24]=B/h,ro[25]=O/p,ro[26]=0,ro[27]=0,ro[28]=A/h,ro[29]=R/p,ro[30]=1,ro[31]=0;const C=r.acquireAndWriteUniformBuffer(ro),E=`bitmap_${d?"s":"n"}_${f?"r":"c"}`;let U=to.get(E);U||(U=e.createSampler({magFilter:d?"linear":"nearest",minFilter:d?"linear":"nearest",addressModeU:f?"repeat":"clamp-to-edge",addressModeV:f?"repeat":"clamp-to-edge"}),to.set(E,U));const $=n.getBindGroupLayout("bitmap_fill");if(!$)return console.error("[WebGPU] bitmap_fill bind group layout not found"),As(y),null;so[0].resource.buffer=C,so[1].resource=U,so[2].resource=y.createView();const G=e.createBindGroup({layout:$,entries:so});if(m&&g){const i=n.getPipeline("stencil_write");if(i){const a=(()=>{const t=n.getBindGroupLayout("fill_dynamic");if(!t)return null;no[0]=w,no[1]=M,no[2]=P,no[3]=S,no[4]=F/h,no[5]=T/p,no[6]=0,no[7]=0,no[8]=B/h,no[9]=O/p,no[10]=0,no[11]=0,no[12]=A/h,no[13]=R/p,no[14]=1,no[15]=0;const i=r.dynamicUniform.allocate(no),a=r.dynamicUniform.getBuffer();return io&&ao===a||(io=e.createBindGroup({layout:t,entries:[{binding:0,resource:{buffer:a,size:256}}]}),ao=a),{bindGroup:io,offset:i}})();a&&(t.setPipeline(i),t.setStencilReference(0),t.setVertexBuffer(0,v),t.setBindGroup(0,a.bindGroup,[a.offset]),t.draw(x.indexCount,1,0,0))}const a=n.getPipeline("bitmap_fill_stencil");a&&(t.setPipeline(a),t.setStencilReference(0),t.setBindGroup(0,G),t.draw(x.indexCount,1,0,0))}else{let e;if(m)e="bitmap_fill";else if(g){if(Da())return As(y),null;e="bitmap_fill_bgra_stencil"}else e="bitmap_fill_bgra";const r=n.getPipeline(e);if(!r)return console.error(`[WebGPU] ${e} pipeline not found`),As(y),null;t.setPipeline(r),t.setVertexBuffer(0,v),t.setBindGroup(0,G),!g||m||Da()||t.setStencilReference(Ka()),t.draw(x.indexCount,1,0,0)}return y},lo=(e,t,r)=>{const n=e.length-5;for(let i=3;i<n;i+=3){let n=4*r;e[i+2]?(t[n++]=e[i-3],t[n++]=e[i-2],t[n++]=.5,t[n++]=.5,t[n++]=e[i],t[n++]=e[i+1],t[n++]=.5,t[n++]=.5,t[n++]=e[i+3],t[n++]=e[i+4],t[n++]=.5,t[n++]=.5):e[i+5]?(t[n++]=e[0],t[n++]=e[1],t[n++]=.5,t[n++]=.5,t[n++]=e[i],t[n++]=e[i+1],t[n++]=.5,t[n++]=.5,t[n++]=e[i+6],t[n++]=e[i+7],t[n++]=.5,t[n++]=.5):(t[n++]=e[0],t[n++]=e[1],t[n++]=.5,t[n++]=.5,t[n++]=e[i],t[n++]=e[i+1],t[n++]=.5,t[n++]=.5,t[n++]=e[i+3],t[n++]=e[i+4],t[n++]=.5,t[n++]=.5),r+=3}return r};let co=new Float32Array(32);let uo=null;const fo=new Float32Array(36),ho=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],po=(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g,b)=>{const x=((e,t)=>{const r=t/2,n=[];for(const t of e){const e=ws(t,r);for(const t of e)n.push(t)}let i=0;for(const e of n){const t=e.length-5;for(let e=3;e<t;e+=3)i+=3}if(0===i)return{buffer:new Float32Array(0),indexCount:0};const a=4*i;var s;co.length<a&&(co=new Float32Array((s=a,s--,s|=s>>1,s|=s>>2,s|=s>>4,s|=s>>8,s|=s>>16,++s)));const o=co;let l=0;for(const e of n)l=lo(e,o,l);return{buffer:o.subarray(0,4*l),indexCount:l}})(i,a);if(0===x.indexCount)return null;const v=r.acquireVertexBuffer(x.buffer.byteLength,x.buffer);let y,_;const w=ks(c,f,d);if(w)y=w.texture,_=w.view;else{const t=zs(c,0,d),r=c.length/5,n=Vs(r);y=Os(e,n,1),e.queue.writeTexture({texture:y},t,{bytesPerRow:4*n,rowsPerImage:1},{width:n,height:1}),_=y.createView(),Ls(c,f,d,y,_)}const M=Xs(u,0,l),P=o[3]>0?o[3]:1,S=s[0],F=s[1],T=s[3],B=s[4],O=s[6],A=s[7];fo[0]=M.inverseMatrix[0],fo[1]=M.inverseMatrix[3],fo[2]=0,fo[3]=0,fo[4]=M.inverseMatrix[1],fo[5]=M.inverseMatrix[4],fo[6]=0,fo[7]=0,fo[8]=M.inverseMatrix[6],fo[9]=M.inverseMatrix[7],fo[10]=1,fo[11]=0,fo[12]=l,fo[13]=Math.max(-.975,Math.min(.975,h)),fo[14]=f,fo[15]=819.2,M.linearPoints?(fo[16]=M.linearPoints[0],fo[17]=M.linearPoints[1],fo[18]=M.linearPoints[2],fo[19]=M.linearPoints[3]):(fo[16]=0,fo[17]=0,fo[18]=0,fo[19]=0),fo[20]=1,fo[21]=1,fo[22]=1,fo[23]=P,fo[24]=S/p,fo[25]=F/m,fo[26]=0,fo[27]=0,fo[28]=T/p,fo[29]=B/m,fo[30]=0,fo[31]=0,fo[32]=O/p,fo[33]=A/m,fo[34]=1,fo[35]=0;const R=r.acquireAndWriteUniformBuffer(fo);uo||(uo=e.createSampler({magFilter:"linear",minFilter:"linear",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"}));const C=uo,E=n.getBindGroupLayout("gradient_fill");if(!E)return console.error("[WebGPU] gradient_fill bind group layout not found"),null;ho[0].resource.buffer=R,ho[1].resource=C,ho[2].resource=_;const U=e.createBindGroup({layout:E,entries:ho}),$=b?g?"gradient_stroke_atlas":"gradient_stroke_bgra":g?"gradient_fill":"gradient_fill_bgra",G=n.getGradientPipeline($,l,f);return G?(t.setPipeline(G),t.setVertexBuffer(0,v),t.setBindGroup(0,U),t.draw(x.indexCount,1,0,0),null):(console.error(`[WebGPU] ${$} pipeline not found`),null)};let mo=new Float32Array(32);const go=new Map,bo=new Float32Array(32),xo=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],vo=(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g,b)=>{const x=((e,t)=>{const r=t/2,n=[];for(const t of e){const e=ws(t,r);for(const t of e)n.push(t)}let i=0;for(const e of n){const t=e.length-5;for(let e=3;e<t;e+=3)i+=3}if(0===i)return{buffer:new Float32Array(0),indexCount:0};const a=4*i;var s;mo.length<a&&(mo=new Float32Array((s=a,s--,s|=s>>1,s|=s>>2,s|=s>>4,s|=s>>8,s|=s>>16,++s)));const o=mo;let l=0;for(const e of n)l=lo(e,o,l);return{buffer:o.subarray(0,4*l),indexCount:l}})(i,a);if(0===x.indexCount)return null;const v=r.acquireVertexBuffer(x.buffer.byteLength,x.buffer),y=Os(e,u,f);e.queue.writeTexture({texture:y},l.buffer,{bytesPerRow:4*u,rowsPerImage:f,offset:l.byteOffset},{width:u,height:f});const _=eo(c,s),w=o[3]>0?o[3]:1,M=s[0],P=s[1],S=s[3],F=s[4],T=s[6],B=s[7];bo[0]=_[0],bo[1]=_[1],bo[2]=_[2],bo[3]=0,bo[4]=_[3],bo[5]=_[4],bo[6]=_[5],bo[7]=0,bo[8]=_[6],bo[9]=_[7],bo[10]=_[8],bo[11]=0,bo[12]=u,bo[13]=f,bo[14]=d?1:0,bo[15]=0,bo[16]=1,bo[17]=1,bo[18]=1,bo[19]=w,bo[20]=M/p,bo[21]=P/m,bo[22]=0,bo[23]=0,bo[24]=S/p,bo[25]=F/m,bo[26]=0,bo[27]=0,bo[28]=T/p,bo[29]=B/m,bo[30]=1,bo[31]=0;const O=r.acquireAndWriteUniformBuffer(bo),A=`bitmap_${h?"s":"n"}_${d?"r":"c"}`;let R=go.get(A);R||(R=e.createSampler({magFilter:h?"linear":"nearest",minFilter:h?"linear":"nearest",addressModeU:d?"repeat":"clamp-to-edge",addressModeV:d?"repeat":"clamp-to-edge"}),go.set(A,R));const C=n.getBindGroupLayout("bitmap_fill");if(!C)return console.error("[WebGPU] bitmap_fill bind group layout not found"),As(y),null;xo[0].resource.buffer=O,xo[1].resource=R,xo[2].resource=y.createView();const E=e.createBindGroup({layout:C,entries:xo}),U=b?g?"bitmap_stroke_atlas":"bitmap_stroke_bgra":g?"bitmap_fill":"bitmap_fill_bgra",$=n.getPipeline(U);return $?(t.setPipeline($),t.setVertexBuffer(0,v),t.setBindGroup(0,E),t.draw(x.indexCount,1,0,0),y):(console.error(`[WebGPU] ${U} pipeline not found`),As(y),null)},yo=new Float32Array([-1,-1,.5,.5,1,-1,.5,.5,-1,1,.5,.5,-1,1,.5,.5,1,-1,.5,.5,1,1,.5,.5]),_o=new Float32Array([1,1,1,1,.5,0,0,0,0,.5,0,0,.5,.5,1,0]),wo=new Float32Array(16),Mo=(e,t,r,n,i,a,s,o,l,c=!1)=>{const u=i.clipLevel,f=i.width,d=i.height,h=o[0],p=o[1],m=o[2],g=o[3]*l;if(0===a.length)return;const b=ns(a);if(0===b.indexCount)return;const x=r.acquireVertexBuffer(b.buffer.byteLength,b.buffer),v=s[0],y=s[1],_=s[3],w=s[4],M=s[6],P=s[7];wo[0]=h,wo[1]=p,wo[2]=m,wo[3]=g,wo[4]=v/f,wo[5]=y/d,wo[6]=0,wo[7]=0,wo[8]=_/f,wo[9]=w/d,wo[10]=0,wo[11]=0,wo[12]=M/f,wo[13]=P/d,wo[14]=1,wo[15]=0;const S=r.dynamicUniform.allocate(wo);let F,T=Qa.get(u)??u;if(c){F=`clip_write_main_${Math.min(8,Math.max(1,T))}`}else F="clip_write";const B=n.getPipeline(F);if(!B)return void console.error(`[WebGPU] ${F} pipeline not found`);const O=n.getBindGroupLayout("fill_dynamic");if(!O)return;const A=e.createBindGroup({layout:O,entries:[{binding:0,resource:{buffer:r.dynamicUniform.getBuffer(),size:256}}]});t.setPipeline(B),t.setStencilReference(0),t.setVertexBuffer(0,x),t.setBindGroup(0,A,[S]),t.draw(b.indexCount,1,0,0),T++,T>8&&(((e,t,r,n,i)=>{if(!i)return;const a=i.clipLevel,s=1<<a-1,o=r.acquireVertexBuffer(yo.byteLength,yo),l=r.dynamicUniform.allocate(_o),c=n.getBindGroupLayout("fill_dynamic");if(!c)return;const u=e.createBindGroup({layout:c,entries:[{binding:0,resource:{buffer:r.dynamicUniform.getBuffer(),size:256}}]}),f=n.getPipeline(`mask_union_merge_${a}`);f&&(t.setPipeline(f),t.setStencilReference(s),t.setVertexBuffer(0,o),t.setBindGroup(0,u,[l]),t.draw(6,1,0,0));const d=n.getPipeline(`mask_union_clear_${a}`);d&&(t.setPipeline(d),t.setStencilReference(0),t.setVertexBuffer(0,o),t.setBindGroup(0,u,[l]),t.draw(6,1,0,0))})(e,t,r,n,i),T=u+1),Qa.set(u,T)};let Po=null,So=null;let Fo=null,To=null;const Bo=new Float32Array(12),Oo=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null},{binding:3,resource:null}],Ao=(e,t,r,n,i)=>{const{device:a,commandEncoder:s,frameBufferManager:o,pipelineManager:l,textureManager:c}=i,u=Math.max(e.width,t.width),f=Math.max(e.height,t.height),d=o.createTemporaryAttachment(u,f),h=l.getPipeline("complex_blend"),p=l.getBindGroupLayout("complex_blend");if(!h||!p)return console.error(`[WebGPU ComplexBlend] Pipeline not found for blend mode: ${r}`),e;const m=c.createSampler("complex_blend_sampler",!0),g=fa.getBlendModeIndex(r);Bo[0]=n[0],Bo[1]=n[1],Bo[2]=n[2],Bo[3]=n[3],Bo[4]=n[4],Bo[5]=n[5],Bo[6]=n[6],Bo[7]=n[7],Bo[8]=g,Bo[9]=0,Bo[10]=0,Bo[11]=0;const b=i.bufferManager?i.bufferManager.acquireAndWriteUniformBuffer(Bo):a.createBuffer({size:48,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});i.bufferManager||a.queue.writeBuffer(b,0,Bo),Oo[0].resource.buffer=b,Oo[1].resource=m,Oo[2].resource=t.texture.view,Oo[3].resource=e.texture.view;const x=a.createBindGroup({layout:p,entries:Oo}),v=o.createRenderPassDescriptor(d.texture.view,0,0,0,0,"clear"),y=s.beginRenderPass(v);return y.setPipeline(h),y.setBindGroup(0,x),y.draw(6,1,0,0),y.end(),d},Ro=new Float32Array(4),Co=new Float32Array(6),Eo=new Float32Array(8),Uo=new Float32Array(12),$o=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],Go=(e,t,r,n,i,a,s,o,l,c,u,f,d,h)=>{const p=d.getPipeline("complex_blend_copy"),m=d.getBindGroupLayout("texture_copy");if(!p||!m)return;Ro[0]=l/s,Ro[1]=c/o,Ro[2]=i/s,Ro[3]=a/o;const g=h.acquireAndWriteUniformBuffer(Ro),b=f.createSampler("complex_blend_copy_sampler",!1);$o[0].resource.buffer=g,$o[1].resource=b,$o[2].resource=r;const x=e.createBindGroup({layout:m,entries:$o}),v=u.createRenderPassDescriptor(n.texture.view,0,0,0,0,"clear"),y=t.beginRenderPass(v);y.setPipeline(p),y.setBindGroup(0,x),y.draw(6,1,0,0),y.end()},ko=(e,t,r,n,i,a,s,o,l,c)=>{const u=n.msaa&&n.msaaTexture?.view,f=u?"complex_blend_output_msaa":"complex_blend_output",d=l.getPipeline(f),h=l.getBindGroupLayout("positioned_texture");if(!d||!h)return;Eo[0]=i,Eo[1]=a,Eo[2]=r.width,Eo[3]=r.height,Eo[4]=n.width,Eo[5]=n.height,Eo[6]=0,Eo[7]=0;const p=c.acquireAndWriteUniformBuffer(Eo),m=o.createSampler("complex_blend_output_sampler",!1);$o[0].resource.buffer=p,$o[1].resource=m,$o[2].resource=r.texture.view;const g=e.createBindGroup({layout:h,entries:$o}),b=u?n.msaaTexture.view:n.texture.view,x=u?n.texture.view:null,v=s.createRenderPassDescriptor(b,0,0,0,0,"load",x),y=t.beginRenderPass(v);y.setPipeline(d),y.setBindGroup(0,g),y.draw(6,1,0,0),y.end()},Lo=(e,t,r,n,i,a,s)=>{const o=$a;if(0===o.length)return;if(!r||!r.texture)return void La();const l=wa()||n.getAttachment("atlas");if(l&&l.texture){for(const c of o){const{node:o,x_min:u,y_min:f,x_max:d,y_max:h,color_transform:p,matrix:m,blend_mode:g,global_alpha:b}=c,x=Math.ceil(Math.abs(d-u)),v=Math.ceil(Math.abs(h-f));if(x<=0||v<=0)continue;const y=Math.max(0,Math.floor(m[6])),_=Math.max(0,Math.floor(m[7]));if(y>=r.width||_>=r.height)continue;const w=1!==m[0]||0!==m[1]||0!==m[3]||1!==m[4],M=w?x:o.w,P=w?v:o.h,S=Math.min(M,r.width-y),F=Math.min(P,r.height-_);if(S<=0||F<=0)continue;let T;if(w){T=n.createTemporaryAttachment(M,P);const r=a.getPipeline("complex_blend_scale"),c=a.getBindGroupLayout("texture_scale");if(r&&c){const a=M/2,u=P/2,f=o.w/2,d=o.h/2;Co[0]=m[0],Co[1]=m[1],Co[2]=m[3],Co[3]=m[4],Co[4]=-f*m[0]-d*m[3]+a,Co[5]=-f*m[1]-d*m[4]+u;const h=n.createTemporaryAttachment(o.w,o.h);t.copyTextureToTexture({texture:l.texture.resource,origin:{x:o.x,y:o.y,z:0}},{texture:h.texture.resource,origin:{x:0,y:0,z:0}},{width:o.w,height:o.h}),Uo[0]=Co[0],Uo[1]=Co[1],Uo[2]=Co[2],Uo[3]=Co[3],Uo[4]=Co[4],Uo[5]=Co[5],Uo[6]=o.w,Uo[7]=o.h,Uo[8]=M,Uo[9]=P,Uo[10]=0,Uo[11]=0;const p=s.acquireAndWriteUniformBuffer(Uo,48),g=i.createSampler("scale_sampler",!0);$o[0].resource.buffer=p,$o[1].resource=g,$o[2].resource=h.texture.view;const b=e.createBindGroup({layout:c,entries:$o}),x=n.createRenderPassDescriptor(T.texture.view,0,0,0,0,"clear"),v=t.beginRenderPass(x);v.setPipeline(r),v.setBindGroup(0,b),v.draw(6,1,0,0),v.end(),n.releaseTemporaryAttachment(h)}else t.copyTextureToTexture({texture:l.texture.resource,origin:{x:o.x,y:o.y,z:0}},{texture:T.texture.resource,origin:{x:0,y:0,z:0}},{width:Math.min(o.w,M),height:Math.min(o.h,P)})}else T=n.createTemporaryAttachment(M,P),t.copyTextureToTexture({texture:l.texture.resource,origin:{x:o.x,y:o.y,z:0}},{texture:T.texture.resource,origin:{x:0,y:0,z:0}},{width:M,height:P});const B=n.createTemporaryAttachment(M,P);Go(e,t,r.texture.view,B,y,_,r.width,r.height,M,P,n,i,a,s),Eo[0]=p[0],Eo[1]=p[1],Eo[2]=p[2],Eo[3]=b,Eo[4]=p[4],Eo[5]=p[5],Eo[6]=p[6],Eo[7]=0;const O=Ao(T,B,g,Eo,{device:e,commandEncoder:t,bufferManager:s,frameBufferManager:n,pipelineManager:a,textureManager:i});ko(e,t,O,r,y,_,n,i,a,s),n.releaseTemporaryAttachment(T),n.releaseTemporaryAttachment(B),n.releaseTemporaryAttachment(O)}La()}else La()},Io={x:0,y:0},Vo=[.5,1.05,1.4,1.55,1.75,1.9,2,2.15,2.2,2.3,2.5,3,3,3.5,3.5],zo=new Float32Array(8),jo=[{binding:0,resource:null},{binding:1,resource:null},{binding:2,resource:{buffer:null}}],Do={label:"blur_compute_pass_h"},No={label:"blur_compute_pass_v"},Wo=(e,t,r,n,i,a,s,o)=>{const l=Math.ceil(.5*s),c=l>=8&&l<=24?a?"blur_compute_shared_horizontal":"blur_compute_shared_vertical":a?"blur_compute_horizontal":"blur_compute_vertical",u=r.getPipeline(c),f=r.getBindGroupLayout("blur_compute");if(!u||!f)return;const d=1-(l-.5*s),h=1+s;zo[0]=a?1:0,zo[1]=a?0:1,zo[2]=l,zo[3]=d,zo[4]=n.width,zo[5]=n.height,zo[6]=h,zo[7]=0;const p=o?o.acquireAndWriteUniformBuffer(zo):(()=>{const t=e.createBuffer({size:zo.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});return e.queue.writeBuffer(t,0,zo),t})();jo[0].resource=n.texture.view,jo[1].resource=i.texture.view,jo[2].resource.buffer=p;const m=e.createBindGroup({layout:f,entries:jo}),g=t.beginComputePass(a?Do:No);g.setPipeline(u),g.setBindGroup(0,m);const b=Math.ceil(i.width/16),x=Math.ceil(i.height/16);g.dispatchWorkgroups(b,x,1),g.end()},qo=new Float32Array(4),Xo=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],Yo=(e,t,r,n,i,a,s)=>{const{device:o,commandEncoder:l,frameBufferManager:c,pipelineManager:u,textureManager:f}=s,d=((e,t,r,n,i)=>{const a=t*(Math.sqrt(e[0]*e[0]+e[1]*e[1])/i),s=r*(Math.sqrt(e[2]*e[2]+e[3]*e[3])/i),o=Vo[Math.min(n-1,Vo.length-1)];let l=1,c=1;return a>128?l=.0625:a>64?l=.125:a>32?l=.25:a>16&&(l=.5),s>128?c=.0625:s>64?c=.125:s>32?c=.25:s>16&&(c=.5),{baseBlurX:a,baseBlurY:s,offsetX:Math.round(a*o),offsetY:Math.round(s*o),bufferScaleX:l,bufferScaleY:c}})(t,r,n,i,a),{baseBlurX:h,baseBlurY:p,offsetX:m,offsetY:g,bufferScaleX:b,bufferScaleY:x}=d;Io.x+=m,Io.y+=g;const v=e.width+2*m,y=e.height+2*g,_=Math.ceil(v*b),w=Math.ceil(y*x),M=c.createTemporaryAttachment(_,w),P=c.createTemporaryAttachment(_,w),S=f.createSampler("blur_sampler",!0);Ko(o,l,c,u,e,M,S,b,x,m*b,g*x,s.bufferManager);const F=h*b,T=p*x,B=s.computePipelineManager&&((e,t,r,n)=>{const i=Math.max(e,t),a=Math.min(r,n);return i>=4&&a>=128})(h,p,_,w),O=[M,P];let A=0;for(let e=0;e<i;++e){if(r>0){const e=A;A=(A+1)%2,B?Wo(o,l,s.computePipelineManager,O[e],O[A],!0,F,s.bufferManager):Ho(o,l,c,u,O[e],O[A],S,!0,F,s.bufferManager)}if(n>0){const e=A;A=(A+1)%2,B?Wo(o,l,s.computePipelineManager,O[e],O[A],!1,T,s.bufferManager):Ho(o,l,c,u,O[e],O[A],S,!1,T,s.bufferManager)}}let R=O[A];if(1!==b||1!==x){const e=c.createTemporaryAttachment(v,y);Qo(o,l,c,u,R,e,S,1/b,1/x,s.bufferManager),c.releaseTemporaryAttachment(M),c.releaseTemporaryAttachment(P),R=e}else{const e=(A+1)%2;c.releaseTemporaryAttachment(O[e])}return R},Ko=(e,t,r,n,i,a,s,o,l,c,u,f)=>{const d=n.getPipeline("texture_copy_rgba8"),h=n.getBindGroupLayout("texture_copy");if(!d||!h)return void console.error("[WebGPU BlurFilter] texture_copy_rgba8 pipeline not found");const p=i.width*o,m=i.height*l;qo[0]=1,qo[1]=1,qo[2]=0,qo[3]=0;const g=f?f.acquireAndWriteUniformBuffer(qo):e.createBuffer({size:qo.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});f||e.queue.writeBuffer(g,0,qo),Xo[0].resource.buffer=g,Xo[1].resource=s,Xo[2].resource=i.texture.view;const b=e.createBindGroup({layout:h,entries:Xo}),x=r.createRenderPassDescriptor(a.texture.view,0,0,0,0,"clear"),v=t.beginRenderPass(x);v.setPipeline(d),v.setBindGroup(0,b),v.setViewport(c,u,p,m,0,1),v.setScissorRect(Math.floor(c),Math.floor(u),Math.ceil(p),Math.ceil(m)),v.draw(6,1,0,0),v.end()},Ho=(e,t,r,n,i,a,s,o,l,c)=>{const u=((e,t,r,n)=>{const i=Math.ceil(.5*t);return{offsetX:e?1/r:0,offsetY:e?0:1/n,fraction:1-(i-.5*t),samples:1+t,halfBlur:i}})(o,l,i.width,i.height),{offsetX:f,offsetY:d,fraction:h,samples:p,halfBlur:m}=u,g=Math.max(1,Math.min(16,m)),b=n.getPipeline(`blur_filter_${g}`),x=n.getBindGroupLayout("blur_filter");if(!b||!x)return void console.error(`[WebGPU BlurFilter] blur_filter_${g} pipeline not found`);qo[0]=f,qo[1]=d,qo[2]=h,qo[3]=p;const v=c?c.acquireAndWriteUniformBuffer(qo):e.createBuffer({size:qo.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});c||e.queue.writeBuffer(v,0,qo),Xo[0].resource.buffer=v,Xo[1].resource=s,Xo[2].resource=i.texture.view;const y=e.createBindGroup({layout:x,entries:Xo}),_=r.createRenderPassDescriptor(a.texture.view,0,0,0,0,"clear"),w=t.beginRenderPass(_);w.setPipeline(b),w.setBindGroup(0,y),w.draw(6,1,0,0),w.end()},Qo=(e,t,r,n,i,a,s,o,l,c)=>{const u=n.getPipeline("texture_copy_rgba8"),f=n.getBindGroupLayout("texture_copy");if(!u||!f)return void console.error("[WebGPU BlurFilter] texture_copy_rgba8 pipeline not found");qo[0]=1,qo[1]=1,qo[2]=0,qo[3]=0;const d=c?c.acquireAndWriteUniformBuffer(qo):e.createBuffer({size:qo.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});c||e.queue.writeBuffer(d,0,qo),Xo[0].resource.buffer=d,Xo[1].resource=s,Xo[2].resource=i.texture.view;const h=e.createBindGroup({layout:f,entries:Xo}),p=r.createRenderPassDescriptor(a.texture.view,0,0,0,0,"clear"),m=t.beginRenderPass(p);m.setPipeline(u),m.setBindGroup(0,h),m.draw(6,1,0,0),m.end()},Zo=new Float32Array(20),Jo=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],el=(e,t,r)=>{const{device:n,commandEncoder:i,frameBufferManager:a,pipelineManager:s,textureManager:o}=r,l=a.createTemporaryAttachment(e.width,e.height),c=s.getPipeline("color_matrix_filter"),u=s.getBindGroupLayout("color_matrix_filter");if(!c||!u)return console.error("[WebGPU ColorMatrixFilter] Pipeline not found"),e;const f=o.createSampler("color_matrix_sampler",!0);Zo[0]=t[0],Zo[1]=t[5],Zo[2]=t[10],Zo[3]=t[15],Zo[4]=t[1],Zo[5]=t[6],Zo[6]=t[11],Zo[7]=t[16],Zo[8]=t[2],Zo[9]=t[7],Zo[10]=t[12],Zo[11]=t[17],Zo[12]=t[3],Zo[13]=t[8],Zo[14]=t[13],Zo[15]=t[18],Zo[16]=t[4]/255,Zo[17]=t[9]/255,Zo[18]=t[14]/255,Zo[19]=t[19]/255;const d=r.bufferManager?r.bufferManager.acquireAndWriteUniformBuffer(Zo):n.createBuffer({size:Zo.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});r.bufferManager||n.queue.writeBuffer(d,0,Zo),Jo[0].resource.buffer=d,Jo[1].resource=f,Jo[2].resource=e.texture.view;const h=n.createBindGroup({layout:u,entries:Jo}),p=a.createRenderPassDescriptor(l.texture.view,0,0,0,0,"clear"),m=i.beginRenderPass(p);return m.setPipeline(c),m.setBindGroup(0,h),m.draw(6,1,0,0),m.end(),l},tl=new Float32Array(16),rl=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null},{binding:3,resource:null}],nl=(e,t,r,n,i,a,s,o,l,c,u,f)=>{const{device:d,commandEncoder:h,frameBufferManager:p,pipelineManager:m,textureManager:g}=f,b=Io.x,x=Io.y,v=e.width,y=e.height,_=Yo(e,t,i,a,o,u,f),w=_.width,M=_.height,P=l?v:w,S=l?y:M,F=Io.x-b,T=Io.y-x,B=P/v,O=S/y,A=(l?0:F)/v,R=(l?0:T)/y,C=P/w,E=S/M,U=(l?-F:0)/w,$=(l?-T:0)/M,G=p.createTemporaryAttachment(P,S),k=m.getFilterPipeline("glow_filter",{IS_INNER:l?1:0,IS_KNOCKOUT:c?1:0}),L=m.getBindGroupLayout("glow_filter");if(!k||!L)return console.error("[WebGPU GlowFilter] Pipeline not found"),p.releaseTemporaryAttachment(_),e;const I=g.createSampler("glow_sampler",!0),[V,z,j,D]=((e,t)=>[(e>>16&255)/255*t,(e>>8&255)/255*t,(255&e)/255*t,t])(r,n);tl[0]=V,tl[1]=z,tl[2]=j,tl[3]=D,tl[4]=B,tl[5]=O,tl[6]=A,tl[7]=R,tl[8]=C,tl[9]=E,tl[10]=U,tl[11]=$,tl[12]=s,tl[13]=l?1:0,tl[14]=c?1:0,tl[15]=0;const N=f.bufferManager?f.bufferManager.acquireAndWriteUniformBuffer(tl):d.createBuffer({size:tl.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});f.bufferManager||d.queue.writeBuffer(N,0,tl),rl[0].resource.buffer=N,rl[1].resource=I,rl[2].resource=_.texture.view,rl[3].resource=e.texture.view;const W=d.createBindGroup({layout:L,entries:rl}),q=p.createRenderPassDescriptor(G.texture.view,0,0,0,0,"clear"),X=h.beginRenderPass(q);return X.setPipeline(k),X.setBindGroup(0,W),X.draw(6,1,0,0),X.end(),p.releaseTemporaryAttachment(_),G},il=Math.PI/180,al=new Float32Array(16),sl=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null},{binding:3,resource:null}],ol=(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p)=>{const{device:m,commandEncoder:g,frameBufferManager:b,pipelineManager:x,textureManager:v}=p,y=Io.x,_=Io.y,w=e.width,M=e.height,P=Yo(e,t,s,o,c,h,p),S=P.width,F=P.height,T=Io.x,B=Io.y,O=T-y,A=B-_,R=Math.sqrt(t[0]*t[0]+t[1]*t[1]),C=Math.sqrt(t[2]*t[2]+t[3]*t[3]),E=n*il,U=Math.cos(E)*r*(R/h),$=Math.sin(E)*r*(C/h),G=u?w:S+Math.max(0,Math.abs(U)-O),k=u?M:F+Math.max(0,Math.abs($)-A),L=Math.ceil(G),I=Math.ceil(k),V=(L-G)/2,z=(I-k)/2,j=u?0:Math.max(0,O-U)+V,D=u?0:Math.max(0,A-$)+z,N=u?U-T:(U>0?Math.max(0,U-O):0)+V,W=u?$-B:($>0?Math.max(0,$-A):0)+z,q=b.createTemporaryAttachment(L,I),X=u;let Y=f,K=d;u?Y=f||d:!f&&d&&(Y=!0,K=!0);const H=x.getFilterPipeline("drop_shadow_filter",{IS_INNER:X?1:0,IS_KNOCKOUT:Y?1:0,IS_HIDE_OBJECT:K?1:0}),Q=x.getBindGroupLayout("drop_shadow_filter");if(!H||!Q)return console.error("[WebGPU DropShadowFilter] Pipeline not found"),b.releaseTemporaryAttachment(P),e;const Z=v.createSampler("drop_shadow_sampler",!0),[J,ee,te,re]=((e,t)=>[(e>>16&255)/255*t,(e>>8&255)/255*t,(255&e)/255*t,t])(i,a),ne=L/w,ie=I/M,ae=j/w,se=D/M,oe=L/S,le=I/F,ce=N/S,ue=W/F;al[0]=J,al[1]=ee,al[2]=te,al[3]=re,al[4]=ne,al[5]=ie,al[6]=ae,al[7]=se,al[8]=oe,al[9]=le,al[10]=ce,al[11]=ue,al[12]=l,al[13]=X?1:0,al[14]=Y?1:0,al[15]=K?1:0;const fe=p.bufferManager?p.bufferManager.acquireAndWriteUniformBuffer(al):m.createBuffer({size:al.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});p.bufferManager||m.queue.writeBuffer(fe,0,al),sl[0].resource.buffer=fe,sl[1].resource=Z,sl[2].resource=P.texture.view,sl[3].resource=e.texture.view;const de=m.createBindGroup({layout:Q,entries:sl}),he=b.createRenderPassDescriptor(q.texture.view,0,0,0,0,"clear"),pe=g.beginRenderPass(he);return pe.setPipeline(H),pe.setBindGroup(0,de),pe.draw(6,1,0,0),pe.end(),b.releaseTemporaryAttachment(P),q},ll=Math.PI/180,cl=new Float32Array(8),ul=new Float32Array(20),fl=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],dl=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null},{binding:3,resource:null}],hl=(e,t)=>[(e>>16&255)/255*t,(e>>8&255)/255*t,(255&e)/255*t,t],pl=(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m)=>{const{device:g,commandEncoder:b,frameBufferManager:x,pipelineManager:v,textureManager:y}=m,_=Io.x,w=Io.y,M=e.width,P=e.height,S=Math.sqrt(t[0]*t[0]+t[1]*t[1]),F=Math.sqrt(t[2]*t[2]+t[3]*t[3]),T=n*ll,B=Math.cos(T)*r*(S/p),O=Math.sin(T)*r*(F/p),A=x.createTemporaryAttachment(M,P);b.copyTextureToTexture({texture:e.texture.resource,origin:{x:0,y:0,z:0}},{texture:A.texture.resource,origin:{x:0,y:0,z:0}},{width:M,height:P});const R=v.getPipeline("texture_erase"),C=v.getBindGroupLayout("texture_copy");if(R&&C){const t=y.createSampler("erase_sampler",!0),r=2*B/M,n=2*O/P;cl[0]=1,cl[1]=1,cl[2]=r,cl[3]=n,cl[4]=0,cl[5]=0,cl[6]=0,cl[7]=0;const i=m.bufferManager?m.bufferManager.acquireAndWriteUniformBuffer(cl):g.createBuffer({size:cl.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});m.bufferManager||g.queue.writeBuffer(i,0,cl),fl[0].resource.buffer=i,fl[1].resource=t,fl[2].resource=e.texture.view;const a=g.createBindGroup({layout:C,entries:fl}),s=x.createRenderPassDescriptor(A.texture.view,0,0,0,0,"load"),o=b.beginRenderPass(s);o.setPipeline(R),o.setBindGroup(0,a),o.draw(6,1,0,0),o.end()}const E=Yo(A,t,l,c,f,p,m);x.releaseTemporaryAttachment(A);const U=E.width,$=E.height,G=Math.abs(B),k=Math.abs(O),L=1===d,I=Math.ceil(U+2*G),V=Math.ceil($+2*k),z=L?M:I,j=L?P:V,D=(U-M)/2,N=($-P)/2,W=L?0:Math.floor(G+D),q=L?0:Math.floor(k+N),X=z/M,Y=j/P,K=W/M,H=q/P,Q=z/U,Z=j/$,J=(L?Math.floor(-D-B):Math.floor(G-B))/U,ee=(L?Math.floor(-N-O):Math.floor(k-O))/$,te=x.createTemporaryAttachment(z,j),re=v.getFilterPipeline("bevel_filter",{BEVEL_TYPE:d,IS_KNOCKOUT:h?1:0}),ne=v.getBindGroupLayout("bevel_filter");if(!re||!ne)return console.error("[WebGPU BevelFilter] Pipeline not found"),x.releaseTemporaryAttachment(E),e;const ie=y.createSampler("bevel_sampler",!0),[ae,se,oe,le]=hl(i,a),[ce,ue,fe,de]=hl(s,o);ul[0]=ae,ul[1]=se,ul[2]=oe,ul[3]=le,ul[4]=ce,ul[5]=ue,ul[6]=fe,ul[7]=de,ul[8]=u,ul[9]=L?1:0,ul[10]=h?1:0,ul[11]=d,ul[12]=X,ul[13]=Y,ul[14]=K,ul[15]=H,ul[16]=Q,ul[17]=Z,ul[18]=J,ul[19]=ee;const he=m.bufferManager?m.bufferManager.acquireAndWriteUniformBuffer(ul):g.createBuffer({size:ul.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});m.bufferManager||g.queue.writeBuffer(he,0,ul),dl[0].resource.buffer=he,dl[1].resource=ie,dl[2].resource=E.texture.view,dl[3].resource=e.texture.view;const pe=g.createBindGroup({layout:ne,entries:dl}),me=x.createRenderPassDescriptor(te.texture.view,0,0,0,0,"clear"),ge=b.beginRenderPass(me);return ge.setPipeline(re),ge.setBindGroup(0,pe),ge.draw(6,1,0,0),ge.end(),x.releaseTemporaryAttachment(E),Io.x=_+W,Io.y=w+q,te},ml=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],gl=new Map,bl=(e,t,r,n,i,a,s,o,l,c,u)=>{const{device:f,commandEncoder:d,frameBufferManager:h,textureManager:p}=u,m=e.width,g=e.height,b=h.createTemporaryAttachment(m,g),x=`${t},${r},${s},${o}`;let v=gl.get(x);if(!v){const e=fa.getConvolutionFilterFragmentShader(t,r,s,o),n=f.createShaderModule({code:e}),i=f.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}}]}),a=f.createPipelineLayout({bindGroupLayouts:[i]});v={pipeline:f.createRenderPipeline({layout:a,vertex:{module:n,entryPoint:"vs_main",buffers:[]},fragment:{module:n,entryPoint:"fs_main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}}),bindGroupLayout:i},gl.set(x,v)}const y=p.createSampler("convolution_sampler",!0),_=t*r,w=Math.ceil(_/4),[M,P,S,F]=((e,t)=>[(e>>16&255)/255,(e>>8&255)/255,(255&e)/255,t])(l,c),T=new Float32Array(4*w);for(let e=0;e<_;e++)T[e]=n[e];const B=new Float32Array((32+16*w)/4);B[0]=1/m,B[1]=1/g,B[2]=0!==i?1/i:1,B[3]=a/255,B[4]=M,B[5]=P,B[6]=S,B[7]=F;for(let e=0;e<T.length;e++)B[8+e]=T[e];const O=u.bufferManager?u.bufferManager.acquireAndWriteUniformBuffer(B):f.createBuffer({size:B.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});u.bufferManager||f.queue.writeBuffer(O,0,B),ml[0].resource.buffer=O,ml[1].resource=y,ml[2].resource=e.texture.view;const A=f.createBindGroup({layout:v.bindGroupLayout,entries:ml}),R=h.createRenderPassDescriptor(b.texture.view,0,0,0,0,"clear"),C=d.beginRenderPass(R);return C.setPipeline(v.pipeline),C.setBindGroup(0,A),C.draw(6,1,0,0),C.end(),b},xl=Math.PI/180,vl=new Float32Array(4),yl=new Float32Array(12),_l=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],wl=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null},{binding:3,resource:null},{binding:4,resource:null}],Ml=(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p)=>{const{device:m,commandEncoder:g,frameBufferManager:b,pipelineManager:x,textureManager:v}=p,y=Io.x,_=Io.y,w=e.width,M=e.height,P=Math.sqrt(t[0]*t[0]+t[1]*t[1]),S=Math.sqrt(t[2]*t[2]+t[3]*t[3]),F=n*xl,T=Math.cos(F)*r*(P/h),B=Math.sin(F)*r*(S/h),O=x.getPipeline("bevel_base"),A=x.getBindGroupLayout("bevel_base");if(!O||!A)return console.error("[WebGPU GradientBevelFilter] bevel_base pipeline not found"),e;const R=b.createTemporaryAttachment(w,M),C=v.createSampler("bevel_base_sampler",!0);vl[0]=2*T/w,vl[1]=2*B/M,vl[2]=0,vl[3]=0;const E=p.bufferManager?p.bufferManager.acquireAndWriteUniformBuffer(vl):m.createBuffer({size:vl.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});p.bufferManager||m.queue.writeBuffer(E,0,vl),_l[0].resource.buffer=E,_l[1].resource=C,_l[2].resource=e.texture.view;const U=m.createBindGroup({layout:A,entries:_l}),$=b.createRenderPassDescriptor(R.texture.view,0,0,0,0,"clear"),G=g.beginRenderPass($);G.setPipeline(O),G.setBindGroup(0,U),G.draw(6,1,0,0),G.end();const k=Yo(R,t,o,l,u,h,p);b.releaseTemporaryAttachment(R);const L=k.width,I=k.height,V=1===f,z=Math.abs(T),j=Math.abs(B),D=(L-w)/2,N=(I-M)/2,W=Math.ceil(L+2*z),q=Math.ceil(I+2*j),X=V?w:W,Y=V?M:q,K=V?0:z+D,H=V?0:j+N,Q=V?-D-T:z-T,Z=V?-N-B:j-B,J=qs(s,i,a),ee=m.createTexture({size:{width:256,height:1},format:"rgba8unorm",usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST});m.queue.writeTexture({texture:ee},J.buffer,{bytesPerRow:1024,offset:J.byteOffset},{width:256,height:1});const te=ee.createView(),re=X/w,ne=Y/M,ie=K/w,ae=H/M,se=X/L,oe=Y/I,le=Q/L,ce=Z/I,ue=b.createTemporaryAttachment(X,Y),fe=x.getFilterPipeline("gradient_bevel_filter",{BEVEL_TYPE:f,IS_KNOCKOUT:d?1:0}),de=x.getBindGroupLayout("gradient_bevel_filter");if(!fe||!de)return console.error("[WebGPU GradientBevelFilter] Pipeline not found"),b.releaseTemporaryAttachment(k),e;const he=v.createSampler("gradient_bevel_sampler",!0);yl[0]=c,yl[1]=V?1:0,yl[2]=d?1:0,yl[3]=f,yl[4]=re,yl[5]=ne,yl[6]=ie,yl[7]=ae,yl[8]=se,yl[9]=oe,yl[10]=le,yl[11]=ce;const pe=p.bufferManager?p.bufferManager.acquireAndWriteUniformBuffer(yl):m.createBuffer({size:yl.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});p.bufferManager||m.queue.writeBuffer(pe,0,yl),wl[0].resource.buffer=pe,wl[1].resource=he,wl[2].resource=k.texture.view,wl[3].resource=e.texture.view,wl[4].resource=te;const me=m.createBindGroup({layout:de,entries:wl}),ge=b.createRenderPassDescriptor(ue.texture.view,0,0,0,0,"clear"),be=g.beginRenderPass(ge);return be.setPipeline(fe),be.setBindGroup(0,me),be.draw(6,1,0,0),be.end(),p.frameTextures.push(ee),b.releaseTemporaryAttachment(k),Io.x=y+K,Io.y=_+H,ue},Pl=Math.PI/180,Sl=new Float32Array(12),Fl=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null},{binding:3,resource:null},{binding:4,resource:null}],Tl=(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p)=>{const{device:m,commandEncoder:g,frameBufferManager:b,pipelineManager:x,textureManager:v}=p,y=Io.x,_=Io.y,w=e.width,M=e.height,P=Yo(e,t,o,l,u,h,p),S=P.width,F=P.height,T=Io.x,B=Io.y,O=T-y,A=B-_,R=Math.sqrt(t[0]*t[0]+t[1]*t[1]),C=Math.sqrt(t[2]*t[2]+t[3]*t[3]),E=n*Pl,U=Math.cos(E)*r*(R/h),$=Math.sin(E)*r*(C/h),G=1===f,k=G?w:S+Math.max(0,Math.abs(U)-O),L=G?M:F+Math.max(0,Math.abs($)-A),I=Math.ceil(k),V=Math.ceil(L),z=(I-k)/2,j=(V-L)/2,D=G?0:Math.max(0,O-U)+z,N=G?0:Math.max(0,A-$)+j,W=G?U-T:(U>0?Math.max(0,U-O):0)+z,q=G?$-B:($>0?Math.max(0,$-A):0)+j,X=qs(s,i,a),Y=m.createTexture({size:{width:256,height:1},format:"rgba8unorm",usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST});m.queue.writeTexture({texture:Y},X.buffer,{bytesPerRow:1024,offset:X.byteOffset},{width:256,height:1});const K=Y.createView(),H=I/w,Q=V/M,Z=D/w,J=N/M,ee=I/S,te=V/F,re=W/S,ne=q/F,ie=b.createTemporaryAttachment(I,V),ae=x.getFilterPipeline("gradient_glow_filter",{GLOW_TYPE:f,IS_KNOCKOUT:d?1:0}),se=x.getBindGroupLayout("gradient_glow_filter");if(!ae||!se)return console.error("[WebGPU GradientGlowFilter] Pipeline not found"),b.releaseTemporaryAttachment(P),e;const oe=v.createSampler("gradient_glow_sampler",!0);Sl[0]=c,Sl[1]=G?1:0,Sl[2]=d?1:0,Sl[3]=f,Sl[4]=H,Sl[5]=Q,Sl[6]=Z,Sl[7]=J,Sl[8]=ee,Sl[9]=te,Sl[10]=re,Sl[11]=ne;const le=p.bufferManager?p.bufferManager.acquireAndWriteUniformBuffer(Sl):m.createBuffer({size:Sl.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});p.bufferManager||m.queue.writeBuffer(le,0,Sl),Fl[0].resource.buffer=le,Fl[1].resource=oe,Fl[2].resource=P.texture.view,Fl[3].resource=e.texture.view,Fl[4].resource=K;const ce=m.createBindGroup({layout:se,entries:Fl}),ue=b.createRenderPassDescriptor(ie.texture.view,0,0,0,0,"clear"),fe=g.beginRenderPass(ue);return fe.setPipeline(ae),fe.setBindGroup(0,ce),fe.draw(6,1,0,0),fe.end(),p.frameTextures.push(Y),b.releaseTemporaryAttachment(P),Io.x=y+D,Io.y=_+N,ie},Bl=new Float32Array(12),Ol=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null},{binding:3,resource:null}],Al=new Map,Rl=(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m)=>{const{device:g,commandEncoder:b,frameBufferManager:x,textureManager:v}=m,y=e.width,_=e.height,w=n,M=i,P=x.createTemporaryAttachment(y,_),S=g.createTexture({size:{width:n,height:i},format:"rgba8unorm",usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST});g.queue.writeTexture({texture:S},r.buffer,{bytesPerRow:4*n,offset:r.byteOffset},{width:n,height:i});const F=`${o},${l},${f}`;let T=Al.get(F);if(!T){const e=fa.getDisplacementMapFilterFragmentShader(o,l,f),t=g.createShaderModule({code:fa.getBlurFilterVertexShader()}),r=g.createShaderModule({code:e}),n=g.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}},{binding:3,visibility:GPUShaderStage.FRAGMENT,texture:{}}]}),i=g.createPipelineLayout({bindGroupLayouts:[n]});T={pipeline:g.createRenderPipeline({layout:i,vertex:{module:t,entryPoint:"main",buffers:[]},fragment:{module:r,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}}),bindGroupLayout:n},Al.set(F,T)}const B=v.createSampler("displacement_sampler",!0),O=1===f,A=O?48:32;if(Bl[0]=w/n,Bl[1]=M/i,Bl[2]=a/n,Bl[3]=(M-i-s)/i,Bl[4]=c/w,Bl[5]=u/M,Bl[6]=0,Bl[7]=0,O){const[e,t,r,n]=((e,t)=>[(e>>16&255)/255*t,(e>>8&255)/255*t,(255&e)/255*t,t])(d,h);Bl[8]=e,Bl[9]=t,Bl[10]=r,Bl[11]=n}const R=m.bufferManager?m.bufferManager.acquireAndWriteUniformBuffer(Bl,A):g.createBuffer({size:A,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});m.bufferManager||g.queue.writeBuffer(R,0,Bl,0,A/4),Ol[0].resource.buffer=R,Ol[1].resource=B,Ol[2].resource=e.texture.view,Ol[3].resource=S.createView();const C=g.createBindGroup({layout:T.bindGroupLayout,entries:Ol}),E=x.createRenderPassDescriptor(P.texture.view,0,0,0,0,"clear"),U=b.beginRenderPass(E);return U.setPipeline(T.pipeline),U.setBindGroup(0,C),U.draw(6,1,0,0),U.end(),m.frameTextures.push(S),P},Cl=new Float32Array(4),El=new Float32Array(6),Ul=new Float32Array(6),$l=new Float32Array(8),Gl=new Float32Array(12),kl=new Float32Array(20),Ll=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],Il=new Set(["normal","layer","add","screen","alpha","erase","copy"]),Vl=new Float32Array([1,-1,0,1]),zl=(e,t,r,n,i,a,s,o)=>{const l=e.mainAttachment||e.frameBufferManager.getAttachment("main");if(!l||!l.texture||!t.texture)return;let c=i,u=a,f=t.width,d=t.height,h=0,p=0;if(c<0&&(h=-c/t.width,f+=c,c=0),u<0&&(p=-u/t.height,d+=u,u=0),f<=0||d<=0)return;const m=l.width,g=l.height;if(c+f>m&&(f=m-c),u+d>g&&(d=g-u),b=n,Il.has(b)){const r=l.msaa&&l.msaaTexture?.view;let i;switch(n){case"add":i=r?"filter_output_add_msaa":"filter_output_add";break;case"screen":i=r?"filter_output_screen_msaa":"filter_output_screen";break;case"alpha":i=r?"filter_output_alpha_msaa":"filter_output_alpha";break;case"erase":i=r?"filter_output_erase_msaa":"filter_output_erase";break;case"copy":i=r?"texture_copy_bgra_msaa":"texture_copy_bgra";break;default:i=r?"filter_output_msaa":"filter_output"}let a=e.pipelineManager.getPipeline(i),s=e.pipelineManager.getBindGroupLayout("texture_copy");if(!(a&&s||(i=r?"filter_output_msaa":"filter_output",a=e.pipelineManager.getPipeline(i),s=e.pipelineManager.getBindGroupLayout("texture_copy"),a&&s)))return;const o=e.textureManager.createSampler("filter_output_sampler",!0),b=f/t.width,x=d/t.height;Cl[0]=b,Cl[1]=x,Cl[2]=h,Cl[3]=p;const v=e.bufferManager.acquireAndWriteUniformBuffer(Cl);Ll[0].resource.buffer=v,Ll[1].resource=o,Ll[2].resource=t.texture.view;const y=e.device.createBindGroup({layout:s,entries:Ll}),_=r?l.msaaTexture.view:l.texture.view,w=r?l.texture.view:null,M=e.frameBufferManager.createRenderPassDescriptor(_,0,0,0,0,"load",w),P=Math.max(0,c),S=Math.max(0,u),F=Math.max(1,f),T=Math.max(1,d),B=Math.max(0,Math.floor(P)),O=Math.max(0,Math.floor(S)),A=Math.max(1,Math.min(Math.ceil(P+F)-B,m-B)),R=Math.max(1,Math.min(Math.ceil(S+T)-O,g-O));if(A<=0||R<=0||B>=m||O>=g)return;const C=e.commandEncoder.beginRenderPass(M);C.setPipeline(a),C.setBindGroup(0,y),C.setViewport(P,S,F,T,0,1),C.setScissorRect(B,O,A,R),C.draw(6,1,0,0),C.end()}else{const i=((e,t,r,n,i,a)=>{const s=e.frameBufferManager.createTemporaryAttachment(i,a),o=e.pipelineManager.getPipeline("complex_blend_copy"),l=e.pipelineManager.getBindGroupLayout("texture_copy");if(!(o&&l&&t.texture&&s.texture))return s;const c=i/t.width,u=a/t.height,f=r/t.width,d=n/t.height;Cl[0]=c,Cl[1]=u,Cl[2]=f,Cl[3]=d;const h=e.bufferManager.acquireAndWriteUniformBuffer(Cl),p=e.textureManager.createSampler("filter_copy_sampler",!1);Ll[0].resource.buffer=h,Ll[1].resource=p,Ll[2].resource=t.texture.view;const m=e.device.createBindGroup({layout:l,entries:Ll}),g=e.frameBufferManager.createRenderPassDescriptor(s.texture.view,0,0,0,0,"clear"),b=e.commandEncoder.beginRenderPass(g);return b.setPipeline(o),b.setBindGroup(0,m),b.draw(6,1,0,0),b.end(),s})(e,l,c,u,f,d);$l[0]=r[0],$l[1]=r[1],$l[2]=r[2],$l[3]=r[3],$l[4]=r[4],$l[5]=r[5],$l[6]=r[6],$l[7]=0;const a=Ao(t,i,n,$l,{device:e.device,commandEncoder:e.commandEncoder,bufferManager:e.bufferManager,frameBufferManager:e.frameBufferManager,pipelineManager:e.pipelineManager,textureManager:e.textureManager,frameTextures:e.frameTextures});((e,t,r,n,i)=>{const a=r.msaa&&r.msaaTexture?.view,s=a?"filter_complex_blend_output_msaa":"filter_complex_blend_output",o=e.pipelineManager.getPipeline(s),l=e.pipelineManager.getBindGroupLayout("positioned_texture");if(!(o&&l&&t.texture&&r.texture))return;$l[0]=n,$l[1]=i,$l[2]=t.width,$l[3]=t.height,$l[4]=r.width,$l[5]=r.height,$l[6]=0,$l[7]=0;const c=e.bufferManager.acquireAndWriteUniformBuffer($l),u=e.textureManager.createSampler("filter_blend_output_sampler",!1);Ll[0].resource.buffer=c,Ll[1].resource=u,Ll[2].resource=t.texture.view;const f=e.device.createBindGroup({layout:l,entries:Ll}),d=a?r.msaaTexture.view:r.texture.view,h=a?r.texture.view:null,p=e.frameBufferManager.createRenderPassDescriptor(d,0,0,0,0,"load",h),m=e.commandEncoder.beginRenderPass(p);m.setPipeline(o),m.setBindGroup(0,f),m.draw(6,1,0,0),m.end()})(e,a,l,c,u),e.frameBufferManager.releaseTemporaryAttachment(i),e.frameBufferManager.releaseTemporaryAttachment(a)}var b},jl=(e,t,r,n,i,a,s,o,l,c,u,f)=>{Io.x=0,Io.y=0;let d=((e,t,r)=>{const n=r.createTemporaryAttachment(e.w,e.h),i=wa()||r.getAttachment("atlas");return i&&i.texture&&n.texture?t.copyTextureToTexture({texture:i.texture.resource,origin:{x:e.x,y:e.y,z:0}},{texture:n.texture.resource,origin:{x:0,y:0,z:0}},{width:e.w,height:e.h}):console.error("[WebGPU Filter] getTextureFromNode: FAILED - missing atlas or textures"),n})(e,c.commandEncoder,c.frameBufferManager);if(d.texture){const t=c.frameBufferManager.createTemporaryAttachment(e.w,e.h),r=c.pipelineManager.getPipeline("texture_copy_rgba8"),n=c.pipelineManager.getBindGroupLayout("texture_copy");if(r&&n&&t.texture){const e=c.textureManager.createSampler("filter_flip_sampler",!1),i=c.bufferManager.acquireAndWriteUniformBuffer(Vl);Ll[0].resource.buffer=i,Ll[1].resource=e,Ll[2].resource=d.texture.view;const a=c.device.createBindGroup({layout:n,entries:Ll}),s=c.frameBufferManager.createRenderPassDescriptor(t.texture.view,0,0,0,0,"clear"),o=c.commandEncoder.beginRenderPass(s);o.setPipeline(r),o.setBindGroup(0,a),o.draw(6,1,0,0),o.end(),c.frameBufferManager.releaseTemporaryAttachment(d),d=t}}const h=Hn.getDevicePixelRatio(),p=Math.sqrt(i[0]*i[0]+i[1]*i[1]),m=Math.sqrt(i[2]*i[2]+i[3]*i[3]),g=Math.atan2(i[1],i[0]),b=Math.atan2(-i[2],i[3]),x=n?p*Math.cos(g):Math.cos(g),v=n?p*Math.sin(g):Math.sin(g),y=n?-m*Math.sin(b):-Math.sin(b),_=n?m*Math.cos(b):Math.cos(b);El[0]=x,El[1]=v,El[2]=y,El[3]=_,El[4]=t/2,El[5]=r/2,Ul[0]=1,Ul[1]=0,Ul[2]=0,Ul[3]=1,Ul[4]=-e.w/2,Ul[5]=-e.h/2;const w=El[0]*Ul[0]+El[2]*Ul[1],M=El[1]*Ul[0]+El[3]*Ul[1],P=El[0]*Ul[2]+El[2]*Ul[3],S=El[1]*Ul[2]+El[3]*Ul[3],F=El[0]*Ul[4]+El[2]*Ul[5]+El[4],T=El[1]*Ul[4]+El[3]*Ul[5]+El[5];let B=0,O=0;if(1!==w||0!==M||0!==P||1!==S){const n=c.frameBufferManager.createTemporaryAttachment(t,r),i="texture_scale",a=c.pipelineManager.getPipeline(i),s=c.pipelineManager.getBindGroupLayout("texture_scale");if(a&&s){Gl[0]=w,Gl[1]=M,Gl[2]=P,Gl[3]=S,Gl[4]=F,Gl[5]=T,Gl[6]=e.w,Gl[7]=e.h,Gl[8]=t,Gl[9]=r,Gl[10]=0,Gl[11]=0;const i=c.bufferManager.acquireAndWriteUniformBuffer(Gl,48),o=c.textureManager.createSampler("filter_scale_sampler",!0);Ll[0].resource.buffer=i,Ll[1].resource=o,Ll[2].resource=d.texture.view;const l=c.device.createBindGroup({layout:s,entries:Ll}),u=c.frameBufferManager.createRenderPassDescriptor(n.texture.view,0,0,0,0,"clear"),f=c.commandEncoder.beginRenderPass(u);f.setPipeline(a),f.setBindGroup(0,l),f.draw(6,1,0,0),f.end(),B=F,O=T,c.frameBufferManager.releaseTemporaryAttachment(d),d=n}}for(let e=0;l.length>e;){switch(l[e++]){case 0:{const t=l[e++],r=l[e++],n=l[e++],a=l[e++],s=l[e++],o=l[e++],u=l[e++],f=l[e++],p=l[e++],m=l[e++],g=l[e++],b=Boolean(l[e++]),x=pl(d,i,t,r,n,a,s,o,u,f,p,m,g,b,h,c);d!==x&&c.frameBufferManager.releaseTemporaryAttachment(d),d=x}break;case 1:{const t=l[e++],r=l[e++],n=l[e++],a=Yo(d,i,t,r,n,h,c);d!==a&&c.frameBufferManager.releaseTemporaryAttachment(d),d=a}break;case 2:{kl[0]=l[e++],kl[1]=l[e++],kl[2]=l[e++],kl[3]=l[e++],kl[4]=l[e++],kl[5]=l[e++],kl[6]=l[e++],kl[7]=l[e++],kl[8]=l[e++],kl[9]=l[e++],kl[10]=l[e++],kl[11]=l[e++],kl[12]=l[e++],kl[13]=l[e++],kl[14]=l[e++],kl[15]=l[e++],kl[16]=l[e++],kl[17]=l[e++],kl[18]=l[e++],kl[19]=l[e++];const t=el(d,kl,c);d!==t&&c.frameBufferManager.releaseTemporaryAttachment(d),d=t}break;case 3:{const t=l[e++],r=l[e++],n=t*r,i=new Float32Array(n);for(let t=0;t<n;t++)i[t]=l[e++];const a=l[e++],s=l[e++],o=Boolean(l[e++]),u=Boolean(l[e++]),f=l[e++],h=l[e++],p=bl(d,t,r,i,a,s,o,u,f,h,c);d!==p&&c.frameBufferManager.releaseTemporaryAttachment(d),d=p}break;case 4:{const t=l[e++],r=new Uint8Array(t);for(let n=0;n<t;n++)r[n]=l[e++];const n=l[e++],i=l[e++],a=l[e++],s=l[e++],o=l[e++],u=l[e++],f=l[e++],h=l[e++],p=l[e++],m=l[e++],g=l[e++],b=Rl(d,0,r,n,i,a,s,o,u,f,h,p,m,g,0,c);d!==b&&c.frameBufferManager.releaseTemporaryAttachment(d),d=b}break;case 5:{const t=l[e++],r=l[e++],n=l[e++],a=l[e++],s=l[e++],o=l[e++],u=l[e++],f=l[e++],p=Boolean(l[e++]),m=Boolean(l[e++]),g=Boolean(l[e++]),b=ol(d,i,t,r,n,a,s,o,u,f,p,m,g,h,c);d!==b&&c.frameBufferManager.releaseTemporaryAttachment(d),d=b}break;case 6:{const t=l[e++],r=l[e++],n=l[e++],a=l[e++],s=l[e++],o=l[e++],u=Boolean(l[e++]),f=Boolean(l[e++]),p=nl(d,i,t,r,n,a,s,o,u,f,h,c);d!==p&&c.frameBufferManager.releaseTemporaryAttachment(d),d=p}break;case 7:{const t=l[e++],r=l[e++],n=l[e++],a=new Float32Array(n);for(let t=0;t<n;t++)a[t]=l[e++];const s=l[e++],o=new Float32Array(s);for(let t=0;t<s;t++)o[t]=l[e++];const u=l[e++],f=new Float32Array(u);for(let t=0;t<u;t++)f[t]=l[e++];const p=l[e++],m=l[e++],g=l[e++],b=l[e++],x=l[e++],v=Boolean(l[e++]),y=Ml(d,i,t,r,a,o,f,p,m,g,b,x,v,h,c);d!==y&&c.frameBufferManager.releaseTemporaryAttachment(d),d=y}break;case 8:{const t=l[e++],r=l[e++],n=l[e++],a=new Float32Array(n);for(let t=0;t<n;t++)a[t]=l[e++];const s=l[e++],o=new Float32Array(s);for(let t=0;t<s;t++)o[t]=l[e++];const u=l[e++],f=new Float32Array(u);for(let t=0;t<u;t++)f[t]=l[e++];const p=l[e++],m=l[e++],g=l[e++],b=l[e++],x=l[e++],v=Boolean(l[e++]),y=Tl(d,i,t,r,a,o,f,p,m,g,b,x,v,h,c);d!==y&&c.frameBufferManager.releaseTemporaryAttachment(d),d=y}}}if(1!==(A=a)[0]||1!==A[1]||1!==A[2]||1!==A[3]||0!==A[4]||0!==A[5]||0!==A[6]||0!==A[7]){const e=((e,t,r)=>{const n=e.frameBufferManager.createTemporaryAttachment(t.width,t.height),i=e.pipelineManager.getPipeline("color_transform"),a=e.pipelineManager.getBindGroupLayout("texture_copy");if(!(i&&a&&t.texture&&n.texture))return t;$l[0]=r[0],$l[1]=r[1],$l[2]=r[2],$l[3]=r[3],$l[4]=r[4],$l[5]=r[5],$l[6]=r[6],$l[7]=0;const s=e.bufferManager.acquireAndWriteUniformBuffer($l),o=e.textureManager.createSampler("color_transform_sampler",!1);Ll[0].resource.buffer=s,Ll[1].resource=o,Ll[2].resource=t.texture.view;const l=e.device.createBindGroup({layout:a,entries:Ll}),c=e.frameBufferManager.createRenderPassDescriptor(n.texture.view,0,0,0,0,"clear"),u=e.commandEncoder.beginRenderPass(c);return u.setPipeline(i),u.setBindGroup(0,l),u.draw(6,1,0,0),u.end(),n})(c,d,a);c.frameBufferManager.releaseTemporaryAttachment(d),d=e}var A;const R=o[0]*(p/h),C=o[1]*(m/h),E=-B+R+i[4],U=-O+C+i[5];zl(c,d,a,s,E,U),c.frameBufferManager.releaseTemporaryAttachment(d)},Dl=new Float32Array(4),Nl=new Float32Array(8),Wl=new Float32Array(20),ql=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],Xl=new Set(["normal","layer","add","screen","alpha","erase","copy"]),Yl=new Float32Array([1,1,1,1,0,0,0,0]),Kl=e=>!e||1===e[0]&&1===e[1]&&1===e[2]&&1===e[3]&&0===e[4]&&0===e[5]&&0===e[6]&&0===e[7],Hl=(e,t,r)=>{const n=e.frameBufferManager.createTemporaryAttachment(t.width,t.height),i=e.pipelineManager.getPipeline("color_transform"),a=e.pipelineManager.getBindGroupLayout("texture_copy");if(!(i&&a&&t.texture&&n.texture))return t;Nl[0]=r[0],Nl[1]=r[1],Nl[2]=r[2],Nl[3]=r[3],Nl[4]=r[4],Nl[5]=r[5],Nl[6]=r[6],Nl[7]=0;const s=e.bufferManager.acquireAndWriteUniformBuffer(Nl),o=e.textureManager.createSampler("container_ct_sampler",!1);ql[0].resource.buffer=s,ql[1].resource=o,ql[2].resource=t.texture.view;const l=e.device.createBindGroup({layout:a,entries:ql}),c=e.frameBufferManager.createRenderPassDescriptor(n.texture.view,0,0,0,0,"clear"),u=e.commandEncoder.beginRenderPass(c);return u.setPipeline(i),u.setBindGroup(0,l),u.draw(6,1,0,0),u.end(),n},Ql=(e,t,r,n,i,a)=>{const s=e.frameBufferManager.createTemporaryAttachment(i,a),o=e.pipelineManager.getPipeline("complex_blend_copy"),l=e.pipelineManager.getBindGroupLayout("texture_copy");if(!(o&&l&&t.texture&&s.texture))return s;const c=i/t.width,u=r/t.width,f=-a/t.height,d=(n+a)/t.height;Dl[0]=c,Dl[1]=f,Dl[2]=u,Dl[3]=d;const h=e.bufferManager.acquireAndWriteUniformBuffer(Dl),p=e.textureManager.createSampler("container_copy_sampler",!1);ql[0].resource.buffer=h,ql[1].resource=p,ql[2].resource=t.texture.view;const m=e.device.createBindGroup({layout:l,entries:ql}),g=e.frameBufferManager.createRenderPassDescriptor(s.texture.view,0,0,0,0,"clear"),b=e.commandEncoder.beginRenderPass(g);return b.setPipeline(o),b.setBindGroup(0,m),b.draw(6,1,0,0),b.end(),s},Zl=(e,t,r,n,i,a,s)=>{if(!r.texture||!t.texture)return;let o=i,l=a,c=t.width,u=t.height,f=0,d=0;if(o<0&&(f=-o/t.width,c+=o,o=0),l<0&&(d=-l/t.height,u+=l,l=0),c<=0||u<=0)return;const h=r.width,p=r.height;if(o+c>h&&(c=h-o),l+u>p&&(u=p-l),Xl.has(n)){const i=r.msaa&&r.msaaTexture?.view;let a;switch(n){case"add":a=i?"filter_output_add_msaa":"filter_output_add";break;case"screen":a=i?"filter_output_screen_msaa":"filter_output_screen";break;case"alpha":a=i?"filter_output_alpha_msaa":"filter_output_alpha";break;case"erase":a=i?"filter_output_erase_msaa":"filter_output_erase";break;case"copy":a=i?"texture_copy_bgra_msaa":"texture_copy_bgra";break;default:a=i?"filter_output_msaa":"filter_output"}const m=e.pipelineManager.getPipeline(a),g=e.pipelineManager.getBindGroupLayout("texture_copy");if(!m||!g)return;const b=e.textureManager.createSampler("container_output_sampler",!0),x=c/t.width,v=u/t.height;Dl[0]=x,Dl[1]=v,Dl[2]=f,Dl[3]=d;const y=s.acquireAndWriteUniformBuffer(Dl);ql[0].resource.buffer=y,ql[1].resource=b,ql[2].resource=t.texture.view;const _=e.device.createBindGroup({layout:g,entries:ql}),w=i?r.msaaTexture.view:r.texture.view,M=i?r.texture.view:null,P=e.frameBufferManager.createRenderPassDescriptor(w,0,0,0,0,"load",M),S=Math.max(0,o),F=Math.max(0,l),T=Math.max(1,c),B=Math.max(1,u),O=Math.max(0,Math.floor(S)),A=Math.max(0,Math.floor(F)),R=Math.max(1,Math.min(Math.ceil(S+T)-O,h-O)),C=Math.max(1,Math.min(Math.ceil(F+B)-A,p-A));if(R<=0||C<=0||O>=h||A>=p)return;const E=e.commandEncoder.beginRenderPass(P);E.setPipeline(m),E.setBindGroup(0,_),E.setViewport(S,F,T,B,0,1),E.setScissorRect(O,A,R,C),E.draw(6,1,0,0),E.end()}else{const i=Ql(e,r,o,l,c,u);Nl[0]=Yl[0],Nl[1]=Yl[1],Nl[2]=Yl[2],Nl[3]=Yl[3],Nl[4]=Yl[4]/255,Nl[5]=Yl[5]/255,Nl[6]=Yl[6]/255,Nl[7]=0;const a=Ao(t,i,n,Nl,{device:e.device,commandEncoder:e.commandEncoder,bufferManager:e.bufferManager,frameBufferManager:e.frameBufferManager,pipelineManager:e.pipelineManager,textureManager:e.textureManager,frameTextures:e.frameTextures}),f=r.msaa&&r.msaaTexture?.view,d=f?"filter_complex_blend_output_msaa":"filter_complex_blend_output",h=e.pipelineManager.getPipeline(d),p=e.pipelineManager.getBindGroupLayout("positioned_texture");if(h&&p&&a.texture&&r.texture){Nl[0]=o,Nl[1]=l,Nl[2]=a.width,Nl[3]=a.height,Nl[4]=r.width,Nl[5]=r.height,Nl[6]=0,Nl[7]=0;const t=s.acquireAndWriteUniformBuffer(Nl),n=e.textureManager.createSampler("container_blend_output_sampler",!1);ql[0].resource.buffer=t,ql[1].resource=n,ql[2].resource=a.texture.view;const i=e.device.createBindGroup({layout:p,entries:ql}),c=f?r.msaaTexture.view:r.texture.view,u=f?r.texture.view:null,d=e.frameBufferManager.createRenderPassDescriptor(c,0,0,0,0,"load",u),m=e.commandEncoder.beginRenderPass(d);m.setPipeline(h),m.setBindGroup(0,i),m.draw(6,1,0,0),m.end()}e.frameBufferManager.releaseTemporaryAttachment(i),e.frameBufferManager.releaseTemporaryAttachment(a)}},Jl=(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p)=>{if(s&&i&&o&&l){let r=Ql(h,e,0,0,e.width,e.height);h.frameBufferManager.releaseTemporaryAttachment(e);const s=Hn.getDevicePixelRatio();if(r=((e,t,r,n,i)=>{Io.x=0,Io.y=0;for(let a=0;r.length>a;)switch(r[a++]){case 0:{const s=pl(e,t,r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],Boolean(r[a++]),n,i);e!==s&&i.frameBufferManager.releaseTemporaryAttachment(e),e=s}break;case 1:{const s=Yo(e,t,r[a++],r[a++],r[a++],n,i);e!==s&&i.frameBufferManager.releaseTemporaryAttachment(e),e=s}break;case 2:{Wl[0]=r[a++],Wl[1]=r[a++],Wl[2]=r[a++],Wl[3]=r[a++],Wl[4]=r[a++],Wl[5]=r[a++],Wl[6]=r[a++],Wl[7]=r[a++],Wl[8]=r[a++],Wl[9]=r[a++],Wl[10]=r[a++],Wl[11]=r[a++],Wl[12]=r[a++],Wl[13]=r[a++],Wl[14]=r[a++],Wl[15]=r[a++],Wl[16]=r[a++],Wl[17]=r[a++],Wl[18]=r[a++],Wl[19]=r[a++];const t=el(e,Wl,i);e!==t&&i.frameBufferManager.releaseTemporaryAttachment(e),e=t}break;case 3:{const t=r[a++],n=r[a++],s=t*n,o=new Float32Array(s);for(let e=0;e<s;e++)o[e]=r[a++];const l=bl(e,t,n,o,r[a++],r[a++],Boolean(r[a++]),Boolean(r[a++]),r[a++],r[a++],i);e!==l&&i.frameBufferManager.releaseTemporaryAttachment(e),e=l}break;case 4:{const t=r[a++],n=new Uint8Array(t);for(let e=0;e<t;e++)n[e]=r[a++];const s=Rl(e,0,n,r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],0,i);e!==s&&i.frameBufferManager.releaseTemporaryAttachment(e),e=s}break;case 5:{const s=ol(e,t,r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],Boolean(r[a++]),Boolean(r[a++]),Boolean(r[a++]),n,i);e!==s&&i.frameBufferManager.releaseTemporaryAttachment(e),e=s}break;case 6:{const s=nl(e,t,r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],Boolean(r[a++]),Boolean(r[a++]),n,i);e!==s&&i.frameBufferManager.releaseTemporaryAttachment(e),e=s}break;case 7:{const s=r[a++],o=r[a++],l=r[a++],c=new Float32Array(l);for(let e=0;e<l;e++)c[e]=r[a++];const u=r[a++],f=new Float32Array(u);for(let e=0;e<u;e++)f[e]=r[a++];const d=r[a++],h=new Float32Array(d);for(let e=0;e<d;e++)h[e]=r[a++];const p=Ml(e,t,s,o,c,f,h,r[a++],r[a++],r[a++],r[a++],r[a++],Boolean(r[a++]),n,i);e!==p&&i.frameBufferManager.releaseTemporaryAttachment(e),e=p}break;case 8:{const s=r[a++],o=r[a++],l=r[a++],c=new Float32Array(l);for(let e=0;e<l;e++)c[e]=r[a++];const u=r[a++],f=new Float32Array(u);for(let e=0;e<u;e++)f[e]=r[a++];const d=r[a++],h=new Float32Array(d);for(let e=0;e<d;e++)h[e]=r[a++];const p=Tl(e,t,s,o,c,f,h,r[a++],r[a++],r[a++],r[a++],r[a++],Boolean(r[a++]),n,i);e!==p&&i.frameBufferManager.releaseTemporaryAttachment(e),e=p}}return e})(r,i,l,s,h),c&&(yn.set(c,"fKey",u),yn.set(c,"fTexture",r)),r){let e=r,l=null;Kl(a)||(l=Hl(h,r,a),e=l);const u=Math.sqrt(i[0]*i[0]+i[1]*i[1]),f=Math.sqrt(i[2]*i[2]+i[3]*i[3]),d=o[0]*(u/s),m=o[1]*(f/s),g=d+i[4],b=m+i[5];Zl(h,e,t,n,g,b,p),l&&h.frameBufferManager.releaseTemporaryAttachment(l),c||h.frameBufferManager.releaseTemporaryAttachment(r)}}else{let r=Ql(h,e,0,0,e.width,e.height);if(h.frameBufferManager.releaseTemporaryAttachment(e),!Kl(a)){const e=Hl(h,r,a);h.frameBufferManager.releaseTemporaryAttachment(r),r=e}Zl(h,r,t,n,i[4],i[5],p),h.frameBufferManager.releaseTemporaryAttachment(r)}},ec=new Float32Array([1,1,0,0]),tc=[],rc=new Float32Array([0,0,.5,.5,1,1,1,1,1,0,0,0,1,0,0,0,1,1,0,.5,.5,1,1,1,1,1,0,0,0,1,0,0,0,1,0,1,.5,.5,1,1,1,1,1,0,0,0,1,0,0,0,1,1,0,.5,.5,1,1,1,1,1,0,0,0,1,0,0,0,1,1,1,.5,.5,1,1,1,1,1,0,0,0,1,0,0,0,1,0,1,.5,.5,1,1,1,1,1,0,0,0,1,0,0,0,1]),nc=new Float32Array([0,0,1,0,0,1,1,0,1,1,0,1]),ic=new Float32Array(8),ac=new Float32Array(16);let sc=null,oc=null,lc=null;const cc={view:null,clearValue:{r:0,g:0,b:0,a:0},loadOp:"clear",storeOp:"store"},uc={colorAttachments:[cc]},fc=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],dc={r:0,g:0,b:0,a:0},hc={view:null,clearValue:dc,loadOp:"clear",storeOp:"store",resolveTarget:void 0},pc={view:null,stencilClearValue:0,stencilLoadOp:"clear",stencilStoreOp:"store"},mc={colorAttachments:[hc]},gc={view:null,resolveTarget:void 0,loadOp:"load",storeOp:"store"},bc={view:null,stencilLoadOp:"load",stencilStoreOp:"store"},xc={colorAttachments:[gc]};class vc{constructor(e,t,r,n=1){Object.defineProperty(this,"$stack",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$matrix",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$clearColorR",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$clearColorG",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$clearColorB",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$clearColorA",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$mainAttachmentObject",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$stackAttachmentObject",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"globalAlpha",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"globalCompositeOperation",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"imageSmoothingEnabled",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$fillStyle",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$strokeStyle",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"maskBounds",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"thickness",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"caps",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"joints",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"miterLimit",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"device",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"canvasContext",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"preferredFormat",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"commandEncoder",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"renderPassEncoder",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"mainTexture",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"mainTextureView",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"frameStarted",{enumerable:!0,configurable:!0,writable:!0,value:!1}),Object.defineProperty(this,"frameTextures",{enumerable:!0,configurable:!0,writable:!0,value:[]}),Object.defineProperty(this,"pooledTextures",{enumerable:!0,configurable:!0,writable:!0,value:[]}),Object.defineProperty(this,"pooledRenderTextures",{enumerable:!0,configurable:!0,writable:!0,value:[]}),Object.defineProperty(this,"currentRenderTarget",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"viewportWidth",{enumerable:!0,configurable:!0,writable:!0,value:0}),Object.defineProperty(this,"viewportHeight",{enumerable:!0,configurable:!0,writable:!0,value:0}),Object.defineProperty(this,"pathCommand",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"bufferManager",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"textureManager",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"frameBufferManager",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"pipelineManager",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"computePipelineManager",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"attachmentManager",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"newDrawState",{enumerable:!0,configurable:!0,writable:!0,value:!1}),Object.defineProperty(this,"$containerLayerStack",{enumerable:!0,configurable:!0,writable:!0,value:[]}),Object.defineProperty(this,"containerLayerContentSizes",{enumerable:!0,configurable:!0,writable:!0,value:[]}),Object.defineProperty(this,"inMaskMode",{enumerable:!0,configurable:!0,writable:!0,value:!1}),Object.defineProperty(this,"nodeAreaCleared",{enumerable:!0,configurable:!0,writable:!0,value:!1}),Object.defineProperty(this,"currentNodeScissor",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"nodeRenderPassAtlasIndex",{enumerable:!0,configurable:!0,writable:!0,value:-1}),Object.defineProperty(this,"fillDynamicBindGroup",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"fillDynamicBindGroupBuffer",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"nodeClearQuadBuffer",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"useOptimizedInstancing",{enumerable:!0,configurable:!0,writable:!0,value:!0}),Object.defineProperty(this,"$uniformData8",{enumerable:!0,configurable:!0,writable:!0,value:new Float32Array(8)}),Object.defineProperty(this,"$scissorRect",{enumerable:!0,configurable:!0,writable:!0,value:{x:0,y:0,w:0,h:0}}),Object.defineProperty(this,"$filterConfig",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.device=e,this.canvasContext=t,this.preferredFormat=r,Hn.setDevice(e),Hn.setDevicePixelRatio(n);const i=e.limits.maxTextureDimension2D,a=Math.max(2048,i/2);var s;Hn.setRenderMaxSize(a),this.$stack=Hn.createArray(),this.$stackAttachmentObject=Hn.createArray(),this.$matrix=Hn.createFloat32Array(9),this.$matrix.set([1,0,0,0,1,0,0,0,1]),this.$clearColorR=0,this.$clearColorG=0,this.$clearColorB=0,this.$clearColorA=0,this.thickness=1,this.caps=0,this.joints=2,this.miterLimit=0,this.$mainAttachmentObject=null,this.globalAlpha=1,this.globalCompositeOperation="normal",this.imageSmoothingEnabled=!1,this.$fillStyle=new Float32Array([1,1,1,1]),this.$strokeStyle=new Float32Array([1,1,1,1]),this.maskBounds={xMin:0,yMin:0,xMax:0,yMax:0},t.configure({device:e,format:r,alphaMode:"premultiplied"}),this.viewportWidth=t.canvas.width,this.viewportHeight=t.canvas.height,this.pathCommand=new Jn,this.bufferManager=new si(e),this.textureManager=new oi(e),this.frameBufferManager=new mi(e,r),this.pipelineManager=new pa(e,r),this.pipelineManager.preloadLazyGroups(),this.computePipelineManager=new ma(e),this.attachmentManager=new Mi(e),s=e=>{const t=Hn.getRenderMaxSize();return this.frameBufferManager.createAttachment(`atlas_${e}`,t,t,!1,!0)},_a=s,this.$filterConfig={device:this.device,commandEncoder:null,bufferManager:this.bufferManager,frameBufferManager:this.frameBufferManager,pipelineManager:this.pipelineManager,textureManager:this.textureManager,computePipelineManager:this.computePipelineManager,frameTextures:this.frameTextures},Qn=this}clearTransferBounds(){this.beginFrame()}updateBackgroundColor(e,t,r,n){this.$clearColorR=e,this.$clearColorG=t,this.$clearColorB=r,this.$clearColorA=n}fillBackgroundColor(){if(!this.$mainAttachmentObject||!this.$mainAttachmentObject.texture)return;this.frameStarted||this.beginFrame(),this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.ensureCommandEncoder();const e=this.$mainAttachmentObject.msaa&&this.$mainAttachmentObject.msaaTexture?.view;hc.view=e?this.$mainAttachmentObject.msaaTexture.view:this.$mainAttachmentObject.texture.view,hc.resolveTarget=e?this.$mainAttachmentObject.texture.view:void 0,dc.r=this.$clearColorR,dc.g=this.$clearColorG,dc.b=this.$clearColorB,dc.a=this.$clearColorA;const t=e&&this.$mainAttachmentObject.msaaStencil?.view?this.$mainAttachmentObject.msaaStencil.view:this.$mainAttachmentObject.stencil?.view;t?(pc.view=t,mc.depthStencilAttachment=pc):mc.depthStencilAttachment=void 0,this.renderPassEncoder=this.commandEncoder.beginRenderPass(mc),this.renderPassEncoder.end(),this.renderPassEncoder=null}resize(e,t,r=!0){this.clearArraysInstanced();for(const e of this.frameTextures)e.destroy();this.frameTextures.length=0;for(const e of this.pooledTextures)As(e);this.pooledTextures.length=0;for(const e of this.pooledRenderTextures)Cs(e);this.pooledRenderTextures.length=0,(()=>{for(const[,e]of Ts)for(const t of e)t.destroy();Ts.clear();for(const[,e]of Bs)for(const t of e)t.destroy();Bs.clear()})(),this.frameStarted=!1,this.commandEncoder=null,this.renderPassEncoder=null,this.currentRenderTarget=null,za=!1,Na=!1,Wa=0,Ha.clear(),Qa.clear();const n=this.canvasContext.canvas;if(n&&"width"in n&&"height"in n&&(n.width=e,n.height=t),this.$stackAttachmentObject.length){for(let e=0;e<this.$stackAttachmentObject.length;++e){const t=this.$stackAttachmentObject[e];t&&(t.texture&&t.texture.resource.destroy(),t.stencil&&t.stencil.resource.destroy(),t.msaaTexture&&t.msaaTexture.resource.destroy(),t.msaaStencil&&t.msaaStencil.resource.destroy())}this.$stackAttachmentObject.length=0}this.$mainAttachmentObject&&this.frameBufferManager.destroyAttachment("main"),r&&((()=>{for(const e of Es.values())e.texture?.resource&&e.texture.resource.destroy();Es.clear()})(),(()=>{for(const e of Us.values())As(e.texture);Us.clear(),$s=0})(),Is?.texture?.resource&&Is.texture.resource.destroy(),Is=null,Aa(),this.frameBufferManager.destroyAttachment("atlas"),this.frameBufferManager.createAttachment("atlas",4096,4096,!1,!0)),this.frameBufferManager.setCurrentAttachment(null),this.canvasContext.configure({device:this.device,format:this.preferredFormat,alphaMode:"premultiplied"}),this.mainTexture=null,this.mainTextureView=null,this.$mainAttachmentObject=this.frameBufferManager.createAttachment("main",e,t,!0,!0),this.bind(this.$mainAttachmentObject)}clearRect(e,t,r,n){}save(){const e=tc.length>0?tc.pop():new Float32Array(9);e.set(this.$matrix),this.$stack.push(e)}restore(){const e=this.$stack.pop();e&&(this.$matrix.set(e),tc.push(e))}setTransform(e,t,r,n,i,a){this.$matrix[0]=e,this.$matrix[1]=t,this.$matrix[3]=r,this.$matrix[4]=n,this.$matrix[6]=i,this.$matrix[7]=a}transform(e,t,r,n,i,a){const s=this.$matrix,o=s[0],l=s[1],c=s[3],u=s[4],f=s[6],d=s[7];s[0]=e*o+t*c,s[1]=e*l+t*u,s[3]=r*o+n*c,s[4]=r*l+n*u,s[6]=i*o+a*c+f,s[7]=i*l+a*u+d}reset(){this.$matrix.set([1,0,0,0,1,0,0,0,1]),this.$stack.length=0,this.$stackAttachmentObject.length=0,this.globalAlpha=1,this.globalCompositeOperation="normal",this.imageSmoothingEnabled=!1}beginPath(){this.pathCommand.beginPath()}moveTo(e,t){this.pathCommand.moveTo(e,t)}lineTo(e,t){this.pathCommand.lineTo(e,t)}quadraticCurveTo(e,t,r,n){this.pathCommand.quadraticCurveTo(e,t,r,n)}fillStyle(e,t,r,n){this.$fillStyle[0]=e,this.$fillStyle[1]=t,this.$fillStyle[2]=r,this.$fillStyle[3]=n}strokeStyle(e,t,r,n){this.$strokeStyle[0]=e,this.$strokeStyle[1]=t,this.$strokeStyle[2]=r,this.$strokeStyle[3]=n}closePath(){this.pathCommand.closePath()}arc(e,t,r){this.pathCommand.arc(e,t,r)}bezierCurveTo(e,t,r,n,i,a){this.pathCommand.bezierCurveTo(e,t,r,n,i,a)}ensureFillRenderPass(){if(this.frameStarted||this.beginFrame(),this.ensureCommandEncoder(),this.renderPassEncoder)this.currentRenderTarget&&this.ensureNodeAreaCleared();else{{const e=this.getCurrentTextureView(),t=wa(),r=t?.msaa&&t?.msaaTexture?.view,n=r?t.msaaTexture.view:e,i=r?e:null;if(this.currentRenderTarget&&t?.stencil?.view){const e=r&&t?.msaaStencil?.view?t.msaaStencil.view:t.stencil.view,a=this.frameBufferManager.createStencilRenderPassDescriptor(n,e,"load","clear",i);this.renderPassEncoder=this.commandEncoder.beginRenderPass(a)}else if(!this.currentRenderTarget&&(Xa()||Da())&&this.$mainAttachmentObject?.stencil?.view){const e=this.$mainAttachmentObject.msaa&&this.$mainAttachmentObject.msaaTexture?.view,t=e?this.$mainAttachmentObject.msaaTexture.view:this.$mainAttachmentObject.texture.view,r=e&&this.$mainAttachmentObject.msaaStencil?.view?this.$mainAttachmentObject.msaaStencil.view:this.$mainAttachmentObject.stencil.view,n=e?this.$mainAttachmentObject.texture.view:null,i=this.frameBufferManager.createStencilRenderPassDescriptor(t,r,"load","load",n);this.renderPassEncoder=this.commandEncoder.beginRenderPass(i),Xa()&&this.renderPassEncoder.setStencilReference(Ka())}else if(!this.currentRenderTarget&&this.$mainAttachmentObject){const e=this.$mainAttachmentObject.msaa&&this.$mainAttachmentObject.msaaTexture?.view,t=e?this.$mainAttachmentObject.msaaTexture.view:this.$mainAttachmentObject.texture.view,r=e?this.$mainAttachmentObject.texture.view:null;if(this.$mainAttachmentObject.stencil?.view){const n=e&&this.$mainAttachmentObject.msaaStencil?.view?this.$mainAttachmentObject.msaaStencil.view:this.$mainAttachmentObject.stencil.view,i=this.frameBufferManager.createStencilRenderPassDescriptor(t,n,"load","clear",r);this.renderPassEncoder=this.commandEncoder.beginRenderPass(i)}else{const e=this.frameBufferManager.createRenderPassDescriptor(t,0,0,0,0,"load",r);this.renderPassEncoder=this.commandEncoder.beginRenderPass(e)}}else{const e=this.frameBufferManager.createRenderPassDescriptor(n,0,0,0,0,"load",i);this.renderPassEncoder=this.commandEncoder.beginRenderPass(e)}}this.currentRenderTarget&&this.ensureNodeAreaCleared()}}fill(){const e=this.pathCommand.$getVertices;if(0===e.length)return;this.ensureFillRenderPass();const t=this.viewportWidth,r=this.viewportHeight,n=ns(e);if(0===n.indexCount)return;const i=this.bufferManager.acquireVertexBuffer(n.buffer.byteLength,n.buffer),a=this.writeFillUniform(this.$fillStyle[0],this.$fillStyle[1],this.$fillStyle[2],this.$fillStyle[3],this.$matrix[0],this.$matrix[1],this.$matrix[3],this.$matrix[4],this.$matrix[6],this.$matrix[7],t,r),s=this.getOrCreateFillDynamicBindGroup(),o=wa();if(this.currentRenderTarget&&o?.stencil?.view)this.fillWithStencil(i,n.indexCount,s,a);else if(this.currentRenderTarget||this.inMaskMode||Xa()||!this.$mainAttachmentObject?.stencil?.view){const e=(this.inMaskMode||Xa())&&!!this.$mainAttachmentObject?.stencil?.view&&!this.currentRenderTarget;this.fillSimple(i,n.indexCount,e,s,a)}else this.fillWithStencilMain(i,n.indexCount,s,a)}getOrCreateFillDynamicBindGroup(){const e=this.bufferManager.dynamicUniform.getBuffer();if(!this.fillDynamicBindGroup||this.fillDynamicBindGroupBuffer!==e){const t=this.pipelineManager.getBindGroupLayout("fill_dynamic");if(!t)throw new Error("[WebGPU] fill_dynamic bind group layout not found");this.fillDynamicBindGroup=this.device.createBindGroup({layout:t,entries:[{binding:0,resource:{buffer:e,size:256}}]}),this.fillDynamicBindGroupBuffer=e}return this.fillDynamicBindGroup}writeFillUniform(e,t,r,n,i,a,s,o,l,c,u,f){return ac[0]=e,ac[1]=t,ac[2]=r,ac[3]=n,ac[4]=i/u,ac[5]=a/f,ac[6]=0,ac[7]=0,ac[8]=s/u,ac[9]=o/f,ac[10]=0,ac[11]=0,ac[12]=l/u,ac[13]=c/f,ac[14]=1,ac[15]=0,this.bufferManager.dynamicUniform.allocate(ac)}fillWithStencil(e,t,r,n){((e,t,r,n,i,a)=>{const s=t.getPipeline("stencil_write_atlas");s&&(e.setPipeline(s),e.setStencilReference(0),e.setVertexBuffer(0,r),e.setBindGroup(0,i,[a]),e.draw(n,1,0,0));const o=t.getPipeline("stencil_fill_atlas");o&&(e.setPipeline(o),e.setStencilReference(0),e.setBindGroup(0,i,[a]),e.draw(n,1,0,0))})(this.renderPassEncoder,this.pipelineManager,e,t,r,n)}fillWithStencilMain(e,t,r,n){((e,t,r,n,i,a)=>{const s=t.getPipeline("stencil_write_main");s&&(e.setPipeline(s),e.setStencilReference(0),e.setVertexBuffer(0,r),e.setBindGroup(0,i,[a]),e.draw(n,1,0,0));const o=t.getPipeline("stencil_fill_main");o&&(e.setPipeline(o),e.setStencilReference(0),e.setBindGroup(0,i,[a]),e.draw(n,1,0,0))})(this.renderPassEncoder,this.pipelineManager,e,t,r,n)}fillSimple(e,t,r,n,i){const a=this.$mainAttachmentObject?.clipLevel??1;((e,t,r,n,i,a,s,o=!1)=>{let l;if(s)l="fill";else if(o){if(Da())return;l="fill_bgra_stencil"}else l="fill_bgra";const c=t.getPipeline(l);c?(e.setPipeline(c),e.setVertexBuffer(0,r),e.setBindGroup(0,i,[a]),!o||s||Da()||e.setStencilReference(Ka()),e.draw(n,1,0,0)):console.error(`[WebGPU] ${l} pipeline not found`)})(this.renderPassEncoder,this.pipelineManager,e,t,n,i,!!this.currentRenderTarget,r,a)}bindAttachment(e){this.attachmentManager.bindAttachment(e);const t=e.color?.view??e.texture?.view;t&&(this.currentRenderTarget=t)}unbindAttachment(){this.attachmentManager.unbindAttachment(),this.currentRenderTarget=null}getAttachmentObject(e,t,r=!1){return this.attachmentManager.getAttachmentObject(e,t,r)}releaseAttachment(e){this.attachmentManager.releaseAttachment(e)}stroke(){const e=this.pathCommand.getVerticesForStroke();if(0===e.length)return;this.ensureFillRenderPass();const t=this.viewportWidth,r=this.viewportHeight,n=((e,t)=>{const r=t/2,n=[];for(const t of e){if(t.length<6)continue;const e=ws(t,r);for(const t of e)n.push(t)}return n})(e,this.thickness);if(0===n.length)return;const i=ns(n);if(0===i.indexCount)return;const a=this.bufferManager.acquireVertexBuffer(i.buffer.byteLength,i.buffer),s=this.writeFillUniform(this.$strokeStyle[0],this.$strokeStyle[1],this.$strokeStyle[2],this.$strokeStyle[3],this.$matrix[0],this.$matrix[1],this.$matrix[3],this.$matrix[4],this.$matrix[6],this.$matrix[7],t,r),o=this.getOrCreateFillDynamicBindGroup(),l=wa();if(this.currentRenderTarget&&l?.stencil?.view)this.fillWithStencil(a,i.indexCount,o,s);else if(this.currentRenderTarget||this.inMaskMode||Xa()||!this.$mainAttachmentObject?.stencil?.view){const e=(this.inMaskMode||Xa())&&!!this.$mainAttachmentObject?.stencil?.view&&!this.currentRenderTarget;this.fillSimple(a,i.indexCount,e,o,s)}else this.fillWithStencilMain(a,i.indexCount,o,s);this.pathCommand.reset()}gradientFill(e,t,r,n,i,a){const s=this.pathCommand.$getVertices;if(0===s.length)return;this.ensureFillRenderPass();const o=this.viewportWidth,l=this.viewportHeight,c=!(!this.inMaskMode&&!Xa()||!this.$mainAttachmentObject?.stencil?.view||this.currentRenderTarget),u=!!this.currentRenderTarget,f=((e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g=!1)=>{const b=ns(i);if(0===b.indexCount)return null;const x=r.acquireVertexBuffer(b.buffer.byteLength,b.buffer);let v,y;const _=ks(l,u,f);if(_)v=_.texture,y=_.view;else{const t=zs(l,0,f),r=l.length/5,n=Vs(r);v=Os(e,n,1),e.queue.writeTexture({texture:v},t,{bytesPerRow:4*n,rowsPerImage:1},{width:n,height:1}),y=v.createView(),Ls(l,u,f,v,y)}const w=Xs(c,0,o),M=s[3]>0?s[3]:1,P=a[0],S=a[1],F=a[3],T=a[4],B=a[6],O=a[7];Ks[0]=w.inverseMatrix[0],Ks[1]=w.inverseMatrix[3],Ks[2]=0,Ks[3]=0,Ks[4]=w.inverseMatrix[1],Ks[5]=w.inverseMatrix[4],Ks[6]=0,Ks[7]=0,Ks[8]=w.inverseMatrix[6],Ks[9]=w.inverseMatrix[7],Ks[10]=1,Ks[11]=0,Ks[12]=o,Ks[13]=Math.max(-.975,Math.min(.975,d)),Ks[14]=u,Ks[15]=819.2,w.linearPoints?(Ks[16]=w.linearPoints[0],Ks[17]=w.linearPoints[1],Ks[18]=w.linearPoints[2],Ks[19]=w.linearPoints[3]):(Ks[16]=0,Ks[17]=0,Ks[18]=0,Ks[19]=0),Ks[20]=1,Ks[21]=1,Ks[22]=1,Ks[23]=M,Ks[24]=P/h,Ks[25]=S/p,Ks[26]=0,Ks[27]=0,Ks[28]=F/h,Ks[29]=T/p,Ks[30]=0,Ks[31]=0,Ks[32]=B/h,Ks[33]=O/p,Ks[34]=1,Ks[35]=0;const A=r.acquireAndWriteUniformBuffer(Ks);Ys||(Ys=e.createSampler({magFilter:"linear",minFilter:"linear",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"}));const R=Ys,C=n.getBindGroupLayout("gradient_fill");if(!C)return console.error("[WebGPU] gradient_fill bind group layout not found"),null;Js[0].resource.buffer=A,Js[1].resource=R,Js[2].resource=y;const E=e.createBindGroup({layout:C,entries:Js}),U=()=>{const t=n.getBindGroupLayout("fill_dynamic");if(!t)return null;Hs[0]=1,Hs[1]=1,Hs[2]=1,Hs[3]=M,Hs[4]=P/h,Hs[5]=S/p,Hs[6]=0,Hs[7]=0,Hs[8]=F/h,Hs[9]=T/p,Hs[10]=0,Hs[11]=0,Hs[12]=B/h,Hs[13]=O/p,Hs[14]=1,Hs[15]=0;const i=r.dynamicUniform.allocate(Hs),a=r.dynamicUniform.getBuffer();return Qs&&Zs===a||(Qs=e.createBindGroup({layout:t,entries:[{binding:0,resource:{buffer:a,size:256}}]}),Zs=a),{bindGroup:Qs,offset:i}};if(m){const e=n.getPipeline("stencil_write_atlas");if(e){const r=U();t.setPipeline(e),t.setStencilReference(0),t.setVertexBuffer(0,x),r&&t.setBindGroup(0,r.bindGroup,[r.offset]),t.draw(b.indexCount,1,0,0)}const r=n.getGradientPipeline("gradient_fill_stencil_atlas",o,u);return r&&(t.setPipeline(r),t.setStencilReference(0),t.setBindGroup(0,E),t.draw(b.indexCount,1,0,0)),null}if(g&&Da())return null;const $=n.getPipeline("stencil_write_main");if($){const e=U();t.setPipeline($),t.setStencilReference(0),t.setVertexBuffer(0,x),e&&t.setBindGroup(0,e.bindGroup,[e.offset]),t.draw(b.indexCount,1,0,0)}const G=g?"gradient_fill_bgra_stencil_masked":"gradient_fill_stencil_main",k=n.getGradientPipeline(G,o,u);return k&&(t.setPipeline(k),t.setStencilReference(g?Ka():0),t.setBindGroup(0,E),t.draw(b.indexCount,1,0,0)),null})(this.device,this.renderPassEncoder,this.bufferManager,this.pipelineManager,s,this.$matrix,this.$fillStyle,e,t,r,n,i,a,o,l,u,c,this.$mainAttachmentObject?.clipLevel??1);f&&this.addFrameTexture(f),this.beginPath()}bitmapFill(e,t,r,n,i,a){const s=this.pathCommand.$getVertices;if(0===s.length)return;this.ensureFillRenderPass();const o=wa(),l=!(!this.currentRenderTarget||!o?.stencil?.view),c=!(!this.inMaskMode&&!Xa()||!this.$mainAttachmentObject?.stencil?.view||this.currentRenderTarget),u=l||c,f=this.$mainAttachmentObject?.clipLevel??1,d=oo(this.device,this.renderPassEncoder,this.bufferManager,this.pipelineManager,s,this.$matrix,this.$fillStyle,e,t,r,n,i,a,this.viewportWidth,this.viewportHeight,!!this.currentRenderTarget,!!u,f);d&&this.addFrameTexture(d),this.beginPath()}gradientStroke(e,t,r,n,i,a){const s=this.pathCommand.getVerticesForStroke();if(0===s.length)return;this.ensureFillRenderPass();const o=wa(),l=!(!this.currentRenderTarget||!o?.stencil?.view),c=!(this.currentRenderTarget||!this.$mainAttachmentObject?.stencil?.view),u=l||c,f=po(this.device,this.renderPassEncoder,this.bufferManager,this.pipelineManager,s,this.thickness,this.$matrix,this.$strokeStyle,e,t,r,n,i,a,this.viewportWidth,this.viewportHeight,!!this.currentRenderTarget,u);f&&this.addFrameTexture(f),this.pathCommand.reset()}bitmapStroke(e,t,r,n,i,a){const s=this.pathCommand.getVerticesForStroke();if(0===s.length)return;this.ensureFillRenderPass();const o=wa(),l=!(!this.currentRenderTarget||!o?.stencil?.view),c=!(this.currentRenderTarget||!this.$mainAttachmentObject?.stencil?.view),u=l||c,f=vo(this.device,this.renderPassEncoder,this.bufferManager,this.pipelineManager,s,this.thickness,this.$matrix,this.$strokeStyle,e,t,r,n,i,a,this.viewportWidth,this.viewportHeight,!!this.currentRenderTarget,u);f&&this.addFrameTexture(f),this.pathCommand.reset()}clip(){let e=this.frameBufferManager.getCurrentAttachment();const t=!e||e===this.$mainAttachmentObject;if(!e&&this.$mainAttachmentObject&&(e=this.$mainAttachmentObject),!e)return;if(!e.stencil)return;const r=this.pathCommand.$getVertices;if(0!==r.length){if(!this.renderPassEncoder){if(this.ensureCommandEncoder(),!t||!this.$mainAttachmentObject?.stencil?.view)return;{const e=this.$mainAttachmentObject.msaa&&this.$mainAttachmentObject.msaaTexture?.view,t=e?this.$mainAttachmentObject.msaaTexture.view:this.$mainAttachmentObject.texture.view,r=e&&this.$mainAttachmentObject.msaaStencil?.view?this.$mainAttachmentObject.msaaStencil.view:this.$mainAttachmentObject.stencil.view,n=this.frameBufferManager.createStencilRenderPassDescriptor(t,r,"load","load");this.renderPassEncoder=this.commandEncoder.beginRenderPass(n)}}Mo(this.device,this.renderPassEncoder,this.bufferManager,this.pipelineManager,e,r,this.$matrix,this.$fillStyle,this.globalAlpha,t)}}bind(e){this.frameBufferManager.setCurrentAttachment(e),this.viewportWidth=e.width,this.viewportHeight=e.height}get currentAttachmentObject(){return this.frameBufferManager.getCurrentAttachment()||this.$mainAttachmentObject}get atlasAttachmentObject(){return wa()}useGrid(e){Ms.set(Ps,e)}beginNodeRendering(e){this.nodeAreaCleared=!1,this.frameStarted||this.beginFrame();const t=Ma(e.index)||wa();if(t&&t.texture){if(this.renderPassEncoder&&this.nodeRenderPassAtlasIndex===e.index)this.currentRenderTarget=t.texture.view,this.viewportWidth=t.width,this.viewportHeight=t.height;else{this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.currentRenderTarget=t.texture.view,this.viewportWidth=t.width,this.viewportHeight=t.height,this.ensureCommandEncoder();const r=t.msaa&&t.msaaTexture?.view,n=r?t.msaaTexture.view:t.texture.view,i=r?t.texture.view:null;if(t.stencil?.view){const e=r&&t.msaaStencil?.view?t.msaaStencil.view:t.stencil.view,a=this.frameBufferManager.createStencilRenderPassDescriptor(n,e,"load","load",i);this.renderPassEncoder=this.commandEncoder.beginRenderPass(a)}else{const e=this.frameBufferManager.createRenderPassDescriptor(n,0,0,0,0,"load",i);this.renderPassEncoder=this.commandEncoder.beginRenderPass(e)}this.nodeRenderPassAtlasIndex=e.index}let r=Math.max(0,e.x),n=Math.max(0,e.y),i=Math.min(e.w,t.width-r),a=Math.min(e.h,t.height-n);if(r=Math.min(r,t.width),n=Math.min(n,t.height),i=Math.max(0,Math.min(i,t.width-r)),a=Math.max(0,Math.min(a,t.height-n)),this.$scissorRect.x=r,this.$scissorRect.y=n,this.$scissorRect.w=i,this.$scissorRect.h=a,this.currentNodeScissor=this.$scissorRect,i>0&&a>0){const e=Math.min(i+1,t.width-r),s=Math.min(a+1,t.height-n);this.renderPassEncoder.setScissorRect(r,n,e,s)}}}ensureNodeAreaCleared(){this.nodeAreaCleared||(this.nodeAreaCleared=!0,this.clearNodeArea())}clearNodeArea(){if(!this.renderPassEncoder)return;const e=this.pipelineManager.getPipeline("node_clear_atlas");if(!e)return;if(!this.nodeClearQuadBuffer){const e=this.device.createBuffer({size:nc.byteLength,usage:GPUBufferUsage.VERTEX|GPUBufferUsage.COPY_DST,mappedAtCreation:!0});new Float32Array(e.getMappedRange()).set(nc),e.unmap(),this.nodeClearQuadBuffer=e}const t=this.nodeClearQuadBuffer;this.renderPassEncoder.setPipeline(e),this.renderPassEncoder.setVertexBuffer(0,t),this.renderPassEncoder.draw(6),this.currentNodeScissor&&this.renderPassEncoder.setScissorRect(this.currentNodeScissor.x,this.currentNodeScissor.y,this.currentNodeScissor.w,this.currentNodeScissor.h)}endNodeRendering(){this.currentRenderTarget=null,this.currentNodeScissor=null,this.viewportWidth=this.canvasContext.canvas.width,this.viewportHeight=this.canvasContext.canvas.height}drawFill(){Ms.clear(),Ps=0}drawDisplayObject(e,t,r,n,i,a){const s=Hn.getRenderMaxSize();((e,t,r,n,i,a,s,o,l,c,u,f)=>{const d=a[0],h=a[1],p=a[2],m=f,g=a[4]/255,b=a[5]/255,x=a[6]/255;if(Ua.has(o)){Ca===o&&Oa()===e.index||(Qn&&(va(Oa()),Qn.drawArraysInstanced()),Ea(o),Ba(e.index),va(e.index));const t=Va();nr.pushInstanceBuffer((e.x+.5)/u,(e.y+.5)/u,(e.w-1)/u,(e.h-1)/u,e.w,e.h,l,c,s[6],s[7],0,0,s[0],s[1],s[3],s[4],d,h,p,m,g,b,x,0),t.count++}else{Qn&&(va(Oa()),Qn.drawArraysInstanced());const d=Ga.length>0?Ga.pop():new Float32Array(8);d.set(a);const h=ka.length>0?ka.pop():new Float32Array(9);h.set(s),$a.push({node:e,x_min:t,y_min:r,x_max:n,y_max:i,color_transform:d,matrix:h,blend_mode:o,viewport_width:l,viewport_height:c,render_max_size:u,global_alpha:f}),Ea(o),Ba(e.index),va(e.index)}})(e,t,r,n,i,a,this.$matrix,this.globalCompositeOperation,this.viewportWidth,this.viewportHeight,s,this.globalAlpha)}drawArraysInstanced(){this.frameStarted||this.beginFrame(),this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.nodeRenderPassAtlasIndex=-1,this.ensureCommandEncoder(),this.$mainAttachmentObject&&(this.useOptimizedInstancing?this.renderPassEncoder=((e,t,r,n,i,a,s,o,l=!0,c=!0)=>{const u=Va();if(0===u.count)return r;r&&(r.end(),r=null);const f=Xa(),d=Ka(),h=(e=>{switch(e){case"add":return"instanced_add";case"screen":return"instanced_screen";case"alpha":return"instanced_alpha";case"erase":return"instanced_erase";case"copy":return"instanced_copy";default:return"instanced"}})(Ca),p=o.getPipeline(h),m=o.getPipeline("instanced_masked"),g=f&&m&&(n.msaaStencil?.view||n.stencil?.view),b=g?m:p;if(!b)return console.error("[WebGPU] Instanced pipeline not found"),null;let x;if(g){const e=n.msaa&&n.msaaTexture?.view,r=e?n.msaaTexture.view:n.texture.view,i=e&&n.msaaStencil?.view?n.msaaStencil.view:n.stencil.view,s=e?n.texture.view:null,o=a.createStencilRenderPassDescriptor(r,i,"load","load",s);x=t.beginRenderPass(o)}else{const e=n.msaa&&n.msaaTexture?.view,r=e?n.msaaTexture.view:n.texture.view,i=e?n.texture.view:null,s=a.createRenderPassDescriptor(r,0,0,0,0,"load",i);x=t.beginRenderPass(s)}x.setPipeline(b),g&&x.setStencilReference(d);const v=new Float32Array(nr.buffer.buffer,nr.buffer.byteOffset,nr.offset);let y;c?(y=i.acquireStorageBuffer(v.byteLength),i.writeStorageBuffer(y,v)):y=i.acquireVertexBuffer(v.byteLength,v);const _=i.getUnitRectBuffer(),w=wa()||a.getAttachment("atlas");if(!w)return console.error("[WebGPU] Atlas attachment not found"),x.end(),null;const M=s.createSampler("atlas_instanced_sampler",!1),P=o.getBindGroupLayout("instanced");if(!P)return console.error("[WebGPU] Instanced bind group layout not found"),x.end(),null;const S=w.texture.view;if(Fo&&To===S||(Fo=e.createBindGroup({layout:P,entries:[{binding:0,resource:M},{binding:1,resource:S}]}),To=S),x.setVertexBuffer(0,_),x.setVertexBuffer(1,y),x.setBindGroup(0,Fo),l){const e=i.createIndirectBuffer(6,u.count,0,0);x.drawIndirect(e,0)}else x.draw(6,u.count,0,0);return x.end(),u.clear(),null})(this.device,this.commandEncoder,this.renderPassEncoder,this.$mainAttachmentObject,this.bufferManager,this.frameBufferManager,this.textureManager,this.pipelineManager,!0,!0):this.renderPassEncoder=((e,t,r,n,i,a,s,o)=>{const l=Va();if(0===l.count)return r;r&&(r.end(),r=null);const c=Xa(),u=Ka(),f=(e=>{switch(e){case"add":return"instanced_add";case"screen":return"instanced_screen";case"alpha":return"instanced_alpha";case"erase":return"instanced_erase";case"copy":return"instanced_copy";default:return"instanced"}})(Ca),d=o.getPipeline(f),h=o.getPipeline("instanced_masked"),p=c&&h&&(n.msaaStencil?.view||n.stencil?.view),m=p?h:d;if(!m)return console.error("[WebGPU] Instanced pipeline not found"),null;let g;if(p){const e=n.msaa&&n.msaaTexture?.view,r=e?n.msaaTexture.view:n.texture.view,i=e&&n.msaaStencil?.view?n.msaaStencil.view:n.stencil.view,s=e?n.texture.view:null,o=a.createStencilRenderPassDescriptor(r,i,"load","load",s);g=t.beginRenderPass(o)}else{const e=n.msaa&&n.msaaTexture?.view,r=e?n.msaaTexture.view:n.texture.view,i=e?n.texture.view:null,s=a.createRenderPassDescriptor(r,0,0,0,0,"load",i);g=t.beginRenderPass(s)}g.setPipeline(m),p&&g.setStencilReference(u);const b=new Float32Array(nr.buffer.buffer,nr.buffer.byteOffset,nr.offset),x=i.acquireVertexBuffer(b.byteLength,b),v=i.getUnitRectBuffer(),y=wa()||a.getAttachment("atlas");if(!y)return console.error("[WebGPU] Atlas attachment not found"),g.end(),null;const _=s.createSampler("atlas_instanced_sampler",!1),w=o.getBindGroupLayout("instanced");if(!w)return console.error("[WebGPU] Instanced bind group layout not found"),g.end(),null;const M=y.texture.view;return Po&&So===M||(Po=e.createBindGroup({layout:w,entries:[{binding:0,resource:_},{binding:1,resource:M}]}),So=M),g.setVertexBuffer(0,v),g.setVertexBuffer(1,x),g.setBindGroup(0,Po),g.draw(6,l.count,0,0),g.end(),l.clear(),null})(this.device,this.commandEncoder,this.renderPassEncoder,this.$mainAttachmentObject,this.bufferManager,this.frameBufferManager,this.textureManager,this.pipelineManager),this.processComplexBlendQueue())}setOptimizedInstancing(e){this.useOptimizedInstancing=e}isOptimizedInstancingEnabled(){return this.useOptimizedInstancing}processComplexBlendQueue(){this.ensureCommandEncoder(),Lo(this.device,this.commandEncoder,this.$mainAttachmentObject,this.frameBufferManager,this.textureManager,this.pipelineManager,this.bufferManager)}clearArraysInstanced(){Va().clear()}drawPixels(e,t){const r=Ma(e.index)||wa();if(!r||!r.texture)return;const n=e.w,i=e.h;if(this.renderPassEncoder&&(this.ensureNodeAreaCleared(),this.renderPassEncoder.end(),this.renderPassEncoder=null),this.nodeRenderPassAtlasIndex=-1,r.msaa&&r.msaaTexture?.view)this.drawPixelsToMsaa(r,e,t,n,i);else{const a=4*n;this.device.queue.writeTexture({texture:r.texture.resource,origin:{x:e.x,y:e.y,z:0}},t,{bytesPerRow:a,rowsPerImage:i,offset:0},{width:n,height:i,depthOrArrayLayers:1})}}drawPixelsToMsaa(e,t,r,n,i){const a=Rs(this.device,n,i),s=4*n;this.device.queue.writeTexture({texture:a},r,{bytesPerRow:s,rowsPerImage:i},{width:n,height:i});const o=this.pipelineManager.getPipeline("bitmap_render_msaa");if(!o)return void Cs(a);const l=this.pipelineManager.getBindGroupLayout("positioned_texture");if(!l)return void Cs(a);const c=this.$uniformData8;c[0]=t.x,c[1]=t.y,c[2]=n,c[3]=i,c[4]=e.width,c[5]=e.height,c[6]=0,c[7]=0;const u=this.bufferManager.acquireAndWriteUniformBuffer(c),f=this.textureManager.createSampler("linear_sampler",!0),d=Fs(a);fc[0].resource.buffer=u,fc[1].resource=f,fc[2].resource=d;const h=this.device.createBindGroup({layout:l,entries:fc});this.ensureCommandEncoder(),gc.view=e.msaaTexture.view,gc.resolveTarget=e.texture.view;const p=e.msaaStencil?.view;p?(bc.view=p,xc.depthStencilAttachment=bc):xc.depthStencilAttachment=void 0;const m=this.commandEncoder.beginRenderPass(xc);m.setViewport(0,0,e.width,e.height,0,1),m.setScissorRect(t.x,t.y,n,i),m.setPipeline(o),m.setBindGroup(0,h),m.draw(6),m.end(),this.pooledRenderTextures.push(a)}drawElement(e,t,r=!1){const n=Ma(e.index)||wa();if(!n||!n.texture)return;const i=e.w,a=e.h;this.renderPassEncoder&&(this.ensureNodeAreaCleared(),this.renderPassEncoder.end(),this.renderPassEncoder=null),this.nodeRenderPassAtlasIndex=-1,n.msaa&&n.msaaTexture?.view?this.drawElementToMsaa(n,e,t,i,a,r):this.drawElementToTexture(n,e,t,i,a,r)}drawElementToMsaa(e,t,r,n,i,a){const s=Rs(this.device,n,i);this.device.queue.copyExternalImageToTexture({source:r,flipY:a},{texture:s,premultipliedAlpha:!0},{width:n,height:i});const o=this.pipelineManager.getPipeline("bitmap_render_msaa");if(!o)return void Cs(s);const l=this.pipelineManager.getBindGroupLayout("positioned_texture");if(!l)return void Cs(s);const c=this.$uniformData8;c[0]=t.x,c[1]=t.y,c[2]=n,c[3]=i,c[4]=e.width,c[5]=e.height,c[6]=0,c[7]=0;const u=this.bufferManager.acquireAndWriteUniformBuffer(c),f=this.textureManager.createSampler("linear_sampler",!0),d=Fs(s);fc[0].resource.buffer=u,fc[1].resource=f,fc[2].resource=d;const h=this.device.createBindGroup({layout:l,entries:fc});this.ensureCommandEncoder(),gc.view=e.msaaTexture.view,gc.resolveTarget=e.texture.view;const p=e.msaaStencil?.view;p?(bc.view=p,xc.depthStencilAttachment=bc):xc.depthStencilAttachment=void 0;const m=this.commandEncoder.beginRenderPass(xc);m.setViewport(0,0,e.width,e.height,0,1),m.setScissorRect(t.x,t.y,n,i),m.setPipeline(o),m.setBindGroup(0,h),m.draw(6),m.end(),this.pooledRenderTextures.push(s)}drawElementToTexture(e,t,r,n,i,a){const s=Rs(this.device,n,i);this.device.queue.copyExternalImageToTexture({source:r,flipY:a},{texture:s,premultipliedAlpha:!0},{width:n,height:i});const o=this.pipelineManager.getPipeline("bitmap_render");if(!o)return void Cs(s);const l=this.pipelineManager.getBindGroupLayout("positioned_texture");if(!l)return void Cs(s);const c=this.$uniformData8;c[0]=t.x,c[1]=t.y,c[2]=n,c[3]=i,c[4]=e.width,c[5]=e.height,c[6]=0,c[7]=0;const u=this.bufferManager.acquireAndWriteUniformBuffer(c),f=this.textureManager.createSampler("linear_sampler",!0),d=Fs(s);fc[0].resource.buffer=u,fc[1].resource=f,fc[2].resource=d;const h=this.device.createBindGroup({layout:l,entries:fc});this.ensureCommandEncoder(),gc.view=e.texture.view,gc.resolveTarget=void 0;const p=e.stencil?.view;p?(bc.view=p,xc.depthStencilAttachment=bc):xc.depthStencilAttachment=void 0;const m=this.commandEncoder.beginRenderPass(xc);m.setViewport(0,0,e.width,e.height,0,1),m.setScissorRect(t.x,t.y,n,i),m.setPipeline(o),m.setBindGroup(0,h),m.draw(6),m.end(),this.pooledRenderTextures.push(s)}applyFilter(e,t,r,n,i,a,s,o,l,c,u){this.drawArraysInstanced(),this.frameStarted||this.beginFrame(),this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.nodeRenderPassAtlasIndex=-1,this.ensureCommandEncoder(),this.$filterConfig.commandEncoder=this.commandEncoder,this.$filterConfig.mainAttachment=this.$mainAttachmentObject,jl(e,n,i,a,s,o,l,c,u,this.$filterConfig,this.mainTextureView,this.bufferManager)}containerBeginLayer(e,t){this.drawArraysInstanced(),this.frameStarted||this.beginFrame(),this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null);const r=this.$mainAttachmentObject;this.$containerLayerStack.push(r),this.containerLayerContentSizes.push({width:e,height:t});const n=this.frameBufferManager.createAttachment("container_layer",e,t,r.msaa,!0);this.$mainAttachmentObject=n,this.bind(n)}containerEndLayer(e,t,r,n,i,a,s,o){this.drawArraysInstanced(),this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.ensureCommandEncoder();const l=this.$mainAttachmentObject,c=this.containerLayerContentSizes.pop()||{width:l.width,height:l.height};this.$mainAttachmentObject=this.$containerLayerStack.pop(),this.$filterConfig.commandEncoder=this.commandEncoder,this.$filterConfig.mainAttachment=void 0,Jl(l,this.$mainAttachmentObject,0,e,t,r,n,i,a,s,o,c.width,c.height,this.$filterConfig,this.bufferManager),this.bind(this.$mainAttachmentObject)}containerDrawCachedFilter(e,t,r,n,i,a){if(yn.get(i,"fKey")!==a)return;const s=yn.get(i,"fTexture");if(!s||!s.texture)return;this.drawArraysInstanced(),this.frameStarted||this.beginFrame(),this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.ensureCommandEncoder();const o=this.$mainAttachmentObject;if(!o||!o.texture)return;let l=s,c=null;if(!(1===r[0]&&1===r[1]&&1===r[2]&&1===r[3]&&0===r[4]&&0===r[5]&&0===r[6]&&0===r[7])){c=this.frameBufferManager.createTemporaryAttachment(s.width,s.height);const e=this.pipelineManager.getPipeline("color_transform"),t=this.pipelineManager.getBindGroupLayout("texture_copy");if(e&&t&&c.texture){ic[0]=r[0],ic[1]=r[1],ic[2]=r[2],ic[3]=r[3],ic[4]=r[4],ic[5]=r[5],ic[6]=r[6],ic[7]=0;const n=ic,i=this.bufferManager.acquireAndWriteUniformBuffer(n),a=this.textureManager.createSampler("cached_ct_sampler",!1);fc[0].resource.buffer=i,fc[1].resource=a,fc[2].resource=s.texture.view;const o=this.device.createBindGroup({layout:t,entries:fc}),u=this.frameBufferManager.createRenderPassDescriptor(c.texture.view,0,0,0,0,"clear"),f=this.commandEncoder.beginRenderPass(u);f.setPipeline(e),f.setBindGroup(0,o),f.draw(6,1,0,0),f.end(),l=c}}const u=Hn.getDevicePixelRatio(),f=Math.sqrt(t[0]*t[0]+t[1]*t[1]),d=Math.sqrt(t[2]*t[2]+t[3]*t[3]),h=n[0]*(f/u),p=n[1]*(d/u),m=Math.floor(h+t[4]),g=Math.floor(p+t[5]),b=o.msaa&&o.msaaTexture?.view;let x;switch(e){case"add":x=b?"filter_output_add_msaa":"filter_output_add";break;case"screen":x=b?"filter_output_screen_msaa":"filter_output_screen";break;case"alpha":x=b?"filter_output_alpha_msaa":"filter_output_alpha";break;case"erase":x=b?"filter_output_erase_msaa":"filter_output_erase";break;default:x=b?"filter_output_msaa":"filter_output"}const v=this.pipelineManager.getPipeline(x),y=this.pipelineManager.getBindGroupLayout("texture_copy");if(!v||!y)return;const _=this.textureManager.createSampler("cached_filter_sampler",!0),w=this.bufferManager.acquireAndWriteUniformBuffer(ec);fc[0].resource.buffer=w,fc[1].resource=_,fc[2].resource=l.texture.view;const M=this.device.createBindGroup({layout:y,entries:fc}),P=b?o.msaaTexture.view:o.texture.view,S=b?o.texture.view:null,F=this.frameBufferManager.createRenderPassDescriptor(P,0,0,0,0,"load",S),T=Math.max(0,m),B=Math.max(0,g),O=Math.max(1,l.width),A=Math.max(1,l.height),R=o.width,C=o.height,E=Math.max(1,Math.min(O,R-T)),U=Math.max(1,Math.min(A,C-B));if(E<=0||U<=0||T>=R||B>=C)return void(c&&this.frameBufferManager.releaseTemporaryAttachment(c));const $=this.commandEncoder.beginRenderPass(F);$.setPipeline(v),$.setBindGroup(0,M),$.setViewport(T,B,O,A,0,1),$.setScissorRect(T,B,E,U),$.draw(6,1,0,0),$.end(),c&&this.frameBufferManager.releaseTemporaryAttachment(c),this.bind(o)}ensureMainTexture(){this.mainTexture||(this.mainTexture=this.canvasContext.getCurrentTexture(),this.mainTextureView=this.mainTexture.createView())}getCurrentTextureView(){return this.currentRenderTarget?this.currentRenderTarget:(this.ensureMainTexture(),this.mainTextureView)}ensureCommandEncoder(){this.commandEncoder||(this.commandEncoder=this.device.createCommandEncoder())}beginFrame(){this.frameStarted||(this.ensureMainTexture(),this.ensureCommandEncoder(),this.frameStarted=!0,this.frameBufferManager.beginFrame())}addFrameTexture(e){this.pooledTextures.push(e)}endFrame(){if(this.frameStarted){if(this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.bufferManager.dynamicUniform.flush(),this.commandEncoder)try{const e=this.commandEncoder.finish();this.device.queue.submit([e])}catch(e){console.error("Failed to submit frame commands:",e)}this.frameBufferManager.flushPendingReleases(),this.bufferManager.clearFrameBuffers();for(const e of this.frameTextures)e.destroy();this.frameTextures.length=0;for(const e of this.pooledTextures)As(e);this.pooledTextures.length=0;for(const e of this.pooledRenderTextures)Cs(e);this.pooledRenderTextures.length=0,(()=>{$s++;for(const[e,t]of Us)$s-t.lastUsedFrame>60&&(As(t.texture),Us.delete(e))})(),this.fillDynamicBindGroup=null,this.fillDynamicBindGroupBuffer=null,this.commandEncoder=null,this.renderPassEncoder=null,this.currentRenderTarget=null,this.nodeRenderPassAtlasIndex=-1,this.mainTexture=null,this.mainTextureView=null,this.frameStarted=!1}}submit(){this.endFrame()}createNode(e,t){const r=xa;if(!Pa[r]){const e=Hn.getRenderMaxSize();Pa[r]=new Jt(r,e,e)}const n=Pa[r].insert(e,t);return n||(va(r+1),this.createNode(e,t))}removeNode(e){const t=e.index,r=Pa[t];r&&r.dispose(e.x,e.y,e.w,e.h)}transferMainCanvas(){if(!this.$mainAttachmentObject||!this.$mainAttachmentObject.texture)return void this.endFrame();this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.ensureCommandEncoder(),this.ensureMainTexture();const e=this.pipelineManager.getPipeline("texture_copy_bgra"),t=this.pipelineManager.getBindGroupLayout("texture_copy");if(!e||!t)return console.error("[WebGPU] texture_copy_bgra pipeline not found"),void this.endFrame();const r=this.$mainAttachmentObject.texture.view;if(!sc||oc!==r){lc||(lc=this.device.createBuffer({size:ec.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST}),this.device.queue.writeBuffer(lc,0,ec.buffer,ec.byteOffset,ec.byteLength));const e=this.textureManager.createSampler("transfer_sampler",!1);fc[0].resource={buffer:lc},fc[1].resource=e,fc[2].resource=r,sc=this.device.createBindGroup({layout:t,entries:fc}),oc=r}const n=sc;cc.view=this.mainTextureView;const i=this.commandEncoder.beginRenderPass(uc);i.setPipeline(e),i.setBindGroup(0,n),i.draw(6,1,0,0),i.end(),this.endFrame()}async createImageBitmap(e,t){const r=wa();if(!r)throw new Error("[WebGPU] Atlas attachment not found");this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null);const n=256*Math.ceil(4*e/256),i=n*t,a=this.device.createBuffer({size:i,usage:GPUBufferUsage.COPY_DST|GPUBufferUsage.MAP_READ}),s=this.device.createCommandEncoder();if(!r.texture)throw new Error("Attachment texture is null");s.copyTextureToBuffer({texture:r.texture.resource,mipLevel:0,origin:{x:0,y:0,z:0}},{buffer:a,bytesPerRow:n,rowsPerImage:t},{width:e,height:t,depthOrArrayLayers:1}),this.device.queue.submit([s.finish()]),await a.mapAsync(GPUMapMode.READ);const o=a.getMappedRange(),l=new Uint8Array(o),c=new Uint8Array(e*t*4);for(let r=0;r<t;r++){const t=r*n,i=r*e*4;c.set(l.subarray(t,t+4*e),i)}a.unmap(),a.destroy();const u=new Float32Array(256);for(let e=1;e<256;e++)u[e]=255/e;for(let e=0;e<c.length;e+=4){const t=c[e+3];if(0===t||255===t)continue;const r=u[t];c[e]=Math.min(255,Math.round(c[e]*r)),c[e+1]=Math.min(255,Math.round(c[e+1]*r)),c[e+2]=Math.min(255,Math.round(c[e+2]*r))}const f=new ImageData(new Uint8ClampedArray(c),e,t);if("undefined"!=typeof createImageBitmap)return await createImageBitmap(f,{premultiplyAlpha:"none",colorSpaceConversion:"none"});throw new Error("[WebGPU] createImageBitmap not available in this environment")}beginMask(){if(this.$mainAttachmentObject&&this.bind(this.$mainAttachmentObject),this.currentRenderTarget=null,this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.frameStarted||this.beginFrame(),this.ensureCommandEncoder(),this.$mainAttachmentObject?.texture&&this.$mainAttachmentObject?.stencil?.view){const e=0===this.$mainAttachmentObject.clipLevel?"clear":"load",t=this.$mainAttachmentObject.msaa&&this.$mainAttachmentObject.msaaTexture?.view,r=t?this.$mainAttachmentObject.msaaTexture.view:this.$mainAttachmentObject.texture.view,n=t&&this.$mainAttachmentObject.msaaStencil?.view?this.$mainAttachmentObject.msaaStencil.view:this.$mainAttachmentObject.stencil.view,i=this.frameBufferManager.createStencilRenderPassDescriptor(r,n,"load",e);this.renderPassEncoder=this.commandEncoder.beginRenderPass(i),this.viewportWidth=this.$mainAttachmentObject.width,this.viewportHeight=this.$mainAttachmentObject.height}(()=>{const e=Qn.currentAttachmentObject;e&&(e.mask=!0,e.clipLevel++,Qa.set(e.clipLevel,e.clipLevel),Da()||ja(!0))})(),this.inMaskMode=!0}setMaskBounds(e,t,r,n){Za(e,t,r,n)}endMask(){this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),Ja(),this.inMaskMode=!1}leaveMask(){this.drawArraysInstanced();const e=this.frameBufferManager.getCurrentAttachment(),t=e?.clipLevel??0,r=1===t;es(),this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.ensureCommandEncoder();const n=this.$mainAttachmentObject?.msaa&&this.$mainAttachmentObject?.msaaTexture?.view,i=n?this.$mainAttachmentObject.msaaTexture.view:this.$mainAttachmentObject?.texture.view,a=n&&this.$mainAttachmentObject?.msaaStencil?.view?this.$mainAttachmentObject.msaaStencil.view:this.$mainAttachmentObject?.stencil?.view;if(r&&a){const e={colorAttachments:[{view:i,loadOp:"load",storeOp:"store"}],depthStencilAttachment:{view:a,stencilLoadOp:"clear",stencilStoreOp:"store",stencilClearValue:0}};this.commandEncoder.beginRenderPass(e).end()}else if(t>1&&a){const e=t,r=`clip_clear_main_${Math.min(8,Math.max(1,e))}`,n=this.pipelineManager.getPipeline(r);if(n){const e=this.frameBufferManager.createStencilRenderPassDescriptor(i,a,"load","load"),t=this.commandEncoder.beginRenderPass(e),r=this.bufferManager.acquireVertexBuffer(rc.byteLength,rc);t.setPipeline(n),t.setStencilReference(0),t.setVertexBuffer(0,r),t.draw(6,1,0,0),t.end()}}}}let yc;const _c=e=>{yc=e};let wc;let Mc=0;let Pc=0;let Sc=!1;const Fc=[],Tc=(...e)=>{const t=Fc.pop()||[];return e.length&&t.push(...e),t},Bc=(e,t=1)=>({R:(16711680&e)>>16,G:(65280&e)>>8,B:255&e,A:255*t}),Oc=async(e,t)=>{if((e=>{wc=e})(e),"gpu"in navigator){const r=navigator.gpu,n=await r.requestAdapter();if(!n)throw new Error("WebGPU adapter not available");const i=await n.requestDevice();if(!i)throw new Error("WebGPU device not available");const a=e.getContext("webgpu");if(!a)throw new Error("WebGPU context not available");const s=r.getPreferredCanvasFormat();_c(new vc(i,a,s,t))}else{const r=e.getContext("webgl2",{stencil:!0,premultipliedAlpha:!0,antialias:!1,depth:!1});if(!r)throw new Error("webgl2 is not supported.");_c(new Kn(r,4,t))}},Ac=(e,t,r=!0)=>{Mc===e&&Pc===t||(Sc=!0,Mc=e,Pc=t,yc.resize(e,t,r),r&&yn.reset())},Rc=(e,t=!1)=>{let r=0;for(;e.length>r;)switch(e[r++]){case 9:yc.beginPath();break;case 0:yc.moveTo(e[r++],e[r++]);break;case 2:yc.lineTo(e[r++],e[r++]);break;case 1:yc.quadraticCurveTo(e[r++],e[r++],e[r++],e[r++]);break;case 5:if(t){r+=4;break}yc.fillStyle(e[r++]/255,e[r++]/255,e[r++]/255,e[r++]/255);break;case 7:yc.fill();break;case 6:if(t){r+=8;break}yc.thickness=e[r++],yc.caps=e[r++],yc.joints=e[r++],yc.miterLimit=e[r++],yc.strokeStyle(e[r++]/255,e[r++]/255,e[r++]/255,e[r++]/255);break;case 8:if(t)break;yc.stroke();break;case 12:yc.closePath();break;case 4:yc.arc(e[r++],e[r++],e[r++]);break;case 3:yc.bezierCurveTo(e[r++],e[r++],e[r++],e[r++],e[r++],e[r++]);break;case 10:{if(t){r+=1;const t=e[r++];r+=5*t,r+=9,yc.fill();break}const n=e[r++],i=Tc(),a=e[r++];for(let t=0;t<a;++t)i.push(e[r++],e[r++],e[r++],e[r++],e[r++]);const s=e.subarray(r,r+6);r+=6;const o=e[r++],l=e[r++],c=e[r++];yc.gradientFill(n,i,s,o,l,c)}break;case 13:{if(t){r+=2;const t=e[r++];r+=t,r+=8,yc.fill();break}const n=e[r++],i=e[r++],a=e[r++],s=new Uint8Array(e.subarray(r,r+a));r+=a;const o=e.subarray(r,r+6);r+=6,yc.bitmapFill(s,o,n,i,Boolean(e[r++]),Boolean(e[r++]))}break;case 11:{if(t){r+=20,yc.fill();break}yc.thickness=e[r++],yc.caps=e[r++],yc.joints=e[r++],yc.miterLimit=e[r++];const n=e[r++],i=Tc(),a=e[r++];for(let t=0;t<a;++t)i.push(e[r++],e[r++],e[r++],e[r++],e[r++]);const s=e.subarray(r,r+6);r+=6;const o=e[r++],l=e[r++],c=e[r++];yc.gradientStroke(n,i,s,o,l,c)}break;case 14:{if(t){r+=6;const t=e[r++];r+=t,r+=8,yc.fill();break}yc.thickness=e[r++],yc.caps=e[r++],yc.joints=e[r++],yc.miterLimit=e[r++];const n=e[r++],i=e[r++],a=e[r++],s=new Uint8Array(e.subarray(r,r+a));r+=a;const o=e.subarray(r,r+6);r+=6,yc.bitmapStroke(s,o,n,i,Boolean(e[r++]),Boolean(e[r++]))}}},Cc=e=>{switch(e){case 0:return"copy";case 1:return"add";case 2:return"alpha";case 3:return"darken";case 4:return"difference";case 5:return"erase";case 6:return"hardlight";case 7:return"invert";case 8:return"layer";case 9:return"lighten";case 10:return"multiply";case 11:default:return"normal";case 12:return"overlay";case 13:return"screen";case 14:return"subtract"}},Ec=(e,t)=>{const r=e.subarray(t,t+6);t+=6;const n=e.subarray(t,t+8);t+=8;const i=e.subarray(t,t+4);t+=4;const a=e[t++],s=e[t++],o=e[t++],l=e[t++],c=Boolean(e[t++]),u=Boolean(e[t++]),f=Boolean(e[t++]),d=`${e[t++]}`,h=e[t++],p=e[t++],m=e[t++],g=`${e[t++]}`;let b;if(e[t++]){if(b=yn.get(d,`${h}`),!b)return t}else{const r=c?new Float32Array(28):null;r&&(r.set(e.subarray(t,t+24)),t+=24),yc.useGrid(r);const n=e[t++],i=e.subarray(t,t+n);if(f&&!c){const e=Math.ceil(Math.abs(o-a)),t=Math.ceil(Math.abs(l-s));b=yc.createNode(e,t),yn.set(d,`${h}`,b);const r=yc.currentAttachmentObject,n=yc.atlasAttachmentObject;n&&yc.bind(n),yc.reset(),yc.beginNodeRendering(b);const c=n?n.height-b.y-t:0;yc.setTransform(1,0,0,1,b.x,c),u?(Rc(i),yc.drawFill()):yc.drawPixels(b,new Uint8Array(i)),yc.endNodeRendering(),r&&yc.bind(r)}else{const e=Math.ceil(Math.abs(o-a)*p),t=Math.ceil(Math.abs(l-s)*m);b=yc.createNode(e,t),yn.set(d,`${h}`,b);const n=yc.currentAttachmentObject,c=yc.atlasAttachmentObject;c&&yc.bind(c),yc.reset(),yc.beginNodeRendering(b);const u=c?c.height-b.y-t:0;yc.setTransform(p,0,0,m,-a*p+b.x,-s*m+u),r&&(r[24]=b.x,r[25]=u),Rc(i),yc.drawFill(),yc.endNodeRendering(),n&&yc.bind(n)}t+=n}const x=e[t++];if(Boolean(e[t++])){const a=Boolean(e[t++]),s=e.subarray(t,t+4);t+=4;const o=e[t++],l=e.subarray(t,t+o),c=Math.ceil(Math.abs(i[2]-i[0])),u=Math.ceil(Math.abs(i[3]-i[1]));return yc.applyFilter(b,g,a,c,u,f,r,n,Cc(x),s,l),t+=o}if(yc.globalAlpha=Math.min(Math.max(0,n[3]+n[7]/255),1),yc.imageSmoothingEnabled=!0,yc.globalCompositeOperation=Cc(x),f&&!c)yc.setTransform(r[0],r[1],r[2],r[3],r[4],r[5]),yc.drawDisplayObject(b,i[0],i[1],i[2],i[3],n);else{const e=Math.atan2(r[1],r[0]),t=Math.atan2(-r[2],r[3]);if(e||t){const n=a*p,i=s*m,o=Math.cos(e),l=Math.sin(e),c=Math.cos(t),u=Math.sin(t);yc.setTransform(o,l,-u,c,n*o-i*u+r[4],n*l+i*c+r[5])}else yc.setTransform(1,0,0,1,i[0],i[1]);yc.drawDisplayObject(b,i[0],i[1],i[2],i[3],n)}return t},Uc=(e,t)=>{const r=e.subarray(t,t+6);t+=6,yc.reset(),yc.setTransform(r[0],r[1],r[2],r[3],r[4],r[5]);const n=Boolean(e[t++])?new Float32Array(28):null;yc.useGrid(n),n&&(n.set(e.subarray(t,t+24)),t+=24);const i=e[t++],a=e.subarray(t,t+i);return Rc(a,!0),t+=i,yc.clip(),t},$c=(e,t,r)=>{const n=e.widthTable[t.line]||0,i=t.textFormat,a=i.leftMargin||0;if(!r.wordWrap&&n>r.rawWidth)return Math.max(0,a);const s=i.rightMargin||0;return"center"===i.align||"center"===r.autoSize?Math.max(0,r.rawWidth/2-a-s-n/2-2):"right"===i.align||"right"===r.autoSize?Math.max(0,r.rawWidth-a-n-s-4):Math.max(0,a)},Gc=e=>{let t="";return e.italic&&(t+="italic "),e.bold&&(t+="bold "),`${t}${e.size}px '${e.font}','sans-serif'`},kc=new TextDecoder,Lc=(e,t)=>{const r=e.subarray(t,t+6);t+=6;const n=e.subarray(t,t+8);t+=8;const i=e.subarray(t,t+4);t+=4;const a=e[t++],s=e[t++],o=e[t++],l=e[t++],c=`${e[t++]}`,u=e[t++],f=Boolean(e[t++]),d=e[t++],h=e[t++],p=`${e[t++]}`;let m;if(e[t++]){if(m=yn.get(c,`${u}`),!m)return t}else{const r=Math.ceil(Math.abs(o-a)*d),n=Math.ceil(Math.abs(l-s)*h),i=Boolean(e[t++]);m=i?yn.get(c,`${u}`):yc.createNode(r,n),i||yn.set(c,`${u}`,m);const f=e[t++],p=new Uint8Array(e.subarray(t,t+f));t+=f;let g="none";switch(e[t++]){case 0:g="center";break;case 1:g="left";break;case 2:g="none";break;case 3:g="right"}const b={width:r,height:n,autoSize:g,stopIndex:e[t++],scrollX:e[t++],scrollY:e[t++],textWidth:e[t++],textHeight:e[t++],rawWidth:e[t++],rawHeight:e[t++],focusIndex:e[t++],selectIndex:e[t++],focusVisible:Boolean(e[t++]),thickness:e[t++],thicknessColor:e[t++],wordWrap:Boolean(e[t++]),border:Boolean(e[t++]),borderColor:e[t++],background:Boolean(e[t++]),backgroundColor:e[t++],defaultColor:e[t++],defaultSize:e[t++]},x=((e,t,r,n)=>{const i=new OffscreenCanvas(t.width,t.height),a=i.getContext("2d");if(!a)return i;const s=Math.min(1,Math.max(r,n));if(t.background||t.border){if(a.beginPath(),a.moveTo(0,0),a.lineTo(t.width,0),a.lineTo(t.width,t.height),a.lineTo(0,t.height),a.lineTo(0,0),t.background){const e=Bc(t.backgroundColor);a.fillStyle=`rgba(${e.R},${e.G},${e.B},${e.A})`,a.fill()}if(t.border){const e=Bc(t.borderColor);a.lineWidth=s,a.strokeStyle=`rgba(${e.R},${e.G},${e.B},${e.A})`,a.stroke()}}if(!e)return i;a.save(),a.beginPath(),a.moveTo(2,2),a.lineTo(t.width-2,2),a.lineTo(t.width-2,t.height-2),a.lineTo(2,t.height-2),a.lineTo(2,2),a.clip();let o=2;if(t.scrollX>0){const e=(t.textWidth+4-t.rawWidth)/t.rawWidth;o+=-t.scrollX*e}let l=2;if(t.scrollY>0){const e=(t.textHeight+2-t.rawHeight)/t.rawHeight;l+=-t.scrollY*e}if(a.setTransform(r,0,0,n,o*r,l*n),a.beginPath(),t.selectIndex>-1&&t.focusIndex>-1){const r=e.textTable.length-1;let n=0,i=0;t.focusIndex<=t.selectIndex?(n=Math.min(t.focusIndex,r),i=Math.min(t.selectIndex,r)):(n=Math.min(t.selectIndex,r),i=Math.min(t.focusIndex-1,r));const s=e.textTable[n],o=e.lineTable[s.line],l=$c(e,o,t);let c=0;if(n&&"text"===s.mode){let t=n;for(;t;){const r=e.textTable[--t];if("text"!==r.mode)break;c+=r.w}}a.fillStyle="#b4d7ff";let u=0;for(let t=n;t<=i;++t){const r=e.textTable[t];if("text"===r.mode&&(u+=r.w,t!==i))continue;let n=0;const s="text"===r.mode?r.line:r.line-1;for(let t=0;t<s;++t)n+=e.heightTable[t];a.beginPath(),a.rect(c,n,u+l,e.heightTable[s]),a.fill(),c=0,u=0}}const c=t.rawWidth;let u=0;if(t.scrollX>0){const e=(t.textWidth-c)/c;u=t.scrollX*e}const f=c+u,d=t.rawHeight;let h=0;if(t.scrollY>0){const e=(t.textHeight-d)/d;h=t.scrollY*e}const p=d+h;let m=0,g=0,b=0,x=0,v=!1,y=-1;for(let r=0;r<e.textTable.length;++r){const n=e.textTable[r];if(!n)continue;if(("text"===n.mode||"break"===n.mode)&&(y++,t.stopIndex>-1&&y>t.stopIndex))break;if(v&&"text"===n.mode)continue;const i=n.textFormat;if("none"===t.autoSize){if(g>p)break;if("text"===n.mode&&(u>m+n.w||m>f)){m+=n.w;continue}}const o=Bc(i.color||0);if(a.fillStyle=`rgba(${o.R},${o.G},${o.B},${o.A})`,t.focusVisible&&t.focusIndex===r){const t=m+b+.1;let r=n.line,i=n.y,s=e.ascentTable[r];"text"!==n.mode&&(i="break"===n.mode?n.h:e.ascentTable[r-1],r>0?(r=n.line-1,s=e.ascentTable[r]):s=n.h),r>0&&0===e.ascentTable[r]&&r++;for(let t=0;t<r;++t)s+=e.heightTable[t];a.strokeStyle=`rgba(${o.R},${o.G},${o.B},${o.A})`,a.beginPath(),a.moveTo(t,s),a.lineTo(t,s-i),a.stroke()}if(t.thickness){const e=Bc(t.thicknessColor);a.lineWidth=t.thickness,a.strokeStyle=`rgba(${e.R},${e.G},${e.B},${e.A})`}const l=0|n.line;switch(n.mode){case"break":case"wrap":if(m=0,l&&(g+=e.heightTable[l-1]),h>g+e.heightTable[l]){v=!0;continue}x=e.ascentTable[l],b=$c(e,n,t),v=!1;break;case"text":{a.beginPath(),a.font=Gc(i);const e=m+b,r=g+x;if(i.underline){const t=Bc(i.color||0);a.lineWidth=s,a.strokeStyle=`rgba(${t.R},${t.G},${t.B},${t.A})`,a.beginPath(),a.moveTo(e,r+2),a.lineTo(e+n.w,r+2),a.stroke()}t.thickness&&a.strokeText(n.text,e,r),a.fillText(n.text,e,r),m+=n.w}}}if(t.focusVisible&&t.focusIndex>=e.textTable.length){const r=e.textTable[t.focusIndex-1];if(r){const e=Bc(r.textFormat.color||0);a.strokeStyle=`rgba(${e.R},${e.G},${e.B},${e.A})`;const t=m+b+.1,n=g+x;a.beginPath(),"text"===r.mode?a.moveTo(t,n-r.y):a.moveTo(t,n+r.h),a.lineTo(t,n),a.stroke()}}return a.restore(),i})(JSON.parse(kc.decode(p)),b,d,h),v=yc.currentAttachmentObject,y=yc.atlasAttachmentObject;y&&yc.bind(y),yc.reset(),yc.beginNodeRendering(m);const _=y?y.height-m.y-n:0;yc.setTransform(1,0,0,1,m.x,_),yc.drawElement(m,x),yc.endNodeRendering(),v&&yc.bind(v)}const g=e[t++];if(Boolean(e[t++])){const a=Boolean(e[t++]),s=e.subarray(t,t+4);t+=4;const o=e[t++],l=e.subarray(t,t+o),c=Math.ceil(Math.abs(i[2]-i[0])),u=Math.ceil(Math.abs(i[3]-i[1]));return yc.applyFilter(m,p,Boolean(Math.max(+f,+a)),c,u,!1,r,n,Cc(g),s,l),t+=o}yc.globalAlpha=Math.min(Math.max(0,n[3]+n[7]/255),1),yc.imageSmoothingEnabled=!0,yc.globalCompositeOperation=Cc(g);const b=Math.atan2(r[1],r[0]),x=Math.atan2(-r[2],r[3]);if(b||x){const e=a*d,t=s*h,n=Math.cos(b),i=Math.sin(b),o=Math.cos(x),l=Math.sin(x);yc.setTransform(n,i,-l,o,e*n-t*l+r[4],e*i+t*o+r[5])}else yc.setTransform(1,0,0,1,i[0],i[1]);return yc.drawDisplayObject(m,i[0],i[1],i[2],i[3],n),t},Ic=(e,t,r)=>{const n=e.subarray(t,t+6);t+=6;const i=e.subarray(t,t+8);t+=8;const a=e.subarray(t,t+4);t+=4;const s=e[t++],o=e[t++],l=e[t++],c=e[t++],u=`${e[t++]}`,f=Boolean(e[t++]),d=`${e[t++]}`;let h;if(e[t++]){if(h=yn.get(u,"0"),!h)return t}else{const n=Math.abs(l-s),i=Math.abs(c-o),a=Boolean(e[t++]);if(h=a?yn.get(u,"0"):yc.createNode(n,i),a||yn.set(u,"0",h),r&&r.length){const e=yc.currentAttachmentObject,t=yc.atlasAttachmentObject;t&&yc.bind(t),yc.reset(),yc.beginNodeRendering(h);const n=t?t.height-h.y-i:0;yc.setTransform(1,0,0,1,h.x,n);const a=r.shift();yc.drawElement(h,a,!0),yc.endNodeRendering(),e&&yc.bind(e)}}const p=e[t++];if(Boolean(e[t++])){const r=Boolean(e[t++]),s=e.subarray(t,t+4);t+=4;const o=e[t++],l=e.subarray(t,t+o),c=Math.ceil(Math.abs(a[2]-a[0])),u=Math.ceil(Math.abs(a[3]-a[1]));return yc.applyFilter(h,d,Boolean(Math.max(+f,+r)),c,u,!0,n,i,Cc(p),s,l),t+=o}return yc.globalAlpha=Math.min(Math.max(0,i[3]+i[7]/255),1),yc.imageSmoothingEnabled=!0,yc.globalCompositeOperation=Cc(p),yc.setTransform(n[0],n[1],n[2],n[3],n[4],n[5]),yc.drawDisplayObject(h,a[0],a[1],a[2],a[3],i),t},Vc=(e,t)=>{const r=e[t++];for(let n=0;n<r;++n){switch(e[t++]){case 0:t=Vc(e,t);break;case 1:t=Uc(e,t)}}return t},zc=(e,t,r)=>{let n=0,i=!0;const a=Cc(e[t++]),s=Boolean(e[t++]);let o=0,l=0,c=!1,u="",f="",d=null,h=null,p=null,m=null;if(s)if(o=e[t++],l=e[t++],c=Boolean(e[t++]),c){const r=Boolean(e[t++]);if(u=`${e[t++]}`,f=`${e[t++]}`,r)return d=e.subarray(t,t+4),t+=4,p=e.subarray(t,t+6),t+=6,m=e.subarray(t,t+8),t+=8,yc.containerDrawCachedFilter(a,p,m,d,u,f),t;d=e.subarray(t,t+4),t+=4,p=e.subarray(t,t+6),t+=6,m=e.subarray(t,t+8),t+=8;const n=e[t++];h=e.subarray(t,t+n),t+=n}else p=e.subarray(t,t+6),t+=6,m=e.subarray(t,t+8),t+=8;s&&yc.containerBeginLayer(o,l);const g=Boolean(e[t++]);if(g){yc.drawArraysInstanced(),yc.save(),yc.beginMask(),yc.setMaskBounds(e[t++],e[t++],e[t++],e[t++]);switch(e[t++]){case 0:t=Vc(e,t);break;case 1:t=Uc(e,t)}yc.endMask()}const b=e[t++];for(let a=0;b>a;a++){const a=e[t++],s=e[t++];if(n&&a>n&&(i&&(yc.restore(),yc.leaveMask()),n=0,i=!0),!i)continue;if(s){if(n=s,i=Boolean(e[t++]),!i)continue;yc.drawArraysInstanced(),yc.save(),yc.beginMask(),yc.setMaskBounds(e[t++],e[t++],e[t++],e[t++]);switch(e[t++]){case 0:t=Vc(e,t);break;case 1:t=Uc(e,t)}yc.endMask();continue}if(!e[t++])continue;switch(e[t++]){case 0:t=zc(e,t,r);break;case 1:t=Ec(e,t);break;case 2:t=Lc(e,t);break;case 3:t=Ic(e,t,r)}}return(n||g)&&(yc.restore(),yc.leaveMask()),s&&yc.containerEndLayer(a,p,m,c,d,h,u,f),t};let jc=-1;const Dc=(e,t)=>{yc.clearTransferBounds();let r=0;const n=e[r++];for(jc!==n&&(jc=n,-1===jc?yc.updateBackgroundColor(0,0,0,0):yc.updateBackgroundColor((jc>>16&255)/255,(jc>>8&255)/255,(255&jc)/255,1)),yc.reset(),yc.setTransform(1,0,0,1,0,0),yc.fillBackgroundColor();e.length>r;){if(!e[r++])continue;const n=e[r++];switch(n){case 0:r=zc(e,r,t);break;case 1:r=Ec(e,r);break;case 2:r=Lc(e,r);break;case 3:r=Ic(e,r,t);break;default:console.error("unknown type",n)}}yc.drawArraysInstanced(),Sc&&(wc.width=Mc,wc.height=Pc,Sc=!1),yc.transferMainCanvas()},Nc=e=>{for(let t=0;t<e.length;++t){const r=`${e[t]}`;if(!yn.has(r))continue;const n=yn.getById(r);for(const e of n.values())yc.removeNode(e);yn.removeById(r)}},Wc=async(e,t,r,n=0,i=0,a)=>{yc.clearTransferBounds();let s=1;yc.reset(),yc.setTransform(1,0,0,1,0,0);const o=yc.$clearColorR,l=yc.$clearColorG,c=yc.$clearColorB,u=yc.$clearColorA;for(yc.updateBackgroundColor((n>>16&255)/255,(n>>8&255)/255,(255&n)/255,i),yc.fillBackgroundColor();e.length>s;){if(!e[s++])continue;const t=e[s++];switch(t){case 0:s=zc(e,s,a);break;case 1:s=Ec(e,s);break;case 2:s=Lc(e,s);break;case 3:s=Ic(e,s,a);break;default:console.error("unknown type",t)}}yc.drawArraysInstanced();const f=await yc.createImageBitmap(t,r);return yc.updateBackgroundColor(o,l,c,u),f};const qc=new class{constructor(){Object.defineProperty(this,"state",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"queue",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.state="deactivate",this.queue=[]}async execute(){for(this.state="active";this.queue.length;){const e=this.queue.shift();if(e)switch(e.command){case"render":Dc(e.buffer.subarray(0,e.length),e.imageBitmaps),globalThis.postMessage({message:"render",buffer:e.buffer},[e.buffer.buffer]);break;case"resize":Ac(e.buffer[0],e.buffer[1],Boolean(e.buffer[2]));break;case"initialize":await Oc(e.canvas,e.devicePixelRatio);break;case"removeCache":Nc(e.buffer);break;case"cacheClear":yn.reset();break;case"capture":{const t=await Wc(e.buffer.subarray(0,e.length),e.width,e.height,e.bgColor,e.bgAlpha,e.imageBitmaps);globalThis.postMessage({message:"capture",buffer:e.buffer,imageBitmap:t},[e.buffer.buffer,t])}}}this.state="deactivate"}};self.addEventListener("message",async e=>{qc.queue.push(e.data),"deactivate"===qc.state&&await qc.execute()});return{}}();
';
1
+ export const workerInlineUrl = 'data:application/javascript;base64,var RendererWorker=function(){"use strict";let e=2048;let t=4;let r;let n;let i=!1;const a=()=>{i||(i=!0,r.enable(r.SCISSOR_TEST))},s=()=>{i&&(i=!1,r.disable(r.SCISSOR_TEST))};let o=!1;const l=()=>{o||(o=!0,r.enable(r.STENCIL_TEST))},c=()=>{o&&(o=!1,r.disable(r.STENCIL_TEST))},u=(e,t,r,n=null)=>{const i=+e;return isNaN(i)&&null!==n?n:Math.min(Math.max(t,isNaN(i)?0:i),r)},f=[],d=(...e)=>{const t=f.pop()||[];return e.length&&t.push(...e),t},h=(e=null)=>{e&&(e.length&&(e.length=0),f.push(e))},p=e=>(e--,e|=e>>1,e|=e>>2,e|=e>>4,e|=e>>8,e|=e>>16,++e),m=[],g=(e=0,t=0,r=0,n=0)=>{const i=m.pop()||new Float32Array(4);return i[0]=e,i[1]=t,i[2]=r,i[3]=n,i},b=e=>{m.push(e)},x=[],v=(e=0,t=0,r=0,n=0,i=0,a=0,s=0,o=0,l=0)=>{const c=x.pop()||new Float32Array(9);return c[0]=e,c[1]=t,c[2]=r,c[3]=n,c[4]=i,c[5]=a,c[6]=s,c[7]=o,c[8]=l,c},y=[],_=(e=0,t=0,r=0,n=0,i=0,a=0)=>{const s=y.pop()||new Float32Array(6);return s[0]=e,s[1]=t,s[2]=r,s[3]=n,s[4]=i,s[5]=a,s},w=e=>{y.push(e)},M=e=>{const t=1/(e[0]*e[4]-e[3]*e[1]),r=e[3]*e[7]-e[4]*e[6],n=e[1]*e[6]-e[0]*e[7];return v(e[4]*t,0-e[1]*t,0,0-e[3]*t,e[0]*t,0,r*t,n*t,1)};let P=0,S=0;let F=1;const T=d(),B=d(),O=(e=!1)=>{const t=e?6:9;T.length>=t&&B.push(T.slice(0)),T.length=0;const r=[];for(let e=0;e<B.length;e++){const n=B[e];n.length>=t&&r.push(n)}return B.length=0,r},A=(e,t,r)=>{T.push(e,t,r)},R=(e,t)=>{const r=T.length,n=+T[r-3],i=+T[r-2];return e===n&&t===i},C=(e,t)=>{T.length?R(e,t)||(T.length<3||B.push(T.slice(0)),T.length=0,A(e,t,!1)):A(e,t,!1)},E=(e,t,r,n)=>{T.length||C(0,0),R(r,n)||(A(e,t,!0),A(r,n,!1))};let U=new Float32Array(64),$=0;const G=(e,t,r,n,i,a,s,o)=>{const l=((e,t,r,n,i,a,s,o)=>{const l=3*r-2*e-s,c=3*n-2*t-o,u=3*i-2*s-e,f=3*a-2*o-t;return Math.max(l*l+c*c,u*u+f*f)})(e,t,r,n,i,a,s,o);if(l<.25)return 2;const c=Math.ceil(Math.log2(Math.sqrt(l)/.5)/2);return Math.min(Math.max(c+2,2),8)},k=[];let L=0;const I=()=>{L=0},V=()=>(L>=k.length&&k.push(new Float32Array(8)),k[L++]),z=(e,t,r,n,i,a,s,o,l,c,u)=>{const f=1-l,d=f*e+l*r,h=f*t+l*n,p=f*r+l*i,m=f*n+l*a,g=f*i+l*s,b=f*a+l*o,x=f*d+l*p,v=f*h+l*m,y=f*p+l*g,_=f*m+l*b,w=f*x+l*y,M=f*v+l*_;c[0]=e,c[1]=t,c[2]=d,c[3]=h,c[4]=x,c[5]=v,c[6]=w,c[7]=M,u[0]=w,u[1]=M,u[2]=y,u[3]=_,u[4]=g,u[5]=b,u[6]=s,u[7]=o},j=(e,t,r,n,i,a,s,o,l,c)=>{const u=.25*(3*r+3*i-e-s),f=.25*(3*n+3*a-t-o);l[c]=u,l[c+1]=f,l[c+2]=s,l[c+3]=o},D=new Float32Array(8),N=new Float32Array(8),W=(e,t,r,n,i,a,s,o)=>{const l=G(e,t,r,n,i,a,s,o);var c;c=4*l,U.length<c&&(U=new Float32Array(2*c));let u=0;if(l<=2)z(e,t,r,n,i,a,s,o,.5,D,N),j(D[0],D[1],D[2],D[3],D[4],D[5],D[6],D[7],U,u),u+=4,j(N[0],N[1],N[2],N[3],N[4],N[5],N[6],N[7],U,u),u+=4;else if(l<=4){I();const l=V(),c=V();z(e,t,r,n,i,a,s,o,.5,l,c);const f=V(),d=V(),h=V(),p=V();z(l[0],l[1],l[2],l[3],l[4],l[5],l[6],l[7],.5,f,d),z(c[0],c[1],c[2],c[3],c[4],c[5],c[6],c[7],.5,h,p),j(f[0],f[1],f[2],f[3],f[4],f[5],f[6],f[7],U,u),u+=4,j(d[0],d[1],d[2],d[3],d[4],d[5],d[6],d[7],U,u),u+=4,j(h[0],h[1],h[2],h[3],h[4],h[5],h[6],h[7],U,u),u+=4,j(p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],U,u),u+=4}else{I();const l=V(),c=V();z(e,t,r,n,i,a,s,o,.5,l,c);const f=V(),d=V(),h=V(),p=V();z(l[0],l[1],l[2],l[3],l[4],l[5],l[6],l[7],.5,f,d),z(c[0],c[1],c[2],c[3],c[4],c[5],c[6],c[7],.5,h,p);const m=V(),g=V(),b=V(),x=V(),v=V(),y=V(),_=V(),w=V();z(f[0],f[1],f[2],f[3],f[4],f[5],f[6],f[7],.5,m,g),z(d[0],d[1],d[2],d[3],d[4],d[5],d[6],d[7],.5,b,x),z(h[0],h[1],h[2],h[3],h[4],h[5],h[6],h[7],.5,v,y),z(p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],.5,_,w),j(m[0],m[1],m[2],m[3],m[4],m[5],m[6],m[7],U,u),u+=4,j(g[0],g[1],g[2],g[3],g[4],g[5],g[6],g[7],U,u),u+=4,j(b[0],b[1],b[2],b[3],b[4],b[5],b[6],b[7],U,u),u+=4,j(x[0],x[1],x[2],x[3],x[4],x[5],x[6],x[7],U,u),u+=4,j(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7],U,u),u+=4,j(y[0],y[1],y[2],y[3],y[4],y[5],y[6],y[7],U,u),u+=4,j(_[0],_[1],_[2],_[3],_[4],_[5],_[6],_[7],U,u),u+=4,j(w[0],w[1],w[2],w[3],w[4],w[5],w[6],w[7],U,u),u+=4}return $=u/4,{buffer:U,count:$}},q=(e,t,r,n,i,a)=>{if(T.length||C(0,0),R(i,a))return;const s=T.length,o=+T[s-3],l=+T[s-2],c=W(o,l,e,t,r,n,i,a),u=c.buffer,f=c.count;for(let e=0;e<4*f;)E(u[e++],u[e++],u[e++],u[e++])},X=[],Y=e=>{let t=-1,r=X.length;for(;Math.abs(r-t)>1;){const n=Math.floor((r+t)/2);e<=X[n].area?r=n:t=n}return r},K=e=>{r.deleteTexture(e.resource)},H=[],Q=[];let Z;let J=null;let ee=null;let te=null;const re=e=>{te=e};let ne=!1;const ie=e=>{ne=e};let ae=null,se=null,oe=null,le=null;const ce=(e,t=!0)=>{var n;e.msaa?((e=>{if(X.indexOf(e)>-1)return;const t=Y(e.area);e.dirty=!0,X.splice(t,0,e)})(e.color),e.color=null,e.stencil=null):(t&&K(e.texture),e.texture=null,n=e.stencil,H.indexOf(n)>-1||(H.length>10?r.deleteRenderbuffer(n.resource):(n.dirty=!0,H.push(n))),e.stencil=null),Q.push(e)};let ue=0;const fe=e=>{if(!X.length)return(()=>{const e={id:0,resource:r.createRenderbuffer(),width:0,height:0,area:0,dirty:!1};return{resource:r.createRenderbuffer(),stencil:e,width:0,height:0,area:0,dirty:!1}})();const t=Y(e);if(t<X.length){const e=X[t];return X.splice(t,1),e}const n=X.shift();if(!n)throw new Error("the color buffer is void.");return n};let de=0;const he=(e,t)=>{if(!H.length)return{id:de++,resource:r.createRenderbuffer(),width:0,height:0,area:0,dirty:!1};let n=-1,i=1/0;for(let r=0;r<H.length;++r){const a=H[r];a.width>=e&&a.height>=t&&a.area<i&&(i=a.area,n=r)}if(-1!==n){const e=H[n];return H[n]=H[H.length-1],H.pop(),e}return H.pop()};let pe=0;const me=(e,t)=>({id:pe++,resource:r.createTexture(),width:e,height:t,area:e*t,smooth:!1});let ge=-1;const be=e=>{ge=e},xe=[null,null,null],ve=(e,t,n=!1)=>{const i=me(e,t);return((e,t=!1)=>{ge!==r.TEXTURE0&&(be(r.TEXTURE0),r.activeTexture(r.TEXTURE0)),xe[0]=e,r.bindTexture(r.TEXTURE_2D,e.resource),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,t?r.LINEAR:r.NEAREST),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,t?r.LINEAR:r.NEAREST),r.texStorage2D(r.TEXTURE_2D,1,r.RGBA8,e.width,e.height)})(i,n),i},ye=(e,n,i=!1)=>{const a=Q.length?Q.pop():{id:ue++,width:0,height:0,clipLevel:0,msaa:!1,mask:!1,color:null,texture:null,stencil:null};return a.width=e,a.height=n,i?(a.msaa=!0,a.texture=null,a.color=((e,n)=>{e=Math.max(256,p(e)),n=Math.max(256,p(n));const i=fe(e*n);return(i.width<e||i.height<n)&&(e=Math.max(e,i.width),n=Math.max(n,i.height),i.width=e,i.height=n,i.area=e*n,r.bindRenderbuffer(r.RENDERBUFFER,i.resource),r.renderbufferStorageMultisample(r.RENDERBUFFER,t,r.RGBA8,e,n),r.bindRenderbuffer(r.RENDERBUFFER,i.stencil.resource),r.renderbufferStorageMultisample(r.RENDERBUFFER,t,r.STENCIL_INDEX8,e,n)),i.dirty=!0,i})(e,n),a.stencil=a.color.stencil):(a.msaa=!1,a.texture=ve(e,n),a.color=null,a.stencil=((e,t)=>{const n=he(e,t);return n.width===e&&n.height===t||(n.width=e,n.height=t,n.area=e*t,n.dirty=!1,r.bindRenderbuffer(r.RENDERBUFFER,n.resource),r.renderbufferStorage(r.RENDERBUFFER,r.STENCIL_INDEX8,e,t)),n})(e,n)),a.mask=!1,a.clipLevel=0,a},_e=Number.MAX_VALUE,we=-Number.MAX_VALUE;let Me=0;const Pe=e=>{Me=e},Se=[],Fe=()=>{var t;return Me in Se||(t=ye(e,e,!0),Se[Me]=t),Se[Me]},Te=[];let Be=null;const Oe=()=>(Be||(Be=(()=>{const t=me(e,e);return r.activeTexture(r.TEXTURE3),r.bindTexture(r.TEXTURE_2D,t.resource),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,r.CLAMP_TO_EDGE),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,r.LINEAR),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,r.NEAREST),r.texStorage2D(r.TEXTURE_2D,1,r.RGBA8,t.width,t.height),r.activeTexture(-1!==ge?ge:r.TEXTURE0),t})()),Be),Ae=[],Re=e=>(e in Ae||(Ae[e]=new Float32Array([_e,_e,we,we])),Ae[e]);let Ce=0;const Ee=e=>{Ce=e},Ue=()=>{Te.length=0,Pe(0);const e=Se;for(let t=0;t<e.length;t++)ce(e[t]);e.length=0},$e=(e,t,n,i=!0)=>{if(e.clearArraysInstanced(),e.$stackAttachmentObject.length)for(let t=0;t<e.$stackAttachmentObject.length;++t){const r=e.$stackAttachmentObject[t];r&&ce(r)}else e.$mainAttachmentObject&&ce(e.$mainAttachmentObject);i&&Ue(),re(null),ne&&(ie(!1),r.bindFramebuffer(r.FRAMEBUFFER,null)),e.$mainAttachmentObject=ye(t,n,!0),e.bind(e.$mainAttachmentObject)},Ge=(e,t,n=null,i=!1)=>{-1!==ge&&t===ge||(be(t),r.activeTexture(t));const a=xe[e];null!==a&&null!==n&&a.id===n.id||n===a||(xe[e]=n,r.bindTexture(r.TEXTURE_2D,n?n.resource:null),n&&n.smooth!==i&&(n.smooth=i,r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MIN_FILTER,i?r.LINEAR:r.NEAREST),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_MAG_FILTER,i?r.LINEAR:r.NEAREST)))},ke=(e,t=!1)=>{Ge(2,r.TEXTURE2,null),Ge(1,r.TEXTURE1,null),Ge(0,r.TEXTURE0,e,t)},Le=()=>{const e=n.currentAttachmentObject;if(!e)return;const t=e.clipLevel;let i=0;for(let e=0;e<t;++e)i|=(1<<t-e)-1;r.stencilMask(255),r.stencilFunc(r.EQUAL,255&i,i),r.stencilOp(r.KEEP,r.KEEP,r.KEEP),r.colorMask(!0,!0,!0,!0),r.disable(r.SAMPLE_ALPHA_TO_COVERAGE),s()};let Ie=!1;const Ve=e=>{Ie=e},ze=()=>Ie,je=new Map,De=new Map,Ne=(e,t)=>{const n=te;if(n&&t.id===n.id)return;var i,a;(e=>{re(e),ne||(ie(!0),r.bindFramebuffer(r.FRAMEBUFFER,Z)),e.msaa?(r.bindRenderbuffer(r.RENDERBUFFER,e.color.resource),r.framebufferRenderbuffer(r.FRAMEBUFFER,r.COLOR_ATTACHMENT0,r.RENDERBUFFER,e.color.resource)):(ke(e.texture),r.framebufferTexture2D(r.FRAMEBUFFER,r.COLOR_ATTACHMENT0,r.TEXTURE_2D,e.texture.resource,0),Ge(0,r.TEXTURE0,null)),r.bindRenderbuffer(r.RENDERBUFFER,e.stencil.resource),r.framebufferRenderbuffer(r.FRAMEBUFFER,r.STENCIL_ATTACHMENT,r.RENDERBUFFER,e.stencil.resource)})(t),n&&n.width===t.width&&n.height===t.height||(i=t.width,a=t.height,P=i,S=a,r.viewport(0,0,t.width,t.height));const o=t.msaa?t.color:t.stencil;var u;o.dirty&&(o.dirty=!1,e.clearRect(0,0,t.width,t.height)),!(u=t.mask)&&ze()?(Ve(!1),c(),s()):u&&!ze()&&(Ve(!0),l(),Le())},We=e=>{if(!e.$stack.length)return;const t=e.$stack.pop();var r;e.$matrix[0]=t[0],e.$matrix[1]=t[1],e.$matrix[3]=t[3],e.$matrix[4]=t[4],e.$matrix[6]=t[6],e.$matrix[7]=t[7],r=t,x.push(r)},qe=(e,t,r,n,i,a,s,o,l,c,u,f,d)=>{const h=e.length-5;for(let p=3;p<h;p+=3){let h=17*r;e[p+2]?(t[h++]=e[p-3],t[h++]=e[p-2],t[h++]=0,t[h++]=0,t[h++]=c,t[h++]=u,t[h++]=f,t[h++]=d,t[h++]=n,t[h++]=i,t[h++]=0,t[h++]=a,t[h++]=s,t[h++]=0,t[h++]=o,t[h++]=l,t[h++]=0,t[h++]=e[p],t[h++]=e[p+1],t[h++]=.5,t[h++]=0,t[h++]=c,t[h++]=u,t[h++]=f,t[h++]=d,t[h++]=n,t[h++]=i,t[h++]=0,t[h++]=a,t[h++]=s,t[h++]=0,t[h++]=o,t[h++]=l,t[h++]=0,t[h++]=e[p+3],t[h++]=e[p+4],t[h++]=1,t[h++]=1,t[h++]=c,t[h++]=u,t[h++]=f,t[h++]=d,t[h++]=n,t[h++]=i,t[h++]=0,t[h++]=a,t[h++]=s,t[h++]=0,t[h++]=o,t[h++]=l,t[h++]=0):e[p+5]?(t[h++]=e[0],t[h++]=e[1],t[h++]=.5,t[h++]=.5,t[h++]=c,t[h++]=u,t[h++]=f,t[h++]=d,t[h++]=n,t[h++]=i,t[h++]=0,t[h++]=a,t[h++]=s,t[h++]=0,t[h++]=o,t[h++]=l,t[h++]=0,t[h++]=e[p],t[h++]=e[p+1],t[h++]=.5,t[h++]=.5,t[h++]=c,t[h++]=u,t[h++]=f,t[h++]=d,t[h++]=n,t[h++]=i,t[h++]=0,t[h++]=a,t[h++]=s,t[h++]=0,t[h++]=o,t[h++]=l,t[h++]=0,t[h++]=e[p+6],t[h++]=e[p+7],t[h++]=.5,t[h++]=.5,t[h++]=c,t[h++]=u,t[h++]=f,t[h++]=d,t[h++]=n,t[h++]=i,t[h++]=0,t[h++]=a,t[h++]=s,t[h++]=0,t[h++]=o,t[h++]=l,t[h++]=0):(t[h++]=e[0],t[h++]=e[1],t[h++]=.5,t[h++]=.5,t[h++]=c,t[h++]=u,t[h++]=f,t[h++]=d,t[h++]=n,t[h++]=i,t[h++]=0,t[h++]=a,t[h++]=s,t[h++]=0,t[h++]=o,t[h++]=l,t[h++]=0,t[h++]=e[p],t[h++]=e[p+1],t[h++]=.5,t[h++]=.5,t[h++]=c,t[h++]=u,t[h++]=f,t[h++]=d,t[h++]=n,t[h++]=i,t[h++]=0,t[h++]=a,t[h++]=s,t[h++]=0,t[h++]=o,t[h++]=l,t[h++]=0,t[h++]=e[p+3],t[h++]=e[p+4],t[h++]=.5,t[h++]=.5,t[h++]=c,t[h++]=u,t[h++]=f,t[h++]=d,t[h++]=n,t[h++]=i,t[h++]=0,t[h++]=a,t[h++]=s,t[h++]=0,t[h++]=o,t[h++]=l,t[h++]=0),r+=3}return r},Xe=e=>(e--,e|=e>>1,e|=e>>2,e|=e>>4,e|=e>>8,e|=e>>16,++e);let Ye=new Float32Array(128),Ke=0;const He=e=>{const t=e.length+Ke;if(t>Ye.length){const r=new Float32Array(Xe(t));r.set(Ye),r.set(e,Ke),Ye=r}else Ye.set(e,Ke);Ke+=e.length},Qe=[],Ze=[],Je=()=>{Ze.length=0,Ke=0,Qe.length=0};let et=new Float32Array(32);const tt=(e,t="fill")=>{const r="fill"===t?n.$fillStyle:n.$strokeStyle,i=r[0],a=r[1],s=r[2],o=r[3],l=n.$matrix,c=P,u=S,f=l[0]/c,d=l[3]/c,h=l[6]/c,p=l[1]/u,m=l[4]/u,g=l[7]/u;let b=0;for(let t=0;t<e.length;++t)b+=51*(e[t].length/3-2);const x=(v=b,et.length<v&&(et=new Float32Array(Xe(v))),et);var v;let y=0;for(let t=0;t<e.length;++t)y=qe(e[t],x,y,f,p,d,m,h,g,i,a,s,o);return{buffer:x.subarray(0,b),indexCount:y}},rt=[],nt=(e,t,r)=>{const n={x:t.x-e.x,y:t.y-e.y},i=((e,t,r)=>{const n=Math.sqrt(e*e+t*t);return{x:-t/n*r,y:e/n*r}})(n.x,n.y,r),a={x:e.x+i.x,y:e.y+i.y},s={x:t.x+i.x,y:t.y+i.y},o={x:e.x-i.x,y:e.y-i.y},l={x:t.x-i.x,y:t.y-i.y};return[a.x,a.y,!1,s.x,s.y,!1,l.x,l.y,!1,o.x,o.y,!1,a.x,a.y,!1]},it=(e,t,r)=>({x:e.x+(t.x-e.x)*r,y:e.y+(t.y-e.y)*r}),at=(e,t,r,n=.5)=>{const i=it(e,t,n),a=it(t,r,n),s=it(i,a,n);return[[e,i,s],[s,a,r]]},st=(e,t,r,n)=>({x:(1-e)**2*t.x+2*(1-e)*e*r.x+e**2*n.x,y:(1-e)**2*t.y+2*(1-e)*e*r.y+e**2*n.y}),ot=(e,t,r,n)=>({x:2*(1-e)*(r.x-t.x)+2*e*(n.x-r.x),y:2*(1-e)*(r.y-t.y)+2*e*(n.y-r.y)}),lt=e=>{const t=Math.sqrt(e.x*e.x+e.y*e.y);return 0===t?{x:0,y:0}:{x:e.x/t,y:e.y/t}},ct=(e,t,r,n)=>{const i=[0,.5,1],a=[];for(let s=0;s<i.length;++s){const o=i[s],l=st(o,e,t,r),c=ot(o,e,t,r),u=lt({x:-c.y,y:c.x});a.push({x:l.x+u.x*n,y:l.y+u.y*n})}return a},ut=(e,t,r,n)=>{const i=((e,t,r,n=4)=>{let i=[[e,t,r]];for(let e=0;e<n;++e){const e=[];for(let t=0;t<i.length;++t){const r=i[t];if(!r)continue;const n=at(r[0],r[1],r[2],.5);e.push(n[0],n[1])}i=e}return i})(e,t,r,5),a=[],s=[];for(let e=0;e<i.length;++e){const[t,r,o]=i[e];a.push(ct(t,r,o,+n)),s.push(ct(t,r,o,-n))}const o=a[0][0],l=[o.x,o.y,!1];for(let e=0;e<a.length;++e){const t=a[e];l.push(t[1].x,t[1].y,!0,t[2].x,t[2].y,!1)}const c=[...s].reverse();for(let e=0;e<c.length;++e){const[t,r,n]=c[e];c[e]=[n,r,t]}const u=c[0][0];l.push(u.x,u.y,!1);for(let e=0;e<c.length;++e){const t=c[e];l.push(t[1].x,t[1].y,!0,t[2].x,t[2].y,!1)}return l},ft=(e,t,r,n)=>{const i=[];for(let a=0;a<n.length;a+=3){if(n[a+2])continue;const s=n[a],o=n[a+1],l=Math.sqrt(Math.pow(s-e,2)+Math.pow(o-t,2));Math.abs(l-r)>1e-4||i.push(s,o)}return i},dt=new OffscreenCanvas(1,1).getContext("2d"),ht=(e,t)=>{dt.beginPath(),dt.moveTo(t[0],t[1]);for(let e=3;e<t.length;e+=3)t[e+2]?(dt.quadraticCurveTo(t[e],t[e+1],t[e+3],t[e+4]),e+=3):dt.lineTo(t[e],t[e+1]);dt.closePath();for(let t=0;t<e.length;t+=2){const r=e[t],n=e[t+1];if(!dt.isPointInPath(r,n))return[r,n]}return null},pt=(e,t,r,n,i=!1)=>{const a=i?0:n.length-1,s=i?n.length-1:n.length-2,o=n[a].length>15,l=n[s].length>15;if(o&&l)return;const c=ft(e,t,r,n[a]),u=ft(e,t,r,n[s]),f=ht(c,n[s]);if(!f)return;const d=ht(u,n[a]);if(!d)return;const h=Math.atan2(f[1]-t,f[0]-e);let p=Math.atan2(d[1]-t,d[0]-e)-h;p>Math.PI?p-=2*Math.PI:p<-Math.PI&&(p+=2*Math.PI);const m=Math.abs(p);if(m<.1||m>Math.PI-.1)return;const g=p/8,b=[e,t,!1];for(let n=0;n<=8;n++){const i=h+n*g,a=e+r*Math.cos(i),s=t+r*Math.sin(i);b.push(a,s,!1)}n.splice(-1,0,b)},mt=(e,t,r,n,i=!1)=>{const a=i?0:n.length-1,s=i?n.length-1:n.length-2,o=n[a].length>15,l=n[s].length>15;if(o&&l)return;const c=ft(e,t,r,n[a]),u=ft(e,t,r,n[s]);if(c[0]===u[0]&&c[1]===u[1]||c[0]===u[2]&&c[1]===u[3])return;const f=ht(c,n[s]);if(!f)return;const d=ht(u,n[a]);d&&n.splice(-1,0,[e,t,!1,f[0],f[1],!1,d[0],d[1],!1,e,t,!1])},gt=(e,t,r,n,i,a=!1)=>{const s=a?0:i.length-1,o=a?i.length-1:i.length-2,l=i[s].length>15,c=i[o].length>15;if(l&&c)return;const u=ft(e.x,e.y,n,i[s]),f=ft(e.x,e.y,n,i[o]);if(u[0]===f[0]&&u[1]===f[1]||u[0]===f[2]&&u[1]===f[3])return;const d=ht(u,i[o]);if(!d)return;const h=ht(f,i[s]);if(!h)return;const p=t.x-e.x,m=t.y-e.y,g=Math.hypot(p,m),b={x:p/g,y:m/g},x=r.x-e.x,v=r.y-e.y,y=Math.hypot(x,v),_={x:x/y,y:v/y},w=b.x,M=b.y,P=_.x,S=_.y,F=w*S-M*P;if(0===F)return void i.splice(-1,0,[e.x,e.y,!1,d[0],d[1],!1,h[0],h[1],!1]);const T=((h[0]-d[0])*S-(h[1]-d[1])*P)/F,B=d[0]+T*w,O=d[1]+T*M;i.splice(-1,0,[e.x,e.y,!1,d[0],d[1],!1,B,O,!1,e.x,e.y,!1,h[0],h[1],!1,B,O,!1])},bt={x:0,y:0},xt={x:0,y:0},vt={x:0,y:0},yt={x:0,y:0},_t=(e,t)=>{const r=bt;r.x=e[0],r.y=e[1];const i=xt;i.x=0,i.y=0;const a=vt;a.x=0,a.y=0;const s=yt;s.x=0,s.y=0;const o=[];for(let l=3;l<e.length;l+=3){const c=e[l],u=e[l+1];if(e[l+2])i.x=c,i.y=u;else{if(a.x=c,a.y=u,e[l-1]?o.push(ut(r,i,a,t)):o.push(nt(r,a,t)),o.length>1)switch(n.joints){case 0:mt(r.x,r.y,t,o);break;case 1:s.x=e[l-6],s.y=e[l-5],gt(r,a,s,t,o);break;case 2:pt(r.x,r.y,t,o)}r.x=a.x,r.y=a.y}}const l=e[0],c=e[1],u=e[e.length-3],f=e[e.length-2],d=1e-4;if(Math.abs(l-u)<d&&Math.abs(c-f)<d&&o.length>1)switch(n.joints){case 0:mt(l,c,t,o,!0);break;case 1:r.x=l,r.y=c,a.x=e[3],a.y=e[4],s.x=e[e.length-6],s.y=e[e.length-5],gt(r,a,s,t,o,!0);break;case 2:pt(l,c,t,o,!0)}else switch(n.caps){case 1:((e,t,r)=>{for(let n=0;n<2;++n){let i=0,a=0,s=0,o=0;0===n?(i=e[0],a=e[1],s=e[3],o=e[4]):(i=e[e.length-3],a=e[e.length-2],s=e[e.length-6],o=e[e.length-5]);const l=s-i,c=o-a,u=Math.atan2(c,l),f=u+Math.PI/2,d=u-Math.PI/2,h=16,p=(d-f)/h,m=[];for(let e=0;e<=h;e++){const r=d+p*e,n=i+t*Math.cos(r),s=a+t*Math.sin(r);m.push(n,s,!1)}0===n?r.unshift(m):r.push(m)}})(e,t,o);break;case 2:((e,t,r)=>{for(let n=0;n<2;++n){let i=0,a=0,s=0,o=0;0===n?(i=e[0],a=e[1],s=e[3],o=e[4]):(i=e[e.length-3],a=e[e.length-2],s=e[e.length-6],o=e[e.length-5]);const l=-(s-i),c=-(o-a),u=Math.sqrt(l*l+c*c);if(0===u)continue;const f=l/u,d=c/u,h=i+t*f,p=a+t*d,m=-d,g=[h+t*f+t*m,p+t*d+t*f,!1,h+t*f-t*m,p+t*d-t*f,!1,h-t*f-t*m,p-t*d-t*f,!1,h+t*f+t*m,p+t*d+t*f,!1,h-t*f-t*m,p-t*d-t*f,!1,h-t*f+t*m,p-t*d+t*f,!1];0===n?r.unshift(g):r.push(g)}})(e,t,o)}return o},wt=e=>{const t=n.thickness/2,r=d();for(let n=0;n<e.length;++n){const i=_t(e[n],t);for(let e=0;e<i.length;++e)r.push(i[e])}const i=tt(r,"stroke");return r.length=0,h(r),i},Mt=new Map,Pt=()=>{Mt.clear()},St=()=>({id:"function"==typeof crypto?.randomUUID?crypto.randomUUID():"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g,e=>{const t=16*Math.random()|0;return("x"===e?t:3&t|8).toString(16)}),resource:r.createVertexArray(),vertexBuffer:r.createBuffer(),vertexLength:0});let Ft;const Tt=e=>{Ft&&Ft.id===e.id||(Ft=e,r.bindVertexArray(e.resource))},Bt=[],Ot=new Float32Array([0,0,0,1,1,0,1,1]);let At;let Rt;let Ct;const Et=()=>(Ct||(Ct=(()=>{const e=St();Tt(e),r.bindBuffer(r.ARRAY_BUFFER,e.vertexBuffer);const t=new Float32Array([0,0,1,0,1,1,0,0,1,1,0,1]);return r.bufferData(r.ARRAY_BUFFER,t,r.STATIC_DRAW),r.enableVertexAttribArray(0),r.vertexAttribPointer(0,2,r.FLOAT,!1,0,0),e})()),Ct),Ut=()=>{const e=(()=>{if(Bt.length)return Bt.pop();const e=St();return Tt(e),r.bindBuffer(r.ARRAY_BUFFER,e.vertexBuffer),r.enableVertexAttribArray(0),r.enableVertexAttribArray(1),r.enableVertexAttribArray(2),r.enableVertexAttribArray(3),r.enableVertexAttribArray(4),r.enableVertexAttribArray(5),r.vertexAttribPointer(0,2,r.FLOAT,!1,68,0),r.vertexAttribPointer(1,2,r.FLOAT,!1,68,8),r.vertexAttribPointer(2,4,r.FLOAT,!1,68,16),r.vertexAttribPointer(3,3,r.FLOAT,!1,68,32),r.vertexAttribPointer(4,3,r.FLOAT,!1,68,44),r.vertexAttribPointer(5,3,r.FLOAT,!1,68,56),e})();Tt(e);const t=Ye,n=Ke;return r.bindBuffer(r.ARRAY_BUFFER,e.vertexBuffer),e.vertexLength<t.length&&(e.vertexLength=p(t.length),r.bufferData(r.ARRAY_BUFFER,4*e.vertexLength,r.STREAM_DRAW)),r.bufferSubData(r.ARRAY_BUFFER,0,t.subarray(0,n)),e},$t=e=>{Bt.indexOf(e)>-1||Bt.push(e)};let Gt=0;let kt=-1;class Lt{constructor(e,t,n=!1){Object.defineProperty(this,"_$programObject",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"_$uniformMap",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"highp",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"mediump",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"textures",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this._$programObject=((e,t)=>{const n=r.createProgram(),i=r.createShader(r.VERTEX_SHADER);r.shaderSource(i,e),r.compileShader(i);const a=r.createShader(r.FRAGMENT_SHADER);return r.shaderSource(a,t),r.compileShader(a),r.attachShader(n,i),r.attachShader(n,a),r.linkProgram(n),r.detachShader(n,i),r.detachShader(n,a),r.deleteShader(i),r.deleteShader(a),{id:Gt++,resource:n}})(e,t),this._$uniformMap=new Map,((e,t,n=!1)=>{const i=r.getProgramParameter(e,r.ACTIVE_UNIFORMS);for(let a=0;a<i;++a){const i=r.getActiveUniform(e,a),s=i.name.endsWith("[0]")?i.name.slice(0,-3):i.name,o=r.getUniformLocation(e,s);if(i.type===r.SAMPLER_2D&&1===i.size&&!n)continue;const l={};switch(i.type){case r.FLOAT_VEC4:l.method=r.uniform4fv.bind(r,o),l.array=new Float32Array(4*i.size),l.assign=-1;break;case r.INT_VEC4:l.method=r.uniform4iv.bind(r,o),l.array=new Int32Array(4*i.size),l.assign=-1;break;case r.SAMPLER_2D:l.method=n?r.uniform1i.bind(r,o,3):r.uniform1iv.bind(r,o),l.array=new Int32Array(i.size),l.assign=1;break;case r.FLOAT:case r.FLOAT_VEC2:case r.FLOAT_VEC3:case r.FLOAT_MAT2:case r.FLOAT_MAT3:case r.FLOAT_MAT4:case r.INT:case r.INT_VEC2:case r.INT_VEC3:default:throw new Error("Use gl.FLOAT_VEC4 or gl.INT_VEC4 instead")}t.set(s,l)}})(this._$programObject.resource,this._$uniformMap,n);const i=new Float32Array(0);this.highp=this._$uniformMap.get("u_highp")?.array??i,this.mediump=this._$uniformMap.get("u_mediump")?.array??i,this.textures=this._$uniformMap.get("u_textures")?.array??i}useProgram(){var e;e=this._$programObject,kt!==e.id&&(kt=e.id,r.useProgram(e.resource))}bindUniform(){(e=>{for(const t of e.values())void 0!==t.method&&void 0!==t.assign&&(t.assign<0?t.method(t.array):t.assign>0&&(t.assign--,t.method(t.array)))})(this._$uniformMap)}}const It=new Map,Vt=(e,t,r,n)=>{const i=r?"layout (location = 1) in vec2 a_bezier;":"",a=r?"out vec2 v_bezier;":t?"out vec2 v_uv;":"",s=r?"v_bezier = a_bezier;":t?"\n    mat3 uv_matrix = mat3(\n        u_highp[0].xyz,\n        u_highp[1].xyz,\n        u_highp[2].xyz\n    );\n    mat3 inverse_matrix = mat3(\n        u_highp[3].xyz,\n        u_highp[4].xyz,\n        vec3(u_highp[2].w, u_highp[3].w, u_highp[4].w)\n    );\n    v_uv = (inverse_matrix * uv_matrix * vec3(a_vertex, 1.0)).xy;":"",o=n?(e=>`\nvec2 applyMatrix(in vec2 vertex) {\n    mat3 parent_matrix = mat3(\n        u_highp[${e}].xyz,\n        u_highp[${e+1}].xyz,\n        u_highp[${e+2}].xyz\n    );\n    mat3 ancestor_matrix = mat3(\n        u_highp[${e+3}].xyz,\n        u_highp[${e+4}].xyz,\n        u_highp[${e+5}].xyz\n    );\n\n    vec2 parent_offset = vec2(u_highp[${e+2}].w, u_highp[${e+3}].w);\n    vec2 parent_size   = vec2(u_highp[${e+4}].w, u_highp[${e+5}].w);\n    vec4 grid_min = u_highp[${e+6}];\n    vec4 grid_max = u_highp[${e+7}];\n\n    vec2 position = (parent_matrix * vec3(vertex, 1.0)).xy;\n    position = (position - parent_offset) / parent_size;\n\n    vec4 ga = grid_min;\n    vec4 gb = grid_max  - grid_min;\n    vec4 gc = vec4(1.0) - grid_max;\n\n    vec2 pa = position;\n    vec2 pb = position - grid_min.st;\n    vec2 pc = position - grid_max.st;\n\n    position = (ga.pq / ga.st) * min(pa, ga.st)\n                + (gb.pq / gb.st) * clamp(pb, vec2(0.0), gb.st)\n                + (gc.pq / gc.st) * max(vec2(0.0), pc);\n\n    position = position * parent_size + parent_offset;\n    position = (ancestor_matrix * vec3(position, 1.0)).xy;\n\n    position = position + vec2(u_highp[${e+8}].x, u_highp[${e+8}].y);\n    return position / vec2(u_highp[0].w, u_highp[1].w);\n}`)(t?5:0):"\nvec2 applyMatrix(in vec2 vertex) {\n    mat3 matrix = mat3(a_matrix0, a_matrix1, a_matrix2);\n    return (matrix * vec3(vertex, 1.0)).xy;\n}";return`#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\n${i}\n${r?"":"layout (location = 2) in vec4 a_color;"}\n${n?"":"layout (location = 3) in vec3 a_matrix0;\nlayout (location = 4) in vec3 a_matrix1;\nlayout (location = 5) in vec3 a_matrix2;"}\n\n${e>1?`uniform vec4 u_highp[${e}];`:""}\n${a}\n${r?"":"out vec4 v_color;"}\n${o}\n\nvoid main() {\n    ${r?"":"v_color = a_color;"}\n    ${s}\n    vec2 pos = applyMatrix(a_vertex);\n    pos = pos * 2.0 - 1.0;\n    gl_Position = vec4(pos.x, -pos.y, 0.0, 1.0);\n}`},zt=e=>{const t="m"+(e?"y":"n");if(It.has(t))return It.get(t);const r=new Lt(Vt(e?9:0,!1,!0,e),"#version 300 es\nprecision mediump float;\n\nin vec2 v_bezier;\nout vec4 o_color;\n\nvoid main() {\n    float f_val = v_bezier.x * v_bezier.x - v_bezier.y;\n\n    float dx = dFdx(f_val);\n    float dy = dFdy(f_val);\n\n    float dist = f_val / length(vec2(dx, dy));\n    float alpha = smoothstep(0.5, -0.5, dist);\n\n    if (alpha > 0.001) {\n        o_color = vec4(min(alpha, 1.0));\n    } else {\n        discard;\n    }\n}");return It.set(t,r),r},jt=(e,t)=>{const r=e.highp;r[0]=t[0],r[1]=t[1],r[2]=0,r[4]=t[2],r[5]=t[3],r[6]=0,r[8]=t[4],r[9]=t[5],r[10]=1,r[12]=t[6],r[13]=t[7],r[14]=0,r[16]=t[8],r[17]=t[9],r[18]=0,r[20]=t[10],r[21]=t[11],r[22]=1,r[3]=P,r[7]=S,r[11]=t[12],r[15]=t[13],r[19]=t[14],r[23]=t[15],r[24]=t[16],r[25]=t[17],r[26]=t[18],r[27]=t[19],r[28]=t[20],r[29]=t[21],r[30]=t[22],r[31]=t[23],r[32]=t[24],r[33]=t[25]};let Dt="normal";const Nt=e=>{Dt=e};let Wt=600;const qt=e=>{Wt=e},Xt=()=>{613!==Wt&&(qt(613),r.blendFunc(r.ONE,r.ONE_MINUS_SRC_ALPHA))},Yt=(e,t,n,i)=>{e.useProgram(),e.bindUniform(),Xt(),Tt(t),r.drawArrays(r.TRIANGLES,n,i)},Kt=()=>{const e="rmnn";if(It.has(e))return It.get(e);const t=new Lt("#version 300 es\nlayout (location = 0) in vec2 a_vertex;\nvoid main() {\n    vec2 pos = a_vertex * 2.0 - 1.0;\n    gl_Position = vec4(pos.x, -pos.y, 0.0, 1.0);\n}","#version 300 es\nprecision mediump float;\nout vec4 o_color;\nvoid main() {\n    o_color = vec4(1.0);\n}");return It.set(e,t),t},Ht=()=>{const e=n.currentAttachmentObject;if(!e)return;const t=1<<e.clipLevel-1;r.stencilMask(~t-1),r.stencilFunc(r.LEQUAL,t,255),r.stencilOp(r.ZERO,r.REPLACE,r.REPLACE),Yt(Kt(),Et(),0,6),r.stencilMask(1<<e.clipLevel),r.stencilFunc(r.ALWAYS,0,255),r.stencilOp(r.REPLACE,r.REPLACE,r.REPLACE),Yt(Kt(),Et(),0,6),r.stencilMask(255),r.stencilOp(r.ZERO,r.INVERT,r.INVERT)},Qt=[];class Zt{constructor(e,t,r,n,i){Object.defineProperty(this,"index",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"x",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"y",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"w",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"h",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"left",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"right",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"used",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.index=e,this.x=t,this.y=r,this.w=n,this.h=i,this.left=null,this.right=null,this.used=!1}insert(e,t){return((e,t,r)=>{if(e.used){const n=e.left?.insert(t,r);return n||e.right?.insert(t,r)||null}if(t>e.w||r>e.h)return null;if(t===e.w&&r===e.h)return e.used=!0,e;const n=t+1,i=r+1,a=e.w-n,s=e.h-i;return a>s?(e.left=e.create(e.index,e.x,e.y,t,e.h),e.right=e.create(e.index,e.x+n,e.y,a,e.h)):(e.left=e.create(e.index,e.x,e.y,e.w,r),e.right=e.create(e.index,e.x,e.y+i,e.w,s)),e.used=!0,e.left.insert(t,r)})(this,e,t)}dispose(e,t,r,n){return((e,t,r,n,i)=>e.left?.dispose(t,r,n,i)?(e.left.used||e.right?.used||(e.left&&e.left.release(),e.right&&e.right.release(),e.left=e.right=null,e.used=!1),!0):e.right?.dispose(t,r,n,i)?(e.right.used||e.left?.used||(e.left&&e.left.release(),e.right&&e.right.release(),e.left=e.right=null,e.used=!1),!0):t===e.x&&r===e.y&&n===e.w&&i===e.h&&(e.used=!1,!0))(this,e,t,r,n)}create(e,t,r,n,i){const a=Qt.length?Qt.pop():new Zt(e,0,0,0,0);return a.index=e,a.x=t,a.y=r,a.w=n,a.h=i,a.left=null,a.right=null,a.used=!1,a}release(){this.left&&(this.left.release(),this.left=null),this.right&&(this.right.release(),this.right=null),this.used=!1,Qt.push(this)}}class Jt{constructor(e,t,r){Object.defineProperty(this,"_$root",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this._$root=new Zt(e,0,0,t,r)}insert(e,t){return this._$root.insert(e,t)}dispose(e,t,r,n){return this._$root.dispose(e,t,r,n)}}const er=(t,r)=>{const n=Me;Te[n]||(Te[n]=new Jt(n,e,e));const i=Te[n].insert(t,r);if(i)return i;for(let e=0;e<10;e++){if(n===e)continue;Pe(e);const i=Te[e];if(!i)return er(t,r);const a=i.insert(t,r);if(a)return a}return er(t,r)},tr=e=>`\n    vec4 mul = u_mediump[${e}];\n    vec4 add = u_mediump[${e+1}];\n\n    if (mul.x != 1.0 || mul.y != 1.0 || mul.z != 1.0 || mul.w != 1.0\n        || add.x != 0.0 || add.y != 0.0 || add.z != 0.0\n    ) {\n        src.rgb /= max(0.0001, src.a);\n        src = clamp(src * mul + add, 0.0, 1.0);\n        src.rgb *= src.a;\n    }\n`,rr=e=>`#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_texture;\n${e?"uniform vec4 u_mediump[2];":""}\n\nin vec2 v_coord;\nout vec4 o_color;\n\nvoid main() {\n    vec4 src = texture(u_texture, v_coord);\n    ${e?tr(0):""}\n    o_color = src;\n}`;const nr=new class{constructor(){Object.defineProperty(this,"buffer",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"offset",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.buffer=new Float32Array(256),this.offset=0}push(...e){this.buffer.length<this.offset+e.length&&this.resize(e.length);for(let t=0;t<e.length;t++)this.buffer[this.offset++]=e[t]}pushDisplayObjectBuffer(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g,b,x,v,y,_){this.buffer.length<this.offset+22&&this.resize(22),this.buffer[this.offset++]=e,this.buffer[this.offset++]=t,this.buffer[this.offset++]=r,this.buffer[this.offset++]=n,this.buffer[this.offset++]=i,this.buffer[this.offset++]=a,this.buffer[this.offset++]=s,this.buffer[this.offset++]=o,this.buffer[this.offset++]=l,this.buffer[this.offset++]=c,this.buffer[this.offset++]=u,this.buffer[this.offset++]=f,this.buffer[this.offset++]=d,this.buffer[this.offset++]=h,this.buffer[this.offset++]=p,this.buffer[this.offset++]=m,this.buffer[this.offset++]=g,this.buffer[this.offset++]=b,this.buffer[this.offset++]=x,this.buffer[this.offset++]=v,this.buffer[this.offset++]=y,this.buffer[this.offset++]=_}pushInstanceBuffer(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g,b,x,v,y,_,w,M){this.buffer.length<this.offset+24&&this.resize(24),this.buffer[this.offset++]=e,this.buffer[this.offset++]=t,this.buffer[this.offset++]=r,this.buffer[this.offset++]=n,this.buffer[this.offset++]=i,this.buffer[this.offset++]=a,this.buffer[this.offset++]=s,this.buffer[this.offset++]=o,this.buffer[this.offset++]=l,this.buffer[this.offset++]=c,this.buffer[this.offset++]=u,this.buffer[this.offset++]=f,this.buffer[this.offset++]=d,this.buffer[this.offset++]=h,this.buffer[this.offset++]=p,this.buffer[this.offset++]=m,this.buffer[this.offset++]=g,this.buffer[this.offset++]=b,this.buffer[this.offset++]=x,this.buffer[this.offset++]=v,this.buffer[this.offset++]=y,this.buffer[this.offset++]=_,this.buffer[this.offset++]=w,this.buffer[this.offset++]=M}pushShapeBuffer(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g,b,x,v,y,_,w,M,P,S,F,T,B,O,A,R){this.buffer.length<this.offset+32&&this.resize(32),this.buffer[this.offset++]=e,this.buffer[this.offset++]=t,this.buffer[this.offset++]=r,this.buffer[this.offset++]=n,this.buffer[this.offset++]=i,this.buffer[this.offset++]=a,this.buffer[this.offset++]=s,this.buffer[this.offset++]=o,this.buffer[this.offset++]=l,this.buffer[this.offset++]=c,this.buffer[this.offset++]=u,this.buffer[this.offset++]=f,this.buffer[this.offset++]=d,this.buffer[this.offset++]=h,this.buffer[this.offset++]=p,this.buffer[this.offset++]=m,this.buffer[this.offset++]=g,this.buffer[this.offset++]=b,this.buffer[this.offset++]=x,this.buffer[this.offset++]=v,this.buffer[this.offset++]=y,this.buffer[this.offset++]=_,this.buffer[this.offset++]=w,this.buffer[this.offset++]=M,this.buffer[this.offset++]=P,this.buffer[this.offset++]=S,this.buffer[this.offset++]=F,this.buffer[this.offset++]=T,this.buffer[this.offset++]=B,this.buffer[this.offset++]=O,this.buffer[this.offset++]=A,this.buffer[this.offset++]=R}pushTextFieldBuffer(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g,b,x,v,y,_,w,M,P,S,F,T,B,O){this.buffer.length<this.offset+30&&this.resize(30),this.buffer[this.offset++]=e,this.buffer[this.offset++]=t,this.buffer[this.offset++]=r,this.buffer[this.offset++]=n,this.buffer[this.offset++]=i,this.buffer[this.offset++]=a,this.buffer[this.offset++]=s,this.buffer[this.offset++]=o,this.buffer[this.offset++]=l,this.buffer[this.offset++]=c,this.buffer[this.offset++]=u,this.buffer[this.offset++]=f,this.buffer[this.offset++]=d,this.buffer[this.offset++]=h,this.buffer[this.offset++]=p,this.buffer[this.offset++]=m,this.buffer[this.offset++]=g,this.buffer[this.offset++]=b,this.buffer[this.offset++]=x,this.buffer[this.offset++]=v,this.buffer[this.offset++]=y,this.buffer[this.offset++]=_,this.buffer[this.offset++]=w,this.buffer[this.offset++]=M,this.buffer[this.offset++]=P,this.buffer[this.offset++]=S,this.buffer[this.offset++]=F,this.buffer[this.offset++]=T,this.buffer[this.offset++]=B,this.buffer[this.offset++]=O}pushVideoBuffer(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g,b,x,v,y,_,w,M,P,S,F){this.buffer.length<this.offset+27&&this.resize(27),this.buffer[this.offset++]=e,this.buffer[this.offset++]=t,this.buffer[this.offset++]=r,this.buffer[this.offset++]=n,this.buffer[this.offset++]=i,this.buffer[this.offset++]=a,this.buffer[this.offset++]=s,this.buffer[this.offset++]=o,this.buffer[this.offset++]=l,this.buffer[this.offset++]=c,this.buffer[this.offset++]=u,this.buffer[this.offset++]=f,this.buffer[this.offset++]=d,this.buffer[this.offset++]=h,this.buffer[this.offset++]=p,this.buffer[this.offset++]=m,this.buffer[this.offset++]=g,this.buffer[this.offset++]=b,this.buffer[this.offset++]=x,this.buffer[this.offset++]=v,this.buffer[this.offset++]=y,this.buffer[this.offset++]=_,this.buffer[this.offset++]=w,this.buffer[this.offset++]=M,this.buffer[this.offset++]=P,this.buffer[this.offset++]=S,this.buffer[this.offset++]=F}set(e){this.buffer.length<this.offset+e.length&&this.resize(e.length),this.buffer.set(e,this.offset),this.offset+=e.length}resize(e){const t=new Float32Array((r=this.offset+e,r--,r|=r>>1,r|=r>>2,r|=r>>4,r|=r>>8,r|=r>>16,++r));var r;this.buffer.length&&t.set(this.buffer),this.buffer=t}};let ir=class extends Lt{constructor(e,t,r=!0){super(e,t,r),Object.defineProperty(this,"count",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.count=0}clear(){this.count=nr.offset=0}};const ar=new Map,sr=()=>{if(ar.has("i"))return ar.get("i");const e=new ir("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\nlayout (location = 1) in vec4 a_rect;\nlayout (location = 2) in vec4 a_size;\nlayout (location = 3) in vec2 a_offset;\nlayout (location = 4) in vec4 a_matrix;\nlayout (location = 5) in vec4 a_mul;\nlayout (location = 6) in vec4 a_add;\n\nout vec2 v_coord;\nout vec4 v_mul;\nout vec4 v_add;\n\nvoid main() {\n    v_coord = a_vertex * a_rect.zw + a_rect.xy;\n    v_mul = a_mul;\n    v_add = a_add;\n\n    vec2 position = vec2(a_vertex.x, 1.0 - a_vertex.y);\n    position = position * a_size.xy;\n\n    mat3 matrix = mat3(\n        a_matrix.x, a_matrix.y, 0.0,\n        a_matrix.z, a_matrix.w, 0.0,\n        a_offset.x, a_offset.y, 1.0\n    );\n\n    position = (matrix * vec3(position, 1.0)).xy;\n    position /= a_size.zw;\n\n    position = position * 2.0 - 1.0;\n    gl_Position = vec4(position.x, -position.y, 0.0, 1.0);\n}","#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_texture;\n\nin vec4 v_mul;\nin vec4 v_add;\nin vec2 v_coord;\nout vec4 o_color;\n\nvoid main() {\n    vec4 src = texture(u_texture, v_coord);\n\n    if (v_mul.x != 1.0 || v_mul.y != 1.0 || v_mul.z != 1.0 || v_mul.w != 1.0\n        || v_add.x != 0.0 || v_add.y != 0.0 || v_add.z != 0.0\n    ) {\n        src.rgb /= max(0.0001, src.a);\n        src = clamp(src * v_mul + v_add, 0.0, 1.0);\n        src.rgb *= src.a;\n    }\n\n    o_color = src;\n}");return ar.set("i",e),e},or=(e,t)=>{const r=`i${e}y`;if(ar.has(r))return ar.get(r);const n=new Lt("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\n\nout vec2 v_coord;\n\nvoid main() {\n    v_coord = a_vertex;\n\n    vec2 position = a_vertex * 2.0 - 1.0;\n    gl_Position = vec4(position, 0.0, 1.0);\n}",(e=>{let t;switch(e){case"subtract":t="\nvec4 blend (in vec4 src, in vec4 dst) {\n    if (src.a == 0.0) { return dst; }\n    if (dst.a == 0.0) { return src; }\n\n    vec4 a = src - src * dst.a;\n    vec4 b = dst - dst * src.a;\n\n    src.rgb /= src.a;\n    dst.rgb /= dst.a;\n\n    vec4 c = vec4(dst.rgb - src.rgb, src.a * dst.a);\n    c.rgb *= c.a;\n\n    return a + b + c;\n}";break;case"multiply":t="\nvec4 blend (in vec4 src, in vec4 dst) {\n    vec4 a = src - src * dst.a;\n    vec4 b = dst - dst * src.a;\n    vec4 c = src * dst;\n\n    return a + b + c;\n}";break;case"lighten":t="\nvec4 blend (in vec4 src, in vec4 dst) {\n    if (src.a == 0.0) { return dst; }\n    if (dst.a == 0.0) { return src; }\n\n    vec4 a = src - src * dst.a;\n    vec4 b = dst - dst * src.a;\n\n    src.rgb /= src.a;\n    dst.rgb /= dst.a;\n\n    vec4 c = vec4(mix(src.rgb, dst.rgb, step(src.rgb, dst.rgb)), src.a * dst.a);\n    c.rgb *= c.a;\n\n    return a + b + c;\n}";break;case"darken":t="\nvec4 blend (in vec4 src, in vec4 dst) {\n    if (src.a == 0.0) { return dst; }\n    if (dst.a == 0.0) { return src; }\n\n    vec4 a = src - src * dst.a;\n    vec4 b = dst - dst * src.a;\n\n    src.rgb /= src.a;\n    dst.rgb /= dst.a;\n\n    vec4 c = vec4(mix(src.rgb, dst.rgb, step(dst.rgb, src.rgb)), src.a * dst.a);\n    c.rgb *= c.a;\n\n    return a + b + c;\n}";break;case"overlay":t="\nvec4 blend (in vec4 src, in vec4 dst) {\n    if (src.a == 0.0) { return dst; }\n    if (dst.a == 0.0) { return src; }\n\n    vec4 a = src - src * dst.a;\n    vec4 b = dst - dst * src.a;\n\n    src.rgb /= src.a;\n    dst.rgb /= dst.a;\n\n    vec4 mul = src * dst;\n    vec3 c1 = 2.0 * mul.rgb;\n    vec3 c2 = 2.0 * (src.rgb + dst.rgb - mul.rgb) - 1.0;\n    vec4 c = vec4(mix(c1, c2, step(vec3(0.5), dst.rgb)), mul.a);\n    c.rgb *= c.a;\n\n    return a + b + c;\n}";break;case"hardlight":t="\nvec4 blend (in vec4 src, in vec4 dst) {\n    if (src.a == 0.0) { return dst; }\n    if (dst.a == 0.0) { return src; }\n\n    vec4 a = src - src * dst.a;\n    vec4 b = dst - dst * src.a;\n\n    src.rgb /= src.a;\n    dst.rgb /= dst.a;\n\n    vec4 mul = src * dst;\n    vec3 c1 = 2.0 * mul.rgb;\n    vec3 c2 = 2.0 * (src.rgb + dst.rgb - mul.rgb) - 1.0;\n    vec4 c = vec4(mix(c1, c2, step(vec3(0.5), src.rgb)), mul.a);\n    c.rgb *= c.a;\n\n    return a + b + c;\n}";break;case"difference":t="\nvec4 blend (in vec4 src, in vec4 dst) {\n    if (src.a == 0.0) { return dst; }\n    if (dst.a == 0.0) { return src; }\n\n    vec4 a = src - src * dst.a;\n    vec4 b = dst - dst * src.a;\n\n    src.rgb /= src.a;\n    dst.rgb /= dst.a;\n\n    vec4 c = vec4(abs(src.rgb - dst.rgb), src.a * dst.a);\n    c.rgb *= c.a;\n\n    return a + b + c;\n}";break;case"invert":t="\nvec4 blend (in vec4 src, in vec4 dst) {\n    if (src.a == 0.0) { return dst; }\n    if (dst.a == 0.0) { return src; }\n\n    vec4 b = dst - dst * src.a;\n    vec4 c = vec4(src.a - dst.rgb * src.a, src.a);\n\n    return b + c;\n}";break;default:t="\nvec4 blend (in vec4 src, in vec4 dst) {\n    return src + dst - dst * src.a;\n}"}return`#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_textures[2];\nuniform vec4 u_mediump[2];\n\nin vec2 v_coord;\nout vec4 o_color;\n\n${t}\n\nvoid main() {\n    vec4 dst = texture(u_textures[0], v_coord);\n    vec4 src = texture(u_textures[1], v_coord);\n    ${tr(0)}\n    o_color = blend(src, dst);\n}`})(e));return ar.set(r,n),n},lr=()=>{if(!n.newDrawState)return;const e=n.currentAttachmentObject,t=n.atlasAttachmentObject;n.bind(t),r.bindFramebuffer(r.DRAW_FRAMEBUFFER,ee),ie(!1);const i=Re(Me);a(),r.scissor(i[0],i[1],i[2]-i[0],i[3]-i[1]),r.blitFramebuffer(0,0,t.width,t.height,0,0,t.width,t.height,r.COLOR_BUFFER_BIT,r.NEAREST),s(),e&&n.bind(e),n.newDrawState=!1},cr=e=>{const t=Me;Pe(e.index),lr(),r.bindFramebuffer(r.FRAMEBUFFER,ae);const n=Oe();r.framebufferTexture2D(r.FRAMEBUFFER,r.COLOR_ATTACHMENT0,r.TEXTURE_2D,n.resource,0),r.bindFramebuffer(r.FRAMEBUFFER,se);const i=ve(e.w,e.h);return r.framebufferTexture2D(r.FRAMEBUFFER,r.COLOR_ATTACHMENT0,r.TEXTURE_2D,i.resource,0),r.bindFramebuffer(r.FRAMEBUFFER,null),r.bindFramebuffer(r.READ_FRAMEBUFFER,ae),r.bindFramebuffer(r.DRAW_FRAMEBUFFER,se),r.blitFramebuffer(e.x,e.y,e.x+e.w,e.y+e.h,0,0,e.w,e.h,r.COLOR_BUFFER_BIT,r.NEAREST),Pe(t),r.bindFramebuffer(r.READ_FRAMEBUFFER,Z),r.bindFramebuffer(r.FRAMEBUFFER,Z),i},ur=(e,t,n=!1)=>{Ge(2,r.TEXTURE2,null,n),Ge(1,r.TEXTURE1,t,n),Ge(0,r.TEXTURE0,e,n)},fr=()=>{if(ar.has("p"))return ar.get("p");const e=new Lt("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\nuniform vec4 u_highp[2];\n\nout vec2 v_coord;\n\nvoid main() {\n    v_coord = a_vertex;\n\n    vec2 offset   = u_highp[0].xy;\n    vec2 size     = u_highp[0].zw;\n    vec2 viewport = vec2(u_highp[1].x, u_highp[1].y);\n\n    vec2 position = vec2(a_vertex.x, 1.0 - a_vertex.y);\n    position = position * size + offset;\n    position /= viewport;\n\n    position = position * 2.0 - 1.0;\n    gl_Position = vec4(position.x, -position.y, 0.0, 1.0);\n}",rr(!1));return ar.set("p",e),e},dr=(e,t,r)=>{const i=e.highp,a=n.$matrix;i[0]=a[6],i[1]=a[7],i[2]=t,i[3]=r,i[4]=P,i[5]=S},hr=e=>{e.useProgram(),e.bindUniform(),Tt(Et()),r.drawArrays(r.TRIANGLES,0,6)};let pr=null;const mr=(e,t,i,o)=>{const l=n.currentAttachmentObject,c=n.$mainAttachmentObject;return n.bind(c),r.bindFramebuffer(r.FRAMEBUFFER,se),pr&&pr.width===c.width&&pr.height===c.height||(pr=ve(c.width,c.height)),ke(pr),r.framebufferTexture2D(r.FRAMEBUFFER,r.COLOR_ATTACHMENT0,r.TEXTURE_2D,pr.resource,0),r.bindFramebuffer(r.FRAMEBUFFER,null),r.bindFramebuffer(r.READ_FRAMEBUFFER,Z),r.bindFramebuffer(r.DRAW_FRAMEBUFFER,se),a(),r.scissor(e,c.height-t-o,i+1,o+1),r.blitFramebuffer(0,0,c.width,c.height,0,0,c.width,c.height,r.COLOR_BUFFER_BIT,r.NEAREST),s(),r.bindFramebuffer(r.FRAMEBUFFER,Z),l&&n.bind(l),pr},gr=(e,t,r,i)=>{const a=n.currentAttachmentObject,s=mr(e,t,r,i),o=ye(r,i,!1);n.bind(o),n.save(),n.setTransform(1,0,0,1,-e,-t);const l=fr();dr(l,s.width,s.height),Xt(),ke(s),hr(l);const c=o.texture;return n.restore(),ce(o,!1),a&&n.bind(a),c},br=()=>{610!==Wt&&(qt(610),r.blendFunc(r.ONE,r.ZERO))},xr=e=>{ke(e),br();const t=fr();dr(t,e.width,e.height),hr(t),Xt()},vr=(e,t,r,n,i,a,s,o,l)=>{const c=e.textures;c[0]=0,c[1]=1;const u=e.mediump;u[0]=t,u[1]=r,u[2]=n,u[3]=i,u[4]=a,u[5]=s,u[6]=o,u[7]=l},yr=(e=!1)=>{const t="m"+(e?"y":"n");if(ar.has(t))return ar.get(t);const r=new Lt("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\nuniform vec4 u_highp[3];\n\nout vec2 v_coord;\n\nvoid main() {\n    v_coord = a_vertex;\n\n    mat3 matrix = mat3(\n        u_highp[0].x, u_highp[0].y, 0.0,\n        u_highp[0].z, u_highp[0].w, 0.0,\n        u_highp[1].x, u_highp[1].y, 1.0\n    );\n\n    vec2 size     = u_highp[1].zw;\n    vec2 viewport = vec2(u_highp[2].x, u_highp[2].y);\n\n    vec2 position = vec2(a_vertex.x, 1.0 - a_vertex.y);\n    position = position * size;\n    position = (matrix * vec3(position, 1.0)).xy;\n    position /= viewport;\n\n    position = position * 2.0 - 1.0;\n    gl_Position = vec4(position.x, -position.y, 0.0, 1.0);\n}",rr(e));return ar.set(t,r),r},_r=(e,t,r)=>{const i=e.highp,a=n.$matrix;i[0]=a[0],i[1]=a[1],i[2]=a[3],i[3]=a[4],i[4]=a[6],i[5]=a[7],i[6]=t,i[7]=r,i[8]=P,i[9]=S};let wr=0;const Mr=e=>{e.useProgram(),e.bindUniform(),Tt(Rt),r.bindBuffer(r.ARRAY_BUFFER,At),nr.buffer.length>wr&&(wr=nr.buffer.length,r.bufferData(r.ARRAY_BUFFER,4*wr,r.STREAM_DRAW)),r.bufferSubData(r.ARRAY_BUFFER,0,nr.buffer,0,nr.offset),r.drawArraysInstanced(r.TRIANGLES,0,6,e.count)},Pr=()=>{603!==Wt&&(qt(603),r.blendFunc(r.ZERO,r.ONE_MINUS_SRC_ALPHA))},Sr=e=>{switch(e){case"add":611!==Wt&&(qt(611),r.blendFunc(r.ONE,r.ONE));break;case"screen":641!==Wt&&(qt(641),r.blendFunc(r.ONE_MINUS_DST_COLOR,r.ONE));break;case"alpha":606!==Wt&&(qt(606),r.blendFunc(r.ZERO,r.SRC_ALPHA));break;case"erase":Pr();break;case"copy":br();break;default:Xt()}},Fr=e=>{var t;(e=>{At=e.createBuffer()})(e),t=(()=>{const e=St();return Tt(e),r.bindBuffer(r.ARRAY_BUFFER,e.vertexBuffer),r.bufferData(r.ARRAY_BUFFER,new Float32Array([0,0,1,0,1,1,0,0,1,1,0,1]),r.STATIC_DRAW),r.enableVertexAttribArray(0),r.vertexAttribPointer(0,2,r.FLOAT,!1,0,0),r.bindBuffer(r.ARRAY_BUFFER,At),r.bufferData(r.ARRAY_BUFFER,nr.buffer.length,r.STREAM_DRAW),r.enableVertexAttribArray(1),r.vertexAttribPointer(1,4,r.FLOAT,!1,88,0),r.vertexAttribDivisor(1,1),r.enableVertexAttribArray(2),r.vertexAttribPointer(2,4,r.FLOAT,!1,88,16),r.vertexAttribDivisor(2,1),r.enableVertexAttribArray(3),r.vertexAttribPointer(3,2,r.FLOAT,!1,88,32),r.vertexAttribDivisor(3,1),r.enableVertexAttribArray(4),r.vertexAttribPointer(4,4,r.FLOAT,!1,88,40),r.vertexAttribDivisor(4,1),r.enableVertexAttribArray(5),r.vertexAttribPointer(5,4,r.FLOAT,!1,88,56),r.vertexAttribDivisor(5,1),r.enableVertexAttribArray(6),r.vertexAttribPointer(6,4,r.FLOAT,!1,88,72),r.vertexAttribDivisor(6,1),e})(),Rt=t},Tr=(e,t,n,i=!1)=>{const a=ve(e,t,i);return r.texSubImage2D(r.TEXTURE_2D,0,0,0,e,t,r.RGBA,r.UNSIGNED_BYTE,n),a},Br=(e,t)=>{const n=((e,t,n,i=!1)=>{const a=ve(e,t,i);return r.texSubImage2D(r.TEXTURE_2D,0,0,0,r.RGBA,r.UNSIGNED_BYTE,n),a})(e.w,e.h,t),i=fr();dr(i,e.w,e.h),Xt(),hr(i),K(n)},Or=[],Ar=new Map,Rr=(e,t,r)=>{ke(e,!0);const n=Math.ceil(.5*r),i=1-(n-.5*r),a=1+r,s=(e=>{const t=`b${e}`;if(Ar.has(t))return Ar.get(t);const r=new Lt("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\n\nout vec2 v_coord;\n\nvoid main() {\n    v_coord = a_vertex;\n\n    vec2 position = a_vertex * 2.0 - 1.0;\n    gl_Position = vec4(position, 0.0, 1.0);\n}",(e=>{const t=e.toFixed(1);return`#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_texture;\nuniform vec4 u_mediump;\n\nin vec2 v_coord;\nout vec4 o_color;\n\nvoid main() {\n    vec2  offset   = u_mediump.xy;\n    float fraction = u_mediump.z;\n    float samples  = u_mediump.w;\n    \n    vec4 color = texture(u_texture, v_coord);\n\n    for (float i = 1.0; i < ${t}; i += 1.0) {\n        color += texture(u_texture, v_coord + offset * i);\n        color += texture(u_texture, v_coord - offset * i);\n    }\n    color += texture(u_texture, v_coord + offset * ${t}) * fraction;\n    color += texture(u_texture, v_coord - offset * ${t}) * fraction;\n    color /= samples;\n\n    o_color = color;\n}`})(e));return Ar.set(t,r),r})(n);((e,t,r,n,i,a)=>{const s=e.mediump;n?(s[0]=1/t,s[1]=0):(s[0]=0,s[1]=1/r),s[2]=i,s[3]=a})(s,e.width,e.height,t,i,a),hr(s)},Cr={x:0,y:0},Er=(e,t,r)=>(e>>16)*(r?t:1)/255,Ur=(e,t,r)=>(e>>8&255)*(r?t:1)/255,$r=(e,t,r)=>(255&e)*(r?t:1)/255,Gr=[.5,1.05,1.4,1.55,1.75,1.9,2,2.15,2.2,2.3,2.5,3,3,3.5,3.5],kr=(e,t,r=4,i=4,a=1,s=!0)=>{const o=n.currentAttachmentObject,l=Math.sqrt(t[0]*t[0]+t[1]*t[1]),c=Math.sqrt(t[2]*t[2]+t[3]*t[3]),u=r*(l/F),f=i*(c/F),d=Gr[a-1],h=Math.round(u*d),p=Math.round(f*d);Cr.x+=h,Cr.y+=p;const m=e.width+2*h,g=e.height+2*p;let b=1,x=1;u>128?b=.0625:u>64?b=.125:u>32?b=.25:u>16&&(b=.5),f>128?x=.0625:f>64?x=.125:f>32?x=.25:f>16&&(x=.5);const v=Math.ceil(m*b),y=Math.ceil(g*x),_=ye(v,y,!1),w=[_,ye(v,y,!1)];n.bind(_),n.reset(),n.setTransform(b,0,0,x,h*b,p*x),ke(e);const M=yr();_r(M,e.width,e.height),hr(M),s&&K(e);const P=u*b,S=f*x;let T=0,B=_.texture;ke(B,!0),br();for(let e=0;e<a;++e){if(r>0){T=(T+1)%2;const e=w[T];n.bind(e),Rr(B,!0,P),B=e.texture}if(i>0){T=(T+1)%2;const e=w[T];n.bind(e),Rr(B,!1,S),B=e.texture}}if(Xt(),1!==b||1!==x){const e=ye(m,g,!1);n.bind(e),n.setTransform(1/b,0,0,1/x,0,0),ke(B,!0),_r(M,B.width,B.height),hr(M),B=e.texture,ce(w[0]),ce(w[1]),ce(e,!1)}else T=(T+1)%2,ce(w[T]),T=(T+1)%2,ce(w[T],!1);return o&&n.bind(o),B},Lr=(e,t)=>{const r=n.currentAttachmentObject,i=ye(e.width,e.height,!1);n.bind(i),n.reset(),n.setTransform(1,0,0,1,0,0),ke(e),Xt();const a=(()=>{if(Ar.has("m"))return Ar.get("m");const e=new Lt("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\n\nout vec2 v_coord;\n\nvoid main() {\n    v_coord = a_vertex;\n\n    vec2 position = a_vertex * 2.0 - 1.0;\n    gl_Position = vec4(position, 0.0, 1.0);\n}","#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_texture;\nuniform vec4 u_mediump[5];\n\nin vec2 v_coord;\nout vec4 o_color;\n\nvoid main() {\n    mat4 mul = mat4(u_mediump[0], u_mediump[1], u_mediump[2], u_mediump[3]);\n    vec4 add = u_mediump[4];\n    \n    vec4 color = texture(u_texture, v_coord);\n\n    color.rgb /= max(0.0001, color.a);\n    color = clamp(color * mul + add, 0.0, 1.0);\n    color.rgb *= color.a;\n\n    o_color = color;\n}");return Ar.set("m",e),e})();((e,t)=>{const r=e.mediump;r[0]=t[0],r[1]=t[1],r[2]=t[2],r[3]=t[3],r[4]=t[5],r[5]=t[6],r[6]=t[7],r[7]=t[8],r[8]=t[10],r[9]=t[11],r[10]=t[12],r[11]=t[13],r[12]=t[15],r[13]=t[16],r[14]=t[17],r[15]=t[18],r[16]=t[4]/255,r[17]=t[9]/255,r[18]=t[14]/255,r[19]=t[19]/255})(a,t),hr(a);const s=i.texture;return K(e),ce(i,!1),r&&n.bind(r),s},Ir=(e,t,r,n,i,a)=>{const s=e?"blur.a = 1.0 - blur.a;":"",o=r?(l=a,`\n    float strength = u_mediump[${Math.floor(l/4)}][${l%4}];\n    blur.a = clamp(blur.a * strength, 0.0, 1.0);\n`):"";var l;const c=n?(e=>`\n    blur = texture(u_textures[${e?2:1}], vec2(blur.a, 0.5));\n`)(t):(e=>`\n    vec4 color = u_mediump[${e}];\n    blur = color * blur.a;\n`)(i);return`\n    ${s}\n    ${o}\n    ${c}\n`},Vr=(e,t,r,n,i,a)=>{const s=t?"\n    vec2 pq = (1.0 - v_coord) * blur_scale - blur_offset;\n    vec4 blur2 = mix(vec4(0.0), texture(u_textures[0], pq), isInside(pq));\n":"\n    vec4 blur2 = texture(u_textures[0], 1.0 - v_coord);\n",o=r?(l=a,`\n    float strength = u_mediump[${Math.floor(l/4)}][${l%4}];\n    highlight_alpha *= strength;\n    shadow_alpha    *= strength;\n`):"";var l;const c=n?(e=>`\n    blur = texture(u_textures[${e?2:1}], vec2(\n        0.5019607843137255 - 0.5019607843137255 * shadow_alpha + 0.4980392156862745 * highlight_alpha,\n        0.5\n    ));\n`)(e):(e=>`\n    vec4 highlight_color = u_mediump[${e}];\n    vec4 shadow_color    = u_mediump[${e+1}];\n    blur = highlight_color * highlight_alpha + shadow_color * shadow_alpha;\n`)(i);return`\n    ${s}\n    float highlight_alpha = blur.a - blur2.a;\n    float shadow_alpha    = blur2.a - blur.a;\n    ${o}\n    highlight_alpha = clamp(highlight_alpha, 0.0, 1.0);\n    shadow_alpha    = clamp(shadow_alpha, 0.0, 1.0);\n    ${c}\n`},zr=(e,t,r,n,i,a,s)=>{const o=`f${e?"y":"n"}${t?"y":"n"}${r?"y":"n"}${n}${i?"y":"n"}${a?"y":"n"}${s?"y":"n"}`;if(Ar.has(o))return Ar.get(o);let l=1;e&&l++,s&&l++;let c=(e?4:0)+(t?4:0)+(a?1:0);s||(c+=r?4:8),c=Math.ceil(c/4);const u=new Lt("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\n\nout vec2 v_coord;\n\nvoid main() {\n    v_coord = a_vertex;\n\n    vec2 position = a_vertex * 2.0 - 1.0;\n    gl_Position = vec4(position, 0.0, 1.0);\n}",((e,t,r,n,i,a,s,o,l)=>{let c=0;const u=r?(e=>`\n    vec2 base_scale  = u_mediump[${e}].xy;\n    vec2 base_offset = u_mediump[${e}].zw;\n\n    vec2 uv = v_coord * base_scale - base_offset;\n    vec4 base = mix(vec4(0.0), texture(u_textures[1], uv), isInside(uv));\n`)(c++):"",f=n?(e=>`\n    vec2 blur_scale  = u_mediump[${e}].xy;\n    vec2 blur_offset = u_mediump[${e}].zw;\n\n    vec2 st = v_coord * blur_scale - blur_offset;\n    vec4 blur = mix(vec4(0.0), texture(u_textures[0], st), isInside(st));\n`)(c++):"\n    vec4 blur = texture(u_textures[0], v_coord);\n",d="inner"===a,h=c;let p,m,g=4*c;switch(l?p=i?Ir(!1,r,o,l,h,g):Vr(r,n,o,l,h,g):i?(g+=4,p=Ir(d,r,o,l,h,g)):(g+=8,p=Vr(r,n,o,l,h,g)),a){case"outer":m=s?"blur - blur * base.a":"base + blur - blur * base.a";break;case"full":m=s?"blur":"base - base * blur.a + blur";break;default:m="blur"}return`#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_textures[${e}];\nuniform vec4 u_mediump[${t}];\n\nin vec2 v_coord;\nout vec4 o_color;\n\n\nfloat isInside(in vec2 uv) {\n    return step(4.0, dot(step(vec4(0.0, uv.x, 0.0, uv.y), vec4(uv.x, 1.0, uv.y, 1.0)), vec4(1.0)));\n}\n\nvoid main() {\n    ${u}\n    ${f}\n    ${p}\n    o_color = ${m};\n}`})(l,c,e,t,r,n,i,a,s));return Ar.set(o,u),u},jr=new Map,Dr=[],Nr=(e,t)=>{const r=`l${("00"+e).slice(-3)}${t?"y":"n"}`,n=(e=>{const t=jr.get(e);if(t){const t=Dr.indexOf(e);-1!==t&&(Dr.splice(t,1),Dr.push(e))}return t})(r);if(n)return n;const i=Math.ceil(5*e/4),a=new Lt("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\n\nout vec2 v_coord;\n\nvoid main() {\n    v_coord = a_vertex;\n\n    vec2 position = a_vertex * 2.0 - 1.0;\n    gl_Position = vec4(position, 0.0, 1.0);\n}",((e,t,r)=>{let n="";for(let e=1;e<t;++e){const r=e-1,i=e,a=`u_mediump[${t+Math.floor(r/4)}][${r%4}]`,s=`u_mediump[${t+Math.floor(i/4)}][${i%4}]`;n+=`\n    if (t <= ${s}) {\n        return mix(u_mediump[${r}], u_mediump[${i}], (t - ${a}) / (${s} - ${a}));\n    }\n`}return`#version 300 es\nprecision mediump float;\n\nuniform vec4 u_mediump[${e}];\n\nin vec2 v_coord;\nout vec4 o_color;\n\nvec4 getGradientColor(in float t) {\n    if (t <= u_mediump[${t}][0]) {\n        return u_mediump[0];\n    }\n    ${n}\n    return u_mediump[${t-1}];\n}\n\nvoid main() {\n    vec4 color = getGradientColor(v_coord.x);\n    ${r?"color = pow(color, vec4(0.45454545));":""}\n    color.rgb *= color.a;\n\n    o_color = color;\n}`})(i,e,t));return((e,t)=>{const r=Dr.indexOf(e);for(-1!==r&&Dr.splice(r,1);jr.size>=16&&Dr.length>0;){const e=Dr.shift();e&&jr.delete(e)}jr.set(e,t),Dr.push(e)})(r,a),a},Wr=(e,t,r,n,i,a)=>{const s=e.mediump;let o=0;for(let e=i;e<a;e++){const t=r[e];s[o++]=(t>>16)/255,s[o++]=(t>>8&255)/255,s[o++]=(255&t)/255,s[o++]=n[e]}for(let e=i;e<a;e++)s[o++]=t[e]/255};let qr;const Xr=(e,t)=>(qr?Ot[0]===e&&Ot[4]===t||(Ot[0]=e,Ot[2]=e,Ot[4]=t,Ot[6]=t,r.bufferSubData(r.ARRAY_BUFFER,0,Ot)):qr=((e,t)=>{const n=St();return Tt(n),r.bindBuffer(r.ARRAY_BUFFER,n.vertexBuffer),Ot[0]=e,Ot[2]=e,Ot[4]=t,Ot[6]=t,r.bufferData(r.ARRAY_BUFFER,Ot,r.STATIC_DRAW),r.enableVertexAttribArray(0),r.vertexAttribPointer(0,2,r.FLOAT,!1,0,0),n})(e,t),qr),Yr=(e,t,n)=>{e.useProgram(),e.bindUniform(),Tt(Xr(t,n)),r.drawArrays(r.TRIANGLE_STRIP,0,4)},Kr=new Map,Hr=e=>{if(!Kr.has(e)){const t=ye(e,1,!1);Kr.set(e,t)}return Kr.get(e)};let Qr=0;const Zr=()=>Qr,Jr=new Float32Array(256),en=new Float32Array(256);for(let e=0;e<256;++e){const t=e/255;Jr[e]=Math.pow(t,2.23333333),en[e]=t}const tn=(e,t,r)=>{const i=n.currentAttachmentObject,a=Hr(512);n.bind(a);const s=e.length;br();const o=Zr();for(let n=0;n<s;n+=o-1){const i=Math.min(n+o,s),a=Nr(i-n,!1);Wr(a,e,t,r,n,i),Yr(a,e[n]/255,e[i-1]/255)}return Xt(),i&&n.bind(i),a.texture},rn=(e,t,i,a,s,o,l,c,u,f,d,h,p,m,g,b,x=null,v=null,y=null,_=0,w=0,M=0,P=0,S=0,F=0,T=0,B=0)=>{const O=n.currentAttachmentObject,A=ye(i,a,!1);n.bind(A);const R="inner"===m,C=null!==x&&null!==v&&null!==y;let E=null;if(C&&(E=tn(x,v,y)),R){n.reset(),n.setTransform(1,0,0,1,0,0),ke(e,!0);const i=fr();dr(i,e.width,e.height),hr(i),C&&E?((e,t,n=!1)=>{Ge(2,r.TEXTURE2,t,n),Ge(1,r.TEXTURE1,null),Ge(0,r.TEXTURE0,e,n)})(t,E,!0):ke(t,!0)}else C&&E?((e,t,n,i=!1)=>{Ge(2,r.TEXTURE2,n,i),Ge(1,r.TEXTURE1,t,i),Ge(0,r.TEXTURE0,e,i)})(t,e,E,!0):ur(t,e,!0);const U=!(R||"full"===m&&g),$=!(i===u&&a===f&&0===d&&0===h),G=!(1===b);R?g?670!==Wt&&(qt(670),r.blendFunc(r.DST_ALPHA,r.ZERO)):673!==Wt&&(qt(673),r.blendFunc(r.DST_ALPHA,r.ONE_MINUS_SRC_ALPHA)):br();const k=zr(U,$,p,m,g,G,C);((e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g,b,x,v,y,_,w,M,P)=>{let S;_?(S=e.textures,S[0]=0,S[1]=1,P&&(S[2]=2)):P&&(S=e.textures,S[0]=0,S[1]=2);const F=e.mediump;let T=0;_&&(F[T++]=t/n,F[T++]=r/i,F[T++]=a/n,F[T++]=(r-i-s)/i),w&&(F[T++]=t/o,F[T++]=r/l,F[T++]=c/o,F[T++]=(r-l-u)/l),P||(f?(F[T++]=h,F[T++]=p,F[T++]=m,F[T++]=g):(F[T++]=h,F[T++]=p,F[T++]=m,F[T++]=g,F[T++]=b,F[T++]=x,F[T++]=v,F[T++]=y)),M&&(F[T]=d)})(k,i,a,s,o,l,c,u,f,d,h,p,b,_,w,M,P,S,F,T,B,U,$,G,C),hr(k);const L=A.texture;return ce(A,!1),Xt(),O&&n.bind(O),L},nn=(e,t,r=0,i=1,a=4,s=4,o=1,l=1,c=!1,u=!1)=>{const f=n.currentAttachmentObject,d=e.width,h=e.height,p=Cr.x,m=Cr.y,g=kr(e,t,a,s,l,!1),b=g.width,x=g.height,v=Cr.x-p,y=Cr.y-m,_=rn(e,g,c?d:b,c?h:x,d,h,c?0:v,c?0:y,b,x,c?-v:0,c?-y:0,!0,c?"inner":"outer",u,o,null,null,null,Er(r,i,!0),Ur(r,i,!0),$r(r,i,!0),i,0,0,0,0);return K(e),K(g),f&&n.bind(f),_},an=Math.PI/180,sn=(e,t,r=4,i=45,a=0,s=1,o=4,l=4,c=1,u=1,f=!1,d=!1,h=!1)=>{const p=n.currentAttachmentObject,m=e.width,g=e.height,b=Cr.x,x=Cr.y,v=kr(e,t,o,l,u,!1),y=v.width,_=v.height,w=Cr.x,M=Cr.y,P=w-b,S=M-x,T=Math.sqrt(t[0]*t[0]+t[1]*t[1]),B=Math.sqrt(t[2]*t[2]+t[3]*t[3]),O=F,A=i*an,R=Math.cos(A)*r*(T/O),C=Math.sin(A)*r*(B/O),E=f?m:y+Math.max(0,Math.abs(R)-P),U=f?g:_+Math.max(0,Math.abs(C)-S),$=Math.ceil(E),G=Math.ceil(U),k=($-E)/2,L=(G-U)/2,I=f?0:Math.max(0,P-R)+k,V=f?0:Math.max(0,S-C)+L,z=f?R-w:(R>0?Math.max(0,R-P):0)+k,j=f?C-M:(C>0?Math.max(0,C-S):0)+L;let D,N="";f?(N="inner",D=d||h):!d&&h?(N="full",D=!0):(N="outer",D=d);const W=rn(e,v,$,G,m,g,I,V,y,_,z,j,!0,N,D,c,null,null,null,Er(a,s,!0),Ur(a,s,!0),$r(a,s,!0),s,0,0,0,0);return K(e),K(v),p&&n.bind(p),W},on=Math.PI/180,ln=(e,t,r=4,i=45,a=16777215,s=1,o=0,l=1,c=4,u=4,f=1,d=1,h=0,p=!1)=>{const m=e.width,g=e.height,b=Cr.x,x=Cr.y,v=Math.sqrt(t[0]*t[0]+t[1]*t[1]),y=Math.sqrt(t[2]*t[2]+t[3]*t[3]),_=F,w=i*on,M=Math.cos(w)*r*(v/_),P=Math.sin(w)*r*(y/_),S=n.currentAttachmentObject,T=ye(m,g,!1);n.bind(T),n.reset(),n.setTransform(1,0,0,1,0,0),ke(e);const B=fr();dr(B,e.width,e.height),hr(B),n.setTransform(1,0,0,1,2*M,2*P),Pr(),dr(B,e.width,e.height),hr(B),Xt();const O=T.texture;S&&n.bind(S);const A=kr(O,t,c,u,d,!1);ce(T);const R=A.width,C=A.height,E=Math.ceil(R+2*Math.abs(M)),U=Math.ceil(C+2*Math.abs(P));let $="";switch(h){case 0:$="full";break;case 1:$="inner";break;case 2:$="outer"}const G="inner"===$,k=G?m:E,L=G?g:U,I=Math.abs(M),V=Math.abs(P),z=(R-m)/2,j=(C-g)/2,D=G?0:I+z,N=G?0:V+j,W=rn(e,A,k,L,m,g,D,N,R,C,G?-z-M:I-M,G?-j-P:V-P,!1,$,p,f,null,null,null,Er(a,s,!0),Ur(a,s,!0),$r(a,s,!0),s,Er(o,l,!0),Ur(o,l,!0),$r(o,l,!0),l);return Cr.x=b+D,Cr.y=x+N,K(e),K(A),W},cn=Math.PI/180,un=(e,t,r=4,i=45,a,s,o,l=4,c=4,u=1,f=1,d=0,h=!1)=>{const p=e.width,m=e.height,g=Cr.x,b=Cr.y,x=Math.sqrt(t[0]*t[0]+t[1]*t[1]),v=Math.sqrt(t[2]*t[2]+t[3]*t[3]),y=F,_=i*cn,w=Math.cos(_)*r*(x/y),M=Math.sin(_)*r*(v/y),P=n.currentAttachmentObject,S=ye(p,m,!1);n.bind(S),n.reset(),n.setTransform(1,0,0,1,0,0),ke(e);const T=fr();dr(T,e.width,e.height),hr(T),n.setTransform(1,0,0,1,2*w,2*M),Pr(),dr(T,e.width,e.height),hr(T),Xt();const B=S.texture;P&&n.bind(P);const O=kr(B,t,l,c,f,!1);ce(S);const A=O.width,R=O.height,C=Math.ceil(A+2*Math.abs(w)),E=Math.ceil(R+2*Math.abs(M));let U="";switch(d){case 0:U="full";break;case 1:U="inner";break;case 2:U="outer"}const $="inner"===U,G=$?p:C,k=$?m:E,L=Math.abs(w),I=Math.abs(M),V=(A-p)/2,z=(R-m)/2,j=$?0:L+V,D=$?0:I+z,N=rn(e,O,G,k,p,m,j,D,A,R,$?-V-w:L-w,$?-z-M:I-M,!1,U,h,u,o,a,s,0,0,0,0,0,0,0,0);return Cr.x=g+j,Cr.y=b+D,K(e),K(O),N},fn=Math.PI/180,dn=(e,t,r=4,n=45,i,a,s,o=4,l=4,c=1,u=1,f=0,d=!1)=>{const h=e.width,p=e.height,m=Cr.x,g=Cr.y,b=kr(e,t,o,l,u,!1),x=b.width,v=b.height,y=Cr.x,_=Cr.y,w=y-m,M=_-g,P=Math.sqrt(t[0]*t[0]+t[1]*t[1]),S=Math.sqrt(t[2]*t[2]+t[3]*t[3]),T=F,B=n*fn,O=Math.cos(B)*r*(P/T),A=Math.sin(B)*r*(S/T),R=1===f,C=R?h:x+Math.max(0,Math.abs(O)-w),E=R?p:v+Math.max(0,Math.abs(A)-M),U=Math.ceil(C),$=Math.ceil(E),G=(U-C)/2,k=($-E)/2,L=R?0:Math.max(0,w-O)+G,I=R?0:Math.max(0,M-A)+k,V=R?O-y:(O>0?Math.max(0,O-w):0)+G,z=R?A-_:(A>0?Math.max(0,A-M):0)+k;let j="";switch(f){case 0:j="full";break;case 1:j="inner";break;case 2:j="outer"}const D=rn(e,b,U,$,h,p,L,I,x,v,V,z,!0,j,d,c,s,i,a,0,0,0,0,0,0,0,0);return Cr.x=m+L,Cr.y=g+I,K(e),K(b),D},hn=(e,t,r,n)=>{const i=`c${("0"+e).slice(-2)}${("0"+t).slice(-2)}${r?"y":"n"}${n?"y":"n"}`;if(Ar.has(i))return Ar.get(i);const a=(n?1:2)+Math.ceil(e*t/4),s=new Lt("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\n\nout vec2 v_coord;\n\nvoid main() {\n    v_coord = a_vertex;\n\n    vec2 position = a_vertex * 2.0 - 1.0;\n    gl_Position = vec4(position, 0.0, 1.0);\n}",((e,t,r,n,i)=>{const a=Math.floor(.5*t),s=Math.floor(.5*r),o=t*r;let l="";const c=i?1:2;for(let e=0;e<o;++e)l+=`\n    result += getWeightedColor(${e}, u_mediump[${c+Math.floor(e/4)}][${e%4}]);\n`;return`#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_texture;\nuniform vec4 u_mediump[${e}];\n\nin vec2 v_coord;\nout vec4 o_color;\n\n\nfloat isInside(in vec2 uv) {\n    return step(4.0, dot(step(vec4(0.0, uv.x, 0.0, uv.y), vec4(uv.x, 1.0, uv.y, 1.0)), vec4(1.0)));\n}\n\nvec4 getWeightedColor (in int i, in float weight) {\n    vec2 rcp_size = u_mediump[0].xy;\n\n    int i_div_x = i / ${t};\n    int i_mod_x = i - ${t} * i_div_x;\n    vec2 offset = vec2(i_mod_x - ${a}, ${s} - i_div_x);\n    vec2 uv = v_coord + offset * rcp_size;\n\n    vec4 color = texture(u_texture, uv);\n    color.rgb /= max(0.0001, color.a);\n    ${i?"":"\n    vec4 substitute_color = u_mediump[1];\n    color = mix(substitute_color, color, isInside(uv));\n"}\n\n    return color * weight;\n}\n\nvoid main() {\n    float rcp_divisor = u_mediump[0].z;\n    float bias        = u_mediump[0].w;\n\n    vec4 result = vec4(0.0);\n    ${l}\n    result = clamp(result * rcp_divisor + bias, 0.0, 1.0);\n    ${n?"result.a = texture(u_texture, v_coord).a;":""}\n\n    result.rgb *= result.a;\n    o_color = result;\n}`})(a,e,t,r,n));return Ar.set(i,s),s},pn=(e,t=0,r=0,i,a=1,s=0,o=!0,l=!0,c=0,u=0)=>{const f=n.currentAttachmentObject,d=e.width,h=e.height,p=ye(d,h,!1);n.bind(p),n.reset(),n.setTransform(1,0,0,1,0,0),ke(e,!0),Xt();const m=hn(t,r,o,l);((e,t,r,n,i,a,s,o,l,c,u)=>{const f=e.mediump;f[0]=1/t,f[1]=1/r,f[2]=1/i,f[3]=a/255;let d=4;s||(f[d++]=o,f[d++]=l,f[d++]=c,f[d++]=u);const h=n.length;for(let e=0;e<h;e++)f[d++]=n[e]})(m,d,h,i,a,s,l,Er(c,u,!1),Ur(c,u,!1),$r(c,u,!1),u),hr(m);const g=p.texture;return K(e),ce(p,!1),f&&n.bind(f),g},mn=(e,t,r=0,i=0,a=0,s=0,o=0,l=0,c=0,u=0,f=2,d=0,h=0)=>{const p=n.currentAttachmentObject,m=e.width,g=e.height,b=ye(m,g,!1);n.bind(b);const x=Tr(r,i,t);ur(e,x);const v=((e,t,r)=>{const n=`d${e}${t}${r}`;if(Ar.has(n))return Ar.get(n);const i=new Lt("#version 300 es\n\nlayout (location = 0) in vec2 a_vertex;\n\nout vec2 v_coord;\n\nvoid main() {\n    v_coord = a_vertex;\n\n    vec2 position = a_vertex * 2.0 - 1.0;\n    gl_Position = vec4(position, 0.0, 1.0);\n}",((e,t,r,n)=>{let i,a,s;switch(t){case 1:i="map_color.r";break;case 2:i="map_color.g";break;case 4:i="map_color.b";break;case 8:i="map_color.a";break;default:i="0.5"}switch(r){case 1:a="map_color.r";break;case 2:a="map_color.g";break;case 4:a="map_color.b";break;case 8:a="map_color.a";break;default:a="0.5"}switch(n){case 0:s="\n    vec4 source_color = texture(u_textures[0], uv);\n";break;case 3:s="\n    vec4 source_color =texture(u_textures[0], mix(v_coord, uv, step(abs(uv - vec2(0.5)), vec2(0.5))));\n";break;case 1:s="\n    vec4 substitute_color = u_mediump[2];\n    vec4 source_color = mix(substitute_color, texture(u_textures[0], uv), isInside(uv));\n";break;default:s="\n    vec4 source_color = texture(u_textures[0], fract(uv));\n"}return`#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_textures[2];\nuniform vec4 u_mediump[${e}];\n\nin vec2 v_coord;\nout vec4 o_color;\n\n\nfloat isInside(in vec2 uv) {\n    return step(4.0, dot(step(vec4(0.0, uv.x, 0.0, uv.y), vec4(uv.x, 1.0, uv.y, 1.0)), vec4(1.0)));\n}\n\nvoid main() {\n    vec2 uv_to_st_scale  = u_mediump[0].xy;\n    vec2 uv_to_st_offset = u_mediump[0].zw;\n    vec2 scale           = u_mediump[1].xy;\n\n    vec2 st = v_coord * uv_to_st_scale - uv_to_st_offset;\n    vec4 map_color = texture(u_textures[1], st);\n\n    vec2 offset = vec2(${i}, ${a}) - 0.5;\n    vec2 uv = v_coord + offset * scale;\n    ${s}\n\n    o_color = mix(texture(u_textures[0], v_coord), source_color, isInside(st));\n}`})(1===r?3:2,e,t,r));return Ar.set(n,i),i})(o,l,f);((e,t,r,n,i,a,s,o,l,c,u,f,d,h)=>{const p=e.textures;p[0]=0,p[1]=1;const m=e.mediump;m[0]=n/t,m[1]=i/r,m[2]=a/t,m[3]=(i-r-s)/r,m[4]=o/n,m[5]=-l/i,1===c&&(m[8]=u,m[9]=f,m[10]=d,m[11]=h)})(v,r,i,r,i,a,s,c,u,f,Er(d,h,!0),Ur(d,h,!0),$r(d,h,!0),h),Xt(),hr(v);const y=b.texture;return p&&n.bind(p),K(e),K(x),ce(b,!1),y},gn=(e,t,r,i)=>{const a=n.currentAttachmentObject,s=e.width,o=e.height;switch(n.globalCompositeOperation){case"normal":case"layer":case"add":case"screen":case"alpha":case"erase":case"copy":{n.bind(n.$mainAttachmentObject),n.setTransform(1,0,0,1,r,i);const a=yr(!0);((e,t,r,i)=>{const a=e.highp,s=n.$matrix;a[0]=s[0],a[1]=s[1],a[2]=s[3],a[3]=s[4],a[4]=s[6],a[5]=s[7],a[6]=r,a[7]=i,a[8]=P,a[9]=S;const o=e.mediump;o[0]=t[0],o[1]=t[1],o[2]=t[2],o[3]=t[3],o[4]=t[4],o[5]=t[5],o[6]=t[6],o[7]=t[7]})(a,t,s,o),ke(e),Sr(n.globalCompositeOperation),hr(a)}break;default:{const a=gr(r,i,s,o),l=ye(s,o,!1);n.bind(l),ur(a,e);const c=or(n.globalCompositeOperation);vr(c,t[0],t[1],t[2],t[3],t[4],t[5],t[6],t[7]),hr(c),n.bind(n.$mainAttachmentObject),n.reset(),n.setTransform(1,0,0,1,r,i),xr(l.texture),K(a),ce(l)}}a&&n.bind(a),Xt()},bn=[],xn=e=>{e.size&&e.clear(),bn.push(e)},vn=(e,t,r,n,i=null)=>{t.has(r)||t.set(r,bn.pop()||new Map);const a=t.get(r);if(null===i){if(!a.has(n))return;return e.destroy(a.get(n)),a.delete(n),void(a.size||(t.delete(r),xn(a)))}a.set(n,i)};const yn=new class{constructor(){Object.defineProperty(this,"_$pool",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"_$store",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"_$trash",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$timerId",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$removeCache",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$removeIds",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this._$pool=[],this._$store=new Map,this._$trash=new Map,this.$timerId=null,this.$removeIds=[],this.$removeCache=!1}reset(){((e,t,r)=>{r.clear(),null!==e.$timerId&&clearTimeout(e.$timerId);for(const r of t.values()){for(const t of r.values())t&&e.destroy(t);xn(r)}t.clear()})(this,this._$store,this._$trash)}destroy(e=null){((e,t)=>{if(t&&"object"==typeof t&&"canvas"in t){const r=t.canvas,n=r.width,i=r.height;t.clearRect(0,0,n+1,i+1),r.width=r.height=1,e.push(r)}})(this._$pool,e)}getCanvas(){return this._$pool.pop()||document.createElement("canvas")}remove(e,t){((e,t,r)=>{if(!e.has(t))return;const n=e.get(t);n.has(r)&&(n.delete(r),n.size||(xn(n),e.delete(t)))})(this._$store,e,t)}removeTimer(e){((e,t,r,n)=>{if(r.has(n))return;const i=t.get(n);i&&(i.set("trash",!0),r.set(n,i),null!==e.$timerId&&clearTimeout(e.$timerId),e.$removeCache=!1,e.$timerId=setTimeout(()=>{e.$removeCache=!0,e.$timerId=null},1e3))})(this,this._$store,this._$trash,e)}removeTimerScheduledCache(){((e,t)=>{if(t.size){for(const[r,n]of t)n.has("trash")&&(e.removeById(r),e.$removeIds.push(+r));t.clear(),e.$removeCache=!1}})(this,this._$trash)}removeById(e){((e,t,r)=>{if(!t.has(r))return;const n=t.get(r);for(const t of n.values())e.destroy(t);t.delete(r),xn(n)})(this,this._$store,e)}getById(e){return this._$store.get(e)}get(e,t){return((e,t,r)=>{const n=e.get(t)||null;return n?(n.delete("trash"),n.get(r)||null):null})(this._$store,e,t)}set(e,t,r=null){vn(this,this._$store,e,t,r)}has(e,t=""){return((e,t,r="")=>r?!!e.has(t)&&e.get(t).has(r):e.has(t))(this._$store,e,t)}generateKeys(e,t,r){return((e,t,r)=>{let n=2166136261,i=100*e|0;return n^=255&i,n=Math.imul(n,16777619),n^=i>>>8&255,n=Math.imul(n,16777619),n^=i>>>16&255,n=Math.imul(n,16777619),n^=i>>>24,n=Math.imul(n,16777619),i=100*t|0,n^=255&i,n=Math.imul(n,16777619),n^=i>>>8&255,n=Math.imul(n,16777619),n^=i>>>16&255,n=Math.imul(n,16777619),n^=i>>>24,n=Math.imul(n,16777619),r&&(i=100*r|0,n^=255&i,n=Math.imul(n,16777619),n^=i>>>8&255,n=Math.imul(n,16777619),n^=i>>>16&255,n=Math.imul(n,16777619),n^=i>>>24,n=Math.imul(n,16777619)),(n>>>0)%16777216})(e,t,r)}generateFilterKeys(e,t,r,n){return((e,t,r,n)=>{let i=2166136261,a=100*e|0;return i^=255&a,i=Math.imul(i,16777619),i^=a>>>8&255,i=Math.imul(i,16777619),i^=a>>>16&255,i=Math.imul(i,16777619),i^=a>>>24,i=Math.imul(i,16777619),a=100*t|0,i^=255&a,i=Math.imul(i,16777619),i^=a>>>8&255,i=Math.imul(i,16777619),i^=a>>>16&255,i=Math.imul(i,16777619),i^=a>>>24,i=Math.imul(i,16777619),a=100*r|0,i^=255&a,i=Math.imul(i,16777619),i^=a>>>8&255,i=Math.imul(i,16777619),i^=a>>>16&255,i=Math.imul(i,16777619),i^=a>>>24,i=Math.imul(i,16777619),a=100*n|0,i^=255&a,i=Math.imul(i,16777619),i^=a>>>8&255,i=Math.imul(i,16777619),i^=a>>>16&255,i=Math.imul(i,16777619),i^=a>>>24,i=Math.imul(i,16777619),(i>>>0)%16777216})(e,t,r,n)}},_n=new Float32Array(20),wn=(e,t,r,i,a,s,o,l,c,u,f)=>{const d=n.currentAttachmentObject;let h=null;const p=Math.sqrt(o[0]*o[0]+o[1]*o[1]),m=Math.sqrt(o[2]*o[2]+o[3]*o[3]),g=yn.generateFilterKeys(o[0],o[1],o[2],o[3]);let b=!1;if(yn.get(t,"fKey")===g){const e=yn.get(t,"fTexture");r?K(e):(b=!0,h=e)}let x=0,v=0;if(b)x=yn.get(t,"offsetX"),v=yn.get(t,"offsetY");else{h=cr(e);const t=Math.atan2(o[1],o[0]),r=Math.atan2(-o[2],o[3]),l=s?p*Math.cos(t):Math.cos(t),c=s?p*Math.sin(t):Math.sin(t),u=s?-m*Math.sin(r):-Math.sin(r),g=s?m*Math.cos(r):Math.cos(r),b=_(l,c,u,g,i/2,a/2),y=_(1,0,0,1,-e.w/2,-e.h/2),M=((e,t)=>{const r=e[0],n=e[1],i=e[2],a=e[3],s=e[4],o=e[5],l=t[0],c=t[1],u=t[2],f=t[3],d=t[4],h=t[5];return _(r*l+i*c,n*l+a*c,r*u+i*f,n*u+a*f,r*d+i*h+s,n*d+a*h+o)})(b,y);if(w(b),w(y),1!==M[0]||0!==M[1]||0!==M[2]||1!==M[3]){const e=ye(i,a,!1);n.bind(e),n.reset(),n.setTransform(M[0],M[1],M[2],M[3],M[4],M[5]),x=M[4],v=M[5],ke(h);const t=yr();_r(t,h.width,h.height),hr(t),K(h),h=e.texture,ce(e,!1),d&&n.bind(d)}w(M),Cr.x=0,Cr.y=0;for(let e=0;f.length>e;){switch(f[e++]){case 0:h=ln(h,o,f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],Boolean(f[e++]));break;case 1:h=kr(h,o,f[e++],f[e++],f[e++]);break;case 2:for(let t=0;t<20;++t)_n[t]=f[e++];h=Lr(h,_n);break;case 3:{const t=f[e++],r=f[e++],n=t*r,i=f.subarray(e,e+n);e+=n,h=pn(h,t,r,i,f[e++],f[e++],Boolean(f[e++]),Boolean(f[e++]),f[e++],f[e++])}break;case 4:{const t=f[e++],r=new Uint8Array(t);r.set(f.subarray(e,e+t)),e+=t,h=mn(h,r,f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++])}break;case 5:h=sn(h,o,f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],Boolean(f[e++]),Boolean(f[e++]),Boolean(f[e++]));break;case 6:h=nn(h,o,f[e++],f[e++],f[e++],f[e++],f[e++],f[e++],Boolean(f[e++]),Boolean(f[e++]));break;case 7:{const t=f[e++],r=f[e++];let n=f[e++];const i=f.subarray(e,e+n);e+=n,n=f[e++];const a=f.subarray(e,e+n);e+=n,n=f[e++];const s=f.subarray(e,e+n);e+=n,h=un(h,o,t,r,i,a,s,f[e++],f[e++],f[e++],f[e++],f[e++],Boolean(f[e++]))}break;case 8:{const t=f[e++],r=f[e++];let n=f[e++];const i=f.subarray(e,e+n);e+=n,n=f[e++];const a=f.subarray(e,e+n);e+=n,n=f[e++];const s=f.subarray(e,e+n);e+=n,h=dn(h,o,t,r,i,a,s,f[e++],f[e++],f[e++],f[e++],f[e++],Boolean(f[e++]))}}}}if(h){const e=F,t=u[0]*(p/e),r=u[1]*(m/e);n.reset(),n.setTransform(1,0,0,1,0,0),n.globalCompositeOperation=c,gn(h,l,-x+t+o[4],-v+r+o[5])}b||(yn.set(t,"fKey",g),yn.set(t,"fTexture",h),yn.set(t,"offsetX",x),yn.set(t,"offsetY",v)),d&&n.bind(d)},Mn=[],Pn=new Float32Array(20),Sn=e=>{const t=Re(e.index),r=t[0],n=t[1],i=t[2],a=t[3];t[0]=Math.min(e.x,r),t[1]=Math.min(e.y,n),t[2]=Math.max(e.x+e.w+1,i),t[3]=Math.max(e.y+e.h+1,a)};let Fn=0;const Tn=e=>{Fn=e};let Bn=!0;const On=e=>{Bn=e};let An=!1;const Rn=e=>{An=e},Cn=()=>{1!==Fn&&(Tn(1),r.stencilFunc(r.ALWAYS,0,255),r.stencilOpSeparate(r.FRONT,r.KEEP,r.KEEP,r.INCR_WRAP),r.stencilOpSeparate(r.BACK,r.KEEP,r.KEEP,r.DECR_WRAP)),Bn&&(On(!1),r.colorMask(!1,!1,!1,!1))},En=()=>{2!==Fn&&(Tn(2),r.stencilFunc(r.NOTEQUAL,0,255),r.stencilOp(r.KEEP,r.ZERO,r.ZERO)),Bn||(On(!0),r.colorMask(!0,!0,!0,!0))},Un=()=>{An||(Rn(!0),r.enable(r.SAMPLE_ALPHA_TO_COVERAGE))},$n=()=>{An&&(Rn(!1),r.disable(r.SAMPLE_ALPHA_TO_COVERAGE))},Gn=(e,t,r,n)=>{Cn();const i=!!n,a=zt(i);n&&jt(a,n),Un(),Yt(a,e,t,r),$n(),En();const s=(e=>{const t="s"+(e?"y":"n");if(It.has(t))return It.get(t);const r=new Lt(Vt(e?9:0,!1,!1,e),"#version 300 es\nprecision mediump float;\n\nin vec4 v_color;\nout vec4 o_color;\n\nvoid main() {\n    o_color = vec4(v_color.rgb * v_color.a, v_color.a);\n}");return It.set(t,r),r})(i);n&&((e,t)=>{const r=e.highp;r[0]=t[0],r[1]=t[1],r[2]=0,r[4]=t[2],r[5]=t[3],r[6]=0,r[8]=t[4],r[9]=t[5],r[10]=1,r[12]=t[6],r[13]=t[7],r[14]=0,r[16]=t[8],r[17]=t[9],r[18]=0,r[20]=t[10],r[21]=t[11],r[22]=1,r[3]=P,r[7]=S,r[11]=t[12],r[15]=t[13],r[19]=t[14],r[23]=t[15],r[24]=t[16],r[25]=t[17],r[26]=t[18],r[27]=t[19],r[28]=t[20],r[29]=t[21],r[30]=t[22],r[31]=t[23],r[32]=t[24],r[33]=t[25]})(s,n),Yt(s,e,t,r)},kn=(e,t,r,n,i)=>{const a=e.mediump;let s=0;for(let e=r;e<n;++e){const r=5*e;a[s++]=i[t[r+1]],a[s++]=i[t[r+2]],a[s++]=i[t[r+3]],a[s++]=i[t[r+4]]}for(let e=r;e<n;++e)a[s++]=t[5*e]},Ln=(e,t)=>{const i=n.currentAttachmentObject,o=r.getParameter(r.SCISSOR_BOX);s();const l=0===t,c=e.length/5,u=(e=>e<=4?256:e<=8?512:1024)(c),f=Hr(u);n.bind(f);const d=l?Jr:en;br();const h=Zr();for(let t=0;t<c;t+=h-1){const r=Math.min(t+h,c),n=Nr(r-t,l);kn(n,e,t,r,d),Yr(n,e[0],e[e.length-5])}return Xt(),i&&n.bind(i),a(),r.scissor(o[0],o[1],o[2],o[3]),f.texture},In=new Map,Vn=(e,t,r,n)=>{const i=((e,t,r,n)=>`${e?"y":"n"}${t?"y":"n"}${t&&r?"y":"n"}${n}`)(n,e,t,r);if(In.has(i))return In.get(i);const a=1+(n?14:5),s=a-1,o=new Lt(Vt(a,!0,!1,n),((e,t,r,n,i)=>{const a=r?((e,t)=>{const r=t?(e=>`\n    vec2 focal = vec2(u_highp[${e}][1], 0.0);\n\n    vec2 diff = coord - focal;\n    float lenDiff = length(diff);\n    vec2 dir = diff / lenDiff;\n    float b = 2.0 * dot(dir, focal);\n    float c = dot(focal, focal) - 1.0;\n    float x = (-b + sqrt(max(b * b - 4.0 * c, 0.0))) * 0.5;\n\n    float t = lenDiff / abs(x);`)(e):"float t = length(coord);";return`\n    float radius = u_highp[${e}][0];\n    vec2 coord = p / radius;\n    ${r}\n`})(t,n):(e=>`\n    vec2 a = u_highp[${e}].xy;\n    vec2 b = u_highp[${e}].zw;\n\n    vec2 ab = b - a;\n    vec2 ap = p - a;\n\n    float t = dot(ab, ap) / dot(ab, ab);`)(t);let s;switch(i){case 0:s="1.0 - abs(fract(t * 0.5) * 2.0 - 1.0)";break;case 1:s="fract(t)";break;default:s="clamp(t, 0.0, 1.0)"}return`#version 300 es\nprecision highp float;\n\nuniform sampler2D u_texture;\nuniform vec4 u_highp[${e}];\n\nin vec2 v_uv;\nout vec4 o_color;\n\nvoid main() {\n    vec2 p = v_uv;\n    ${a}\n    t = ${s};\n    o_color = texture(u_texture, vec2(t, 0.5));\n}`})(a,s,e,t,r));return In.set(i,o),o},zn=(e,t,r,n,i=0,a=null,s=null)=>{const o=e.highp;o[0]=r[0],o[1]=r[1],o[2]=r[2],o[4]=r[3],o[5]=r[4],o[6]=r[5],o[8]=r[6],o[9]=r[7],o[10]=r[8],o[12]=n[0],o[13]=n[1],o[14]=n[2],o[16]=n[3],o[17]=n[4],o[18]=n[5],o[11]=n[6],o[15]=n[7],o[19]=n[8],o[3]=P,o[7]=S;let l=20;s&&(o[20]=s[0],o[21]=s[1],o[22]=0,o[24]=s[2],o[25]=s[3],o[26]=0,o[28]=s[4],o[29]=s[5],o[30]=1,o[32]=s[6],o[33]=s[7],o[34]=0,o[36]=s[8],o[37]=s[9],o[38]=0,o[40]=s[10],o[41]=s[11],o[42]=1,o[31]=s[12],o[35]=s[13],o[39]=s[14],o[43]=s[15],o[44]=s[16],o[45]=s[17],o[46]=s[18],o[47]=s[19],o[48]=s[20],o[49]=s[21],o[50]=s[22],o[51]=s[23],o[52]=s[24],o[53]=s[25],l=56),0===t?(o[l++]=a[0],o[l++]=a[1],o[l++]=a[2],o[l]=a[3]):(o[l++]=819.2,o[l]=u(i,-.975,.975,0))},jn=()=>{Fn=0,On(!0),Rn(!1)},Dn=(e,t,i,a)=>{const s=rt.shift(),o=rt.shift(),u=rt.shift(),f=rt.shift();jn(),c();const d=Ln(s,f);ke(d),l(),r.stencilMask(255),Cn();const h=!!a,p=zt(h);a&&jt(p,a),Un(),Yt(p,e,t,i),$n(),En();const m=Vn(!1,!1,u,h),x=(e=>{const t=-819.2*e[0]-819.2*e[2]+e[4],r=819.2*e[0]-819.2*e[2]+e[4],n=-819.2*e[0]+819.2*e[2]+e[4],i=-819.2*e[1]-819.2*e[3]+e[5],a=819.2*e[1]-819.2*e[3]+e[5];let s=n-t,o=-819.2*e[1]+819.2*e[3]+e[5]-i;const l=Math.sqrt(s*s+o*o);l?(s/=l,o/=l):(s=0,o=0);const c=(r-t)*s+(a-i)*o;return g(t+c*s,i+c*o,r,a)})(o),v=M(n.$matrix);zn(m,0,n.$matrix,v,0,x,a),b(x),w(v),Yt(m,e,t,i)},Nn=(e,t,i,a)=>{const s=rt.shift(),o=rt.shift(),u=rt.shift(),f=rt.shift(),d=rt.shift();jn(),c();const h=Ln(s,f);ke(h),l(),r.stencilMask(255),Cn();const p=!!a,m=zt(p);a&&jt(m,a),Un(),Yt(m,e,t,i),$n(),En(),n.save(),n.transform(o[0],o[1],o[2],o[3],o[4],o[5]);const g=n.$stack[n.$stack.length-1],b=M(n.$matrix),x=Vn(!0,Boolean(d),u,p);zn(x,1,g,b,d,a),n.restore(),w(b),Yt(x,e,t,i)},Wn=new Map,qn=(e,t,r,i)=>{Cn();const a=!!i,s=zt(a);i&&jt(s,i),Un(),Yt(s,e,t,r),$n();const o=Or.shift(),l=Or.shift(),c=Or.shift(),u=Or.shift(),f=Or.shift(),d=Or.shift(),h=Tr(c,u,o,d);n.save(),n.transform(l[0],l[1],l[2],l[3],l[4],l[5]),En();const p=((e,t)=>{const r=`b${e?"y":"n"}${t?"y":"n"}`;if(Wn.has(r))return Wn.get(r);const n=e?"#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_texture;\nuniform vec4 u_mediump[1];\n\nin vec2 v_uv;\nout vec4 o_color;\n\nvoid main() {\n    vec2 uv = fract(vec2(v_uv.x, -v_uv.y) / u_mediump[0].xy);\n\n    vec4 src = texture(u_texture, uv);\n    o_color = src;\n}":"#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_texture;\nuniform vec4 u_mediump[1];\n\nin vec2 v_uv;\nout vec4 o_color;\n\nvoid main() {\n    vec2 uv = vec2(v_uv.x, u_mediump[0].y - v_uv.y) / u_mediump[0].xy;\n\n    vec4 src = texture(u_texture, uv);\n    o_color = src;\n}",i=new Lt(Vt(t?14:5,!0,!1,t),n);return Wn.set(r,i),i})(f,a);((e,t,r,i)=>{const a=e.highp,s=n.$stack[n.$stack.length-1];a[0]=s[0],a[1]=s[1],a[2]=s[2],a[4]=s[3],a[5]=s[4],a[6]=s[5],a[8]=s[6],a[9]=s[7],a[10]=s[8];const o=M(n.$matrix);a[12]=o[0],a[13]=o[1],a[14]=o[2],a[16]=o[3],a[17]=o[4],a[18]=o[5],a[11]=o[6],a[15]=o[7],a[19]=o[8],a[3]=P,a[7]=S,i&&(a[20]=i[0],a[21]=i[1],a[22]=0,a[24]=i[2],a[25]=i[3],a[26]=0,a[28]=i[4],a[29]=i[5],a[30]=1,a[32]=i[6],a[33]=i[7],a[34]=0,a[36]=i[8],a[37]=i[9],a[38]=0,a[40]=i[10],a[41]=i[11],a[42]=1,a[31]=i[12],a[35]=i[13],a[39]=i[14],a[43]=i[15],a[44]=i[16],a[45]=i[17],a[46]=i[18],a[47]=i[19],a[48]=i[20],a[49]=i[21],a[50]=i[22],a[51]=i[23],a[52]=i[24],a[53]=i[25]);const l=e.mediump;l[0]=t,l[1]=r})(p,c,u,i),Yt(p,e,t,r),n.restore(),K(h)};let Xn=0;const Yn=new Float32Array(256);for(let e=1;e<256;e++)Yn[e]=255/e;let Kn=class{constructor(i,a,s=1){var o;Object.defineProperty(this,"$stack",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$matrix",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$clearColorR",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$clearColorG",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$clearColorB",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$clearColorA",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$mainAttachmentObject",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$stackAttachmentObject",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"globalAlpha",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"globalCompositeOperation",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"imageSmoothingEnabled",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$fillStyle",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$strokeStyle",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"maskBounds",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"thickness",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"caps",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"joints",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"miterLimit",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"newDrawState",{enumerable:!0,configurable:!0,writable:!0,value:!1}),(e=>{r=e})(i),o=i.getParameter(i.MAX_TEXTURE_SIZE),e=Math.max(2048,o/2),(e=>{t=e})(a),(e=>{F=e})(s),this.$stack=d(),this.$stackAttachmentObject=d(),this.$matrix=v(1,0,0,0,1,0,0,0,1),this.$clearColorR=0,this.$clearColorG=0,this.$clearColorB=0,this.$clearColorA=0,this.thickness=1,this.caps=0,this.joints=2,this.miterLimit=0,this.$mainAttachmentObject=null,this.globalAlpha=1,this.globalCompositeOperation="normal",this.imageSmoothingEnabled=!1,this.$fillStyle=new Float32Array([1,1,1,1]),this.$strokeStyle=new Float32Array([1,1,1,1]),this.maskBounds={xMin:0,yMin:0,xMax:0,yMax:0},i.pixelStorei(i.UNPACK_ALIGNMENT,1),i.pixelStorei(i.UNPACK_FLIP_Y_WEBGL,!0),i.clearColor(0,0,0,0),i.frontFace(i.CCW),(e=>{Z=e.createFramebuffer()})(i),(e=>{J=e.createFramebuffer()})(i),((e,t)=>{ee=e.createFramebuffer(),e.bindFramebuffer(e.FRAMEBUFFER,ee),e.framebufferTexture2D(e.FRAMEBUFFER,e.COLOR_ATTACHMENT0,e.TEXTURE_2D,t.resource,0),e.bindFramebuffer(e.FRAMEBUFFER,null),e.bindFramebuffer(e.DRAW_FRAMEBUFFER,ee)})(i,Oe()),(e=>{se=e.createFramebuffer(),ae=e.createFramebuffer(),oe=e.createFramebuffer(),le=e.createBuffer(),e.bindBuffer(e.PIXEL_PACK_BUFFER,le)})(i),Fr(i),r.enable(r.BLEND),Xt(),(e=>{Qr=Math.floor(.75*e.getParameter(e.MAX_FRAGMENT_UNIFORM_VECTORS))})(i),n=this}clearTransferBounds(){(()=>{for(let e=0;e<Ae.length;++e){const t=Ae[e];t&&(t[0]=t[1]=_e,t[2]=t[3]=we)}})()}updateBackgroundColor(e,t,r,n){((e,t,r,n,i)=>{e.$clearColorR=u(t,0,1,0),e.$clearColorG=u(r,0,1,0),e.$clearColorB=u(n,0,1,0),e.$clearColorA=u(i,0,1,0)})(this,e,t,r,n)}fillBackgroundColor(){var e,t,n,i;e=this.$clearColorR,t=this.$clearColorG,n=this.$clearColorB,i=this.$clearColorA,r.clearColor(e,t,n,i),r.clear(r.COLOR_BUFFER_BIT|r.STENCIL_BUFFER_BIT),r.clearColor(0,0,0,0)}resize(e,t,r=!0){$e(this,e,t,r)}clearRect(e,t,n,i){((e,t,n,i)=>{a(),r.scissor(e,t,n,i),r.clear(r.COLOR_BUFFER_BIT|r.STENCIL_BUFFER_BIT),s()})(e,t,n,i)}bind(e){Ne(this,e)}save(){var e;(e=this).$stack.push(v(...e.$matrix))}restore(){We(this)}setTransform(e,t,r,n,i,a){((e,t,r,n,i,a,s)=>{e[0]=t,e[1]=r,e[3]=n,e[4]=i,e[6]=a,e[7]=s})(this.$matrix,e,t,r,n,i,a)}transform(e,t,r,n,i,a){((e,t,r,n,i,a,s)=>{const o=e.$matrix[0],l=e.$matrix[1],c=e.$matrix[3],u=e.$matrix[4],f=e.$matrix[6],d=e.$matrix[7];e.$matrix[0]=t*o+r*c,e.$matrix[1]=t*l+r*u,e.$matrix[3]=n*o+i*c,e.$matrix[4]=n*l+i*u,e.$matrix[6]=a*o+s*c+f,e.$matrix[7]=a*l+s*u+d})(this,e,t,r,n,i,a)}reset(){var e;(e=this).globalAlpha=1,e.globalCompositeOperation="normal",e.imageSmoothingEnabled=!1}beginPath(){var e;(e=this).$fillStyle.fill(1),e.$strokeStyle.fill(1),(()=>{for(T.length=0;B.length;)h(B.pop())})()}moveTo(e,t){C(e,t)}lineTo(e,t){((e,t)=>{T.length||C(e,t),R(e,t)||A(e,t,!1)})(e,t)}quadraticCurveTo(e,t,r,n){E(e,t,r,n)}fillStyle(e,t,r,n){this.$fillStyle[0]=e,this.$fillStyle[1]=t,this.$fillStyle[2]=r,this.$fillStyle[3]=n}strokeStyle(e,t,r,n){this.$strokeStyle[0]=e,this.$strokeStyle[1]=t,this.$strokeStyle[2]=r,this.$strokeStyle[3]=n}closePath(){(()=>{if(T.length<7)return;const e=+T[0],t=+T[1];R(e,t)||A(e,t,!1)})()}arc(e,t,r){((e,t,r)=>{const n=r,i=.5522847498307936*r;q(e+n,t+i,e+i,t+n,e,t+n),q(e-i,t+n,e-n,t+i,e-n,t),q(e-n,t-i,e-i,t-n,e,t-n),q(e+i,t-n,e+n,t-i,e+n,t)})(e,t,r)}bezierCurveTo(e,t,r,n,i,a){q(e,t,r,n,i,a)}fill(){(e=>{const t=O();if(!t.length)return;Ze.push(e);const r=tt(t);He(r.buffer),Qe.push(r.indexCount)})("fill")}gradientFill(e,t,r,n,i,a){((e,t,r,n,i,a)=>{const s=O();if(!s.length)return;Ze.push(0===e?"linear":"radial");const o=tt(s);He(o.buffer),Qe.push(o.indexCount),rt.push(t,r,n,i),1===e&&rt.push(a)})(e,t,r,n,i,a)}bitmapFill(e,t,r,n,i,a){((e,t,r,n,i,a)=>{const s=O();if(!s.length)return;Ze.push("bitmap");const o=tt(s);He(o.buffer),Qe.push(o.indexCount),Or.push(e,t,r,n,i,a)})(e,t,r,n,i,a)}stroke(){(()=>{const e=O(!0);if(!e.length)return;Ze.push("fill");const t=wt(e);He(t.buffer),Qe.push(t.indexCount)})()}gradientStroke(e,t,r,n,i,a){((e,t,r,n,i,a)=>{const s=O(!0);if(!s.length)return;Ze.push(0===e?"linear":"radial");const o=wt(s);He(o.buffer),Qe.push(o.indexCount),rt.push(t,r,n,i),1===e&&rt.push(a)})(e,t,r,n,i,a)}bitmapStroke(e,t,r,n,i,a){((e,t,r,n,i,a)=>{const s=O(!0);if(!s.length)return;Ze.push("bitmap");const o=wt(s);He(o.buffer),Qe.push(o.indexCount),Or.push(e,t,r,n,i,a)})(e,t,r,n,i,a)}clip(){(()=>{const e=n.currentAttachmentObject;if(!e)return;const t=je.get(e.clipLevel),i=t[0],o=t[1],l=t[2],c=t[3],u=Math.ceil(Math.abs(l-i)),f=Math.ceil(Math.abs(c-o));a(),r.scissor(i,e.height-o-f,u,f);const d=Ut();let h=De.get(e.clipLevel),p=0,m=null;const g=Qe.length;for(let t=0;t<g;t++){r.stencilMask(1<<h-1);const n=Qe[t];Mt.has(t)&&(m=Mt.get(t));const i=zt(!!m);m&&jt(i,m),Yt(i,d,p,n),p+=n,++h,h>7&&(Ht(),h=e.clipLevel+1)}De.set(e.clipLevel,h),$t(d),Je(),Pt(),s()})()}get currentAttachmentObject(){return te}get atlasAttachmentObject(){return Fe()}createNode(e,t){return er(e,t)}removeNode(e){(e=>{const t=Te[e.index];t&&t.dispose(e.x,e.y,e.w,e.h)})(e)}beginNodeRendering(e){var t,n,i,s;this.newDrawState=!0,Sn(e),t=e.x,n=e.y,i=e.w,s=e.h,a(),r.scissor(t,n,i+1,s+1),r.clear(r.COLOR_BUFFER_BIT|r.STENCIL_BUFFER_BIT),r.scissor(t,n,i,s)}endNodeRendering(){s()}drawFill(){(()=>{const e=Ut();l(),r.stencilMask(255),jn();let t=0,n=null;for(let r=0;r<Ze.length;r++)switch(Mt.has(r)&&(n=Mt.get(r)),Ze[r]){case"fill":{const r=Qe.shift();Gn(e,t,r,n),t+=r}break;case"linear":{const r=Qe.shift();Dn(e,t,r,n),t+=r}break;case"radial":{const r=Qe.shift();Nn(e,t,r,n),t+=r}break;case"bitmap":{const r=Qe.shift();qn(e,t,r,n),t+=r}}c(),jn(),$t(e),Je(),Pt()})()}drawDisplayObject(t,r,i,a,s,o){Sn(t),((t,r,i,a,s,o)=>{const l=o[0],c=o[1],u=o[2],f=n.globalAlpha,d=o[4]/255,h=o[5]/255,p=o[6]/255,m=n.$matrix;switch(n.globalCompositeOperation){case"normal":case"layer":case"add":case"screen":case"alpha":case"erase":case"copy":{if(Dt!==n.globalCompositeOperation||Ce!==t.index){Pe(Ce);const e=n.globalCompositeOperation;n.globalCompositeOperation=Dt,n.newDrawState=!0,n.drawArraysInstanced(),n.newDrawState=!0,n.globalCompositeOperation=e,Nt(n.globalCompositeOperation),Ee(t.index),Pe(t.index)}const r=sr();nr.pushDisplayObjectBuffer((t.x+.5)/e,(t.y+.5)/e,(t.w-1)/e,(t.h-1)/e,t.w,t.h,P,S,m[6],m[7],m[0],m[1],m[3],m[4],l,c,u,f,d,h,p,0),r.count++}break;default:{const e=n.currentAttachmentObject;n.drawArraysInstanced();const o=Math.ceil(Math.abs(a-r)),g=Math.ceil(Math.abs(s-i));let b=0,x=0,v=cr(t);if(1!==m[0]||0!==m[1]||0!==m[3]||1!==m[4]){const r=ye(o,g,!1),i=_(m[0],m[1],m[3],m[4],o/2,g/2),a=_(1,0,0,1,-t.w/2,-t.h/2),s=_(i[0]*a[0]+i[2]*a[1],i[1]*a[0]+i[3]*a[1],i[0]*a[2]+i[2]*a[3],i[1]*a[2]+i[3]*a[3],i[0]*a[4]+i[2]*a[5]+i[4],i[1]*a[4]+i[3]*a[5]+i[5]);n.save(),n.bind(r),n.setTransform(s[0],s[1],s[2],s[3],s[4],s[5]),b=s[4],x=s[5];const l=yr();_r(l,v.width,v.height),ke(v,!0),hr(l),K(v),v=r.texture,ce(r,!1),e&&n.bind(e),n.restore()}(b||x)&&(m[6]-=b,m[7]-=x);const y=gr(m[6],m[7],o,g),w=ye(o,g,!1);n.bind(w),ur(y,v);const M=or(n.globalCompositeOperation);vr(M,l,c,u,f,d,h,p,0),hr(M),e&&n.bind(e),xr(w.texture),(b||x)&&(m[6]+=b,m[7]+=x),K(v),K(y),ce(w),Nt(n.globalCompositeOperation),Ee(t.index),Pe(t.index)}}})(t,r,i,a,s,o)}drawArraysInstanced(){(()=>{const e=sr();e.count&&(lr(),Sr(Dt),Mr(e),e.clear())})()}clearArraysInstanced(){sr().clear()}transferMainCanvas(){(()=>{const e=n.$mainAttachmentObject;n.bind(e),r.bindFramebuffer(r.READ_FRAMEBUFFER,Z),r.bindFramebuffer(r.DRAW_FRAMEBUFFER,null);const t=e.width,i=e.height;r.blitFramebuffer(0,0,t,i,0,0,t,i,r.COLOR_BUFFER_BIT,r.NEAREST),r.bindFramebuffer(r.DRAW_FRAMEBUFFER,J),r.bindFramebuffer(r.FRAMEBUFFER,Z)})()}drawPixels(e,t){((e,t)=>{const r=Tr(e.w,e.h,t),n=fr();dr(n,e.w,e.h),Xt(),hr(n),K(r)})(e,t)}drawElement(e,t,r=!1){Br(e,t)}beginMask(){(()=>{const e=n.currentAttachmentObject;e&&(e.mask=!0,e.clipLevel++,De.set(e.clipLevel,e.clipLevel),ze()||(Ve(!0),l(),r.enable(r.SAMPLE_ALPHA_TO_COVERAGE),r.stencilFunc(r.ALWAYS,0,255),r.stencilOp(r.ZERO,r.INVERT,r.INVERT),r.colorMask(!1,!1,!1,!1)))})()}setMaskBounds(e,t,i,s){((e,t,i,s)=>{const o=n.currentAttachmentObject;if(!o)return;je.set(o.clipLevel,g(e,t,i,s));const l=Math.ceil(Math.abs(i-e)),c=Math.ceil(Math.abs(s-t));a(),r.scissor(e,o.height-t-c,l,c)})(e,t,i,s)}endMask(){Le()}leaveMask(){this.drawArraysInstanced(),(()=>{const e=n.currentAttachmentObject;if(!e)return;const t=e.clipLevel,i=je.get(t),o=i[0],l=i[1],u=i[2],f=i[3];je.delete(t),De.delete(t),b(i);const d=Math.ceil(Math.abs(u-o)),h=Math.ceil(Math.abs(f-l));if(a(),r.scissor(o,e.height-l-h,d,h),--e.clipLevel,!e.clipLevel)return e.mask=!1,Ve(!1),r.clear(r.STENCIL_BUFFER_BIT),c(),s(),De.clear(),void je.clear();r.stencilMask(1<<e.clipLevel),r.stencilFunc(r.ALWAYS,0,255),r.stencilOp(r.REPLACE,r.REPLACE,r.REPLACE),r.colorMask(!1,!1,!1,!1),Yt(Kt(),Et(),0,6),Le()})()}useGrid(e){(e=>{Mt.set(Qe.length,e)})(e)}applyFilter(e,t,r,n,i,a,s,o,l,c,u){this.drawArraysInstanced(),wn(e,t,r,n,i,a,s,o,l,c,u)}containerBeginLayer(e,t){this.drawArraysInstanced(),((e,t)=>{n.drawArraysInstanced();const r=n.$mainAttachmentObject;Mn.push(r);const i=ye(e,t,!1);n.$mainAttachmentObject=i,n.bind(i)})(e,t)}containerEndLayer(e,t,r,i,a,s,o,l){((e,t,r,i,a,s,o,l)=>{n.drawArraysInstanced();const c=n.$mainAttachmentObject;let u=null;if(i&&a&&s){u=gr(0,0,c.width,c.height),n.$mainAttachmentObject=Mn.pop(),ce(c),n.bind(n.$mainAttachmentObject),Cr.x=0,Cr.y=0;for(let e=0;s.length>e;)switch(s[e++]){case 0:u=ln(u,t,s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],Boolean(s[e++]));break;case 1:u=kr(u,t,s[e++],s[e++],s[e++]);break;case 2:for(let t=0;t<20;++t)Pn[t]=s[e++];u=Lr(u,Pn);break;case 3:{const t=s[e++],r=s[e++],n=t*r,i=s.subarray(e,e+n);e+=n,u=pn(u,t,r,i,s[e++],s[e++],Boolean(s[e++]),Boolean(s[e++]),s[e++],s[e++])}break;case 4:{const t=s[e++],r=new Uint8Array(t);r.set(s.subarray(e,e+t)),e+=t,u=mn(u,r,s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++])}break;case 5:u=sn(u,t,s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],Boolean(s[e++]),Boolean(s[e++]),Boolean(s[e++]));break;case 6:u=nn(u,t,s[e++],s[e++],s[e++],s[e++],s[e++],s[e++],Boolean(s[e++]),Boolean(s[e++]));break;case 7:{const r=s[e++],n=s[e++];let i=s[e++];const a=s.subarray(e,e+i);e+=i,i=s[e++];const o=s.subarray(e,e+i);e+=i,i=s[e++];const l=s.subarray(e,e+i);e+=i,u=un(u,t,r,n,a,o,l,s[e++],s[e++],s[e++],s[e++],s[e++],Boolean(s[e++]))}break;case 8:{const r=s[e++],n=s[e++];let i=s[e++];const a=s.subarray(e,e+i);e+=i,i=s[e++];const o=s.subarray(e,e+i);e+=i,i=s[e++];const l=s.subarray(e,e+i);e+=i,u=dn(u,t,r,n,a,o,l,s[e++],s[e++],s[e++],s[e++],s[e++],Boolean(s[e++]))}}if(o&&(yn.set(o,"fKey",l),yn.set(o,"fTexture",u)),u){const i=Math.sqrt(t[0]*t[0]+t[1]*t[1]),s=Math.sqrt(t[2]*t[2]+t[3]*t[3]),o=F,l=a[0]*(i/o),c=a[1]*(s/o);n.reset(),n.globalCompositeOperation=e,gn(u,r,l+t[4],c+t[5])}}else u=gr(0,0,c.width,c.height),n.$mainAttachmentObject=Mn.pop(),ce(c),n.bind(n.$mainAttachmentObject),u&&(n.reset(),n.globalCompositeOperation=e,gn(u,r,t[4],t[5]),K(u));n.bind(n.$mainAttachmentObject)})(e,t,r,i,a,s,o,l)}containerDrawCachedFilter(e,t,r,i,a,s){((e,t,r,i,a,s)=>{if(yn.get(a,"fKey")!==s)return;const o=yn.get(a,"fTexture");if(!o)return;const l=Math.sqrt(t[0]*t[0]+t[1]*t[1]),c=Math.sqrt(t[2]*t[2]+t[3]*t[3]),u=F,f=i[0]*(l/u),d=i[1]*(c/u);n.drawArraysInstanced(),n.reset(),n.globalCompositeOperation=e,gn(o,r,f+t[4],d+t[5])})(e,t,r,i,a,s)}async createImageBitmap(e,t){return await(async(e,t)=>{const i=mr(0,0,e,t);ke(i),r.bindFramebuffer(r.FRAMEBUFFER,oe),r.framebufferTexture2D(r.FRAMEBUFFER,r.COLOR_ATTACHMENT0,r.TEXTURE_2D,i.resource,0);const a=new Uint8Array(e*t*4),s=n.$mainAttachmentObject;a.byteLength>Xn&&(Xn=p(a.byteLength),r.bufferData(r.PIXEL_PACK_BUFFER,Xn,r.STREAM_READ)),r.readPixels(0,s.height-t,e,t,r.RGBA,r.UNSIGNED_BYTE,0);const o=r.fenceSync(r.SYNC_GPU_COMMANDS_COMPLETE,0);await new Promise(e=>{const t=()=>{if(r.clientWaitSync(o,r.SYNC_FLUSH_COMMANDS_BIT,0)!==r.TIMEOUT_EXPIRED)return r.deleteSync(o),r.getBufferSubData(r.PIXEL_PACK_BUFFER,0,a),e();requestAnimationFrame(t)};t()}),r.bindFramebuffer(r.FRAMEBUFFER,Z);for(let e=0;e<a.length;e+=4){const t=a[e+3];if(0===t||255===t)continue;const r=Yn[t];a[e]=Math.min(255,Math.round(a[e]*r)),a[e+1]=Math.min(255,Math.round(a[e+1]*r)),a[e+2]=Math.min(255,Math.round(a[e+2]*r))}return await createImageBitmap(new ImageData(new Uint8ClampedArray(a),e,t),{imageOrientation:"flipY",premultiplyAlpha:"none",colorSpaceConversion:"none"})})(e,t)}};class Hn{static setDevice(e){Hn.device=e}static getDevice(){if(!Hn.device)throw new Error("GPUDevice is not initialized");return Hn.device}static setDevicePixelRatio(e){Hn.devicePixelRatio=e}static getDevicePixelRatio(){return Hn.devicePixelRatio}static setRenderMaxSize(e){Hn.renderMaxSize=e}static getRenderMaxSize(){return Hn.renderMaxSize}static createFloat32Array(e){return new Float32Array(e)}static createArray(){return[]}static getFloat32Array4(){return Hn.float32Array4Pool.length>0?Hn.float32Array4Pool.pop():new Float32Array(4)}static poolFloat32Array4(e){4===e.length&&Hn.float32Array4Pool.push(e)}}Object.defineProperty(Hn,"device",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(Hn,"devicePixelRatio",{enumerable:!0,configurable:!0,writable:!0,value:1}),Object.defineProperty(Hn,"renderMaxSize",{enumerable:!0,configurable:!0,writable:!0,value:8192}),Object.defineProperty(Hn,"float32Array4Pool",{enumerable:!0,configurable:!0,writable:!0,value:[]});let Qn=null;const Zn=(e,t,r,n,i=.25)=>{const a=[],s=(e,t,r,n,o)=>{const l=((e,t,r,n)=>{const i=n.x-e.x,a=n.y-e.y,s=i*i+a*a;if(s<1e-10){const n=(t.x-e.x)*(t.x-e.x)+(t.y-e.y)*(t.y-e.y),i=(r.x-e.x)*(r.x-e.x)+(r.y-e.y)*(r.y-e.y);return Math.max(n,i)}const o=(t.x-e.x)*a-(t.y-e.y)*i,l=o*o/s,c=(r.x-e.x)*a-(r.y-e.y)*i,u=c*c/s;return Math.max(l,u)})(e,t,r,n);if(l<=i||o>=8){const e={x:.5*(t.x+r.x),y:.5*(t.y+r.y)};return void a.push({ctrl:e,end:n})}const c=((e,t,r,n)=>{const i={x:.5*(e.x+t.x),y:.5*(e.y+t.y)},a=.5*(t.x+r.x),s=.5*(t.y+r.y),o={x:.5*(r.x+n.x),y:.5*(r.y+n.y)},l={x:.5*(i.x+a),y:.5*(i.y+s)},c={x:.5*(a+o.x),y:.5*(s+o.y)},u={x:.5*(l.x+c.x),y:.5*(l.y+c.y)};return{first:[e,i,l,u],second:[u,c,o,n]}})(e,t,r,n);s(c.first[0],c.first[1],c.first[2],c.first[3],o+1),s(c.second[0],c.second[1],c.second[2],c.second[3],o+1)};return s(e,t,r,n,0),a};class Jn{constructor(){Object.defineProperty(this,"$currentPath",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$vertices",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$currentX",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$currentY",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$startX",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$startY",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$flatnessThreshold",{enumerable:!0,configurable:!0,writable:!0,value:.25}),this.$currentPath=[],this.$vertices=[],this.$currentX=0,this.$currentY=0,this.$startX=0,this.$startY=0}beginPath(){this.$currentPath=[],this.$vertices=[],this.$currentX=0,this.$currentY=0,this.$startX=0,this.$startY=0}moveTo(e,t){this.$currentPath.length>=6&&this.$vertices.push(this.$currentPath),this.$currentPath=[e,t,!1],this.$currentX=e,this.$currentY=t,this.$startX=e,this.$startY=t}lineTo(e,t){e===this.$currentX&&t===this.$currentY||(this.$currentPath.push(e,t,!1),this.$currentX=e,this.$currentY=t)}quadraticCurveTo(e,t,r,n){this.$currentPath.push(e,t,!0),this.$currentPath.push(r,n,!1),this.$currentX=r,this.$currentY=n}setScale(e){this.$flatnessThreshold=(e=>{const t=.25/(e*e);return Math.max(.0625,Math.min(4,t))})(e)}bezierCurveTo(e,t,r,n,i,a){const s={x:this.$currentX,y:this.$currentY},o=Zn(s,{x:e,y:t},{x:r,y:n},{x:i,y:a},this.$flatnessThreshold);for(const e of o)this.$currentPath.push(e.ctrl.x,e.ctrl.y,!0),this.$currentPath.push(e.end.x,e.end.y,!1);this.$currentX=i,this.$currentY=a}arc(e,t,r){const n=r,i=.5522847498307936*r;this.bezierCurveTo(e+n,t+i,e+i,t+n,e,t+n),this.bezierCurveTo(e-i,t+n,e-n,t+i,e-n,t),this.bezierCurveTo(e-n,t-i,e-i,t-n,e,t-n),this.bezierCurveTo(e+i,t-n,e+n,t-i,e+n,t);const a=this.$currentPath.length;a>=3&&(this.$currentPath[a-3]=this.$startX,this.$currentPath[a-2]=this.$startY),this.$currentX=this.$startX,this.$currentY=this.$startY}closePath(){this.$currentPath.length>=3&&(this.$currentX===this.$startX&&this.$currentY===this.$startY||this.$currentPath.push(this.$startX,this.$startY,!1))}get $getVertices(){const e=[...this.$vertices];return this.$currentPath.length>=9&&e.push(this.$currentPath),e}generateVertices(){const e=this.$getVertices,t=[];for(const r of e){if(r.length<9)continue;const e=[];for(let t=0;t<r.length;t+=3)e.push({x:r[t],y:r[t+1]});for(let r=1;r<e.length-1;r++)t.push(e[0].x,e[0].y,e[r].x,e[r].y,e[r+1].x,e[r+1].y)}return new Float32Array(t)}getCurrentPath(){const e=[];for(let t=0;t<this.$currentPath.length;t+=3)e.push({x:this.$currentPath[t],y:this.$currentPath[t+1]});return e}getAllPaths(){const e=[];for(const t of this.$vertices){const r=[];for(let e=0;e<t.length;e+=3)r.push({x:t[e],y:t[e+1]});r.length>0&&e.push(r)}if(this.$currentPath.length>=3){const t=[];for(let e=0;e<this.$currentPath.length;e+=3)t.push({x:this.$currentPath[e],y:this.$currentPath[e+1]});t.length>0&&e.push(t)}return e}getVerticesForStroke(){const e=[...this.$vertices];return this.$currentPath.length>=6&&e.push(this.$currentPath),e}reset(){this.$currentPath=[],this.$vertices=[],this.$currentX=0,this.$currentY=0,this.$startX=0,this.$startY=0}}const ei=(e,t)=>{const r=t.size;let n=e.get(r);n||(n=[],e.set(r,n)),n.length>=32?t.destroy():n.push(t)},ti=(e,t)=>{const r=t.size;let n=e.get(r);n||(n=[],e.set(r,n)),n.length>=32?t.destroy():n.push(t)},ri=(e,t,r,n)=>{const i=256*Math.ceil(r/256);let a=null,s=1/0;for(const e of t)if(!e.inUse&&e.size>=i){const t=e.size-i;t<s&&(a=e,s=t)}if(a)return a.inUse=!0,a.lastUsedFrame=n,a.buffer;const o=Math.max(i,16384),l=((e,t)=>e.createBuffer({size:t.size,usage:t.usage|GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_DST|GPUBufferUsage.VERTEX,label:t.label||"storage_buffer"}))(e,{size:o,usage:GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_DST|GPUBufferUsage.VERTEX,label:`storage_buffer_${t.length}`});return t.push({buffer:l,size:o,inUse:!0,lastUsedFrame:n}),l},ni=(e,t,r,n=0,i=0)=>{const a=new Uint32Array([t,r,n,i]),s=e.createBuffer({size:a.byteLength,usage:GPUBufferUsage.INDIRECT|GPUBufferUsage.COPY_DST,mappedAtCreation:!0,label:"indirect_buffer"});return new Uint32Array(s.getMappedRange()).set(a),s.unmap(),s},ii=(e,t,r,n,i=0,a=0)=>{const s=new Uint32Array([r,n,i,a]);e.queue.writeBuffer(t,0,s)};class ai{constructor(e,t=65536){Object.defineProperty(this,"device",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"buffer",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"offset",{enumerable:!0,configurable:!0,writable:!0,value:0}),Object.defineProperty(this,"capacity",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"alignment",{enumerable:!0,configurable:!0,writable:!0,value:256}),Object.defineProperty(this,"pendingDestroyBuffers",{enumerable:!0,configurable:!0,writable:!0,value:[]}),Object.defineProperty(this,"stagingBuffer",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"stagingFloat32",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"dirtyEnd",{enumerable:!0,configurable:!0,writable:!0,value:0}),this.device=e,this.capacity=t,this.stagingBuffer=new ArrayBuffer(t),this.stagingFloat32=new Float32Array(this.stagingBuffer)}resetFrame(){this.offset=0,this.dirtyEnd=0;for(const e of this.pendingDestroyBuffers)e.destroy();this.pendingDestroyBuffers.length=0}getBuffer(){return this.buffer||(this.buffer=this.device.createBuffer({size:this.capacity,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST})),this.buffer}allocate(e){this.buffer||this.getBuffer();const t=this.offset,r=e.byteLength;if(t+r>this.capacity){this.flush(),this.capacity*=2;const e=this.buffer;this.buffer=this.device.createBuffer({size:this.capacity,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST}),e&&this.pendingDestroyBuffers.push(e),this.stagingBuffer=new ArrayBuffer(this.capacity),this.stagingFloat32=new Float32Array(this.stagingBuffer)}this.stagingFloat32.set(e,t/4);const n=t+r;return n>this.dirtyEnd&&(this.dirtyEnd=n),this.offset=t+Math.ceil(r/this.alignment)*this.alignment,t}flush(){this.dirtyEnd>0&&this.buffer&&(this.device.queue.writeBuffer(this.buffer,0,this.stagingBuffer,0,this.dirtyEnd),this.dirtyEnd=0)}dispose(){this.buffer&&(this.buffer.destroy(),this.buffer=null);for(const e of this.pendingDestroyBuffers)e.destroy();this.pendingDestroyBuffers.length=0}}class si{constructor(e){Object.defineProperty(this,"device",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"vertexBuffers",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"uniformBuffers",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"vertexBufferBuckets",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"uniformBufferBuckets",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"storageBufferPool",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"indirectBuffer",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"indirectBufferPool",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"frameIndirectBuffers",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"frameNumber",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"unitRectBuffer",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"frameVertexPoolBuffers",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"frameUniformPoolBuffers",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"dynamicUniform",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.device=e,this.vertexBuffers=new Map,this.uniformBuffers=new Map,this.vertexBufferBuckets=new Map,this.uniformBufferBuckets=new Map,this.storageBufferPool=[],this.indirectBuffer=null,this.indirectBufferPool=[],this.frameIndirectBuffers=[],this.frameNumber=0,this.unitRectBuffer=null,this.frameVertexPoolBuffers=[],this.frameUniformPoolBuffers=[],this.dynamicUniform=new ai(e)}createVertexBuffer(e,t){const r=this.device.createBuffer({size:t.byteLength,usage:GPUBufferUsage.VERTEX|GPUBufferUsage.COPY_DST,mappedAtCreation:!0});return new Float32Array(r.getMappedRange()).set(t),r.unmap(),this.vertexBuffers.set(e,r),r}createUniformBuffer(e,t){const r=this.device.createBuffer({size:t,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});return this.uniformBuffers.set(e,r),r}updateUniformBuffer(e,t){const r=this.uniformBuffers.get(e);r&&this.device.queue.writeBuffer(r,0,t.buffer,t.byteOffset,t.byteLength)}getVertexBuffer(e){return this.vertexBuffers.get(e)}getUniformBuffer(e){return this.uniformBuffers.get(e)}createRectVertices(e,t,r,n){return((e,t,r,n)=>new Float32Array([e,t,0,0,e+r,t,1,0,e,t+n,0,1,e+r,t,1,0,e+r,t+n,1,1,e,t+n,0,1]))(e,t,r,n)}acquireVertexBuffer(e,t){const r=((e,t,r,n)=>{const i=(a=r,a--,a|=a>>1,a|=a>>2,a|=a>>4,a|=a>>8,1+(a|=a>>16));var a;const s=t.get(i);let o;return s&&s.length>0?(o=s.pop(),n&&e.queue.writeBuffer(o,0,n.buffer,n.byteOffset,n.byteLength)):n?(o=e.createBuffer({size:i,usage:GPUBufferUsage.VERTEX|GPUBufferUsage.COPY_DST,mappedAtCreation:!0}),new Float32Array(o.getMappedRange()).set(n),o.unmap()):o=e.createBuffer({size:i,usage:GPUBufferUsage.VERTEX|GPUBufferUsage.COPY_DST}),o})(this.device,this.vertexBufferBuckets,e,t);return this.frameVertexPoolBuffers.push(r),r}releaseVertexBuffer(e){ei(this.vertexBufferBuckets,e)}acquireUniformBuffer(e){const t=((e,t,r)=>{const n=16*Math.ceil(r/16),i=t.get(n);return i&&i.length>0?i.pop():e.createBuffer({size:n,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST})})(this.device,this.uniformBufferBuckets,e);return this.frameUniformPoolBuffers.push(t),t}acquireAndWriteUniformBuffer(e,t){const r=t??e.byteLength,n=this.acquireUniformBuffer(r);return this.device.queue.writeBuffer(n,0,e.buffer,e.byteOffset,r),n}releaseUniformBuffer(e){ti(this.uniformBufferBuckets,e)}destroyBuffer(e){const t=this.vertexBuffers.get(e);t&&(t.destroy(),this.vertexBuffers.delete(e));const r=this.uniformBuffers.get(e);r&&(r.destroy(),this.uniformBuffers.delete(e))}dispose(){for(const e of this.vertexBuffers.values())e.destroy();this.vertexBuffers.clear();for(const e of this.uniformBuffers.values())e.destroy();this.uniformBuffers.clear();for(const e of this.vertexBufferBuckets.values())for(const t of e)t.destroy();this.vertexBufferBuckets.clear();for(const e of this.uniformBufferBuckets.values())for(const t of e)t.destroy();this.uniformBufferBuckets.clear();for(const e of this.storageBufferPool)e.buffer.destroy();this.storageBufferPool=[],this.indirectBuffer&&(this.indirectBuffer.destroy(),this.indirectBuffer=null);for(const e of this.indirectBufferPool)e.destroy();this.indirectBufferPool=[];for(const e of this.frameIndirectBuffers)e.destroy();this.frameIndirectBuffers=[],this.unitRectBuffer&&(this.unitRectBuffer.destroy(),this.unitRectBuffer=null),this.frameVertexPoolBuffers.length=0,this.frameUniformPoolBuffers.length=0,this.dynamicUniform.dispose()}getPoolStats(){let e=0;for(const t of this.vertexBufferBuckets.values())e+=t.length;let t=0;for(const e of this.uniformBufferBuckets.values())t+=e.length;return{vertexPoolSize:e,uniformPoolSize:t}}clearFrameBuffers(){for(const e of this.vertexBuffers.values())e.destroy();this.vertexBuffers.clear();for(const e of this.uniformBuffers.values())e.destroy();this.uniformBuffers.clear();for(const e of this.frameVertexPoolBuffers)ei(this.vertexBufferBuckets,e);this.frameVertexPoolBuffers.length=0;for(const e of this.frameUniformPoolBuffers)ti(this.uniformBufferBuckets,e);this.frameUniformPoolBuffers.length=0;for(const e of this.frameIndirectBuffers)this.indirectBufferPool.push(e);this.frameIndirectBuffers.length=0,this.releaseAllStorageBuffers(),this.dynamicUniform.resetFrame(),this.frameNumber++,this.frameNumber%60==0&&((e,t,r=60)=>{for(let n=e.length-1;n>=0;n--){const i=e[n];!i.inUse&&t-i.lastUsedFrame>r&&(i.buffer.destroy(),e.splice(n,1))}})(this.storageBufferPool,this.frameNumber)}releaseAllStorageBuffers(){for(const e of this.storageBufferPool)e.inUse=!1}acquireStorageBuffer(e){return ri(this.device,this.storageBufferPool,e,this.frameNumber)}releaseStorageBuffer(e){((e,t)=>{for(const r of e)if(r.buffer===t)return void(r.inUse=!1)})(this.storageBufferPool,e)}writeStorageBuffer(e,t){this.device.queue.writeBuffer(e,0,t.buffer,t.byteOffset,t.byteLength)}getOrCreateIndirectBuffer(e,t,r=0,n=0){return this.indirectBuffer?ii(this.device,this.indirectBuffer,e,t,r,n):this.indirectBuffer=ni(this.device,e,t,r,n),this.indirectBuffer}createIndirectBuffer(e,t,r=0,n=0){let i=this.indirectBufferPool.pop();return i?ii(this.device,i,e,t,r,n):i=ni(this.device,e,t,r,n),this.frameIndirectBuffers.push(i),i}getUnitRectBuffer(){if(!this.unitRectBuffer){const e=this.createRectVertices(0,0,1,1);this.unitRectBuffer=this.device.createBuffer({size:e.byteLength,usage:GPUBufferUsage.VERTEX|GPUBufferUsage.COPY_DST,mappedAtCreation:!0}),new Float32Array(this.unitRectBuffer.getMappedRange()).set(e),this.unitRectBuffer.unmap()}return this.unitRectBuffer}getFrameNumber(){return this.frameNumber}getStoragePoolStats(){const e=this.storageBufferPool.filter(e=>e.inUse).length;return{storagePoolSize:this.storageBufferPool.length,storagePoolInUse:e}}}class oi{constructor(e){Object.defineProperty(this,"device",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"textures",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"samplers",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.device=e,this.textures=new Map,this.samplers=new Map,((e,t)=>{const r=e.createSampler({magFilter:"linear",minFilter:"linear",mipmapFilter:"linear",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"});t.set("linear",r);const n=e.createSampler({magFilter:"nearest",minFilter:"nearest",mipmapFilter:"nearest",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"});t.set("nearest",n);const i=e.createSampler({magFilter:"nearest",minFilter:"linear",mipmapFilter:"nearest",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"});t.set("atlas_instanced_sampler",i);const a=e.createSampler({magFilter:"linear",minFilter:"linear",mipmapFilter:"linear",addressModeU:"repeat",addressModeV:"repeat"});t.set("repeat",a)})(e,this.samplers)}createTexture(e,t,r,n="rgba8unorm"){const i=this.device.createTexture({size:{width:t,height:r},format:n,usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.RENDER_ATTACHMENT});return this.textures.set(e,i),i}createTextureFromPixels(e,t,r,n){return((e,t,r,n,i,a)=>{const s=e.createTexture({size:{width:i,height:a},format:"rgba8unorm",usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.RENDER_ATTACHMENT});return e.queue.writeTexture({texture:s},n.buffer,{bytesPerRow:4*i,offset:n.byteOffset},{width:i,height:a}),t.set(r,s),s})(this.device,this.textures,e,t,r,n)}createTextureFromImageBitmap(e,t){return((e,t,r,n)=>{const i=e.createTexture({size:{width:n.width,height:n.height},format:"rgba8unorm",usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.RENDER_ATTACHMENT});return e.queue.copyExternalImageToTexture({source:n,flipY:!0},{texture:i,premultipliedAlpha:!0},{width:n.width,height:n.height}),t.set(r,i),i})(this.device,this.textures,e,t)}updateTexture(e,t,r,n){const i=this.textures.get(e);i&&this.device.queue.writeTexture({texture:i},t.buffer,{bytesPerRow:4*r,offset:t.byteOffset},{width:r,height:n})}getTexture(e){return this.textures.get(e)}getSampler(e){return this.samplers.get(e)}createSampler(e,t=!0){const r=this.samplers.get(e);if(r)return r;const n=this.device.createSampler({magFilter:t?"linear":"nearest",minFilter:t?"linear":"nearest",mipmapFilter:t?"linear":"nearest",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"});return this.samplers.set(e,n),n}destroyTexture(e){const t=this.textures.get(e);t&&(t.destroy(),this.textures.delete(e))}dispose(){for(const e of this.textures.values())e.destroy();this.textures.clear(),this.samplers.clear()}}const li={r:0,g:0,b:0,a:0},ci={view:null,clearValue:li,loadOp:"clear",storeOp:"store"},ui={colorAttachments:[ci]},fi={view:null,clearValue:{r:0,g:0,b:0,a:0},loadOp:"load",storeOp:"store"},di={view:null,stencilClearValue:0,stencilLoadOp:"clear",stencilStoreOp:"store"},hi={colorAttachments:[fi],depthStencilAttachment:di};class pi{constructor(e){Object.defineProperty(this,"device",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"buckets",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"currentFrame",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"totalCount",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.device=e,this.buckets=new Map,this.currentFrame=0,this.totalCount=[0]}beginFrame(){this.currentFrame++,this.currentFrame%60==0&&((e,t,r,n)=>{const i=t-r;for(const[t,r]of e){for(let e=r.length-1;e>=0;e--){const t=r[e];!t.inUse&&t.lastUsedFrame<i&&(t.texture.destroy(),r.splice(e,1),n[0]--)}0===r.length&&e.delete(t)}})(this.buckets,this.currentFrame,180,this.totalCount)}acquire(e,t,r="rgba8unorm",n=GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.RENDER_ATTACHMENT){return((e,t,r,n,i,a,s,o,l)=>{const c=((e,t,r)=>`${e}_${t}_${r}`)(r,n,i),u=t.get(c);if(u)for(let e=0;e<u.length;e++){const t=u[e];if(!t.inUse)return t.inUse=!0,t.lastUsedFrame=s,t.texture}if(l[0]>=o){let e=1/0,r="",n=-1;for(const[i,a]of t)for(let t=0;t<a.length;t++){const s=a[t];!s.inUse&&s.lastUsedFrame<e&&(e=s.lastUsedFrame,r=i,n=t)}if(n>=0){const e=t.get(r);e[n].texture.destroy(),e.splice(n,1),0===e.length&&t.delete(r),l[0]--}}const f=e.createTexture({size:{width:r,height:n},format:i,usage:a}),d={texture:f,width:r,height:n,format:i,lastUsedFrame:s,inUse:!0};return u?u.push(d):t.set(c,[d]),l[0]++,f})(this.device,this.buckets,e,t,r,n,this.currentFrame,32,this.totalCount)}release(e){((e,t,r)=>{for(const n of e.values())for(let e=0;e<n.length;e++)if(n[e].texture===t)return n[e].inUse=!1,void(n[e].lastUsedFrame=r)})(this.buckets,e,this.currentFrame)}getStats(){let e=0,t=0;for(const r of this.buckets.values())for(const n of r)n.inUse?e++:t++;return{total:this.totalCount[0],inUse:e,available:t}}dispose(){for(const e of this.buckets.values())for(const t of e)t.texture.destroy();this.buckets.clear(),this.totalCount[0]=0}}class mi{constructor(e,t){Object.defineProperty(this,"device",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"format",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"attachments",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"currentAttachment",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"idCounter",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"texturePool",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"pendingReleases",{enumerable:!0,configurable:!0,writable:!0,value:[]}),this.device=e,this.format=t,this.attachments=new Map,this.currentAttachment=null,this.idCounter={nextId:1,textureId:1,stencilId:1},this.texturePool=new pi(e)}beginFrame(){this.texturePool.beginFrame()}createAttachment(e,t,r,n=!1,i=!1){return((e,t,r,n,i,a,s,o,l)=>{const c="atlas"===n||n.startsWith("atlas_"),u=c||n.startsWith("temp_")?"rgba8unorm":t,f=s||c&&!0,d=f?4:1,h=e.createTexture({size:{width:i,height:a},format:u,usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC|GPUTextureUsage.COPY_DST}),p=h.createView(),m={id:l.textureId++,resource:h,view:p,width:i,height:a,area:i*a,smooth:!0};let g=null;if(f){const t=e.createTexture({size:{width:i,height:a},format:u,sampleCount:d,usage:GPUTextureUsage.RENDER_ATTACHMENT}),r=t.createView();g={id:l.textureId++,resource:t,view:r,width:i,height:a,area:i*a,smooth:!0}}let b=null,x=null;if(c||"main"===n||o){const t=e.createTexture({size:{width:i,height:a},format:"stencil8",usage:GPUTextureUsage.RENDER_ATTACHMENT}),r=t.createView();if(b={id:l.stencilId++,resource:t,view:r,width:i,height:a,area:i*a,dirty:!1},f){const t=e.createTexture({size:{width:i,height:a},format:"stencil8",sampleCount:d,usage:GPUTextureUsage.RENDER_ATTACHMENT}),r=t.createView();x={id:l.stencilId++,resource:t,view:r,width:i,height:a,area:i*a,dirty:!1}}}const v={id:l.nextId++,width:i,height:a,clipLevel:0,msaa:f,mask:o,color:null,texture:m,stencil:b,msaaTexture:g,msaaStencil:x};return r.set(n,v),v})(this.device,this.format,this.attachments,e,t,r,n,i,this.idCounter)}getAttachment(e){return this.attachments.get(e)}setCurrentAttachment(e){this.currentAttachment=e}getCurrentAttachment(){return this.currentAttachment}createRenderPassDescriptor(e,t=0,r=0,n=0,i=0,a="clear",s=null){return((e,t=0,r=0,n=0,i=0,a="clear",s=null)=>(ci.view=e,li.r=t,li.g=r,li.b=n,li.a=i,ci.loadOp=a,ci.resolveTarget=s??void 0,ui))(e,t,r,n,i,a,s)}createStencilRenderPassDescriptor(e,t,r="load",n="clear",i=null){return((e,t,r="load",n="clear",i=null)=>(fi.view=e,fi.loadOp=r,fi.resolveTarget=i??void 0,di.view=t,di.stencilLoadOp=n,hi))(e,t,r,n,i)}destroyAttachment(e){const t=this.attachments.get(e);t&&(t.texture&&t.texture.resource.destroy(),t.stencil&&t.stencil.resource.destroy(),this.attachments.delete(e))}resizeAttachment(e,t,r){return this.destroyAttachment(e),this.createAttachment(e,t,r)}createTemporaryAttachment(e,t){const r=`temp_${this.idCounter.nextId}`,n=GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC|GPUTextureUsage.COPY_DST|GPUTextureUsage.STORAGE_BINDING,i=this.texturePool.acquire(e,t,"rgba8unorm",n),a=i.createView(),s={id:this.idCounter.textureId++,resource:i,view:a,width:e,height:t,area:e*t,smooth:!0},o={id:this.idCounter.nextId++,width:e,height:t,clipLevel:0,msaa:!1,mask:!1,color:null,texture:s,stencil:null,msaaTexture:null,msaaStencil:null};return this.attachments.set(r,o),o}releaseTemporaryAttachment(e){((e,t,r)=>{for(const[n,i]of e.entries())if(i.id===r.id){e.delete(n),t.push(i);break}})(this.attachments,this.pendingReleases,e)}flushPendingReleases(){for(const e of this.pendingReleases)e.texture&&this.texturePool.release(e.texture.resource),e.msaaTexture&&e.msaaTexture.resource.destroy(),e.stencil&&e.stencil.resource.destroy(),e.msaaStencil&&e.msaaStencil.resource.destroy();this.pendingReleases=[]}dispose(){for(const e of this.attachments.values())e.texture&&e.texture.resource.destroy(),e.stencil&&e.stencil.resource.destroy();this.attachments.clear(),this.currentAttachment=null,this.texturePool.dispose()}}const gi=(e,t,r,n,i)=>{for(let e=0;e<t.length;e++){const i=t[e];if(i.width>=r&&i.height>=n)return t.splice(e,1),i.dirty=!1,i}return((e,t,r,n)=>{const i=e.createTexture({size:{width:t,height:r},format:"depth24plus-stencil8",usage:GPUTextureUsage.RENDER_ATTACHMENT});return{id:n.stencilId++,resource:i,view:i.createView(),width:t,height:r,area:t*r,dirty:!1}})(e,r,n,i)},bi=(e,t,r,n,i)=>{for(let e=0;e<t.length;e++){const a=t[e];if(a.width>=r&&a.height>=n)return t.splice(e,1),a.stencil=i,a.dirty=!1,a}return((e,t,r,n)=>{const i=e.createTexture({size:{width:t,height:r},format:"rgba8unorm",usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC|GPUTextureUsage.COPY_DST});return{resource:i,view:i.createView(),stencil:n,width:t,height:r,area:t*r,dirty:!1}})(e,r,n,i)},xi=(e,t,r,n,i,a)=>{const s=`${r}x${n}_smooth`;if(t.has(s)){const e=t.get(s);if(e.length>0)return e.pop()}return((e,t,r,n,i)=>{const a=e.createTexture({size:{width:t,height:r},format:"rgba8unorm",usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_SRC|GPUTextureUsage.COPY_DST}),s=a.createView();return{id:i.textureId++,resource:a,view:s,width:t,height:r,area:t*r,smooth:n}})(e,r,n,i,a)},vi={r:0,g:0,b:0,a:0},yi={view:null,loadOp:"clear",storeOp:"store",clearValue:vi},_i={view:null,depthLoadOp:"clear",depthStoreOp:"store",depthClearValue:1,stencilLoadOp:"clear",stencilStoreOp:"store",stencilClearValue:0},wi={colorAttachments:[yi]};class Mi{constructor(e){Object.defineProperty(this,"device",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"attachmentPool",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"texturePool",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"colorBufferPool",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"stencilBufferPool",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"idCounter",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"currentAttachment",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.device=e,this.attachmentPool=[],this.texturePool=new Map,this.colorBufferPool=[],this.stencilBufferPool=[],this.idCounter={attachmentId:0,textureId:0,stencilId:0},this.currentAttachment=null}getAttachmentObject(e,t,r=!1){return((e,t,r,n,i,a,s,o,l)=>{const c=t.length>0?t.pop():(e=>({id:e.attachmentId++,width:0,height:0,clipLevel:0,msaa:!1,mask:!1,color:null,texture:null,stencil:null,msaaTexture:null,msaaStencil:null}))(l);c.width=a,c.height=s,c.msaa=o,c.mask=!1,c.clipLevel=0;const u=gi(e,i,a,s,l),f=bi(e,n,a,s,u);c.color=f,c.stencil=u;const d=xi(e,r,a,s,!0,l);return c.texture=d,c})(this.device,this.attachmentPool,this.texturePool,this.colorBufferPool,this.stencilBufferPool,e,t,r,this.idCounter)}bindAttachment(e){this.currentAttachment=e}getCurrentAttachment(){return this.currentAttachment}get currentAttachmentObject(){return this.currentAttachment}unbindAttachment(){this.currentAttachment=null}releaseAttachment(e){((e,t,r,n,i)=>{i.texture&&(((e,t)=>{const r=`${t.width}x${t.height}_${t.smooth?"smooth":"nearest"}`;e.has(r)||e.set(r,[]),e.get(r).push(t)})(t,i.texture),i.texture=null),i.color&&(r.push(i.color),i.color=null),i.stencil&&(n.push(i.stencil),i.stencil=null),e.push(i)})(this.attachmentPool,this.texturePool,this.colorBufferPool,this.stencilBufferPool,e)}createRenderPassDescriptor(e,t,r,n,i,a="clear"){return((e,t,r,n,i,a="clear")=>{const s=e.color?.view??e.texture?.view;if(!s)throw new Error("No color view available for render pass");return yi.view=s,yi.loadOp=a,vi.r=t,vi.g=r,vi.b=n,vi.a=i,e.stencil?.view?(_i.view=e.stencil.view,wi.depthStencilAttachment=_i):wi.depthStencilAttachment=void 0,wi})(e,t,r,n,i,a)}dispose(){for(const e of this.texturePool.values())for(const t of e)t.resource.destroy();this.texturePool.clear();for(const e of this.colorBufferPool)e.resource.destroy();this.colorBufferPool=[];for(const e of this.stencilBufferPool)e.resource.destroy();this.stencilBufferPool=[];for(const e of this.attachmentPool)e.texture&&e.texture.resource.destroy(),e.color&&e.color.resource.destroy(),e.stencil&&e.stencil.resource.destroy();this.attachmentPool=[]}}const Pi="\noverride yFlipSign: f32 = 1.0;\n\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) bezier: vec2<f32>,\n    @location(1) color: vec4<f32>,\n}\n\nstruct FillUniforms {\n    color: vec4<f32>,\n    matrix0: vec4<f32>,\n    matrix1: vec4<f32>,\n    matrix2: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: FillUniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let matrix = mat3x3<f32>(uniforms.matrix0.xyz, uniforms.matrix1.xyz, uniforms.matrix2.xyz);\n    let transformed = matrix * vec3<f32>(input.position, 1.0);\n    let ndc = transformed.xy * 2.0 - 1.0;\n    output.position = vec4<f32>(ndc.x, ndc.y * yFlipSign, 0.0, 1.0);\n    output.bezier = input.bezier;\n    output.color = uniforms.color;\n    return output;\n}\n",Si="\noverride yFlipSign: f32 = 1.0;\n\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) bezier: vec2<f32>,\n}\n\nstruct FillUniforms {\n    color: vec4<f32>,\n    matrix0: vec4<f32>,\n    matrix1: vec4<f32>,\n    matrix2: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: FillUniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let matrix = mat3x3<f32>(uniforms.matrix0.xyz, uniforms.matrix1.xyz, uniforms.matrix2.xyz);\n    let transformed = matrix * vec3<f32>(input.position, 1.0);\n    let ndc = transformed.xy * 2.0 - 1.0;\n    output.position = vec4<f32>(ndc.x, ndc.y * yFlipSign, 0.0, 1.0);\n    output.bezier = input.bezier;\n    return output;\n}\n",Fi="\noverride yFlipSign: f32 = 1.0;\n\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) color: vec4<f32>,\n}\n\nstruct FillUniforms {\n    color: vec4<f32>,\n    matrix0: vec4<f32>,\n    matrix1: vec4<f32>,\n    matrix2: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: FillUniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let matrix = mat3x3<f32>(uniforms.matrix0.xyz, uniforms.matrix1.xyz, uniforms.matrix2.xyz);\n    let transformed = matrix * vec3<f32>(input.position, 1.0);\n    let ndc = transformed.xy * 2.0 - 1.0;\n    output.position = vec4<f32>(ndc.x, ndc.y * yFlipSign, 0.0, 1.0);\n    output.color = uniforms.color;\n    return output;\n}\n",Ti="\noverride yFlipSign: f32 = 1.0;\n\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) texCoord: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n    @location(1) color: vec4<f32>,\n}\n\nstruct Uniforms {\n    matrix: mat3x3<f32>,\n    color: vec4<f32>,\n    alpha: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: Uniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let pos = uniforms.matrix * vec3<f32>(input.position, 1.0);\n    let ndc = pos.xy * 2.0 - 1.0;\n    output.position = vec4<f32>(ndc.x, ndc.y * yFlipSign, 0.0, 1.0);\n    output.texCoord = input.texCoord;\n    let premultipliedColor = vec4<f32>(\n        uniforms.color.rgb * uniforms.color.a * uniforms.alpha,\n        uniforms.color.a * uniforms.alpha\n    );\n    output.color = premultipliedColor;\n    return output;\n}\n",Bi="\noverride yFlipSign: f32 = 1.0;\n\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) v_uv: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n    @location(2) color: vec4<f32>,\n}\n\nstruct GradientUniforms {\n    inverseMatrix: mat3x3<f32>,\n    gradientType: f32,\n    focal: f32,\n    spread: f32,\n    radius: f32,\n    linearPoints: vec4<f32>,\n    color: vec4<f32>,\n    contextMatrix0: vec4<f32>,\n    contextMatrix1: vec4<f32>,\n    contextMatrix2: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> gradient: GradientUniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let contextMatrix = mat3x3<f32>(gradient.contextMatrix0.xyz, gradient.contextMatrix1.xyz, gradient.contextMatrix2.xyz);\n    let pos = contextMatrix * vec3<f32>(input.position, 1.0);\n    let ndc = vec2<f32>(pos.x * 2.0 - 1.0, pos.y * 2.0 - 1.0);\n    output.position = vec4<f32>(ndc.x, ndc.y * yFlipSign, 0.0, 1.0);\n    let uvPos = gradient.inverseMatrix * vec3<f32>(input.position, 1.0);\n    output.v_uv = uvPos.xy;\n    output.bezier = input.bezier;\n    output.color = gradient.color;\n    return output;\n}\n",Oi="\noverride yFlipSign: f32 = 1.0;\n\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) bezier: vec2<f32>,\n    @location(1) color: vec4<f32>,\n    @location(2) worldPos: vec2<f32>,\n}\n\nstruct BitmapUniforms {\n    bitmapMatrix: mat3x3<f32>,\n    width: f32,\n    height: f32,\n    repeat: f32,\n    _pad: f32,\n    color: vec4<f32>,\n    contextMatrix0: vec4<f32>,\n    contextMatrix1: vec4<f32>,\n    contextMatrix2: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> bitmap: BitmapUniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let matrix = mat3x3<f32>(bitmap.contextMatrix0.xyz, bitmap.contextMatrix1.xyz, bitmap.contextMatrix2.xyz);\n    let transformedPos = matrix * vec3<f32>(input.position, 1.0);\n    let clipX = transformedPos.x * 2.0 - 1.0;\n    let clipY = (transformedPos.y * 2.0 - 1.0) * yFlipSign;\n    output.position = vec4<f32>(clipX, clipY, 0.0, 1.0);\n    output.bezier = input.bezier;\n    output.color = bitmap.color;\n    output.worldPos = input.position;\n    return output;\n}\n",Ai="\nfn isInside(uv: vec2<f32>) -> f32 {\n    let s = step(vec2<f32>(0.0), uv) * step(uv, vec2<f32>(1.0));\n    return s.x * s.y;\n}",Ri="\n    const vertices = array<vec2<f32>, 6>(\n        vec2<f32>(0.0, 0.0),\n        vec2<f32>(1.0, 0.0),\n        vec2<f32>(0.0, 1.0),\n        vec2<f32>(0.0, 1.0),\n        vec2<f32>(1.0, 0.0),\n        vec2<f32>(1.0, 1.0)\n    );",Ci="\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}",Ei=e=>`\n${Ci}\n\n@vertex\nfn main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {\n    var output: VertexOutput;\n\n    const positions = array<vec2<f32>, 6>(\n        vec2<f32>(-1.0, -1.0),\n        vec2<f32>( 1.0, -1.0),\n        vec2<f32>(-1.0,  1.0),\n        vec2<f32>(-1.0,  1.0),\n        vec2<f32>( 1.0, -1.0),\n        vec2<f32>( 1.0,  1.0)\n    );\n    var texCoords = array<vec2<f32>, 6>(\n        vec2<f32>(0.0, ${e?"1.0":"0.0"}),\n        vec2<f32>(1.0, ${e?"1.0":"0.0"}),\n        vec2<f32>(0.0, ${e?"0.0":"1.0"}),\n        vec2<f32>(0.0, ${e?"0.0":"1.0"}),\n        vec2<f32>(1.0, ${e?"1.0":"0.0"}),\n        vec2<f32>(1.0, ${e?"0.0":"1.0"})\n    );\n    output.position = vec4<f32>(positions[vertexIndex], 0.0, 1.0);\n    output.texCoord = texCoords[vertexIndex];\n    return output;\n}\n`,Ui=Ei(!0),$i=Ei(!1),Gi=Ei(!1),ki=`\nstruct PositionUniforms {\n    offset: vec2<f32>,\n    size: vec2<f32>,\n    viewport: vec2<f32>,\n    padding: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: PositionUniforms;\n\n@vertex\nfn main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {\n    var output: VertexOutput;\n${Ri}\n    let vertex = vertices[vertexIndex];\n    output.texCoord = vec2<f32>(vertex.x, 1.0 - vertex.y);\n    var position = vertex * uniforms.size + uniforms.offset;\n    position = position / uniforms.viewport;\n    position = position * 2.0 - 1.0;\n    output.position = vec4<f32>(position.x, -position.y, 0.0, 1.0);\n    return output;\n}\n`,Li=`\nstruct BitmapSyncUniforms {\n    nodeRect: vec4<f32>,\n    textureSize: vec2<f32>,\n    padding: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: BitmapSyncUniforms;\n\n@vertex\nfn main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {\n    var output: VertexOutput;\n${Ri}\n    let vertex = vertices[vertexIndex];\n    let pixelPos = vec2<f32>(\n        uniforms.nodeRect.x + vertex.x * uniforms.nodeRect.z,\n        uniforms.nodeRect.y + vertex.y * uniforms.nodeRect.w\n    );\n    let ndc = pixelPos / uniforms.textureSize * 2.0 - 1.0;\n    output.position = vec4<f32>(ndc.x, -ndc.y, 0.0, 1.0);\n    output.texCoord = pixelPos / uniforms.textureSize;\n    return output;\n}\n`,Ii=e=>`\n\nstruct ScaleUniforms {\n    matrix: vec4<f32>,\n    translate: vec2<f32>,\n    srcSize: vec2<f32>,\n    dstSize: vec2<f32>,\n    padding: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: ScaleUniforms;\n\n\n@vertex\nfn main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {\n    var output: VertexOutput;\n${Ri}\n    let vertex = vertices[vertexIndex];\n    output.texCoord = ${e?"vec2<f32>(vertex.x, 1.0 - vertex.y)":"vertex"};\n\n    var pos = vertex * uniforms.srcSize;\n    let a = uniforms.matrix.x;\n    let b = uniforms.matrix.y;\n    let c = uniforms.matrix.z;\n    let d = uniforms.matrix.w;\n    let tx = uniforms.translate.x;\n    let ty = uniforms.translate.y;\n    let transformedX = pos.x * a + pos.y * c + tx;\n    let transformedY = pos.x * b + pos.y * d + ty;\n    var position = vec2<f32>(transformedX, transformedY) / uniforms.dstSize;\n    position = position * 2.0 - 1.0;\n    output.position = vec4<f32>(position.x, -position.y, 0.0, 1.0);\n\n    return output;\n}\n`,Vi=Ii(!1),zi=Ii(!0),ji=Ii(!1),Di=e=>`\nstruct PositionUniforms {\n    offset: vec2<f32>,\n    size: vec2<f32>,\n    viewport: vec2<f32>,\n    padding: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: PositionUniforms;\n\n@vertex\nfn main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {\n    var output: VertexOutput;\n${Ri}\n    let vertex = vertices[vertexIndex];\n    output.texCoord = ${e?"vec2<f32>(vertex.x, 1.0 - vertex.y)":"vertex"};\n    var position = vertex * uniforms.size + uniforms.offset;\n    position = position / uniforms.viewport;\n    position = position * 2.0 - 1.0;\n    output.position = vec4<f32>(position.x, -position.y, 0.0, 1.0);\n    return output;\n}\n`,Ni=Di(!1),Wi=Di(!0),qi="\nstruct GradientUniforms {\n    inverseMatrix: mat3x3<f32>,\n    gradientType: f32,\n    focal: f32,\n    spread: f32,\n    radius: f32,\n    linearPoints: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> gradient: GradientUniforms;\n@group(0) @binding(1) var gradientSampler: sampler;\n@group(0) @binding(2) var gradientTexture: texture_2d<f32>;\n\noverride GRADIENT_TYPE: u32 = 0u;\noverride SPREAD_MODE: u32 = 2u;\n\nfn applySpread(t: f32) -> f32 {\n    if (SPREAD_MODE == 0u) {\n        return 1.0 - abs(fract(t * 0.5) * 2.0 - 1.0);\n    } else if (SPREAD_MODE == 1u) {\n        return fract(t);\n    } else {\n        return clamp(t, 0.0, 1.0);\n    }\n}\n",Xi="\n    var t: f32;\n    if (GRADIENT_TYPE == 0u) {\n        let a = gradient.linearPoints.xy;\n        let b = gradient.linearPoints.zw;\n        let ab = b - a;\n        let ap = p - a;\n        let dotAB = dot(ab, ab);\n        if (dotAB < 0.0001) {\n            t = 0.0;\n        } else {\n            t = dot(ab, ap) / dotAB;\n        }\n    } else {\n        let r = gradient.radius;\n        let coord = p / r;\n        let focalRatio = gradient.focal;\n\n        if (abs(focalRatio) < 0.001) {\n            t = length(coord);\n        } else {\n            let focal = vec2<f32>(focalRatio, 0.0);\n            let diff = coord - focal;\n            let lenDiff = length(diff);\n\n            if (lenDiff < 0.0001) {\n                t = 0.0;\n            } else {\n                let dir = diff / lenDiff;\n\n                // Solve quadratic equation for unit circle intersection (a=1 since dir is normalized)\n                let b_coef = 2.0 * dot(dir, focal);\n                let c_coef = dot(focal, focal) - 1.0;\n                let discriminant = b_coef * b_coef - 4.0 * c_coef;\n                let x = (-b_coef + sqrt(max(discriminant, 0.0))) * 0.5;\n                t = lenDiff / abs(x);\n            }\n        }\n    }\n    t = applySpread(t);\n    let gradientColor = textureSampleLevel(gradientTexture, gradientSampler, vec2<f32>(t, 0.5), 0);\n",Yi=`\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) v_uv: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n    @location(2) color: vec4<f32>,\n}\n${qi}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let p = input.v_uv;\n${Xi}\n    let result = gradientColor * input.color;\n    return vec4<f32>(result.rgb * result.a, result.a);\n}\n`,Ki=`\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) v_uv: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n    @location(2) color: vec4<f32>,\n}\n${qi}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let p = input.v_uv;\n${Xi}\n    return vec4<f32>(gradientColor.rgb * gradientColor.a, gradientColor.a);\n}\n`,Hi=`\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n    @location(1) color: vec4<f32>,\n}\n${qi}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let p = input.texCoord;\n${Xi}\n    let result = gradientColor * input.color;\n    return vec4<f32>(result.rgb * result.a, result.a);\n}\n`,Qi=`\n${Ci}\n\nstruct CopyUniforms {\n    scale: vec2<f32>,\n    offset: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: CopyUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let uv = input.texCoord * uniforms.scale + uniforms.offset;\n    return textureSampleLevel(inputTexture, textureSampler, uv, 0);\n}\n`,Zi=`\n${Ci}\n\nstruct CopyUniforms {\n    scale: vec2<f32>,\n    offset: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: CopyUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let uv = (input.texCoord - uniforms.offset) * uniforms.scale;\n    let clampedUv = clamp(uv, vec2<f32>(0.0), vec2<f32>(1.0));\n    let color = textureSampleLevel(inputTexture, textureSampler, clampedUv, 0);\n    let inBounds = uv.x >= 0.0 && uv.x <= 1.0 && uv.y >= 0.0 && uv.y <= 1.0;\n    return select(vec4<f32>(0.0, 0.0, 0.0, 0.0), color, inBounds);\n}\n`,Ji=`\n${Ci}\n\nstruct CopyUniforms {\n    scale: vec2<f32>,\n    offset: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: CopyUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let uv = input.texCoord * uniforms.scale + uniforms.offset;\n    let clampedUv = clamp(uv, vec2<f32>(0.0), vec2<f32>(1.0));\n    let color = textureSampleLevel(inputTexture, textureSampler, clampedUv, 0);\n    let inBounds = uv.x >= 0.0 && uv.x <= 1.0 && uv.y >= 0.0 && uv.y <= 1.0;\n    return select(vec4<f32>(0.0, 0.0, 0.0, 0.0), color, inBounds);\n}\n`,ea=`\n${Ci}\n\nstruct ColorTransformUniforms {\n    mul: vec4<f32>,\n    add: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> ct: ColorTransformUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    var color = textureSampleLevel(inputTexture, textureSampler, input.texCoord, 0);\n\n    color = vec4<f32>(color.rgb / max(vec3<f32>(0.0001), vec3<f32>(color.a)), color.a);\n    color = clamp(color * ct.mul + ct.add, vec4<f32>(0.0), vec4<f32>(1.0));\n    color = vec4<f32>(color.rgb * color.a, color.a);\n\n    return color;\n}\n`,ta=`\n${Ci}\n\nstruct YFlipCTUniforms {\n    scale: vec2<f32>,\n    offset: vec2<f32>,\n    mul: vec4<f32>,\n    add: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: YFlipCTUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let uv = input.texCoord * uniforms.scale + uniforms.offset;\n    var color = textureSampleLevel(inputTexture, textureSampler, uv, 0);\n\n    color = vec4<f32>(color.rgb / max(vec3<f32>(0.0001), vec3<f32>(color.a)), color.a);\n    color = clamp(color * uniforms.mul + uniforms.add, vec4<f32>(0.0), vec4<f32>(1.0));\n    color = vec4<f32>(color.rgb * color.a, color.a);\n\n    return color;\n}\n`,ra=`\n${Ci}\n\nstruct ColorMatrixUniforms {\n    matrix: mat4x4<f32>,\n    offset: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: ColorMatrixUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    var color = textureSampleLevel(inputTexture, textureSampler, input.texCoord, 0);\n\n    color = vec4<f32>(color.rgb / max(vec3<f32>(0.0001), vec3<f32>(color.a)), color.a);\n    var result = uniforms.matrix * color + uniforms.offset;\n    result = clamp(result, vec4<f32>(0.0), vec4<f32>(1.0));\n    result = vec4<f32>(result.rgb * result.a, result.a);\n\n    return result;\n}\n`,na=`\n${Ci}\n\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    return textureSampleLevel(inputTexture, textureSampler, input.texCoord, 0);\n}\n`,ia=`\n${Ci}\n\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    return textureSampleLevel(inputTexture, textureSampler, input.texCoord, 0);\n}\n`,aa=`\n${Ci}\n\noverride IS_INNER: u32 = 0u;\noverride IS_KNOCKOUT: u32 = 0u;\n\nstruct GlowUniforms {\n    color: vec4<f32>,\n    baseScale: vec2<f32>,\n    baseOffset: vec2<f32>,\n    blurScale: vec2<f32>,\n    blurOffset: vec2<f32>,\n    strength: f32,\n    _padding1: f32,\n    _padding2: f32,\n    _padding3: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: GlowUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var blurTexture: texture_2d<f32>;\n@group(0) @binding(3) var baseTexture: texture_2d<f32>;\n${Ai}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;\n    let baseColor = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);\n\n    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;\n    let blurColor = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);\n\n    var rawAlpha = blurColor.a;\n    if (IS_INNER == 1u) {\n        rawAlpha = 1.0 - rawAlpha;\n    }\n    let glowAlpha = clamp(rawAlpha * uniforms.strength, 0.0, 1.0);\n    let glowColor = vec4<f32>(uniforms.color.rgb * glowAlpha, uniforms.color.a * glowAlpha);\n    if (IS_INNER == 1u) {\n        let innerGlow = glowColor * baseColor.a;\n        if (IS_KNOCKOUT == 1u) {\n            return innerGlow;\n        } else {\n            return innerGlow + baseColor * (1.0 - glowColor.a);\n        }\n    } else {\n        if (IS_KNOCKOUT == 1u) {\n            return glowColor * (1.0 - baseColor.a);\n        } else {\n            return baseColor + glowColor * (1.0 - baseColor.a);\n        }\n    }\n}\n`,sa=`\n${Ci}\n\noverride IS_INNER: u32 = 0u;\noverride IS_KNOCKOUT: u32 = 0u;\noverride IS_HIDE_OBJECT: u32 = 0u;\n\nstruct DropShadowUniforms {\n    color: vec4<f32>,\n    baseScale: vec2<f32>,\n    baseOffset: vec2<f32>,\n    blurScale: vec2<f32>,\n    blurOffset: vec2<f32>,\n    strength: f32,\n    _padding1: f32,\n    _padding2: f32,\n    _padding3: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: DropShadowUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var blurTexture: texture_2d<f32>;\n@group(0) @binding(3) var baseTexture: texture_2d<f32>;\n${Ai}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;\n    let baseColor = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);\n\n    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;\n    let blur = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);\n\n    var rawAlpha = blur.a;\n    if (IS_INNER == 1u) {\n        rawAlpha = 1.0 - rawAlpha;\n    }\n    let shadowAlpha = clamp(rawAlpha * uniforms.strength, 0.0, 1.0);\n    let shadowColor = vec4<f32>(uniforms.color.rgb * shadowAlpha, uniforms.color.a * shadowAlpha);\n\n    if (IS_INNER == 1u) {\n        let innerShadow = shadowColor * baseColor.a;\n        if (IS_KNOCKOUT == 1u) {\n            return innerShadow;\n        } else {\n            return innerShadow + baseColor * (1.0 - shadowColor.a);\n        }\n    } else {\n        if (IS_HIDE_OBJECT == 1u) {\n            return shadowColor;\n        } else if (IS_KNOCKOUT == 1u) {\n            return shadowColor * (1.0 - baseColor.a);\n        } else {\n            return shadowColor * (1.0 - baseColor.a) + baseColor;\n        }\n    }\n}\n`,oa=`\n${Ci}\n\noverride GLOW_TYPE: u32 = 0u;\noverride IS_KNOCKOUT: u32 = 0u;\n\nstruct GradientGlowUniforms {\n    strength: f32,\n    _padding1: f32,\n    _padding2: f32,\n    _padding3: f32,\n    baseScale: vec2<f32>,\n    baseOffset: vec2<f32>,\n    blurScale: vec2<f32>,\n    blurOffset: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: GradientGlowUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var blurTexture: texture_2d<f32>;\n@group(0) @binding(3) var baseTexture: texture_2d<f32>;\n@group(0) @binding(4) var gradientLUT: texture_2d<f32>;\n${Ai}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;\n    let base = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);\n\n    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;\n    var blur = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);\n\n    blur.a = clamp(blur.a * uniforms.strength, 0.0, 1.0);\n    let glowColor = textureSampleLevel(gradientLUT, textureSampler, vec2<f32>(blur.a, 0.5), 0);\n    var result: vec4<f32>;\n    if (GLOW_TYPE == 0u) {\n        if (IS_KNOCKOUT == 1u) {\n            result = glowColor;\n        } else {\n            result = base - base * glowColor.a + glowColor;\n        }\n    } else if (GLOW_TYPE == 1u) {\n        if (IS_KNOCKOUT == 1u) {\n            result = glowColor * base.a;\n        } else {\n            result = glowColor * base.a + base * (1.0 - glowColor.a);\n        }\n    } else {\n        if (IS_KNOCKOUT == 1u) {\n            result = glowColor - glowColor * base.a;\n        } else {\n            result = base + glowColor - glowColor * base.a;\n        }\n    }\n    return result;\n}\n`,la=`\n${Ci}\n\noverride BEVEL_TYPE: u32 = 0u;\noverride IS_KNOCKOUT: u32 = 0u;\n\nstruct GradientBevelUniforms {\n    strength: f32,\n    _padding1: f32,\n    _padding2: f32,\n    _padding3: f32,\n    baseScale: vec2<f32>,\n    baseOffset: vec2<f32>,\n    blurScale: vec2<f32>,\n    blurOffset: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: GradientBevelUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var blurTexture: texture_2d<f32>;\n@group(0) @binding(3) var baseTexture: texture_2d<f32>;\n@group(0) @binding(4) var gradientLUT: texture_2d<f32>;\n${Ai}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;\n    let base = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);\n\n    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;\n    let blur1 = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);\n\n    let mirrorUV = (1.0 - input.texCoord) * uniforms.blurScale - uniforms.blurOffset;\n    let blur2 = textureSampleLevel(blurTexture, textureSampler, mirrorUV, 0) * isInside(mirrorUV);\n\n    var highlightAlpha = blur1.a - blur2.a;\n    var shadowAlpha = blur2.a - blur1.a;\n    highlightAlpha = clamp(highlightAlpha * uniforms.strength, 0.0, 1.0);\n    shadowAlpha = clamp(shadowAlpha * uniforms.strength, 0.0, 1.0);\n\n    let lutCoord = 0.5019607843137255 - 0.5019607843137255 * shadowAlpha + 0.4980392156862745 * highlightAlpha;\n    let bevelColor = textureSampleLevel(gradientLUT, textureSampler, vec2<f32>(lutCoord, 0.5), 0);\n\n    var result: vec4<f32>;\n    if (BEVEL_TYPE == 0u) {\n        if (IS_KNOCKOUT == 1u) {\n            result = bevelColor;\n        } else {\n            result = base - base * bevelColor.a + bevelColor;\n        }\n    } else if (BEVEL_TYPE == 1u) {\n        if (IS_KNOCKOUT == 1u) {\n            result = bevelColor * base.a;\n        } else {\n            result = bevelColor * base.a + base * (1.0 - bevelColor.a);\n        }\n    } else {\n        if (IS_KNOCKOUT == 1u) {\n            result = bevelColor - bevelColor * base.a;\n        } else {\n            result = base + bevelColor - bevelColor * base.a;\n        }\n    }\n\n    return result;\n}\n`,ca=`\n${Ci}\n\noverride BEVEL_TYPE: u32 = 0u;\noverride IS_KNOCKOUT: u32 = 0u;\n\nstruct BevelUniforms {\n    highlightColor: vec4<f32>,\n    shadowColor: vec4<f32>,\n    strength: f32,\n    _padding1: f32,\n    _padding2: f32,\n    _padding3: f32,\n    baseScale: vec2<f32>,\n    baseOffset: vec2<f32>,\n    blurScale: vec2<f32>,\n    blurOffset: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: BevelUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var blurTexture: texture_2d<f32>;\n@group(0) @binding(3) var baseTexture: texture_2d<f32>;\n${Ai}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;\n    let base = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);\n\n    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;\n    let blur1 = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);\n\n    let mirrorUV = (1.0 - input.texCoord) * uniforms.blurScale - uniforms.blurOffset;\n    let blur2 = textureSampleLevel(blurTexture, textureSampler, mirrorUV, 0) * isInside(mirrorUV);\n\n    var highlightAlpha = blur1.a - blur2.a;\n    var shadowAlpha = blur2.a - blur1.a;\n    highlightAlpha = clamp(highlightAlpha * uniforms.strength, 0.0, 1.0);\n    shadowAlpha = clamp(shadowAlpha * uniforms.strength, 0.0, 1.0);\n\n    let bevelColor = uniforms.highlightColor * highlightAlpha + uniforms.shadowColor * shadowAlpha;\n    var result: vec4<f32>;\n    if (BEVEL_TYPE == 0u) {\n        if (IS_KNOCKOUT == 1u) {\n            result = bevelColor;\n        } else {\n            result = base - base * bevelColor.a + bevelColor;\n        }\n    } else if (BEVEL_TYPE == 1u) {\n        if (IS_KNOCKOUT == 1u) {\n            result = bevelColor * base.a;\n        } else {\n            result = bevelColor * base.a + base * (1.0 - bevelColor.a);\n        }\n    } else {\n        if (IS_KNOCKOUT == 1u) {\n            result = bevelColor - bevelColor * base.a;\n        } else {\n            result = base + bevelColor - bevelColor * base.a;\n        }\n    }\n\n    return result;\n}\n`,ua=`\n${Ci}\n\nstruct BevelBaseUniforms {\n    offset: vec2<f32>,\n    _padding: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: BevelBaseUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var sourceTexture: texture_2d<f32>;\n${Ai}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let original = textureSampleLevel(sourceTexture, textureSampler, input.texCoord, 0);\n    let shiftedUV = input.texCoord - uniforms.offset;\n    let shifted = textureSampleLevel(sourceTexture, textureSampler, shiftedUV, 0) * isInside(shiftedUV);\n    return original * (1.0 - shifted.a);\n}\n`;class fa{static getFillVertexShader(){return Pi}static getFillMainVertexShader(){return Pi}static getFillFragmentShader(){return"\nstruct FragmentInput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) bezier: vec2<f32>,\n    @location(1) color: vec4<f32>,\n}\n\n@fragment\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\n    let f_val = input.bezier.x * input.bezier.x - input.bezier.y;\n    let dx = dpdx(f_val);\n    let dy = dpdy(f_val);\n\n    if (input.bezier.x == 0.5 && input.bezier.y == 0.5) {\n        return vec4<f32>(input.color.rgb * input.color.a, input.color.a);\n    }\n\n    let dist = f_val * inverseSqrt(dx * dx + dy * dy);\n    let coverage = smoothstep(0.5, -0.5, dist);\n\n    if (coverage <= 0.001) {\n        discard;\n    }\n\n    let finalAlpha = input.color.a * min(coverage, 1.0);\n    return vec4<f32>(input.color.rgb * finalAlpha, finalAlpha);\n}\n"}static getStencilWriteVertexShader(){return Si}static getStencilWriteMainVertexShader(){return Si}static getStencilWriteFragmentShader(){return"\nstruct FragmentInput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) bezier: vec2<f32>,\n}\n\n@fragment\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\n    let f_val = input.bezier.x * input.bezier.x - input.bezier.y;\n    let dx = dpdx(f_val);\n    let dy = dpdy(f_val);\n    let dist = f_val * inverseSqrt(dx * dx + dy * dy);\n    let alpha = smoothstep(0.5, -0.5, dist);\n\n    if (alpha <= 0.001) {\n        discard;\n    }\n\n    return vec4<f32>(0.0, 0.0, 0.0, min(alpha, 1.0));\n}\n"}static getStencilFillVertexShader(){return Fi}static getStencilFillMainVertexShader(){return Fi}static getStencilFillFragmentShader(){return"\nstruct FragmentInput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) color: vec4<f32>,\n}\n\n@fragment\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\n    let a = input.color.a;\n    return vec4<f32>(input.color.r * a, input.color.g * a, input.color.b * a, a);\n}\n"}static getMaskVertexShader(){return"\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) bezier: vec2<f32>,\n}\n\nstruct Uniforms {\n    viewportSize: vec2<f32>,\n    _padding0: vec2<f32>,\n    matrixCol0: vec3<f32>,\n    _padding1: f32,\n    matrixCol1: vec3<f32>,\n    _padding2: f32,\n    matrixCol2: vec3<f32>,\n    _padding3: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: Uniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let matrix = mat3x3<f32>(uniforms.matrixCol0, uniforms.matrixCol1, uniforms.matrixCol2);\n    let transformed = matrix * vec3<f32>(input.position, 1.0);\n    let pos = transformed.xy;\n    let ndc = pos * 2.0 - 1.0;\n    output.position = vec4<f32>(ndc.x, -ndc.y, 0.0, 1.0);\n    output.bezier = input.bezier;\n    return output;\n}\n"}static getMaskFragmentShader(){return"\nstruct FragmentInput {\n    @location(0) bezier: vec2<f32>,\n}\n\n@fragment\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\n    let px = dpdx(input.bezier);\n    let py = dpdy(input.bezier);\n    let f = (2.0 * input.bezier.x) * vec2<f32>(px.x, py.x) - vec2<f32>(px.y, py.y);\n    let alpha = 0.5 - (input.bezier.x * input.bezier.x - input.bezier.y) / length(f);\n    if (alpha <= 0.0) {\n        discard;\n    }\n    return vec4<f32>(min(alpha, 1.0));\n}\n"}static getBasicVertexShader(){return Ti}static getBasicMainVertexShader(){return Ti}static getBasicFragmentShader(){return"\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n    @location(1) color: vec4<f32>,\n}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    return input.color;\n}\n"}static getTextureFragmentShader(){return"\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n    @location(1) color: vec4<f32>,\n}\n\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var textureData: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let textureColor = textureSampleLevel(textureData, textureSampler, input.texCoord, 0);\n    return textureColor * input.color;\n}\n"}static getInstancedVertexShader(){return"\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) texCoord: vec2<f32>,\n}\n\nstruct InstanceInput {\n    @location(2) textureRect: vec4<f32>,\n    @location(3) textureDim: vec4<f32>,\n    @location(4) matrixTx: vec4<f32>,\n    @location(5) matrixScale: vec4<f32>,\n    @location(6) mulColor: vec4<f32>,\n    @location(7) addColor: vec4<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n    @location(1) mulColor: vec4<f32>,\n    @location(2) addColor: vec4<f32>,\n}\n\n@vertex\nfn main(\n    input: VertexInput,\n    instance: InstanceInput,\n    @builtin(instance_index) instanceIdx: u32\n) -> VertexOutput {\n    var output: VertexOutput;\n    let texX = instance.textureRect.x + input.texCoord.x * instance.textureRect.z;\n    let texY = instance.textureRect.y + input.texCoord.y * instance.textureRect.w;\n    output.texCoord = vec2<f32>(texX, texY);\n    var pos = vec2<f32>(input.position.x, 1.0 - input.position.y);\n    pos = pos * vec2<f32>(instance.textureDim.x, instance.textureDim.y);\n    let scale0 = instance.matrixScale.x;\n    let rotate0 = instance.matrixScale.y;\n    let scale1 = instance.matrixScale.z;\n    let rotate1 = instance.matrixScale.w;\n    let transformedX = pos.x * scale0 + pos.y * scale1 + instance.matrixTx.x;\n    let transformedY = pos.x * rotate0 + pos.y * rotate1 + instance.matrixTx.y;\n    var position = vec2<f32>(transformedX, transformedY) / vec2<f32>(instance.textureDim.z, instance.textureDim.w);\n    position = position * 2.0 - 1.0;\n    output.position = vec4<f32>(position.x, -position.y, 0.0, 1.0);\n    output.mulColor = instance.mulColor;\n    output.addColor = instance.addColor;\n    return output;\n}\n"}static getInstancedFragmentShader(){return"\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n    @location(1) mulColor: vec4<f32>,\n    @location(2) addColor: vec4<f32>,\n}\n\n@group(0) @binding(0) var textureSampler: sampler;\n@group(0) @binding(1) var textureData: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    var src = textureSample(textureData, textureSampler, input.texCoord);\n    src = vec4<f32>(src.rgb / max(0.0001, src.a), src.a);\n    src = clamp(src * input.mulColor + input.addColor, vec4<f32>(0.0), vec4<f32>(1.0));\n    src = vec4<f32>(src.rgb * src.a, src.a);\n    return src;\n}\n"}static getGradientFillVertexShader(){return Bi}static getGradientFillMainVertexShader(){return Bi}static getGradientFillFragmentShader(){return Yi}static getGradientFillStencilFragmentShader(){return Ki}static getGradientFragmentShader(){return Hi}static getBitmapFillVertexShader(){return Oi}static getBitmapFillMainVertexShader(){return Oi}static getBitmapFillFragmentShader(){return"\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) bezier: vec2<f32>,\n    @location(1) color: vec4<f32>,\n    @location(2) worldPos: vec2<f32>,\n}\n\nstruct BitmapUniforms {\n    bitmapMatrix: mat3x3<f32>,\n    textureWidth: f32,\n    textureHeight: f32,\n    repeat: f32,\n    _pad: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: BitmapUniforms;\n@group(0) @binding(1) var bitmapSampler: sampler;\n@group(0) @binding(2) var bitmapTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let u = input.bezier.x;\n    let v = input.bezier.y;\n    if (abs(u - 0.5) > 0.001 || abs(v - 0.5) > 0.001) {\n        let d = u * u - v;\n        if (d > 0.0) {\n            discard;\n        }\n    }\n    let transformedPos = uniforms.bitmapMatrix * vec3<f32>(input.worldPos, 1.0);\n    var uv = vec2<f32>(\n        transformedPos.x / uniforms.textureWidth,\n        transformedPos.y / uniforms.textureHeight\n    );\n    if (uniforms.repeat > 0.5) {\n        uv = fract(uv);\n    }\n    let bitmapColor = textureSampleLevel(bitmapTexture, bitmapSampler, uv, 0);\n    let alpha = bitmapColor.a * input.color.a;\n    return vec4<f32>(bitmapColor.rgb * input.color.a, alpha);\n}\n"}static getBlendFragmentShader(){return"\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n    @location(1) color: vec4<f32>,\n}\n\nstruct BlendUniforms {\n    blendMode: f32,\n}\n\n@group(0) @binding(1) var<uniform> blend: BlendUniforms;\n@group(0) @binding(2) var srcSampler: sampler;\n@group(0) @binding(3) var srcTexture: texture_2d<f32>;\n@group(0) @binding(4) var dstSampler: sampler;\n@group(0) @binding(5) var dstTexture: texture_2d<f32>;\n\nfn blendNormal(src: vec4<f32>, dst: vec4<f32>) -> vec4<f32> {\n    return src;\n}\n\nfn blendMultiply(src: vec4<f32>, dst: vec4<f32>) -> vec4<f32> {\n    return src * dst;\n}\n\nfn blendScreen(src: vec4<f32>, dst: vec4<f32>) -> vec4<f32> {\n    return src + dst - src * dst;\n}\n\nfn blendAdd(src: vec4<f32>, dst: vec4<f32>) -> vec4<f32> {\n    return min(src + dst, vec4<f32>(1.0));\n}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let src = textureSampleLevel(srcTexture, srcSampler, input.texCoord, 0);\n    let dst = textureSampleLevel(dstTexture, dstSampler, input.texCoord, 0);\n    var result: vec4<f32>;\n    if (blend.blendMode < 0.5) {\n        result = blendNormal(src, dst);\n    } else if (blend.blendMode < 1.5) {\n        result = blendMultiply(src, dst);\n    } else if (blend.blendMode < 2.5) {\n        result = blendScreen(src, dst);\n    } else {\n        result = blendAdd(src, dst);\n    }\n    return result * input.color;\n}\n"}static getBlurFilterVertexShader(){return Ui}static getBitmapSyncVertexShader(){return Li}static getBitmapSyncFragmentShader(){return ia}static getBlurFilterFragmentShader(e){const t=e.toFixed(1);return`\n${Ci}\n\nstruct BlurUniforms {\n    offset: vec2<f32>,\n    fraction: f32,\n    samples: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: BlurUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let offset = uniforms.offset;\n    let fraction = uniforms.fraction;\n    let samples = uniforms.samples;\n    var color = textureSample(inputTexture, textureSampler, input.texCoord);\n    for (var i: f32 = 1.0; i < ${t}; i += 1.0) {\n        color += textureSample(inputTexture, textureSampler, input.texCoord + offset * i);\n        color += textureSample(inputTexture, textureSampler, input.texCoord - offset * i);\n    }\n    color += textureSample(inputTexture, textureSampler, input.texCoord + offset * ${t}) * fraction;\n    color += textureSample(inputTexture, textureSampler, input.texCoord - offset * ${t}) * fraction;\n    color /= samples;\n    return color;\n}\n`}static getTextureCopyFragmentShader(){return Qi}static getBlurTextureCopyFragmentShader(){return Zi}static getFilterOutputFragmentShader(){return Ji}static getColorTransformFragmentShader(){return ea}static getYFlipColorTransformFragmentShader(){return ta}static getColorMatrixFilterFragmentShader(){return ra}static getGlowFilterFragmentShader(){return aa}static getDropShadowFilterFragmentShader(){return sa}static getGradientGlowFilterFragmentShader(){return oa}static getGradientBevelFilterFragmentShader(){return la}static getBevelFilterFragmentShader(){return ca}static getBevelBaseFragmentShader(){return ua}static getConvolutionFilterFragmentShader(e,t,r=!0,n=!0){const i=Math.floor(.5*e),a=Math.floor(.5*t),s=e*t;let o="";for(let e=0;e<s;e++)o+=`\n    result = result + getWeightedColor(${e}, getMatrixWeight(${e}));`;const l=r?"result.a = textureSample(sourceTexture, sourceSampler, input.texCoord).a;":"",c=n?"":"\n    let substituteColor = uniforms.substituteColor;\n    color = mix(substituteColor, color, isInside(uv));";return`\nstruct ConvolutionUniforms {\n    rcpSize: vec2<f32>,\n    rcpDivisor: f32,\n    bias: f32,\n    substituteColor: vec4<f32>,\n    matrix: array<vec4<f32>, ${Math.ceil(s/4)}>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: ConvolutionUniforms;\n@group(0) @binding(1) var sourceSampler: sampler;\n@group(0) @binding(2) var sourceTexture: texture_2d<f32>;\n\n${Ci}\n\n${Ai}\n\nfn getMatrixWeight(index: i32) -> f32 {\n    let vecIndex = index / 4;\n    let component = index % 4;\n    let vec = uniforms.matrix[vecIndex];\n    if (component == 0) { return vec.x; }\n    else if (component == 1) { return vec.y; }\n    else if (component == 2) { return vec.z; }\n    else { return vec.w; }\n}\n\nfn getWeightedColor(i: i32, weight: f32) -> vec4<f32> {\n    let rcpSize = uniforms.rcpSize;\n    let iDivX = i / ${e};\n    let iModX = i - ${e} * iDivX;\n    let offset = vec2<f32>(f32(iModX - ${i}), f32(${a} - iDivX));\n    var uv = input.texCoord + offset * rcpSize;\n    var color = textureSample(sourceTexture, sourceSampler, uv);\n    color = vec4<f32>(color.rgb / max(0.0001, color.a), color.a);\n    ${c}\n    return color * weight;\n}\n\nvar<private> input: VertexOutput;\n\n@vertex\nfn vs_main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {\n    var positions = array<vec2<f32>, 6>(\n        vec2<f32>(-1.0, -1.0),\n        vec2<f32>(1.0, -1.0),\n        vec2<f32>(-1.0, 1.0),\n        vec2<f32>(-1.0, 1.0),\n        vec2<f32>(1.0, -1.0),\n        vec2<f32>(1.0, 1.0)\n    );\n    var texCoords = array<vec2<f32>, 6>(\n        vec2<f32>(0.0, 1.0),\n        vec2<f32>(1.0, 1.0),\n        vec2<f32>(0.0, 0.0),\n        vec2<f32>(0.0, 0.0),\n        vec2<f32>(1.0, 1.0),\n        vec2<f32>(1.0, 0.0)\n    );\n    var output: VertexOutput;\n    output.position = vec4<f32>(positions[vertexIndex], 0.0, 1.0);\n    output.texCoord = texCoords[vertexIndex];\n    return output;\n}\n\n@fragment\nfn fs_main(fragInput: VertexOutput) -> @location(0) vec4<f32> {\n    input = fragInput;\n    let rcpDivisor = uniforms.rcpDivisor;\n    let bias = uniforms.bias;\n    var result = vec4<f32>(0.0);\n    ${o}\n    result = clamp(result * rcpDivisor + bias, vec4<f32>(0.0), vec4<f32>(1.0));\n    ${l}\n    result = vec4<f32>(result.rgb * result.a, result.a);\n    return result;\n}\n`}static getComplexBlendFragmentShader(){return fa.getUnifiedComplexBlendFragmentShader()}static getBlendModeIndex(e){switch(e){case"subtract":return 0;case"multiply":default:return 1;case"lighten":return 2;case"darken":return 3;case"overlay":return 4;case"hardlight":return 5;case"difference":return 6;case"invert":return 7}}static getUnifiedComplexBlendFragmentShader(){return`\n${Ci}\n\nstruct BlendUniforms {\n    mulColor: vec4<f32>,\n    addColor: vec4<f32>,\n    blendMode: f32,\n    _pad0: f32,\n    _pad1: f32,\n    _pad2: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: BlendUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var dstTexture: texture_2d<f32>;\n@group(0) @binding(3) var srcTexture: texture_2d<f32>;\n\nfn blend(src: vec4<f32>, dst: vec4<f32>, mode: i32) -> vec4<f32> {\n    if (src.a == 0.0) { return dst; }\n    if (dst.a == 0.0) { return src; }\n\n    let a = src - src * dst.a;\n    let b = dst - dst * src.a;\n\n    if (mode == 1) {\n        let c = src * dst;\n        return a + b + c;\n    }\n\n    let srcRgb = src.rgb / src.a;\n    let dstRgb = dst.rgb / dst.a;\n\n    var blended: vec3<f32>;\n\n    switch (mode) {\n        case 0: {\n            blended = dstRgb - srcRgb;\n        }\n        case 2: {\n            blended = mix(srcRgb, dstRgb, step(srcRgb, dstRgb));\n        }\n        case 3: {\n            blended = mix(srcRgb, dstRgb, step(dstRgb, srcRgb));\n        }\n        case 4: {\n            let mul = srcRgb * dstRgb;\n            let c1 = 2.0 * mul;\n            let c2 = 2.0 * (srcRgb + dstRgb - mul) - 1.0;\n            blended = mix(c1, c2, step(vec3<f32>(0.5), dstRgb));\n        }\n        case 5: {\n            let mul = srcRgb * dstRgb;\n            let c1 = 2.0 * mul;\n            let c2 = 2.0 * (srcRgb + dstRgb - mul) - 1.0;\n            blended = mix(c1, c2, step(vec3<f32>(0.5), srcRgb));\n        }\n        case 6: {\n            blended = abs(srcRgb - dstRgb);\n        }\n        case 7: {\n            let ib = dst - dst * src.a;\n            let ic = vec4<f32>(src.a - dst.rgb * src.a, src.a);\n            return ib + ic;\n        }\n        default: {\n            blended = srcRgb;\n        }\n    }\n\n    var c = vec4<f32>(blended, src.a * dst.a);\n    c = vec4<f32>(c.rgb * c.a, c.a);\n    return a + b + c;\n}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    var dst = textureSample(dstTexture, textureSampler, input.texCoord);\n    var src = textureSample(srcTexture, textureSampler, input.texCoord);\n    let mul = uniforms.mulColor;\n    let add = uniforms.addColor;\n    if (mul.x != 1.0 || mul.y != 1.0 || mul.z != 1.0 || mul.w != 1.0\n        || add.x != 0.0 || add.y != 0.0 || add.z != 0.0) {\n        src = vec4<f32>(src.rgb / max(vec3<f32>(0.0001), vec3<f32>(src.a)), src.a);\n        src = clamp(src * mul + add, vec4<f32>(0.0), vec4<f32>(1.0));\n        src = vec4<f32>(src.rgb * src.a, src.a);\n    }\n    return blend(src, dst, i32(uniforms.blendMode));\n}\n`}static getDisplacementMapFilterFragmentShader(e,t,r){let n,i,a;switch(e){case 1:n="mapColor.r";break;case 2:n="mapColor.g";break;case 4:n="mapColor.b";break;case 8:n="mapColor.a";break;default:n="0.5"}switch(t){case 1:i="mapColor.r";break;case 2:i="mapColor.g";break;case 4:i="mapColor.b";break;case 8:i="mapColor.a";break;default:i="0.5"}let s=!1;switch(r){case 0:a="\nsourceColor = textureSample(srcTexture, textureSampler, uv);\n";break;case 1:s=!0,a="\nsourceColor = mix(uniforms.substituteColor, textureSample(srcTexture, textureSampler, uv), isInside(uv));\n";break;case 2:default:a="\nsourceColor = textureSample(srcTexture, textureSampler, fract(uv));\n";break;case 3:a="\nlet insideUV = step(abs(uv - vec2<f32>(0.5)), vec2<f32>(0.5));\nsourceColor = textureSample(srcTexture, textureSampler, mix(input.texCoord, uv, insideUV));\n"}return`\n${Ci}\n\n${s?"struct DisplacementUniforms {\n    uvToStScale: vec2<f32>,\n    uvToStOffset: vec2<f32>,\n    scale: vec2<f32>,\n    padding: vec2<f32>,\n    substituteColor: vec4<f32>,\n}":"struct DisplacementUniforms {\n    uvToStScale: vec2<f32>,\n    uvToStOffset: vec2<f32>,\n    scale: vec2<f32>,\n    padding: vec2<f32>,\n}"}\n\n@group(0) @binding(0) var<uniform> uniforms: DisplacementUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var srcTexture: texture_2d<f32>;\n@group(0) @binding(3) var mapTexture: texture_2d<f32>;\n\n${Ai}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let stCoord = vec2<f32>(input.texCoord.x, 1.0 - input.texCoord.y);\n    let st = stCoord * uniforms.uvToStScale - uniforms.uvToStOffset;\n    let mapColor = textureSample(mapTexture, textureSampler, vec2<f32>(st.x, 1.0 - st.y));\n    let offset = vec2<f32>(${n}, ${i}) - 0.5;\n    let uv = input.texCoord + offset * uniforms.scale;\n    var sourceColor: vec4<f32>;\n    ${a}\n    return mix(textureSample(srcTexture, textureSampler, input.texCoord), sourceColor, isInside(st));\n}\n`}static getNodeClearVertexShader(){return"\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n}\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let ndc = input.position * 2.0 - 1.0;\n    output.position = vec4<f32>(ndc.x, ndc.y, 0.0, 1.0);\n    return output;\n}\n"}static getNodeClearFragmentShader(){return"\n@fragment\nfn main() -> @location(0) vec4<f32> {\n    return vec4<f32>(0.0, 0.0, 0.0, 0.0);\n}\n"}static getPositionedTextureVertexShader(){return ki}static getTextureScaleVertexShader(){return Vi}static getTextureScaleBlendVertexShader(){return zi}static getComplexBlendScaleVertexShader(){return ji}static getComplexBlendVertexShader(){return $i}static getComplexBlendCopyVertexShader(){return Gi}static getComplexBlendOutputVertexShader(){return Ni}static getFilterComplexBlendOutputVertexShader(){return Wi}static getPositionedTextureFragmentShader(){return na}}const da={arrayStride:16,attributes:[{shaderLocation:0,offset:0,format:"float32x2"},{shaderLocation:1,offset:8,format:"float32x2"}]},ha={color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}};class pa{constructor(e,t){Object.defineProperty(this,"device",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"format",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"pipelines",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"bindGroupLayouts",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"sampleCount",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"shaderModuleCache",{enumerable:!0,configurable:!0,writable:!0,value:new Map}),Object.defineProperty(this,"filterBindGroupLayouts",{enumerable:!0,configurable:!0,writable:!0,value:new Map}),Object.defineProperty(this,"lazyInitGroups",{enumerable:!0,configurable:!0,writable:!0,value:new Set}),Object.defineProperty(this,"lazyGroupMap",{enumerable:!0,configurable:!0,writable:!0,value:new Map([...Array.from({length:16},(e,t)=>[`blur_filter_${t+1}`,"blur_filter"]),["blur_filter","blur_filter"],["texture_copy","texture_copy"],["texture_copy_rgba8","texture_copy"],["color_transform","texture_copy"],["y_flip_color_transform","texture_copy"],["texture_erase","texture_copy"],["blur_texture_copy","texture_copy"],["filter_blend","texture_copy"],["texture_copy_bgra","texture_copy"],["filter_output","texture_copy"],["filter_output_add","texture_copy"],["filter_output_screen","texture_copy"],["filter_output_alpha","texture_copy"],["filter_output_erase","texture_copy"],["texture_copy_bgra_msaa","texture_copy"],["filter_output_msaa","texture_copy"],["filter_output_add_msaa","texture_copy"],["filter_output_screen_msaa","texture_copy"],["filter_output_alpha_msaa","texture_copy"],["filter_output_erase_msaa","texture_copy"],["positioned_texture","texture_copy"],["positioned_texture_rgba","texture_copy"],["bitmap_render_msaa","texture_copy"],["bitmap_render","texture_copy"],["texture_scale","texture_copy"],["texture_scale_blend","texture_copy"],["bitmap_sync","bitmap_sync"],["color_matrix_filter","filter"],["bevel_base","filter"],["glow_filter","filter"],["drop_shadow_filter","filter"],["bevel_filter","filter"],["gradient_glow_filter","filter"],["gradient_bevel_filter","filter"],["complex_blend","complex_blend"],["complex_blend_copy","complex_blend"],["complex_blend_scale","complex_blend"],["complex_blend_output","complex_blend"],["complex_blend_output_msaa","complex_blend"],["filter_complex_blend_output","complex_blend"],["filter_complex_blend_output_msaa","complex_blend"]])}),Object.defineProperty(this,"gradientPipelineLayout",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"gradientVertexShaderModule",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"gradientFragmentShaderModule",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"gradientStencilFragmentShaderModule",{enumerable:!0,configurable:!0,writable:!0,value:null}),this.device=e,this.format=t,this.pipelines=new Map,this.bindGroupLayouts=new Map,this.sampleCount=4,this.initialize()}getOrCreateShaderModule(e,t){let r=this.shaderModuleCache.get(e);return r||(r=this.device.createShaderModule({code:t}),this.shaderModuleCache.set(e,r)),r}initialize(){this.createFillPipeline(),this.createStencilFillPipelines(),this.createClipPipeline(),this.createMaskUnionPipelines(),this.createMaskPipeline(),this.createBasicPipeline(),this.createTexturePipeline(),this.createInstancedPipeline(),this.createGradientPipeline(),this.createBitmapFillPipeline(),this.createBlendPipeline(),this.createNodeClearPipeline()}ensureLazyGroup(e){const t=this.lazyGroupMap.get(e);if(t&&!this.lazyInitGroups.has(t))switch(this.lazyInitGroups.add(t),t){case"blur_filter":this.createBlurFilterPipeline();break;case"texture_copy":this.createTextureCopyPipeline();break;case"bitmap_sync":this.createBitmapSyncPipeline();break;case"filter":this.createColorMatrixFilterPipeline();break;case"complex_blend":this.createComplexBlendPipelines()}}preloadLazyGroups(){const e=["blur_filter","texture_copy","bitmap_sync","filter","complex_blend"];for(const t of e)this.ensureLazyGroup(t)}createFillPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,buffer:{type:"uniform",hasDynamicOffset:!0}}]});this.bindGroupLayouts.set("fill_dynamic",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("fillVertex",fa.getFillVertexShader()),n=this.getOrCreateShaderModule("fillFragment",fa.getFillFragmentShader()),i=da,a=ha,s=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[i]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilReadMask:0,stencilWriteMask:0},multisample:{count:this.sampleCount,alphaToCoverageEnabled:!0}}),o=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[i],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:this.sampleCount,alphaToCoverageEnabled:!0}});this.pipelines.set("fill",s),this.pipelines.set("fill_bgra",o);const l=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[i],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilReadMask:255,stencilWriteMask:0},multisample:{count:this.sampleCount,alphaToCoverageEnabled:!0}});this.pipelines.set("fill_bgra_stencil",l)}createStencilFillPipelines(){const e=da,t=this.bindGroupLayouts.get("fill_dynamic"),r=this.device.createPipelineLayout({bindGroupLayouts:[t]}),n=this.device.createRenderPipeline({layout:r,vertex:{module:this.getOrCreateShaderModule("stencilWriteVertex",fa.getStencilWriteVertexShader()),entryPoint:"main",buffers:[e]},fragment:{module:this.getOrCreateShaderModule("stencilWriteFragment",fa.getStencilWriteFragmentShader()),entryPoint:"main",targets:[{format:"rgba8unorm",writeMask:0}]},primitive:{topology:"triangle-list",cullMode:"none",frontFace:"ccw"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"increment-wrap"},stencilBack:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"decrement-wrap"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount,alphaToCoverageEnabled:!0}});this.pipelines.set("stencil_write",n);const i=this.device.createRenderPipeline({layout:r,vertex:{module:this.getOrCreateShaderModule("stencilFillVertex",fa.getStencilFillVertexShader()),entryPoint:"main",buffers:[e]},fragment:{module:this.getOrCreateShaderModule("stencilFillFragment",fa.getStencilFillFragmentShader()),entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount}});this.pipelines.set("stencil_fill",i);const a=this.device.createRenderPipeline({layout:r,vertex:{module:this.getOrCreateShaderModule("stencilWriteVertex",fa.getStencilWriteVertexShader()),entryPoint:"main",buffers:[e]},fragment:{module:this.getOrCreateShaderModule("stencilWriteFragment",fa.getStencilWriteFragmentShader()),entryPoint:"main",targets:[{format:"rgba8unorm",writeMask:0}]},primitive:{topology:"triangle-list",cullMode:"none",frontFace:"ccw"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"increment-wrap"},stencilBack:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"decrement-wrap"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount,alphaToCoverageEnabled:!0}});this.pipelines.set("stencil_write_atlas",a);const s=this.device.createRenderPipeline({layout:r,vertex:{module:this.getOrCreateShaderModule("stencilWriteVertex",fa.getStencilWriteVertexShader()),entryPoint:"main",buffers:[e],constants:{yFlipSign:-1}},fragment:{module:this.getOrCreateShaderModule("stencilWriteFragment",fa.getStencilWriteFragmentShader()),entryPoint:"main",targets:[{format:this.format,writeMask:0}]},primitive:{topology:"triangle-list",cullMode:"none",frontFace:"ccw"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"increment-wrap"},stencilBack:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"decrement-wrap"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount,alphaToCoverageEnabled:!0}});this.pipelines.set("stencil_write_main",s);const o=this.device.createRenderPipeline({layout:r,vertex:{module:this.getOrCreateShaderModule("stencilFillVertex",fa.getStencilFillVertexShader()),entryPoint:"main",buffers:[e]},fragment:{module:this.getOrCreateShaderModule("stencilFillFragment",fa.getStencilFillFragmentShader()),entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one",operation:"max"}}}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount}});this.pipelines.set("stencil_fill_atlas",o);const l=this.device.createRenderPipeline({layout:r,vertex:{module:this.getOrCreateShaderModule("stencilFillVertex",fa.getStencilFillVertexShader()),entryPoint:"main",buffers:[e],constants:{yFlipSign:-1}},fragment:{module:this.getOrCreateShaderModule("stencilFillFragment",fa.getStencilFillFragmentShader()),entryPoint:"main",targets:[{format:this.format,blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one",operation:"max"}}}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount}});this.pipelines.set("stencil_fill_main",l);const c=this.device.createRenderPipeline({layout:r,vertex:{module:this.getOrCreateShaderModule("stencilFillVertex",fa.getStencilFillVertexShader()),entryPoint:"main",buffers:[e]},fragment:{module:this.getOrCreateShaderModule("stencilFillFragment",fa.getStencilFillFragmentShader()),entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"greater",failOp:"keep",depthFailOp:"replace",passOp:"replace"},stencilBack:{compare:"greater",failOp:"keep",depthFailOp:"replace",passOp:"replace"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount}});this.pipelines.set("stencil_fill_masked",c)}createClipPipeline(){const e=da,t=this.bindGroupLayouts.get("fill_dynamic"),r=this.device.createPipelineLayout({bindGroupLayouts:[t]}),n=this.device.createRenderPipeline({layout:r,vertex:{module:this.getOrCreateShaderModule("stencilWriteVertex",fa.getStencilWriteVertexShader()),entryPoint:"main",buffers:[e]},fragment:{module:this.getOrCreateShaderModule("stencilWriteFragment",fa.getStencilWriteFragmentShader()),entryPoint:"main",targets:[{format:"rgba8unorm",writeMask:0}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"zero",depthFailOp:"invert",passOp:"invert"},stencilBack:{compare:"always",failOp:"zero",depthFailOp:"invert",passOp:"invert"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount}});this.pipelines.set("clip_write",n);const i=this.getOrCreateShaderModule("stencilWriteVertex",fa.getStencilWriteVertexShader()),a=this.getOrCreateShaderModule("stencilWriteFragment",fa.getStencilWriteFragmentShader());for(let t=1;t<=8;t++){const n=1<<t-1,s=this.device.createRenderPipeline({layout:r,vertex:{module:i,entryPoint:"main",buffers:[e],constants:{yFlipSign:-1}},fragment:{module:a,entryPoint:"main",targets:[{format:this.format,writeMask:0}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"zero",depthFailOp:"invert",passOp:"invert"},stencilBack:{compare:"always",failOp:"zero",depthFailOp:"invert",passOp:"invert"},stencilReadMask:255,stencilWriteMask:n},multisample:{count:this.sampleCount,alphaToCoverageEnabled:!0}});this.pipelines.set(`clip_write_main_${t}`,s)}this.pipelines.set("clip_write_main",this.pipelines.get("clip_write_main_1"));for(let t=1;t<=8;t++){const n=1<<t-1,s=this.device.createRenderPipeline({layout:r,vertex:{module:i,entryPoint:"main",buffers:[e],constants:{yFlipSign:-1}},fragment:{module:a,entryPoint:"main",targets:[{format:this.format,writeMask:0}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"replace",depthFailOp:"replace",passOp:"replace"},stencilBack:{compare:"always",failOp:"replace",depthFailOp:"replace",passOp:"replace"},stencilReadMask:255,stencilWriteMask:n},multisample:{count:this.sampleCount}});this.pipelines.set(`clip_clear_main_${t}`,s)}}createMaskUnionPipelines(){const e=da,t=this.bindGroupLayouts.get("fill_dynamic"),r=this.device.createPipelineLayout({bindGroupLayouts:[t]}),n=this.getOrCreateShaderModule("stencilWriteVertex",fa.getStencilWriteVertexShader()),i=this.getOrCreateShaderModule("stencilWriteFragment",fa.getStencilWriteFragmentShader());for(let t=1;t<=8;t++){const a=255&~(1<<t-1),s=this.device.createRenderPipeline({layout:r,vertex:{module:n,entryPoint:"main",buffers:[e],constants:{yFlipSign:-1}},fragment:{module:i,entryPoint:"main",targets:[{format:this.format,writeMask:0}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"less-equal",failOp:"zero",depthFailOp:"replace",passOp:"replace"},stencilBack:{compare:"less-equal",failOp:"zero",depthFailOp:"replace",passOp:"replace"},stencilReadMask:255,stencilWriteMask:a}});this.pipelines.set(`mask_union_merge_${t}`,s);const o=this.device.createRenderPipeline({layout:r,vertex:{module:n,entryPoint:"main",buffers:[e],constants:{yFlipSign:-1}},fragment:{module:i,entryPoint:"main",targets:[{format:this.format,writeMask:0}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"replace",depthFailOp:"replace",passOp:"replace"},stencilBack:{compare:"always",failOp:"replace",depthFailOp:"replace",passOp:"replace"},stencilReadMask:255,stencilWriteMask:1<<t}});this.pipelines.set(`mask_union_clear_${t}`,o)}}createMaskPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX,buffer:{type:"uniform"}}]});this.bindGroupLayouts.set("mask",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("maskVertex",fa.getMaskVertexShader()),n=this.getOrCreateShaderModule("maskFragment",fa.getMaskFragmentShader()),i=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[{arrayStride:16,attributes:[{shaderLocation:0,offset:0,format:"float32x2"},{shaderLocation:1,offset:8,format:"float32x2"}]}]},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("mask",i)}createBasicPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}}]});this.bindGroupLayouts.set("basic",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("basicVertex",fa.getBasicVertexShader()),n=this.getOrCreateShaderModule("basicFragment",fa.getBasicFragmentShader()),i={arrayStride:16,attributes:[{shaderLocation:0,offset:0,format:"float32x2"},{shaderLocation:1,offset:8,format:"float32x2"}]},a=ha,s=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[i]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:this.sampleCount}}),o=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[i],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("basic",s),this.pipelines.set("basic_bgra",o)}createTexturePipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("texture",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("basicVertex",fa.getBasicVertexShader()),n=this.getOrCreateShaderModule("textureFragment",fa.getTextureFragmentShader()),i=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[{arrayStride:16,attributes:[{shaderLocation:0,offset:0,format:"float32x2"},{shaderLocation:1,offset:8,format:"float32x2"}]}]},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("texture",i)}createInstancedPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:1,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("instanced",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("instancedVertex",fa.getInstancedVertexShader()),n=this.getOrCreateShaderModule("instancedFragment",fa.getInstancedFragmentShader()),i={arrayStride:96,stepMode:"instance",attributes:[{shaderLocation:2,offset:0,format:"float32x4"},{shaderLocation:3,offset:16,format:"float32x4"},{shaderLocation:4,offset:32,format:"float32x4"},{shaderLocation:5,offset:48,format:"float32x4"},{shaderLocation:6,offset:64,format:"float32x4"},{shaderLocation:7,offset:80,format:"float32x4"}]},a=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[{arrayStride:16,stepMode:"vertex",attributes:[{shaderLocation:0,offset:0,format:"float32x2"},{shaderLocation:1,offset:8,format:"float32x2"}]},i]},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:this.sampleCount}});this.pipelines.set("instanced",a);const s=[{arrayStride:16,stepMode:"vertex",attributes:[{shaderLocation:0,offset:0,format:"float32x2"},{shaderLocation:1,offset:8,format:"float32x2"}]},i],o=[["instanced_add",{color:{srcFactor:"one",dstFactor:"one",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}],["instanced_screen",{color:{srcFactor:"one-minus-dst",dstFactor:"one",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}],["instanced_alpha",{color:{srcFactor:"zero",dstFactor:"src-alpha",operation:"add"},alpha:{srcFactor:"zero",dstFactor:"src-alpha",operation:"add"}}],["instanced_erase",{color:{srcFactor:"zero",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"zero",dstFactor:"one-minus-src-alpha",operation:"add"}}],["instanced_copy",{color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}}]];for(const[e,i]of o){const a=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:s},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:i}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:this.sampleCount}});this.pipelines.set(e,a)}const l=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[{arrayStride:16,stepMode:"vertex",attributes:[{shaderLocation:0,offset:0,format:"float32x2"},{shaderLocation:1,offset:8,format:"float32x2"}]},i]},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilReadMask:255,stencilWriteMask:0},multisample:{count:this.sampleCount}});this.pipelines.set("instanced_masked",l)}createGradientPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("gradient_fill",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]});this.gradientPipelineLayout=t;const r=this.getOrCreateShaderModule("gradientFillVertex",fa.getGradientFillVertexShader());this.gradientVertexShaderModule=r;const n=this.getOrCreateShaderModule("gradientFillFragment",fa.getGradientFillFragmentShader());this.gradientFragmentShaderModule=n;const i=this.getOrCreateShaderModule("gradientFillStencilFragment",fa.getGradientFillStencilFragmentShader());this.gradientStencilFragmentShaderModule=i;const a=da,s=ha,o=this.device.createRenderPipeline({label:"gradient_fill_no_stencil_pipeline",layout:t,vertex:{module:r,entryPoint:"main",buffers:[a]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:s}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:this.sampleCount}}),l=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[a],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:s}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:this.sampleCount}});this.pipelines.set("gradient_fill",o),this.pipelines.set("gradient_fill_no_stencil",o),this.pipelines.set("gradient_fill_bgra",l);const c={format:"stencil8",stencilFront:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilReadMask:0,stencilWriteMask:0},u=this.device.createRenderPipeline({label:"gradient_stroke_atlas_pipeline",layout:t,vertex:{module:r,entryPoint:"main",buffers:[a]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:s}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:c,multisample:{count:this.sampleCount}});this.pipelines.set("gradient_stroke_atlas",u);const f=this.device.createRenderPipeline({label:"gradient_stroke_bgra_pipeline",layout:t,vertex:{module:r,entryPoint:"main",buffers:[a],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:s}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:c,multisample:{count:this.sampleCount}});this.pipelines.set("gradient_stroke_bgra",f);const d=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[a],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:s}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:1}});this.pipelines.set("gradient_fill_bgra_no_msaa",d);const h=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[a]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:s}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount}});this.pipelines.set("gradient_fill_stencil",h);const p=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[a]},fragment:{module:i,entryPoint:"main",targets:[{format:"rgba8unorm",blend:s}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount}});this.pipelines.set("gradient_fill_stencil_atlas",p);const m=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[a],constants:{yFlipSign:-1}},fragment:{module:i,entryPoint:"main",targets:[{format:this.format,blend:s}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:1}});this.pipelines.set("gradient_fill_stencil_main",m);const g=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[a],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:s}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilReadMask:255,stencilWriteMask:0},multisample:{count:this.sampleCount}});this.pipelines.set("gradient_fill_bgra_stencil",g)}createBitmapFillPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("bitmap_fill",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("bitmapFillVertex",fa.getBitmapFillVertexShader()),n=this.getOrCreateShaderModule("bitmapFillFragment",fa.getBitmapFillFragmentShader()),i=da,a=ha,s=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[i]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:this.sampleCount}}),o=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[i],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("bitmap_fill",s),this.pipelines.set("bitmap_fill_bgra",o);const l={format:"stencil8",stencilFront:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilReadMask:0,stencilWriteMask:0},c=this.device.createRenderPipeline({label:"bitmap_stroke_atlas_pipeline",layout:t,vertex:{module:r,entryPoint:"main",buffers:[i]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:l,multisample:{count:this.sampleCount}});this.pipelines.set("bitmap_stroke_atlas",c);const u=this.device.createRenderPipeline({label:"bitmap_stroke_bgra_pipeline",layout:t,vertex:{module:r,entryPoint:"main",buffers:[i],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:l,multisample:{count:this.sampleCount}});this.pipelines.set("bitmap_stroke_bgra",u);const f=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[i]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount}});this.pipelines.set("bitmap_fill_stencil",f);const d=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[i],constants:{yFlipSign:-1}},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:a}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilReadMask:255,stencilWriteMask:0}});this.pipelines.set("bitmap_fill_bgra_stencil",d)}createBlendPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX|GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:2,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:3,visibility:GPUShaderStage.FRAGMENT,texture:{}},{binding:4,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:5,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("blend",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("basicVertex",fa.getBasicVertexShader()),n=this.getOrCreateShaderModule("blendFragment",fa.getBlendFragmentShader()),i=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[{arrayStride:16,attributes:[{shaderLocation:0,offset:0,format:"float32x2"},{shaderLocation:1,offset:8,format:"float32x2"}]}]},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("blend",i)}createBlurFilterPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("blur_filter",e);const t=this.getOrCreateShaderModule("blurFilterVertex",fa.getBlurFilterVertexShader()),r=this.device.createPipelineLayout({bindGroupLayouts:[e]});for(let e=1;e<=16;e++){const n=this.getOrCreateShaderModule(`blurFilterFragment_${e}`,fa.getBlurFilterFragmentShader(e)),i=this.device.createRenderPipeline({layout:r,vertex:{module:t,entryPoint:"main",buffers:[]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set(`blur_filter_${e}`,i)}}createTextureCopyPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("texture_copy",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("blurFilterVertex",fa.getBlurFilterVertexShader()),n=this.getOrCreateShaderModule("textureCopyFragment",fa.getTextureCopyFragmentShader()),i={color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}},a={color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}};this.pipelines.set("texture_copy",this.createFullscreenQuadPipeline(t,r,n,this.format,i)),this.pipelines.set("texture_copy_rgba8",this.createFullscreenQuadPipeline(t,r,n,"rgba8unorm",i));const s=this.getOrCreateShaderModule("colorTransformFragment",fa.getColorTransformFragmentShader());this.pipelines.set("color_transform",this.createFullscreenQuadPipeline(t,r,s,"rgba8unorm",i));const o=this.getOrCreateShaderModule("yFlipColorTransformFragment",fa.getYFlipColorTransformFragmentShader());this.pipelines.set("y_flip_color_transform",this.createFullscreenQuadPipeline(t,r,o,"rgba8unorm",i));const l=this.getOrCreateShaderModule("blurTextureCopyFragment",fa.getBlurTextureCopyFragmentShader());this.pipelines.set("texture_erase",this.createFullscreenQuadPipeline(t,r,l,"rgba8unorm",{color:{srcFactor:"zero",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"zero",dstFactor:"one-minus-src-alpha",operation:"add"}})),this.pipelines.set("blur_texture_copy",this.createFullscreenQuadPipeline(t,r,l,"rgba8unorm",i)),this.pipelines.set("filter_blend",this.createFullscreenQuadPipeline(t,r,n,this.format,a)),this.pipelines.set("texture_copy_bgra",this.createFullscreenQuadPipeline(t,r,n,this.format,i));const c=this.getOrCreateShaderModule("filterOutputFragment",fa.getFilterOutputFragmentShader());this.pipelines.set("filter_output",this.createFullscreenQuadPipeline(t,r,c,this.format,a));const u=[["filter_output_add",{color:{srcFactor:"one",dstFactor:"one",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one",operation:"add"}}],["filter_output_screen",{color:{srcFactor:"one",dstFactor:"one-minus-src",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}],["filter_output_alpha",{color:{srcFactor:"zero",dstFactor:"src-alpha",operation:"add"},alpha:{srcFactor:"zero",dstFactor:"src-alpha",operation:"add"}}],["filter_output_erase",{color:{srcFactor:"zero",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"zero",dstFactor:"one-minus-src-alpha",operation:"add"}}]];for(const[e,n]of u)this.pipelines.set(e,this.createFullscreenQuadPipeline(t,r,c,this.format,n));if(this.sampleCount>1){const e={color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}};this.pipelines.set("texture_copy_bgra_msaa",this.createFullscreenQuadPipeline(t,r,n,this.format,e,this.sampleCount));const i={color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}};this.pipelines.set("filter_output_msaa",this.createFullscreenQuadPipeline(t,r,c,this.format,i,this.sampleCount));for(const[e,n]of u)this.pipelines.set(`${e}_msaa`,this.createFullscreenQuadPipeline(t,r,c,this.format,n,this.sampleCount))}this.createPositionedTexturePipeline(),this.createTextureScalePipeline()}createPositionedTexturePipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("positioned_texture",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("positionedTextureVertex",fa.getPositionedTextureVertexShader()),n=this.getOrCreateShaderModule("positionedTextureFragment",fa.getPositionedTextureFragmentShader()),i=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[]},fragment:{module:n,entryPoint:"main",targets:[{format:this.format,blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("positioned_texture",i);const a=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("positioned_texture_rgba",a);const s=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:4},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"}}});this.pipelines.set("bitmap_render_msaa",s);const o=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"}}});this.pipelines.set("bitmap_render",o)}createTextureScalePipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("texture_scale",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("textureScaleVertex",fa.getTextureScaleVertexShader()),n=this.getOrCreateShaderModule("positionedTextureFragment",fa.getPositionedTextureFragmentShader()),i=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("texture_scale",i);const a=this.getOrCreateShaderModule("textureScaleBlendVertex",fa.getTextureScaleBlendVertexShader()),s=this.device.createRenderPipeline({layout:t,vertex:{module:a,entryPoint:"main",buffers:[]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("texture_scale_blend",s)}createBitmapSyncPipeline(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.VERTEX,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{type:"filtering"}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{sampleType:"float"}}]});this.bindGroupLayouts.set("bitmap_sync",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("bitmapSyncVertex",fa.getBitmapSyncVertexShader()),n=this.getOrCreateShaderModule("bitmapSyncFragment",fa.getBitmapSyncFragmentShader()),i=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:4}});this.pipelines.set("bitmap_sync",i)}createColorMatrixFilterPipeline(){const e={color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}},t={color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}};this.createFilterPipelineWithLayout("color_matrix_filter",fa.getColorMatrixFilterFragmentShader(),1,e),this.createFilterPipelineWithLayout("bevel_base",fa.getBevelBaseFragmentShader(),1,e),this.createFilterPipelineWithLayout("glow_filter",fa.getGlowFilterFragmentShader(),2,t),this.createFilterPipelineWithLayout("drop_shadow_filter",fa.getDropShadowFilterFragmentShader(),2,t),this.createFilterPipelineWithLayout("bevel_filter",fa.getBevelFilterFragmentShader(),2,t),this.createFilterPipelineWithLayout("gradient_glow_filter",fa.getGradientGlowFilterFragmentShader(),3,t),this.createFilterPipelineWithLayout("gradient_bevel_filter",fa.getGradientBevelFilterFragmentShader(),3,t)}createComplexBlendPipelines(){const e=this.device.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}},{binding:3,visibility:GPUShaderStage.FRAGMENT,texture:{}}]});this.bindGroupLayouts.set("complex_blend",e);const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("complexBlendVertex",fa.getComplexBlendVertexShader()),n=this.getOrCreateShaderModule("unifiedComplexBlendFragment",fa.getUnifiedComplexBlendFragmentShader()),i=this.device.createRenderPipeline({layout:t,vertex:{module:r,entryPoint:"main",buffers:[]},fragment:{module:n,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}});this.pipelines.set("complex_blend",i),this.createComplexBlendCopyPipeline(),this.createComplexBlendOutputPipeline()}createComplexBlendCopyPipeline(){const e={color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}},t=this.bindGroupLayouts.get("texture_copy");if(t){const r=this.device.createPipelineLayout({bindGroupLayouts:[t]}),n=this.getOrCreateShaderModule("complexBlendCopyVertex",fa.getComplexBlendCopyVertexShader()),i=this.getOrCreateShaderModule("textureCopyFragment",fa.getTextureCopyFragmentShader());this.pipelines.set("complex_blend_copy",this.createFullscreenQuadPipeline(r,n,i,"rgba8unorm",e))}const r=this.bindGroupLayouts.get("texture_scale");if(r){const t=this.device.createPipelineLayout({bindGroupLayouts:[r]}),n=this.getOrCreateShaderModule("complexBlendScaleVertex",fa.getComplexBlendScaleVertexShader()),i=this.getOrCreateShaderModule("positionedTextureFragment",fa.getPositionedTextureFragmentShader());this.pipelines.set("complex_blend_scale",this.createFullscreenQuadPipeline(t,n,i,"rgba8unorm",e))}}createComplexBlendOutputPipeline(){const e=this.bindGroupLayouts.get("positioned_texture");if(!e)return;const t=this.device.createPipelineLayout({bindGroupLayouts:[e]}),r=this.getOrCreateShaderModule("positionedTextureFragment",fa.getPositionedTextureFragmentShader()),n={color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}},i=this.getOrCreateShaderModule("complexBlendOutputVertex",fa.getComplexBlendOutputVertexShader());this.pipelines.set("complex_blend_output",this.createFullscreenQuadPipeline(t,i,r,this.format,n)),this.sampleCount>1&&this.pipelines.set("complex_blend_output_msaa",this.createFullscreenQuadPipeline(t,i,r,this.format,n,this.sampleCount));const a=this.getOrCreateShaderModule("filterComplexBlendOutputVertex",fa.getFilterComplexBlendOutputVertexShader());this.pipelines.set("filter_complex_blend_output",this.createFullscreenQuadPipeline(t,a,r,this.format,n)),this.sampleCount>1&&this.pipelines.set("filter_complex_blend_output_msaa",this.createFullscreenQuadPipeline(t,a,r,this.format,n,this.sampleCount))}createFilterPipelineWithLayout(e,t,r,n){let i=this.filterBindGroupLayouts.get(r);if(!i){const e=[{binding:0,visibility:GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}}];for(let t=0;t<r;t++)e.push({binding:2+t,visibility:GPUShaderStage.FRAGMENT,texture:{}});i=this.device.createBindGroupLayout({entries:e}),this.filterBindGroupLayouts.set(r,i)}this.bindGroupLayouts.set(e,i);const a=this.device.createPipelineLayout({bindGroupLayouts:[i]}),s=this.getOrCreateShaderModule("blurFilterVertex",fa.getBlurFilterVertexShader()),o=this.getOrCreateShaderModule(`filter_${e}`,t);this.pipelines.set(e,this.createFullscreenQuadPipeline(a,s,o,"rgba8unorm",n))}createFullscreenQuadPipeline(e,t,r,n,i,a,s){const o={layout:e,vertex:{module:t,entryPoint:"main",buffers:[]},fragment:{module:r,entryPoint:"main",targets:[{format:n,blend:i}]},primitive:{topology:"triangle-list",cullMode:"none"}};return a&&a>1&&(o.multisample={count:a}),s&&(o.depthStencil=s),this.device.createRenderPipeline(o)}getPipeline(e){let t=this.pipelines.get(e);return t||(this.ensureLazyGroup(e),t=this.pipelines.get(e)),t}getFilterPipeline(e,t){const r=`${e}_${Object.keys(t).sort().map(e=>`${e}${t[e]}`).join("_")}`;let n=this.pipelines.get(r);if(n)return n;this.ensureLazyGroup(e);const i=this.shaderModuleCache.get(`filter_${e}`),a=this.shaderModuleCache.get("blurFilterVertex"),s=this.bindGroupLayouts.get(e);if(!i||!a||!s)return this.pipelines.get(e);const o=this.device.createPipelineLayout({bindGroupLayouts:[s]});return n=this.device.createRenderPipeline({layout:o,vertex:{module:a,entryPoint:"main",buffers:[]},fragment:{module:i,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}],constants:t},primitive:{topology:"triangle-list",cullMode:"none"}}),this.pipelines.set(r,n),n}getGradientPipeline(e,t,r){const n=`${e}_t${t}s${r}`;let i=this.pipelines.get(n);return i||(this.gradientPipelineLayout?(i=this.createGradientVariant(e,t,r),i?(this.pipelines.set(n,i),i):this.getPipeline(e)):this.getPipeline(e))}createGradientVariant(e,t,r){if(!this.gradientPipelineLayout)return;const n={GRADIENT_TYPE:t,SPREAD_MODE:r},i=da,a=ha,s=e.includes("stencil_atlas")||"gradient_fill_stencil_main"===e?this.gradientStencilFragmentShaderModule:this.gradientFragmentShaderModule,o=e.includes("bgra")||"gradient_fill_stencil_main"===e?this.format:"rgba8unorm",l={};let c;(e.includes("bgra")||"gradient_fill_stencil_main"===e)&&(l.yFlipSign=-1);let u=this.sampleCount;e.includes("stroke")?c={format:"stencil8",stencilFront:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"always",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilReadMask:0,stencilWriteMask:0}:"gradient_fill_stencil"===e||"gradient_fill_stencil_atlas"===e?c={format:"stencil8",stencilFront:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255}:"gradient_fill_stencil_main"===e?(c={format:"stencil8",stencilFront:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"not-equal",failOp:"keep",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255},u=1):"gradient_fill_bgra_stencil"===e?c={format:"stencil8",stencilFront:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilBack:{compare:"equal",failOp:"keep",depthFailOp:"keep",passOp:"keep"},stencilReadMask:255,stencilWriteMask:0}:"gradient_fill_bgra_no_msaa"===e&&(u=1);const f={layout:this.gradientPipelineLayout,vertex:{module:this.gradientVertexShaderModule,entryPoint:"main",buffers:[i],constants:Object.keys(l).length>0?l:void 0},fragment:{module:s,entryPoint:"main",targets:[{format:o,blend:a}],constants:n},primitive:{topology:"triangle-list",cullMode:"none"},multisample:{count:u}};return c&&(f.depthStencil=c),this.device.createRenderPipeline(f)}getBindGroupLayout(e){let t=this.bindGroupLayouts.get(e);return t||(this.ensureLazyGroup(e),t=this.bindGroupLayouts.get(e)),t}createNodeClearPipeline(){const e=this.device.createRenderPipeline({layout:"auto",vertex:{module:this.getOrCreateShaderModule("nodeClearVertex",fa.getNodeClearVertexShader()),entryPoint:"main",buffers:[{arrayStride:8,attributes:[{shaderLocation:0,offset:0,format:"float32x2"}]}]},fragment:{module:this.getOrCreateShaderModule("nodeClearFragment",fa.getNodeClearFragmentShader()),entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"zero",operation:"add"},alpha:{srcFactor:"one",dstFactor:"zero",operation:"add"}},writeMask:GPUColorWrite.ALL}]},primitive:{topology:"triangle-list",cullMode:"none"},depthStencil:{format:"stencil8",stencilFront:{compare:"always",failOp:"zero",depthFailOp:"zero",passOp:"zero"},stencilBack:{compare:"always",failOp:"zero",depthFailOp:"zero",passOp:"zero"},stencilReadMask:255,stencilWriteMask:255},multisample:{count:this.sampleCount}});this.pipelines.set("node_clear_atlas",e)}dispose(){this.pipelines.clear(),this.bindGroupLayouts.clear(),this.shaderModuleCache.clear(),this.filterBindGroupLayouts.clear()}}class ma{constructor(e){Object.defineProperty(this,"device",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"pipelines",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"bindGroupLayouts",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.device=e,this.pipelines=new Map,this.bindGroupLayouts=new Map,this.initializeBlurPipelines()}initializeBlurPipelines(){const e=this.device.createBindGroupLayout({label:"blur_compute_bind_group_layout",entries:[{binding:0,visibility:GPUShaderStage.COMPUTE,texture:{sampleType:"float"}},{binding:1,visibility:GPUShaderStage.COMPUTE,storageTexture:{access:"write-only",format:"rgba8unorm"}},{binding:2,visibility:GPUShaderStage.COMPUTE,buffer:{type:"uniform"}}]});this.bindGroupLayouts.set("blur_compute",e),this.createBlurComputePipeline("blur_compute_horizontal"),this.createBlurComputePipeline("blur_compute_vertical"),this.createBlurComputePipeline("blur_compute_shared_horizontal",!0),this.createBlurComputePipeline("blur_compute_shared_vertical",!0)}createBlurComputePipeline(e,t=!1){const r=this.device.createShaderModule({label:`${e}_shader`,code:t?this.getSharedBlurComputeShaderCode():this.getBlurComputeShaderCode()}),n=this.device.createPipelineLayout({label:`${e}_layout`,bindGroupLayouts:[this.bindGroupLayouts.get("blur_compute")]}),i=this.device.createComputePipeline({label:e,layout:n,compute:{module:r,entryPoint:"main"}});this.pipelines.set(e,i)}getBlurComputeShaderCode(){return"\nstruct BlurParams {\n    direction: vec2<f32>,  // (1,0) or (0,1)\n    radius: f32,           // ブラー半径\n    fraction: f32,         // 端ピクセルのブレンド割合\n    texSize: vec2<f32>,    // テクスチャサイズ\n    samples: f32,          // サンプル数\n    padding: f32,          // パディング（16バイトアライメント）\n}\n\n@group(0) @binding(0) var inputTexture: texture_2d<f32>;\n@group(0) @binding(1) var outputTexture: texture_storage_2d<rgba8unorm, write>;\n@group(0) @binding(2) var<uniform> params: BlurParams;\n\nconst WORKGROUP_SIZE: u32 = 16u;\n\n@compute @workgroup_size(16, 16, 1)\nfn main(\n    @builtin(global_invocation_id) globalId: vec3<u32>\n) {\n    let texSize = vec2<u32>(u32(params.texSize.x), u32(params.texSize.y));\n    let radius = i32(params.radius);\n\n    let outCoord = globalId.xy;\n\n    if (outCoord.x >= texSize.x || outCoord.y >= texSize.y) {\n        return;\n    }\n\n    let direction = vec2<i32>(i32(params.direction.x), i32(params.direction.y));\n    let samples = params.samples;\n    let fraction = params.fraction;\n\n    var color = vec4<f32>(0.0);\n\n    for (var i = -radius; i <= radius; i = i + 1) {\n        var sampleCoord = vec2<i32>(outCoord) + direction * i;\n\n        sampleCoord.x = clamp(sampleCoord.x, 0, i32(texSize.x) - 1);\n        sampleCoord.y = clamp(sampleCoord.y, 0, i32(texSize.y) - 1);\n\n        let sample = textureLoad(inputTexture, vec2<u32>(sampleCoord), 0);\n\n        // 端ピクセルにfraction重みを適用（Fragment Shaderと同じロジック）\n        if (i == -radius || i == radius) {\n            color = color + sample * fraction;\n        } else {\n            color = color + sample;\n        }\n    }\n\n    color = color / samples;\n\n    textureStore(outputTexture, outCoord, color);\n}\n"}getSharedBlurComputeShaderCode(){return"\nstruct BlurParams {\n    direction: vec2<f32>,\n    radius: f32,\n    fraction: f32,\n    texSize: vec2<f32>,\n    samples: f32,\n    padding: f32,\n}\n\n@group(0) @binding(0) var inputTexture: texture_2d<f32>;\n@group(0) @binding(1) var outputTexture: texture_storage_2d<rgba8unorm, write>;\n@group(0) @binding(2) var<uniform> params: BlurParams;\n\nconst TILE: u32 = 16u;\nconst MAX_APRON: u32 = 24u;\nconst SHARED_W: u32 = TILE + 2u * MAX_APRON;\n\nvar<workgroup> tile: array<vec4<f32>, 1024>;\n\n@compute @workgroup_size(16, 16, 1)\nfn main(\n    @builtin(global_invocation_id) globalId: vec3<u32>,\n    @builtin(local_invocation_id) localId: vec3<u32>,\n    @builtin(workgroup_id) workgroupId: vec3<u32>\n) {\n    let texSize = vec2<u32>(u32(params.texSize.x), u32(params.texSize.y));\n    let radius = u32(params.radius);\n    let apron = min(radius, MAX_APRON);\n    let isHorizontal = params.direction.x > 0.5;\n    let fraction = params.fraction;\n    let samples = params.samples;\n\n    let threadIdx = localId.x + localId.y * TILE;\n    let totalThreads = TILE * TILE;\n\n    if (isHorizontal) {\n        let sharedWidth = TILE + 2u * apron;\n        let baseX = workgroupId.x * TILE;\n        let y = globalId.y;\n        let clampedY = clamp(y, 0u, max(texSize.y, 1u) - 1u);\n\n        // 全スレッドが協調ロード（範囲外スレッドもclampされた座標でロード）\n        var idx = threadIdx;\n        loop {\n            if (idx >= sharedWidth) { break; }\n            let gx = i32(baseX) + i32(idx) - i32(apron);\n            let cx = u32(clamp(gx, 0, i32(max(texSize.x, 1u)) - 1));\n            tile[localId.y * SHARED_W + idx] = textureLoad(inputTexture, vec2<u32>(cx, clampedY), 0);\n            idx += totalThreads;\n        }\n\n        // 全スレッドがバリアに到達（早期returnなし）\n        workgroupBarrier();\n\n        // 範囲内のスレッドのみ出力\n        let outX = globalId.x;\n        if (outX < texSize.x && y < texSize.y) {\n            let iRadius = i32(radius);\n            var color = vec4<f32>(0.0);\n            for (var i = -iRadius; i <= iRadius; i = i + 1) {\n                let tileIdx = i32(localId.x) + i32(apron) + i;\n                let s = tile[localId.y * SHARED_W + u32(clamp(tileIdx, 0, i32(sharedWidth) - 1))];\n                if (i == -iRadius || i == iRadius) {\n                    color += s * fraction;\n                } else {\n                    color += s;\n                }\n            }\n            textureStore(outputTexture, vec2<u32>(outX, y), color / samples);\n        }\n    } else {\n        let sharedHeight = TILE + 2u * apron;\n        let baseY = workgroupId.y * TILE;\n        let x = globalId.x;\n        let clampedX = clamp(x, 0u, max(texSize.x, 1u) - 1u);\n\n        // 全スレッドが協調ロード（範囲外スレッドもclampされた座標でロード）\n        var idx = threadIdx;\n        loop {\n            if (idx >= sharedHeight) { break; }\n            let gy = i32(baseY) + i32(idx) - i32(apron);\n            let cy = u32(clamp(gy, 0, i32(max(texSize.y, 1u)) - 1));\n            tile[idx * TILE + localId.x] = textureLoad(inputTexture, vec2<u32>(clampedX, cy), 0);\n            idx += totalThreads;\n        }\n\n        // 全スレッドがバリアに到達（早期returnなし）\n        workgroupBarrier();\n\n        // 範囲内のスレッドのみ出力\n        let outY = globalId.y;\n        if (x < texSize.x && outY < texSize.y) {\n            let iRadius = i32(radius);\n            var color = vec4<f32>(0.0);\n            for (var i = -iRadius; i <= iRadius; i = i + 1) {\n                let tileIdx = i32(localId.y) + i32(apron) + i;\n                let s = tile[u32(clamp(tileIdx, 0, i32(sharedHeight) - 1)) * TILE + localId.x];\n                if (i == -iRadius || i == iRadius) {\n                    color += s * fraction;\n                } else {\n                    color += s;\n                }\n            }\n            textureStore(outputTexture, vec2<u32>(x, outY), color / samples);\n        }\n    }\n}\n"}getPipeline(e){return this.pipelines.get(e)}getBindGroupLayout(e){return this.bindGroupLayouts.get(e)}destroy(){this.pipelines.clear(),this.bindGroupLayouts.clear()}}const ga=Number.MAX_VALUE,ba=-Number.MAX_VALUE;let xa=0;const va=e=>{xa=e},ya=[];let _a=null;const wa=()=>{if(!(xa in ya)){if(!_a)return null;{const t=_a(xa);e=t,ya[xa]=e}}var e;return ya[xa]},Ma=e=>e in ya?ya[e]:null,Pa=[],Sa=[],Fa=[];let Ta=0;const Ba=e=>{Ta=e},Oa=()=>Ta,Aa=()=>{Pa.length=0,va(0);for(let e=0;e<ya.length;e++){const t=ya[e];t&&(t.texture&&t.texture.resource.destroy(),t.stencil&&t.stencil.resource.destroy(),t.msaaTexture&&t.msaaTexture.resource.destroy(),t.msaaStencil&&t.msaaStencil.resource.destroy())}ya.length=0,(()=>{for(let e=0;e<Sa.length;++e){const t=Sa[e];t&&(t[0]=t[1]=ga,t[2]=t[3]=ba)}for(let e=0;e<Fa.length;++e){const t=Fa[e];t&&(t[0]=t[1]=ga,t[2]=t[3]=ba)}})(),Ba(0)};class Ra{constructor(){Object.defineProperty(this,"count",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.count=0}clear(){this.count=nr.offset=0}}let Ca="normal";const Ea=e=>{Ca=e},Ua=new Set(["normal","layer","add","screen","alpha","erase","copy"]),$a=[],Ga=[],ka=[],La=()=>{for(let e=0;e<$a.length;e++){const t=$a[e];Ga.push(t.color_transform),ka.push(t.matrix)}$a.length=0},Ia=new Map,Va=()=>{const e="blend_instanced";return Ia.has(e)||Ia.set(e,new Ra),Ia.get(e)};let za=!1;const ja=e=>{za=e},Da=()=>za;let Na=!1,Wa=0;const qa=e=>{Na=e},Xa=()=>Na,Ya=e=>{Wa=e},Ka=()=>Wa,Ha=new Map,Qa=new Map,Za=(e,t,r,n)=>{const i=Qn.currentAttachmentObject;if(!i)return;const a=i.clipLevel;let s=Ha.get(a);s?(s[0]=Math.min(s[0],e),s[1]=Math.min(s[1],t),s[2]=Math.max(s[2],r),s[3]=Math.max(s[3],n)):(s=Hn.getFloat32Array4(),s[0]=e,s[1]=t,s[2]=r,s[3]=n,Ha.set(a,s))},Ja=()=>{const e=Qn.currentAttachmentObject;if(!e)return;const t=(1<<e.clipLevel)-1;qa(!0),Ya(255&t),ja(!1)},es=()=>{const e=Qn.currentAttachmentObject;if(!e)return;const t=e.clipLevel,r=Ha.get(t);var n;if(r&&(Ha.delete(t),n=r,Hn.poolFloat32Array4(n)),Qa.delete(t),--e.clipLevel,!e.clipLevel)return e.mask=!1,ja(!1),qa(!1),Ya(0),e.needsStencilClear=!0,Qa.clear(),void Ha.clear();e.pendingStencilClearLevel=e.clipLevel,Ja()},ts=(e,t,r)=>{const n=e.length-5;for(let i=3;i<n;i+=3){let n=4*r;e[i+2]?(t[n++]=e[i-3],t[n++]=e[i-2],t[n++]=0,t[n++]=0,t[n++]=e[i],t[n++]=e[i+1],t[n++]=.5,t[n++]=0,t[n++]=e[i+3],t[n++]=e[i+4],t[n++]=1,t[n++]=1):e[i+5]?(t[n++]=e[0],t[n++]=e[1],t[n++]=.5,t[n++]=.5,t[n++]=e[i],t[n++]=e[i+1],t[n++]=.5,t[n++]=.5,t[n++]=e[i+6],t[n++]=e[i+7],t[n++]=.5,t[n++]=.5):(t[n++]=e[0],t[n++]=e[1],t[n++]=.5,t[n++]=.5,t[n++]=e[i],t[n++]=e[i+1],t[n++]=.5,t[n++]=.5,t[n++]=e[i+3],t[n++]=e[i+4],t[n++]=.5,t[n++]=.5),r+=3}return r};let rs=new Float32Array(32);const ns=e=>{let t=0;for(const r of e){const e=r.length-5;for(let r=3;r<e;r+=3)t+=3}const r=4*t;var n;rs.length<r&&(rs=new Float32Array((n=r,n--,n|=n>>1,n|=n>>2,n|=n>>4,n|=n>>8,n|=n>>16,++n)));const i=rs;let a=0;for(const t of e)a=ts(t,i,a);return{buffer:i.subarray(0,4*a),indexCount:a}},is=new OffscreenCanvas(1,1).getContext("2d"),as={x:0,y:0},ss={x:0,y:0},os={x:0,y:0},ls={x:0,y:0},cs=(e,t,r)=>({x:e.x+(t.x-e.x)*r,y:e.y+(t.y-e.y)*r}),us=e=>{const t=Math.sqrt(e.x*e.x+e.y*e.y);return 0===t?{x:0,y:0}:{x:e.x/t,y:e.y/t}},fs=(e,t,r,n)=>({x:(1-e)**2*t.x+2*(1-e)*e*r.x+e**2*n.x,y:(1-e)**2*t.y+2*(1-e)*e*r.y+e**2*n.y}),ds=(e,t,r,n)=>({x:2*(1-e)*(r.x-t.x)+2*e*(n.x-r.x),y:2*(1-e)*(r.y-t.y)+2*e*(n.y-r.y)}),hs=(e,t,r,n=.5)=>{const i=cs(e,t,n),a=cs(t,r,n),s=cs(i,a,n);return[[e,i,s],[s,a,r]]},ps=(e,t,r,n)=>{const i=[0,.5,1],a=[];for(const s of i){const i=fs(s,e,t,r),o=ds(s,e,t,r),l=us({x:-o.y,y:o.x});a.push({x:i.x+l.x*n,y:i.y+l.y*n})}return a},ms=(e,t,r,n)=>{const i=((e,t,r,n=4)=>{let i=[[e,t,r]];for(let e=0;e<n;e++){const e=[];for(const t of i){const r=hs(t[0],t[1],t[2],.5);e.push(r[0],r[1])}i=e}return i})(e,t,r,5),a=[],s=[];for(const e of i)a.push(ps(e[0],e[1],e[2],+n)),s.push(ps(e[0],e[1],e[2],-n));for(let e=0;e<a.length-1;++e)a[e+1][0]=a[e][2];for(let e=0;e<s.length-1;++e)s[e+1][0]=s[e][2];const o=a[0][0],l=[o.x,o.y,!1];for(let e=0;e<a.length;++e){const t=a[e];l.push(t[1].x,t[1].y,!0,t[2].x,t[2].y,!1)}const c=[...s].reverse();for(let e=0;e<c.length;++e){const[t,r,n]=c[e];c[e]=[n,r,t]}const u=c[0][0];l.push(u.x,u.y,!1);for(let e=0;e<c.length;++e){const t=c[e];l.push(t[1].x,t[1].y,!0,t[2].x,t[2].y,!1)}return l},gs=(e,t,r)=>{const n={x:t.x-e.x,y:t.y-e.y},i=((e,t,r)=>{const n=Math.sqrt(e*e+t*t);return 0===n?{x:0,y:0}:{x:-t/n*r,y:e/n*r}})(n.x,n.y,r),a={x:e.x+i.x,y:e.y+i.y},s={x:t.x+i.x,y:t.y+i.y},o={x:t.x-i.x,y:t.y-i.y},l={x:e.x-i.x,y:e.y-i.y};return[a.x,a.y,!1,s.x,s.y,!1,o.x,o.y,!1,l.x,l.y,!1,a.x,a.y,!1]},bs=(e,t,r,n)=>{const i=[];for(let a=0;a<n.length;a+=3){if(n[a+2])continue;const s=n[a],o=n[a+1],l=Math.sqrt(Math.pow(s-e,2)+Math.pow(o-t,2));Math.abs(l-r)>1e-4||i.push(s,o)}return i},xs=(e,t)=>{is.beginPath(),is.moveTo(t[0],t[1]);for(let e=3;e<t.length;e+=3)t[e+2]?(is.quadraticCurveTo(t[e],t[e+1],t[e+3],t[e+4]),e+=3):is.lineTo(t[e],t[e+1]);is.closePath();for(let t=0;t<e.length;t+=2){const r=e[t],n=e[t+1];if(!is.isPointInPath(r,n))return[r,n]}return null},vs=(e,t,r,n,i=!1)=>{const a=i?0:n.length-1,s=i?n.length-1:n.length-2,o=bs(e,t,r,n[a]),l=bs(e,t,r,n[s]);if(o[0]===l[0]&&o[1]===l[1]||o[0]===l[2]&&o[1]===l[3])return;const c=xs(o,n[s]);if(!c)return;const u=xs(l,n[a]);u&&n.splice(-1,0,[e,t,!1,c[0],c[1],!1,u[0],u[1],!1,e,t,!1])},ys=(e,t,r,n,i=!1)=>{const a=i?0:n.length-1,s=i?n.length-1:n.length-2,o=bs(e,t,r,n[a]),l=bs(e,t,r,n[s]),c=xs(o,n[s]);if(!c)return;const u=xs(l,n[a]);if(!u)return;const f=Math.atan2(c[1]-t,c[0]-e);let d=Math.atan2(u[1]-t,u[0]-e)-f;d>Math.PI?d-=2*Math.PI:d<-Math.PI&&(d+=2*Math.PI);const h=d/8,p=[e,t,!1];for(let n=0;n<=8;n++){const i=f+n*h,a=e+r*Math.cos(i),s=t+r*Math.sin(i);p.push(a,s,!1)}n.splice(-1,0,p)},_s=(e,t,r,n,i,a=!1)=>{const s=a?0:i.length-1,o=a?i.length-1:i.length-2,l=bs(e.x,e.y,n,i[s]),c=bs(e.x,e.y,n,i[o]);if(l[0]===c[0]&&l[1]===c[1]||l[0]===c[2]&&l[1]===c[3])return;const u=xs(l,i[o]);if(!u)return;const f=xs(c,i[s]);if(!f)return;const d=t.x-e.x,h=t.y-e.y,p=Math.hypot(d,h),m={x:d/p,y:h/p},g=r.x-e.x,b=r.y-e.y,x=Math.hypot(g,b),v={x:g/x,y:b/x},y=m.x,_=m.y,w=v.x,M=v.y,P=y*M-_*w;if(0===P)return void i.splice(-1,0,[e.x,e.y,!1,u[0],u[1],!1,f[0],f[1],!1]);const S=((f[0]-u[0])*M-(f[1]-u[1])*w)/P,F=u[0]+S*y,T=u[1]+S*_;i.splice(-1,0,[e.x,e.y,!1,u[0],u[1],!1,F,T,!1,e.x,e.y,!1,f[0],f[1],!1,F,T,!1])},ws=(e,t)=>{const r=as;r.x=e[0],r.y=e[1];const n=ss;n.x=0,n.y=0;const i=os;i.x=0,i.y=0;const a=ls;a.x=0,a.y=0;const s=[];for(let o=3;o<e.length;o+=3){const l=e[o],c=e[o+1];if(e[o+2])n.x=l,n.y=c;else{if(i.x=l,i.y=c,e[o-1]?s.push(ms(r,n,i,t)):s.push(gs(r,i,t)),s.length>1)switch(Qn.joints){case 0:vs(r.x,r.y,t,s);break;case 1:a.x=e[o-6],a.y=e[o-5],_s(r,i,a,t,s);break;case 2:ys(r.x,r.y,t,s)}r.x=i.x,r.y=i.y}}const o=e[0],l=e[1],c=e[e.length-3],u=e[e.length-2],f=1e-4;if(Math.abs(o-c)<f&&Math.abs(l-u)<f&&s.length>1)switch(Qn.joints){case 0:vs(o,l,t,s,!0);break;case 1:r.x=o,r.y=l,i.x=e[3],i.y=e[4],a.x=e[e.length-6],a.y=e[e.length-5],_s(r,i,a,t,s,!0);break;case 2:ys(o,l,t,s,!0)}else if(s.length>0)switch(Qn.caps){case 1:((e,t,r)=>{const n=e[0],i=e[1],a=e[3],s=e[4],o=Math.atan2(i-s,n-a),l=[n,i,!1];for(let e=0;e<=8;e++){const r=o-Math.PI/2+e*Math.PI/8;l.push(n+t*Math.cos(r),i+t*Math.sin(r),!1)}r.unshift(l);const c=e[e.length-3],u=e[e.length-2],f=e[e.length-6],d=e[e.length-5],h=Math.atan2(u-d,c-f),p=[c,u,!1];for(let e=0;e<=8;e++){const r=h-Math.PI/2+e*Math.PI/8;p.push(c+t*Math.cos(r),u+t*Math.sin(r),!1)}r.push(p)})(e,t,s);break;case 2:((e,t,r)=>{const n=e[0],i=e[1],a=n-e[3],s=i-e[4],o=Math.hypot(a,s);if(o>0){const e=a/o,l=s/o,c=n+e*t,u=i+l*t,f=[n-l*t,i+e*t,!1,c-l*t,u+e*t,!1,c+l*t,u-e*t,!1,n+l*t,i-e*t,!1,n-l*t,i+e*t,!1];r.unshift(f)}const l=e[e.length-3],c=e[e.length-2],u=l-e[e.length-6],f=c-e[e.length-5],d=Math.hypot(u,f);if(d>0){const e=u/d,n=f/d,i=l+e*t,a=c+n*t,s=[l-n*t,c+e*t,!1,i-n*t,a+e*t,!1,i+n*t,a-e*t,!1,l+n*t,c-e*t,!1,l-n*t,c+e*t,!1];r.push(s)}})(e,t,s)}return s},Ms=new Map;let Ps=0;const Ss=new WeakMap,Fs=e=>{let t=Ss.get(e);return t||(t=e.createView(),Ss.set(e,t)),t},Ts=new Map,Bs=new Map,Os=(e,t,r)=>{const n=`${t}_${r}`,i=Ts.get(n);return i&&i.length>0?i.pop():e.createTexture({size:{width:t,height:r},format:"rgba8unorm",usage:6})},As=e=>{const t=`${e.width}_${e.height}`;let r=Ts.get(t);r||(r=[],Ts.set(t,r)),r.push(e)},Rs=(e,t,r)=>{const n=`${t}_${r}`,i=Bs.get(n);return i&&i.length>0?i.pop():e.createTexture({size:{width:t,height:r},format:"rgba8unorm",usage:22})},Cs=e=>{const t=`${e.width}_${e.height}`;let r=Bs.get(t);r||(r=[],Bs.set(t,r)),r.push(e)},Es=new Map,Us=new Map;let $s=0;const Gs=(e,t,r)=>`${t}_${r}_${e.join(",")}`,ks=(e,t,r)=>{const n=Gs(e,t,r),i=Us.get(n);return i?(i.lastUsedFrame=$s,i):null},Ls=(e,t,r,n,i)=>{const a=Gs(e,t,r);Us.set(a,{texture:n,view:i,lastUsedFrame:$s})};let Is=null;const Vs=e=>e<=4?256:e<=8?512:1024,zs=(e,t,r)=>{const n=e.length/5,i=Vs(n),a=new Uint8Array(4*i);for(let t=0;t<i;t++){const n=js(e,t/(i-1),r),s=4*t;a[s+0]=Math.round(Math.max(0,Math.min(255,n.r))),a[s+1]=Math.round(Math.max(0,Math.min(255,n.g))),a[s+2]=Math.round(Math.max(0,Math.min(255,n.b))),a[s+3]=Math.round(Math.max(0,Math.min(255,n.a)))}return a},js=(e,t,r)=>{const n=e.length/5;let i=0,a=0;for(let r=0;r<n;r++){const n=e[5*r];if(n<=t&&(i=r),n>=t&&0===a){a=r;break}}if(0===a&&(a=n-1),i===a){const t=5*i;return{r:e[t+1],g:e[t+2],b:e[t+3],a:e[t+4]}}const s=e[5*i],o=(t-s)/(e[5*a]-s),l=e[5*i+1],c=e[5*i+2],u=e[5*i+3],f=e[5*i+4],d=e[5*a+1],h=e[5*a+2],p=e[5*a+3],m=e[5*a+4];return 0===r?{r:255*Ws(Ds(Ns(l/255),Ns(d/255),o)),g:255*Ws(Ds(Ns(c/255),Ns(h/255),o)),b:255*Ws(Ds(Ns(u/255),Ns(p/255),o)),a:Ds(f,m,o)}:{r:Ds(l,d,o),g:Ds(c,h,o),b:Ds(u,p,o),a:Ds(f,m,o)}},Ds=(e,t,r)=>e+(t-e)*r,Ns=e=>Math.pow(e,2.23333333),Ws=e=>Math.pow(e,.45454545),qs=(e,t,r)=>{const n=new Uint8Array(1024),i=e.length,a=[];for(let n=0;n<i;n++){const i=t[n];a.push({offset:e[n]/255,r:(i>>16&255)/255,g:(i>>8&255)/255,b:(255&i)/255,a:r[n]})}for(let e=0;e<256;e++){const t=e/255;let r=0,s=i-1;for(let e=0;e<i-1;e++)if(a[e].offset<=t&&a[e+1].offset>=t){r=e,s=e+1;break}const o=a[r],l=a[s];let c=0;l.offset!==o.offset&&(c=(t-o.offset)/(l.offset-o.offset));const u=Ds(o.r,l.r,c),f=Ds(o.g,l.g,c),d=Ds(o.b,l.b,c),h=Ds(o.a,l.a,c),p=4*e;n[p+0]=Math.round(u*h*255),n[p+1]=Math.round(f*h*255),n[p+2]=Math.round(d*h*255),n[p+3]=Math.round(255*h)}return n},Xs=(e,t,r)=>{const n=e[0],i=e[1],a=e[2],s=e[3],o=e[4],l=e[5];if(0===r){const e=-819.2*n-819.2*a+o,t=819.2*n-819.2*a+o,r=-819.2*i-819.2*s+l,c=819.2*i-819.2*s+l;let u=-819.2*n+819.2*a+o-e,f=-819.2*i+819.2*s+l-r;const d=Math.sqrt(u*u+f*f);d?(u/=d,f/=d):(u=0,f=0);const h=(t-e)*u+(c-r)*f,p=new Float32Array([e+h*u,r+h*f,t,c]);return{inverseMatrix:new Float32Array([1,0,0,0,1,0,0,0,1]),linearPoints:p}}const c=n*s-i*a;if(Math.abs(c)<1e-10)return{inverseMatrix:new Float32Array([1,0,0,0,1,0,0,0,1]),linearPoints:null};const u=1/c;return{inverseMatrix:new Float32Array([s*u,-i*u,0,-a*u,n*u,0,(a*l-s*o)*u,(i*o-n*l)*u,1]),linearPoints:null}};let Ys=null;const Ks=new Float32Array(36),Hs=new Float32Array(16);let Qs=null,Zs=null;const Js=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],eo=(e,t)=>{const r=e[0],n=e[1],i=e[2],a=e[3],s=e[4],o=e[5],l=t[0],c=t[1],u=t[3],f=t[4],d=t[6],h=t[7],p=l*r+u*n,m=l*i+u*a,g=c*r+f*n,b=c*i+f*a,x=l*s+u*o+d,v=c*s+f*o+h,y=p*b-m*g;if(Math.abs(y)<1e-10)return new Float32Array([1,0,0,0,1,0,0,0,1]);const _=1/y,w=b*_,M=-m*_,P=-g*_,S=p*_;return new Float32Array([w*l+M*c,P*l+S*c,0,w*u+M*f,P*u+S*f,0,w*d+M*h+(m*v-b*x)*_,P*d+S*h+(g*x-p*v)*_,1])},to=new Map,ro=new Float32Array(32),no=new Float32Array(16);let io=null,ao=null;const so=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],oo=(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g=!1,b=1)=>{const x=ns(i);if(0===x.indexCount)return null;const v=r.acquireVertexBuffer(x.buffer.byteLength,x.buffer),y=Os(e,c,u);e.queue.writeTexture({texture:y},o.buffer,{bytesPerRow:4*c,rowsPerImage:u,offset:o.byteOffset},{width:c,height:u});const _=eo(l,a),w=s[0],M=s[1],P=s[2],S=s[3],F=a[0],T=a[1],B=a[3],O=a[4],A=a[6],R=a[7];ro[0]=_[0],ro[1]=_[1],ro[2]=_[2],ro[3]=0,ro[4]=_[3],ro[5]=_[4],ro[6]=_[5],ro[7]=0,ro[8]=_[6],ro[9]=_[7],ro[10]=_[8],ro[11]=0,ro[12]=c,ro[13]=u,ro[14]=f?1:0,ro[15]=0,ro[16]=w,ro[17]=M,ro[18]=P,ro[19]=S,ro[20]=F/h,ro[21]=T/p,ro[22]=0,ro[23]=0,ro[24]=B/h,ro[25]=O/p,ro[26]=0,ro[27]=0,ro[28]=A/h,ro[29]=R/p,ro[30]=1,ro[31]=0;const C=r.acquireAndWriteUniformBuffer(ro),E=`bitmap_${d?"s":"n"}_${f?"r":"c"}`;let U=to.get(E);U||(U=e.createSampler({magFilter:d?"linear":"nearest",minFilter:d?"linear":"nearest",addressModeU:f?"repeat":"clamp-to-edge",addressModeV:f?"repeat":"clamp-to-edge"}),to.set(E,U));const $=n.getBindGroupLayout("bitmap_fill");if(!$)return console.error("[WebGPU] bitmap_fill bind group layout not found"),As(y),null;so[0].resource.buffer=C,so[1].resource=U,so[2].resource=y.createView();const G=e.createBindGroup({layout:$,entries:so});if(m&&g){const i=n.getPipeline("stencil_write");if(i){const a=(()=>{const t=n.getBindGroupLayout("fill_dynamic");if(!t)return null;no[0]=w,no[1]=M,no[2]=P,no[3]=S,no[4]=F/h,no[5]=T/p,no[6]=0,no[7]=0,no[8]=B/h,no[9]=O/p,no[10]=0,no[11]=0,no[12]=A/h,no[13]=R/p,no[14]=1,no[15]=0;const i=r.dynamicUniform.allocate(no),a=r.dynamicUniform.getBuffer();return io&&ao===a||(io=e.createBindGroup({layout:t,entries:[{binding:0,resource:{buffer:a,size:256}}]}),ao=a),{bindGroup:io,offset:i}})();a&&(t.setPipeline(i),t.setStencilReference(0),t.setVertexBuffer(0,v),t.setBindGroup(0,a.bindGroup,[a.offset]),t.draw(x.indexCount,1,0,0))}const a=n.getPipeline("bitmap_fill_stencil");a&&(t.setPipeline(a),t.setStencilReference(0),t.setBindGroup(0,G),t.draw(x.indexCount,1,0,0))}else{let e;if(m)e="bitmap_fill";else if(g){if(Da())return As(y),null;e="bitmap_fill_bgra_stencil"}else e="bitmap_fill_bgra";const r=n.getPipeline(e);if(!r)return console.error(`[WebGPU] ${e} pipeline not found`),As(y),null;t.setPipeline(r),t.setVertexBuffer(0,v),t.setBindGroup(0,G),!g||m||Da()||t.setStencilReference(Ka()),t.draw(x.indexCount,1,0,0)}return y},lo=(e,t,r)=>{const n=e.length-5;for(let i=3;i<n;i+=3){let n=4*r;e[i+2]?(t[n++]=e[i-3],t[n++]=e[i-2],t[n++]=.5,t[n++]=.5,t[n++]=e[i],t[n++]=e[i+1],t[n++]=.5,t[n++]=.5,t[n++]=e[i+3],t[n++]=e[i+4],t[n++]=.5,t[n++]=.5):e[i+5]?(t[n++]=e[0],t[n++]=e[1],t[n++]=.5,t[n++]=.5,t[n++]=e[i],t[n++]=e[i+1],t[n++]=.5,t[n++]=.5,t[n++]=e[i+6],t[n++]=e[i+7],t[n++]=.5,t[n++]=.5):(t[n++]=e[0],t[n++]=e[1],t[n++]=.5,t[n++]=.5,t[n++]=e[i],t[n++]=e[i+1],t[n++]=.5,t[n++]=.5,t[n++]=e[i+3],t[n++]=e[i+4],t[n++]=.5,t[n++]=.5),r+=3}return r};let co=new Float32Array(32);let uo=null;const fo=new Float32Array(36),ho=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],po=(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g,b)=>{const x=((e,t)=>{const r=t/2,n=[];for(const t of e){const e=ws(t,r);for(const t of e)n.push(t)}let i=0;for(const e of n){const t=e.length-5;for(let e=3;e<t;e+=3)i+=3}if(0===i)return{buffer:new Float32Array(0),indexCount:0};const a=4*i;var s;co.length<a&&(co=new Float32Array((s=a,s--,s|=s>>1,s|=s>>2,s|=s>>4,s|=s>>8,s|=s>>16,++s)));const o=co;let l=0;for(const e of n)l=lo(e,o,l);return{buffer:o.subarray(0,4*l),indexCount:l}})(i,a);if(0===x.indexCount)return null;const v=r.acquireVertexBuffer(x.buffer.byteLength,x.buffer);let y,_;const w=ks(c,f,d);if(w)y=w.texture,_=w.view;else{const t=zs(c,0,d),r=c.length/5,n=Vs(r);y=Os(e,n,1),e.queue.writeTexture({texture:y},t,{bytesPerRow:4*n,rowsPerImage:1},{width:n,height:1}),_=y.createView(),Ls(c,f,d,y,_)}const M=Xs(u,0,l),P=o[3]>0?o[3]:1,S=s[0],F=s[1],T=s[3],B=s[4],O=s[6],A=s[7];fo[0]=M.inverseMatrix[0],fo[1]=M.inverseMatrix[3],fo[2]=0,fo[3]=0,fo[4]=M.inverseMatrix[1],fo[5]=M.inverseMatrix[4],fo[6]=0,fo[7]=0,fo[8]=M.inverseMatrix[6],fo[9]=M.inverseMatrix[7],fo[10]=1,fo[11]=0,fo[12]=l,fo[13]=Math.max(-.975,Math.min(.975,h)),fo[14]=f,fo[15]=819.2,M.linearPoints?(fo[16]=M.linearPoints[0],fo[17]=M.linearPoints[1],fo[18]=M.linearPoints[2],fo[19]=M.linearPoints[3]):(fo[16]=0,fo[17]=0,fo[18]=0,fo[19]=0),fo[20]=1,fo[21]=1,fo[22]=1,fo[23]=P,fo[24]=S/p,fo[25]=F/m,fo[26]=0,fo[27]=0,fo[28]=T/p,fo[29]=B/m,fo[30]=0,fo[31]=0,fo[32]=O/p,fo[33]=A/m,fo[34]=1,fo[35]=0;const R=r.acquireAndWriteUniformBuffer(fo);uo||(uo=e.createSampler({magFilter:"linear",minFilter:"linear",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"}));const C=uo,E=n.getBindGroupLayout("gradient_fill");if(!E)return console.error("[WebGPU] gradient_fill bind group layout not found"),null;ho[0].resource.buffer=R,ho[1].resource=C,ho[2].resource=_;const U=e.createBindGroup({layout:E,entries:ho}),$=b?g?"gradient_stroke_atlas":"gradient_stroke_bgra":g?"gradient_fill":"gradient_fill_bgra",G=n.getGradientPipeline($,l,f);return G?(t.setPipeline(G),t.setVertexBuffer(0,v),t.setBindGroup(0,U),t.draw(x.indexCount,1,0,0),null):(console.error(`[WebGPU] ${$} pipeline not found`),null)};let mo=new Float32Array(32);const go=new Map,bo=new Float32Array(32),xo=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],vo=(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g,b)=>{const x=((e,t)=>{const r=t/2,n=[];for(const t of e){const e=ws(t,r);for(const t of e)n.push(t)}let i=0;for(const e of n){const t=e.length-5;for(let e=3;e<t;e+=3)i+=3}if(0===i)return{buffer:new Float32Array(0),indexCount:0};const a=4*i;var s;mo.length<a&&(mo=new Float32Array((s=a,s--,s|=s>>1,s|=s>>2,s|=s>>4,s|=s>>8,s|=s>>16,++s)));const o=mo;let l=0;for(const e of n)l=lo(e,o,l);return{buffer:o.subarray(0,4*l),indexCount:l}})(i,a);if(0===x.indexCount)return null;const v=r.acquireVertexBuffer(x.buffer.byteLength,x.buffer),y=Os(e,u,f);e.queue.writeTexture({texture:y},l.buffer,{bytesPerRow:4*u,rowsPerImage:f,offset:l.byteOffset},{width:u,height:f});const _=eo(c,s),w=o[3]>0?o[3]:1,M=s[0],P=s[1],S=s[3],F=s[4],T=s[6],B=s[7];bo[0]=_[0],bo[1]=_[1],bo[2]=_[2],bo[3]=0,bo[4]=_[3],bo[5]=_[4],bo[6]=_[5],bo[7]=0,bo[8]=_[6],bo[9]=_[7],bo[10]=_[8],bo[11]=0,bo[12]=u,bo[13]=f,bo[14]=d?1:0,bo[15]=0,bo[16]=1,bo[17]=1,bo[18]=1,bo[19]=w,bo[20]=M/p,bo[21]=P/m,bo[22]=0,bo[23]=0,bo[24]=S/p,bo[25]=F/m,bo[26]=0,bo[27]=0,bo[28]=T/p,bo[29]=B/m,bo[30]=1,bo[31]=0;const O=r.acquireAndWriteUniformBuffer(bo),A=`bitmap_${h?"s":"n"}_${d?"r":"c"}`;let R=go.get(A);R||(R=e.createSampler({magFilter:h?"linear":"nearest",minFilter:h?"linear":"nearest",addressModeU:d?"repeat":"clamp-to-edge",addressModeV:d?"repeat":"clamp-to-edge"}),go.set(A,R));const C=n.getBindGroupLayout("bitmap_fill");if(!C)return console.error("[WebGPU] bitmap_fill bind group layout not found"),As(y),null;xo[0].resource.buffer=O,xo[1].resource=R,xo[2].resource=y.createView();const E=e.createBindGroup({layout:C,entries:xo}),U=b?g?"bitmap_stroke_atlas":"bitmap_stroke_bgra":g?"bitmap_fill":"bitmap_fill_bgra",$=n.getPipeline(U);return $?(t.setPipeline($),t.setVertexBuffer(0,v),t.setBindGroup(0,E),t.draw(x.indexCount,1,0,0),y):(console.error(`[WebGPU] ${U} pipeline not found`),As(y),null)},yo=new Float32Array([-1,-1,.5,.5,1,-1,.5,.5,-1,1,.5,.5,-1,1,.5,.5,1,-1,.5,.5,1,1,.5,.5]),_o=new Float32Array([1,1,1,1,.5,0,0,0,0,.5,0,0,.5,.5,1,0]),wo=new Float32Array(16),Mo=(e,t,r,n,i,a,s,o,l,c=!1)=>{const u=i.clipLevel,f=i.width,d=i.height,h=o[0],p=o[1],m=o[2],g=o[3]*l;if(0===a.length)return;const b=ns(a);if(0===b.indexCount)return;const x=r.acquireVertexBuffer(b.buffer.byteLength,b.buffer),v=s[0],y=s[1],_=s[3],w=s[4],M=s[6],P=s[7];wo[0]=h,wo[1]=p,wo[2]=m,wo[3]=g,wo[4]=v/f,wo[5]=y/d,wo[6]=0,wo[7]=0,wo[8]=_/f,wo[9]=w/d,wo[10]=0,wo[11]=0,wo[12]=M/f,wo[13]=P/d,wo[14]=1,wo[15]=0;const S=r.dynamicUniform.allocate(wo);let F,T=Qa.get(u)??u;if(c){F=`clip_write_main_${Math.min(8,Math.max(1,T))}`}else F="clip_write";const B=n.getPipeline(F);if(!B)return void console.error(`[WebGPU] ${F} pipeline not found`);const O=n.getBindGroupLayout("fill_dynamic");if(!O)return;const A=e.createBindGroup({layout:O,entries:[{binding:0,resource:{buffer:r.dynamicUniform.getBuffer(),size:256}}]});t.setPipeline(B),t.setStencilReference(0),t.setVertexBuffer(0,x),t.setBindGroup(0,A,[S]),t.draw(b.indexCount,1,0,0),T++,T>8&&(((e,t,r,n,i)=>{if(!i)return;const a=i.clipLevel,s=1<<a-1,o=r.acquireVertexBuffer(yo.byteLength,yo),l=r.dynamicUniform.allocate(_o),c=n.getBindGroupLayout("fill_dynamic");if(!c)return;const u=e.createBindGroup({layout:c,entries:[{binding:0,resource:{buffer:r.dynamicUniform.getBuffer(),size:256}}]}),f=n.getPipeline(`mask_union_merge_${a}`);f&&(t.setPipeline(f),t.setStencilReference(s),t.setVertexBuffer(0,o),t.setBindGroup(0,u,[l]),t.draw(6,1,0,0));const d=n.getPipeline(`mask_union_clear_${a}`);d&&(t.setPipeline(d),t.setStencilReference(0),t.setVertexBuffer(0,o),t.setBindGroup(0,u,[l]),t.draw(6,1,0,0))})(e,t,r,n,i),T=u+1),Qa.set(u,T)};let Po=null,So=null;let Fo=null,To=null;const Bo=new Float32Array(12),Oo=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null},{binding:3,resource:null}],Ao=(e,t,r,n,i)=>{const{device:a,commandEncoder:s,frameBufferManager:o,pipelineManager:l,textureManager:c}=i,u=Math.max(e.width,t.width),f=Math.max(e.height,t.height),d=o.createTemporaryAttachment(u,f),h=l.getPipeline("complex_blend"),p=l.getBindGroupLayout("complex_blend");if(!h||!p)return console.error(`[WebGPU ComplexBlend] Pipeline not found for blend mode: ${r}`),e;const m=c.createSampler("complex_blend_sampler",!0),g=fa.getBlendModeIndex(r);Bo[0]=n[0],Bo[1]=n[1],Bo[2]=n[2],Bo[3]=n[3],Bo[4]=n[4],Bo[5]=n[5],Bo[6]=n[6],Bo[7]=n[7],Bo[8]=g,Bo[9]=0,Bo[10]=0,Bo[11]=0;const b=i.bufferManager?i.bufferManager.acquireAndWriteUniformBuffer(Bo):a.createBuffer({size:48,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});i.bufferManager||a.queue.writeBuffer(b,0,Bo),Oo[0].resource.buffer=b,Oo[1].resource=m,Oo[2].resource=t.texture.view,Oo[3].resource=e.texture.view;const x=a.createBindGroup({layout:p,entries:Oo}),v=o.createRenderPassDescriptor(d.texture.view,0,0,0,0,"clear"),y=s.beginRenderPass(v);return y.setPipeline(h),y.setBindGroup(0,x),y.draw(6,1,0,0),y.end(),d},Ro=new Float32Array(4),Co=new Float32Array(6),Eo=new Float32Array(8),Uo=new Float32Array(12),$o=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],Go=(e,t,r,n,i,a,s,o,l,c,u,f,d,h)=>{const p=d.getPipeline("complex_blend_copy"),m=d.getBindGroupLayout("texture_copy");if(!p||!m)return;Ro[0]=l/s,Ro[1]=c/o,Ro[2]=i/s,Ro[3]=a/o;const g=h.acquireAndWriteUniformBuffer(Ro),b=f.createSampler("complex_blend_copy_sampler",!1);$o[0].resource.buffer=g,$o[1].resource=b,$o[2].resource=r;const x=e.createBindGroup({layout:m,entries:$o}),v=u.createRenderPassDescriptor(n.texture.view,0,0,0,0,"clear"),y=t.beginRenderPass(v);y.setPipeline(p),y.setBindGroup(0,x),y.draw(6,1,0,0),y.end()},ko=(e,t,r,n,i,a,s,o,l,c)=>{const u=n.msaa&&n.msaaTexture?.view,f=u?"complex_blend_output_msaa":"complex_blend_output",d=l.getPipeline(f),h=l.getBindGroupLayout("positioned_texture");if(!d||!h)return;Eo[0]=i,Eo[1]=a,Eo[2]=r.width,Eo[3]=r.height,Eo[4]=n.width,Eo[5]=n.height,Eo[6]=0,Eo[7]=0;const p=c.acquireAndWriteUniformBuffer(Eo),m=o.createSampler("complex_blend_output_sampler",!1);$o[0].resource.buffer=p,$o[1].resource=m,$o[2].resource=r.texture.view;const g=e.createBindGroup({layout:h,entries:$o}),b=u?n.msaaTexture.view:n.texture.view,x=u?n.texture.view:null,v=s.createRenderPassDescriptor(b,0,0,0,0,"load",x),y=t.beginRenderPass(v);y.setPipeline(d),y.setBindGroup(0,g),y.draw(6,1,0,0),y.end()},Lo=(e,t,r,n,i,a,s)=>{const o=$a;if(0===o.length)return;if(!r||!r.texture)return void La();const l=wa()||n.getAttachment("atlas");if(l&&l.texture){for(const c of o){const{node:o,x_min:u,y_min:f,x_max:d,y_max:h,color_transform:p,matrix:m,blend_mode:g,global_alpha:b}=c,x=Math.ceil(Math.abs(d-u)),v=Math.ceil(Math.abs(h-f));if(x<=0||v<=0)continue;const y=Math.max(0,Math.floor(m[6])),_=Math.max(0,Math.floor(m[7]));if(y>=r.width||_>=r.height)continue;const w=1!==m[0]||0!==m[1]||0!==m[3]||1!==m[4],M=w?x:o.w,P=w?v:o.h,S=Math.min(M,r.width-y),F=Math.min(P,r.height-_);if(S<=0||F<=0)continue;let T;if(w){T=n.createTemporaryAttachment(M,P);const r=a.getPipeline("complex_blend_scale"),c=a.getBindGroupLayout("texture_scale");if(r&&c){const a=M/2,u=P/2,f=o.w/2,d=o.h/2;Co[0]=m[0],Co[1]=m[1],Co[2]=m[3],Co[3]=m[4],Co[4]=-f*m[0]-d*m[3]+a,Co[5]=-f*m[1]-d*m[4]+u;const h=n.createTemporaryAttachment(o.w,o.h);t.copyTextureToTexture({texture:l.texture.resource,origin:{x:o.x,y:o.y,z:0}},{texture:h.texture.resource,origin:{x:0,y:0,z:0}},{width:o.w,height:o.h}),Uo[0]=Co[0],Uo[1]=Co[1],Uo[2]=Co[2],Uo[3]=Co[3],Uo[4]=Co[4],Uo[5]=Co[5],Uo[6]=o.w,Uo[7]=o.h,Uo[8]=M,Uo[9]=P,Uo[10]=0,Uo[11]=0;const p=s.acquireAndWriteUniformBuffer(Uo,48),g=i.createSampler("scale_sampler",!0);$o[0].resource.buffer=p,$o[1].resource=g,$o[2].resource=h.texture.view;const b=e.createBindGroup({layout:c,entries:$o}),x=n.createRenderPassDescriptor(T.texture.view,0,0,0,0,"clear"),v=t.beginRenderPass(x);v.setPipeline(r),v.setBindGroup(0,b),v.draw(6,1,0,0),v.end(),n.releaseTemporaryAttachment(h)}else t.copyTextureToTexture({texture:l.texture.resource,origin:{x:o.x,y:o.y,z:0}},{texture:T.texture.resource,origin:{x:0,y:0,z:0}},{width:Math.min(o.w,M),height:Math.min(o.h,P)})}else T=n.createTemporaryAttachment(M,P),t.copyTextureToTexture({texture:l.texture.resource,origin:{x:o.x,y:o.y,z:0}},{texture:T.texture.resource,origin:{x:0,y:0,z:0}},{width:M,height:P});const B=n.createTemporaryAttachment(M,P);Go(e,t,r.texture.view,B,y,_,r.width,r.height,M,P,n,i,a,s),Eo[0]=p[0],Eo[1]=p[1],Eo[2]=p[2],Eo[3]=b,Eo[4]=p[4],Eo[5]=p[5],Eo[6]=p[6],Eo[7]=0;const O=Ao(T,B,g,Eo,{device:e,commandEncoder:t,bufferManager:s,frameBufferManager:n,pipelineManager:a,textureManager:i});ko(e,t,O,r,y,_,n,i,a,s),n.releaseTemporaryAttachment(T),n.releaseTemporaryAttachment(B),n.releaseTemporaryAttachment(O)}La()}else La()},Io={x:0,y:0},Vo=[.5,1.05,1.4,1.55,1.75,1.9,2,2.15,2.2,2.3,2.5,3,3,3.5,3.5],zo=new Float32Array(8),jo=[{binding:0,resource:null},{binding:1,resource:null},{binding:2,resource:{buffer:null}}],Do={label:"blur_compute_pass_h"},No={label:"blur_compute_pass_v"},Wo=(e,t,r,n,i,a,s,o)=>{const l=Math.ceil(.5*s),c=l>=8&&l<=24?a?"blur_compute_shared_horizontal":"blur_compute_shared_vertical":a?"blur_compute_horizontal":"blur_compute_vertical",u=r.getPipeline(c),f=r.getBindGroupLayout("blur_compute");if(!u||!f)return;const d=1-(l-.5*s),h=1+s;zo[0]=a?1:0,zo[1]=a?0:1,zo[2]=l,zo[3]=d,zo[4]=n.width,zo[5]=n.height,zo[6]=h,zo[7]=0;const p=o?o.acquireAndWriteUniformBuffer(zo):(()=>{const t=e.createBuffer({size:zo.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});return e.queue.writeBuffer(t,0,zo),t})();jo[0].resource=n.texture.view,jo[1].resource=i.texture.view,jo[2].resource.buffer=p;const m=e.createBindGroup({layout:f,entries:jo}),g=t.beginComputePass(a?Do:No);g.setPipeline(u),g.setBindGroup(0,m);const b=Math.ceil(i.width/16),x=Math.ceil(i.height/16);g.dispatchWorkgroups(b,x,1),g.end()},qo=new Float32Array(4),Xo=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],Yo=(e,t,r,n,i,a,s)=>{const{device:o,commandEncoder:l,frameBufferManager:c,pipelineManager:u,textureManager:f}=s,d=((e,t,r,n,i)=>{const a=t*(Math.sqrt(e[0]*e[0]+e[1]*e[1])/i),s=r*(Math.sqrt(e[2]*e[2]+e[3]*e[3])/i),o=Vo[Math.min(n-1,Vo.length-1)];let l=1,c=1;return a>128?l=.0625:a>64?l=.125:a>32?l=.25:a>16&&(l=.5),s>128?c=.0625:s>64?c=.125:s>32?c=.25:s>16&&(c=.5),{baseBlurX:a,baseBlurY:s,offsetX:Math.round(a*o),offsetY:Math.round(s*o),bufferScaleX:l,bufferScaleY:c}})(t,r,n,i,a),{baseBlurX:h,baseBlurY:p,offsetX:m,offsetY:g,bufferScaleX:b,bufferScaleY:x}=d;Io.x+=m,Io.y+=g;const v=e.width+2*m,y=e.height+2*g,_=Math.ceil(v*b),w=Math.ceil(y*x),M=c.createTemporaryAttachment(_,w),P=c.createTemporaryAttachment(_,w),S=f.createSampler("blur_sampler",!0);Ko(o,l,c,u,e,M,S,b,x,m*b,g*x,s.bufferManager);const F=h*b,T=p*x,B=s.computePipelineManager&&((e,t,r,n)=>{const i=Math.max(e,t),a=Math.min(r,n);return i>=4&&a>=128})(h,p,_,w),O=[M,P];let A=0;for(let e=0;e<i;++e){if(r>0){const e=A;A=(A+1)%2,B?Wo(o,l,s.computePipelineManager,O[e],O[A],!0,F,s.bufferManager):Ho(o,l,c,u,O[e],O[A],S,!0,F,s.bufferManager)}if(n>0){const e=A;A=(A+1)%2,B?Wo(o,l,s.computePipelineManager,O[e],O[A],!1,T,s.bufferManager):Ho(o,l,c,u,O[e],O[A],S,!1,T,s.bufferManager)}}let R=O[A];if(1!==b||1!==x){const e=c.createTemporaryAttachment(v,y);Qo(o,l,c,u,R,e,S,1/b,1/x,s.bufferManager),c.releaseTemporaryAttachment(M),c.releaseTemporaryAttachment(P),R=e}else{const e=(A+1)%2;c.releaseTemporaryAttachment(O[e])}return R},Ko=(e,t,r,n,i,a,s,o,l,c,u,f)=>{const d=n.getPipeline("texture_copy_rgba8"),h=n.getBindGroupLayout("texture_copy");if(!d||!h)return void console.error("[WebGPU BlurFilter] texture_copy_rgba8 pipeline not found");const p=i.width*o,m=i.height*l;qo[0]=1,qo[1]=1,qo[2]=0,qo[3]=0;const g=f?f.acquireAndWriteUniformBuffer(qo):e.createBuffer({size:qo.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});f||e.queue.writeBuffer(g,0,qo),Xo[0].resource.buffer=g,Xo[1].resource=s,Xo[2].resource=i.texture.view;const b=e.createBindGroup({layout:h,entries:Xo}),x=r.createRenderPassDescriptor(a.texture.view,0,0,0,0,"clear"),v=t.beginRenderPass(x);v.setPipeline(d),v.setBindGroup(0,b),v.setViewport(c,u,p,m,0,1),v.setScissorRect(Math.floor(c),Math.floor(u),Math.ceil(p),Math.ceil(m)),v.draw(6,1,0,0),v.end()},Ho=(e,t,r,n,i,a,s,o,l,c)=>{const u=((e,t,r,n)=>{const i=Math.ceil(.5*t);return{offsetX:e?1/r:0,offsetY:e?0:1/n,fraction:1-(i-.5*t),samples:1+t,halfBlur:i}})(o,l,i.width,i.height),{offsetX:f,offsetY:d,fraction:h,samples:p,halfBlur:m}=u,g=Math.max(1,Math.min(16,m)),b=n.getPipeline(`blur_filter_${g}`),x=n.getBindGroupLayout("blur_filter");if(!b||!x)return void console.error(`[WebGPU BlurFilter] blur_filter_${g} pipeline not found`);qo[0]=f,qo[1]=d,qo[2]=h,qo[3]=p;const v=c?c.acquireAndWriteUniformBuffer(qo):e.createBuffer({size:qo.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});c||e.queue.writeBuffer(v,0,qo),Xo[0].resource.buffer=v,Xo[1].resource=s,Xo[2].resource=i.texture.view;const y=e.createBindGroup({layout:x,entries:Xo}),_=r.createRenderPassDescriptor(a.texture.view,0,0,0,0,"clear"),w=t.beginRenderPass(_);w.setPipeline(b),w.setBindGroup(0,y),w.draw(6,1,0,0),w.end()},Qo=(e,t,r,n,i,a,s,o,l,c)=>{const u=n.getPipeline("texture_copy_rgba8"),f=n.getBindGroupLayout("texture_copy");if(!u||!f)return void console.error("[WebGPU BlurFilter] texture_copy_rgba8 pipeline not found");qo[0]=1,qo[1]=1,qo[2]=0,qo[3]=0;const d=c?c.acquireAndWriteUniformBuffer(qo):e.createBuffer({size:qo.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});c||e.queue.writeBuffer(d,0,qo),Xo[0].resource.buffer=d,Xo[1].resource=s,Xo[2].resource=i.texture.view;const h=e.createBindGroup({layout:f,entries:Xo}),p=r.createRenderPassDescriptor(a.texture.view,0,0,0,0,"clear"),m=t.beginRenderPass(p);m.setPipeline(u),m.setBindGroup(0,h),m.draw(6,1,0,0),m.end()},Zo=new Float32Array(20),Jo=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],el=(e,t,r)=>{const{device:n,commandEncoder:i,frameBufferManager:a,pipelineManager:s,textureManager:o}=r,l=a.createTemporaryAttachment(e.width,e.height),c=s.getPipeline("color_matrix_filter"),u=s.getBindGroupLayout("color_matrix_filter");if(!c||!u)return console.error("[WebGPU ColorMatrixFilter] Pipeline not found"),e;const f=o.createSampler("color_matrix_sampler",!0);Zo[0]=t[0],Zo[1]=t[5],Zo[2]=t[10],Zo[3]=t[15],Zo[4]=t[1],Zo[5]=t[6],Zo[6]=t[11],Zo[7]=t[16],Zo[8]=t[2],Zo[9]=t[7],Zo[10]=t[12],Zo[11]=t[17],Zo[12]=t[3],Zo[13]=t[8],Zo[14]=t[13],Zo[15]=t[18],Zo[16]=t[4]/255,Zo[17]=t[9]/255,Zo[18]=t[14]/255,Zo[19]=t[19]/255;const d=r.bufferManager?r.bufferManager.acquireAndWriteUniformBuffer(Zo):n.createBuffer({size:Zo.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});r.bufferManager||n.queue.writeBuffer(d,0,Zo),Jo[0].resource.buffer=d,Jo[1].resource=f,Jo[2].resource=e.texture.view;const h=n.createBindGroup({layout:u,entries:Jo}),p=a.createRenderPassDescriptor(l.texture.view,0,0,0,0,"clear"),m=i.beginRenderPass(p);return m.setPipeline(c),m.setBindGroup(0,h),m.draw(6,1,0,0),m.end(),l},tl=new Float32Array(16),rl=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null},{binding:3,resource:null}],nl=(e,t,r,n,i,a,s,o,l,c,u,f)=>{const{device:d,commandEncoder:h,frameBufferManager:p,pipelineManager:m,textureManager:g}=f,b=Io.x,x=Io.y,v=e.width,y=e.height,_=Yo(e,t,i,a,o,u,f),w=_.width,M=_.height,P=l?v:w,S=l?y:M,F=Io.x-b,T=Io.y-x,B=P/v,O=S/y,A=(l?0:F)/v,R=(l?0:T)/y,C=P/w,E=S/M,U=(l?-F:0)/w,$=(l?-T:0)/M,G=p.createTemporaryAttachment(P,S),k=m.getFilterPipeline("glow_filter",{IS_INNER:l?1:0,IS_KNOCKOUT:c?1:0}),L=m.getBindGroupLayout("glow_filter");if(!k||!L)return console.error("[WebGPU GlowFilter] Pipeline not found"),p.releaseTemporaryAttachment(_),e;const I=g.createSampler("glow_sampler",!0),[V,z,j,D]=((e,t)=>[(e>>16&255)/255*t,(e>>8&255)/255*t,(255&e)/255*t,t])(r,n);tl[0]=V,tl[1]=z,tl[2]=j,tl[3]=D,tl[4]=B,tl[5]=O,tl[6]=A,tl[7]=R,tl[8]=C,tl[9]=E,tl[10]=U,tl[11]=$,tl[12]=s,tl[13]=l?1:0,tl[14]=c?1:0,tl[15]=0;const N=f.bufferManager?f.bufferManager.acquireAndWriteUniformBuffer(tl):d.createBuffer({size:tl.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});f.bufferManager||d.queue.writeBuffer(N,0,tl),rl[0].resource.buffer=N,rl[1].resource=I,rl[2].resource=_.texture.view,rl[3].resource=e.texture.view;const W=d.createBindGroup({layout:L,entries:rl}),q=p.createRenderPassDescriptor(G.texture.view,0,0,0,0,"clear"),X=h.beginRenderPass(q);return X.setPipeline(k),X.setBindGroup(0,W),X.draw(6,1,0,0),X.end(),p.releaseTemporaryAttachment(_),G},il=Math.PI/180,al=new Float32Array(16),sl=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null},{binding:3,resource:null}],ol=(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p)=>{const{device:m,commandEncoder:g,frameBufferManager:b,pipelineManager:x,textureManager:v}=p,y=Io.x,_=Io.y,w=e.width,M=e.height,P=Yo(e,t,s,o,c,h,p),S=P.width,F=P.height,T=Io.x,B=Io.y,O=T-y,A=B-_,R=Math.sqrt(t[0]*t[0]+t[1]*t[1]),C=Math.sqrt(t[2]*t[2]+t[3]*t[3]),E=n*il,U=Math.cos(E)*r*(R/h),$=Math.sin(E)*r*(C/h),G=u?w:S+Math.max(0,Math.abs(U)-O),k=u?M:F+Math.max(0,Math.abs($)-A),L=Math.ceil(G),I=Math.ceil(k),V=(L-G)/2,z=(I-k)/2,j=u?0:Math.max(0,O-U)+V,D=u?0:Math.max(0,A-$)+z,N=u?U-T:(U>0?Math.max(0,U-O):0)+V,W=u?$-B:($>0?Math.max(0,$-A):0)+z,q=b.createTemporaryAttachment(L,I),X=u;let Y=f,K=d;u?Y=f||d:!f&&d&&(Y=!0,K=!0);const H=x.getFilterPipeline("drop_shadow_filter",{IS_INNER:X?1:0,IS_KNOCKOUT:Y?1:0,IS_HIDE_OBJECT:K?1:0}),Q=x.getBindGroupLayout("drop_shadow_filter");if(!H||!Q)return console.error("[WebGPU DropShadowFilter] Pipeline not found"),b.releaseTemporaryAttachment(P),e;const Z=v.createSampler("drop_shadow_sampler",!0),[J,ee,te,re]=((e,t)=>[(e>>16&255)/255*t,(e>>8&255)/255*t,(255&e)/255*t,t])(i,a),ne=L/w,ie=I/M,ae=j/w,se=D/M,oe=L/S,le=I/F,ce=N/S,ue=W/F;al[0]=J,al[1]=ee,al[2]=te,al[3]=re,al[4]=ne,al[5]=ie,al[6]=ae,al[7]=se,al[8]=oe,al[9]=le,al[10]=ce,al[11]=ue,al[12]=l,al[13]=X?1:0,al[14]=Y?1:0,al[15]=K?1:0;const fe=p.bufferManager?p.bufferManager.acquireAndWriteUniformBuffer(al):m.createBuffer({size:al.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});p.bufferManager||m.queue.writeBuffer(fe,0,al),sl[0].resource.buffer=fe,sl[1].resource=Z,sl[2].resource=P.texture.view,sl[3].resource=e.texture.view;const de=m.createBindGroup({layout:Q,entries:sl}),he=b.createRenderPassDescriptor(q.texture.view,0,0,0,0,"clear"),pe=g.beginRenderPass(he);return pe.setPipeline(H),pe.setBindGroup(0,de),pe.draw(6,1,0,0),pe.end(),b.releaseTemporaryAttachment(P),q},ll=Math.PI/180,cl=new Float32Array(8),ul=new Float32Array(20),fl=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],dl=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null},{binding:3,resource:null}],hl=(e,t)=>[(e>>16&255)/255*t,(e>>8&255)/255*t,(255&e)/255*t,t],pl=(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m)=>{const{device:g,commandEncoder:b,frameBufferManager:x,pipelineManager:v,textureManager:y}=m,_=Io.x,w=Io.y,M=e.width,P=e.height,S=Math.sqrt(t[0]*t[0]+t[1]*t[1]),F=Math.sqrt(t[2]*t[2]+t[3]*t[3]),T=n*ll,B=Math.cos(T)*r*(S/p),O=Math.sin(T)*r*(F/p),A=x.createTemporaryAttachment(M,P);b.copyTextureToTexture({texture:e.texture.resource,origin:{x:0,y:0,z:0}},{texture:A.texture.resource,origin:{x:0,y:0,z:0}},{width:M,height:P});const R=v.getPipeline("texture_erase"),C=v.getBindGroupLayout("texture_copy");if(R&&C){const t=y.createSampler("erase_sampler",!0),r=2*B/M,n=2*O/P;cl[0]=1,cl[1]=1,cl[2]=r,cl[3]=n,cl[4]=0,cl[5]=0,cl[6]=0,cl[7]=0;const i=m.bufferManager?m.bufferManager.acquireAndWriteUniformBuffer(cl):g.createBuffer({size:cl.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});m.bufferManager||g.queue.writeBuffer(i,0,cl),fl[0].resource.buffer=i,fl[1].resource=t,fl[2].resource=e.texture.view;const a=g.createBindGroup({layout:C,entries:fl}),s=x.createRenderPassDescriptor(A.texture.view,0,0,0,0,"load"),o=b.beginRenderPass(s);o.setPipeline(R),o.setBindGroup(0,a),o.draw(6,1,0,0),o.end()}const E=Yo(A,t,l,c,f,p,m);x.releaseTemporaryAttachment(A);const U=E.width,$=E.height,G=Math.abs(B),k=Math.abs(O),L=1===d,I=Math.ceil(U+2*G),V=Math.ceil($+2*k),z=L?M:I,j=L?P:V,D=(U-M)/2,N=($-P)/2,W=L?0:Math.floor(G+D),q=L?0:Math.floor(k+N),X=z/M,Y=j/P,K=W/M,H=q/P,Q=z/U,Z=j/$,J=(L?Math.floor(-D-B):Math.floor(G-B))/U,ee=(L?Math.floor(-N-O):Math.floor(k-O))/$,te=x.createTemporaryAttachment(z,j),re=v.getFilterPipeline("bevel_filter",{BEVEL_TYPE:d,IS_KNOCKOUT:h?1:0}),ne=v.getBindGroupLayout("bevel_filter");if(!re||!ne)return console.error("[WebGPU BevelFilter] Pipeline not found"),x.releaseTemporaryAttachment(E),e;const ie=y.createSampler("bevel_sampler",!0),[ae,se,oe,le]=hl(i,a),[ce,ue,fe,de]=hl(s,o);ul[0]=ae,ul[1]=se,ul[2]=oe,ul[3]=le,ul[4]=ce,ul[5]=ue,ul[6]=fe,ul[7]=de,ul[8]=u,ul[9]=L?1:0,ul[10]=h?1:0,ul[11]=d,ul[12]=X,ul[13]=Y,ul[14]=K,ul[15]=H,ul[16]=Q,ul[17]=Z,ul[18]=J,ul[19]=ee;const he=m.bufferManager?m.bufferManager.acquireAndWriteUniformBuffer(ul):g.createBuffer({size:ul.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});m.bufferManager||g.queue.writeBuffer(he,0,ul),dl[0].resource.buffer=he,dl[1].resource=ie,dl[2].resource=E.texture.view,dl[3].resource=e.texture.view;const pe=g.createBindGroup({layout:ne,entries:dl}),me=x.createRenderPassDescriptor(te.texture.view,0,0,0,0,"clear"),ge=b.beginRenderPass(me);return ge.setPipeline(re),ge.setBindGroup(0,pe),ge.draw(6,1,0,0),ge.end(),x.releaseTemporaryAttachment(E),Io.x=_+W,Io.y=w+q,te},ml=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],gl=new Map,bl=(e,t,r,n,i,a,s,o,l,c,u)=>{const{device:f,commandEncoder:d,frameBufferManager:h,textureManager:p}=u,m=e.width,g=e.height,b=h.createTemporaryAttachment(m,g),x=`${t},${r},${s},${o}`;let v=gl.get(x);if(!v){const e=fa.getConvolutionFilterFragmentShader(t,r,s,o),n=f.createShaderModule({code:e}),i=f.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}}]}),a=f.createPipelineLayout({bindGroupLayouts:[i]});v={pipeline:f.createRenderPipeline({layout:a,vertex:{module:n,entryPoint:"vs_main",buffers:[]},fragment:{module:n,entryPoint:"fs_main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}}),bindGroupLayout:i},gl.set(x,v)}const y=p.createSampler("convolution_sampler",!0),_=t*r,w=Math.ceil(_/4),[M,P,S,F]=((e,t)=>[(e>>16&255)/255,(e>>8&255)/255,(255&e)/255,t])(l,c),T=new Float32Array(4*w);for(let e=0;e<_;e++)T[e]=n[e];const B=new Float32Array((32+16*w)/4);B[0]=1/m,B[1]=1/g,B[2]=0!==i?1/i:1,B[3]=a/255,B[4]=M,B[5]=P,B[6]=S,B[7]=F;for(let e=0;e<T.length;e++)B[8+e]=T[e];const O=u.bufferManager?u.bufferManager.acquireAndWriteUniformBuffer(B):f.createBuffer({size:B.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});u.bufferManager||f.queue.writeBuffer(O,0,B),ml[0].resource.buffer=O,ml[1].resource=y,ml[2].resource=e.texture.view;const A=f.createBindGroup({layout:v.bindGroupLayout,entries:ml}),R=h.createRenderPassDescriptor(b.texture.view,0,0,0,0,"clear"),C=d.beginRenderPass(R);return C.setPipeline(v.pipeline),C.setBindGroup(0,A),C.draw(6,1,0,0),C.end(),b},xl=Math.PI/180,vl=new Float32Array(4),yl=new Float32Array(12),_l=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],wl=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null},{binding:3,resource:null},{binding:4,resource:null}],Ml=(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p)=>{const{device:m,commandEncoder:g,frameBufferManager:b,pipelineManager:x,textureManager:v}=p,y=Io.x,_=Io.y,w=e.width,M=e.height,P=Math.sqrt(t[0]*t[0]+t[1]*t[1]),S=Math.sqrt(t[2]*t[2]+t[3]*t[3]),F=n*xl,T=Math.cos(F)*r*(P/h),B=Math.sin(F)*r*(S/h),O=x.getPipeline("bevel_base"),A=x.getBindGroupLayout("bevel_base");if(!O||!A)return console.error("[WebGPU GradientBevelFilter] bevel_base pipeline not found"),e;const R=b.createTemporaryAttachment(w,M),C=v.createSampler("bevel_base_sampler",!0);vl[0]=2*T/w,vl[1]=2*B/M,vl[2]=0,vl[3]=0;const E=p.bufferManager?p.bufferManager.acquireAndWriteUniformBuffer(vl):m.createBuffer({size:vl.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});p.bufferManager||m.queue.writeBuffer(E,0,vl),_l[0].resource.buffer=E,_l[1].resource=C,_l[2].resource=e.texture.view;const U=m.createBindGroup({layout:A,entries:_l}),$=b.createRenderPassDescriptor(R.texture.view,0,0,0,0,"clear"),G=g.beginRenderPass($);G.setPipeline(O),G.setBindGroup(0,U),G.draw(6,1,0,0),G.end();const k=Yo(R,t,o,l,u,h,p);b.releaseTemporaryAttachment(R);const L=k.width,I=k.height,V=1===f,z=Math.abs(T),j=Math.abs(B),D=(L-w)/2,N=(I-M)/2,W=Math.ceil(L+2*z),q=Math.ceil(I+2*j),X=V?w:W,Y=V?M:q,K=V?0:z+D,H=V?0:j+N,Q=V?-D-T:z-T,Z=V?-N-B:j-B,J=qs(s,i,a),ee=m.createTexture({size:{width:256,height:1},format:"rgba8unorm",usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST});m.queue.writeTexture({texture:ee},J.buffer,{bytesPerRow:1024,offset:J.byteOffset},{width:256,height:1});const te=ee.createView(),re=X/w,ne=Y/M,ie=K/w,ae=H/M,se=X/L,oe=Y/I,le=Q/L,ce=Z/I,ue=b.createTemporaryAttachment(X,Y),fe=x.getFilterPipeline("gradient_bevel_filter",{BEVEL_TYPE:f,IS_KNOCKOUT:d?1:0}),de=x.getBindGroupLayout("gradient_bevel_filter");if(!fe||!de)return console.error("[WebGPU GradientBevelFilter] Pipeline not found"),b.releaseTemporaryAttachment(k),e;const he=v.createSampler("gradient_bevel_sampler",!0);yl[0]=c,yl[1]=V?1:0,yl[2]=d?1:0,yl[3]=f,yl[4]=re,yl[5]=ne,yl[6]=ie,yl[7]=ae,yl[8]=se,yl[9]=oe,yl[10]=le,yl[11]=ce;const pe=p.bufferManager?p.bufferManager.acquireAndWriteUniformBuffer(yl):m.createBuffer({size:yl.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});p.bufferManager||m.queue.writeBuffer(pe,0,yl),wl[0].resource.buffer=pe,wl[1].resource=he,wl[2].resource=k.texture.view,wl[3].resource=e.texture.view,wl[4].resource=te;const me=m.createBindGroup({layout:de,entries:wl}),ge=b.createRenderPassDescriptor(ue.texture.view,0,0,0,0,"clear"),be=g.beginRenderPass(ge);return be.setPipeline(fe),be.setBindGroup(0,me),be.draw(6,1,0,0),be.end(),p.frameTextures.push(ee),b.releaseTemporaryAttachment(k),Io.x=y+K,Io.y=_+H,ue},Pl=Math.PI/180,Sl=new Float32Array(12),Fl=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null},{binding:3,resource:null},{binding:4,resource:null}],Tl=(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p)=>{const{device:m,commandEncoder:g,frameBufferManager:b,pipelineManager:x,textureManager:v}=p,y=Io.x,_=Io.y,w=e.width,M=e.height,P=Yo(e,t,o,l,u,h,p),S=P.width,F=P.height,T=Io.x,B=Io.y,O=T-y,A=B-_,R=Math.sqrt(t[0]*t[0]+t[1]*t[1]),C=Math.sqrt(t[2]*t[2]+t[3]*t[3]),E=n*Pl,U=Math.cos(E)*r*(R/h),$=Math.sin(E)*r*(C/h),G=1===f,k=G?w:S+Math.max(0,Math.abs(U)-O),L=G?M:F+Math.max(0,Math.abs($)-A),I=Math.ceil(k),V=Math.ceil(L),z=(I-k)/2,j=(V-L)/2,D=G?0:Math.max(0,O-U)+z,N=G?0:Math.max(0,A-$)+j,W=G?U-T:(U>0?Math.max(0,U-O):0)+z,q=G?$-B:($>0?Math.max(0,$-A):0)+j,X=qs(s,i,a),Y=m.createTexture({size:{width:256,height:1},format:"rgba8unorm",usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST});m.queue.writeTexture({texture:Y},X.buffer,{bytesPerRow:1024,offset:X.byteOffset},{width:256,height:1});const K=Y.createView(),H=I/w,Q=V/M,Z=D/w,J=N/M,ee=I/S,te=V/F,re=W/S,ne=q/F,ie=b.createTemporaryAttachment(I,V),ae=x.getFilterPipeline("gradient_glow_filter",{GLOW_TYPE:f,IS_KNOCKOUT:d?1:0}),se=x.getBindGroupLayout("gradient_glow_filter");if(!ae||!se)return console.error("[WebGPU GradientGlowFilter] Pipeline not found"),b.releaseTemporaryAttachment(P),e;const oe=v.createSampler("gradient_glow_sampler",!0);Sl[0]=c,Sl[1]=G?1:0,Sl[2]=d?1:0,Sl[3]=f,Sl[4]=H,Sl[5]=Q,Sl[6]=Z,Sl[7]=J,Sl[8]=ee,Sl[9]=te,Sl[10]=re,Sl[11]=ne;const le=p.bufferManager?p.bufferManager.acquireAndWriteUniformBuffer(Sl):m.createBuffer({size:Sl.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});p.bufferManager||m.queue.writeBuffer(le,0,Sl),Fl[0].resource.buffer=le,Fl[1].resource=oe,Fl[2].resource=P.texture.view,Fl[3].resource=e.texture.view,Fl[4].resource=K;const ce=m.createBindGroup({layout:se,entries:Fl}),ue=b.createRenderPassDescriptor(ie.texture.view,0,0,0,0,"clear"),fe=g.beginRenderPass(ue);return fe.setPipeline(ae),fe.setBindGroup(0,ce),fe.draw(6,1,0,0),fe.end(),p.frameTextures.push(Y),b.releaseTemporaryAttachment(P),Io.x=y+D,Io.y=_+N,ie},Bl=new Float32Array(12),Ol=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null},{binding:3,resource:null}],Al=new Map,Rl=(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m)=>{const{device:g,commandEncoder:b,frameBufferManager:x,textureManager:v}=m,y=e.width,_=e.height,w=n,M=i,P=x.createTemporaryAttachment(y,_),S=g.createTexture({size:{width:n,height:i},format:"rgba8unorm",usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST});g.queue.writeTexture({texture:S},r.buffer,{bytesPerRow:4*n,offset:r.byteOffset},{width:n,height:i});const F=`${o},${l},${f}`;let T=Al.get(F);if(!T){const e=fa.getDisplacementMapFilterFragmentShader(o,l,f),t=g.createShaderModule({code:fa.getBlurFilterVertexShader()}),r=g.createShaderModule({code:e}),n=g.createBindGroupLayout({entries:[{binding:0,visibility:GPUShaderStage.FRAGMENT,buffer:{type:"uniform"}},{binding:1,visibility:GPUShaderStage.FRAGMENT,sampler:{}},{binding:2,visibility:GPUShaderStage.FRAGMENT,texture:{}},{binding:3,visibility:GPUShaderStage.FRAGMENT,texture:{}}]}),i=g.createPipelineLayout({bindGroupLayouts:[n]});T={pipeline:g.createRenderPipeline({layout:i,vertex:{module:t,entryPoint:"main",buffers:[]},fragment:{module:r,entryPoint:"main",targets:[{format:"rgba8unorm",blend:{color:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"},alpha:{srcFactor:"one",dstFactor:"one-minus-src-alpha",operation:"add"}}}]},primitive:{topology:"triangle-list",cullMode:"none"}}),bindGroupLayout:n},Al.set(F,T)}const B=v.createSampler("displacement_sampler",!0),O=1===f,A=O?48:32;if(Bl[0]=w/n,Bl[1]=M/i,Bl[2]=a/n,Bl[3]=(M-i-s)/i,Bl[4]=c/w,Bl[5]=u/M,Bl[6]=0,Bl[7]=0,O){const[e,t,r,n]=((e,t)=>[(e>>16&255)/255*t,(e>>8&255)/255*t,(255&e)/255*t,t])(d,h);Bl[8]=e,Bl[9]=t,Bl[10]=r,Bl[11]=n}const R=m.bufferManager?m.bufferManager.acquireAndWriteUniformBuffer(Bl,A):g.createBuffer({size:A,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});m.bufferManager||g.queue.writeBuffer(R,0,Bl,0,A/4),Ol[0].resource.buffer=R,Ol[1].resource=B,Ol[2].resource=e.texture.view,Ol[3].resource=S.createView();const C=g.createBindGroup({layout:T.bindGroupLayout,entries:Ol}),E=x.createRenderPassDescriptor(P.texture.view,0,0,0,0,"clear"),U=b.beginRenderPass(E);return U.setPipeline(T.pipeline),U.setBindGroup(0,C),U.draw(6,1,0,0),U.end(),m.frameTextures.push(S),P},Cl=new Float32Array(4),El=new Float32Array(6),Ul=new Float32Array(6),$l=new Float32Array(8),Gl=new Float32Array(12),kl=new Float32Array(20),Ll=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],Il=new Set(["normal","layer","add","screen","alpha","erase","copy"]),Vl=new Float32Array([1,-1,0,1]),zl=(e,t,r,n,i,a,s,o)=>{const l=e.mainAttachment||e.frameBufferManager.getAttachment("main");if(!l||!l.texture||!t.texture)return;let c=i,u=a,f=t.width,d=t.height,h=0,p=0;if(c<0&&(h=-c/t.width,f+=c,c=0),u<0&&(p=-u/t.height,d+=u,u=0),f<=0||d<=0)return;const m=l.width,g=l.height;if(c+f>m&&(f=m-c),u+d>g&&(d=g-u),b=n,Il.has(b)){const r=l.msaa&&l.msaaTexture?.view;let i;switch(n){case"add":i=r?"filter_output_add_msaa":"filter_output_add";break;case"screen":i=r?"filter_output_screen_msaa":"filter_output_screen";break;case"alpha":i=r?"filter_output_alpha_msaa":"filter_output_alpha";break;case"erase":i=r?"filter_output_erase_msaa":"filter_output_erase";break;case"copy":i=r?"texture_copy_bgra_msaa":"texture_copy_bgra";break;default:i=r?"filter_output_msaa":"filter_output"}let a=e.pipelineManager.getPipeline(i),s=e.pipelineManager.getBindGroupLayout("texture_copy");if(!(a&&s||(i=r?"filter_output_msaa":"filter_output",a=e.pipelineManager.getPipeline(i),s=e.pipelineManager.getBindGroupLayout("texture_copy"),a&&s)))return;const o=e.textureManager.createSampler("filter_output_sampler",!0),b=f/t.width,x=d/t.height;Cl[0]=b,Cl[1]=x,Cl[2]=h,Cl[3]=p;const v=e.bufferManager.acquireAndWriteUniformBuffer(Cl);Ll[0].resource.buffer=v,Ll[1].resource=o,Ll[2].resource=t.texture.view;const y=e.device.createBindGroup({layout:s,entries:Ll}),_=r?l.msaaTexture.view:l.texture.view,w=r?l.texture.view:null,M=e.frameBufferManager.createRenderPassDescriptor(_,0,0,0,0,"load",w),P=Math.max(0,c),S=Math.max(0,u),F=Math.max(1,f),T=Math.max(1,d),B=Math.max(0,Math.floor(P)),O=Math.max(0,Math.floor(S)),A=Math.max(1,Math.min(Math.ceil(P+F)-B,m-B)),R=Math.max(1,Math.min(Math.ceil(S+T)-O,g-O));if(A<=0||R<=0||B>=m||O>=g)return;const C=e.commandEncoder.beginRenderPass(M);C.setPipeline(a),C.setBindGroup(0,y),C.setViewport(P,S,F,T,0,1),C.setScissorRect(B,O,A,R),C.draw(6,1,0,0),C.end()}else{const i=((e,t,r,n,i,a)=>{const s=e.frameBufferManager.createTemporaryAttachment(i,a),o=e.pipelineManager.getPipeline("complex_blend_copy"),l=e.pipelineManager.getBindGroupLayout("texture_copy");if(!(o&&l&&t.texture&&s.texture))return s;const c=i/t.width,u=a/t.height,f=r/t.width,d=n/t.height;Cl[0]=c,Cl[1]=u,Cl[2]=f,Cl[3]=d;const h=e.bufferManager.acquireAndWriteUniformBuffer(Cl),p=e.textureManager.createSampler("filter_copy_sampler",!1);Ll[0].resource.buffer=h,Ll[1].resource=p,Ll[2].resource=t.texture.view;const m=e.device.createBindGroup({layout:l,entries:Ll}),g=e.frameBufferManager.createRenderPassDescriptor(s.texture.view,0,0,0,0,"clear"),b=e.commandEncoder.beginRenderPass(g);return b.setPipeline(o),b.setBindGroup(0,m),b.draw(6,1,0,0),b.end(),s})(e,l,c,u,f,d);$l[0]=r[0],$l[1]=r[1],$l[2]=r[2],$l[3]=r[3],$l[4]=r[4],$l[5]=r[5],$l[6]=r[6],$l[7]=0;const a=Ao(t,i,n,$l,{device:e.device,commandEncoder:e.commandEncoder,bufferManager:e.bufferManager,frameBufferManager:e.frameBufferManager,pipelineManager:e.pipelineManager,textureManager:e.textureManager,frameTextures:e.frameTextures});((e,t,r,n,i)=>{const a=r.msaa&&r.msaaTexture?.view,s=a?"filter_complex_blend_output_msaa":"filter_complex_blend_output",o=e.pipelineManager.getPipeline(s),l=e.pipelineManager.getBindGroupLayout("positioned_texture");if(!(o&&l&&t.texture&&r.texture))return;$l[0]=n,$l[1]=i,$l[2]=t.width,$l[3]=t.height,$l[4]=r.width,$l[5]=r.height,$l[6]=0,$l[7]=0;const c=e.bufferManager.acquireAndWriteUniformBuffer($l),u=e.textureManager.createSampler("filter_blend_output_sampler",!1);Ll[0].resource.buffer=c,Ll[1].resource=u,Ll[2].resource=t.texture.view;const f=e.device.createBindGroup({layout:l,entries:Ll}),d=a?r.msaaTexture.view:r.texture.view,h=a?r.texture.view:null,p=e.frameBufferManager.createRenderPassDescriptor(d,0,0,0,0,"load",h),m=e.commandEncoder.beginRenderPass(p);m.setPipeline(o),m.setBindGroup(0,f),m.draw(6,1,0,0),m.end()})(e,a,l,c,u),e.frameBufferManager.releaseTemporaryAttachment(i),e.frameBufferManager.releaseTemporaryAttachment(a)}var b},jl=(e,t,r,n,i,a,s,o,l,c,u,f)=>{Io.x=0,Io.y=0;let d=((e,t,r)=>{const n=r.createTemporaryAttachment(e.w,e.h),i=wa()||r.getAttachment("atlas");return i&&i.texture&&n.texture?t.copyTextureToTexture({texture:i.texture.resource,origin:{x:e.x,y:e.y,z:0}},{texture:n.texture.resource,origin:{x:0,y:0,z:0}},{width:e.w,height:e.h}):console.error("[WebGPU Filter] getTextureFromNode: FAILED - missing atlas or textures"),n})(e,c.commandEncoder,c.frameBufferManager);if(d.texture){const t=c.frameBufferManager.createTemporaryAttachment(e.w,e.h),r=c.pipelineManager.getPipeline("texture_copy_rgba8"),n=c.pipelineManager.getBindGroupLayout("texture_copy");if(r&&n&&t.texture){const e=c.textureManager.createSampler("filter_flip_sampler",!1),i=c.bufferManager.acquireAndWriteUniformBuffer(Vl);Ll[0].resource.buffer=i,Ll[1].resource=e,Ll[2].resource=d.texture.view;const a=c.device.createBindGroup({layout:n,entries:Ll}),s=c.frameBufferManager.createRenderPassDescriptor(t.texture.view,0,0,0,0,"clear"),o=c.commandEncoder.beginRenderPass(s);o.setPipeline(r),o.setBindGroup(0,a),o.draw(6,1,0,0),o.end(),c.frameBufferManager.releaseTemporaryAttachment(d),d=t}}const h=Hn.getDevicePixelRatio(),p=Math.sqrt(i[0]*i[0]+i[1]*i[1]),m=Math.sqrt(i[2]*i[2]+i[3]*i[3]),g=Math.atan2(i[1],i[0]),b=Math.atan2(-i[2],i[3]),x=n?p*Math.cos(g):Math.cos(g),v=n?p*Math.sin(g):Math.sin(g),y=n?-m*Math.sin(b):-Math.sin(b),_=n?m*Math.cos(b):Math.cos(b);El[0]=x,El[1]=v,El[2]=y,El[3]=_,El[4]=t/2,El[5]=r/2,Ul[0]=1,Ul[1]=0,Ul[2]=0,Ul[3]=1,Ul[4]=-e.w/2,Ul[5]=-e.h/2;const w=El[0]*Ul[0]+El[2]*Ul[1],M=El[1]*Ul[0]+El[3]*Ul[1],P=El[0]*Ul[2]+El[2]*Ul[3],S=El[1]*Ul[2]+El[3]*Ul[3],F=El[0]*Ul[4]+El[2]*Ul[5]+El[4],T=El[1]*Ul[4]+El[3]*Ul[5]+El[5];let B=0,O=0;if(1!==w||0!==M||0!==P||1!==S){const n=c.frameBufferManager.createTemporaryAttachment(t,r),i="texture_scale",a=c.pipelineManager.getPipeline(i),s=c.pipelineManager.getBindGroupLayout("texture_scale");if(a&&s){Gl[0]=w,Gl[1]=M,Gl[2]=P,Gl[3]=S,Gl[4]=F,Gl[5]=T,Gl[6]=e.w,Gl[7]=e.h,Gl[8]=t,Gl[9]=r,Gl[10]=0,Gl[11]=0;const i=c.bufferManager.acquireAndWriteUniformBuffer(Gl,48),o=c.textureManager.createSampler("filter_scale_sampler",!0);Ll[0].resource.buffer=i,Ll[1].resource=o,Ll[2].resource=d.texture.view;const l=c.device.createBindGroup({layout:s,entries:Ll}),u=c.frameBufferManager.createRenderPassDescriptor(n.texture.view,0,0,0,0,"clear"),f=c.commandEncoder.beginRenderPass(u);f.setPipeline(a),f.setBindGroup(0,l),f.draw(6,1,0,0),f.end(),B=F,O=T,c.frameBufferManager.releaseTemporaryAttachment(d),d=n}}for(let e=0;l.length>e;){switch(l[e++]){case 0:{const t=l[e++],r=l[e++],n=l[e++],a=l[e++],s=l[e++],o=l[e++],u=l[e++],f=l[e++],p=l[e++],m=l[e++],g=l[e++],b=Boolean(l[e++]),x=pl(d,i,t,r,n,a,s,o,u,f,p,m,g,b,h,c);d!==x&&c.frameBufferManager.releaseTemporaryAttachment(d),d=x}break;case 1:{const t=l[e++],r=l[e++],n=l[e++],a=Yo(d,i,t,r,n,h,c);d!==a&&c.frameBufferManager.releaseTemporaryAttachment(d),d=a}break;case 2:{kl[0]=l[e++],kl[1]=l[e++],kl[2]=l[e++],kl[3]=l[e++],kl[4]=l[e++],kl[5]=l[e++],kl[6]=l[e++],kl[7]=l[e++],kl[8]=l[e++],kl[9]=l[e++],kl[10]=l[e++],kl[11]=l[e++],kl[12]=l[e++],kl[13]=l[e++],kl[14]=l[e++],kl[15]=l[e++],kl[16]=l[e++],kl[17]=l[e++],kl[18]=l[e++],kl[19]=l[e++];const t=el(d,kl,c);d!==t&&c.frameBufferManager.releaseTemporaryAttachment(d),d=t}break;case 3:{const t=l[e++],r=l[e++],n=t*r,i=new Float32Array(n);for(let t=0;t<n;t++)i[t]=l[e++];const a=l[e++],s=l[e++],o=Boolean(l[e++]),u=Boolean(l[e++]),f=l[e++],h=l[e++],p=bl(d,t,r,i,a,s,o,u,f,h,c);d!==p&&c.frameBufferManager.releaseTemporaryAttachment(d),d=p}break;case 4:{const t=l[e++],r=new Uint8Array(t);for(let n=0;n<t;n++)r[n]=l[e++];const n=l[e++],i=l[e++],a=l[e++],s=l[e++],o=l[e++],u=l[e++],f=l[e++],h=l[e++],p=l[e++],m=l[e++],g=l[e++],b=Rl(d,0,r,n,i,a,s,o,u,f,h,p,m,g,0,c);d!==b&&c.frameBufferManager.releaseTemporaryAttachment(d),d=b}break;case 5:{const t=l[e++],r=l[e++],n=l[e++],a=l[e++],s=l[e++],o=l[e++],u=l[e++],f=l[e++],p=Boolean(l[e++]),m=Boolean(l[e++]),g=Boolean(l[e++]),b=ol(d,i,t,r,n,a,s,o,u,f,p,m,g,h,c);d!==b&&c.frameBufferManager.releaseTemporaryAttachment(d),d=b}break;case 6:{const t=l[e++],r=l[e++],n=l[e++],a=l[e++],s=l[e++],o=l[e++],u=Boolean(l[e++]),f=Boolean(l[e++]),p=nl(d,i,t,r,n,a,s,o,u,f,h,c);d!==p&&c.frameBufferManager.releaseTemporaryAttachment(d),d=p}break;case 7:{const t=l[e++],r=l[e++],n=l[e++],a=new Float32Array(n);for(let t=0;t<n;t++)a[t]=l[e++];const s=l[e++],o=new Float32Array(s);for(let t=0;t<s;t++)o[t]=l[e++];const u=l[e++],f=new Float32Array(u);for(let t=0;t<u;t++)f[t]=l[e++];const p=l[e++],m=l[e++],g=l[e++],b=l[e++],x=l[e++],v=Boolean(l[e++]),y=Ml(d,i,t,r,a,o,f,p,m,g,b,x,v,h,c);d!==y&&c.frameBufferManager.releaseTemporaryAttachment(d),d=y}break;case 8:{const t=l[e++],r=l[e++],n=l[e++],a=new Float32Array(n);for(let t=0;t<n;t++)a[t]=l[e++];const s=l[e++],o=new Float32Array(s);for(let t=0;t<s;t++)o[t]=l[e++];const u=l[e++],f=new Float32Array(u);for(let t=0;t<u;t++)f[t]=l[e++];const p=l[e++],m=l[e++],g=l[e++],b=l[e++],x=l[e++],v=Boolean(l[e++]),y=Tl(d,i,t,r,a,o,f,p,m,g,b,x,v,h,c);d!==y&&c.frameBufferManager.releaseTemporaryAttachment(d),d=y}}}if(1!==(A=a)[0]||1!==A[1]||1!==A[2]||1!==A[3]||0!==A[4]||0!==A[5]||0!==A[6]||0!==A[7]){const e=((e,t,r)=>{const n=e.frameBufferManager.createTemporaryAttachment(t.width,t.height),i=e.pipelineManager.getPipeline("color_transform"),a=e.pipelineManager.getBindGroupLayout("texture_copy");if(!(i&&a&&t.texture&&n.texture))return t;$l[0]=r[0],$l[1]=r[1],$l[2]=r[2],$l[3]=r[3],$l[4]=r[4],$l[5]=r[5],$l[6]=r[6],$l[7]=0;const s=e.bufferManager.acquireAndWriteUniformBuffer($l),o=e.textureManager.createSampler("color_transform_sampler",!1);Ll[0].resource.buffer=s,Ll[1].resource=o,Ll[2].resource=t.texture.view;const l=e.device.createBindGroup({layout:a,entries:Ll}),c=e.frameBufferManager.createRenderPassDescriptor(n.texture.view,0,0,0,0,"clear"),u=e.commandEncoder.beginRenderPass(c);return u.setPipeline(i),u.setBindGroup(0,l),u.draw(6,1,0,0),u.end(),n})(c,d,a);c.frameBufferManager.releaseTemporaryAttachment(d),d=e}var A;const R=o[0]*(p/h),C=o[1]*(m/h),E=-B+R+i[4],U=-O+C+i[5];zl(c,d,a,s,E,U),c.frameBufferManager.releaseTemporaryAttachment(d)},Dl=new Float32Array(4),Nl=new Float32Array(8),Wl=new Float32Array(20),ql=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],Xl=new Set(["normal","layer","add","screen","alpha","erase","copy"]),Yl=new Float32Array([1,1,1,1,0,0,0,0]),Kl=e=>!e||1===e[0]&&1===e[1]&&1===e[2]&&1===e[3]&&0===e[4]&&0===e[5]&&0===e[6]&&0===e[7],Hl=(e,t,r)=>{const n=e.frameBufferManager.createTemporaryAttachment(t.width,t.height),i=e.pipelineManager.getPipeline("color_transform"),a=e.pipelineManager.getBindGroupLayout("texture_copy");if(!(i&&a&&t.texture&&n.texture))return t;Nl[0]=r[0],Nl[1]=r[1],Nl[2]=r[2],Nl[3]=r[3],Nl[4]=r[4],Nl[5]=r[5],Nl[6]=r[6],Nl[7]=0;const s=e.bufferManager.acquireAndWriteUniformBuffer(Nl),o=e.textureManager.createSampler("container_ct_sampler",!1);ql[0].resource.buffer=s,ql[1].resource=o,ql[2].resource=t.texture.view;const l=e.device.createBindGroup({layout:a,entries:ql}),c=e.frameBufferManager.createRenderPassDescriptor(n.texture.view,0,0,0,0,"clear"),u=e.commandEncoder.beginRenderPass(c);return u.setPipeline(i),u.setBindGroup(0,l),u.draw(6,1,0,0),u.end(),n},Ql=(e,t,r,n,i,a)=>{const s=e.frameBufferManager.createTemporaryAttachment(i,a),o=e.pipelineManager.getPipeline("complex_blend_copy"),l=e.pipelineManager.getBindGroupLayout("texture_copy");if(!(o&&l&&t.texture&&s.texture))return s;const c=i/t.width,u=r/t.width,f=-a/t.height,d=(n+a)/t.height;Dl[0]=c,Dl[1]=f,Dl[2]=u,Dl[3]=d;const h=e.bufferManager.acquireAndWriteUniformBuffer(Dl),p=e.textureManager.createSampler("container_copy_sampler",!1);ql[0].resource.buffer=h,ql[1].resource=p,ql[2].resource=t.texture.view;const m=e.device.createBindGroup({layout:l,entries:ql}),g=e.frameBufferManager.createRenderPassDescriptor(s.texture.view,0,0,0,0,"clear"),b=e.commandEncoder.beginRenderPass(g);return b.setPipeline(o),b.setBindGroup(0,m),b.draw(6,1,0,0),b.end(),s},Zl=(e,t,r,n,i,a,s)=>{if(!r.texture||!t.texture)return;let o=i,l=a,c=t.width,u=t.height,f=0,d=0;if(o<0&&(f=-o/t.width,c+=o,o=0),l<0&&(d=-l/t.height,u+=l,l=0),c<=0||u<=0)return;const h=r.width,p=r.height;if(o+c>h&&(c=h-o),l+u>p&&(u=p-l),Xl.has(n)){const i=r.msaa&&r.msaaTexture?.view;let a;switch(n){case"add":a=i?"filter_output_add_msaa":"filter_output_add";break;case"screen":a=i?"filter_output_screen_msaa":"filter_output_screen";break;case"alpha":a=i?"filter_output_alpha_msaa":"filter_output_alpha";break;case"erase":a=i?"filter_output_erase_msaa":"filter_output_erase";break;case"copy":a=i?"texture_copy_bgra_msaa":"texture_copy_bgra";break;default:a=i?"filter_output_msaa":"filter_output"}const m=e.pipelineManager.getPipeline(a),g=e.pipelineManager.getBindGroupLayout("texture_copy");if(!m||!g)return;const b=e.textureManager.createSampler("container_output_sampler",!0),x=c/t.width,v=u/t.height;Dl[0]=x,Dl[1]=v,Dl[2]=f,Dl[3]=d;const y=s.acquireAndWriteUniformBuffer(Dl);ql[0].resource.buffer=y,ql[1].resource=b,ql[2].resource=t.texture.view;const _=e.device.createBindGroup({layout:g,entries:ql}),w=i?r.msaaTexture.view:r.texture.view,M=i?r.texture.view:null,P=e.frameBufferManager.createRenderPassDescriptor(w,0,0,0,0,"load",M),S=Math.max(0,o),F=Math.max(0,l),T=Math.max(1,c),B=Math.max(1,u),O=Math.max(0,Math.floor(S)),A=Math.max(0,Math.floor(F)),R=Math.max(1,Math.min(Math.ceil(S+T)-O,h-O)),C=Math.max(1,Math.min(Math.ceil(F+B)-A,p-A));if(R<=0||C<=0||O>=h||A>=p)return;const E=e.commandEncoder.beginRenderPass(P);E.setPipeline(m),E.setBindGroup(0,_),E.setViewport(S,F,T,B,0,1),E.setScissorRect(O,A,R,C),E.draw(6,1,0,0),E.end()}else{const i=Ql(e,r,o,l,c,u);Nl[0]=Yl[0],Nl[1]=Yl[1],Nl[2]=Yl[2],Nl[3]=Yl[3],Nl[4]=Yl[4]/255,Nl[5]=Yl[5]/255,Nl[6]=Yl[6]/255,Nl[7]=0;const a=Ao(t,i,n,Nl,{device:e.device,commandEncoder:e.commandEncoder,bufferManager:e.bufferManager,frameBufferManager:e.frameBufferManager,pipelineManager:e.pipelineManager,textureManager:e.textureManager,frameTextures:e.frameTextures}),f=r.msaa&&r.msaaTexture?.view,d=f?"filter_complex_blend_output_msaa":"filter_complex_blend_output",h=e.pipelineManager.getPipeline(d),p=e.pipelineManager.getBindGroupLayout("positioned_texture");if(h&&p&&a.texture&&r.texture){Nl[0]=o,Nl[1]=l,Nl[2]=a.width,Nl[3]=a.height,Nl[4]=r.width,Nl[5]=r.height,Nl[6]=0,Nl[7]=0;const t=s.acquireAndWriteUniformBuffer(Nl),n=e.textureManager.createSampler("container_blend_output_sampler",!1);ql[0].resource.buffer=t,ql[1].resource=n,ql[2].resource=a.texture.view;const i=e.device.createBindGroup({layout:p,entries:ql}),c=f?r.msaaTexture.view:r.texture.view,u=f?r.texture.view:null,d=e.frameBufferManager.createRenderPassDescriptor(c,0,0,0,0,"load",u),m=e.commandEncoder.beginRenderPass(d);m.setPipeline(h),m.setBindGroup(0,i),m.draw(6,1,0,0),m.end()}e.frameBufferManager.releaseTemporaryAttachment(i),e.frameBufferManager.releaseTemporaryAttachment(a)}},Jl=(e,t,r,n,i,a,s,o,l,c,u,f,d,h,p)=>{if(s&&i&&o&&l){let r=Ql(h,e,0,0,e.width,e.height);h.frameBufferManager.releaseTemporaryAttachment(e);const s=Hn.getDevicePixelRatio();if(r=((e,t,r,n,i)=>{Io.x=0,Io.y=0;for(let a=0;r.length>a;)switch(r[a++]){case 0:{const s=pl(e,t,r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],Boolean(r[a++]),n,i);e!==s&&i.frameBufferManager.releaseTemporaryAttachment(e),e=s}break;case 1:{const s=Yo(e,t,r[a++],r[a++],r[a++],n,i);e!==s&&i.frameBufferManager.releaseTemporaryAttachment(e),e=s}break;case 2:{Wl[0]=r[a++],Wl[1]=r[a++],Wl[2]=r[a++],Wl[3]=r[a++],Wl[4]=r[a++],Wl[5]=r[a++],Wl[6]=r[a++],Wl[7]=r[a++],Wl[8]=r[a++],Wl[9]=r[a++],Wl[10]=r[a++],Wl[11]=r[a++],Wl[12]=r[a++],Wl[13]=r[a++],Wl[14]=r[a++],Wl[15]=r[a++],Wl[16]=r[a++],Wl[17]=r[a++],Wl[18]=r[a++],Wl[19]=r[a++];const t=el(e,Wl,i);e!==t&&i.frameBufferManager.releaseTemporaryAttachment(e),e=t}break;case 3:{const t=r[a++],n=r[a++],s=t*n,o=new Float32Array(s);for(let e=0;e<s;e++)o[e]=r[a++];const l=bl(e,t,n,o,r[a++],r[a++],Boolean(r[a++]),Boolean(r[a++]),r[a++],r[a++],i);e!==l&&i.frameBufferManager.releaseTemporaryAttachment(e),e=l}break;case 4:{const t=r[a++],n=new Uint8Array(t);for(let e=0;e<t;e++)n[e]=r[a++];const s=Rl(e,0,n,r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],0,i);e!==s&&i.frameBufferManager.releaseTemporaryAttachment(e),e=s}break;case 5:{const s=ol(e,t,r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],Boolean(r[a++]),Boolean(r[a++]),Boolean(r[a++]),n,i);e!==s&&i.frameBufferManager.releaseTemporaryAttachment(e),e=s}break;case 6:{const s=nl(e,t,r[a++],r[a++],r[a++],r[a++],r[a++],r[a++],Boolean(r[a++]),Boolean(r[a++]),n,i);e!==s&&i.frameBufferManager.releaseTemporaryAttachment(e),e=s}break;case 7:{const s=r[a++],o=r[a++],l=r[a++],c=new Float32Array(l);for(let e=0;e<l;e++)c[e]=r[a++];const u=r[a++],f=new Float32Array(u);for(let e=0;e<u;e++)f[e]=r[a++];const d=r[a++],h=new Float32Array(d);for(let e=0;e<d;e++)h[e]=r[a++];const p=Ml(e,t,s,o,c,f,h,r[a++],r[a++],r[a++],r[a++],r[a++],Boolean(r[a++]),n,i);e!==p&&i.frameBufferManager.releaseTemporaryAttachment(e),e=p}break;case 8:{const s=r[a++],o=r[a++],l=r[a++],c=new Float32Array(l);for(let e=0;e<l;e++)c[e]=r[a++];const u=r[a++],f=new Float32Array(u);for(let e=0;e<u;e++)f[e]=r[a++];const d=r[a++],h=new Float32Array(d);for(let e=0;e<d;e++)h[e]=r[a++];const p=Tl(e,t,s,o,c,f,h,r[a++],r[a++],r[a++],r[a++],r[a++],Boolean(r[a++]),n,i);e!==p&&i.frameBufferManager.releaseTemporaryAttachment(e),e=p}}return e})(r,i,l,s,h),c&&(yn.set(c,"fKey",u),yn.set(c,"fTexture",r)),r){let e=r,l=null;Kl(a)||(l=Hl(h,r,a),e=l);const u=Math.sqrt(i[0]*i[0]+i[1]*i[1]),f=Math.sqrt(i[2]*i[2]+i[3]*i[3]),d=o[0]*(u/s),m=o[1]*(f/s),g=d+i[4],b=m+i[5];Zl(h,e,t,n,g,b,p),l&&h.frameBufferManager.releaseTemporaryAttachment(l),c||h.frameBufferManager.releaseTemporaryAttachment(r)}}else{let r=Ql(h,e,0,0,e.width,e.height);if(h.frameBufferManager.releaseTemporaryAttachment(e),!Kl(a)){const e=Hl(h,r,a);h.frameBufferManager.releaseTemporaryAttachment(r),r=e}Zl(h,r,t,n,i[4],i[5],p),h.frameBufferManager.releaseTemporaryAttachment(r)}},ec=new Float32Array([1,1,0,0]),tc=[],rc=new Float32Array([0,0,.5,.5,1,1,1,1,1,0,0,0,1,0,0,0,1,1,0,.5,.5,1,1,1,1,1,0,0,0,1,0,0,0,1,0,1,.5,.5,1,1,1,1,1,0,0,0,1,0,0,0,1,1,0,.5,.5,1,1,1,1,1,0,0,0,1,0,0,0,1,1,1,.5,.5,1,1,1,1,1,0,0,0,1,0,0,0,1,0,1,.5,.5,1,1,1,1,1,0,0,0,1,0,0,0,1]),nc=new Float32Array([0,0,1,0,0,1,1,0,1,1,0,1]),ic=new Float32Array(8),ac=new Float32Array(16);let sc=null,oc=null,lc=null;const cc={view:null,clearValue:{r:0,g:0,b:0,a:0},loadOp:"clear",storeOp:"store"},uc={colorAttachments:[cc]},fc=[{binding:0,resource:{buffer:null}},{binding:1,resource:null},{binding:2,resource:null}],dc={r:0,g:0,b:0,a:0},hc={view:null,clearValue:dc,loadOp:"clear",storeOp:"store",resolveTarget:void 0},pc={view:null,stencilClearValue:0,stencilLoadOp:"clear",stencilStoreOp:"store"},mc={colorAttachments:[hc]},gc={view:null,resolveTarget:void 0,loadOp:"load",storeOp:"store"},bc={view:null,stencilLoadOp:"load",stencilStoreOp:"store"},xc={colorAttachments:[gc]};class vc{constructor(e,t,r,n=1){Object.defineProperty(this,"$stack",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$matrix",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$clearColorR",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$clearColorG",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$clearColorB",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$clearColorA",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$mainAttachmentObject",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$stackAttachmentObject",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"globalAlpha",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"globalCompositeOperation",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"imageSmoothingEnabled",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$fillStyle",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"$strokeStyle",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"maskBounds",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"thickness",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"caps",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"joints",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"miterLimit",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"device",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"canvasContext",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"preferredFormat",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"commandEncoder",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"renderPassEncoder",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"mainTexture",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"mainTextureView",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"frameStarted",{enumerable:!0,configurable:!0,writable:!0,value:!1}),Object.defineProperty(this,"frameTextures",{enumerable:!0,configurable:!0,writable:!0,value:[]}),Object.defineProperty(this,"pooledTextures",{enumerable:!0,configurable:!0,writable:!0,value:[]}),Object.defineProperty(this,"pooledRenderTextures",{enumerable:!0,configurable:!0,writable:!0,value:[]}),Object.defineProperty(this,"currentRenderTarget",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"viewportWidth",{enumerable:!0,configurable:!0,writable:!0,value:0}),Object.defineProperty(this,"viewportHeight",{enumerable:!0,configurable:!0,writable:!0,value:0}),Object.defineProperty(this,"pathCommand",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"bufferManager",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"textureManager",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"frameBufferManager",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"pipelineManager",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"computePipelineManager",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"attachmentManager",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"newDrawState",{enumerable:!0,configurable:!0,writable:!0,value:!1}),Object.defineProperty(this,"$containerLayerStack",{enumerable:!0,configurable:!0,writable:!0,value:[]}),Object.defineProperty(this,"containerLayerContentSizes",{enumerable:!0,configurable:!0,writable:!0,value:[]}),Object.defineProperty(this,"inMaskMode",{enumerable:!0,configurable:!0,writable:!0,value:!1}),Object.defineProperty(this,"nodeAreaCleared",{enumerable:!0,configurable:!0,writable:!0,value:!1}),Object.defineProperty(this,"currentNodeScissor",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"nodeRenderPassAtlasIndex",{enumerable:!0,configurable:!0,writable:!0,value:-1}),Object.defineProperty(this,"fillDynamicBindGroup",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"fillDynamicBindGroupBuffer",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"nodeClearQuadBuffer",{enumerable:!0,configurable:!0,writable:!0,value:null}),Object.defineProperty(this,"useOptimizedInstancing",{enumerable:!0,configurable:!0,writable:!0,value:!0}),Object.defineProperty(this,"$needsReconfigure",{enumerable:!0,configurable:!0,writable:!0,value:!1}),Object.defineProperty(this,"$uniformData8",{enumerable:!0,configurable:!0,writable:!0,value:new Float32Array(8)}),Object.defineProperty(this,"$scissorRect",{enumerable:!0,configurable:!0,writable:!0,value:{x:0,y:0,w:0,h:0}}),Object.defineProperty(this,"$filterConfig",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.device=e,this.canvasContext=t,this.preferredFormat=r,Hn.setDevice(e),Hn.setDevicePixelRatio(n);const i=e.limits.maxTextureDimension2D,a=Math.max(2048,i/2);var s;Hn.setRenderMaxSize(a),this.$stack=Hn.createArray(),this.$stackAttachmentObject=Hn.createArray(),this.$matrix=Hn.createFloat32Array(9),this.$matrix.set([1,0,0,0,1,0,0,0,1]),this.$clearColorR=0,this.$clearColorG=0,this.$clearColorB=0,this.$clearColorA=0,this.thickness=1,this.caps=0,this.joints=2,this.miterLimit=0,this.$mainAttachmentObject=null,this.globalAlpha=1,this.globalCompositeOperation="normal",this.imageSmoothingEnabled=!1,this.$fillStyle=new Float32Array([1,1,1,1]),this.$strokeStyle=new Float32Array([1,1,1,1]),this.maskBounds={xMin:0,yMin:0,xMax:0,yMax:0},t.configure({device:e,format:r,alphaMode:"premultiplied"}),this.viewportWidth=t.canvas.width,this.viewportHeight=t.canvas.height,this.pathCommand=new Jn,this.bufferManager=new si(e),this.textureManager=new oi(e),this.frameBufferManager=new mi(e,r),this.pipelineManager=new pa(e,r),this.pipelineManager.preloadLazyGroups(),this.computePipelineManager=new ma(e),this.attachmentManager=new Mi(e),s=e=>{const t=Hn.getRenderMaxSize();return this.frameBufferManager.createAttachment(`atlas_${e}`,t,t,!1,!0)},_a=s,this.$filterConfig={device:this.device,commandEncoder:null,bufferManager:this.bufferManager,frameBufferManager:this.frameBufferManager,pipelineManager:this.pipelineManager,textureManager:this.textureManager,computePipelineManager:this.computePipelineManager,frameTextures:this.frameTextures},Qn=this}clearTransferBounds(){this.beginFrame()}updateBackgroundColor(e,t,r,n){this.$clearColorR=e,this.$clearColorG=t,this.$clearColorB=r,this.$clearColorA=n}fillBackgroundColor(){if(!this.$mainAttachmentObject||!this.$mainAttachmentObject.texture)return;this.frameStarted||this.beginFrame(),this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.ensureCommandEncoder();const e=this.$mainAttachmentObject.msaa&&this.$mainAttachmentObject.msaaTexture?.view;hc.view=e?this.$mainAttachmentObject.msaaTexture.view:this.$mainAttachmentObject.texture.view,hc.resolveTarget=e?this.$mainAttachmentObject.texture.view:void 0,dc.r=this.$clearColorR,dc.g=this.$clearColorG,dc.b=this.$clearColorB,dc.a=this.$clearColorA;const t=e&&this.$mainAttachmentObject.msaaStencil?.view?this.$mainAttachmentObject.msaaStencil.view:this.$mainAttachmentObject.stencil?.view;t?(pc.view=t,mc.depthStencilAttachment=pc):mc.depthStencilAttachment=void 0,this.renderPassEncoder=this.commandEncoder.beginRenderPass(mc),this.renderPassEncoder.end(),this.renderPassEncoder=null}resize(e,t,r=!0){this.clearArraysInstanced();for(const e of this.frameTextures)e.destroy();this.frameTextures.length=0;for(const e of this.pooledTextures)As(e);this.pooledTextures.length=0;for(const e of this.pooledRenderTextures)Cs(e);if(this.pooledRenderTextures.length=0,(()=>{for(const[,e]of Ts)for(const t of e)t.destroy();Ts.clear();for(const[,e]of Bs)for(const t of e)t.destroy();Bs.clear()})(),this.frameStarted=!1,this.commandEncoder=null,this.renderPassEncoder=null,this.currentRenderTarget=null,za=!1,Na=!1,Wa=0,Ha.clear(),Qa.clear(),this.$stackAttachmentObject.length){for(let e=0;e<this.$stackAttachmentObject.length;++e){const t=this.$stackAttachmentObject[e];t&&(t.texture&&t.texture.resource.destroy(),t.stencil&&t.stencil.resource.destroy(),t.msaaTexture&&t.msaaTexture.resource.destroy(),t.msaaStencil&&t.msaaStencil.resource.destroy())}this.$stackAttachmentObject.length=0}this.$mainAttachmentObject&&this.frameBufferManager.destroyAttachment("main"),r&&((()=>{for(const e of Es.values())e.texture?.resource&&e.texture.resource.destroy();Es.clear()})(),(()=>{for(const e of Us.values())As(e.texture);Us.clear(),$s=0})(),Is?.texture?.resource&&Is.texture.resource.destroy(),Is=null,Aa(),this.frameBufferManager.destroyAttachment("atlas"),this.frameBufferManager.createAttachment("atlas",4096,4096,!1,!0)),this.frameBufferManager.setCurrentAttachment(null),this.$needsReconfigure=!0,this.mainTexture=null,this.mainTextureView=null,this.$mainAttachmentObject=this.frameBufferManager.createAttachment("main",e,t,!0,!0),this.bind(this.$mainAttachmentObject)}clearRect(e,t,r,n){}save(){const e=tc.length>0?tc.pop():new Float32Array(9);e.set(this.$matrix),this.$stack.push(e)}restore(){const e=this.$stack.pop();e&&(this.$matrix.set(e),tc.push(e))}setTransform(e,t,r,n,i,a){this.$matrix[0]=e,this.$matrix[1]=t,this.$matrix[3]=r,this.$matrix[4]=n,this.$matrix[6]=i,this.$matrix[7]=a}transform(e,t,r,n,i,a){const s=this.$matrix,o=s[0],l=s[1],c=s[3],u=s[4],f=s[6],d=s[7];s[0]=e*o+t*c,s[1]=e*l+t*u,s[3]=r*o+n*c,s[4]=r*l+n*u,s[6]=i*o+a*c+f,s[7]=i*l+a*u+d}reset(){this.$matrix.set([1,0,0,0,1,0,0,0,1]),this.$stack.length=0,this.$stackAttachmentObject.length=0,this.globalAlpha=1,this.globalCompositeOperation="normal",this.imageSmoothingEnabled=!1}beginPath(){this.pathCommand.beginPath()}moveTo(e,t){this.pathCommand.moveTo(e,t)}lineTo(e,t){this.pathCommand.lineTo(e,t)}quadraticCurveTo(e,t,r,n){this.pathCommand.quadraticCurveTo(e,t,r,n)}fillStyle(e,t,r,n){this.$fillStyle[0]=e,this.$fillStyle[1]=t,this.$fillStyle[2]=r,this.$fillStyle[3]=n}strokeStyle(e,t,r,n){this.$strokeStyle[0]=e,this.$strokeStyle[1]=t,this.$strokeStyle[2]=r,this.$strokeStyle[3]=n}closePath(){this.pathCommand.closePath()}arc(e,t,r){this.pathCommand.arc(e,t,r)}bezierCurveTo(e,t,r,n,i,a){this.pathCommand.bezierCurveTo(e,t,r,n,i,a)}ensureFillRenderPass(){if(this.frameStarted||this.beginFrame(),this.ensureCommandEncoder(),this.renderPassEncoder)this.currentRenderTarget&&this.ensureNodeAreaCleared();else{{const e=this.getCurrentTextureView(),t=wa(),r=t?.msaa&&t?.msaaTexture?.view,n=r?t.msaaTexture.view:e,i=r?e:null;if(this.currentRenderTarget&&t?.stencil?.view){const e=r&&t?.msaaStencil?.view?t.msaaStencil.view:t.stencil.view,a=this.frameBufferManager.createStencilRenderPassDescriptor(n,e,"load","clear",i);this.renderPassEncoder=this.commandEncoder.beginRenderPass(a)}else if(!this.currentRenderTarget&&(Xa()||Da())&&this.$mainAttachmentObject?.stencil?.view){const e=this.$mainAttachmentObject.msaa&&this.$mainAttachmentObject.msaaTexture?.view,t=e?this.$mainAttachmentObject.msaaTexture.view:this.$mainAttachmentObject.texture.view,r=e&&this.$mainAttachmentObject.msaaStencil?.view?this.$mainAttachmentObject.msaaStencil.view:this.$mainAttachmentObject.stencil.view,n=e?this.$mainAttachmentObject.texture.view:null,i=this.frameBufferManager.createStencilRenderPassDescriptor(t,r,"load","load",n);this.renderPassEncoder=this.commandEncoder.beginRenderPass(i),Xa()&&this.renderPassEncoder.setStencilReference(Ka())}else if(!this.currentRenderTarget&&this.$mainAttachmentObject){const e=this.$mainAttachmentObject.msaa&&this.$mainAttachmentObject.msaaTexture?.view,t=e?this.$mainAttachmentObject.msaaTexture.view:this.$mainAttachmentObject.texture.view,r=e?this.$mainAttachmentObject.texture.view:null;if(this.$mainAttachmentObject.stencil?.view){const n=e&&this.$mainAttachmentObject.msaaStencil?.view?this.$mainAttachmentObject.msaaStencil.view:this.$mainAttachmentObject.stencil.view,i=this.frameBufferManager.createStencilRenderPassDescriptor(t,n,"load","clear",r);this.renderPassEncoder=this.commandEncoder.beginRenderPass(i)}else{const e=this.frameBufferManager.createRenderPassDescriptor(t,0,0,0,0,"load",r);this.renderPassEncoder=this.commandEncoder.beginRenderPass(e)}}else{const e=this.frameBufferManager.createRenderPassDescriptor(n,0,0,0,0,"load",i);this.renderPassEncoder=this.commandEncoder.beginRenderPass(e)}}this.currentRenderTarget&&this.ensureNodeAreaCleared()}}fill(){const e=this.pathCommand.$getVertices;if(0===e.length)return;this.ensureFillRenderPass();const t=this.viewportWidth,r=this.viewportHeight,n=ns(e);if(0===n.indexCount)return;const i=this.bufferManager.acquireVertexBuffer(n.buffer.byteLength,n.buffer),a=this.writeFillUniform(this.$fillStyle[0],this.$fillStyle[1],this.$fillStyle[2],this.$fillStyle[3],this.$matrix[0],this.$matrix[1],this.$matrix[3],this.$matrix[4],this.$matrix[6],this.$matrix[7],t,r),s=this.getOrCreateFillDynamicBindGroup(),o=wa();if(this.currentRenderTarget&&o?.stencil?.view)this.fillWithStencil(i,n.indexCount,s,a);else if(this.currentRenderTarget||this.inMaskMode||Xa()||!this.$mainAttachmentObject?.stencil?.view){const e=(this.inMaskMode||Xa())&&!!this.$mainAttachmentObject?.stencil?.view&&!this.currentRenderTarget;this.fillSimple(i,n.indexCount,e,s,a)}else this.fillWithStencilMain(i,n.indexCount,s,a)}getOrCreateFillDynamicBindGroup(){const e=this.bufferManager.dynamicUniform.getBuffer();if(!this.fillDynamicBindGroup||this.fillDynamicBindGroupBuffer!==e){const t=this.pipelineManager.getBindGroupLayout("fill_dynamic");if(!t)throw new Error("[WebGPU] fill_dynamic bind group layout not found");this.fillDynamicBindGroup=this.device.createBindGroup({layout:t,entries:[{binding:0,resource:{buffer:e,size:256}}]}),this.fillDynamicBindGroupBuffer=e}return this.fillDynamicBindGroup}writeFillUniform(e,t,r,n,i,a,s,o,l,c,u,f){return ac[0]=e,ac[1]=t,ac[2]=r,ac[3]=n,ac[4]=i/u,ac[5]=a/f,ac[6]=0,ac[7]=0,ac[8]=s/u,ac[9]=o/f,ac[10]=0,ac[11]=0,ac[12]=l/u,ac[13]=c/f,ac[14]=1,ac[15]=0,this.bufferManager.dynamicUniform.allocate(ac)}fillWithStencil(e,t,r,n){((e,t,r,n,i,a)=>{const s=t.getPipeline("stencil_write_atlas");s&&(e.setPipeline(s),e.setStencilReference(0),e.setVertexBuffer(0,r),e.setBindGroup(0,i,[a]),e.draw(n,1,0,0));const o=t.getPipeline("stencil_fill_atlas");o&&(e.setPipeline(o),e.setStencilReference(0),e.setBindGroup(0,i,[a]),e.draw(n,1,0,0))})(this.renderPassEncoder,this.pipelineManager,e,t,r,n)}fillWithStencilMain(e,t,r,n){((e,t,r,n,i,a)=>{const s=t.getPipeline("stencil_write_main");s&&(e.setPipeline(s),e.setStencilReference(0),e.setVertexBuffer(0,r),e.setBindGroup(0,i,[a]),e.draw(n,1,0,0));const o=t.getPipeline("stencil_fill_main");o&&(e.setPipeline(o),e.setStencilReference(0),e.setBindGroup(0,i,[a]),e.draw(n,1,0,0))})(this.renderPassEncoder,this.pipelineManager,e,t,r,n)}fillSimple(e,t,r,n,i){const a=this.$mainAttachmentObject?.clipLevel??1;((e,t,r,n,i,a,s,o=!1)=>{let l;if(s)l="fill";else if(o){if(Da())return;l="fill_bgra_stencil"}else l="fill_bgra";const c=t.getPipeline(l);c?(e.setPipeline(c),e.setVertexBuffer(0,r),e.setBindGroup(0,i,[a]),!o||s||Da()||e.setStencilReference(Ka()),e.draw(n,1,0,0)):console.error(`[WebGPU] ${l} pipeline not found`)})(this.renderPassEncoder,this.pipelineManager,e,t,n,i,!!this.currentRenderTarget,r,a)}bindAttachment(e){this.attachmentManager.bindAttachment(e);const t=e.color?.view??e.texture?.view;t&&(this.currentRenderTarget=t)}unbindAttachment(){this.attachmentManager.unbindAttachment(),this.currentRenderTarget=null}getAttachmentObject(e,t,r=!1){return this.attachmentManager.getAttachmentObject(e,t,r)}releaseAttachment(e){this.attachmentManager.releaseAttachment(e)}stroke(){const e=this.pathCommand.getVerticesForStroke();if(0===e.length)return;this.ensureFillRenderPass();const t=this.viewportWidth,r=this.viewportHeight,n=((e,t)=>{const r=t/2,n=[];for(const t of e){if(t.length<6)continue;const e=ws(t,r);for(const t of e)n.push(t)}return n})(e,this.thickness);if(0===n.length)return;const i=ns(n);if(0===i.indexCount)return;const a=this.bufferManager.acquireVertexBuffer(i.buffer.byteLength,i.buffer),s=this.writeFillUniform(this.$strokeStyle[0],this.$strokeStyle[1],this.$strokeStyle[2],this.$strokeStyle[3],this.$matrix[0],this.$matrix[1],this.$matrix[3],this.$matrix[4],this.$matrix[6],this.$matrix[7],t,r),o=this.getOrCreateFillDynamicBindGroup(),l=wa();if(this.currentRenderTarget&&l?.stencil?.view)this.fillWithStencil(a,i.indexCount,o,s);else if(this.currentRenderTarget||this.inMaskMode||Xa()||!this.$mainAttachmentObject?.stencil?.view){const e=(this.inMaskMode||Xa())&&!!this.$mainAttachmentObject?.stencil?.view&&!this.currentRenderTarget;this.fillSimple(a,i.indexCount,e,o,s)}else this.fillWithStencilMain(a,i.indexCount,o,s);this.pathCommand.reset()}gradientFill(e,t,r,n,i,a){const s=this.pathCommand.$getVertices;if(0===s.length)return;this.ensureFillRenderPass();const o=this.viewportWidth,l=this.viewportHeight,c=!(!this.inMaskMode&&!Xa()||!this.$mainAttachmentObject?.stencil?.view||this.currentRenderTarget),u=!!this.currentRenderTarget,f=((e,t,r,n,i,a,s,o,l,c,u,f,d,h,p,m,g=!1)=>{const b=ns(i);if(0===b.indexCount)return null;const x=r.acquireVertexBuffer(b.buffer.byteLength,b.buffer);let v,y;const _=ks(l,u,f);if(_)v=_.texture,y=_.view;else{const t=zs(l,0,f),r=l.length/5,n=Vs(r);v=Os(e,n,1),e.queue.writeTexture({texture:v},t,{bytesPerRow:4*n,rowsPerImage:1},{width:n,height:1}),y=v.createView(),Ls(l,u,f,v,y)}const w=Xs(c,0,o),M=s[3]>0?s[3]:1,P=a[0],S=a[1],F=a[3],T=a[4],B=a[6],O=a[7];Ks[0]=w.inverseMatrix[0],Ks[1]=w.inverseMatrix[3],Ks[2]=0,Ks[3]=0,Ks[4]=w.inverseMatrix[1],Ks[5]=w.inverseMatrix[4],Ks[6]=0,Ks[7]=0,Ks[8]=w.inverseMatrix[6],Ks[9]=w.inverseMatrix[7],Ks[10]=1,Ks[11]=0,Ks[12]=o,Ks[13]=Math.max(-.975,Math.min(.975,d)),Ks[14]=u,Ks[15]=819.2,w.linearPoints?(Ks[16]=w.linearPoints[0],Ks[17]=w.linearPoints[1],Ks[18]=w.linearPoints[2],Ks[19]=w.linearPoints[3]):(Ks[16]=0,Ks[17]=0,Ks[18]=0,Ks[19]=0),Ks[20]=1,Ks[21]=1,Ks[22]=1,Ks[23]=M,Ks[24]=P/h,Ks[25]=S/p,Ks[26]=0,Ks[27]=0,Ks[28]=F/h,Ks[29]=T/p,Ks[30]=0,Ks[31]=0,Ks[32]=B/h,Ks[33]=O/p,Ks[34]=1,Ks[35]=0;const A=r.acquireAndWriteUniformBuffer(Ks);Ys||(Ys=e.createSampler({magFilter:"linear",minFilter:"linear",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"}));const R=Ys,C=n.getBindGroupLayout("gradient_fill");if(!C)return console.error("[WebGPU] gradient_fill bind group layout not found"),null;Js[0].resource.buffer=A,Js[1].resource=R,Js[2].resource=y;const E=e.createBindGroup({layout:C,entries:Js}),U=()=>{const t=n.getBindGroupLayout("fill_dynamic");if(!t)return null;Hs[0]=1,Hs[1]=1,Hs[2]=1,Hs[3]=M,Hs[4]=P/h,Hs[5]=S/p,Hs[6]=0,Hs[7]=0,Hs[8]=F/h,Hs[9]=T/p,Hs[10]=0,Hs[11]=0,Hs[12]=B/h,Hs[13]=O/p,Hs[14]=1,Hs[15]=0;const i=r.dynamicUniform.allocate(Hs),a=r.dynamicUniform.getBuffer();return Qs&&Zs===a||(Qs=e.createBindGroup({layout:t,entries:[{binding:0,resource:{buffer:a,size:256}}]}),Zs=a),{bindGroup:Qs,offset:i}};if(m){const e=n.getPipeline("stencil_write_atlas");if(e){const r=U();t.setPipeline(e),t.setStencilReference(0),t.setVertexBuffer(0,x),r&&t.setBindGroup(0,r.bindGroup,[r.offset]),t.draw(b.indexCount,1,0,0)}const r=n.getGradientPipeline("gradient_fill_stencil_atlas",o,u);return r&&(t.setPipeline(r),t.setStencilReference(0),t.setBindGroup(0,E),t.draw(b.indexCount,1,0,0)),null}if(g&&Da())return null;const $=n.getPipeline("stencil_write_main");if($){const e=U();t.setPipeline($),t.setStencilReference(0),t.setVertexBuffer(0,x),e&&t.setBindGroup(0,e.bindGroup,[e.offset]),t.draw(b.indexCount,1,0,0)}const G=g?"gradient_fill_bgra_stencil_masked":"gradient_fill_stencil_main",k=n.getGradientPipeline(G,o,u);return k&&(t.setPipeline(k),t.setStencilReference(g?Ka():0),t.setBindGroup(0,E),t.draw(b.indexCount,1,0,0)),null})(this.device,this.renderPassEncoder,this.bufferManager,this.pipelineManager,s,this.$matrix,this.$fillStyle,e,t,r,n,i,a,o,l,u,c,this.$mainAttachmentObject?.clipLevel??1);f&&this.addFrameTexture(f),this.beginPath()}bitmapFill(e,t,r,n,i,a){const s=this.pathCommand.$getVertices;if(0===s.length)return;this.ensureFillRenderPass();const o=wa(),l=!(!this.currentRenderTarget||!o?.stencil?.view),c=!(!this.inMaskMode&&!Xa()||!this.$mainAttachmentObject?.stencil?.view||this.currentRenderTarget),u=l||c,f=this.$mainAttachmentObject?.clipLevel??1,d=oo(this.device,this.renderPassEncoder,this.bufferManager,this.pipelineManager,s,this.$matrix,this.$fillStyle,e,t,r,n,i,a,this.viewportWidth,this.viewportHeight,!!this.currentRenderTarget,!!u,f);d&&this.addFrameTexture(d),this.beginPath()}gradientStroke(e,t,r,n,i,a){const s=this.pathCommand.getVerticesForStroke();if(0===s.length)return;this.ensureFillRenderPass();const o=wa(),l=!(!this.currentRenderTarget||!o?.stencil?.view),c=!(this.currentRenderTarget||!this.$mainAttachmentObject?.stencil?.view),u=l||c,f=po(this.device,this.renderPassEncoder,this.bufferManager,this.pipelineManager,s,this.thickness,this.$matrix,this.$strokeStyle,e,t,r,n,i,a,this.viewportWidth,this.viewportHeight,!!this.currentRenderTarget,u);f&&this.addFrameTexture(f),this.pathCommand.reset()}bitmapStroke(e,t,r,n,i,a){const s=this.pathCommand.getVerticesForStroke();if(0===s.length)return;this.ensureFillRenderPass();const o=wa(),l=!(!this.currentRenderTarget||!o?.stencil?.view),c=!(this.currentRenderTarget||!this.$mainAttachmentObject?.stencil?.view),u=l||c,f=vo(this.device,this.renderPassEncoder,this.bufferManager,this.pipelineManager,s,this.thickness,this.$matrix,this.$strokeStyle,e,t,r,n,i,a,this.viewportWidth,this.viewportHeight,!!this.currentRenderTarget,u);f&&this.addFrameTexture(f),this.pathCommand.reset()}clip(){let e=this.frameBufferManager.getCurrentAttachment();const t=!e||e===this.$mainAttachmentObject;if(!e&&this.$mainAttachmentObject&&(e=this.$mainAttachmentObject),!e)return;if(!e.stencil)return;const r=this.pathCommand.$getVertices;if(0!==r.length){if(!this.renderPassEncoder){if(this.ensureCommandEncoder(),!t||!this.$mainAttachmentObject?.stencil?.view)return;{const e=this.$mainAttachmentObject.msaa&&this.$mainAttachmentObject.msaaTexture?.view,t=e?this.$mainAttachmentObject.msaaTexture.view:this.$mainAttachmentObject.texture.view,r=e&&this.$mainAttachmentObject.msaaStencil?.view?this.$mainAttachmentObject.msaaStencil.view:this.$mainAttachmentObject.stencil.view,n=this.frameBufferManager.createStencilRenderPassDescriptor(t,r,"load","load");this.renderPassEncoder=this.commandEncoder.beginRenderPass(n)}}Mo(this.device,this.renderPassEncoder,this.bufferManager,this.pipelineManager,e,r,this.$matrix,this.$fillStyle,this.globalAlpha,t)}}bind(e){this.frameBufferManager.setCurrentAttachment(e),this.viewportWidth=e.width,this.viewportHeight=e.height}get currentAttachmentObject(){return this.frameBufferManager.getCurrentAttachment()||this.$mainAttachmentObject}get atlasAttachmentObject(){return wa()}useGrid(e){Ms.set(Ps,e)}beginNodeRendering(e){this.nodeAreaCleared=!1,this.frameStarted||this.beginFrame();const t=Ma(e.index)||wa();if(t&&t.texture){if(this.renderPassEncoder&&this.nodeRenderPassAtlasIndex===e.index)this.currentRenderTarget=t.texture.view,this.viewportWidth=t.width,this.viewportHeight=t.height;else{this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.currentRenderTarget=t.texture.view,this.viewportWidth=t.width,this.viewportHeight=t.height,this.ensureCommandEncoder();const r=t.msaa&&t.msaaTexture?.view,n=r?t.msaaTexture.view:t.texture.view,i=r?t.texture.view:null;if(t.stencil?.view){const e=r&&t.msaaStencil?.view?t.msaaStencil.view:t.stencil.view,a=this.frameBufferManager.createStencilRenderPassDescriptor(n,e,"load","load",i);this.renderPassEncoder=this.commandEncoder.beginRenderPass(a)}else{const e=this.frameBufferManager.createRenderPassDescriptor(n,0,0,0,0,"load",i);this.renderPassEncoder=this.commandEncoder.beginRenderPass(e)}this.nodeRenderPassAtlasIndex=e.index}let r=Math.max(0,e.x),n=Math.max(0,e.y),i=Math.min(e.w,t.width-r),a=Math.min(e.h,t.height-n);if(r=Math.min(r,t.width),n=Math.min(n,t.height),i=Math.max(0,Math.min(i,t.width-r)),a=Math.max(0,Math.min(a,t.height-n)),this.$scissorRect.x=r,this.$scissorRect.y=n,this.$scissorRect.w=i,this.$scissorRect.h=a,this.currentNodeScissor=this.$scissorRect,i>0&&a>0){const e=Math.min(i+1,t.width-r),s=Math.min(a+1,t.height-n);this.renderPassEncoder.setScissorRect(r,n,e,s)}}}ensureNodeAreaCleared(){this.nodeAreaCleared||(this.nodeAreaCleared=!0,this.clearNodeArea())}clearNodeArea(){if(!this.renderPassEncoder)return;const e=this.pipelineManager.getPipeline("node_clear_atlas");if(!e)return;if(!this.nodeClearQuadBuffer){const e=this.device.createBuffer({size:nc.byteLength,usage:GPUBufferUsage.VERTEX|GPUBufferUsage.COPY_DST,mappedAtCreation:!0});new Float32Array(e.getMappedRange()).set(nc),e.unmap(),this.nodeClearQuadBuffer=e}const t=this.nodeClearQuadBuffer;this.renderPassEncoder.setPipeline(e),this.renderPassEncoder.setVertexBuffer(0,t),this.renderPassEncoder.draw(6),this.currentNodeScissor&&this.renderPassEncoder.setScissorRect(this.currentNodeScissor.x,this.currentNodeScissor.y,this.currentNodeScissor.w,this.currentNodeScissor.h)}endNodeRendering(){this.currentRenderTarget=null,this.currentNodeScissor=null,this.viewportWidth=this.canvasContext.canvas.width,this.viewportHeight=this.canvasContext.canvas.height}drawFill(){Ms.clear(),Ps=0}drawDisplayObject(e,t,r,n,i,a){const s=Hn.getRenderMaxSize();((e,t,r,n,i,a,s,o,l,c,u,f)=>{const d=a[0],h=a[1],p=a[2],m=f,g=a[4]/255,b=a[5]/255,x=a[6]/255;if(Ua.has(o)){Ca===o&&Oa()===e.index||(Qn&&(va(Oa()),Qn.drawArraysInstanced()),Ea(o),Ba(e.index),va(e.index));const t=Va();nr.pushInstanceBuffer((e.x+.5)/u,(e.y+.5)/u,(e.w-1)/u,(e.h-1)/u,e.w,e.h,l,c,s[6],s[7],0,0,s[0],s[1],s[3],s[4],d,h,p,m,g,b,x,0),t.count++}else{Qn&&(va(Oa()),Qn.drawArraysInstanced());const d=Ga.length>0?Ga.pop():new Float32Array(8);d.set(a);const h=ka.length>0?ka.pop():new Float32Array(9);h.set(s),$a.push({node:e,x_min:t,y_min:r,x_max:n,y_max:i,color_transform:d,matrix:h,blend_mode:o,viewport_width:l,viewport_height:c,render_max_size:u,global_alpha:f}),Ea(o),Ba(e.index),va(e.index)}})(e,t,r,n,i,a,this.$matrix,this.globalCompositeOperation,this.viewportWidth,this.viewportHeight,s,this.globalAlpha)}drawArraysInstanced(){this.frameStarted||this.beginFrame(),this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.nodeRenderPassAtlasIndex=-1,this.ensureCommandEncoder(),this.$mainAttachmentObject&&(this.useOptimizedInstancing?this.renderPassEncoder=((e,t,r,n,i,a,s,o,l=!0,c=!0)=>{const u=Va();if(0===u.count)return r;r&&(r.end(),r=null);const f=Xa(),d=Ka(),h=(e=>{switch(e){case"add":return"instanced_add";case"screen":return"instanced_screen";case"alpha":return"instanced_alpha";case"erase":return"instanced_erase";case"copy":return"instanced_copy";default:return"instanced"}})(Ca),p=o.getPipeline(h),m=o.getPipeline("instanced_masked"),g=f&&m&&(n.msaaStencil?.view||n.stencil?.view),b=g?m:p;if(!b)return console.error("[WebGPU] Instanced pipeline not found"),null;let x;if(g){const e=n.msaa&&n.msaaTexture?.view,r=e?n.msaaTexture.view:n.texture.view,i=e&&n.msaaStencil?.view?n.msaaStencil.view:n.stencil.view,s=e?n.texture.view:null,o=a.createStencilRenderPassDescriptor(r,i,"load","load",s);x=t.beginRenderPass(o)}else{const e=n.msaa&&n.msaaTexture?.view,r=e?n.msaaTexture.view:n.texture.view,i=e?n.texture.view:null,s=a.createRenderPassDescriptor(r,0,0,0,0,"load",i);x=t.beginRenderPass(s)}x.setPipeline(b),g&&x.setStencilReference(d);const v=new Float32Array(nr.buffer.buffer,nr.buffer.byteOffset,nr.offset);let y;c?(y=i.acquireStorageBuffer(v.byteLength),i.writeStorageBuffer(y,v)):y=i.acquireVertexBuffer(v.byteLength,v);const _=i.getUnitRectBuffer(),w=wa()||a.getAttachment("atlas");if(!w)return console.error("[WebGPU] Atlas attachment not found"),x.end(),null;const M=s.createSampler("atlas_instanced_sampler",!1),P=o.getBindGroupLayout("instanced");if(!P)return console.error("[WebGPU] Instanced bind group layout not found"),x.end(),null;const S=w.texture.view;if(Fo&&To===S||(Fo=e.createBindGroup({layout:P,entries:[{binding:0,resource:M},{binding:1,resource:S}]}),To=S),x.setVertexBuffer(0,_),x.setVertexBuffer(1,y),x.setBindGroup(0,Fo),l){const e=i.createIndirectBuffer(6,u.count,0,0);x.drawIndirect(e,0)}else x.draw(6,u.count,0,0);return x.end(),u.clear(),null})(this.device,this.commandEncoder,this.renderPassEncoder,this.$mainAttachmentObject,this.bufferManager,this.frameBufferManager,this.textureManager,this.pipelineManager,!0,!0):this.renderPassEncoder=((e,t,r,n,i,a,s,o)=>{const l=Va();if(0===l.count)return r;r&&(r.end(),r=null);const c=Xa(),u=Ka(),f=(e=>{switch(e){case"add":return"instanced_add";case"screen":return"instanced_screen";case"alpha":return"instanced_alpha";case"erase":return"instanced_erase";case"copy":return"instanced_copy";default:return"instanced"}})(Ca),d=o.getPipeline(f),h=o.getPipeline("instanced_masked"),p=c&&h&&(n.msaaStencil?.view||n.stencil?.view),m=p?h:d;if(!m)return console.error("[WebGPU] Instanced pipeline not found"),null;let g;if(p){const e=n.msaa&&n.msaaTexture?.view,r=e?n.msaaTexture.view:n.texture.view,i=e&&n.msaaStencil?.view?n.msaaStencil.view:n.stencil.view,s=e?n.texture.view:null,o=a.createStencilRenderPassDescriptor(r,i,"load","load",s);g=t.beginRenderPass(o)}else{const e=n.msaa&&n.msaaTexture?.view,r=e?n.msaaTexture.view:n.texture.view,i=e?n.texture.view:null,s=a.createRenderPassDescriptor(r,0,0,0,0,"load",i);g=t.beginRenderPass(s)}g.setPipeline(m),p&&g.setStencilReference(u);const b=new Float32Array(nr.buffer.buffer,nr.buffer.byteOffset,nr.offset),x=i.acquireVertexBuffer(b.byteLength,b),v=i.getUnitRectBuffer(),y=wa()||a.getAttachment("atlas");if(!y)return console.error("[WebGPU] Atlas attachment not found"),g.end(),null;const _=s.createSampler("atlas_instanced_sampler",!1),w=o.getBindGroupLayout("instanced");if(!w)return console.error("[WebGPU] Instanced bind group layout not found"),g.end(),null;const M=y.texture.view;return Po&&So===M||(Po=e.createBindGroup({layout:w,entries:[{binding:0,resource:_},{binding:1,resource:M}]}),So=M),g.setVertexBuffer(0,v),g.setVertexBuffer(1,x),g.setBindGroup(0,Po),g.draw(6,l.count,0,0),g.end(),l.clear(),null})(this.device,this.commandEncoder,this.renderPassEncoder,this.$mainAttachmentObject,this.bufferManager,this.frameBufferManager,this.textureManager,this.pipelineManager),this.processComplexBlendQueue())}setOptimizedInstancing(e){this.useOptimizedInstancing=e}isOptimizedInstancingEnabled(){return this.useOptimizedInstancing}processComplexBlendQueue(){this.ensureCommandEncoder(),Lo(this.device,this.commandEncoder,this.$mainAttachmentObject,this.frameBufferManager,this.textureManager,this.pipelineManager,this.bufferManager)}clearArraysInstanced(){Va().clear()}drawPixels(e,t){const r=Ma(e.index)||wa();if(!r||!r.texture)return;const n=e.w,i=e.h;if(this.renderPassEncoder&&(this.ensureNodeAreaCleared(),this.renderPassEncoder.end(),this.renderPassEncoder=null),this.nodeRenderPassAtlasIndex=-1,r.msaa&&r.msaaTexture?.view)this.drawPixelsToMsaa(r,e,t,n,i);else{const a=4*n;this.device.queue.writeTexture({texture:r.texture.resource,origin:{x:e.x,y:e.y,z:0}},t,{bytesPerRow:a,rowsPerImage:i,offset:0},{width:n,height:i,depthOrArrayLayers:1})}}drawPixelsToMsaa(e,t,r,n,i){const a=Rs(this.device,n,i),s=4*n;this.device.queue.writeTexture({texture:a},r,{bytesPerRow:s,rowsPerImage:i},{width:n,height:i});const o=this.pipelineManager.getPipeline("bitmap_render_msaa");if(!o)return void Cs(a);const l=this.pipelineManager.getBindGroupLayout("positioned_texture");if(!l)return void Cs(a);const c=this.$uniformData8;c[0]=t.x,c[1]=t.y,c[2]=n,c[3]=i,c[4]=e.width,c[5]=e.height,c[6]=0,c[7]=0;const u=this.bufferManager.acquireAndWriteUniformBuffer(c),f=this.textureManager.createSampler("linear_sampler",!0),d=Fs(a);fc[0].resource.buffer=u,fc[1].resource=f,fc[2].resource=d;const h=this.device.createBindGroup({layout:l,entries:fc});this.ensureCommandEncoder(),gc.view=e.msaaTexture.view,gc.resolveTarget=e.texture.view;const p=e.msaaStencil?.view;p?(bc.view=p,xc.depthStencilAttachment=bc):xc.depthStencilAttachment=void 0;const m=this.commandEncoder.beginRenderPass(xc);m.setViewport(0,0,e.width,e.height,0,1),m.setScissorRect(t.x,t.y,n,i),m.setPipeline(o),m.setBindGroup(0,h),m.draw(6),m.end(),this.pooledRenderTextures.push(a)}drawElement(e,t,r=!1){const n=Ma(e.index)||wa();if(!n||!n.texture)return;const i=e.w,a=e.h;this.renderPassEncoder&&(this.ensureNodeAreaCleared(),this.renderPassEncoder.end(),this.renderPassEncoder=null),this.nodeRenderPassAtlasIndex=-1,n.msaa&&n.msaaTexture?.view?this.drawElementToMsaa(n,e,t,i,a,r):this.drawElementToTexture(n,e,t,i,a,r)}drawElementToMsaa(e,t,r,n,i,a){const s=Rs(this.device,n,i);this.device.queue.copyExternalImageToTexture({source:r,flipY:a},{texture:s,premultipliedAlpha:!0},{width:n,height:i});const o=this.pipelineManager.getPipeline("bitmap_render_msaa");if(!o)return void Cs(s);const l=this.pipelineManager.getBindGroupLayout("positioned_texture");if(!l)return void Cs(s);const c=this.$uniformData8;c[0]=t.x,c[1]=t.y,c[2]=n,c[3]=i,c[4]=e.width,c[5]=e.height,c[6]=0,c[7]=0;const u=this.bufferManager.acquireAndWriteUniformBuffer(c),f=this.textureManager.createSampler("linear_sampler",!0),d=Fs(s);fc[0].resource.buffer=u,fc[1].resource=f,fc[2].resource=d;const h=this.device.createBindGroup({layout:l,entries:fc});this.ensureCommandEncoder(),gc.view=e.msaaTexture.view,gc.resolveTarget=e.texture.view;const p=e.msaaStencil?.view;p?(bc.view=p,xc.depthStencilAttachment=bc):xc.depthStencilAttachment=void 0;const m=this.commandEncoder.beginRenderPass(xc);m.setViewport(0,0,e.width,e.height,0,1),m.setScissorRect(t.x,t.y,n,i),m.setPipeline(o),m.setBindGroup(0,h),m.draw(6),m.end(),this.pooledRenderTextures.push(s)}drawElementToTexture(e,t,r,n,i,a){const s=Rs(this.device,n,i);this.device.queue.copyExternalImageToTexture({source:r,flipY:a},{texture:s,premultipliedAlpha:!0},{width:n,height:i});const o=this.pipelineManager.getPipeline("bitmap_render");if(!o)return void Cs(s);const l=this.pipelineManager.getBindGroupLayout("positioned_texture");if(!l)return void Cs(s);const c=this.$uniformData8;c[0]=t.x,c[1]=t.y,c[2]=n,c[3]=i,c[4]=e.width,c[5]=e.height,c[6]=0,c[7]=0;const u=this.bufferManager.acquireAndWriteUniformBuffer(c),f=this.textureManager.createSampler("linear_sampler",!0),d=Fs(s);fc[0].resource.buffer=u,fc[1].resource=f,fc[2].resource=d;const h=this.device.createBindGroup({layout:l,entries:fc});this.ensureCommandEncoder(),gc.view=e.texture.view,gc.resolveTarget=void 0;const p=e.stencil?.view;p?(bc.view=p,xc.depthStencilAttachment=bc):xc.depthStencilAttachment=void 0;const m=this.commandEncoder.beginRenderPass(xc);m.setViewport(0,0,e.width,e.height,0,1),m.setScissorRect(t.x,t.y,n,i),m.setPipeline(o),m.setBindGroup(0,h),m.draw(6),m.end(),this.pooledRenderTextures.push(s)}applyFilter(e,t,r,n,i,a,s,o,l,c,u){this.drawArraysInstanced(),this.frameStarted||this.beginFrame(),this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.nodeRenderPassAtlasIndex=-1,this.ensureCommandEncoder(),this.$filterConfig.commandEncoder=this.commandEncoder,this.$filterConfig.mainAttachment=this.$mainAttachmentObject,jl(e,n,i,a,s,o,l,c,u,this.$filterConfig,this.mainTextureView,this.bufferManager)}containerBeginLayer(e,t){this.drawArraysInstanced(),this.frameStarted||this.beginFrame(),this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null);const r=this.$mainAttachmentObject;this.$containerLayerStack.push(r),this.containerLayerContentSizes.push({width:e,height:t});const n=this.frameBufferManager.createAttachment("container_layer",e,t,r.msaa,!0);this.$mainAttachmentObject=n,this.bind(n)}containerEndLayer(e,t,r,n,i,a,s,o){this.drawArraysInstanced(),this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.ensureCommandEncoder();const l=this.$mainAttachmentObject,c=this.containerLayerContentSizes.pop()||{width:l.width,height:l.height};this.$mainAttachmentObject=this.$containerLayerStack.pop(),this.$filterConfig.commandEncoder=this.commandEncoder,this.$filterConfig.mainAttachment=void 0,Jl(l,this.$mainAttachmentObject,0,e,t,r,n,i,a,s,o,c.width,c.height,this.$filterConfig,this.bufferManager),this.bind(this.$mainAttachmentObject)}containerDrawCachedFilter(e,t,r,n,i,a){if(yn.get(i,"fKey")!==a)return;const s=yn.get(i,"fTexture");if(!s||!s.texture)return;this.drawArraysInstanced(),this.frameStarted||this.beginFrame(),this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.ensureCommandEncoder();const o=this.$mainAttachmentObject;if(!o||!o.texture)return;let l=s,c=null;if(!(1===r[0]&&1===r[1]&&1===r[2]&&1===r[3]&&0===r[4]&&0===r[5]&&0===r[6]&&0===r[7])){c=this.frameBufferManager.createTemporaryAttachment(s.width,s.height);const e=this.pipelineManager.getPipeline("color_transform"),t=this.pipelineManager.getBindGroupLayout("texture_copy");if(e&&t&&c.texture){ic[0]=r[0],ic[1]=r[1],ic[2]=r[2],ic[3]=r[3],ic[4]=r[4],ic[5]=r[5],ic[6]=r[6],ic[7]=0;const n=ic,i=this.bufferManager.acquireAndWriteUniformBuffer(n),a=this.textureManager.createSampler("cached_ct_sampler",!1);fc[0].resource.buffer=i,fc[1].resource=a,fc[2].resource=s.texture.view;const o=this.device.createBindGroup({layout:t,entries:fc}),u=this.frameBufferManager.createRenderPassDescriptor(c.texture.view,0,0,0,0,"clear"),f=this.commandEncoder.beginRenderPass(u);f.setPipeline(e),f.setBindGroup(0,o),f.draw(6,1,0,0),f.end(),l=c}}const u=Hn.getDevicePixelRatio(),f=Math.sqrt(t[0]*t[0]+t[1]*t[1]),d=Math.sqrt(t[2]*t[2]+t[3]*t[3]),h=n[0]*(f/u),p=n[1]*(d/u),m=Math.floor(h+t[4]),g=Math.floor(p+t[5]),b=o.msaa&&o.msaaTexture?.view;let x;switch(e){case"add":x=b?"filter_output_add_msaa":"filter_output_add";break;case"screen":x=b?"filter_output_screen_msaa":"filter_output_screen";break;case"alpha":x=b?"filter_output_alpha_msaa":"filter_output_alpha";break;case"erase":x=b?"filter_output_erase_msaa":"filter_output_erase";break;default:x=b?"filter_output_msaa":"filter_output"}const v=this.pipelineManager.getPipeline(x),y=this.pipelineManager.getBindGroupLayout("texture_copy");if(!v||!y)return;const _=this.textureManager.createSampler("cached_filter_sampler",!0),w=this.bufferManager.acquireAndWriteUniformBuffer(ec);fc[0].resource.buffer=w,fc[1].resource=_,fc[2].resource=l.texture.view;const M=this.device.createBindGroup({layout:y,entries:fc}),P=b?o.msaaTexture.view:o.texture.view,S=b?o.texture.view:null,F=this.frameBufferManager.createRenderPassDescriptor(P,0,0,0,0,"load",S),T=Math.max(0,m),B=Math.max(0,g),O=Math.max(1,l.width),A=Math.max(1,l.height),R=o.width,C=o.height,E=Math.max(1,Math.min(O,R-T)),U=Math.max(1,Math.min(A,C-B));if(E<=0||U<=0||T>=R||B>=C)return void(c&&this.frameBufferManager.releaseTemporaryAttachment(c));const $=this.commandEncoder.beginRenderPass(F);$.setPipeline(v),$.setBindGroup(0,M),$.setViewport(T,B,O,A,0,1),$.setScissorRect(T,B,E,U),$.draw(6,1,0,0),$.end(),c&&this.frameBufferManager.releaseTemporaryAttachment(c),this.bind(o)}ensureMainTexture(){this.mainTexture||(this.$needsReconfigure&&(this.canvasContext.configure({device:this.device,format:this.preferredFormat,alphaMode:"premultiplied"}),this.$needsReconfigure=!1),this.mainTexture=this.canvasContext.getCurrentTexture(),this.mainTextureView=this.mainTexture.createView())}getCurrentTextureView(){return this.currentRenderTarget?this.currentRenderTarget:(this.ensureMainTexture(),this.mainTextureView)}ensureCommandEncoder(){this.commandEncoder||(this.commandEncoder=this.device.createCommandEncoder())}beginFrame(){this.frameStarted||(this.ensureMainTexture(),this.ensureCommandEncoder(),this.frameStarted=!0,this.frameBufferManager.beginFrame())}addFrameTexture(e){this.pooledTextures.push(e)}endFrame(){if(this.frameStarted){if(this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.bufferManager.dynamicUniform.flush(),this.commandEncoder)try{const e=this.commandEncoder.finish();this.device.queue.submit([e])}catch(e){console.error("Failed to submit frame commands:",e)}this.frameBufferManager.flushPendingReleases(),this.bufferManager.clearFrameBuffers();for(const e of this.frameTextures)e.destroy();this.frameTextures.length=0;for(const e of this.pooledTextures)As(e);this.pooledTextures.length=0;for(const e of this.pooledRenderTextures)Cs(e);this.pooledRenderTextures.length=0,(()=>{$s++;for(const[e,t]of Us)$s-t.lastUsedFrame>60&&(As(t.texture),Us.delete(e))})(),this.fillDynamicBindGroup=null,this.fillDynamicBindGroupBuffer=null,this.commandEncoder=null,this.renderPassEncoder=null,this.currentRenderTarget=null,this.nodeRenderPassAtlasIndex=-1,this.mainTexture=null,this.mainTextureView=null,this.frameStarted=!1}}submit(){this.endFrame()}createNode(e,t){const r=xa;if(!Pa[r]){const e=Hn.getRenderMaxSize();Pa[r]=new Jt(r,e,e)}const n=Pa[r].insert(e,t);return n||(va(r+1),this.createNode(e,t))}removeNode(e){const t=e.index,r=Pa[t];r&&r.dispose(e.x,e.y,e.w,e.h)}transferMainCanvas(){if(!this.$mainAttachmentObject||!this.$mainAttachmentObject.texture)return void this.endFrame();this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.ensureCommandEncoder(),this.ensureMainTexture();const e=this.pipelineManager.getPipeline("texture_copy_bgra"),t=this.pipelineManager.getBindGroupLayout("texture_copy");if(!e||!t)return console.error("[WebGPU] texture_copy_bgra pipeline not found"),void this.endFrame();const r=this.$mainAttachmentObject.texture.view;if(!sc||oc!==r){lc||(lc=this.device.createBuffer({size:ec.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST}),this.device.queue.writeBuffer(lc,0,ec.buffer,ec.byteOffset,ec.byteLength));const e=this.textureManager.createSampler("transfer_sampler",!1);fc[0].resource={buffer:lc},fc[1].resource=e,fc[2].resource=r,sc=this.device.createBindGroup({layout:t,entries:fc}),oc=r}const n=sc;cc.view=this.mainTextureView;const i=this.commandEncoder.beginRenderPass(uc);i.setPipeline(e),i.setBindGroup(0,n),i.draw(6,1,0,0),i.end(),this.endFrame()}async createImageBitmap(e,t){const r=wa();if(!r)throw new Error("[WebGPU] Atlas attachment not found");this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null);const n=256*Math.ceil(4*e/256),i=n*t,a=this.device.createBuffer({size:i,usage:GPUBufferUsage.COPY_DST|GPUBufferUsage.MAP_READ}),s=this.device.createCommandEncoder();if(!r.texture)throw new Error("Attachment texture is null");s.copyTextureToBuffer({texture:r.texture.resource,mipLevel:0,origin:{x:0,y:0,z:0}},{buffer:a,bytesPerRow:n,rowsPerImage:t},{width:e,height:t,depthOrArrayLayers:1}),this.device.queue.submit([s.finish()]),await a.mapAsync(GPUMapMode.READ);const o=a.getMappedRange(),l=new Uint8Array(o),c=new Uint8Array(e*t*4);for(let r=0;r<t;r++){const t=r*n,i=r*e*4;c.set(l.subarray(t,t+4*e),i)}a.unmap(),a.destroy();const u=new Float32Array(256);for(let e=1;e<256;e++)u[e]=255/e;for(let e=0;e<c.length;e+=4){const t=c[e+3];if(0===t||255===t)continue;const r=u[t];c[e]=Math.min(255,Math.round(c[e]*r)),c[e+1]=Math.min(255,Math.round(c[e+1]*r)),c[e+2]=Math.min(255,Math.round(c[e+2]*r))}const f=new ImageData(new Uint8ClampedArray(c),e,t);if("undefined"!=typeof createImageBitmap)return await createImageBitmap(f,{premultiplyAlpha:"none",colorSpaceConversion:"none"});throw new Error("[WebGPU] createImageBitmap not available in this environment")}beginMask(){if(this.$mainAttachmentObject&&this.bind(this.$mainAttachmentObject),this.currentRenderTarget=null,this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.frameStarted||this.beginFrame(),this.ensureCommandEncoder(),this.$mainAttachmentObject?.texture&&this.$mainAttachmentObject?.stencil?.view){const e=0===this.$mainAttachmentObject.clipLevel?"clear":"load",t=this.$mainAttachmentObject.msaa&&this.$mainAttachmentObject.msaaTexture?.view,r=t?this.$mainAttachmentObject.msaaTexture.view:this.$mainAttachmentObject.texture.view,n=t&&this.$mainAttachmentObject.msaaStencil?.view?this.$mainAttachmentObject.msaaStencil.view:this.$mainAttachmentObject.stencil.view,i=this.frameBufferManager.createStencilRenderPassDescriptor(r,n,"load",e);this.renderPassEncoder=this.commandEncoder.beginRenderPass(i),this.viewportWidth=this.$mainAttachmentObject.width,this.viewportHeight=this.$mainAttachmentObject.height}(()=>{const e=Qn.currentAttachmentObject;e&&(e.mask=!0,e.clipLevel++,Qa.set(e.clipLevel,e.clipLevel),Da()||ja(!0))})(),this.inMaskMode=!0}setMaskBounds(e,t,r,n){Za(e,t,r,n)}endMask(){this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),Ja(),this.inMaskMode=!1}leaveMask(){this.drawArraysInstanced();const e=this.frameBufferManager.getCurrentAttachment(),t=e?.clipLevel??0,r=1===t;es(),this.renderPassEncoder&&(this.renderPassEncoder.end(),this.renderPassEncoder=null),this.ensureCommandEncoder();const n=this.$mainAttachmentObject?.msaa&&this.$mainAttachmentObject?.msaaTexture?.view,i=n?this.$mainAttachmentObject.msaaTexture.view:this.$mainAttachmentObject?.texture.view,a=n&&this.$mainAttachmentObject?.msaaStencil?.view?this.$mainAttachmentObject.msaaStencil.view:this.$mainAttachmentObject?.stencil?.view;if(r&&a){const e={colorAttachments:[{view:i,loadOp:"load",storeOp:"store"}],depthStencilAttachment:{view:a,stencilLoadOp:"clear",stencilStoreOp:"store",stencilClearValue:0}};this.commandEncoder.beginRenderPass(e).end()}else if(t>1&&a){const e=t,r=`clip_clear_main_${Math.min(8,Math.max(1,e))}`,n=this.pipelineManager.getPipeline(r);if(n){const e=this.frameBufferManager.createStencilRenderPassDescriptor(i,a,"load","load"),t=this.commandEncoder.beginRenderPass(e),r=this.bufferManager.acquireVertexBuffer(rc.byteLength,rc);t.setPipeline(n),t.setStencilReference(0),t.setVertexBuffer(0,r),t.draw(6,1,0,0),t.end()}}}}let yc;const _c=e=>{yc=e};let wc;let Mc=0;let Pc=0;let Sc=!1;const Fc=[],Tc=(...e)=>{const t=Fc.pop()||[];return e.length&&t.push(...e),t},Bc=(e,t=1)=>({R:(16711680&e)>>16,G:(65280&e)>>8,B:255&e,A:255*t}),Oc=async(e,t)=>{if((e=>{wc=e})(e),"gpu"in navigator){const r=navigator.gpu,n=await r.requestAdapter();if(!n)throw new Error("WebGPU adapter not available");const i=await n.requestDevice();if(!i)throw new Error("WebGPU device not available");const a=e.getContext("webgpu");if(!a)throw new Error("WebGPU context not available");const s=r.getPreferredCanvasFormat();_c(new vc(i,a,s,t))}else{const r=e.getContext("webgl2",{stencil:!0,premultipliedAlpha:!0,antialias:!1,depth:!1});if(!r)throw new Error("webgl2 is not supported.");_c(new Kn(r,4,t))}},Ac=(e,t,r=!0)=>{Mc===e&&Pc===t||(Sc=!0,Mc=e,Pc=t,yc.resize(e,t,r),r&&yn.reset())},Rc=(e,t=!1)=>{let r=0;for(;e.length>r;)switch(e[r++]){case 9:yc.beginPath();break;case 0:yc.moveTo(e[r++],e[r++]);break;case 2:yc.lineTo(e[r++],e[r++]);break;case 1:yc.quadraticCurveTo(e[r++],e[r++],e[r++],e[r++]);break;case 5:if(t){r+=4;break}yc.fillStyle(e[r++]/255,e[r++]/255,e[r++]/255,e[r++]/255);break;case 7:yc.fill();break;case 6:if(t){r+=8;break}yc.thickness=e[r++],yc.caps=e[r++],yc.joints=e[r++],yc.miterLimit=e[r++],yc.strokeStyle(e[r++]/255,e[r++]/255,e[r++]/255,e[r++]/255);break;case 8:if(t)break;yc.stroke();break;case 12:yc.closePath();break;case 4:yc.arc(e[r++],e[r++],e[r++]);break;case 3:yc.bezierCurveTo(e[r++],e[r++],e[r++],e[r++],e[r++],e[r++]);break;case 10:{if(t){r+=1;const t=e[r++];r+=5*t,r+=9,yc.fill();break}const n=e[r++],i=Tc(),a=e[r++];for(let t=0;t<a;++t)i.push(e[r++],e[r++],e[r++],e[r++],e[r++]);const s=e.subarray(r,r+6);r+=6;const o=e[r++],l=e[r++],c=e[r++];yc.gradientFill(n,i,s,o,l,c)}break;case 13:{if(t){r+=2;const t=e[r++];r+=t,r+=8,yc.fill();break}const n=e[r++],i=e[r++],a=e[r++],s=new Uint8Array(e.subarray(r,r+a));r+=a;const o=e.subarray(r,r+6);r+=6,yc.bitmapFill(s,o,n,i,Boolean(e[r++]),Boolean(e[r++]))}break;case 11:{if(t){r+=20,yc.fill();break}yc.thickness=e[r++],yc.caps=e[r++],yc.joints=e[r++],yc.miterLimit=e[r++];const n=e[r++],i=Tc(),a=e[r++];for(let t=0;t<a;++t)i.push(e[r++],e[r++],e[r++],e[r++],e[r++]);const s=e.subarray(r,r+6);r+=6;const o=e[r++],l=e[r++],c=e[r++];yc.gradientStroke(n,i,s,o,l,c)}break;case 14:{if(t){r+=6;const t=e[r++];r+=t,r+=8,yc.fill();break}yc.thickness=e[r++],yc.caps=e[r++],yc.joints=e[r++],yc.miterLimit=e[r++];const n=e[r++],i=e[r++],a=e[r++],s=new Uint8Array(e.subarray(r,r+a));r+=a;const o=e.subarray(r,r+6);r+=6,yc.bitmapStroke(s,o,n,i,Boolean(e[r++]),Boolean(e[r++]))}}},Cc=e=>{switch(e){case 0:return"copy";case 1:return"add";case 2:return"alpha";case 3:return"darken";case 4:return"difference";case 5:return"erase";case 6:return"hardlight";case 7:return"invert";case 8:return"layer";case 9:return"lighten";case 10:return"multiply";case 11:default:return"normal";case 12:return"overlay";case 13:return"screen";case 14:return"subtract"}},Ec=(e,t)=>{const r=e.subarray(t,t+6);t+=6;const n=e.subarray(t,t+8);t+=8;const i=e.subarray(t,t+4);t+=4;const a=e[t++],s=e[t++],o=e[t++],l=e[t++],c=Boolean(e[t++]),u=Boolean(e[t++]),f=Boolean(e[t++]),d=`${e[t++]}`,h=e[t++],p=e[t++],m=e[t++],g=`${e[t++]}`;let b;if(e[t++]){if(b=yn.get(d,`${h}`),!b)return t}else{const r=c?new Float32Array(28):null;r&&(r.set(e.subarray(t,t+24)),t+=24),yc.useGrid(r);const n=e[t++],i=e.subarray(t,t+n);if(f&&!c){const e=Math.ceil(Math.abs(o-a)),t=Math.ceil(Math.abs(l-s));b=yc.createNode(e,t),yn.set(d,`${h}`,b);const r=yc.currentAttachmentObject,n=yc.atlasAttachmentObject;n&&yc.bind(n),yc.reset(),yc.beginNodeRendering(b);const c=n?n.height-b.y-t:0;yc.setTransform(1,0,0,1,b.x,c),u?(Rc(i),yc.drawFill()):yc.drawPixels(b,new Uint8Array(i)),yc.endNodeRendering(),r&&yc.bind(r)}else{const e=Math.ceil(Math.abs(o-a)*p),t=Math.ceil(Math.abs(l-s)*m);b=yc.createNode(e,t),yn.set(d,`${h}`,b);const n=yc.currentAttachmentObject,c=yc.atlasAttachmentObject;c&&yc.bind(c),yc.reset(),yc.beginNodeRendering(b);const u=c?c.height-b.y-t:0;yc.setTransform(p,0,0,m,-a*p+b.x,-s*m+u),r&&(r[24]=b.x,r[25]=u),Rc(i),yc.drawFill(),yc.endNodeRendering(),n&&yc.bind(n)}t+=n}const x=e[t++];if(Boolean(e[t++])){const a=Boolean(e[t++]),s=e.subarray(t,t+4);t+=4;const o=e[t++],l=e.subarray(t,t+o),c=Math.ceil(Math.abs(i[2]-i[0])),u=Math.ceil(Math.abs(i[3]-i[1]));return yc.applyFilter(b,g,a,c,u,f,r,n,Cc(x),s,l),t+=o}if(yc.globalAlpha=Math.min(Math.max(0,n[3]+n[7]/255),1),yc.imageSmoothingEnabled=!0,yc.globalCompositeOperation=Cc(x),f&&!c)yc.setTransform(r[0],r[1],r[2],r[3],r[4],r[5]),yc.drawDisplayObject(b,i[0],i[1],i[2],i[3],n);else{const e=Math.atan2(r[1],r[0]),t=Math.atan2(-r[2],r[3]);if(e||t){const n=a*p,i=s*m,o=Math.cos(e),l=Math.sin(e),c=Math.cos(t),u=Math.sin(t);yc.setTransform(o,l,-u,c,n*o-i*u+r[4],n*l+i*c+r[5])}else yc.setTransform(1,0,0,1,i[0],i[1]);yc.drawDisplayObject(b,i[0],i[1],i[2],i[3],n)}return t},Uc=(e,t)=>{const r=e.subarray(t,t+6);t+=6,yc.reset(),yc.setTransform(r[0],r[1],r[2],r[3],r[4],r[5]);const n=Boolean(e[t++])?new Float32Array(28):null;yc.useGrid(n),n&&(n.set(e.subarray(t,t+24)),t+=24);const i=e[t++],a=e.subarray(t,t+i);return Rc(a,!0),t+=i,yc.clip(),t},$c=(e,t,r)=>{const n=e.widthTable[t.line]||0,i=t.textFormat,a=i.leftMargin||0;if(!r.wordWrap&&n>r.rawWidth)return Math.max(0,a);const s=i.rightMargin||0;return"center"===i.align||"center"===r.autoSize?Math.max(0,r.rawWidth/2-a-s-n/2-2):"right"===i.align||"right"===r.autoSize?Math.max(0,r.rawWidth-a-n-s-4):Math.max(0,a)},Gc=e=>{let t="";return e.italic&&(t+="italic "),e.bold&&(t+="bold "),`${t}${e.size}px '${e.font}','sans-serif'`},kc=new TextDecoder,Lc=(e,t)=>{const r=e.subarray(t,t+6);t+=6;const n=e.subarray(t,t+8);t+=8;const i=e.subarray(t,t+4);t+=4;const a=e[t++],s=e[t++],o=e[t++],l=e[t++],c=`${e[t++]}`,u=e[t++],f=Boolean(e[t++]),d=e[t++],h=e[t++],p=`${e[t++]}`;let m;if(e[t++]){if(m=yn.get(c,`${u}`),!m)return t}else{const r=Math.ceil(Math.abs(o-a)*d),n=Math.ceil(Math.abs(l-s)*h),i=Boolean(e[t++]);m=i?yn.get(c,`${u}`):yc.createNode(r,n),i||yn.set(c,`${u}`,m);const f=e[t++],p=new Uint8Array(e.subarray(t,t+f));t+=f;let g="none";switch(e[t++]){case 0:g="center";break;case 1:g="left";break;case 2:g="none";break;case 3:g="right"}const b={width:r,height:n,autoSize:g,stopIndex:e[t++],scrollX:e[t++],scrollY:e[t++],textWidth:e[t++],textHeight:e[t++],rawWidth:e[t++],rawHeight:e[t++],focusIndex:e[t++],selectIndex:e[t++],focusVisible:Boolean(e[t++]),thickness:e[t++],thicknessColor:e[t++],wordWrap:Boolean(e[t++]),border:Boolean(e[t++]),borderColor:e[t++],background:Boolean(e[t++]),backgroundColor:e[t++],defaultColor:e[t++],defaultSize:e[t++]},x=((e,t,r,n)=>{const i=new OffscreenCanvas(t.width,t.height),a=i.getContext("2d");if(!a)return i;const s=Math.min(1,Math.max(r,n));if(t.background||t.border){if(a.beginPath(),a.moveTo(0,0),a.lineTo(t.width,0),a.lineTo(t.width,t.height),a.lineTo(0,t.height),a.lineTo(0,0),t.background){const e=Bc(t.backgroundColor);a.fillStyle=`rgba(${e.R},${e.G},${e.B},${e.A})`,a.fill()}if(t.border){const e=Bc(t.borderColor);a.lineWidth=s,a.strokeStyle=`rgba(${e.R},${e.G},${e.B},${e.A})`,a.stroke()}}if(!e)return i;a.save(),a.beginPath(),a.moveTo(2,2),a.lineTo(t.width-2,2),a.lineTo(t.width-2,t.height-2),a.lineTo(2,t.height-2),a.lineTo(2,2),a.clip();let o=2;if(t.scrollX>0){const e=(t.textWidth+4-t.rawWidth)/t.rawWidth;o+=-t.scrollX*e}let l=2;if(t.scrollY>0){const e=(t.textHeight+2-t.rawHeight)/t.rawHeight;l+=-t.scrollY*e}if(a.setTransform(r,0,0,n,o*r,l*n),a.beginPath(),t.selectIndex>-1&&t.focusIndex>-1){const r=e.textTable.length-1;let n=0,i=0;t.focusIndex<=t.selectIndex?(n=Math.min(t.focusIndex,r),i=Math.min(t.selectIndex,r)):(n=Math.min(t.selectIndex,r),i=Math.min(t.focusIndex-1,r));const s=e.textTable[n],o=e.lineTable[s.line],l=$c(e,o,t);let c=0;if(n&&"text"===s.mode){let t=n;for(;t;){const r=e.textTable[--t];if("text"!==r.mode)break;c+=r.w}}a.fillStyle="#b4d7ff";let u=0;for(let t=n;t<=i;++t){const r=e.textTable[t];if("text"===r.mode&&(u+=r.w,t!==i))continue;let n=0;const s="text"===r.mode?r.line:r.line-1;for(let t=0;t<s;++t)n+=e.heightTable[t];a.beginPath(),a.rect(c,n,u+l,e.heightTable[s]),a.fill(),c=0,u=0}}const c=t.rawWidth;let u=0;if(t.scrollX>0){const e=(t.textWidth-c)/c;u=t.scrollX*e}const f=c+u,d=t.rawHeight;let h=0;if(t.scrollY>0){const e=(t.textHeight-d)/d;h=t.scrollY*e}const p=d+h;let m=0,g=0,b=0,x=0,v=!1,y=-1;for(let r=0;r<e.textTable.length;++r){const n=e.textTable[r];if(!n)continue;if(("text"===n.mode||"break"===n.mode)&&(y++,t.stopIndex>-1&&y>t.stopIndex))break;if(v&&"text"===n.mode)continue;const i=n.textFormat;if("none"===t.autoSize){if(g>p)break;if("text"===n.mode&&(u>m+n.w||m>f)){m+=n.w;continue}}const o=Bc(i.color||0);if(a.fillStyle=`rgba(${o.R},${o.G},${o.B},${o.A})`,t.focusVisible&&t.focusIndex===r){const t=m+b+.1;let r=n.line,i=n.y,s=e.ascentTable[r];"text"!==n.mode&&(i="break"===n.mode?n.h:e.ascentTable[r-1],r>0?(r=n.line-1,s=e.ascentTable[r]):s=n.h),r>0&&0===e.ascentTable[r]&&r++;for(let t=0;t<r;++t)s+=e.heightTable[t];a.strokeStyle=`rgba(${o.R},${o.G},${o.B},${o.A})`,a.beginPath(),a.moveTo(t,s),a.lineTo(t,s-i),a.stroke()}if(t.thickness){const e=Bc(t.thicknessColor);a.lineWidth=t.thickness,a.strokeStyle=`rgba(${e.R},${e.G},${e.B},${e.A})`}const l=0|n.line;switch(n.mode){case"break":case"wrap":if(m=0,l&&(g+=e.heightTable[l-1]),h>g+e.heightTable[l]){v=!0;continue}x=e.ascentTable[l],b=$c(e,n,t),v=!1;break;case"text":{a.beginPath(),a.font=Gc(i);const e=m+b,r=g+x;if(i.underline){const t=Bc(i.color||0);a.lineWidth=s,a.strokeStyle=`rgba(${t.R},${t.G},${t.B},${t.A})`,a.beginPath(),a.moveTo(e,r+2),a.lineTo(e+n.w,r+2),a.stroke()}t.thickness&&a.strokeText(n.text,e,r),a.fillText(n.text,e,r),m+=n.w}}}if(t.focusVisible&&t.focusIndex>=e.textTable.length){const r=e.textTable[t.focusIndex-1];if(r){const e=Bc(r.textFormat.color||0);a.strokeStyle=`rgba(${e.R},${e.G},${e.B},${e.A})`;const t=m+b+.1,n=g+x;a.beginPath(),"text"===r.mode?a.moveTo(t,n-r.y):a.moveTo(t,n+r.h),a.lineTo(t,n),a.stroke()}}return a.restore(),i})(JSON.parse(kc.decode(p)),b,d,h),v=yc.currentAttachmentObject,y=yc.atlasAttachmentObject;y&&yc.bind(y),yc.reset(),yc.beginNodeRendering(m);const _=y?y.height-m.y-n:0;yc.setTransform(1,0,0,1,m.x,_),yc.drawElement(m,x),yc.endNodeRendering(),v&&yc.bind(v)}const g=e[t++];if(Boolean(e[t++])){const a=Boolean(e[t++]),s=e.subarray(t,t+4);t+=4;const o=e[t++],l=e.subarray(t,t+o),c=Math.ceil(Math.abs(i[2]-i[0])),u=Math.ceil(Math.abs(i[3]-i[1]));return yc.applyFilter(m,p,Boolean(Math.max(+f,+a)),c,u,!1,r,n,Cc(g),s,l),t+=o}yc.globalAlpha=Math.min(Math.max(0,n[3]+n[7]/255),1),yc.imageSmoothingEnabled=!0,yc.globalCompositeOperation=Cc(g);const b=Math.atan2(r[1],r[0]),x=Math.atan2(-r[2],r[3]);if(b||x){const e=a*d,t=s*h,n=Math.cos(b),i=Math.sin(b),o=Math.cos(x),l=Math.sin(x);yc.setTransform(n,i,-l,o,e*n-t*l+r[4],e*i+t*o+r[5])}else yc.setTransform(1,0,0,1,i[0],i[1]);return yc.drawDisplayObject(m,i[0],i[1],i[2],i[3],n),t},Ic=(e,t,r)=>{const n=e.subarray(t,t+6);t+=6;const i=e.subarray(t,t+8);t+=8;const a=e.subarray(t,t+4);t+=4;const s=e[t++],o=e[t++],l=e[t++],c=e[t++],u=`${e[t++]}`,f=Boolean(e[t++]),d=`${e[t++]}`;let h;if(e[t++]){if(h=yn.get(u,"0"),!h)return t}else{const n=Math.abs(l-s),i=Math.abs(c-o),a=Boolean(e[t++]);if(h=a?yn.get(u,"0"):yc.createNode(n,i),a||yn.set(u,"0",h),r&&r.length){const e=yc.currentAttachmentObject,t=yc.atlasAttachmentObject;t&&yc.bind(t),yc.reset(),yc.beginNodeRendering(h);const n=t?t.height-h.y-i:0;yc.setTransform(1,0,0,1,h.x,n);const a=r.shift();yc.drawElement(h,a,!0),yc.endNodeRendering(),e&&yc.bind(e)}}const p=e[t++];if(Boolean(e[t++])){const r=Boolean(e[t++]),s=e.subarray(t,t+4);t+=4;const o=e[t++],l=e.subarray(t,t+o),c=Math.ceil(Math.abs(a[2]-a[0])),u=Math.ceil(Math.abs(a[3]-a[1]));return yc.applyFilter(h,d,Boolean(Math.max(+f,+r)),c,u,!0,n,i,Cc(p),s,l),t+=o}return yc.globalAlpha=Math.min(Math.max(0,i[3]+i[7]/255),1),yc.imageSmoothingEnabled=!0,yc.globalCompositeOperation=Cc(p),yc.setTransform(n[0],n[1],n[2],n[3],n[4],n[5]),yc.drawDisplayObject(h,a[0],a[1],a[2],a[3],i),t},Vc=(e,t)=>{const r=e[t++];for(let n=0;n<r;++n){switch(e[t++]){case 0:t=Vc(e,t);break;case 1:t=Uc(e,t)}}return t},zc=(e,t,r)=>{let n=0,i=!0;const a=Cc(e[t++]),s=Boolean(e[t++]);let o=0,l=0,c=!1,u="",f="",d=null,h=null,p=null,m=null;if(s)if(o=e[t++],l=e[t++],c=Boolean(e[t++]),c){const r=Boolean(e[t++]);if(u=`${e[t++]}`,f=`${e[t++]}`,r)return d=e.subarray(t,t+4),t+=4,p=e.subarray(t,t+6),t+=6,m=e.subarray(t,t+8),t+=8,yc.containerDrawCachedFilter(a,p,m,d,u,f),t;d=e.subarray(t,t+4),t+=4,p=e.subarray(t,t+6),t+=6,m=e.subarray(t,t+8),t+=8;const n=e[t++];h=e.subarray(t,t+n),t+=n}else p=e.subarray(t,t+6),t+=6,m=e.subarray(t,t+8),t+=8;s&&yc.containerBeginLayer(o,l);const g=Boolean(e[t++]);if(g){yc.drawArraysInstanced(),yc.save(),yc.beginMask(),yc.setMaskBounds(e[t++],e[t++],e[t++],e[t++]);switch(e[t++]){case 0:t=Vc(e,t);break;case 1:t=Uc(e,t)}yc.endMask()}const b=e[t++];for(let a=0;b>a;a++){const a=e[t++],s=e[t++];if(n&&a>n&&(i&&(yc.restore(),yc.leaveMask()),n=0,i=!0),!i)continue;if(s){if(n=s,i=Boolean(e[t++]),!i)continue;yc.drawArraysInstanced(),yc.save(),yc.beginMask(),yc.setMaskBounds(e[t++],e[t++],e[t++],e[t++]);switch(e[t++]){case 0:t=Vc(e,t);break;case 1:t=Uc(e,t)}yc.endMask();continue}if(!e[t++])continue;switch(e[t++]){case 0:t=zc(e,t,r);break;case 1:t=Ec(e,t);break;case 2:t=Lc(e,t);break;case 3:t=Ic(e,t,r)}}return(n||g)&&(yc.restore(),yc.leaveMask()),s&&yc.containerEndLayer(a,p,m,c,d,h,u,f),t};let jc=-1;const Dc=(e,t)=>{Sc&&(wc.width=Mc,wc.height=Pc,Sc=!1),yc.clearTransferBounds();let r=0;const n=e[r++];for(jc!==n&&(jc=n,-1===jc?yc.updateBackgroundColor(0,0,0,0):yc.updateBackgroundColor((jc>>16&255)/255,(jc>>8&255)/255,(255&jc)/255,1)),yc.reset(),yc.setTransform(1,0,0,1,0,0),yc.fillBackgroundColor();e.length>r;){if(!e[r++])continue;const n=e[r++];switch(n){case 0:r=zc(e,r,t);break;case 1:r=Ec(e,r);break;case 2:r=Lc(e,r);break;case 3:r=Ic(e,r,t);break;default:console.error("unknown type",n)}}yc.drawArraysInstanced(),yc.transferMainCanvas()},Nc=e=>{for(let t=0;t<e.length;++t){const r=`${e[t]}`;if(!yn.has(r))continue;const n=yn.getById(r);for(const e of n.values())yc.removeNode(e);yn.removeById(r)}},Wc=async(e,t,r,n=0,i=0,a)=>{yc.clearTransferBounds();let s=1;yc.reset(),yc.setTransform(1,0,0,1,0,0);const o=yc.$clearColorR,l=yc.$clearColorG,c=yc.$clearColorB,u=yc.$clearColorA;for(yc.updateBackgroundColor((n>>16&255)/255,(n>>8&255)/255,(255&n)/255,i),yc.fillBackgroundColor();e.length>s;){if(!e[s++])continue;const t=e[s++];switch(t){case 0:s=zc(e,s,a);break;case 1:s=Ec(e,s);break;case 2:s=Lc(e,s);break;case 3:s=Ic(e,s,a);break;default:console.error("unknown type",t)}}yc.drawArraysInstanced();const f=await yc.createImageBitmap(t,r);return yc.updateBackgroundColor(o,l,c,u),f};const qc=new class{constructor(){Object.defineProperty(this,"state",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"queue",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.state="deactivate",this.queue=[]}async execute(){for(this.state="active";this.queue.length;){const e=this.queue.shift();if(e)switch(e.command){case"render":Dc(e.buffer.subarray(0,e.length),e.imageBitmaps),globalThis.postMessage({message:"render",buffer:e.buffer},[e.buffer.buffer]);break;case"resize":Ac(e.buffer[0],e.buffer[1],Boolean(e.buffer[2]));break;case"initialize":await Oc(e.canvas,e.devicePixelRatio);break;case"removeCache":Nc(e.buffer);break;case"cacheClear":yn.reset();break;case"capture":{const t=await Wc(e.buffer.subarray(0,e.length),e.width,e.height,e.bgColor,e.bgAlpha,e.imageBitmaps);globalThis.postMessage({message:"capture",buffer:e.buffer,imageBitmap:t},[e.buffer.buffer,t])}}}this.state="deactivate"}};self.addEventListener("message",async e=>{qc.queue.push(e.data),"deactivate"===qc.state&&await qc.execute()});return{}}();
';