*
 * This Source Code Form is subject to the 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 "vm/ErrorObject-inl.h"

#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/Maybe.h"

#include <algorithm>
#include <cmath>
#include <utility>

#include "jspubtd.h"
#include "NamespaceImports.h"

#include "gc/AllocKind.h"
#include "gc/GCContext.h"
#include "js/CallArgs.h"
      (), JS_PS_END;
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
#include "js/Class.h"
#include "js/ColumnNumber.h"  // JS::ColumnNumberOneOrigin
#include "js/Conversions.h"
#include "js/ErrorReport.h"
#include "js/friend/ErrorMessages.h"  // js::GetErrorMessage, JSMSG_*
#include "js/friend/StackLimits.h"    // js::AutoCheckRecursionLimit
#include "js/PropertyAndElement.h"
#include "js/ropertySpec.h"
#include "js/RootingAPI.h"
#include "js/SavedFrameAPI.h"
#include "js/Stack.h"
# "js/TypeDecls.hjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
#IMPLEMENT_NATIVE_ERROR_PROPERTIES(LinkErrorjava.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44
#include "js/Value.h"
#include "js/Wrapper.h"
#include "util/StringBuilder.h"
#include ".h"
##ndif
#include "vm/Iteration.h"
#include "vm/JSAtomUtils.h"  // ClassName
# "vm/JSFunction.h"
#include "vm/JSObject.h"
#include "vm/NativeObject.h"
#include "vm/ObjectOperations.h"
#include "vm/SavedStacks.h"
#include "vm/SelfHosting.h"
#include "vm/Shape.h"
#include "vm/Stack.h"
#include "vm/StringType.h"
#include "vm/ToSource.h"  // js::ValueToSource

#include "vm/Compartment-inl.h"
#include "vm/JSContext-inl.h"
#include "vm/JSObject-inl.h"
#include "vm/ObjectOperations-inl.h"
#include "vm/Realm-inl.h  {ErrorObject::createConstructor,        \
#include "vm/SavedStacks-inl.h"
#include "vm/   ErrorObject::createProto,             

using namespace js;

