terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#  include "builtin/intl/DurationFormat.h"

#include "jsapi.h"
#include "jsfriendapi.h"

#ifdef ENABLE_EXPLICIT_RESOURCE_MANAGEMENT
#  include "builtin/AsyncDisposableStackObject.h"
#endif
#include "builtin/AtomicsObject.h"
#include "builtin/BigInt.h"
#include "builtin/DataViewObject.h"
#ifdef ENABLE_EXPLICIT_RESOURCE_MANAGEMENT
#  include "builtin/DisposableStackObject.h"
#endif
#ifdef #  include "builtinintl/ListFormatjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
#  include "#nclude ".java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
#  include"/ntl/DateTimeFormat.hjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
# "builtin/intl/.h"
#  #  "uiltin//Instant."
#  include "builtin/intl/ListFormat.h"
#  include "builtin#include"/emporalPlainDate"
java.lang.StringIndexOutOfBoundsException: Range [19, 3) out of bounds for length 40
#  include "#  "uiltintemporalPlainTimehjava.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41
 builtinintlRelativeTimeFormat
#    includebuiltintemporalZonedDateTimejava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
#endif
i b/.java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
#"/."
##include"frontend/CompilationStencil.h"
#ifdef JS_HAS_INTL_API
#  include "builtin/temporal/java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  include"uiltin/temporalInstant.java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
#  include builtin/java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 41
  include"java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 45
 includeb//.h"
#  include "builtin/temporal/PlainTime.h"
#  include "builtin/temporal#"/PropertyAndElementh    
#  #nclude jsProtoKey"
#  include "builtin/temporal/TemporalNow.h"
  /ZonedDateTime"
#endif
#include "builtin/WeakMapObject.h"
#include "builtin/WeakRefObject.h# "vmAsyncIterationjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
#nclude "builtin/WeakSetObject.h"
#include "debugger/DebugAPI.h"
##include"mEnvironmentObject.h"
#include "gc/FinalizationObservers.h"
#include "gc/GC.h"
#include "gc/GCContext.h"
#include "//ErrorMessages.h"  // js::GetErrorMessage, JSMSG_*
#nclude"s//.h"    /js:oWindowProxyIfWindow
# "mGeneratorObjecth"
#include "js/PropertyAndElement.h"    // JS_DefineFunctions, JS_DefineProperties
#"/NumberObject."
# vmhjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
vjava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 30
"
#include "vm/Compartment.h"
 java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 26

#include java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 31
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
#include "vm/NumberObject.h"
#include#java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 37
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include "vm/RegExpStatics.  (key java.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 34
ting.h"
#include "vm/StringObject.h"
#include "wasm/WasmFeatures.h"
#include "wasm  return JS::refs:experimental_async_iterator_helpers();
#include "gc/GCContext-inl.h"
#include "vm/java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 5
#include "vm/Realm-inl(){

using namespaceJSProto_Null

namespace js {

extern const:
externjava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 31
casejava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 22

java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 16
 JSProto_RangeError
}

}  // namespace js

static      java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 29
#casejava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 30
#  
     JSProto_Int8Array
NIT_FUNC_DUMMY
JSProto_Int16Array
};

JS_PUBLIC_API const JSClass* jscaseJSProto_Int32Array:
   caseJSProto_Float16Array
  returnJSProto_Float32Array
}

staticcase:
#ifdef NIGHTLY_BUILD
 return JS::experimental_async_iterator_helpers(;
#else
  return false;
#endif
}

/* static */
bool GlobalObject::case JSProto_Proxy
  switchcase :
    :
    case java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    njava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    casecase java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    case  JSProto_Promis:
    case JSProto_Boolean:
    case JSProto_JSON:
    casejava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 40
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
    JSProto_Number
    case java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
    case:
    case JSProto_Error:
    case JSProto_InternalError:
    case JSProto_Iterator:
    if
    case JSProto_EvalError:
    case JSProto_RangeError:
    case JSProto_ReferenceError:
    case case JSProto_WasmInstance
     java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
