ah)throw B(172);
+var ag=(am===(void 0))
+?ah-ai
+:am;
+if(ag<0||ai+ag>ah){
+throw new B(171);
+}
+var aT=%NewObject(h,new.target);
+%_DataViewInitialize(aT,ae,ai,ag);
+return aT;
+}
+function DataViewGetBufferJS(){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,'DataView.buffer',this);
+}
+return %DataViewGetBuffer(this);
+}
+function DataViewGetByteOffset(){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.byteOffset',this);
+}
+return %_ArrayBufferViewGetByteOffset(this);
+}
+function DataViewGetByteLength(){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.byteLength',this);
+}
+return %_ArrayBufferViewGetByteLength(this);
+}
+function DataViewGetInt8JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getInt8',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetInt8(this,ai,!!br);
+}
+function DataViewSetInt8JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setInt8',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetInt8(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetUint8JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getUint8',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetUint8(this,ai,!!br);
+}
+function DataViewSetUint8JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setUint8',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetUint8(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetInt16JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getInt16',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetInt16(this,ai,!!br);
+}
+function DataViewSetInt16JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setInt16',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetInt16(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetUint16JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getUint16',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetUint16(this,ai,!!br);
+}
+function DataViewSetUint16JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setUint16',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetUint16(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetInt32JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getInt32',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetInt32(this,ai,!!br);
+}
+function DataViewSetInt32JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setInt32',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetInt32(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetUint32JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getUint32',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetUint32(this,ai,!!br);
+}
+function DataViewSetUint32JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setUint32',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetUint32(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetFloat32JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getFloat32',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetFloat32(this,ai,!!br);
+}
+function DataViewSetFloat32JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setFloat32',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetFloat32(this,ai,(%_ToNumber(av)),!!br);
+}
+
+function DataViewGetFloat64JS(ai,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.getFloat64',this);
+}
+if(%_ArgumentsLength()<1)throw C(45);
+ai=H(ai,170);
+return %DataViewGetFloat64(this,ai,!!br);
+}
+function DataViewSetFloat64JS(ai,av,br){
+if(!(%_ClassOf(this)==='DataView')){
+throw C(42,
+'DataView.setFloat64',this);
+}
+if(%_ArgumentsLength()<2)throw C(45);
+ai=H(ai,170);
+%DataViewSetFloat64(this,ai,(%_ToNumber(av)),!!br);
+}
+
+
+%SetCode(h,DataViewConstructor);
+%FunctionSetPrototype(h,new i);
+%AddNamedProperty(h.prototype,"constructor",h,
+2);
+%AddNamedProperty(h.prototype,J,"DataView",
+1|2);
+b.InstallGetter(h.prototype,"buffer",DataViewGetBufferJS);
+b.InstallGetter(h.prototype,"byteOffset",
+DataViewGetByteOffset);
+b.InstallGetter(h.prototype,"byteLength",
+DataViewGetByteLength);
+b.InstallFunctions(h.prototype,2,[
+"getInt8",DataViewGetInt8JS,
+"setInt8",DataViewSetInt8JS,
+"getUint8",DataViewGetUint8JS,
+"setUint8",DataViewSetUint8JS,
+"getInt16",DataViewGetInt16JS,
+"setInt16",DataViewSetInt16JS,
+"getUint16",DataViewGetUint16JS,
+"setUint16",DataViewSetUint16JS,
+"getInt32",DataViewGetInt32JS,
+"setInt32",DataViewSetInt32JS,
+"getUint32",DataViewGetUint32JS,
+"setUint32",DataViewSetUint32JS,
+"getFloat32",DataViewGetFloat32JS,
+"setFloat32",DataViewSetFloat32JS,
+"getFloat64",DataViewGetFloat64JS,
+"setFloat64",DataViewSetFloat64JS
+]);
+})
+
+Hiterator-prototype
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Object;
+var d=b.ImportNow("IteratorPrototype");
+var e=b.ImportNow("iterator_symbol");
+function IteratorPrototypeIterator(){
+return this;
+}
+b.SetFunctionName(IteratorPrototypeIterator,e);
+%AddNamedProperty(d,e,
+IteratorPrototypeIterator,2);
+})
+
+$generator
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=b.ImportNow("GeneratorFunctionPrototype");
+var d=b.ImportNow("GeneratorFunction");
+var e=a.Function;
+var f;
+var g=b.ImportNow("to_string_tag_symbol");
+b.Import(function(h){
+f=h.MakeTypeError;
+});
+function GeneratorObjectNext(i){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(42,
+'[Generator].prototype.next',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+if(%_DebugIsActive()!=0)%DebugPrepareStepInIfStepping(this);
+try{
+return %_GeneratorNext(this,i);
+}catch(e){
+%GeneratorClose(this);
+throw e;
+}
+}else if(j==0){
+return{value:void 0,done:true};
+}else{
+throw f(40);
+}
+}
+function GeneratorObjectThrow(k){
+if(!(%_ClassOf(this)==='Generator')){
+throw f(42,
+'[Generator].prototype.throw',this);
+}
+var j=%GeneratorGetContinuation(this);
+if(j>0){
+try{
+return %_GeneratorThrow(this,k);
+}catch(e){
+%GeneratorClose(this);
+throw e;
+}
+}else if(j==0){
+throw k;
+}else{
+throw f(40);
+}
+}
+%NeverOptimizeFunction(GeneratorObjectNext);
+%NeverOptimizeFunction(GeneratorObjectThrow);
+var l=c.prototype;
+b.InstallFunctions(l,
+2,
+["next",GeneratorObjectNext,
+"throw",GeneratorObjectThrow]);
+%AddNamedProperty(l,"constructor",
+c,2|1);
+%AddNamedProperty(l,
+g,"Generator",2|1);
+%InternalSetPrototype(c,e.prototype);
+%AddNamedProperty(c,
+g,"GeneratorFunction",2|1);
+%AddNamedProperty(c,"constructor",
+d,2|1);
+%InternalSetPrototype(d,e);
+})
+
+8object-observeѭ
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c;
+var d=a.Array;
+var e=a.Object;
+var f=b.InternalArray;
+var g;
+b.Import(function(h){
+c=h.GetHash;
+g=h.MakeTypeError;
+});
+var i;
+var j={};
+function GetObservationStateJS(){
+if((i===(void 0))){
+i=%GetObservationState();
+}
+if((i.callbackInfoMap===(void 0))){
+i.callbackInfoMap=%ObservationWeakMapCreate();
+i.objectInfoMap=%ObservationWeakMapCreate();
+i.notifierObjectInfoMap=%ObservationWeakMapCreate();
+i.pendingObservers=null;
+i.nextCallbackPriority=0;
+i.lastMicrotaskId=0;
+}
+return i;
+}
+function GetPendingObservers(){
+return GetObservationStateJS().pendingObservers;
+}
+function SetPendingObservers(k){
+GetObservationStateJS().pendingObservers=k;
+}
+function GetNextCallbackPriority(){
+return GetObservationStateJS().nextCallbackPriority++;
+}
+function nullProtoObject(){
+return{__proto__:null};
+}
+function TypeMapCreate(){
+return nullProtoObject();
+}
+function TypeMapAddType(l,m,n){
+l[m]=n?1:(l[m]||0)+1;
+}
+function TypeMapRemoveType(l,m){
+l[m]--;
+}
+function TypeMapCreateFromList(o,p){
+var l=TypeMapCreate();
+for(var q=0;q0?y.performing:null;
+}
+function ConvertAcceptListToTypeMap(E){
+if((E===(void 0)))
+return E;
+if(!(%_IsJSReceiver(E)))throw g(80);
+var F=(%_ToInteger(E.length));
+if(F<0)F=0;
+return TypeMapCreateFromList(E,F);
+}
+function CallbackInfoGet(v){
+return %WeakCollectionGet(GetObservationStateJS().callbackInfoMap,v,
+c(v));
+}
+function CallbackInfoSet(v,C){
+%WeakCollectionSet(GetObservationStateJS().callbackInfoMap,
+v,C,c(v));
+}
+function CallbackInfoGetOrCreate(v){
+var C=CallbackInfoGet(v);
+if(!(C===(void 0)))
+return C;
+var D=GetNextCallbackPriority();
+CallbackInfoSet(v,D);
+return D;
+}
+function CallbackInfoGetPriority(C){
+if((typeof(C)==='number'))
+return C;
+else
+return C.priority;
+}
+function CallbackInfoNormalize(v){
+var C=CallbackInfoGet(v);
+if((typeof(C)==='number')){
+var D=C;
+C=new f;
+C.priority=D;
+CallbackInfoSet(v,C);
+}
+return C;
+}
+function ObjectObserve(z,v,w){
+if(!(%_IsJSReceiver(z)))
+throw g(82,"observe","observe");
+if(%IsJSGlobalProxy(z))
+throw g(78,"observe");
+if(%IsAccessCheckNeeded(z))
+throw g(79,"observe");
+if(!(typeof(v)==='function'))
+throw g(81,"observe");
+if(%object_is_frozen(v))
+throw g(77);
+var G=%GetObjectContextObjectObserve(z);
+return G(z,v,w);
+}
+function NativeObjectObserve(z,v,w){
+var y=ObjectInfoGetOrCreate(z);
+var o=ConvertAcceptListToTypeMap(w);
+ObjectInfoAddObserver(y,v,o);
+return z;
+}
+function ObjectUnobserve(z,v){
+if(!(%_IsJSReceiver(z)))
+throw g(82,"unobserve","unobserve");
+if(%IsJSGlobalProxy(z))
+throw g(78,"unobserve");
+if(!(typeof(v)==='function'))
+throw g(81,"unobserve");
+var y=ObjectInfoGet(z);
+if((y===(void 0)))
+return z;
+ObjectInfoRemoveObserver(y,v);
+return z;
+}
+function ArrayObserve(z,v){
+return ObjectObserve(z,v,['add',
+'update',
+'delete',
+'splice']);
+}
+function ArrayUnobserve(z,v){
+return ObjectUnobserve(z,v);
+}
+function ObserverEnqueueIfActive(x,y,H){
+if(!ObserverIsActive(x,y)||
+!TypeMapHasType(ObserverGetAcceptTypes(x),H.type)){
+return;
+}
+var v=ObserverGetCallback(x);
+if(!%ObserverObjectAndRecordHaveSameOrigin(v,H.object,
+H)){
+return;
+}
+var C=CallbackInfoNormalize(v);
+if((GetPendingObservers()===null)){
+SetPendingObservers(nullProtoObject());
+if((%_DebugIsActive()!=0)){
+var I=++GetObservationStateJS().lastMicrotaskId;
+var J="Object.observe";
+%EnqueueMicrotask(function(){
+%DebugAsyncTaskEvent({type:"willHandle",id:I,name:J});
+ObserveMicrotaskRunner();
+%DebugAsyncTaskEvent({type:"didHandle",id:I,name:J});
+});
+%DebugAsyncTaskEvent({type:"enqueue",id:I,name:J});
+}else{
+%EnqueueMicrotask(ObserveMicrotaskRunner);
+}
+}
+GetPendingObservers()[C.priority]=v;
+C.push(H);
+}
+function ObjectInfoEnqueueExternalChangeRecord(y,H,m){
+if(!ObjectInfoHasActiveObservers(y))
+return;
+var K=!(m===(void 0));
+var L=K?
+{object:y.object,type:m}:
+{object:y.object};
+for(var M in H){
+if(M==='object'||(K&&M==='type'))continue;
+%DefineDataPropertyUnchecked(
+L,M,H[M],1+4);
+}
+%object_freeze(L);
+ObjectInfoEnqueueInternalChangeRecord(y,L);
+}
+function ObjectInfoEnqueueInternalChangeRecord(y,H){
+if((typeof(H.name)==='symbol'))return;
+if(ChangeObserversIsOptimized(y.changeObservers)){
+var x=y.changeObservers;
+ObserverEnqueueIfActive(x,y,H);
+return;
+}
+for(var D in y.changeObservers){
+var x=y.changeObservers[D];
+if((x===null))
+continue;
+ObserverEnqueueIfActive(x,y,H);
+}
+}
+function BeginPerformSplice(N){
+var y=ObjectInfoGet(N);
+if(!(y===(void 0)))
+ObjectInfoAddPerformingType(y,'splice');
+}
+function EndPerformSplice(N){
+var y=ObjectInfoGet(N);
+if(!(y===(void 0)))
+ObjectInfoRemovePerformingType(y,'splice');
+}
+function EnqueueSpliceRecord(N,O,P,Q){
+var y=ObjectInfoGet(N);
+if(!ObjectInfoHasActiveObservers(y))
+return;
+var H={
+type:'splice',
+object:N,
+index:O,
+removed:P,
+addedCount:Q
+};
+%object_freeze(H);
+%object_freeze(H.removed);
+ObjectInfoEnqueueInternalChangeRecord(y,H);
+}
+function NotifyChange(m,z,J,R){
+var y=ObjectInfoGet(z);
+if(!ObjectInfoHasActiveObservers(y))
+return;
+var H;
+if(arguments.length==2){
+H={type:m,object:z};
+}else if(arguments.length==3){
+H={type:m,object:z,name:J};
+}else{
+H={
+type:m,
+object:z,
+name:J,
+oldValue:R
+};
+}
+%object_freeze(H);
+ObjectInfoEnqueueInternalChangeRecord(y,H);
+}
+function ObjectNotifierNotify(H){
+if(!(%_IsJSReceiver(this)))
+throw g(16,"notify");
+var y=ObjectInfoGetFromNotifier(this);
+if((y===(void 0)))
+throw g(83);
+if(!(typeof(H.type)==='string'))
+throw g(86);
+ObjectInfoEnqueueExternalChangeRecord(y,H);
+}
+function ObjectNotifierPerformChange(S,T){
+if(!(%_IsJSReceiver(this)))
+throw g(16,"performChange");
+var y=ObjectInfoGetFromNotifier(this);
+if((y===(void 0)))
+throw g(83);
+if(!(typeof(S)==='string'))
+throw g(85);
+if(!(typeof(T)==='function'))
+throw g(84);
+var U=%GetObjectContextNotifierPerformChange(y);
+U(y,S,T);
+}
+function NativeObjectNotifierPerformChange(y,S,T){
+ObjectInfoAddPerformingType(y,S);
+var H;
+try{
+H=T();
+}finally{
+ObjectInfoRemovePerformingType(y,S);
+}
+if((%_IsJSReceiver(H)))
+ObjectInfoEnqueueExternalChangeRecord(y,H,S);
+}
+function ObjectGetNotifier(z){
+if(!(%_IsJSReceiver(z)))
+throw g(82,"getNotifier","getNotifier");
+if(%IsJSGlobalProxy(z))
+throw g(78,"getNotifier");
+if(%IsAccessCheckNeeded(z))
+throw g(79,"getNotifier");
+if(%object_is_frozen(z))return null;
+if(!%ObjectWasCreatedInCurrentOrigin(z))return null;
+var V=%GetObjectContextObjectGetNotifier(z);
+return V(z);
+}
+function NativeObjectGetNotifier(z){
+var y=ObjectInfoGetOrCreate(z);
+return ObjectInfoGetNotifier(y);
+}
+function CallbackDeliverPending(v){
+var C=CallbackInfoGet(v);
+if((C===(void 0))||(typeof(C)==='number'))
+return false;
+var D=C.priority;
+CallbackInfoSet(v,D);
+var k=GetPendingObservers();
+if(!(k===null))
+delete k[D];
+var W=[];
+%MoveArrayContents(C,W);
+%DeliverObservationChangeRecords(v,W);
+return true;
+}
+function ObjectDeliverChangeRecords(v){
+if(!(typeof(v)==='function'))
+throw g(81,"deliverChangeRecords");
+while(CallbackDeliverPending(v)){}
+}
+function ObserveMicrotaskRunner(){
+var k=GetPendingObservers();
+if(!(k===null)){
+SetPendingObservers(null);
+for(var q in k){
+CallbackDeliverPending(k[q]);
+}
+}
+}
+b.InstallFunctions(j,2,[
+"notify",ObjectNotifierNotify,
+"performChange",ObjectNotifierPerformChange
+]);
+var X=[
+"deliverChangeRecords",ObjectDeliverChangeRecords,
+"getNotifier",ObjectGetNotifier,
+"observe",ObjectObserve,
+"unobserve",ObjectUnobserve
+];
+var Y=[
+"observe",ArrayObserve,
+"unobserve",ArrayUnobserve
+];
+var Z=function(aa,q){
+if(q % 2===1)%FunctionRemovePrototype(aa);
+};
+X.forEach(Z);
+Y.forEach(Z);
+%InstallToContext([
+"native_object_get_notifier",NativeObjectGetNotifier,
+"native_object_notifier_perform_change",NativeObjectNotifierPerformChange,
+"native_object_observe",NativeObjectObserve,
+"observers_begin_perform_splice",BeginPerformSplice,
+"observers_end_perform_splice",EndPerformSplice,
+"observers_enqueue_splice",EnqueueSpliceRecord,
+"observers_notify_change",NotifyChange,
+]);
+b.Export(function(ab){
+ab.ObserveArrayMethods=Y;
+ab.ObserveBeginPerformSplice=BeginPerformSplice;
+ab.ObserveEndPerformSplice=EndPerformSplice;
+ab.ObserveEnqueueSpliceRecord=EnqueueSpliceRecord;
+ab.ObserveObjectMethods=X;
+});
+})
+
+(collectionE}
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Map;
+var d=a.Object;
+var e=a.Set;
+var f=b.ImportNow("hash_code_symbol");
+var g;
+var h;
+var i;
+var j;
+var k;
+var l=b.ImportNow("to_string_tag_symbol");
+b.Import(function(m){
+g=m.IntRandom;
+h=m.MakeTypeError;
+i=m.MapIterator;
+j=m.NumberIsNaN;
+k=m.SetIterator;
+});
+function HashToEntry(n,o,p){
+var q=(o&((p)-1));
+return((%_FixedArrayGet(n,(3+(q))|0)));
+}
+%SetForceInlineFlag(HashToEntry);
+function SetFindEntry(n,p,r,o){
+var s=HashToEntry(n,o,p);
+if(s===-1)return s;
+var t=((%_FixedArrayGet(n,((3+(p)+((s)<<1)))|0)));
+if(r===t)return s;
+var u=j(r);
+while(true){
+if(u&&j(t)){
+return s;
+}
+s=((%_FixedArrayGet(n,((3+(p)+((s)<<1))+1)|0)));
+if(s===-1)return s;
+t=((%_FixedArrayGet(n,((3+(p)+((s)<<1)))|0)));
+if(r===t)return s;
+}
+return-1;
+}
+%SetForceInlineFlag(SetFindEntry);
+function MapFindEntry(n,p,r,o){
+var s=HashToEntry(n,o,p);
+if(s===-1)return s;
+var t=((%_FixedArrayGet(n,((3+(p)+((s)*3)))|0)));
+if(r===t)return s;
+var u=j(r);
+while(true){
+if(u&&j(t)){
+return s;
+}
+s=((%_FixedArrayGet(n,((3+(p)+((s)*3))+2)|0)));
+if(s===-1)return s;
+t=((%_FixedArrayGet(n,((3+(p)+((s)*3)))|0)));
+if(r===t)return s;
+}
+return-1;
+}
+%SetForceInlineFlag(MapFindEntry);
+function ComputeIntegerHash(r,v){
+var o=r;
+o=o^v;
+o=~o+(o<<15);
+o=o^(o>>>12);
+o=o+(o<<2);
+o=o^(o>>>4);
+o=(o*2057)|0;
+o=o^(o>>>16);
+return o&0x3fffffff;
+}
+%SetForceInlineFlag(ComputeIntegerHash);
+function GetExistingHash(r){
+if(%_IsSmi(r)){
+return ComputeIntegerHash(r,0);
+}
+if((typeof(r)==='string')){
+var w=%_StringGetRawHashField(r);
+if((w&1)===0){
+return w>>>2;
+}
+}else if((%_IsJSReceiver(r))&&!(%_IsJSProxy(r))&&!(%_ClassOf(r)==='global')){
+var o=(r[f]);
+return o;
+}
+return %GenericHash(r);
+}
+%SetForceInlineFlag(GetExistingHash);
+function GetHash(r){
+var o=GetExistingHash(r);
+if((o===(void 0))){
+o=g()|0;
+if(o===0)o=1;
+(r[f]=o);
+}
+return o;
+}
+%SetForceInlineFlag(GetHash);
+function SetConstructor(x){
+if((new.target===(void 0))){
+throw h(26,"Set");
+}
+%_SetInitialize(this);
+if(!(x==null)){
+var y=this.add;
+if(!(typeof(y)==='function')){
+throw h(91,y,'add',this);
+}
+for(var z of x){
+%_Call(y,this,z);
+}
+}
+}
+function SetAdd(r){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,'Set.prototype.add',this);
+}
+if(r===0){
+r=0;
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+if(SetFindEntry(n,p,r,o)!==-1)return this;
+var A=((%_FixedArrayGet(n,(1)|0)));
+var B=((%_FixedArrayGet(n,(2)|0)));
+var C=p<<1;
+if((A+B)>=C){
+%SetGrow(this);
+n=%_JSCollectionGetTable(this);
+p=((%_FixedArrayGet(n,(0)|0)));
+A=((%_FixedArrayGet(n,(1)|0)));
+B=((%_FixedArrayGet(n,(2)|0)));
+}
+var s=A+B;
+var D=(3+(p)+((s)<<1));
+var q=(o&((p)-1));
+var E=((%_FixedArrayGet(n,(3+(q))|0)));
+((%_FixedArraySet(n,(3+(q))|0,s)));
+(((%_FixedArraySet(n,(1)|0,(A+1)|0))));
+(%_FixedArraySet(n,(D)|0,r));
+((%_FixedArraySet(n,(D+1)|0,(E)|0)));
+return this;
+}
+function SetHas(r){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,'Set.prototype.has',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetExistingHash(r);
+if((o===(void 0)))return false;
+return SetFindEntry(n,p,r,o)!==-1;
+}
+function SetDelete(r){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,
+'Set.prototype.delete',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetExistingHash(r);
+if((o===(void 0)))return false;
+var s=SetFindEntry(n,p,r,o);
+if(s===-1)return false;
+var A=((%_FixedArrayGet(n,(1)|0)))-1;
+var B=((%_FixedArrayGet(n,(2)|0)))+1;
+var D=(3+(p)+((s)<<1));
+(%_FixedArraySet(n,(D)|0,%_TheHole()));
+(((%_FixedArraySet(n,(1)|0,(A)|0))));
+(((%_FixedArraySet(n,(2)|0,(B)|0))));
+if(A<(p>>>1))%SetShrink(this);
+return true;
+}
+function SetGetSize(){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,
+'Set.prototype.size',this);
+}
+var n=%_JSCollectionGetTable(this);
+return((%_FixedArrayGet(n,(1)|0)));
+}
+function SetClearJS(){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,
+'Set.prototype.clear',this);
+}
+%_SetClear(this);
+}
+function SetForEach(F,G){
+if(!(%_ClassOf(this)==='Set')){
+throw h(42,
+'Set.prototype.forEach',this);
+}
+if(!(typeof(F)==='function'))throw h(15,F);
+var H=new k(this,2);
+var r;
+var I=[(void 0)];
+while(%SetIteratorNext(H,I)){
+r=I[0];
+%_Call(F,G,r,r,this);
+}
+}
+%SetCode(e,SetConstructor);
+%FunctionSetLength(e,0);
+%FunctionSetPrototype(e,new d());
+%AddNamedProperty(e.prototype,"constructor",e,2);
+%AddNamedProperty(e.prototype,l,"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(x){
+if((new.target===(void 0))){
+throw h(26,"Map");
+}
+%_MapInitialize(this);
+if(!(x==null)){
+var y=this.set;
+if(!(typeof(y)==='function')){
+throw h(91,y,'set',this);
+}
+for(var J of x){
+if(!(%_IsJSReceiver(J))){
+throw h(49,J);
+}
+%_Call(y,this,J[0],J[1]);
+}
+}
+}
+function MapGet(r){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.get',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetExistingHash(r);
+if((o===(void 0)))return(void 0);
+var s=MapFindEntry(n,p,r,o);
+if(s===-1)return(void 0);
+return((%_FixedArrayGet(n,((3+(p)+((s)*3))+1)|0)));
+}
+function MapSet(r,z){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.set',this);
+}
+if(r===0){
+r=0;
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+var s=MapFindEntry(n,p,r,o);
+if(s!==-1){
+var K=(3+(p)+((s)*3));
+(%_FixedArraySet(n,(K+1)|0,z));
+return this;
+}
+var A=((%_FixedArrayGet(n,(1)|0)));
+var B=((%_FixedArrayGet(n,(2)|0)));
+var C=p<<1;
+if((A+B)>=C){
+%MapGrow(this);
+n=%_JSCollectionGetTable(this);
+p=((%_FixedArrayGet(n,(0)|0)));
+A=((%_FixedArrayGet(n,(1)|0)));
+B=((%_FixedArrayGet(n,(2)|0)));
+}
+s=A+B;
+var D=(3+(p)+((s)*3));
+var q=(o&((p)-1));
+var E=((%_FixedArrayGet(n,(3+(q))|0)));
+((%_FixedArraySet(n,(3+(q))|0,s)));
+(((%_FixedArraySet(n,(1)|0,(A+1)|0))));
+(%_FixedArraySet(n,(D)|0,r));
+(%_FixedArraySet(n,(D+1)|0,z));
+(%_FixedArraySet(n,(D+2)|0,E));
+return this;
+}
+function MapHas(r){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.has',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+return MapFindEntry(n,p,r,o)!==-1;
+}
+function MapDelete(r){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.delete',this);
+}
+var n=%_JSCollectionGetTable(this);
+var p=((%_FixedArrayGet(n,(0)|0)));
+var o=GetHash(r);
+var s=MapFindEntry(n,p,r,o);
+if(s===-1)return false;
+var A=((%_FixedArrayGet(n,(1)|0)))-1;
+var B=((%_FixedArrayGet(n,(2)|0)))+1;
+var D=(3+(p)+((s)*3));
+(%_FixedArraySet(n,(D)|0,%_TheHole()));
+(%_FixedArraySet(n,(D+1)|0,%_TheHole()));
+(((%_FixedArraySet(n,(1)|0,(A)|0))));
+(((%_FixedArraySet(n,(2)|0,(B)|0))));
+if(A<(p>>>1))%MapShrink(this);
+return true;
+}
+function MapGetSize(){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.size',this);
+}
+var n=%_JSCollectionGetTable(this);
+return((%_FixedArrayGet(n,(1)|0)));
+}
+function MapClearJS(){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.clear',this);
+}
+%_MapClear(this);
+}
+function MapForEach(F,G){
+if(!(%_ClassOf(this)==='Map')){
+throw h(42,
+'Map.prototype.forEach',this);
+}
+if(!(typeof(F)==='function'))throw h(15,F);
+var H=new i(this,3);
+var I=[(void 0),(void 0)];
+while(%MapIteratorNext(H,I)){
+%_Call(F,G,I[1],I[0],this);
+}
+}
+%SetCode(c,MapConstructor);
+%FunctionSetLength(c,0);
+%FunctionSetPrototype(c,new d());
+%AddNamedProperty(c.prototype,"constructor",c,2);
+%AddNamedProperty(
+c.prototype,l,"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(L){
+L.GetExistingHash=GetExistingHash;
+L.GetHash=GetHash;
+});
+})
+
+{
+if(r===true)return;
+r=true;
+PromiseResolve(q,value);
+};
+var t=reason=>{
+if(r===true)return;
+r=true;
+PromiseReject(q,reason);
+};
+return{
+__proto__:null,
+resolve:s,
+reject:t
+};
+}
+var u=function Promise(v){
+if(v===j){
+return %NewObject(u,new.target);
+}
+if((new.target===(void 0)))throw e(61,this);
+if(!(typeof(v)==='function'))
+throw e(134,v);
+var q=PromiseInit(%NewObject(u,new.target));
+var w=CreateResolvingFunctions(q);
+try{
+%DebugPushPromise(q,Promise);
+v(w.resolve,w.reject);
+}catch(e){
+%_Call(w.reject,(void 0),e);
+}finally{
+%DebugPopPromise();
+}
+return q;
+}
+function PromiseSet(q,x,y,z,A){
+(q[k]=x);
+(q[l]=y);
+(q[i]=z);
+(q[h]=A);
+if((%_DebugIsActive()!=0)){
+%DebugPromiseEvent({promise:q,status:x,value:y});
+}
+return q;
+}
+function PromiseCreateAndSet(x,y){
+var q=new u(j);
+if((%_DebugIsActive()!=0))PromiseSet(q,0,(void 0));
+return PromiseSet(q,x,y);
+}
+function PromiseInit(q){
+return PromiseSet(
+q,0,(void 0),new d,new d)
+}
+function PromiseDone(q,x,y,B){
+if((q[k])===0){
+var C=(q[B]);
+if(C.length)PromiseEnqueue(y,C,x);
+PromiseSet(q,x,y);
+}
+}
+function PromiseHandle(y,D,E){
+try{
+%DebugPushPromise(E.promise,PromiseHandle);
+var F=D(y);
+E.resolve(F);
+}catch(exception){
+try{E.reject(exception);}catch(e){}
+}finally{
+%DebugPopPromise();
+}
+}
+function PromiseEnqueue(y,C,x){
+var G,H,I=(%_DebugIsActive()!=0);
+%EnqueueMicrotask(function(){
+if(I){
+%DebugAsyncTaskEvent({type:"willHandle",id:G,name:H});
+}
+for(var J=0;J0?"Promise.resolve":"Promise.reject";
+%DebugAsyncTaskEvent({type:"enqueue",id:G,name:H});
+}
+}
+function PromiseIdResolveHandler(K){return K}
+function PromiseIdRejectHandler(L){throw L}
+function PromiseNopResolver(){}
+function IsPromise(K){
+return(%_IsJSReceiver(K))&&(!(K[k]===(void 0)));
+}
+function PromiseCreate(){
+return new u(PromiseNopResolver)
+}
+function PromiseResolve(q,K){
+if(K===q){
+return PromiseReject(q,e(88,K));
+}
+if((%_IsJSReceiver(K))){
+try{
+var M=K.then;
+}catch(e){
+return PromiseReject(q,e);
+}
+if((typeof(M)==='function')){
+var G,H,I=(%_DebugIsActive()!=0);
+%EnqueueMicrotask(function(){
+if(I){
+%DebugAsyncTaskEvent({type:"willHandle",id:G,name:H});
+}
+var w=CreateResolvingFunctions(q);
+try{
+%_Call(M,K,w.resolve,w.reject);
+}catch(e){
+%_Call(w.reject,(void 0),e);
+}
+if(I){
+%DebugAsyncTaskEvent({type:"didHandle",id:G,name:H});
+}
+});
+if(I){
+G=++p;
+H="PromseResolveThenableJob";
+%DebugAsyncTaskEvent({type:"enqueue",id:G,name:H});
+}
+return;
+}
+}
+PromiseDone(q,+1,K,i);
+}
+function PromiseReject(q,L){
+if((q[k])==0){
+var N=(%_DebugIsActive()!=0);
+if(N||
+!(!(q[g]===(void 0)))){
+%PromiseRejectEvent(q,L,N);
+}
+}
+PromiseDone(q,-1,L,h)
+}
+function NewPromiseCapability(O){
+if(O===u){
+var q=PromiseInit(new u(j));
+var w=CreateResolvingFunctions(q);
+return{
+promise:q,
+resolve:w.resolve,
+reject:w.reject
+};
+}
+var F={promise:(void 0),resolve:(void 0),reject:(void 0)};
+F.promise=new O((s,t)=>{
+if(!(F.resolve===(void 0))||!(F.reject===(void 0)))
+throw e(89);
+F.resolve=s;
+F.reject=t;
+});
+return F;
+}
+function PromiseDeferred(){
+%IncrementUseCounter(19);
+return NewPromiseCapability(this);
+}
+function PromiseResolved(K){
+%IncrementUseCounter(18);
+return %_Call(PromiseCast,this,K);
+}
+function PromiseRejected(L){
+if(!(%_IsJSReceiver(this))){
+throw e(16,PromiseRejected);
+}
+if(this===u){
+var q=PromiseCreateAndSet(-1,L);
+%PromiseRejectEvent(q,L,false);
+return q;
+}else{
+var P=NewPromiseCapability(this);
+%_Call(P.reject,(void 0),L);
+return P.promise;
+}
+}
+function PromiseThen(z,A){
+var x=(this[k]);
+if((x===(void 0))){
+throw e(61,this);
+}
+var Q=m(this,u);
+z=(typeof(z)==='function')?z:PromiseIdResolveHandler;
+A=(typeof(A)==='function')?A:PromiseIdRejectHandler;
+var E=NewPromiseCapability(Q);
+switch(x){
+case 0:
+(this[i]).push(z,E);
+(this[h]).push(A,E);
+break;
+case+1:
+PromiseEnqueue((this[l]),
+[z,E],
++1);
+break;
+case-1:
+if(!(!(this[g]===(void 0)))){
+%PromiseRevokeReject(this);
+}
+PromiseEnqueue((this[l]),
+[A,E],
+-1);
+break;
+}
+(this[g]=true);
+if((%_DebugIsActive()!=0)){
+%DebugPromiseEvent({promise:E.promise,parentPromise:this});
+}
+return E.promise;
+}
+function PromiseChain(z,A){
+%IncrementUseCounter(17);
+return %_Call(PromiseThen,this,z,A);
+}
+function PromiseCatch(A){
+return this.then((void 0),A);
+}
+function PromiseCast(K){
+if(!(%_IsJSReceiver(this))){
+throw e(16,PromiseCast);
+}
+if(IsPromise(K)&&K.constructor===this)return K;
+var P=NewPromiseCapability(this);
+var R=%_Call(P.resolve,(void 0),K);
+return P.promise;
+}
+function PromiseAll(S){
+if(!(%_IsJSReceiver(this))){
+throw e(16,"Promise.all");
+}
+var E=NewPromiseCapability(this);
+var T=new d();
+var U;
+function CreateResolveElementFunction(V,W,P){
+var X=false;
+return(K)=>{
+if(X===true)return;
+X=true;
+W[V]=K;
+if(--U===0){
+var Y=[];
+%MoveArrayContents(W,Y);
+%_Call(P.resolve,(void 0),Y);
+}
+};
+}
+try{
+var J=0;
+U=1;
+for(var y of S){
+var Z=this.resolve(y);
+++U;
+Z.then(
+CreateResolveElementFunction(J,T,E),
+E.reject);
+(E.reject[f]=E);
+++J;
+}
+if(--U===0){
+var Y=[];
+%MoveArrayContents(T,Y);
+%_Call(E.resolve,(void 0),Y);
+}
+}catch(e){
+%_Call(E.reject,(void 0),e);
+}
+return E.promise;
+}
+function PromiseRace(S){
+if(!(%_IsJSReceiver(this))){
+throw e(16,PromiseRace);
+}
+var E=NewPromiseCapability(this);
+try{
+for(var y of S){
+this.resolve(y).then(E.resolve,E.reject);
+(E.reject[f]=E);
+}
+}catch(e){
+E.reject(e)
+}
+return E.promise;
+}
+function PromiseHasUserDefinedRejectHandlerRecursive(q){
+var aa=(q[h]);
+if((aa===(void 0)))return false;
+for(var J=0;J%FunctionRemovePrototype(fn));
+b.Export(function(ab){
+ab.PromiseChain=PromiseChain;
+ab.PromiseDeferred=PromiseDeferred;
+ab.PromiseResolved=PromiseResolved;
+});
+})
+
+ messages
+(function(a,b){
+%CheckIsBootstrapping();
+var c;
+var d;
+var e;
+var f;
+var g=
+b.ImportNow("call_site_receiver_symbol");
+var h=
+b.ImportNow("call_site_function_symbol");
+var i=
+b.ImportNow("call_site_position_symbol");
+var j=
+b.ImportNow("call_site_strict_symbol");
+var k;
+var l;
+var m=
+b.ImportNow("formatted_stack_trace_symbol");
+var n=a.Object;
+var o;
+var p;
+var q;
+var r=b.InternalArray;
+var s=b.ImportNow("internal_error_symbol");
+var t;
+var u=b.ImportNow("object_to_string");
+var v=b.ImportNow("Script");
+var w=b.ImportNow("stack_trace_symbol");
+var x;
+var y;
+var z;
+var A;
+var B=b.ImportNow("to_string_tag_symbol");
+var C;
+var D;
+var E;
+b.Import(function(F){
+c=F.ArrayJoin;
+d=F.Bool16x8ToString;
+e=F.Bool32x4ToString;
+f=F.Bool8x16ToString;
+l=F.Float32x4ToString;
+o=F.Int16x8ToString;
+p=F.Int32x4ToString;
+q=F.Int8x16ToString;
+t=F.ObjectDefineProperty;
+x=F.StringCharAt;
+y=F.StringIndexOf;
+z=F.StringSubstring;
+A=F.SymbolToString;
+C=F.Uint16x8ToString;
+D=F.Uint32x4ToString;
+E=F.Uint8x16ToString;
+});
+b.ImportFromExperimental(function(F){
+k=F.FLAG_harmony_tostring;
+});
+var G;
+var H;
+var I;
+var J;
+var K;
+var L;
+var M;
+function NoSideEffectsObjectToString(){
+if((this===(void 0)))return"[object Undefined]";
+if((this===null))return"[object Null]";
+var N=(%_ToObject(this));
+var O=%_ClassOf(N);
+var P;
+if(k){
+P=%GetDataProperty(N,B);
+if(!(typeof(P)==='string')){
+P=O;
+}
+}else{
+P=O;
+}
+return`[object ${P}]`;
+}
+function IsErrorObject(Q){
+return(%HasOwnProperty(Q,w));
+}
+function NoSideEffectsErrorToString(){
+var R=%GetDataProperty(this,"name");
+var S=%GetDataProperty(this,"message");
+R=(R===(void 0))?"Error":NoSideEffectsToString(R);
+S=(S===(void 0))?"":NoSideEffectsToString(S);
+if(R=="")return S;
+if(S=="")return R;
+return`${R}: ${S}`;
+}
+function NoSideEffectsToString(Q){
+if((typeof(Q)==='string'))return Q;
+if((typeof(Q)==='number'))return %_NumberToString(Q);
+if((typeof(Q)==='boolean'))return Q?'true':'false';
+if((Q===(void 0)))return'undefined';
+if((Q===null))return'null';
+if((%_IsFunction(Q))){
+var T=%FunctionToString(Q);
+if(T.length>128){
+T=%_SubString(T,0,111)+"......"+
+%_SubString(T,T.length-2,T.length);
+}
+return T;
+}
+if((typeof(Q)==='symbol'))return %_Call(A,Q);
+if((%_IsSimdValue(Q))){
+switch(typeof(Q)){
+case'float32x4':return %_Call(l,Q);
+case'int32x4':return %_Call(p,Q);
+case'int16x8':return %_Call(o,Q);
+case'int8x16':return %_Call(q,Q);
+case'uint32x4':return %_Call(D,Q);
+case'uint16x8':return %_Call(C,Q);
+case'uint8x16':return %_Call(E,Q);
+case'bool32x4':return %_Call(e,Q);
+case'bool16x8':return %_Call(d,Q);
+case'bool8x16':return %_Call(f,Q);
+}
+}
+if((%_IsJSReceiver(Q))){
+if(IsErrorObject(Q)||
+%GetDataProperty(Q,"toString")===ErrorToString){
+return %_Call(NoSideEffectsErrorToString,Q);
+}
+if(%GetDataProperty(Q,"toString")===u){
+var U=%GetDataProperty(Q,"constructor");
+if((%_IsFunction(U))){
+var V=%FunctionGetName(U);
+if(V!="")return`#<${V}>`;
+}
+}
+}
+return %_Call(NoSideEffectsObjectToString,Q);
+}
+function MakeGenericError(U,W,X,Y,Z){
+var aa=new U(FormatMessage(W,X,Y,Z));
+aa[s]=true;
+return aa;
+}
+%FunctionSetInstanceClassName(v,'Script');
+%AddNamedProperty(v.prototype,'constructor',v,
+2|4|1);
+%SetCode(v,function(ab){
+throw MakeError(6);
+});
+function FormatMessage(W,X,Y,Z){
+var X=NoSideEffectsToString(X);
+var Y=NoSideEffectsToString(Y);
+var Z=NoSideEffectsToString(Z);
+try{
+return %FormatMessageString(W,X,Y,Z);
+}catch(e){
+return"";
+}
+}
+function GetLineNumber(S){
+var ac=%MessageGetStartPosition(S);
+if(ac==-1)return 0;
+var ad=%MessageGetScript(S);
+var ae=ad.locationFromPosition(ac,true);
+if(ae==null)return 0;
+return ae.line+1;
+}
+function GetColumnNumber(S){
+var ad=%MessageGetScript(S);
+var ac=%MessageGetStartPosition(S);
+var ae=ad.locationFromPosition(ac,true);
+if(ae==null)return-1;
+return ae.column;
+}
+function GetSourceLine(S){
+var ad=%MessageGetScript(S);
+var ac=%MessageGetStartPosition(S);
+var ae=ad.locationFromPosition(ac,true);
+if(ae==null)return"";
+return ae.sourceText();
+}
+function ScriptLineFromPosition(af){
+var ag=0;
+var ah=this.lineCount()-1;
+var ai=this.line_ends;
+if(af>ai[ah]){
+return-1;
+}
+if(af<=ai[0]){
+return 0;
+}
+while(ah>=1){
+var aj=(ag+ah)>>1;
+if(af>ai[aj]){
+ag=aj+1;
+}else if(af<=ai[aj-1]){
+ah=aj-1;
+}else{
+return aj;
+}
+}
+return-1;
+}
+function ScriptLocationFromPosition(af,
+include_resource_offset){
+var ak=this.lineFromPosition(af);
+if(ak==-1)return null;
+var ai=this.line_ends;
+var al=ak==0?0:ai[ak-1]+1;
+var am=ai[ak];
+if(am>0&&%_Call(x,this.source,am-1)=='\r'){
+am--;
+}
+var an=af-al;
+if(include_resource_offset){
+ak+=this.line_offset;
+if(ak==this.line_offset){
+an+=this.column_offset;
+}
+}
+return new SourceLocation(this,af,ak,an,al,am);
+}
+function ScriptLocationFromLine(ao,ap,aq){
+var ak=0;
+if(!(ao===(void 0))){
+ak=ao-this.line_offset;
+}
+var an=ap||0;
+if(ak==0){
+an-=this.column_offset;
+}
+var ar=aq||0;
+if(ak<0||an<0||ar<0)return null;
+if(ak==0){
+return this.locationFromPosition(ar+an,false);
+}else{
+var as=this.lineFromPosition(ar);
+if(as==-1||as+ak>=this.lineCount()){
+return null;
+}
+return this.locationFromPosition(
+this.line_ends[as+ak-1]+1+an);
+}
+}
+function ScriptSourceSlice(at,au){
+var av=(at===(void 0))?this.line_offset
+:at;
+var aw=(au===(void 0))?this.line_offset+this.lineCount()
+:au;
+av-=this.line_offset;
+aw-=this.line_offset;
+if(av<0)av=0;
+if(aw>this.lineCount())aw=this.lineCount();
+if(av>=this.lineCount()||
+aw<0||
+av>aw){
+return null;
+}
+var ai=this.line_ends;
+var ax=av==0?0:ai[av-1]+1;
+var ay=aw==0?0:ai[aw-1]+1;
+return new SourceSlice(this,
+av+this.line_offset,
+aw+this.line_offset,
+ax,ay);
+}
+function ScriptSourceLine(ao){
+var ak=0;
+if(!(ao===(void 0))){
+ak=ao-this.line_offset;
+}
+if(ak<0||this.lineCount()<=ak){
+return null;
+}
+var ai=this.line_ends;
+var al=ak==0?0:ai[ak-1]+1;
+var am=ai[ak];
+return %_Call(z,this.source,al,am);
+}
+function ScriptLineCount(){
+return this.line_ends.length;
+}
+function ScriptLineEnd(az){
+return this.line_ends[az];
+}
+function ScriptNameOrSourceURL(){
+if(this.source_url)return this.source_url;
+return this.name;
+}
+b.SetUpLockedPrototype(v,[
+"source",
+"name",
+"source_url",
+"source_mapping_url",
+"line_ends",
+"line_offset",
+"column_offset"
+],[
+"lineFromPosition",ScriptLineFromPosition,
+"locationFromPosition",ScriptLocationFromPosition,
+"locationFromLine",ScriptLocationFromLine,
+"sourceSlice",ScriptSourceSlice,
+"sourceLine",ScriptSourceLine,
+"lineCount",ScriptLineCount,
+"nameOrSourceURL",ScriptNameOrSourceURL,
+"lineEnd",ScriptLineEnd
+]
+);
+function SourceLocation(ad,af,ak,an,al,am){
+this.script=ad;
+this.position=af;
+this.line=ak;
+this.column=an;
+this.start=al;
+this.end=am;
+}
+function SourceLocationSourceText(){
+return %_Call(z,this.script.source,this.start,this.end);
+}
+b.SetUpLockedPrototype(SourceLocation,
+["script","position","line","column","start","end"],
+["sourceText",SourceLocationSourceText]
+);
+function SourceSlice(ad,av,aw,ax,ay){
+this.script=ad;
+this.from_line=av;
+this.to_line=aw;
+this.from_position=ax;
+this.to_position=ay;
+}
+function SourceSliceSourceText(){
+return %_Call(z,
+this.script.source,
+this.from_position,
+this.to_position);
+}
+b.SetUpLockedPrototype(SourceSlice,
+["script","from_line","to_line","from_position","to_position"],
+["sourceText",SourceSliceSourceText]
+);
+function GetStackTraceLine(aA,aB,aC,aD){
+return new CallSite(aA,aB,aC,false).toString();
+}
+function CallSite(aE,aB,aC,aF){
+if(!(%_IsFunction(aB))){
+throw MakeTypeError(18,typeof aB);
+}
+if((new.target===(void 0))){
+return new CallSite(aE,aB,aC,aF);
+}
+(this[g]=aE);
+(this[h]=aB);
+(this[i]=((aC)|0));
+(this[j]=(!!(aF)));
+}
+function CallSiteGetThis(){
+return(this[j])
+?(void 0):(this[g]);
+}
+function CallSiteGetFunction(){
+return(this[j])
+?(void 0):(this[h]);
+}
+function CallSiteGetPosition(){
+return(this[i]);
+}
+function CallSiteGetTypeName(){
+return GetTypeName((this[g]),false);
+}
+function CallSiteIsToplevel(){
+return %CallSiteIsToplevelRT(this);
+}
+function CallSiteIsEval(){
+return %CallSiteIsEvalRT(this);
+}
+function CallSiteGetEvalOrigin(){
+var ad=%FunctionGetScript((this[h]));
+return FormatEvalOrigin(ad);
+}
+function CallSiteGetScriptNameOrSourceURL(){
+return %CallSiteGetScriptNameOrSourceUrlRT(this);
+}
+function CallSiteGetFunctionName(){
+return %CallSiteGetFunctionNameRT(this);
+}
+function CallSiteGetMethodName(){
+return %CallSiteGetMethodNameRT(this);
+}
+function CallSiteGetFileName(){
+return %CallSiteGetFileNameRT(this);
+}
+function CallSiteGetLineNumber(){
+return %CallSiteGetLineNumberRT(this);
+}
+function CallSiteGetColumnNumber(){
+return %CallSiteGetColumnNumberRT(this);
+}
+function CallSiteIsNative(){
+return %CallSiteIsNativeRT(this);
+}
+function CallSiteIsConstructor(){
+return %CallSiteIsConstructorRT(this);
+}
+function CallSiteToString(){
+var aG;
+var aH="";
+if(this.isNative()){
+aH="native";
+}else{
+aG=this.getScriptNameOrSourceURL();
+if(!aG&&this.isEval()){
+aH=this.getEvalOrigin();
+aH+=", ";
+}
+if(aG){
+aH+=aG;
+}else{
+aH+="";
+}
+var aI=this.getLineNumber();
+if(aI!=null){
+aH+=":"+aI;
+var aJ=this.getColumnNumber();
+if(aJ){
+aH+=":"+aJ;
+}
+}
+}
+var ak="";
+var aK=this.getFunctionName();
+var aL=true;
+var aM=this.isConstructor();
+var aN=!(this.isToplevel()||aM);
+if(aN){
+var aO=GetTypeName((this[g]),true);
+var aP=this.getMethodName();
+if(aK){
+if(aO&&%_Call(y,aK,aO)!=0){
+ak+=aO+".";
+}
+ak+=aK;
+if(aP&&
+(%_Call(y,aK,"."+aP)!=
+aK.length-aP.length-1)){
+ak+=" [as "+aP+"]";
+}
+}else{
+ak+=aO+"."+(aP||"");
+}
+}else if(aM){
+ak+="new "+(aK||"");
+}else if(aK){
+ak+=aK;
+}else{
+ak+=aH;
+aL=false;
+}
+if(aL){
+ak+=" ("+aH+")";
+}
+return ak;
+}
+b.SetUpLockedPrototype(CallSite,["receiver","fun","pos"],[
+"getThis",CallSiteGetThis,
+"getTypeName",CallSiteGetTypeName,
+"isToplevel",CallSiteIsToplevel,
+"isEval",CallSiteIsEval,
+"getEvalOrigin",CallSiteGetEvalOrigin,
+"getScriptNameOrSourceURL",CallSiteGetScriptNameOrSourceURL,
+"getFunction",CallSiteGetFunction,
+"getFunctionName",CallSiteGetFunctionName,
+"getMethodName",CallSiteGetMethodName,
+"getFileName",CallSiteGetFileName,
+"getLineNumber",CallSiteGetLineNumber,
+"getColumnNumber",CallSiteGetColumnNumber,
+"isNative",CallSiteIsNative,
+"getPosition",CallSiteGetPosition,
+"isConstructor",CallSiteIsConstructor,
+"toString",CallSiteToString
+]);
+function FormatEvalOrigin(ad){
+var aQ=ad.nameOrSourceURL();
+if(aQ){
+return aQ;
+}
+var aR="eval at ";
+if(ad.eval_from_function_name){
+aR+=ad.eval_from_function_name;
+}else{
+aR+="";
+}
+var aS=ad.eval_from_script;
+if(aS){
+if(aS.compilation_type==1){
+aR+=" ("+FormatEvalOrigin(aS)+")";
+}else{
+if(aS.name){
+aR+=" ("+aS.name;
+var ae=aS.locationFromPosition(
+ad.eval_from_script_position,true);
+if(ae){
+aR+=":"+(ae.line+1);
+aR+=":"+(ae.column+1);
+}
+aR+=")";
+}else{
+aR+=" (unknown source)";
+}
+}
+}
+return aR;
+}
+function FormatErrorString(aa){
+try{
+return %_Call(ErrorToString,aa);
+}catch(e){
+try{
+return"";
+}catch(ee){
+return"";
+}
+}
+}
+function GetStackFrames(aT){
+var aU=new r();
+var aV=aT[0];
+for(var aj=1;aj";
+}catch(ee){
+ak="";
+}
+}
+bb.push(" at "+ak);
+}
+return %_Call(c,bb,"\n");
+}
+function GetTypeName(aE,bd){
+if((aE==null))return null;
+if((%_IsJSProxy(aE)))return"Proxy";
+var U=%GetDataProperty((%_ToObject(aE)),"constructor");
+if(!(%_IsFunction(U))){
+return bd?null:%_Call(NoSideEffectsToString,aE);
+}
+return %FunctionGetName(U);
+}
+var be=function(){
+var bf=(void 0);
+var bg=this;
+while(bg){
+var bf=
+(bg[m]);
+if((bf===(void 0))){
+var ba=(bg[w]);
+if((ba===(void 0))){
+bg=%_GetPrototype(bg);
+continue;
+}
+bf=FormatStackTrace(bg,ba);
+(bg[w]=(void 0));
+(bg[m]=bf);
+}
+return bf;
+}
+return(void 0);
+};
+var bh=function(bi){
+if(IsErrorObject(this)){
+(this[w]=(void 0));
+(this[m]=bi);
+}
+};
+var bj=function(){};
+function SetUpError(bk){
+%FunctionSetInstanceClassName(bk,'Error');
+var R=bk.name;
+var bl=new n();
+if(R!=='Error'){
+%InternalSetPrototype(bk,G);
+%InternalSetPrototype(bl,G.prototype);
+}
+%FunctionSetPrototype(bk,bl);
+%AddNamedProperty(bk.prototype,'name',R,2);
+%AddNamedProperty(bk.prototype,'message','',2);
+%AddNamedProperty(
+bk.prototype,'constructor',bk,2);
+%SetCode(bk,function(bm){
+if((new.target===(void 0)))return new bk(bm);
+try{bj(this,bk);}catch(e){}
+if(!(bm===(void 0))){
+%AddNamedProperty(this,'message',(%_ToString(bm)),2);
+}
+});
+%SetNativeFlag(bk);
+return bk;
+};
+G=SetUpError(a.Error);
+M=SetUpError(a.EvalError);
+I=SetUpError(a.RangeError);
+L=SetUpError(a.ReferenceError);
+K=SetUpError(a.SyntaxError);
+H=SetUpError(a.TypeError);
+J=SetUpError(a.URIError);
+b.InstallFunctions(G.prototype,2,
+['toString',ErrorToString]);
+function ErrorToString(){
+if(!(%_IsJSReceiver(this))){
+throw MakeTypeError(16,"Error.prototype.toString");
+}
+var R=this.name;
+R=(R===(void 0))?"Error":(%_ToString(R));
+var S=this.message;
+S=(S===(void 0))?"":(%_ToString(S));
+if(R=="")return S;
+if(S=="")return R;
+return`${R}: ${S}`
+}
+function MakeError(W,X,Y,Z){
+return MakeGenericError(G,W,X,Y,Z);
+}
+function MakeRangeError(W,X,Y,Z){
+return MakeGenericError(I,W,X,Y,Z);
+}
+function MakeSyntaxError(W,X,Y,Z){
+return MakeGenericError(K,W,X,Y,Z);
+}
+function MakeTypeError(W,X,Y,Z){
+return MakeGenericError(H,W,X,Y,Z);
+}
+function MakeURIError(){
+return MakeGenericError(J,283);
+}
+var bn=MakeRangeError(187);
+b.InstallGetterSetter(bn,'stack',
+be,bh)
+bj=function captureStackTrace(Q,bo){
+t(Q,'stack',{get:be,
+set:bh,
+configurable:true});
+%CollectStackTrace(Q,bo?bo:bj);
+};
+G.captureStackTrace=bj;
+%InstallToContext([
+"get_stack_trace_line_fun",GetStackTraceLine,
+"make_error_function",MakeGenericError,
+"make_range_error",MakeRangeError,
+"make_type_error",MakeTypeError,
+"message_get_column_number",GetColumnNumber,
+"message_get_line_number",GetLineNumber,
+"message_get_source_line",GetSourceLine,
+"no_side_effects_to_string_fun",NoSideEffectsToString,
+"stack_overflow_boilerplate",bn,
+]);
+b.Export(function(bp){
+bp.ErrorToString=ErrorToString;
+bp.MakeError=MakeError;
+bp.MakeRangeError=MakeRangeError;
+bp.MakeSyntaxError=MakeSyntaxError;
+bp.MakeTypeError=MakeTypeError;
+bp.MakeURIError=MakeURIError;
+});
+});
+
+jsonE
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=a.Date;
+var d=a.JSON;
+var e=a.Set;
+var f=b.InternalArray;
+var g;
+var h;
+var i;
+var j;
+var k=b.ImportNow("to_string_tag_symbol");
+b.Import(function(l){
+g=l.MakeTypeError;
+h=l.MaxSimple;
+i=l.MinSimple;
+j=l.ObjectHasOwnProperty;
+});
+function CreateDataProperty(m,n,o){
+var p={value:o,enumerable:true,writable:true,configurable:true};
+return %reflect_define_property(m,n,p);
+}
+function InternalizeJSONProperty(q,r,s){
+var t=q[r];
+if((%_IsJSReceiver(t))){
+if(%is_arraylike(t)){
+var u=(%_ToLength(t.length));
+for(var v=0;v0){
+var J=",\n"+C;
+I="[\n"+C+F.join(J)+"\n"+
+E+"]";
+}else{
+I="[]";
+}
+B.pop();
+return I;
+}
+function SerializeObject(z,A,B,C,D){
+if(!%PushIfAbsent(B,z))throw g(22);
+var E=C;
+C+=D;
+var F=new f();
+if((%_IsArray(A))){
+var u=A.length;
+for(var v=0;v0){
+var J=",\n"+C;
+I="{\n"+C+F.join(J)+"\n"+
+E+"}";
+}else{
+I="{}";
+}
+B.pop();
+return I;
+}
+function JSONSerialize(L,q,A,B,C,D){
+var z=q[L];
+if((%_IsJSReceiver(z))){
+var M=z.toJSON;
+if((typeof(M)==='function')){
+z=%_Call(M,z,L);
+}
+}
+if((typeof(A)==='function')){
+z=%_Call(A,q,L,z);
+}
+if((typeof(z)==='string')){
+return %QuoteJSONString(z);
+}else if((typeof(z)==='number')){
+return((%_IsSmi(%IS_VAR(z))||z-z==0)?%_NumberToString(z):"null");
+}else if((typeof(z)==='boolean')){
+return z?"true":"false";
+}else if((z===null)){
+return"null";
+}else if((%_IsJSReceiver(z))&&!(typeof(z)==='function')){
+if(%is_arraylike(z)){
+return SerializeArray(z,A,B,C,D);
+}else if((%_ClassOf(z)==='Number')){
+z=(%_ToNumber(z));
+return((%_IsSmi(%IS_VAR(z))||z-z==0)?%_NumberToString(z):"null");
+}else if((%_ClassOf(z)==='String')){
+return %QuoteJSONString((%_ToString(z)));
+}else if((%_ClassOf(z)==='Boolean')){
+return %_ValueOf(z)?"true":"false";
+}else{
+return SerializeObject(z,A,B,C,D);
+}
+}
+return(void 0);
+}
+function JSONStringify(z,A,N){
+if(%_ArgumentsLength()==1&&!(%_IsJSProxy(z))){
+return %BasicJSONStringify(z);
+}
+if(!(typeof(A)==='function')&&%is_arraylike(A)){
+var O=new f();
+var P=new e();
+var u=(%_ToLength(A.length));
+for(var v=0;v10){
+D=%_SubString(N,0,10);
+}else{
+D=N;
+}
+}else{
+D="";
+}
+return JSONSerialize('',{'':z},A,new f(),"",D);
+}
+%AddNamedProperty(d,k,"JSON",1|2);
+b.InstallFunctions(d,2,[
+"parse",JSONParse,
+"stringify",JSONStringify
+]);
+function DateToJSON(L){
+var m=(%_ToObject(this));
+var R=(%_ToPrimitive_Number(m));
+if((typeof(R)==='number')&&!(%_IsSmi(%IS_VAR(R))||((R==R)&&(R!=1/0)&&(R!=-1/0)))){
+return null;
+}
+return m.toISOString();
+}
+b.InstallFunctions(c.prototype,2,[
+"toJSON",DateToJSON
+]);
+function JsonSerializeAdapter(L,S){
+var q={};
+q[L]=S;
+return JSONSerialize(L,q,(void 0),new f(),"","");
+}
+%InstallToContext(["json_serialize_adapter",JsonSerializeAdapter]);
+})
+
+8array-iterator
+(function(a,b){
+"use strict";
+%CheckIsBootstrapping();
+var c=
+b.ImportNow("array_iteration_kind_symbol");
+var d=
+b.ImportNow("array_iterator_next_symbol");
+var e=
+b.ImportNow("array_iterator_object_symbol");
+var f=a.Array;
+var g=b.ImportNow("IteratorPrototype");
+var h=b.ImportNow("iterator_symbol");
+var i;
+var j=b.ImportNow("to_string_tag_symbol");
+var k=a.Uint8Array.__proto__;
+b.Import(function(l){
+i=l.MakeTypeError;
+})
+function ArrayIterator(){}
+function CreateArrayIterator(m,n){
+var o=(%_ToObject(m));
+var p=new ArrayIterator;
+(p[e]=o);
+(p[d]=0);
+(p[c]=n);
+return p;
+}
+function ArrayIteratorIterator(){
+return this;
+}
+function ArrayIteratorNext(){
+var p=this;
+var q=(void 0);
+var r=true;
+if(!(%_IsJSReceiver(p))||
+!(!(p[d]===(void 0)))){
+throw i(42,
+'Array Iterator.prototype.next',this);
+}
+var m=(p[e]);
+if(!(m===(void 0))){
+var s=(p[d]);
+var t=(p[c]);
+var u=((m.length)>>>0);
+if(s>=u){
+(p[e]=(void 0));
+}else{
+(p[d]=s+1);
+if(t==2){
+q=m[s];
+}else if(t==3){
+q=[s,m[s]];
+}else{
+q=s;
+}
+r=false;
+}
+}
+return %_CreateIterResultObject(q,r);
+}
+function ArrayEntries(){
+return CreateArrayIterator(this,3);
+}
+function ArrayValues(){
+return CreateArrayIterator(this,2);
+}
+function ArrayKeys(){
+return CreateArrayIterator(this,1);
+}
+%FunctionSetPrototype(ArrayIterator,{__proto__:g});
+%FunctionSetInstanceClassName(ArrayIterator,'Array Iterator');
+b.InstallFunctions(ArrayIterator.prototype,2,[
+'next',ArrayIteratorNext
+]);
+b.SetFunctionName(ArrayIteratorIterator,h);
+%AddNamedProperty(ArrayIterator.prototype,h,
+ArrayIteratorIterator,2);
+%AddNamedProperty(ArrayIterator.prototype,j,
+"Array Iterator",1|2);
+b.InstallFunctions(f.prototype,2,[
+'entries',ArrayEntries,
+'keys',ArrayKeys
+]);
+b.SetFunctionName(ArrayValues,'values');
+%AddNamedProperty(f.prototype,h,ArrayValues,
+2);
+%AddNamedProperty(k.prototype,
+'entries',ArrayEntries,2);
+%AddNamedProperty(k.prototype,'values',ArrayValues,2);
+%AddNamedProperty(k.prototype,'keys',ArrayKeys,2);
+%AddNamedProperty(k.prototype,
+h,ArrayValues,2);
+b.Export(function(v){
+v.ArrayValues=ArrayValues;
+});
+%InstallToContext(["array_values_iterator",ArrayValues]);
+})
+
+>>0);
+if(p>=q){
+(m[g]=(void 0));
+}else{
+var r=%_StringCharCodeAt(l,p);
+n=%_StringCharFromCode(r);
+o=false;
+p++;
+if(r>=0xD800&&r<=0xDBFF&&p=0xDC00&&s<=0xDFFF){
+n+=%_StringCharFromCode(s);
+p++;
+}
+}
+(m[h]=p);
+}
+}
+return %_CreateIterResultObject(n,o);
+}
+function StringPrototypeIterator(){
+return CreateStringIterator(this);
+}
+%FunctionSetPrototype(StringIterator,{__proto__:d});
+%FunctionSetInstanceClassName(StringIterator,'String Iterator');
+b.InstallFunctions(StringIterator.prototype,2,[
+'next',StringIteratorNext
+]);
+%AddNamedProperty(StringIterator.prototype,i,
+"String Iterator",1|2);
+b.SetFunctionName(StringPrototypeIterator,e);
+%AddNamedProperty(c.prototype,e,
+StringPrototypeIterator,2);
+})
+
+$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;k0){
+return R(U,%_Arguments(0));
+}else{
+return R(U);
+}
+}
+}
+%FunctionSetName(V,T);
+%FunctionRemovePrototype(V);
+%SetNativeFlag(V);
+this[T]=V;
+}
+return this[T];
+}
+%FunctionSetName(getter,Q);
+%FunctionRemovePrototype(getter);
+%SetNativeFlag(getter);
+r(P.prototype,Q,{
+get:getter,
+enumerable:false,
+configurable:true
+});
+}
+function supportedLocalesOf(Y,Z,aa){
+if((%_Call(x,Y,GetServiceRE())===null)){
+throw m(7,Y);
+}
+if((aa===(void 0))){
+aa={};
+}else{
+aa=(%_ToObject(aa));
+}
+var ab=aa.localeMatcher;
+if(!(ab===(void 0))){
+ab=l(ab);
+if(ab!=='lookup'&&ab!=='best fit'){
+throw n(183,ab);
+}
+}else{
+ab='best fit';
+}
+var ac=initializeLocaleList(Z);
+if((E[Y]===(void 0))){
+E[Y]=getAvailableLocalesOf(Y);
+}
+if(ab==='best fit'){
+return initializeLocaleList(bestFitSupportedLocalesOf(
+ac,E[Y]));
+}
+return initializeLocaleList(lookupSupportedLocalesOf(
+ac,E[Y]));
+}
+function lookupSupportedLocalesOf(ac,ad){
+var ae=[];
+for(var af=0;af=3&&S<=8&&!(au===(void 0))){
+at[au]=av;
+au=(void 0);
+}else{
+return{};
+}
+}
+return at;
+}
+function setOptions(aw,at,ax,aj,ay){
+var ar='';
+var az=function updateExtension(aA,ao){
+return'-'+aA+'-'+l(ao);
+}
+var aB=function updateProperty(ak,al,ao){
+if(al==='boolean'&&(typeof ao==='string')){
+ao=(ao==='true')?true:false;
+}
+if(!(ak===(void 0))){
+defineWEProperty(ay,ak,ao);
+}
+}
+for(var aA in ax){
+if(%HasOwnProperty(ax,aA)){
+var ao=(void 0);
+var aC=ax[aA];
+if(!(aC.property===(void 0))){
+ao=aj(aC.property,aC.type,aC.values);
+}
+if(!(ao===(void 0))){
+aB(aC.property,aC.type,ao);
+ar+=az(aA,ao);
+continue;
+}
+if(%HasOwnProperty(at,aA)){
+ao=at[aA];
+if(!(ao===(void 0))){
+aB(aC.property,aC.type,ao);
+ar+=az(aA,ao);
+}else if(aC.type==='boolean'){
+aB(aC.property,aC.type,true);
+ar+=az(aA,true);
+}
+}
+}
+}
+return ar===''?'':'-u'+ar;
+}
+function freezeArray(aD){
+var aE=aD.length;
+for(var af=0;af>>0);
+for(var aX=0;aXbB){
+throw n(186,ak);
+}
+return p(ao);
+}
+return bC;
+}
+var bD={
+get(){
+%IncrementUseCounter(15);
+return this[s];
+},
+set(ao){
+this[s]=ao;
+}
+};
+function initializeNumberFormat(bE,Z,aa){
+if(%IsInitializedIntlObject(bE)){
+throw o(132,"NumberFormat");
+}
+if((aa===(void 0))){
+aa={};
+}
+var aj=getGetOption(aa,'numberformat');
+var ag=resolveLocale('numberformat',Z,aa);
+var br={};
+defineWEProperty(br,'style',aj(
+'style','string',['decimal','percent','currency'],'decimal'));
+var bz=aj('currency','string');
+if(!(bz===(void 0))&&!isWellFormedCurrencyCode(bz)){
+throw n(169,bz);
+}
+if(br.style==='currency'&&(bz===(void 0))){
+throw o(28);
+}
+var bF=aj(
+'currencyDisplay','string',['code','symbol','name'],'symbol');
+if(br.style==='currency'){
+defineWEProperty(br,'currency',%StringToUpperCase(bz));
+defineWEProperty(br,'currencyDisplay',bF);
+}
+var bG=getNumberOption(aa,'minimumIntegerDigits',1,21,1);
+defineWEProperty(br,'minimumIntegerDigits',bG);
+var bH=aa['minimumFractionDigits'];
+var bI=aa['maximumFractionDigits'];
+if(!(bH===(void 0))||br.style!=='currency'){
+bH=getNumberOption(aa,'minimumFractionDigits',0,20,0);
+defineWEProperty(br,'minimumFractionDigits',bH);
+}
+if(!(bI===(void 0))||br.style!=='currency'){
+var bJ=br.style==='percent'?0:3;
+bH=(bH===(void 0))?0:bH;
+var bK=(bH>bJ)?bH:bJ;
+bI=getNumberOption(aa,'maximumFractionDigits',bH,20,bK);
+defineWEProperty(br,'maximumFractionDigits',bI);
+}
+var bL=aa['minimumSignificantDigits'];
+var bM=aa['maximumSignificantDigits'];
+if(!(bL===(void 0))||!(bM===(void 0))){
+bL=getNumberOption(aa,'minimumSignificantDigits',1,21,0);
+defineWEProperty(br,'minimumSignificantDigits',bL);
+bM=getNumberOption(aa,'maximumSignificantDigits',bL,21,21);
+defineWEProperty(br,'maximumSignificantDigits',bM);
+}
+defineWEProperty(br,'useGrouping',aj(
+'useGrouping','boolean',(void 0),true));
+var at=parseExtension(ag.extension);
+var bN={
+'nu':{'property':(void 0),'type':'string'}
+};
+var ar=setOptions(aa,at,bN,
+aj,br);
+var bw=ag.locale+ar;
+var ap=q({},{
+currency:{writable:true},
+currencyDisplay:{writable:true},
+locale:{writable:true},
+maximumFractionDigits:{writable:true},
+minimumFractionDigits:{writable:true},
+minimumIntegerDigits:{writable:true},
+numberingSystem:{writable:true},
+pattern:bD,
+requestedLocale:{value:bw,writable:true},
+style:{value:br.style,writable:true},
+useGrouping:{writable:true}
+});
+if(%HasOwnProperty(br,'minimumSignificantDigits')){
+defineWEProperty(ap,'minimumSignificantDigits',(void 0));
+}
+if(%HasOwnProperty(br,'maximumSignificantDigits')){
+defineWEProperty(ap,'maximumSignificantDigits',(void 0));
+}
+var bO=%CreateNumberFormat(bw,
+br,
+ap);
+if(br.style==='currency'){
+r(ap,'currencyDisplay',{value:bF,
+writable:true});
+}
+%MarkAsInitializedIntlObjectOfType(bE,'numberformat',bO);
+bE[u]=ap;
+r(bE,'resolved',bp);
+return bE;
+}
+%AddNamedProperty(D,'NumberFormat',function(){
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+if(!this||this===D){
+return new D.NumberFormat(Z,aa);
+}
+return initializeNumberFormat((%_ToObject(this)),Z,aa);
+},
+2
+);
+%AddNamedProperty(D.NumberFormat.prototype,'resolvedOptions',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(!%IsInitializedIntlObjectOfType(this,'numberformat')){
+throw o(133,"NumberFormat");
+}
+var bP=this;
+var ag=getOptimalLanguageTag(bP[u].requestedLocale,
+bP[u].locale);
+var aN={
+locale:ag,
+numberingSystem:bP[u].numberingSystem,
+style:bP[u].style,
+useGrouping:bP[u].useGrouping,
+minimumIntegerDigits:bP[u].minimumIntegerDigits,
+minimumFractionDigits:bP[u].minimumFractionDigits,
+maximumFractionDigits:bP[u].maximumFractionDigits,
+};
+if(aN.style==='currency'){
+defineWECProperty(aN,'currency',bP[u].currency);
+defineWECProperty(aN,'currencyDisplay',
+bP[u].currencyDisplay);
+}
+if(%HasOwnProperty(bP[u],'minimumSignificantDigits')){
+defineWECProperty(aN,'minimumSignificantDigits',
+bP[u].minimumSignificantDigits);
+}
+if(%HasOwnProperty(bP[u],'maximumSignificantDigits')){
+defineWECProperty(aN,'maximumSignificantDigits',
+bP[u].maximumSignificantDigits);
+}
+return aN;
+},
+2
+);
+%FunctionSetName(D.NumberFormat.prototype.resolvedOptions,
+'resolvedOptions');
+%FunctionRemovePrototype(D.NumberFormat.prototype.resolvedOptions);
+%SetNativeFlag(D.NumberFormat.prototype.resolvedOptions);
+%AddNamedProperty(D.NumberFormat,'supportedLocalesOf',function(Z){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return supportedLocalesOf('numberformat',Z,%_Arguments(1));
+},
+2
+);
+%FunctionSetName(D.NumberFormat.supportedLocalesOf,'supportedLocalesOf');
+%FunctionRemovePrototype(D.NumberFormat.supportedLocalesOf);
+%SetNativeFlag(D.NumberFormat.supportedLocalesOf);
+function formatNumber(bO,ao){
+var bQ=(%_ToNumber(ao))+0;
+return %InternalNumberFormat(%GetImplFromInitializedIntlObject(bO),
+bQ);
+}
+function parseNumber(bO,ao){
+return %InternalNumberParse(%GetImplFromInitializedIntlObject(bO),
+l(ao));
+}
+addBoundMethod(D.NumberFormat,'format',formatNumber,1);
+addBoundMethod(D.NumberFormat,'v8Parse',parseNumber,1);
+function toLDMLString(aa){
+var aj=getGetOption(aa,'dateformat');
+var bR='';
+var bS=aj('weekday','string',['narrow','short','long']);
+bR+=appendToLDMLString(
+bS,{narrow:'EEEEE',short:'EEE',long:'EEEE'});
+bS=aj('era','string',['narrow','short','long']);
+bR+=appendToLDMLString(
+bS,{narrow:'GGGGG',short:'GGG',long:'GGGG'});
+bS=aj('year','string',['2-digit','numeric']);
+bR+=appendToLDMLString(bS,{'2-digit':'yy','numeric':'y'});
+bS=aj('month','string',
+['2-digit','numeric','narrow','short','long']);
+bR+=appendToLDMLString(bS,{'2-digit':'MM','numeric':'M',
+'narrow':'MMMMM','short':'MMM','long':'MMMM'});
+bS=aj('day','string',['2-digit','numeric']);
+bR+=appendToLDMLString(
+bS,{'2-digit':'dd','numeric':'d'});
+var bT=aj('hour12','boolean');
+bS=aj('hour','string',['2-digit','numeric']);
+if((bT===(void 0))){
+bR+=appendToLDMLString(bS,{'2-digit':'jj','numeric':'j'});
+}else if(bT===true){
+bR+=appendToLDMLString(bS,{'2-digit':'hh','numeric':'h'});
+}else{
+bR+=appendToLDMLString(bS,{'2-digit':'HH','numeric':'H'});
+}
+bS=aj('minute','string',['2-digit','numeric']);
+bR+=appendToLDMLString(bS,{'2-digit':'mm','numeric':'m'});
+bS=aj('second','string',['2-digit','numeric']);
+bR+=appendToLDMLString(bS,{'2-digit':'ss','numeric':'s'});
+bS=aj('timeZoneName','string',['short','long']);
+bR+=appendToLDMLString(bS,{short:'z',long:'zzzz'});
+return bR;
+}
+function appendToLDMLString(bS,bU){
+if(!(bS===(void 0))){
+return bU[bS];
+}else{
+return'';
+}
+}
+function fromLDMLString(bR){
+bR=%_Call(y,bR,GetQuotedStringRE(),'');
+var aa={};
+var aM=%_Call(x,bR,/E{3,5}/g);
+aa=appendToDateTimeObject(
+aa,'weekday',aM,{EEEEE:'narrow',EEE:'short',EEEE:'long'});
+aM=%_Call(x,bR,/G{3,5}/g);
+aa=appendToDateTimeObject(
+aa,'era',aM,{GGGGG:'narrow',GGG:'short',GGGG:'long'});
+aM=%_Call(x,bR,/y{1,2}/g);
+aa=appendToDateTimeObject(
+aa,'year',aM,{y:'numeric',yy:'2-digit'});
+aM=%_Call(x,bR,/M{1,5}/g);
+aa=appendToDateTimeObject(aa,'month',aM,{MM:'2-digit',
+M:'numeric',MMMMM:'narrow',MMM:'short',MMMM:'long'});
+aM=%_Call(x,bR,/L{1,5}/g);
+aa=appendToDateTimeObject(aa,'month',aM,{LL:'2-digit',
+L:'numeric',LLLLL:'narrow',LLL:'short',LLLL:'long'});
+aM=%_Call(x,bR,/d{1,2}/g);
+aa=appendToDateTimeObject(
+aa,'day',aM,{d:'numeric',dd:'2-digit'});
+aM=%_Call(x,bR,/h{1,2}/g);
+if(aM!==null){
+aa['hour12']=true;
+}
+aa=appendToDateTimeObject(
+aa,'hour',aM,{h:'numeric',hh:'2-digit'});
+aM=%_Call(x,bR,/H{1,2}/g);
+if(aM!==null){
+aa['hour12']=false;
+}
+aa=appendToDateTimeObject(
+aa,'hour',aM,{H:'numeric',HH:'2-digit'});
+aM=%_Call(x,bR,/m{1,2}/g);
+aa=appendToDateTimeObject(
+aa,'minute',aM,{m:'numeric',mm:'2-digit'});
+aM=%_Call(x,bR,/s{1,2}/g);
+aa=appendToDateTimeObject(
+aa,'second',aM,{s:'numeric',ss:'2-digit'});
+aM=%_Call(x,bR,/z|zzzz/g);
+aa=appendToDateTimeObject(
+aa,'timeZoneName',aM,{z:'short',zzzz:'long'});
+return aa;
+}
+function appendToDateTimeObject(aa,bS,aM,bU){
+if((aM===null)){
+if(!%HasOwnProperty(aa,bS)){
+defineWEProperty(aa,bS,(void 0));
+}
+return aa;
+}
+var ak=aM[0];
+defineWEProperty(aa,bS,bU[ak]);
+return aa;
+}
+function toDateTimeOptions(aa,bV,bW){
+if((aa===(void 0))){
+aa={};
+}else{
+aa=(%_ToObject(aa));
+}
+var bX=true;
+if((bV==='date'||bV==='any')&&
+(!(aa.weekday===(void 0))||!(aa.year===(void 0))||
+!(aa.month===(void 0))||!(aa.day===(void 0)))){
+bX=false;
+}
+if((bV==='time'||bV==='any')&&
+(!(aa.hour===(void 0))||!(aa.minute===(void 0))||
+!(aa.second===(void 0)))){
+bX=false;
+}
+if(bX&&(bW==='date'||bW==='all')){
+r(aa,'year',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+r(aa,'month',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+r(aa,'day',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+}
+if(bX&&(bW==='time'||bW==='all')){
+r(aa,'hour',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+r(aa,'minute',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+r(aa,'second',{value:'numeric',
+writable:true,
+enumerable:true,
+configurable:true});
+}
+return aa;
+}
+function initializeDateTimeFormat(bY,Z,aa){
+if(%IsInitializedIntlObject(bY)){
+throw o(132,"DateTimeFormat");
+}
+if((aa===(void 0))){
+aa={};
+}
+var ag=resolveLocale('dateformat',Z,aa);
+aa=toDateTimeOptions(aa,'any','date');
+var aj=getGetOption(aa,'dateformat');
+var ab=aj('formatMatcher','string',
+['basic','best fit'],'best fit');
+var bR=toLDMLString(aa);
+var bZ=canonicalizeTimeZoneID(aa.timeZone);
+var br={};
+var at=parseExtension(ag.extension);
+var ca={
+'ca':{'property':(void 0),'type':'string'},
+'nu':{'property':(void 0),'type':'string'}
+};
+var ar=setOptions(aa,at,ca,
+aj,br);
+var bw=ag.locale+ar;
+var ap=q({},{
+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},
+[s]:{writable:true},
+pattern:bD,
+requestedLocale:{value:bw,writable:true},
+second:{writable:true},
+timeZone:{writable:true},
+timeZoneName:{writable:true},
+tz:{value:bZ,writable:true},
+weekday:{writable:true},
+year:{writable:true}
+});
+var bO=%CreateDateTimeFormat(
+bw,{skeleton:bR,timeZone:bZ},ap);
+if(ap.timeZone==="Etc/Unknown"){
+throw n(192,bZ);
+}
+%MarkAsInitializedIntlObjectOfType(bY,'dateformat',bO);
+bY[u]=ap;
+r(bY,'resolved',bp);
+return bY;
+}
+%AddNamedProperty(D,'DateTimeFormat',function(){
+var Z=%_Arguments(0);
+var aa=%_Arguments(1);
+if(!this||this===D){
+return new D.DateTimeFormat(Z,aa);
+}
+return initializeDateTimeFormat((%_ToObject(this)),Z,aa);
+},
+2
+);
+%AddNamedProperty(D.DateTimeFormat.prototype,'resolvedOptions',function(){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+if(!%IsInitializedIntlObjectOfType(this,'dateformat')){
+throw o(133,"DateTimeFormat");
+}
+var cb={
+'gregorian':'gregory',
+'japanese':'japanese',
+'buddhist':'buddhist',
+'roc':'roc',
+'persian':'persian',
+'islamic-civil':'islamicc',
+'islamic':'islamic',
+'hebrew':'hebrew',
+'chinese':'chinese',
+'indian':'indian',
+'coptic':'coptic',
+'ethiopic':'ethiopic',
+'ethiopic-amete-alem':'ethioaa'
+};
+var bP=this;
+var cc=fromLDMLString(bP[u][s]);
+var cd=cb[bP[u].calendar];
+if((cd===(void 0))){
+cd=bP[u].calendar;
+}
+var ag=getOptimalLanguageTag(bP[u].requestedLocale,
+bP[u].locale);
+var aN={
+locale:ag,
+numberingSystem:bP[u].numberingSystem,
+calendar:cd,
+timeZone:bP[u].timeZone
+};
+addWECPropertyIfDefined(aN,'timeZoneName',cc.timeZoneName);
+addWECPropertyIfDefined(aN,'era',cc.era);
+addWECPropertyIfDefined(aN,'year',cc.year);
+addWECPropertyIfDefined(aN,'month',cc.month);
+addWECPropertyIfDefined(aN,'day',cc.day);
+addWECPropertyIfDefined(aN,'weekday',cc.weekday);
+addWECPropertyIfDefined(aN,'hour12',cc.hour12);
+addWECPropertyIfDefined(aN,'hour',cc.hour);
+addWECPropertyIfDefined(aN,'minute',cc.minute);
+addWECPropertyIfDefined(aN,'second',cc.second);
+return aN;
+},
+2
+);
+%FunctionSetName(D.DateTimeFormat.prototype.resolvedOptions,
+'resolvedOptions');
+%FunctionRemovePrototype(D.DateTimeFormat.prototype.resolvedOptions);
+%SetNativeFlag(D.DateTimeFormat.prototype.resolvedOptions);
+%AddNamedProperty(D.DateTimeFormat,'supportedLocalesOf',function(Z){
+if(!(new.target===(void 0))){
+throw o(87);
+}
+return supportedLocalesOf('dateformat',Z,%_Arguments(1));
+},
+2
+);
+%FunctionSetName(D.DateTimeFormat.supportedLocalesOf,'supportedLocalesOf');
+%FunctionRemovePrototype(D.DateTimeFormat.supportedLocalesOf);
+%SetNativeFlag(D.DateTimeFormat.supportedLocalesOf);
+function formatDate(bO,ce){
+var cf;
+if((ce===(void 0))){
+cf=%DateCurrentTime();
+}else{
+cf=(%_ToNumber(ce));
+}
+if(!f(cf))throw n(161);
+return %InternalDateFormat(%GetImplFromInitializedIntlObject(bO),
+new i(cf));
+}
+function parseDate(bO,ao){
+return %InternalDateParse(%GetImplFromInitializedIntlObject(bO),
+l(ao));
+}
+addBoundMethod(D.DateTimeFormat,'format',formatDate,0);
+addBoundMethod(D.DateTimeFormat,'v8Parse',parseDate,1);
+function canonicalizeTimeZoneID(cg){
+if((cg===(void 0))){
+return cg;
+}
+var ch=%StringToUpperCase(cg);
+if(ch==='UTC'||ch==='GMT'||
+ch==='ETC/UTC'||ch==='ETC/GMT'){
+return'UTC';
+}
+var aM=%_Call(x,cg,GetTimezoneNameCheckRE());
+if((aM===null))throw n(162,cg);
+var aN=toTitleCaseTimezoneLocation(aM[1])+'/'+
+toTitleCaseTimezoneLocation(aM[2]);
+if(!(aM[3]===(void 0))&&3