@linkTimeConstant

function createObjectWithoutPrototype(/* key1, value1, key2, value2, ... */)

@linkTimeConstant

function createArrayWithoutPrototype(/* value1, value2, ... */)

@linkTimeConstant

@visibility=PrivateRecursive

function createInspectorInjectedScript(InjectedScriptHost, inspectedGlobalObject, injectedScriptId)

function PrototypelessObjectBase() {}

PrototypelessObjectBase.prototype = null;

function toString(obj)

return @String(obj);

function toStringDescription(obj)

function isUInt32(obj)

function isSymbol(value)

return typeof value === "symbol";

function isBigInt(value)

return typeof value === "bigint";

function isEmptyObject(object)

function isDefined(value)

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

function isPrimitiveValue(value)

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

}

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)

}

function processDescriptor(descriptor, isOwnProperty, possibleNativeBindingGetter)

}

function processProperty(o, propertyName, isOwnProperty, isPrivate)

}

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;

// FIXME: <https://webkit.org/b/201861> Web Inspector: show autocomplete entries for non-index properties on arrays

if (isArrayLike && isOwnProperty) {

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

if (!(i in o))

continue;

let result = processProperty(o, toString(i), isOwnProperty);

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

if (shouldBreak)

break;

}

} else {

let propertyNames = @Object.@getOwnPropertyNames(o);

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

let result = processProperty(o, propertyNames[i], isOwnProperty);