RoboCommander/node_modules/electron/dist/natives_blob.bin

 prologue 
(function(a,b,c){
"use strict";
%CheckIsBootstrapping();
var d=(void 0);
var e=%ExportFromRuntime({});
function Export(f){
f(e);
}
function Import(f){
f.next=d;
d=f;
}
function ImportNow(g){
return e[g];
}
function InstallConstants(h,i){
%CheckIsBootstrapping();
%OptimizeObjectForAddingMultipleProperties(h,i.length>>1);
var j=2|4|1;
for(var k=0;k<i.length;k+=2){
var g=i[k];
var l=i[k+1];
%AddNamedProperty(h,g,l,j);
}
%ToFastProperties(h);
}
function SetUpLockedPrototype(
constructor,fields,methods){
%CheckIsBootstrapping();
var m=constructor.prototype;
var n=(methods.length>>1)+(fields?fields.length:0);
if(n>=4){
%OptimizeObjectForAddingMultipleProperties(m,n);
}
if(fields){
for(var k=0;k<fields.length;k++){
%AddNamedProperty(m,fields[k],
(void 0),2|4);
}
}
for(var k=0;k<methods.length;k+=2){
var o=methods[k];
var f=methods[k+1];
%AddNamedProperty(m,o,f,2|4|1);
%SetNativeFlag(f);
}
%InternalSetPrototype(m,null);
%ToFastProperties(m);
}
function PostNatives(b){
%CheckIsBootstrapping();
for(;!(d===(void 0));d=d.next){
d(e);
}
e=(void 0);
b.Export=(void 0);
b.Import=(void 0);
b.ImportNow=(void 0);
b.PostNatives=(void 0);
}
%OptimizeObjectForAddingMultipleProperties(b,14);
b.Import=Import;
b.ImportNow=ImportNow;
b.Export=Export;
b.InstallConstants=InstallConstants;
b.SetUpLockedPrototype=SetUpLockedPrototype;
b.PostNatives=PostNatives;
%ToFastProperties(b);
%OptimizeObjectForAddingMultipleProperties(c,11);
c.logStackTrace=function logStackTrace(){
%DebugTrace();
};
c.log=function log(){
let message='';
for(const arg of arguments){
message+=arg;
}
%GlobalPrint(message);
};
c.createPrivateSymbol=function createPrivateSymbol(g){
return %CreatePrivateSymbol(g);
};
c.uncurryThis=function uncurryThis(p){
return function(thisArg,...args){
return %reflect_apply(p,thisArg,args);
};
};
c.markPromiseAsHandled=function markPromiseAsHandled(q){
%PromiseMarkAsHandled(q);
};
c.promiseState=function promiseState(q){
return %PromiseStatus(q);
};
c.kPROMISE_PENDING=0;
c.kPROMISE_FULFILLED=1;
c.kPROMISE_REJECTED=2;
%ToFastProperties(c);
})

array<61><79>
(function(a,b,c){
"use strict";
%CheckIsBootstrapping();
var d=a.Array;
var e=b.InternalArray;
var f=a.Math.max;
var g=a.Math.min;
var h=a.Object.prototype.hasOwnProperty;
var i=a.Object.prototype.toString;
var j=b.ImportNow("iterator_symbol");
var k=b.ImportNow("unscopables_symbol");
function ArraySpeciesCreate(l,m){
m=((m)+0)
;
var n=%ArraySpeciesConstructor(l);
return new n(m);
}
function KeySortCompare(o,p){
return o-p;
}
function GetSortedArrayKeys(l,q){
if((typeof(q)==='number')){
var r=q;
var s=new e();
for(var t=0;t<r;++t){
var u=l[t];
if(!(u===(void 0))||t in l){
s.push(t);
}
}
return s;
}
return InnerArraySort(q,q.length,KeySortCompare);
}
function SparseJoinWithSeparatorJS(
l,s,m,use_locale,separator,locales,options){
var v=s.length;
var w=new e(v*2);
for(var t=0;t<v;t++){
var x=s[t];
w[t*2]=x;
w[t*2+1]=ConvertToString(
use_locale,l[x],locales,options);
}
return %SparseJoinWithSeparator(w,m,separator);
}
function SparseJoin(l,s,y,z,A){
var v=s.length;
var w=new e(v);
for(var t=0;t<v;t++){
w[t]=ConvertToString(y,l[s[t]],z,A);
}
return %StringBuilderConcat(w,v,'');
}
function UseSparseVariant(l,m,B,C){
if(!B||m<1000||%HasComplexElements(l)){
return false;
}
if(!%_IsSmi(m)){
return true;
}
var D=m>>2;
var E=%EstimateNumberOfElements(l);
return(E<D)&&
(C>E*4);
}
function Stack(){
this.length=0;
this.values=new e();
}
Stack.prototype.length=null;
Stack.prototype.values=null;
function StackPush(F,G){
F.values[F.length++]=G;
}
function StackPop(F){
F.values[--F.length]=null
}
function StackHas(F,H){
var m=F.length;
var I=F.values;
for(var t=0;t<m;t++){
if(I[t]===H)return true;
}
return false;
}
var J=new Stack();
function DoJoin(
l,m,B,separator,y,z,A){
if(UseSparseVariant(l,m,B,m)){
%NormalizeElements(l);
var s=GetSortedArrayKeys(l,%GetArrayKeys(l,m));
if(separator===''){
if(s.length===0)return'';
return SparseJoin(l,s,y,z,A);
}else{
return SparseJoinWithSeparatorJS(
l,s,m,y,separator,z,A);
}
}
if(m===1){
return ConvertToString(y,l[0],z,A);
}
var w=new e(m);
for(var t=0;t<m;t++){
w[t]=ConvertToString(y,l[t],z,A);
}
if(separator===''){
return %StringBuilderConcat(w,m,'');
}else{
return %StringBuilderJoin(w,m,separator);
}
}
function Join(l,m,K,y,z,A){
if(m===0)return'';
var B=(%_IsArray(l));
if(B){
if(StackHas(J,l))return'';
StackPush(J,l);
}
try{
return DoJoin(
l,m,B,K,y,z,A);
}finally{
if(B)StackPop(J);
}
}
function ConvertToString(y,L,z,A){
if((L==null))return'';
if(y){
if((z==null)){
return(%_ToString(L.toLocaleString()));
}else if((A==null)){
return(%_ToString(L.toLocaleString(z)));
}
return(%_ToString(L.toLocaleString(z,A)));
}
return(%_ToString(L));
}
function SparseSlice(l,M,N,O,P){
var q=%GetArrayKeys(l,M+N);
if((typeof(q)==='number')){
var r=q;
for(var t=M;t<r;++t){
var Q=l[t];
if(!(Q===(void 0))||t in l){
%CreateDataProperty(P,t-M,Q);
}
}
}else{
var m=q.length;
for(var R=0;R<m;++R){
var x=q[R];
if(x>=M){
var Q=l[x];
if(!(Q===(void 0))||x in l){
%CreateDataProperty(P,x-M,Q);
}
}
}
}
}
function SparseMove(l,M,N,O,S){
if(S===N)return;
var T=new e(
g(O-N+S,0xffffffff));
var U;
var q=%GetArrayKeys(l,O);
if((typeof(q)==='number')){
var r=q;
for(var t=0;t<M&&t<r;++t){
var Q=l[t];
if(!(Q===(void 0))||t in l){
T[t]=Q;
}
}
for(var t=M+N;t<r;++t){
var Q=l[t];
if(!(Q===(void 0))||t in l){
T[t-N+S]=Q;
}
}
}else{
var m=q.length;
for(var R=0;R<m;++R){
var x=q[R];
if(x<M){
var Q=l[x];
if(!(Q===(void 0))||x in l){
T[x]=Q;
}
}else if(x>=M+N){
var Q=l[x];
if(!(Q===(void 0))||x in l){
var V=x-N+S;
T[V]=Q;
if(V>0xfffffffe){
U=U||new e();
U.push(V);
}
}
}
}
}
%MoveArrayContents(T,l);
if(!(U===(void 0))){
var m=U.length;
for(var t=0;t<m;++t){
var x=U[t];
l[x]=T[x];
}
}
}
function SimpleSlice(l,M,N,O,P){
for(var t=0;t<N;t++){
var W=M+t;
if(W in l){
var Q=l[W];
%CreateDataProperty(P,t,Q);
}
}
}
function SimpleMove(l,M,N,O,S){
if(S!==N){
if(S>N){
for(var t=O-N;t>M;t--){
var X=t+N-1;
var Y=t+S-1;
if(X in l){
l[Y]=l[X];
}else{
delete l[Y];
}
}
}else{
for(var t=M;t<O-N;t++){
var X=t+N;
var Y=t+S;
if(X in l){
l[Y]=l[X];
}else{
delete l[Y];
}
}
for(var t=O;t>O-N+S;t--){
delete l[t-1];
}
}
}
}
var Z;
%DefineMethodsInternal(d.prototype,class{toString(){
var l;
var aa;
if((%_IsArray(this))){
aa=this.join;
if(aa===Z){
return Join(this,this.length,',',false);
}
l=this;
}else{
l=(%_ToObject(this));
aa=l.join;
}
if(!(typeof(aa)==='function')){
return %_Call(i,l);
}
return %_Call(aa,l);
}},-1);
function InnerArrayToLocaleString(l,m,z,A){
return Join(l,(%_ToLength(m)),',',true,z,A);
}
%DefineMethodsInternal(d.prototype,class{
toLocaleString(){
var l=(%_ToObject(this));
var ab=l.length;
var z=arguments[0];
var A=arguments[1];
return InnerArrayToLocaleString(l,ab,z,A);
}},-1);
function InnerArrayJoin(K,l,m){
if((K===(void 0))){
K=',';
}else{
K=(%_ToString(K));
}
if(m===1){
var u=l[0];
if((u==null))return'';
return(%_ToString(u));
}
return Join(l,m,K,false);
}
%DefineMethodsInternal(d.prototype,class{join(K){
var l=(%_ToObject(this));
var m=(%_ToLength(l.length));
return InnerArrayJoin(K,l,m);
}},-1);
function SparseReverse(l,O){
var s=GetSortedArrayKeys(l,%GetArrayKeys(l,O));
var ac=s.length-1;
var ad=0;
while(ad<=ac){
var t=s[ad];
var ae=s[ac];
var af=O-ae-1;
var ag,ah;
if(af<=t){
ah=ae;
while(s[--ac]==ae){}
ag=af;
}
if(af>=t){
ag=t;
while(s[++ad]==t){}
ah=O-t-1;
}
var ai=l[ag];
if(!(ai===(void 0))||ag in l){
var aj=l[ah];
if(!(aj===(void 0))||ah in l){
l[ag]=aj;
l[ah]=ai;
}else{
l[ah]=ai;
delete l[ag];
}
}else{
var aj=l[ah];
if(!(aj===(void 0))||ah in l){
l[ag]=aj;
delete l[ah];
}
}
}
}
function PackedArrayReverse(l,O){
var ae=O-1;
for(var t=0;t<ae;t++,ae--){
var ai=l[t];
var aj=l[ae];
l[t]=aj;
l[ae]=ai;
}
return l;
}
function GenericArrayReverse(l,O){
var ae=O-1;
for(var t=0;t<ae;t++,ae--){
if(t in l){
var ai=l[t];
if(ae in l){
var aj=l[ae];
l[t]=aj;
l[ae]=ai;
}else{
l[ae]=ai;
delete l[t];
}
}else{
if(ae in l){
var aj=l[ae];
l[t]=aj;
delete l[ae];
}
}
}
return l;
}
%DefineMethodsInternal(d.prototype,class{reverse(){
var l=(%_ToObject(this));
var O=(%_ToLength(l.length));
var ak=(%_IsArray(l));
if(UseSparseVariant(l,O,ak,O)){
%NormalizeElements(l);
SparseReverse(l,O);
return l;
}else if(ak&&%_HasFastPackedElements(l)){
return PackedArrayReverse(l,O);
}else{
return GenericArrayReverse(l,O);
}
}},-1);
function ArrayShiftFallback(){
var l=(%_ToObject(this));
var O=(%_ToLength(l.length));
if(O===0){
l.length=0;
return;
}
var al=l[0];
if(UseSparseVariant(l,O,(%_IsArray(l)),O)){
SparseMove(l,0,1,O,0);
}else{
SimpleMove(l,0,1,O,0);
}
l.length=O-1;
return al;
}
function ArrayUnshiftFallback(am){
var l=(%_ToObject(this));
var O=(%_ToLength(l.length));
var an=arguments.length;
const new_len=O+an;
if(an>0){
if(new_len>=2**53)throw %make_type_error(178);
if(O>0&&UseSparseVariant(l,O,(%_IsArray(l)),O)&&
!%object_is_sealed(l)){
SparseMove(l,0,0,O,an);
}else{
SimpleMove(l,0,0,O,an);
}
for(var t=0;t<an;t++){
l[t]=arguments[t];
}
}
l.length=new_len;
return new_len;
}
function ArraySliceFallback(ao,ap){
return null;
}
function ComputeSpliceStartIndex(M,O){
if(M<0){
M+=O;
return M<0?0:M;
}
return M>O?O:M;
}
function ComputeSpliceDeleteCount(aq,an,O,M){
var N=0;
if(an==1)
return O-M;
N=(%_ToInteger(aq));
if(N<0)
return 0;
if(N>O-M)
return O-M;
return N;
}
function ArraySpliceFallback(ao,aq){
var an=arguments.length;
var l=(%_ToObject(this));
var O=(%_ToLength(l.length));
var M=ComputeSpliceStartIndex((%_ToInteger(ao)),O);
var N=ComputeSpliceDeleteCount(aq,an,O,
M);
var ar=an>2?an-2:0;
const new_len=O-N+ar;
if(new_len>=2**53)throw %make_type_error(178);
var P=ArraySpeciesCreate(l,N);
P.length=N;
var as=N;
if(ar!=N){
as+=O-M-N;
}
if(UseSparseVariant(l,O,(%_IsArray(l)),as)){
%NormalizeElements(l);
if((%_IsArray(P)))%NormalizeElements(P);
SparseSlice(l,M,N,O,P);
SparseMove(l,M,N,O,ar);
}else{
SimpleSlice(l,M,N,O,P);
SimpleMove(l,M,N,O,ar);
}
var t=M;
var at=2;
var au=arguments.length;
while(at<au){
l[t++]=arguments[at++];
}
l.length=new_len;
return P;
}
function InnerArraySort(l,m,av){
if(!(typeof(av)==='function')){
av=function(L,aw){
if(L===aw)return 0;
if(%_IsSmi(L)&&%_IsSmi(aw)){
return %SmiLexicographicCompare(L,aw);
}
L=(%_ToString(L));
aw=(%_ToString(aw));
if(L==aw)return 0;
else return L<aw?-1:1;
};
}
function InsertionSort(o,ax,ay){
for(var t=ax+1;t<ay;t++){
var az=o[t];
for(var ae=t-1;ae>=ax;ae--){
var aA=o[ae];
var aB=av(aA,az);
if(aB>0){
o[ae+1]=aA;
}else{
break;
}
}
o[ae+1]=az;
}
};
function GetThirdIndex(o,ax,ay){
var aC=new e();
var aD=200+((ay-ax)&15);
var ae=0;
ax+=1;
ay-=1;
for(var t=ax;t<ay;t+=aD){
aC[ae]=[t,o[t]];
ae++;
}
aC.sort(function(o,p){
return av(o[1],p[1]);
});
var aE=aC[aC.length>>1][0];
return aE;
}
function QuickSort(o,ax,ay){
var aE=0;
while(true){
if(ay-ax<=10){
InsertionSort(o,ax,ay);
return;
}
if(ay-ax>1000){
aE=GetThirdIndex(o,ax,ay);
}else{
aE=ax+((ay-ax)>>1);
}
var aF=o[ax];
var aG=o[ay-1];
var aH=o[aE];
var aI=av(aF,aG);
if(aI>0){
var aA=aF;
aF=aG;
aG=aA;
}
var aJ=av(aF,aH);
if(aJ>=0){
var aA=aF;
aF=aH;
aH=aG;
aG=aA;
}else{
var aK=av(aG,aH);
if(aK>0){
var aA=aG;
aG=aH;
aH=aA;
}
}
o[ax]=aF;
o[ay-1]=aH;
var aL=aG;
var aM=ax+1;
var aN=ay-1;
o[aE]=o[aM];
o[aM]=aL;
partition:for(var t=aM+1;t<aN;t++){
var az=o[t];
var aB=av(az,aL);
if(aB<0){
o[t]=o[aM];
o[aM]=az;
aM++;
}else if(aB>0){
do{
aN--;
if(aN==t)break partition;
var aO=o[aN];
aB=av(aO,aL);
}while(aB>0);
o[t]=o[aN];
o[aN]=az;
if(aB<0){
az=o[t];
o[t]=o[aM];
o[aM]=az;
aM++;
}
}
}
if(ay-aN<aM-ax){
QuickSort(o,aN,ay);
ay=aM;
}else{
QuickSort(o,ax,aM);
ax=aN;
}
}
};
if(m<2)return l;
var aP=%PrepareElementsForSort(l,m);
QuickSort(l,0,aP);
return l;
}
%DefineMethodsInternal(d.prototype,class{sort(av){
if(!(av===(void 0))&&!(typeof(av)==='function')){
throw %make_type_error(16,av);
}
var l=(%_ToObject(this));
var m=(%_ToLength(l.length));
return InnerArraySort(l,m,av);
}},-1);
%DefineMethodsInternal(d.prototype,class{lastIndexOf(az,W){
var l=(%_ToObject(this));
var m=(%_ToLength(this.length));
if(m==0)return-1;
if(arguments.length<2){
W=m-1;
}else{
W=(((%_ToInteger(W)))+0)
;
if(W<0)W+=m;
if(W<0)return-1;
else if(W>=m)W=m-1;
}
var aQ=0;
var aR=W;
if(UseSparseVariant(l,m,(%_IsArray(l)),W)){
%NormalizeElements(l);
var q=%GetArrayKeys(l,W+1);
if((typeof(q)==='number')){
aR=q;
}else{
if(q.length==0)return-1;
var aS=GetSortedArrayKeys(l,q);
var t=aS.length-1;
while(t>=0){
var x=aS[t];
if(l[x]===az)return x;
t--;
}
return-1;
}
}
if(!(az===(void 0))){
for(var t=aR;t>=aQ;t--){
if(l[t]===az)return t;
}
return-1;
}
for(var t=aR;t>=aQ;t--){
if((l[t]===(void 0))&&t in l){
return t;
}
}
return-1;
}},1);
%DefineMethodsInternal(d.prototype,class{copyWithin(target,ao,ap){
var l=(%_ToObject(this));
var m=(%_ToLength(l.length));
target=(%_ToInteger(target));
var ay;
if(target<0){
ay=f(m+target,0);
}else{
ay=g(target,m);
}
ao=(%_ToInteger(ao));
var ax;
if(ao<0){
ax=f(m+ao,0);
}else{
ax=g(ao,m);
}
ap=(ap===(void 0))?m:(%_ToInteger(ap));
var aT;
if(ap<0){
aT=f(m+ap,0);
}else{
aT=g(ap,m);
}
var aU=g(aT-ax,m-ay);
var aV=1;
if(ax<ay&&ay<(ax+aU)){
aV=-1;
ax=ax+aU-1;
ay=ay+aU-1;
}
while(aU>0){
if(ax in l){
l[ay]=l[ax];
}else{
delete l[ay];
}
ax=ax+aV;
ay=ay+aV;
aU--;
}
return l;
}},2);
%DefineMethodsInternal(d.prototype,class{fill(G,ao,ap){
var l=(%_ToObject(this));
var m=(%_ToLength(l.length));
var t=(ao===(void 0))?0:(%_ToInteger(ao));
var ap=(ap===(void 0))?m:(%_ToInteger(ap));
if(t<0){
t+=m;
if(t<0)t=0;
}else{
if(t>m)t=m;
}
if(ap<0){
ap+=m;
if(ap<0)ap=0;
}else{
if(ap>m)ap=m;
}
for(;t<ap;t++)
l[t]=G;
return l;
}},1);
var aW={
__proto__:null,
copyWithin:true,
entries:true,
fill:true,
find:true,
findIndex:true,
includes:true,
keys:true,
};
%ToFastProperties(aW);
%AddNamedProperty(d.prototype,k,aW,
2|1);
var aX=d.prototype.indexOf;
var Z=d.prototype.join;
var aY=d.prototype.pop;
var aZ=d.prototype.push;
var ba=d.prototype.slice;
var bb=d.prototype.shift;
var bc=d.prototype.sort;
var bd=d.prototype.splice;
var be=d.prototype.toString;
var bf=d.prototype.unshift;
var bg=d.prototype.entries;
var bh=d.prototype.forEach;
var bi=d.prototype.keys;
var bj=d.prototype[j];
b.SetUpLockedPrototype(e,d(),[
"indexOf",aX,
"join",Z,
"pop",aY,
"push",aZ,
"shift",bb,
"sort",bc,
"splice",bd
]);
b.SetUpLockedPrototype(c.InternalPackedArray,d(),[
"push",aZ,
"pop",aY,
"shift",bb,
"unshift",bf,
"splice",bd,
"slice",ba
]);
b.Export(function(ay){
ay.ArrayJoin=Z;
ay.ArrayPush=aZ;
ay.ArrayToString=be;
ay.ArrayValues=bj;
ay.InnerArrayJoin=InnerArrayJoin;
ay.InnerArrayToLocaleString=InnerArrayToLocaleString;
});
%InstallToContext([
"array_entries_iterator",bg,
"array_for_each_iterator",bh,
"array_keys_iterator",bi,
"array_values_iterator",bj,
"array_shift",ArrayShiftFallback,
"array_splice",ArraySpliceFallback,
"array_unshift",ArrayUnshiftFallback,
]);
});

