@mce/gif 0.24.3 → 0.25.0

package/dist/encode-CgtJBzpo.js

@@ -0,0 +1,22 @@
+import { Encoder } from "modern-gif";
+//#region src/encode.ts
+/**
+* 编码逻辑单独成模块，由 plugin 的导出 handle 通过 `await import('./encode')` 动态加载，
+* 使 modern-gif 与内联 worker 落到独立异步 chunk —— 注册 gif 插件时不付出体积，
+* 仅在真正导出 GIF 时才加载（与 @mce/mp4 的按需策略一致）。
+*/
+function createGifEncoder(config) {
+	let { workerUrl } = config;
+	if (!workerUrl) try {
+		workerUrl = new URL("data:text/javascript;base64,var je=Object.defineProperty,Qe=Object.defineProperties;var Je=Object.getOwnPropertyDescriptors;var Se=Object.getOwnPropertySymbols;var Ye=Object.prototype.hasOwnProperty,et=Object.prototype.propertyIsEnumerable;var T=Math.pow,de=(B,I,k)=>I in B?je(B,I,{enumerable:!0,configurable:!0,writable:!0,value:k}):B[I]=k,O=(B,I)=>{for(var k in I||(I={}))Ye.call(I,k)&&de(B,k,I[k]);if(Se)for(var k of Se(I))et.call(I,k)&&de(B,k,I[k]);return B},R=(B,I)=>Qe(B,Je(I));var y=(B,I,k)=>de(B,typeof I!="symbol"?I+"":I,k);var G=(B,I,k)=>new Promise((Z,z)=>{var j=E=>{try{q(k.next(E))}catch(F){z(F)}},Q=E=>{try{q(k.throw(E))}catch(F){z(F)}},q=E=>E.done?Z(E.value):Promise.resolve(E.value).then(j,Q);q((k=k.apply(B,I)).next())});(function(){"use strict";function B(h){const e=new Map,{workerUrl:t}=h;let{workerNumber:r=1}=h;const c=[...Array.from({length:t?r:0})].map(()=>{try{const i=new Worker(t);return i.onmessage=a,i}catch(i){return console.warn(i),null}}).filter(Boolean);r=c.length;function a(i){var l;const{id:o,data:d}=i.data;(l=e.get(o))==null||l(d),e.delete(o)}const s=function(){let i=0;return o=>c[(o!=null?o:i++)%r]}();return{call:function(){let i=0;return(o,d,l,f)=>new Promise(u=>{const g=s(f);if(!g)return u(void 0);e.set(i,u),g.postMessage({id:i++,type:o,data:d},{transfer:l})})}()}}const I="GIF",k=["87a","89a"],Z=44,z=33,j=255,Q=11,q=254,E=249,F=4,Ie=1,ke=1,fe=59;function ue(h){const e=new Uint8Array(h.reduce((t,r)=>t+r.byteLength,0));return h.reduce((t,r)=>(e.set(r,t),t+r.byteLength),0),e}function ee(h,e,t){let r;if(ArrayBuffer.isView(h))r=h.buffer;else if(h instanceof ArrayBuffer)r=h;else{const c=document.createElement("canvas"),{width:a,height:s}=t||{},n=c.getContext("2d");if(!n)throw new Error("Failed to create canvas context2d");c.width=a!=null?a:"width"in h?typeof h.width=="number"?h.width:h.width.baseVal.value:0,c.height=s!=null?s:"height"in h?typeof h.height=="number"?h.height:h.height.baseVal.value:0,n.drawImage(h,0,0,c.width,c.height),r=n.getImageData(0,0,c.width,c.height).data.buffer}switch(e){case"uint8Array":return new Uint8Array(r);case"uint8ClampedArray":return new Uint8ClampedArray(r);case"dataView":return new DataView(r);default:throw new Error("Unsupported output format")}}function Be(h){const e=new Image;return e.decoding="sync",e.loading="eager",e.crossOrigin="anonymous",e.src=h,e}function Te(h){return new Promise((e,t)=>{const r=Be(h);r.onload=()=>e(r),r.onerror=t})}class Ae{constructor(e){y(this,"_view");y(this,"offset",0);this._view=ee(e,"dataView")}readByte(){return this._view.getUint8(this.offset++)}readBytes(e){return Array.from({length:e}).map(()=>this.readByte())}readString(e){return String.fromCharCode(...this.readBytes(e))}readUnsigned(){return[this._view.getUint16(this.offset,!0),this.offset+=2][0]}readBits(){return this._view.getUint8(this.offset++).toString(2).padStart(8,"0").split("").map(Number)}readColorTable(e){return Array.from({length:e},()=>Array.from(this.readBytes(3)))}readSubBlock(){const e=[];for(;;){const t=this.readByte();if(t===0&&this._view.getUint8(this.offset)!==0)break;e.push(t)}return e}}function Ee(h){const e={},t=new Ae(h),r=()=>({index:0,delay:100,disposal:0}),c=t.readString(3),a=t.readString(3);if(c!==I||!k.includes(a))throw new Error("This is not a 87a/89a GIF data.");e.version=a,e.width=t.readUnsigned(),e.height=t.readUnsigned();const s=t.readBits();e.globalColorTable=!!s[0],e.colorResoluTion=Number.parseInt(s.slice(1,4).join(""),2)+1,e.colorTableSorted=!!s[4];const n=Number.parseInt(s.slice(5,8).join(""),2);e.colorTableSize=T(2,n+1),e.backgroundColorIndex=t.readByte(),e.pixelAspectRatio=t.readByte(),e.globalColorTable&&(e.colorTableSize?e.colorTable=t.readColorTable(e.colorTableSize):t.readSubBlock()),e.frames=[];let i=r();const o=[],d=[];for(;;){const l=t.readByte();if(o.push(l),l===Z){i.left=t.readUnsigned(),i.top=t.readUnsigned(),i.width=t.readUnsigned(),i.height=t.readUnsigned();const f=t.readBits();i.localColorTable=!!f[0],i.interlaced=!!f[1],i.colorTableSorted=!!f[2],i.reserved=Number.parseInt(f.slice(3,5).join(""),2);const u=Number.parseInt(f.slice(5,8).join(""),2);for(i.colorTableSize=T(2,u+1),i.localColorTable&&(i.colorTable=t.readColorTable(i.colorTableSize)),i.lzwMinCodeSize=t.readByte(),i.dataPositions=[];;){const g=t.readByte();if(g===0)break;const w=t.offset;i.dataPositions.push([w,g]),t.offset=w+g}e.frames.push(i),i=r(),i.index=e.frames.length;continue}if(l===z){const f=t.readByte();if(d.push(f),f===j){if(t.readByte()!==Q)continue;const u={identifier:t.readString(8),code:t.readString(3),data:[]};`${u.identifier}${u.code}`=="NETSCAPE2.0"&&t.readByte()===3&&(e.looped=!!t.readByte(),e.loopCount=t.readUnsigned()),u.data=t.readSubBlock(),i.application=u;continue}if(f===q){i.comment=t.readSubBlock().map(u=>String.fromCharCode(u)).join("");continue}if(f===E){if(t.readByte()!==F)continue;const u=t.readBits(),g={reserved:Number.parseInt(u.slice(0,3).join(""),2),disposal:Number.parseInt(u.slice(3,6).join(""),2),userInput:!!u[6],transparent:!!u[7],delayTime:t.readUnsigned(),transparentIndex:t.readByte()};t.readSubBlock(),i.graphicControl=g,i.disposal=g.disposal,i.delay=(g.delayTime||10)*10;continue}if(f===Ie){if(t.readByte()!==ke)continue;i.plainText={left:t.readUnsigned(),top:t.readUnsigned(),width:t.readUnsigned(),height:t.readUnsigned(),cellWidth:t.readByte(),cellHeight:t.readByte(),colorIndex:t.readByte(),backgroundColorIndex:t.readByte(),data:t.readSubBlock()};continue}console.warn(`Unknown extension block: 0x${f.toString(16)}`,o.slice(0,o.length-1).map(u=>`0x${u.toString(16)}`),d.slice(0,d.length-1).map(u=>`0x${u.toString(16)}`));continue}if(l===fe)break;console.warn(`Unknown block: 0x${l.toString(16)}`,o.slice(0,o.length-1).map(f=>`0x${f.toString(16)}`),d.slice(0,d.length-1).map(f=>`0x${f.toString(16)}`))}return e}function Ue(h,e){const t=Array.from({length:h.length}),r=h.length/e,c=[0,4,2,1],a=[8,8,4,2];let s=0;for(let n=0;n<4;n++)for(let i=c[n];i<r;i+=a[n])t.splice.apply(t,[i*e,e].concat(h.slice(s*e,(s+1)*e))),s++;return t}function ve(h,e,t){const a=t;let s,n,i,o,d,l,f;const u=Array.from({length:t}),g=Array.from({length:4096}),w=Array.from({length:4096}),p=Array.from({length:4097}),C=h,x=1<<C,b=x+1;for(s=x+2,d=-1,i=C+1,n=(1<<i)-1,l=0;l<x;l++)g[l]=0,w[l]=l;let m,S,A,U,L,H;for(m=S=A=U=L=H=0,f=0;f<a;){if(U===0){if(S<i){m+=e[H]<<S,S+=8,H++;continue}if(l=m&n,m>>=i,S-=i,l>s||l===b)break;if(l===x){i=C+1,n=(1<<i)-1,s=x+2,d=-1;continue}if(d===-1){p[U++]=w[l],d=l,A=l;continue}for(o=l,l===s&&(p[U++]=A,l=d);l>x;)p[U++]=w[l],l=g[l];A=w[l]&255,p[U++]=A,s<4096&&(g[s]=d,w[s]=A,s++,!(s&n)&&s<4096&&(i++,n+=s)),d=o}U--,u[L++]=p[U],f++}for(f=L;f<a;f++)u[f]=0;return u}function Ne(h,e){const t=ee(h,"uint8Array"),{gif:r=Ee(h),range:c}={},{width:a,height:s,colorTable:n,frames:i}=r,o=c?i.slice(c[0],c[1]+1):i,d=o.some(g=>g.disposal===3);let l=new Uint8ClampedArray(a*s*4),f,u=l.slice();return o.map(g=>{var Ce;const{left:w,top:p,width:C,height:x,interlaced:b,localColorTable:m,colorTable:S,lzwMinCodeSize:A,dataPositions:U,graphicControl:L,delay:H,disposal:ye}=g,xe=f==null?void 0:f.disposal,qe=p+x,{transparent:He,transparentIndex:Ke}=L!=null?L:{},ae=m?S:n,Ge=He?Ke:-1,Ze=ue(U.map(([N,W])=>t.subarray(N,N+W)));let le=ve(A,Ze,C*x);if(b&&(le=Ue(le,C)),xe===3)l=u.slice();else if(xe===2){const{left:N,top:W,width:ce,height:X}=f,Y=W+X;for(let M=W;M<Y;M++){const he=M*a+N;for(let K=0;K<ce;K++){const V=(he+K)*4;l[V]=l[V+1]=l[V+2]=l[V+3]=0}}}for(let N=p;N<qe;N++){const W=N*a+w,ce=(N-p)*C;for(let X=0;X<C;X++){const Y=le[ce+X],M=(W+X)*4;if(Y!==Ge){const[he,K,V]=(Ce=ae==null?void 0:ae[Y])!=null?Ce:[0,0,0];l[M]=he,l[M+1]=K,l[M+2]=V,l[M+3]=255}}}return d&&ye!==1&&ye!==3&&(u=l.slice()),f=g,{width:a,height:s,delay:H,data:l.slice()}})}const Oe=typeof window<"u",_=65535,P=_*_,Me=511,te=[0,20,40,60,80,99,119,139,159,179,199,219,241,264,288,313,340,367,396,427,458,491,526,562,599,637,677,718,761,805,851,898,947,997,1048,1101,1156,1212,1270,1330,1391,1453,1517,1583,1651,1720,1790,1863,1937,2013,2090,2170,2250,2333,2418,2504,2592,2681,2773,2866,2961,3058,3157,3258,3360,3464,3570,3678,3788,3900,4014,4129,4247,4366,4488,4611,4736,4864,4993,5124,5257,5392,5530,5669,5810,5953,6099,6246,6395,6547,6700,6856,7014,7174,7335,7500,7666,7834,8004,8177,8352,8528,8708,8889,9072,9258,9445,9635,9828,10022,10219,10417,10619,10822,11028,11235,11446,11658,11873,12090,12309,12530,12754,12980,13209,13440,13673,13909,14146,14387,14629,14874,15122,15371,15623,15878,16135,16394,16656,16920,17187,17456,17727,18001,18277,18556,18837,19121,19407,19696,19987,20281,20577,20876,21177,21481,21787,22096,22407,22721,23038,23357,23678,24002,24329,24658,24990,25325,25662,26001,26344,26688,27036,27386,27739,28094,28452,28813,29176,29542,29911,30282,30656,31033,31412,31794,32179,32567,32957,33350,33745,34143,34544,34948,35355,35764,36176,36591,37008,37429,37852,38278,38706,39138,39572,40009,40449,40891,41337,41785,42236,42690,43147,43606,44069,44534,45002,45473,45947,46423,46903,47385,47871,48359,48850,49344,49841,50341,50844,51349,51858,52369,52884,53401,53921,54445,54971,55500,56032,56567,57105,57646,58190,58737,59287,59840,60396,60955,61517,62082,62650,63221,63795,64372,64952,65535],ge=[0,6,13,18,22,25,28,31,34,36,38,40,42,44,46,48,50,51,53,54,56,57,59,60,61,62,64,65,66,67,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,86,87,88,89,90,91,91,92,93,94,95,95,96,97,98,98,99,100,101,101,102,103,103,104,105,106,106,107,108,108,109,110,110,111,111,112,113,113,114,115,115,116,116,117,118,118,119,119,120,121,121,122,122,123,123,124,125,125,126,126,127,127,128,128,129,129,130,130,131,132,132,133,133,134,134,135,135,136,136,137,137,138,138,139,139,140,140,140,141,141,142,142,143,143,144,144,145,145,146,146,147,147,147,148,148,149,149,150,150,151,151,151,152,152,153,153,154,154,154,155,155,156,156,156,157,157,158,158,159,159,159,160,160,161,161,161,162,162,163,163,163,164,164,165,165,165,166,166,166,167,167,168,168,168,169,169,169,170,170,171,171,171,172,172,172,173,173,174,174,174,175,175,175,176,176,176,177,177,177,178,178,179,179,179,180,180,180,181,181,181,182,182,182,183,183,183,184,184,184,185,185,185,186,186,186,187,187,187,188,188,188,189,189,189,190,190,190,191,191,191,192,192,192,193,193,193,193,194,194,194,195,195,195,196,196,196,197,197,197,198,198,198,198,199,199,199,200,200,200,201,201,201,201,202,202,202,203,203,203,204,204,204,204,205,205,205,206,206,206,206,207,207,207,208,208,208,208,209,209,209,210,210,210,210,211,211,211,212,212,212,212,213,213,213,214,214,214,214,215,215,215,215,216,216,216,217,217,217,217,218,218,218,218,219,219,219,220,220,220,220,221,221,221,221,222,222,222,222,223,223,223,224,224,224,224,225,225,225,225,226,226,226,226,227,227,227,227,228,228,228,228,229,229,229,229,230,230,230,230,231,231,231,231,232,232,232,232,233,233,233,233,234,234,234,234,235,235,235,235,236,236,236,236,237,237,237,237,238,238,238,238,239,239,239,239,239,240,240,240,240,241,241,241,241,242,242,242,242,243,243,243,243,243,244,244,244,244,245,245,245,245,246,246,246,246,246,247,247,247,247,248,248,248,248,249,249,249,249,249,250,250,250,250,251,251,251,251,251,252,252,252,252,253,253,253,253,253,254,254,254,254,255,255,255];function re(h){let e;if(h<=0)return 0;if(h>=_)return _;e=h*(h*(h+-144107)/_+132114)/_+14379;for(let t=0;t<2;t++){const r=e*e*e,c=h+(2*r+P/2)/P;e=(e*(2*h+(r+P/2)/P)+c/2)/c}return e}function v(h,e){return(h^e)<0?(h-e/2)/e:(h+e/2)/e}function we(h,e,t,r,c=!0,a=[255,255,255]){if(!c){r/=255;const s=1-r;h=h*r+s*a[0]&255,e=e*r+s*a[1]&255,t=t*r+s*a[2]&255}return{r:h,g:e,b:t}}function ne(h,e,t){return h<<16|e<<8|t}function pe(h,e,t){h=te[h],e=te[e],t=te[t];const r=(27015*h+35149*e+3372*t+_/2)/_,c=(13887*h+44610*e+7038*t+_/2)/_,a=(5787*h+18462*e+41286*t+_/2)/_,s=re(r),n=re(c),i=re(a);return{l:v(13792*s+52010*n-267*i,_),a:v(129628*s-159158*n+29530*i,_),b:v(1698*s+51299*n-52997*i,_)}}function ie(h){if(h<=0)return 0;if(h>=_)return 255;{const e=h*Me,t=~~(e/_),r=e%_,c=ge[t],a=ge[t+1];return(r*(a-c)+_/2)/_+c}}function Re(h){const e=h.l+v(25974*h.a,_)+v(14143*h.b,_),t=h.l+v(-6918*h.a,_)+v(-4185*h.b,_),r=h.l+v(-5864*h.a,_)+v(-84638*h.b,_),c=T(e,3)/P,a=T(t,3)/P,s=T(r,3)/P,n=~~ie((267169*c+-216771*a+15137*s+_/2)/_),i=~~ie((-83127*c+171030*a+-22368*s+_/2)/_),o=~~ie((-275*c+-46099*a+111909*s+_/2)/_);return{r:n,g:i,b:o}}function Pe(h){return new Promise(e=>{const t=new Image;t.decoding="sync",t.loading="eager",t.crossOrigin="anonymous",t.onload=()=>e(t),t.onerror=()=>e(t),t.src=h})}class J{constructor(){this.readable=new ReadableStream({start:e=>this._rsControler=e}),this.writable=new WritableStream({write:e=>G(this,null,function*(){var r,c,a,s;let t;switch(typeof e){case"string":{const n=yield Pe(e),i=J.ctx2d,o=i.canvas;i.clearRect(0,0,o.width,o.height),o.width=n.width,o.height=n.height,i.drawImage(n,0,0,o.width,o.height),t=i.getImageData(0,0,o.width,o.height).data;break}default:if(ArrayBuffer.isView(e))t=new Uint8ClampedArray(e.buffer);else if(e instanceof ArrayBuffer)t=new Uint8ClampedArray(e);else if(Array.isArray(e))if(Array.isArray(e[0])){const n=[];for(let i=e.length,o=0;o<i;o++)n.push((r=e[o][0])!=null?r:0,(c=e[o][1])!=null?c:0,(a=e[o][2])!=null?a:0,(s=e[o][3])!=null?s:255);t=new Uint8ClampedArray(n)}else t=new Uint8ClampedArray(e);else{const n=J.ctx2d,i=n.canvas;n.clearRect(0,0,i.width,i.height),i.width=typeof e.width=="number"?e.width:e.width.baseVal.value,i.height=typeof e.height=="number"?e.height:e.height.baseVal.value,n.drawImage(e,0,0,i.width,i.height),t=n.getImageData(0,0,i.width,i.height).data}break}this._rsControler.enqueue(t)}),close:()=>{this._rsControler.close()}})}static get ctx2d(){if(!this._ctx2d){if(!Oe)throw new Error("Failed to get ImageToPixels.ctx2d, not in browser.");const e=document.createElement("canvas").getContext("2d",{willReadFrequently:!0});if(!e)throw new Error("Failed to get ImageToPixels.ctx2d, getContext('2d') return null.");this._ctx2d=e}return this._ctx2d}}class oe{constructor(e){this.maxColors=e,this.readable=new ReadableStream({start:t=>this._rsControler=t}),this.writable=new WritableStream({write:t=>{this._rsControler.enqueue(this._boxesToQuantizedColors(this._colorsToBoxes(t)))},close:()=>{this._rsControler.close()}})}static createSorter(e){const t=e[0],r=e[1],c=e[2];return(a,s)=>a.lab[t]-s.lab[t]||a.lab[r]-s.lab[r]||a.lab[c]-s.lab[c]}_colorsToBoxes(e){let t={start:0,end:e.length-1,sorted:null,count:0,score:0,weight:0,sort:"lab",avg:{l:0,a:0,b:0}};const r=[t];let c=1;const a=(o,d,l)=>o>=d?d>=l?"lab":o>=l?"lba":"bla":o>=l?"alb":d>=l?"abl":"bal",s=o=>{const{start:d,end:l}=o;o.count=l-d+1,o.weight=0;const f={l:0,a:0,b:0};for(let g=d;g<=l;g++){const w=e[g];f.l+=w.lab.l*w.count,f.a+=w.lab.a*w.count,f.b+=w.lab.b*w.count,o.weight+=w.count}o.avg.l=f.l/o.weight,o.avg.a=f.a/o.weight,o.avg.b=f.b/o.weight;const u={l:0,a:0,b:0};for(let g=d;g<=l;g++){const w=e[g];u.l+=T(w.lab.l-o.avg.l,2)*w.count,u.a+=T(w.lab.a-o.avg.a,2)*w.count,u.b+=T(w.lab.b-o.avg.b,2)*w.count}o.sort=a(u.l,u.a,u.b),o.score=Math.max(u.l,u.a,u.b)},n=(o,d)=>{const l={start:d+1,end:o.end,sorted:o.sorted,count:0,score:0,weight:0,sort:"lab",avg:{l:0,a:0,b:0}};s(l),o.end-=l.count,s(o),r.push(l),c++},i=()=>{let o=-1,d=-1;if(c===this.maxColors)return-1;for(let l=0;l<c;l++){const f=r[l];f.count>=2&&f.score>d&&(o=l,d=f.score)}return o};for(s(t);t&&t.count>1;){const{start:o,end:d,sort:l,sorted:f}=t;if(l!==f){const C=e.slice(o,d+1).sort(oe.createSorter(l));for(let x=C.length,b=0;b<x;b++)e[o+b]=C[b];t.sorted=l}const u=t.weight+1>>1;let g=o,w=0;for(;g<d-1&&(w+=e[g].count,!(w>u));g++);n(t,g);const p=i();t=p>=0?r[p]:null}return r}_boxesToQuantizedColors(e){const t=e.reduce((r,c)=>r+c.weight,0);return e.map(r=>{const{r:c,g:a,b:s}=Re(r.avg);return{rgbInt:ne(c,a,s),rgb:{r:c,g:a,b:s},hex:`#${c.toString(16).padStart(2,"0")}${a.toString(16).padStart(2,"0")}${s.toString(16).padStart(2,"0")}`,lab:r.avg,count:r.weight,percentage:r.weight/t}}).sort((r,c)=>r.rgbInt-c.rgbInt)}}class $e{constructor(e,t,r){this.statsMode=e,this.premultipliedAlpha=t,this.tint=r,this._colors=[],this._cache=new Map,this.readable=new ReadableStream({start:c=>this._rsControler=c}),this.writable=new WritableStream({write:c=>{for(let a=c.length,s=0;s<a;s+=4){let n=c[s],i=c[s+1],o=c[s+2];const d=c[s+3];if(this.statsMode==="diff"&&this._previousPixels&&n===this._previousPixels[s]&&i===this._previousPixels[s+1]&&o===this._previousPixels[s+2]&&d===this._previousPixels[s+3])continue;({r:n,g:i,b:o}=we(n,i,o,d,this.premultipliedAlpha,this.tint));const l=ne(n,i,o),f={rgbInt:l,lab:pe(n,i,o),count:1},u=l%32768;let g=this._cache.get(u);g||this._cache.set(u,g=new Map);let w=g.get(l);if(w!==void 0){this._colors[w].count++;continue}w=this._colors.push(f)-1,g.set(l,w)}this.statsMode==="diff"&&(this._previousPixels=c)},close:()=>{this._rsControler.enqueue(this._colors.slice()),this._rsControler.close(),this._colors.length=0,this._cache.clear(),this._previousPixels=void 0}})}}class be{constructor(e=[],t=!1,r=[255,255,255]){this._premultipliedAlpha=t,this._tint=r,this._cache=new Map,this._colorMap=[],e.length&&this.setup(e)}setup(e){e=e.sort((s,n)=>s.rgbInt-n.rgbInt),this._cache.clear();const t=[],r=new Map;for(let s=-1,n=e.length,i=0;i<n;i++){const{rgbInt:o}=e[i];if(o===s){r.set(i,!0);continue}s=o}a({min:[-65535,-65535,-65535],max:[65535,65535,65535]}),this._colorMap=t;function c(s){const n={min:[65535,65535,65535],max:[-65535,-65535,-65535]},i=[];for(let g=e.length,w=0;w<g;w++){const{lab:p}=e[w];r.has(w)||p.l<s.min[0]||p.a<s.min[1]||p.b<s.min[2]||p.l>s.max[0]||p.a>s.max[1]||p.b>s.max[2]||(p.l<n.min[0]&&(n.min[0]=p.l),p.a<n.min[1]&&(n.min[1]=p.a),p.b<n.min[2]&&(n.min[2]=p.b),p.l>n.max[0]&&(n.max[0]=p.l),p.a>n.max[1]&&(n.max[1]=p.a),p.b>n.max[2]&&(n.max[2]=p.b),i.push({lab:p,index:w}))}let o="l",d=0;if(!i.length)return{index:-1,longest:o,longestIndex:d};const l=n.max[0]-n.min[0],f=n.max[1]-n.min[1],u=n.max[2]-n.min[2];return u>=l&&u>=f&&(o="b",d=2),f>=l&&f>=u&&(o="a",d=1),l>=f&&l>=u&&(o="l",d=0),{index:i.sort((g,w)=>g.lab[o]-w.lab[o])[i.length>>1].index,longest:o,longestIndex:d}}function a(s){const{index:n,longest:i,longestIndex:o}=c(s);if(n<0)return-1;r.set(n,!0);const{lab:d}=e[n],l={left:0,right:0,longest:i,lab:d,index:n},f=t.push(l)-1,u={max:[...s.max],min:[...s.min]},g={max:[...s.max],min:[...s.min]};u.max[o]=d[i],g.min[o]=Math.min(d[i]+1,65535);const w=a(u);let p=-1;return g.min[o]<=g.max[o]&&(p=a(g)),l.left=w,l.right=p,f}}_colormapNearestNode(e,t,r){const{left:c,right:a,longest:s,lab:n,index:i}=this._colorMap[e],o=Math.min(T(t.l-n.l,2)+T(t.a-n.a,2)+T(t.b-n.b,2),4294967294);o<r.dist&&(r.index=i,r.dist=o);let d,l;if(c!==-1||a!==-1){const f=t[s]-n[s];f<=0?(d=c,l=a):(d=a,l=c),d!==-1&&this._colormapNearestNode(d,t,r),l!==-1&&T(f,2)<r.dist&&this._colormapNearestNode(l,t,r)}}findNearestIndex(e,t,r,c=255){({r:e,g:t,b:r}=we(e,t,r,c,this._premultipliedAlpha,this._tint));const a=ne(e,t,r),s=a%32768;let n=this._cache.get(s);n||this._cache.set(s,n=new Map);let i=n.get(a);if(i!==void 0)return i;const o={dist:Number.MAX_SAFE_INTEGER,index:-1};return this._colormapNearestNode(0,pe(e,t,r),o),i=o.index,n.set(a,i),i}}class De{constructor(e={}){this.colors=[],this.config=this._resolveOptions(e),this._stream=this._createStream()}_resolveOptions(e){const{maxColors:t=256,statsMode:r="full",algorithm:c="median-cut",premultipliedAlpha:a=!1,tint:s=[255,255,255],samples:n=[]}=e;return{maxColors:t,statsMode:r,algorithm:c,premultipliedAlpha:a,tint:s,samples:n}}_createStream(){let e;switch(this.config.algorithm){case"median-cut":default:e=new oe(this.config.maxColors);break}return new ReadableStream({start:t=>{this._streamControler=t,this.config.samples.forEach(r=>t.enqueue(r))}}).pipeThrough(new J).pipeThrough(new $e(this.config.statsMode,this.config.premultipliedAlpha,this.config.tint)).pipeThrough(e)}addSample(e){this._streamControler.enqueue(e)}generate(){return new Promise(e=>{this._streamControler.close(),this._stream.pipeTo(new WritableStream({write:t=>{this.colors=t,this.finder=new be(t,this.config.premultipliedAlpha,this.config.tint),this._stream=this._createStream(),e(t)}}))})}match(e){var t;let r;if(typeof e=="number")r=[e>>24&255,e>>16&255,e>>8&255,e&255];else if(typeof e=="string"){const s=e.replace(/^#/,"");r=[`${s[0]}${s[1]}`,`${s[2]}${s[3]}`,`${s[4]}${s[5]}`].map(n=>parseInt(n,16))}else if(Array.isArray(e))r=e;else throw new TypeError("Unsupported color format");const c=(t=this.finder)==null?void 0:t.findNearestIndex(r[0],r[1],r[2],r[3]);if(c===void 0||c<0)return;const a=this.colors[c];if(a)return{color:a,index:c}}toColors(){return this.colors.slice()}toHexColors(){return this.colors.map(e=>e.hex)}toRgbColors(){return this.colors.map(e=>e.rgb)}toRgbIntColors(){return this.colors.map(e=>e.rgbInt)}toLabColors(){return this.colors.map(e=>e.lab)}toUint8Array(e=this.colors.length*4){var a;var t;let r;const c=new Uint8ClampedArray(e);for(let s=0;s<e;s++){const n=s*4,i=(a=(t=this.colors[s])==null?void 0:t.rgb)!=null?a:r;i&&(c[n]=i.r,c[n+1]=i.g,c[n+2]=i.b,c[n+3]=255,r=i)}return c}clear(){this.colors.length=0,this._stream=this._createStream()}}const D=class D{constructor(e=!0){this.isDebug=e}time(e){this.isDebug&&console.time(`${D.prefix} ${e}`)}timeEnd(e){this.isDebug&&console.timeEnd(`${D.prefix} ${e}`)}debug(...e){this.isDebug&&console.debug(D.prefix,...e)}warn(...e){this.isDebug&&console.warn(D.prefix,...e)}};y(D,"prefix","[modern-gif]");let se=D;class Le{constructor(e){y(this,"_rsControler");y(this,"_frames",[]);y(this,"readable",new ReadableStream({start:e=>this._rsControler=e}));y(this,"writable",new WritableStream({write:e=>{this._frames.push(e)},close:()=>{const e=this._config.backgroundColorIndex;let t;this._frames.forEach((r,c)=>{var C,x;const{width:a=1,height:s=1,data:n}=r,i=r.transparent||((x=(C=this._frames[c+1])==null?void 0:C.transparent)!=null?x:!0);let o=0,d=0,l=a-1,f=s-1,u;if(i){for(;d<f;){let b=!0;for(let m=0;m<a;m++)if(n[a*d+m]!==e){b=!1;break}if(!b)break;d++}for(;f>d;){let b=!0;for(let m=0;m<a;m++)if(n[a*f+m]!==e){b=!1;break}if(!b)break;f--}for(;o<l;){let b=!0;for(let m=d;m<f;m++)if(n[a*m+o]!==e){b=!1;break}if(!b)break;o++}for(;l>o;){let b=!0;for(let m=d;m<f;m++)if(n[a*m+l]!==e){b=!1;break}if(!b)break;l--}}else{if(t){for(;d<f;){let b=!0;for(let m=0;m<a;m++){const S=a*d+m;if(n[S]!==t[S]){b=!1;break}}if(!b)break;d++}for(;f>d;){let b=!0;for(let m=0;m<a;m++){const S=a*f+m;if(n[S]!==t[S]){b=!1;break}}if(!b)break;f--}if(d===f)o=l;else{for(;o<l;){let b=!0;for(let m=d;m<=f;m++){const S=m*a+o;if(n[S]!==t[S]){b=!1;break}}if(!b)break;o++}for(;l>o;){let b=!0;for(let m=d;m<=f;m++){const S=m*a+l;if(n[S]!==t[S]){b=!1;break}}if(!b)break;l--}}}u=t,t=n}const g=l+1-o,w=f+1-d,p=new Uint8ClampedArray(g*w);for(let b=0;b<w;b++)for(let m=0;m<g;m++){const S=b*g+m,A=(d+b)*a+(o+m);if(!i&&u&&n[A]===u[A]){p[S]=e;continue}p[S]=n[A]}this._rsControler.enqueue(R(O({},r),{left:o,top:d,width:g,height:w,disposal:i?2:1,data:p,graphicControl:R(O({},r.graphicControl),{transparent:!0,transparentIndex:e})}))}),this._rsControler.close()}}));this._config=e}}class me{constructor(e=4096){y(this,"_chunks");y(this,"_chunkIndex",0);y(this,"_chunkOffset",0);this._chunkByteLength=e,this._chunks=[this._createChunk()]}get cursor(){return[this._chunkIndex,this._chunkOffset]}_createChunk(){return new DataView(new ArrayBuffer(this._chunkByteLength))}writeByte(e,t){t?this._chunks[t[0]].setUint8(t[1],e):(this._chunkOffset>=this._chunkByteLength&&(this._chunks[++this._chunkIndex]=this._createChunk(),this._chunkOffset=0),this._chunks[this._chunkIndex].setUint8(this._chunkOffset++,e))}writeBytes(e){e.forEach(t=>this.writeByte(t))}writeString(e){e.split("").forEach(t=>{this.writeByte(t.charCodeAt(0))})}writeUnsigned(e){this.writeBytes([e&255,e>>8&255])}calculateDistance(e){return this._chunkIndex*this._chunkByteLength+this._chunkOffset-(e[0]*this._chunkByteLength+e[1])}toUint8Array(){this._chunks[this._chunkIndex]=new DataView(this._chunks[this._chunkIndex].buffer.slice(0,this._chunkOffset));const e=new Uint8Array(this._chunks.reduce((r,c)=>r+c.byteLength,0));let t=0;return this._chunks.forEach(r=>{e.set(new Uint8Array(r.buffer),t),t+=r.byteLength}),this._chunks=[this._createChunk()],this._chunkIndex=0,this._chunkOffset=0,e}}class ze{constructor(e){y(this,"_rsControler");y(this,"_frames",[]);y(this,"readable",new ReadableStream({start:e=>this._rsControler=e}));y(this,"writable",new WritableStream({write:e=>{this._frames.push(e)},close:()=>{const e=this._encodeHeader(),t=ue(this._frames),r=new Uint8Array(e.length+t.byteLength+1);r.set(e),r.set(t,e.byteLength),r[r.length-1]=fe,this._rsControler.enqueue(r),this._rsControler.close(),this._frames.length=0}}));this._config=e}_encodeHeader(){var c,a,s;const e=O({version:"89a",looped:!0,loopCount:0,pixelAspectRatio:0},this._config);if(e.width<=0||e.width>65535)throw new Error("Width invalid.");if(e.height<=0||e.height>65535)throw new Error("Height invalid.");let t=0;if((c=e.colorTable)!=null&&c.length){let n=e.colorTable.length;if(n<2||n>256||n&n-1)throw new Error("Invalid color table length, must be power of 2 and 2 .. 256.");for(;n>>=1;)++t;if(n=1<<t,e.colorTableSize=--t,e.backgroundColorIndex>=n)throw new Error("Background index out of range.");if(e.backgroundColorIndex===0)throw new Error("Background index explicitly passed as 0.")}const r=new me;return r.writeString(I),r.writeString(e.version),r.writeUnsigned(e.width),r.writeUnsigned(e.height),r.writeByte(Number.parseInt(`${e.colorTableSize?1:0}1110${e.colorTableSize.toString(2).padStart(3,"0")}`,2)),r.writeByte(e.backgroundColorIndex),r.writeByte(e.pixelAspectRatio),r.writeBytes((s=(a=e.colorTable)==null?void 0:a.flat())!=null?s:[]),e.looped&&(r.writeByte(z),r.writeByte(j),r.writeByte(Q),r.writeString("NETSCAPE2.0"),r.writeByte(3),r.writeByte(1),r.writeUnsigned(e.loopCount),r.writeByte(0)),r.toUint8Array()}}function Fe(h,e,t){t.writeByte(h);let r=t.cursor;t.writeByte(0);const c=1<<h,a=c-1,s=c+1;let n=s+1,i=h+1,o=0,d=0;function l(x){for(;o>=x;)t.writeByte(d&255),d>>=8,o-=8,t.calculateDistance(r)===256&&(t.writeByte(255,r),r=t.cursor,t.writeByte(0))}function f(x){d|=x<<o,o+=i,l(8)}let u=e[0]&a,g={},w,p,C;f(c);for(let x=e.length,b=1;b<x;++b)if(C=e[b]&a,w=u<<8|C,p=g[w],p===void 0){for(d|=u<<o,o+=i;o>=8;)t.writeByte(d&255),d>>=8,o-=8,t.calculateDistance(r)===256&&(t.writeByte(255,r),r=t.cursor,t.writeByte(0));n===4096?(f(c),n=s+1,i=h+1,g={}):(n>=1<<i&&++i,g[w]=n++),u=C}else u=p;f(u),f(s),l(1),t.calculateDistance(r)===1?t.writeByte(0,r):(t.writeByte(t.calculateDistance(r)-1,r),t.writeByte(0))}class We{constructor(e){y(this,"_rsControler");y(this,"readable",new ReadableStream({start:e=>this._rsControler=e}));y(this,"writable",new WritableStream({write:e=>{var g,w,p;const t=new me,{left:r=0,top:c=0,width:a=0,height:s=0,delay:n=100,colorTable:i}=e;let{disposal:o=0}=e;const d=(g=e.graphicControl)==null?void 0:g.transparent;let l=(p=(w=e.graphicControl)==null?void 0:w.transparentIndex)!=null?p:255;if(r<0||r>65535)throw new Error("Left invalid.");if(c<0||c>65535)throw new Error("Top invalid.");if(a<=0||a>65535)throw new Error("Width invalid.");if(s<=0||s>65535)throw new Error("Height invalid.");let f=8,u=i?i.length:0;if(u){if(u<2||u>256||u&u-1)throw new Error("Invalid color table length, must be power of 2 and 2 .. 256.");for(;u>>=1;)++f}t.writeByte(z),t.writeByte(E),t.writeByte(F),d?o||(o=2):l=0,t.writeByte(Number.parseInt(`000${Number(o&7).toString(2).padStart(3,"0")}0${d?1:0}`,2)),t.writeUnsigned(n/10),t.writeByte(l),t.writeByte(0),t.writeByte(Z),t.writeUnsigned(r),t.writeUnsigned(c),t.writeUnsigned(a),t.writeUnsigned(s),i!=null&&i.length?(t.writeByte(Number.parseInt(`10000${(f-1).toString(2).padStart(3,"0")}`,2)),t.writeBytes(i.flat())):t.writeByte(0),Fe(f,e.data,t),this._rsControler.enqueue(t.toUint8Array())},close:()=>this._rsControler.close()}));this._config=e}}const _e={"floyd-steinberg":[[7/16,1,0],[3/16,-1,1],[5/16,0,1],[1/16,1,1]],atkinson:[[1/8,1,0],[1/8,2,0],[1/8,-1,1],[1/8,0,1],[1/8,1,1],[1/8,0,2]],stucki:[[8/42,1,0],[4/42,2,0],[2/42,-2,1],[4/42,-1,1],[8/42,0,1],[4/42,1,1],[2/42,2,1],[1/42,-2,2],[2/42,-1,2],[4/42,0,2],[2/42,1,2],[1/42,2,2]]};class Xe{constructor(e,t){y(this,"_rsControler");y(this,"_finder");y(this,"_colors");y(this,"readable",new ReadableStream({start:e=>this._rsControler=e}));y(this,"writable",new WritableStream({write:e=>{const t=this._config.backgroundColorIndex,r=e.data;if(e.width&&e.height&&(this._config.dither||this._config.ditherTransparency)){const s=(n,i,o)=>(i*e.width+n)*4+o;if(this._config.dither){const n=_e[this._config.dither];for(let i=0;i<e.height;i++)for(let o=0;o<e.width;o++){const d=s(o,i,0),l={r:r[d],g:r[d+1],b:r[d+2]},f=this._colors[this._finder.findNearestIndex(l.r,l.g,l.b,this._config.premultipliedAlpha?r[d+3]:255)].rgb,u={r:l.r-f.r,g:l.g-f.g,b:l.b-f.b};r[d]=f.r,r[d+1]=f.g,r[d+2]=f.b;for(const[g,w,p]of n){const C=w<0?o+w>=0:o+w<e.width,x=p<0?i+p>=0:i+p<e.height;if(C&&x){const b=s(o+w,i+p,0);r[b]+=u.r*g,r[b+1]+=u.g*g,r[b+2]+=u.b*g}}}}if(this._config.ditherTransparency){const n=_e[this._config.ditherTransparency];for(let i=0;i<e.height;i++)for(let o=0;o<e.width;o++){const d=s(o,i,3),l=r[d],f=l<128?0:255,u=l-f;r[d]=f;for(const[g,w,p]of n){const C=w<0?o+w>=0:o+w<e.width,x=p<0?i+p>=0:i+p<e.height;if(C&&x){const b=s(o+w,i+p,3);r[b]+=u*g}}}}}let c=!1;const a=new Uint8ClampedArray(r.length/4);for(let s=r.length,n=0;n<s;n+=4)r[n+3]===0?(a[n/4]=t,c=!0):a[n/4]=this._finder.findNearestIndex(r[n],r[n+1],r[n+2],r[n+3]);this._rsControler.enqueue(R(O({},e),{data:a,transparent:c}))},close:()=>{this._rsControler.close()}}));this._config=e,this._finder=new be(t,e.premultipliedAlpha,e.tint),this._colors=t}}class Ve{constructor(e){y(this,"_logger");y(this,"_palette");y(this,"_config");y(this,"_encodingFrames",[]);y(this,"_encodeUUID",0);y(this,"_worker");var t;this._logger=new se(!!e.debug),this._config=this._resolveOptions(e),this._palette=new De({maxColors:this._config.maxColors,premultipliedAlpha:this._config.premultipliedAlpha,tint:this._config.tint}),this._config.workerUrl?(this._worker=B({workerUrl:this._config.workerUrl}),this._worker.call("encoder:init",e)):(t=this._config.frames)==null||t.forEach(r=>this.encode(r))}_resolveOptions(e){["width","height"].forEach(n=>{typeof e[n]!="undefined"&&Math.floor(e[n])!==e[n]&&(console.warn(`${n} cannot be a floating point number`),e[n]=Math.floor(e[n]))});const{colorTableSize:t=256,backgroundColorIndex:r=t-1,maxColors:c=t-1,premultipliedAlpha:a=!1,tint:s=[255,255,255]}=e;return R(O({},e),{colorTableSize:t,backgroundColorIndex:r,maxColors:c,premultipliedAlpha:a,tint:s})}encode(e){return G(this,null,function*(){if(this._worker){let s;return ArrayBuffer.isView(e.data)?s=[e.data.buffer]:e.data instanceof ArrayBuffer&&(s=[e.data]),this._worker.call("encoder:encode",e,s)}const t=this._encodeUUID;this._encodeUUID++;const{width:r=this._config.width,height:c=this._config.height}=e;let{data:a}=e;try{this._logger.time(`palette:sample-${t}`),a=typeof a=="string"?yield Te(a):a,a=ee(a,"uint8ClampedArray",{width:r,height:c}),this._encodingFrames.push(R(O({},e),{width:r,height:c,data:a})),this._palette.addSample(a)}finally{this._logger.timeEnd(`palette:sample-${t}`)}})}flush(e){return G(this,null,function*(){if(this._worker)return this._worker.call("encoder:flush",e);this._logger.time("palette:generate");const t=yield this._palette.generate();this._logger.timeEnd("palette:generate");const r=t.map(a=>[a.rgb.r,a.rgb.g,a.rgb.b]);for(;r.length<this._config.colorTableSize;)r.push([0,0,0]);this._logger.debug("palette:maxColors",this._config.maxColors),this._logger.isDebug&&console.debug(t.map(()=>"%c ").join(""),...t.map(a=>`margin: 1px; background: ${a.hex}`)),this._logger.time("encode");const c=yield new Promise(a=>{new ReadableStream({start:s=>{this._encodingFrames.forEach(n=>{s.enqueue(n)}),s.close()}}).pipeThrough(new Xe(this._config,t)).pipeThrough(new Le(this._config)).pipeThrough(new We(this._config)).pipeThrough(new ze(R(O({},this._config),{colorTable:r}))).pipeTo(new WritableStream({write:s=>a(s)}))});switch(this._logger.timeEnd("encode"),this._encodingFrames=[],this._encodeUUID=0,e){case"blob":return new Blob([c.buffer],{type:"image/gif"});case"arrayBuffer":default:return c.buffer}})}}let $;self.onmessage=h=>G(this,null,function*(){const{id:e,type:t,data:r}=h.data;switch(t){case"encoder:init":return $=new Ve(R(O({},r),{workerUrl:void 0})),self.postMessage({id:e,type:t,data:!0});case"encoder:encode":return self.postMessage({id:e,type:t,data:yield $==null?void 0:$.encode(r)});case"encoder:flush":return self.postMessage({id:e,type:t,data:yield $==null?void 0:$.flush(r)});case"frames:decode":{const c=Ne(r);return self.postMessage({id:e,type:t,data:c},c.map(a=>a.data.buffer))}}})})();
", "" + import.meta.url).href;
+	} catch {
+		workerUrl = void 0;
+	}
+	return new Encoder({
+		width: config.width,
+		height: config.height,
+		workerUrl
+	});
+}
+//#endregion
+export { createGifEncoder };

package/dist/encode.d.ts

@@ -0,0 +1,11 @@
+import { Encoder } from 'modern-gif';
+/**
+ * 编码逻辑单独成模块，由 plugin 的导出 handle 通过 `await import('./encode')` 动态加载，
+ * 使 modern-gif 与内联 worker 落到独立异步 chunk —— 注册 gif 插件时不付出体积，
+ * 仅在真正导出 GIF 时才加载（与 @mce/mp4 的按需策略一致）。
+ */
+export declare function createGifEncoder(config: {
+    width: number;
+    height: number;
+    workerUrl?: string;
+}): Encoder;

package/dist/index.js

@@ -1,12 +1,10 @@
 import { definePlugin } from "mce";
 import { render } from "modern-canvas";
-import { Encoder } from "modern-gif";
 //#region src/plugin.ts
 function plugin() {
 	return definePlugin((editor, options) => {
-		const { assets, fonts, to, runExclusiveRender } = editor;
+		const { fonts, to, runExclusiveRender } = editor;
 		const gifWorkerUrl = options.gifWorkerUrl;
-		assets.gifWorkerUrl = gifWorkerUrl;
 		return {
 			name: "mce:gif",
 			messages: {
@@ -16,13 +14,14 @@ function plugin() {
 			exporters: [{
 				name: "gif",
 				saveAs: true,
-				handle: async (options) => {
-					const { onProgress, ...restOptions } = options;
+				handle: async (exportOptions) => {
+					const { onProgress, ...restOptions } = exportOptions;
 					const data = to("json", restOptions);
 					const { startTime, endTime } = data.meta;
 					const width = Math.floor(data.style.width);
 					const height = Math.floor(data.style.height);
-					const encoder = new Encoder({
+					const { createGifEncoder } = await import("./encode-CgtJBzpo.js");
+					const encoder = createGifEncoder({
 						width,
 						height,
 						workerUrl: gifWorkerUrl

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mce/gif",
   "type": "module",
-  "version": "0.24.3",
+  "version": "0.25.0",
   "description": "GIF plugin for mce",
   "author": "wxm",
   "license": "MIT",
@@ -49,7 +49,7 @@
     "modern-gif": "^2.1.0"
   },
   "devDependencies": {
-    "mce": "0.24.3"
+    "mce": "0.25.0"
   },
   "peerDependencies": {
     "mce": "^0"