/*
 * 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"
#include "js/CallNonGenericMethod.h"
#include "js/CharacterEncoding.h"  // JS::ConstUTF8CharsZ
#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/PropertySpec.h"
#include "js/RootingAPI.h"
#include "js/SavedFrameAPI.h"
#include "js/Stack.h"
#include "js/TypeDecls.h"
#include "js/Utility.h"
#include "js/Value.h"
#include "js/Wrapper.h"
#include "util/StringBuilder.h"
#include "vm/ErrorReporting.h"
#include "vm/GlobalObject.h"
#include "vm/Iteration.h"
#include "vm/JSAtomUtils.h"  // ClassName
#include "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"
#include "vm/SavedStacks-inl.h"
#include "vm/Shape-inl.h"

using namespace js;

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

const JSClass ErrorObject::protoClasses[JSEXN_ERROR_LIMIT] = {
    IMPLEMENT_ERROR_PROTO_CLASS(Error),

    IMPLEMENT_ERROR_PROTO_CLASS(InternalError),
    IMPLEMENT_ERROR_PROTO_CLASS(AggregateError),
    IMPLEMENT_ERROR_PROTO_CLASS(EvalError),
    IMPLEMENT_ERROR_PROTO_CLASS(RangeError),
    IMPLEMENT_ERROR_PROTO_CLASS(ReferenceError),
#ifdef ENABLE_EXPLICIT_RESOURCE_MANAGEMENT
    IMPLEMENT_ERROR_PROTO_CLASS(SuppressedError),
#endif
    IMPLEMENT_ERROR_PROTO_CLASS(SyntaxError),
    IMPLEMENT_ERROR_PROTO_CLASS(TypeError),
    IMPLEMENT_ERROR_PROTO_CLASS(URIError),

    IMPLEMENT_ERROR_PROTO_CLASS(DebuggeeWouldRun),
    IMPLEMENT_ERROR_PROTO_CLASS(CompileError),
    IMPLEMENT_ERROR_PROTO_CLASS(LinkError),
    IMPLEMENT_ERROR_PROTO_CLASS(RuntimeError),
#ifdef ENABLE_WASM_JSPI
    IMPLEMENT_ERROR_PROTO_CLASS(SuspendError),
#endif
};

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

static const JSFunctionSpec error_methods[] = {
    JS_FN("toSource", exn_toSource, 0, 0),
    JS_SELF_HOSTED_FN("toString", "ErrorToString", 0, 0),
    JS_FS_END,
};

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

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

static const JSFunctionSpec error_static_methods[] = {
    JS_FN("isError", exn_isError, 1, 0),
    JS_FN("captureStackTrace", exn_captureStackTrace, 2, 0),
    JS_FS_END,
};

static const JSPropertySpec error_static_properties[] = {
    JS_INT32_PS("stackTraceLimit", int32_t(MAX_REPORTED_STACK_DEPTH),
                JSPROP_ENUMERATE),
    JS_PS_END,
};

// Error.prototype and NativeError.prototype have own .message and .name
// properties.
#define COMMON_ERROR_PROPERTIES(name) \
  JS_STRING_PS("message", "", 0), JS_STRING_PS("name", #name, 0)

static const JSPropertySpec error_properties[] = {
    COMMON_ERROR_PROPERTIES(Error),
    // Only Error.prototype has .stack!
    JS_PSGS("stack", ErrorObject::getStack, ErrorObject::setStack, 0),
    JS_PS_END,
};

#define IMPLEMENT_NATIVE_ERROR_PROPERTIES(name)       \
  static const JSPropertySpec name##_properties[] /java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
COMMON_ERROR_PROPERTIESname}

IMPLEMENT_NATIVE_ERROR_PROPERTIES(InternalError)
IMPLEMENT_NATIVE_ERROR_PROPERTIES(AggregateError)
IMPLEMENT_NATIVE_ERROR_PROPERTIES(EvalError)
IMPLEMENT_NATIVE_ERROR_PROPERTIES(RangeError)
IMPLEMENT_NATIVE_ERROR_PROPERTIES(ReferenceError)
#ifdef ENABLE_EXPLICIT_RESOURCE_MANAGEMENT
IMPLEMENT_NATIVE_ERROR_PROPERTIES(SuppressedError)
#endif
IMPLEMENT_NATIVE_ERROR_PROPERTIES(java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 21
/java.lang.StringIndexOutOfBoundsException: Range [28, 25) out of bounds for length 28
include"
IMPLEMENT_NATIVE_ERROR_PROPERTIES(DebuggeeWouldRun)
IMPLEMENT_NATIVE_ERROR_PROPERTIES(CompileError)
)
IMPLEMENT_NATIVE_ERROR_PROPERTIES(RuntimeError)
#ifdef java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 21
vm/ErrorReporting
ejava.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6

#include java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 26
java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 43
 \
   nullptr,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                         java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   
pjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 43
   
    IMPLEMENT_ERRjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

#define IMPLEMENT_NONGLOBAL_ERROR_SPEC(name) \
  {ErrorObject    java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 48
              \
#ndif
nullptr,\
   nullptr,                                  \
_java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 46
                       
java.lang.StringIndexOutOfBoundsException: Range [18, 16) out of bounds for length 52

const java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
{:java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 62
,
     error_properties},

   java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 47
    IMPLEMENT_NATIVE_ERROR_SPEC
java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    IMPLEMENT_NATIVE_ERROR_SPEC(RangeError),
    IMPLEMENT_NATIVE_ERROR_SPEC(ReferenceError),
# 
java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 49
ejava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
    java.lang.StringIndexOutOfBoundsException: Range [45, 43) out of bounds for length 45
    IMPLEMENT_NATIVE_ERROR_SPEC(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 34
    IMPLEMENT_NATIVE_ERROR_SPEC(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 14

    IMPLEMENT_NONGLOBAL_ERROR_SPEC(DebuggeeWouldRun)
Cjava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 49
    JS_PSGS("stack", ErrorObject::getStack, java.lang.StringIndexOutOfBoundsException: Range [0, 55) out of bounds for length 14
     
#ifdef COMMON_ERROR_PROPname java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 48
java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 49
#endif
};

 java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 58
  Ijava.lang.StringIndexOutOfBoundsException: Range [45, 33) out of bounds for length 46
to_             
       java.lang.StringIndexOutOfBoundsException: Range [48, 33) out of bounds for length 58
 \
   &ErrorObjectClassOpsjava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 47
   &ErrorObject:[JSProto_##name -JSProto_Error}

#define IMPLEMENT_ERROR_CLASS(name) \
  IMPLEMENT_ERROR_CLASS_CORE(name, 

// 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 IMPLEMENT_ERROR_CLASS_MAYBE_WASM_TRAP:createProtojava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 79

static void exn_finalize(JS::name#                     

static const JSClassOps ErrorObjectClassOps:java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 46
    .finalize\
};

const :  java.lang.StringIndexOutOfBoundsException: Range [57, 58) out of bounds for length 57
    IMPLEMENT_ERROR_CLASS(Error),\
    InternalError),
    IMPLEMENT_ERROR_CLASS(AggregateError),
    IMPLEMENT_ERROR_CLASS(EvalError),
   IMPLEMENT_ERROR_CLASS()java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    IMPLEMENT_ERROR_CLASS(ReferenceError),
#ifdef ENABLE_EXPLICIT_RESOURCE_MANAGEMENT
    IMPLEMENT_ERROR_CLASSSuppressedError,
#endif
    IMPLEMENT_ERROR_CLASS(SyntaxError),
    java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 6
ror,
    // These Error subclasses are not accessible via the global object:
    (DebuggeeWouldRun,
    IMPLEMENT_NONGLOBAL_ERROR_SPEC(DebuggeeWouldRun,
    IMPLEMENT_ERROR_CLASS(LinkError),
    IMPLEMENT_NONGLOBAL_ERROR_SPEC(),
#ifdef     (LinkError)
    java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 40
#endif
};

e
if(*report=obj><>)getErrorReport) {
    // Bug 1560019: This allocation is not currently tracked.IMPLEMENT_ERROR_CLASS_COREname ) \
    gcx-deleteUntrackedreport;
  }
}

static ErrorObject* CreateErrorObject(JSContext* cx, const CallArgs& args,
                                      ,JSExnTypeexnType
                                      HandleObject proto java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  // Compute the error message, if any.
  RootedString message(cx, nullptr);
  if (args.hasDefined(messageArg)) {
    message = ToString<CanGC>(cx, args[messageArg]);
    if (!message) {
      return nullptr;
    }
  }

  // Don't interpret the two parameters following the message parameter as the
  // non-standard fileName and lineNumber arguments when we have an options
  // object argument and the exception type is not SuppressedError.
  bool hasOptions =
#ifdef ENABLE_EXPLICIT_RESOURCE_MANAGEMENT
      args.get(messageArg + 1).isObject() && exnType != JSEXN_SUPPRESSEDERR;
#else
      args.get(messageArg + 1).isObject();
#endif

  Rooted<mozilla::Maybe<Value>> cause(cx, mozilla::Nothing());
  if (hasOptions) {
    RootedObject options(cx, &args[messageArg + 1].toObject());

    bool hasCause = false;
    if (!HasProperty(cx, options, cx->names().cause, &hasCause)) {
      return nullptr;
    }

    if (hasCause) {
      RootedValue causeValue(cx);
      if (!GetProperty(cx, options, options, cx->names().cause, &causeValue)) {
        return nullptr;
      }
      cause = mozilla::Some(causeValue.get());
    }
  }

  // Find the scripted caller, but only ones we're allowed to know about.
  NonBuiltinFrameIter iter(cx, cx->realm()->principals());

  RootedString fileName(cx);
  uint32_t sourceId = 0;
  if (!hasOptions && args.length() > messageArg + 1) {
    fileName = ToString<CanGC>(cx, args[messageArg + 1]);
  } else {
    fileName = cx->runtime()->emptyString;
    if (!iter.done()) {
      if (const char* cfilename = iter.filename()) {
        fileName = JS_NewStringCopyUTF8Z(
            cx, JS::ConstUTF8CharsZ(cfilename, strlen(cfilename)));
      }
      if (iter.hasScript()) {
        sourceId = iter.script()->scriptSource()->id();
      }
    }
  }
  if (!fileName) {
    return nullptr;
  }

  uint32_t lineNumber;
  JS::ColumnNumberOneOrigin columnNumber;
  if (!hasOptions && args.length() > messageArg + 2) {
    if (!ToUint32(cx, args[messageArg + 2], &lineNumber)) {
      return nullptr;
    }
  } else {
    JS::TaggedColumnNumberOneOrigin tmp;
    lineNumber = iter.done() ? 0 : iter.computeLine(&tmp);
    columnNumber = JS::ColumnNumberOneOrigin(tmp.oneOriginValue());
  }

  mozilla::Maybe<uint32_t> limit = GetStackTraceLimit(cx);
  RootedObject stack(cx);
  if (!CaptureStack(cx, &stack, limit.valueOr(0))) {
    return nullptr;
  }

  Rooted<ErrorObject*> errObject(
      cx,
      ErrorObject::create(cx, exnType, stack, fileName, sourceId, lineNumber,
                          columnNumber, nullptr, message, cause, proto));
  if (!errObject) {
    return nullptr;
  }
  if (limit.isNothing() && !DefineDataProperty(cx, errObject, cx->names().stack,
                                               JS::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>().getExtendedSlot(0).toInt32());

  MOZ_ASSERT(exnType != JSEXN_AGGREGATEERR,
             "AggregateError has its own constructor function");

#ifdef ENABLE_EXPLICIT_RESOURCE_MANAGEMENT
  MOZ_ASSERT(exnType != JSEXN_SUPPRESSEDERR,
             "SuppressedError has its own constuctor function");
#endif

  JSProtoKey protoKey =
      JSCLASS_CACHED_PROTO_KEY(&ErrorObject::classes[exnType]);

  // ES6 19.5.1.1 mandates the .prototype lookup happens before the toString
  RootedObject proto(cx);
  if (!GetPrototypeFromBuiltinConstructor(cx, args, protoKey, &proto)) {
    return false;
  }

  auto* obj = CreateErrorObject(cx, args, 0, exnType, proto);
  if (!obj) {
    return false;
  }

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

// AggregateError ( errors, message )
static bool AggregateError(JSContext* cx, unsigned argc, Value* vp) {
  CallArgs args = CallArgsFromVp(argc, vp);

  mozilla::DebugOnly<JSExnType> exnType =
      JSExnType(args.callee().as<JSFunction>().getExtendedSlot(0).toInt32());

  MOZ_ASSERT(exnType == JSEXN_AGGREGATEERR);

  // Steps 1-2. (9.1.13 OrdinaryCreateFromConstructor, steps 1-2).
  RootedObject proto(cx);
  if (!GetPrototypeFromBuiltinConstructor(cx, args, JSProto_AggregateError,
                                          &proto)) {
    return false;
  }

  // TypeError anyway, but this gives a better error message.
  if (!args.requireAtLeast(cx, "AggregateError", 1)) {
    return false;
  }

  // 9.1.13 OrdinaryCreateFromConstructor, step 3.
  // Step 3.
  Rooted<ErrorObject*> obj(
      cx, CreateErrorObject(cx, args, 1, JSEXN_AGGREGATEERR, proto));
  if (!obj) {
    return false;
  }

  // Step 4.

  Rooted<ArrayObject*> errorsList(cx, IterableToArray(cx, args.get(0)));
  if (!errorsList) {
    return false;
  }

  // Step 5.
  RootedValue errorsVal(cx, JS::ObjectValue(*errorsList));
  if (!NativeDefineDataProperty(cx, obj, cx->names().errors, errorsVal, 0)) {
    return false;
  }

  // Step 6.
  args.rval().setObject(*obj);
  return true;
}

#ifdef ENABLE_EXPLICIT_RESOURCE_MANAGEMENT
// Explicit Resource Management Proposal
// SuppressedError ( error, suppressed, message )
// https://arai-a.github.io/ecma262-compare/?pr=3000&id=sec-suppressederror
static bool SuppressedError(JSContext* cx, unsigned argc, Value* vp) {
  CallArgs args = CallArgsFromVp(argc, vp);

  mozilla::DebugOnly<JSExnType> exnType =
      JSExnType(args.callee().as<JSFunction>().getExtendedSlot(0).toInt32());

  MOZ_ASSERT(exnType == JSEXN_SUPPRESSEDERR);

  // Step 1. If NewTarget is undefined, let newTarget be the active function
  // object; else let newTarget be NewTarget.
  // Step 2. Let O be ? OrdinaryCreateFromConstructor(newTarget,
  // "%SuppressedError.prototype%", « [[ErrorData]] »).
  JS::Rooted<JSObject*> proto(cx);

  if (!GetPrototypeFromBuiltinConstructor(cx, args, JSProto_SuppressedError,
                                          &proto)) {
    return false;
  }

  // Step 3. If message is not undefined, then
  // Step 3.a. Let messageString be ? ToString(message).
  // Step 3.b. Perform CreateNonEnumerableDataPropertyOrThrow(O, "message",
  // messageString).
  JS::Rooted<ErrorObject*> obj(
      cx, CreateErrorObject(cx, args, 2, JSEXN_SUPPRESSEDERR, proto));

  if (!obj) {
    return false;
  }

  // Step 4. Perform CreateNonEnumerableDataPropertyOrThrow(O, "error", error).
  JS::Rooted<JS::Value> errorVal(cx, args.get(0));
  if (!NativeDefineDataProperty(cx, obj, cx->names().error, errorVal, 0)) {
    return false;
  }

  // Step 5. Perform CreateNonEnumerableDataPropertyOrThrow(O, "suppressed",
  // suppressed).
  JS::Rooted<JS::Value> suppressedVal(cx, args.get(1));
  if (!NativeDefineDataPropertycx, obj,cx->names()suppressed ,
                                0)) {
    return false;
  }

  // Step 6. Return O.
  // will #define IMPLEMENT_ERROR_CLASS_MAYBE_WASM_TRAP) \
  return true;
}
#endif

/* static */
JSObject* ErrorObject::createProto(JSContext*  (,ErrorObject::)
  JSExnTypestatic void (JS::*,JSObject*o);

  if (ype = ) java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    return GlobalObject::createBlankPrototype(
        cx, cx->global(), &ErrorObject::protoClasses[JSEXN_ERR]);
  }

  RootedObject protoProto(
      cx, GlobalObject::getOrCreateErrorPrototype(cx, cx->global()));
  if (!protoProto) {
    return nullptr;
  }

  return GlobalObject::createBlankPrototypeInheriting(
      cx, &ErrorObject::protoClasses[type], protoProto);
}