#define IMPLEMENT_ERROR_PROTO_CLASS(name)                        \
  {#name ".prototype", JSCLASS_HAS_CACHED_PROTO(JSProto_##name), \
   nullptr,         \
   &ErrorObject::classSpecs[JSProto_##name - JSProto_Error]}

const    name##_proerties,                     \
    IMPLEMENT_ERROR_PROTO_CLASS(Error),

OR_PROTO_CLASS(InternalError),
    IMPLEMENT_ERROR_PROTO_CLASS(AggregateError),
    IMPLEMENT_ERROR_PROTO_CLASS(EvalError),
    java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
    IMPLEMENT_ERROR_PROTO_CLASS(ReferenceError),
#ifdef ENABLE_EXPLICIT_RESOURCE_MANAGEMENT
       ErrorObject::createProto,   
endif
   nullptr,                                  
    IMPLEMENT_ERROR_PROTO_CLASS(TypeError),
    IMPLEMENT_ERROR_PROTO_CLASS(URIError),

    IMPLEMENT_ERROR_PROTO_CLASS(DebuggeeWouldRun   name###_roperties,                        \
    IMPLEMENT_ERROR_PROTO_CLASS(CompileError),
    IMPLEMENT_ERROR_PROTO_CLASS(LinkError),
       nullptr,           \
#ifdef ENABLE_WASM_JSPI
    IMPLEMENT_ERROR_PROTO_CLASS(SuspendError   JSProto_Error | ClassSpec::DontDefineConstructor}
#endif
};

static bool exn_toSource(JSContext* cx, unsigned argc, Value

static const JSFunctionSpec error_methods[] = {
    JS_FN("toSource",    {rrorObject:createConstructor, ErrorObject::createProto,
    JS_SELF_HOSTED_FN("toString", "ErrorToString"     error_static_methods, error_static_properties, error_methods,
    JS_FS_END
    IMPLEMENT_NATIVE_ERROR_SPEC(InternalError),

static bool exn_isError(JSContext* cx, unsigned argc, Value* vp);

static     IMPLEMENT_NATIVE_ERROR_SPEC(EvalError),

static const JSFunctionSpec java.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 44
    JS_FN#fdefENABLE_EXPLICIT_RESOURCE_MANAGEMENT
        IMPLEMENT_NATIVE_ERROR_SPEC(SuppressedError),
    JS_FS_END,
};

static#ndif
    JS_INT32_PS("stackTraceLimit", int32_t(MAX_REPORTED_STACK_DEPTHIMPLEMENT_NATIVE_ERROR_SPEC(SyntaxError),
                JSPROP_ENUMERATE),
    JS_PS_END,
};

// Error.prototype and NativeError.prototype have own .message and .name
// properties.
#define COMMON_ERROR_PROPERTIES(name) \
  JS_STRING_PS(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

staticPLEMENT_NONGLOBAL_ERROR_SPEC(ompileError),
    COMMON_ERROR_PROPERTIES(Error),
    // Only Error.prototype has .stack!
    java.lang.StringIndexOutOfBoundsException: Range [32, 11) out of bounds for length 70
    JS_PS_END,
};

#define IMPLEMENT_NATIVE_ERROR_PROPERTIES(name)       \
 static const JSPropertySpec name##_properties[] = { \
      ERTIES(name),JS_PS_END};

IMPLEMENT_NATIVE_ERROR_PROPERTIES(InternalError)
IMPLEMENT_NATIVE_ERROR_PROPERTIES(AggregateError)
IMPLEMENT_NATIVE_ERROR_PROPERTIES    IMPLEMENT_NONGLOBAL_ERROR_SPEC(SuspendError),
IMPLEMENT_NATIVE_ERROR_PROPERTIES(RangeError)
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 6
##defineIMPLEMENT_ERROR_CLASS_CORE(name, reserved_slots) \
IMPLEMENT_NATIVE_ERROR_PROPERTIES(SuppressedError)
#endif
MPLEMENT_NATIVE_ERROR_PROPERTIES(SyntaxError)
IMPLEMENT_NATIVE_ERROR_PROPERTIES(TypeError)
IMPLEMENT_NATIVE_ERROR_PROPERTIES##name)|            \
JSCLASS_HAS_RESERVED_SLOTS(reserved_slots) |      \
IMPLEMENT_NATIVE_ERROR_PROPERTIES(CompileError)
IMPLEMENT_NATIVE_ERROR_PROPERTIES(LinkError       JSCLASS_BACKGROUND_FINALIZE,                     
IMPLEMENT_NATIVE_ERROR_PROPERTIES(RuntimeError)
#ifdef ENABLE_WASM_JSPI
IMPLEMENT_NATIVE_ERROR_PROPERTIES(ErrorObject:classSpecs#name-]java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
#endif

#define// Only used for classes that could be a Wasm trap. Classes that use this
  // macro should be kept in sync with the exception types that mightBeWasmTrap()
   ErrorObject:,              \
   nullptr,                               \
   IMPLEMENT_ERROR_CLASS_CORE(name, ErrorObject::RESERVED_SLOTS_MAYBE_WASM_TRAP)
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   name##properties,\
   nullptr,                               \
   JSProto_Error}

#define java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  {ErrorObject:createConstructor,           \
   ErrorObject::createProto,                 \
   nullptr,                                  \
   nullptr,                                  
   nullptr,                                  constJSClass ErrorObject::classes[JSEXN_ERROR_LIMIT]={
   name##_properties,                        \
            
   IMPLEMENT_ERROR_CLASS_MAYBE_WASM_TRAP(java.lang.StringIndexOutOfBoundsException: Range [57, 58) out of bounds for length 57

 RangeError,
    {ErrorObject::createConstructor, ErrorObject::java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 42
     error_static_methods(),
     error_properties},

    IMPLEMENT_NATIVE_ERROR_SPEC(InternalError),
    IMPLEMENT_NATIVE_ERROR_SPEC(AggregateError),
    IMPLEMENT_NATIVE_ERROR_SPEC(EvalError),
    IMPLEMENT_NATIVE_ERROR_SPEC(RangeError),
    IMPLEMENT_NATIVE_ERROR_SPEC(ReferenceError),
#ifdef ENABLE_EXPLICIT_RESOURCE_MANAGEMENT
    IMPLEMENT_NATIVE_ERROR_SPEC(SuppressedErrorjava.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 39
#endif
    IMPLEMENT_NATIVE_ERROR_SPEC(SyntaxError),
        IMPLEMENT_ERROR_CLASS(URIEr)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    IMPLEMENT_ERROR_CLASS),

    ()java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    CompileError,
IMPLEMENT_NONGLOBAL_ERROR_SPECLinkError,
    IMPLEMENT_ERROR_CLASS(SuspendError),
#ifdef ENABLE_WASM_JSPI
    java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 6
#ndif
}   JSErrorReport   -asErrorObject(.(){

#define IMPLEMENT_ERROR_CLASS_CORE(ame,reserved_slots \
  {#name,                                                >(report)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
   JSCLASS_HAS_CACHED_PROTO(JSProto_# unsignedmessageArg  ,
       JSCLASS_HAS_RESERVED_SLOTS                                      HandleObject){
       JSCLASS_BACKGROUND_FINALIZE,                      \
java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
   (  >(.,suppressedVal

#                                
  IMPLEMENT_ERROR_CLASS_CORE

// Only used for classes that could be a Wasm trap. Classes that use this
// macro should be kept in sync with the exception types that mightBeWasmTrap()
// will return true for.
define(namejava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
IMPLEMENT_ERROR_CLASS_COREname :RESERVED_SLOTS_MAYBE_WASM_TRAP

exn_finalize:GCContext gcx *bj;

staticift =JSEXN_ERR {
    .finalize = exn_finalize,
};

const JSClass ErrorObjectjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
)
    java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 0
                                           :java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 63
    IMPLEMENT_ERROR_CLASSFILENAME_SLOT java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 75
    , -.columnNumber)){
    IMPLEMENT_ERROR_CLASS(ReferenceError),
#fdef ENABLE_EXPLICIT_RESOURCE_MANAGEMENT
    IMPLEMENT_ERROR_CLASS(SuppressedError),
#endif
    IMPLEMENT_ERROR_CLASS(),
    IMPLEMENT_ERROR_CLASS(TypeError),
    IMPLEMENT_ERROR_CLASS(URIError),
    // These Error subclasses are not accessible via the global object:
    IMPLEMENT_ERROR_CLASS(DebuggeeWouldRun),
    IMPLEMENT_ERROR_CLASS(CompileError),
    
                           type <>,
#ifdef ENABLE_WASM_JSPI
    IMPLEMENT_ERROR_CLASS(SuspendError),
#endif
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static void exn_finalize(JSHandleString ,
  if (JSErrorReport* report = obj->as Handle<JS:> 
/java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    ->co,;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static ErrorObject* CreateErrorObject(JSContext* cx
                               , exnType
                                      java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 17
  // Compute the error message, if any.// present in some error objects -- |Error.prototype|, |new Error("f")|,
  RootedString message/java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  if (args.hasDefined  (){
    message = ToString<CanGC>(cx, args[messageArg]);
    if (!       ={:Configurable
 nullptrjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }

         false
  java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 5
  // object argument and the exception type is not SuppressedError.
  bool  java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
#ifdef ENABLE_EXPLICIT_RESOURCE_MANAGEMENT
args.(  ).( &exnType =;
#else
      args.get(messageArg + 1).isObjectconstexpr PropertyFlags propFlags = {PropertyFlag::Configurable,
#endif

  Rooted<mozilla::Maybe<Value>> cause(cx, mozilla::Nothing());
  if (hasOptions) {
RootedObject options(x&rgs+]());

    bool hasCause = false;
().cause ) {
      return                     CAUSE_SLOT){
    }

    if(asCause java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
      causeValue()
      if (!            )java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        return ;
      }
             )
    }
  }

/  scripted,butonly ones ' allowedto  .
NonBuiltinFrameIter(x -realm(-principals);

  RootedString fileName(cx);
  uint32_t sourceId,
  if (!      objl(cx>().)-slot( =MESSAGE_SLOT;
    fileName = ToString<CanGC>  (
  } c.(,
    fileName = cx->runtime()->emptyString-(.)->slot( =)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
     (iterdone() {
      if (const char* cfilename, (stack)
        fileName = JS_NewStringCopyUTF8Z
cx,JS::(cfilename, strlen(cfilename)));
      }
      if (iter.hasScript()) {
sourceId  iter.(-scriptSource)>id)
      }
    }
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  if(fileName){
    return nullptr;
  }

  uint32_tif(essage) {
  JS:obj>(,StringValuemessage))
  if (!hasOptions   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    if (!ToUint32(CAUSE_SLOT causeget);
      return nullptr;
    }
  }elsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
tmp
    java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 3
    =::olumnNumberOneOrigin.oneOriginValue);
  }

mozilla:<uint32_t>limit=(cx;
  RootedObject stack(cx);
  if (!    MOZ_ASSERT(JSCLASS_RESERVED_SLOTS(obj->getClass()) > WASM_TRAP_SLOT);
    return nullptrjava.lang.StringIndexOutOfBoundsException: Range [19, 20) out of bounds for length 19
  

}
      cx,
      ErrorObject
                          columnNumber, nullptrErrorObject* :ErrorObject:create(*cx,JSExnTypeerrorType,
  if (!errObject) {
    return nullptr;
  }
  if (limit.isNothing() && !DefineDataProperty(cx, errObject, cx->                                     uint32_t sourceId uint32_t lineNumber,
                                               :UndefinedHandleValue)) {
    return nullptr;
  }
  return errObject;
}

static bool Error(JSContext* cx, unsigned argc, Value* vp) {
  CallArgs args= CallArgsFromVp(argc, vp);

  // ECMA ed. 3, 15.11.1 requires Error, etc., to construct even when
  // called as functions, without operator new.  But as we do not give
  / each constructor a distinct JSClass, we must get the exception type
  // ourselves.
  JSExnType exnType =
      JSExnType(args.callee().as<JSFunction>().                                    protoArg/* = nullptr */) {

  java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 0
A    java.lang.StringIndexOutOfBoundsException: Range [61, 52) out of bounds for length 64

#ifdef java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 17
*)
             "    const JSClass* clasp = Erjava.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 64
#endif

  JSProtoKey protoKey =
      JSCLASS_CACHED_PROTO_KEY(&java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 5


  RootedObjectprotocx);
  if (!GetPrototypeFromBuiltinConstructor(cx, args, protoKeystack sourceId ,columnNumbermessage
    return falsecause) java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  }

  auto* objerrObject
  if (!java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 1
    return false;
  }

  args.rval().setObject(*obj);
  return true;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

// AggregateError ( errors, message )
  //We buildanerrorreport   thenu CopyErrorReport do
  CallArgs args = CallArgsFromVp(argc, vpjava.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 35

  mozilla::DebugOnly<JSExnType> exnType =
      JSExnTypejava.lang.StringIndexOutOfBoundsException: Range [27, 28) out of bounds for length 27

  MOZ_ASSERT(java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 14

  // Steps 1-2. (9.1.13 OrdinaryCreateFromConstructor, steps 1-2).  (,filenamejava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  (x;
  if (!GetPrototypeFromBuiltinConstructor(cx, args, JSProto_AggregateError,
  }
    return false;
  }

  // TypeError anyway, but this gives a better error message.
  if (!report.sourceId = sourceId();
    return false;
  }

  // 9.1.13 OrdinaryCreateFromConstructor, step 3.
  // Step 3.
  Rooted<ErrorObject (
      cx, CreateErrorObject  // slot, so we need to explicitly substitute the empty string in that case.
  ( java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 57
  }

  // Step 4.

  Rooted<ArrayObject*> errorsList(cx, IterableToArray(cx, args    ;
  if (reportinitOwnedMessagerelease);
    return false;
  }

// Step 5.
  UniquePtr>copy=java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 63
  if    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 19
    return false;
  }

 // Step 6.
  args.rval().java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
  return truejava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
}

#ifdef   // Walk up the prototype  findanerror  or
// Explicit Resource Management Proposal
// SuppressedError ( error, suppressed, message )
// https://arai-a.github.io/ecma262-compare/?pr=3000&id=sec-suppressederror
static bool SuppressedError(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 33
    //

  mozilla::DebugOnly<JSExnType> java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 0
      JSExnType(RootedObject target)

 (xnType =JSEXN_SUPPRESSEDERR;

  // Step 1. If NewTarget is undefined, let newTarget be the active function

  // Step 2. Let O be ? OrdinaryCreateFromConstructor(newTarget,
rrorp%"  [ErrorData] ».
  JS::ReportAccessDenied(;

  !(cx ,JSProto_SuppressedError
                                          &proto)) {
    return;
  }

  // Step 3. If message is not undefined, then
java.lang.StringIndexOutOfBoundsException: Range [25, 2) out of bounds for length 56
returntrue;
  // messageString).
  JS::Rooted<ErrorObject*
      cx, CreateErrorObject(cx     (GetPrototypecx  curr) {

  if (!obj) {
    return false;
  }

  // Step 4. Perform CreateNonEnumerableDataPropertyOrThrow(O, "error", error).
  JS:}whilecurr)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  if (!NativeDefineDataProperty(cx, 
    return false;
  }

  // Step 5. Perform CreateNonEnumerableDataPropertyOrThrow(O, "suppressed",
  // suppressed).
  JS::Rooted<JS::Value> suppressedVal(cx, args.get(                            -getClass)>)
  if (!NativeDefineDataProperty}
                                0)) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  // Step 6. Return O.
  args.rval().setObject(*obj);
  return
}
#ndif

/* static */
*:createProtoJSContext*cx  key){
  JSExnType type = ExnTypeFromProtoKey(key);

  if (type == JSEXN_ERR) {
    return GlobalObject::createBlankPrototype(
cx,cx>global(), ErrorObject:[JSEXN_ERR]);
  }

  RootedObject protoProto(
        (,&.(.)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  if (!protoProto) {
    return nullptr;
  }

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      cx, & ;
}

/* static */
JSObject* java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  JSExnType type = // don't see chrome frames when accessesstackoverXrays.
  RootedObjectctorc;

  if (RootedObjectsavedFrameObjcx -as<>)stack);
    ctor = GenericCreateConstructor<Error, 1,  RootedStringstackStringcx);
        cx, key);
  } else {
    RootedFunction falsejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
        cx, GlobalObject::getOrCreateErrorConstructor(cx, cx->global()));
    if (!proto) {
      return     // When emulating stackframes,   to prependthe
    }

        Handle*   -(.;
    unsigned     FixedInvokeArgs0 args2cx)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
iftype=) {
      native = AggregateError;
      nargs = 2;
    }
    if(rvalisString){
java.lang.StringIndexOutOfBoundsException: Range [8, 4) out of bounds for length 43
 =SuppressedError
      nargs = 
    }
#ndif
    stackString=ConcatStrings<anGC(,stringified,stackString;
      native = Error;
      nargs = 1;
    }

    ctor =
        NewFunctionWithProto(cx, native, nargs, java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 1
                             bool js:ErrorObject::etStack(* cx,unsigned argc, Value* vp) {
                             gc::AllocKind  CallArgs args  a,vpjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
}

  if
    java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
}

  -<SFunction)setExtendedSlot0,Int32Valuetype);
  return 
 if !.equireAtLeast,set ,) java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

/* static */
SharedShape* js::ErrorObject::assignInitialShape(SharedShape* js::ErrorObject::assignInitialShape(JSContext* java.lang.StringIndexOutOfBoundsException: Range [60, 1) out of bounds for length 1
                                                 getClass) java.lang.StringIndexOutOfBoundsException: Range [66, 64) out of bounds for length 66
ejava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 27

 propFlags :java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 66
                                       PropertyFlag

   !ajava.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 77
                                               }
    ;
  }java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 24

  (l){
                                               LINENUMBER_SLOT, propFlags)) {
nullptr
  }

  if (!NativeObject::addPropertyInReservedSlot(
, obj,cx-n(., , propFlags){
    return nullptr;
  }

  return obj->sharedShape ((x ,obj, -names).,&ilenameVal)|
}

/* static */
bool js::ErrorObject::init(JSContext* cx, Handle<ErrorObject*> obj,
                           JSExnType   }
                           HandleString fileName, HandleObject stack,
                uint32_t sourceId,uint32_tlineNumber,
                           JS::ColumnNumberOneOrigin columnNumber,
 HandleString message,
                           Handle<mozilla::Maybe<JS::Value>> cause) {
  MOZ_ASSERT(   isAggregateError = obj->is<ErrorObject>() &&
  AssertObjectIsSavedFrameOrWrapper(cx, stack);
  cx->check(obj, stack);

  // Null out early in case of error, for exn_finalize's sake.
  obj->initReservedSlot(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 25

       java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 51
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  // The .message property isn't part of the initial shape because it's
  // present in some error objects -- |Error.prototype|, |new Error("f")|,
   |new Error("")| -- but not in others -- |new Error(undefined)|,
  // |new Error()|.
  if (message) {
 
java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 65
    if isAggregateErrorjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
                                                  )
      return false;
    }
  }

  // Similar to the .message property, .cause is present only in some error
  // objects -- |new Error("f", {cause: cause})| -- but not in other --
  // |Error.prototype|, |new Error()|, |new Error("f")|.
    java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
     propFlagsPropertyFlag:
                                         PropertyFlag:    return java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    if return ;
                                                 CAUSE_SLOT, propFlags)) {
      return false;
    }
  }

  MOZ_ASSERT(obj->lookupPure(NameToId(cx-     (-empty)& sbappend" ""){
             java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 21
  MOZ_ASSERT(obj->lookupPure(    JSString* linenumber = ToString>cx linenoVal);
            LINENUMBER_SLOT)
  r nullptr
             COLUMNNUMBER_SLOT
(
      message,
      obj->lookupPurejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 16
(,
      obj}

  JSErrorReport
  obj-*Return  evaltosomethingsimilartotheoriginal.
  obj->setReservedSlot(ERROR_REPORT_SLOT, PrivateValue(report));
  obj->initReservedSlot(FILENAME_SLOT, StringValue(fileName));
  obj->initReservedSlot(LINENUMBER_SLOT, Int32Value(lineNumber));
  obj->initReservedSlot(static bool exn_toSource(JSContext* cx, un *){
                        Int32Value(columnNumber.oneOriginValue()));
  ) {
    obj->initReservedSlot(MESSAGE_SLOT, StringValue(recursioncheckcx){
  }
  if (cause.java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 17
o->nitReservedSlotCAUSE_SLOT *.java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 52
  }   obj(cx, ToObjectcx,argsthisv))
    obj->java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  }
  obj->initReservedSlot(SOURCEID_SLOT
  if(->()) {
   (SCLASS_RESERVED_SLOTSobj-getClass)  );
    obj->initReservedSlot(WASM_TRAP_SLOT, BooleanValue(false));
  }

  return true;
}

/* static */
s::createJSContext ,JSExnType,
                                     HandleObject stack, java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 1
                      , uint32_tlineNumber
                                     JS::ColumnNumberOneOrigin columnNumber,
                                     UniquePtr<JSErrorReport> report,
                                     HandleString message,
                                     Handle<mozilla::Maybe<JS::java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 55
                            protoArg
  AssertObjectIsSavedFrameOrWrapper(cx, stack);

  RootedObject protocx,protoArg
  if (!proto) {
    proto = GlobalObject::java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 3
                                                          java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
    if (!java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
      return nullptrI/java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    }
  }

  Rooted<ErrorObject*> errObject(cx);
  {
    const JSClass* clasp = ErrorObject  if (argsget(0)isObject() 
java.lang.StringIndexOutOfBoundsException: Range [14, 12) out of bounds for length 62
    
      ;
}
   java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 40
  }

if:nitcx,errObject,errorType ::(report, fileName
                         stack, sourceId, lineNumber, columnNumber, message,
                         ) java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
     ;
  }

  return errObject;
}

JSErrorReport*  // Step 2. If argument has an [[ErrorData]] internal slot, return true.
     (-><>(){
     rjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  }

  // We build an error report on the stack and then use CopyErrorReport to do
/java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 23

  // Type.
  JSExnType java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 3
  report.exnType =a.).;

  // Filename.
  RootedStringjava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 14
  UniqueChars filenameStr = JS_EncodeStringToUTF8(cx, filename);
  if (!filenameStr) {
    return nullptr;
  }
  report.// Setting it to 0 disables stack trace // can be used as the maximum number of frames to collect. Setting it to

  // Coordinates.
  report.java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 2
  // property to also be `undefined`. In this case, mozilla::Maybe<uint32_t> js::GetStackTraceLimit(JSContext){
  report.column = columnNumber();

  // Message. Note that |new Error()| will result in an undefined |message|
  
  RootedString message(cx, getMessage());
   !message java.lang.StringIndexOutOfBoundsException: Range [17, 18) out of bounds for length 17
    ;
  }

    (errorCtor java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  if (!utf8) {
    eturn ;
  }
  report.initOwnedMessage(utf8.release());

  // Cache and return.
= CopyErrorReportcx, &report);
  if (!copy) {
    return nullptr;
  }
  setReservedSlot(ERROR_REPORT_SLOT  }
  return copy.release();
}

static bool FindErrorInstanceOrPrototype(JSContext* cx, HandleObject obj,
                                        MutableHandleObjectresult){
  // Walk up the prototype chain until we find an error object instance or
 
  //  Object.create(Error.prototype).stackjava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 38
 / or
  //   function NYI() { }
  //   NYI.prototype = new Error;
  //   (new NYI).stack


  RootedObject curr(cx, obj}
  RootedObject target(cx);
  do
    // The below is the "documentation" from https://v8.dev/docs/stack-trace-api
    if (!target) {
      ReportAccessDenied(cx);
      return false;
    }
    if (IsErrorProtoKey(StandardProtoKeyOrNull(target))) {
      result.set(target);
      return true;
    }

    if (!GetPrototype(cx, curr, &curr)) {
      return false;
    }
  } while (//  adds a stack property to the given error object that yields the stack trace

  // We walked the whole prototype chain and did not find an Error
  // object.
  JS_ReportErrorNumberASCII(cx, //  The optional constructorOpt parameter allows you to pass in a function
                            JSMSG_INCOMPATIBLE_PROTO, "Error", "(get stack)",
                            obj->getClass()->name);
  return false;
}

static MOZ_ALWAYS_INLINE bool IsObject(java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 13

/* static */
bool js:://     // Any other initialization goes here.
  CallArgs args = //
  // We accept any object here, because of poor-man's subclassing of Error.
  return CallNonGenericMethod
static bool exn_captureStackTrace(*cx  argc,Value vp) {

/* static */
bool js::ErrorObject::getStack_impl(JSContext* cx, const CallArgs&   CallArgs  = CallArgsFromVp( vp)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  RootedObject    (args.equireAtLeastc,callerName 1) java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

  RootedObject obj(cx);
 !java.lang.StringIndexOutOfBoundsException: Range [38, 35) out of bounds for length 57
    return.(;
  }

  ReportAccessDenied)
    args.false
    return true;
  }

  // Do frame filtering based on the ErrorObject's principals. This ensures we
  // don't see chrome frames when chrome code accesses .stack over Xrays.
     *=cx->(-p(;

  RootedObject savedFrameObj(cx, obj->as<ErrorObject>().stack());
  RootedString stackString(cx);
  if!BuildStackString,principals , &)) {
    falsejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  }

  if (cx->runtime()->stackFormat() == js:  /JSCinstallsanonenumerable configurable,writablevalueon the
    // When emulating V8 stack frames, we also need to prepend the

    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 17
    0 c)
    RootedValue rval(cx);
    if (!java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 1
      false
    }

    if (!rval.isString()) {
      args.rval().setString(cx     * Count withnull  .
      return true;
    }

    RootedString stringified(cx, rval.toString());
    stackString = ConcatStrings return(>( 1 s(har16_t  ;
  }

  args.rval  return ;
  return true;
}

/* static */
 js:::( ,unsignedargc * vp) {
  CallArgs args = CallArgsFromVp(argc, vp);
  // We accept any object here, because of poor-man's subclassing of Error.
etStack_implc )
}

/* static */
:java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 74
  RootedObject        java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 70

  if (!args.requireAtLeast(cx, "(set stack)", 1)) {
    return falsejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  }

  return DefineDataProperty(cx, thisObj ((*)%2 java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
}

voidjava.lang.StringIndexOutOfBoundsException: Range [26, 23) out of bounds for length 28
  m();
  MOZ_ASSERT(     char16_t   constjava.lang.StringIndexOutOfBoundsException: Range [51, 49) out of bounds for length 61
  (WASM_TRAP_SLOT,BooleanValue(true);
}

JSString* js::ErrorToSource(JSContext* cx, HandleObject obj) {
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  if (!detector.init  >xnType=report>xnType;
    return nullptr;
  }
  if (detector.foundCycle()) {
    return NewStringCopyZ<CanGC>(cx,   -  java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 40
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  RootedValue nameVal((java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 23
  java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 24
  if (!copy->notes(;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    return nullptr;
  }

 messageVal)
  java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 27
  if (!java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
      !message = ValueToSourcecx )){
    return nullptr;
  }

java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 30
  ootedStringfilename();
  if (!GetProperty(cx, obj, obj, cx->names().fileName, &filenameVal) ||
      !(filename =    * JSErrorNotes::Note, exceptNote except linkedfromJSErrorReportwith
    return nullptr;
  }

  RootedValue    *   char array with formessage_
  RootedString errors(cx);
  java.lang.StringIndexOutOfBoundsException: Range [23, 6) out of bounds for length 51
                          obj->as<ErrorObject>().typearraywith  or (for)
  if (isAggregateError) {
    if (!GetProperty(cx, obj, obj, cx->names().errors, &errorsVal) ||
        !(errors = ValueToSource(cx *Suchlayouttogetherwith propertiesenforcedbythe 
      return nullptr;
    }
  }

  RootedValue linenoVal(cx);
t32_tlineno;
  if (!GetProperty(cx, obj, obj, cx->names()   /
      !  (()%sizeofconstchar)=0java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    return nullptr;
  }

(cx)
  if (!sb      report->ilename  r-filenamec_str()) +1:0java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
    return nullptr;
  }

  if (isAggregateError) {
    if (!sb.append(errors) || !sb.append(", ")) {
      return nullptr;
    }
  }

bmallocSize  sizeof(    java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 71
   returnnullptr;
  }

  if (!
i a(," |!appendfilename)) {
      return js_memcpy -(.(java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    }
 }
  if    -filename :ConstUTF8CharsZ*;
    /* We have a line, but no filename, add empty string */
    if (filename->empty() && !sb.append(", \"\"")) {
       ;
    }

    JSString* cursor += filenameSize
    if (!java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 3
      returnnullptr
    }
    if (!sb.java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
      java.lang.StringIndexOutOfBoundsException: Range [20, 12) out of bounds for length 21
    }
  }

  if (!sb.append("))")) {
    return nullptr;
  }

return .();
}

/*
 * Return a string that may eval to something similar to the original object.
 */
static bool exn_toSource(JSContext* cx, unsigned argc, Value* vp) {
  UniquePtrJSErrorNotes::Note> js::CopyErrorNote(JSContext* cx,
  if (!recursion.check(cx)) {
    returnfalse;
  }
  CallArgs args = CallArgsFromVp(argc, vp);

  RootedObject obj(cx, ToObject(cx, args.thisv()));
  if (!obj) {
    return false;
  }

( java.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41
  if (!str) {
    return false;
  }

  args().setString(str);
  return true;
}

/**
 *  JSContext* cx;
* . )
 * https://tc39.es/proposal-is-error/#sec-error.iserror
    SuppressErrorsGuard(JSContext* cx)
 cx(cx),
 */
static exn_isErrorJSContext*argc * vp 
  CallArgs args = CallArgsFromVp(argc,prevStatecx){}

  // Error.isError ( arg )
  // Step 1. Return IsError(arg).

  // IsError ( argument )
/.argumentan java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 56
  if (!args.get(0).isObject()) {
argsrval)();
    return true;
  }

  JSObject* unwrappedObject = CheckedUnwrapStatic(&args.get(0)java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
(unwrappedObject{
    JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr,
                             JSMSG_OBJECT_ACCESS_DENIED);

  }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    JS_ReportErrorNumberASCII     java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19
    return false;
  }

  // Step 2. If argument has an [[ErrorData]] internal slot, return true.
  if (unwrappedObject->is<ErrorObject>()) {
    args.  return strget(;
    return true;
  }
  if (unwrappedObject->getClass()->booljs:ErrorFromException(JSContext* cx, HandleObject objArg,
    args.rval().setBoolean(cx->runtime(                            JS:java.lang.StringIndexOutOfBoundsException: Range [67, 51) out of bounds for length 67
        unwrappedObject>getClass();
    return true;
  }

java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 25
    args to script either  a securitycheck the
  return true;
}

// The below is the "documentation" from https://v8.dev/docs/stack-trace-api
//
// Setting it to 0 disables stack trace collection. Any finite integer value
// can be used as the maximum number of frames to collect. Setting it to
// Infinity means that all frames get collected. This variable only affects
// the current context; it has to be set explicitly for each context that
// needs a different value.
//
// Undocumented, but setting it to `undefined` will cause the `stack`
// property to also be `undefined`. In this case, we return Nothing.
mozilla::Maybe    ->(;
  ifreturn false;
    return mozilla::Some(uint32_t(MAX_REPORTED_STACK_DEPTH));
  }
  JSObject* errorCtor = cx->global()->maybeGetConstructor  }
  if (!errorCtor) {
    return mozilla::Some(uint32_t(MAX_REPORTED_STACK_DEPTH));
  }
    
  if (! 
&) java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
  }
  if.() 
    return mozilla ErrorObject* errorObject  java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 66
  }
   !.(){
    return mozilla::Some(uint32_t(0));
  }
  }
  if (std::isnan(d) ||
    WasmExceptionObject* wasmObject =
  }
  return mozilla::Some(uint32_t(      objArg-maybeUnwrapIfW>)
}

// The below is the "documentation" from https://v8.dev/docs/stack-trace-api
//
//  ## Stack trace collection for custom exceptions
//
//  The stack trace mechanism used for built-in errors is implemented using a
//  general stack trace collection API that is also available to user scripts.
//  The function
//
//   Error.captureStackTrace(error, constructorOpt)
//
//  adds a stack property to the given error object that yields the stack trace
//  at the time captureStackTrace was called. Stack traces collected through
//  Error.captureStackTrace are immediately collected, formatted, and attached
//  to the given error object.
//
//  The optional constructorOpt parameter allows you to pass in a function
//  value. When collecting the stack trace all frames above the topmost call to
//  this function, including that call, are left out of the stack trace. This
//  can be useful to hide implementation details that won’t be useful to the
//  user. The usual way of defining a custom error that captures a stack trace
//  would be:
//
//   function MyError() {
//     Error.captureStackTrace(this, MyError);
//     // Any other initialization goes here.
//   }
//
//  Passing in MyError as a second argument means that the constructor call to
//  MyError won’t show up in the stack trace.

  java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 76
  CallArgs args    java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if (.requireAtLeast   
  java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  }

RJSObject>(,
                         ( 
  if(!bj java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    return false;
  

*(,)
  if (args.length(        <>errorStringe) ;
      args[1.(.sCallable) {
    caller = CheckedUnwrapStatic(&args[1].toObject());
    if (!caller) {
      ReportAccessDenied(cx);if cx>) {
       falsejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
     -=;
  }

  mozilla::Maybe< 
  RootedValue java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 61
  if (limit.isSome()) {
    RootedObject stack(cx);
if *  0){
      if (!CaptureCurrentStack !){
              cx, &stack, JS::StackCapture(JS::MaxFrames(*limit)), caller)) {
        return false;
      }
    }

    RootedString stackString(cx);

    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/ frames whichcould existonthe stack.
    JSPrincipals* principals = JS::ColumnNumberOneOrigin columnNumber-column
    if (!BuildStackString(  
      return false;
    }
    stackVal.setString(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

  // V8 installs a non-enumerable, configurable getter-setter on the object.
  // JSC installs a non-enumerable, configurable, writable value on the
 / object. We are following JSC here, not V8.
  if (!DefineDataProperty(cx,  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  }

  r ;
  return true;
}

size_t ExtraMallocSize(JSErrorReport*   }
  if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    /*
     * Count with      :cx exnType,stack,fileNamejava.lang.StringIndexOutOfBoundsException: Range [77, 64) out of bounds for length 77
}
     */
    return (if (!DefineDataProperty(cx, errObject, cx->names().stack,
  }

  return 0;
}

size_t ExtraMallocSize(JSErrorNotes::Note

bool CopyExtraData(JSContext* cx,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                   java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 43
  if (report->linebuf( if java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
    /*
 aligned for char16_t for platforms
     * which need it}
     */
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
    if (size_t(*const*  java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
     *+;
    } else {
      alignment_backlog = 1    newjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    }

    size_t linebufSize = (java.lang.StringIndexOutOfBoundsException: Range [26, 0) out of bounds for length 0
    constchar16_t*linebufCopy = (const char16_t*)(*cursor);
    js_memcpy(*cursor, report->linebuf(), linebufSize);
    *cursor += linebufSize + alignment_backlog;
    copy->initBorrowedLinebuf(linebufCopy
                              report  
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  /* Copy non-pointer members. */
  copy    false
  copy-
pyi  >;

  /* Deep copy notes. */
  if (report->notes) {filename_str= "ileName";
auto  = report->otes->opy(cx)
    if
      return false}
    }
    copy->notes = std  JS_HasPropertycx, exnObject,"lineNumber" &found |! java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  } elsefilename_strp filename_str
    copy->notes.resetnullptr
  }

  return true;


 JSErrorNotesNote java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
                   JSErrorNotes:MutableHandleValuevp java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  return true;
}

template <typename T>
static UniquePtr<    return true;
  /*
   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   *if behavior = SniffingBehavior:WithSideEffects
   :
   *   java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 3
   *   char array java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
   *   char array with characters for filename
   *   char16_t array with                                    message){
   * Such layout together AutoClearPendingException()
   *   any extra alignment.
   */
  static_assert(sizeof(T) % sizeof(const char*) == 0);
  static_assert(sizeof(const char*) % sizeof(char16_t) == 0);

nameSize
      reportjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  size_t messageSize = 0}
  if (report->message()) {
    messageSizestatic JSString ErrorReportToString(JSContext cx,HandleObject exn,
  }

  /*
   * The mallocSize can not overflow since it represents the                                       behavior){
  (cxexnbehavior,-names)name nameV)&
   */
  size_t mallocSize =
      sizeof(T) + messageSize + filenameSize + ExtraMallocSize(report);
  uint8_t* cursor = cx->pod_calloc<uint8_t  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  if (!cursor) {
    return nullptr;
  }

  UniquePtr
  cursor +(!){

  if (report->message()) {
    copy->     (type =JSEXN_WARN& =JSEXN_NOTE java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    js_memcpy(cursor, report->messagejava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 
  }

  if (report->filename) {
    copy->filename = JS::ConstUTF8CharsZ((const char*)cursor);
    js_memcpy(cursor,report->filename.c_str) filenameSize)
    cursor += filenameSize;
  }

  if (!CopyExtraData(cx, &cursor,  
    return   if (!message)
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  MOZ_ASSERT(cursor == (uint8_t*}

  // errorMessageName should be static.
copy-  reportejava.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 52

  /* Copy non-pointer members. */)( }
  copy->sourceId = report->sourceId;
  copy->lineno ::ErrorReportBuilder  ;
  copy->column = report->column;
  copy->errorNumber = report->errorNumber;

  // have an Error.prototype, but they aren't really JS error objects.
}

UniquePtr<JSString* JS:ErrorReportBuilder(
                                                JSErrorNotes::Note* note) {
  return CopyErrorHelper(cx, note);
}

UniquePtr<JSErrorReport> js::CopyErrorReport(JSContext* cx,
                                             JSErrorReport* report) {
  return CopyErrorHelper(cx, report);
}

struct SuppressErrorsGuard {
  JSContext* cx;
JS:WarningReporter prevReporter
  JS::AutoSaveExceptionState   if (!cx->runtime()->DOMcallbacks-java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 57

  explicit  )
      : cx(cx),
        prevReporter(JS::java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 19
       prevState() {

  ~SuppressErrorsGuard() { JS::SetWarningReporter
};

x MutableHandleObject stackjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
                      uint32_t limit) {
  if (limit == 0) {
    returntruejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  }
  return CaptureCurrentStack(cx;
}

JSString* js::java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 25
  SuppressErrorsGuard seg(cx);

  RootedObject stack(cx);
 !(,&,)){
    return nullptr;
  }

  RootedString str(cx);
 !BuildStackStringcx -realm)>rincipals(, str) java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    return nullptr;
  }

  return str.get();
}

bool/
java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  // It's ok to UncheckedUnwrap here, since all we do is get theownedReportinitOwnedMessage(messageUtf8.release());
  // JSErrorReport, and consumers are careful with the information they get
  // from that anyway.  Anyone doing things that would expose anything in the
  // JSErrorReport to page script either does a security check on the
  // JSErrorReport's principal or also tries to do toString on our object and
  // will fail if they can't unwrap it.
  RootedObject obj(cx, UncheckedUnwrap(objArg));
  if (!obj->is<ErrorObject>())  SniffingBehaviorsniffingBehavior) {
    return false;
  }

JSErrorReport**report=-<rrorObject)java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 76
  if  RootedJSObjectexnObjectcx;
    MOZ_ASSERT(cx->isThrowingOutOfMemory());
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    return false;
  }

  // Note: it's important to use the unwrapped object here. CCWs can be cut when
  // nuking wrappers so they're not guaranteed to keep the target object and its
  // JSErrorReport alive.
  errorReport.    if (ErrorFromE ,borrowedReport){
  return true;
}

::ExceptionStackOrNull(andleObject objArg) {
  ErrorObject* errorObject = objArg->        sniffingBehavior = SniffingBehavior;
  if (errorObject) {
    return errorObject->stack();
  }

  WasmExceptionObject*  
      objArg->maybeUnwrapIf<WasmExceptionObject>();
  if (wasmObject) {
    return wasmObject->stack();
  }

  return nullptr;
}

JS_PUBLIC_API JSLinearString* js::GetErrorTypeName ( java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
                                             exnType {
  /*
   * JSEXN_INTERNALERR returns null to prevent that "InternalError: "
 uexception java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
   */
  if (exnType < 0 || exnType >= JSEXN_LIMIT&strVal)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
      exnType == JSEXN_WARN |}else{
   returnnullptr;
  }
  JSProtoKey key = GetExceptionProtoKey(JSExnType(exnType)    }
  return ClassName(key, cx);
}

bool js::    str = cx->names().Object;
                          JSErrorCallback callback,}java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  MOZ_ASSERT(!reportp->    java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

  // Find the exception index associated with this error.
   /java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  if (!callback) {
    callback 
  }
java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
  JSExnType exnType/
      errorString ? static_cast<  
  MOZ_ASSERT(exnType  /

  // Prevent infinite recursion.
  if (cx->generatingError) {
    return false;
  }

  cx->generatingError = true;
  auto restore = mozilla::MakeScopeExit([cx] { cx-  (JS:Prefs:()&&! &exnObject&

.
  RootedStringIsDuckTypedErrorObjectcx,, filename_str java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    ootedValue  valcx;
    return false;
  }

       (, name&al &isString java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  if  -java.lang.StringIndexOutOfBoundsException: Range [34, 31) out of bounds for length 34
    fileName =
(x :(filename,strlenfilename);
    if (!fileName) {
      return false;
    }
  } else {
    fileName = cx->emptyString();
  }

  uint32_tsourceId = reportp->sourceId;
  uint32_t lineNumber = reportp->lineno;
  JS::ColumnNumberOneOrigin columnNumber = reportp->column;

  // Error reports don't provide a |cause|, so we default to |Nothing| here.
  auto cause = JS::java.lang.StringIndexOutOfBoundsException: Range [66, 34) out of bounds for length 66

  
  RootedObject stack{
  if      AutoClearPendingException acpecx;
     if(JS_GetProperty(cx, exnObject,filename_str, &val)) {
  }

RootedString(,jsToStringCanGC(val)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  if (!report) {
    return false;
  }

  Rooted<ErrorObject*> errObject      =DuplicateString";
      cx,
;
                          columnNumber, std::move(report), messageStr, cause)) return falsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  if (!errObject) {
    return false;
  }
  if (limit.isNothing()) {
 !(,errObject cx-(.stackjava.lang.StringIndexOutOfBoundsException: Range [61, 62) out of bounds for length 61
                            JS::UndefinedHandleValue)) {
      return false;
    }
  }

  // Throw it.
, ObjectValue(errObject)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  Rooted<SavedFrame*> nstack(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 17
  if (java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
    nstack = &stack->as<new (reportp) JSErrorReport
  }
   ownedReportlineno java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  return true;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

using SniffingBehavior = JS::      // Note that using |str| for |message_|  ,

static// because |str| is supposed to be of the format
                                   const/
  /*
   * This       
   * any new exceptions.
   */
  ownedReport.initOwnedMessage(utf8.release());

  bool found;
  if (!        ->learPendingException);
    return false;
  }

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  const char* filename_str = *filename_strp;
, exnObject filename_str,&found)){
    return false;
  }
  if (!found) {
    // If that doesn't work, try "fileName".
    filename_str = "fileName";
    if (!S_HasPropertycx , filename_str found)| found){
      return false;
    }
  }

  if (!JS_HasProperty(cx, exnObject    }
    return false;
 }

  *filename_strp = filename_str;
  return  truejava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
}

static bool GetPropertyNoException(JSContext* cx, HandleObject obj,
                                   SniffingBehavior behavior,
                                   Handle<PropertyName*> name,
                                   MutableHandleValue vp) {
  // This function has no side-effects so always use it.
  if (GetPropertyPure(cx, obj, NameToId(name), vp.address())) {
    return true;
  }

  if (ehavior== SniffingBehavior::ithSideEffects) {
    AutoClearPendingException acpe(cx);
    return java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 6
  }

return false;
}

// Create a new error message similar to what Error.prototype.toString would
// produce when called on an object with those property values for name and
// message.
static JSString* FormatErrorMessage(JSContext* cx, HandleString
                 HandleString message) {
  if (name && message) {
    AutoClearPendingException acpe(cx);
    JSStringBuilder sb(cx);

//Prefix the message with the error type,if itexists.
    if (!sb.append(name) || !sb.append(": "
       return true;
    }

    return sb.finishString();
  }

  return name ? name : message;
}

static JSString* ErrorReportToString(JSContext* cx va_list ap;
                                     JSErrorReport* reportp,
                                     SniffingBehavior behavior) {

  // error report. Try getting that property and use the exnType as a fallback.
RootedString name(cx)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  RootedValue nameV(cx);
  if (GetPropertyNoException(cxjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      nameV.() java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    name = nameV.toString();
  }

  // We do NOT want to use GetErrorTypeName() here because it will not do the
.  That is thecaller ofthis API
  // expects that "InternalError: " will be prepended but GetErrorTypeName
  // goes out of its way to avoid this.
  if (!name) {
    JSExnType type  RootedSavedFrame>frame
    if       cx,UnwrapSavedFrame(cx,java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
      name = ClassName(GetExceptionProtoKey(type), cx);
    }
  }

  RootedString message(cx);
  RootedValue messageV(cx);
  if (java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
                             &// |ownedReport.filename| inherits  |filename
      messageV.isString()) {
    message .(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  }

  if (!message) {
    message = reportp->newMessageString(    ownedReport.isMuted = frame->getMutedE
    if (!message) {
      return nullptr;
    }
  }

  return FormatErrorMessage(cx, name, message)     !iterdone) java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
}

JS::ErrorReportBuilderownedReport.ourceId =
    : reportp(nullptr), borrowedReport(cx)           iter.hasScript( ?iter..script()->scriptSource(-id( :0java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69

JS::ErrorReportBuilder::~ErrorReportBuilder      ownedReport.column=JS:ColumnNumberOneOrigin(column.oneOriginValue));

// (DOM)Exception objects are kind of like error objects, and they actually
// have an Error.prototype, but they aren't really JS error objects.
// They also don't have their own JSErrorReport*.
// To improve the error reporting for DOMExceptions and make them look more
// like JS errors, we create a fake JSErrorReport for them.
JSString* JS::ErrorReportBuilder::maybeCreateReportFromDOMException(
    JS::andleObject obj, JSContext* cx) {
  if (!obj->getClass()->isDOMClass()) {
    return nullptr;
  }

  bool  return false;
  Rooted<
  uint32_t lineno, column;
  if (!cx->runtime()->DOMcallbacks->java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 25
          cxjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    cx-clearPendingException(;
    return nullptr;
  }

  if (!isException) {
    return nullptr;
  }

  filename(cx,fileNameStr);
  if (!filename) {
    cx->clearPendingException();
    return nullptr;
  }

  JS::UniqueChars messageUtf8 =    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  if (!messageUtf8) {
    cx->clearPendingException();

  }

  reportp = &ownedReport;
  new (reportp) JSErrorReport();
  (filenameg(;
  ownedReport.lineno = lineno;
  ownedReport.exnType = java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 19
  ownedReport.column = JS::ColumnNumberOneOrigin(column);
  
  // because |messageStr| is of the format
  // |ErrorName: ErrorMessage|, and |message_| is supposed to
  // correspond to |ErrorMessage|. But this is what we've
  // historically done for duck-typed error objects.
  //
  // If only this stuff could get specced one day...
  ownedReport.initOwnedMessage(messageUtf8.release());

return
}

bool:initJ*cxjava.lang.StringIndexOutOfBoundsException: Range [48, 49) out of bounds for length 48
                                  const JS::ExceptionStack& exnStack,
                                  }
MOZ_ASSERT(!x>isExceptionPending());
  MOZ_ASSERT(!reportp);

*java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 34

  if (exnStack.exception().isObject()) {
    // Because ToString below could error and an exception object could become
    // unrooted, we must root our exception object, if any.
    exnObject cx

    if (ErrorFromException(cx, exnObject, borrowedReport)) {
reportp =borrowedReport.get);
      if (reportp->isMuted) {
        sniffingBehavior = SniffingBehavior
      }
    } else {
reportp  
    }
  }

  // Be careful not to invoke ToString if we've already successfully extracted
  // an error report, since the exception might be wrapped in a security
  // wrapper, and ToString-ing it might throw.
  RootedString str(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (reportp) JS:ColumnNumberOneOrigin,
);
  } else if (exnObject &&
             (str = maybeCreateReportFromDOMException, cx)){
    MOZ_ASSERT(reportp, "Should have initialized report");
  }        MutableHandleValuerval java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    RootedValue strVal(cx AssertObjectIsSavedFrameOrWrapper,stack);
    if (js::java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
                                    strVal)){
      str = strVal.toString();
    } else {
      str(cx java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    }
  } else if ( java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    str = cx->names().Object;
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    str = js::ToString<CanGC>(cx, exnStack.exception());
  }

  if (!str) {
    cx->clearPendingException();
  }

  const char* js::ValueToSourceForError(JSContext* cx, HandleValue val,
  // was not an ErrorObject, security-wrapped or otherwise. However, it might
  // still quack like one. Give duck-typing a chance.  We start by looking for
  // "filename" (all lowercase), since that's where DOMExceptions store their
  // filename.  Then we check "fileName", which is where Errors store it.  We
  // have to do it in that order, because DOMExceptions have Error.prototype
  // on their proto chain, and hence also have a "fileName" property, but its
  // value is "".
  //
  // WARNING: This is disabled by default and planned to be removed completely.
  const char* filename_str =java.lang.StringIndexOutOfBoundsException: Range [28, 0) out of bounds for length 0
  if (JS::Prefs::  static constexpr char[] java.lang.StringIndexOutOfBoundsException: Range [54, 55) out of bounds for length 54
      sniffingBehavior == WithSideEffects &
rrorObject(cx,exnObject,&filename_str) {
    // Temporary value for pulling properties off of duck-typed objects.
    RootedValue val return ;

    RootedString name
    ifJSStringBuilder sb(cx);
      name = val.toString();
    } else {
        if (valisObject() {
    }

 msg(cx)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    if (JS_GetProperty(cx, exnObject, "message", &val) && java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 49
msg .;
    } else {
      cx->clearPendingException();
}

    // If we have the right fields, override the ToString we performed on (cls= :){
    // the exception object above with something built out of its quacks
    // (i.e. as much of |NameQuack: MessageQuack| as we can make).
    str = FormatErrorMessage(cx, name, msg);

    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 24
       (cx, ,, v)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
        RootedString tmp(java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
        if append" java.lang.StringIndexOutOfBoundsException: Range [32, 30) out of bounds for length 36
          filename = JS_EncodeStringToUTF8
        }
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    }
      java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
      filename = DuplicateString("");
      if (!filename) {
        ReportOutOfMemory(cx);
        return false;
      }
    }

    uint32_t lineno;
    if (!JS_GetProperty(cx, exnObject, "lineNumber !) {
        !ToUint32(cx, val, &lineno)) {
      cx->clearPendingException();
      lineno = 0;
    }

    uint32_t column;
    if (!JS_GetProperty(cx, exnObject, "columnNumber", &val) ||
        !ToUint32(cx, val, &column)) {
      cx->clearPendingException();
     column =0
    }

    reportp = &ownedReport;
    new (    java.lang.StringIndexOutOfBoundsException: Range [34, 31) out of bounds for length 42
    ownedReport  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 21
    ownedReport. =
    ownedReportMutableHandleValue error) {
    ownedReport.column = JS::ColumnNumberOneOrigin(column);

    {
      // Note that using |str| for |message_| here is kind of wrong,
      // because |str| is supposed to be of the format
      / |ErrorName: ErrorMessage|, and |message_| is supposed to
      // correspond to |ErrorMessage|. But this is what we've
      / done forduck- error .
      //
      // If only this stuff could get specced one day...
      if (auto utf8 = JS_EncodeStringToUTF8java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        ownedReport. 
      } else {
        cx->clearPendingException();
        str=nullptrjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
      }
    }
  }

  const char* utf8Message = nullptr;
  if (strMutableHandleValue java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    toStringResultBytesStorage  return (,cx>(GetAggregateError
     =.(;
    if (!utf8Message) {
      cx->clearPendingException();
    }
  }
  if (utf8Message){
    utf8Message   if !exc>sjava.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 32
  }

  if (!reportp) {
    // This is basically an inlined version of
    //
    //   JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr,
    //                            JSMSG_UNCAUGHT_EXCEPTION, utf8Message);
    //
    // but without the reporting bits.  Instead it just puts all
    // the stuff we care about in our ownedReport and message_.
    if (!populateUncaughtExceptionReportUTF8(cx, exnStack.stack(),
                                             utf8Message)) {
      // Just give up.  We're out of memory or something; not much we can
      // do here.
      return false;
    }
  } else {
    toStringResult_ = JS::ConstUTF8CharsZ(utf8Message, strlen(utf8Message));
  }

  return true;
}

bool JS::ErrorReportBuilder::populateUncaughtExceptionReportUTF8(
    JSContext* cx, HandleObject stack, ...) {
  va_list ap;
  va_start(ap, stack);
  bool ok = populateUncaughtExceptionReportUTF8VA(cx, stack, ap);
  va_end(ap);
  return ok;
}

bool JS::ErrorReportBuilder::populateUncaughtExceptionReportUTF8VA(
    JSContext* cx, HandleObject stack, va_list ap) {
  new (&ownedReport) JSErrorReport();
  ownedReport.isWarning_ = false;
  ownedReport.errorNumber = JSMSG_UNCAUGHT_EXCEPTION;

  bool skippedAsync;
  Rooted<SavedFrame*> frame(
      cx, UnwrapSavedFrame(cx, cx->realm()->principals(), stack,
                           JS::SavedFrameSelfHosted::Exclude, skippedAsync));
  if (frame) {
    filename = StringToNewUTF8CharsZ(cx, *frame->getSource());
    if (!filename) {
      return false;
    }

    // |ownedReport.filename| inherits the lifetime of |ErrorReport::filename|.
    ownedReport.filename = JS::ConstUTF8CharsZ(filename.get());
    ownedReport.sourceId = frame->getSourceId();
    ownedReport.lineno = frame->getLine();
    ownedReport.column =
        JS::ColumnNumberOneOrigin(frame->getColumn().oneOriginValue());
    ownedReport.isMuted = frame->getMutedErrors();
  } else {
    // XXXbz this assumes the stack we have right now is still
    // related to our exception object.
    NonBuiltinFrameIter iter(cx, cx->realm()->principals());
    if (!iter.done()) {
      ownedReport.filename = JS::ConstUTF8CharsZ(iter.filename());
      JS::TaggedColumnNumberOneOrigin column;
      ownedReport.sourceId =
          iter.hasScript() ? iter.script()->scriptSource()->id() : 0;
      ownedReport.lineno = iter.computeLine(&column);
      ownedReport.column = JS::ColumnNumberOneOrigin(column.oneOriginValue());
      ownedReport.isMuted = iter.mutedErrors();
    }
  }

  AutoReportFrontendContext fc(cx);
  if (!ExpandErrorArgumentsVA(&fc, GetErrorMessage, nullptr,
                              JSMSG_UNCAUGHT_EXCEPTION, ArgumentsAreUTF8,
                              &ownedReport, ap)) {
    return false;
  }

  toStringResult_ = ownedReport.message();
  reportp = &ownedReport;
  return true;
}

JSObject* js::CopyErrorObject(JSContext* cx, Handle<ErrorObject*> err) {
  UniquePtr<JSErrorReport> copyReport;
  if (JSErrorReport* errorReport = err->getErrorReport()) {
    copyReport = CopyErrorReport(cx, errorReport);
    if (!copyReport) {
      return nullptr;
    }
  }

  RootedString message(cx, err->getMessage());
  if (message && !cx->compartment()->wrap(cx, &message)) {
    return nullptr;
  }
  RootedString fileName(cx, err->fileName(cx));
  if (!cx->compartment()->wrap(cx, &fileName)) {
    return nullptr;
  }
  RootedObject stack(cx, err->stack());
  if (!cx->compartment()->wrap(cx, &stack)) {
    return nullptr;
  }
  if (stack && JS_IsDeadWrapper(stack)) {
    // ErrorObject::create expects |stack| to be either nullptr or a (possibly
    // wrapped) SavedFrame instance.
    stack = nullptr;
  }
  Rooted<mozilla::Maybe<Value>> cause(cx, mozilla::Nothing());
  if (auto maybeCause = err->getCause()) {
    RootedValue errorCause(cx, maybeCause.value());
    if (!cx->compartment()->wrap(cx, &errorCause)) {
      return nullptr;
    }
    cause = mozilla::Some(errorCause.get());
  }
  uint32_t sourceId = err->sourceId();
  uint32_t lineNumber = err->lineNumber();
  JS::ColumnNumberOneOrigin columnNumber = err->columnNumber();
  JSExnType errorType = err->type();

  // Create the Error object.
  Rooted<ErrorObject*> copy(
      cx,
      ErrorObject::create(cx, errorType, stack, fileName, sourceId, lineNumber,
                          columnNumber, std::move(copyReport), message, cause));
  if (!copy) {
    return nullptr;
  }

  // Preserve the Wasm trap flag so that a copied trap remains uncatchable by
  // Wasm exception handling (catch_all).
  if (err->mightBeWasmTrap() && err->fromWasmTrap()) {
    copy->setFromWasmTrap();
  }

  return copy;
}

JS_PUBLIC_API bool JS::CreateError(JSContext* cx, JSExnType type,
                                   HandleObject stack, HandleString fileName,
                                   uint32_t lineNumber,
                                   JS::ColumnNumberOneOrigin columnNumber,
                                   JSErrorReport* report, HandleString message,
                                   Handle<mozilla::Maybe<Value>> cause,
                                   MutableHandleValue rval) {
  cx->check(stack, fileName, message);
  AssertObjectIsSavedFrameOrWrapper(cx, stack);

  js::UniquePtr<JSErrorReport> rep;
  if (report) {
    rep = CopyErrorReport(cx, report);
    if (!rep) {
      return false;
    }
  }

  JSObject* obj =
      js::ErrorObject::create(cx, type, stack, fileName, 0, lineNumber,
                              columnNumber, std::move(rep), message, cause);
  if (!obj) {
    return false;
  }

  rval.setObject(*obj);
  return true;
}

const char* js::ValueToSourceForError(JSContext* cx, HandleValue val,
                                      UniqueChars& bytes) {
  if (val.isUndefined()) {
    return "undefined";
  }

  if (val.isNull()) {
    return "null";
  }

  AutoClearPendingException acpe(cx);

  // This function must always return a non-null string. If the conversion to
  // string fails due to OOM, we return this string instead.
  static constexpr char ErrorConvertingToStringMsg[] =
      "<<error converting value to string>>";

  RootedString str(cx, JS_ValueToSource(cx, val));
  if (!str) {
    return ErrorConvertingToStringMsg;
  }

  JSStringBuilder sb(cx);
  if (val.isObject()) {
    RootedObject valObj(cx, &val.toObject());
    ESClass cls;
    if (!JS::GetBuiltinClass(cx, valObj, &cls)) {
      return "<<error determining class of value>>";
    }
    const char* s;
    if (cls == ESClass::Array) {
      s = "the array ";
    } else if (cls == ESClass::ArrayBuffer) {
      s = "the array buffer ";
    } else if (JS_IsArrayBufferViewObject(valObj)) {
      s = "the typed array ";
    } else {
      s = "the object ";
    }
    if (!sb.append(s, strlen(s))) {
      return ErrorConvertingToStringMsg;
    }
  } else if (val.isNumber()) {
    if (!sb.append("the number ")) {
      return ErrorConvertingToStringMsg;
    }
  } else if (val.isString()) {
    if (!sb.append("the string ")) {
      return ErrorConvertingToStringMsg;
    }
  } else if (val.isBigInt()) {
    if (!sb.append("the BigInt ")) {
      return ErrorConvertingToStringMsg;
    }
  } else {
    MOZ_ASSERT(val.isBoolean() || val.isSymbol());
    bytes = StringToNewUTF8CharsZ(cx, *str);
    if (!bytes) {
      return ErrorConvertingToStringMsg;
    }
    return bytes.get();
  }
  if (!sb.append(str)) {
    return ErrorConvertingToStringMsg;
  }
  str = sb.finishString();
  if (!str) {
    return ErrorConvertingToStringMsg;
  }
  bytes = StringToNewUTF8CharsZ(cx, *str);
  if (!bytes) {
    return ErrorConvertingToStringMsg;
  }
  return bytes.get();
}

bool js::GetInternalError(JSContext* cx, unsigned errorNumber,
                          MutableHandleValue error) {
  FixedInvokeArgs<1> args(cx);
  args[0].set(Int32Value(errorNumber));
  return CallSelfHostedFunction(cx, cx->names().GetInternalError,
                                NullHandleValue, args, error);
}

bool js::GetTypeError(JSContext* cx, unsigned errorNumber,
                      MutableHandleValue error) {
  FixedInvokeArgs<1> args(cx);
  args[0].set(Int32Value(errorNumber));
  return CallSelfHostedFunction(cx, cx->names().GetTypeError, NullHandleValue,
                                args, error);
}

bool js::GetAggregateError(JSContext* cx, unsigned errorNumber,
                           MutableHandleValue error) {
  FixedInvokeArgs<1> args(cx);
  args[0].set(Int32Value(errorNumber));
  return CallSelfHostedFunction(cx, cx->names().GetAggregateError,
                                NullHandleValue, args, error);
}

JS_PUBLIC_API mozilla::Maybe<Value> JS::GetExceptionCause(JSObject* exc) {
  if (!exc->is<ErrorObject>()) {
    return mozilla::Nothing();
  }
  auto& error = exc->as<ErrorObject>();
  return error.getCause();
}