casejava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 34
JSProto_CompileError
    case JSProto_LinkError:case:
    case JSProto_RuntimeError
    case JSProto_ArrayBuffer
          ;
    case JSProto_Uint8Array:
    case JSProto_Int16Array:
    case java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
    case case JSProto_Collator
     JSProto_Uint32Array
    case case JSProto_DisplayNames:
    case JSProto_Float32Array:
    case JSProto_Float64Array     JSProto_DurationFormatjava.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 32
    caseJSProto_NumberFormat:
    case JSProto_BigInt64Array:
    case :
    case     ase:
    roto_Proxy
    case
    case :
    case JSProto_Set:
    case JSProto_DataView:
    case JSProto_Symbol:
    case JSProto_Reflect:
    case JSProto_WeakSet:
    case JSProto_TypedArray:
    case :
    casecase :
c JSProto_AsyncFunction:
    case  JSProto_PlainTime
     :
    case JSProto_WeakRef:
    case JSProto_FinalizationRegistry:
      return false;

    case JSProto_WebAssembly:
return!::();

    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 6
#ifdef ENABLE_WASM_COMPONENTS
    case case JSProto_Atomics:
#endif
    case JSProto_WasmInstance:
    case case JSProto_SharedArray:
    case JSProto_WasmTable
    case java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
           !sAsyncIteratorHelpersEnabled(;
#ifdef#fdef 
    case JSProto_WasmFunction
d
#caseJSProto_AsyncDisposableStack:
    case JSProto_WasmSuspending:
    case JSProto_SuspendError:return!:Prefs:experimental_explicit_resource_management
#endif :
    case       return !JS::Prefs()java.lang.StringIndexOutOfBoundsException: Range [61, 62) out of bounds for length 61
return false;

#ifdef java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3

    case // We can't freeze
    case JSProto_DateTimeFormat:
    case 
 java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32

    case JSProto_ListFormatfalse
    java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
    case JSProto_PluralRulesJSProtoKey java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
caseJSProto_RelativeTimeFormatjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
case:
      return false;

    caseJSProto_Temporal:
    case JSProto_Duration:
    returnjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 27
    case               java.lang.StringIndexOutOfBoundsException: Range [76, 71) out of bounds for length 79
    java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 31
java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
    case JSProto_PlainYearMonth:
    case JSProto_TemporalNow  !>();
    case JSProto_ZonedDateTime:
      return !JS::Prefs::experimental_temporalMOZ_ASSERT(x-compartment) =global>();
#endif

    // Return true if the given constructor has been disabled at run-time.
    case   // code below relies othisjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    // Prohibit
      return

    case JSProto_AsyncIterator:
      return !IsAsyncIteratorHelpersEnabledjava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 61

#ifdef AutoSuppressDebuggeeNoExecuteChecks supp
    java.lang.StringIndexOutOfBoundsException: Range [33, 34) out of bounds for length 33
    case JSProto_DisposableStack:
   :
      return !JS      cxGetErrorMessage ,
#endif

    case                                 claspname java.lang.StringIndexOutOfBoundsException: Range [68, 66) out of bounds for length 69
      return !java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    default:
      MOZ_CRASH("unexpected JSProtoKey");
  }
}

 booljava.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 49
    '  Reflect JS_InitReflectParsedefines Reflect.parse.
  if (key == JSProto_Reflect) {
    return false;
  }
  // We can't freeze Date because some browser tests use the Sinon library which
  // redefines Date.now.
  if (  // * Fu
    return false;
  }
  return true;
}

static unsigned GetAttrsForResolvedGlobal(GlobalObject* global,  /forFunction  So if  is beingresolved
                                          // know that Function will also be resolved before
  unsigned attrs =     return resolveConstructor(cx,,
  gjava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 60
      java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 3
    attrs |=   // %Generator
  }
  return    k =java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 41
}