(typedarray	
(function(a,b){
"use strict";
%CheckIsBootstrapping();
var c=b.ImportNow("ArrayToString");
var d;
var e;
var f=a.Uint8Array;

var g=a.Int8Array;

var h=a.Uint16Array;

var i=a.Int16Array;

var j=a.Uint32Array;

var k=a.Int32Array;

var l=a.Float32Array;

var m=a.Float64Array;

var n=a.Uint8ClampedArray;

var o=a.BigUint64Array;

var p=a.BigInt64Array;


var q=%object_get_prototype_of(f);
b.Import(function(r){
d=r.InnerArrayJoin;
e=r.InnerArrayToLocaleString;
});
function ValidateTypedArray(s,t){
if(!(%_IsTypedArray(s))
)throw %make_type_error(94);
if(%_ArrayBufferViewWasNeutered(s))
throw %make_type_error(48,t);
}
%DefineMethodsInternal(q.prototype,class{toLocaleString(){
ValidateTypedArray(this,"%TypedArray%.prototype.toLocaleString");
var u=arguments[0];
var v=arguments[1];
var w=%_TypedArrayGetLength(this);
return e(this,w,u,v);
}},-1);
%DefineMethodsInternal(q.prototype,class{join(separator){
ValidateTypedArray(this,"%TypedArray%.prototype.join");
var w=%_TypedArrayGetLength(this);
return d(separator,this,w);
}},-1);
%AddNamedProperty(q.prototype,"toString",c,
2);
})

intl2<6C>

(function(a,b){
"use strict";
%CheckIsBootstrapping();
var c;
var d;
var e=a.Date;
var f=a.Intl;
var g=f.DateTimeFormat;
var h=f.NumberFormat;
var i=f.Collator;
var j=f.PluralRules;
var k=f.v8BreakIterator;
var l=a.Number;
var m=a.RegExp;
var n=a.String;
var o=a.Array;
var p=b.ImportNow("intl_fallback_symbol");
var q=b.InternalArray;
var r=a.Math.max;
var s=a.Object.prototype.hasOwnProperty;
var t=a.Object.keys;
var u=b.ImportNow("intl_pattern_symbol");
var v=b.ImportNow("intl_resolved_symbol");
var w=n.prototype.substr;
var x=n.prototype.substring;
var y=o.prototype.slice;
b.Import(function(z){
c=z.ArrayJoin;
d=z.ArrayPush;
});
function AddBoundMethod(obj,methodName,implementation,length,type,
compat){
%CheckIsBootstrapping();
var A=%CreatePrivateSymbol(methodName);
%DefineMethodsInternal(obj.prototype,class{get[methodName](){
if(!(%_IsJSReceiver(this))){
throw %make_type_error(59,methodName,this);
}
var B=%IntlUnwrapReceiver(this,type,obj,methodName,compat);
if((B[A]===(void 0))){
var C;
if((length===(void 0))||length===2){
C=
(0,((fst,snd)=>implementation(B,fst,snd)))
;
}else if(length===1){
C=(0,(fst=>implementation(B,fst)))
;
}else{
C=(0,((...args)=>{
if(args.length>0){
return implementation(B,args[0]);
}else{
return implementation(B);
}
}))
;
}
%SetNativeFlag(C);
B[A]=C;
}
return B[A];
}},-1);
}
function IntlConstruct(B,constructor,create,newTarget,args,
compat){
var D=args[0];
var E=args[1];
var F=create(D,E);
if(compat&&(newTarget===(void 0))&&B instanceof constructor){
%object_define_property(B,p,{value:F});
return B;
}
return F;
}
var G={
__proto__:null,
'collator':(void 0),
'numberformat':(void 0),
'dateformat':(void 0),
'breakiterator':(void 0),
'pluralrules':(void 0),
'relativetimeformat':(void 0),
};
var H=(void 0);
function GetDefaultICULocaleJS(){
if((H===(void 0))){
H=%GetDefaultICULocale();
}
return H;
}
var I=(void 0);
function GetUnicodeExtensionRE(){
if(((void 0)===(void 0))){
I=new m('-u(-[a-z0-9]{2,8})+','g');
}
return I;
}
var J=(void 0);
function GetAnyExtensionRE(){
if((J===(void 0))){
J=new m('-[a-z0-9]{1}-.*','g');
}
return J;
}
var K=(void 0);
function GetQuotedStringRE(){
if((K===(void 0))){
K=new m("'[^']+'",'g');
}
return K;
}
var L=(void 0);
function GetServiceRE(){
if((L===(void 0))){
L=
new m('^('+%_Call(c,t(G),'|')+')$');
}
return L;
}
var M=(void 0);
function GetLanguageTagRE(){
if((M===(void 0))){
BuildLanguageTagREs();
}
return M;
}
var N=(void 0);
function GetLanguageVariantRE(){
if((N===(void 0))){
BuildLanguageTagREs();
}
return N;
}
var O=(void 0);
function GetLanguageSingletonRE(){
if((O===(void 0))){
BuildLanguageTagREs();
}
return O;
}
var P=(void 0);
function GetTimezoneNameCheckRE(){
if((P===(void 0))){
P=new m(
'^([A-Za-z]+)/([A-Za-z_-]+)((?:\/[A-Za-z_-]+)+)*$');
}
return P;
}
var Q=(void 0);
function GetTimezoneNameLocationPartRE(){
if((Q===(void 0))){
Q=
new m('^([A-Za-z]+)((?:[_-][A-Za-z]+)+)*$');
}
return Q;
}
function supportedLocalesOf(R,D,E){
if((%regexp_internal_match(GetServiceRE(),R)===null)){
throw %make_error(8,R);
}
if((E===(void 0))){
E={__proto__:null};
}else{
E=(%_ToObject(E));
}
var S=E.localeMatcher;
if(!(S===(void 0))){
S=(%_ToString(S));
if(S!=='lookup'&&S!=='best fit'){
throw %make_range_error(197,S);
}
}else{
S='best fit';
}
var T=initializeLocaleList(D);
var U=getAvailableLocalesOf(R);
if(S==='best fit'){
return initializeLocaleList(bestFitSupportedLocalesOf(
T,U));
}
return initializeLocaleList(lookupSupportedLocalesOf(
T,U));
}
function lookupSupportedLocalesOf(T,U){
var V=new q();
for(var W=0;W<T.length;++W){
var X=%RegExpInternalReplace(
GetUnicodeExtensionRE(),T[W],'');
do{
if(!(U[X]===(void 0))){
%_Call(d,V,T[W]);
break;
}
var Y=%StringLastIndexOf(X,'-');
if(Y===-1){
break;
}
X=%_Call(x,X,0,Y);
}while(true);
}
return V;
}
function bestFitSupportedLocalesOf(T,U){
return lookupSupportedLocalesOf(T,U);
}
function getGetOption(E,Z){
if((E===(void 0)))throw %make_error(4,Z);
var aa=function(ab,ac,ad,ae){
var af=E[ab];
if(!(af===(void 0))){
switch(ac){
case'boolean':
af=(!!(af));
break;
case'string':
af=(%_ToString(af));
break;
default:
throw %make_error(9);
}
if(!(ad===(void 0))&&%ArrayIndexOf(ad,af,0)===-1){
throw %make_range_error(210,af,Z,ab);
}
return af;
}
return ae;
}
return aa;
}
function resolveLocale(R,T,E){
T=initializeLocaleList(T);
var aa=getGetOption(E,R);
var S=aa('localeMatcher','string',
['lookup','best fit'],'best fit');
var ag;
if(S==='lookup'){
ag=lookupMatcher(R,T);
}else{
ag=bestFitMatcher(R,T);
}
return ag;
}
%InstallToContext([
"resolve_locale",resolveLocale
]);
function bestAvailableLocale(U,X){
do{
if(!(U[X]===(void 0))){
return X;
}
var Y=%StringLastIndexOf(X,'-');
if(Y===-1){
break;
}
X=%_Call(x,X,0,Y);
}while(true);
return(void 0);
}
function attemptSingleLookup(U,ah){
var ai=%RegExpInternalReplace(
GetAnyExtensionRE(),ah,'');
var aj=bestAvailableLocale(
U,ah);
if(!(aj===(void 0))){
var ak=%regexp_internal_match(
GetUnicodeExtensionRE(),ah);
var al=(ak===null)?'':ak[0];
return{__proto__:null,locale:aj,extension:al};
}
return(void 0);
}
function lookupMatcher(R,T){
if((%regexp_internal_match(GetServiceRE(),R)===null)){
throw %make_error(8,R);
}
var U=getAvailableLocalesOf(R);
for(var W=0;W<T.length;++W){
var am=attemptSingleLookup(U,T[W]);
if(!(am===(void 0))){
return am;
}
}
var an=GetDefaultICULocaleJS();
var am=attemptSingleLookup(U,an);
if(!(am===(void 0))){
return am;
}
return{
__proto__:null,
locale:'und',
extension:''
};
}
function bestFitMatcher(R,T){
return lookupMatcher(R,T);
}
function parseExtension(al){
var ao=%StringSplit(al,'-',4294967295);
if(ao.length<=2||
(ao[0]!==''&&ao[1]!=='u')){
return{__proto__:null};
}
var ap={__proto__:null};
var aq=(void 0);
var af=(void 0);
for(var W=2;W<ao.length;++W){
var ar=ao[W].length;
var as=ao[W];
if(ar===2){
if(!(aq===(void 0))){
if(!(aq in ap)){
ap[aq]=af;
}
af=(void 0);
}
aq=as;
}else if(ar>=3&&ar<=8&&!(aq===(void 0))){
if((af===(void 0))){
af=as;
}else{
af=af+"-"+as;
}
}else{
return{__proto__:null};
}
}
if(!(aq===(void 0))&&!(aq in ap)){
ap[aq]=af;
}
return ap;
}
function setOptions(at,ap,au,aa,av){
var al='';
var aw=function updateExtension(aq,af){
return'-'+aq+'-'+(%_ToString(af));
}
var ax=function updateProperty(ab,ac,af){
if(ac==='boolean'&&(typeof af==='string')){
af=(af==='true')?true:false;
}
if(!(ab===(void 0))){
defineWEProperty(av,ab,af);
}
}
for(var aq in au){
if((%_Call(s,au,aq))){
var af=(void 0);
var ay=au[aq];
if(!(ay.property===(void 0))){
af=aa(ay.property,ay.type,ay.values);
}
if(!(af===(void 0))){
ax(ay.property,ay.type,af);
al+=aw(aq,af);
continue;
}
if((%_Call(s,ap,aq))){
af=ap[aq];
if(!(af===(void 0))){
ax(ay.property,ay.type,af);
al+=aw(aq,af);
}else if(ay.type==='boolean'){
ax(ay.property,ay.type,true);
al+=aw(aq,true);
}
}
}
}
return al===''?'':'-u'+al;
}
function freezeArray(az){
var aA=[];
var aB=az.length;
for(var W=0;W<aB;W++){
if(W in az){
%object_define_property(aA,W,{value:az[W],
configurable:false,
writable:false,
enumerable:true});
}
}
%object_define_property(aA,'length',{value:aB,writable:false});
return aA;
}
function makeArray(az){
var aA=[];
%MoveArrayContents(az,aA);
return aA;
}
function getAvailableLocalesOf(R){
if(!(G[R]===(void 0))){
return G[R];
}
var aC=%AvailableLocalesOf(R);
for(var W in aC){
if((%_Call(s,aC,W))){
var aD=%regexp_internal_match(
/^([a-z]{2,3})-([A-Z][a-z]{3})-([A-Z]{2})$/,W);
if(!(aD===null)){
aC[aD[1]+'-'+aD[3]]=null;
}
}
}
G[R]=aC;
return aC;
}
function defineWEProperty(aE,ab,af){
%object_define_property(aE,ab,
{value:af,writable:true,enumerable:true});
}
function addWEPropertyIfDefined(aE,ab,af){
if(!(af===(void 0))){
defineWEProperty(aE,ab,af);
}
}
function defineWECProperty(aE,ab,af){
%object_define_property(aE,ab,{value:af,
writable:true,
enumerable:true,
configurable:true});
}
function addWECPropertyIfDefined(aE,ab,af){
if(!(af===(void 0))){
defineWECProperty(aE,ab,af);
}
}
function toTitleCaseWord(aF){
return %StringToUpperCaseIntl(%_Call(w,aF,0,1))+
%StringToLowerCaseIntl(%_Call(w,aF,1));
}
function toTitleCaseTimezoneLocation(aG){
var aH=%regexp_internal_match(GetTimezoneNameLocationPartRE(),aG)
if((aH===null))throw %make_range_error(175,aG);
var am=toTitleCaseWord(aH[1]);
if(!(aH[2]===(void 0))&&2<aH.length){
var aI=%_Call(x,aH[2],0,1);
var aD=%StringSplit(aH[2],aI,4294967295);
for(var W=1;W<aD.length;W++){
var aJ=aD[W]
var aK=%StringToLowerCaseIntl(aJ);
am=am+aI+
((aK!=='es'&&
aK!=='of'&&aK!=='au')?
toTitleCaseWord(aJ):aK);
}
}
return am;
}
function canonicalizeLanguageTag(aL){
if((!(typeof(aL)==='string')&&!(%_IsJSReceiver(aL)))||
(aL===null)){
throw %make_type_error(68);
}
var aM=(%_ToString(aL));
if((!(%regexp_internal_match(/^[a-z]{2}$/,aM)===null)&&
(%regexp_internal_match(/^(in|iw|ji|jw)$/,aM)===null))||
aM==="fil"){
return aM;
}
if(isStructuallyValidLanguageTag(aM)===false){
throw %make_range_error(188,aM);
}
var aN=%CanonicalizeLanguageTag(aM);
if(aN==='invalid-tag'){
throw %make_range_error(188,aM);
}
return aN;
}
function canonicalizeLocaleList(D){
var aO=new q();
if(!(D===(void 0))){
if(typeof D==='string'){
%_Call(d,aO,canonicalizeLanguageTag(D));
return aO;
}
var aP=(%_ToObject(D));
var aQ=(%_ToLength(aP.length));
for(var aR=0;aR<aQ;aR++){
if(aR in aP){
var af=aP[aR];
var aN=canonicalizeLanguageTag(af);
if(%ArrayIndexOf(aO,aN,0)===-1){
%_Call(d,aO,aN);
}
}
}
}
return aO;
}
function initializeLocaleList(D){
return freezeArray(canonicalizeLocaleList(D));
}
function isStructuallyValidLanguageTag(X){
if((%regexp_internal_match(GetLanguageTagRE(),X)===null)){
return false;
}
X=%StringToLowerCaseIntl(X);
if(%StringIndexOf(X,'x-',0)===0){
return true;
}
X=%StringSplit(X,'-x-',4294967295)[0];
var aS=new q();
var aT=new q();
var aD=%StringSplit(X,'-',4294967295);
for(var W=1;W<aD.length;W++){
var af=aD[W];
if(!(%regexp_internal_match(GetLanguageVariantRE(),af)===null)&&
aT.length===0){
if(%ArrayIndexOf(aS,af,0)===-1){
%_Call(d,aS,af);
}else{
return false;
}
}
if(!(%regexp_internal_match(GetLanguageSingletonRE(),af)===null)){
if(%ArrayIndexOf(aT,af,0)===-1){
%_Call(d,aT,af);
}else{
return false;
}
}
}
return true;
}
function BuildLanguageTagREs(){
var aU='[a-zA-Z]';
var aV='[0-9]';
var aW='('+aU+'|'+aV+')';
var aX='(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|'+
'zh-min|zh-min-nan|zh-xiang)';
var aY='(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|'+
'i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|'+
'i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)';
var aZ='('+aY+'|'+aX+')';
var ba='(x(-'+aW+'{1,8})+)';
var bb='('+aV+'|[A-WY-Za-wy-z])';
O=new m('^'+bb+'$','i');
var al='('+bb+'(-'+aW+'{2,8})+)';
var bc='('+aW+'{5,8}|('+aV+aW+'{3}))';
N=new m('^'+bc+'$','i');
var bd='('+aU+'{2}|'+aV+'{3})';
var be='('+aU+'{4})';
var bf='('+aU+'{3}(-'+aU+'{3}){0,2})';
var bg='('+aU+'{2,3}(-'+bf+')?|'+aU+'{4}|'+
aU+'{5,8})';
var bh=bg+'(-'+be+')?(-'+bd+')?(-'+
bc+')*(-'+al+')*(-'+ba+')?';
var bi=
'^('+bh+'|'+ba+'|'+aZ+')$';
M=new m(bi,'i');
}
%DefineMethodsInternal(f,class{getCanonicalLocales(D){
return makeArray(canonicalizeLocaleList(D));
}},-1);
function CreateCollator(D,E){
if((E===(void 0))){
E={__proto__:null};
}
var aa=getGetOption(E,'collator');
var bj={__proto__:null};
defineWEProperty(bj,'usage',aa(
'usage','string',['sort','search'],'sort'));
var bk=aa('sensitivity','string',
['base','accent','case','variant']);
if((bk===(void 0))&&bj.usage==='sort'){
bk='variant';
}
defineWEProperty(bj,'sensitivity',bk);
defineWEProperty(bj,'ignorePunctuation',aa(
'ignorePunctuation','boolean',(void 0),false));
var X=resolveLocale('collator',D,E);
var ap=parseExtension(X.extension);
var bl={
__proto__:null,
'kn':{__proto__:null,'property':'numeric','type':'boolean'},
'kf':{__proto__:null,'property':'caseFirst','type':'string',
'values':['false','lower','upper']}
};
setOptions(
E,ap,bl,aa,bj);
var bm='default';
var al='';
if((%_Call(s,ap,'co'))&&bj.usage==='sort'){
var bn=[
'big5han','dict','direct','ducet','gb2312','phonebk','phonetic',
'pinyin','reformed','searchjl','stroke','trad','unihan','zhuyin'
];
if(%ArrayIndexOf(bn,ap.co,0)!==-1){
al='-u-co-'+ap.co;
bm=ap.co;
}
}else if(bj.usage==='search'){
al='-u-co-search';
}
defineWEProperty(bj,'collation',bm);
var ah=X.locale+al;
var ag=%object_define_properties({__proto__:null},{
caseFirst:{writable:true},
collation:{value:bj.collation,writable:true},
ignorePunctuation:{writable:true},
locale:{writable:true},
numeric:{writable:true},
requestedLocale:{value:ah,writable:true},
sensitivity:{writable:true},
strength:{writable:true},
usage:{value:bj.usage,writable:true}
});
var bo=%CreateCollator(ah,bj,ag);
%MarkAsInitializedIntlObjectOfType(bo,1);
bo[v]=ag;
return bo;
}
function CollatorConstructor(){
return IntlConstruct(this,i,CreateCollator,new.target,
arguments);
}
%SetCode(i,CollatorConstructor);
%DefineMethodsInternal(i.prototype,class{resolvedOptions(){
var bp='resolvedOptions';
if(!(%_IsJSReceiver(this))){
throw %make_type_error(59,bp,this);
}
var bq=%IntlUnwrapReceiver(this,1,i,
bp,false);
return{
locale:bq[v].locale,
usage:bq[v].usage,
sensitivity:bq[v].sensitivity,
ignorePunctuation:bq[v].ignorePunctuation,
numeric:bq[v].numeric,
caseFirst:bq[v].caseFirst,
collation:bq[v].collation
};
}},-1);
%DefineMethodsInternal(i,class{supportedLocalesOf(D){
return supportedLocalesOf('collator',D,arguments[1]);
}},-1);
function compare(bo,br,bs){
return %InternalCompare(bo,(%_ToString(br)),(%_ToString(bs)));
};
AddBoundMethod(i,'compare',compare,2,1,false);
function PluralRulesConstructor(){
if((new.target===(void 0))){
throw %make_type_error(38,"PluralRules");
}
var D=arguments[0];
var E=arguments[1];
if((E===(void 0))){
E={__proto__:null};
}
var aa=getGetOption(E,'pluralrules');
var X=resolveLocale('pluralrules',D,E);
var bj={__proto__:null};
defineWEProperty(bj,'type',aa(
'type','string',['cardinal','ordinal'],'cardinal'));
SetNumberFormatDigitOptions(bj,E,0,3);
var ah=X.locale;
var ag=%object_define_properties({__proto__:null},{
type:{value:bj.type,writable:true},
locale:{writable:true},
maximumFractionDigits:{writable:true},
minimumFractionDigits:{writable:true},
minimumIntegerDigits:{writable:true},
requestedLocale:{value:ah,writable:true},
});
if((%_Call(s,bj,'minimumSignificantDigits'))){
defineWEProperty(ag,'minimumSignificantDigits',(void 0));
}
if((%_Call(s,bj,'maximumSignificantDigits'))){
defineWEProperty(ag,'maximumSignificantDigits',(void 0));
}
defineWEProperty(ag,'pluralCategories',[]);
var bt=%CreatePluralRules(ah,bj,
ag);
%MarkAsInitializedIntlObjectOfType(bt,3);
bt[v]=ag;
return bt;
}
%SetCode(j,PluralRulesConstructor);
%DefineMethodsInternal(j.prototype,class{resolvedOptions(){
if(!%IsInitializedIntlObjectOfType(this,3)){
throw %make_type_error(59,
'Intl.PluralRules.prototype.resolvedOptions',
this);
}
var am={
locale:this[v].locale,
type:this[v].type,
minimumIntegerDigits:this[v].minimumIntegerDigits,
minimumFractionDigits:this[v].minimumFractionDigits,
maximumFractionDigits:this[v].maximumFractionDigits,
};
if((%_Call(s,this[v],'minimumSignificantDigits'))){
defineWECProperty(am,'minimumSignificantDigits',
this[v].minimumSignificantDigits);
}
if((%_Call(s,this[v],'maximumSignificantDigits'))){
defineWECProperty(am,'maximumSignificantDigits',
this[v].maximumSignificantDigits);
}
defineWECProperty(am,'pluralCategories',
%_Call(y,this[v].pluralCategories));
return am;
}},-1);
%DefineMethodsInternal(j,class{supportedLocalesOf(D){
return supportedLocalesOf('pluralrules',D,arguments[1]);
}},-1);
%DefineMethodsInternal(j.prototype,class{select(af){
if(!%IsInitializedIntlObjectOfType(this,3)){
throw %make_type_error(59,
'Intl.PluralRules.prototype.select',
this);
}
return %PluralRulesSelect(this,(%_ToNumber(af))+0);
}},-1);
function isWellFormedCurrencyCode(bu){
return typeof bu==="string"&&bu.length===3&&
(%regexp_internal_match(/[^A-Za-z]/,bu)===null);
}
function defaultNumberOption(af,bv,bw,ae,ab){
if(!(af===(void 0))){
af=(%_ToNumber(af));
if((%IS_VAR(af)!==af)
||af<bv||af>bw){
throw %make_range_error(203,ab);
}
return %math_floor(af);
}
return ae;
}
function getNumberOption(E,ab,bv,bw,ae){
var af=E[ab];
return defaultNumberOption(af,bv,bw,ae,ab);
}
function SetNumberFormatDigitOptions(bj,E,
mnfdDefault,mxfdDefault){
var bx=getNumberOption(E,'minimumIntegerDigits',1,21,1);
defineWEProperty(bj,'minimumIntegerDigits',bx);
var by=getNumberOption(E,'minimumFractionDigits',0,20,
mnfdDefault);
defineWEProperty(bj,'minimumFractionDigits',by);
var bz=r(by,mxfdDefault);
var bA=getNumberOption(E,'maximumFractionDigits',by,20,
bz);
defineWEProperty(bj,'maximumFractionDigits',bA);
var bB=E['minimumSignificantDigits'];
var bC=E['maximumSignificantDigits'];
if(!(bB===(void 0))||!(bC===(void 0))){
bB=defaultNumberOption(bB,1,21,1,'minimumSignificantDigits');
defineWEProperty(bj,'minimumSignificantDigits',bB);
bC=defaultNumberOption(bC,bB,21,21,'maximumSignificantDigits');
defineWEProperty(bj,'maximumSignificantDigits',bC);
}
}
function CreateNumberFormat(D,E){
if((E===(void 0))){
E={__proto__:null};
}
var aa=getGetOption(E,'numberformat');
var X=resolveLocale('numberformat',D,E);
var bj={__proto__:null};
defineWEProperty(bj,'style',aa(
'style','string',['decimal','percent','currency'],'decimal'));
var bu=aa('currency','string');
if(!(bu===(void 0))&&!isWellFormedCurrencyCode(bu)){
throw %make_range_error(182,bu);
}
if(bj.style==='currency'&&(bu===(void 0))){
throw %make_type_error(40);
}
var bD,bE;
var bF=aa(
'currencyDisplay','string',['code','symbol','name'],'symbol');
if(bj.style==='currency'){
defineWEProperty(bj,'currency',%StringToUpperCaseIntl(bu));
defineWEProperty(bj,'currencyDisplay',bF);
bD=bE=%CurrencyDigits(bj.currency);
}else{
bD=0;
bE=bj.style==='percent'?0:3;
}
SetNumberFormatDigitOptions(bj,E,bD,
bE);
defineWEProperty(bj,'useGrouping',aa(
'useGrouping','boolean',(void 0),true));
var ap=parseExtension(X.extension);
var bG={
__proto__:null,
'nu':{__proto__:null,'property':(void 0),'type':'string'}
};
var al=setOptions(E,ap,bG,
aa,bj);
var ah=X.locale+al;
var ag=%object_define_properties({__proto__:null},{
currency:{writable:true},
currencyDisplay:{writable:true},
locale:{writable:true},
maximumFractionDigits:{writable:true},
minimumFractionDigits:{writable:true},
minimumIntegerDigits:{writable:true},
numberingSystem:{writable:true},
requestedLocale:{value:ah,writable:true},
style:{value:bj.style,writable:true},
useGrouping:{writable:true}
});
if((%_Call(s,bj,'minimumSignificantDigits'))){
defineWEProperty(ag,'minimumSignificantDigits',(void 0));
}
if((%_Call(s,bj,'maximumSignificantDigits'))){
defineWEProperty(ag,'maximumSignificantDigits',(void 0));
}
var bH=%CreateNumberFormat(ah,bj,
ag);
if(bj.style==='currency'){
%object_define_property(ag,'currencyDisplay',
{value:bF,writable:true});
}
%MarkAsInitializedIntlObjectOfType(bH,0);
bH[v]=ag;
return bH;
}
function NumberFormatConstructor(){
return IntlConstruct(this,h,CreateNumberFormat,
new.target,arguments,true);
}
%SetCode(h,NumberFormatConstructor);
%DefineMethodsInternal(h.prototype,class{resolvedOptions(){
var bp='resolvedOptions';
if(!(%_IsJSReceiver(this))){
throw %make_type_error(59,bp,this);
}
var bI=%IntlUnwrapReceiver(this,0,
h,
bp,true);
var am={
locale:bI[v].locale,
numberingSystem:bI[v].numberingSystem,
style:bI[v].style,
useGrouping:bI[v].useGrouping,
minimumIntegerDigits:bI[v].minimumIntegerDigits,
minimumFractionDigits:bI[v].minimumFractionDigits,
maximumFractionDigits:bI[v].maximumFractionDigits,
};
if(am.style==='currency'){
defineWECProperty(am,'currency',bI[v].currency);
defineWECProperty(am,'currencyDisplay',
bI[v].currencyDisplay);
}
if((%_Call(s,bI[v],'minimumSignificantDigits'))){
defineWECProperty(am,'minimumSignificantDigits',
bI[v].minimumSignificantDigits);
}
if((%_Call(s,bI[v],'maximumSignificantDigits'))){
defineWECProperty(am,'maximumSignificantDigits',
bI[v].maximumSignificantDigits);
}
return am;
}},-1);
%DefineMethodsInternal(h,class{supportedLocalesOf(D){
return supportedLocalesOf('numberformat',D,arguments[1]);
}},-1);
function formatNumber(bJ,af){
var bK=(%_ToNumber(af))+0;
return %InternalNumberFormat(bJ,bK);
}
function toLDMLString(E){
var aa=getGetOption(E,'dateformat');
var bL='';
var bM=aa('weekday','string',['narrow','short','long']);
bL+=appendToLDMLString(
bM,{narrow:'EEEEE',short:'EEE',long:'EEEE'});
bM=aa('era','string',['narrow','short','long']);
bL+=appendToLDMLString(
bM,{narrow:'GGGGG',short:'GGG',long:'GGGG'});
bM=aa('year','string',['2-digit','numeric']);
bL+=appendToLDMLString(bM,{'2-digit':'yy','numeric':'y'});
bM=aa('month','string',
['2-digit','numeric','narrow','short','long']);
bL+=appendToLDMLString(bM,{'2-digit':'MM','numeric':'M',
'narrow':'MMMMM','short':'MMM','long':'MMMM'});
bM=aa('day','string',['2-digit','numeric']);
bL+=appendToLDMLString(
bM,{'2-digit':'dd','numeric':'d'});
var bN=aa('hour12','boolean');
bM=aa('hour','string',['2-digit','numeric']);
if((bN===(void 0))){
bL+=appendToLDMLString(bM,{'2-digit':'jj','numeric':'j'});
}else if(bN===true){
bL+=appendToLDMLString(bM,{'2-digit':'hh','numeric':'h'});
}else{
bL+=appendToLDMLString(bM,{'2-digit':'HH','numeric':'H'});
}
bM=aa('minute','string',['2-digit','numeric']);
bL+=appendToLDMLString(bM,{'2-digit':'mm','numeric':'m'});
bM=aa('second','string',['2-digit','numeric']);
bL+=appendToLDMLString(bM,{'2-digit':'ss','numeric':'s'});
bM=aa('timeZoneName','string',['short','long']);
bL+=appendToLDMLString(bM,{short:'z',long:'zzzz'});
return bL;
}
function appendToLDMLString(bM,bO){
if(!(bM===(void 0))){
return bO[bM];
}else{
return'';
}
}
function fromLDMLString(bL){
bL=%RegExpInternalReplace(GetQuotedStringRE(),bL,'');
var E={__proto__:null};
var aH=%regexp_internal_match(/E{3,5}/,bL);
E=appendToDateTimeObject(
E,'weekday',aH,{EEEEE:'narrow',EEE:'short',EEEE:'long'});
aH=%regexp_internal_match(/G{3,5}/,bL);
E=appendToDateTimeObject(
E,'era',aH,{GGGGG:'narrow',GGG:'short',GGGG:'long'});
aH=%regexp_internal_match(/y{1,2}/,bL);
E=appendToDateTimeObject(
E,'year',aH,{y:'numeric',yy:'2-digit'});
aH=%regexp_internal_match(/M{1,5}/,bL);
E=appendToDateTimeObject(E,'month',aH,{MM:'2-digit',
M:'numeric',MMMMM:'narrow',MMM:'short',MMMM:'long'});
aH=%regexp_internal_match(/L{1,5}/,bL);
E=appendToDateTimeObject(E,'month',aH,{LL:'2-digit',
L:'numeric',LLLLL:'narrow',LLL:'short',LLLL:'long'});
aH=%regexp_internal_match(/d{1,2}/,bL);
E=appendToDateTimeObject(
E,'day',aH,{d:'numeric',dd:'2-digit'});
aH=%regexp_internal_match(/h{1,2}/,bL);
if(aH!==null){
E['hour12']=true;
}
E=appendToDateTimeObject(
E,'hour',aH,{h:'numeric',hh:'2-digit'});
aH=%regexp_internal_match(/H{1,2}/,bL);
if(aH!==null){
E['hour12']=false;
}
E=appendToDateTimeObject(
E,'hour',aH,{H:'numeric',HH:'2-digit'});
aH=%regexp_internal_match(/m{1,2}/,bL);
E=appendToDateTimeObject(
E,'minute',aH,{m:'numeric',mm:'2-digit'});
aH=%regexp_internal_match(/s{1,2}/,bL);
E=appendToDateTimeObject(
E,'second',aH,{s:'numeric',ss:'2-digit'});
aH=%regexp_internal_match(/z|zzzz/,bL);
E=appendToDateTimeObject(
E,'timeZoneName',aH,{z:'short',zzzz:'long'});
return E;
}
function appendToDateTimeObject(E,bM,aH,bO){
if((aH===null)){
if(!(%_Call(s,E,bM))){
defineWEProperty(E,bM,(void 0));
}
return E;
}
var ab=aH[0];
defineWEProperty(E,bM,bO[ab]);
return E;
}
function toDateTimeOptions(E,bP,bQ){
if((E===(void 0))){
E={__proto__:null};
}else{
E=(%_ToObject(E));
}
E=%object_create(E);
var bR=true;
if((bP==='date'||bP==='any')&&
(!(E.weekday===(void 0))||!(E.year===(void 0))||
!(E.month===(void 0))||!(E.day===(void 0)))){
bR=false;
}
if((bP==='time'||bP==='any')&&
(!(E.hour===(void 0))||!(E.minute===(void 0))||
!(E.second===(void 0)))){
bR=false;
}
if(bR&&(bQ==='date'||bQ==='all')){
%object_define_property(E,'year',{value:'numeric',
writable:true,
enumerable:true,
configurable:true});
%object_define_property(E,'month',{value:'numeric',
writable:true,
enumerable:true,
configurable:true});
%object_define_property(E,'day',{value:'numeric',
writable:true,
enumerable:true,
configurable:true});
}
if(bR&&(bQ==='time'||bQ==='all')){
%object_define_property(E,'hour',{value:'numeric',
writable:true,
enumerable:true,
configurable:true});
%object_define_property(E,'minute',{value:'numeric',
writable:true,
enumerable:true,
configurable:true});
%object_define_property(E,'second',{value:'numeric',
writable:true,
enumerable:true,
configurable:true});
}
return E;
}
function CreateDateTimeFormat(D,E){
if((E===(void 0))){
E={__proto__:null};
}
var X=resolveLocale('dateformat',D,E);
E=toDateTimeOptions(E,'any','date');
var aa=getGetOption(E,'dateformat');
var S=aa('formatMatcher','string',
['basic','best fit'],'best fit');
var bL=toLDMLString(E);
var bS=canonicalizeTimeZoneID(E.timeZone);
var bj={__proto__:null};
var ap=parseExtension(X.extension);
var bT={
__proto__:null,
'ca':{__proto__:null,'property':(void 0),'type':'string'},
'nu':{__proto__:null,'property':(void 0),'type':'string'}
};
var al=setOptions(E,ap,bT,
aa,bj);
var ah=X.locale+al;
var ag=%object_define_properties({__proto__:null},{
calendar:{writable:true},
day:{writable:true},
era:{writable:true},
hour12:{writable:true},
hour:{writable:true},
locale:{writable:true},
minute:{writable:true},
month:{writable:true},
numberingSystem:{writable:true},
[u]:{writable:true},
requestedLocale:{value:ah,writable:true},
second:{writable:true},
timeZone:{writable:true},
timeZoneName:{writable:true},
tz:{value:bS,writable:true},
weekday:{writable:true},
year:{writable:true}
});
var bU=%CreateDateTimeFormat(
ah,
{__proto__:null,skeleton:bL,timeZone:bS},ag);
if(ag.timeZone==="Etc/Unknown"){
throw %make_range_error(209,bS);
}
%MarkAsInitializedIntlObjectOfType(bU,2);
bU[v]=ag;
return bU;
}
function DateTimeFormatConstructor(){
return IntlConstruct(this,g,CreateDateTimeFormat,
new.target,arguments,true);
}
%SetCode(g,DateTimeFormatConstructor);
%DefineMethodsInternal(g.prototype,class{resolvedOptions(){
var bp='resolvedOptions';
if(!(%_IsJSReceiver(this))){
throw %make_type_error(59,bp,this);
}
var bI=%IntlUnwrapReceiver(this,2,
g,
bp,true);
var bV={
__proto__:null,
'gregorian':'gregory',
'ethiopic-amete-alem':'ethioaa'
};
var bW=fromLDMLString(bI[v][u]);
var bX=bV[bI[v].calendar];
if((bX===(void 0))){
bX=bI[v].calendar;
}
var am={
locale:bI[v].locale,
numberingSystem:bI[v].numberingSystem,
calendar:bX,
timeZone:bI[v].timeZone
};
addWECPropertyIfDefined(am,'timeZoneName',bW.timeZoneName);
addWECPropertyIfDefined(am,'era',bW.era);
addWECPropertyIfDefined(am,'year',bW.year);
addWECPropertyIfDefined(am,'month',bW.month);
addWECPropertyIfDefined(am,'day',bW.day);
addWECPropertyIfDefined(am,'weekday',bW.weekday);
addWECPropertyIfDefined(am,'hour12',bW.hour12);
addWECPropertyIfDefined(am,'hour',bW.hour);
addWECPropertyIfDefined(am,'minute',bW.minute);
addWECPropertyIfDefined(am,'second',bW.second);
return am;
}},-1);
%DefineMethodsInternal(g,class{supportedLocalesOf(D){
return supportedLocalesOf('dateformat',D,arguments[1]);
}},-1);
function formatDate(bJ,bY){
var bZ;
if((bY===(void 0))){
bZ=%DateCurrentTime();
}else{
bZ=(%_ToNumber(bY));
}
return %InternalDateFormat(bJ,bZ);
}
AddBoundMethod(g,'format',formatDate,1,2,
true);
function canonicalizeTimeZoneID(ca){
if((ca===(void 0))){
return ca;
}
ca=(%_ToString(ca));
var cb=%StringToUpperCaseIntl(ca);
if(cb==='UTC'||cb==='GMT'||
cb==='ETC/UTC'||cb==='ETC/GMT'){
return'UTC';
}
var aH=%regexp_internal_match(GetTimezoneNameCheckRE(),ca);
if((aH===null))throw %make_range_error(174,ca);
var am=toTitleCaseTimezoneLocation(aH[1])+'/'+
toTitleCaseTimezoneLocation(aH[2]);
if(!(aH[3]===(void 0))&&3<aH.length){
var cc=%StringSplit(aH[3],'/',4294967295);
for(var W=1;W<cc.length;W++){
am=am+'/'+toTitleCaseTimezoneLocation(cc[W]);
}
}
return am;
}
function CreateBreakIterator(D,E){
if((E===(void 0))){
E={__proto__:null};
}
var aa=getGetOption(E,'breakiterator');
var bj={__proto__:null};
defineWEProperty(bj,'type',aa(
'type','string',['character','word','sentence','line'],'word'));
var X=resolveLocale('breakiterator',D,E);
var ag=%object_define_properties({__proto__:null},{
requestedLocale:{value:X.locale,writable:true},
type:{value:bj.type,writable:true},
locale:{writable:true}
});
var cd=%CreateBreakIterator(X.locale,bj,ag);
%MarkAsInitializedIntlObjectOfType(cd,4);
cd[v]=ag;
return cd;
}
function v8BreakIteratorConstructor(){
return IntlConstruct(this,k,CreateBreakIterator,
new.target,arguments);
}
%SetCode(k,v8BreakIteratorConstructor);
%DefineMethodsInternal(k.prototype,class{resolvedOptions(){
if(!(new.target===(void 0))){
throw %make_type_error(104);
}
var bp='resolvedOptions';
if(!(%_IsJSReceiver(this))){
throw %make_type_error(59,bp,this);
}
var ce=%IntlUnwrapReceiver(this,4,
k,bp,
false);
return{
locale:ce[v].locale,
type:ce[v].type
};
}},-1);
%DefineMethodsInternal(k,class{supportedLocalesOf(D){
if(!(new.target===(void 0))){
throw %make_type_error(104);
}
return supportedLocalesOf('breakiterator',D,arguments[1]);
}},-1);
function adoptText(cd,cf){
%BreakIteratorAdoptText(cd,(%_ToString(cf)));
}
function first(cd){
return %BreakIteratorFirst(cd);
}
function next(cd){
return %BreakIteratorNext(cd);
}
function current(cd){
return %BreakIteratorCurrent(cd);
}
function breakType(cd){
return %BreakIteratorBreakType(cd);
}
AddBoundMethod(k,'adoptText',adoptText,1,
4,false);
AddBoundMethod(k,'first',first,0,
4,false);
AddBoundMethod(k,'next',next,0,
4,false);
AddBoundMethod(k,'current',current,0,
4,false);
AddBoundMethod(k,'breakType',breakType,0,
4,false);
var cg={
__proto__:null,
'collator':i,
'numberformat':h,
'dateformatall':g,
'dateformatdate':g,
'dateformattime':g
};
var ch={
__proto__:null,
'collator':(void 0),
'numberformat':(void 0),
'dateformatall':(void 0),
'dateformatdate':(void 0),
'dateformattime':(void 0),
};
function clearDefaultObjects(){
ch['dateformatall']=(void 0);
ch['dateformatdate']=(void 0);
ch['dateformattime']=(void 0);
}
var ci=0;
function checkDateCacheCurrent(){
var cj=%DateCacheVersion();
if(cj==ci){
return;
}
ci=cj;
clearDefaultObjects();
}
function cachedOrNewService(R,D,E,bQ){
var ck=((bQ===(void 0)))?E:bQ;
if((D===(void 0))&&(E===(void 0))){
checkDateCacheCurrent();
if((ch[R]===(void 0))){
ch[R]=new cg[R](D,ck);
}
return ch[R];
}
return new cg[R](D,ck);
}
function LocaleConvertCase(cl,D,cm){
var bg;
if((D===(void 0))){
bg=GetDefaultICULocaleJS();
}else if((typeof(D)==='string')){
bg=canonicalizeLanguageTag(D);
}else{
var D=initializeLocaleList(D);
bg=D.length>0?D[0]:GetDefaultICULocaleJS();
}
var Y=%StringIndexOf(bg,'-',0);
if(Y!==-1){
bg=%_Call(x,bg,0,Y);
}
return %StringLocaleConvertCase(cl,cm,bg);
}
%DefineMethodsInternal(n.prototype,class{localeCompare(that){
if((this==null)){
throw %make_type_error(73);
}
var D=arguments[1];
var E=arguments[2];
var bo=cachedOrNewService('collator',D,E);
return compare(bo,this,that);
}},-1);
%DefineMethodsInternal(n.prototype,class{
toLocaleLowerCase(D){
if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(25,"String.prototype.toLocaleLowerCase");
return LocaleConvertCase((%_ToString(this)),D,false);
}
toLocaleUpperCase(D){
if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(25,"String.prototype.toLocaleUpperCase");
return LocaleConvertCase((%_ToString(this)),D,true);
}
},0);
%DefineMethodsInternal(l.prototype,class{toLocaleString(){
if(!(this instanceof l)&&typeof(this)!=='number'){
throw %make_type_error(74,"Number");
}
var D=arguments[0];
var E=arguments[1];
var bH=cachedOrNewService('numberformat',D,E);
return formatNumber(bH,this);
}},-1);
function toLocaleDateTime(cn,D,E,bP,bQ,R){
if(!(cn instanceof e)){
throw %make_type_error(74,"Date");
}
var bY=(%_ToNumber(cn));
if((%IS_VAR(bY)!==bY)
)return'Invalid Date';
var bj=toDateTimeOptions(E,bP,bQ);
var bU=
cachedOrNewService(R,D,E,bj);
return formatDate(bU,cn);
}
%DefineMethodsInternal(e.prototype,class{toLocaleString(){
var D=arguments[0];
var E=arguments[1];
return toLocaleDateTime(
this,D,E,'any','all','dateformatall');
}},-1);
%DefineMethodsInternal(e.prototype,class{toLocaleDateString(){
var D=arguments[0];
var E=arguments[1];
return toLocaleDateTime(
this,D,E,'date','date','dateformatdate');
}},-1);
%DefineMethodsInternal(e.prototype,class{toLocaleTimeString(){
var D=arguments[0];
var E=arguments[1];
return toLocaleDateTime(
this,D,E,'time','time','dateformattime');
}},-1);
})

 @CommonOperations<6E>J
(function(global, binding, v8) {
'use strict';
const _queue = v8.createPrivateSymbol('[[queue]]');
const _queueTotalSize = v8.createPrivateSymbol('[[queueTotalSize]]');
const Boolean = global.Boolean;
const Number = global.Number;
const Number_isFinite = Number.isFinite;
const Number_isNaN = Number.isNaN;
const RangeError = global.RangeError;
const TypeError = global.TypeError;
const hasOwnProperty = v8.uncurryThis(global.Object.hasOwnProperty);
function hasOwnPropertyNoThrow(x, property) {
return Boolean(x) && hasOwnProperty(x, property);
}
function streamInternalError() {
throw new RangeError('Stream API Internal Error');
}
function rejectPromise(p, reason) {
if (!v8.isPromise(p)) {
streamInternalError();
}
v8.rejectPromise(p, reason);
}
function resolvePromise(p, value) {
if (!v8.isPromise(p)) {
streamInternalError();
}
v8.resolvePromise(p, value);
}
function markPromiseAsHandled(p) {
if (!v8.isPromise(p)) {
streamInternalError();
}
v8.markPromiseAsHandled(p);
}
function promiseState(p) {
if (!v8.isPromise(p)) {
streamInternalError();
}
return v8.promiseState(p);
}
function DequeueValue(container) {
const pair = container[_queue].shift();
container[_queueTotalSize] -= pair.size;
if (container[_queueTotalSize] < 0) {
container[_queueTotalSize] = 0;
}
return pair.value;
}
function EnqueueValueWithSize(container, value, size) {
size = Number(size);
if (!IsFiniteNonNegativeNumber(size)) {
throw new RangeError(binding.streamErrors.invalidSize);
}
container[_queue].push({value, size});
container[_queueTotalSize] += size;
}
function PeekQueueValue(container) {
const pair = container[_queue].peek();
return pair.value;
}
function ResetQueue(container) {
container[_queue] = new binding.SimpleQueue();
container[_queueTotalSize] = 0;
}
function IsFiniteNonNegativeNumber(v) {
return Number_isFinite(v) && v >= 0;
}
function ValidateAndNormalizeHighWaterMark(highWaterMark) {
highWaterMark = Number(highWaterMark);
if (Number_isNaN(highWaterMark)) {
throw new RangeError(binding.streamErrors.invalidHWM);
}
if (highWaterMark < 0) {
throw new RangeError(binding.streamErrors.invalidHWM);
}
return highWaterMark;
}
function MakeSizeAlgorithmFromSizeFunction(size) {
if (size === undefined) {
return () => 1;
}
if (typeof size !== 'function') {
throw new TypeError(binding.streamErrors.sizeNotAFunction);
}
return size;
}
const callFunction = v8.uncurryThis(global.Function.prototype.call);
const errTmplMustBeFunctionOrUndefined = name =>
`${name} must be a function or undefined`;
const Promise_resolve = Promise.resolve.bind(Promise);
const Promise_reject = Promise.reject.bind(Promise);
const Function_bind = v8.uncurryThis(global.Function.prototype.bind);
function resolveMethod(O, P, nameForError) {
const method = O[P];
if (typeof method !== 'function' && typeof method !== 'undefined') {
throw new TypeError(errTmplMustBeFunctionOrUndefined(nameForError));
}
return method;
}
function CreateAlgorithmFromUnderlyingMethod(
underlyingObject, methodName, algoArgCount, methodNameForError) {
const method =
resolveMethod(underlyingObject, methodName, methodNameForError);
if (method === undefined) {
return () => Promise_resolve();
}
if (algoArgCount === 0) {
return Function_bind(PromiseCall0, undefined, method, underlyingObject);
}
return Function_bind(PromiseCall1, undefined, method, underlyingObject);
}
function CreateAlgorithmFromUnderlyingMethodPassingController(
underlyingObject, methodName, algoArgCount, controller,
methodNameForError) {
const method =
resolveMethod(underlyingObject, methodName, methodNameForError);
if (method === undefined) {
return () => Promise_resolve();
}
if (algoArgCount === 0) {
return Function_bind(
PromiseCall1, undefined, method, underlyingObject, controller);
}
return arg => PromiseCall2(method, underlyingObject, arg, controller);
}
function CallOrNoop1(O, P, arg0, nameForError) {
const method = resolveMethod(O, P, nameForError);
if (method === undefined) {
return undefined;
}
return callFunction(method, O, arg0);
}
function PromiseCall0(F, V) {
try {
return Promise_resolve(callFunction(F, V));
} catch (e) {
return Promise_reject(e);
}
}
function PromiseCall1(F, V, arg0) {
try {
return Promise_resolve(callFunction(F, V, arg0));
} catch (e) {
return Promise_reject(e);
}
}
function PromiseCall2(F, V, arg0, arg1) {
try {
return Promise_resolve(callFunction(F, V, arg0, arg1));
} catch (e) {
return Promise_reject(e);
}
}
binding.streamOperations = {
_queue,
_queueTotalSize,
hasOwnPropertyNoThrow,
rejectPromise,
resolvePromise,
markPromiseAsHandled,
promiseState,
CreateAlgorithmFromUnderlyingMethod,
CreateAlgorithmFromUnderlyingMethodPassingController,
DequeueValue,
EnqueueValueWithSize,
PeekQueueValue,
ResetQueue,
ValidateAndNormalizeHighWaterMark,
MakeSizeAlgorithmFromSizeFunction,
CallOrNoop1,
PromiseCall2
};
});
4CommonStrings<EFBFBD>
(function(global, binding, v8) {
'use strict';
binding.streamErrors = {
illegalInvocation: 'Illegal invocation',
illegalConstructor: 'Illegal constructor',
invalidType: 'Invalid type is specified',
invalidSize: 'The return value of a queuing strategy\'s size function ' +
'must be a finite, non-NaN, non-negative number',
sizeNotAFunction: 'A queuing strategy\'s size property must be a function',
invalidHWM:
'A queueing strategy\'s highWaterMark property must be a nonnegative, ' +
'non-NaN number',
};
});
,SimpleQueue<75> 
(function(global, binding, v8) {
'use strict';
const _front = v8.createPrivateSymbol('front');
const _back = v8.createPrivateSymbol('back');
const _cursor = v8.createPrivateSymbol('cursor');
const _size = v8.createPrivateSymbol('size');
const _elements = v8.createPrivateSymbol('elements');
const _next = v8.createPrivateSymbol('next');
const RangeError = global.RangeError;
function requireNonEmptyQueue(queue, functionName) {
if (queue[_size] === 0) {
throw new RangeError(
`${functionName}() must not be called on an empty queue`);
}
}
const QUEUE_MAX_ARRAY_SIZE = 16384;
class SimpleQueue {
constructor() {
this[_front] = {
[_elements]: new v8.InternalPackedArray(),
[_next]: undefined,
};
this[_back] = this[_front];
this[_cursor] = 0;
this[_size] = 0;
}
get length() {
return this[_size];
}
push(element) {
const oldBack = this[_back];
let newBack = oldBack;
if (oldBack[_elements].length === QUEUE_MAX_ARRAY_SIZE - 1) {
newBack = {
[_elements]: new v8.InternalPackedArray(),
[_next]: undefined,
};
}
oldBack[_elements].push(element);
if (newBack !== oldBack) {
this[_back] = newBack;
oldBack[_next] = newBack;
}
++this[_size];
}
shift() {
requireNonEmptyQueue(this, 'shift');
const oldFront = this[_front];
let newFront = oldFront;
const oldCursor = this[_cursor];
let newCursor = oldCursor + 1;
const elements = oldFront[_elements];
const element = elements[oldCursor];
if (newCursor === QUEUE_MAX_ARRAY_SIZE) {
newFront = oldFront[_next];
newCursor = 0;
}
--this[_size];
this[_cursor] = newCursor;
if (oldFront !== newFront) {
this[_front] = newFront;
}
elements[oldCursor] = undefined;
return element;
}
forEach(callback) {
let i = this[_cursor];
let node = this[_front];
let elements = node[_elements];
while (i !== elements.length || node[_next] !== undefined) {
if (i === elements.length) {
node = node[_next];
elements = node[_elements];
i = 0;
if (elements.length === 0) {
break;
}
}
callback(elements[i]);
++i;
}
}
peek() {
requireNonEmptyQueue(this, 'peek');
const front = this[_front];
const cursor = this[_cursor];
return front[_elements][cursor];
}
}
binding.SimpleQueue = SimpleQueue;
});
dByteLengthQueuingStrategy<EFBFBD>
(function(global, binding, v8) {
'use strict';
const defineProperty = global.Object.defineProperty;
class ByteLengthQueuingStrategy {
constructor(options) {
defineProperty(this, 'highWaterMark', {
value: options.highWaterMark,
enumerable: true,
configurable: true,
writable: true
});
}
size(chunk) {
return chunk.byteLength;
}
}
defineProperty(global, 'ByteLengthQueuingStrategy', {
value: ByteLengthQueuingStrategy,
enumerable: false,
configurable: true,
writable: true
});
});
PCountQueuingStrategy

(function(global, binding, v8) {
'use strict';
const defineProperty = global.Object.defineProperty;
class CountQueuingStrategy {
constructor(options) {
defineProperty(this, 'highWaterMark', {
value: options.highWaterMark,
enumerable: true,
configurable: true,
writable: true
});
}
size() {
return 1;
}
}
defineProperty(global, 'CountQueuingStrategy', {
value: CountQueuingStrategy,
enumerable: false,
configurable: true,
writable: true
});
class BuiltInCountQueuingStrategy {
constructor(highWaterMark) {
defineProperty(this, 'highWaterMark', {value: highWaterMark});
}
size() {
return 1;
}
}
binding.createBuiltInCountQueuingStrategy = highWaterMark =>
new BuiltInCountQueuingStrategy(highWaterMark);
});
8ReadableStream<EFBFBD><EFBFBD>

(function(global, binding, v8) {
'use strict';
const _reader = v8.createPrivateSymbol('[[reader]]');
const _storedError = v8.createPrivateSymbol('[[storedError]]');
const _controller = v8.createPrivateSymbol('[[controller]]');
const _closedPromise = v8.createPrivateSymbol('[[closedPromise]]');
const _ownerReadableStream =
v8.createPrivateSymbol('[[ownerReadableStream]]');
const _readRequests = v8.createPrivateSymbol('[[readRequests]]');
const createWithExternalControllerSentinel =
v8.createPrivateSymbol('flag for UA-created ReadableStream to pass');
const _readableStreamBits =
v8.createPrivateSymbol('bit field for [[state]] and [[disturbed]]');
const DISTURBED = 0b1;
const STATE_MASK = 0b110;
const STATE_BITS_OFFSET = 1;
const STATE_READABLE = 0;
const STATE_CLOSED = 1;
const STATE_ERRORED = 2;
const _controlledReadableStream =
v8.createPrivateSymbol('[[controlledReadableStream]]');
const _strategyHWM = v8.createPrivateSymbol('[[strategyHWM]]');
const _readableStreamDefaultControllerBits = v8.createPrivateSymbol(
'bit field for [[started]], [[closeRequested]], [[pulling]], ' +
'[[pullAgain]]');
const _lockNotifyTarget = v8.createPrivateSymbol('[[lockNotifyTarget]]');
const _strategySizeAlgorithm = v8.createPrivateSymbol(
'[[strategySizeAlgorithm]]');
const _pullAlgorithm = v8.createPrivateSymbol('[[pullAlgorithm]]');
const _cancelAlgorithm = v8.createPrivateSymbol('[[cancelAlgorithm]]');
const STARTED = 0b1;
const CLOSE_REQUESTED = 0b10;
const PULLING = 0b100;
const PULL_AGAIN = 0b1000;
const BLINK_LOCK_NOTIFICATIONS = 0b10000;
const defineProperty = global.Object.defineProperty;
const ObjectCreate = global.Object.create;
const callFunction = v8.uncurryThis(global.Function.prototype.call);
const applyFunction = v8.uncurryThis(global.Function.prototype.apply);
const TypeError = global.TypeError;
const RangeError = global.RangeError;
const Boolean = global.Boolean;
const String = global.String;
const Promise = global.Promise;
const thenPromise = v8.uncurryThis(Promise.prototype.then);
const Promise_resolve = Promise.resolve.bind(Promise);
const Promise_reject = Promise.reject.bind(Promise);
const {
_queue,
_queueTotalSize,
hasOwnPropertyNoThrow,
rejectPromise,
resolvePromise,
markPromiseAsHandled,
CallOrNoop1,
CreateAlgorithmFromUnderlyingMethod,
CreateAlgorithmFromUnderlyingMethodPassingController,
DequeueValue,
EnqueueValueWithSize,
MakeSizeAlgorithmFromSizeFunction,
ValidateAndNormalizeHighWaterMark,
} = binding.streamOperations;
const streamErrors = binding.streamErrors;
const errCancelLockedStream =
'Cannot cancel a readable stream that is locked to a reader';
const errEnqueueCloseRequestedStream =
'Cannot enqueue a chunk into a readable stream that is closed or ' +
'has been requested to be closed';
const errCancelReleasedReader =
'This readable stream reader has been released and cannot be used ' +
'to cancel its previous owner stream';
const errReadReleasedReader =
'This readable stream reader has been released and cannot be used ' +
'to read from its previous owner stream';
const errCloseCloseRequestedStream =
'Cannot close a readable stream that has already been requested to ' +
'be closed';
const errEnqueueClosedStream =
'Cannot enqueue a chunk into a closed readable stream';
const errEnqueueErroredStream =
'Cannot enqueue a chunk into an errored readable stream';
const errCloseClosedStream = 'Cannot close a closed readable stream';
const errCloseErroredStream = 'Cannot close an errored readable stream';
const errGetReaderNotByteStream =
'This readable stream does not support BYOB readers';
const errGetReaderBadMode =
'Invalid reader mode given: expected undefined or "byob"';
const errReaderConstructorBadArgument =
'ReadableStreamReader constructor argument is not a readable stream';
const errReaderConstructorStreamAlreadyLocked =
'ReadableStreamReader constructor can only accept readable streams ' +
'that are not yet locked to a reader';
const errReleaseReaderWithPendingRead =
'Cannot release a readable stream reader when it still has ' +
'outstanding read() calls that have not yet settled';
const errReleasedReaderClosedPromise =
'This readable stream reader has been released and cannot be used ' +
'to monitor the stream\'s state';
const errCannotPipeLockedStream = 'Cannot pipe a locked stream';
const errCannotPipeToALockedStream = 'Cannot pipe to a locked stream';
const errDestinationStreamClosed = 'Destination stream closed';
const errPipeThroughUndefinedWritable =
'Failed to execute \'pipeThrough\' on \'ReadableStream\': parameter ' +
'1\'s \'writable\' property is undefined.';
const errPipeThroughUndefinedReadable =
'Failed to execute \'pipeThrough\' on \'ReadableStream\': parameter ' +
'1\'s \'readable\' property is undefined.';
let useCounted = false;
class ReadableStream {
constructor(underlyingSource = {}, strategy = {},
internalArgument = undefined) {
const enableBlinkLockNotifications =
internalArgument === createWithExternalControllerSentinel;
if (!useCounted && !enableBlinkLockNotifications) {
binding.countUse('ReadableStreamConstructor');
useCounted = true;
}
InitializeReadableStream(this);
const type = underlyingSource.type;
const size = strategy.size;
let highWaterMark = strategy.highWaterMark;
const typeString = String(type);
if (typeString === 'bytes') {
throw new RangeError('bytes type is not yet implemented');
}
if (type !== undefined) {
throw new RangeError(streamErrors.invalidType);
}
if (highWaterMark === undefined) {
highWaterMark = 1;
}
highWaterMark = ValidateAndNormalizeHighWaterMark(highWaterMark);
const sizeAlgorithm = MakeSizeAlgorithmFromSizeFunction(size);
SetUpReadableStreamDefaultControllerFromUnderlyingSource(
this, underlyingSource, highWaterMark, sizeAlgorithm,
enableBlinkLockNotifications);
}
get locked() {
if (IsReadableStream(this) === false) {
throw new TypeError(streamErrors.illegalInvocation);
}
return IsReadableStreamLocked(this);
}
cancel(reason) {
if (IsReadableStream(this) === false) {
return Promise_reject(new TypeError(streamErrors.illegalInvocation));
}
if (IsReadableStreamLocked(this) === true) {
return Promise_reject(new TypeError(errCancelLockedStream));
}
return ReadableStreamCancel(this, reason);
}
getReader({mode} = {}) {
if (IsReadableStream(this) === false) {
throw new TypeError(streamErrors.illegalInvocation);
}
if (mode === undefined) {
return AcquireReadableStreamDefaultReader(this);
}
mode = String(mode);
if (mode === 'byob') {
throw new TypeError(errGetReaderNotByteStream);
}
throw new RangeError(errGetReaderBadMode);
}
pipeThrough({writable, readable}, options) {
if (writable === undefined) {
throw new TypeError(errPipeThroughUndefinedWritable);
}
if (readable === undefined) {
throw new TypeError(errPipeThroughUndefinedReadable);
}
const promise = this.pipeTo(writable, options);
if (v8.isPromise(promise)) {
markPromiseAsHandled(promise);
}
return readable;
}
pipeTo(dest, {preventClose, preventAbort, preventCancel} = {}) {
if (!IsReadableStream(this)) {
return Promise_reject(new TypeError(streamErrors.illegalInvocation));
}
if (!binding.IsWritableStream(dest)) {
return Promise_reject(new TypeError(streamErrors.illegalInvocation));
}
preventClose = Boolean(preventClose);
preventAbort = Boolean(preventAbort);
preventCancel = Boolean(preventCancel);
if (IsReadableStreamLocked(this)) {
return Promise_reject(new TypeError(errCannotPipeLockedStream));
}
if (binding.IsWritableStreamLocked(dest)) {
return Promise_reject(new TypeError(errCannotPipeToALockedStream));
}
return ReadableStreamPipeTo(
this, dest, preventClose, preventAbort, preventCancel);
}
tee() {
if (IsReadableStream(this) === false) {
throw new TypeError(streamErrors.illegalInvocation);
}
return ReadableStreamTee(this);
}
}
const ReadableStream_prototype = ReadableStream.prototype;
function ReadableStreamPipeTo(
readable, dest, preventClose, preventAbort, preventCancel) {
const reader = AcquireReadableStreamDefaultReader(readable);
const writer = binding.AcquireWritableStreamDefaultWriter(dest);
let shuttingDown = false;
const promise = v8.createPromise();
let reading = false;
if (checkInitialState()) {
thenPromise(reader[_closedPromise], onReaderClosed, readableError);
thenPromise(
binding.getWritableStreamDefaultWriterClosedPromise(writer),
undefined, writableError);
pump();
}
function checkInitialState() {
const state = ReadableStreamGetState(readable);
if (state === STATE_ERRORED) {
readableError(readable[_storedError]);
return false;
}
if (binding.isWritableStreamErrored(dest)) {
writableError(binding.getWritableStreamStoredError(dest));
return false;
}
if (state === STATE_CLOSED) {
readableClosed();
return false;
}
if (binding.isWritableStreamClosingOrClosed(dest)) {
writableStartedClosed();
return false;
}
return true;
}
function pump() {
if (shuttingDown) {
return;
}
const desiredSize =
binding.WritableStreamDefaultWriterGetDesiredSize(writer);
if (desiredSize === null) {
return;
}
if (desiredSize <= 0) {
thenPromise(
binding.getWritableStreamDefaultWriterReadyPromise(writer), pump,
writableError);
return;
}
reading = true;
thenPromise(
ReadableStreamDefaultReaderRead(reader), readFulfilled, readRejected);
}
function readFulfilled({value, done}) {
reading = false;
if (shuttingDown) {
return;
}
if (done) {
readableClosed();
return;
}
const write = binding.WritableStreamDefaultWriterWrite(writer, value);
thenPromise(write, undefined, writableError);
pump();
}
function readRejected() {
reading = false;
readableError(readable[_storedError]);
}
function onReaderClosed() {
if (!reading) {
readableClosed();
}
}
function readableError(error) {
if (!preventAbort) {
shutdownWithAction(
binding.WritableStreamAbort, [dest, error], error, true);
} else {
shutdown(error, true);
}
}
function writableError(error) {
if (!preventCancel) {
shutdownWithAction(
ReadableStreamCancel, [readable, error], error, true);
} else {
shutdown(error, true);
}
}
function readableClosed() {
if (!preventClose) {
shutdownWithAction(
binding.WritableStreamDefaultWriterCloseWithErrorPropagation,
[writer]);
} else {
shutdown();
}
}
function writableStartedClosed() {
const destClosed = new TypeError(errDestinationStreamClosed);
if (!preventCancel) {
shutdownWithAction(
ReadableStreamCancel, [readable, destClosed], destClosed, true);
} else {
shutdown(destClosed, true);
}
}
function shutdownWithAction(
action, args, originalError = undefined, errorGiven = false) {
if (shuttingDown) {
return;
}
shuttingDown = true;
const p = applyFunction(action, undefined, args);
thenPromise(
p, () => finalize(originalError, errorGiven),
newError => finalize(newError, true));
}
function shutdown(error = undefined, errorGiven = false) {
if (shuttingDown) {
return;
}
shuttingDown = true;
finalize(error, errorGiven);
}
function finalize(error, errorGiven) {
binding.WritableStreamDefaultWriterRelease(writer);
ReadableStreamReaderGenericRelease(reader);
if (errorGiven) {
rejectPromise(promise, error);
} else {
resolvePromise(promise, undefined);
}
}
return promise;
}
function AcquireReadableStreamDefaultReader(stream) {
return new ReadableStreamDefaultReader(stream);
}
function CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm,
highWaterMark, sizeAlgorithm,
enableBlinkLockNotifications) {
if (highWaterMark === undefined) {
highWaterMark = 1;
}
if (sizeAlgorithm === undefined) {
sizeAlgorithm = () => 1;
}
const stream = ObjectCreate(ReadableStream_prototype);
InitializeReadableStream(stream);
const controller = ObjectCreate(ReadableStreamDefaultController_prototype);
SetUpReadableStreamDefaultController(
stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm,
highWaterMark, sizeAlgorithm, enableBlinkLockNotifications);
return stream;
}
function InitializeReadableStream(stream) {
stream[_readableStreamBits] = 0b0;
ReadableStreamSetState(stream, STATE_READABLE);
stream[_reader] = undefined;
stream[_storedError] = undefined;
}
function IsReadableStream(x) {
return hasOwnPropertyNoThrow(x, _controller);
}
function IsReadableStreamDisturbed(stream) {
return stream[_readableStreamBits] & DISTURBED;
}
function IsReadableStreamLocked(stream) {
return stream[_reader] !== undefined;
}
function ReadableStreamTee(stream) {
const reader = AcquireReadableStreamDefaultReader(stream);
let closedOrErrored = false;
let canceled1 = false;
let canceled2 = false;
let reason1;
let reason2;
const cancelPromise = v8.createPromise();
function pullAlgorithm() {
return thenPromise(
ReadableStreamDefaultReaderRead(reader), ({value, done}) => {
if (done && !closedOrErrored) {
if (!canceled1) {
ReadableStreamDefaultControllerClose(branch1controller);
}
if (!canceled2) {
ReadableStreamDefaultControllerClose(branch2controller);
}
closedOrErrored = true;
}
if (closedOrErrored) {
return;
}
if (!canceled1) {
ReadableStreamDefaultControllerEnqueue(branch1controller, value);
}
if (!canceled2) {
ReadableStreamDefaultControllerEnqueue(branch2controller, value);
}
});
}
function cancel1Algorithm(reason) {
canceled1 = true;
reason1 = reason;
if (canceled2) {
const cancelResult = ReadableStreamCancel(stream, [reason1, reason2]);
resolvePromise(cancelPromise, cancelResult);
}
return cancelPromise;
}
function cancel2Algorithm(reason) {
canceled2 = true;
reason2 = reason;
if (canceled1) {
const cancelResult = ReadableStreamCancel(stream, [reason1, reason2]);
resolvePromise(cancelPromise, cancelResult);
}
return cancelPromise;
}
const startAlgorithm = () => undefined;
const branch1Stream = CreateReadableStream(
startAlgorithm, pullAlgorithm, cancel1Algorithm, undefined, undefined,
false);
const branch2Stream = CreateReadableStream(
startAlgorithm, pullAlgorithm, cancel2Algorithm, undefined, undefined,
false);
const branch1controller = branch1Stream[_controller];
const branch2controller = branch2Stream[_controller];
thenPromise(reader[_closedPromise], undefined, r => {
if (closedOrErrored === true) {
return;
}
ReadableStreamDefaultControllerError(branch1controller, r);
ReadableStreamDefaultControllerError(branch2controller, r);
closedOrErrored = true;
});
return [branch1Stream, branch2Stream];
}
function ReadableStreamAddReadRequest(stream) {
const promise = v8.createPromise();
stream[_reader][_readRequests].push(promise);
return promise;
}
function ReadableStreamCancel(stream, reason) {
stream[_readableStreamBits] |= DISTURBED;
const state = ReadableStreamGetState(stream);
if (state === STATE_CLOSED) {
return Promise_resolve(undefined);
}
if (state === STATE_ERRORED) {
return Promise_reject(stream[_storedError]);
}
ReadableStreamClose(stream);
const sourceCancelPromise =
ReadableStreamDefaultControllerCancel(stream[_controller], reason);
return thenPromise(sourceCancelPromise, () => undefined);
}
function ReadableStreamClose(stream) {
ReadableStreamSetState(stream, STATE_CLOSED);
const reader = stream[_reader];
if (reader === undefined) {
return;
}
if (IsReadableStreamDefaultReader(reader) === true) {
reader[_readRequests].forEach(
request =>
resolvePromise(request, CreateIterResultObject(undefined, true)));
reader[_readRequests] = new binding.SimpleQueue();
}
resolvePromise(reader[_closedPromise], undefined);
}
function ReadableStreamError(stream, e) {
ReadableStreamSetState(stream, STATE_ERRORED);
stream[_storedError] = e;
const reader = stream[_reader];
if (reader === undefined) {
return;
}
if (IsReadableStreamDefaultReader(reader) === true) {
reader[_readRequests].forEach(request => rejectPromise(request, e));
reader[_readRequests] = new binding.SimpleQueue();
}
rejectPromise(reader[_closedPromise], e);
markPromiseAsHandled(reader[_closedPromise]);
}
function ReadableStreamFulfillReadRequest(stream, chunk, done) {
const readRequest = stream[_reader][_readRequests].shift();
resolvePromise(readRequest, CreateIterResultObject(chunk, done));
}
function ReadableStreamGetNumReadRequests(stream) {
const reader = stream[_reader];
const readRequests = reader[_readRequests];
return readRequests.length;
}
class ReadableStreamDefaultReader {
constructor(stream) {
if (IsReadableStream(stream) === false) {
throw new TypeError(errReaderConstructorBadArgument);
}
if (IsReadableStreamLocked(stream) === true) {
throw new TypeError(errReaderConstructorStreamAlreadyLocked);
}
ReadableStreamReaderGenericInitialize(this, stream);
this[_readRequests] = new binding.SimpleQueue();
}
get closed() {
if (IsReadableStreamDefaultReader(this) === false) {
return Promise_reject(new TypeError(streamErrors.illegalInvocation));
}
return this[_closedPromise];
}
cancel(reason) {
if (IsReadableStreamDefaultReader(this) === false) {
return Promise_reject(new TypeError(streamErrors.illegalInvocation));
}
if (this[_ownerReadableStream] === undefined) {
return Promise_reject(new TypeError(errCancelReleasedReader));
}
return ReadableStreamReaderGenericCancel(this, reason);
}
read() {
if (IsReadableStreamDefaultReader(this) === false) {
return Promise_reject(new TypeError(streamErrors.illegalInvocation));
}
if (this[_ownerReadableStream] === undefined) {
return Promise_reject(new TypeError(errReadReleasedReader));
}
return ReadableStreamDefaultReaderRead(this);
}
releaseLock() {
if (IsReadableStreamDefaultReader(this) === false) {
throw new TypeError(streamErrors.illegalInvocation);
}
if (this[_ownerReadableStream] === undefined) {
return;
}
if (this[_readRequests].length > 0) {
throw new TypeError(errReleaseReaderWithPendingRead);
}
ReadableStreamReaderGenericRelease(this);
}
}
function IsReadableStreamDefaultReader(x) {
return hasOwnPropertyNoThrow(x, _readRequests);
}
function ReadableStreamReaderGenericCancel(reader, reason) {
return ReadableStreamCancel(reader[_ownerReadableStream], reason);
}
function ReadableStreamReaderGenericInitialize(reader, stream) {
const controller = stream[_controller];
if (controller[_readableStreamDefaultControllerBits] &
BLINK_LOCK_NOTIFICATIONS) {
const lockNotifyTarget = controller[_lockNotifyTarget];
callFunction(lockNotifyTarget.notifyLockAcquired, lockNotifyTarget);
}
reader[_ownerReadableStream] = stream;
stream[_reader] = reader;
switch (ReadableStreamGetState(stream)) {
case STATE_READABLE:
reader[_closedPromise] = v8.createPromise();
break;
case STATE_CLOSED:
reader[_closedPromise] = Promise_resolve(undefined);
break;
case STATE_ERRORED:
reader[_closedPromise] = Promise_reject(stream[_storedError]);
markPromiseAsHandled(reader[_closedPromise]);
break;
}
}
function ReadableStreamReaderGenericRelease(reader) {
const controller = reader[_ownerReadableStream][_controller];
if (controller[_readableStreamDefaultControllerBits] &
BLINK_LOCK_NOTIFICATIONS) {
const lockNotifyTarget = controller[_lockNotifyTarget];
callFunction(lockNotifyTarget.notifyLockReleased, lockNotifyTarget);
}
if (ReadableStreamGetState(reader[_ownerReadableStream]) ===
STATE_READABLE) {
rejectPromise(
reader[_closedPromise],
new TypeError(errReleasedReaderClosedPromise));
} else {
reader[_closedPromise] =
Promise_reject(new TypeError(errReleasedReaderClosedPromise));
}
markPromiseAsHandled(reader[_closedPromise]);
reader[_ownerReadableStream][_reader] = undefined;
reader[_ownerReadableStream] = undefined;
}
function ReadableStreamDefaultReaderRead(reader) {
const stream = reader[_ownerReadableStream];
stream[_readableStreamBits] |= DISTURBED;
switch (ReadableStreamGetState(stream)) {
case STATE_CLOSED:
return Promise_resolve(CreateIterResultObject(undefined, true));
case STATE_ERRORED:
return Promise_reject(stream[_storedError]);
default:
return ReadableStreamDefaultControllerPull(stream[_controller]);
}
}
class ReadableStreamDefaultController {
constructor() {
throw new TypeError(streamErrors.illegalConstructor);
}
get desiredSize() {
if (IsReadableStreamDefaultController(this) === false) {
throw new TypeError(streamErrors.illegalInvocation);
}
return ReadableStreamDefaultControllerGetDesiredSize(this);
}
close() {
if (IsReadableStreamDefaultController(this) === false) {
throw new TypeError(streamErrors.illegalInvocation);
}
if (ReadableStreamDefaultControllerCanCloseOrEnqueue(this) === false) {
let errorDescription;
if (this[_readableStreamDefaultControllerBits] & CLOSE_REQUESTED) {
errorDescription = errCloseCloseRequestedStream;
} else {
const stream = this[_controlledReadableStream];
switch (ReadableStreamGetState(stream)) {
case STATE_ERRORED:
errorDescription = errCloseErroredStream;
break;
case STATE_CLOSED:
errorDescription = errCloseClosedStream;
break;
}
}
throw new TypeError(errorDescription);
}
return ReadableStreamDefaultControllerClose(this);
}
enqueue(chunk) {
if (IsReadableStreamDefaultController(this) === false) {
throw new TypeError(streamErrors.illegalInvocation);
}
if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) {
const stream = this[_controlledReadableStream];
throw getReadableStreamEnqueueError(stream, this);
}
return ReadableStreamDefaultControllerEnqueue(this, chunk);
}
error(e) {
if (IsReadableStreamDefaultController(this) === false) {
throw new TypeError(streamErrors.illegalInvocation);
}
return ReadableStreamDefaultControllerError(this, e);
}
}
const ReadableStreamDefaultController_prototype =
ReadableStreamDefaultController.prototype;
function ReadableStreamDefaultControllerCancel(controller, reason) {
controller[_queue] = new binding.SimpleQueue();
return controller[_cancelAlgorithm](reason);
}
function ReadableStreamDefaultControllerPull(controller) {
const stream = controller[_controlledReadableStream];
if (controller[_queue].length > 0) {
const chunk = DequeueValue(controller);
if ((controller[_readableStreamDefaultControllerBits] &
CLOSE_REQUESTED) &&
controller[_queue].length === 0) {
ReadableStreamClose(stream);
} else {
ReadableStreamDefaultControllerCallPullIfNeeded(controller);
}
return Promise_resolve(CreateIterResultObject(chunk, false));
}
const pendingPromise = ReadableStreamAddReadRequest(stream);
ReadableStreamDefaultControllerCallPullIfNeeded(controller);
return pendingPromise;
}
function IsReadableStreamDefaultController(x) {
return hasOwnPropertyNoThrow(x, _controlledReadableStream);
}
function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
const shouldPull =
ReadableStreamDefaultControllerShouldCallPull(controller);
if (shouldPull === false) {
return;
}
if (controller[_readableStreamDefaultControllerBits] & PULLING) {
controller[_readableStreamDefaultControllerBits] |= PULL_AGAIN;
return;
}
controller[_readableStreamDefaultControllerBits] |= PULLING;
thenPromise(
controller[_pullAlgorithm](),
() => {
controller[_readableStreamDefaultControllerBits] &= ~PULLING;
if (controller[_readableStreamDefaultControllerBits] & PULL_AGAIN) {
controller[_readableStreamDefaultControllerBits] &= ~PULL_AGAIN;
ReadableStreamDefaultControllerCallPullIfNeeded(controller);
}
},
e => {
ReadableStreamDefaultControllerError(controller, e);
});
}
function ReadableStreamDefaultControllerShouldCallPull(controller) {
if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {
return false;
}
if (!(controller[_readableStreamDefaultControllerBits] & STARTED)) {
return false;
}
const stream = controller[_controlledReadableStream];
if (IsReadableStreamLocked(stream) === true &&
ReadableStreamGetNumReadRequests(stream) > 0) {
return true;
}
const desiredSize =
ReadableStreamDefaultControllerGetDesiredSize(controller);
return desiredSize > 0;
}
function ReadableStreamDefaultControllerClose(controller) {
controller[_readableStreamDefaultControllerBits] |= CLOSE_REQUESTED;
if (controller[_queue].length === 0) {
ReadableStreamClose(controller[_controlledReadableStream]);
}
}
function ReadableStreamDefaultControllerEnqueue(controller, chunk) {
const stream = controller[_controlledReadableStream];
if (IsReadableStreamLocked(stream) === true &&
ReadableStreamGetNumReadRequests(stream) > 0) {
ReadableStreamFulfillReadRequest(stream, chunk, false);
} else {
let chunkSize;
try {
chunkSize = callFunction(controller[_strategySizeAlgorithm], undefined,
chunk);
} catch (chunkSizeE) {
ReadableStreamDefaultControllerError(controller, chunkSizeE);
throw chunkSizeE;
}
try {
EnqueueValueWithSize(controller, chunk, chunkSize);
} catch (enqueueE) {
ReadableStreamDefaultControllerError(controller, enqueueE);
throw enqueueE;
}
}
ReadableStreamDefaultControllerCallPullIfNeeded(controller);
}
function ReadableStreamDefaultControllerError(controller, e) {
const stream = controller[_controlledReadableStream];
if (ReadableStreamGetState(stream) !== STATE_READABLE) {
return;
}
controller[_queue] = new binding.SimpleQueue();
ReadableStreamError(stream, e);
}
function ReadableStreamDefaultControllerGetDesiredSize(controller) {
switch (ReadableStreamGetState(controller[_controlledReadableStream])) {
case STATE_ERRORED:
return null;
case STATE_CLOSED:
return 0;
default:
return controller[_strategyHWM] - controller[_queueTotalSize];
}
}
function ReadableStreamDefaultControllerHasBackpressure(controller) {
return !ReadableStreamDefaultControllerShouldCallPull(controller);
}
function ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) {
if (controller[_readableStreamDefaultControllerBits] & CLOSE_REQUESTED) {
return false;
}
const state = ReadableStreamGetState(controller[_controlledReadableStream]);
return state === STATE_READABLE;
}
function SetUpReadableStreamDefaultController(
stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm,
highWaterMark, sizeAlgorithm, enableBlinkLockNotifications) {
controller[_controlledReadableStream] = stream;
controller[_queue] = new binding.SimpleQueue();
controller[_queueTotalSize] = 0;
controller[_readableStreamDefaultControllerBits] =
enableBlinkLockNotifications ? BLINK_LOCK_NOTIFICATIONS : 0b0;
controller[_strategySizeAlgorithm] = sizeAlgorithm;
controller[_strategyHWM] = highWaterMark;
controller[_pullAlgorithm] = pullAlgorithm;
controller[_cancelAlgorithm] = cancelAlgorithm;
stream[_controller] = controller;
thenPromise(Promise_resolve(startAlgorithm()), () => {
controller[_readableStreamDefaultControllerBits] |= STARTED;
ReadableStreamDefaultControllerCallPullIfNeeded(controller);
}, r =>  ReadableStreamDefaultControllerError(controller, r));
}
function SetUpReadableStreamDefaultControllerFromUnderlyingSource(
stream, underlyingSource, highWaterMark, sizeAlgorithm,
enableBlinkLockNotifications) {
const controller = ObjectCreate(ReadableStreamDefaultController_prototype);
const startAlgorithm =
() => CallOrNoop1(underlyingSource, 'start', controller,
'underlyingSource.start');
const pullAlgorithm = CreateAlgorithmFromUnderlyingMethodPassingController(
underlyingSource, 'pull', 0, controller, 'underlyingSource.pull');
const cancelAlgorithm = CreateAlgorithmFromUnderlyingMethod(
underlyingSource, 'cancel', 1, 'underlyingSource.cancel');
if (enableBlinkLockNotifications) {
controller[_lockNotifyTarget] = underlyingSource;
}
SetUpReadableStreamDefaultController(
stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm,
highWaterMark, sizeAlgorithm, enableBlinkLockNotifications);
}
function ReadableStreamGetState(stream) {
return (stream[_readableStreamBits] & STATE_MASK) >> STATE_BITS_OFFSET;
}
function ReadableStreamSetState(stream, state) {
stream[_readableStreamBits] = (stream[_readableStreamBits] & ~STATE_MASK) |
(state << STATE_BITS_OFFSET);
}
function IsReadableStreamReadable(stream) {
return ReadableStreamGetState(stream) === STATE_READABLE;
}
function IsReadableStreamClosed(stream) {
return ReadableStreamGetState(stream) === STATE_CLOSED;
}
function IsReadableStreamErrored(stream) {
return ReadableStreamGetState(stream) === STATE_ERRORED;
}
function getReadableStreamEnqueueError(stream, controller) {
if (controller[_readableStreamDefaultControllerBits] & CLOSE_REQUESTED) {
return new TypeError(errEnqueueCloseRequestedStream);
}
const state = ReadableStreamGetState(stream);
if (state === STATE_ERRORED) {
return new TypeError(errEnqueueErroredStream);
}
return new TypeError(errEnqueueClosedStream);
}
function CreateIterResultObject(value, done) {
return {value, done};
}
function getReadableStreamController(stream) {
return stream[_controller];
}
function getReadableStreamStoredError(stream) {
return stream[_storedError];
}
defineProperty(global, 'ReadableStream', {
value: ReadableStream,
enumerable: false,
configurable: true,
writable: true
});
binding.AcquireReadableStreamDefaultReader =
AcquireReadableStreamDefaultReader;
binding.IsReadableStream = IsReadableStream;
binding.IsReadableStreamDisturbed = IsReadableStreamDisturbed;
binding.IsReadableStreamLocked = IsReadableStreamLocked;
binding.IsReadableStreamReadable = IsReadableStreamReadable;
binding.IsReadableStreamClosed = IsReadableStreamClosed;
binding.IsReadableStreamErrored = IsReadableStreamErrored;
binding.IsReadableStreamDefaultReader = IsReadableStreamDefaultReader;
binding.ReadableStreamDefaultReaderRead = ReadableStreamDefaultReaderRead;
binding.ReadableStreamTee = ReadableStreamTee;
binding.ReadableStreamDefaultControllerClose =
ReadableStreamDefaultControllerClose;
binding.ReadableStreamDefaultControllerGetDesiredSize =
ReadableStreamDefaultControllerGetDesiredSize;
binding.ReadableStreamDefaultControllerEnqueue =
ReadableStreamDefaultControllerEnqueue;
binding.ReadableStreamDefaultControllerError =
ReadableStreamDefaultControllerError;
binding.createReadableStreamWithExternalController =
(underlyingSource, strategy) => {
return new ReadableStream(
underlyingSource, strategy, createWithExternalControllerSentinel);
};
binding.CreateReadableStream = CreateReadableStream;
binding.ReadableStreamDefaultControllerCanCloseOrEnqueue =
ReadableStreamDefaultControllerCanCloseOrEnqueue;
binding.ReadableStreamDefaultControllerHasBackpressure =
ReadableStreamDefaultControllerHasBackpressure;
binding.getReadableStreamEnqueueError = getReadableStreamEnqueueError;
binding.getReadableStreamController = getReadableStreamController;
binding.getReadableStreamStoredError = getReadableStreamStoredError;
});
8WritableStream*<2A>