/* static */
JSObject* ErrorObject::createConstructor(JSContext* cx, JSProtoKey key) {
  JSExnType type = ExnTypeFromProtoKey(key);
  RootedObject ctor(cx);

  if (type == JSEXN_ERR) {
    ctor = GenericCreateConstructor<Error, 1, gc::AllocKind::FUNCTION_EXTENDED>(
        cx, key);
  } else {
    RootedFunction proto(
        cx, GlobalObject::getOrCreateErrorConstructor(cx, cx->global()));
    if (!proto) {
      return nullptr;
    }

    Native native;
    unsigned nargs;
    if (type == JSEXN_AGGREGATEERR) {
      native = AggregateError;
      nargs = 2;
    }
#ifdef ENABLE_EXPLICIT_RESOURCE_MANAGEMENT
    else if (type == JSEXN_SUPPRESSEDERR) {
      native = SuppressedError;
      nargs = 3;
    }
#endif
    else {
      native = Error;
      nargs = 1;
    }

    ctor =
        NewFunctionWithProto(cx, native, nargs, FunctionFlags::NATIVE_CTOR,
                             nullptr, ClassName(key, cx), proto,
                             gc::AllocKind::FUNCTION_EXTENDED, TenuredObject);
  }

  if (!ctor) {
    return nullptr;
  }

  ctor->as<JSFunction>().setExtendedSlot(0, Int32Value(type));
  return ctor;
}