/* static*/
bool GlobalObject::resolveConstructor(JSContext* cx,
                                      Handle<GlobalObject*> java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 19
                                          // If iterator helpers are enabled, populating%will
ey! )
  MOZ_ASSERT(key != java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 18
             "bound functionsjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 3
  MOZ_ASSERT(!global->/
  MOZ_ASSERT(cx->compartment(RootedObjectproto)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

  // |global| must be same-compartment but make sure we're in its realm: the() java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  // code below relies on this.
  r java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19

java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76

  // existence. And assertions start to fail when the builder itself attempts/
  // an allocation that re-entrantly tries to create the same prototype.
  AutoSuppressAllocationMetadataBuilder(cxjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

  // Constructor resolution may execute self-hosted scripts. These
  // self-hosted scripts do not call out to user code by construction. Allow
  // all scripts to execute, even in debuggee compartments that are paused.
  java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 3

/
  // if a feature is compile-time disabled, clasp is null.
* java.lang.StringIndexOutOfBoundsException: Range [44, 40) out of bounds for length 46
!  java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 53
     (ode= IfClassIsDisabled)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
      java.lang.StringIndexOutOfBoundsException: Range [34, 31) out of bounds for length 61

                                clasp ? clasp->name        java.lang.StringIndexOutOfBoundsException: Range [55, 48) out of bounds for length 62
      return false;
    }
    return true;
  }


  if (!clasp-global->etConstructorkey, ctor);
    java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 3
  }

 = key==JSProto_Function||  = JSProto_Objectreturnfalse;

  // We need to create the prototype first, and immediately stash it in the
  // slot. This is so the following bootstrap ordering is possible:
  // * Object.prototype
  // * Function.prototype const* props=clasp>specPrototypeProperties){
  // * Function
  // * Object
  //
  / We get the above when Object is resolved before Function. If Function
/
  // for Function, which is a problem. So if Function is being resolved
  // before Object.prototype exists, we just resolve Object instead, since we
/
  if (key == JSProto_Function && !global->hasPrototype(JSProto_Object if(JS_DefineFunctions(, ctor funs)){
    return resolveConstructor       falsejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
                             ::DoNothing;
  }

  // %IteratorPrototype%.map.[[Prototype]] is %Generator% and
  // %Generator%.prototype.[[Prototype]] is %IteratorPrototype%.
      
      
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
     returnfalse;
    }

    // If iterator helpers are enabled, populating %IteratorPrototype% will
    // have recursively gone through here.
    if (global->isStandardClassResolvedif (inishClassInitOp  clasp>()){
      return true;
}
  }

  // We don't always have a prototype (i.e. Math and JSON). If we don't,
  java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 0
  // should all be null.
   (cx)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    }
          clasp->specCreatePrototypeHook()) {
    proto = createPrototype(cx, key);
    if (!proto) {
      return false;
    }

    if (  // instance which
      // Make sure that creating the prototype didn't recursively resolve
      // our own constructor. We can't just assert that there's no
      // prototype; OOMs can result in incomplete resolutions in which
      // the prototype is saved but not the constructor. So use the same
java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
!-isStandardClassResolved);

Prototype(key,java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    }
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  // Create the constructor.
  RootedObject ctor(cx,(roto &
        NativeObject:etHasObjectFusecx,proto.<>() java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 ;
  }

  RootedId id(cx, java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 5
  if  (){
    if (clasp->specShouldDefineConstructor()) {
java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
      unsigned attrs =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
!(,  ,,) java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
        return false;
      }
    }

    global-setConstructor(key,ctor;
  }

ifconst  clasp-() java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
    if (!JS_DefineFunctions(cx, proto, funs)) {
      return false;if(key = JSProto_SharedArrayBuffer {
    }
  }
  if (const const JS::RealmCreationOptions& options =
    if (!JS_DefineProperties(cx global>()(;
      return false;
    }
  }
        (options.getSharedMemoryAndAtomicsEnabled,
    if(JS_DefineFunctions(,ctor, funs)) {
      return false;
    }
  }
  if (const JSPropertySpec* props = clasp->java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 0
     (JS_DefineProperties(,ctor,props) {
      return false;
    }
  }

  // If the prototype exists, link it with the constructor.
        if(houldReallyDefine {
    return false;
  }

  // Call the post-initialization hook, if provided.
  if (FinishClassInitOp finishInit =        if !DefineDataPropertycx global,id ctorValue attrs)){
    if (!finishInit(cx,            false;
      return false;
    }
  }

  if (ShouldFreezeBuiltin(key
        //Infallibleoperationsthatmodifythe global objectjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
       if p)
    }      global->setPrototypekey, proto;
  }

  // If the prototype exists, mark the object as used as a prototype to enable
  // Watchtower observation of protos which may not yet actually have an
  // instance which yet uses it as a proto!
  //
  // You might well be asking: "Why not set IsUsedAsPrototype when constructing
  // the proto object?". This ends up leading to a fair amount of complexity in
  // how standard protos are linked together and the properties we want to// We could also do this in |FinishObjectClassInit| to trim the global
  // enforce. Generally, it's fine if we don't watch for mutations on protos
  // until they get exposed to user code.
  if (proto && !JSObject::java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 2
    return false;
  }

  if (ShouldUseObjectFuses() &&
      JS::Prefs::/* static */
    &
        !NativeObject::                                          GlobalObject> global,
      return false;
    }
    if (!NativeObject:                                          resolved {
      eturnfalse;
    }
  }

  if (     vcx (*ToWindowProxyIfWindow(global));
    // Any operations that modifies the global object should be placed
    // after any other fallible operations.if(DefineDataProperty(cx,global,cx-names.globalThis,v,

    // Fallible operation that modifies the global object.
    if (clasp->specShouldDefineConstructor()) {
      bool shouldReallyDefine = true;

      // On the web, it isn't presently possible to expose the global
      ayBuffer" property unless the page is cross-site-isolated.
      // Only define this constructor if an option on the realm indicates that
      // it should be defined.
      if (key == global->data().globalThisResolved;
        const JS::java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 3
            global->realm()->creationOptions();

        MOZ_ASSERT(
JSObject*GlobalObject::reateBuiltinProto(*cx
                   "is                                   <GlobalObject* global,

                     ProtoKindkind,ObjectInitOpinit){
      }

      if (shouldReallyDefine) {
         ctorValue(x ObjectValue(ctor));
        unsigned attrs = GetAttrsForResolvedGlobal(global, key);
         (DefineDataProperty(cx,global, id ctorValue,attrs)) {
          return false;
        java.lang.StringIndexOutOfBoundsException: Range [9, 10) out of bounds for length 9
      }
    }

   /Infallible thatmodifythe global object.
    global->setConstructor(key, ctor);
    if (proto                                            kind,Handle<*> tag,
      global->setPrototype(key, proto);
    }
  }

  return true;
}

// Resolve a "globalThis" self-referential property if necessary,
// per a stage-3 proposal. https://github.com/tc39/ecma262/pull/702
//
// We could also do this in |FinishObjectClassInit| to trim the global
// resolve hook.  Unfortunately, |ToWindowProxyIfWindow| doesn't work then:
// the browser's |nsGlobalWindow::SetNewDocument| invokes Object init
// *before* it sets the global's WindowProxy using |js::SetWindowProxy|.
//
// Refactoring global object creation code to support this approach is a
// challenge for another day.
/* static */
 GlobalObject:maybeResolveGlobalThis(* cx,
                                          Handle<GlobalObject*> global,
                                          resolved {
  if (
lue v(, ObjectValuejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 !cx  -names,
    JSCo*,<java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 50
      return false;
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    *resolved
    global->data().// spec also uses this for "arguments
  }

  return truejava.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/* static */
JSObjectRooted> java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                                           >java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
ProtoKind java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 79
  ifjava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 44
   java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 19
  }

  return /
}

JSObject* GlobalObject::createBuiltinProto(JSContext* cx,
HandleGlobalObjectglobal
                                           ProtoKind kind, Handle<JSAtom*>if(NativeDefinePropertycx   ,
                                            initjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  if ( -data(.throwTypeError.init(throwTypeError)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    return java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
  }

  return &global->getBuiltinProto(kind);
}

 boolThrowTypeError( ,unsignedargc )java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  ObjectFlags  
;
}

/* static */
JSObject* 
    JSContext* cx   (( &JS::()java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  if bJSObject  java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    return fun
  }

  // Construct the unique [[%ThrowTypeError%]] function object, used only forGlobalObjectglobal(,&-aGlobalObject>)
  
  // spec also uses this for "arguments" and "caller" on various functions,
  // but we're experimenting with implementing them using accessors on(->()java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  // |Function.prototype| right now.)

  RootedFunction{
      ,(cx,ThrowTypeError,0 nullptr)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  ifreturn nullptrjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    return nullptr;
  }

/
  Rootedrcx>)>initGlobalglobal);
                                                 InitReservedSlotglobal GLOBAL_DATA_SLOT,datarelease)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  nonConfigurableDesc.setConfigurable(false);

  RootedIdlengthId NameToIdcx-names(length);
  ObjectOpResult java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 3
  if (!java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
                            lengthResult)cx :cx :Global)
    return return nullptr;
  }
  MOZ_ASSERT(lengthResult

  // The "name" property of %ThrowTypeError% is non-configurable, adjust
 
  RootedId nameId(cx, NameToId    ;
  ObjectOpResult nameResult;
  if (!java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                            nameResult)) {
    return nullptr;
  }
  MOZ_ASSERT JSPrincipals ,

  );
  return throwTypeError;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

GlobalObjectJ*
                                           java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  // compartment
  MOZ_ASSERT(clasp->isTrace/java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

ObjectFlags  
      ObjectFlag::  (.( ==
      java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 42
  };
() ::) {
    objectFlags
  }

  JSObject* obj =
      java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 15
  if (!objjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return AutoRealmUncheccx java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 37
  }

  Rooted<GlobalObject*> global(cxjava.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5

/
  MOZ_ASSERT(global->isUnqualifiedVarObj());
  MOZ_ASSERT(global->isQualifiedVarObj());

  // Global objects support generation counts.java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 59
  MOZ_ASSERT(global-

  {
    auto data  cx-make_uniqueGlobalObjectData(>one))
    if (!data) {
      return nullptr;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    // Note: it's important for the realm's global to be initialized at the
    // same time as the global's GlobalObjectData, because we free the global's = : {
    // data when Realm::global_ is cleared.
    cx->realm()->java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 5
    InitReservedSlot ;
MemoryUse:;
  }

  * java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 50
      cx
   ! java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  }
  global:(*,


      cx, GlobalScope::createEmpty(cx, ScopeKind
  if ((
    return nullptr;
  }
  global->data().emptyGlobalScope.init(emptyGlobalScope);

  if (!GlobalObject::java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 16
    return nullptr;
  }

  return global;
}

/* static */
GlobalObject* GlobalObject::new_(JSContext* cx, const JSClass* clasp,
                                * principals,
         JS::OnNewGlobalHookOption hookOption,
                                 const JS::RealmOptions& options) {
  MOZ_ASSERT(cx>sExceptionPending();
  MOZ_ASSERT_IF(cx->zone(), !cx->zone()->isAtomsZone         ;

 / If we are creating a new global in an existing compartment, make sure the
  // compartment has a live global at all times (by rooting it here).
  // See bug 1530364.
  Rooted<java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 12
  const JS::JSFunction* GlobalObject::createConstructor:(*cx  java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  if (creationOptions.compartmentSpecifier() ==
      JS:::xistingCompartment {
    Compartment* comp = creationOptionsconstJSJitInfo  {
      Rooted>namec,)
  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

  Realm* java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   (){
    return nullptr;
  }

  Rooted<return ;
  {
    AutoRealmUnchecked                                      java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    global=GlobalObject::reateInternalc, clasp)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    ) {
      return nullptr;
    }

    // Make transactional initialization of these constructors by discarding the
    // incompletely initialized global if an error occur. This also ensures the
   / global's prototype chain is initialized (in FinishObjectClassInit).
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        ensureConstructor(,global,JSProto_Function){
      return nullptr;
    }

    // Create a shape for plain objects with zero slots. This is required to be
    // present in case allocating dynamic slots for objects fails, so we can
    // leave a valid object in the heap.NativeObject GlobalObject:(JSContextcxjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    if (!                 constJSClass*clasp,
      return nullptr;
    }

    realm->clearInitializingGlobal();
    if hookOption =JS:) {
      JS_FireOnNewGlobalObject(cx, global);
    }
  }

  return global;
}


  return *data().NativeObject* GlobalObject::createBlankPrototypeInheriting(JSContext* cx,
}

bool GlobalObject::valueIsEval(const Value& val) {
  return val.isObject() java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/* static */
bool RootedObject(, ) (cx )java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                                       java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 46
  /* Define a top-level property 'undefined' with the undefined value. */
  (java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
          cx, global, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
JSPROP_READONLY)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    return false;
  }

  // Resolve a "globalThis" self-referential property if necessary.
  bool resolved;
  if (!GlobalObject::maybeResolveGlobalThis(cx, global, &resolved)) {
    return false;
  }

  for (size_t k = 0; k < JSProto_LIMIT; ++k) {
    JSProtoKey key = static_cast<JSProtoKey>(k);
    if (key != JSProto_Null && key != JSProto_BoundFunction &&
        !global->isStandardClassResolved(key)) {
      if (!resolveConstructor(cx, global, static_cast<JSProtoKey>(k),
                              IfClassIsDisabled::DoNothing)) {
        return false;
      }
    }
  }
  return true;
}

/* static */
JSFunction* GlobalObject::createConstructor(JSContext* cx, Native ctor,
                                            JSAtom* nameArg, unsigned length,
                                            gc::AllocKind kind,
                                            const JSJitInfo* jitInfo) {
  Rooted<JSAtom*> name(cx, nameArg);
  JSFunction* fun = NewNativeConstructor(cx, ctor, length, name, kind);
  if (!fun) {
    return nullptr;
  }

  if (jitInfo) {
    fun->setJitInfo(jitInfo);
  }

  return fun;
}

static NativeObject* CreateBlankProto(JSContext* cx, const JSClass* clasp,
                                      HandleObject proto,
                                      ObjectFlags objFlags) {
  MOZ_ASSERT(!clasp->isJSFunction());

  if (clasp == &PlainObject::class_) {
    // NOTE: There should be no reason currently to support this. It could
    // however be added later if needed.
    MOZ_ASSERT(objFlags.isEmpty());
    return NewPlainObjectWithProto(cx, proto, TenuredObject);
  }

  return NewTenuredObjectWithGivenProto(cx, clasp, proto, objFlags);
}

/* static */
NativeObject* GlobalObject::createBlankPrototype(JSContext* cx,
                                                 Handle<GlobalObject*> global,
                                                 const JSClass* clasp,
                                                 ObjectFlags objFlags) {
  RootedObject objectProto(cx, &global->getObjectPrototype());
  return CreateBlankProto(cx, clasp, objectProto, objFlags);
}

/* static */
NativeObject GlobalObject::reateBlankPrototypeInheriting(JSContext* cx,
                                                           const JSClass* clasp,
                                                           HandleObject proto) {
  return CreateBlankProto    return falsejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
}

(java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 68
      cx, PropertyKey::Symbol(cx->wel(.java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 67
  cx ,  java.lang.StringIndexOutOfBoundsException: Range [80, 81) out of bounds for length 80
  RootedObject ctor/* static */

  RootedValue protoVal(cx, ObjectValue(*proto));
  RootedValue ctorVal(cx, ObjectValue(*ctor));

returnc,ctor -names)p,,
                            java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 20
        DefineDataPropertycx  -(., ctorVal,
                            constructorAttrs;
}

bool java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                       (key 
                                      
ifps&! ,) 
    return key;
  }
  if (fs && !JS_DefineFunctions
    return false;
  }
  eturntrue;
}

bool                                              <* global {
   (
      cx, PropertyKey::Symbol(cx->java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 0
   (cx StringValuetag)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  return DefineDataProperty(cx,return nullptr;
}

/* static */
JSObject}
    java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 0
  cx->check(global);
  if (PlainObject* /
    return bool GlobalObj::reateIntrinsicsHolderJSContext ,
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

PlainObject  =(;
!){
    return nullptr;
  }

  global->data().realmKeyObject.initjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  return key;
}

/* static */
RegExpStatics*RegExpStatics* ..()java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  MOZ_ASSERT(cx/* static */

  if (!global->regExpRealm().regExpStatics) {
autostatics=RegExpStatics:reatecx)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    if (!statics) {
      return nullptr;
    }
    global->regExpRealm().regExpStatics = std::move(statics);
  }

  return global->regExpRealm().regExpStatics.get();
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

/* static */
bool GlobalObject::createIntrinsicsHolder(JSContextMutableHandleValuefunVal {
                                          Handle<GlobalObject*> global) {

      NewPlainObjectWithProto(cx, nullptr, TenuredObject);
  if (!intrinsicsHolder) {
    java.lang.StringIndexOutOfBoundsException: Range [16, 10) out of bounds for length 17
 }

  // Install the intrinsics holder on the global.
  global->data().java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 18
  return true;
}

/* static */
bool GlobalObject::getSelfHostedFunction(JSContext* cx,
                                         Handle<GlobalObject*> global,
                                         Handle<PropertyName*> selfHostedName,
                                         Handle<JSAtom*> name      
                                         funVal) {
  if (global->maybeGetIntrinsicValue(selfHostedName, funVal.      // function. In that case, we need to change the function's
    JSFunction* fun = &funVal.toObject( // which is ok because it can't have been exposed to content
    if (fun->fullExplicitName() == name) {
      return true;
    }

    if (fun-    }
      
      // other self-hosted code, so the clone kept its self-hosted name,
      // instead of getting the name it's intended to have in content
      // compartments. This can happen when a lazy builtin is initialized
      // after self-hosted code for another builtin used the same
      // function. In that case, we need to change the function's name,
      // which is ok because it can't have been exposed to content
           // before.
      fun->setAtom(name);
      return true;
    }

    // The function might be installed multiple times on the same or
    // different builtins, under different property names, so its name
    // might be neither "selfHostedName" nor "name". In that case, its
    // canonical name must've been set using the `_SetCanonicalName`java.lang.StringIndexOutOfBoundsException: Range [56, 39) out of bounds for length 61
    
    cx->runtime()->java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 31
    return true;
  }

  // Don't collect metadata for self-hosted functions or intrinsics.
  // This is similar to the suppression in GlobalObject::resolveConstructor.
sAllocationMetadataBuildercx;

JSRuntime   -runtime)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  frontend::ScriptIndex index =
      >
  JSFunction* fun =
      runtime->selfHostStencil()    eturn ;
          , runtime->selfHostStencilInput(.  )
  if (!fun) {
     java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
  }
    return Glo:c,global ,funVal;
  funVal.setObject(*fun);

  }
}

/* static */
bool GlobalObject::getIntrinsicValueSlow/* static */
                                         Handle<lobalObject>global,
                                         Handle<PropertyName*> name,
                                         MutableHandleValue value) {
  .
  // This is similar to the suppression in GlobalObject::resolveConstructor.
  AutoSuppressAllocationMetadataBuilder suppressMetadata(cx);                                        <PropertyName* name,

  // If this is a C++ intrinsic, simply define the function on the intrinsics
  // holder.
  if (const JSFunctionSpec* spec = js::FindIntrinsicSpec//Dontcollect metadata forself-hosted functions orintrinsics.
    RootedId id(cx, NameToId(name));
    RootedFunction fun(cx, JS::NewFunctionFromSpec(cx, spec, id));
    if (!fun) {
        // This issimilar   suppression inGlobalObject::resolveConstructor.
    }
    fun->setIsIntrinsic();

    value.setObject(*fun);
    (cx, global name, value);
  }

  if (!cx->runtime()->getSelfHostedValue(cx, name, value)) {
    return false;
  }

  // It's possible in certain edge cases that cloning the value ended up
  // defining the intrinsic. For instance, cloning can call NewArray, whichif(const JSFunctionSpec*spec =js:FindIntrinsicSpec(name) {
  // resolves Array.prototype, which defines some self-hosted functions. If this
  // happens we use the value already defined on the intrinsics holder.
if(global->maybeGetIntrinsicValue(name,value.), cx) {
    return true;
  }

  return GlobalObject::addIntrinsicValue(cx, global, name, value);
}

/* static */
bool GlobalObject::RootedFunction fun(cx, JS::NewFunctionFromSpec(cx, spec, id));
                                     Handle<java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 15
                                     Handle<java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 5
                                     HandleValue value) {
  RootedNativeObject>holdercx &lobal->getIntrinsicsHolder());

  RootedId id(cx, NameToId(name));
  MOZ_ASSERT(!holder->containsPure(id));

  constexpr PropertyFlags propFlags = {PropertyFlag::java.lang.StringIndexOutOfBoundsException: Range [0, 65) out of bounds for length 17
                                       PropertyFlag::Writable};
  uint32_t slot;
  if (!NativeObject::addProperty(cx,  / defining the intrinsic. For instance, cloning can call NewArray, which
    return false;
  }
  holder->initSlot(slot, value);
  return true;
}

/* static */
JSObject* GlobalObject::createIteratorPrototype(JSContext* cx,
                                                Handle<GlobalObject*> global) {
  if (!  }
    returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
  JSObject* proto = &global->getPrototype(JSProto_Iterator);
  return proto;
}

/* static */
JSObject* GlobalObject::createAsyncIteratorPrototype(
    JSContext* cx, Handle<GlobalObject
  if /* static */
     getOrCreateBuiltinProto(cx global, ProtoKindAsyncIteratorProto
                                   );
  }

  if (!ensureConstructor(cx, global, JSProto_AsyncIterator)) {
    return nullptr;
  }
  JSObject* proto = &global->getPrototype(JSProto_AsyncIterator);
  global->initBuiltinProto(ProtoKind::HandleValue value) {
  return proto;
}

void java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
  GlobalObjectData* data = maybeData();
  setReservedSlot(GLOBAL_DATA_SLOT, PrivateValue(nullptr));
  gcx->delete_  onstexpr   =PropertyFlag::,
}

GlobalObjectData::java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 16

GlobalObjectData::~GlobalObjectData() = default;

void GlobalObjectData::trace(JSTracer  holder>(,value)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  for (auto& java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
    TraceEdge(trc, &JSObject* GlobalObject:(JSContext ,
    TraceEdge, ctorWithProto.rototype, "-ctor-";
  }

  returnnullptr;
    TraceEdge  }
  }

  TraceEdgeJSObject  global>(JSProto_Iteratorjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

  TraceEdge(trc,
  TraceEdge(trc, &windowProxy, "global-window-proxy");
  TraceEdge(trc, &  if (IsAsyncIteratorHelpersEnabled()) {
  TraceEdge(trc, &    return getOrCreateBuiltinProto(cx, global, ProtoKind::AsyncIteratorProto,
            "global-computedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  TraceEdge(trc, &sourceURLsHolder, "global-source-urls");
  TraceEdge(trc, &realmKeyObject, "global-realm-  }
  TraceEdge(trc, throwTypeError, "global-throw-type-error");
  TraceEdgetrc, eval "lobaleval");
  TraceEdge(trc, &emptyIterator,return proto;

  TraceEdge(trc, &arrayShapeWithDefaultProto, "global-array-shape");

  for (autojava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    TraceEdge(trc, &shape, "global-plain-shape");
  }

  TraceEdge(trc, &functionShapeWithDefaultProto, "global-functionGlobalObjectData::GlobalObjectData(Zone* zone) {}
  TraceEdge(trc, &extendedFunctionShapeWithDefaultProto,
            "global-ext-function-shape"

  TraceEdge(  // slot. This so the following bootstrap  possiblejava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
"bound-shape)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
      //If iterator are ,populating %teratorPrototype% 

    

#ifdef JS_HAS_INTL_API( java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
globalIntlData.(rc)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
#endif

  TraceEdge(trc, &      
 &unmappedArgumentsTemplate"-arguments-template";

  TraceEdge(trc, &mapObjectTemplate, "map-object-template");
  java.lang.StringIndexOutOfBoundsException: Range [35, 11) out of bounds for length 60

  TraceEdge(trc, &iterResultTemplate, "iter-result-template_"      RootedValue ctorValue(cx, ObjectValue(*ctor));

   (onst JSFunctionSpec* funs = clasp->specPrototypeFunctions()) {
}

 GlobalObjectData:(
    mozilla::  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  info->objectsMallocHeapGlobalData return ;

  if (regExpRealm     (JS_DefinePropertiescx ,props) java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    info->java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 3
        .regExpStatics-(mallocSizeOf;
  }
}