if (arguments.length % 2 !== 0)

@throwRangeError("`createObjectWithoutPrototype` requires that each key argument be followed by a value, resulting in an even number of arguments.");

let object = @Object.@create(null)

for (let i = 0; i < arguments.length; i += 2)

object[arguments[i]] = arguments[i + 1];

return object;

let array = new @Array(arguments.length);

array.__proto__ = null;

for (let i = 0; i < arguments.length; ++i)

@arrayPush(array, arguments[i]);

return array;

function PrototypelessObjectBase() {}

PrototypelessObjectBase.prototype = null;

function toString(obj)

return @String(obj);

function toStringDescription(obj)

if (obj === 0 && 1 / obj < 0)

return "-0";

if (isBigInt(obj))

return toString(obj) + "n";

return toString(obj);

function isUInt32(obj)

if (typeof obj === "number")

return obj >>> 0 === obj && (obj > 0 || 1 / obj > 0);

return "" + (obj >>> 0) === obj;

function isSymbol(value)

return typeof value === "symbol";

function isBigInt(value)

return typeof value === "bigint";

function isEmptyObject(object)

for (let key in object)

return false;

return true;

function isDefined(value)

return !!value || InjectedScriptHost.isHTMLAllCollection(value);

function isPrimitiveValue(value)

switch (typeof value) {

case "boolean":

case "number":

case "string":

return true;

case "undefined":

return !InjectedScriptHost.isHTMLAllCollection(value);

default:

return false;

}