/* static */
SharedShape* js::ErrorObject::assignInitialShape(JSContext* cx,
                                                 Handle<ErrorObject*> obj) {
  MOZ_ASSERT(obj->empty()    IMPLEMENT_ERROR_CLASS(Error),

  constexpr PropertyFlags propFlags = {PropertyFlag::Configurable,
PropertyFlag:Writable};

  if (!NativeObject::addPropertyInReservedSlot(cx, obj, cx->names().fileName,
                                               FILENAME_SLOT,propFlags)) {
    return nullptr;
  }

  if (!NativeObject::addPropertyInReservedSlot(cx, obj, cx->names().lineNumber,
                                               LINENUMBER_SLOT, propFlags)) {
    return nullptr;
  }

  if (!NativeObject::addPropertyInReservedSlot(
          cx,obj,cx>names(), COLUMNNUMBER_SLOT, propFlags){
    return#


  return obj->sharedShape();
}

/* static */SyntaxErrorjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
bool IMPLEMENT_ERROR_CLASS(LinkError),
JSExnType ,UniquePtrJSErrorReport errorReport
                           HandleStringENABLE_WASM_JSPI
                           uint32_t;
                           JS::ColumnNumberOneOrigin columnNumber,
                           HandleStringmessagejava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
                          mozilla::Maybe<:Value> cause){
  MOZ_ASSERT    / Bug 1560019: This allocation is not currently tracked.
  AssertObjectIsSavedFrameOrWrapper(cx, stack);
heck(bj stack);

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

  if (!        unsignedmessageArg JSExnTypeexnType,
    return false;
  }

  // The .message property isn't part of the initial shape because it's
  
  / |new Error("")| -- but not in others -- |new Error(undefined)|,
  // |new Error()|.
  fmessage java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
constexprPropertyFlagspropFlags  PropertyFlag:,
      returnnullptr;
    if  }
                                                 MESSAGE_SLOT, propFlags)) {
      return false;
    }
  }

  // Similar to the .message property, .cause is present only in some error
  // objects -- |new Error("f", {cause: cause})| -- but not in other --boolhasOptions=
  // |Error.prototype|, |new Error()|, |new Error("f")|.
  if (      .getmessageArg+1isObject)&  ! JSEXN_SUPPRESSEDERR
    java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 68
    c, &rgs[messageArg  1.toObjectjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    if (!NativeObject::    if (!HasProperty(cx, options, cx->names, &hasCause){
                             , propFlags) {
      return false;
    }     h){
  }

  MOZ_ASSERT(obj->lookupPure(NameToId(cx->names(). RootedValuecauseValuecx;
            FILENAME_SLOT;
  MOZ_ASSERT(obj->lookupPure(NameToId(cx->names().lineNumber        returnnullptr
LINENUMBER_SLOT;
  }
               /Findthe  caller  only oneswere allowed  knowabout
     iterc,cx-realm(>()java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
      message
->ookupPureNameToId(-names).message)>slot)= MESSAGE_SLOT)java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
MOZ_ASSERT_IF
      auseisSome)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
      obj->lookupPure(NameToId(cx-names)cause))= CAUSE_SLOT;

  JSErrorReport* report = errorReportif(!.done) {
LOT ObjectOrNullValue);
  obj->(
            cx ::ConstUTF8CharsZjava.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 67
  obj->        sourceId=script)>(->()
  obj}
                        Int32Value(columnNumber.   !)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
   (essage) {
    -initReservedSlotMESSAGE_SLOT (message);
}
  if (cause.isSome()) {
rvedSlot(,*.()java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  }     {
    obj->initReservedSlot(CAUSE_SLOT;
  }
  obj->initReservedSlot(SOURCEID_SLOTcolumnNumber  JS::(tmp();
  if (obj  :Maybe   GetStackTraceLimit)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
java.lang.StringIndexOutOfBoundsException: Range [14, 4) out of bounds for length 73
    obj->initReservedSlot(WASM_TRAP_SLOT ;
  }

  return  
}

/* static */
* js::JSContext   java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                                     
uint32_t,lineNumber
                                     JS::ColumnNumberOneOrigin columnNumberJS:java.lang.StringIndexOutOfBoundsException: Range [73, 71) out of bounds for length 75
                                     UniquePtr<JSErrorReport>   java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 43
                                     HandleString message,/
                                     java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 15
                                    HandleObject  /* = nullptr */) {
  AssertObjectIsSavedFrameOrWrapper(cx

  RootedObject proto(cx, protoArg);
  if (!proto) {
    proto = GlobalObject::getOrCreateCustomErrorPrototype             "ggregateErrorhas itsownconstructor function");
                                                          errorType);
    if (!proto) {
      return nullptr;
    }
  }

  Rooted<ErrorObject> errObject(cx)
  {
rorObject::classForType(errorType);
    JSObject* obj = NewObjectWithGivenProto(cx, clasp, proto);
    if (!obj) {
      java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
    }
    errObject = &obj->as<ErrorObject>();
  }

    RootedObject proto()java.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25
                         , ,lineNumber , ,
                         ){
    return nullptr;
  }

  return ;
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if}
    return r;
  }

 We build    onthe stack and se to
  // the nitty-gritty malloc stuff.
  JSErrorReport reportjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // Type.
  JSExnType type_ = type();
  report.exnType = type_;

  // Filename.
  RootedString filename(
  UniqueChars filenameStr=JS_EncodeStringToUTF8cx );
  if (!filenameStr) {
    return  RootedObjectprotocx)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
  report

  // Coordinates.
  java.lang.StringIndexOutOfBoundsException: Range [17, 8) out of bounds for length 31
  report.}
  report

  // Message. Note that |new Error()| will result in an undefined |message|*>obj
  // slot, so we need to explicitly substitute the empty string in that case.
  RootedString message( if (obj){
  if (!message) {
    message = cx->runtime()->emptyString;
  }

  UniqueChars utf8 = StringToNewUTF8CharsZ(cx, *message);
  if (!utf8) {
    return nullptr;
  }
 .(utf8.()java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

  // Step 5.
  <JSErrorReport   CopyErrorReport(cx, &report);
  if (!copy) {
    return nullptr;
  }
  setReservedSlot(java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 17
   
}

static  return ;
                                         MutableHandleObject}
 chain until wefind   objectinstance
  // prototype object. This allows code like:
  //  Object.create(Error.prototype).stack// SuppressedError ( error, suppressed, message )
  // or
  //   function NYI() { }
  //   NYI.prototype = new Error;
  //   (new NYI).stack
   to continue returning stacks that are useless, but at least don't throw.

  RootedObject curr(cx, obj);
  (cx)
  do  MOZ_ASSERT(xnType = )java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    target  // object; else let newTarget be NewTarget.
    if (!  // "%SuppressedE.rototype,«[] ».
      cx)
      return false if(GetPrototypeFromBuiltinConstructorcx,args ,
    }
    if     falsejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
      result.set(  // Step 3.a. Let messageString be ? ToString(message).
       truejava.lang.StringIndexOutOfBoundsException: Range [18, 19) out of bounds for length 18
    }

if!(,curr,&))java.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41
      return false     java.lang.StringIndexOutOfBoundsException: Range [17, 18) out of bounds for length 17
    }
    (curr;

  // We walked the whole prototype chain and did not find an Error
java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 12
  java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 3
                            JSMSG_INCOMPATIBLE_PROTOjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
obj>(-name;
  return false;
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

static MOZ_ALWAYS_INLINE java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 3

c */
boole
  CallArgs
  JSObject*ErrorObject:(JSContext*,JSProtoKey key)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  return java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 26
}

/* static */
bool js::         -,&:protoClassesjava.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 65
RootedObject thisObj(x args.hisv)toObject();

  RootedObject obj(cx);
  if (!FindErrorInstanceOrPrototype(cx, thisObj, &java.lang.StringIndexOutOfBoundsException: Range [0, 53) out of bounds for length 20
    return false;
  }

  if (!obj->is<ErrorObject>()) {
    args.rval().setString(cx->runtime()->emptyString);
    return truejava.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 16
  }

  // Do frame filtering based on the ErrorObject's principals. This ensures we
   chromecode  .stack  Xrays.
  JSPrincipals* principals  RootedObject ctor(x)

 RootedObject (,obj>ErrorObject(.()java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
RootedString (;
  if (!java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    return;
  }

  ifjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
     V8stack ,wealsoneedto  the
    // stringified Error to the stack string.
<PropertyName>name=cx->ames)ErrorToStringWithTrailingNewline
<>(;
    RootedValue rval(cx);
    if (!     ( = JSEXN_AGGREGATEERRjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
      return false;
    }

     (.() 
          else if (type == JSEXN_SUPPRESSEDERR) {
            native ;
    }

e
    stackString  ConcatStringsC>cx stringified,stackString)
  }

      
  return java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

/* static */
bool js:ErrorObject:s(JSContext java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 73
CallArgs=CallArgsFromVp(rgc );
  // We accept any object here, because of poor-man's subclassing of Error.
  return CallNonGenericMethod<IsObject, setStack_impl>(cx, args  }
}

/* static */
bool  }
  RootedObject  ctor-as<>().(0 (type);

  (argsr(cx,"( stack)" 1){
    return false;
  }

  return java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 12


void js::ErrorObject::setFromWasmTrap() {
  MOZ_ASSERT(mightBeWasmTrap());
  MOZ_ASSERT(JSCLASS_RESERVED_SLOTS(() >WASM_TRAP_SLOT);
  setReservedSlot(WASM_TRAP_SLOT, BooleanValue(true));
}

JSString* js::ErrorToSource(  MOZ_ASSERT(obj->mpty());
  AutoCycleDetector detector(cx, obj);
  if (!detector.  constexpr PropertyFlags = {PropertyFlag:Configurable,
    return nullptr;
  }
java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 30
    return  if(NativeObject::ddPropertyInReservedSlot(cx, obj, cx->names().fileName,
  }

  return nullptr
 RootedString name(cx);
  if (!GetProperty(cx, obj,
  if !NativeObject::addPropertyInReservedSlot(cx, obj, cx->names().lineNumber,
    return nullptr;
  }

  RootedValue messageVal(cx);
  RootedString message(cx);
  if (!GetProperty(cx, obj, obj, cx->names().message, &messageVal) ||
      !(message = ValueToSource(cx, essageVal))) java.lang.StringIndexOutOfBoundsException: Range [51, 52) out of bounds for length 51
    return nullptr    return nullptr;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

            cxobj,>ames(columnNumberCOLUMNNUMBER_SLOT) java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  RootedString filename(cx);
  if!GetPropertycx,obj cx-names(.ileName filenameVal)|
      !}
    return java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 12
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

             , java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  RootedString errors(cx)                          java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 48
booljava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 51
java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 24
  if (isAggregateError) {
    if (!GetProperty(cx, obj, obj, cx->names().errors, &errorsVal) ||
    !(errors =ValueToSource(cx, errorsVal))) {
      return nullptr;
}
  }

  RootedValue linenoVal  }
  uint32_t lineno;
  if (!GetProperty(cx, obj, obj, cx->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      !ToUint32(cx, linenoVal, &
    return nullptr;
  }//java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68

  JSStringBuilder sb(cx)ags propFlags ={PropertyFlag::Configurable,
  if (!sb.append                         PropertyFlag::Writable};
    return nullptr;
  }

  if() {
    if (!sb.append(errors) || !sb.append(", ")                                                 MESSAGE_SLOT,propFlags)){
      return nullptr;
java.lang.StringIndexOutOfBoundsException: Range [71, 5) out of bounds for length 5
}

  if (!sb.append(constexpr PropertyFlags = {:Configurable,
return nullptr;
  }

  if (!filename->empty()) {
    if (!sb.append(", ") || !sb.append(filename)) {
      nullptrjava.lang.StringIndexOutOfBoundsException: Range [21, 22) out of bounds for length 21
    }
  }
  if (lineno != 0) {
    /* We have a line, but no filename, add empty string */
    if(filename>( &!sb.(",\"")) {
      return nullptr;
    }

<CanGC(cx,;
    if (! LINENUMBER_SLOT)
      eturn;
    }
    if SSERT_IF
      return nullptr;
    }
  }

  if (!sb.append("))")) {
    return   MOZ_ASSERT_IF(
  }

  return sb.      cause.isSome),
}

/*
* a string thatmay    similar    object.
 */
signed argc, Value vp java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    if (messagejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  if !.check() java.lang.StringIndexOutOfBoundsException: Range [29, 30) out of bounds for length 29
    return false;
  }
  CallArgs    bj->(, causeget());

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

   obj-mightBeWasmTrap{
   MOZ_ASSERTJ(>()>WASM_TRAP_SLOTjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    return false;
  }

  args.
  return ErrorObject* j:ErrorObject:create(*cx  errorType
}

/**
 * Error.                uint32_tsourceId, uint32_t ,
 * Error.isError ( arg )
 * https://tc39.es/proposal-is-error/#sec-error.iserror
 *           HandleObject  /* = nullptr */) {
 * https://tc39.es/proposal-is-error/#sec-iserrorproto( protoArg);
 */
static bool exn_isError(JSContext* cxerrorType);
  CallArgs args = CallArgsFromVp(argc, vp);

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

  // IsError ( argument )
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  !.0.){
    args.rval().setBoolean(false    JSObject* obj = NewObjectWithGivenProto(cx, clasp, proto);
    return true;
  }

  return nullptr
  if    }
        errObject = &obj->as<ErrorObject>();
                             JSMSG_OBJECT_ACCESS_DENIED);
    return false;   (!ErrorObject:i(  ,stdmove) ,
  }

                           cause){
    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DEAD_OBJECT);
    returnfalsejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  }

// Step 2. If argument has an [[ErrorData]] internal slot, return true.
ifunwrappedObjectisErrorObject( 
return;
    return true;
  }
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    args.rval(  / the nitty-gritty malloc stuff.
        unwrappedObject->getClass( JSErrorReport report;
    return true;
  }

  // Step 3. Return false
  rgsrval().etBoolean(false)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  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.
* cx)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  if (!JS  // slot, so we need to explicitly substitute the empty string in that case.
    return mozillaif (message) {
  }
  JSObject* errorCtor = cx->global()->    message = cx->runtime()->emptyString
 if!errorCtor){
    return mozilla::Some(uint32_t(MAX_REPORTED_STACK_DEPTH));
  }
  Value limitVal;
  if (!GetPropertyPure(rnullptrjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
                       &  UniquePtr<JSErrorReport> copy (;
    return mozilla  
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  if (limitVal.isUndefined(  
    return mozilla
  }
  if (!limitVal.isNumber( // prototype object. This allows code like:
    return mozilla::Some(uint32_t(0));
  }
  double d = limitVal.toNumber();
  if  /
    return mozilla::Some(uint32_t(0));
  }
  return mozilla:  // to continue returning stacks that are useless, but at least don't throw.
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

// 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
  return false;
//  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.

taticexn_captureStackTraceJSContext*,unsigned *vp java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
args= CallArgsFromVpargc,vp;
  const char* callerName = "Error.captureStackTrace";

if!r(x ,){
    return false;
  }

    if(FindErrorInstanceOrPrototype(cx, thisObj, &obj)) {
                        RequireObjectArg(cx, "`target`", callerName, args[0]));
  if (!obj) {
    return false;
  }

  Rooted<JSObject*> caller(cx, nullptr);
  if (args.length() > 1 && args[1].isObject() &&
      args[1].toObject().isCallable()) {
    caller = CheckedUnwrapStatic(&args[1].oObject();
    if (!caller) {
      (cx;
      return ;
    }
  }

  mozilla::Maybe<uint32_t
  RootedValue stackVal(cx, UndefinedValue());
  if (limit.isSome()) {
    RootedObject stack(cx);
    if (*limit > 0) {
      if (!CaptureCurrentStack(
              cx, &stack, JS::StackCapture(JS::MaxFrames(*limit)), caller)) {
        return false;
      }
    }

    RootedString stackString(cx);

    // Do frame filtering based on the current realm, to filter out any
    // chrome frames which could exist on the stack.
 JSPrincipals*principals =->realm)>rincipals)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
     ((cx ,savedFrameObjstackString){
      returnreturn ;
    }
    stackVal.setString(stackString);
  }

  // V8 installs a non-enumerable, configurable getter-setter on the object.
/   a -, configurable writable  on 
  // object. We are following JSC here, not V8.
  if (!DefineDataProperty(cx, obj    // stringified Error to the stack string.
    return false;
  }

  args.rval().setUndefined();
  return    FixedInvokeArgs<0>args2(x)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
}

size_t ExtraMallocSizereturn ;
  if (report->linebuf())java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    /*
  null terminatorandalignment
     *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     */
    report-linebufLength)+ 1)* izeofc)+1;
  }

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

bool:ErrorObjectsetStackJSContext*cx  ,Value vp) java.lang.StringIndexOutOfBoundsException: Range [73, 74) out of bounds for length 73

bool CopyExtraData(JSContext* cx, uint8_t>(x,args)
                   JSErrorReport* report
  if (report-ool js:ErrorObject::setStack_impl(JSContext* cx, const CallArgs& args) {
    /*
*Makesurecursor is properly aligned for char16_t for platforms
     * which ;
     */
    size_t alignment_backlog = 0;
    if(size_t(cursor  ){
      (*cursor)++;
    } else {
      alignment_backlog = 1;
    }

    size_t linebufSizeMOZ_ASSERT(ightBeWasmTrap)
constchar16_t*linebufCopy=( char16_t*)(*cursor);
    js_memcpy(*cursor, report->linebuf(), linebufSize);
    *cursor += linebufSize + alignment_backlog;
    copy->initBorrowedLinebufsetReservedSlotWASM_TRAP_SLOT,);
java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
  }

  /* Copy non-pointer members. */
  copy->isMuted = report->isMuted;
  copy->xnType  report-ejava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 34
copy>isWarning_ =report->isWarning_;

  /* Deep copy notes. */
  if (report}
    auto copiedNotes = report->notes
   if !copiedNotes) {
      return false;
    }
    copy->notes = stdRootedString name(cx);
  } else {
    .reset(nullptr);
}

  return true;
}

bool   RootedValuemessageVal(cx)
                   RootedString message(cx);
  return true;
}

template <typename T!message = ValueToSource(,messageVal) java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
static   RootedValue filenameVal(cx);
  /*
   * We use a single malloc blockR cx)
   * JSErrorNotes::Note,except JSErrorNoteslinked   
   * the following layout:
   *   JSErrorReport or JSErrorNotes::Note
 charactersfor 
   *   char bool isAggregateError = obj->is<ErrorObject>() &&
   *   char16_t array charactersf linebuf(nly  JSErrorReportjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
      with the  enforced   following
   * t32_t ;
   */
static_assertsizeofT  ( * = );
  static_assert(sizeof(const char*) % sizeof(char16_t) == 0);

  size_t   JSStringBuilder sb;
report->ilename?strlen(eport>.+1  ;
  size_t messageSize = 0;
  if (report->message()) {
    messageSize = strlen(java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 25
  }

  /*
   * Theb.append(message)) {
   * sizes of already allocated objects.
   */
  size_t mallocSize =
     sizeofT)+messageSize+ filenameSize +ExtraMallocSize(report);
  uint8_t* cursor = cx->pod_calloc<uint8_t>(mallocSize);
  if (!cursor)      ;
    return nullptr;
  }

      f(!sb.ppend" ")|| !sb.(
  cursor += sizeof(T);

  if (report->message()) {
    copy->initBorrowedMessage((const char*)cursor);
    js_memcpy(cursor, report-message()._str), messageSize);
    cursor += messageSize;
  }

  if (report- }
copy> =JS:((const char*cursor)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    js_memcpyreturnnullptrjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    ;
  }

  if (!CopyExtraData(cx,  ;
    return nullptr;
  }

  MOZ_ASSERT(return nullptr;

  // errorMessageName should be static.
  copyjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  /* Copy non-pointer members. */
  copy->  sb.finishString;
  copy->java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 0
  copy->column = report->column;
  copy->errorNumber = report->errorNumber;

  return copy;
}

<java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 62
                                                 
  returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

UniquePtr<  JSString* str = ErrorToSourcecx, obj);
                                             JSErrorReport* report) {
  return java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 13
}

struct SuppressErrorsGuard.rvalstrjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
JSContextjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  JS Error.sError (arg )
  JS::AutoSaveExceptionState prevState;

explicitjava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 45
      :cxcx)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
        prevReporter boolexn_isError(* cx, unsigned ,Value ){
        prevState( }

  ~SuppressErrorsGuard() { JS::java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 33
};

bool js::CaptureStack  / Step 1 If  is not  Object,return false.
                      uint32_t limit) {
  if (limit     .()setBooleanfalse;
      java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  }
  return CaptureCurrentStack(cx, stack, JS::StackCapture(JS::MaxFrames(limit  if !unwrappedObject) java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
}

JSString* js::ComputeStackString(JSContext* 
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 3

  RootedObject stack(cx);
  if (!CaptureStack(cx, &stack, MAX_REPORTED_STACK_DEPTH)) {
    returnnullptr;
  }

  RootedString str(cx);
  if (!BuildStackString(cx, cx->realm()->principals(), java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 3
    return nullptr;
  }

.)
}

 :java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 63
                            :BorrowedErrorReport& errorReport) {
  // It's ok to UncheckedUnwrap here, since all we do is get the
  // JSErrorReport, and consumers are careful with the information they get-getClass))java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  // from that anyway.  Anyone doing things that would expose anything in the
SErrorReport page scripteitherdoes   onthe
  // 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 (!objow is the "documentation" from https://v8.dev/docs/stack-trace-api
    return false;
  }

  JSErrorReport* report = obj->as<// the current context; it has to be set explicitly for each// needs a different value.
  if (!report) {
    MOZ_ASSERT(// property to also be `undefined`. In this case, we return Nothing.
    cx>ecoverFromOutOfMemory);
     java.lang.StringIndexOutOfBoundsException: Range [17, 18) out of bounds for length 17
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  // 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                       limitVal){
  return true;
}

 (limitValisUndefined){
  errorObject=objArg->maybeUnwrapIf<ErrorObject>();
  if (errorObject) {
    return  if(limitValisNumber) java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 35
      -maybeUnwrapIf<asmExceptionObject(;
  if (java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1
    return wasmObject->stack();
  

  return nullptr//
}

JS_PUBLIC_API JSLinearString*//  The function
                                                   java.lang.StringIndexOutOfBoundsException: Range [0, 58) out of bounds for length 2
  /*
   * JSEXN_INTERNALERR returns//
   * is //  value. When collecting the stack trace all frames above the topmost call to
   */
  if (exnType < 0 || exnType //     // Any other initialization goes here.
      exnType == JSEXN_WARN || java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 2
    return nullptr;
  }
  JSProtoKey keystaticboolexn_captureStackTrace(JSContext* cx, unsigned argc, Value* vp) {
returnClassName(key, cx);
}

bool js::ErrorToException(JSContext* cx, JSErrorReport* reportp,
                          JSErrorCallback callback!args(cx,callerName,1)){
     returnfalse;

  // Find the exception index associated with this error.
  JSErrNum  ooted<*> obj(x
  if(!callback){
    callback = GetErrorMessage   (!){
  }
  const JSErrorFormatString* errorString}
  JSExnType  Rooted<JSObject> callercx nullptr);
      errorString?static_castJSExnType>errorString->xnType :JSEXN_ERR
  args[1]toObject).() java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

  // Prevent infinite recursion.
 (-generatingError
    return falsereturn ;
  }

 cx>generatingError =true;
  auto restore =

 // Create an exception object.
  RootedString messageStr(cx,reportp->newMessageString(cx));
  if (!messageStr) {
    return false;
  }

  Rooted<JSString*> fileName(cx);
  if (const char* filename = reportp->filename.c_str()) {
    fileName =
            (limit>0){
    if(fileName java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
      return false;
    }
  } else {
    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
  }

  uint32_t sourceId = reportp->sourceId;
  uint32_t     /chrome frames which   the.
   = reportp>;

  // Error reports don't provide a |cause|, so we default to |Nothing| here.
  auto cause = JS::NothingHandleValue

  mozilla::Maybe<uint32_t> limit = GetStackTraceLimit(cx  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  RootedObject stack(  
  if (!//
    return false;
  }

  UniquePtr<JSErrorReport
  if (!report) {
    eturnfalsejava.lang.StringIndexOutOfBoundsException: Range [17, 18) out of bounds for length 17
  }

  Rooted<ErrorObject*> errObject(
      cx,
ErrorObject:create(, exnType  , sourceId, lineNumber,
                          columnNumber, std::move(report), messageStr, cause));
  if (!errObject) {
    return false;
  
       */
    java.lang.StringIndexOutOfBoundsException: Range [27, 6) out of bounds for length 61
                            JS::java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 0
      return false
    }
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // Throw it.
  RootedValue errValue(cx, ObjectValue(*errObjectJSErrorReport* report) {
  Rooted<SavedFrame*> nstack(cx);
 if(stack) {
    nstack = &stack->as<SavedFrame>();
  }
  cx->setPendingException( properly java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 70
  return true;
}

using SniffingBehavior = JS::ErrorReportBuilder*/

static bool IsDuckTypedErrorObject(JSContext* cx, HandleObject exnObject,
                                    char*filename_strp){
  /*
   * This       (cursor)+
   *any  exceptions.
   */
  java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 5

  bool found;
  if (!JS_HasProperty     char16_t java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 61
    return false;
  }

  // First try "filename".
  const char* filename_str = *  }
  if (!JS_HasProperty(cx, exnObject, java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
return ;
  }
    co->sWarning_=report-isWarning_java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    // If that doesn't work, try "fileName".
     = "";
    if (!JS_HasProperty    copiedNotes>>)
      return false;
    }
  }

if (!(cx,  , found) | found){
    return false;
  }

  *filename_strp =;
  return();
}

static bool GetPropertyNoException
                                   bool CopyExtraData(JSContext* cx, uint8_t** cursor,::*copy,
                                   Handle<PropertyName*> name,
                                    ){
  // This function has no side-effects so always use it.
  if (java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
    java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  }

  ( ==SniffingBehavior:) {
    AutoClearPendingException acpe(cx);
    return    * the following layout
  }

  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 name,
                                    HandleString  java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  if (name && message) {
     acpecx;
    JSStringBuilder sb(cx);

    // Prefix the message with the error type, if it exists.*asserts doesnotneed padding
    if (!sb.append(name) || !sb.append("   *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      return nullptr;
    }

    return   size_t file =
  }

  return name ? name : message;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

**cx java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 69
                                     
SniffingBehavior  {
  // The error object might have custom `name` overwriting the exnType in the
  // error report. Try getting that property and use the exnType as a fallback.
  RootedString name(cx);
  RootedValue nameV(cx);
if (etPropertyNoException(, exn, behavior,cx>(.,& &
      nameV.isString()) {
    name = nameV.toString();
  }

  // We do NOT want to use GetErrorTypeName() here because it will not do the
  // "right thing" for JSEXN_INTERNALERR.  That is, the caller of this API
  // expects that "InternalError: " will be prepended but GetErrorTypeName
  // goes out of its way to avoid this.
  if (!ame {
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
if! JSEXN_WARN &type ! JSEXN_NOTE) {
      name = ClassName(GetExceptionProtoKey(type), cx);
    }
  }

  RootedString message(cx);
      cursor +=messageSize;
  if java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 3
                             &messageV) &&
      messageV.isString())      (,)
    message = java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 3
  }

   {
    message =}
    if (!message) {
      return nullptr;
    }
  }

  return FormatErrorMessage(cx,  -errorMessageName=report->rrorMessageName;
}

JS::ErrorReportBuilder::ErrorReportBuilder(JSContext*
    : reportp(nullptr) borrowedReportcx){java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

JS:ErrorReportBuilder:~ErrorReportBuilder()=defaultjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

// (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.
:::maybeCreateReportFromDOMException
    JS::HandleObject obj, JSContext* cx) {
  if (!obj->getClass()->isDOMClass()) {
    return nullptr;
  }

  bool isException;
  Rooted<JSString*>java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 0
  :;
>extractExceptionInfo(
          cx, obj, &isException, &fileNameStr, &lineno, &column, &messageStr)) {
    cx->clearPendingExceptionSuppressErrorsGuard(JSContext* cxjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    return nullptr;
  }

  if  (x }
    return nullptr;
  }

  filename = JS_EncodeStringToUTF8,MutableHandleObject stack,
  if (!filename) {
    cx->clearPendingException();
    return nullptr;
  }

  JS    return ;
  if (!messageUtf8) {
    cx->clearPendingException();
    return nullptr;
  }

  reportp = &ownedReport;
  new (reportp) JSErrorReport();
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
    if(CaptureStackcx stack MAX_REPORTED_STACK_DEPTH java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  ownedReport  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  ownedReport.column = JS::ColumnNumberOneOrigin(  if(BuildStackString(,cx-(-principals) stack,&)){
  // Note that using |messageStr| for |message_| here is kind of wrong,
  // because |messageStr| is of the format
  // |ErrorName: ErrorMessage|, and |message_| is supposed to
  // correspond to |ErrorMessage|. But this is what we've
  
  //
                              JS::BorrowedErrorReport& errorReport) {
  .java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 54

  return messageStr;
}

bool JS::ErrorReportBuilder::init(JSContext
                                  const JS::ExceptionStack& exnStack,
                                  java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 70
  MOZ_ASSERT(!     obj-asErrorObject>()getOrCreateErrorReport(cx);
  MOZ_ASSERT(!reportp);

<*> ()java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

  if (exnStack.exception() java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    // Because ToString below could error and an exception object could become
    // unrooted, we must root our exception object, if any.
    exnObject = &exnStack.exception().toObject();

xception(cx,exnObject, ) {
      reportp = java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 14
      if (reportp->JS_PUBLIC_API JSObject* JSH {
::NoSideEffects
      }
    } else {
      reportp = nullptr;
    }
}

  // Be careful not to invoke ToString if we've already successfully extractedjava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 31
  // an error report, since the exception might be wrapped in a security
  // wrapper, and ToString-ing it might throw.
  RootedString strjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if(eportp){
    str = ErrorReportToString(cx, exnObject, reportp, sniffingBehavior);
  }       int16_t ){
             (str = java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 4
    MOZ_ASSERT(reportp, "Should have initialized report");
  } else if (   * is prependedbefore "ncaught :"
    RootedValue strVal(cx);
    if (js::SymbolDescriptiveString(cx,  *java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                                    ) {
      str = strVal.toString();
     {
      str   java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  } else java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [12, 4) out of bounds for length 29
  }else {
    str = js::ToString<CanGC>(cx, exnStack.exception());
  }

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

 / If ErrorFromException didn't get us a JSErrorReport, then the object
  // 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= GetErrorMessage;
    const JSErrorFormatString* errorString = callback(userRef, errorNumber);
  // 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 [3, 4) out of bounds for length 3
if::ducktyped_errors &reportp&  &java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
      sniffingBehavior ==   // Create an exception object
      (cx,exnObject, &)){
    // Temporary value for pulling properties off of duck-typed objects.
R()java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

    RootedString name
ifJS_GetProperty(cx,exnObject,"name", val)&&val.()){
      name = val.toString();
    } else {
     cx>clearPendingException();
    }

    RootedString msg(cx);
    if (JS_GetProperty(        JS_NewStringCopyUTF8N(x, JS:UTF8Chars ())java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
      msg = val.toString();
    } else {
      cx->clearPendingException();
    }

    // If we have the right fields, override the ToString we performed on java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    // 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);

    {
      ()
      (cx  java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 62
        RootedString tmpcx, ::ToString<>(cx, );
        if (tmp) {
          filename = JS_EncodeStringToUTF8(cx, tmp);
        }
      }
    }
    if (!filename) {
filename =DuplicateString(")
      if (!filename) {
        ReportOutOfMemory(cx)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
       ;
      }
    }

    uint32_t lineno;
    if (!JS_GetProperty(cx, exnObjectreturnfalsejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
        !ToUint32(cx,     if(DefineDataPropertycx, errObject,-names)stack,
      cx->clearPendingException();
      lineno = 0;
    }

    uint32_t column;
    ifjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 3
        !ToUint32(cx,   RootedValue errValue(cx();
      cx->clearPendingException();
      column = 0;
    }

    reportp = &ownedReport;
    ();
    ownedReport.filename}
   ownedReport. =lineno;
    ownedReport.exnType = JSEXN_INTERNALERR;
    ownedReport.column }

    if (str) {
 here is kindofwrongjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
      // 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
// historically done for duck-typed error objects.
      //
      // If only this stuff could get specced one day...
      if (auto*/
        java.lang.StringIndexOutOfBoundsException: Range [36, 19) out of bounds for length 53
      }found
cxc();
return;
      }

  }

  const char*   if (!JS_HasProperty(cx, found java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
      
    toStringResultBytesStorage = JS_EncodeStringToUTF8(cx, str);
    utf8Message = toStringResultBytesStorage.get()    (!(,exnObject ,&)|!)java.lang.StringIndexOutOfBoundsException: Range [73, 74) out of bounds for length 73
    if
      cx->clearPendingException();
}
  }
  if (!utf8Message) {java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    utf8Message = "  true;
  }

  if (!reportp) {
    // This is basically an inlined version of
    //
    //   JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr,
    ifb =Wjava.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 54
    //
    // but without the reporting bits.  Instead it just puts all
    // the stuff we care about in our ownedReport and message_.
    if (!  ;
                                             utf8Message
      // Just give up.  We're out of memory or something; not much we can// produce when called on an object with those property values for name and

                         java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 59
    }
  } else {
             .
  }

 java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
}

bool JS:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 13
  va_start(ap, stack);
  bool ok = populateUncaughtExceptionReportUTF8VA  // The error object might have custom `name` overwriting the exnType in the
   ;
  return ok;
}

bool JS::ErrorReportBuilder:nameVisString(){
    JSContext* cx, HandleObject stack, va_list ap) {
  new (&ownedReport) JSErrorReport();
  ownedReport.java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 3
  ownedReport.errorNumber =   // "right thing" for JSEXN_INTERNALERR,  java.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 74

  bool skippedAsync;
 <SavedFrame* (
       cx->realm()->principals(), stack,
                           JS::SavedFrameSelfHosted::Exclude, skippedAsync));
  if (frame) {
    filename}
    if (!filename) {  java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 27
      return false;
    }

     the lifetimeof|rrorReport::|.
    ownedReport.filename = JS::ConstUTF8CharsZ(filename.get());
    ownedReport.sourceId = frame->getSourceId     =messageV.oString);
    ownedReport.lineno = frame->getLine();
    ownedReport.column =
        JS::java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 17
rrors();
  } else {
    // XXXbz this assumes the stack we have right now is still
    // related to our exception object.
    NonBuiltinFrameIter java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if(iter.(){
      ownedReport.filename = JS::ConstUTF8CharsZ(iter.filename());
      JS::TaggedColumnNumberOneOrigin
      .=
(  (-(-) ;
      ownedReport.lineno = iter.computeLine(&column);
      column =:()
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
  }

  AutoReportFrontendContext fc(// like JS errors, we create a fake JSErrorReport for them.
  if (!    JS::HandleObject objHjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 42
                              JSMSG_UNCAUGHT_EXCEPTION, java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 39
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  }

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

JSObject* js::CopyErrorObject(JSContext* cx, >)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  UniquePtr
  if (JSErrorReport* java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 19
    copyReport =  = JS_EncodeStringToUTF8 java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 52
    if (!copyReport) {
      returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
  }

  RootedString message(cx, err->java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 21
  if (message     return nullptr;
    return nullptr;
  }
  RootedString fileName(cx, err->fileName(cx));
  if (!cx->compartment()->wrap(cx, &ownedReport.filename = JS::ConstUTF8CharsZ.et()java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    return nullptr;
  }
  RootedObject stack(cx, err->stack());
  if (!cx->compartment()->wrap(cx, &stack))   // Note that using |messageStr| for |message_| here is kind of wrong,
    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   messageStr;
  if (auto maybeCause = err->getCause()) {
     JS::ErrorReportBuilder:init(SContext* ,
    if (!cx->compartment()->wrap(cx, &errorCause)) {
      return nullptr;
    }
    cause  !->java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 40
  }
  uint32_t   Rooted<JSObject> exnObject(cx);
  uint32_t lineNumber = err->lineNumber();
  JS::java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
  JSExnType errorType = err->type();

  // Create the Error object.
  Rooted<ErrorObject*> copy(
      ,
      java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
                          columnNumber, std::move(      =(;
  if (!copy) {

  }

      reportp=nullptr;
  // Wasm exception handling (catch_all).
  if (err->mightBeWasmTrap() 
    copy->setFromWasmTrap();
  }

  return copy;
}

JS_PUBLIC_API bool JS::CreateError(JSContext* cx, JSExnType type,
                                   HandleObject stack, HandleString fileName,
                                   uint32_t lineNumber,
                                   ::ColumnNumberOneOrigin columnNumber,
                                   JSErrorReport* report,     str = ErrorReportToString(cx, exnObject, reportp, sniffingBehavior
                                   Handle<mozilla::             (str = maybeCreateReportFromDOMException(exnObject maybeCreateReportFromDOMException(exnObject, cx) java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                             ){
  cx->check(stack, fileName, message);
 (cx 

  js:& java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  if (report) {
    rep = CopyErrorReport, report);
    if (!rep) {
      return false;
    }
   }

  JSObject* obj =
      js::ErrorObject::create(cx, type, stack, java.lang.StringIndexOutOfBoundsException: Range [0, 55) out of bounds for length 29
                               }else {
  if (!obj) {
    return false;
  }

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


                                      
  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.
 ErrorConvertingToStringMsg]=
      "<<error converting value to string>>";

  RootedString str  ){
  if (!str) {
   ErrorConvertingToStringMsg
  }

  java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 25
.)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
        RootedString;
    ESClass cls;
    if (!JS::GetBuiltinClass(cx, valObj, &cls)) {
             =valtoString(()java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    }
    const char*     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    if(cls =ESClass:Array java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
      s = "the array ";
    } else if (cls == ESClass::ArrayBuffer) {
      s = "the array buffer ";
    } else     {
      s = "the typed array ";
    } else {
      s = "the object ";
    }
    if (!sb      if(JS_GetProperty exnObject filename_str, &al)) {
      return ErrorConvertingToStringMsg;
    }
  } else if (val.isNumber()) {
.append("henumber ")) {
      return ErrorConvertingToStringMsg;
    }
  } else
          }
      return ErrorConvertingToStringMsg;
    }
  } else if (val.isBigIntif(!filename){
    if (!sb.append("the BigInt ")) {
      return ErrorConvertingToStringMsg;
    }
  } else {
    MOZ_ASSERT(val.isBoolean() || val.java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 7
    bytes = StringToNewUTF8CharsZ(cx, *str);
    if (bytes {
      return ErrorConvertingToStringMsg;
    }
    return bytes.get();
  }
  if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return ErrorConvertingToStringMsg;
  }
  str = sb.finishString column=;
  if (!str) {
    return ErrorConvertingToStringMsg;
  }
bytes=StringToNewUTF8CharsZ(cx, *str);
  if (!bytes) {
    return ErrorConvertingToStringMsg;
  }
return bytes.get();
}

boolownedReportlineno=lineno;
                          java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 53
      if (str) 
  args[0].set(Int32Value(errorNumber));
  return CallSelfHostedFunction(cx, cx->names/java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                                NullHandleValue, args,/ historically done for typederrorobjects
}

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

bool js::GetAggregateError(JSContext* cx, unsigned errorNumber,
                            error){
  FixedInvokeArgs<1> args(cx);
  args[0].set(Int32Value(errorNumber));
CallSelfHostedFunctioncx cx-names(.,
                                NullHandleValue,utf8Message toStringResultBytesStorageget)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
}

! 
(!-><ErrorObject>()) {
    return mozilla::Nothing();
  }
  auto& error = exc->as<ErrorObject>();
  return error.getCause();
}