(function(global, binding, v8) {
'use strict';
const _abortAlgorithm = v8.createPrivateSymbol('[[abortAlgorithm]]');
const _closeAlgorithm = v8.createPrivateSymbol('[[closeAlgorithm]]');
const _closeRequest = v8.createPrivateSymbol('[[closeRequest]]');
const _inFlightWriteRequest =
v8.createPrivateSymbol('[[inFlightWriteRequest]]');
const _inFlightCloseRequest =
v8.createPrivateSymbol('[[inFlightCloseRequest]]');
const _pendingAbortRequest =
v8.createPrivateSymbol('[[pendingAbortRequest]]');
const _stateAndFlags = v8.createPrivateSymbol('[[state]] and flags');
const _storedError = v8.createPrivateSymbol('[[storedError]]');
const _writableStreamController =
v8.createPrivateSymbol('[[writableStreamController]]');
const _writer = v8.createPrivateSymbol('[[writer]]');
const _writeRequests = v8.createPrivateSymbol('[[writeRequests]]');
const _closedPromise = v8.createPrivateSymbol('[[closedPromise]]');
const _ownerWritableStream =
v8.createPrivateSymbol('[[ownerWritableStream]]');
const _readyPromise = v8.createPrivateSymbol('[[readyPromise]]');
const _controlledWritableStream =
v8.createPrivateSymbol('[[controlledWritableStream]]');
const _started = v8.createPrivateSymbol('[[started]]');
const _strategyHWM = v8.createPrivateSymbol('[[strategyHWM]]');
const _strategySizeAlgorithm =
v8.createPrivateSymbol('[[strategySizeAlgorithm]]');
const _writeAlgorithm = v8.createPrivateSymbol('[[writeAlgorithm]]');
const WRITABLE = 0;
const CLOSED = 1;
const ERRORING = 2;
const ERRORED = 3;
const STATE_MASK = 0xF;
const BACKPRESSURE_FLAG = 0x10;
const defineProperty = global.Object.defineProperty;
const ObjectCreate = global.Object.create;
const Function_call = v8.uncurryThis(global.Function.prototype.call);
const TypeError = global.TypeError;
const RangeError = global.RangeError;
const Boolean = global.Boolean;
const Promise = global.Promise;
const thenPromise = v8.uncurryThis(Promise.prototype.then);
const Promise_resolve = Promise.resolve.bind(Promise);
const Promise_reject = Promise.reject.bind(Promise);
const {
_queue,
_queueTotalSize,
hasOwnPropertyNoThrow,
rejectPromise,
resolvePromise,
markPromiseAsHandled,
promiseState,
CreateAlgorithmFromUnderlyingMethod,
CreateAlgorithmFromUnderlyingMethodPassingController,
DequeueValue,
EnqueueValueWithSize,
MakeSizeAlgorithmFromSizeFunction,
PeekQueueValue,
ResetQueue,
ValidateAndNormalizeHighWaterMark,
CallOrNoop1,
} = binding.streamOperations;
const streamErrors = binding.streamErrors;
const errAbortLockedStream =
'Cannot abort a writable stream that is locked to a writer';
const errWriterLockReleasedPrefix =
'This writable stream writer has been released and cannot be ';
const errCloseCloseRequestedStream = 'Cannot close a writable stream that ' +
'has already been requested to be closed';
const templateErrorCannotActionOnStateStream = (action, state) =>
`Cannot ${action} a ${state} writable stream`;
const errReleasedWriterClosedPromise = 'This writable stream writer has ' +
'been released and cannot be used to monitor the stream\'s state';
const verbUsedToGetTheDesiredSize = 'used to get the desiredSize';
const verbAborted = 'aborted';
const verbClosed = 'closed';
const verbWrittenTo = 'written to';
let useCounted = false;
function createWriterLockReleasedError(verb) {
return new TypeError(errWriterLockReleasedPrefix + verb);
}
const stateNames = {
[CLOSED]: 'closed',
[ERRORED]: 'errored'
};
function createCannotActionOnStateStreamError(action, state) {
return new TypeError(
templateErrorCannotActionOnStateStream(action, stateNames[state]));
}
function rejectPromises(queue, e) {
queue.forEach(promise => rejectPromise(promise, e));
}
class WritableStream {
constructor(underlyingSink = {}, strategy = {}) {
if (!useCounted) {
binding.countUse('WritableStreamConstructor');
useCounted = true;
}
InitializeWritableStream(this);
const type = underlyingSink.type;
const size = strategy.size;
let highWaterMark = strategy.highWaterMark;
if (type !== undefined) {
throw new RangeError(streamErrors.invalidType);
}
const sizeAlgorithm = MakeSizeAlgorithmFromSizeFunction(size);
if (highWaterMark === undefined) {
highWaterMark = 1;
}
highWaterMark = ValidateAndNormalizeHighWaterMark(highWaterMark);
SetUpWritableStreamDefaultControllerFromUnderlyingSink(
this, underlyingSink, highWaterMark, sizeAlgorithm);
}
get locked() {
if (!IsWritableStream(this)) {
throw new TypeError(streamErrors.illegalInvocation);
}
return IsWritableStreamLocked(this);
}
abort(reason) {
if (!IsWritableStream(this)) {
return Promise_reject(new TypeError(streamErrors.illegalInvocation));
}
if (IsWritableStreamLocked(this)) {
return Promise_reject(new TypeError(errAbortLockedStream));
}
return WritableStreamAbort(this, reason);
}
getWriter() {
if (!IsWritableStream(this)) {
throw new TypeError(streamErrors.illegalInvocation);
}
return AcquireWritableStreamDefaultWriter(this);
}
}
const WritableStream_prototype = WritableStream.prototype;
function AcquireWritableStreamDefaultWriter(stream) {
return new WritableStreamDefaultWriter(stream);
}
function CreateWritableStream(
startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm,
highWaterMark, sizeAlgorithm) {
if (highWaterMark === undefined) {
highWaterMark = 1;
}
if (sizeAlgorithm === undefined) {
sizeAlgorithm = () => 1;
}
const stream = ObjectCreate(WritableStream_prototype);
InitializeWritableStream(stream);
const controller = ObjectCreate(WritableStreamDefaultController_prototype);
SetUpWritableStreamDefaultController(
stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm,
abortAlgorithm, highWaterMark, sizeAlgorithm);
return stream;
}
function InitializeWritableStream(stream) {
stream[_stateAndFlags] = WRITABLE;
stream[_storedError] = undefined;
stream[_writer] = undefined;
stream[_writableStreamController] = undefined;
stream[_inFlightWriteRequest] = undefined;
stream[_closeRequest] = undefined;
stream[_inFlightCloseRequest] = undefined;
stream[_pendingAbortRequest] = undefined;
stream[_writeRequests] = new binding.SimpleQueue();
}
function IsWritableStream(x) {
return hasOwnPropertyNoThrow(x, _writableStreamController);
}
function IsWritableStreamLocked(stream) {
return stream[_writer] !== undefined;
}
function WritableStreamAbort(stream, reason) {
const state = stream[_stateAndFlags] & STATE_MASK;
if (state === CLOSED || state === ERRORED) {
return Promise_resolve(undefined);
}
if (stream[_pendingAbortRequest] !== undefined) {
return stream[_pendingAbortRequest].promise;
}
const wasAlreadyErroring = state === ERRORING;
if (wasAlreadyErroring) {
reason = undefined;
}
const promise = v8.createPromise();
stream[_pendingAbortRequest] = {promise, reason, wasAlreadyErroring};
if (!wasAlreadyErroring) {
WritableStreamStartErroring(stream, reason);
}
return promise;
}
function WritableStreamAddWriteRequest(stream) {
const promise = v8.createPromise();
stream[_writeRequests].push(promise);
return promise;
}
function WritableStreamDealWithRejection(stream, error) {
const state = stream[_stateAndFlags] & STATE_MASK;
if (state === WRITABLE) {
WritableStreamStartErroring(stream, error);
return;
}
WritableStreamFinishErroring(stream);
}
function WritableStreamStartErroring(stream, reason) {
const controller = stream[_writableStreamController];
stream[_stateAndFlags] = (stream[_stateAndFlags] & ~STATE_MASK) | ERRORING;
stream[_storedError] = reason;
const writer = stream[_writer];
if (writer !== undefined) {
WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason);
}
if (!WritableStreamHasOperationMarkedInFlight(stream) &&
controller[_started]) {
WritableStreamFinishErroring(stream);
}
}
function WritableStreamFinishErroring(stream) {
stream[_stateAndFlags] = (stream[_stateAndFlags] & ~STATE_MASK) | ERRORED;
WritableStreamDefaultControllerErrorSteps(
stream[_writableStreamController]);
const storedError = stream[_storedError];
rejectPromises(stream[_writeRequests], storedError);
stream[_writeRequests] = new binding.SimpleQueue();
if (stream[_pendingAbortRequest] === undefined) {
WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
return;
}
const abortRequest = stream[_pendingAbortRequest];
stream[_pendingAbortRequest] = undefined;
if (abortRequest.wasAlreadyErroring === true) {
rejectPromise(abortRequest.promise, storedError);
WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
return;
}
const promise = WritableStreamDefaultControllerAbortSteps(
stream[_writableStreamController], abortRequest.reason);
thenPromise(
promise,
() => {
resolvePromise(abortRequest.promise, undefined);
WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
},
reason => {
rejectPromise(abortRequest.promise, reason);
WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
});
}
function WritableStreamFinishInFlightWrite(stream) {
resolvePromise(stream[_inFlightWriteRequest], undefined);
stream[_inFlightWriteRequest] = undefined;
}
function WritableStreamFinishInFlightWriteWithError(stream, error) {
rejectPromise(stream[_inFlightWriteRequest], error);
stream[_inFlightWriteRequest] = undefined;
WritableStreamDealWithRejection(stream, error);
}
function WritableStreamFinishInFlightClose(stream) {
resolvePromise(stream[_inFlightCloseRequest], undefined);
stream[_inFlightCloseRequest] = undefined;
const state = stream[_stateAndFlags] & STATE_MASK;
if (state === ERRORING) {
stream[_storedError] = undefined;
if (stream[_pendingAbortRequest] !== undefined) {
resolvePromise(stream[_pendingAbortRequest].promise, undefined);
stream[_pendingAbortRequest] = undefined;
}
}
stream[_stateAndFlags] = (stream[_stateAndFlags] & ~STATE_MASK) | CLOSED;
const writer = stream[_writer];
if (writer !== undefined) {
resolvePromise(writer[_closedPromise], undefined);
}
}
function WritableStreamFinishInFlightCloseWithError(stream, error) {
rejectPromise(stream[_inFlightCloseRequest], error);
stream[_inFlightCloseRequest] = undefined;
if (stream[_pendingAbortRequest] !== undefined) {
rejectPromise(stream[_pendingAbortRequest].promise, error);
stream[_pendingAbortRequest] = undefined;
}
WritableStreamDealWithRejection(stream, error);
}
function WritableStreamCloseQueuedOrInFlight(stream) {
return stream[_closeRequest] !== undefined ||
stream[_inFlightCloseRequest] !== undefined;
}
function WritableStreamHasOperationMarkedInFlight(stream) {
return stream[_inFlightWriteRequest] !== undefined ||
stream[_inFlightCloseRequest] !== undefined;
}
function WritableStreamMarkCloseRequestInFlight(stream) {
stream[_inFlightCloseRequest] = stream[_closeRequest];
stream[_closeRequest] = undefined;
}
function WritableStreamMarkFirstWriteRequestInFlight(stream) {
const writeRequest = stream[_writeRequests].shift();
stream[_inFlightWriteRequest] = writeRequest;
}
function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
if (stream[_closeRequest] !== undefined) {
rejectPromise(stream[_closeRequest], stream[_storedError]);
stream[_closeRequest] = undefined;
}
const writer = stream[_writer];
if (writer !== undefined) {
rejectPromise(writer[_closedPromise], stream[_storedError]);
markPromiseAsHandled(writer[_closedPromise]);
}
}
function WritableStreamUpdateBackpressure(stream, backpressure) {
const writer = stream[_writer];
if (writer !== undefined &&
backpressure !== Boolean(stream[_stateAndFlags] & BACKPRESSURE_FLAG)) {
if (backpressure) {
writer[_readyPromise] = v8.createPromise();
} else {
resolvePromise(writer[_readyPromise], undefined);
}
}
if (backpressure) {
stream[_stateAndFlags] |= BACKPRESSURE_FLAG;
} else {
stream[_stateAndFlags] &= ~BACKPRESSURE_FLAG;
}
}
function isWritableStreamErrored(stream) {
return (stream[_stateAndFlags] & STATE_MASK) === ERRORED;
}
function isWritableStreamClosingOrClosed(stream) {
return WritableStreamCloseQueuedOrInFlight(stream) ||
(stream[_stateAndFlags] & STATE_MASK) === CLOSED;
}
function getWritableStreamStoredError(stream) {
return stream[_storedError];
}
function isWritableStreamWritable(stream) {
return  (stream[_stateAndFlags] & STATE_MASK) === WRITABLE;
}
function isWritableStreamErroring(stream) {
return  (stream[_stateAndFlags] & STATE_MASK) === ERRORING;
}
function getWritableStreamController(stream) {
return stream[_writableStreamController];
}
class WritableStreamDefaultWriter {
constructor(stream) {
if (!IsWritableStream(stream)) {
throw new TypeError(streamErrors.illegalConstructor);
}
if (IsWritableStreamLocked(stream)) {
throw new TypeError(streamErrors.illegalConstructor);
}
this[_ownerWritableStream] = stream;
stream[_writer] = this;
const state = stream[_stateAndFlags] & STATE_MASK;
switch (state) {
case WRITABLE: {
if (!WritableStreamCloseQueuedOrInFlight(stream) &&
stream[_stateAndFlags] & BACKPRESSURE_FLAG) {
this[_readyPromise] = v8.createPromise();
} else {
this[_readyPromise] = Promise_resolve(undefined);
}
this[_closedPromise] = v8.createPromise();
break;
}
case ERRORING: {
this[_readyPromise] = Promise_reject(stream[_storedError]);
markPromiseAsHandled(this[_readyPromise]);
this[_closedPromise] = v8.createPromise();
break;
}
case CLOSED: {
this[_readyPromise] = Promise_resolve(undefined);
this[_closedPromise] = Promise_resolve(undefined);
break;
}
default: {
const storedError = stream[_storedError];
this[_readyPromise] = Promise_reject(storedError);
markPromiseAsHandled(this[_readyPromise]);
this[_closedPromise] = Promise_reject(storedError);
markPromiseAsHandled(this[_closedPromise]);
break;
}
}
}
get closed() {
if (!IsWritableStreamDefaultWriter(this)) {
return Promise_reject(new TypeError(streamErrors.illegalInvocation));
}
return this[_closedPromise];
}
get desiredSize() {
if (!IsWritableStreamDefaultWriter(this)) {
throw new TypeError(streamErrors.illegalInvocation);
}
if (this[_ownerWritableStream] === undefined) {
throw createWriterLockReleasedError(verbUsedToGetTheDesiredSize);
}
return WritableStreamDefaultWriterGetDesiredSize(this);
}
get ready() {
if (!IsWritableStreamDefaultWriter(this)) {
return Promise_reject(new TypeError(streamErrors.illegalInvocation));
}
return this[_readyPromise];
}
abort(reason) {
if (!IsWritableStreamDefaultWriter(this)) {
return Promise_reject(new TypeError(streamErrors.illegalInvocation));
}
if (this[_ownerWritableStream] === undefined) {
return Promise_reject(createWriterLockReleasedError(verbAborted));
}
return WritableStreamDefaultWriterAbort(this, reason);
}
close() {
if (!IsWritableStreamDefaultWriter(this)) {
return Promise_reject(new TypeError(streamErrors.illegalInvocation));
}
const stream = this[_ownerWritableStream];
if (stream === undefined) {
return Promise_reject(createWriterLockReleasedError(verbClosed));
}
if (WritableStreamCloseQueuedOrInFlight(stream)) {
return Promise_reject(new TypeError(errCloseCloseRequestedStream));
}
return WritableStreamDefaultWriterClose(this);
}
releaseLock() {
if (!IsWritableStreamDefaultWriter(this)) {
throw new TypeError(streamErrors.illegalInvocation);
}
const stream = this[_ownerWritableStream];
if (stream === undefined) {
return;
}
WritableStreamDefaultWriterRelease(this);
}
write(chunk) {
if (!IsWritableStreamDefaultWriter(this)) {
return Promise_reject(new TypeError(streamErrors.illegalInvocation));
}
if (this[_ownerWritableStream] === undefined) {
return Promise_reject(createWriterLockReleasedError(verbWrittenTo));
}
return WritableStreamDefaultWriterWrite(this, chunk);
}
}
function IsWritableStreamDefaultWriter(x) {
return hasOwnPropertyNoThrow(x, _ownerWritableStream);
}
function WritableStreamDefaultWriterAbort(writer, reason) {
const stream = writer[_ownerWritableStream];
return WritableStreamAbort(stream, reason);
}
function WritableStreamDefaultWriterClose(writer) {
const stream = writer[_ownerWritableStream];
const state = stream[_stateAndFlags] & STATE_MASK;
if (state === CLOSED || state === ERRORED) {
return Promise_reject(
createCannotActionOnStateStreamError('close', state));
}
const promise = v8.createPromise();
stream[_closeRequest] = promise;
if ((stream[_stateAndFlags] & BACKPRESSURE_FLAG) && state === WRITABLE) {
resolvePromise(writer[_readyPromise], undefined);
}
WritableStreamDefaultControllerClose(stream[_writableStreamController]);
return promise;
}
function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) {
const stream = writer[_ownerWritableStream];
const state = stream[_stateAndFlags] & STATE_MASK;
if (WritableStreamCloseQueuedOrInFlight(stream) || state === CLOSED) {
return Promise_resolve(undefined);
}
if (state === ERRORED) {
return Promise_reject(stream[_storedError]);
}
return WritableStreamDefaultWriterClose(writer);
}
function WritableStreamDefaultWriterEnsureClosedPromiseRejected(
writer, error) {
if (promiseState(writer[_closedPromise]) === v8.kPROMISE_PENDING) {
rejectPromise(writer[_closedPromise], error);
} else {
writer[_closedPromise] = Promise_reject(error);
}
markPromiseAsHandled(writer[_closedPromise]);
}
function WritableStreamDefaultWriterEnsureReadyPromiseRejected(
writer, error) {
if (promiseState(writer[_readyPromise]) === v8.kPROMISE_PENDING) {
rejectPromise(writer[_readyPromise], error);
} else {
writer[_readyPromise] = Promise_reject(error);
}
markPromiseAsHandled(writer[_readyPromise]);
}
function WritableStreamDefaultWriterGetDesiredSize(writer) {
const stream = writer[_ownerWritableStream];
const state = stream[_stateAndFlags] & STATE_MASK;
if (state === ERRORED || state === ERRORING) {
return null;
}
if (state === CLOSED) {
return 0;
}
return WritableStreamDefaultControllerGetDesiredSize(
stream[_writableStreamController]);
}
function WritableStreamDefaultWriterRelease(writer) {
const stream = writer[_ownerWritableStream];
const releasedError = new TypeError(errReleasedWriterClosedPromise);
WritableStreamDefaultWriterEnsureReadyPromiseRejected(
writer, releasedError);
WritableStreamDefaultWriterEnsureClosedPromiseRejected(
writer, releasedError);
stream[_writer] = undefined;
writer[_ownerWritableStream] = undefined;
}
function WritableStreamDefaultWriterWrite(writer, chunk) {
const stream = writer[_ownerWritableStream];
const controller = stream[_writableStreamController];
const chunkSize =
WritableStreamDefaultControllerGetChunkSize(controller, chunk);
if (stream !== writer[_ownerWritableStream]) {
return Promise_reject(createWriterLockReleasedError(verbWrittenTo));
}
const state = stream[_stateAndFlags] & STATE_MASK;
if (state === ERRORED) {
return Promise_reject(stream[_storedError]);
}
if (WritableStreamCloseQueuedOrInFlight(stream)) {
return Promise_reject(new TypeError(
templateErrorCannotActionOnStateStream('write to', 'closing')));
}
if (state === CLOSED) {
return Promise_reject(
createCannotActionOnStateStreamError('write to', CLOSED));
}
if (state === ERRORING) {
return Promise_reject(stream[_storedError]);
}
const promise = WritableStreamAddWriteRequest(stream);
WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);
return promise;
}
function getWritableStreamDefaultWriterClosedPromise(writer) {
return writer[_closedPromise];
}
function getWritableStreamDefaultWriterReadyPromise(writer) {
return writer[_readyPromise];
}
class WritableStreamDefaultController {
constructor() {
throw new TypeError(streamErrors.illegalConstructor);
}
error(e) {
if (!IsWritableStreamDefaultController(this)) {
throw new TypeError(streamErrors.illegalInvocation);
}
const state =
this[_controlledWritableStream][_stateAndFlags] & STATE_MASK;
if (state !== WRITABLE) {
return;
}
WritableStreamDefaultControllerError(this, e);
}
}
const WritableStreamDefaultController_prototype =
WritableStreamDefaultController.prototype;
function WritableStreamDefaultControllerAbortSteps(controller, reason) {
return controller[_abortAlgorithm](reason);
}
function WritableStreamDefaultControllerErrorSteps(controller) {
ResetQueue(controller);
}
function IsWritableStreamDefaultController(x) {
return hasOwnPropertyNoThrow(x, _controlledWritableStream);
}
function SetUpWritableStreamDefaultController(
stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm,
abortAlgorithm, highWaterMark, sizeAlgorithm) {
controller[_controlledWritableStream] = stream;
stream[_writableStreamController] = controller;
controller[_queue] = undefined;
controller[_queueTotalSize] = undefined;
ResetQueue(controller);
controller[_started] = false;
controller[_strategySizeAlgorithm] = sizeAlgorithm;
controller[_strategyHWM] = highWaterMark;
controller[_writeAlgorithm] = writeAlgorithm;
controller[_closeAlgorithm] = closeAlgorithm;
controller[_abortAlgorithm] = abortAlgorithm;
const backpressure =
WritableStreamDefaultControllerGetBackpressure(controller);
WritableStreamUpdateBackpressure(stream, backpressure);
const startResult = startAlgorithm();
const startPromise = Promise_resolve(startResult);
thenPromise(
startPromise,
() => {
controller[_started] = true;
WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
},
r => {
controller[_started] = true;
WritableStreamDealWithRejection(stream, r);
});
}
function SetUpWritableStreamDefaultControllerFromUnderlyingSink(
stream, underlyingSink, highWaterMark, sizeAlgorithm) {
const controller = ObjectCreate(WritableStreamDefaultController_prototype);
const startAlgorithm =
() => CallOrNoop1(underlyingSink, 'start', controller,
'underlyingSink.start');
const writeAlgorithm = CreateAlgorithmFromUnderlyingMethodPassingController(
underlyingSink, 'write', 1, controller, 'underlyingSink.write');
const closeAlgorithm = CreateAlgorithmFromUnderlyingMethod(
underlyingSink, 'close', 0, 'underlyingSink.close');
const abortAlgorithm = CreateAlgorithmFromUnderlyingMethod(
underlyingSink, 'abort', 1, 'underlyingSink.abort');
SetUpWritableStreamDefaultController(stream, controller, startAlgorithm,
writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark,
sizeAlgorithm);
}
function WritableStreamDefaultControllerClose(controller) {
EnqueueValueWithSize(controller, 'close', 0);
WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
}
function WritableStreamDefaultControllerGetChunkSize(controller, chunk) {
try {
return Function_call(controller[_strategySizeAlgorithm], undefined,
chunk);
} catch (e) {
WritableStreamDefaultControllerErrorIfNeeded(controller, e);
return 1;
}
}
function WritableStreamDefaultControllerGetDesiredSize(controller) {
return controller[_strategyHWM] - controller[_queueTotalSize];
}
function WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) {
const writeRecord = {chunk};
try {
EnqueueValueWithSize(controller, writeRecord, chunkSize);
} catch (e) {
WritableStreamDefaultControllerErrorIfNeeded(controller, e);
return;
}
const stream = controller[_controlledWritableStream];
if (!WritableStreamCloseQueuedOrInFlight(stream) &&
(stream[_stateAndFlags] & STATE_MASK) === WRITABLE) {
const backpressure =
WritableStreamDefaultControllerGetBackpressure(controller);
WritableStreamUpdateBackpressure(stream, backpressure);
}
WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
}
function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
const stream = controller[_controlledWritableStream];
if (!controller[_started]) {
return;
}
if (stream[_inFlightWriteRequest] !== undefined) {
return;
}
const state = stream[_stateAndFlags] & STATE_MASK;
if (state === CLOSED || state === ERRORED) {
return;
}
if (state === ERRORING) {
WritableStreamFinishErroring(stream);
return;
}
if (controller[_queue].length === 0) {
return;
}
const writeRecord = PeekQueueValue(controller);
if (writeRecord === 'close') {
WritableStreamDefaultControllerProcessClose(controller);
} else {
WritableStreamDefaultControllerProcessWrite(
controller, writeRecord.chunk);
}
}
function WritableStreamDefaultControllerErrorIfNeeded(controller, error) {
const state =
controller[_controlledWritableStream][_stateAndFlags] & STATE_MASK;
if (state === WRITABLE) {
WritableStreamDefaultControllerError(controller, error);
}
}
function WritableStreamDefaultControllerProcessClose(controller) {
const stream = controller[_controlledWritableStream];
WritableStreamMarkCloseRequestInFlight(stream);
DequeueValue(controller);
const sinkClosePromise = controller[_closeAlgorithm]();
thenPromise(
sinkClosePromise, () => WritableStreamFinishInFlightClose(stream),
reason => WritableStreamFinishInFlightCloseWithError(stream, reason));
}
function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
const stream = controller[_controlledWritableStream];
WritableStreamMarkFirstWriteRequestInFlight(stream);
const sinkWritePromise = controller[_writeAlgorithm](chunk);
thenPromise(
sinkWritePromise,
() => {
WritableStreamFinishInFlightWrite(stream);
const state = stream[_stateAndFlags] & STATE_MASK;
DequeueValue(controller);
if (!WritableStreamCloseQueuedOrInFlight(stream) &&
state === WRITABLE) {
const backpressure =
WritableStreamDefaultControllerGetBackpressure(controller);
WritableStreamUpdateBackpressure(stream, backpressure);
}
WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
},
reason => {
WritableStreamFinishInFlightWriteWithError(stream, reason);
});
}
function WritableStreamDefaultControllerGetBackpressure(controller) {
const desiredSize =
WritableStreamDefaultControllerGetDesiredSize(controller);
return desiredSize <= 0;
}
function WritableStreamDefaultControllerError(controller, error) {
const stream = controller[_controlledWritableStream];
WritableStreamStartErroring(stream, error);
}
defineProperty(global, 'WritableStream', {
value: WritableStream,
enumerable: false,
configurable: true,
writable: true
});
binding.AcquireWritableStreamDefaultWriter =
AcquireWritableStreamDefaultWriter;
binding.IsWritableStream = IsWritableStream;
binding.isWritableStreamClosingOrClosed = isWritableStreamClosingOrClosed;
binding.isWritableStreamErrored = isWritableStreamErrored;
binding.IsWritableStreamLocked = IsWritableStreamLocked;
binding.WritableStreamAbort = WritableStreamAbort;
binding.WritableStreamDefaultWriterCloseWithErrorPropagation =
WritableStreamDefaultWriterCloseWithErrorPropagation;
binding.getWritableStreamDefaultWriterClosedPromise =
getWritableStreamDefaultWriterClosedPromise;
binding.WritableStreamDefaultWriterGetDesiredSize =
WritableStreamDefaultWriterGetDesiredSize;
binding.getWritableStreamDefaultWriterReadyPromise =
getWritableStreamDefaultWriterReadyPromise;
binding.WritableStreamDefaultWriterRelease =
WritableStreamDefaultWriterRelease;
binding.WritableStreamDefaultWriterWrite = WritableStreamDefaultWriterWrite;
binding.getWritableStreamStoredError = getWritableStreamStoredError;
binding.CreateWritableStream = CreateWritableStream;
binding.WritableStream = WritableStream;
binding.WritableStreamDefaultControllerErrorIfNeeded =
WritableStreamDefaultControllerErrorIfNeeded;
binding.isWritableStreamWritable = isWritableStreamWritable;
binding.isWritableStreamErroring = isWritableStreamErroring;
binding.getWritableStreamController = getWritableStreamController;
});
<TransformStreamu<6D>
(function(global, binding, v8) {
'use strict';
const _backpressure = v8.createPrivateSymbol('[[backpressure]]');
const _backpressureChangePromise =
v8.createPrivateSymbol('[[backpressureChangePromise]]');
const _readable = v8.createPrivateSymbol('[[readable]]');
const _transformStreamController =
v8.createPrivateSymbol('[[transformStreamController]]');
const _writable = v8.createPrivateSymbol('[[writable]]');
const _controlledTransformStream =
v8.createPrivateSymbol('[[controlledTransformStream]]');
const _flushAlgorithm = v8.createPrivateSymbol('[[flushAlgorithm]]');
const _transformAlgorithm = v8.createPrivateSymbol('[[transformAlgorithm]]');
const defineProperty = global.Object.defineProperty;
const ObjectCreate = global.Object.create;
const TypeError = global.TypeError;
const RangeError = global.RangeError;
const Promise = global.Promise;
const thenPromise = v8.uncurryThis(Promise.prototype.then);
const Promise_resolve = Promise.resolve.bind(Promise);
const Promise_reject = Promise.reject.bind(Promise);
const {
hasOwnPropertyNoThrow,
resolvePromise,
CreateAlgorithmFromUnderlyingMethodPassingController,
CallOrNoop1,
MakeSizeAlgorithmFromSizeFunction,
PromiseCall2,
ValidateAndNormalizeHighWaterMark
} = binding.streamOperations;
const streamErrors = binding.streamErrors;
const errStreamTerminated = 'The transform stream has been terminated';
let useCounted = false;
class TransformStream {
constructor(transformer = {},
writableStrategy = {}, readableStrategy = {}) {
if (!useCounted) {
binding.countUse('TransformStreamConstructor');
useCounted = true;
}
const readableType = transformer.readableType;
if (readableType !== undefined) {
throw new RangeError(streamErrors.invalidType);
}
const writableType = transformer.writableType;
if (writableType !== undefined) {
throw new RangeError(streamErrors.invalidType);
}
const writableSizeFunction = writableStrategy.size;
const writableSizeAlgorithm =
MakeSizeAlgorithmFromSizeFunction(writableSizeFunction);
let writableHighWaterMark = writableStrategy.highWaterMark;
if (writableHighWaterMark === undefined) {
writableHighWaterMark = 1;
}
writableHighWaterMark =
ValidateAndNormalizeHighWaterMark(writableHighWaterMark);
const readableSizeFunction = readableStrategy.size;
const readableSizeAlgorithm =
MakeSizeAlgorithmFromSizeFunction(readableSizeFunction);
let readableHighWaterMark = readableStrategy.highWaterMark;
if (readableHighWaterMark === undefined) {
readableHighWaterMark = 0;
}
readableHighWaterMark =
ValidateAndNormalizeHighWaterMark(readableHighWaterMark);
const startPromise = v8.createPromise();
InitializeTransformStream(
this, startPromise, writableHighWaterMark, writableSizeAlgorithm,
readableHighWaterMark, readableSizeAlgorithm);
SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);
const startResult = CallOrNoop1(
transformer, 'start', this[_transformStreamController],
'transformer.start');
resolvePromise(startPromise, startResult);
}
get readable() {
if (!IsTransformStream(this)) {
throw new TypeError(streamErrors.illegalInvocation);
}
return this[_readable];
}
get writable() {
if (!IsTransformStream(this)) {
throw new TypeError(streamErrors.illegalInvocation);
}
return this[_writable];
}
}
const TransformStream_prototype = TransformStream.prototype;
function CreateTransformStream(
startAlgorithm, transformAlgorithm, flushAlgorithm, writableHighWaterMark,
writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm) {
if (writableHighWaterMark === undefined) {
writableHighWaterMark = 1;
}
if (writableSizeAlgorithm === undefined) {
writableSizeAlgorithm = () => 1;
}
if (readableHighWaterMark === undefined) {
readableHighWaterMark = 0;
}
if (readableSizeAlgorithm === undefined) {
readableSizeAlgorithm = () => 1;
}
const stream = ObjectCreate(TransformStream_prototype);
const startPromise = v8.createPromise();
InitializeTransformStream(
stream, startPromise, writableHighWaterMark, writableSizeAlgorithm,
readableHighWaterMark, readableSizeAlgorithm);
const controller = ObjectCreate(TransformStreamDefaultController_prototype);
SetUpTransformStreamDefaultController(
stream, controller, transformAlgorithm, flushAlgorithm);
const startResult = startAlgorithm();
resolvePromise(startPromise, startResult);
return stream;
}
function InitializeTransformStream(
stream, startPromise, writableHighWaterMark, writableSizeAlgorithm,
readableHighWaterMark, readableSizeAlgorithm) {
const startAlgorithm = () => startPromise;
const writeAlgorithm = chunk =>
TransformStreamDefaultSinkWriteAlgorithm(stream, chunk);
const abortAlgorithm = reason =>
TransformStreamDefaultSinkAbortAlgorithm(stream, reason);
const closeAlgorithm = () =>
TransformStreamDefaultSinkCloseAlgorithm(stream);
stream[_writable] = binding.CreateWritableStream(
startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm,
writableHighWaterMark, writableSizeAlgorithm);
const pullAlgorithm = () =>
TransformStreamDefaultSourcePullAlgorithm(stream);
const cancelAlgorithm = reason => {
TransformStreamErrorWritableAndUnblockWrite(stream, reason);
return Promise_resolve(undefined);
};
stream[_readable] = binding.CreateReadableStream(
startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark,
readableSizeAlgorithm, false);
stream[_backpressure] = undefined;
stream[_backpressureChangePromise] = undefined;
TransformStreamSetBackpressure(stream, true);
stream[_transformStreamController] = undefined;
}
function IsTransformStream(x) {
return hasOwnPropertyNoThrow(x, _transformStreamController);
}
function TransformStreamError(stream, e) {
const readable = stream[_readable];
if (binding.IsReadableStreamReadable(readable)) {
binding.ReadableStreamDefaultControllerError(
binding.getReadableStreamController(readable), e);
}
TransformStreamErrorWritableAndUnblockWrite(stream, e);
}
function TransformStreamErrorWritableAndUnblockWrite(stream, e) {
binding.WritableStreamDefaultControllerErrorIfNeeded(
binding.getWritableStreamController(stream[_writable]), e);
if (stream[_backpressure]) {
TransformStreamSetBackpressure(stream, false);
}
}
function TransformStreamSetBackpressure(stream, backpressure) {
if (stream[_backpressureChangePromise] !== undefined) {
resolvePromise(stream[_backpressureChangePromise], undefined);
}
stream[_backpressureChangePromise] = v8.createPromise();
stream[_backpressure] = backpressure;
}
class TransformStreamDefaultController {
constructor() {
throw new TypeError(streamErrors.illegalConstructor);
}
get desiredSize() {
if (!IsTransformStreamDefaultController(this)) {
throw new TypeError(streamErrors.illegalInvocation);
}
const readableController = binding.getReadableStreamController(
this[_controlledTransformStream][_readable]);
return binding.ReadableStreamDefaultControllerGetDesiredSize(
readableController);
}
enqueue(chunk) {
if (!IsTransformStreamDefaultController(this)) {
throw new TypeError(streamErrors.illegalInvocation);
}
TransformStreamDefaultControllerEnqueue(this, chunk);
}
error(reason) {
if (!IsTransformStreamDefaultController(this)) {
throw new TypeError(streamErrors.illegalInvocation);
}
TransformStreamDefaultControllerError(this, reason);
}
terminate() {
if (!IsTransformStreamDefaultController(this)) {
throw new TypeError(streamErrors.illegalInvocation);
}
TransformStreamDefaultControllerTerminate(this);
}
}
const TransformStreamDefaultController_prototype =
TransformStreamDefaultController.prototype;
function IsTransformStreamDefaultController(x) {
return hasOwnPropertyNoThrow(x, _controlledTransformStream);
}
function SetUpTransformStreamDefaultController(
stream, controller, transformAlgorithm, flushAlgorithm) {
controller[_controlledTransformStream] = stream;
stream[_transformStreamController] = controller;
controller[_transformAlgorithm] = transformAlgorithm;
controller[_flushAlgorithm] = flushAlgorithm;
}
function SetUpTransformStreamDefaultControllerFromTransformer(
stream, transformer) {
const controller = ObjectCreate(TransformStreamDefaultController_prototype);
let transformAlgorithm;
const transformMethod = transformer.transform;
if (transformMethod !== undefined) {
if (typeof transformMethod !== 'function') {
throw new TypeError('transformer.transform is not a function');
}
transformAlgorithm = chunk => {
const transformPromise =
PromiseCall2(transformMethod, transformer, chunk, controller);
return thenPromise(transformPromise, undefined, e => {
TransformStreamError(stream, e);
throw e;
});
};
} else {
transformAlgorithm = chunk => {
try {
TransformStreamDefaultControllerEnqueue(controller, chunk);
return Promise_resolve();
} catch (resultValue) {
return Promise_reject(resultValue);
}
};
}
const flushAlgorithm = CreateAlgorithmFromUnderlyingMethodPassingController(
transformer, 'flush', 0, controller, 'transformer.flush');
SetUpTransformStreamDefaultController(
stream, controller, transformAlgorithm, flushAlgorithm);
}
function TransformStreamDefaultControllerEnqueue(controller, chunk) {
const stream = controller[_controlledTransformStream];
const readableController =
binding.getReadableStreamController(stream[_readable]);
if (!binding.ReadableStreamDefaultControllerCanCloseOrEnqueue(
readableController)) {
throw binding.getReadableStreamEnqueueError(stream[_readable]);
}
try {
binding.ReadableStreamDefaultControllerEnqueue(readableController, chunk);
} catch (e) {
TransformStreamErrorWritableAndUnblockWrite(stream, e);
throw binding.getReadableStreamStoredError(stream[_readable]);
}
const backpressure = binding.ReadableStreamDefaultControllerHasBackpressure(
readableController);
if (backpressure !== stream[_backpressure]) {
TransformStreamSetBackpressure(stream, true);
}
}
function TransformStreamDefaultControllerError(controller, e) {
TransformStreamError(controller[_controlledTransformStream], e);
}
function TransformStreamDefaultControllerTerminate(controller) {
const stream = controller[_controlledTransformStream];
const readableController =
binding.getReadableStreamController(stream[_readable]);
if (binding.ReadableStreamDefaultControllerCanCloseOrEnqueue(
readableController)) {
binding.ReadableStreamDefaultControllerClose(readableController);
}
const error = new TypeError(errStreamTerminated);
TransformStreamErrorWritableAndUnblockWrite(stream, error);
}
function TransformStreamDefaultSinkWriteAlgorithm(stream, chunk) {
const controller = stream[_transformStreamController];
if (stream[_backpressure]) {
const backpressureChangePromise = stream[_backpressureChangePromise];
return thenPromise(backpressureChangePromise, () => {
const writable = stream[_writable];
if (binding.isWritableStreamErroring(writable)) {
throw binding.getWritableStreamStoredError(writable);
}
return controller[_transformAlgorithm](chunk);
});
}
return controller[_transformAlgorithm](chunk);
}
function TransformStreamDefaultSinkAbortAlgorithm(stream, reason) {
TransformStreamError(stream, reason);
return Promise_resolve();
}
function TransformStreamDefaultSinkCloseAlgorithm(stream) {
const readable = stream[_readable];
const flushPromise = stream[_transformStreamController][_flushAlgorithm]();
return thenPromise(
flushPromise,
() => {
if (binding.IsReadableStreamErrored(readable)) {
throw binding.getReadableStreamStoredError(readable);
}
const readableController =
binding.getReadableStreamController(readable);
if (binding.ReadableStreamDefaultControllerCanCloseOrEnqueue(
readableController)) {
binding.ReadableStreamDefaultControllerClose(readableController);
}
},
r => {
TransformStreamError(stream, r);
throw binding.getReadableStreamStoredError(readable);
});
}
function TransformStreamDefaultSourcePullAlgorithm(stream) {
TransformStreamSetBackpressure(stream, false);
return stream[_backpressureChangePromise];
}
defineProperty(global, 'TransformStream', {
value: TransformStream,
enumerable: false,
configurable: true,
writable: true
});
binding.CreateTransformStream = CreateTransformStream;
});
dummy<(function() {})