function createIterableWithoutPrototypeFromArguments(argumentsObject) {

let iteratorFunction = argumentsObject.@@iterator;

return @wrappedIterator(iteratorFunction.@call(argumentsObject));

function max(a, b) {

return a > b ? a : b;

let InjectedScript = class InjectedScript extends PrototypelessObjectBase

constructor()

{

super();

this._lastBoundObjectId = 1;

this._idToWrappedObject = @createObjectWithoutPrototype();

this._idToObjectGroupName = @createObjectWithoutPrototype();

this._objectGroups = @createObjectWithoutPrototype();

this._modules = @createObjectWithoutPrototype();

this._nextSavedResultIndex = 1;

this._savedResults = @createArrayWithoutPrototype();

}

// InjectedScript C++ API

execute(functionString, objectGroup, includeCommandLineAPI, returnByValue, generatePreview, saveResult, args)

{

return this._wrapAndSaveCall(objectGroup, returnByValue, generatePreview, saveResult, () => {

const isEvalOnCallFrame = false;

return this._evaluateOn(InjectedScriptHost.evaluateWithScopeExtension, InjectedScriptHost, functionString, isEvalOnCallFrame, includeCommandLineAPI).@apply(@undefined, args);

});

}

evaluate(expression, objectGroup, includeCommandLineAPI, returnByValue, generatePreview, saveResult)

{

const isEvalOnCallFrame = false;

return this._evaluateAndWrap(InjectedScriptHost.evaluateWithScopeExtension, InjectedScriptHost, expression, objectGroup, isEvalOnCallFrame, includeCommandLineAPI, returnByValue, generatePreview, saveResult);

}

awaitPromise(promiseObjectId, returnByValue, generatePreview, saveResult, callback)

{

let parsedPromiseObjectId = this._parseObjectId(promiseObjectId);

let promiseObject = this._objectForId(parsedPromiseObjectId);

let promiseObjectGroupName = this._idToObjectGroupName[parsedPromiseObjectId.id];

if (!isDefined(promiseObject)) {

callback("Could not find object with given id");

return;

}

if (!@isPromise(promiseObject)) {

callback("Object with given id is not a Promise");

return;

}

let resolve = (value) => {

let returnObject = @createObjectWithoutPrototype(

"wasThrown", false,

"result", RemoteObject.create(value, promiseObjectGroupName, returnByValue, generatePreview),

);

if (saveResult) {

this._savedResultIndex = 0;

this._saveResult(returnObject.result);

if (this._savedResultIndex)

returnObject.savedResultIndex = this._savedResultIndex;

}

callback(returnObject);

};

let reject = (reason) => {

callback(this._createThrownValue(reason, promiseObjectGroupName));

};

promiseObject.@then(resolve, reject);

}

evaluateOnCallFrame(topCallFrame, callFrameId, expression, objectGroup, includeCommandLineAPI, returnByValue, generatePreview, saveResult)

{

let callFrame = this._callFrameForId(topCallFrame, callFrameId);

if (!callFrame)

return "Could not find call frame with given id";

const isEvalOnCallFrame = true;

return this._evaluateAndWrap(callFrame.evaluateWithScopeExtension, callFrame, expression, objectGroup, isEvalOnCallFrame, includeCommandLineAPI, returnByValue, generatePreview, saveResult);

}

callFunctionOn(objectId, expression, args, returnByValue, generatePreview, awaitPromise, callback)

{

let parsedObjectId = this._parseObjectId(objectId);

let object = this._objectForId(parsedObjectId);

let objectGroupName = this._idToObjectGroupName[parsedObjectId.id];

if (!isDefined(object)) {

callback("Could not find object with given id");

return;

}

let resolvedArgs = @createArrayWithoutPrototype();

if (args) {

let callArgs = InjectedScriptHost.evaluate(args);

for (let i = 0; i < callArgs.length; ++i) {

try {

resolvedArgs[i] = this._resolveCallArgument(callArgs[i]);

} catch (e) {

callback(@String(e));

return;

}

}

}

try {

let func = InjectedScriptHost.evaluate("(" + expression + ")");

if (typeof func !== "function") {

callback("Given expression does not evaluate to a function");

return;

}

let result = func.@apply(object, resolvedArgs);

if (awaitPromise && isDefined(result) && @isPromise(result)) {

result.then((value) => {

callback(@createObjectWithoutPrototype(

"wasThrown", false,

"result", RemoteObject.create(value, objectGroupName, returnByValue, generatePreview),

));

}, (reason) => {

callback(this._createThrownValue(reason, objectGroupName));

});

} else {

callback(@createObjectWithoutPrototype(

"wasThrown", false,

"result", RemoteObject.create(result, objectGroupName, returnByValue, generatePreview),

));

}

} catch (e) {

callback(this._createThrownValue(e, objectGroupName));

return;

}

}

getFunctionDetails(objectId)

{

let parsedObjectId = this._parseObjectId(objectId);

let object = this._objectForId(parsedObjectId);

if (typeof object !== "function")

return "Cannot resolve function by id.";

return this.functionDetails(object);

}

functionDetails(func)

{

let details = InjectedScriptHost.functionDetails(func);

if (!details)

return "Cannot resolve function details.";

return details;

}

getPreview(objectId)

{

let parsedObjectId = this._parseObjectId(objectId);

let object = this._objectForId(parsedObjectId);

return RemoteObject.createObjectPreviewForValue(object, true);

}

getProperties(objectId, ownProperties, fetchStart, fetchCount, generatePreview)

{

let collectionMode = ownProperties ? InjectedScript.CollectionMode.OwnProperties : InjectedScript.CollectionMode.AllProperties;

return this._getProperties(objectId, collectionMode, @createObjectWithoutPrototype(

"fetchStart", fetchStart,

"fetchCount", fetchCount,

"generatePreview", generatePreview,

));

}

getDisplayableProperties(objectId, fetchStart, fetchCount, generatePreview)

{

let collectionMode = InjectedScript.CollectionMode.OwnProperties | InjectedScript.CollectionMode.NativeGetterProperties;

return this._getProperties(objectId, collectionMode, @createObjectWithoutPrototype(

"fetchStart", fetchStart,

"fetchCount", fetchCount,

"generatePreview", generatePreview,

"nativeGettersAsValues", true,

));

}

getInternalProperties(objectId, generatePreview)

{

let parsedObjectId = this._parseObjectId(objectId);

let object = this._objectForId(parsedObjectId);

let objectGroupName = this._idToObjectGroupName[parsedObjectId.id];

if (!isDefined(object))

return false;

if (isSymbol(object))

return false;

let descriptors = this._internalPropertyDescriptors(object);

if (!descriptors)

return @createArrayWithoutPrototype();

for (let i = 0; i < descriptors.length; ++i) {

let descriptor = descriptors[i];

if ("value" in descriptor)

descriptor.value = RemoteObject.create(descriptor.value, objectGroupName, false, generatePreview);

}

return descriptors;

}

getCollectionEntries(objectId, objectGroupName, fetchStart, fetchCount)

{

let parsedObjectId = this._parseObjectId(objectId);

let object = this._objectForId(parsedObjectId);

objectGroupName = objectGroupName || this._idToObjectGroupName[parsedObjectId.id];

if (!isDefined(object))

return;

if (typeof object !== "object")

return;

let entries = this._entries(object, InjectedScriptHost.subtype(object), fetchStart, fetchCount);

for (let i = 0; i < entries.length; ++i) {

let entry = entries[i];

entry.value = RemoteObject.create(entry.value, objectGroupName, false, true);

if ("key" in entry)

entry.key = RemoteObject.create(entry.key, objectGroupName, false, true);

}

return entries;

}

saveResult(callArgumentJSON)

{

this._savedResultIndex = 0;

try {

let callArgument = InjectedScriptHost.evaluate("(" + callArgumentJSON + ")");

let value = this._resolveCallArgument(callArgument);

this._saveResult(value);

} catch { }

return this._savedResultIndex;

}

wrapCallFrames(callFrame)

{

if (!callFrame)

return false;

let result = @createArrayWithoutPrototype();

let depth = 0;

do {

@arrayPush(result, new InjectedScript.CallFrameProxy(depth++, callFrame));

callFrame = callFrame.caller;

} while (callFrame);

return result;

}

wrapObject(object, groupName, canAccessInspectedGlobalObject, generatePreview)

{

if (!canAccessInspectedGlobalObject)

return this._fallbackWrapper(object);

return RemoteObject.create(object, groupName, false, generatePreview);

}

wrapJSONString(jsonString, groupName, generatePreview)

{

try {

return this.wrapObject(@jsonParse(jsonString), groupName, true, generatePreview);

} catch {

return null;

}

}

wrapTable(canAccessInspectedGlobalObject, table, columns)

{

if (!canAccessInspectedGlobalObject)

return this._fallbackWrapper(table);

// FIXME: Currently columns are ignored. Instead, the frontend filters all

// properties based on the provided column names and in the provided order.

// We could filter here to avoid sending very large preview objects.

let columnNames = null;

if (typeof columns === "string")

columns = @createArrayWithoutPrototype(columns);

if (InjectedScriptHost.subtype(columns) === "array") {

columnNames = @createArrayWithoutPrototype();

for (let i = 0; i < columns.length; ++i)

@arrayPush(columnNames, toString(columns[i]));

}

return RemoteObject.create(table, "console", false, true, columnNames);

}

previewValue(value)

{

return RemoteObject.createObjectPreviewForValue(value, true);

}

setEventValue(value)

{

this._eventValue = value;

}

clearEventValue()

{

delete this._eventValue;

}

setExceptionValue(value)

{

this._exceptionValue = value;

}

clearExceptionValue()

{

delete this._exceptionValue;

}

findObjectById(objectId)

{

let parsedObjectId = this._parseObjectId(objectId);

return this._objectForId(parsedObjectId);

}

releaseObject(objectId)

{

let parsedObjectId = this._parseObjectId(objectId);

this._releaseObject(parsedObjectId.id);

}

releaseObjectGroup(objectGroupName)

{

if (objectGroupName === "console") {

delete this._lastResult;

this._nextSavedResultIndex = 1;

this._savedResults = @createArrayWithoutPrototype();

}

let group = this._objectGroups[objectGroupName];

if (!group)

return;

for (let i = 0; i < group.length; i++)

this._releaseObject(group[i]);

delete this._objectGroups[objectGroupName];

}

createCommandLineAPIObject(callFrame)

{

return new CommandLineAPI(callFrame || null);

}

// CommandLineAPI

inspectObject(object)

{

if (this._inspectObject)

this._inspectObject(object);

}

// InjectedScriptModule C++ API

hasInjectedModule(name)

{

return this._modules[name];

}

injectModule(name, moduleFunction, host)

{

this._modules[name] = false;

if (typeof moduleFunction !== "function")

throw "Error: Web Inspector: a function was expected for injectModule";

moduleFunction(InjectedScriptHost, inspectedGlobalObject, injectedScriptId, this, @createObjectWithoutPrototype(

"RemoteObject", RemoteObject,

"CommandLineAPI", CommandLineAPI,

), host);

this._modules[name] = true;

}

// InjectedScriptModule JavaScript API

isPrimitiveValue(value)

{

return isPrimitiveValue(value);

}

// Private

_parseObjectId(objectId)

{

return InjectedScriptHost.evaluate("(" + objectId + ")");

}

_objectForId(objectId)

{

return this._idToWrappedObject[objectId.id];

}

_bind(object, objectGroupName)

{

let id = this._lastBoundObjectId++;

let objectId = `{"injectedScriptId":${injectedScriptId},"id":${id}}`;

this._idToWrappedObject[id] = object;

if (objectGroupName) {

let group = this._objectGroups[objectGroupName];

if (!group) {

group = @createArrayWithoutPrototype();

this._objectGroups[objectGroupName] = group;

}

@arrayPush(group, id);

this._idToObjectGroupName[id] = objectGroupName;

}

return objectId;

}

_releaseObject(id)

{

delete this._idToWrappedObject[id];

delete this._idToObjectGroupName[id];

}

_fallbackWrapper(object)

{

let result = @createObjectWithoutPrototype("type", typeof object);

if (isPrimitiveValue(object))

result.value = object;

else

result.description = toStringDescription(object);

return result;

}

_resolveCallArgument(callArgumentJSON)

{

if ("value" in callArgumentJSON)

return callArgumentJSON.value;

let objectId = callArgumentJSON.objectId;

if (objectId) {

let parsedArgId = this._parseObjectId(objectId);

if (!parsedArgId || parsedArgId["injectedScriptId"] !== injectedScriptId)

throw "Arguments should belong to the same JavaScript world as the target object.";

let resolvedArg = this._objectForId(parsedArgId);

if (!isDefined(resolvedArg))

throw "Could not find object with given id";

return resolvedArg;

}

return @undefined;

}

_createThrownValue(value, objectGroup)

{

let remoteObject = RemoteObject.create(value, objectGroup);

try {

remoteObject.description = toStringDescription(value);

} catch { }

return @createObjectWithoutPrototype(

"wasThrown", true,

"result", remoteObject,

);

}

_evaluateAndWrap(evalFunction, object, expression, objectGroup, isEvalOnCallFrame, includeCommandLineAPI, returnByValue, generatePreview, saveResult)

{

return this._wrapAndSaveCall(objectGroup, returnByValue, generatePreview, saveResult, () => {

return this._evaluateOn(evalFunction, object, expression, isEvalOnCallFrame, includeCommandLineAPI);

});

}

_wrapAndSaveCall(objectGroup, returnByValue, generatePreview, saveResult, func)

{

return this._wrapCall(objectGroup, returnByValue, generatePreview, saveResult, () => {

let result = func();

if (saveResult)

this._saveResult(result);

return result;

});

}

_wrapCall(objectGroup, returnByValue, generatePreview, saveResult, func)

{

try {

this._savedResultIndex = 0;

let returnObject = @createObjectWithoutPrototype(

"wasThrown", false,

"result", RemoteObject.create(func(), objectGroup, returnByValue, generatePreview),

);

if (saveResult && this._savedResultIndex)

returnObject.savedResultIndex = this._savedResultIndex;

return returnObject;

} catch (e) {

return this._createThrownValue(e, objectGroup);

}

}

_evaluateOn(evalFunction, object, expression, isEvalOnCallFrame, includeCommandLineAPI)

{

let commandLineAPI = null;

if (includeCommandLineAPI)

commandLineAPI = this.createCommandLineAPIObject(isEvalOnCallFrame ? object : null);

return evalFunction.@call(object, expression, commandLineAPI);

}

_callFrameForId(topCallFrame, callFrameId)

{

let parsedCallFrameId = InjectedScriptHost.evaluate("(" + callFrameId + ")");

let ordinal = parsedCallFrameId["ordinal"];

let callFrame = topCallFrame;

while (--ordinal >= 0 && callFrame)

callFrame = callFrame.caller;

return callFrame;

}

_getProperties(objectId, collectionMode, {fetchStart, fetchCount, generatePreview, nativeGettersAsValues})

{

let parsedObjectId = this._parseObjectId(objectId);

let object = this._objectForId(parsedObjectId);

let objectGroupName = this._idToObjectGroupName[parsedObjectId.id];

if (!isDefined(object))

return false;

if (isSymbol(object))

return false;

let start = fetchStart || 0;

if (start < 0)

start = 0;

let count = fetchCount || 0;

if (count < 0)

count = 0;

// Always include __proto__ at the end, but only for the first fetch.

let includeProto = !start;

let descriptors = @createArrayWithoutPrototype();

this._forEachPropertyDescriptor(object, collectionMode, (descriptor) => {

if (start > 0) {

--start;

return InjectedScript.PropertyFetchAction.Continue;

}

if ("get" in descriptor)

descriptor.get = RemoteObject.create(descriptor.get, objectGroupName);

if ("set" in descriptor)

descriptor.set = RemoteObject.create(descriptor.set, objectGroupName);

if ("value" in descriptor)

descriptor.value = RemoteObject.create(descriptor.value, objectGroupName, false, generatePreview);

if ("symbol" in descriptor)

descriptor.symbol = RemoteObject.create(descriptor.symbol, objectGroupName);

@arrayPush(descriptors, descriptor);

if (includeProto && count && descriptors.length >= count && descriptor.name !== "__proto__")

return InjectedScript.PropertyFetchAction.Stop;

return (count && descriptors.length >= count) ? InjectedScript.PropertyFetchAction.Stop : InjectedScript.PropertyFetchAction.Continue;

}, @createObjectWithoutPrototype(

"nativeGettersAsValues", nativeGettersAsValues,

"includeProto", includeProto,

));

return descriptors;

}

_internalPropertyDescriptors(object, completeDescriptor)

{

let internalProperties = InjectedScriptHost.getInternalProperties(object);

if (!internalProperties)

return null;

let descriptors = @createArrayWithoutPrototype();

for (let i = 0; i < internalProperties.length; i++) {

let property = internalProperties[i];

let descriptor = @createObjectWithoutPrototype(

"name", property.name,

"value", property.value,

);

if (completeDescriptor)

descriptor.isOwn = true;

@arrayPush(descriptors, descriptor);

}

return descriptors;

}

_forEachPropertyDescriptor(object, collectionMode, callback, {nativeGettersAsValues, includeProto})

{

let subtype = RemoteObject.subtype(object);

if (subtype === "proxy" || subtype === "weakref")

return;

let nameProcessed = new @Set;

// Handled below when `includeProto`.

nameProcessed.@add("__proto__");

function createFakeValueDescriptor(name, symbol, descriptor, isOwnProperty, possibleNativeBindingGetter)

{

try {

let fakeDescriptor = @createObjectWithoutPrototype(

"name", name,

"value", object[name],

);

if (descriptor) {

if (descriptor.writable)

fakeDescriptor.writable = true;

if (descriptor.configurable)

fakeDescriptor.configurable = true;

if (descriptor.enumerable)

fakeDescriptor.enumerable = true;

}

if (possibleNativeBindingGetter)

fakeDescriptor.nativeGetter = true;

if (isOwnProperty)

fakeDescriptor.isOwn = true;

if (symbol)

fakeDescriptor.symbol = symbol;

// Silence any possible unhandledrejection exceptions created from accessing a native accessor with a wrong this object.

if (@isPromise(fakeDescriptor.value) && InjectedScriptHost.isPromiseRejectedWithNativeGetterTypeError(fakeDescriptor.value))

fakeDescriptor.value.@then(@undefined, function(){});

return fakeDescriptor;

} catch (e) {

let errorDescriptor = @createObjectWithoutPrototype(

"name", name,

"value", e,

"wasThrown", true,

);

if (isOwnProperty)

errorDescriptor.isOwn = true;

if (symbol)

errorDescriptor.symbol = symbol;

return errorDescriptor;

}

}

function processDescriptor(descriptor, isOwnProperty, possibleNativeBindingGetter)

{

// All properties.

if (collectionMode & InjectedScript.CollectionMode.AllProperties)

return callback(descriptor);

// Own properties.

if (collectionMode & InjectedScript.CollectionMode.OwnProperties && isOwnProperty)

return callback(descriptor);

// Native Getter properties.

if (collectionMode & InjectedScript.CollectionMode.NativeGetterProperties) {

if (possibleNativeBindingGetter)

return callback(descriptor);

}

}

function processProperty(o, propertyName, isOwnProperty, isPrivate)

{

if (nameProcessed.@has(propertyName))

return InjectedScript.PropertyFetchAction.Continue;

nameProcessed.@add(propertyName);

// Private fields are implemented as hidden symbols, so don't treat them like regular `Symbol`.

let name = isPrivate ? propertyName.description : toString(propertyName);

let symbol = (!isPrivate && isSymbol(propertyName)) ? propertyName : null;

let descriptor = @Object.@getOwnPropertyDescriptor(o, propertyName);

if (!descriptor) {

// FIXME: Bad descriptor. Can we get here?

// Fall back to very restrictive settings.

let fakeDescriptor = createFakeValueDescriptor(name, symbol, descriptor, isOwnProperty);

return processDescriptor(fakeDescriptor, isOwnProperty);

}

if (nativeGettersAsValues) {

if (@String(descriptor.get).@endsWith("[native code]\n}") || (!descriptor.get && @Object.@hasOwn(descriptor, "get") && !descriptor.set && @Object.@hasOwn(descriptor, "set"))) {

// Developers may create such a descriptor, so we should be resilient:

// let x = {}; Object.defineProperty(x, "p", {get:undefined}); Object.getOwnPropertyDescriptor(x, "p")

let fakeDescriptor = createFakeValueDescriptor(name, symbol, descriptor, isOwnProperty, true);

return processDescriptor(fakeDescriptor, isOwnProperty, true);

}

}

descriptor.name = name;

if (isOwnProperty)

descriptor.isOwn = true;

if (symbol)

descriptor.symbol = symbol;

if (isPrivate)

descriptor.isPrivate = true;

return processDescriptor(descriptor, isOwnProperty);

}

let isArrayLike = false;

try {

isArrayLike = subtype === "array" && @isFinite(object.length) && object.length > 0;

} catch { }

for (let o = object; isDefined(o); o = @Object.@getPrototypeOf(o)) {

let isOwnProperty = o === object;

let shouldBreak = false;

let privatePropertySymbols = InjectedScriptHost.getOwnPrivatePropertySymbols(o);

for (let i = 0; i < privatePropertySymbols.length; ++i) {

let privatePropertySymbol = privatePropertySymbols[i];

let result = processProperty(o, privatePropertySymbol, isOwnProperty, true);

shouldBreak = result === InjectedScript.PropertyFetchAction.Stop;

if (shouldBreak)

break;

}

if (shouldBreak)

break;

let privateMethods = InjectedScriptHost.getOwnPrivatePropertyMethods(o, isOwnProperty);

for (let i = 0; i < privateMethods.length; ++i) {

let privateMethod = privateMethods[i];

let descriptor = @createObjectWithoutPrototype();

descriptor.name = privateMethod.name;

if (@Object.@hasOwn(privateMethod, "value"))

descriptor.value = privateMethod.value;

if (@Object.@hasOwn(privateMethod, "get"))

descriptor.get = privateMethod.get;

if (@Object.@hasOwn(privateMethod, "set"))