diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/CefSharp.BrowserSubprocess.Core.dll b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/CefSharp.BrowserSubprocess.Core.dll new file mode 100644 index 0000000..9a7f3fc Binary files /dev/null and b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/CefSharp.BrowserSubprocess.Core.dll differ diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/CefSharp.BrowserSubprocess.exe b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/CefSharp.BrowserSubprocess.exe new file mode 100644 index 0000000..f8891fa Binary files /dev/null and b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/CefSharp.BrowserSubprocess.exe differ diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/cef.pak b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/cef.pak new file mode 100644 index 0000000..f40fe1a Binary files /dev/null and b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/cef.pak differ diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/cef_100_percent.pak b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/cef_100_percent.pak new file mode 100644 index 0000000..6dc4a19 Binary files /dev/null and b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/cef_100_percent.pak differ diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/cef_200_percent.pak b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/cef_200_percent.pak new file mode 100644 index 0000000..d3721d8 Binary files /dev/null and b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/cef_200_percent.pak differ diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/cef_extensions.pak b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/cef_extensions.pak new file mode 100644 index 0000000..a66463c Binary files /dev/null and b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/cef_extensions.pak differ diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/chrome_elf.dll b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/chrome_elf.dll new file mode 100644 index 0000000..6bb65f9 Binary files /dev/null and b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/chrome_elf.dll differ diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/d3dcompiler_47.dll b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/d3dcompiler_47.dll new file mode 100644 index 0000000..71220ae Binary files /dev/null and b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/d3dcompiler_47.dll differ diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/icudtl.dat b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/icudtl.dat new file mode 100644 index 0000000..9782827 Binary files /dev/null and b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/icudtl.dat differ diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/libEGL.dll b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/libEGL.dll new file mode 100644 index 0000000..030f757 Binary files /dev/null and b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/libEGL.dll differ diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/libGLESv2.dll b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/libGLESv2.dll new file mode 100644 index 0000000..3fbd1c8 Binary files /dev/null and b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/libGLESv2.dll differ diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/libcef.dll b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/libcef.dll new file mode 100644 index 0000000..4fab92f Binary files /dev/null and b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/libcef.dll differ diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/locales/en-US.pak b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/locales/en-US.pak new file mode 100644 index 0000000..2f6903b Binary files /dev/null and b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/locales/en-US.pak differ diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/natives_blob.bin b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/natives_blob.bin new file mode 100644 index 0000000..305d48a --- /dev/null +++ b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/natives_blob.bin @@ -0,0 +1,14203 @@ + mirrorsJ} +(function(a,b){ +"use strict"; +var c=a.Array; +var d=a.isNaN; +var e=a.JSON.stringify; +var f; +var g; +var h; +var i; +b.Import(function(j){ +f=j.MapEntries; +g=j.MapIteratorNext; +h=j.SetIteratorNext; +i=j.SetValues; +}); +var k={ +UNDEFINED_TYPE:'undefined', +NULL_TYPE:'null', +BOOLEAN_TYPE:'boolean', +NUMBER_TYPE:'number', +STRING_TYPE:'string', +SYMBOL_TYPE:'symbol', +OBJECT_TYPE:'object', +FUNCTION_TYPE:'function', +REGEXP_TYPE:'regexp', +ERROR_TYPE:'error', +PROPERTY_TYPE:'property', +INTERNAL_PROPERTY_TYPE:'internalProperty', +FRAME_TYPE:'frame', +SCRIPT_TYPE:'script', +CONTEXT_TYPE:'context', +SCOPE_TYPE:'scope', +PROMISE_TYPE:'promise', +MAP_TYPE:'map', +SET_TYPE:'set', +ITERATOR_TYPE:'iterator', +GENERATOR_TYPE:'generator', +} +var l=0; +var m=-1; +var n=[]; +var o=true; +function MirrorCacheIsEmpty(){ +return l==0&&n.length==0; +} +function ToggleMirrorCache(p){ +o=p; +ClearMirrorCache(); +} +function ClearMirrorCache(p){ +l=0; +n=[]; +} +function MakeMirror(p,q){ +var r; +if(!q&&o){ +for(var s in n){ +r=n[s]; +if(r.value()===p){ +return r; +} +if(r.isNumber()&&d(r.value())&& +typeof p=='number'&&d(p)){ +return r; +} +} +} +if((p===(void 0))){ +r=new UndefinedMirror(); +}else if((p===null)){ +r=new NullMirror(); +}else if((typeof(p)==='boolean')){ +r=new BooleanMirror(p); +}else if((typeof(p)==='number')){ +r=new NumberMirror(p); +}else if((typeof(p)==='string')){ +r=new StringMirror(p); +}else if((typeof(p)==='symbol')){ +r=new SymbolMirror(p); +}else if((%_IsArray(p))){ +r=new ArrayMirror(p); +}else if((%IsDate(p))){ +r=new DateMirror(p); +}else if((%IsFunction(p))){ +r=new FunctionMirror(p); +}else if(%IsRegExp(p)){ +r=new RegExpMirror(p); +}else if((%_ClassOf(p)==='Error')){ +r=new ErrorMirror(p); +}else if((%_ClassOf(p)==='Script')){ +r=new ScriptMirror(p); +}else if((%_ClassOf(p)==='Map')||(%_ClassOf(p)==='WeakMap')){ +r=new MapMirror(p); +}else if((%_ClassOf(p)==='Set')||(%_ClassOf(p)==='WeakSet')){ +r=new SetMirror(p); +}else if((%_ClassOf(p)==='Map Iterator')||(%_ClassOf(p)==='Set Iterator')){ +r=new IteratorMirror(p); +}else if(%is_promise(p)){ +r=new PromiseMirror(p); +}else if((%_ClassOf(p)==='Generator')){ +r=new GeneratorMirror(p); +}else{ +r=new ObjectMirror(p,k.OBJECT_TYPE,q); +} +if(o)n[r.handle()]=r; +return r; +} +function LookupMirror(t){ +if(!o){ +throw %make_error(2,"Mirror cache is disabled"); +} +return n[t]; +} +function GetUndefinedMirror(){ +return MakeMirror((void 0)); +} +function inherits(u,v){ +var w=function(){}; +w.prototype=v.prototype; +u.super_=v.prototype; +u.prototype=new w(); +u.prototype.constructor=u; +} +var x=80; +var y={}; +y.Data=0; +y.Accessor=1; +var z={}; +z.None=0; +z.ReadOnly=1; +z.DontEnum=2; +z.DontDelete=4; +var A={Global:0, +Local:1, +With:2, +Closure:3, +Catch:4, +Block:5, +Script:6, +Eval:7, +Module:8, +}; +function Mirror(B){ +this.type_=B; +} +Mirror.prototype.type=function(){ +return this.type_; +}; +Mirror.prototype.isValue=function(){ +return this instanceof ValueMirror; +}; +Mirror.prototype.isUndefined=function(){ +return this instanceof UndefinedMirror; +}; +Mirror.prototype.isNull=function(){ +return this instanceof NullMirror; +}; +Mirror.prototype.isBoolean=function(){ +return this instanceof BooleanMirror; +}; +Mirror.prototype.isNumber=function(){ +return this instanceof NumberMirror; +}; +Mirror.prototype.isString=function(){ +return this instanceof StringMirror; +}; +Mirror.prototype.isSymbol=function(){ +return this instanceof SymbolMirror; +}; +Mirror.prototype.isObject=function(){ +return this instanceof ObjectMirror; +}; +Mirror.prototype.isFunction=function(){ +return this instanceof FunctionMirror; +}; +Mirror.prototype.isUnresolvedFunction=function(){ +return this instanceof UnresolvedFunctionMirror; +}; +Mirror.prototype.isArray=function(){ +return this instanceof ArrayMirror; +}; +Mirror.prototype.isDate=function(){ +return this instanceof DateMirror; +}; +Mirror.prototype.isRegExp=function(){ +return this instanceof RegExpMirror; +}; +Mirror.prototype.isError=function(){ +return this instanceof ErrorMirror; +}; +Mirror.prototype.isPromise=function(){ +return this instanceof PromiseMirror; +}; +Mirror.prototype.isGenerator=function(){ +return this instanceof GeneratorMirror; +}; +Mirror.prototype.isProperty=function(){ +return this instanceof PropertyMirror; +}; +Mirror.prototype.isInternalProperty=function(){ +return this instanceof InternalPropertyMirror; +}; +Mirror.prototype.isFrame=function(){ +return this instanceof FrameMirror; +}; +Mirror.prototype.isScript=function(){ +return this instanceof ScriptMirror; +}; +Mirror.prototype.isContext=function(){ +return this instanceof ContextMirror; +}; +Mirror.prototype.isScope=function(){ +return this instanceof ScopeMirror; +}; +Mirror.prototype.isMap=function(){ +return this instanceof MapMirror; +}; +Mirror.prototype.isSet=function(){ +return this instanceof SetMirror; +}; +Mirror.prototype.isIterator=function(){ +return this instanceof IteratorMirror; +}; +Mirror.prototype.allocateHandle_=function(){ +if(o)this.handle_=l++; +}; +Mirror.prototype.allocateTransientHandle_=function(){ +this.handle_=m--; +}; +Mirror.prototype.toText=function(){ +return"#<"+this.constructor.name+">"; +}; +function ValueMirror(B,p,C){ +%_Call(Mirror,this,B); +this.value_=p; +if(!C){ +this.allocateHandle_(); +}else{ +this.allocateTransientHandle_(); +} +} +inherits(ValueMirror,Mirror); +Mirror.prototype.handle=function(){ +return this.handle_; +}; +ValueMirror.prototype.isPrimitive=function(){ +var B=this.type(); +return B==='undefined'|| +B==='null'|| +B==='boolean'|| +B==='number'|| +B==='string'|| +B==='symbol'; +}; +ValueMirror.prototype.value=function(){ +return this.value_; +}; +function UndefinedMirror(){ +%_Call(ValueMirror,this,k.UNDEFINED_TYPE,(void 0)); +} +inherits(UndefinedMirror,ValueMirror); +UndefinedMirror.prototype.toText=function(){ +return'undefined'; +}; +function NullMirror(){ +%_Call(ValueMirror,this,k.NULL_TYPE,null); +} +inherits(NullMirror,ValueMirror); +NullMirror.prototype.toText=function(){ +return'null'; +}; +function BooleanMirror(p){ +%_Call(ValueMirror,this,k.BOOLEAN_TYPE,p); +} +inherits(BooleanMirror,ValueMirror); +BooleanMirror.prototype.toText=function(){ +return this.value_?'true':'false'; +}; +function NumberMirror(p){ +%_Call(ValueMirror,this,k.NUMBER_TYPE,p); +} +inherits(NumberMirror,ValueMirror); +NumberMirror.prototype.toText=function(){ +return %_NumberToString(this.value_); +}; +function StringMirror(p){ +%_Call(ValueMirror,this,k.STRING_TYPE,p); +} +inherits(StringMirror,ValueMirror); +StringMirror.prototype.length=function(){ +return this.value_.length; +}; +StringMirror.prototype.getTruncatedValue=function(D){ +if(D!=-1&&this.length()>D){ +return this.value_.substring(0,D)+ +'... (length: '+this.length()+')'; +} +return this.value_; +}; +StringMirror.prototype.toText=function(){ +return this.getTruncatedValue(x); +}; +function SymbolMirror(p){ +%_Call(ValueMirror,this,k.SYMBOL_TYPE,p); +} +inherits(SymbolMirror,ValueMirror); +SymbolMirror.prototype.description=function(){ +return %SymbolDescription(%ValueOf(this.value_)); +} +SymbolMirror.prototype.toText=function(){ +return %SymbolDescriptiveString(%ValueOf(this.value_)); +} +function ObjectMirror(p,B,C){ +B=B||k.OBJECT_TYPE; +%_Call(ValueMirror,this,B,p,C); +} +inherits(ObjectMirror,ValueMirror); +ObjectMirror.prototype.className=function(){ +return %_ClassOf(this.value_); +}; +ObjectMirror.prototype.constructorFunction=function(){ +return MakeMirror(%DebugGetProperty(this.value_,'constructor')); +}; +ObjectMirror.prototype.prototypeObject=function(){ +return MakeMirror(%DebugGetProperty(this.value_,'prototype')); +}; +ObjectMirror.prototype.protoObject=function(){ +return MakeMirror(%DebugGetPrototype(this.value_)); +}; +ObjectMirror.prototype.hasNamedInterceptor=function(){ +var E=%GetInterceptorInfo(this.value_); +return(E&2)!=0; +}; +ObjectMirror.prototype.hasIndexedInterceptor=function(){ +var E=%GetInterceptorInfo(this.value_); +return(E&1)!=0; +}; +ObjectMirror.prototype.propertyNames=function(){ +return %GetOwnPropertyKeys(this.value_,0); +}; +ObjectMirror.prototype.properties=function(){ +var F=this.propertyNames(); +var G=new c(F.length); +for(var H=0;H'; +}; +ObjectMirror.GetInternalProperties=function(p){ +var G=%DebugGetInternalProperties(p); +var M=[]; +for(var H=0;HT)return new c(); +var U=new c(T-S+1); +for(var H=S;H<=T;H++){ +var J=%DebugGetPropertyDetails(this.value_,(%_ToString(H))); +var p; +if(J){ +p=new PropertyMirror(this,H,J); +}else{ +p=GetUndefinedMirror(); +} +U[H-S]=p; +} +return U; +}; +function DateMirror(p){ +%_Call(ObjectMirror,this,p); +} +inherits(DateMirror,ObjectMirror); +DateMirror.prototype.toText=function(){ +var V=e(this.value_); +return V.substring(1,V.length-1); +}; +function RegExpMirror(p){ +%_Call(ObjectMirror,this,p,k.REGEXP_TYPE); +} +inherits(RegExpMirror,ObjectMirror); +RegExpMirror.prototype.source=function(){ +return this.value_.source; +}; +RegExpMirror.prototype.global=function(){ +return this.value_.global; +}; +RegExpMirror.prototype.ignoreCase=function(){ +return this.value_.ignoreCase; +}; +RegExpMirror.prototype.multiline=function(){ +return this.value_.multiline; +}; +RegExpMirror.prototype.sticky=function(){ +return this.value_.sticky; +}; +RegExpMirror.prototype.unicode=function(){ +return this.value_.unicode; +}; +RegExpMirror.prototype.toText=function(){ +return"/"+this.source()+"/"; +}; +function ErrorMirror(p){ +%_Call(ObjectMirror,this,p,k.ERROR_TYPE); +} +inherits(ErrorMirror,ObjectMirror); +ErrorMirror.prototype.message=function(){ +return this.value_.message; +}; +ErrorMirror.prototype.toText=function(){ +var W; +try{ +W=%ErrorToString(this.value_); +}catch(e){ +W='#'; +} +return W; +}; +function PromiseMirror(p){ +%_Call(ObjectMirror,this,p,k.PROMISE_TYPE); +} +inherits(PromiseMirror,ObjectMirror); +function PromiseGetStatus_(p){ +var X=%PromiseStatus(p); +if(X==0)return"pending"; +if(X==1)return"resolved"; +return"rejected"; +} +function PromiseGetValue_(p){ +return %PromiseResult(p); +} +PromiseMirror.prototype.status=function(){ +return PromiseGetStatus_(this.value_); +}; +PromiseMirror.prototype.promiseValue=function(){ +return MakeMirror(PromiseGetValue_(this.value_)); +}; +function MapMirror(p){ +%_Call(ObjectMirror,this,p,k.MAP_TYPE); +} +inherits(MapMirror,ObjectMirror); +MapMirror.prototype.entries=function(Y){ +var M=[]; +if((%_ClassOf(this.value_)==='WeakMap')){ +var Z=%GetWeakMapEntries(this.value_,Y||0); +for(var H=0;H3){ +this.exception_=J[3]; +this.getter_=J[4]; +this.setter_=J[5]; +} +} +inherits(PropertyMirror,Mirror); +PropertyMirror.prototype.isReadOnly=function(){ +return(this.attributes()&z.ReadOnly)!=0; +}; +PropertyMirror.prototype.isEnum=function(){ +return(this.attributes()&z.DontEnum)==0; +}; +PropertyMirror.prototype.canDelete=function(){ +return(this.attributes()&z.DontDelete)==0; +}; +PropertyMirror.prototype.name=function(){ +return this.name_; +}; +PropertyMirror.prototype.toText=function(){ +if((typeof(this.name_)==='symbol'))return %SymbolDescriptiveString(this.name_); +return this.name_; +}; +PropertyMirror.prototype.isIndexed=function(){ +for(var H=0;H0; +}; +FrameDetails.prototype.inlinedFrameIndex=function(){ +%CheckExecutionState(this.break_id_); +var ay=aw; +return(this.details_[ap]&ay)>>2; +}; +FrameDetails.prototype.argumentCount=function(){ +%CheckExecutionState(this.break_id_); +return this.details_[ak]; +}; +FrameDetails.prototype.argumentName=function(P){ +%CheckExecutionState(this.break_id_); +if(P>=0&&P=0&&P=0&&P=0&&P0){ +for(var H=0;H0){ +M+=this.lineOffset(); +M+='-'; +M+=this.lineOffset()+this.lineCount()-1; +}else{ +M+=this.lineCount(); +} +M+=')'; +return M; +}; +function ContextMirror(aZ){ +%_Call(Mirror,this,k.CONTEXT_TYPE); +this.data_=aZ; +this.allocateHandle_(); +} +inherits(ContextMirror,Mirror); +ContextMirror.prototype.data=function(){ +return this.data_; +}; +function MakeMirrorSerializer(J,ba){ +return new JSONProtocolSerializer(J,ba); +} +function JSONProtocolSerializer(J,ba){ +this.details_=J; +this.options_=ba; +this.mirrors_=[]; +} +JSONProtocolSerializer.prototype.serializeReference=function(r){ +return this.serialize_(r,true,true); +}; +JSONProtocolSerializer.prototype.serializeValue=function(r){ +var bb=this.serialize_(r,false,true); +return bb; +}; +JSONProtocolSerializer.prototype.serializeReferencedObjects=function(){ +var bc=[]; +var bd=this.mirrors_.length; +for(var H=0;Hthis.maxStringLength_()){ +var bf=r.getTruncatedValue(this.maxStringLength_()); +bc.value=bf; +bc.fromIndex=0; +bc.toIndex=this.maxStringLength_(); +}else{ +bc.value=r.value(); +} +bc.length=r.length(); +break; +case k.SYMBOL_TYPE: +bc.description=r.description(); +break; +case k.OBJECT_TYPE: +case k.FUNCTION_TYPE: +case k.ERROR_TYPE: +case k.REGEXP_TYPE: +case k.PROMISE_TYPE: +case k.GENERATOR_TYPE: +this.serializeObject_(r,bc,J); +break; +case k.PROPERTY_TYPE: +case k.INTERNAL_PROPERTY_TYPE: +throw %make_error(2, +'PropertyMirror cannot be serialized independently'); +break; +case k.FRAME_TYPE: +this.serializeFrame_(r,bc); +break; +case k.SCOPE_TYPE: +this.serializeScope_(r,bc); +break; +case k.SCRIPT_TYPE: +if(r.name()){ +bc.name=r.name(); +} +bc.id=r.id(); +bc.lineOffset=r.lineOffset(); +bc.columnOffset=r.columnOffset(); +bc.lineCount=r.lineCount(); +if(r.data()){ +bc.data=r.data(); +} +if(this.includeSource_()){ +bc.source=r.source(); +}else{ +var bg=r.source().substring(0,80); +bc.sourceStart=bg; +} +bc.sourceLength=r.source().length; +bc.scriptType=r.scriptType(); +bc.compilationType=r.compilationType(); +if(r.compilationType()==1&& +r.evalFromScript()){ +bc.evalFromScript= +this.serializeReference(r.evalFromScript()); +var bh=r.evalFromLocation(); +if(bh){ +bc.evalFromLocation={line:bh.line, +column:bh.column}; +} +if(r.evalFromFunctionName()){ +bc.evalFromFunctionName=r.evalFromFunctionName(); +} +} +if(r.context()){ +bc.context=this.serializeReference(r.context()); +} +break; +case k.CONTEXT_TYPE: +bc.data=r.data(); +break; +} +bc.text=r.toText(); +return bc; +}; +JSONProtocolSerializer.prototype.serializeObject_=function(r,bc, +J){ +bc.className=r.className(); +bc.constructorFunction= +this.serializeReference(r.constructorFunction()); +bc.protoObject=this.serializeReference(r.protoObject()); +bc.prototypeObject=this.serializeReference(r.prototypeObject()); +if(r.hasNamedInterceptor()){ +bc.namedInterceptor=true; +} +if(r.hasIndexedInterceptor()){ +bc.indexedInterceptor=true; +} +if(r.isFunction()){ +bc.name=r.name(); +if(!(r.inferredName()===(void 0))){ +bc.inferredName=r.inferredName(); +} +bc.resolved=r.resolved(); +if(r.resolved()){ +bc.source=r.source(); +} +if(r.script()){ +bc.script=this.serializeReference(r.script()); +bc.scriptId=r.script().id(); +serializeLocationFields(r.sourceLocation(),bc); +} +bc.scopes=[]; +for(var H=0;H0){ +var bl=[]; +for(var H=0;H0){ +return'Infinity'; +}else{ +return'-Infinity'; +} +} +return p; +} +b.InstallFunctions(a,2,[ +"MakeMirror",MakeMirror, +"MakeMirrorSerializer",MakeMirrorSerializer, +"LookupMirror",LookupMirror, +"ToggleMirrorCache",ToggleMirrorCache, +"MirrorCacheIsEmpty",MirrorCacheIsEmpty, +]); +b.InstallConstants(a,[ +"ScopeType",A, +"PropertyType",y, +"PropertyAttribute",z, +"Mirror",Mirror, +"ValueMirror",ValueMirror, +"UndefinedMirror",UndefinedMirror, +"NullMirror",NullMirror, +"BooleanMirror",BooleanMirror, +"NumberMirror",NumberMirror, +"StringMirror",StringMirror, +"SymbolMirror",SymbolMirror, +"ObjectMirror",ObjectMirror, +"FunctionMirror",FunctionMirror, +"UnresolvedFunctionMirror",UnresolvedFunctionMirror, +"ArrayMirror",ArrayMirror, +"DateMirror",DateMirror, +"RegExpMirror",RegExpMirror, +"ErrorMirror",ErrorMirror, +"PromiseMirror",PromiseMirror, +"MapMirror",MapMirror, +"SetMirror",SetMirror, +"IteratorMirror",IteratorMirror, +"GeneratorMirror",GeneratorMirror, +"PropertyMirror",PropertyMirror, +"InternalPropertyMirror",InternalPropertyMirror, +"FrameMirror",FrameMirror, +"ScriptMirror",ScriptMirror, +"ScopeMirror",ScopeMirror, +"FrameDetails",FrameDetails, +]); +b.InstallFunctions(b,2,[ +"ClearMirrorCache",ClearMirrorCache +]); +b.Export(function(bt){ +bt.MirrorType=k; +}); +}) + +debugêL +(function(a,b){ +"use strict"; +var c=a.FrameMirror; +var d=a.Array; +var e=a.RegExp; +var f=a.isNaN; +var g=a.JSON.parse; +var h=a.JSON.stringify; +var i=a.LookupMirror; +var j=a.MakeMirror; +var k=a.MakeMirrorSerializer; +var l=a.Math.min; +var m=a.Mirror; +var n; +var o=a.parseInt; +var p=a.ValueMirror; +b.Import(function(q){ +n=q.MirrorType; +}); +var r=10; +var s={}; +var t=/^(?:\s*(?:\/\*.*?\*\/)*)*/; +s.DebugEvent={Break:1, +Exception:2, +AfterCompile:3, +CompileError:4, +AsyncTaskEvent:5}; +s.ExceptionBreak={Caught:0, +Uncaught:1}; +s.StepAction={StepOut:0, +StepNext:1, +StepIn:2, +StepFrame:3}; +s.ScriptType={Native:0, +Extension:1, +Normal:2, +Wasm:3}; +s.ScriptCompilationType={Host:0, +Eval:1, +JSON:2}; +s.ScriptBreakPointType={ScriptId:0, +ScriptName:1, +ScriptRegExp:2}; +s.BreakPositionAlignment={ +Statement:0, +BreakPosition:1 +}; +function ScriptTypeFlag(u){ +return(1<=this.frameCount()){ +throw %make_type_error(32); +} +return new c(this.break_id,au); +}; +ExecutionState.prototype.setSelectedFrame=function(av){ +var J=(%_ToNumber(av)); +if(J<0||J>=this.frameCount()){ +throw %make_type_error(32); +} +this.selected_frame=J; +}; +ExecutionState.prototype.selectedFrame=function(){ +return this.selected_frame; +}; +ExecutionState.prototype.debugCommandProcessor=function(aw){ +return new DebugCommandProcessor(this,aw); +}; +function MakeBreakEvent(H,ax){ +return new BreakEvent(H,ax); +} +function BreakEvent(H,ax){ +this.frame_=new c(H,0); +this.break_points_hit_=ax; +} +BreakEvent.prototype.eventType=function(){ +return s.DebugEvent.Break; +}; +BreakEvent.prototype.func=function(){ +return this.frame_.func(); +}; +BreakEvent.prototype.sourceLine=function(){ +return this.frame_.sourceLine(); +}; +BreakEvent.prototype.sourceColumn=function(){ +return this.frame_.sourceColumn(); +}; +BreakEvent.prototype.sourceLineText=function(){ +return this.frame_.sourceLineText(); +}; +BreakEvent.prototype.breakPointsHit=function(){ +return this.break_points_hit_; +}; +BreakEvent.prototype.toJSONProtocol=function(){ +var ay={seq:v++, +type:"event", +event:"break", +body:{invocationText:this.frame_.invocationText()} +}; +var M=this.func().script(); +if(M){ +ay.body.sourceLine=this.sourceLine(), +ay.body.sourceColumn=this.sourceColumn(), +ay.body.sourceLineText=this.sourceLineText(), +ay.body.script=MakeScriptObject_(M,false); +} +if(this.breakPointsHit()){ +ay.body.breakpoints=[]; +for(var J=0;J0){ +ay.body.sourceLine=this.sourceLine(); +ay.body.sourceColumn=this.sourceColumn(); +ay.body.sourceLineText=this.sourceLineText(); +var M=this.func().script(); +if(M){ +ay.body.script=MakeScriptObject_(M,false); +} +}else{ +ay.body.sourceLine=-1; +} +return ay.toJSONProtocol(); +}; +function MakeCompileEvent(M,u){ +return new CompileEvent(M,u); +} +function CompileEvent(M,u){ +this.script_=j(M); +this.type_=u; +} +CompileEvent.prototype.eventType=function(){ +return this.type_; +}; +CompileEvent.prototype.script=function(){ +return this.script_; +}; +CompileEvent.prototype.toJSONProtocol=function(){ +var ay=new ProtocolMessage(); +ay.running=true; +switch(this.type_){ +case s.DebugEvent.BeforeCompile: +ay.event="beforeCompile"; +break; +case s.DebugEvent.AfterCompile: +ay.event="afterCompile"; +break; +case s.DebugEvent.CompileError: +ay.event="compileError"; +break; +} +ay.body={}; +ay.body.script=this.script_; +return ay.toJSONProtocol(); +}; +function MakeScriptObject_(M,aE){ +var ay={id:M.id(), +name:M.name(), +lineOffset:M.lineOffset(), +columnOffset:M.columnOffset(), +lineCount:M.lineCount(), +}; +if(!(M.data()===(void 0))){ +ay.data=M.data(); +} +if(aE){ +ay.source=M.source(); +} +return ay; +} +function MakeAsyncTaskEvent(u,aF){ +return new AsyncTaskEvent(u,aF); +} +function AsyncTaskEvent(u,aF){ +this.type_=u; +this.id_=aF; +} +AsyncTaskEvent.prototype.type=function(){ +return this.type_; +} +AsyncTaskEvent.prototype.id=function(){ +return this.id_; +} +function DebugCommandProcessor(F,aw){ +this.exec_state_=F; +this.running_=aw||false; +} +DebugCommandProcessor.prototype.processDebugRequest=function(aG){ +return this.processDebugJSONRequest(aG); +}; +function ProtocolMessage(aG){ +this.seq=v++; +if(aG){ +this.type='response'; +this.request_seq=aG.seq; +this.command=aG.command; +}else{ +this.type='event'; +} +this.success=true; +this.running=(void 0); +} +ProtocolMessage.prototype.setOption=function(aH,A){ +if(!this.options_){ +this.options_={}; +} +this.options_[aH]=A; +}; +ProtocolMessage.prototype.failed=function(aI,aJ){ +this.success=false; +this.message=aI; +if((typeof(aJ)==='object')){ +this.error_details=aJ; +} +}; +ProtocolMessage.prototype.toJSONProtocol=function(){ +var aK={}; +aK.seq=this.seq; +if(this.request_seq){ +aK.request_seq=this.request_seq; +} +aK.type=this.type; +if(this.event){ +aK.event=this.event; +} +if(this.command){ +aK.command=this.command; +} +if(this.success){ +aK.success=this.success; +}else{ +aK.success=false; +} +if(this.body){ +var aL; +var aM=k(true,this.options_); +if(this.body instanceof m){ +aL=aM.serializeValue(this.body); +}else if(this.body instanceof d){ +aL=[]; +for(var J=0;J=this.exec_state_.frameCount()){ +return aN.failed('Invalid frame "'+bl+'"'); +} +aN.body=this.exec_state_.frame(bx).evaluate(bw); +return; +}else{ +aN.body=this.exec_state_.frame().evaluate(bw); +return; +} +}; +DebugCommandProcessor.prototype.lookupRequest_=function(aG,aN){ +if(!aG.arguments){ +return aN.failed('Missing arguments'); +} +var by=aG.arguments.handles; +if((by===(void 0))){ +return aN.failed('Argument "handles" missing'); +} +if(!(aG.arguments.includeSource===(void 0))){ +var bz=(!!(aG.arguments.includeSource)); +aN.setOption('includeSource',bz); +} +var bA={}; +for(var J=0;J=this.exec_state_.frameCount()){ +return aN.failed('Invalid frame "'+bl+'"'); +} +bl=this.exec_state_.frame(bx); +} +} +var M=bl.func().script(); +if(!M){ +return aN.failed('No source'); +} +var bD=M.value(); +var bE=bD.line_offset; +var bF=%ScriptLineCount(bD); +bB=(bB===(void 0))?0:bB-bE; +bC=(bC===(void 0))?bF:bC-bE; +if(bB<0)bB=0; +if(bC>bF)bC=bF; +if(bB>=bF||bC<0||bB>bC){ +return aN.failed('Invalid line interval'); +} +aN.body={}; +aN.body.fromLine=bB+bE; +aN.body.toLine=bC+bE; +aN.body.fromPosition=%ScriptLineStartPosition(bD,bB); +aN.body.toPosition= +(bC==0)?0:%ScriptLineEndPosition(bD,bC-1); +aN.body.totalLines=%ScriptLineCount(bD); +aN.body.source=%_SubString(bD.source, +aN.body.fromPosition, +aN.body.toPosition); +}; +DebugCommandProcessor.prototype.scriptsRequest_=function(aG,aN){ +var bG=ScriptTypeFlag(s.ScriptType.Normal); +var bz=false; +var bH=null; +if(aG.arguments){ +if(!(aG.arguments.types===(void 0))){ +bG=(%_ToNumber(aG.arguments.types)); +if(f(bG)||bG<0){ +return aN.failed('Invalid types "'+ +aG.arguments.types+'"'); +} +} +if(!(aG.arguments.includeSource===(void 0))){ +bz=(!!(aG.arguments.includeSource)); +aN.setOption('includeSource',bz); +} +if((%_IsArray(aG.arguments.ids))){ +bH={}; +var bI=aG.arguments.ids; +for(var J=0;J=0){ +bM=true; +} +} +if(!bM)continue; +} +if(bG&ScriptTypeFlag(V[J].type)){ +aN.body.push(j(V[J])); +} +} +}; +DebugCommandProcessor.prototype.suspendRequest_=function(aG,aN){ +aN.running=false; +}; +DebugCommandProcessor.prototype.versionRequest_=function(aG,aN){ +aN.body={ +V8Version:%GetV8Version() +}; +}; +DebugCommandProcessor.prototype.changeLiveRequest_=function( +aG,aN){ +if(!aG.arguments){ +return aN.failed('Missing arguments'); +} +var bN=aG.arguments.script_id; +var bO=!!aG.arguments.preview_only; +var bP=scriptById(bN); +if(!bP){ +aN.failed('Script not found'); +return; +} +var bQ=new d(); +if(!(typeof(aG.arguments.new_source)==='string')){ +throw"new_source argument expected"; +} +var bR=aG.arguments.new_source; +var bS; +try{ +bS=s.LiveEdit.SetScriptSource(bP, +bR,bO,bQ); +}catch(e){ +if(e instanceof s.LiveEdit.Failure&&"details"in e){ +aN.failed(e.message,e.details); +return; +} +throw e; +} +aN.body={change_log:bQ,result:bS}; +if(!bO&&!this.running_&&bS.stack_modified){ +aN.body.stepin_recommended=true; +} +}; +DebugCommandProcessor.prototype.restartFrameRequest_=function( +aG,aN){ +if(!aG.arguments){ +return aN.failed('Missing arguments'); +} +var bl=aG.arguments.frame; +if(this.exec_state_.frameCount()==0){ +return aN.failed('No frames'); +} +var bT; +if(!(bl===(void 0))){ +var bx=(%_ToNumber(bl)); +if(bx<0||bx>=this.exec_state_.frameCount()){ +return aN.failed('Invalid frame "'+bl+'"'); +} +bT=this.exec_state_.frame(bx); +}else{ +bT=this.exec_state_.frame(); +} +var bS=bT.restart(); +aN.body={result:bS}; +}; +DebugCommandProcessor.prototype.debuggerFlagsRequest_=function(aG, +aN){ +if(!aG.arguments){ +aN.failed('Missing arguments'); +return; +} +var bU=aG.arguments.flags; +aN.body={flags:[]}; +if(!(bU===(void 0))){ +for(var J=0;Jf(max,info.function_literal_id),0); +var q=BuildCodeInfoTree(m); +FindCorrespondingFunctions(k,q); +var r=new d(); +var s=new d(); +var t=new d(); +var u=new d(); +function HarvestTodo(v){ +function CollectDamaged(w){ +s.push(w); +for(var x=0;xO[E].start_position){ +R=E; +} +} +if(R!=x){ +var S=O[R]; +var T=P[R]; +O[R]=O[x]; +P[R]=P[x]; +O[x]=S; +P[x]=T; +} +} +var U=0; +function ResetIndexes(V,W){ +var X=-1; +while(U=ay.pos1+ay.len1){ +return as+ay.pos2+ay.len2-ay.pos1-ay.len1; +} +if(!at){ +at=PosTranslator.DefaultInsideChunkHandler; +} +return at(as,ay); +}; +PosTranslator.DefaultInsideChunkHandler=function(as,az){ +Assert(false,"Cannot translate position in changed area"); +}; +PosTranslator.ShiftWithTopInsideChunkHandler= +function(as,az){ +return as-az.pos1+az.pos2; +}; +var h={ +UNCHANGED:"unchanged", +SOURCE_CHANGED:"source changed", +CHANGED:"changed", +DAMAGED:"damaged" +}; +function CodeInfoTreeNode(aA,aB,aC){ +this.info=aA; +this.children=aB; +this.array_index=aC; +this.parent=(void 0); +this.status=h.UNCHANGED; +this.status_explanation=(void 0); +this.new_start_pos=(void 0); +this.new_end_pos=(void 0); +this.corresponding_node=(void 0); +this.unmatched_new_nodes=(void 0); +this.textual_corresponding_node=(void 0); +this.textually_unmatched_new_nodes=(void 0); +this.live_shared_function_infos=(void 0); +} +function BuildCodeInfoTree(aD){ +var aE=0; +function BuildNode(){ +var aF=aE; +aE++; +var aG=new d(); +while(aE=am.length;}; +this.TranslatePos=function(as){return as+aL;}; +}; +function ProcessInternals(aM){ +aM.new_start_pos=aJ.TranslatePos( +aM.info.start_position); +var aN=0; +var aO=false; +var aP=false; +while(!aJ.done()&& +aJ.current().pos1= +aJ.current().pos1+aJ.current().len1){ +aO=true; +aJ.next(); +continue; +}else if(aQ.info.start_position<=aJ.current().pos1&& +aQ.info.end_position>=aJ.current().pos1+ +aJ.current().len1){ +ProcessInternals(aQ); +aP=aP|| +(aQ.status!=h.UNCHANGED); +aO=aO|| +(aQ.status==h.DAMAGED); +aN++; +continue; +}else{ +aO=true; +aQ.status=h.DAMAGED; +aQ.status_explanation= +"Text diff overlaps with function boundary"; +aN++; +continue; +} +}else{ +if(aJ.current().pos1+aJ.current().len1<= +aM.info.end_position){ +aM.status=h.CHANGED; +aJ.next(); +continue; +}else{ +aM.status=h.DAMAGED; +aM.status_explanation= +"Text diff overlaps with function boundary"; +return; +} +} +Assert("Unreachable",false); +} +while(aN0){ +return bd; +} +} +function TraverseTree(w){ +w.live_shared_function_infos=FindFunctionInfos(w.info); +for(var x=0;x ["+bl+"]"; +} +return; +} +var bm; +function CheckStackActivations(old_shared_wrapper_list, +new_shared_list, +Z){ +var bn=new d(); +for(var x=0;x0){ +Z.push({dropped_from_stack:bq}); +} +if(bp.length>0){ +Z.push({functions_on_stack:bp}); +throw new Failure("Blocked by functions on stack"); +} +return bq.length; +} +var bm={ +AVAILABLE_FOR_PATCH:1, +BLOCKED_ON_ACTIVE_STACK:2, +BLOCKED_ON_OTHER_STACK:3, +BLOCKED_UNDER_NATIVE_CODE:4, +REPLACED_ON_ACTIVE_STACK:5, +BLOCKED_UNDER_GENERATOR:6, +BLOCKED_ACTIVE_GENERATOR:7, +BLOCKED_NO_NEW_TARGET_ON_RESTART:8 +}; +bm.SymbolName=function(bt){ +var bu=bm; +for(var bv in bu){ +if(bu[bv]==bt){ +return bv; +} +} +}; +function Failure(ag){ +this.message=ag; +} +Failure.prototype.toString=function(){ +return"LiveEdit Failure: "+this.message; +}; +function CopyErrorPositionToDetails(bw,o){ +function createPositionStruct(M,bx){ +if(bx==-1)return; +var by=M.locationFromPosition(bx,true); +if(by==null)return; +return{ +line:by.line+1, +column:by.column+1, +position:bx +}; +} +if(!("scriptObject"in bw)||!("startPosition"in bw)){ +return; +} +var M=bw.scriptObject; +var bz={ +start:createPositionStruct(M,bw.startPosition), +end:createPositionStruct(M,bw.endPosition) +}; +o.position=bz; +} +function SetScriptSource(M,bA,bB,Z){ +var i=M.source; +var bC=CompareStrings(i,bA); +return ApplyPatchMultiChunk(M,bC,bA,bB, +Z); +} +function CompareStrings(bD,bE){ +return %LiveEditCompareStrings(bD,bE); +} +function ApplySingleChunkPatch(M,change_pos,change_len,new_str, +Z){ +var i=M.source; +var bA=i.substring(0,change_pos)+ +new_str+i.substring(change_pos+change_len); +return ApplyPatchMultiChunk(M, +[change_pos,change_pos+change_len,change_pos+new_str.length], +bA,false,Z); +} +function DescribeChangeTree(aR){ +function ProcessOldNode(w){ +var bF=[]; +for(var x=0;x>1); +var m=2|4|1; +for(var n=0;n>1); +for(var n=0;n>1)+(fields?fields.length:0); +if(u>=4){ +%OptimizeObjectForAddingMultipleProperties(t,u); +} +if(fields){ +for(var n=0;n9007199254740991)throw %make_range_error(i); +return j; +} +function MaxSimple(k,l){ +return k>l?k:l; +} +function MinSimple(k,l){ +return k>l?l:k; +} +%SetForceInlineFlag(MaxSimple); +%SetForceInlineFlag(MinSimple); +function SpeciesConstructor(m,n){ +var o=m.constructor; +if((o===(void 0))){ +return n; +} +if(!(%_IsJSReceiver(o))){ +throw %make_type_error(27); +} +var p=o[f]; +if((p==null)){ +return n; +} +if(%IsConstructor(p)){ +return p; +} +throw %make_type_error(235); +} +%FunctionSetPrototype(c,new c(0)); +b.Export(function(q){ +q.MaxSimple=MaxSimple; +q.MinSimple=MinSimple; +q.ToPositiveInteger=ToPositiveInteger; +q.ToIndex=ToIndex; +q.SpeciesConstructor=SpeciesConstructor; +}); +}) + +$v8nativesu +(function(a,b){ +%CheckIsBootstrapping(); +var c=a.Number; +var d=a.Object; +var e=b.ImportNow("iterator_symbol"); +var f=%GetRootNaN(); +var g=b.ImportNow("object_to_string"); +var h=2|4|1; +b.InstallConstants(a,[ +"Infinity",(1/0), +"NaN",f, +"undefined",(void 0), +]); +function ObjectToLocaleString(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"Object.prototype.toLocaleString"); +return this.toString(); +} +function ObjectValueOf(){ +return(%_ToObject(this)); +} +function ObjectIsPrototypeOf(i){ +if(!(%_IsJSReceiver(i)))return false; +var j=(%_ToObject(this)); +return %HasInPrototypeChain(i,j); +} +function GetMethod(k,l){ +var m=k[l]; +if((m==null))return(void 0); +if((typeof(m)==='function'))return m; +throw %make_type_error(14,typeof m); +} +function ObjectConstructor(n){ +if(d!=new.target&&!(new.target===(void 0))){ +return this; +} +if((n===null)||(n===(void 0)))return{}; +return(%_ToObject(n)); +} +%SetNativeFlag(d); +%SetCode(d,ObjectConstructor); +%AddNamedProperty(d.prototype,"constructor",d, +2); +b.InstallFunctions(d.prototype,2,[ +"toString",g, +"toLocaleString",ObjectToLocaleString, +"valueOf",ObjectValueOf, +"isPrototypeOf",ObjectIsPrototypeOf, +]); +b.InstallConstants(c,[ +"MAX_VALUE",1.7976931348623157e+308, +"MIN_VALUE",5e-324, +"NaN",f, +"NEGATIVE_INFINITY",-(1/0), +"POSITIVE_INFINITY",(1/0), +"MAX_SAFE_INTEGER",9007199254740991, +"MIN_SAFE_INTEGER",-9007199254740991, +"EPSILON",2.220446049250313e-16, +]); +function GetIterator(k,o){ +if((o===(void 0))){ +o=k[e]; +} +if(!(typeof(o)==='function')){ +throw %make_type_error(70,k); +} +var p=%_Call(o,k); +if(!(%_IsJSReceiver(p))){ +throw %make_type_error(64,p); +} +return p; +} +b.Export(function(q){ +q.GetIterator=GetIterator; +q.GetMethod=GetMethod; +q.ObjectHasOwnProperty=d.prototype.hasOwnProperty; +}); +%InstallToContext([ +"object_value_of",ObjectValueOf, +]); +}) + +arrayji +(function(a,b,c){ +"use strict"; +%CheckIsBootstrapping(); +var d; +var e; +var f=a.Array; +var g=b.InternalArray; +var h=b.InternalPackedArray; +var i; +var j; +var k; +var l=b.ImportNow("object_to_string"); +var m=b.ImportNow("iterator_symbol"); +var n=b.ImportNow("unscopables_symbol"); +b.Import(function(o){ +d=o.GetIterator; +e=o.GetMethod; +i=o.MaxSimple; +j=o.MinSimple; +k=o.ObjectHasOwnProperty; +}); +function ArraySpeciesCreate(p,q){ +q=((q)+0); +var r=%ArraySpeciesConstructor(p); +return new r(q); +} +function KeySortCompare(s,t){ +return s-t; +} +function GetSortedArrayKeys(p,u){ +if((typeof(u)==='number')){ +var v=u; +var w=new g(); +for(var x=0;x>2; +var H=%EstimateNumberOfElements(p); +return(HH*4); +} +function Stack(){ +this.length=0; +this.values=new g(); +} +Stack.prototype.length=null; +Stack.prototype.values=null; +function StackPush(I,J){ +I.values[I.length++]=J; +} +function StackPop(I){ +I.values[--I.length]=null +} +function StackHas(I,K){ +var q=I.length; +var L=I.values; +for(var x=0;x=O){ +var S=p[D]; +if(!(S===(void 0))||D in p){ +%CreateDataProperty(R,D-O,S); +} +} +} +} +} +function SparseMove(p,O,P,Q,U){ +if(U===P)return; +var V=new g( +j(Q-P+U,0xffffffff)); +var W; +var u=%GetArrayKeys(p,Q); +if((typeof(u)==='number')){ +var v=u; +for(var x=0;x=O+P){ +var S=p[D]; +if(!(S===(void 0))||D in p){ +var X=D-P+U; +V[X]=S; +if(X>0xfffffffe){ +W=W||new g(); +W.push(X); +} +} +} +} +} +%MoveArrayContents(V,p); +if(!(W===(void 0))){ +var q=W.length; +for(var x=0;xP){ +for(var x=Q-P;x>O;x--){ +var Z=x+P-1; +var aa=x+U-1; +if(Z in p){ +p[aa]=p[Z]; +}else{ +delete p[aa]; +} +} +}else{ +for(var x=O;xQ-P+U;x--){ +delete p[x-1]; +} +} +} +} +function ArrayToString(){ +var p; +var ab; +if((%_IsArray(this))){ +ab=this.join; +if(ab===ArrayJoin){ +return Join(this,this.length,',',false); +} +p=this; +}else{ +p=(%_ToObject(this)); +ab=p.join; +} +if(!(typeof(ab)==='function')){ +return %_Call(l,p); +} +return %_Call(ab,p); +} +function InnerArrayToLocaleString(p,q){ +return Join(p,(%_ToLength(q)),',',true); +} +function ArrayToLocaleString(){ +var p=(%_ToObject(this)); +var ac=p.length; +return InnerArrayToLocaleString(p,ac); +} +function InnerArrayJoin(A,p,q){ +if((A===(void 0))){ +A=','; +}else{ +A=(%_ToString(A)); +} +if(q===1){ +var y=p[0]; +if((y==null))return''; +return(%_ToString(y)); +} +return Join(p,q,A,false); +} +function ArrayJoin(A){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"Array.prototype.join"); +var p=(%_ToObject(this)); +var q=(%_ToLength(p.length)); +return InnerArrayJoin(A,p,q); +} +function ArrayPop(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"Array.prototype.pop"); +var p=(%_ToObject(this)); +var ad=(%_ToLength(p.length)); +if(ad==0){ +p.length=ad; +return; +} +ad--; +var J=p[ad]; +%DeleteProperty_Strict(p,ad); +p.length=ad; +return J; +} +function ArrayPush(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"Array.prototype.push"); +var p=(%_ToObject(this)); +var ad=(%_ToLength(p.length)); +var ae=arguments.length; +if(ae>9007199254740991-ad)throw %make_type_error(227,ae,ad); +for(var x=0;x=x){ +ak=x; +while(w[++ah]==x){} +al=Q-x-1; +} +var am=p[ak]; +if(!(am===(void 0))||ak in p){ +var an=p[al]; +if(!(an===(void 0))||al in p){ +p[ak]=an; +p[al]=am; +}else{ +p[al]=am; +delete p[ak]; +} +}else{ +var an=p[al]; +if(!(an===(void 0))||al in p){ +p[ak]=an; +delete p[al]; +} +} +} +} +function PackedArrayReverse(p,Q){ +var ai=Q-1; +for(var x=0;x0&&UseSparseVariant(p,Q,(%_IsArray(p)),Q)&& +!%object_is_sealed(p)){ +SparseMove(p,0,0,Q,ar); +}else{ +SimpleMove(p,0,0,Q,ar); +} +for(var x=0;xQ)O=Q; +} +if(au<0){ +au+=Q; +if(au<0)au=0; +}else{ +if(au>Q)au=Q; +} +var av=ArraySpeciesCreate(p,i(au-O,0)); +if(auQ?Q:O; +} +function ComputeSpliceDeleteCount(aw,ar,Q,O){ +var P=0; +if(ar==1) +return Q-O; +P=(%_ToInteger(aw)); +if(P<0) +return 0; +if(P>Q-O) +return Q-O; +return P; +} +function ArraySplice(as,aw){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"Array.prototype.splice"); +var ar=arguments.length; +var p=(%_ToObject(this)); +var Q=(%_ToLength(p.length)); +var O=ComputeSpliceStartIndex((%_ToInteger(as)),Q); +var P=ComputeSpliceDeleteCount(aw,ar,Q, +O); +var R=ArraySpeciesCreate(p,P); +R.length=P; +var ax=ar>2?ar-2:0; +if(P!=ax&&%object_is_sealed(p)){ +throw %make_type_error(13); +}else if(P>0&&%object_is_frozen(p)){ +throw %make_type_error(12); +} +var ay=P; +if(ax!=P){ +ay+=Q-O-P; +} +if(UseSparseVariant(p,Q,(%_IsArray(p)),ay)){ +%NormalizeElements(p); +if((%_IsArray(R)))%NormalizeElements(R); +SparseSlice(p,O,P,Q,R); +SparseMove(p,O,P,Q,ax); +}else{ +SimpleSlice(p,O,P,Q,R); +SimpleMove(p,O,P,Q,ax); +} +var x=O; +var az=2; +var aA=arguments.length; +while(az=o;ai--){ +var aF=s[ai]; +var aG=aB(aF,aE); +if(aG>0){ +s[ai+1]=aF; +}else{ +break; +} +} +s[ai+1]=aE; +} +}; +function GetThirdIndex(s,o,aD){ +var aH=new g(); +var aI=200+((aD-o)&15); +var ai=0; +o+=1; +aD-=1; +for(var x=o;x>1][0]; +return aJ; +} +function QuickSort(s,o,aD){ +var aJ=0; +while(true){ +if(aD-o<=10){ +InsertionSort(s,o,aD); +return; +} +if(aD-o>1000){ +aJ=GetThirdIndex(s,o,aD); +}else{ +aJ=o+((aD-o)>>1); +} +var aK=s[o]; +var aL=s[aD-1]; +var aM=s[aJ]; +var aN=aB(aK,aL); +if(aN>0){ +var aF=aK; +aK=aL; +aL=aF; +} +var aO=aB(aK,aM); +if(aO>=0){ +var aF=aK; +aK=aM; +aM=aL; +aL=aF; +}else{ +var aP=aB(aL,aM); +if(aP>0){ +var aF=aL; +aL=aM; +aM=aF; +} +} +s[o]=aK; +s[aD-1]=aM; +var aQ=aL; +var aR=o+1; +var aS=aD-1; +s[aJ]=s[aR]; +s[aR]=aQ; +partition:for(var x=aR+1;x0){ +do{ +aS--; +if(aS==x)break partition; +var aT=s[aS]; +aG=aB(aT,aQ); +}while(aG>0); +s[x]=s[aS]; +s[aS]=aE; +if(aG<0){ +aE=s[x]; +s[x]=s[aR]; +s[aR]=aE; +aR++; +} +} +} +if(aD-aS=aV){aV=x+1;} +} +} +}else{ +for(var x=0;x=aV){aV=Y+1;} +} +} +} +} +return aV; +}; +function ShadowPrototypeElements(aU,o,aD){ +for(var aW=%object_get_prototype_of(aU);aW; +aW=%object_get_prototype_of(aW)){ +var u=(%_IsJSProxy(aW))?aD:%GetArrayKeys(aW,aD); +if((typeof(u)==='number')){ +var aX=u; +for(var x=o;x=q)Y=q-1; +} +var bh=0; +var aV=Y; +if(UseSparseVariant(p,q,(%_IsArray(p)),Y)){ +%NormalizeElements(p); +var u=%GetArrayKeys(p,Y+1); +if((typeof(u)==='number')){ +aV=u; +}else{ +if(u.length==0)return-1; +var bi=GetSortedArrayKeys(p,u); +var x=bi.length-1; +while(x>=0){ +var D=bi[x]; +if(p[D]===aE)return D; +x--; +} +return-1; +} +} +if(!(aE===(void 0))){ +for(var x=aV;x>=bh;x--){ +if(p[x]===aE)return x; +} +return-1; +} +for(var x=aV;x>=bh;x--){ +if((p[x]===(void 0))&&x in p){ +return x; +} +} +return-1; +} +function ArrayLastIndexOf(aE,Y){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"Array.prototype.lastIndexOf"); +var q=(%_ToLength(this.length)); +return InnerArrayLastIndexOf(this,aE,Y,q, +arguments.length); +} +function InnerArrayReduce(bj,S,p,q,bg){ +if(!(typeof(bj)==='function')){ +throw %make_type_error(14,bj); +} +var x=0; +find_initial:if(bg<2){ +for(;x=0;x--){ +if(x in p){ +S=p[x--]; +break find_initial; +} +} +throw %make_type_error(122); +} +for(;x>=0;x--){ +if(x in p){ +var aE=p[x]; +S=bj(S,aE,x,p); +} +} +return S; +} +function ArrayReduceRight(bj,S){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"Array.prototype.reduceRight"); +var p=(%_ToObject(this)); +var q=(%_ToLength(p.length)); +return InnerArrayReduceRight(bj,S,p,q, +arguments.length); +} +function InnerArrayCopyWithin(bk,as,at,p,q){ +bk=(%_ToInteger(bk)); +var aD; +if(bk<0){ +aD=i(q+bk,0); +}else{ +aD=j(bk,q); +} +as=(%_ToInteger(as)); +var o; +if(as<0){ +o=i(q+as,0); +}else{ +o=j(as,q); +} +at=(at===(void 0))?q:(%_ToInteger(at)); +var bl; +if(at<0){ +bl=i(q+at,0); +}else{ +bl=j(at,q); +} +var bm=j(bl-o,q-aD); +var bn=1; +if(o0){ +if(o in p){ +p[aD]=p[o]; +}else{ +delete p[aD]; +} +o=o+bn; +aD=aD+bn; +bm--; +} +return p; +} +function ArrayCopyWithin(bk,as,at){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"Array.prototype.copyWithin"); +var p=(%_ToObject(this)); +var q=(%_ToLength(p.length)); +return InnerArrayCopyWithin(bk,as,at,p,q); +} +function InnerArrayFind(bo,bp,p,q){ +if(!(typeof(bo)==='function')){ +throw %make_type_error(14,bo); +} +for(var x=0;xq)x=q; +} +if(at<0){ +at+=q; +if(at<0)at=0; +}else{ +if(at>q)at=q; +} +if((at-x)>0&&%object_is_frozen(p)){ +throw %make_type_error(12); +} +for(;x0)D+=%_SubString(y,0,H); +while(true){ +F='$'; +E=H+1; +if(E=48&&G<=57){ +I=(G-48); +J=1; +if(E+1=48&&H<=57){ +K=I*10+((H-48)); +if(KE){ +D+=%_SubString(y,E,H); +} +} +return D; +} +function StringReplace(M,N){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.replace"); +if(!(M==null)){ +var O=M[i]; +if(!(O===(void 0))){ +return %_Call(O,M,this,N); +} +} +var s=(%_ToString(this)); +M=(%_ToString(M)); +if(M.length==1&& +s.length>0xFF&& +(typeof(N)==='string')&& +%StringIndexOf(N,'$',0)<0){ +return %StringReplaceOneCharWithString(s,M,N); +} +var P=%StringIndexOf(s,M,0); +if(P<0)return s; +var Q=P+M.length; +var D=%_SubString(s,0,P); +if((typeof(N)==='function')){ +D+=N(M,P,s); +}else{ +const x={length:1}; +const u=%_SubString(s,P,Q); +D+=GetSubstitution(u,s,P,x, +(%_ToString(N))); +} +return D+%_SubString(s,Q,s.length); +} +function StringSearch(q){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.search"); +if(!(q==null)){ +var R=q[j]; +if(!(R===(void 0))){ +return %_Call(R,q,this); +} +} +var s=(%_ToString(this)); +var t=%RegExpCreate(q); +return %_Call(t[j],t,s); +} +function StringSlice(P,Q){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.slice"); +var n=(%_ToString(this)); +var S=n.length; +var T=(%_ToInteger(P)); +var U=S; +if(!(Q===(void 0))){ +U=(%_ToInteger(Q)); +} +if(T<0){ +T+=S; +if(T<0){ +T=0; +} +}else{ +if(T>S){ +return''; +} +} +if(U<0){ +U+=S; +if(U<0){ +return''; +} +}else{ +if(U>S){ +U=S; +} +} +if(U<=T){ +return''; +} +return %_SubString(n,T,U); +} +function StringSplitJS(V,W){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.split"); +if(!(V==null)){ +var X=V[k]; +if(!(X===(void 0))){ +return %_Call(X,V,this,W); +} +} +var s=(%_ToString(this)); +W=((W===(void 0)))?4294967295:((W)>>>0); +var Y=s.length; +var Z=(%_ToString(V)); +if(W===0)return[]; +if((V===(void 0)))return[s]; +var aa=Z.length; +if(aa===0)return %StringToArray(s,W); +return %StringSplit(s,Z,W); +} +function StringToLowerCaseJS(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.toLowerCase"); +return %StringToLowerCase((%_ToString(this))); +} +function StringToLocaleLowerCase(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.toLocaleLowerCase"); +return %StringToLowerCase((%_ToString(this))); +} +function StringToUpperCaseJS(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.toUpperCase"); +return %StringToUpperCase((%_ToString(this))); +} +function StringToLocaleUpperCase(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.toLocaleUpperCase"); +return %StringToUpperCase((%_ToString(this))); +} +function HtmlEscape(ab){ +return %RegExpInternalReplace(/"/g,(%_ToString(ab)),"""); +} +function StringAnchor(ac){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.anchor"); +return""+(%_ToString(this))+ +""; +} +function StringBig(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.big"); +return""+(%_ToString(this))+""; +} +function StringBlink(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.blink"); +return""+(%_ToString(this))+""; +} +function StringBold(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.bold"); +return""+(%_ToString(this))+""; +} +function StringFixed(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.fixed"); +return""+(%_ToString(this))+""; +} +function StringFontcolor(ad){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.fontcolor"); +return""+(%_ToString(this))+ +""; +} +function StringFontsize(ae){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.fontsize"); +return""+(%_ToString(this))+ +""; +} +function StringItalics(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.italics"); +return""+(%_ToString(this))+""; +} +function StringLink(n){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.link"); +return""+(%_ToString(this))+""; +} +function StringSmall(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.small"); +return""+(%_ToString(this))+""; +} +function StringStrike(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.strike"); +return""+(%_ToString(this))+""; +} +function StringSub(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.sub"); +return""+(%_ToString(this))+""; +} +function StringSup(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.sup"); +return""+(%_ToString(this))+""; +} +function StringRepeat(af){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.repeat"); +var n=(%_ToString(this)); +var ag=(%_ToInteger(af)); +if(ag<0||ag===(1/0))throw %make_range_error(157); +if(n.length===0)return""; +if(ag>%_MaxSmi())throw %make_range_error(157); +var ah=""; +while(true){ +if(ag&1)ah+=n; +ag>>=1; +if(ag===0)return ah; +n+=n; +} +} +function StringCodePointAt(E){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.codePointAt"); +var v=(%_ToString(this)); +var ae=v.length; +E=(%_ToInteger(E)); +if(E<0||E>=ae){ +return(void 0); +} +var ai=%_StringCharCodeAt(v,E); +if(ai<0xD800||ai>0xDBFF||E+1==ae){ +return ai; +} +var aj=%_StringCharCodeAt(v,E+1); +if(aj<0xDC00||aj>0xDFFF){ +return ai; +} +return(ai-0xD800)*0x400+aj+0x2400; +} +function StringRaw(ak){ +"use strict"; +var al=arguments.length; +var am=(%_ToObject(ak)); +var an=(%_ToObject(am.raw)); +var ao=(%_ToLength(an.length)); +if(ao<=0)return""; +var D=(%_ToString(an[0])); +for(var p=1;p%_MaxSmi()){ +throw %make_range_error(170); +} +var ae=%_ArrayBufferGetByteLength(ab); +var af; +if((ac===(void 0))){ +af=0; +}else{ +af=ac; +if(af % 1!==0){ +throw %make_range_error(168, +"start offset","Uint8Array",1); +} +} +var ag; +if((ad===(void 0))){ +if(ae % 1!==0){ +throw %make_range_error(168, +"byte length","Uint8Array",1); +} +ag=ae-af; +if(ag<0){ +throw %make_range_error(168, +"byte length","Uint8Array",1); +} +}else{ +ag=ad*1; +if(af+ag>ae){ +throw %make_range_error(170); +} +} +%_TypedArrayInitialize(aa,1,ab,af,ag,true); +} +function Uint8ArrayConstructByLength(aa,ad){ +var ah=(ad===(void 0))? +0:D(ad,170); +if(ad>%_MaxSmi()){ +throw %make_range_error(170); +} +var ai=ah*1; +if(ai>%_TypedArrayMaxSizeInHeap()){ +var ab=new h(ai); +%_TypedArrayInitialize(aa,1,ab,0,ai,true); +}else{ +%_TypedArrayInitialize(aa,1,null,0,ai,true); +} +} +function Uint8ArrayConstructByArrayLike(aa,aj,ad){ +var ah=C(ad,170); +if(ah>%_MaxSmi()){ +throw %make_range_error(170); +} +var ak=false; +var ai=ah*1; +if(ai<=%_TypedArrayMaxSizeInHeap()){ +%_TypedArrayInitialize(aa,1,null,0,ai,false); +}else{ +ak= +%TypedArrayInitializeFromArrayLike(aa,1,aj,ah); +} +if(!ak){ +for(var al=0;al%_MaxSmi()){ +throw %make_range_error(170); +} +var ae=%_ArrayBufferGetByteLength(ab); +var af; +if((ac===(void 0))){ +af=0; +}else{ +af=ac; +if(af % 1!==0){ +throw %make_range_error(168, +"start offset","Int8Array",1); +} +} +var ag; +if((ad===(void 0))){ +if(ae % 1!==0){ +throw %make_range_error(168, +"byte length","Int8Array",1); +} +ag=ae-af; +if(ag<0){ +throw %make_range_error(168, +"byte length","Int8Array",1); +} +}else{ +ag=ad*1; +if(af+ag>ae){ +throw %make_range_error(170); +} +} +%_TypedArrayInitialize(aa,2,ab,af,ag,true); +} +function Int8ArrayConstructByLength(aa,ad){ +var ah=(ad===(void 0))? +0:D(ad,170); +if(ad>%_MaxSmi()){ +throw %make_range_error(170); +} +var ai=ah*1; +if(ai>%_TypedArrayMaxSizeInHeap()){ +var ab=new h(ai); +%_TypedArrayInitialize(aa,2,ab,0,ai,true); +}else{ +%_TypedArrayInitialize(aa,2,null,0,ai,true); +} +} +function Int8ArrayConstructByArrayLike(aa,aj,ad){ +var ah=C(ad,170); +if(ah>%_MaxSmi()){ +throw %make_range_error(170); +} +var ak=false; +var ai=ah*1; +if(ai<=%_TypedArrayMaxSizeInHeap()){ +%_TypedArrayInitialize(aa,2,null,0,ai,false); +}else{ +ak= +%TypedArrayInitializeFromArrayLike(aa,2,aj,ah); +} +if(!ak){ +for(var al=0;al%_MaxSmi()){ +throw %make_range_error(170); +} +var ae=%_ArrayBufferGetByteLength(ab); +var af; +if((ac===(void 0))){ +af=0; +}else{ +af=ac; +if(af % 2!==0){ +throw %make_range_error(168, +"start offset","Uint16Array",2); +} +} +var ag; +if((ad===(void 0))){ +if(ae % 2!==0){ +throw %make_range_error(168, +"byte length","Uint16Array",2); +} +ag=ae-af; +if(ag<0){ +throw %make_range_error(168, +"byte length","Uint16Array",2); +} +}else{ +ag=ad*2; +if(af+ag>ae){ +throw %make_range_error(170); +} +} +%_TypedArrayInitialize(aa,3,ab,af,ag,true); +} +function Uint16ArrayConstructByLength(aa,ad){ +var ah=(ad===(void 0))? +0:D(ad,170); +if(ad>%_MaxSmi()){ +throw %make_range_error(170); +} +var ai=ah*2; +if(ai>%_TypedArrayMaxSizeInHeap()){ +var ab=new h(ai); +%_TypedArrayInitialize(aa,3,ab,0,ai,true); +}else{ +%_TypedArrayInitialize(aa,3,null,0,ai,true); +} +} +function Uint16ArrayConstructByArrayLike(aa,aj,ad){ +var ah=C(ad,170); +if(ah>%_MaxSmi()){ +throw %make_range_error(170); +} +var ak=false; +var ai=ah*2; +if(ai<=%_TypedArrayMaxSizeInHeap()){ +%_TypedArrayInitialize(aa,3,null,0,ai,false); +}else{ +ak= +%TypedArrayInitializeFromArrayLike(aa,3,aj,ah); +} +if(!ak){ +for(var al=0;al%_MaxSmi()){ +throw %make_range_error(170); +} +var ae=%_ArrayBufferGetByteLength(ab); +var af; +if((ac===(void 0))){ +af=0; +}else{ +af=ac; +if(af % 2!==0){ +throw %make_range_error(168, +"start offset","Int16Array",2); +} +} +var ag; +if((ad===(void 0))){ +if(ae % 2!==0){ +throw %make_range_error(168, +"byte length","Int16Array",2); +} +ag=ae-af; +if(ag<0){ +throw %make_range_error(168, +"byte length","Int16Array",2); +} +}else{ +ag=ad*2; +if(af+ag>ae){ +throw %make_range_error(170); +} +} +%_TypedArrayInitialize(aa,4,ab,af,ag,true); +} +function Int16ArrayConstructByLength(aa,ad){ +var ah=(ad===(void 0))? +0:D(ad,170); +if(ad>%_MaxSmi()){ +throw %make_range_error(170); +} +var ai=ah*2; +if(ai>%_TypedArrayMaxSizeInHeap()){ +var ab=new h(ai); +%_TypedArrayInitialize(aa,4,ab,0,ai,true); +}else{ +%_TypedArrayInitialize(aa,4,null,0,ai,true); +} +} +function Int16ArrayConstructByArrayLike(aa,aj,ad){ +var ah=C(ad,170); +if(ah>%_MaxSmi()){ +throw %make_range_error(170); +} +var ak=false; +var ai=ah*2; +if(ai<=%_TypedArrayMaxSizeInHeap()){ +%_TypedArrayInitialize(aa,4,null,0,ai,false); +}else{ +ak= +%TypedArrayInitializeFromArrayLike(aa,4,aj,ah); +} +if(!ak){ +for(var al=0;al%_MaxSmi()){ +throw %make_range_error(170); +} +var ae=%_ArrayBufferGetByteLength(ab); +var af; +if((ac===(void 0))){ +af=0; +}else{ +af=ac; +if(af % 4!==0){ +throw %make_range_error(168, +"start offset","Uint32Array",4); +} +} +var ag; +if((ad===(void 0))){ +if(ae % 4!==0){ +throw %make_range_error(168, +"byte length","Uint32Array",4); +} +ag=ae-af; +if(ag<0){ +throw %make_range_error(168, +"byte length","Uint32Array",4); +} +}else{ +ag=ad*4; +if(af+ag>ae){ +throw %make_range_error(170); +} +} +%_TypedArrayInitialize(aa,5,ab,af,ag,true); +} +function Uint32ArrayConstructByLength(aa,ad){ +var ah=(ad===(void 0))? +0:D(ad,170); +if(ad>%_MaxSmi()){ +throw %make_range_error(170); +} +var ai=ah*4; +if(ai>%_TypedArrayMaxSizeInHeap()){ +var ab=new h(ai); +%_TypedArrayInitialize(aa,5,ab,0,ai,true); +}else{ +%_TypedArrayInitialize(aa,5,null,0,ai,true); +} +} +function Uint32ArrayConstructByArrayLike(aa,aj,ad){ +var ah=C(ad,170); +if(ah>%_MaxSmi()){ +throw %make_range_error(170); +} +var ak=false; +var ai=ah*4; +if(ai<=%_TypedArrayMaxSizeInHeap()){ +%_TypedArrayInitialize(aa,5,null,0,ai,false); +}else{ +ak= +%TypedArrayInitializeFromArrayLike(aa,5,aj,ah); +} +if(!ak){ +for(var al=0;al%_MaxSmi()){ +throw %make_range_error(170); +} +var ae=%_ArrayBufferGetByteLength(ab); +var af; +if((ac===(void 0))){ +af=0; +}else{ +af=ac; +if(af % 4!==0){ +throw %make_range_error(168, +"start offset","Int32Array",4); +} +} +var ag; +if((ad===(void 0))){ +if(ae % 4!==0){ +throw %make_range_error(168, +"byte length","Int32Array",4); +} +ag=ae-af; +if(ag<0){ +throw %make_range_error(168, +"byte length","Int32Array",4); +} +}else{ +ag=ad*4; +if(af+ag>ae){ +throw %make_range_error(170); +} +} +%_TypedArrayInitialize(aa,6,ab,af,ag,true); +} +function Int32ArrayConstructByLength(aa,ad){ +var ah=(ad===(void 0))? +0:D(ad,170); +if(ad>%_MaxSmi()){ +throw %make_range_error(170); +} +var ai=ah*4; +if(ai>%_TypedArrayMaxSizeInHeap()){ +var ab=new h(ai); +%_TypedArrayInitialize(aa,6,ab,0,ai,true); +}else{ +%_TypedArrayInitialize(aa,6,null,0,ai,true); +} +} +function Int32ArrayConstructByArrayLike(aa,aj,ad){ +var ah=C(ad,170); +if(ah>%_MaxSmi()){ +throw %make_range_error(170); +} +var ak=false; +var ai=ah*4; +if(ai<=%_TypedArrayMaxSizeInHeap()){ +%_TypedArrayInitialize(aa,6,null,0,ai,false); +}else{ +ak= +%TypedArrayInitializeFromArrayLike(aa,6,aj,ah); +} +if(!ak){ +for(var al=0;al%_MaxSmi()){ +throw %make_range_error(170); +} +var ae=%_ArrayBufferGetByteLength(ab); +var af; +if((ac===(void 0))){ +af=0; +}else{ +af=ac; +if(af % 4!==0){ +throw %make_range_error(168, +"start offset","Float32Array",4); +} +} +var ag; +if((ad===(void 0))){ +if(ae % 4!==0){ +throw %make_range_error(168, +"byte length","Float32Array",4); +} +ag=ae-af; +if(ag<0){ +throw %make_range_error(168, +"byte length","Float32Array",4); +} +}else{ +ag=ad*4; +if(af+ag>ae){ +throw %make_range_error(170); +} +} +%_TypedArrayInitialize(aa,7,ab,af,ag,true); +} +function Float32ArrayConstructByLength(aa,ad){ +var ah=(ad===(void 0))? +0:D(ad,170); +if(ad>%_MaxSmi()){ +throw %make_range_error(170); +} +var ai=ah*4; +if(ai>%_TypedArrayMaxSizeInHeap()){ +var ab=new h(ai); +%_TypedArrayInitialize(aa,7,ab,0,ai,true); +}else{ +%_TypedArrayInitialize(aa,7,null,0,ai,true); +} +} +function Float32ArrayConstructByArrayLike(aa,aj,ad){ +var ah=C(ad,170); +if(ah>%_MaxSmi()){ +throw %make_range_error(170); +} +var ak=false; +var ai=ah*4; +if(ai<=%_TypedArrayMaxSizeInHeap()){ +%_TypedArrayInitialize(aa,7,null,0,ai,false); +}else{ +ak= +%TypedArrayInitializeFromArrayLike(aa,7,aj,ah); +} +if(!ak){ +for(var al=0;al%_MaxSmi()){ +throw %make_range_error(170); +} +var ae=%_ArrayBufferGetByteLength(ab); +var af; +if((ac===(void 0))){ +af=0; +}else{ +af=ac; +if(af % 8!==0){ +throw %make_range_error(168, +"start offset","Float64Array",8); +} +} +var ag; +if((ad===(void 0))){ +if(ae % 8!==0){ +throw %make_range_error(168, +"byte length","Float64Array",8); +} +ag=ae-af; +if(ag<0){ +throw %make_range_error(168, +"byte length","Float64Array",8); +} +}else{ +ag=ad*8; +if(af+ag>ae){ +throw %make_range_error(170); +} +} +%_TypedArrayInitialize(aa,8,ab,af,ag,true); +} +function Float64ArrayConstructByLength(aa,ad){ +var ah=(ad===(void 0))? +0:D(ad,170); +if(ad>%_MaxSmi()){ +throw %make_range_error(170); +} +var ai=ah*8; +if(ai>%_TypedArrayMaxSizeInHeap()){ +var ab=new h(ai); +%_TypedArrayInitialize(aa,8,ab,0,ai,true); +}else{ +%_TypedArrayInitialize(aa,8,null,0,ai,true); +} +} +function Float64ArrayConstructByArrayLike(aa,aj,ad){ +var ah=C(ad,170); +if(ah>%_MaxSmi()){ +throw %make_range_error(170); +} +var ak=false; +var ai=ah*8; +if(ai<=%_TypedArrayMaxSizeInHeap()){ +%_TypedArrayInitialize(aa,8,null,0,ai,false); +}else{ +ak= +%TypedArrayInitializeFromArrayLike(aa,8,aj,ah); +} +if(!ak){ +for(var al=0;al%_MaxSmi()){ +throw %make_range_error(170); +} +var ae=%_ArrayBufferGetByteLength(ab); +var af; +if((ac===(void 0))){ +af=0; +}else{ +af=ac; +if(af % 1!==0){ +throw %make_range_error(168, +"start offset","Uint8ClampedArray",1); +} +} +var ag; +if((ad===(void 0))){ +if(ae % 1!==0){ +throw %make_range_error(168, +"byte length","Uint8ClampedArray",1); +} +ag=ae-af; +if(ag<0){ +throw %make_range_error(168, +"byte length","Uint8ClampedArray",1); +} +}else{ +ag=ad*1; +if(af+ag>ae){ +throw %make_range_error(170); +} +} +%_TypedArrayInitialize(aa,9,ab,af,ag,true); +} +function Uint8ClampedArrayConstructByLength(aa,ad){ +var ah=(ad===(void 0))? +0:D(ad,170); +if(ad>%_MaxSmi()){ +throw %make_range_error(170); +} +var ai=ah*1; +if(ai>%_TypedArrayMaxSizeInHeap()){ +var ab=new h(ai); +%_TypedArrayInitialize(aa,9,ab,0,ai,true); +}else{ +%_TypedArrayInitialize(aa,9,null,0,ai,true); +} +} +function Uint8ClampedArrayConstructByArrayLike(aa,aj,ad){ +var ah=C(ad,170); +if(ah>%_MaxSmi()){ +throw %make_range_error(170); +} +var ak=false; +var ai=ah*1; +if(ai<=%_TypedArrayMaxSizeInHeap()){ +%_TypedArrayInitialize(aa,9,null,0,ai,false); +}else{ +ak= +%TypedArrayInitializeFromArrayLike(aa,9,aj,ah); +} +if(!ak){ +for(var al=0;al0){ +for(var al=0;al=aK&&aI>=aJ; +aL--){ +aD[af+aL]=aE[aL]; +aI-=aH; +aJ-=aG; +} +return aL; +} +var aL=CopyRightPart(); +var aM=new g(aL+1-aK); +for(var al=aK;al<=aL;al++){ +aM[al-aK]=aE[al]; +} +for(al=aK;al<=aL;al++){ +aD[af+al]=aM[al-aK]; +} +} +function TypedArraySet(aa,af){ +var aN=(af===(void 0))?0:(%_ToInteger(af)); +if(aN<0)throw %make_type_error(181); +if(aN>%_MaxSmi()){ +throw %make_range_error(182); +} +switch(%TypedArraySetFastCases(this,aa,aN)){ +case 0: +return; +case 1: +TypedArraySetFromOverlappingTypedArray(this,aa,aN); +return; +case 2: +TypedArraySetFromArrayLike(this, +aa,%_TypedArrayGetLength(aa),aN); +return; +case 3: +var ah=aa.length; +if((ah===(void 0))){ +if((typeof(aa)==='number')){ +throw %make_type_error(46); +} +return; +} +ah=(%_ToLength(ah)); +if(aN+ah>%_TypedArrayGetLength(this)){ +throw %make_range_error(182); +} +TypedArraySetFromArrayLike(this,aa,ah,aN); +return; +} +} +%FunctionSetLength(TypedArraySet,1); +function TypedArrayGetToStringTag(){ +if(!(%_IsTypedArray(this)))return; +var aO=%_ClassOf(this); +if((aO===(void 0)))return; +return aO; +} +function TypedArrayCopyWithin(aD,aP,ax){ +if(!(%_IsTypedArray(this)))throw %make_type_error(72); +var ad=%_TypedArrayGetLength(this); +return k(aD,aP,ax,this,ad); +} +%FunctionSetLength(TypedArrayCopyWithin,2); +function TypedArrayEvery(aQ,aR){ +if(!(%_IsTypedArray(this)))throw %make_type_error(72); +var ad=%_TypedArrayGetLength(this); +return l(aQ,aR,this,ad); +} +%FunctionSetLength(TypedArrayEvery,1); +function TypedArrayForEach(aQ,aR){ +if(!(%_IsTypedArray(this)))throw %make_type_error(72); +var ad=%_TypedArrayGetLength(this); +q(aQ,aR,this,ad); +} +%FunctionSetLength(TypedArrayForEach,1); +function TypedArrayFill(ar,aP,ax){ +if(!(%_IsTypedArray(this)))throw %make_type_error(72); +var ad=%_TypedArrayGetLength(this); +return m(ar,aP,ax,this,ad); +} +%FunctionSetLength(TypedArrayFill,1); +function TypedArrayFilter(aQ,aS){ +if(!(%_IsTypedArray(this)))throw %make_type_error(72); +var ad=%_TypedArrayGetLength(this); +if(!(typeof(aQ)==='function'))throw %make_type_error(14,aQ); +var aT=new x(); +n(aQ,aS,this,ad,aT); +var aU=aT.length; +var aV=TypedArraySpeciesCreate(this,aU); +for(var al=0;alaY){ +return 1; +}else if((!%_IsSmi(%IS_VAR(aX))&&!(aX==aX))&&(!%_IsSmi(%IS_VAR(aY))&&!(aY==aY))){ +return(!%_IsSmi(%IS_VAR(aY))&&!(aY==aY))?0:1; +}else if((!%_IsSmi(%IS_VAR(aX))&&!(aX==aX))){ +return 1; +} +return 0; +} +function TypedArraySort(aZ){ +if(!(%_IsTypedArray(this)))throw %make_type_error(72); +var ad=%_TypedArrayGetLength(this); +if((aZ===(void 0))){ +aZ=TypedArrayComparefn; +} +return v(this,ad,aZ); +} +function TypedArrayIndexOf(ba,bb){ +if(!(%_IsTypedArray(this)))throw %make_type_error(72); +var ad=%_TypedArrayGetLength(this); +if(ad===0)return-1; +if(!(typeof(ba)==='number'))return-1; +var bc=(%_ToInteger(bb)); +var bd; +if(bc===0){ +bd=0; +}else if(bc>0){ +bd=bc; +}else{ +bd=ad+bc; +if(bd<0){ +bd=0; +} +} +while(bd=0){ +if(ad<=bc){ +bd=ad-1; +}else if(bc===0){ +bd=0; +}else{ +bd=bc; +} +}else{ +bd=ad+bc; +} +while(bd>=0){ +var be=this[bd]; +if(ba===be){ +return bd; +} +--bd; +} +return-1; +} +%FunctionSetLength(TypedArrayLastIndexOf,1); +function TypedArrayMap(aQ,aS){ +if(!(%_IsTypedArray(this)))throw %make_type_error(72); +var ad=%_TypedArrayGetLength(this); +var aT=TypedArraySpeciesCreate(this,ad); +if(!(typeof(aQ)==='function'))throw %make_type_error(14,aQ); +for(var al=0;al=0){ +bd=bc; +}else{ +bd=ad+bc; +if(bd<0){ +bd=0; +} +} +while(bd>>12); +m=m+(m<<2); +m=m^(m>>>4); +m=(m*2057)|0; +m=m^(m>>>16); +return m&0x3fffffff; +} +%SetForceInlineFlag(ComputeIntegerHash); +function GetExistingHash(p){ +if(%_IsSmi(p)){ +return ComputeIntegerHash(p,0); +} +if((typeof(p)==='string')){ +var u=%_StringGetRawHashField(p); +if((u&1)===0){ +return u>>>2; +} +}else if((%_IsJSReceiver(p))&&!(%_IsJSProxy(p))&&!(%_ClassOf(p)==='global')){ +var m=(p[f]); +return m; +} +return %GenericHash(p); +} +%SetForceInlineFlag(GetExistingHash); +function GetHash(p){ +var m=GetExistingHash(p); +if((m===(void 0))){ +m=(g()*0x40000000)|0; +if(m===0)m=1; +(p[f]=m); +} +return m; +} +%SetForceInlineFlag(GetHash); +function SetConstructor(v){ +if((new.target===(void 0))){ +throw %make_type_error(26,"Set"); +} +%_SetInitialize(this); +if(!(v==null)){ +var w=this.add; +if(!(typeof(w)==='function')){ +throw %make_type_error(87,w,'add',this); +} +for(var x of v){ +%_Call(w,this,x); +} +} +} +function SetAdd(p){ +if(!(%_ClassOf(this)==='Set')){ +throw %make_type_error(44,'Set.prototype.add',this); +} +if(p===0){ +p=0; +} +var l=%_JSCollectionGetTable(this); +var n=((%_FixedArrayGet(l,(0)|0))); +var m=GetHash(p); +if(SetFindEntry(l,n,p,m)!==-1)return this; +var y=((%_FixedArrayGet(l,(1)|0))); +var z=((%_FixedArrayGet(l,(2)|0))); +var A=n<<1; +if((y+z)>=A){ +%SetGrow(this); +l=%_JSCollectionGetTable(this); +n=((%_FixedArrayGet(l,(0)|0))); +y=((%_FixedArrayGet(l,(1)|0))); +z=((%_FixedArrayGet(l,(2)|0))); +} +var q=y+z; +var B=(3+(n)+((q)<<1)); +var o=(m&((n)-1)); +var C=((%_FixedArrayGet(l,(3+(o))|0))); +((%_FixedArraySet(l,(3+(o))|0,q))); +(((%_FixedArraySet(l,(1)|0,(y+1)|0)))); +(%_FixedArraySet(l,(B)|0,p)); +((%_FixedArraySet(l,(B+1)|0,(C)|0))); +return this; +} +function SetHas(p){ +if(!(%_ClassOf(this)==='Set')){ +throw %make_type_error(44,'Set.prototype.has',this); +} +var l=%_JSCollectionGetTable(this); +var n=((%_FixedArrayGet(l,(0)|0))); +var m=GetExistingHash(p); +if((m===(void 0)))return false; +return SetFindEntry(l,n,p,m)!==-1; +} +function SetDelete(p){ +if(!(%_ClassOf(this)==='Set')){ +throw %make_type_error(44, +'Set.prototype.delete',this); +} +var l=%_JSCollectionGetTable(this); +var n=((%_FixedArrayGet(l,(0)|0))); +var m=GetExistingHash(p); +if((m===(void 0)))return false; +var q=SetFindEntry(l,n,p,m); +if(q===-1)return false; +var y=((%_FixedArrayGet(l,(1)|0)))-1; +var z=((%_FixedArrayGet(l,(2)|0)))+1; +var B=(3+(n)+((q)<<1)); +(%_FixedArraySet(l,(B)|0,%_TheHole())); +(((%_FixedArraySet(l,(1)|0,(y)|0)))); +(((%_FixedArraySet(l,(2)|0,(z)|0)))); +if(y<(n>>>1))%SetShrink(this); +return true; +} +function SetGetSize(){ +if(!(%_ClassOf(this)==='Set')){ +throw %make_type_error(44, +'Set.prototype.size',this); +} +var l=%_JSCollectionGetTable(this); +return((%_FixedArrayGet(l,(1)|0))); +} +function SetClearJS(){ +if(!(%_ClassOf(this)==='Set')){ +throw %make_type_error(44, +'Set.prototype.clear',this); +} +%_SetClear(this); +} +function SetForEach(D,E){ +if(!(%_ClassOf(this)==='Set')){ +throw %make_type_error(44, +'Set.prototype.forEach',this); +} +if(!(typeof(D)==='function'))throw %make_type_error(14,D); +var F=new i(this,2); +var p; +var G=[(void 0)]; +while(%SetIteratorNext(F,G)){ +p=G[0]; +%_Call(D,E,p,p,this); +} +} +%SetCode(e,SetConstructor); +%FunctionSetLength(e,0); +%FunctionSetPrototype(e,new d()); +%AddNamedProperty(e.prototype,"constructor",e,2); +%AddNamedProperty(e.prototype,j,"Set", +2|1); +%FunctionSetLength(SetForEach,1); +b.InstallGetter(e.prototype,"size",SetGetSize); +b.InstallFunctions(e.prototype,2,[ +"add",SetAdd, +"has",SetHas, +"delete",SetDelete, +"clear",SetClearJS, +"forEach",SetForEach +]); +function MapConstructor(v){ +if((new.target===(void 0))){ +throw %make_type_error(26,"Map"); +} +%_MapInitialize(this); +if(!(v==null)){ +var w=this.set; +if(!(typeof(w)==='function')){ +throw %make_type_error(87,w,'set',this); +} +for(var H of v){ +if(!(%_IsJSReceiver(H))){ +throw %make_type_error(51,H); +} +%_Call(w,this,H[0],H[1]); +} +} +} +function MapGet(p){ +if(!(%_ClassOf(this)==='Map')){ +throw %make_type_error(44, +'Map.prototype.get',this); +} +var l=%_JSCollectionGetTable(this); +var n=((%_FixedArrayGet(l,(0)|0))); +var m=GetExistingHash(p); +if((m===(void 0)))return(void 0); +var q=MapFindEntry(l,n,p,m); +if(q===-1)return(void 0); +return((%_FixedArrayGet(l,((3+(n)+((q)*3))+1)|0))); +} +function MapSet(p,x){ +if(!(%_ClassOf(this)==='Map')){ +throw %make_type_error(44, +'Map.prototype.set',this); +} +if(p===0){ +p=0; +} +var l=%_JSCollectionGetTable(this); +var n=((%_FixedArrayGet(l,(0)|0))); +var m=GetHash(p); +var q=MapFindEntry(l,n,p,m); +if(q!==-1){ +var I=(3+(n)+((q)*3)); +(%_FixedArraySet(l,(I+1)|0,x)); +return this; +} +var y=((%_FixedArrayGet(l,(1)|0))); +var z=((%_FixedArrayGet(l,(2)|0))); +var A=n<<1; +if((y+z)>=A){ +%MapGrow(this); +l=%_JSCollectionGetTable(this); +n=((%_FixedArrayGet(l,(0)|0))); +y=((%_FixedArrayGet(l,(1)|0))); +z=((%_FixedArrayGet(l,(2)|0))); +} +q=y+z; +var B=(3+(n)+((q)*3)); +var o=(m&((n)-1)); +var C=((%_FixedArrayGet(l,(3+(o))|0))); +((%_FixedArraySet(l,(3+(o))|0,q))); +(((%_FixedArraySet(l,(1)|0,(y+1)|0)))); +(%_FixedArraySet(l,(B)|0,p)); +(%_FixedArraySet(l,(B+1)|0,x)); +(%_FixedArraySet(l,(B+2)|0,C)); +return this; +} +function MapHas(p){ +if(!(%_ClassOf(this)==='Map')){ +throw %make_type_error(44, +'Map.prototype.has',this); +} +var l=%_JSCollectionGetTable(this); +var n=((%_FixedArrayGet(l,(0)|0))); +var m=GetHash(p); +return MapFindEntry(l,n,p,m)!==-1; +} +function MapDelete(p){ +if(!(%_ClassOf(this)==='Map')){ +throw %make_type_error(44, +'Map.prototype.delete',this); +} +var l=%_JSCollectionGetTable(this); +var n=((%_FixedArrayGet(l,(0)|0))); +var m=GetHash(p); +var q=MapFindEntry(l,n,p,m); +if(q===-1)return false; +var y=((%_FixedArrayGet(l,(1)|0)))-1; +var z=((%_FixedArrayGet(l,(2)|0)))+1; +var B=(3+(n)+((q)*3)); +(%_FixedArraySet(l,(B)|0,%_TheHole())); +(%_FixedArraySet(l,(B+1)|0,%_TheHole())); +(((%_FixedArraySet(l,(1)|0,(y)|0)))); +(((%_FixedArraySet(l,(2)|0,(z)|0)))); +if(y<(n>>>1))%MapShrink(this); +return true; +} +function MapGetSize(){ +if(!(%_ClassOf(this)==='Map')){ +throw %make_type_error(44, +'Map.prototype.size',this); +} +var l=%_JSCollectionGetTable(this); +return((%_FixedArrayGet(l,(1)|0))); +} +function MapClearJS(){ +if(!(%_ClassOf(this)==='Map')){ +throw %make_type_error(44, +'Map.prototype.clear',this); +} +%_MapClear(this); +} +function MapForEach(D,E){ +if(!(%_ClassOf(this)==='Map')){ +throw %make_type_error(44, +'Map.prototype.forEach',this); +} +if(!(typeof(D)==='function'))throw %make_type_error(14,D); +var F=new h(this,3); +var G=[(void 0),(void 0)]; +while(%MapIteratorNext(F,G)){ +%_Call(D,E,G[1],G[0],this); +} +} +%SetCode(c,MapConstructor); +%FunctionSetLength(c,0); +%FunctionSetPrototype(c,new d()); +%AddNamedProperty(c.prototype,"constructor",c,2); +%AddNamedProperty( +c.prototype,j,"Map",2|1); +%FunctionSetLength(MapForEach,1); +b.InstallGetter(c.prototype,"size",MapGetSize); +b.InstallFunctions(c.prototype,2,[ +"get",MapGet, +"set",MapSet, +"has",MapHas, +"delete",MapDelete, +"clear",MapClearJS, +"forEach",MapForEach +]); +%InstallToContext([ +"map_get",MapGet, +"map_set",MapSet, +"map_has",MapHas, +"map_delete",MapDelete, +"set_add",SetAdd, +"set_has",SetHas, +"set_delete",SetDelete, +]); +b.Export(function(J){ +J.GetExistingHash=GetExistingHash; +J.GetHash=GetHash; +}); +}) + +{ +if(r===true)return; +r=true; +p[o]=h; +if(--m===0){ +var s=[]; +%MoveArrayContents(p,s); +%_Call(q.resolve,(void 0),s); +} +}; +} +try{ +var t=0; +m=1; +for(var u of j){ +var v=this.resolve(u); +++m; +var w=v.then( +CreateResolveElementFunction(t,l,k), +k.reject); +if(n&&%is_promise(w)){ +(w[e]=k.promise); +} +++t; +} +if(--m===0){ +var s=[]; +%MoveArrayContents(l,s); +%_Call(k.resolve,(void 0),s); +} +}catch(e){ +%_Call(k.reject,(void 0),e); +} +return k.promise; +} +function PromiseRace(j){ +if(!(%_IsJSReceiver(this))){ +throw %make_type_error(15,PromiseRace); +} +var k=%new_promise_capability(this,false); +var n=(%_DebugIsActive()!=0); +if(n){ +(k.reject[f]=true); +} +try{ +for(var u of j){ +var w=this.resolve(u).then(k.resolve, +k.reject); +if(n&&%is_promise(w)){ +(w[e]=k.promise); +} +} +}catch(e){ +%_Call(k.reject,(void 0),e); +} +return k.promise; +} +b.InstallFunctions(g,2,[ +"all",PromiseAll, +"race",PromiseRace, +]); +%InstallToContext([ +"promise_id_resolve_handler",PromiseIdResolveHandler, +"promise_id_reject_handler",PromiseIdRejectHandler +]); +}) + + messagesÍ +(function(a,b){ +%CheckIsBootstrapping(); +var c=b.ImportNow("Script"); +%FunctionSetInstanceClassName(c,'Script'); +%AddNamedProperty(c.prototype,'constructor',c, +2|4|1); +function ScriptLocationFromPosition(position, +include_resource_offset){ +return %ScriptPositionInfo(this,position,!!include_resource_offset); +} +function ScriptNameOrSourceURL(){ +if(this.source_url)return this.source_url; +return this.name; +} +b.SetUpLockedPrototype(c,[ +"source", +"name", +"source_url", +"source_mapping_url", +"line_offset", +"column_offset" +],[ +"locationFromPosition",ScriptLocationFromPosition, +"nameOrSourceURL",ScriptNameOrSourceURL, +] +); +}); + +$templates +(function(a,b){ +"use strict"; +%CheckIsBootstrapping(); +var c=a.Map; +var d=b.InternalArray; +var e=new c; +var f=c.prototype.get; +var g=c.prototype.set; +function SameCallSiteElements(h,i){ +var j=h.length; +var i=i.raw; +if(j!==i.length)return false; +for(var k=0;k%JSProxyRevoke(f)}; +} +b.InstallFunctions(c,2,[ +"revocable",ProxyCreateRevocable +]); +}) + +,async-await¡ +(function(a,b,c){ +"use strict"; +%CheckIsBootstrapping(); +var d; +var e; +b.Import(function(f){ +d=f.AsyncFunctionNext; +e=f.AsyncFunctionThrow; +}); +var g= +b.ImportNow("promise_handled_by_symbol"); +var h= +b.ImportNow("promise_forwarding_handler_symbol"); +function PromiseCastResolved(i){ +if(%is_promise(i)){ +return i; +}else{ +var j=%promise_internal_constructor((void 0)); +%promise_resolve(j,i); +return j; +} +} +function AsyncFunctionAwait(k,l,m){ +var j=PromiseCastResolved(l); +var n=sentValue=>{ +%_Call(d,k,sentValue); +return; +}; +var o=sentError=>{ +%_Call(e,k,sentError); +return; +} +var p=%promise_internal_constructor(j); +%PromiseMarkAsHandled(p); +if((%_DebugIsActive()!=0)){ +if(%is_promise(l)){ +(o[h]=true); +} +(p[g]=m); +} +%perform_promise_then(j,n,o,p); +} +function AsyncFunctionAwaitUncaught(k,l,m){ +AsyncFunctionAwait(k,l,m); +} +function AsyncFunctionAwaitCaught(k,l,m){ +if((%_DebugIsActive()!=0)&&%is_promise(l)){ +%PromiseMarkHandledHint(l); +} +AsyncFunctionAwait(k,l,m); +} +function RejectPromiseNoDebugEvent(j,q){ +return %promise_internal_reject(j,q,false); +} +function AsyncFunctionPromiseCreate(){ +var j=%promise_internal_constructor((void 0)); +if((%_DebugIsActive()!=0)){ +%DebugAsyncFunctionPromiseCreated(j); +} +return j; +} +function AsyncFunctionPromiseRelease(j){ +if((%_DebugIsActive()!=0)){ +%DebugPopPromise(); +} +} +%InstallToContext([ +"async_function_await_caught",AsyncFunctionAwaitCaught, +"async_function_await_uncaught",AsyncFunctionAwaitUncaught, +"reject_promise_no_debug_event",RejectPromiseNoDebugEvent, +"async_function_promise_create",AsyncFunctionPromiseCreate, +"async_function_promise_release",AsyncFunctionPromiseRelease, +]); +}) + +Xharmony-string-paddingY +(function(a,b){ +%CheckIsBootstrapping(); +var c=a.String; +function StringPad(d,e,f){ +e=(%_ToLength(e)); +var g=d.length; +if(e<=g)return""; +if((f===(void 0))){ +f=" "; +}else{ +f=(%_ToString(f)); +if(f===""){ +return""; +} +} +var h=e-g; +var i=(h/f.length)|0; +var j=(h-f.length*i)|0; +var k=""; +while(true){ +if(i&1)k+=f; +i>>=1; +if(i===0)break; +f+=f; +} +if(j){ +k+=%_SubString(f,0,j); +} +return k; +} +function StringPadStart(e,f){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.padStart") +var d=(%_ToString(this)); +return StringPad(d,e,f)+d; +} +%FunctionSetLength(StringPadStart,1); +function StringPadEnd(e,f){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.padEnd") +var d=(%_ToString(this)); +return d+StringPad(d,e,f); +} +%FunctionSetLength(StringPadEnd,1); +b.InstallFunctions(c.prototype,2,[ +"padStart",StringPadStart, +"padEnd",StringPadEnd +]); +}); + +i18nêï +(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.v8BreakIterator; +var k=a.Number; +var l=a.RegExp; +var m=a.String; +var n=b.ImportNow("intl_fallback_symbol"); +var o=b.InstallFunctions; +var p=b.InstallGetter; +var q=b.InternalArray; +var r=b.ImportNow("ObjectHasOwnProperty"); +var s=b.OverrideFunction; +var t=b.ImportNow("intl_pattern_symbol"); +var u=b.ImportNow("intl_resolved_symbol"); +var v=b.SetFunctionName; +var w=m.prototype.substr; +var x=m.prototype.substring; +b.Import(function(y){ +c=y.ArrayJoin; +d=y.ArrayPush; +}); +function InstallFunction(z,A,B){ +o(z,2,[A,B]); +} +function AddBoundMethod(obj,methodName,implementation,length,typename, +compat){ +%CheckIsBootstrapping(); +var C=%CreatePrivateSymbol(methodName); +var D=(0,(function(){ +var E=Unwrap(this,typename,obj,methodName,compat); +if((E[C]===(void 0))){ +var F; +if((length===(void 0))||length===2){ +F= +(0,((fst,snd)=>implementation(E,fst,snd))); +}else if(length===1){ +F=(0,(fst=>implementation(E,fst))); +}else{ +F=(0,((...args)=>{ +if(args.length>0){ +return implementation(E,args[0]); +}else{ +return implementation(E); +} +})); +} +%SetNativeFlag(F); +E[C]=F; +} +return E[C]; +})); +%FunctionRemovePrototype(D); +%DefineGetterPropertyUnchecked(obj.prototype,methodName,D,2); +%SetNativeFlag(D); +} +function IntlConstruct(E,constructor,create,newTarget,args, +compat){ +var G=args[0]; +var H=args[1]; +if((newTarget===(void 0))){ +if(compat&&E instanceof constructor){ +let success=%object_define_property(E,n, +{value:new constructor(G,H)}); +if(!success){ +throw %make_type_error(126,constructor); +} +return E; +} +return new constructor(G,H); +} +return create(G,H); +} +function Unwrap(E,I,J,K,L){ +if(!%IsInitializedIntlObjectOfType(E,I)){ +if(L&&E instanceof J){ +let fallback=E[n]; +if(%IsInitializedIntlObjectOfType(fallback,I)){ +return fallback; +} +} +throw %make_type_error(44,K,E); +} +return E; +} +var M={ +'collator':(void 0), +'numberformat':(void 0), +'dateformat':(void 0), +'breakiterator':(void 0) +}; +var N=(void 0); +function GetDefaultICULocaleJS(){ +if((N===(void 0))){ +N=%GetDefaultICULocale(); +} +return N; +} +var O=(void 0); +function GetUnicodeExtensionRE(){ +if(((void 0)===(void 0))){ +O=new l('-u(-[a-z0-9]{2,8})+','g'); +} +return O; +} +var P=(void 0); +function GetAnyExtensionRE(){ +if((P===(void 0))){ +P=new l('-[a-z0-9]{1}-.*','g'); +} +return P; +} +var Q=(void 0); +function GetQuotedStringRE(){ +if((Q===(void 0))){ +Q=new l("'[^']+'",'g'); +} +return Q; +} +var R=(void 0); +function GetServiceRE(){ +if((R===(void 0))){ +R= +new l('^(collator|numberformat|dateformat|breakiterator)$'); +} +return R; +} +var S=(void 0); +function GetLanguageTagRE(){ +if((S===(void 0))){ +BuildLanguageTagREs(); +} +return S; +} +var T=(void 0); +function GetLanguageVariantRE(){ +if((T===(void 0))){ +BuildLanguageTagREs(); +} +return T; +} +var U=(void 0); +function GetLanguageSingletonRE(){ +if((U===(void 0))){ +BuildLanguageTagREs(); +} +return U; +} +var V=(void 0); +function GetTimezoneNameCheckRE(){ +if((V===(void 0))){ +V=new l( +'^([A-Za-z]+)/([A-Za-z_-]+)((?:\/[A-Za-z_-]+)+)*$'); +} +return V; +} +var W=(void 0); +function GetTimezoneNameLocationPartRE(){ +if((W===(void 0))){ +W= +new l('^([A-Za-z]+)((?:[_-][A-Za-z]+)+)*$'); +} +return W; +} +function supportedLocalesOf(X,G,H){ +if((%regexp_internal_match(GetServiceRE(),X)===null)){ +throw %make_error(7,X); +} +if((H===(void 0))){ +H={}; +}else{ +H=(%_ToObject(H)); +} +var Y=H.localeMatcher; +if(!(Y===(void 0))){ +Y=(%_ToString(Y)); +if(Y!=='lookup'&&Y!=='best fit'){ +throw %make_range_error(174,Y); +} +}else{ +Y='best fit'; +} +var Z=initializeLocaleList(G); +if((M[X]===(void 0))){ +M[X]=getAvailableLocalesOf(X); +} +if(Y==='best fit'){ +return initializeLocaleList(bestFitSupportedLocalesOf( +Z,M[X])); +} +return initializeLocaleList(lookupSupportedLocalesOf( +Z,M[X])); +} +function lookupSupportedLocalesOf(Z,aa){ +var ab=new q(); +for(var ac=0;ac=3&&as<=8&&!(ar===(void 0))){ +if((al===(void 0))){ +al=at; +}else{ +al=al+"-"+at; +} +}else{ +return{}; +} +} +if(!(ar===(void 0))&&!(ar in aq)){ +aq[ar]=al; +} +return aq; +} +function setOptions(au,aq,av,ag,aw){ +var ao=''; +var ax=function updateExtension(ar,al){ +return'-'+ar+'-'+(%_ToString(al)); +} +var ay=function updateProperty(ah,ai,al){ +if(ai==='boolean'&&(typeof al==='string')){ +al=(al==='true')?true:false; +} +if(!(ah===(void 0))){ +defineWEProperty(aw,ah,al); +} +} +for(var ar in av){ +if((%_Call(r,av,ar))){ +var al=(void 0); +var az=av[ar]; +if(!(az.property===(void 0))){ +al=ag(az.property,az.type,az.values); +} +if(!(al===(void 0))){ +ay(az.property,az.type,al); +ao+=ax(ar,al); +continue; +} +if((%_Call(r,aq,ar))){ +al=aq[ar]; +if(!(al===(void 0))){ +ay(az.property,az.type,al); +ao+=ax(ar,al); +}else if(az.type==='boolean'){ +ay(az.property,az.type,true); +ao+=ax(ar,true); +} +} +} +} +return ao===''?'':'-u'+ao; +} +function freezeArray(aA){ +var aB=[]; +var aC=aA.length; +for(var ac=0;acbz){ +throw %make_range_error(177,ah); +} +return %math_floor(al); +} +return bA; +} +var bB={ +get(){ +%IncrementUseCounter(15); +return this[t]; +}, +set(al){ +this[t]=al; +} +}; +function CreateNumberFormat(G,H){ +if((H===(void 0))){ +H={}; +} +var ag=getGetOption(H,'numberformat'); +var ad=resolveLocale('numberformat',G,H); +var bn={}; +defineWEProperty(bn,'style',ag( +'style','string',['decimal','percent','currency'],'decimal')); +var bx=ag('currency','string'); +if(!(bx===(void 0))&&!isWellFormedCurrencyCode(bx)){ +throw %make_range_error(158,bx); +} +if(bn.style==='currency'&&(bx===(void 0))){ +throw %make_type_error(28); +} +var bC=ag( +'currencyDisplay','string',['code','symbol','name'],'symbol'); +if(bn.style==='currency'){ +defineWEProperty(bn,'currency',%StringToUpperCase(bx)); +defineWEProperty(bn,'currencyDisplay',bC); +} +var bD=getNumberOption(H,'minimumIntegerDigits',1,21,1); +defineWEProperty(bn,'minimumIntegerDigits',bD); +var bE=H['minimumFractionDigits']; +var bF=H['maximumFractionDigits']; +if(!(bE===(void 0))||bn.style!=='currency'){ +bE=getNumberOption(H,'minimumFractionDigits',0,20,0); +defineWEProperty(bn,'minimumFractionDigits',bE); +} +if(!(bF===(void 0))||bn.style!=='currency'){ +var bG=bn.style==='percent'?0:3; +bE=(bE===(void 0))?0:bE; +var bH=(bE>bG)?bE:bG; +bF=getNumberOption(H,'maximumFractionDigits',bE,20,bH); +defineWEProperty(bn,'maximumFractionDigits',bF); +} +var bI=H['minimumSignificantDigits']; +var bJ=H['maximumSignificantDigits']; +if(!(bI===(void 0))||!(bJ===(void 0))){ +bI=getNumberOption(H,'minimumSignificantDigits',1,21,0); +defineWEProperty(bn,'minimumSignificantDigits',bI); +bJ=getNumberOption(H,'maximumSignificantDigits',bI,21,21); +defineWEProperty(bn,'maximumSignificantDigits',bJ); +} +defineWEProperty(bn,'useGrouping',ag( +'useGrouping','boolean',(void 0),true)); +var aq=parseExtension(ad.extension); +var bK={ +'nu':{'property':(void 0),'type':'string'} +}; +var ao=setOptions(H,aq,bK, +ag,bn); +var bs=ad.locale+ao; +var am=%object_define_properties({},{ +currency:{writable:true}, +currencyDisplay:{writable:true}, +locale:{writable:true}, +maximumFractionDigits:{writable:true}, +minimumFractionDigits:{writable:true}, +minimumIntegerDigits:{writable:true}, +numberingSystem:{writable:true}, +requestedLocale:{value:bs,writable:true}, +style:{value:bn.style,writable:true}, +useGrouping:{writable:true} +}); +if((%_Call(r,bn,'minimumSignificantDigits'))){ +defineWEProperty(am,'minimumSignificantDigits',(void 0)); +} +if((%_Call(r,bn,'maximumSignificantDigits'))){ +defineWEProperty(am,'maximumSignificantDigits',(void 0)); +} +var bL=%CreateNumberFormat(bs,bn, +am); +if(bn.style==='currency'){ +%object_define_property(am,'currencyDisplay', +{value:bC,writable:true}); +} +%MarkAsInitializedIntlObjectOfType(bL,'numberformat'); +bL[u]=am; +return bL; +} +function NumberFormatConstructor(){ +return IntlConstruct(this,h,CreateNumberFormat, +new.target,arguments,true); +} +%SetCode(h,NumberFormatConstructor); +InstallFunction(h.prototype,'resolvedOptions', +function(){ +var bM=Unwrap(this,'numberformat',h, +'resolvedOptions',true); +var ad=getOptimalLanguageTag(bM[u].requestedLocale, +bM[u].locale); +var aK={ +locale:ad, +numberingSystem:bM[u].numberingSystem, +style:bM[u].style, +useGrouping:bM[u].useGrouping, +minimumIntegerDigits:bM[u].minimumIntegerDigits, +minimumFractionDigits:bM[u].minimumFractionDigits, +maximumFractionDigits:bM[u].maximumFractionDigits, +}; +if(aK.style==='currency'){ +defineWECProperty(aK,'currency',bM[u].currency); +defineWECProperty(aK,'currencyDisplay', +bM[u].currencyDisplay); +} +if((%_Call(r,bM[u],'minimumSignificantDigits'))){ +defineWECProperty(aK,'minimumSignificantDigits', +bM[u].minimumSignificantDigits); +} +if((%_Call(r,bM[u],'maximumSignificantDigits'))){ +defineWECProperty(aK,'maximumSignificantDigits', +bM[u].maximumSignificantDigits); +} +return aK; +} +); +InstallFunction(h,'supportedLocalesOf', +function(G){ +return supportedLocalesOf('numberformat',G,arguments[1]); +} +); +function formatNumber(bN,al){ +var bO=(%_ToNumber(al))+0; +return %InternalNumberFormat(bN,bO); +} +AddBoundMethod(h,'format',formatNumber,1, +'numberformat',true); +function toLDMLString(H){ +var ag=getGetOption(H,'dateformat'); +var bP=''; +var bQ=ag('weekday','string',['narrow','short','long']); +bP+=appendToLDMLString( +bQ,{narrow:'EEEEE',short:'EEE',long:'EEEE'}); +bQ=ag('era','string',['narrow','short','long']); +bP+=appendToLDMLString( +bQ,{narrow:'GGGGG',short:'GGG',long:'GGGG'}); +bQ=ag('year','string',['2-digit','numeric']); +bP+=appendToLDMLString(bQ,{'2-digit':'yy','numeric':'y'}); +bQ=ag('month','string', +['2-digit','numeric','narrow','short','long']); +bP+=appendToLDMLString(bQ,{'2-digit':'MM','numeric':'M', +'narrow':'MMMMM','short':'MMM','long':'MMMM'}); +bQ=ag('day','string',['2-digit','numeric']); +bP+=appendToLDMLString( +bQ,{'2-digit':'dd','numeric':'d'}); +var bR=ag('hour12','boolean'); +bQ=ag('hour','string',['2-digit','numeric']); +if((bR===(void 0))){ +bP+=appendToLDMLString(bQ,{'2-digit':'jj','numeric':'j'}); +}else if(bR===true){ +bP+=appendToLDMLString(bQ,{'2-digit':'hh','numeric':'h'}); +}else{ +bP+=appendToLDMLString(bQ,{'2-digit':'HH','numeric':'H'}); +} +bQ=ag('minute','string',['2-digit','numeric']); +bP+=appendToLDMLString(bQ,{'2-digit':'mm','numeric':'m'}); +bQ=ag('second','string',['2-digit','numeric']); +bP+=appendToLDMLString(bQ,{'2-digit':'ss','numeric':'s'}); +bQ=ag('timeZoneName','string',['short','long']); +bP+=appendToLDMLString(bQ,{short:'z',long:'zzzz'}); +return bP; +} +function appendToLDMLString(bQ,bS){ +if(!(bQ===(void 0))){ +return bS[bQ]; +}else{ +return''; +} +} +function fromLDMLString(bP){ +bP=%RegExpInternalReplace(GetQuotedStringRE(),bP,''); +var H={}; +var aJ=%regexp_internal_match(/E{3,5}/,bP); +H=appendToDateTimeObject( +H,'weekday',aJ,{EEEEE:'narrow',EEE:'short',EEEE:'long'}); +aJ=%regexp_internal_match(/G{3,5}/,bP); +H=appendToDateTimeObject( +H,'era',aJ,{GGGGG:'narrow',GGG:'short',GGGG:'long'}); +aJ=%regexp_internal_match(/y{1,2}/,bP); +H=appendToDateTimeObject( +H,'year',aJ,{y:'numeric',yy:'2-digit'}); +aJ=%regexp_internal_match(/M{1,5}/,bP); +H=appendToDateTimeObject(H,'month',aJ,{MM:'2-digit', +M:'numeric',MMMMM:'narrow',MMM:'short',MMMM:'long'}); +aJ=%regexp_internal_match(/L{1,5}/,bP); +H=appendToDateTimeObject(H,'month',aJ,{LL:'2-digit', +L:'numeric',LLLLL:'narrow',LLL:'short',LLLL:'long'}); +aJ=%regexp_internal_match(/d{1,2}/,bP); +H=appendToDateTimeObject( +H,'day',aJ,{d:'numeric',dd:'2-digit'}); +aJ=%regexp_internal_match(/h{1,2}/,bP); +if(aJ!==null){ +H['hour12']=true; +} +H=appendToDateTimeObject( +H,'hour',aJ,{h:'numeric',hh:'2-digit'}); +aJ=%regexp_internal_match(/H{1,2}/,bP); +if(aJ!==null){ +H['hour12']=false; +} +H=appendToDateTimeObject( +H,'hour',aJ,{H:'numeric',HH:'2-digit'}); +aJ=%regexp_internal_match(/m{1,2}/,bP); +H=appendToDateTimeObject( +H,'minute',aJ,{m:'numeric',mm:'2-digit'}); +aJ=%regexp_internal_match(/s{1,2}/,bP); +H=appendToDateTimeObject( +H,'second',aJ,{s:'numeric',ss:'2-digit'}); +aJ=%regexp_internal_match(/z|zzzz/,bP); +H=appendToDateTimeObject( +H,'timeZoneName',aJ,{z:'short',zzzz:'long'}); +return H; +} +function appendToDateTimeObject(H,bQ,aJ,bS){ +if((aJ===null)){ +if(!(%_Call(r,H,bQ))){ +defineWEProperty(H,bQ,(void 0)); +} +return H; +} +var ah=aJ[0]; +defineWEProperty(H,bQ,bS[ah]); +return H; +} +function toDateTimeOptions(H,bT,bU){ +if((H===(void 0))){ +H={}; +}else{ +H=(%_ToObject(H)); +} +H=%object_create(H); +var bV=true; +if((bT==='date'||bT==='any')&& +(!(H.weekday===(void 0))||!(H.year===(void 0))|| +!(H.month===(void 0))||!(H.day===(void 0)))){ +bV=false; +} +if((bT==='time'||bT==='any')&& +(!(H.hour===(void 0))||!(H.minute===(void 0))|| +!(H.second===(void 0)))){ +bV=false; +} +if(bV&&(bU==='date'||bU==='all')){ +%object_define_property(H,'year',{value:'numeric', +writable:true, +enumerable:true, +configurable:true}); +%object_define_property(H,'month',{value:'numeric', +writable:true, +enumerable:true, +configurable:true}); +%object_define_property(H,'day',{value:'numeric', +writable:true, +enumerable:true, +configurable:true}); +} +if(bV&&(bU==='time'||bU==='all')){ +%object_define_property(H,'hour',{value:'numeric', +writable:true, +enumerable:true, +configurable:true}); +%object_define_property(H,'minute',{value:'numeric', +writable:true, +enumerable:true, +configurable:true}); +%object_define_property(H,'second',{value:'numeric', +writable:true, +enumerable:true, +configurable:true}); +} +return H; +} +function CreateDateTimeFormat(G,H){ +if((H===(void 0))){ +H={}; +} +var ad=resolveLocale('dateformat',G,H); +H=toDateTimeOptions(H,'any','date'); +var ag=getGetOption(H,'dateformat'); +var Y=ag('formatMatcher','string', +['basic','best fit'],'best fit'); +var bP=toLDMLString(H); +var bW=canonicalizeTimeZoneID(H.timeZone); +var bn={}; +var aq=parseExtension(ad.extension); +var bX={ +'ca':{'property':(void 0),'type':'string'}, +'nu':{'property':(void 0),'type':'string'} +}; +var ao=setOptions(H,aq,bX, +ag,bn); +var bs=ad.locale+ao; +var am=%object_define_properties({},{ +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}, +[t]:{writable:true}, +requestedLocale:{value:bs,writable:true}, +second:{writable:true}, +timeZone:{writable:true}, +timeZoneName:{writable:true}, +tz:{value:bW,writable:true}, +weekday:{writable:true}, +year:{writable:true} +}); +var bY=%CreateDateTimeFormat( +bs,{skeleton:bP,timeZone:bW},am); +if(am.timeZone==="Etc/Unknown"){ +throw %make_range_error(183,bW); +} +%MarkAsInitializedIntlObjectOfType(bY,'dateformat'); +bY[u]=am; +return bY; +} +function DateTimeFormatConstructor(){ +return IntlConstruct(this,g,CreateDateTimeFormat, +new.target,arguments,true); +} +%SetCode(g,DateTimeFormatConstructor); +InstallFunction(g.prototype,'resolvedOptions', +function(){ +var bM=Unwrap(this,'dateformat',g, +'resolvedOptions',true); +var bZ={ +'gregorian':'gregory', +'ethiopic-amete-alem':'ethioaa' +}; +var ca=fromLDMLString(bM[u][t]); +var cb=bZ[bM[u].calendar]; +if((cb===(void 0))){ +cb=bM[u].calendar; +} +var ad=getOptimalLanguageTag(bM[u].requestedLocale, +bM[u].locale); +var aK={ +locale:ad, +numberingSystem:bM[u].numberingSystem, +calendar:cb, +timeZone:bM[u].timeZone +}; +addWECPropertyIfDefined(aK,'timeZoneName',ca.timeZoneName); +addWECPropertyIfDefined(aK,'era',ca.era); +addWECPropertyIfDefined(aK,'year',ca.year); +addWECPropertyIfDefined(aK,'month',ca.month); +addWECPropertyIfDefined(aK,'day',ca.day); +addWECPropertyIfDefined(aK,'weekday',ca.weekday); +addWECPropertyIfDefined(aK,'hour12',ca.hour12); +addWECPropertyIfDefined(aK,'hour',ca.hour); +addWECPropertyIfDefined(aK,'minute',ca.minute); +addWECPropertyIfDefined(aK,'second',ca.second); +return aK; +} +); +InstallFunction(g,'supportedLocalesOf', +function(G){ +return supportedLocalesOf('dateformat',G,arguments[1]); +} +); +function formatDate(bN,cc){ +var cd; +if((cc===(void 0))){ +cd=%DateCurrentTime(); +}else{ +cd=(%_ToNumber(cc)); +} +if(!(%_IsSmi(%IS_VAR(cd))||((cd==cd)&&(cd!=1/0)&&(cd!=-1/0))))throw %make_range_error(149); +return %InternalDateFormat(bN,new e(cd)); +} +function FormatDateToParts(cc){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"Intl.DateTimeFormat.prototype.formatToParts"); +if(!(typeof(this)==='object')){ +throw %make_type_error(15,this); +} +if(!%IsInitializedIntlObjectOfType(this,'dateformat')){ +throw %make_type_error(44, +'Intl.DateTimeFormat.prototype.formatToParts', +this); +} +var cd; +if((cc===(void 0))){ +cd=%DateCurrentTime(); +}else{ +cd=(%_ToNumber(cc)); +} +if(!(%_IsSmi(%IS_VAR(cd))||((cd==cd)&&(cd!=1/0)&&(cd!=-1/0))))throw %make_range_error(149); +return %InternalDateFormatToParts(this,new e(cd)); +} +%FunctionSetLength(FormatDateToParts,0); +AddBoundMethod(g,'format',formatDate,0,'dateformat', +true); +function canonicalizeTimeZoneID(ce){ +if((ce===(void 0))){ +return ce; +} +ce=(%_ToString(ce)); +var cf=%StringToUpperCase(ce); +if(cf==='UTC'||cf==='GMT'|| +cf==='ETC/UTC'||cf==='ETC/GMT'){ +return'UTC'; +} +var aJ=%regexp_internal_match(GetTimezoneNameCheckRE(),ce); +if((aJ===null))throw %make_range_error(150,ce); +var aK=toTitleCaseTimezoneLocation(aJ[1])+'/'+ +toTitleCaseTimezoneLocation(aJ[2]); +if(!(aJ[3]===(void 0))&&30?G[0]:GetDefaultICULocaleJS(); +} +var ae=%StringIndexOf(bj,'-',0); +if(ae!==-1){ +bj=%_Call(x,bj,0,ae); +} +return %StringLocaleConvertCase(cp,cq,bj); +} +s(m.prototype,'localeCompare',function(cr){ +if((this==null)){ +throw %make_type_error(54); +} +var G=arguments[1]; +var H=arguments[2]; +var bt=cachedOrNewService('collator',G,H); +return compare(bt,this,cr); +} +); +s(m.prototype,'normalize',function(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.normalize"); +var cp=(%_ToString(this)); +var cs=arguments[0]; +var ct=(cs===(void 0))?'NFC':(%_ToString(cs)); +var cu=['NFC','NFD','NFKC','NFKD']; +var cv=%ArrayIndexOf(cu,ct,0); +if(cv===-1){ +throw %make_range_error(175, +%_Call(c,cu,', ')); +} +return %StringNormalize(cp,cv); +} +); +function ToLowerCaseI18N(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.toLowerCase"); +return %StringToLowerCaseI18N((%_ToString(this))); +} +function ToUpperCaseI18N(){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.toUpperCase"); +return %StringToUpperCaseI18N((%_ToString(this))); +} +function ToLocaleLowerCaseI18N(G){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.toLocaleLowerCase"); +return LocaleConvertCase((%_ToString(this)),G,false); +} +%FunctionSetLength(ToLocaleLowerCaseI18N,0); +function ToLocaleUpperCaseI18N(G){ +if((%IS_VAR(this)===null)||(this===(void 0)))throw %make_type_error(16,"String.prototype.toLocaleUpperCase"); +return LocaleConvertCase((%_ToString(this)),G,true); +} +%FunctionSetLength(ToLocaleUpperCaseI18N,0); +%FunctionRemovePrototype(ToLowerCaseI18N); +%FunctionRemovePrototype(ToUpperCaseI18N); +%FunctionRemovePrototype(ToLocaleLowerCaseI18N); +%FunctionRemovePrototype(ToLocaleUpperCaseI18N); +b.Export(function(cw){ +cw.ToLowerCaseI18N=ToLowerCaseI18N; +cw.ToUpperCaseI18N=ToUpperCaseI18N; +cw.ToLocaleLowerCaseI18N=ToLocaleLowerCaseI18N; +cw.ToLocaleUpperCaseI18N=ToLocaleUpperCaseI18N; +}); +s(k.prototype,'toLocaleString',function(){ +if(!(this instanceof k)&&typeof(this)!=='number'){ +throw %make_type_error(55,"Number"); +} +var G=arguments[0]; +var H=arguments[1]; +var bL=cachedOrNewService('numberformat',G,H); +return formatNumber(bL,this); +} +); +function toLocaleDateTime(cx,G,H,bT,bU,X){ +if(!(cx instanceof e)){ +throw %make_type_error(55,"Date"); +} +var cc=(%_ToNumber(cx)); +if((!%_IsSmi(%IS_VAR(cc))&&!(cc==cc)))return'Invalid Date'; +var bn=toDateTimeOptions(H,bT,bU); +var bY= +cachedOrNewService(X,G,H,bn); +return formatDate(bY,cx); +} +s(e.prototype,'toLocaleString',function(){ +var G=arguments[0]; +var H=arguments[1]; +return toLocaleDateTime( +this,G,H,'any','all','dateformatall'); +} +); +s(e.prototype,'toLocaleDateString',function(){ +var G=arguments[0]; +var H=arguments[1]; +return toLocaleDateTime( +this,G,H,'date','date','dateformatdate'); +} +); +s(e.prototype,'toLocaleTimeString',function(){ +var G=arguments[0]; +var H=arguments[1]; +return toLocaleDateTime( +this,G,H,'time','time','dateformattime'); +} +); +%FunctionRemovePrototype(FormatDateToParts); +b.Export(function(cw){ +cw.FormatDateToParts=FormatDateToParts; +}); +}) + +=i){ +throw %make_range_error(155); +} +return k; +} +function AtomicsCompareExchangeJS(l,h,m,n){ +CheckSharedIntegerTypedArray(l); +h=ValidateIndex(h,%_TypedArrayGetLength(l)); +m=(%_ToNumber(m)); +n=(%_ToNumber(n)); +return %_AtomicsCompareExchange(l,h,m,n); +} +function AtomicsAddJS(g,h,o){ +CheckSharedIntegerTypedArray(g); +h=ValidateIndex(h,%_TypedArrayGetLength(g)); +o=(%_ToNumber(o)); +return %_AtomicsAdd(g,h,o); +} +function AtomicsSubJS(g,h,o){ +CheckSharedIntegerTypedArray(g); +h=ValidateIndex(h,%_TypedArrayGetLength(g)); +o=(%_ToNumber(o)); +return %_AtomicsSub(g,h,o); +} +function AtomicsAndJS(g,h,o){ +CheckSharedIntegerTypedArray(g); +h=ValidateIndex(h,%_TypedArrayGetLength(g)); +o=(%_ToNumber(o)); +return %_AtomicsAnd(g,h,o); +} +function AtomicsOrJS(g,h,o){ +CheckSharedIntegerTypedArray(g); +h=ValidateIndex(h,%_TypedArrayGetLength(g)); +o=(%_ToNumber(o)); +return %_AtomicsOr(g,h,o); +} +function AtomicsXorJS(g,h,o){ +CheckSharedIntegerTypedArray(g); +h=ValidateIndex(h,%_TypedArrayGetLength(g)); +o=(%_ToNumber(o)); +return %_AtomicsXor(g,h,o); +} +function AtomicsExchangeJS(g,h,o){ +CheckSharedIntegerTypedArray(g); +h=ValidateIndex(h,%_TypedArrayGetLength(g)); +o=(%_ToNumber(o)); +return %_AtomicsExchange(g,h,o); +} +function AtomicsIsLockFreeJS(p){ +return %_AtomicsIsLockFree(p); +} +function AtomicsWaitJS(g,h,o,q){ +CheckSharedInteger32TypedArray(g); +h=ValidateIndex(h,%_TypedArrayGetLength(g)); +if((q===(void 0))){ +q=(1/0); +}else{ +q=(%_ToNumber(q)); +if((!%_IsSmi(%IS_VAR(q))&&!(q==q))){ +q=(1/0); +}else{ +q=d(0,q); +} +} +return %AtomicsWait(g,h,o,q); +} +function AtomicsWakeJS(g,h,r){ +CheckSharedInteger32TypedArray(g); +h=ValidateIndex(h,%_TypedArrayGetLength(g)); +r=d(0,(%_ToInteger(r))); +return %AtomicsWake(g,h,r); +} +var s=a.Atomics; +%AddNamedProperty(s,e,"Atomics",1|2); +b.InstallFunctions(s,2,[ +"compareExchange",AtomicsCompareExchangeJS, +"add",AtomicsAddJS, +"sub",AtomicsSubJS, +"and",AtomicsAndJS, +"or",AtomicsOrJS, +"xor",AtomicsXorJS, +"exchange",AtomicsExchangeJS, +"isLockFree",AtomicsIsLockFreeJS, +"wait",AtomicsWaitJS, +"wake",AtomicsWakeJS, +]); +}) + +0harmony-simdŽ´ +(function(a,b){ +"use strict"; +%CheckIsBootstrapping(); +var c=a.SIMD; +var d=b.ImportNow("to_string_tag_symbol"); +var e=c.Float32x4; + + +var f=c.Int32x4; + +var g=c.Int16x8; + +var h=c.Int8x16; + + +var i=c.Uint32x4; + +var j=c.Uint16x8; + +var k=c.Uint8x16; + + +var l=c.Bool32x4; + +var m=c.Bool16x8; + +var n=c.Bool8x16; + + + +function Float32x4CheckJS(o){ +return %Float32x4Check(o); +} +function Float32x4ToString(){ +var p=%ValueOf(this); +if(typeof(p)!=='float32x4'){ +throw %make_type_error(44, +"Float32x4.prototype.toString",this); +} +var q="SIMD.Float32x4("; +q+=%Float32x4ExtractLane(p,0); +for(var r=1;r<4;r++){ +q+=", "+%Float32x4ExtractLane(p,r); +} +return q+")"; +} +function Float32x4ToLocaleString(){ +var p=%ValueOf(this); +if(typeof(p)!=='float32x4'){ +throw %make_type_error(44, +"Float32x4.prototype.toLocaleString",this); +} +var q="SIMD.Float32x4("; +q+=%Float32x4ExtractLane(p,0).toLocaleString(); +for(var r=1;r<4;r++){ +q+=", "+%Float32x4ExtractLane(p,r).toLocaleString(); +} +return q+")"; +} +function Float32x4ValueOf(){ +var p=%ValueOf(this); +if(typeof(p)!=='float32x4'){ +throw %make_type_error(44, +"Float32x4.prototype.valueOf",this); +} +return p; +} +function Float32x4ExtractLaneJS(s,t){ +return %Float32x4ExtractLane(s,t); +} + + +function Int32x4CheckJS(o){ +return %Int32x4Check(o); +} +function Int32x4ToString(){ +var p=%ValueOf(this); +if(typeof(p)!=='int32x4'){ +throw %make_type_error(44, +"Int32x4.prototype.toString",this); +} +var q="SIMD.Int32x4("; +q+=%Int32x4ExtractLane(p,0); +for(var r=1;r<4;r++){ +q+=", "+%Int32x4ExtractLane(p,r); +} +return q+")"; +} +function Int32x4ToLocaleString(){ +var p=%ValueOf(this); +if(typeof(p)!=='int32x4'){ +throw %make_type_error(44, +"Int32x4.prototype.toLocaleString",this); +} +var q="SIMD.Int32x4("; +q+=%Int32x4ExtractLane(p,0).toLocaleString(); +for(var r=1;r<4;r++){ +q+=", "+%Int32x4ExtractLane(p,r).toLocaleString(); +} +return q+")"; +} +function Int32x4ValueOf(){ +var p=%ValueOf(this); +if(typeof(p)!=='int32x4'){ +throw %make_type_error(44, +"Int32x4.prototype.valueOf",this); +} +return p; +} +function Int32x4ExtractLaneJS(s,t){ +return %Int32x4ExtractLane(s,t); +} + +function Int16x8CheckJS(o){ +return %Int16x8Check(o); +} +function Int16x8ToString(){ +var p=%ValueOf(this); +if(typeof(p)!=='int16x8'){ +throw %make_type_error(44, +"Int16x8.prototype.toString",this); +} +var q="SIMD.Int16x8("; +q+=%Int16x8ExtractLane(p,0); +for(var r=1;r<8;r++){ +q+=", "+%Int16x8ExtractLane(p,r); +} +return q+")"; +} +function Int16x8ToLocaleString(){ +var p=%ValueOf(this); +if(typeof(p)!=='int16x8'){ +throw %make_type_error(44, +"Int16x8.prototype.toLocaleString",this); +} +var q="SIMD.Int16x8("; +q+=%Int16x8ExtractLane(p,0).toLocaleString(); +for(var r=1;r<8;r++){ +q+=", "+%Int16x8ExtractLane(p,r).toLocaleString(); +} +return q+")"; +} +function Int16x8ValueOf(){ +var p=%ValueOf(this); +if(typeof(p)!=='int16x8'){ +throw %make_type_error(44, +"Int16x8.prototype.valueOf",this); +} +return p; +} +function Int16x8ExtractLaneJS(s,t){ +return %Int16x8ExtractLane(s,t); +} + +function Int8x16CheckJS(o){ +return %Int8x16Check(o); +} +function Int8x16ToString(){ +var p=%ValueOf(this); +if(typeof(p)!=='int8x16'){ +throw %make_type_error(44, +"Int8x16.prototype.toString",this); +} +var q="SIMD.Int8x16("; +q+=%Int8x16ExtractLane(p,0); +for(var r=1;r<16;r++){ +q+=", "+%Int8x16ExtractLane(p,r); +} +return q+")"; +} +function Int8x16ToLocaleString(){ +var p=%ValueOf(this); +if(typeof(p)!=='int8x16'){ +throw %make_type_error(44, +"Int8x16.prototype.toLocaleString",this); +} +var q="SIMD.Int8x16("; +q+=%Int8x16ExtractLane(p,0).toLocaleString(); +for(var r=1;r<16;r++){ +q+=", "+%Int8x16ExtractLane(p,r).toLocaleString(); +} +return q+")"; +} +function Int8x16ValueOf(){ +var p=%ValueOf(this); +if(typeof(p)!=='int8x16'){ +throw %make_type_error(44, +"Int8x16.prototype.valueOf",this); +} +return p; +} +function Int8x16ExtractLaneJS(s,t){ +return %Int8x16ExtractLane(s,t); +} + + +function Uint32x4CheckJS(o){ +return %Uint32x4Check(o); +} +function Uint32x4ToString(){ +var p=%ValueOf(this); +if(typeof(p)!=='uint32x4'){ +throw %make_type_error(44, +"Uint32x4.prototype.toString",this); +} +var q="SIMD.Uint32x4("; +q+=%Uint32x4ExtractLane(p,0); +for(var r=1;r<4;r++){ +q+=", "+%Uint32x4ExtractLane(p,r); +} +return q+")"; +} +function Uint32x4ToLocaleString(){ +var p=%ValueOf(this); +if(typeof(p)!=='uint32x4'){ +throw %make_type_error(44, +"Uint32x4.prototype.toLocaleString",this); +} +var q="SIMD.Uint32x4("; +q+=%Uint32x4ExtractLane(p,0).toLocaleString(); +for(var r=1;r<4;r++){ +q+=", "+%Uint32x4ExtractLane(p,r).toLocaleString(); +} +return q+")"; +} +function Uint32x4ValueOf(){ +var p=%ValueOf(this); +if(typeof(p)!=='uint32x4'){ +throw %make_type_error(44, +"Uint32x4.prototype.valueOf",this); +} +return p; +} +function Uint32x4ExtractLaneJS(s,t){ +return %Uint32x4ExtractLane(s,t); +} + +function Uint16x8CheckJS(o){ +return %Uint16x8Check(o); +} +function Uint16x8ToString(){ +var p=%ValueOf(this); +if(typeof(p)!=='uint16x8'){ +throw %make_type_error(44, +"Uint16x8.prototype.toString",this); +} +var q="SIMD.Uint16x8("; +q+=%Uint16x8ExtractLane(p,0); +for(var r=1;r<8;r++){ +q+=", "+%Uint16x8ExtractLane(p,r); +} +return q+")"; +} +function Uint16x8ToLocaleString(){ +var p=%ValueOf(this); +if(typeof(p)!=='uint16x8'){ +throw %make_type_error(44, +"Uint16x8.prototype.toLocaleString",this); +} +var q="SIMD.Uint16x8("; +q+=%Uint16x8ExtractLane(p,0).toLocaleString(); +for(var r=1;r<8;r++){ +q+=", "+%Uint16x8ExtractLane(p,r).toLocaleString(); +} +return q+")"; +} +function Uint16x8ValueOf(){ +var p=%ValueOf(this); +if(typeof(p)!=='uint16x8'){ +throw %make_type_error(44, +"Uint16x8.prototype.valueOf",this); +} +return p; +} +function Uint16x8ExtractLaneJS(s,t){ +return %Uint16x8ExtractLane(s,t); +} + +function Uint8x16CheckJS(o){ +return %Uint8x16Check(o); +} +function Uint8x16ToString(){ +var p=%ValueOf(this); +if(typeof(p)!=='uint8x16'){ +throw %make_type_error(44, +"Uint8x16.prototype.toString",this); +} +var q="SIMD.Uint8x16("; +q+=%Uint8x16ExtractLane(p,0); +for(var r=1;r<16;r++){ +q+=", "+%Uint8x16ExtractLane(p,r); +} +return q+")"; +} +function Uint8x16ToLocaleString(){ +var p=%ValueOf(this); +if(typeof(p)!=='uint8x16'){ +throw %make_type_error(44, +"Uint8x16.prototype.toLocaleString",this); +} +var q="SIMD.Uint8x16("; +q+=%Uint8x16ExtractLane(p,0).toLocaleString(); +for(var r=1;r<16;r++){ +q+=", "+%Uint8x16ExtractLane(p,r).toLocaleString(); +} +return q+")"; +} +function Uint8x16ValueOf(){ +var p=%ValueOf(this); +if(typeof(p)!=='uint8x16'){ +throw %make_type_error(44, +"Uint8x16.prototype.valueOf",this); +} +return p; +} +function Uint8x16ExtractLaneJS(s,t){ +return %Uint8x16ExtractLane(s,t); +} + + +function Bool32x4CheckJS(o){ +return %Bool32x4Check(o); +} +function Bool32x4ToString(){ +var p=%ValueOf(this); +if(typeof(p)!=='bool32x4'){ +throw %make_type_error(44, +"Bool32x4.prototype.toString",this); +} +var q="SIMD.Bool32x4("; +q+=%Bool32x4ExtractLane(p,0); +for(var r=1;r<4;r++){ +q+=", "+%Bool32x4ExtractLane(p,r); +} +return q+")"; +} +function Bool32x4ToLocaleString(){ +var p=%ValueOf(this); +if(typeof(p)!=='bool32x4'){ +throw %make_type_error(44, +"Bool32x4.prototype.toLocaleString",this); +} +var q="SIMD.Bool32x4("; +q+=%Bool32x4ExtractLane(p,0).toLocaleString(); +for(var r=1;r<4;r++){ +q+=", "+%Bool32x4ExtractLane(p,r).toLocaleString(); +} +return q+")"; +} +function Bool32x4ValueOf(){ +var p=%ValueOf(this); +if(typeof(p)!=='bool32x4'){ +throw %make_type_error(44, +"Bool32x4.prototype.valueOf",this); +} +return p; +} +function Bool32x4ExtractLaneJS(s,t){ +return %Bool32x4ExtractLane(s,t); +} + +function Bool16x8CheckJS(o){ +return %Bool16x8Check(o); +} +function Bool16x8ToString(){ +var p=%ValueOf(this); +if(typeof(p)!=='bool16x8'){ +throw %make_type_error(44, +"Bool16x8.prototype.toString",this); +} +var q="SIMD.Bool16x8("; +q+=%Bool16x8ExtractLane(p,0); +for(var r=1;r<8;r++){ +q+=", "+%Bool16x8ExtractLane(p,r); +} +return q+")"; +} +function Bool16x8ToLocaleString(){ +var p=%ValueOf(this); +if(typeof(p)!=='bool16x8'){ +throw %make_type_error(44, +"Bool16x8.prototype.toLocaleString",this); +} +var q="SIMD.Bool16x8("; +q+=%Bool16x8ExtractLane(p,0).toLocaleString(); +for(var r=1;r<8;r++){ +q+=", "+%Bool16x8ExtractLane(p,r).toLocaleString(); +} +return q+")"; +} +function Bool16x8ValueOf(){ +var p=%ValueOf(this); +if(typeof(p)!=='bool16x8'){ +throw %make_type_error(44, +"Bool16x8.prototype.valueOf",this); +} +return p; +} +function Bool16x8ExtractLaneJS(s,t){ +return %Bool16x8ExtractLane(s,t); +} + +function Bool8x16CheckJS(o){ +return %Bool8x16Check(o); +} +function Bool8x16ToString(){ +var p=%ValueOf(this); +if(typeof(p)!=='bool8x16'){ +throw %make_type_error(44, +"Bool8x16.prototype.toString",this); +} +var q="SIMD.Bool8x16("; +q+=%Bool8x16ExtractLane(p,0); +for(var r=1;r<16;r++){ +q+=", "+%Bool8x16ExtractLane(p,r); +} +return q+")"; +} +function Bool8x16ToLocaleString(){ +var p=%ValueOf(this); +if(typeof(p)!=='bool8x16'){ +throw %make_type_error(44, +"Bool8x16.prototype.toLocaleString",this); +} +var q="SIMD.Bool8x16("; +q+=%Bool8x16ExtractLane(p,0).toLocaleString(); +for(var r=1;r<16;r++){ +q+=", "+%Bool8x16ExtractLane(p,r).toLocaleString(); +} +return q+")"; +} +function Bool8x16ValueOf(){ +var p=%ValueOf(this); +if(typeof(p)!=='bool8x16'){ +throw %make_type_error(44, +"Bool8x16.prototype.valueOf",this); +} +return p; +} +function Bool8x16ExtractLaneJS(s,t){ +return %Bool8x16ExtractLane(s,t); +} + + + +function Int32x4ShiftLeftByScalarJS(s,u){ +return %Int32x4ShiftLeftByScalar(s,u); +} +function Int32x4ShiftRightByScalarJS(s,u){ +return %Int32x4ShiftRightByScalar(s,u); +} + +function Int16x8ShiftLeftByScalarJS(s,u){ +return %Int16x8ShiftLeftByScalar(s,u); +} +function Int16x8ShiftRightByScalarJS(s,u){ +return %Int16x8ShiftRightByScalar(s,u); +} + +function Int8x16ShiftLeftByScalarJS(s,u){ +return %Int8x16ShiftLeftByScalar(s,u); +} +function Int8x16ShiftRightByScalarJS(s,u){ +return %Int8x16ShiftRightByScalar(s,u); +} + + +function Uint32x4ShiftLeftByScalarJS(s,u){ +return %Uint32x4ShiftLeftByScalar(s,u); +} +function Uint32x4ShiftRightByScalarJS(s,u){ +return %Uint32x4ShiftRightByScalar(s,u); +} + +function Uint16x8ShiftLeftByScalarJS(s,u){ +return %Uint16x8ShiftLeftByScalar(s,u); +} +function Uint16x8ShiftRightByScalarJS(s,u){ +return %Uint16x8ShiftRightByScalar(s,u); +} + +function Uint8x16ShiftLeftByScalarJS(s,u){ +return %Uint8x16ShiftLeftByScalar(s,u); +} +function Uint8x16ShiftRightByScalarJS(s,u){ +return %Uint8x16ShiftRightByScalar(s,u); +} + + +function Int16x8AddSaturateJS(o,v){ +return %Int16x8AddSaturate(o,v); +} +function Int16x8SubSaturateJS(o,v){ +return %Int16x8SubSaturate(o,v); +} + +function Int8x16AddSaturateJS(o,v){ +return %Int8x16AddSaturate(o,v); +} +function Int8x16SubSaturateJS(o,v){ +return %Int8x16SubSaturate(o,v); +} + +function Uint8x16AddSaturateJS(o,v){ +return %Uint8x16AddSaturate(o,v); +} +function Uint8x16SubSaturateJS(o,v){ +return %Uint8x16SubSaturate(o,v); +} + +function Uint16x8AddSaturateJS(o,v){ +return %Uint16x8AddSaturate(o,v); +} +function Uint16x8SubSaturateJS(o,v){ +return %Uint16x8SubSaturate(o,v); +} + + +function Float32x4NegJS(o){ +return %Float32x4Neg(o); +} + + +function Int32x4NegJS(o){ +return %Int32x4Neg(o); +} + +function Int16x8NegJS(o){ +return %Int16x8Neg(o); +} + +function Int8x16NegJS(o){ +return %Int8x16Neg(o); +} + + +function Bool32x4ReplaceLaneJS(s,t,p){ +return %Bool32x4ReplaceLane(s,t,p); +} +function Bool32x4AnyTrueJS(w){ +return %Bool32x4AnyTrue(w); +} +function Bool32x4AllTrueJS(w){ +return %Bool32x4AllTrue(w); +} + +function Bool16x8ReplaceLaneJS(s,t,p){ +return %Bool16x8ReplaceLane(s,t,p); +} +function Bool16x8AnyTrueJS(w){ +return %Bool16x8AnyTrue(w); +} +function Bool16x8AllTrueJS(w){ +return %Bool16x8AllTrue(w); +} + +function Bool8x16ReplaceLaneJS(s,t,p){ +return %Bool8x16ReplaceLane(s,t,p); +} +function Bool8x16AnyTrueJS(w){ +return %Bool8x16AnyTrue(w); +} +function Bool8x16AllTrueJS(w){ +return %Bool8x16AllTrue(w); +} + + +function Float32x4ReplaceLaneJS(s,t,p){ +return %Float32x4ReplaceLane(s,t,(%_ToNumber(p))); +} +function Float32x4SelectJS(x,o,v){ +return %Float32x4Select(x,o,v); +} +function Float32x4AddJS(o,v){ +return %Float32x4Add(o,v); +} +function Float32x4SubJS(o,v){ +return %Float32x4Sub(o,v); +} +function Float32x4MulJS(o,v){ +return %Float32x4Mul(o,v); +} +function Float32x4MinJS(o,v){ +return %Float32x4Min(o,v); +} +function Float32x4MaxJS(o,v){ +return %Float32x4Max(o,v); +} +function Float32x4EqualJS(o,v){ +return %Float32x4Equal(o,v); +} +function Float32x4NotEqualJS(o,v){ +return %Float32x4NotEqual(o,v); +} +function Float32x4LessThanJS(o,v){ +return %Float32x4LessThan(o,v); +} +function Float32x4LessThanOrEqualJS(o,v){ +return %Float32x4LessThanOrEqual(o,v); +} +function Float32x4GreaterThanJS(o,v){ +return %Float32x4GreaterThan(o,v); +} +function Float32x4GreaterThanOrEqualJS(o,v){ +return %Float32x4GreaterThanOrEqual(o,v); +} +function Float32x4LoadJS(y,z){ +return %Float32x4Load(y,z); +} +function Float32x4StoreJS(y,z,o){ +return %Float32x4Store(y,z,o); +} + + +function Int32x4ReplaceLaneJS(s,t,p){ +return %Int32x4ReplaceLane(s,t,(%_ToNumber(p))); +} +function Int32x4SelectJS(x,o,v){ +return %Int32x4Select(x,o,v); +} +function Int32x4AddJS(o,v){ +return %Int32x4Add(o,v); +} +function Int32x4SubJS(o,v){ +return %Int32x4Sub(o,v); +} +function Int32x4MulJS(o,v){ +return %Int32x4Mul(o,v); +} +function Int32x4MinJS(o,v){ +return %Int32x4Min(o,v); +} +function Int32x4MaxJS(o,v){ +return %Int32x4Max(o,v); +} +function Int32x4EqualJS(o,v){ +return %Int32x4Equal(o,v); +} +function Int32x4NotEqualJS(o,v){ +return %Int32x4NotEqual(o,v); +} +function Int32x4LessThanJS(o,v){ +return %Int32x4LessThan(o,v); +} +function Int32x4LessThanOrEqualJS(o,v){ +return %Int32x4LessThanOrEqual(o,v); +} +function Int32x4GreaterThanJS(o,v){ +return %Int32x4GreaterThan(o,v); +} +function Int32x4GreaterThanOrEqualJS(o,v){ +return %Int32x4GreaterThanOrEqual(o,v); +} +function Int32x4LoadJS(y,z){ +return %Int32x4Load(y,z); +} +function Int32x4StoreJS(y,z,o){ +return %Int32x4Store(y,z,o); +} + +function Int16x8ReplaceLaneJS(s,t,p){ +return %Int16x8ReplaceLane(s,t,(%_ToNumber(p))); +} +function Int16x8SelectJS(x,o,v){ +return %Int16x8Select(x,o,v); +} +function Int16x8AddJS(o,v){ +return %Int16x8Add(o,v); +} +function Int16x8SubJS(o,v){ +return %Int16x8Sub(o,v); +} +function Int16x8MulJS(o,v){ +return %Int16x8Mul(o,v); +} +function Int16x8MinJS(o,v){ +return %Int16x8Min(o,v); +} +function Int16x8MaxJS(o,v){ +return %Int16x8Max(o,v); +} +function Int16x8EqualJS(o,v){ +return %Int16x8Equal(o,v); +} +function Int16x8NotEqualJS(o,v){ +return %Int16x8NotEqual(o,v); +} +function Int16x8LessThanJS(o,v){ +return %Int16x8LessThan(o,v); +} +function Int16x8LessThanOrEqualJS(o,v){ +return %Int16x8LessThanOrEqual(o,v); +} +function Int16x8GreaterThanJS(o,v){ +return %Int16x8GreaterThan(o,v); +} +function Int16x8GreaterThanOrEqualJS(o,v){ +return %Int16x8GreaterThanOrEqual(o,v); +} +function Int16x8LoadJS(y,z){ +return %Int16x8Load(y,z); +} +function Int16x8StoreJS(y,z,o){ +return %Int16x8Store(y,z,o); +} + +function Int8x16ReplaceLaneJS(s,t,p){ +return %Int8x16ReplaceLane(s,t,(%_ToNumber(p))); +} +function Int8x16SelectJS(x,o,v){ +return %Int8x16Select(x,o,v); +} +function Int8x16AddJS(o,v){ +return %Int8x16Add(o,v); +} +function Int8x16SubJS(o,v){ +return %Int8x16Sub(o,v); +} +function Int8x16MulJS(o,v){ +return %Int8x16Mul(o,v); +} +function Int8x16MinJS(o,v){ +return %Int8x16Min(o,v); +} +function Int8x16MaxJS(o,v){ +return %Int8x16Max(o,v); +} +function Int8x16EqualJS(o,v){ +return %Int8x16Equal(o,v); +} +function Int8x16NotEqualJS(o,v){ +return %Int8x16NotEqual(o,v); +} +function Int8x16LessThanJS(o,v){ +return %Int8x16LessThan(o,v); +} +function Int8x16LessThanOrEqualJS(o,v){ +return %Int8x16LessThanOrEqual(o,v); +} +function Int8x16GreaterThanJS(o,v){ +return %Int8x16GreaterThan(o,v); +} +function Int8x16GreaterThanOrEqualJS(o,v){ +return %Int8x16GreaterThanOrEqual(o,v); +} +function Int8x16LoadJS(y,z){ +return %Int8x16Load(y,z); +} +function Int8x16StoreJS(y,z,o){ +return %Int8x16Store(y,z,o); +} + + +function Uint32x4ReplaceLaneJS(s,t,p){ +return %Uint32x4ReplaceLane(s,t,(%_ToNumber(p))); +} +function Uint32x4SelectJS(x,o,v){ +return %Uint32x4Select(x,o,v); +} +function Uint32x4AddJS(o,v){ +return %Uint32x4Add(o,v); +} +function Uint32x4SubJS(o,v){ +return %Uint32x4Sub(o,v); +} +function Uint32x4MulJS(o,v){ +return %Uint32x4Mul(o,v); +} +function Uint32x4MinJS(o,v){ +return %Uint32x4Min(o,v); +} +function Uint32x4MaxJS(o,v){ +return %Uint32x4Max(o,v); +} +function Uint32x4EqualJS(o,v){ +return %Uint32x4Equal(o,v); +} +function Uint32x4NotEqualJS(o,v){ +return %Uint32x4NotEqual(o,v); +} +function Uint32x4LessThanJS(o,v){ +return %Uint32x4LessThan(o,v); +} +function Uint32x4LessThanOrEqualJS(o,v){ +return %Uint32x4LessThanOrEqual(o,v); +} +function Uint32x4GreaterThanJS(o,v){ +return %Uint32x4GreaterThan(o,v); +} +function Uint32x4GreaterThanOrEqualJS(o,v){ +return %Uint32x4GreaterThanOrEqual(o,v); +} +function Uint32x4LoadJS(y,z){ +return %Uint32x4Load(y,z); +} +function Uint32x4StoreJS(y,z,o){ +return %Uint32x4Store(y,z,o); +} + +function Uint16x8ReplaceLaneJS(s,t,p){ +return %Uint16x8ReplaceLane(s,t,(%_ToNumber(p))); +} +function Uint16x8SelectJS(x,o,v){ +return %Uint16x8Select(x,o,v); +} +function Uint16x8AddJS(o,v){ +return %Uint16x8Add(o,v); +} +function Uint16x8SubJS(o,v){ +return %Uint16x8Sub(o,v); +} +function Uint16x8MulJS(o,v){ +return %Uint16x8Mul(o,v); +} +function Uint16x8MinJS(o,v){ +return %Uint16x8Min(o,v); +} +function Uint16x8MaxJS(o,v){ +return %Uint16x8Max(o,v); +} +function Uint16x8EqualJS(o,v){ +return %Uint16x8Equal(o,v); +} +function Uint16x8NotEqualJS(o,v){ +return %Uint16x8NotEqual(o,v); +} +function Uint16x8LessThanJS(o,v){ +return %Uint16x8LessThan(o,v); +} +function Uint16x8LessThanOrEqualJS(o,v){ +return %Uint16x8LessThanOrEqual(o,v); +} +function Uint16x8GreaterThanJS(o,v){ +return %Uint16x8GreaterThan(o,v); +} +function Uint16x8GreaterThanOrEqualJS(o,v){ +return %Uint16x8GreaterThanOrEqual(o,v); +} +function Uint16x8LoadJS(y,z){ +return %Uint16x8Load(y,z); +} +function Uint16x8StoreJS(y,z,o){ +return %Uint16x8Store(y,z,o); +} + +function Uint8x16ReplaceLaneJS(s,t,p){ +return %Uint8x16ReplaceLane(s,t,(%_ToNumber(p))); +} +function Uint8x16SelectJS(x,o,v){ +return %Uint8x16Select(x,o,v); +} +function Uint8x16AddJS(o,v){ +return %Uint8x16Add(o,v); +} +function Uint8x16SubJS(o,v){ +return %Uint8x16Sub(o,v); +} +function Uint8x16MulJS(o,v){ +return %Uint8x16Mul(o,v); +} +function Uint8x16MinJS(o,v){ +return %Uint8x16Min(o,v); +} +function Uint8x16MaxJS(o,v){ +return %Uint8x16Max(o,v); +} +function Uint8x16EqualJS(o,v){ +return %Uint8x16Equal(o,v); +} +function Uint8x16NotEqualJS(o,v){ +return %Uint8x16NotEqual(o,v); +} +function Uint8x16LessThanJS(o,v){ +return %Uint8x16LessThan(o,v); +} +function Uint8x16LessThanOrEqualJS(o,v){ +return %Uint8x16LessThanOrEqual(o,v); +} +function Uint8x16GreaterThanJS(o,v){ +return %Uint8x16GreaterThan(o,v); +} +function Uint8x16GreaterThanOrEqualJS(o,v){ +return %Uint8x16GreaterThanOrEqual(o,v); +} +function Uint8x16LoadJS(y,z){ +return %Uint8x16Load(y,z); +} +function Uint8x16StoreJS(y,z,o){ +return %Uint8x16Store(y,z,o); +} + + + +function Int32x4AndJS(o,v){ +return %Int32x4And(o,v); +} +function Int32x4OrJS(o,v){ +return %Int32x4Or(o,v); +} +function Int32x4XorJS(o,v){ +return %Int32x4Xor(o,v); +} +function Int32x4NotJS(o){ +return %Int32x4Not(o); +} + +function Int16x8AndJS(o,v){ +return %Int16x8And(o,v); +} +function Int16x8OrJS(o,v){ +return %Int16x8Or(o,v); +} +function Int16x8XorJS(o,v){ +return %Int16x8Xor(o,v); +} +function Int16x8NotJS(o){ +return %Int16x8Not(o); +} + +function Int8x16AndJS(o,v){ +return %Int8x16And(o,v); +} +function Int8x16OrJS(o,v){ +return %Int8x16Or(o,v); +} +function Int8x16XorJS(o,v){ +return %Int8x16Xor(o,v); +} +function Int8x16NotJS(o){ +return %Int8x16Not(o); +} + + +function Uint32x4AndJS(o,v){ +return %Uint32x4And(o,v); +} +function Uint32x4OrJS(o,v){ +return %Uint32x4Or(o,v); +} +function Uint32x4XorJS(o,v){ +return %Uint32x4Xor(o,v); +} +function Uint32x4NotJS(o){ +return %Uint32x4Not(o); +} + +function Uint16x8AndJS(o,v){ +return %Uint16x8And(o,v); +} +function Uint16x8OrJS(o,v){ +return %Uint16x8Or(o,v); +} +function Uint16x8XorJS(o,v){ +return %Uint16x8Xor(o,v); +} +function Uint16x8NotJS(o){ +return %Uint16x8Not(o); +} + +function Uint8x16AndJS(o,v){ +return %Uint8x16And(o,v); +} +function Uint8x16OrJS(o,v){ +return %Uint8x16Or(o,v); +} +function Uint8x16XorJS(o,v){ +return %Uint8x16Xor(o,v); +} +function Uint8x16NotJS(o){ +return %Uint8x16Not(o); +} + + +function Bool32x4AndJS(o,v){ +return %Bool32x4And(o,v); +} +function Bool32x4OrJS(o,v){ +return %Bool32x4Or(o,v); +} +function Bool32x4XorJS(o,v){ +return %Bool32x4Xor(o,v); +} +function Bool32x4NotJS(o){ +return %Bool32x4Not(o); +} + +function Bool16x8AndJS(o,v){ +return %Bool16x8And(o,v); +} +function Bool16x8OrJS(o,v){ +return %Bool16x8Or(o,v); +} +function Bool16x8XorJS(o,v){ +return %Bool16x8Xor(o,v); +} +function Bool16x8NotJS(o){ +return %Bool16x8Not(o); +} + +function Bool8x16AndJS(o,v){ +return %Bool8x16And(o,v); +} +function Bool8x16OrJS(o,v){ +return %Bool8x16Or(o,v); +} +function Bool8x16XorJS(o,v){ +return %Bool8x16Xor(o,v); +} +function Bool8x16NotJS(o){ +return %Bool8x16Not(o); +} + + + +function Float32x4FromInt32x4JS(o){ +return %Float32x4FromInt32x4(o); +} + +function Float32x4FromUint32x4JS(o){ +return %Float32x4FromUint32x4(o); +} + +function Int32x4FromFloat32x4JS(o){ +return %Int32x4FromFloat32x4(o); +} + +function Int32x4FromUint32x4JS(o){ +return %Int32x4FromUint32x4(o); +} + +function Uint32x4FromFloat32x4JS(o){ +return %Uint32x4FromFloat32x4(o); +} + +function Uint32x4FromInt32x4JS(o){ +return %Uint32x4FromInt32x4(o); +} + +function Int16x8FromUint16x8JS(o){ +return %Int16x8FromUint16x8(o); +} + +function Uint16x8FromInt16x8JS(o){ +return %Uint16x8FromInt16x8(o); +} + +function Int8x16FromUint8x16JS(o){ +return %Int8x16FromUint8x16(o); +} + +function Uint8x16FromInt8x16JS(o){ +return %Uint8x16FromInt8x16(o); +} + + +function Float32x4FromInt32x4BitsJS(o){ +return %Float32x4FromInt32x4Bits(o); +} + +function Float32x4FromUint32x4BitsJS(o){ +return %Float32x4FromUint32x4Bits(o); +} + +function Float32x4FromInt16x8BitsJS(o){ +return %Float32x4FromInt16x8Bits(o); +} + +function Float32x4FromUint16x8BitsJS(o){ +return %Float32x4FromUint16x8Bits(o); +} + +function Float32x4FromInt8x16BitsJS(o){ +return %Float32x4FromInt8x16Bits(o); +} + +function Float32x4FromUint8x16BitsJS(o){ +return %Float32x4FromUint8x16Bits(o); +} + +function Int32x4FromFloat32x4BitsJS(o){ +return %Int32x4FromFloat32x4Bits(o); +} + +function Int32x4FromUint32x4BitsJS(o){ +return %Int32x4FromUint32x4Bits(o); +} + +function Int32x4FromInt16x8BitsJS(o){ +return %Int32x4FromInt16x8Bits(o); +} + +function Int32x4FromUint16x8BitsJS(o){ +return %Int32x4FromUint16x8Bits(o); +} + +function Int32x4FromInt8x16BitsJS(o){ +return %Int32x4FromInt8x16Bits(o); +} + +function Int32x4FromUint8x16BitsJS(o){ +return %Int32x4FromUint8x16Bits(o); +} + +function Uint32x4FromFloat32x4BitsJS(o){ +return %Uint32x4FromFloat32x4Bits(o); +} + +function Uint32x4FromInt32x4BitsJS(o){ +return %Uint32x4FromInt32x4Bits(o); +} + +function Uint32x4FromInt16x8BitsJS(o){ +return %Uint32x4FromInt16x8Bits(o); +} + +function Uint32x4FromUint16x8BitsJS(o){ +return %Uint32x4FromUint16x8Bits(o); +} + +function Uint32x4FromInt8x16BitsJS(o){ +return %Uint32x4FromInt8x16Bits(o); +} + +function Uint32x4FromUint8x16BitsJS(o){ +return %Uint32x4FromUint8x16Bits(o); +} + +function Int16x8FromFloat32x4BitsJS(o){ +return %Int16x8FromFloat32x4Bits(o); +} + +function Int16x8FromInt32x4BitsJS(o){ +return %Int16x8FromInt32x4Bits(o); +} + +function Int16x8FromUint32x4BitsJS(o){ +return %Int16x8FromUint32x4Bits(o); +} + +function Int16x8FromUint16x8BitsJS(o){ +return %Int16x8FromUint16x8Bits(o); +} + +function Int16x8FromInt8x16BitsJS(o){ +return %Int16x8FromInt8x16Bits(o); +} + +function Int16x8FromUint8x16BitsJS(o){ +return %Int16x8FromUint8x16Bits(o); +} + +function Uint16x8FromFloat32x4BitsJS(o){ +return %Uint16x8FromFloat32x4Bits(o); +} + +function Uint16x8FromInt32x4BitsJS(o){ +return %Uint16x8FromInt32x4Bits(o); +} + +function Uint16x8FromUint32x4BitsJS(o){ +return %Uint16x8FromUint32x4Bits(o); +} + +function Uint16x8FromInt16x8BitsJS(o){ +return %Uint16x8FromInt16x8Bits(o); +} + +function Uint16x8FromInt8x16BitsJS(o){ +return %Uint16x8FromInt8x16Bits(o); +} + +function Uint16x8FromUint8x16BitsJS(o){ +return %Uint16x8FromUint8x16Bits(o); +} + +function Int8x16FromFloat32x4BitsJS(o){ +return %Int8x16FromFloat32x4Bits(o); +} + +function Int8x16FromInt32x4BitsJS(o){ +return %Int8x16FromInt32x4Bits(o); +} + +function Int8x16FromUint32x4BitsJS(o){ +return %Int8x16FromUint32x4Bits(o); +} + +function Int8x16FromInt16x8BitsJS(o){ +return %Int8x16FromInt16x8Bits(o); +} + +function Int8x16FromUint16x8BitsJS(o){ +return %Int8x16FromUint16x8Bits(o); +} + +function Int8x16FromUint8x16BitsJS(o){ +return %Int8x16FromUint8x16Bits(o); +} + +function Uint8x16FromFloat32x4BitsJS(o){ +return %Uint8x16FromFloat32x4Bits(o); +} + +function Uint8x16FromInt32x4BitsJS(o){ +return %Uint8x16FromInt32x4Bits(o); +} + +function Uint8x16FromUint32x4BitsJS(o){ +return %Uint8x16FromUint32x4Bits(o); +} + +function Uint8x16FromInt16x8BitsJS(o){ +return %Uint8x16FromInt16x8Bits(o); +} + +function Uint8x16FromUint16x8BitsJS(o){ +return %Uint8x16FromUint16x8Bits(o); +} + +function Uint8x16FromInt8x16BitsJS(o){ +return %Uint8x16FromInt8x16Bits(o); +} + + +function Float32x4Load1JS(y,z){ +return %Float32x4Load1(y,z); +} +function Float32x4Store1JS(y,z,o){ +return %Float32x4Store1(y,z,o); +} + +function Float32x4Load2JS(y,z){ +return %Float32x4Load2(y,z); +} +function Float32x4Store2JS(y,z,o){ +return %Float32x4Store2(y,z,o); +} + +function Float32x4Load3JS(y,z){ +return %Float32x4Load3(y,z); +} +function Float32x4Store3JS(y,z,o){ +return %Float32x4Store3(y,z,o); +} + +function Int32x4Load1JS(y,z){ +return %Int32x4Load1(y,z); +} +function Int32x4Store1JS(y,z,o){ +return %Int32x4Store1(y,z,o); +} + +function Int32x4Load2JS(y,z){ +return %Int32x4Load2(y,z); +} +function Int32x4Store2JS(y,z,o){ +return %Int32x4Store2(y,z,o); +} + +function Int32x4Load3JS(y,z){ +return %Int32x4Load3(y,z); +} +function Int32x4Store3JS(y,z,o){ +return %Int32x4Store3(y,z,o); +} + +function Uint32x4Load1JS(y,z){ +return %Uint32x4Load1(y,z); +} +function Uint32x4Store1JS(y,z,o){ +return %Uint32x4Store1(y,z,o); +} + +function Uint32x4Load2JS(y,z){ +return %Uint32x4Load2(y,z); +} +function Uint32x4Store2JS(y,z,o){ +return %Uint32x4Store2(y,z,o); +} + +function Uint32x4Load3JS(y,z){ +return %Uint32x4Load3(y,z); +} +function Uint32x4Store3JS(y,z,o){ +return %Uint32x4Store3(y,z,o); +} + + +function Float32x4Splat(w){ +return %CreateFloat32x4(w,w,w,w); +} +function Float32x4SwizzleJS(o,A,B,C,D){ +return %Float32x4Swizzle(o,A,B,C,D); +} +function Float32x4ShuffleJS(o,v,A,B,C,D){ +return %Float32x4Shuffle(o,v,A,B,C,D); +} + +function Int32x4Splat(w){ +return %CreateInt32x4(w,w,w,w); +} +function Int32x4SwizzleJS(o,A,B,C,D){ +return %Int32x4Swizzle(o,A,B,C,D); +} +function Int32x4ShuffleJS(o,v,A,B,C,D){ +return %Int32x4Shuffle(o,v,A,B,C,D); +} + +function Uint32x4Splat(w){ +return %CreateUint32x4(w,w,w,w); +} +function Uint32x4SwizzleJS(o,A,B,C,D){ +return %Uint32x4Swizzle(o,A,B,C,D); +} +function Uint32x4ShuffleJS(o,v,A,B,C,D){ +return %Uint32x4Shuffle(o,v,A,B,C,D); +} + +function Bool32x4Splat(w){ +return %CreateBool32x4(w,w,w,w); +} +function Bool32x4SwizzleJS(o,A,B,C,D){ +return %Bool32x4Swizzle(o,A,B,C,D); +} +function Bool32x4ShuffleJS(o,v,A,B,C,D){ +return %Bool32x4Shuffle(o,v,A,B,C,D); +} + + +function Int16x8Splat(w){ +return %CreateInt16x8(w,w,w,w,w,w,w,w); +} +function Int16x8SwizzleJS(o,A,B,C,D,E,F,G,H){ +return %Int16x8Swizzle(o,A,B,C,D,E,F,G,H); +} +function Int16x8ShuffleJS(o,v,A,B,C,D,E,F,G,H){ +return %Int16x8Shuffle(o,v,A,B,C,D,E,F,G,H); +} + +function Uint16x8Splat(w){ +return %CreateUint16x8(w,w,w,w,w,w,w,w); +} +function Uint16x8SwizzleJS(o,A,B,C,D,E,F,G,H){ +return %Uint16x8Swizzle(o,A,B,C,D,E,F,G,H); +} +function Uint16x8ShuffleJS(o,v,A,B,C,D,E,F,G,H){ +return %Uint16x8Shuffle(o,v,A,B,C,D,E,F,G,H); +} + +function Bool16x8Splat(w){ +return %CreateBool16x8(w,w,w,w,w,w,w,w); +} +function Bool16x8SwizzleJS(o,A,B,C,D,E,F,G,H){ +return %Bool16x8Swizzle(o,A,B,C,D,E,F,G,H); +} +function Bool16x8ShuffleJS(o,v,A,B,C,D,E,F,G,H){ +return %Bool16x8Shuffle(o,v,A,B,C,D,E,F,G,H); +} + + +function Int8x16Splat(w){ +return %CreateInt8x16(w,w,w,w,w,w,w,w,w,w,w,w,w,w,w,w); +} +function Int8x16SwizzleJS(o,A,B,C,D,E,F,G,H,c8,c9,c10,c11, +c12,c13,c14,c15){ +return %Int8x16Swizzle(o,A,B,C,D,E,F,G,H,c8,c9,c10,c11, +c12,c13,c14,c15); +} +function Int8x16ShuffleJS(o,v,A,B,C,D,E,F,G,H,c8,c9,c10, +c11,c12,c13,c14,c15){ +return %Int8x16Shuffle(o,v,A,B,C,D,E,F,G,H,c8,c9,c10, +c11,c12,c13,c14,c15); +} + +function Uint8x16Splat(w){ +return %CreateUint8x16(w,w,w,w,w,w,w,w,w,w,w,w,w,w,w,w); +} +function Uint8x16SwizzleJS(o,A,B,C,D,E,F,G,H,c8,c9,c10,c11, +c12,c13,c14,c15){ +return %Uint8x16Swizzle(o,A,B,C,D,E,F,G,H,c8,c9,c10,c11, +c12,c13,c14,c15); +} +function Uint8x16ShuffleJS(o,v,A,B,C,D,E,F,G,H,c8,c9,c10, +c11,c12,c13,c14,c15){ +return %Uint8x16Shuffle(o,v,A,B,C,D,E,F,G,H,c8,c9,c10, +c11,c12,c13,c14,c15); +} + +function Bool8x16Splat(w){ +return %CreateBool8x16(w,w,w,w,w,w,w,w,w,w,w,w,w,w,w,w); +} +function Bool8x16SwizzleJS(o,A,B,C,D,E,F,G,H,c8,c9,c10,c11, +c12,c13,c14,c15){ +return %Bool8x16Swizzle(o,A,B,C,D,E,F,G,H,c8,c9,c10,c11, +c12,c13,c14,c15); +} +function Bool8x16ShuffleJS(o,v,A,B,C,D,E,F,G,H,c8,c9,c10, +c11,c12,c13,c14,c15){ +return %Bool8x16Shuffle(o,v,A,B,C,D,E,F,G,H,c8,c9,c10, +c11,c12,c13,c14,c15); +} + + +function Float32x4Constructor(A,B,C,D){ +if(!(new.target===(void 0))){ +throw %make_type_error(66,"Float32x4"); +} +return %CreateFloat32x4((%_ToNumber(A)),(%_ToNumber(B)), +(%_ToNumber(C)),(%_ToNumber(D))); +} +function Int32x4Constructor(A,B,C,D){ +if(!(new.target===(void 0))){ +throw %make_type_error(66,"Int32x4"); +} +return %CreateInt32x4((%_ToNumber(A)),(%_ToNumber(B)), +(%_ToNumber(C)),(%_ToNumber(D))); +} +function Uint32x4Constructor(A,B,C,D){ +if(!(new.target===(void 0))){ +throw %make_type_error(66,"Uint32x4"); +} +return %CreateUint32x4((%_ToNumber(A)),(%_ToNumber(B)), +(%_ToNumber(C)),(%_ToNumber(D))); +} +function Bool32x4Constructor(A,B,C,D){ +if(!(new.target===(void 0))){ +throw %make_type_error(66,"Bool32x4"); +} +return %CreateBool32x4(A,B,C,D); +} +function Int16x8Constructor(A,B,C,D,E,F,G,H){ +if(!(new.target===(void 0))){ +throw %make_type_error(66,"Int16x8"); +} +return %CreateInt16x8((%_ToNumber(A)),(%_ToNumber(B)), +(%_ToNumber(C)),(%_ToNumber(D)), +(%_ToNumber(E)),(%_ToNumber(F)), +(%_ToNumber(G)),(%_ToNumber(H))); +} +function Uint16x8Constructor(A,B,C,D,E,F,G,H){ +if(!(new.target===(void 0))){ +throw %make_type_error(66,"Uint16x8"); +} +return %CreateUint16x8((%_ToNumber(A)),(%_ToNumber(B)), +(%_ToNumber(C)),(%_ToNumber(D)), +(%_ToNumber(E)),(%_ToNumber(F)), +(%_ToNumber(G)),(%_ToNumber(H))); +} +function Bool16x8Constructor(A,B,C,D,E,F,G,H){ +if(!(new.target===(void 0))){ +throw %make_type_error(66,"Bool16x8"); +} +return %CreateBool16x8(A,B,C,D,E,F,G,H); +} +function Int8x16Constructor(A,B,C,D,E,F,G,H,c8,c9,c10,c11, +c12,c13,c14,c15){ +if(!(new.target===(void 0))){ +throw %make_type_error(66,"Int8x16"); +} +return %CreateInt8x16((%_ToNumber(A)),(%_ToNumber(B)), +(%_ToNumber(C)),(%_ToNumber(D)), +(%_ToNumber(E)),(%_ToNumber(F)), +(%_ToNumber(G)),(%_ToNumber(H)), +(%_ToNumber(c8)),(%_ToNumber(c9)), +(%_ToNumber(c10)),(%_ToNumber(c11)), +(%_ToNumber(c12)),(%_ToNumber(c13)), +(%_ToNumber(c14)),(%_ToNumber(c15))); +} +function Uint8x16Constructor(A,B,C,D,E,F,G,H,c8,c9,c10,c11, +c12,c13,c14,c15){ +if(!(new.target===(void 0))){ +throw %make_type_error(66,"Uint8x16"); +} +return %CreateUint8x16((%_ToNumber(A)),(%_ToNumber(B)), +(%_ToNumber(C)),(%_ToNumber(D)), +(%_ToNumber(E)),(%_ToNumber(F)), +(%_ToNumber(G)),(%_ToNumber(H)), +(%_ToNumber(c8)),(%_ToNumber(c9)), +(%_ToNumber(c10)),(%_ToNumber(c11)), +(%_ToNumber(c12)),(%_ToNumber(c13)), +(%_ToNumber(c14)),(%_ToNumber(c15))); +} +function Bool8x16Constructor(A,B,C,D,E,F,G,H,c8,c9,c10,c11, +c12,c13,c14,c15){ +if(!(new.target===(void 0))){ +throw %make_type_error(66,"Bool8x16"); +} +return %CreateBool8x16(A,B,C,D,E,F,G,H,c8,c9,c10,c11,c12, +c13,c14,c15); +} +function Float32x4AbsJS(o){ +return %Float32x4Abs(o); +} +function Float32x4SqrtJS(o){ +return %Float32x4Sqrt(o); +} +function Float32x4RecipApproxJS(o){ +return %Float32x4RecipApprox(o); +} +function Float32x4RecipSqrtApproxJS(o){ +return %Float32x4RecipSqrtApprox(o); +} +function Float32x4DivJS(o,v){ +return %Float32x4Div(o,v); +} +function Float32x4MinNumJS(o,v){ +return %Float32x4MinNum(o,v); +} +function Float32x4MaxNumJS(o,v){ +return %Float32x4MaxNum(o,v); +} +%AddNamedProperty(c,d,'SIMD',1|2); +%SetCode(e,Float32x4Constructor); +%FunctionSetPrototype(e,{}); +%AddNamedProperty(e.prototype,'constructor',e, +2); +%AddNamedProperty(e.prototype,d,'Float32x4', +2|1); +b.InstallFunctions(e.prototype,2,[ +'toLocaleString',Float32x4ToLocaleString, +'toString',Float32x4ToString, +'valueOf',Float32x4ValueOf, +]); + + +%SetCode(f,Int32x4Constructor); +%FunctionSetPrototype(f,{}); +%AddNamedProperty(f.prototype,'constructor',f, +2); +%AddNamedProperty(f.prototype,d,'Int32x4', +2|1); +b.InstallFunctions(f.prototype,2,[ +'toLocaleString',Int32x4ToLocaleString, +'toString',Int32x4ToString, +'valueOf',Int32x4ValueOf, +]); + +%SetCode(g,Int16x8Constructor); +%FunctionSetPrototype(g,{}); +%AddNamedProperty(g.prototype,'constructor',g, +2); +%AddNamedProperty(g.prototype,d,'Int16x8', +2|1); +b.InstallFunctions(g.prototype,2,[ +'toLocaleString',Int16x8ToLocaleString, +'toString',Int16x8ToString, +'valueOf',Int16x8ValueOf, +]); + +%SetCode(h,Int8x16Constructor); +%FunctionSetPrototype(h,{}); +%AddNamedProperty(h.prototype,'constructor',h, +2); +%AddNamedProperty(h.prototype,d,'Int8x16', +2|1); +b.InstallFunctions(h.prototype,2,[ +'toLocaleString',Int8x16ToLocaleString, +'toString',Int8x16ToString, +'valueOf',Int8x16ValueOf, +]); + + +%SetCode(i,Uint32x4Constructor); +%FunctionSetPrototype(i,{}); +%AddNamedProperty(i.prototype,'constructor',i, +2); +%AddNamedProperty(i.prototype,d,'Uint32x4', +2|1); +b.InstallFunctions(i.prototype,2,[ +'toLocaleString',Uint32x4ToLocaleString, +'toString',Uint32x4ToString, +'valueOf',Uint32x4ValueOf, +]); + +%SetCode(j,Uint16x8Constructor); +%FunctionSetPrototype(j,{}); +%AddNamedProperty(j.prototype,'constructor',j, +2); +%AddNamedProperty(j.prototype,d,'Uint16x8', +2|1); +b.InstallFunctions(j.prototype,2,[ +'toLocaleString',Uint16x8ToLocaleString, +'toString',Uint16x8ToString, +'valueOf',Uint16x8ValueOf, +]); + +%SetCode(k,Uint8x16Constructor); +%FunctionSetPrototype(k,{}); +%AddNamedProperty(k.prototype,'constructor',k, +2); +%AddNamedProperty(k.prototype,d,'Uint8x16', +2|1); +b.InstallFunctions(k.prototype,2,[ +'toLocaleString',Uint8x16ToLocaleString, +'toString',Uint8x16ToString, +'valueOf',Uint8x16ValueOf, +]); + + +%SetCode(l,Bool32x4Constructor); +%FunctionSetPrototype(l,{}); +%AddNamedProperty(l.prototype,'constructor',l, +2); +%AddNamedProperty(l.prototype,d,'Bool32x4', +2|1); +b.InstallFunctions(l.prototype,2,[ +'toLocaleString',Bool32x4ToLocaleString, +'toString',Bool32x4ToString, +'valueOf',Bool32x4ValueOf, +]); + +%SetCode(m,Bool16x8Constructor); +%FunctionSetPrototype(m,{}); +%AddNamedProperty(m.prototype,'constructor',m, +2); +%AddNamedProperty(m.prototype,d,'Bool16x8', +2|1); +b.InstallFunctions(m.prototype,2,[ +'toLocaleString',Bool16x8ToLocaleString, +'toString',Bool16x8ToString, +'valueOf',Bool16x8ValueOf, +]); + +%SetCode(n,Bool8x16Constructor); +%FunctionSetPrototype(n,{}); +%AddNamedProperty(n.prototype,'constructor',n, +2); +%AddNamedProperty(n.prototype,d,'Bool8x16', +2|1); +b.InstallFunctions(n.prototype,2,[ +'toLocaleString',Bool8x16ToLocaleString, +'toString',Bool8x16ToString, +'valueOf',Bool8x16ValueOf, +]); + + + +b.InstallFunctions(e,2,[ +'splat',Float32x4Splat, +'check',Float32x4CheckJS, +'extractLane',Float32x4ExtractLaneJS, +'replaceLane',Float32x4ReplaceLaneJS, +'neg',Float32x4NegJS, +'abs',Float32x4AbsJS, +'sqrt',Float32x4SqrtJS, +'reciprocalApproximation',Float32x4RecipApproxJS, +'reciprocalSqrtApproximation',Float32x4RecipSqrtApproxJS, +'add',Float32x4AddJS, +'sub',Float32x4SubJS, +'mul',Float32x4MulJS, +'div',Float32x4DivJS, +'min',Float32x4MinJS, +'max',Float32x4MaxJS, +'minNum',Float32x4MinNumJS, +'maxNum',Float32x4MaxNumJS, +'lessThan',Float32x4LessThanJS, +'lessThanOrEqual',Float32x4LessThanOrEqualJS, +'greaterThan',Float32x4GreaterThanJS, +'greaterThanOrEqual',Float32x4GreaterThanOrEqualJS, +'equal',Float32x4EqualJS, +'notEqual',Float32x4NotEqualJS, +'select',Float32x4SelectJS, +'swizzle',Float32x4SwizzleJS, +'shuffle',Float32x4ShuffleJS, +'fromInt32x4',Float32x4FromInt32x4JS, +'fromUint32x4',Float32x4FromUint32x4JS, +'fromInt32x4Bits',Float32x4FromInt32x4BitsJS, +'fromUint32x4Bits',Float32x4FromUint32x4BitsJS, +'fromInt16x8Bits',Float32x4FromInt16x8BitsJS, +'fromUint16x8Bits',Float32x4FromUint16x8BitsJS, +'fromInt8x16Bits',Float32x4FromInt8x16BitsJS, +'fromUint8x16Bits',Float32x4FromUint8x16BitsJS, +'load',Float32x4LoadJS, +'load1',Float32x4Load1JS, +'load2',Float32x4Load2JS, +'load3',Float32x4Load3JS, +'store',Float32x4StoreJS, +'store1',Float32x4Store1JS, +'store2',Float32x4Store2JS, +'store3',Float32x4Store3JS, +]); +b.InstallFunctions(f,2,[ +'splat',Int32x4Splat, +'check',Int32x4CheckJS, +'extractLane',Int32x4ExtractLaneJS, +'replaceLane',Int32x4ReplaceLaneJS, +'neg',Int32x4NegJS, +'add',Int32x4AddJS, +'sub',Int32x4SubJS, +'mul',Int32x4MulJS, +'min',Int32x4MinJS, +'max',Int32x4MaxJS, +'and',Int32x4AndJS, +'or',Int32x4OrJS, +'xor',Int32x4XorJS, +'not',Int32x4NotJS, +'shiftLeftByScalar',Int32x4ShiftLeftByScalarJS, +'shiftRightByScalar',Int32x4ShiftRightByScalarJS, +'lessThan',Int32x4LessThanJS, +'lessThanOrEqual',Int32x4LessThanOrEqualJS, +'greaterThan',Int32x4GreaterThanJS, +'greaterThanOrEqual',Int32x4GreaterThanOrEqualJS, +'equal',Int32x4EqualJS, +'notEqual',Int32x4NotEqualJS, +'select',Int32x4SelectJS, +'swizzle',Int32x4SwizzleJS, +'shuffle',Int32x4ShuffleJS, +'fromFloat32x4',Int32x4FromFloat32x4JS, +'fromUint32x4',Int32x4FromUint32x4JS, +'fromFloat32x4Bits',Int32x4FromFloat32x4BitsJS, +'fromUint32x4Bits',Int32x4FromUint32x4BitsJS, +'fromInt16x8Bits',Int32x4FromInt16x8BitsJS, +'fromUint16x8Bits',Int32x4FromUint16x8BitsJS, +'fromInt8x16Bits',Int32x4FromInt8x16BitsJS, +'fromUint8x16Bits',Int32x4FromUint8x16BitsJS, +'load',Int32x4LoadJS, +'load1',Int32x4Load1JS, +'load2',Int32x4Load2JS, +'load3',Int32x4Load3JS, +'store',Int32x4StoreJS, +'store1',Int32x4Store1JS, +'store2',Int32x4Store2JS, +'store3',Int32x4Store3JS, +]); +b.InstallFunctions(i,2,[ +'splat',Uint32x4Splat, +'check',Uint32x4CheckJS, +'extractLane',Uint32x4ExtractLaneJS, +'replaceLane',Uint32x4ReplaceLaneJS, +'add',Uint32x4AddJS, +'sub',Uint32x4SubJS, +'mul',Uint32x4MulJS, +'min',Uint32x4MinJS, +'max',Uint32x4MaxJS, +'and',Uint32x4AndJS, +'or',Uint32x4OrJS, +'xor',Uint32x4XorJS, +'not',Uint32x4NotJS, +'shiftLeftByScalar',Uint32x4ShiftLeftByScalarJS, +'shiftRightByScalar',Uint32x4ShiftRightByScalarJS, +'lessThan',Uint32x4LessThanJS, +'lessThanOrEqual',Uint32x4LessThanOrEqualJS, +'greaterThan',Uint32x4GreaterThanJS, +'greaterThanOrEqual',Uint32x4GreaterThanOrEqualJS, +'equal',Uint32x4EqualJS, +'notEqual',Uint32x4NotEqualJS, +'select',Uint32x4SelectJS, +'swizzle',Uint32x4SwizzleJS, +'shuffle',Uint32x4ShuffleJS, +'fromFloat32x4',Uint32x4FromFloat32x4JS, +'fromInt32x4',Uint32x4FromInt32x4JS, +'fromFloat32x4Bits',Uint32x4FromFloat32x4BitsJS, +'fromInt32x4Bits',Uint32x4FromInt32x4BitsJS, +'fromInt16x8Bits',Uint32x4FromInt16x8BitsJS, +'fromUint16x8Bits',Uint32x4FromUint16x8BitsJS, +'fromInt8x16Bits',Uint32x4FromInt8x16BitsJS, +'fromUint8x16Bits',Uint32x4FromUint8x16BitsJS, +'load',Uint32x4LoadJS, +'load1',Uint32x4Load1JS, +'load2',Uint32x4Load2JS, +'load3',Uint32x4Load3JS, +'store',Uint32x4StoreJS, +'store1',Uint32x4Store1JS, +'store2',Uint32x4Store2JS, +'store3',Uint32x4Store3JS, +]); +b.InstallFunctions(l,2,[ +'splat',Bool32x4Splat, +'check',Bool32x4CheckJS, +'extractLane',Bool32x4ExtractLaneJS, +'replaceLane',Bool32x4ReplaceLaneJS, +'and',Bool32x4AndJS, +'or',Bool32x4OrJS, +'xor',Bool32x4XorJS, +'not',Bool32x4NotJS, +'anyTrue',Bool32x4AnyTrueJS, +'allTrue',Bool32x4AllTrueJS, +'swizzle',Bool32x4SwizzleJS, +'shuffle',Bool32x4ShuffleJS, +]); +b.InstallFunctions(g,2,[ +'splat',Int16x8Splat, +'check',Int16x8CheckJS, +'extractLane',Int16x8ExtractLaneJS, +'replaceLane',Int16x8ReplaceLaneJS, +'neg',Int16x8NegJS, +'add',Int16x8AddJS, +'sub',Int16x8SubJS, +'addSaturate',Int16x8AddSaturateJS, +'subSaturate',Int16x8SubSaturateJS, +'mul',Int16x8MulJS, +'min',Int16x8MinJS, +'max',Int16x8MaxJS, +'and',Int16x8AndJS, +'or',Int16x8OrJS, +'xor',Int16x8XorJS, +'not',Int16x8NotJS, +'shiftLeftByScalar',Int16x8ShiftLeftByScalarJS, +'shiftRightByScalar',Int16x8ShiftRightByScalarJS, +'lessThan',Int16x8LessThanJS, +'lessThanOrEqual',Int16x8LessThanOrEqualJS, +'greaterThan',Int16x8GreaterThanJS, +'greaterThanOrEqual',Int16x8GreaterThanOrEqualJS, +'equal',Int16x8EqualJS, +'notEqual',Int16x8NotEqualJS, +'select',Int16x8SelectJS, +'swizzle',Int16x8SwizzleJS, +'shuffle',Int16x8ShuffleJS, +'fromUint16x8',Int16x8FromUint16x8JS, +'fromFloat32x4Bits',Int16x8FromFloat32x4BitsJS, +'fromInt32x4Bits',Int16x8FromInt32x4BitsJS, +'fromUint32x4Bits',Int16x8FromUint32x4BitsJS, +'fromUint16x8Bits',Int16x8FromUint16x8BitsJS, +'fromInt8x16Bits',Int16x8FromInt8x16BitsJS, +'fromUint8x16Bits',Int16x8FromUint8x16BitsJS, +'load',Int16x8LoadJS, +'store',Int16x8StoreJS, +]); +b.InstallFunctions(j,2,[ +'splat',Uint16x8Splat, +'check',Uint16x8CheckJS, +'extractLane',Uint16x8ExtractLaneJS, +'replaceLane',Uint16x8ReplaceLaneJS, +'add',Uint16x8AddJS, +'sub',Uint16x8SubJS, +'addSaturate',Uint16x8AddSaturateJS, +'subSaturate',Uint16x8SubSaturateJS, +'mul',Uint16x8MulJS, +'min',Uint16x8MinJS, +'max',Uint16x8MaxJS, +'and',Uint16x8AndJS, +'or',Uint16x8OrJS, +'xor',Uint16x8XorJS, +'not',Uint16x8NotJS, +'shiftLeftByScalar',Uint16x8ShiftLeftByScalarJS, +'shiftRightByScalar',Uint16x8ShiftRightByScalarJS, +'lessThan',Uint16x8LessThanJS, +'lessThanOrEqual',Uint16x8LessThanOrEqualJS, +'greaterThan',Uint16x8GreaterThanJS, +'greaterThanOrEqual',Uint16x8GreaterThanOrEqualJS, +'equal',Uint16x8EqualJS, +'notEqual',Uint16x8NotEqualJS, +'select',Uint16x8SelectJS, +'swizzle',Uint16x8SwizzleJS, +'shuffle',Uint16x8ShuffleJS, +'fromInt16x8',Uint16x8FromInt16x8JS, +'fromFloat32x4Bits',Uint16x8FromFloat32x4BitsJS, +'fromInt32x4Bits',Uint16x8FromInt32x4BitsJS, +'fromUint32x4Bits',Uint16x8FromUint32x4BitsJS, +'fromInt16x8Bits',Uint16x8FromInt16x8BitsJS, +'fromInt8x16Bits',Uint16x8FromInt8x16BitsJS, +'fromUint8x16Bits',Uint16x8FromUint8x16BitsJS, +'load',Uint16x8LoadJS, +'store',Uint16x8StoreJS, +]); +b.InstallFunctions(m,2,[ +'splat',Bool16x8Splat, +'check',Bool16x8CheckJS, +'extractLane',Bool16x8ExtractLaneJS, +'replaceLane',Bool16x8ReplaceLaneJS, +'and',Bool16x8AndJS, +'or',Bool16x8OrJS, +'xor',Bool16x8XorJS, +'not',Bool16x8NotJS, +'anyTrue',Bool16x8AnyTrueJS, +'allTrue',Bool16x8AllTrueJS, +'swizzle',Bool16x8SwizzleJS, +'shuffle',Bool16x8ShuffleJS, +]); +b.InstallFunctions(h,2,[ +'splat',Int8x16Splat, +'check',Int8x16CheckJS, +'extractLane',Int8x16ExtractLaneJS, +'replaceLane',Int8x16ReplaceLaneJS, +'neg',Int8x16NegJS, +'add',Int8x16AddJS, +'sub',Int8x16SubJS, +'addSaturate',Int8x16AddSaturateJS, +'subSaturate',Int8x16SubSaturateJS, +'mul',Int8x16MulJS, +'min',Int8x16MinJS, +'max',Int8x16MaxJS, +'and',Int8x16AndJS, +'or',Int8x16OrJS, +'xor',Int8x16XorJS, +'not',Int8x16NotJS, +'shiftLeftByScalar',Int8x16ShiftLeftByScalarJS, +'shiftRightByScalar',Int8x16ShiftRightByScalarJS, +'lessThan',Int8x16LessThanJS, +'lessThanOrEqual',Int8x16LessThanOrEqualJS, +'greaterThan',Int8x16GreaterThanJS, +'greaterThanOrEqual',Int8x16GreaterThanOrEqualJS, +'equal',Int8x16EqualJS, +'notEqual',Int8x16NotEqualJS, +'select',Int8x16SelectJS, +'swizzle',Int8x16SwizzleJS, +'shuffle',Int8x16ShuffleJS, +'fromUint8x16',Int8x16FromUint8x16JS, +'fromFloat32x4Bits',Int8x16FromFloat32x4BitsJS, +'fromInt32x4Bits',Int8x16FromInt32x4BitsJS, +'fromUint32x4Bits',Int8x16FromUint32x4BitsJS, +'fromInt16x8Bits',Int8x16FromInt16x8BitsJS, +'fromUint16x8Bits',Int8x16FromUint16x8BitsJS, +'fromUint8x16Bits',Int8x16FromUint8x16BitsJS, +'load',Int8x16LoadJS, +'store',Int8x16StoreJS, +]); +b.InstallFunctions(k,2,[ +'splat',Uint8x16Splat, +'check',Uint8x16CheckJS, +'extractLane',Uint8x16ExtractLaneJS, +'replaceLane',Uint8x16ReplaceLaneJS, +'add',Uint8x16AddJS, +'sub',Uint8x16SubJS, +'addSaturate',Uint8x16AddSaturateJS, +'subSaturate',Uint8x16SubSaturateJS, +'mul',Uint8x16MulJS, +'min',Uint8x16MinJS, +'max',Uint8x16MaxJS, +'and',Uint8x16AndJS, +'or',Uint8x16OrJS, +'xor',Uint8x16XorJS, +'not',Uint8x16NotJS, +'shiftLeftByScalar',Uint8x16ShiftLeftByScalarJS, +'shiftRightByScalar',Uint8x16ShiftRightByScalarJS, +'lessThan',Uint8x16LessThanJS, +'lessThanOrEqual',Uint8x16LessThanOrEqualJS, +'greaterThan',Uint8x16GreaterThanJS, +'greaterThanOrEqual',Uint8x16GreaterThanOrEqualJS, +'equal',Uint8x16EqualJS, +'notEqual',Uint8x16NotEqualJS, +'select',Uint8x16SelectJS, +'swizzle',Uint8x16SwizzleJS, +'shuffle',Uint8x16ShuffleJS, +'fromInt8x16',Uint8x16FromInt8x16JS, +'fromFloat32x4Bits',Uint8x16FromFloat32x4BitsJS, +'fromInt32x4Bits',Uint8x16FromInt32x4BitsJS, +'fromUint32x4Bits',Uint8x16FromUint32x4BitsJS, +'fromInt16x8Bits',Uint8x16FromInt16x8BitsJS, +'fromUint16x8Bits',Uint8x16FromUint16x8BitsJS, +'fromInt8x16Bits',Uint8x16FromInt8x16BitsJS, +'load',Uint8x16LoadJS, +'store',Uint8x16StoreJS, +]); +b.InstallFunctions(n,2,[ +'splat',Bool8x16Splat, +'check',Bool8x16CheckJS, +'extractLane',Bool8x16ExtractLaneJS, +'replaceLane',Bool8x16ReplaceLaneJS, +'and',Bool8x16AndJS, +'or',Bool8x16OrJS, +'xor',Bool8x16XorJS, +'not',Bool8x16NotJS, +'anyTrue',Bool8x16AnyTrueJS, +'allTrue',Bool8x16AllTrueJS, +'swizzle',Bool8x16SwizzleJS, +'shuffle',Bool8x16ShuffleJS, +]); +}) + +`datetime-format-to-partsé +(function(a,b){ +"use strict"; +%CheckIsBootstrapping(); +var c=a.Intl; +var d=b.ImportNow("FormatDateToParts"); +b.InstallFunctions(c.DateTimeFormat.prototype,2,[ +'formatToParts',d +]); +}) + +@icu-case-mapping± +(function(a,b){ +"use strict"; +%CheckIsBootstrapping(); +var c=a.String; +var d=b.OverrideFunction; +var e=b.ImportNow("ToLowerCaseI18N"); +var f=b.ImportNow("ToUpperCaseI18N"); +var g=b.ImportNow("ToLocaleLowerCaseI18N"); +var h=b.ImportNow("ToLocaleUpperCaseI18N"); +d(c.prototype,'toLowerCase',e,true); +d(c.prototype,'toUpperCase',f,true); +d(c.prototype,'toLocaleLowerCase', +g,true); +d(c.prototype,'toLocaleUpperCase', +h,true); +}) + +4CommonStringsI +(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', + }; +}); +dByteLengthQueuingStrategyÑ +(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(chunk) { return 1; } + } + defineProperty(global, 'CountQueuingStrategy', { + value: CountQueuingStrategy, + enumerable: false, + configurable: true, + writable: true + }); + class BuiltInCountQueuingStrategy { + constructor(highWaterMark) { + defineProperty(this, 'highWaterMark', {value: highWaterMark}); + } + size(chunk) { return 1; } + } + binding.createBuiltInCountQueuingStrategy = highWaterMark => + new BuiltInCountQueuingStrategy(highWaterMark); +}); +8ReadableStreamr´ +(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 _underlyingSource = v8.createPrivateSymbol('[[underlyingSource]]'); + const _controlledReadableStream = + v8.createPrivateSymbol('[[controlledReadableStream]]'); + const _queue = v8.createPrivateSymbol('[[queue]]'); + const _totalQueuedSize = v8.createPrivateSymbol('[[totalQueuedSize]]'); + const _strategySize = v8.createPrivateSymbol('[[strategySize]]'); + const _strategyHWM = v8.createPrivateSymbol('[[strategyHWM]]'); + const _readableStreamDefaultControllerBits = v8.createPrivateSymbol( + 'bit field for [[started]], [[closeRequested]], [[pulling]], [[pullAgain]]'); + const STARTED = 0b1; + const CLOSE_REQUESTED = 0b10; + const PULLING = 0b100; + const PULL_AGAIN = 0b1000; + const EXTERNALLY_CONTROLLED = 0b10000; + const undefined = global.undefined; + const Infinity = global.Infinity; + const defineProperty = global.Object.defineProperty; + const hasOwnProperty = v8.uncurryThis(global.Object.hasOwnProperty); + const callFunction = v8.uncurryThis(global.Function.prototype.call); + const TypeError = global.TypeError; + const RangeError = global.RangeError; + const Number = global.Number; + const Number_isNaN = Number.isNaN; + const Number_isFinite = Number.isFinite; + const Promise = global.Promise; + const thenPromise = v8.uncurryThis(Promise.prototype.then); + const Promise_resolve = v8.simpleBind(Promise.resolve, Promise); + const Promise_reject = v8.simpleBind(Promise.reject, Promise); + 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 errErrorClosedStream = 'Cannot error a close readable stream'; + const errErrorErroredStream = + 'Cannot error a readable stream that is already errored'; + 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 errTmplMustBeFunctionOrUndefined = name => + `${name} must be a function or undefined`; + class ReadableStream { + constructor() { + const underlyingSource = arguments[0] === undefined ? {} : arguments[0]; + const strategy = arguments[1] === undefined ? {} : arguments[1]; + const size = strategy.size; + let highWaterMark = strategy.highWaterMark; + if (highWaterMark === undefined) { + highWaterMark = 1; + } + this[_readableStreamBits] = 0b0; + ReadableStreamSetState(this, STATE_READABLE); + this[_reader] = undefined; + this[_storedError] = undefined; + this[_controller] = undefined; + const type = underlyingSource.type; + const typeString = String(type); + if (typeString === 'bytes') { + throw new RangeError('bytes type is not yet implemented'); + } else if (type !== undefined) { + throw new RangeError(streamErrors.invalidType); + } + this[_controller] = + new ReadableStreamDefaultController(this, underlyingSource, size, highWaterMark, arguments[2] === createWithExternalControllerSentinel); + } + 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 === 'byob') { + throw new TypeError(errGetReaderNotByteStream); + } + if (mode === undefined) { + return AcquireReadableStreamDefaultReader(this); + } + throw new RangeError(errGetReaderBadMode); + } + tee() { + if (IsReadableStream(this) === false) { + throw new TypeError(streamErrors.illegalInvocation); + } + return ReadableStreamTee(this); + } + } + class ReadableStreamDefaultController { + constructor(stream, underlyingSource, size, highWaterMark, isExternallyControlled) { + if (IsReadableStream(stream) === false) { + throw new TypeError(streamErrors.illegalConstructor); + } + if (stream[_controller] !== undefined) { + throw new TypeError(streamErrors.illegalConstructor); + } + this[_controlledReadableStream] = stream; + this[_underlyingSource] = underlyingSource; + this[_queue] = new v8.InternalPackedArray(); + this[_totalQueuedSize] = 0; + this[_readableStreamDefaultControllerBits] = 0b0; + if (isExternallyControlled === true) { + this[_readableStreamDefaultControllerBits] |= EXTERNALLY_CONTROLLED; + } + const normalizedStrategy = + ValidateAndNormalizeQueuingStrategy(size, highWaterMark); + this[_strategySize] = normalizedStrategy.size; + this[_strategyHWM] = normalizedStrategy.highWaterMark; + const controller = this; + const startResult = CallOrNoop( + underlyingSource, 'start', this, 'underlyingSource.start'); + thenPromise(Promise_resolve(startResult), + () => { + controller[_readableStreamDefaultControllerBits] |= STARTED; + ReadableStreamDefaultControllerCallPullIfNeeded(controller); + }, + r => { + if (ReadableStreamGetState(stream) === STATE_READABLE) { + ReadableStreamDefaultControllerError(controller, r); + } + }); + } + get desiredSize() { + if (IsReadableStreamDefaultController(this) === false) { + throw new TypeError(streamErrors.illegalInvocation); + } + return ReadableStreamDefaultControllerGetDesiredSize(this); + } + close() { + if (IsReadableStreamDefaultController(this) === false) { + throw new TypeError(streamErrors.illegalInvocation); + } + const stream = this[_controlledReadableStream]; + if (this[_readableStreamDefaultControllerBits] & CLOSE_REQUESTED) { + throw new TypeError(errCloseCloseRequestedStream); + } + const state = ReadableStreamGetState(stream); + if (state === STATE_ERRORED) { + throw new TypeError(errCloseErroredStream); + } + if (state === STATE_CLOSED) { + throw new TypeError(errCloseClosedStream); + } + return ReadableStreamDefaultControllerClose(this); + } + enqueue(chunk) { + if (IsReadableStreamDefaultController(this) === false) { + throw new TypeError(streamErrors.illegalInvocation); + } + const stream = this[_controlledReadableStream]; + if (this[_readableStreamDefaultControllerBits] & CLOSE_REQUESTED) { + throw new TypeError(errEnqueueCloseRequestedStream); + } + const state = ReadableStreamGetState(stream); + if (state === STATE_ERRORED) { + throw new TypeError(errEnqueueErroredStream); + } + if (state === STATE_CLOSED) { + throw new TypeError(errEnqueueClosedStream); + } + return ReadableStreamDefaultControllerEnqueue(this, chunk); + } + error(e) { + if (IsReadableStreamDefaultController(this) === false) { + throw new TypeError(streamErrors.illegalInvocation); + } + const stream = this[_controlledReadableStream]; + const state = ReadableStreamGetState(stream); + if (state === STATE_ERRORED) { + throw new TypeError(errErrorErroredStream); + } + if (state === STATE_CLOSED) { + throw new TypeError(errErrorClosedStream); + } + return ReadableStreamDefaultControllerError(this, e); + } + } + function ReadableStreamDefaultControllerCancel(controller, reason) { + controller[_queue] = new v8.InternalPackedArray(); + const underlyingSource = controller[_underlyingSource]; + return PromiseCallOrNoop(underlyingSource, 'cancel', reason, 'underlyingSource.cancel'); + } + 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 ReadableStreamAddReadRequest(stream) { + const promise = v8.createPromise(); + stream[_reader][_readRequests].push(promise); + return promise; + } + 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 v8.InternalPackedArray(); + } + 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)); + } + const stream = this[_ownerReadableStream]; + if (stream === 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); + } + const stream = this[_ownerReadableStream]; + if (stream === undefined) { + return undefined; + } + if (this[_readRequests].length > 0) { + throw new TypeError(errReleaseReaderWithPendingRead); + } + ReadableStreamReaderGenericRelease(this); + } + } + function ReadableStreamReaderGenericCancel(reader, reason) { + return ReadableStreamCancel(reader[_ownerReadableStream], reason); + } + function AcquireReadableStreamDefaultReader(stream) { + return new ReadableStreamDefaultReader(stream); + } + 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 ReadableStreamDefaultControllerClose(controller) { + const stream = controller[_controlledReadableStream]; + controller[_readableStreamDefaultControllerBits] |= CLOSE_REQUESTED; + if (controller[_queue].length === 0) { + ReadableStreamClose(stream); + } + } + function ReadableStreamFulfillReadRequest(stream, chunk, done) { + const reader = stream[_reader]; + const readRequest = stream[_reader][_readRequests].shift(); + v8.resolvePromise(readRequest, CreateIterResultObject(chunk, done)); + } + function ReadableStreamDefaultControllerEnqueue(controller, chunk) { + const stream = controller[_controlledReadableStream]; + if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) { + ReadableStreamFulfillReadRequest(stream, chunk, false); + } else { + let chunkSize = 1; + const strategySize = controller[_strategySize]; + if (strategySize !== undefined) { + try { + chunkSize = strategySize(chunk); + } catch (chunkSizeE) { + if (ReadableStreamGetState(stream) === STATE_READABLE) { + ReadableStreamDefaultControllerError(controller, chunkSizeE); + } + throw chunkSizeE; + } + } + try { + EnqueueValueWithSize(controller, chunk, chunkSize); + } catch (enqueueE) { + if (ReadableStreamGetState(stream) === STATE_READABLE) { + ReadableStreamDefaultControllerError(controller, enqueueE); + } + throw enqueueE; + } + } + ReadableStreamDefaultControllerCallPullIfNeeded(controller); + } + 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 ReadableStreamDefaultControllerError(controller, e) { + controller[_queue] = new v8.InternalPackedArray(); + const stream = controller[_controlledReadableStream]; + ReadableStreamError(stream, e); + } + function ReadableStreamError(stream, e) { + stream[_storedError] = e; + ReadableStreamSetState(stream, STATE_ERRORED); + const reader = stream[_reader]; + if (reader === undefined) { + return undefined; + } + if (IsReadableStreamDefaultReader(reader) === true) { + const readRequests = reader[_readRequests]; + for (let i = 0; i < readRequests.length; i++) { + v8.rejectPromise(readRequests[i], e); + } + reader[_readRequests] = new v8.InternalPackedArray(); + } + v8.rejectPromise(reader[_closedPromise], e); + v8.markPromiseAsHandled(reader[_closedPromise]); + } + function ReadableStreamClose(stream) { + ReadableStreamSetState(stream, STATE_CLOSED); + const reader = stream[_reader]; + if (reader === undefined) { + return undefined; + } + if (IsReadableStreamDefaultReader(reader) === true) { + const readRequests = reader[_readRequests]; + for (let i = 0; i < readRequests.length; i++) { + v8.resolvePromise( + readRequests[i], CreateIterResultObject(undefined, true)); + } + reader[_readRequests] = new v8.InternalPackedArray(); + } + v8.resolvePromise(reader[_closedPromise], undefined); + } + function ReadableStreamDefaultControllerGetDesiredSize(controller) { + const queueSize = GetTotalQueueSize(controller); + return controller[_strategyHWM] - queueSize; + } + function IsReadableStream(x) { + return hasOwnProperty(x, _controller); + } + function IsReadableStreamDisturbed(stream) { + return stream[_readableStreamBits] & DISTURBED; + } + function IsReadableStreamLocked(stream) { + return stream[_reader] !== undefined; + } + function IsReadableStreamDefaultController(x) { + return hasOwnProperty(x, _controlledReadableStream); + } + function IsReadableStreamDefaultReader(x) { + return hasOwnProperty(x, _readRequests); + } + 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 ReadableStreamReaderGenericInitialize(reader, stream) { + const controller = stream[_controller]; + if (controller[_readableStreamDefaultControllerBits] & EXTERNALLY_CONTROLLED) { + const underlyingSource = controller[_underlyingSource]; + callFunction(underlyingSource.notifyLockAcquired, underlyingSource); + } + 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]); + v8.markPromiseAsHandled(reader[_closedPromise]); + break; + } + } + function ReadableStreamReaderGenericRelease(reader) { + const controller = reader[_ownerReadableStream][_controller]; + if (controller[_readableStreamDefaultControllerBits] & EXTERNALLY_CONTROLLED) { + const underlyingSource = controller[_underlyingSource]; + callFunction(underlyingSource.notifyLockReleased, underlyingSource); + } + if (ReadableStreamGetState(reader[_ownerReadableStream]) === STATE_READABLE) { + v8.rejectPromise(reader[_closedPromise], new TypeError(errReleasedReaderClosedPromise)); + } else { + reader[_closedPromise] = Promise_reject(new TypeError(errReleasedReaderClosedPromise)); + } + v8.markPromiseAsHandled(reader[_closedPromise]); + reader[_ownerReadableStream][_reader] = undefined; + reader[_ownerReadableStream] = undefined; + } + function ReadableStreamDefaultReaderRead(reader) { + const stream = reader[_ownerReadableStream]; + stream[_readableStreamBits] |= DISTURBED; + if (ReadableStreamGetState(stream) === STATE_CLOSED) { + return Promise_resolve(CreateIterResultObject(undefined, true)); + } + if (ReadableStreamGetState(stream) === STATE_ERRORED) { + return Promise_reject(stream[_storedError]); + } + return ReadableStreamDefaultControllerPull(stream[_controller]); + } + function ReadableStreamDefaultControllerCallPullIfNeeded(controller) { + const shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller); + if (shouldPull === false) { + return undefined; + } + if (controller[_readableStreamDefaultControllerBits] & PULLING) { + controller[_readableStreamDefaultControllerBits] |= PULL_AGAIN; + return undefined; + } + controller[_readableStreamDefaultControllerBits] |= PULLING; + const underlyingSource = controller[_underlyingSource]; + const pullPromise = PromiseCallOrNoop( + underlyingSource, 'pull', controller, 'underlyingSource.pull'); + thenPromise(pullPromise, + () => { + controller[_readableStreamDefaultControllerBits] &= ~PULLING; + if (controller[_readableStreamDefaultControllerBits] & PULL_AGAIN) { + controller[_readableStreamDefaultControllerBits] &= ~PULL_AGAIN; + ReadableStreamDefaultControllerCallPullIfNeeded(controller); + } + }, + e => { + if (ReadableStreamGetState(controller[_controlledReadableStream]) === STATE_READABLE) { + ReadableStreamDefaultControllerError(controller, e); + } + }); + } + function ReadableStreamDefaultControllerShouldCallPull(controller) { + const stream = controller[_controlledReadableStream]; + const state = ReadableStreamGetState(stream); + if (state === STATE_CLOSED || state === STATE_ERRORED) { + return false; + } + if (controller[_readableStreamDefaultControllerBits] & CLOSE_REQUESTED) { + return false; + } + if (!(controller[_readableStreamDefaultControllerBits] & STARTED)) { + return false; + } + if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) { + return true; + } + const desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller); + if (desiredSize > 0) { + return true; + } + return false; + } + function ReadableStreamGetNumReadRequests(stream) { + const reader = stream[_reader]; + const readRequests = reader[_readRequests]; + return readRequests.length; + } + function ReadableStreamTee(stream) { + const reader = AcquireReadableStreamDefaultReader(stream); + let closedOrErrored = false; + let canceled1 = false; + let canceled2 = false; + let reason1; + let reason2; + let promise = v8.createPromise(); + const branch1Stream = new ReadableStream({pull, cancel: cancel1}); + const branch2Stream = new ReadableStream({pull, cancel: cancel2}); + const branch1 = branch1Stream[_controller]; + const branch2 = branch2Stream[_controller]; + thenPromise( + reader[_closedPromise], undefined, function(r) { + if (closedOrErrored === true) { + return; + } + ReadableStreamDefaultControllerError(branch1, r); + ReadableStreamDefaultControllerError(branch2, r); + closedOrErrored = true; + }); + return [branch1Stream, branch2Stream]; + function pull() { + return thenPromise( + ReadableStreamDefaultReaderRead(reader), function(result) { + const value = result.value; + const done = result.done; + if (done === true && closedOrErrored === false) { + if (canceled1 === false) { + ReadableStreamDefaultControllerClose(branch1); + } + if (canceled2 === false) { + ReadableStreamDefaultControllerClose(branch2); + } + closedOrErrored = true; + } + if (closedOrErrored === true) { + return; + } + if (canceled1 === false) { + ReadableStreamDefaultControllerEnqueue(branch1, value); + } + if (canceled2 === false) { + ReadableStreamDefaultControllerEnqueue(branch2, value); + } + }); + } + function cancel1(reason) { + canceled1 = true; + reason1 = reason; + if (canceled2 === true) { + const compositeReason = [reason1, reason2]; + const cancelResult = ReadableStreamCancel(stream, compositeReason); + v8.resolvePromise(promise, cancelResult); + } + return promise; + } + function cancel2(reason) { + canceled2 = true; + reason2 = reason; + if (canceled1 === true) { + const compositeReason = [reason1, reason2]; + const cancelResult = ReadableStreamCancel(stream, compositeReason); + v8.resolvePromise(promise, cancelResult); + } + return promise; + } + } + function DequeueValue(controller) { + const result = controller[_queue].shift(); + controller[_totalQueuedSize] -= result.size; + return result.value; + } + function EnqueueValueWithSize(controller, value, size) { + size = Number(size); + if (Number_isNaN(size) || size === +Infinity || size < 0) { + throw new RangeError(streamErrors.invalidSize); + } + controller[_totalQueuedSize] += size; + controller[_queue].push({value, size}); + } + function GetTotalQueueSize(controller) { return controller[_totalQueuedSize]; } + function ValidateAndNormalizeQueuingStrategy(size, highWaterMark) { + if (size !== undefined && typeof size !== 'function') { + throw new TypeError(streamErrors.sizeNotAFunction); + } + highWaterMark = Number(highWaterMark); + if (Number_isNaN(highWaterMark)) { + throw new RangeError(streamErrors.errInvalidHWM); + } + if (highWaterMark < 0) { + throw new RangeError(streamErrors.invalidHWM); + } + return {size, highWaterMark}; + } + function CallOrNoop(O, P, arg, nameForError) { + const method = O[P]; + if (method === undefined) { + return undefined; + } + if (typeof method !== 'function') { + throw new TypeError(errTmplMustBeFunctionOrUndefined(nameForError)); + } + return callFunction(method, O, arg); + } + function PromiseCallOrNoop(O, P, arg, nameForError) { + let method; + try { + method = O[P]; + } catch (methodE) { + return Promise_reject(methodE); + } + if (method === undefined) { + return Promise_resolve(undefined); + } + if (typeof method !== 'function') { + return Promise_reject(new TypeError(errTmplMustBeFunctionOrUndefined(nameForError))); + } + try { + return Promise_resolve(callFunction(method, O, arg)); + } catch (e) { + return Promise_reject(e); + } + } + function CreateIterResultObject(value, done) { return {value, done}; } + 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); + }; +}); +8WritableStream’é +(function(global, binding, v8) { + 'use strict'; + const _pendingWriteRequest = v8.createPrivateSymbol('[[pendingWriteRequest]]'); + const _pendingCloseRequest = v8.createPrivateSymbol('[[pendingCloseRequest]]'); + const _pendingAbortRequest = v8.createPrivateSymbol('[[pendingAbortRequest]]'); + const _state = v8.createPrivateSymbol('[[state]]'); + const _storedError = v8.createPrivateSymbol('[[storedError]]'); + const _writer = v8.createPrivateSymbol('[[writer]]'); + const _writableStreamController = + v8.createPrivateSymbol('[[writableStreamController]]'); + 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 _queue = v8.createPrivateSymbol('[[queue]]'); + const _queueSize = v8.createPrivateSymbol('[[queueSize]]'); + const _strategyHWM = v8.createPrivateSymbol('[[strategyHWM]]'); + const _strategySize = v8.createPrivateSymbol('[[strategySize]]'); + const _underlyingSink = v8.createPrivateSymbol('[[underlyingSink]]'); + const _defaultControllerFlags = + v8.createPrivateSymbol('[[defaultControllerFlags]]'); + const FLAG_STARTED = 0b1; + const FLAG_WRITING = 0b10; + const FLAG_INCLOSE = 0b100; + const WRITABLE = 0; + const CLOSING = 1; + const CLOSED = 2; + const ERRORED = 3; + const undefined = global.undefined; + const defineProperty = global.Object.defineProperty; + const hasOwnProperty = v8.uncurryThis(global.Object.hasOwnProperty); + const Function_apply = v8.uncurryThis(global.Function.prototype.apply); + const TypeError = global.TypeError; + const RangeError = global.RangeError; + const Boolean = global.Boolean; + const Number = global.Number; + const Number_isNaN = Number.isNaN; + const Number_isFinite = Number.isFinite; + const Promise = global.Promise; + const thenPromise = v8.uncurryThis(Promise.prototype.then); + const Promise_resolve = v8.simpleBind(Promise.resolve, Promise); + const Promise_reject = v8.simpleBind(Promise.reject, Promise); + const streamErrors = binding.streamErrors; + const errAbortLockedStream = 'Cannot abort a writable stream that is locked to a writer'; + const errStreamAborted = 'The stream has been aborted'; + 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 errWriteCloseRequestedStream = + 'Cannot write to a writable stream that is due 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 templateErrorIsNotAFunction = f => `${f} is not a function`; + const verbUsedToGetTheDesiredSize = 'used to get the desiredSize'; + const verbAborted = 'aborted'; + const verbClosed = 'closed'; + const verbWrittenTo = 'written to'; + function createWriterLockReleasedError(verb) { + return new TypeError(errWriterLockReleasedPrefix + verb); + } + const stateNames = {[CLOSED]: 'closed', [ERRORED]: 'errored'}; + function createCannotActionOnStateStreamError(action, state) { + TEMP_ASSERT(stateNames[state] !== undefined, + `name for state ${state} exists in stateNames`); + return new TypeError( + templateErrorCannotActionOnStateStream(action, stateNames[state])); + } + function setDefaultControllerFlag(controller, flag, value) { + let flags = controller[_defaultControllerFlags]; + if (value) { + flags = flags | flag; + } else { + flags = flags & ~flag; + } + controller[_defaultControllerFlags] = flags; + } + function getDefaultControllerStartedFlag(controller) { + return Boolean(controller[_defaultControllerFlags] & FLAG_STARTED); + } + function setDefaultControllerStartedFlag(controller, value) { + setDefaultControllerFlag(controller, FLAG_STARTED, value); + } + function getDefaultControllerWritingFlag(controller) { + return Boolean(controller[_defaultControllerFlags] & FLAG_WRITING); + } + function setDefaultControllerWritingFlag(controller, value) { + setDefaultControllerFlag(controller, FLAG_WRITING, value); + } + function getDefaultControllerInCloseFlag(controller) { + return Boolean(controller[_defaultControllerFlags] & FLAG_INCLOSE); + } + function setDefaultControllerInCloseFlag(controller, value) { + setDefaultControllerFlag(controller, FLAG_INCLOSE, value); + } + function rejectPromises(array, e) { + for (let i = 0; i < array.length; ++i) { + v8.rejectPromise(array[i], e); + } + } + function IsPropertyKey(argument) { + return typeof argument === 'string' || typeof argument === 'symbol'; + } + function TEMP_ASSERT(predicate, message) { + if (predicate) { + return; + } + v8.log(`Assertion failed: ${message}\n`); + v8.logStackTrace(); + class WritableStreamInternalError extends Error { + constructor(message) { + super(message); + } + } + throw new WritableStreamInternalError(message); + } + class WritableStream { + constructor(underlyingSink = {}, { size, highWaterMark = 1 } = {}) { + this[_state] = WRITABLE; + this[_storedError] = undefined; + this[_writer] = undefined; + this[_writableStreamController] = undefined; + this[_pendingWriteRequest] = undefined; + this[_pendingCloseRequest] = undefined; + this[_pendingAbortRequest] = undefined; + this[_writeRequests] = new v8.InternalPackedArray(); + const type = underlyingSink.type; + if (type !== undefined) { + throw new RangeError(streamErrors.invalidType); + } + this[_writableStreamController] = + new WritableStreamDefaultController(this, underlyingSink, size, + highWaterMark); + } + 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); + } + } + function AcquireWritableStreamDefaultWriter(stream) { + return new WritableStreamDefaultWriter(stream); + } + function IsWritableStream(x) { + return hasOwnProperty(x, _writableStreamController); + } + function IsWritableStreamLocked(stream) { + TEMP_ASSERT(IsWritableStream(stream), + '! IsWritableStream(stream) is true.'); + return stream[_writer] !== undefined; + } + function WritableStreamAbort(stream, reason) { + const state = stream[_state]; + if (state === CLOSED) { + return Promise_resolve(undefined); + } + if (state === ERRORED) { + return Promise_reject(stream[_storedError]); + } + TEMP_ASSERT(state === WRITABLE || state === CLOSING, + 'state is "writable" or "closing".'); + const error = new TypeError(errStreamAborted); + WritableStreamError(stream, error); + const controller = stream[_writableStreamController]; + TEMP_ASSERT(controller !== undefined, + 'controller is not undefined'); + const isWriting = getDefaultControllerWritingFlag(controller); + if (isWriting || getDefaultControllerInCloseFlag(controller)) { + const promise = v8.createPromise(); + stream[_pendingAbortRequest] = promise; + if (isWriting) { + return thenPromise(promise, () => { + return WritableStreamDefaultControllerAbort(controller, reason); + }); + } + return promise; + } + return WritableStreamDefaultControllerAbort(controller, reason); + } + function WritableStreamAddWriteRequest(stream) { + TEMP_ASSERT(IsWritableStreamLocked(stream), + '! IsWritableStreamLocked(writer) is true.'); + TEMP_ASSERT(stream[_state] === WRITABLE, + 'stream.[[state]] is "writable".'); + const promise = v8.createPromise(); + stream[_writeRequests].push(promise); + return promise; + } + function WritableStreamError(stream, e) { + const oldState = stream[_state]; + TEMP_ASSERT(oldState === WRITABLE || oldState === CLOSING, + 'oldState is "writable" or "closing".'); + stream[_state] = ERRORED; + stream[_storedError] = e; + const controller = stream[_writableStreamController]; + if (controller === undefined || + (!getDefaultControllerWritingFlag(controller) && + !getDefaultControllerInCloseFlag(controller))) { + WritableStreamRejectPromisesInReactionToError(stream); + } + const writer = stream[_writer]; + if (writer !== undefined) { + if (oldState === WRITABLE && + WritableStreamDefaultControllerGetBackpressure(controller) === true) { + v8.rejectPromise(writer[_readyPromise], e); + } else { + writer[_readyPromise] = Promise_reject(e); + } + v8.markPromiseAsHandled(writer[_readyPromise]); + } + } + function WritableStreamFinishClose(stream) { + const state = stream[_state]; + TEMP_ASSERT(state === CLOSING || state === ERRORED, + 'state is "closing" or "errored"'); + const writer = stream[_writer]; + if (state === CLOSING) { + if (writer !== undefined) { + v8.resolvePromise(writer[_closedPromise], undefined); + } + stream[_state] = CLOSED; + } else if (writer !== undefined) { + TEMP_ASSERT(state === ERRORED, 'state is "errored"'); + v8.rejectPromise(writer[_closedPromise], stream[_storedError]); + v8.markPromiseAsHandled(writer[_closedPromise]); + } + if (stream[_pendingAbortRequest] !== undefined) { + v8.resolvePromise(stream[_pendingAbortRequest], undefined); + stream[_pendingAbortRequest] = undefined; + } + } + function WritableStreamRejectPromisesInReactionToError(stream) { + TEMP_ASSERT(stream[_state] === ERRORED, 'stream.[[state]] is "errored"'); + TEMP_ASSERT(stream[_pendingWriteRequest] === undefined, + 'stream.[[pendingWriteRequest]] is undefined'); + const storedError = stream[_storedError]; + rejectPromises(stream[_writeRequests], storedError); + stream[_writeRequests] = new v8.InternalPackedArray(); + if (stream[_pendingCloseRequest] !== undefined) { + TEMP_ASSERT( + getDefaultControllerInCloseFlag(stream[_writableStreamController]) === + false, 'stream.[[writableStreamController]].[[inClose]] === false'); + v8.rejectPromise(stream[_pendingCloseRequest], storedError); + stream[_pendingCloseRequest] = undefined; + } + const writer = stream[_writer]; + if (writer !== undefined) { + v8.rejectPromise(writer[_closedPromise], storedError); + v8.markPromiseAsHandled(writer[_closedPromise]); + } + } + function WritableStreamUpdateBackpressure(stream, backpressure) { + TEMP_ASSERT(stream[_state] === WRITABLE, + 'stream.[[state]] is "writable".'); + const writer = stream[_writer]; + if (writer === undefined) { + return; + } + if (backpressure) { + writer[_readyPromise] = v8.createPromise(); + } else { + TEMP_ASSERT(backpressure === false, + 'backpressure is false.'); + v8.resolvePromise(writer[_readyPromise], undefined); + } + } + 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[_state]; + if (state === WRITABLE || state === CLOSING) { + this[_closedPromise] = v8.createPromise(); + } else if (state === CLOSED) { + this[_closedPromise] = Promise_resolve(undefined); + } else { + TEMP_ASSERT(state === ERRORED, + 'state is "errored".'); + this[_closedPromise] = Promise_reject(stream[_storedError]); + v8.markPromiseAsHandled(this[_closedPromise]); + } + if (state === WRITABLE && + WritableStreamDefaultControllerGetBackpressure( + stream[_writableStreamController])) { + this[_readyPromise] = v8.createPromise(); + } else { + this[_readyPromise] = Promise_resolve(undefined); + } + } + 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 (stream[_state] === CLOSING) { + 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; + } + TEMP_ASSERT(stream[_writer] !== undefined, + 'stream.[[writer]] is not undefined.'); + WritableStreamDefaultWriterRelease(this); + } + write(chunk) { + if (!IsWritableStreamDefaultWriter(this)) { + return Promise_reject(new TypeError(streamErrors.illegalInvocation)); + } + const stream = this[_ownerWritableStream]; + if (stream === undefined) { + return Promise_reject(createWriterLockReleasedError(verbWrittenTo)); + } + if (stream[_state] === CLOSING) { + return Promise_reject(new TypeError(errWriteCloseRequestedStream)); + } + return WritableStreamDefaultWriterWrite(this, chunk); + } + } + function IsWritableStreamDefaultWriter(x) { + return hasOwnProperty(x, _ownerWritableStream); + } + function WritableStreamDefaultWriterAbort(writer, reason) { + const stream = writer[_ownerWritableStream]; + TEMP_ASSERT(stream !== undefined, + 'stream is not undefined.'); + return WritableStreamAbort(stream, reason); + } + function WritableStreamDefaultWriterClose(writer) { + const stream = writer[_ownerWritableStream]; + TEMP_ASSERT(stream !== undefined, + 'stream is not undefined.'); + const state = stream[_state]; + if (state === CLOSED || state === ERRORED) { + return Promise_reject( + createCannotActionOnStateStreamError('close', state)); + } + TEMP_ASSERT(state === WRITABLE, + 'state is "writable".'); + stream[_pendingCloseRequest] = v8.createPromise(); + if (WritableStreamDefaultControllerGetBackpressure( + stream[_writableStreamController])) { + v8.resolvePromise(writer[_readyPromise], undefined); + } + stream[_state] = CLOSING; + WritableStreamDefaultControllerClose(stream[_writableStreamController]); + return stream[_pendingCloseRequest]; + } + function WritableStreamDefaultWriterGetDesiredSize(writer) { + const stream = writer[_ownerWritableStream]; + const state = stream[_state]; + if (state === ERRORED) { + return null; + } + if (state === CLOSED) { + return 0; + } + return WritableStreamDefaultControllerGetDesiredSize( + stream[_writableStreamController]); + } + function WritableStreamDefaultWriterRelease(writer) { + const stream = writer[_ownerWritableStream]; + TEMP_ASSERT(stream !== undefined, + 'stream is not undefined.'); + TEMP_ASSERT(stream[_writer] === writer, + 'stream.[[writer]] is writer.'); + const releasedError = new TypeError(errReleasedWriterClosedPromise); + const state = stream[_state]; + if (state === WRITABLE || state === CLOSING || + stream[_pendingAbortRequest] !== undefined) { + v8.rejectPromise(writer[_closedPromise], releasedError); + } else { + writer[_closedPromise] = Promise_reject(releasedError); + } + v8.markPromiseAsHandled(writer[_closedPromise]); + if (state === WRITABLE && + WritableStreamDefaultControllerGetBackpressure( + stream[_writableStreamController])) { + v8.rejectPromise(writer[_readyPromise], releasedError); + } else { + writer[_readyPromise] = Promise_reject(releasedError); + } + v8.markPromiseAsHandled(writer[_readyPromise]); + stream[_writer] = undefined; + writer[_ownerWritableStream] = undefined; + } + function WritableStreamDefaultWriterWrite(writer, chunk) { + const stream = writer[_ownerWritableStream]; + TEMP_ASSERT(stream !== undefined, + 'stream is not undefined.'); + const state = stream[_state]; + if (state === CLOSED || state === ERRORED) { + return Promise_reject( + createCannotActionOnStateStreamError('write to', state)); + } + TEMP_ASSERT(state === WRITABLE, + 'state is "writable".'); + const promise = WritableStreamAddWriteRequest(stream); + WritableStreamDefaultControllerWrite(stream[_writableStreamController], + chunk); + return promise; + } + class WritableStreamDefaultController { + constructor(stream, underlyingSink, size, highWaterMark) { + if (!IsWritableStream(stream)) { + throw new TypeError(streamErrors.illegalConstructor); + } + if (stream[_writableStreamController] !== undefined) { + throw new TypeError(streamErrors.illegalConstructor); + } + this[_controlledWritableStream] = stream; + this[_underlyingSink] = underlyingSink; + this[_queue] = new v8.InternalPackedArray(); + this[_queueSize] = 0; + this[_defaultControllerFlags] = 0; + const normalizedStrategy = + ValidateAndNormalizeQueuingStrategy(size, highWaterMark); + this[_strategySize] = normalizedStrategy.size; + this[_strategyHWM] = normalizedStrategy.highWaterMark; + const backpressure = WritableStreamDefaultControllerGetBackpressure(this); + if (backpressure) { + WritableStreamUpdateBackpressure(stream, backpressure); + } + const controller = this; + const startResult = InvokeOrNoop(underlyingSink, 'start', [this]); + const onFulfilled = () => { + setDefaultControllerStartedFlag(controller, true); + WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller); + }; + const onRejected = r => { + WritableStreamDefaultControllerErrorIfNeeded(controller, r); + }; + thenPromise(Promise_resolve(startResult), onFulfilled, onRejected); + } + error(e) { + if (!IsWritableStreamDefaultController(this)) { + throw new TypeError(streamErrors.illegalInvocation); + } + const state = this[_controlledWritableStream][_state]; + if (state === CLOSED || state === ERRORED) { + throw createCannotActionOnStateStreamError('error', state); + } + WritableStreamDefaultControllerError(this, e); + } + } + function IsWritableStreamDefaultController(x) { + return hasOwnProperty(x, _underlyingSink); + } + function WritableStreamDefaultControllerAbort(controller, reason) { + controller[_queue] = v8.InternalPackedArray(); + controller[_queueSize] = 0; + const sinkAbortPromise = + PromiseInvokeOrNoop(controller[_underlyingSink], 'abort', [reason]); + return thenPromise(sinkAbortPromise, () => undefined); + } + function WritableStreamDefaultControllerClose(controller) { + EnqueueValueWithSizeForController(controller, 'close', 0); + WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller); + } + function WritableStreamDefaultControllerGetDesiredSize(controller) { + const queueSize = GetTotalQueueSizeForController(controller); + return controller[_strategyHWM] - queueSize; + } + function WritableStreamDefaultControllerWrite(controller, chunk) { + const stream = controller[_controlledWritableStream]; + TEMP_ASSERT(stream[_state] === WRITABLE, + 'stream.[[state]] is "writable".'); + let chunkSize = 1; + const strategySize = controller[_strategySize]; + if (strategySize !== undefined) { + try { + chunkSize = strategySize(chunk); + } catch (e) { + WritableStreamDefaultControllerErrorIfNeeded(controller, e); + return; + } + } + const writeRecord = {chunk}; + const lastBackpressure = + WritableStreamDefaultControllerGetBackpressure(controller); + try { + EnqueueValueWithSizeForController(controller, writeRecord, chunkSize); + } catch (e) { + WritableStreamDefaultControllerErrorIfNeeded(controller, e); + return; + } + if (stream[_state] === WRITABLE) { + const backpressure = + WritableStreamDefaultControllerGetBackpressure(controller); + if (lastBackpressure !== backpressure) { + WritableStreamUpdateBackpressure(stream, backpressure); + } + } + WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller); + } + function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) { + const state = controller[_controlledWritableStream][_state]; + if (state === CLOSED || state === ERRORED) { + return; + } + if (!getDefaultControllerStartedFlag(controller)) { + return; + } + if (getDefaultControllerWritingFlag(controller)) { + return; + } + if (controller[_queue].length === 0) { + return; + } + const writeRecord = PeekQueueValue(controller[_queue]); + if (writeRecord === 'close') { + WritableStreamDefaultControllerProcessClose(controller); + } else { + WritableStreamDefaultControllerProcessWrite(controller, + writeRecord.chunk); + } + } + function WritableStreamDefaultControllerErrorIfNeeded(controller, e) { + const state = controller[_controlledWritableStream][_state]; + if (state === WRITABLE || state === CLOSING) { + WritableStreamDefaultControllerError(controller, e); + } + } + function WritableStreamDefaultControllerProcessClose(controller) { + const stream = controller[_controlledWritableStream]; + TEMP_ASSERT(stream[_state] === CLOSING, + 'stream.[[state]] is "closing".'); + DequeueValueForController(controller); + TEMP_ASSERT(controller[_queue].length === 0, + 'controller.[[queue]] is empty.'); + setDefaultControllerInCloseFlag(controller, true); + const sinkClosePromise = PromiseInvokeOrNoop(controller[_underlyingSink], + 'close', [controller]); + thenPromise(sinkClosePromise, + () => { + TEMP_ASSERT(getDefaultControllerInCloseFlag(controller) + === true, + 'controller.[[inClose]] is true'); + setDefaultControllerInCloseFlag(controller, false); + if (stream[_state] !== CLOSING && + stream[_state] !== ERRORED) { + return; + } + TEMP_ASSERT(stream[_pendingCloseRequest] !== undefined); + v8.resolvePromise(stream[_pendingCloseRequest], undefined); + stream[_pendingCloseRequest] = undefined; + WritableStreamFinishClose(stream); + }, + r => { + TEMP_ASSERT(getDefaultControllerInCloseFlag(controller) + === true, + 'controller.[[inClose]] is true'); + setDefaultControllerInCloseFlag(controller, false); + TEMP_ASSERT(stream[_pendingCloseRequest] !== undefined); + v8.rejectPromise(stream[_pendingCloseRequest], r); + stream[_pendingCloseRequest] = undefined; + if (stream[_pendingAbortRequest] !== undefined) { + v8.rejectPromise(stream[_pendingAbortRequest], r); + stream[_pendingAbortRequest] = undefined; + } + WritableStreamDefaultControllerErrorIfNeeded(controller, r); + } + ); + } + function WritableStreamDefaultControllerProcessWrite(controller, chunk) { + setDefaultControllerWritingFlag(controller, true); + const stream = controller[_controlledWritableStream]; + TEMP_ASSERT(stream[_pendingWriteRequest] === undefined, + 'stream.[[pendingWriteRequest]] is undefined'); + TEMP_ASSERT(stream[_writeRequests].length > 0, + 'stream.[[writeRequests]] is not empty'); + stream[_pendingWriteRequest] = stream[_writeRequests].shift(); + const sinkWritePromise = PromiseInvokeOrNoop(controller[_underlyingSink], + 'write', [chunk, controller]); + thenPromise( + sinkWritePromise, + () => { + TEMP_ASSERT(getDefaultControllerWritingFlag(controller) === true, + 'controller.[[writing]] is true'); + setDefaultControllerWritingFlag(controller, false); + TEMP_ASSERT(stream[_pendingWriteRequest] !== undefined, + 'stream.[[pendingWriteRequest]] is not undefined'); + v8.resolvePromise(stream[_pendingWriteRequest], undefined); + stream[_pendingWriteRequest] = undefined; + const state = stream[_state]; + if (state === ERRORED) { + WritableStreamRejectPromisesInReactionToError(stream); + if (stream[_pendingAbortRequest] !== undefined) { + v8.resolvePromise(stream[_pendingAbortRequest], undefined); + stream[_pendingAbortRequest] = undefined; + } + return; + } + const lastBackpressure = + WritableStreamDefaultControllerGetBackpressure(controller); + DequeueValueForController(controller); + if (state !== CLOSING) { + const backpressure = + WritableStreamDefaultControllerGetBackpressure(controller); + if (lastBackpressure !== backpressure) { + WritableStreamUpdateBackpressure( + controller[_controlledWritableStream], backpressure); + } + } + WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller); + }, + r => { + TEMP_ASSERT(getDefaultControllerWritingFlag(controller) === true, + 'controller.[[writing]] is true'); + setDefaultControllerWritingFlag(controller, false); + TEMP_ASSERT(stream[_pendingWriteRequest] !== undefined, + 'stream.[[pendingWriteRequest]] is not undefined'); + v8.rejectPromise(stream[_pendingWriteRequest], r); + stream[_pendingWriteRequest] = undefined; + if (stream[_state] === ERRORED) { + stream[_storedError] = r; + WritableStreamRejectPromisesInReactionToError(stream); + } + if (stream[_pendingAbortRequest] !== undefined) { + v8.rejectPromise(stream[_pendingAbortRequest], r); + stream[_pendingAbortRequest] = undefined; + } + WritableStreamDefaultControllerErrorIfNeeded(controller, r); + } + ); + } + function WritableStreamDefaultControllerGetBackpressure(controller) { + const desiredSize = + WritableStreamDefaultControllerGetDesiredSize(controller); + return desiredSize <= 0; + } + function WritableStreamDefaultControllerError(controller, e) { + const stream = controller[_controlledWritableStream]; + const state = stream[_state]; + TEMP_ASSERT(state === WRITABLE || state === CLOSING, + 'stream.[[state]] is "writable" or "closing".'); + WritableStreamError(stream, e); + controller[_queue] = new v8.InternalPackedArray(); + controller[_queueSize] = 0; + } + function DequeueValueForController(controller) { + TEMP_ASSERT(controller[_queue].length !== 0, + 'queue is not empty.'); + const result = controller[_queue].shift(); + controller[_queueSize] -= result.size; + return result.value; + } + function EnqueueValueWithSizeForController(controller, value, size) { + size = Number(size); + if (!IsFiniteNonNegativeNumber(size)) { + throw new RangeError(streamErrors.invalidSize); + } + controller[_queueSize] += size; + controller[_queue].push({value, size}); + } + function GetTotalQueueSizeForController(controller) { + return controller[_queueSize]; + } + function PeekQueueValue(queue) { + TEMP_ASSERT(queue.length !== 0, + 'queue is not empty.'); + return queue[0].value; + } + function InvokeOrNoop(O, P, args) { + TEMP_ASSERT(IsPropertyKey(P), + 'P is a valid property key.'); + if (args === undefined) { + args = []; + } + const method = O[P]; + if (method === undefined) { + return undefined; + } + if (typeof method !== 'function') { + throw new TypeError(templateErrorIsNotAFunction(P)); + } + return Function_apply(method, O, args); + } + function IsFiniteNonNegativeNumber(v) { + return Number_isFinite(v) && v >= 0; + } + function PromiseInvokeOrNoop(O, P, args) { + try { + return Promise_resolve(InvokeOrNoop(O, P, args)); + } catch (e) { + return Promise_reject(e); + } + } + function ValidateAndNormalizeQueuingStrategy(size, highWaterMark) { + if (size !== undefined && typeof size !== 'function') { + throw new TypeError(streamErrors.sizeNotAFunction); + } + highWaterMark = Number(highWaterMark); + if (Number_isNaN(highWaterMark)) { + throw new RangeError(streamErrors.errInvalidHWM); + } + if (highWaterMark < 0) { + throw new RangeError(streamErrors.invalidHWM); + } + return {size, highWaterMark}; + } + defineProperty(global, 'WritableStream', { + value: WritableStream, + enumerable: false, + configurable: true, + writable: true + }); +}); diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/snapshot_blob.bin b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/snapshot_blob.bin new file mode 100644 index 0000000..75eb706 Binary files /dev/null and b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/snapshot_blob.bin differ diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/widevinecdmadapter.dll b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/widevinecdmadapter.dll new file mode 100644 index 0000000..f0001de Binary files /dev/null and b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/CefSharp/widevinecdmadapter.dll differ diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/Helper.cs b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/Helper.cs deleted file mode 100644 index bd201f5..0000000 --- a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/Helper.cs +++ /dev/null @@ -1,50 +0,0 @@ -using System.IO; -using System.Text; -using Microsoft.Win32; - -namespace QuickLook.Plugin.HtmlViewer -{ - internal static class Helper - { - public static string FilePathToFileUrl(string filePath) - { - var uri = new StringBuilder(); - foreach (var v in filePath) - if (v >= 'a' && v <= 'z' || v >= 'A' && v <= 'Z' || v >= '0' && v <= '9' || - v == '+' || v == '/' || v == ':' || v == '.' || v == '-' || v == '_' || v == '~' || - v > '\xFF') - uri.Append(v); - else if (v == Path.DirectorySeparatorChar || v == Path.AltDirectorySeparatorChar) - uri.Append('/'); - else - uri.Append($"%{(int) v:X2}"); - if (uri.Length >= 2 && uri[0] == '/' && uri[1] == '/') // UNC path - uri.Insert(0, "file:"); - else - uri.Insert(0, "file:///"); - return uri.ToString(); - } - - public static void SetBrowserFeatureControl() - { - var exeName = Path.GetFileName(App.AppFullPath); - - // use latest engine - SetBrowserFeatureControlKey("FEATURE_BROWSER_EMULATION", exeName, 0); - // - SetBrowserFeatureControlKey("FEATURE_GPU_RENDERING", exeName, 0); - // turn on hi-dpi mode - SetBrowserFeatureControlKey("FEATURE_96DPI_PIXEL", exeName, 1); - } - - private static void SetBrowserFeatureControlKey(string feature, string appName, uint value) - { - using (var key = Registry.CurrentUser.CreateSubKey( - string.Concat(@"Software\Microsoft\Internet Explorer\Main\FeatureControl\", feature), - RegistryKeyPermissionCheck.ReadWriteSubTree)) - { - key?.SetValue(appName, value, RegistryValueKind.DWord); - } - } - } -} \ No newline at end of file diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/JsDialogHandler.cs b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/JsDialogHandler.cs new file mode 100644 index 0000000..01644d7 --- /dev/null +++ b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/JsDialogHandler.cs @@ -0,0 +1,36 @@ +// Copyright © 2010-2017 The CefSharp Authors. All rights reserved. +// +// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. + +using CefSharp; + +namespace QuickLook.Plugin.HtmlViewer +{ + public class JsDialogHandler : IJsDialogHandler + { + public bool OnJSDialog(IWebBrowser browserControl, IBrowser browser, string originUrl, + CefJsDialogType dialogType, string messageText, string defaultPromptText, IJsDialogCallback callback, + ref bool suppressMessage) + { + return true; + } + + public bool OnJSBeforeUnload(IWebBrowser browserControl, IBrowser browser, string message, bool isReload, + IJsDialogCallback callback) + { + //NOTE: No need to execute the callback if you return false + // callback.Continue(true); + + //NOTE: Returning false will trigger the default behaviour, you need to return true to handle yourself. + return true; + } + + public void OnResetDialogState(IWebBrowser browserControl, IBrowser browser) + { + } + + public void OnDialogClosed(IWebBrowser browserControl, IBrowser browser) + { + } + } +} \ No newline at end of file diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/MenuHandler.cs b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/MenuHandler.cs new file mode 100644 index 0000000..bbe364b --- /dev/null +++ b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/MenuHandler.cs @@ -0,0 +1,35 @@ +// Copyright © 2010-2017 The CefSharp Authors. All rights reserved. +// +// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. + +using CefSharp; + +namespace QuickLook.Plugin.HtmlViewer +{ + internal class MenuHandler : IContextMenuHandler + { + public void OnBeforeContextMenu(IWebBrowser browserControl, IBrowser browser, IFrame frame, + IContextMenuParams parameters, + IMenuModel model) + { + } + + public bool OnContextMenuCommand(IWebBrowser browserControl, IBrowser browser, IFrame frame, + IContextMenuParams parameters, + CefMenuCommand commandId, CefEventFlags eventFlags) + { + return false; + } + + public void OnContextMenuDismissed(IWebBrowser browserControl, IBrowser browser, IFrame frame) + { + } + + public bool RunContextMenu(IWebBrowser browserControl, IBrowser browser, IFrame frame, + IContextMenuParams parameters, + IMenuModel model, IRunContextMenuCallback callback) + { + return true; + } + } +} \ No newline at end of file diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/Plugin.cs b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/Plugin.cs index 1876273..448367d 100644 --- a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/Plugin.cs +++ b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/Plugin.cs @@ -1,16 +1,15 @@ using System; using System.IO; using System.Windows; -using System.Windows.Threading; namespace QuickLook.Plugin.HtmlViewer { public class Plugin : IViewer { - private WebpagePanel _panel; + private WebkitPanel _panel; public int Priority => int.MaxValue; - public bool AllowsTransparency => false; + public bool AllowsTransparency => true; public bool CanHandle(string path) { @@ -37,12 +36,12 @@ namespace QuickLook.Plugin.HtmlViewer public void View(string path, ContextObject context) { - _panel = new WebpagePanel(); + _panel = new WebkitPanel(); context.ViewerContent = _panel; context.Title = Path.IsPathRooted(path) ? Path.GetFileName(path) : path; _panel.Navigate(path); - _panel.Dispatcher.Invoke(() => { context.IsBusy = false; }, DispatcherPriority.Loaded); + context.IsBusy = false; } public void Cleanup() diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/QuickLook.Plugin.HtmlViewer.csproj b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/QuickLook.Plugin.HtmlViewer.csproj index e458db4..563bddf 100644 --- a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/QuickLook.Plugin.HtmlViewer.csproj +++ b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/QuickLook.Plugin.HtmlViewer.csproj @@ -35,10 +35,20 @@ MinimumRecommendedRules.ruleset - + + False + References\CefSharp.dll + + + False + References\CefSharp.Core.dll + + + False + References\CefSharp.Wpf.dll + - 4.0 @@ -47,18 +57,20 @@ - - + MSBuild:Compile Designer Properties\GitVersion.cs + + - - - WebpagePanel.xaml + + + + WebkitPanel.xaml Code @@ -66,6 +78,38 @@ Code + + Always + cef.pak + + + Always + cef_100_percent.pak + + + Always + cef_200_percent.pak + + + Always + cef_extensions.pak + + + Always + icudtl.dat + + + Always + locales\en-US.pak + + + Always + natives_blob.bin + + + Always + snapshot_blob.bin + @@ -75,15 +119,38 @@ - - {EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B} - 1 - 1 - 0 - tlbimp - False - True - + + Always + CefSharp.BrowserSubprocess.Core.dll + + + Always + CefSharp.BrowserSubprocess.exe + + + Always + chrome_elf.dll + + + Always + d3dcompiler_47.dll + + + Always + libcef.dll + + + Always + libEGL.dll + + + Always + libGLESv2.dll + + + Always + widevinecdmadapter.dll + \ No newline at end of file diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/RequestHandler.cs b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/RequestHandler.cs new file mode 100644 index 0000000..119b47a --- /dev/null +++ b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/RequestHandler.cs @@ -0,0 +1,113 @@ +// Copyright © 2010-2017 The CefSharp Authors. All rights reserved. +// +// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. + +using System.Security.Cryptography.X509Certificates; +using CefSharp; + +namespace QuickLook.Plugin.HtmlViewer +{ + public class RequestHandler : IRequestHandler + { + bool IRequestHandler.OnBeforeBrowse(IWebBrowser browserControl, IBrowser browser, IFrame frame, + IRequest request, bool isRedirect) + { + return request.TransitionType != TransitionType.Explicit; + } + + bool IRequestHandler.OnOpenUrlFromTab(IWebBrowser browserControl, IBrowser browser, IFrame frame, + string targetUrl, WindowOpenDisposition targetDisposition, bool userGesture) + { + return OnOpenUrlFromTab(browserControl, browser, frame, targetUrl, targetDisposition, userGesture); + } + + bool IRequestHandler.OnCertificateError(IWebBrowser browserControl, IBrowser browser, CefErrorCode errorCode, + string requestUrl, ISslInfo sslInfo, IRequestCallback callback) + { + callback.Dispose(); + return false; + } + + void IRequestHandler.OnPluginCrashed(IWebBrowser browserControl, IBrowser browser, string pluginPath) + { + } + + CefReturnValue IRequestHandler.OnBeforeResourceLoad(IWebBrowser browserControl, IBrowser browser, IFrame frame, + IRequest request, IRequestCallback callback) + { + return CefReturnValue.Continue; + } + + bool IRequestHandler.GetAuthCredentials(IWebBrowser browserControl, IBrowser browser, IFrame frame, + bool isProxy, string host, int port, string realm, string scheme, IAuthCallback callback) + { + callback.Dispose(); + return false; + } + + bool IRequestHandler.OnSelectClientCertificate(IWebBrowser browserControl, IBrowser browser, bool isProxy, + string host, int port, X509Certificate2Collection certificates, ISelectClientCertificateCallback callback) + { + //NOTE: If you do not wish to implement this method returning false is the default behaviour + // We also suggest you explicitly Dispose of the callback as it wraps an unmanaged resource. + + return OnSelectClientCertificate(browserControl, browser, isProxy, host, port, certificates, callback); + } + + void IRequestHandler.OnRenderProcessTerminated(IWebBrowser browserControl, IBrowser browser, + CefTerminationStatus status) + { + } + + bool IRequestHandler.OnQuotaRequest(IWebBrowser browserControl, IBrowser browser, string originUrl, + long newSize, IRequestCallback callback) + { + callback.Dispose(); + return false; + } + + void IRequestHandler.OnResourceRedirect(IWebBrowser browserControl, IBrowser browser, IFrame frame, + IRequest request, IResponse response, ref string newUrl) + { + } + + bool IRequestHandler.OnProtocolExecution(IWebBrowser browserControl, IBrowser browser, string url) + { + return false; + } + + void IRequestHandler.OnRenderViewReady(IWebBrowser browserControl, IBrowser browser) + { + } + + bool IRequestHandler.OnResourceResponse(IWebBrowser browserControl, IBrowser browser, IFrame frame, + IRequest request, IResponse response) + { + return false; + } + + IResponseFilter IRequestHandler.GetResourceResponseFilter(IWebBrowser browserControl, IBrowser browser, + IFrame frame, IRequest request, IResponse response) + { + return null; + } + + void IRequestHandler.OnResourceLoadComplete(IWebBrowser browserControl, IBrowser browser, IFrame frame, + IRequest request, IResponse response, UrlRequestStatus status, long receivedContentLength) + { + } + + protected virtual bool OnOpenUrlFromTab(IWebBrowser browserControl, IBrowser browser, IFrame frame, + string targetUrl, WindowOpenDisposition targetDisposition, bool userGesture) + { + return false; + } + + protected virtual bool OnSelectClientCertificate(IWebBrowser browserControl, IBrowser browser, bool isProxy, + string host, int port, X509Certificate2Collection certificates, ISelectClientCertificateCallback callback) + { + callback.Dispose(); + return false; + } + } +} \ No newline at end of file diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/UrlHelper.cs b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/UrlHelper.cs new file mode 100644 index 0000000..b49bc8b --- /dev/null +++ b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/UrlHelper.cs @@ -0,0 +1,27 @@ +using System.IO; +using System.Text; + +namespace QuickLook.Plugin.HtmlViewer +{ + internal static class UrlHelper + { + internal static string FilePathToFileUrl(string filePath) + { + var uri = new StringBuilder(); + foreach (var v in filePath) + if (v >= 'a' && v <= 'z' || v >= 'A' && v <= 'Z' || v >= '0' && v <= '9' || + v == '+' || v == '/' || v == ':' || v == '.' || v == '-' || v == '_' || v == '~' || + v > '\xFF') + uri.Append(v); + else if (v == Path.DirectorySeparatorChar || v == Path.AltDirectorySeparatorChar) + uri.Append('/'); + else + uri.Append($"%{(int) v:X2}"); + if (uri.Length >= 2 && uri[0] == '/' && uri[1] == '/') // UNC path + uri.Insert(0, "file:"); + else + uri.Insert(0, "file:///"); + return uri.ToString(); + } + } +} \ No newline at end of file diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/WebpagePanel.xaml b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/WebkitPanel.xaml similarity index 72% rename from QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/WebpagePanel.xaml rename to QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/WebkitPanel.xaml index 93268d0..edd7fe1 100644 --- a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/WebpagePanel.xaml +++ b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/WebkitPanel.xaml @@ -1,12 +1,13 @@ - - + \ No newline at end of file diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/WebkitPanel.xaml.cs b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/WebkitPanel.xaml.cs new file mode 100644 index 0000000..d03678c --- /dev/null +++ b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/WebkitPanel.xaml.cs @@ -0,0 +1,63 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Reflection; +using System.Windows; +using System.Windows.Controls; +using CefSharp; + +namespace QuickLook.Plugin.HtmlViewer +{ + /// + /// Interaction logic for UserControl1.xaml + /// + public partial class WebkitPanel : UserControl, IDisposable + { + private readonly string _cefPath = + Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)); + + public WebkitPanel() + { + var libraryLoader = new CefLibraryHandle(Path.Combine(_cefPath, "libcef.dll")); + + if (!Cef.IsInitialized) + Cef.Initialize(new CefSettings + { + BrowserSubprocessPath = Path.Combine(_cefPath, "CefSharp.BrowserSubprocess.exe"), + LocalesDirPath = Path.Combine(_cefPath, "locales"), + ResourcesDirPath = _cefPath, + LogSeverity = LogSeverity.Disable, + CefCommandLineArgs = {new KeyValuePair("disable-gpu", "1")} + }); + + InitializeComponent(); + + Application.Current.Exit += (sender, e) => Cef.Shutdown(); + + browser.RequestHandler = new RequestHandler(); + browser.MenuHandler = new MenuHandler(); + browser.JsDialogHandler = new JsDialogHandler(); + } + + public void Dispose() + { + browser?.Dispose(); + } + + public void Navigate(string path) + { + if (Path.IsPathRooted(path)) + path = UrlHelper.FilePathToFileUrl(path); + + browser.IsBrowserInitializedChanged += (sender, e) => browser.Load(path); + } + + public void LoadHtml(string html, string path) + { + if (Path.IsPathRooted(path)) + path = UrlHelper.FilePathToFileUrl(path); + + browser.IsBrowserInitializedChanged += (sender, e) => browser.LoadHtml(html, path); + } + } +} \ No newline at end of file diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/WebpagePanel.xaml.cs b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/WebpagePanel.xaml.cs deleted file mode 100644 index acadbbd..0000000 --- a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/WebpagePanel.xaml.cs +++ /dev/null @@ -1,42 +0,0 @@ -using System; -using System.IO; -using System.Text; -using System.Windows.Controls; -using System.Windows.Threading; - -namespace QuickLook.Plugin.HtmlViewer -{ - /// - /// Interaction logic for UserControl1.xaml - /// - public partial class WebpagePanel : UserControl, IDisposable - { - public WebpagePanel() - { - InitializeComponent(); - - Helper.SetBrowserFeatureControl(); - } - - public void Dispose() - { - browser?.Dispose(); - browser = null; - } - - public void Navigate(string path) - { - if (Path.IsPathRooted(path)) - path = Helper.FilePathToFileUrl(path); - - browser.Dispatcher.Invoke(() => { browser.Navigate(path); }, DispatcherPriority.Loaded); - } - - public void LoadHtml(string html) - { - var s = new MemoryStream(Encoding.UTF8.GetBytes(html ?? "")); - - browser.Dispatcher.Invoke(() => { browser.Navigate(s); }, DispatcherPriority.Loaded); - } - } -} \ No newline at end of file diff --git a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/WpfBrowserWrapper.cs b/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/WpfBrowserWrapper.cs deleted file mode 100644 index c60c14e..0000000 --- a/QuickLook.Plugin/QuickLook.Plugin.HtmlViewer/WpfBrowserWrapper.cs +++ /dev/null @@ -1,230 +0,0 @@ -using System; -using System.Diagnostics; -using System.IO; -using System.Reflection; -using System.Runtime.InteropServices; -using System.Windows; -using System.Windows.Controls; -using System.Windows.Forms; -using System.Windows.Navigation; -using SHDocVw; -using HorizontalAlignment = System.Windows.HorizontalAlignment; -using WebBrowser = System.Windows.Controls.WebBrowser; - -namespace QuickLook.Plugin.HtmlViewer -{ - /// - /// Class wraps a Browser (which itself is a bad designed WPF control) and presents itself as - /// a better designed WPF control. For example provides a bindable source property or commands. - /// - public class WpfWebBrowserWrapper : ContentControl, IDisposable - { - private static readonly Guid SidSWebBrowserApp = new Guid("0002DF05-0000-0000-C000-000000000046"); - - private WebBrowser _innerBrowser; - private bool _loaded; - private int _zoom; - - public WpfWebBrowserWrapper() - { - _innerBrowser = new WebBrowser - { - HorizontalAlignment = HorizontalAlignment.Stretch, - VerticalAlignment = VerticalAlignment.Stretch - }; - - Content = _innerBrowser; - _innerBrowser.Navigated += InnerBrowserNavigated; - _innerBrowser.Navigating += InnerBrowserNavigating; - _innerBrowser.LoadCompleted += InnerBrowserLoadCompleted; - _innerBrowser.Loaded += InnerBrowserLoaded; - _innerBrowser.SizeChanged += InnerBrowserSizeChanged; - } - - public string Url { get; private set; } - - public int Zoom - { - get => _zoom; - set - { - _zoom = value; - ApplyZoom(); - } - } - - - // gets the browser control's underlying activeXcontrol. Ready only from within Loaded-event but before loaded Document! - // do not use prior loaded event. - public InternetExplorer ActiveXControl - { - get - { - // this is a brilliant way to access the WebBrowserObject prior to displaying the actual document (eg. Document property) - var fiComWebBrowser = - typeof(WebBrowser).GetField("_axIWebBrowser2", BindingFlags.Instance | BindingFlags.NonPublic); - if (fiComWebBrowser == null) return null; - var objComWebBrowser = fiComWebBrowser.GetValue(_innerBrowser); - return objComWebBrowser as InternetExplorer; - } - } - - public void Dispose() - { - _innerBrowser.Source = null; - _innerBrowser.Dispose(); - _innerBrowser = null; - Content = null; - } - - private void InnerBrowserSizeChanged(object sender, SizeChangedEventArgs e) - { - ApplyZoom(); - } - - private void InnerBrowserLoaded(object sender, EventArgs e) - { - // make browser control not silent: allow HTTP-Auth-dialogs. Requery command availability - var ie = ActiveXControl; - ie.Silent = true; - } - - // called when the loading of a web page is done - private void InnerBrowserLoadCompleted(object sender, NavigationEventArgs e) - { - ApplyZoom(); // apply later and not only at changed event, since only works if browser is rendered. - } - - // called when the browser started to load and retrieve data. - private void InnerBrowserNavigating(object sender, NavigatingCancelEventArgs e) - { - if (_loaded) - e.Cancel = true; - _loaded = true; - } - - // re query the commands once done navigating. - private void InnerBrowserNavigated(object sender, NavigationEventArgs e) - { - RegisterWindowErrorHanlder_(); - } - - public void Navigate(string uri) - { - Url = uri; - - if (_innerBrowser == null) - return; - - if (!string.IsNullOrWhiteSpace(uri) && Uri.IsWellFormedUriString(uri, UriKind.Absolute)) - try - { - _innerBrowser.Source = new Uri(uri); - } - catch (UriFormatException) - { - // just don't crash because of a malformed url - } - else - _innerBrowser.Source = null; - } - - public void Navigate(Stream stream) - { - if (_innerBrowser == null) - return; - - try - { - _innerBrowser.NavigateToStream(stream); - } - catch (Exception) - { - // ignored - } - } - - // register script errors handler on DOM - document.window - private void RegisterWindowErrorHanlder_() - { - object parwin = ((dynamic) _innerBrowser.Document).parentWindow; - var cookie = new AxHost.ConnectionPointCookie(parwin, new HtmlWindowEvents2Impl(this), - typeof(IIntHTMLWindowEvents2)); - // MemoryLEAK? No: cookie has a Finalize() to Disconnect istelf. We'll rely on that. If disconnected too early, - // though (eg. in LoadCompleted-event) scripts continue to run and can cause error messages to appear again. - // --> forget cookie and be happy. - } - - private void ApplyZoom() - { - if (_innerBrowser == null || !_innerBrowser.IsLoaded) - return; - - // grab a handle to the underlying ActiveX object - IServiceProvider serviceProvider = null; - if (_innerBrowser.Document != null) - serviceProvider = (IServiceProvider) _innerBrowser.Document; - if (serviceProvider == null) - return; - - var serviceGuid = SidSWebBrowserApp; - var iid = typeof(IWebBrowser2).GUID; - var browserInst = - (IWebBrowser2) serviceProvider.QueryService(ref serviceGuid, ref iid); - - try - { - object zoomPercObj = _zoom; - // send the zoom command to the ActiveX object - browserInst.ExecWB(OLECMDID.OLECMDID_OPTICAL_ZOOM, - OLECMDEXECOPT.OLECMDEXECOPT_DONTPROMPTUSER, - ref zoomPercObj, - IntPtr.Zero); - } - catch (Exception) - { - // ignore this dynamic call if it fails. - } - } - - // needed to implement the Event for script errors - [Guid("3050f625-98b5-11cf-bb82-00aa00bdce0b")] - [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)] - [TypeLibType(TypeLibTypeFlags.FHidden)] - [ComImport] - private interface IIntHTMLWindowEvents2 - { - [DispId(1002)] - bool onerror(string description, string url, int line); - } - - // needed to implement the Event for script errors - private class HtmlWindowEvents2Impl : IIntHTMLWindowEvents2 - { - private readonly WpfWebBrowserWrapper _control; - - public HtmlWindowEvents2Impl(WpfWebBrowserWrapper control) - { - _control = control; - } - - // implementation of the onerror Javascript error. Return true to indicate a "Handled" state. - public bool onerror(string description, string urlString, int line) - { - Debug.WriteLine(description + "@" + urlString + ": " + line); - // Handled: - return true; - } - } - - // Needed to expose the WebBrowser's underlying ActiveX control for zoom functionality - [ComImport] - [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] - [Guid("6d5140c1-7436-11ce-8034-00aa006009fa")] - internal interface IServiceProvider - { - [return: MarshalAs(UnmanagedType.IUnknown)] - object QueryService(ref Guid guidService, ref Guid riid); - } - } -} \ No newline at end of file diff --git a/QuickLook.Plugin/QuickLook.Plugin.MarkdownViewer/Plugin.cs b/QuickLook.Plugin/QuickLook.Plugin.MarkdownViewer/Plugin.cs index 8db0618..c40f1e4 100644 --- a/QuickLook.Plugin/QuickLook.Plugin.MarkdownViewer/Plugin.cs +++ b/QuickLook.Plugin/QuickLook.Plugin.MarkdownViewer/Plugin.cs @@ -1,17 +1,16 @@ using System; using System.IO; using System.Windows; -using System.Windows.Threading; using QuickLook.Plugin.HtmlViewer; namespace QuickLook.Plugin.MarkdownViewer { public class Plugin : IViewer { - private WebpagePanel _panel; + private WebkitPanel _panel; public int Priority => int.MaxValue; - public bool AllowsTransparency => false; + public bool AllowsTransparency => true; public bool CanHandle(string path) { @@ -21,7 +20,6 @@ namespace QuickLook.Plugin.MarkdownViewer switch (Path.GetExtension(path).ToLower()) { case ".md": - case ".rmd": return true; default: @@ -38,12 +36,13 @@ namespace QuickLook.Plugin.MarkdownViewer public void View(string path, ContextObject context) { - _panel = new WebpagePanel(); + _panel = new WebkitPanel(); context.ViewerContent = _panel; context.Title = Path.GetFileName(path); - _panel.LoadHtml(GenerateMarkdownHtml(path)); - _panel.Dispatcher.Invoke(() => { context.IsBusy = false; }, DispatcherPriority.Loaded); + _panel.LoadHtml(GenerateMarkdownHtml(path), path); + + context.IsBusy = false; } public void Cleanup()