foster/denoland-deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-11-24 15:19:26 -05:00
Code Issues Packages 1 Wiki Activity

Revert "refactor: update runtime code for primordial checks for "instanceof" (#13497)" (#13511)

Browse source 
This reverts commit 884143218f.
This commit is contained in:
Bartek Iwańczuk 2022-01-27 16:27:22 +01:00 committed by GitHub
parent 382a978859
commit f248e6f177
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
41 changed files with 658 additions and 1028 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
core/01_core.js
View file

@ -195,7 +195,6 @@
this.name = "BadResource"; this.name = "BadResource";
} }
} }
const BadResourcePrototype = BadResource.prototype;
class Interrupted extends Error { class Interrupted extends Error {
constructor(msg) { constructor(msg) {
@ -203,7 +202,6 @@
this.name = "Interrupted"; this.name = "Interrupted";
} }
} }
const InterruptedPrototype = Interrupted.prototype;
// Extra Deno.core.* exports // Extra Deno.core.* exports
const core = ObjectAssign(globalThis.Deno.core, { const core = ObjectAssign(globalThis.Deno.core, {
@ -223,9 +221,7 @@
opresolve, opresolve,
syncOpsCache, syncOpsCache,
BadResource, BadResource,
BadResourcePrototype,
Interrupted, Interrupted,
InterruptedPrototype,
}); });
ObjectAssign(globalThis.__bootstrap, { core }); ObjectAssign(globalThis.__bootstrap, { core });

5
ext/broadcast_channel/01_broadcast_channel.js
View file

@ -98,7 +98,7 @@
} }
postMessage(message) { postMessage(message) {
webidl.assertBranded(this, BroadcastChannelPrototype); webidl.assertBranded(this, BroadcastChannel);
const prefix = "Failed to execute 'postMessage' on 'BroadcastChannel'"; const prefix = "Failed to execute 'postMessage' on 'BroadcastChannel'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
@ -121,7 +121,7 @@
} }
close() { close() {
webidl.assertBranded(this, BroadcastChannelPrototype); webidl.assertBranded(this, BroadcastChannel);
this[_closed] = true; this[_closed] = true;
const index = ArrayPrototypeIndexOf(channels, this); const index = ArrayPrototypeIndexOf(channels, this);
@ -134,7 +134,6 @@
defineEventHandler(BroadcastChannel.prototype, "message"); defineEventHandler(BroadcastChannel.prototype, "message");
defineEventHandler(BroadcastChannel.prototype, "messageerror"); defineEventHandler(BroadcastChannel.prototype, "messageerror");
const BroadcastChannelPrototype = BroadcastChannel.prototype;
window.__bootstrap.broadcastChannel = { BroadcastChannel }; window.__bootstrap.broadcastChannel = { BroadcastChannel };
})(this); })(this);

62
ext/console/02_console.js
View file

@ -10,13 +10,12 @@
const { const {
ArrayBufferIsView, ArrayBufferIsView,
isNaN, isNaN,
DataViewPrototype, DataView,
DatePrototype, Date,
DateNow, DateNow,
DatePrototypeGetTime, DatePrototypeGetTime,
DatePrototypeToISOString, DatePrototypeToISOString,
Boolean, Boolean,
BooleanPrototype,
BooleanPrototypeToString, BooleanPrototypeToString,
ObjectKeys, ObjectKeys,
ObjectCreate, ObjectCreate,
@ -28,11 +27,9 @@
ObjectGetOwnPropertyDescriptor, ObjectGetOwnPropertyDescriptor,
ObjectGetOwnPropertySymbols, ObjectGetOwnPropertySymbols,
ObjectPrototypeHasOwnProperty, ObjectPrototypeHasOwnProperty,
ObjectPrototypeIsPrototypeOf,
ObjectPrototypePropertyIsEnumerable, ObjectPrototypePropertyIsEnumerable,
PromisePrototype, Promise,
String, String,
StringPrototype,
StringPrototypeRepeat, StringPrototypeRepeat,
StringPrototypeReplace, StringPrototypeReplace,
StringPrototypeReplaceAll, StringPrototypeReplaceAll,
@ -50,13 +47,11 @@
TypeError, TypeError,
NumberParseInt, NumberParseInt,
RegExp, RegExp,
RegExpPrototype,
RegExpPrototypeTest, RegExpPrototypeTest,
RegExpPrototypeToString, RegExpPrototypeToString,
SetPrototype, Set,
SetPrototypeEntries, SetPrototypeEntries,
Symbol, Symbol,
SymbolPrototype,
SymbolPrototypeToString, SymbolPrototypeToString,
SymbolPrototypeValueOf, SymbolPrototypeValueOf,
SymbolToStringTag, SymbolToStringTag,
@ -78,7 +73,6 @@
ArrayPrototypeFind, ArrayPrototypeFind,
FunctionPrototypeBind, FunctionPrototypeBind,
Map, Map,
MapPrototype,
MapPrototypeHas, MapPrototypeHas,
MapPrototypeGet, MapPrototypeGet,
MapPrototypeSet, MapPrototypeSet,
@ -86,7 +80,6 @@
MapPrototypeEntries, MapPrototypeEntries,
MapPrototypeForEach, MapPrototypeForEach,
Error, Error,
ErrorPrototype,
ErrorCaptureStackTrace, ErrorCaptureStackTrace,
MathAbs, MathAbs,
MathMax, MathMax,
@ -95,17 +88,16 @@
MathRound, MathRound,
MathFloor, MathFloor,
Number, Number,
NumberPrototype,
NumberPrototypeToString, NumberPrototypeToString,
NumberPrototypeValueOf, NumberPrototypeValueOf,
BigIntPrototype, BigInt,
BigIntPrototypeToString, BigIntPrototypeToString,
Proxy, Proxy,
ReflectGet, ReflectGet,
ReflectGetOwnPropertyDescriptor, ReflectGetOwnPropertyDescriptor,
ReflectGetPrototypeOf, ReflectGetPrototypeOf,
WeakMapPrototype, WeakMap,
WeakSetPrototype, WeakSet,
} = window.__bootstrap.primordials; } = window.__bootstrap.primordials;
function isInvalidDate(x) { function isInvalidDate(x) {
@ -134,8 +126,7 @@
// Forked from Node's lib/internal/cli_table.js // Forked from Node's lib/internal/cli_table.js
function isTypedArray(x) { function isTypedArray(x) {
return ArrayBufferIsView(x) && return ArrayBufferIsView(x) && !(x instanceof DataView);
!ObjectPrototypeIsPrototypeOf(DataViewPrototype, x);
} }
const tableChars = { const tableChars = {
@ -897,8 +888,7 @@
let err = value; let err = value;
while ( while (
ObjectPrototypeIsPrototypeOf(ErrorPrototype, err.cause) && err.cause instanceof Error && err.cause !== value &&
err.cause !== value &&
!ArrayPrototypeIncludes(causes, err.cause) // circular check !ArrayPrototypeIncludes(causes, err.cause) // circular check
) { ) {
ArrayPrototypePush(causes, err.cause); ArrayPrototypePush(causes, err.cause);
@ -1170,33 +1160,33 @@
// namespace is always enabled. // namespace is always enabled.
return String(value[privateCustomInspect](inspect)); return String(value[privateCustomInspect](inspect));
} }
if (ObjectPrototypeIsPrototypeOf(ErrorPrototype, value)) { if (value instanceof Error) {
return inspectError(value); return inspectError(value);
} else if (ArrayIsArray(value)) { } else if (ArrayIsArray(value)) {
return inspectArray(value, level, inspectOptions); return inspectArray(value, level, inspectOptions);
} else if (ObjectPrototypeIsPrototypeOf(NumberPrototype, value)) { } else if (value instanceof Number) {
return inspectNumberObject(value, inspectOptions); return inspectNumberObject(value, inspectOptions);
} else if (ObjectPrototypeIsPrototypeOf(BigIntPrototype, value)) { } else if (value instanceof BigInt) {
return inspectBigIntObject(value, inspectOptions); return inspectBigIntObject(value, inspectOptions);
} else if (ObjectPrototypeIsPrototypeOf(BooleanPrototype, value)) { } else if (value instanceof Boolean) {
return inspectBooleanObject(value, inspectOptions); return inspectBooleanObject(value, inspectOptions);
} else if (ObjectPrototypeIsPrototypeOf(StringPrototype, value)) { } else if (value instanceof String) {
return inspectStringObject(value, inspectOptions); return inspectStringObject(value, inspectOptions);
} else if (ObjectPrototypeIsPrototypeOf(SymbolPrototype, value)) { } else if (value instanceof Symbol) {
return inspectSymbolObject(value, inspectOptions); return inspectSymbolObject(value, inspectOptions);
} else if (ObjectPrototypeIsPrototypeOf(PromisePrototype, value)) { } else if (value instanceof Promise) {
return inspectPromise(value, level, inspectOptions); return inspectPromise(value, level, inspectOptions);
} else if (ObjectPrototypeIsPrototypeOf(RegExpPrototype, value)) { } else if (value instanceof RegExp) {
return inspectRegExp(value, inspectOptions); return inspectRegExp(value, inspectOptions);
} else if (ObjectPrototypeIsPrototypeOf(DatePrototype, value)) { } else if (value instanceof Date) {
return inspectDate(value, inspectOptions); return inspectDate(value, inspectOptions);
} else if (ObjectPrototypeIsPrototypeOf(SetPrototype, value)) { } else if (value instanceof Set) {
return inspectSet(value, level, inspectOptions); return inspectSet(value, level, inspectOptions);
} else if (ObjectPrototypeIsPrototypeOf(MapPrototype, value)) { } else if (value instanceof Map) {
return inspectMap(value, level, inspectOptions); return inspectMap(value, level, inspectOptions);
} else if (ObjectPrototypeIsPrototypeOf(WeakSetPrototype, value)) { } else if (value instanceof WeakSet) {
return inspectWeakSet(inspectOptions); return inspectWeakSet(inspectOptions);
} else if (ObjectPrototypeIsPrototypeOf(WeakMapPrototype, value)) { } else if (value instanceof WeakMap) {
return inspectWeakMap(inspectOptions); return inspectWeakMap(inspectOptions);
} else if (isTypedArray(value)) { } else if (isTypedArray(value)) {
return inspectTypedArray( return inspectTypedArray(
@ -1921,14 +1911,14 @@
const toTable = (header, body) => this.log(cliTable(header, body)); const toTable = (header, body) => this.log(cliTable(header, body));
let resultData; let resultData;
const isSet = ObjectPrototypeIsPrototypeOf(SetPrototype, data); const isSet = data instanceof Set;
const isMap = ObjectPrototypeIsPrototypeOf(MapPrototype, data); const isMap = data instanceof Map;
const valuesKey = "Values"; const valuesKey = "Values";
const indexKey = isSet || isMap ? "(iter idx)" : "(idx)"; const indexKey = isSet || isMap ? "(iter idx)" : "(idx)";
if (isSet) { if (data instanceof Set) {
resultData = [...data]; resultData = [...data];
} else if (isMap) { } else if (data instanceof Map) {
let idx = 0; let idx = 0;
resultData = {}; resultData = {};

100
ext/crypto/00_crypto.js
View file

@ -15,20 +15,18 @@
const { TextEncoder, TextDecoder } = window.__bootstrap.encoding; const { TextEncoder, TextDecoder } = window.__bootstrap.encoding;
const { const {
ArrayBufferPrototype, ArrayBuffer,
ArrayBufferIsView, ArrayBufferIsView,
ArrayPrototypeEvery, ArrayPrototypeEvery,
ArrayPrototypeFind, ArrayPrototypeFind,
ArrayPrototypeIncludes, ArrayPrototypeIncludes,
BigInt64ArrayPrototype, BigInt64Array,
BigUint64ArrayPrototype, Int16Array,
Int16ArrayPrototype, Int32Array,
Int32ArrayPrototype, Int8Array,
Int8ArrayPrototype,
JSONParse, JSONParse,
JSONStringify, JSONStringify,
ObjectAssign, ObjectAssign,
ObjectPrototypeIsPrototypeOf,
StringPrototypeToLowerCase, StringPrototypeToLowerCase,
StringPrototypeToUpperCase, StringPrototypeToUpperCase,
Symbol, Symbol,
@ -36,11 +34,10 @@
SyntaxError, SyntaxError,
TypedArrayPrototypeSlice, TypedArrayPrototypeSlice,
TypeError, TypeError,
Uint16ArrayPrototype, Uint16Array,
Uint32ArrayPrototype, Uint32Array,
Uint8Array, Uint8Array,
Uint8ArrayPrototype, Uint8ClampedArray,
Uint8ClampedArrayPrototype,
WeakMap, WeakMap,
WeakMapPrototypeGet, WeakMapPrototypeGet,
WeakMapPrototypeSet, WeakMapPrototypeSet,
@ -289,26 +286,26 @@
/** @returns {string} */ /** @returns {string} */
get type() { get type() {
webidl.assertBranded(this, CryptoKeyPrototype); webidl.assertBranded(this, CryptoKey);
return this[_type]; return this[_type];
} }
/** @returns {boolean} */ /** @returns {boolean} */
get extractable() { get extractable() {
webidl.assertBranded(this, CryptoKeyPrototype); webidl.assertBranded(this, CryptoKey);
return this[_extractable]; return this[_extractable];
} }
/** @returns {string[]} */ /** @returns {string[]} */
get usages() { get usages() {
webidl.assertBranded(this, CryptoKeyPrototype); webidl.assertBranded(this, CryptoKey);
// TODO(lucacasonato): return a SameObject copy // TODO(lucacasonato): return a SameObject copy
return this[_usages]; return this[_usages];
} }
/** @returns {object} */ /** @returns {object} */
get algorithm() { get algorithm() {
webidl.assertBranded(this, CryptoKeyPrototype); webidl.assertBranded(this, CryptoKey);
// TODO(lucacasonato): return a SameObject copy // TODO(lucacasonato): return a SameObject copy
return this[_algorithm]; return this[_algorithm];
} }
@ -326,7 +323,6 @@
} }
webidl.configurePrototype(CryptoKey); webidl.configurePrototype(CryptoKey);
const CryptoKeyPrototype = CryptoKey.prototype;
/** /**
* @param {string} type * @param {string} type
@ -433,7 +429,7 @@
* @returns {Promise<Uint8Array>} * @returns {Promise<Uint8Array>}
*/ */
async digest(algorithm, data) { async digest(algorithm, data) {
webidl.assertBranded(this, SubtleCryptoPrototype); webidl.assertBranded(this, SubtleCrypto);
const prefix = "Failed to execute 'digest' on 'SubtleCrypto'"; const prefix = "Failed to execute 'digest' on 'SubtleCrypto'";
webidl.requiredArguments(arguments.length, 2, { prefix }); webidl.requiredArguments(arguments.length, 2, { prefix });
algorithm = webidl.converters.AlgorithmIdentifier(algorithm, { algorithm = webidl.converters.AlgorithmIdentifier(algorithm, {
@ -465,7 +461,7 @@
* @returns {Promise<any>} * @returns {Promise<any>}
*/ */
async encrypt(algorithm, key, data) { async encrypt(algorithm, key, data) {
webidl.assertBranded(this, SubtleCryptoPrototype); webidl.assertBranded(this, SubtleCrypto);
const prefix = "Failed to execute 'encrypt' on 'SubtleCrypto'"; const prefix = "Failed to execute 'encrypt' on 'SubtleCrypto'";
webidl.requiredArguments(arguments.length, 3, { prefix }); webidl.requiredArguments(arguments.length, 3, { prefix });
algorithm = webidl.converters.AlgorithmIdentifier(algorithm, { algorithm = webidl.converters.AlgorithmIdentifier(algorithm, {
@ -513,7 +509,7 @@
* @returns {Promise<any>} * @returns {Promise<any>}
*/ */
async decrypt(algorithm, key, data) { async decrypt(algorithm, key, data) {
webidl.assertBranded(this, SubtleCryptoPrototype); webidl.assertBranded(this, SubtleCrypto);
const prefix = "Failed to execute 'decrypt' on 'SubtleCrypto'"; const prefix = "Failed to execute 'decrypt' on 'SubtleCrypto'";
webidl.requiredArguments(arguments.length, 3, { prefix }); webidl.requiredArguments(arguments.length, 3, { prefix });
algorithm = webidl.converters.AlgorithmIdentifier(algorithm, { algorithm = webidl.converters.AlgorithmIdentifier(algorithm, {
@ -709,7 +705,7 @@
* @returns {Promise<any>} * @returns {Promise<any>}
*/ */
async sign(algorithm, key, data) { async sign(algorithm, key, data) {
webidl.assertBranded(this, SubtleCryptoPrototype); webidl.assertBranded(this, SubtleCrypto);
const prefix = "Failed to execute 'sign' on 'SubtleCrypto'"; const prefix = "Failed to execute 'sign' on 'SubtleCrypto'";
webidl.requiredArguments(arguments.length, 3, { prefix }); webidl.requiredArguments(arguments.length, 3, { prefix });
algorithm = webidl.converters.AlgorithmIdentifier(algorithm, { algorithm = webidl.converters.AlgorithmIdentifier(algorithm, {
@ -841,7 +837,7 @@
*/ */
// deno-lint-ignore require-await // deno-lint-ignore require-await
async importKey(format, keyData, algorithm, extractable, keyUsages) { async importKey(format, keyData, algorithm, extractable, keyUsages) {
webidl.assertBranded(this, SubtleCryptoPrototype); webidl.assertBranded(this, SubtleCrypto);
const prefix = "Failed to execute 'importKey' on 'SubtleCrypto'"; const prefix = "Failed to execute 'importKey' on 'SubtleCrypto'";
webidl.requiredArguments(arguments.length, 4, { prefix }); webidl.requiredArguments(arguments.length, 4, { prefix });
format = webidl.converters.KeyFormat(format, { format = webidl.converters.KeyFormat(format, {
@ -867,19 +863,13 @@
// 2. // 2.
if (format !== "jwk") { if (format !== "jwk") {
if ( if (ArrayBufferIsView(keyData) || keyData instanceof ArrayBuffer) {
ArrayBufferIsView(keyData) ||
ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, keyData)
) {
keyData = copyBuffer(keyData); keyData = copyBuffer(keyData);
} else { } else {
throw new TypeError("keyData is a JsonWebKey"); throw new TypeError("keyData is a JsonWebKey");
} }
} else { } else {
if ( if (ArrayBufferIsView(keyData) || keyData instanceof ArrayBuffer) {
ArrayBufferIsView(keyData) ||
ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, keyData)
) {
throw new TypeError("keyData is not a JsonWebKey"); throw new TypeError("keyData is not a JsonWebKey");
} }
} }
@ -959,7 +949,7 @@
*/ */
// deno-lint-ignore require-await // deno-lint-ignore require-await
async exportKey(format, key) { async exportKey(format, key) {
webidl.assertBranded(this, SubtleCryptoPrototype); webidl.assertBranded(this, SubtleCrypto);
const prefix = "Failed to execute 'exportKey' on 'SubtleCrypto'"; const prefix = "Failed to execute 'exportKey' on 'SubtleCrypto'";
webidl.requiredArguments(arguments.length, 2, { prefix }); webidl.requiredArguments(arguments.length, 2, { prefix });
format = webidl.converters.KeyFormat(format, { format = webidl.converters.KeyFormat(format, {
@ -1009,7 +999,7 @@
* @returns {Promise<ArrayBuffer>} * @returns {Promise<ArrayBuffer>}
*/ */
async deriveBits(algorithm, baseKey, length) { async deriveBits(algorithm, baseKey, length) {
webidl.assertBranded(this, SubtleCryptoPrototype); webidl.assertBranded(this, SubtleCrypto);
const prefix = "Failed to execute 'deriveBits' on 'SubtleCrypto'"; const prefix = "Failed to execute 'deriveBits' on 'SubtleCrypto'";
webidl.requiredArguments(arguments.length, 3, { prefix }); webidl.requiredArguments(arguments.length, 3, { prefix });
algorithm = webidl.converters.AlgorithmIdentifier(algorithm, { algorithm = webidl.converters.AlgorithmIdentifier(algorithm, {
@ -1057,7 +1047,7 @@
extractable, extractable,
keyUsages, keyUsages,
) { ) {
webidl.assertBranded(this, SubtleCryptoPrototype); webidl.assertBranded(this, SubtleCrypto);
const prefix = "Failed to execute 'deriveKey' on 'SubtleCrypto'"; const prefix = "Failed to execute 'deriveKey' on 'SubtleCrypto'";
webidl.requiredArguments(arguments.length, 5, { prefix }); webidl.requiredArguments(arguments.length, 5, { prefix });
algorithm = webidl.converters.AlgorithmIdentifier(algorithm, { algorithm = webidl.converters.AlgorithmIdentifier(algorithm, {
@ -1152,7 +1142,7 @@
* @returns {Promise<boolean>} * @returns {Promise<boolean>}
*/ */
async verify(algorithm, key, signature, data) { async verify(algorithm, key, signature, data) {
webidl.assertBranded(this, SubtleCryptoPrototype); webidl.assertBranded(this, SubtleCrypto);
const prefix = "Failed to execute 'verify' on 'SubtleCrypto'"; const prefix = "Failed to execute 'verify' on 'SubtleCrypto'";
webidl.requiredArguments(arguments.length, 4, { prefix }); webidl.requiredArguments(arguments.length, 4, { prefix });
algorithm = webidl.converters.AlgorithmIdentifier(algorithm, { algorithm = webidl.converters.AlgorithmIdentifier(algorithm, {
@ -1273,7 +1263,7 @@
* @returns {Promise<any>} * @returns {Promise<any>}
*/ */
async wrapKey(format, key, wrappingKey, wrapAlgorithm) { async wrapKey(format, key, wrappingKey, wrapAlgorithm) {
webidl.assertBranded(this, SubtleCryptoPrototype); webidl.assertBranded(this, SubtleCrypto);
const prefix = "Failed to execute 'wrapKey' on 'SubtleCrypto'"; const prefix = "Failed to execute 'wrapKey' on 'SubtleCrypto'";
webidl.requiredArguments(arguments.length, 4, { prefix }); webidl.requiredArguments(arguments.length, 4, { prefix });
format = webidl.converters.KeyFormat(format, { format = webidl.converters.KeyFormat(format, {
@ -1406,7 +1396,7 @@
extractable, extractable,
keyUsages, keyUsages,
) { ) {
webidl.assertBranded(this, SubtleCryptoPrototype); webidl.assertBranded(this, SubtleCrypto);
const prefix = "Failed to execute 'unwrapKey' on 'SubtleCrypto'"; const prefix = "Failed to execute 'unwrapKey' on 'SubtleCrypto'";
webidl.requiredArguments(arguments.length, 7, { prefix }); webidl.requiredArguments(arguments.length, 7, { prefix });
format = webidl.converters.KeyFormat(format, { format = webidl.converters.KeyFormat(format, {
@ -1564,7 +1554,7 @@
* @returns {Promise<any>} * @returns {Promise<any>}
*/ */
async generateKey(algorithm, extractable, keyUsages) { async generateKey(algorithm, extractable, keyUsages) {
webidl.assertBranded(this, SubtleCryptoPrototype); webidl.assertBranded(this, SubtleCrypto);
const prefix = "Failed to execute 'generateKey' on 'SubtleCrypto'"; const prefix = "Failed to execute 'generateKey' on 'SubtleCrypto'";
webidl.requiredArguments(arguments.length, 3, { prefix }); webidl.requiredArguments(arguments.length, 3, { prefix });
algorithm = webidl.converters.AlgorithmIdentifier(algorithm, { algorithm = webidl.converters.AlgorithmIdentifier(algorithm, {
@ -1590,14 +1580,12 @@
usages, usages,
); );
if (ObjectPrototypeIsPrototypeOf(CryptoKeyPrototype, result)) { if (result instanceof CryptoKey) {
const type = result[_type]; const type = result[_type];
if ((type === "secret" || type === "private") && usages.length === 0) { if ((type === "secret" || type === "private") && usages.length === 0) {
throw new DOMException("Invalid key usages", "SyntaxError"); throw new DOMException("Invalid key usages", "SyntaxError");
} }
} else if ( } else if (result.privateKey instanceof CryptoKey) {
ObjectPrototypeIsPrototypeOf(CryptoKeyPrototype, result.privateKey)
) {
if (result.privateKey[_usages].length === 0) { if (result.privateKey[_usages].length === 0) {
throw new DOMException("Invalid key usages", "SyntaxError"); throw new DOMException("Invalid key usages", "SyntaxError");
} }
@ -1606,7 +1594,6 @@
return result; return result;
} }
} }
const SubtleCryptoPrototype = SubtleCrypto.prototype;
async function generateKey(normalizedAlgorithm, extractable, usages) { async function generateKey(normalizedAlgorithm, extractable, usages) {
const algorithmName = normalizedAlgorithm.name; const algorithmName = normalizedAlgorithm.name;
@ -3839,7 +3826,7 @@
} }
getRandomValues(arrayBufferView) { getRandomValues(arrayBufferView) {
webidl.assertBranded(this, CryptoPrototype); webidl.assertBranded(this, Crypto);
const prefix = "Failed to execute 'getRandomValues' on 'Crypto'"; const prefix = "Failed to execute 'getRandomValues' on 'Crypto'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
arrayBufferView = webidl.converters.ArrayBufferView(arrayBufferView, { arrayBufferView = webidl.converters.ArrayBufferView(arrayBufferView, {
@ -3848,21 +3835,15 @@
}); });
if ( if (
!( !(
ObjectPrototypeIsPrototypeOf(Int8ArrayPrototype, arrayBufferView) || arrayBufferView instanceof Int8Array ||
ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, arrayBufferView) || arrayBufferView instanceof Uint8Array ||
ObjectPrototypeIsPrototypeOf( arrayBufferView instanceof Uint8ClampedArray ||
Uint8ClampedArrayPrototype, arrayBufferView instanceof Int16Array ||
arrayBufferView, arrayBufferView instanceof Uint16Array ||
) || arrayBufferView instanceof Int32Array ||
ObjectPrototypeIsPrototypeOf(Int16ArrayPrototype, arrayBufferView) || arrayBufferView instanceof Uint32Array ||
ObjectPrototypeIsPrototypeOf(Uint16ArrayPrototype, arrayBufferView) || arrayBufferView instanceof BigInt64Array ||
ObjectPrototypeIsPrototypeOf(Int32ArrayPrototype, arrayBufferView) || arrayBufferView instanceof BigUint64Array
ObjectPrototypeIsPrototypeOf(Uint32ArrayPrototype, arrayBufferView) ||
ObjectPrototypeIsPrototypeOf(
BigInt64ArrayPrototype,
arrayBufferView,
) ||
ObjectPrototypeIsPrototypeOf(BigUint64ArrayPrototype, arrayBufferView)
) )
) { ) {
throw new DOMException( throw new DOMException(
@ -3880,12 +3861,12 @@
} }
randomUUID() { randomUUID() {
webidl.assertBranded(this, CryptoPrototype); webidl.assertBranded(this, Crypto);
return core.opSync("op_crypto_random_uuid"); return core.opSync("op_crypto_random_uuid");
} }
get subtle() { get subtle() {
webidl.assertBranded(this, CryptoPrototype); webidl.assertBranded(this, Crypto);
return subtle; return subtle;
} }
@ -3895,7 +3876,6 @@
} }
webidl.configurePrototype(Crypto); webidl.configurePrototype(Crypto);
const CryptoPrototype = Crypto.prototype;
window.__bootstrap.crypto = { window.__bootstrap.crypto = {
SubtleCrypto, SubtleCrypto,

13
ext/crypto/01_webidl.js
View file

@ -9,11 +9,7 @@
((window) => { ((window) => {
const webidl = window.__bootstrap.webidl; const webidl = window.__bootstrap.webidl;
const { CryptoKey } = window.__bootstrap.crypto; const { CryptoKey } = window.__bootstrap.crypto;
const { const { ArrayBufferIsView, ArrayBuffer } = window.__bootstrap.primordials;
ArrayBufferIsView,
ArrayBufferPrototype,
ObjectPrototypeIsPrototypeOf,
} = window.__bootstrap.primordials;
webidl.converters.AlgorithmIdentifier = (V, opts) => { webidl.converters.AlgorithmIdentifier = (V, opts) => {
// Union for (object or DOMString) // Union for (object or DOMString)
@ -25,10 +21,7 @@
webidl.converters["BufferSource or JsonWebKey"] = (V, opts) => { webidl.converters["BufferSource or JsonWebKey"] = (V, opts) => {
// Union for (BufferSource or JsonWebKey) // Union for (BufferSource or JsonWebKey)
if ( if (ArrayBufferIsView(V) || V instanceof ArrayBuffer) {
ArrayBufferIsView(V) ||
ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, V)
) {
return webidl.converters.BufferSource(V, opts); return webidl.converters.BufferSource(V, opts);
} }
return webidl.converters.JsonWebKey(V, opts); return webidl.converters.JsonWebKey(V, opts);
@ -467,7 +460,7 @@
webidl.converters.CryptoKey = webidl.createInterfaceConverter( webidl.converters.CryptoKey = webidl.createInterfaceConverter(
"CryptoKey", "CryptoKey",
CryptoKey.prototype, CryptoKey,
); );
const dictCryptoKeyPair = [ const dictCryptoKeyPair = [

7
ext/fetch/20_headers.js
View file

@ -263,7 +263,7 @@
* @param {string} value * @param {string} value
*/ */
append(name, value) { append(name, value) {
webidl.assertBranded(this, HeadersPrototype); webidl.assertBranded(this, Headers);
const prefix = "Failed to execute 'append' on 'Headers'"; const prefix = "Failed to execute 'append' on 'Headers'";
webidl.requiredArguments(arguments.length, 2, { prefix }); webidl.requiredArguments(arguments.length, 2, { prefix });
name = webidl.converters["ByteString"](name, { name = webidl.converters["ByteString"](name, {
@ -354,7 +354,7 @@
* @param {string} value * @param {string} value
*/ */
set(name, value) { set(name, value) {
webidl.assertBranded(this, HeadersPrototype); webidl.assertBranded(this, Headers);
const prefix = "Failed to execute 'set' on 'Headers'"; const prefix = "Failed to execute 'set' on 'Headers'";
webidl.requiredArguments(arguments.length, 2, { prefix }); webidl.requiredArguments(arguments.length, 2, { prefix });
name = webidl.converters["ByteString"](name, { name = webidl.converters["ByteString"](name, {
@ -411,7 +411,6 @@
webidl.mixinPairIterable("Headers", Headers, _iterableHeaders, 0, 1); webidl.mixinPairIterable("Headers", Headers, _iterableHeaders, 0, 1);
webidl.configurePrototype(Headers); webidl.configurePrototype(Headers);
const HeadersPrototype = Headers.prototype;
webidl.converters["HeadersInit"] = (V, opts) => { webidl.converters["HeadersInit"] = (V, opts) => {
// Union for (sequence<sequence<ByteString>> or record<ByteString, ByteString>) // Union for (sequence<sequence<ByteString>> or record<ByteString, ByteString>)
@ -429,7 +428,7 @@
}; };
webidl.converters["Headers"] = webidl.createInterfaceConverter( webidl.converters["Headers"] = webidl.createInterfaceConverter(
"Headers", "Headers",
Headers.prototype, Headers,
); );
/** /**

34
ext/fetch/21_formdata.js
View file

@ -13,8 +13,7 @@
((window) => { ((window) => {
const core = window.Deno.core; const core = window.Deno.core;
const webidl = globalThis.__bootstrap.webidl; const webidl = globalThis.__bootstrap.webidl;
const { Blob, BlobPrototype, File, FilePrototype } = const { Blob, File } = globalThis.__bootstrap.file;
globalThis.__bootstrap.file;
const { const {
ArrayPrototypeMap, ArrayPrototypeMap,
ArrayPrototypePush, ArrayPrototypePush,
@ -26,7 +25,6 @@
MapPrototypeGet, MapPrototypeGet,
MapPrototypeSet, MapPrototypeSet,
MathRandom, MathRandom,
ObjectPrototypeIsPrototypeOf,
Symbol, Symbol,
StringFromCharCode, StringFromCharCode,
StringPrototypeTrim, StringPrototypeTrim,
@ -50,16 +48,10 @@
* @returns {FormDataEntry} * @returns {FormDataEntry}
*/ */
function createEntry(name, value, filename) { function createEntry(name, value, filename) {
if ( if (value instanceof Blob && !(value instanceof File)) {
ObjectPrototypeIsPrototypeOf(BlobPrototype, value) &&
!ObjectPrototypeIsPrototypeOf(FilePrototype, value)
) {
value = new File([value], "blob", { type: value.type }); value = new File([value], "blob", { type: value.type });
} }
if ( if (value instanceof File && filename !== undefined) {
ObjectPrototypeIsPrototypeOf(FilePrototype, value) &&
filename !== undefined
) {
value = new File([value], filename, { value = new File([value], filename, {
type: value.type, type: value.type,
lastModified: value.lastModified, lastModified: value.lastModified,
@ -97,7 +89,7 @@
* @returns {void} * @returns {void}
*/ */
append(name, valueOrBlobValue, filename) { append(name, valueOrBlobValue, filename) {
webidl.assertBranded(this, FormDataPrototype); webidl.assertBranded(this, FormData);
const prefix = "Failed to execute 'append' on 'FormData'"; const prefix = "Failed to execute 'append' on 'FormData'";
webidl.requiredArguments(arguments.length, 2, { prefix }); webidl.requiredArguments(arguments.length, 2, { prefix });
@ -105,7 +97,7 @@
prefix, prefix,
context: "Argument 1", context: "Argument 1",
}); });
if (ObjectPrototypeIsPrototypeOf(BlobPrototype, valueOrBlobValue)) { if (valueOrBlobValue instanceof Blob) {
valueOrBlobValue = webidl.converters["Blob"](valueOrBlobValue, { valueOrBlobValue = webidl.converters["Blob"](valueOrBlobValue, {
prefix, prefix,
context: "Argument 2", context: "Argument 2",
@ -133,7 +125,7 @@
* @returns {void} * @returns {void}
*/ */
delete(name) { delete(name) {
webidl.assertBranded(this, FormDataPrototype); webidl.assertBranded(this, FormData);
const prefix = "Failed to execute 'name' on 'FormData'"; const prefix = "Failed to execute 'name' on 'FormData'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
@ -156,7 +148,7 @@
* @returns {FormDataEntryValue | null} * @returns {FormDataEntryValue | null}
*/ */
get(name) { get(name) {
webidl.assertBranded(this, FormDataPrototype); webidl.assertBranded(this, FormData);
const prefix = "Failed to execute 'get' on 'FormData'"; const prefix = "Failed to execute 'get' on 'FormData'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
@ -176,7 +168,7 @@
* @returns {FormDataEntryValue[]} * @returns {FormDataEntryValue[]}
*/ */
getAll(name) { getAll(name) {
webidl.assertBranded(this, FormDataPrototype); webidl.assertBranded(this, FormData);
const prefix = "Failed to execute 'getAll' on 'FormData'"; const prefix = "Failed to execute 'getAll' on 'FormData'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
@ -197,7 +189,7 @@
* @returns {boolean} * @returns {boolean}
*/ */
has(name) { has(name) {
webidl.assertBranded(this, FormDataPrototype); webidl.assertBranded(this, FormData);
const prefix = "Failed to execute 'has' on 'FormData'"; const prefix = "Failed to execute 'has' on 'FormData'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
@ -219,7 +211,7 @@
* @returns {void} * @returns {void}
*/ */
set(name, valueOrBlobValue, filename) { set(name, valueOrBlobValue, filename) {
webidl.assertBranded(this, FormDataPrototype); webidl.assertBranded(this, FormData);
const prefix = "Failed to execute 'set' on 'FormData'"; const prefix = "Failed to execute 'set' on 'FormData'";
webidl.requiredArguments(arguments.length, 2, { prefix }); webidl.requiredArguments(arguments.length, 2, { prefix });
@ -227,7 +219,7 @@
prefix, prefix,
context: "Argument 1", context: "Argument 1",
}); });
if (ObjectPrototypeIsPrototypeOf(BlobPrototype, valueOrBlobValue)) { if (valueOrBlobValue instanceof Blob) {
valueOrBlobValue = webidl.converters["Blob"](valueOrBlobValue, { valueOrBlobValue = webidl.converters["Blob"](valueOrBlobValue, {
prefix, prefix,
context: "Argument 2", context: "Argument 2",
@ -269,7 +261,6 @@
webidl.mixinPairIterable("FormData", FormData, entryList, "name", "value"); webidl.mixinPairIterable("FormData", FormData, entryList, "name", "value");
webidl.configurePrototype(FormData); webidl.configurePrototype(FormData);
const FormDataPrototype = FormData.prototype;
const escape = (str, isFilename) => const escape = (str, isFilename) =>
StringPrototypeReplace( StringPrototypeReplace(
@ -500,11 +491,10 @@
} }
webidl.converters["FormData"] = webidl webidl.converters["FormData"] = webidl
.createInterfaceConverter("FormData", FormDataPrototype); .createInterfaceConverter("FormData", FormData);
globalThis.__bootstrap.formData = { globalThis.__bootstrap.formData = {
FormData, FormData,
FormDataPrototype,
formDataToBlob, formDataToBlob,
parseFormData, parseFormData,
formDataFromEntries, formDataFromEntries,

105
ext/fetch/22_body.js
View file

@ -16,35 +16,23 @@
const core = window.Deno.core; const core = window.Deno.core;
const webidl = globalThis.__bootstrap.webidl; const webidl = globalThis.__bootstrap.webidl;
const { parseUrlEncoded } = globalThis.__bootstrap.url; const { parseUrlEncoded } = globalThis.__bootstrap.url;
const { URLSearchParamsPrototype } = globalThis.__bootstrap.url; const { parseFormData, formDataFromEntries, formDataToBlob } =
const { globalThis.__bootstrap.formData;
parseFormData,
formDataFromEntries,
formDataToBlob,
FormDataPrototype,
} = globalThis.__bootstrap.formData;
const mimesniff = globalThis.__bootstrap.mimesniff; const mimesniff = globalThis.__bootstrap.mimesniff;
const { BlobPrototype } = globalThis.__bootstrap.file; const { isReadableStreamDisturbed, errorReadableStream, createProxy } =
globalThis.__bootstrap.streams;
const { const {
isReadableStreamDisturbed, ArrayBuffer,
errorReadableStream,
createProxy,
ReadableStreamPrototype,
} = globalThis.__bootstrap.streams;
const {
ArrayBufferPrototype,
ArrayBufferIsView, ArrayBufferIsView,
ArrayPrototypePush, ArrayPrototypePush,
ArrayPrototypeMap, ArrayPrototypeMap,
JSONParse, JSONParse,
ObjectDefineProperties, ObjectDefineProperties,
ObjectPrototypeIsPrototypeOf,
PromiseResolve, PromiseResolve,
TypedArrayPrototypeSet, TypedArrayPrototypeSet,
TypedArrayPrototypeSlice, TypedArrayPrototypeSlice,
TypeError, TypeError,
Uint8Array, Uint8Array,
Uint8ArrayPrototype,
} = window.__bootstrap.primordials; } = window.__bootstrap.primordials;
/** /**
@ -78,12 +66,7 @@
} }
get stream() { get stream() {
if ( if (!(this.streamOrStatic instanceof ReadableStream)) {
!ObjectPrototypeIsPrototypeOf(
ReadableStreamPrototype,
this.streamOrStatic,
)
) {
const { body, consumed } = this.streamOrStatic; const { body, consumed } = this.streamOrStatic;
if (consumed) { if (consumed) {
this.streamOrStatic = new ReadableStream(); this.streamOrStatic = new ReadableStream();
@ -105,12 +88,7 @@
* @returns {boolean} * @returns {boolean}
*/ */
unusable() { unusable() {
if ( if (this.streamOrStatic instanceof ReadableStream) {
ObjectPrototypeIsPrototypeOf(
ReadableStreamPrototype,
this.streamOrStatic,
)
) {
return this.streamOrStatic.locked || return this.streamOrStatic.locked ||
isReadableStreamDisturbed(this.streamOrStatic); isReadableStreamDisturbed(this.streamOrStatic);
} }
@ -121,12 +99,7 @@
* @returns {boolean} * @returns {boolean}
*/ */
consumed() { consumed() {
if ( if (this.streamOrStatic instanceof ReadableStream) {
ObjectPrototypeIsPrototypeOf(
ReadableStreamPrototype,
this.streamOrStatic,
)
) {
return isReadableStreamDisturbed(this.streamOrStatic); return isReadableStreamDisturbed(this.streamOrStatic);
} }
return this.streamOrStatic.consumed; return this.streamOrStatic.consumed;
@ -138,12 +111,7 @@
*/ */
async consume() { async consume() {
if (this.unusable()) throw new TypeError("Body already consumed."); if (this.unusable()) throw new TypeError("Body already consumed.");
if ( if (this.streamOrStatic instanceof ReadableStream) {
ObjectPrototypeIsPrototypeOf(
ReadableStreamPrototype,
this.streamOrStatic,
)
) {
const reader = this.stream.getReader(); const reader = this.stream.getReader();
/** @type {Uint8Array[]} */ /** @type {Uint8Array[]} */
const chunks = []; const chunks = [];
@ -168,12 +136,7 @@
} }
cancel(error) { cancel(error) {
if ( if (this.streamOrStatic instanceof ReadableStream) {
ObjectPrototypeIsPrototypeOf(
ReadableStreamPrototype,
this.streamOrStatic,
)
) {
this.streamOrStatic.cancel(error); this.streamOrStatic.cancel(error);
} else { } else {
this.streamOrStatic.consumed = true; this.streamOrStatic.consumed = true;
@ -181,12 +144,7 @@
} }
error(error) { error(error) {
if ( if (this.streamOrStatic instanceof ReadableStream) {
ObjectPrototypeIsPrototypeOf(
ReadableStreamPrototype,
this.streamOrStatic,
)
) {
errorReadableStream(this.streamOrStatic, error); errorReadableStream(this.streamOrStatic, error);
} else { } else {
this.streamOrStatic.consumed = true; this.streamOrStatic.consumed = true;
@ -210,12 +168,7 @@
*/ */
createProxy() { createProxy() {
let proxyStreamOrStatic; let proxyStreamOrStatic;
if ( if (this.streamOrStatic instanceof ReadableStream) {
ObjectPrototypeIsPrototypeOf(
ReadableStreamPrototype,
this.streamOrStatic,
)
) {
proxyStreamOrStatic = createProxy(this.streamOrStatic); proxyStreamOrStatic = createProxy(this.streamOrStatic);
} else { } else {
proxyStreamOrStatic = { ...this.streamOrStatic }; proxyStreamOrStatic = { ...this.streamOrStatic };
@ -329,7 +282,7 @@
enumerable: true, enumerable: true,
}, },
}; };
return ObjectDefineProperties(prototype, mixin); return ObjectDefineProperties(prototype.prototype, mixin);
} }
/** /**
@ -388,21 +341,18 @@
let source = null; let source = null;
let length = null; let length = null;
let contentType = null; let contentType = null;
if (ObjectPrototypeIsPrototypeOf(BlobPrototype, object)) { if (object instanceof Blob) {
stream = object.stream(); stream = object.stream();
source = object; source = object;
length = object.size; length = object.size;
if (object.type.length !== 0) { if (object.type.length !== 0) {
contentType = object.type; contentType = object.type;
} }
} else if (ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, object)) { } else if (object instanceof Uint8Array) {
// Fast(er) path for common case of Uint8Array // Fast(er) path for common case of Uint8Array
const copy = TypedArrayPrototypeSlice(object, 0, object.byteLength); const copy = TypedArrayPrototypeSlice(object, 0, object.byteLength);
source = copy; source = copy;
} else if ( } else if (ArrayBufferIsView(object) || object instanceof ArrayBuffer) {
ArrayBufferIsView(object) ||
ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, object)
) {
const u8 = ArrayBufferIsView(object) const u8 = ArrayBufferIsView(object)
? new Uint8Array( ? new Uint8Array(
object.buffer, object.buffer,
@ -412,28 +362,26 @@
: new Uint8Array(object); : new Uint8Array(object);
const copy = TypedArrayPrototypeSlice(u8, 0, u8.byteLength); const copy = TypedArrayPrototypeSlice(u8, 0, u8.byteLength);
source = copy; source = copy;
} else if (ObjectPrototypeIsPrototypeOf(FormDataPrototype, object)) { } else if (object instanceof FormData) {
const res = formDataToBlob(object); const res = formDataToBlob(object);
stream = res.stream(); stream = res.stream();
source = res; source = res;
length = res.size; length = res.size;
contentType = res.type; contentType = res.type;
} else if ( } else if (object instanceof URLSearchParams) {
ObjectPrototypeIsPrototypeOf(URLSearchParamsPrototype, object)
) {
// TODO(@satyarohith): not sure what primordial here. // TODO(@satyarohith): not sure what primordial here.
source = object.toString(); source = object.toString();
contentType = "application/x-www-form-urlencoded;charset=UTF-8"; contentType = "application/x-www-form-urlencoded;charset=UTF-8";
} else if (typeof object === "string") { } else if (typeof object === "string") {
source = object; source = object;
contentType = "text/plain;charset=UTF-8"; contentType = "text/plain;charset=UTF-8";
} else if (ObjectPrototypeIsPrototypeOf(ReadableStreamPrototype, object)) { } else if (object instanceof ReadableStream) {
stream = object; stream = object;
if (object.locked || isReadableStreamDisturbed(object)) { if (object.locked || isReadableStreamDisturbed(object)) {
throw new TypeError("ReadableStream is locked or disturbed"); throw new TypeError("ReadableStream is locked or disturbed");
} }
} }
if (ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, source)) { if (source instanceof Uint8Array) {
stream = { body: source, consumed: false }; stream = { body: source, consumed: false };
length = source.byteLength; length = source.byteLength;
} else if (typeof source === "string") { } else if (typeof source === "string") {
@ -451,22 +399,19 @@
webidl.converters["BodyInit_DOMString"] = (V, opts) => { webidl.converters["BodyInit_DOMString"] = (V, opts) => {
// Union for (ReadableStream or Blob or ArrayBufferView or ArrayBuffer or FormData or URLSearchParams or USVString) // Union for (ReadableStream or Blob or ArrayBufferView or ArrayBuffer or FormData or URLSearchParams or USVString)
if (ObjectPrototypeIsPrototypeOf(ReadableStreamPrototype, V)) { if (V instanceof ReadableStream) {
// TODO(lucacasonato): ReadableStream is not branded // TODO(lucacasonato): ReadableStream is not branded
return V; return V;
} else if (ObjectPrototypeIsPrototypeOf(BlobPrototype, V)) { } else if (V instanceof Blob) {
return webidl.converters["Blob"](V, opts); return webidl.converters["Blob"](V, opts);
} else if (ObjectPrototypeIsPrototypeOf(FormDataPrototype, V)) { } else if (V instanceof FormData) {
return webidl.converters["FormData"](V, opts); return webidl.converters["FormData"](V, opts);
} else if (ObjectPrototypeIsPrototypeOf(URLSearchParamsPrototype, V)) { } else if (V instanceof URLSearchParams) {
// TODO(lucacasonato): URLSearchParams is not branded // TODO(lucacasonato): URLSearchParams is not branded
return V; return V;
} }
if (typeof V === "object") { if (typeof V === "object") {
if ( if (V instanceof ArrayBuffer || V instanceof SharedArrayBuffer) {
ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, V) ||
ObjectPrototypeIsPrototypeOf(SharedArrayBuffer.prototype, V)
) {
return webidl.converters["ArrayBuffer"](V, opts); return webidl.converters["ArrayBuffer"](V, opts);
} }
if (ArrayBufferIsView(V)) { if (ArrayBufferIsView(V)) {

2
ext/fetch/22_http_client.js
View file

@ -34,10 +34,8 @@
core.close(this.rid); core.close(this.rid);
} }
} }
const HttpClientPrototype = HttpClient.prototype;
window.__bootstrap.fetch ??= {}; window.__bootstrap.fetch ??= {};
window.__bootstrap.fetch.createHttpClient = createHttpClient; window.__bootstrap.fetch.createHttpClient = createHttpClient;
window.__bootstrap.fetch.HttpClient = HttpClient; window.__bootstrap.fetch.HttpClient = HttpClient;
window.__bootstrap.fetch.HttpClientPrototype = HttpClientPrototype;
})(globalThis); })(globalThis);

36
ext/fetch/23_request.js
View file

@ -26,7 +26,7 @@
fillHeaders, fillHeaders,
getDecodeSplitHeader, getDecodeSplitHeader,
} = window.__bootstrap.headers; } = window.__bootstrap.headers;
const { HttpClientPrototype } = window.__bootstrap.fetch; const { HttpClient } = window.__bootstrap.fetch;
const abortSignal = window.__bootstrap.abortSignal; const abortSignal = window.__bootstrap.abortSignal;
const { const {
ArrayPrototypeMap, ArrayPrototypeMap,
@ -36,7 +36,6 @@
MapPrototypeGet, MapPrototypeGet,
MapPrototypeSet, MapPrototypeSet,
ObjectKeys, ObjectKeys,
ObjectPrototypeIsPrototypeOf,
RegExpPrototypeTest, RegExpPrototypeTest,
Symbol, Symbol,
SymbolFor, SymbolFor,
@ -242,9 +241,7 @@
const parsedURL = new URL(input, baseURL); const parsedURL = new URL(input, baseURL);
request = newInnerRequest("GET", parsedURL.href, [], null, true); request = newInnerRequest("GET", parsedURL.href, [], null, true);
} else { // 6. } else { // 6.
if (!ObjectPrototypeIsPrototypeOf(RequestPrototype, input)) { if (!(input instanceof Request)) throw new TypeError("Unreachable");
throw new TypeError("Unreachable");
}
request = input[_request]; request = input[_request];
signal = input[_signal]; signal = input[_signal];
} }
@ -271,10 +268,7 @@
// NOTE: non standard extension. This handles Deno.HttpClient parameter // NOTE: non standard extension. This handles Deno.HttpClient parameter
if (init.client !== undefined) { if (init.client !== undefined) {
if ( if (init.client !== null && !(init.client instanceof HttpClient)) {
init.client !== null &&
!ObjectPrototypeIsPrototypeOf(HttpClientPrototype, init.client)
) {
throw webidl.makeException( throw webidl.makeException(
TypeError, TypeError,
"`client` must be a Deno.HttpClient", "`client` must be a Deno.HttpClient",
@ -318,7 +312,7 @@
// 33. // 33.
let inputBody = null; let inputBody = null;
if (ObjectPrototypeIsPrototypeOf(RequestPrototype, input)) { if (input instanceof Request) {
inputBody = input[_body]; inputBody = input[_body];
} }
@ -362,32 +356,32 @@
} }
get method() { get method() {
webidl.assertBranded(this, RequestPrototype); webidl.assertBranded(this, Request);
return this[_request].method; return this[_request].method;
} }
get url() { get url() {
webidl.assertBranded(this, RequestPrototype); webidl.assertBranded(this, Request);
return this[_request].url(); return this[_request].url();
} }
get headers() { get headers() {
webidl.assertBranded(this, RequestPrototype); webidl.assertBranded(this, Request);
return this[_headers]; return this[_headers];
} }
get redirect() { get redirect() {
webidl.assertBranded(this, RequestPrototype); webidl.assertBranded(this, Request);
return this[_request].redirectMode; return this[_request].redirectMode;
} }
get signal() { get signal() {
webidl.assertBranded(this, RequestPrototype); webidl.assertBranded(this, Request);
return this[_signal]; return this[_signal];
} }
clone() { clone() {
webidl.assertBranded(this, RequestPrototype); webidl.assertBranded(this, Request);
if (this[_body] && this[_body].unusable()) { if (this[_body] && this[_body].unusable()) {
throw new TypeError("Body is unusable."); throw new TypeError("Body is unusable.");
} }
@ -404,7 +398,7 @@
[SymbolFor("Deno.customInspect")](inspect) { [SymbolFor("Deno.customInspect")](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf(RequestPrototype, this), evaluate: this instanceof Request,
keys: [ keys: [
"bodyUsed", "bodyUsed",
"headers", "headers",
@ -416,18 +410,18 @@
} }
} }
mixinBody(Request, _body, _mimeType);
webidl.configurePrototype(Request); webidl.configurePrototype(Request);
const RequestPrototype = Request.prototype;
mixinBody(RequestPrototype, _body, _mimeType);
webidl.converters["Request"] = webidl.createInterfaceConverter( webidl.converters["Request"] = webidl.createInterfaceConverter(
"Request", "Request",
RequestPrototype, Request,
); );
webidl.converters["RequestInfo_DOMString"] = (V, opts) => { webidl.converters["RequestInfo_DOMString"] = (V, opts) => {
// Union for (Request or USVString) // Union for (Request or USVString)
if (typeof V == "object") { if (typeof V == "object") {
if (ObjectPrototypeIsPrototypeOf(RequestPrototype, V)) { if (V instanceof Request) {
return webidl.converters["Request"](V, opts); return webidl.converters["Request"](V, opts);
} }
} }

26
ext/fetch/23_response.js
View file

@ -33,7 +33,6 @@
MapPrototypeHas, MapPrototypeHas,
MapPrototypeGet, MapPrototypeGet,
MapPrototypeSet, MapPrototypeSet,
ObjectPrototypeIsPrototypeOf,
RangeError, RangeError,
RegExp, RegExp,
RegExpPrototypeTest, RegExpPrototypeTest,
@ -298,7 +297,7 @@
* @returns {"basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect"} * @returns {"basic" | "cors" | "default" | "error" | "opaque" | "opaqueredirect"}
*/ */
get type() { get type() {
webidl.assertBranded(this, ResponsePrototype); webidl.assertBranded(this, Response);
return this[_response].type; return this[_response].type;
} }
@ -306,7 +305,7 @@
* @returns {string} * @returns {string}
*/ */
get url() { get url() {
webidl.assertBranded(this, ResponsePrototype); webidl.assertBranded(this, Response);
const url = this[_response].url(); const url = this[_response].url();
if (url === null) return ""; if (url === null) return "";
const newUrl = new URL(url); const newUrl = new URL(url);
@ -318,7 +317,7 @@
* @returns {boolean} * @returns {boolean}
*/ */
get redirected() { get redirected() {
webidl.assertBranded(this, ResponsePrototype); webidl.assertBranded(this, Response);
return this[_response].urlList.length > 1; return this[_response].urlList.length > 1;
} }
@ -326,7 +325,7 @@
* @returns {number} * @returns {number}
*/ */
get status() { get status() {
webidl.assertBranded(this, ResponsePrototype); webidl.assertBranded(this, Response);
return this[_response].status; return this[_response].status;
} }
@ -334,7 +333,7 @@
* @returns {boolean} * @returns {boolean}
*/ */
get ok() { get ok() {
webidl.assertBranded(this, ResponsePrototype); webidl.assertBranded(this, Response);
const status = this[_response].status; const status = this[_response].status;
return status >= 200 && status <= 299; return status >= 200 && status <= 299;
} }
@ -343,7 +342,7 @@
* @returns {string} * @returns {string}
*/ */
get statusText() { get statusText() {
webidl.assertBranded(this, ResponsePrototype); webidl.assertBranded(this, Response);
return this[_response].statusMessage; return this[_response].statusMessage;
} }
@ -351,7 +350,7 @@
* @returns {Headers} * @returns {Headers}
*/ */
get headers() { get headers() {
webidl.assertBranded(this, ResponsePrototype); webidl.assertBranded(this, Response);
return this[_headers]; return this[_headers];
} }
@ -359,7 +358,7 @@
* @returns {Response} * @returns {Response}
*/ */
clone() { clone() {
webidl.assertBranded(this, ResponsePrototype); webidl.assertBranded(this, Response);
if (this[_body] && this[_body].unusable()) { if (this[_body] && this[_body].unusable()) {
throw new TypeError("Body is unusable."); throw new TypeError("Body is unusable.");
} }
@ -376,7 +375,7 @@
[SymbolFor("Deno.customInspect")](inspect) { [SymbolFor("Deno.customInspect")](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf(ResponsePrototype, this), evaluate: this instanceof Response,
keys: [ keys: [
"body", "body",
"bodyUsed", "bodyUsed",
@ -391,13 +390,13 @@
} }
} }
mixinBody(Response, _body, _mimeType);
webidl.configurePrototype(Response); webidl.configurePrototype(Response);
const ResponsePrototype = Response.prototype;
mixinBody(ResponsePrototype, _body, _mimeType);
webidl.converters["Response"] = webidl.createInterfaceConverter( webidl.converters["Response"] = webidl.createInterfaceConverter(
"Response", "Response",
ResponsePrototype, Response,
); );
webidl.converters["ResponseInit"] = webidl.createDictionaryConverter( webidl.converters["ResponseInit"] = webidl.createDictionaryConverter(
"ResponseInit", "ResponseInit",
@ -458,7 +457,6 @@
window.__bootstrap.fetch ??= {}; window.__bootstrap.fetch ??= {};
window.__bootstrap.fetch.Response = Response; window.__bootstrap.fetch.Response = Response;
window.__bootstrap.fetch.ResponsePrototype = ResponsePrototype;
window.__bootstrap.fetch.newInnerResponse = newInnerResponse; window.__bootstrap.fetch.newInnerResponse = newInnerResponse;
window.__bootstrap.fetch.toInnerResponse = toInnerResponse; window.__bootstrap.fetch.toInnerResponse = toInnerResponse;
window.__bootstrap.fetch.fromInnerResponse = fromInnerResponse; window.__bootstrap.fetch.fromInnerResponse = fromInnerResponse;

46
ext/fetch/26_fetch.js
View file

@ -15,9 +15,7 @@
const core = window.Deno.core; const core = window.Deno.core;
const webidl = window.__bootstrap.webidl; const webidl = window.__bootstrap.webidl;
const { byteLowerCase } = window.__bootstrap.infra; const { byteLowerCase } = window.__bootstrap.infra;
const { BlobPrototype } = window.__bootstrap.file; const { errorReadableStream } = window.__bootstrap.streams;
const { errorReadableStream, ReadableStreamPrototype } =
window.__bootstrap.streams;
const { InnerBody, extractBody } = window.__bootstrap.fetchBody; const { InnerBody, extractBody } = window.__bootstrap.fetchBody;
const { const {
toInnerRequest, toInnerRequest,
@ -34,7 +32,6 @@
ArrayPrototypeSplice, ArrayPrototypeSplice,
ArrayPrototypeFilter, ArrayPrototypeFilter,
ArrayPrototypeIncludes, ArrayPrototypeIncludes,
ObjectPrototypeIsPrototypeOf,
Promise, Promise,
PromisePrototypeThen, PromisePrototypeThen,
PromisePrototypeCatch, PromisePrototypeCatch,
@ -44,7 +41,6 @@
TypedArrayPrototypeSubarray, TypedArrayPrototypeSubarray,
TypeError, TypeError,
Uint8Array, Uint8Array,
Uint8ArrayPrototype,
WeakMap, WeakMap,
WeakMapPrototypeDelete, WeakMapPrototypeDelete,
WeakMapPrototypeGet, WeakMapPrototypeGet,
@ -176,16 +172,8 @@
let reqBody = null; let reqBody = null;
if (req.body !== null) { if (req.body !== null) {
if ( if (req.body.streamOrStatic instanceof ReadableStream) {
ObjectPrototypeIsPrototypeOf( if (req.body.length === null || req.body.source instanceof Blob) {
ReadableStreamPrototype,
req.body.streamOrStatic,
)
) {
if (
req.body.length === null ||
ObjectPrototypeIsPrototypeOf(BlobPrototype, req.body.source)
) {
reqBody = req.body.stream; reqBody = req.body.stream;
} else { } else {
const reader = req.body.stream.getReader(); const reader = req.body.stream.getReader();
@ -208,19 +196,14 @@
} }
} }
const { requestRid, requestBodyRid, cancelHandleRid } = opFetch( const { requestRid, requestBodyRid, cancelHandleRid } = opFetch({
{ method: req.method,
method: req.method, url: req.currentUrl(),
url: req.currentUrl(), headers: req.headerList,
headers: req.headerList, clientRid: req.clientRid,
clientRid: req.clientRid, hasBody: reqBody !== null,
hasBody: reqBody !== null, bodyLength: req.body?.length,
bodyLength: req.body?.length, }, reqBody instanceof Uint8Array ? reqBody : null);
},
ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, reqBody)
? reqBody
: null,
);
function onAbort() { function onAbort() {
if (cancelHandleRid !== null) { if (cancelHandleRid !== null) {
@ -233,10 +216,7 @@
terminator[abortSignal.add](onAbort); terminator[abortSignal.add](onAbort);
if (requestBodyRid !== null) { if (requestBodyRid !== null) {
if ( if (reqBody === null || !(reqBody instanceof ReadableStream)) {
reqBody === null ||
!ObjectPrototypeIsPrototypeOf(ReadableStreamPrototype, reqBody)
) {
throw new TypeError("Unreachable"); throw new TypeError("Unreachable");
} }
const reader = reqBody.getReader(); const reader = reqBody.getReader();
@ -251,7 +231,7 @@
}, },
); );
if (done) break; if (done) break;
if (!ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, value)) { if (!(value instanceof Uint8Array)) {
await reader.cancel("value not a Uint8Array"); await reader.cancel("value not a Uint8Array");
break; break;
} }

8
ext/ffi/00_ffi.js
View file

@ -5,11 +5,10 @@
const core = window.Deno.core; const core = window.Deno.core;
const __bootstrap = window.__bootstrap; const __bootstrap = window.__bootstrap;
const { const {
ArrayBufferPrototype, ArrayBuffer,
Uint8Array, Uint8Array,
BigInt, BigInt,
Number, Number,
ObjectPrototypeIsPrototypeOf,
TypeError, TypeError,
} = window.__bootstrap.primordials; } = window.__bootstrap.primordials;
@ -142,7 +141,6 @@
return this.value; return this.value;
} }
} }
const UnsafePointerPrototype = UnsafePointer.prototype;
function prepareArgs(types, args) { function prepareArgs(types, args) {
const parameters = []; const parameters = [];
@ -154,12 +152,12 @@
if (type === "pointer") { if (type === "pointer") {
if ( if (
ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, arg?.buffer) && arg?.buffer instanceof ArrayBuffer &&
arg.byteLength !== undefined arg.byteLength !== undefined
) { ) {
parameters.push(buffers.length); parameters.push(buffers.length);
buffers.push(arg); buffers.push(arg);
} else if (ObjectPrototypeIsPrototypeOf(UnsafePointerPrototype, arg)) { } else if (arg instanceof UnsafePointer) {
parameters.push(packU64(arg.value)); parameters.push(packU64(arg.value));
buffers.push(undefined); buffers.push(undefined);
} else if (arg === null) { } else if (arg === null) {

57
ext/http/01_http.js
View file

@ -5,9 +5,8 @@
const webidl = window.__bootstrap.webidl; const webidl = window.__bootstrap.webidl;
const { InnerBody } = window.__bootstrap.fetchBody; const { InnerBody } = window.__bootstrap.fetchBody;
const { setEventTargetData } = window.__bootstrap.eventTarget; const { setEventTargetData } = window.__bootstrap.eventTarget;
const { BlobPrototype } = window.__bootstrap.file;
const { const {
ResponsePrototype, Response,
fromInnerRequest, fromInnerRequest,
toInnerResponse, toInnerResponse,
newInnerRequest, newInnerRequest,
@ -15,9 +14,8 @@
fromInnerResponse, fromInnerResponse,
} = window.__bootstrap.fetch; } = window.__bootstrap.fetch;
const core = window.Deno.core; const core = window.Deno.core;
const { BadResourcePrototype, InterruptedPrototype } = core; const { BadResource, Interrupted } = core;
const { ReadableStream, ReadableStreamPrototype } = const { ReadableStream } = window.__bootstrap.streams;
window.__bootstrap.streams;
const abortSignal = window.__bootstrap.abortSignal; const abortSignal = window.__bootstrap.abortSignal;
const { const {
WebSocket, WebSocket,
@ -34,8 +32,7 @@
ArrayPrototypeIncludes, ArrayPrototypeIncludes,
ArrayPrototypePush, ArrayPrototypePush,
ArrayPrototypeSome, ArrayPrototypeSome,
ObjectPrototypeIsPrototypeOf, Promise,
PromisePrototype,
Set, Set,
SetPrototypeAdd, SetPrototypeAdd,
SetPrototypeDelete, SetPrototypeDelete,
@ -49,7 +46,6 @@
TypedArrayPrototypeSubarray, TypedArrayPrototypeSubarray,
TypeError, TypeError,
Uint8Array, Uint8Array,
Uint8ArrayPrototype,
} = window.__bootstrap.primordials; } = window.__bootstrap.primordials;
const connErrorSymbol = Symbol("connError"); const connErrorSymbol = Symbol("connError");
@ -85,8 +81,8 @@
// those with it. // those with it.
this[connErrorSymbol] = error; this[connErrorSymbol] = error;
if ( if (
ObjectPrototypeIsPrototypeOf(BadResourcePrototype, error) || error instanceof BadResource ||
ObjectPrototypeIsPrototypeOf(InterruptedPrototype, error) || error instanceof Interrupted ||
StringPrototypeIncludes(error.message, "connection closed") StringPrototypeIncludes(error.message, "connection closed")
) { ) {
return null; return null;
@ -162,11 +158,11 @@
function createRespondWith(httpConn, streamRid) { function createRespondWith(httpConn, streamRid) {
return async function respondWith(resp) { return async function respondWith(resp) {
try { try {
if (ObjectPrototypeIsPrototypeOf(PromisePrototype, resp)) { if (resp instanceof Promise) {
resp = await resp; resp = await resp;
} }
if (!(ObjectPrototypeIsPrototypeOf(ResponsePrototype, resp))) { if (!(resp instanceof Response)) {
throw new TypeError( throw new TypeError(
"First argument to respondWith must be a Response or a promise resolving to a Response.", "First argument to respondWith must be a Response or a promise resolving to a Response.",
); );
@ -183,18 +179,10 @@
if (innerResp.body.unusable()) { if (innerResp.body.unusable()) {
throw new TypeError("Body is unusable."); throw new TypeError("Body is unusable.");
} }
if ( if (innerResp.body.streamOrStatic instanceof ReadableStream) {
ObjectPrototypeIsPrototypeOf(
ReadableStreamPrototype,
innerResp.body.streamOrStatic,
)
) {
if ( if (
innerResp.body.length === null || innerResp.body.length === null ||
ObjectPrototypeIsPrototypeOf( innerResp.body.source instanceof Blob
BlobPrototype,
innerResp.body.source,
)
) { ) {
respBody = innerResp.body.stream; respBody = innerResp.body.stream;
} else { } else {
@ -216,8 +204,7 @@
respBody = new Uint8Array(0); respBody = new Uint8Array(0);
} }
const isStreamingResponseBody = !( const isStreamingResponseBody = !(
typeof respBody === "string" || typeof respBody === "string" || respBody instanceof Uint8Array
ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, respBody)
); );
try { try {
@ -228,34 +215,25 @@
); );
} catch (error) { } catch (error) {
const connError = httpConn[connErrorSymbol]; const connError = httpConn[connErrorSymbol];
if ( if (error instanceof BadResource && connError != null) {
ObjectPrototypeIsPrototypeOf(BadResourcePrototype, error) &&
connError != null
) {
// deno-lint-ignore no-ex-assign // deno-lint-ignore no-ex-assign
error = new connError.constructor(connError.message); error = new connError.constructor(connError.message);
} }
if ( if (respBody !== null && respBody instanceof ReadableStream) {
respBody !== null &&
ObjectPrototypeIsPrototypeOf(ReadableStreamPrototype, respBody)
) {
await respBody.cancel(error); await respBody.cancel(error);
} }
throw error; throw error;
} }
if (isStreamingResponseBody) { if (isStreamingResponseBody) {
if ( if (respBody === null || !(respBody instanceof ReadableStream)) {
respBody === null ||
!ObjectPrototypeIsPrototypeOf(ReadableStreamPrototype, respBody)
) {
throw new TypeError("Unreachable"); throw new TypeError("Unreachable");
} }
const reader = respBody.getReader(); const reader = respBody.getReader();
while (true) { while (true) {
const { value, done } = await reader.read(); const { value, done } = await reader.read();
if (done) break; if (done) break;
if (!ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, value)) { if (!(value instanceof Uint8Array)) {
await reader.cancel(new TypeError("Value not a Uint8Array")); await reader.cancel(new TypeError("Value not a Uint8Array"));
break; break;
} }
@ -263,10 +241,7 @@
await core.opAsync("op_http_write", streamRid, value); await core.opAsync("op_http_write", streamRid, value);
} catch (error) { } catch (error) {
const connError = httpConn[connErrorSymbol]; const connError = httpConn[connErrorSymbol];
if ( if (error instanceof BadResource && connError != null) {
ObjectPrototypeIsPrototypeOf(BadResourcePrototype, error) &&
connError != null
) {
// deno-lint-ignore no-ex-assign // deno-lint-ignore no-ex-assign
error = new connError.constructor(connError.message); error = new connError.constructor(connError.message);
} }

13
ext/net/01_net.js
View file

@ -3,9 +3,8 @@
((window) => { ((window) => {
const core = window.Deno.core; const core = window.Deno.core;
const { BadResourcePrototype, InterruptedPrototype } = core; const { BadResource, Interrupted } = core;
const { const {
ObjectPrototypeIsPrototypeOf,
PromiseResolve, PromiseResolve,
SymbolAsyncIterator, SymbolAsyncIterator,
Uint8Array, Uint8Array,
@ -125,10 +124,7 @@
try { try {
conn = await this.accept(); conn = await this.accept();
} catch (error) { } catch (error) {
if ( if (error instanceof BadResource || error instanceof Interrupted) {
ObjectPrototypeIsPrototypeOf(BadResourcePrototype, error) ||
ObjectPrototypeIsPrototypeOf(InterruptedPrototype, error)
) {
return { value: undefined, done: true }; return { value: undefined, done: true };
} }
throw error; throw error;
@ -195,10 +191,7 @@
try { try {
yield await this.receive(); yield await this.receive();
} catch (err) { } catch (err) {
if ( if (err instanceof BadResource || err instanceof Interrupted) {
ObjectPrototypeIsPrototypeOf(BadResourcePrototype, err) ||
ObjectPrototypeIsPrototypeOf(InterruptedPrototype, err)
) {
break; break;
} }
throw err; throw err;

3
ext/timers/01_timers.js
View file

@ -16,7 +16,6 @@
// deno-lint-ignore camelcase // deno-lint-ignore camelcase
NumberPOSITIVE_INFINITY, NumberPOSITIVE_INFINITY,
PromisePrototypeThen, PromisePrototypeThen,
ObjectPrototypeIsPrototypeOf,
SymbolFor, SymbolFor,
TypeError, TypeError,
} = window.__bootstrap.primordials; } = window.__bootstrap.primordials;
@ -288,7 +287,7 @@
} }
}, },
(err) => { (err) => {
if (ObjectPrototypeIsPrototypeOf(core.InterruptedPrototype, err)) { if (err instanceof core.Interrupted) {
// The timer was cancelled. // The timer was cancelled.
removeFromScheduledTimers(timerObject); removeFromScheduledTimers(timerObject);
} else { } else {

61
ext/timers/02_performance.js
View file

@ -9,7 +9,6 @@
ArrayPrototypeReverse, ArrayPrototypeReverse,
ArrayPrototypeSlice, ArrayPrototypeSlice,
ObjectKeys, ObjectKeys,
ObjectPrototypeIsPrototypeOf,
Symbol, Symbol,
SymbolFor, SymbolFor,
TypeError, TypeError,
@ -128,22 +127,22 @@
[_duration] = 0; [_duration] = 0;
get name() { get name() {
webidl.assertBranded(this, PerformanceEntryPrototype); webidl.assertBranded(this, PerformanceEntry);
return this[_name]; return this[_name];
} }
get entryType() { get entryType() {
webidl.assertBranded(this, PerformanceEntryPrototype); webidl.assertBranded(this, PerformanceEntry);
return this[_entryType]; return this[_entryType];
} }
get startTime() { get startTime() {
webidl.assertBranded(this, PerformanceEntryPrototype); webidl.assertBranded(this, PerformanceEntry);
return this[_startTime]; return this[_startTime];
} }
get duration() { get duration() {
webidl.assertBranded(this, PerformanceEntryPrototype); webidl.assertBranded(this, PerformanceEntry);
return this[_duration]; return this[_duration];
} }
@ -166,7 +165,7 @@
} }
toJSON() { toJSON() {
webidl.assertBranded(this, PerformanceEntryPrototype); webidl.assertBranded(this, PerformanceEntry);
return { return {
name: this[_name], name: this[_name],
entryType: this[_entryType], entryType: this[_entryType],
@ -178,10 +177,7 @@
[customInspect](inspect) { [customInspect](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf( evaluate: this instanceof PerformanceEntry,
PerformanceEntryPrototype,
this,
),
keys: [ keys: [
"name", "name",
"entryType", "entryType",
@ -192,19 +188,18 @@
} }
} }
webidl.configurePrototype(PerformanceEntry); webidl.configurePrototype(PerformanceEntry);
const PerformanceEntryPrototype = PerformanceEntry.prototype;
const _detail = Symbol("[[detail]]"); const _detail = Symbol("[[detail]]");
class PerformanceMark extends PerformanceEntry { class PerformanceMark extends PerformanceEntry {
[_detail] = null; [_detail] = null;
get detail() { get detail() {
webidl.assertBranded(this, PerformanceMarkPrototype); webidl.assertBranded(this, PerformanceMark);
return this[_detail]; return this[_detail];
} }
get entryType() { get entryType() {
webidl.assertBranded(this, PerformanceMarkPrototype); webidl.assertBranded(this, PerformanceMark);
return "mark"; return "mark";
} }
@ -236,7 +231,7 @@
} }
toJSON() { toJSON() {
webidl.assertBranded(this, PerformanceMarkPrototype); webidl.assertBranded(this, PerformanceMark);
return { return {
name: this.name, name: this.name,
entryType: this.entryType, entryType: this.entryType,
@ -249,7 +244,7 @@
[customInspect](inspect) { [customInspect](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf(PerformanceMarkPrototype, this), evaluate: this instanceof PerformanceMark,
keys: [ keys: [
"name", "name",
"entryType", "entryType",
@ -261,17 +256,17 @@
} }
} }
webidl.configurePrototype(PerformanceMark); webidl.configurePrototype(PerformanceMark);
const PerformanceMarkPrototype = PerformanceMark.prototype;
class PerformanceMeasure extends PerformanceEntry { class PerformanceMeasure extends PerformanceEntry {
[_detail] = null; [_detail] = null;
get detail() { get detail() {
webidl.assertBranded(this, PerformanceMeasurePrototype); webidl.assertBranded(this, PerformanceMeasure);
return this[_detail]; return this[_detail];
} }
get entryType() { get entryType() {
webidl.assertBranded(this, PerformanceMeasurePrototype); webidl.assertBranded(this, PerformanceMeasure);
return "measure"; return "measure";
} }
@ -292,7 +287,7 @@
} }
toJSON() { toJSON() {
webidl.assertBranded(this, PerformanceMeasurePrototype); webidl.assertBranded(this, PerformanceMeasure);
return { return {
name: this.name, name: this.name,
entryType: this.entryType, entryType: this.entryType,
@ -305,10 +300,7 @@
[customInspect](inspect) { [customInspect](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf( evaluate: this instanceof PerformanceMeasure,
PerformanceMeasurePrototype,
this,
),
keys: [ keys: [
"name", "name",
"entryType", "entryType",
@ -320,14 +312,14 @@
} }
} }
webidl.configurePrototype(PerformanceMeasure); webidl.configurePrototype(PerformanceMeasure);
const PerformanceMeasurePrototype = PerformanceMeasure.prototype;
class Performance { class Performance {
constructor() { constructor() {
webidl.illegalConstructor(); webidl.illegalConstructor();
} }
clearMarks(markName = undefined) { clearMarks(markName = undefined) {
webidl.assertBranded(this, PerformancePrototype); webidl.assertBranded(this, Performance);
if (markName !== undefined) { if (markName !== undefined) {
markName = webidl.converters.DOMString(markName, { markName = webidl.converters.DOMString(markName, {
prefix: "Failed to execute 'clearMarks' on 'Performance'", prefix: "Failed to execute 'clearMarks' on 'Performance'",
@ -347,7 +339,7 @@
} }
clearMeasures(measureName = undefined) { clearMeasures(measureName = undefined) {
webidl.assertBranded(this, PerformancePrototype); webidl.assertBranded(this, Performance);
if (measureName !== undefined) { if (measureName !== undefined) {
measureName = webidl.converters.DOMString(measureName, { measureName = webidl.converters.DOMString(measureName, {
prefix: "Failed to execute 'clearMeasures' on 'Performance'", prefix: "Failed to execute 'clearMeasures' on 'Performance'",
@ -368,7 +360,7 @@
} }
getEntries() { getEntries() {
webidl.assertBranded(this, PerformancePrototype); webidl.assertBranded(this, Performance);
return filterByNameType(); return filterByNameType();
} }
@ -376,7 +368,7 @@
name, name,
type = undefined, type = undefined,
) { ) {
webidl.assertBranded(this, PerformancePrototype); webidl.assertBranded(this, Performance);
const prefix = "Failed to execute 'getEntriesByName' on 'Performance'"; const prefix = "Failed to execute 'getEntriesByName' on 'Performance'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
@ -396,7 +388,7 @@
} }
getEntriesByType(type) { getEntriesByType(type) {
webidl.assertBranded(this, PerformancePrototype); webidl.assertBranded(this, Performance);
const prefix = "Failed to execute 'getEntriesByName' on 'Performance'"; const prefix = "Failed to execute 'getEntriesByName' on 'Performance'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
@ -412,7 +404,7 @@
markName, markName,
markOptions = {}, markOptions = {},
) { ) {
webidl.assertBranded(this, PerformancePrototype); webidl.assertBranded(this, Performance);
const prefix = "Failed to execute 'mark' on 'Performance'"; const prefix = "Failed to execute 'mark' on 'Performance'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
@ -440,7 +432,7 @@
startOrMeasureOptions = {}, startOrMeasureOptions = {},
endMark = undefined, endMark = undefined,
) { ) {
webidl.assertBranded(this, PerformancePrototype); webidl.assertBranded(this, Performance);
const prefix = "Failed to execute 'measure' on 'Performance'"; const prefix = "Failed to execute 'measure' on 'Performance'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
@ -539,25 +531,24 @@
} }
now() { now() {
webidl.assertBranded(this, PerformancePrototype); webidl.assertBranded(this, Performance);
return now(); return now();
} }
toJSON() { toJSON() {
webidl.assertBranded(this, PerformancePrototype); webidl.assertBranded(this, Performance);
return {}; return {};
} }
[customInspect](inspect) { [customInspect](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf(PerformancePrototype, this), evaluate: this instanceof Performance,
keys: [], keys: [],
})); }));
} }
} }
webidl.configurePrototype(Performance); webidl.configurePrototype(Performance);
const PerformancePrototype = Performance.prototype;
window.__bootstrap.performance = { window.__bootstrap.performance = {
PerformanceEntry, PerformanceEntry,

66
ext/url/00_url.js
View file

@ -134,7 +134,7 @@
* @param {string} value * @param {string} value
*/ */
append(name, value) { append(name, value) {
webidl.assertBranded(this, URLSearchParamsPrototype); webidl.assertBranded(this, URLSearchParams);
const prefix = "Failed to execute 'append' on 'URLSearchParams'"; const prefix = "Failed to execute 'append' on 'URLSearchParams'";
webidl.requiredArguments(arguments.length, 2, { prefix }); webidl.requiredArguments(arguments.length, 2, { prefix });
name = webidl.converters.USVString(name, { name = webidl.converters.USVString(name, {
@ -153,7 +153,7 @@
* @param {string} name * @param {string} name
*/ */
delete(name) { delete(name) {
webidl.assertBranded(this, URLSearchParamsPrototype); webidl.assertBranded(this, URLSearchParams);
const prefix = "Failed to execute 'append' on 'URLSearchParams'"; const prefix = "Failed to execute 'append' on 'URLSearchParams'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
name = webidl.converters.USVString(name, { name = webidl.converters.USVString(name, {
@ -177,7 +177,7 @@
* @returns {string[]} * @returns {string[]}
*/ */
getAll(name) { getAll(name) {
webidl.assertBranded(this, URLSearchParamsPrototype); webidl.assertBranded(this, URLSearchParams);
const prefix = "Failed to execute 'getAll' on 'URLSearchParams'"; const prefix = "Failed to execute 'getAll' on 'URLSearchParams'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
name = webidl.converters.USVString(name, { name = webidl.converters.USVString(name, {
@ -198,7 +198,7 @@
* @return {string | null} * @return {string | null}
*/ */
get(name) { get(name) {
webidl.assertBranded(this, URLSearchParamsPrototype); webidl.assertBranded(this, URLSearchParams);
const prefix = "Failed to execute 'get' on 'URLSearchParams'"; const prefix = "Failed to execute 'get' on 'URLSearchParams'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
name = webidl.converters.USVString(name, { name = webidl.converters.USVString(name, {
@ -218,7 +218,7 @@
* @return {boolean} * @return {boolean}
*/ */
has(name) { has(name) {
webidl.assertBranded(this, URLSearchParamsPrototype); webidl.assertBranded(this, URLSearchParams);
const prefix = "Failed to execute 'has' on 'URLSearchParams'"; const prefix = "Failed to execute 'has' on 'URLSearchParams'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
name = webidl.converters.USVString(name, { name = webidl.converters.USVString(name, {
@ -233,7 +233,7 @@
* @param {string} value * @param {string} value
*/ */
set(name, value) { set(name, value) {
webidl.assertBranded(this, URLSearchParamsPrototype); webidl.assertBranded(this, URLSearchParams);
const prefix = "Failed to execute 'set' on 'URLSearchParams'"; const prefix = "Failed to execute 'set' on 'URLSearchParams'";
webidl.requiredArguments(arguments.length, 2, { prefix }); webidl.requiredArguments(arguments.length, 2, { prefix });
name = webidl.converters.USVString(name, { name = webidl.converters.USVString(name, {
@ -276,7 +276,7 @@
} }
sort() { sort() {
webidl.assertBranded(this, URLSearchParamsPrototype); webidl.assertBranded(this, URLSearchParams);
ArrayPrototypeSort( ArrayPrototypeSort(
this[_list], this[_list],
(a, b) => (a[0] === b[0] ? 0 : a[0] > b[0] ? 1 : -1), (a, b) => (a[0] === b[0] ? 0 : a[0] > b[0] ? 1 : -1),
@ -288,7 +288,7 @@
* @return {string} * @return {string}
*/ */
toString() { toString() {
webidl.assertBranded(this, URLSearchParamsPrototype); webidl.assertBranded(this, URLSearchParams);
return core.opSync("op_url_stringify_search_params", this[_list]); return core.opSync("op_url_stringify_search_params", this[_list]);
} }
} }
@ -296,7 +296,6 @@
webidl.mixinPairIterable("URLSearchParams", URLSearchParams, _list, 0, 1); webidl.mixinPairIterable("URLSearchParams", URLSearchParams, _list, 0, 1);
webidl.configurePrototype(URLSearchParams); webidl.configurePrototype(URLSearchParams);
const URLSearchParamsPrototype = URLSearchParams.prototype;
const _url = Symbol("url"); const _url = Symbol("url");
@ -351,13 +350,13 @@
/** @return {string} */ /** @return {string} */
get hash() { get hash() {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
return this[_url].hash; return this[_url].hash;
} }
/** @param {string} value */ /** @param {string} value */
set hash(value) { set hash(value) {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
const prefix = "Failed to set 'hash' on 'URL'"; const prefix = "Failed to set 'hash' on 'URL'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
value = webidl.converters.DOMString(value, { value = webidl.converters.DOMString(value, {
@ -373,13 +372,13 @@
/** @return {string} */ /** @return {string} */
get host() { get host() {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
return this[_url].host; return this[_url].host;
} }
/** @param {string} value */ /** @param {string} value */
set host(value) { set host(value) {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
const prefix = "Failed to set 'host' on 'URL'"; const prefix = "Failed to set 'host' on 'URL'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
value = webidl.converters.DOMString(value, { value = webidl.converters.DOMString(value, {
@ -395,13 +394,13 @@
/** @return {string} */ /** @return {string} */
get hostname() { get hostname() {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
return this[_url].hostname; return this[_url].hostname;
} }
/** @param {string} value */ /** @param {string} value */
set hostname(value) { set hostname(value) {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
const prefix = "Failed to set 'hostname' on 'URL'"; const prefix = "Failed to set 'hostname' on 'URL'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
value = webidl.converters.DOMString(value, { value = webidl.converters.DOMString(value, {
@ -417,13 +416,13 @@
/** @return {string} */ /** @return {string} */
get href() { get href() {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
return this[_url].href; return this[_url].href;
} }
/** @param {string} value */ /** @param {string} value */
set href(value) { set href(value) {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
const prefix = "Failed to set 'href' on 'URL'"; const prefix = "Failed to set 'href' on 'URL'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
value = webidl.converters.DOMString(value, { value = webidl.converters.DOMString(value, {
@ -436,19 +435,19 @@
/** @return {string} */ /** @return {string} */
get origin() { get origin() {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
return this[_url].origin; return this[_url].origin;
} }
/** @return {string} */ /** @return {string} */
get password() { get password() {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
return this[_url].password; return this[_url].password;
} }
/** @param {string} value */ /** @param {string} value */
set password(value) { set password(value) {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
const prefix = "Failed to set 'password' on 'URL'"; const prefix = "Failed to set 'password' on 'URL'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
value = webidl.converters.DOMString(value, { value = webidl.converters.DOMString(value, {
@ -464,13 +463,13 @@
/** @return {string} */ /** @return {string} */
get pathname() { get pathname() {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
return this[_url].pathname; return this[_url].pathname;
} }
/** @param {string} value */ /** @param {string} value */
set pathname(value) { set pathname(value) {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
const prefix = "Failed to set 'pathname' on 'URL'"; const prefix = "Failed to set 'pathname' on 'URL'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
value = webidl.converters.DOMString(value, { value = webidl.converters.DOMString(value, {
@ -486,13 +485,13 @@
/** @return {string} */ /** @return {string} */
get port() { get port() {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
return this[_url].port; return this[_url].port;
} }
/** @param {string} value */ /** @param {string} value */
set port(value) { set port(value) {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
const prefix = "Failed to set 'port' on 'URL'"; const prefix = "Failed to set 'port' on 'URL'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
value = webidl.converters.DOMString(value, { value = webidl.converters.DOMString(value, {
@ -508,13 +507,13 @@
/** @return {string} */ /** @return {string} */
get protocol() { get protocol() {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
return this[_url].protocol; return this[_url].protocol;
} }
/** @param {string} value */ /** @param {string} value */
set protocol(value) { set protocol(value) {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
const prefix = "Failed to set 'protocol' on 'URL'"; const prefix = "Failed to set 'protocol' on 'URL'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
value = webidl.converters.DOMString(value, { value = webidl.converters.DOMString(value, {
@ -530,13 +529,13 @@
/** @return {string} */ /** @return {string} */
get search() { get search() {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
return this[_url].search; return this[_url].search;
} }
/** @param {string} value */ /** @param {string} value */
set search(value) { set search(value) {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
const prefix = "Failed to set 'search' on 'URL'"; const prefix = "Failed to set 'search' on 'URL'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
value = webidl.converters.DOMString(value, { value = webidl.converters.DOMString(value, {
@ -553,13 +552,13 @@
/** @return {string} */ /** @return {string} */
get username() { get username() {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
return this[_url].username; return this[_url].username;
} }
/** @param {string} value */ /** @param {string} value */
set username(value) { set username(value) {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
const prefix = "Failed to set 'username' on 'URL'"; const prefix = "Failed to set 'username' on 'URL'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
value = webidl.converters.DOMString(value, { value = webidl.converters.DOMString(value, {
@ -584,19 +583,18 @@
/** @return {string} */ /** @return {string} */
toString() { toString() {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
return this[_url].href; return this[_url].href;
} }
/** @return {string} */ /** @return {string} */
toJSON() { toJSON() {
webidl.assertBranded(this, URLPrototype); webidl.assertBranded(this, URL);
return this[_url].href; return this[_url].href;
} }
} }
webidl.configurePrototype(URL); webidl.configurePrototype(URL);
const URLPrototype = URL.prototype;
/** /**
* This function implements application/x-www-form-urlencoded parsing. * This function implements application/x-www-form-urlencoded parsing.
@ -624,9 +622,7 @@
window.__bootstrap.url = { window.__bootstrap.url = {
URL, URL,
URLPrototype,
URLSearchParams, URLSearchParams,
URLSearchParamsPrototype,
parseUrlEncoded, parseUrlEncoded,
}; };
})(this); })(this);

21
ext/url/01_urlpattern.js
View file

@ -85,42 +85,42 @@
} }
get protocol() { get protocol() {
webidl.assertBranded(this, URLPatternPrototype); webidl.assertBranded(this, URLPattern);
return this[_components].protocol.patternString; return this[_components].protocol.patternString;
} }
get username() { get username() {
webidl.assertBranded(this, URLPatternPrototype); webidl.assertBranded(this, URLPattern);
return this[_components].username.patternString; return this[_components].username.patternString;
} }
get password() { get password() {
webidl.assertBranded(this, URLPatternPrototype); webidl.assertBranded(this, URLPattern);
return this[_components].password.patternString; return this[_components].password.patternString;
} }
get hostname() { get hostname() {
webidl.assertBranded(this, URLPatternPrototype); webidl.assertBranded(this, URLPattern);
return this[_components].hostname.patternString; return this[_components].hostname.patternString;
} }
get port() { get port() {
webidl.assertBranded(this, URLPatternPrototype); webidl.assertBranded(this, URLPattern);
return this[_components].port.patternString; return this[_components].port.patternString;
} }
get pathname() { get pathname() {
webidl.assertBranded(this, URLPatternPrototype); webidl.assertBranded(this, URLPattern);
return this[_components].pathname.patternString; return this[_components].pathname.patternString;
} }
get search() { get search() {
webidl.assertBranded(this, URLPatternPrototype); webidl.assertBranded(this, URLPattern);
return this[_components].search.patternString; return this[_components].search.patternString;
} }
get hash() { get hash() {
webidl.assertBranded(this, URLPatternPrototype); webidl.assertBranded(this, URLPattern);
return this[_components].hash.patternString; return this[_components].hash.patternString;
} }
@ -130,7 +130,7 @@
* @returns {boolean} * @returns {boolean}
*/ */
test(input, baseURL = undefined) { test(input, baseURL = undefined) {
webidl.assertBranded(this, URLPatternPrototype); webidl.assertBranded(this, URLPattern);
const prefix = "Failed to execute 'test' on 'URLPattern'"; const prefix = "Failed to execute 'test' on 'URLPattern'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
input = webidl.converters.URLPatternInput(input, { input = webidl.converters.URLPatternInput(input, {
@ -170,7 +170,7 @@
* @returns {URLPatternResult | null} * @returns {URLPatternResult | null}
*/ */
exec(input, baseURL = undefined) { exec(input, baseURL = undefined) {
webidl.assertBranded(this, URLPatternPrototype); webidl.assertBranded(this, URLPattern);
const prefix = "Failed to execute 'exec' on 'URLPattern'"; const prefix = "Failed to execute 'exec' on 'URLPattern'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
input = webidl.converters.URLPatternInput(input, { input = webidl.converters.URLPatternInput(input, {
@ -241,7 +241,6 @@
} }
webidl.configurePrototype(URLPattern); webidl.configurePrototype(URLPattern);
const URLPatternPrototype = URLPattern.prototype;
webidl.converters.URLPatternInit = webidl webidl.converters.URLPatternInit = webidl
.createDictionaryConverter("URLPatternInit", [ .createDictionaryConverter("URLPatternInit", [

4
ext/web/01_dom_exception.js
View file

@ -16,7 +16,6 @@
ErrorPrototype, ErrorPrototype,
ObjectDefineProperty, ObjectDefineProperty,
ObjectEntries, ObjectEntries,
ObjectPrototypeIsPrototypeOf,
ObjectSetPrototypeOf, ObjectSetPrototypeOf,
SymbolFor, SymbolFor,
} = window.__bootstrap.primordials; } = window.__bootstrap.primordials;
@ -127,7 +126,7 @@
} }
[SymbolFor("Deno.customInspect")](inspect) { [SymbolFor("Deno.customInspect")](inspect) {
if (ObjectPrototypeIsPrototypeOf(DOMExceptionPrototype, this)) { if (this instanceof DOMException) {
return `DOMException: ${this.#message}`; return `DOMException: ${this.#message}`;
} else { } else {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
@ -146,7 +145,6 @@
ObjectSetPrototypeOf(DOMException.prototype, ErrorPrototype); ObjectSetPrototypeOf(DOMException.prototype, ErrorPrototype);
webidl.configurePrototype(DOMException); webidl.configurePrototype(DOMException);
const DOMExceptionPrototype = DOMException.prototype;
for ( for (
const [key, value] of ObjectEntries({ const [key, value] of ObjectEntries({

16
ext/web/02_event.js
View file

@ -29,7 +29,6 @@
ObjectCreate, ObjectCreate,
ObjectDefineProperty, ObjectDefineProperty,
ObjectGetOwnPropertyDescriptor, ObjectGetOwnPropertyDescriptor,
ObjectPrototypeIsPrototypeOf,
ReflectDefineProperty, ReflectDefineProperty,
Symbol, Symbol,
SymbolFor, SymbolFor,
@ -175,7 +174,7 @@
[SymbolFor("Deno.privateCustomInspect")](inspect) { [SymbolFor("Deno.privateCustomInspect")](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf(Event.prototype, this), evaluate: this instanceof Event,
keys: EVENT_PROPS, keys: EVENT_PROPS,
})); }));
} }
@ -1059,7 +1058,7 @@
[SymbolFor("Deno.privateCustomInspect")](inspect) { [SymbolFor("Deno.privateCustomInspect")](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf(ErrorEvent.prototype, this), evaluate: this instanceof ErrorEvent,
keys: [ keys: [
...EVENT_PROPS, ...EVENT_PROPS,
"message", "message",
@ -1120,7 +1119,7 @@
[SymbolFor("Deno.privateCustomInspect")](inspect) { [SymbolFor("Deno.privateCustomInspect")](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf(CloseEvent.prototype, this), evaluate: this instanceof CloseEvent,
keys: [ keys: [
...EVENT_PROPS, ...EVENT_PROPS,
"wasClean", "wasClean",
@ -1152,7 +1151,7 @@
[SymbolFor("Deno.privateCustomInspect")](inspect) { [SymbolFor("Deno.privateCustomInspect")](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf(MessageEvent.prototype, this), evaluate: this instanceof MessageEvent,
keys: [ keys: [
...EVENT_PROPS, ...EVENT_PROPS,
"data", "data",
@ -1185,7 +1184,7 @@
[SymbolFor("Deno.privateCustomInspect")](inspect) { [SymbolFor("Deno.privateCustomInspect")](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf(CustomEvent.prototype, this), evaluate: this instanceof CustomEvent,
keys: [ keys: [
...EVENT_PROPS, ...EVENT_PROPS,
"detail", "detail",
@ -1215,7 +1214,7 @@
[SymbolFor("Deno.privateCustomInspect")](inspect) { [SymbolFor("Deno.privateCustomInspect")](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf(ProgressEvent.prototype, this), evaluate: this instanceof ProgressEvent,
keys: [ keys: [
...EVENT_PROPS, ...EVENT_PROPS,
"lengthComputable", "lengthComputable",
@ -1239,8 +1238,7 @@
if ( if (
isSpecialErrorEventHandler && isSpecialErrorEventHandler &&
ObjectPrototypeIsPrototypeOf(ErrorEvent.prototype, evt) && evt instanceof ErrorEvent && evt.type === "error"
evt.type === "error"
) { ) {
const ret = FunctionPrototypeCall( const ret = FunctionPrototypeCall(
wrappedHandler.handler, wrappedHandler.handler,

12
ext/web/02_structured_clone.js
View file

@ -13,12 +13,10 @@
const { DOMException } = window.__bootstrap.domException; const { DOMException } = window.__bootstrap.domException;
const { const {
ArrayBuffer, ArrayBuffer,
ArrayBufferPrototype,
ArrayBufferIsView, ArrayBufferIsView,
DataViewPrototype, DataView,
ObjectPrototypeIsPrototypeOf,
TypedArrayPrototypeSlice, TypedArrayPrototypeSlice,
TypeErrorPrototype, TypeError,
WeakMap, WeakMap,
WeakMapPrototypeSet, WeakMapPrototypeSet,
} = window.__bootstrap.primordials; } = window.__bootstrap.primordials;
@ -44,7 +42,7 @@
function structuredClone(value) { function structuredClone(value) {
// Performance optimization for buffers, otherwise // Performance optimization for buffers, otherwise
// `serialize/deserialize` will allocate new buffer. // `serialize/deserialize` will allocate new buffer.
if (ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, value)) { if (value instanceof ArrayBuffer) {
const cloned = cloneArrayBuffer( const cloned = cloneArrayBuffer(
value, value,
0, 0,
@ -61,7 +59,7 @@
// only DataView has a length in bytes and TypedArrays use a length in // only DataView has a length in bytes and TypedArrays use a length in
// terms of elements, so we adjust for that. // terms of elements, so we adjust for that.
let length; let length;
if (ObjectPrototypeIsPrototypeOf(DataViewPrototype, view)) { if (value instanceof DataView) {
length = value.byteLength; length = value.byteLength;
} else { } else {
length = value.length; length = value.length;
@ -76,7 +74,7 @@
try { try {
return core.deserialize(core.serialize(value)); return core.deserialize(core.serialize(value));
} catch (e) { } catch (e) {
if (ObjectPrototypeIsPrototypeOf(TypeErrorPrototype, e)) { if (e instanceof TypeError) {
throw new DOMException("Uncloneable value", "DataCloneError"); throw new DOMException("Uncloneable value", "DataCloneError");
} }
throw e; throw e;

15
ext/web/03_abort_signal.js
View file

@ -77,17 +77,17 @@
} }
get aborted() { get aborted() {
webidl.assertBranded(this, AbortSignalPrototype); webidl.assertBranded(this, AbortSignal);
return this[abortReason] !== undefined; return this[abortReason] !== undefined;
} }
get reason() { get reason() {
webidl.assertBranded(this, AbortSignalPrototype); webidl.assertBranded(this, AbortSignal);
return this[abortReason]; return this[abortReason];
} }
throwIfAborted() { throwIfAborted() {
webidl.assertBranded(this, AbortSignalPrototype); webidl.assertBranded(this, AbortSignal);
if (this[abortReason] !== undefined) { if (this[abortReason] !== undefined) {
throw this[abortReason]; throw this[abortReason];
} }
@ -96,7 +96,6 @@
defineEventHandler(AbortSignal.prototype, "abort"); defineEventHandler(AbortSignal.prototype, "abort");
webidl.configurePrototype(AbortSignal); webidl.configurePrototype(AbortSignal);
const AbortSignalPrototype = AbortSignal.prototype;
class AbortController { class AbortController {
[signal] = new AbortSignal(illegalConstructorKey); [signal] = new AbortSignal(illegalConstructorKey);
@ -106,22 +105,21 @@
} }
get signal() { get signal() {
webidl.assertBranded(this, AbortControllerPrototype); webidl.assertBranded(this, AbortController);
return this[signal]; return this[signal];
} }
abort(reason) { abort(reason) {
webidl.assertBranded(this, AbortControllerPrototype); webidl.assertBranded(this, AbortController);
this[signal][signalAbort](reason); this[signal][signalAbort](reason);
} }
} }
webidl.configurePrototype(AbortController); webidl.configurePrototype(AbortController);
const AbortControllerPrototype = AbortController.prototype;
webidl.converters["AbortSignal"] = webidl.createInterfaceConverter( webidl.converters["AbortSignal"] = webidl.createInterfaceConverter(
"AbortSignal", "AbortSignal",
AbortSignal.prototype, AbortSignal,
); );
function newSignal() { function newSignal() {
@ -144,7 +142,6 @@
window.AbortSignal = AbortSignal; window.AbortSignal = AbortSignal;
window.AbortController = AbortController; window.AbortController = AbortController;
window.__bootstrap.abortSignal = { window.__bootstrap.abortSignal = {
AbortSignalPrototype,
add, add,
signalAbort, signalAbort,
remove, remove,

235
ext/web/06_streams.js
View file

@ -9,22 +9,21 @@
((window) => { ((window) => {
const webidl = window.__bootstrap.webidl; const webidl = window.__bootstrap.webidl;
const { add, remove, signalAbort, newSignal, AbortSignalPrototype } = const { add, remove, signalAbort, newSignal } =
window.__bootstrap.abortSignal; window.__bootstrap.abortSignal;
const { const {
ArrayBuffer, ArrayBuffer,
ArrayBufferPrototype,
ArrayBufferIsView, ArrayBufferIsView,
ArrayPrototypeMap, ArrayPrototypeMap,
ArrayPrototypePush, ArrayPrototypePush,
ArrayPrototypeShift, ArrayPrototypeShift,
BigInt64ArrayPrototype, BigInt64Array,
BigUint64ArrayPrototype, BigUint64Array,
DataView, DataView,
Error, Error,
Int8ArrayPrototype, Int8Array,
Int16ArrayPrototype, Int16Array,
Int32ArrayPrototype, Int32Array,
NumberIsInteger, NumberIsInteger,
NumberIsNaN, NumberIsNaN,
MathMin, MathMin,
@ -32,7 +31,6 @@
ObjectDefineProperties, ObjectDefineProperties,
ObjectDefineProperty, ObjectDefineProperty,
ObjectGetPrototypeOf, ObjectGetPrototypeOf,
ObjectPrototypeIsPrototypeOf,
ObjectSetPrototypeOf, ObjectSetPrototypeOf,
Promise, Promise,
PromiseAll, PromiseAll,
@ -48,10 +46,9 @@
SymbolFor, SymbolFor,
TypeError, TypeError,
Uint8Array, Uint8Array,
Uint8ArrayPrototype, Uint16Array,
Uint16ArrayPrototype, Uint32Array,
Uint32ArrayPrototype, Uint8ClampedArray,
Uint8ClampedArrayPrototype,
WeakMap, WeakMap,
WeakMapPrototypeGet, WeakMapPrototypeGet,
WeakMapPrototypeHas, WeakMapPrototypeHas,
@ -137,7 +134,7 @@
/** @param {any} e */ /** @param {any} e */
function rethrowAssertionErrorRejection(e) { function rethrowAssertionErrorRejection(e) {
if (e && ObjectPrototypeIsPrototypeOf(AssertionError.prototype, e)) { if (e && e instanceof AssertionError) {
queueMicrotask(() => { queueMicrotask(() => {
console.error(`Internal Error: ${e.stack}`); console.error(`Internal Error: ${e.stack}`);
}); });
@ -217,10 +214,7 @@
*/ */
function canTransferArrayBuffer(O) { function canTransferArrayBuffer(O) {
assert(typeof O === "object"); assert(typeof O === "object");
assert( assert(O instanceof ArrayBuffer || O instanceof SharedArrayBuffer);
ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, O) ||
ObjectPrototypeIsPrototypeOf(SharedArrayBuffer.prototype, O),
);
if (isDetachedBuffer(O)) { if (isDetachedBuffer(O)) {
return false; return false;
} }
@ -1370,15 +1364,15 @@
let ctor = DataView; let ctor = DataView;
if ( if (
ObjectPrototypeIsPrototypeOf(Int8ArrayPrototype, view) || view instanceof Int8Array ||
ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, view) || view instanceof Uint8Array ||
ObjectPrototypeIsPrototypeOf(Uint8ClampedArrayPrototype, view) || view instanceof Uint8ClampedArray ||
ObjectPrototypeIsPrototypeOf(Int16ArrayPrototype, view) || view instanceof Int16Array ||
ObjectPrototypeIsPrototypeOf(Uint16ArrayPrototype, view) || view instanceof Uint16Array ||
ObjectPrototypeIsPrototypeOf(Int32ArrayPrototype, view) || view instanceof Int32Array ||
ObjectPrototypeIsPrototypeOf(Uint32ArrayPrototype, view) || view instanceof Uint32Array ||
ObjectPrototypeIsPrototypeOf(BigInt64ArrayPrototype, view) || view instanceof BigInt64Array ||
ObjectPrototypeIsPrototypeOf(BigUint64ArrayPrototype, view) view instanceof BigUint64Array
) { ) {
elementSize = view.constructor.BYTES_PER_ELEMENT; elementSize = view.constructor.BYTES_PER_ELEMENT;
ctor = view.constructor; ctor = view.constructor;
@ -1989,10 +1983,7 @@
typeof preventClose === "boolean" && typeof preventAbort === "boolean" && typeof preventClose === "boolean" && typeof preventAbort === "boolean" &&
typeof preventCancel === "boolean", typeof preventCancel === "boolean",
); );
assert( assert(signal === undefined || signal instanceof AbortSignal);
signal === undefined ||
ObjectPrototypeIsPrototypeOf(AbortSignalPrototype, signal),
);
assert(!isReadableStreamLocked(source)); assert(!isReadableStreamLocked(source));
assert(!isWritableStreamLocked(dest)); assert(!isWritableStreamLocked(dest));
// We use acquireReadableStreamDefaultReader even in case of ReadableByteStreamController // We use acquireReadableStreamDefaultReader even in case of ReadableByteStreamController
@ -2336,12 +2327,7 @@
function readableStreamTee(stream, cloneForBranch2) { function readableStreamTee(stream, cloneForBranch2) {
assert(isReadableStream(stream)); assert(isReadableStream(stream));
assert(typeof cloneForBranch2 === "boolean"); assert(typeof cloneForBranch2 === "boolean");
if ( if (stream[_controller] instanceof ReadableByteStreamController) {
ObjectPrototypeIsPrototypeOf(
ReadableByteStreamControllerPrototype,
stream[_controller],
)
) {
return readableByteStreamTee(stream); return readableByteStreamTee(stream);
} else { } else {
return readableStreamDefaultTee(stream, cloneForBranch2); return readableStreamDefaultTee(stream, cloneForBranch2);
@ -2505,12 +2491,7 @@
*/ */
function readableByteStreamTee(stream) { function readableByteStreamTee(stream) {
assert(isReadableStream(stream)); assert(isReadableStream(stream));
assert( assert(stream[_controller] instanceof ReadableByteStreamController);
ObjectPrototypeIsPrototypeOf(
ReadableByteStreamControllerPrototype,
stream[_controller],
),
);
let reader = acquireReadableStreamDefaultReader(stream); let reader = acquireReadableStreamDefaultReader(stream);
let reading = false; let reading = false;
let readAgainForBranch1 = false; let readAgainForBranch1 = false;
@ -3018,12 +2999,7 @@
if (isReadableStreamLocked(stream)) { if (isReadableStreamLocked(stream)) {
throw new TypeError("ReadableStream is locked."); throw new TypeError("ReadableStream is locked.");
} }
if ( if (!(stream[_controller] instanceof ReadableByteStreamController)) {
!(ObjectPrototypeIsPrototypeOf(
ReadableByteStreamControllerPrototype,
stream[_controller],
))
) {
throw new TypeError("Cannot use a BYOB reader with a non-byte stream"); throw new TypeError("Cannot use a BYOB reader with a non-byte stream");
} }
readableStreamReaderGenericInitialize(reader, stream); readableStreamReaderGenericInitialize(reader, stream);
@ -3056,7 +3032,7 @@
transformAlgorithm, transformAlgorithm,
flushAlgorithm, flushAlgorithm,
) { ) {
assert(ObjectPrototypeIsPrototypeOf(TransformStreamPrototype, stream)); assert(stream instanceof TransformStream);
assert(stream[_controller] === undefined); assert(stream[_controller] === undefined);
controller[_stream] = stream; controller[_stream] = stream;
stream[_controller] = controller; stream[_controller] = controller;
@ -4198,13 +4174,13 @@
/** @returns {number} */ /** @returns {number} */
get highWaterMark() { get highWaterMark() {
webidl.assertBranded(this, ByteLengthQueuingStrategyPrototype); webidl.assertBranded(this, ByteLengthQueuingStrategy);
return this[_highWaterMark]; return this[_highWaterMark];
} }
/** @returns {(chunk: ArrayBufferView) => number} */ /** @returns {(chunk: ArrayBufferView) => number} */
get size() { get size() {
webidl.assertBranded(this, ByteLengthQueuingStrategyPrototype); webidl.assertBranded(this, ByteLengthQueuingStrategy);
initializeByteLengthSizeFunction(this[_globalObject]); initializeByteLengthSizeFunction(this[_globalObject]);
return WeakMapPrototypeGet(byteSizeFunctionWeakMap, this[_globalObject]); return WeakMapPrototypeGet(byteSizeFunctionWeakMap, this[_globalObject]);
} }
@ -4212,10 +4188,7 @@
[SymbolFor("Deno.customInspect")](inspect) { [SymbolFor("Deno.customInspect")](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf( evaluate: this instanceof ByteLengthQueuingStrategy,
ByteLengthQueuingStrategyPrototype,
this,
),
keys: [ keys: [
"highWaterMark", "highWaterMark",
"size", "size",
@ -4225,8 +4198,6 @@
} }
webidl.configurePrototype(ByteLengthQueuingStrategy); webidl.configurePrototype(ByteLengthQueuingStrategy);
const ByteLengthQueuingStrategyPrototype =
ByteLengthQueuingStrategy.prototype;
/** @type {WeakMap<typeof globalThis, (chunk: ArrayBufferView) => number>} */ /** @type {WeakMap<typeof globalThis, (chunk: ArrayBufferView) => number>} */
const byteSizeFunctionWeakMap = new WeakMap(); const byteSizeFunctionWeakMap = new WeakMap();
@ -4255,13 +4226,13 @@
/** @returns {number} */ /** @returns {number} */
get highWaterMark() { get highWaterMark() {
webidl.assertBranded(this, CountQueuingStrategyPrototype); webidl.assertBranded(this, CountQueuingStrategy);
return this[_highWaterMark]; return this[_highWaterMark];
} }
/** @returns {(chunk: any) => 1} */ /** @returns {(chunk: any) => 1} */
get size() { get size() {
webidl.assertBranded(this, CountQueuingStrategyPrototype); webidl.assertBranded(this, CountQueuingStrategy);
initializeCountSizeFunction(this[_globalObject]); initializeCountSizeFunction(this[_globalObject]);
return WeakMapPrototypeGet(countSizeFunctionWeakMap, this[_globalObject]); return WeakMapPrototypeGet(countSizeFunctionWeakMap, this[_globalObject]);
} }
@ -4269,10 +4240,7 @@
[SymbolFor("Deno.customInspect")](inspect) { [SymbolFor("Deno.customInspect")](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf( evaluate: this instanceof CountQueuingStrategy,
CountQueuingStrategyPrototype,
this,
),
keys: [ keys: [
"highWaterMark", "highWaterMark",
"size", "size",
@ -4282,7 +4250,6 @@
} }
webidl.configurePrototype(CountQueuingStrategy); webidl.configurePrototype(CountQueuingStrategy);
const CountQueuingStrategyPrototype = CountQueuingStrategy.prototype;
/** @type {WeakMap<typeof globalThis, () => 1>} */ /** @type {WeakMap<typeof globalThis, () => 1>} */
const countSizeFunctionWeakMap = new WeakMap(); const countSizeFunctionWeakMap = new WeakMap();
@ -4366,7 +4333,7 @@
/** @returns {boolean} */ /** @returns {boolean} */
get locked() { get locked() {
webidl.assertBranded(this, ReadableStreamPrototype); webidl.assertBranded(this, ReadableStream);
return isReadableStreamLocked(this); return isReadableStreamLocked(this);
} }
@ -4376,7 +4343,7 @@
*/ */
cancel(reason = undefined) { cancel(reason = undefined) {
try { try {
webidl.assertBranded(this, ReadableStreamPrototype); webidl.assertBranded(this, ReadableStream);
if (reason !== undefined) { if (reason !== undefined) {
reason = webidl.converters.any(reason); reason = webidl.converters.any(reason);
} }
@ -4396,7 +4363,7 @@
* @returns {ReadableStreamDefaultReader<R> | ReadableStreamBYOBReader} * @returns {ReadableStreamDefaultReader<R> | ReadableStreamBYOBReader}
*/ */
getReader(options = {}) { getReader(options = {}) {
webidl.assertBranded(this, ReadableStreamPrototype); webidl.assertBranded(this, ReadableStream);
const prefix = "Failed to execute 'getReader' on 'ReadableStream'"; const prefix = "Failed to execute 'getReader' on 'ReadableStream'";
options = webidl.converters.ReadableStreamGetReaderOptions(options, { options = webidl.converters.ReadableStreamGetReaderOptions(options, {
prefix, prefix,
@ -4417,7 +4384,7 @@
* @returns {ReadableStream<T>} * @returns {ReadableStream<T>}
*/ */
pipeThrough(transform, options = {}) { pipeThrough(transform, options = {}) {
webidl.assertBranded(this, ReadableStreamPrototype); webidl.assertBranded(this, ReadableStream);
const prefix = "Failed to execute 'pipeThrough' on 'ReadableStream'"; const prefix = "Failed to execute 'pipeThrough' on 'ReadableStream'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
transform = webidl.converters.ReadableWritablePair(transform, { transform = webidl.converters.ReadableWritablePair(transform, {
@ -4455,7 +4422,7 @@
*/ */
pipeTo(destination, options = {}) { pipeTo(destination, options = {}) {
try { try {
webidl.assertBranded(this, ReadableStreamPrototype); webidl.assertBranded(this, ReadableStream);
const prefix = "Failed to execute 'pipeTo' on 'ReadableStream'"; const prefix = "Failed to execute 'pipeTo' on 'ReadableStream'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
destination = webidl.converters.WritableStream(destination, { destination = webidl.converters.WritableStream(destination, {
@ -4492,7 +4459,7 @@
/** @returns {[ReadableStream<R>, ReadableStream<R>]} */ /** @returns {[ReadableStream<R>, ReadableStream<R>]} */
tee() { tee() {
webidl.assertBranded(this, ReadableStreamPrototype); webidl.assertBranded(this, ReadableStream);
return readableStreamTee(this, false); return readableStreamTee(this, false);
} }
@ -4502,7 +4469,7 @@
* @returns {AsyncIterableIterator<R>} * @returns {AsyncIterableIterator<R>}
*/ */
values(options = {}) { values(options = {}) {
webidl.assertBranded(this, ReadableStreamPrototype); webidl.assertBranded(this, ReadableStream);
const prefix = "Failed to execute 'values' on 'ReadableStream'"; const prefix = "Failed to execute 'values' on 'ReadableStream'";
options = webidl.converters.ReadableStreamIteratorOptions(options, { options = webidl.converters.ReadableStreamIteratorOptions(options, {
prefix, prefix,
@ -4531,7 +4498,6 @@
}); });
webidl.configurePrototype(ReadableStream); webidl.configurePrototype(ReadableStream);
const ReadableStreamPrototype = ReadableStream.prototype;
function errorReadableStream(stream, e) { function errorReadableStream(stream, e) {
readableStreamDefaultControllerError(stream[_controller], e); readableStreamDefaultControllerError(stream[_controller], e);
@ -4561,7 +4527,7 @@
/** @returns {Promise<ReadableStreamReadResult<R>>} */ /** @returns {Promise<ReadableStreamReadResult<R>>} */
read() { read() {
try { try {
webidl.assertBranded(this, ReadableStreamDefaultReaderPrototype); webidl.assertBranded(this, ReadableStreamDefaultReader);
} catch (err) { } catch (err) {
return PromiseReject(err); return PromiseReject(err);
} }
@ -4590,7 +4556,7 @@
/** @returns {void} */ /** @returns {void} */
releaseLock() { releaseLock() {
webidl.assertBranded(this, ReadableStreamDefaultReaderPrototype); webidl.assertBranded(this, ReadableStreamDefaultReader);
if (this[_stream] === undefined) { if (this[_stream] === undefined) {
return; return;
} }
@ -4599,7 +4565,7 @@
get closed() { get closed() {
try { try {
webidl.assertBranded(this, ReadableStreamDefaultReaderPrototype); webidl.assertBranded(this, ReadableStreamDefaultReader);
} catch (err) { } catch (err) {
return PromiseReject(err); return PromiseReject(err);
} }
@ -4612,7 +4578,7 @@
*/ */
cancel(reason = undefined) { cancel(reason = undefined) {
try { try {
webidl.assertBranded(this, ReadableStreamDefaultReaderPrototype); webidl.assertBranded(this, ReadableStreamDefaultReader);
if (reason !== undefined) { if (reason !== undefined) {
reason = webidl.converters.any(reason); reason = webidl.converters.any(reason);
} }
@ -4634,8 +4600,6 @@
} }
webidl.configurePrototype(ReadableStreamDefaultReader); webidl.configurePrototype(ReadableStreamDefaultReader);
const ReadableStreamDefaultReaderPrototype =
ReadableStreamDefaultReader.prototype;
/** @template R */ /** @template R */
class ReadableStreamBYOBReader { class ReadableStreamBYOBReader {
@ -4664,7 +4628,7 @@
*/ */
read(view) { read(view) {
try { try {
webidl.assertBranded(this, ReadableStreamBYOBReaderPrototype); webidl.assertBranded(this, ReadableStreamBYOBReader);
const prefix = "Failed to execute 'read' on 'ReadableStreamBYOBReader'"; const prefix = "Failed to execute 'read' on 'ReadableStreamBYOBReader'";
view = webidl.converters.ArrayBufferView(view, { view = webidl.converters.ArrayBufferView(view, {
prefix, prefix,
@ -4714,7 +4678,7 @@
/** @returns {void} */ /** @returns {void} */
releaseLock() { releaseLock() {
webidl.assertBranded(this, ReadableStreamBYOBReaderPrototype); webidl.assertBranded(this, ReadableStreamBYOBReader);
if (this[_stream] === undefined) { if (this[_stream] === undefined) {
return; return;
} }
@ -4723,7 +4687,7 @@
get closed() { get closed() {
try { try {
webidl.assertBranded(this, ReadableStreamBYOBReaderPrototype); webidl.assertBranded(this, ReadableStreamBYOBReader);
} catch (err) { } catch (err) {
return PromiseReject(err); return PromiseReject(err);
} }
@ -4736,7 +4700,7 @@
*/ */
cancel(reason = undefined) { cancel(reason = undefined) {
try { try {
webidl.assertBranded(this, ReadableStreamBYOBReaderPrototype); webidl.assertBranded(this, ReadableStreamBYOBReader);
if (reason !== undefined) { if (reason !== undefined) {
reason = webidl.converters.any(reason); reason = webidl.converters.any(reason);
} }
@ -4758,7 +4722,6 @@
} }
webidl.configurePrototype(ReadableStreamBYOBReader); webidl.configurePrototype(ReadableStreamBYOBReader);
const ReadableStreamBYOBReaderPrototype = ReadableStreamBYOBReader.prototype;
class ReadableStreamBYOBRequest { class ReadableStreamBYOBRequest {
/** @type {ReadableByteStreamController} */ /** @type {ReadableByteStreamController} */
@ -4768,7 +4731,7 @@
/** @returns {ArrayBufferView | null} */ /** @returns {ArrayBufferView | null} */
get view() { get view() {
webidl.assertBranded(this, ReadableStreamBYOBRequestPrototype); webidl.assertBranded(this, ReadableStreamBYOBRequest);
return this[_view]; return this[_view];
} }
@ -4777,7 +4740,7 @@
} }
respond(bytesWritten) { respond(bytesWritten) {
webidl.assertBranded(this, ReadableStreamBYOBRequestPrototype); webidl.assertBranded(this, ReadableStreamBYOBRequest);
const prefix = const prefix =
"Failed to execute 'respond' on 'ReadableStreamBYOBRequest'"; "Failed to execute 'respond' on 'ReadableStreamBYOBRequest'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
@ -4801,7 +4764,7 @@
} }
respondWithNewView(view) { respondWithNewView(view) {
webidl.assertBranded(this, ReadableStreamBYOBRequestPrototype); webidl.assertBranded(this, ReadableStreamBYOBRequest);
const prefix = const prefix =
"Failed to execute 'respondWithNewView' on 'ReadableStreamBYOBRequest'"; "Failed to execute 'respondWithNewView' on 'ReadableStreamBYOBRequest'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
@ -4823,8 +4786,6 @@
} }
webidl.configurePrototype(ReadableStreamBYOBRequest); webidl.configurePrototype(ReadableStreamBYOBRequest);
const ReadableStreamBYOBRequestPrototype =
ReadableStreamBYOBRequest.prototype;
class ReadableByteStreamController { class ReadableByteStreamController {
/** @type {number | undefined} */ /** @type {number | undefined} */
@ -4860,19 +4821,19 @@
/** @returns {ReadableStreamBYOBRequest | null} */ /** @returns {ReadableStreamBYOBRequest | null} */
get byobRequest() { get byobRequest() {
webidl.assertBranded(this, ReadableByteStreamControllerPrototype); webidl.assertBranded(this, ReadableByteStreamController);
return readableByteStreamControllerGetBYOBRequest(this); return readableByteStreamControllerGetBYOBRequest(this);
} }
/** @returns {number | null} */ /** @returns {number | null} */
get desiredSize() { get desiredSize() {
webidl.assertBranded(this, ReadableByteStreamControllerPrototype); webidl.assertBranded(this, ReadableByteStreamController);
return readableByteStreamControllerGetDesiredSize(this); return readableByteStreamControllerGetDesiredSize(this);
} }
/** @returns {void} */ /** @returns {void} */
close() { close() {
webidl.assertBranded(this, ReadableByteStreamControllerPrototype); webidl.assertBranded(this, ReadableByteStreamController);
if (this[_closeRequested] === true) { if (this[_closeRequested] === true) {
throw new TypeError("Closed already requested."); throw new TypeError("Closed already requested.");
} }
@ -4889,7 +4850,7 @@
* @returns {void} * @returns {void}
*/ */
enqueue(chunk) { enqueue(chunk) {
webidl.assertBranded(this, ReadableByteStreamControllerPrototype); webidl.assertBranded(this, ReadableByteStreamController);
const prefix = const prefix =
"Failed to execute 'enqueue' on 'ReadableByteStreamController'"; "Failed to execute 'enqueue' on 'ReadableByteStreamController'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
@ -4929,7 +4890,7 @@
* @returns {void} * @returns {void}
*/ */
error(e = undefined) { error(e = undefined) {
webidl.assertBranded(this, ReadableByteStreamControllerPrototype); webidl.assertBranded(this, ReadableByteStreamController);
if (e !== undefined) { if (e !== undefined) {
e = webidl.converters.any(e); e = webidl.converters.any(e);
} }
@ -4939,10 +4900,7 @@
[SymbolFor("Deno.customInspect")](inspect) { [SymbolFor("Deno.customInspect")](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf( evaluate: this instanceof ReadableByteStreamController,
ReadableByteStreamControllerPrototype,
this,
),
keys: ["desiredSize"], keys: ["desiredSize"],
})); }));
} }
@ -5009,8 +4967,6 @@
} }
webidl.configurePrototype(ReadableByteStreamController); webidl.configurePrototype(ReadableByteStreamController);
const ReadableByteStreamControllerPrototype =
ReadableByteStreamController.prototype;
/** @template R */ /** @template R */
class ReadableStreamDefaultController { class ReadableStreamDefaultController {
@ -5043,13 +4999,13 @@
/** @returns {number | null} */ /** @returns {number | null} */
get desiredSize() { get desiredSize() {
webidl.assertBranded(this, ReadableStreamDefaultControllerPrototype); webidl.assertBranded(this, ReadableStreamDefaultController);
return readableStreamDefaultControllerGetDesiredSize(this); return readableStreamDefaultControllerGetDesiredSize(this);
} }
/** @returns {void} */ /** @returns {void} */
close() { close() {
webidl.assertBranded(this, ReadableStreamDefaultControllerPrototype); webidl.assertBranded(this, ReadableStreamDefaultController);
if (readableStreamDefaultControllerCanCloseOrEnqueue(this) === false) { if (readableStreamDefaultControllerCanCloseOrEnqueue(this) === false) {
throw new TypeError("The stream controller cannot close or enqueue."); throw new TypeError("The stream controller cannot close or enqueue.");
} }
@ -5061,7 +5017,7 @@
* @returns {void} * @returns {void}
*/ */
enqueue(chunk = undefined) { enqueue(chunk = undefined) {
webidl.assertBranded(this, ReadableStreamDefaultControllerPrototype); webidl.assertBranded(this, ReadableStreamDefaultController);
if (chunk !== undefined) { if (chunk !== undefined) {
chunk = webidl.converters.any(chunk); chunk = webidl.converters.any(chunk);
} }
@ -5076,7 +5032,7 @@
* @returns {void} * @returns {void}
*/ */
error(e = undefined) { error(e = undefined) {
webidl.assertBranded(this, ReadableStreamDefaultControllerPrototype); webidl.assertBranded(this, ReadableStreamDefaultController);
if (e !== undefined) { if (e !== undefined) {
e = webidl.converters.any(e); e = webidl.converters.any(e);
} }
@ -5086,10 +5042,7 @@
[SymbolFor("Deno.customInspect")](inspect) { [SymbolFor("Deno.customInspect")](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf( evaluate: this instanceof ReadableStreamDefaultController,
ReadableStreamDefaultController.prototype,
this,
),
keys: ["desiredSize"], keys: ["desiredSize"],
})); }));
} }
@ -5132,8 +5085,6 @@
} }
webidl.configurePrototype(ReadableStreamDefaultController); webidl.configurePrototype(ReadableStreamDefaultController);
const ReadableStreamDefaultControllerPrototype =
ReadableStreamDefaultController.prototype;
/** /**
* @template I * @template I
@ -5235,13 +5186,13 @@
/** @returns {ReadableStream<O>} */ /** @returns {ReadableStream<O>} */
get readable() { get readable() {
webidl.assertBranded(this, TransformStreamPrototype); webidl.assertBranded(this, TransformStream);
return this[_readable]; return this[_readable];
} }
/** @returns {WritableStream<I>} */ /** @returns {WritableStream<I>} */
get writable() { get writable() {
webidl.assertBranded(this, TransformStreamPrototype); webidl.assertBranded(this, TransformStream);
return this[_writable]; return this[_writable];
} }
@ -5253,7 +5204,6 @@
} }
webidl.configurePrototype(TransformStream); webidl.configurePrototype(TransformStream);
const TransformStreamPrototype = TransformStream.prototype;
/** @template O */ /** @template O */
class TransformStreamDefaultController { class TransformStreamDefaultController {
@ -5270,7 +5220,7 @@
/** @returns {number | null} */ /** @returns {number | null} */
get desiredSize() { get desiredSize() {
webidl.assertBranded(this, TransformStreamDefaultController.prototype); webidl.assertBranded(this, TransformStreamDefaultController);
const readableController = this[_stream][_readable][_controller]; const readableController = this[_stream][_readable][_controller];
return readableStreamDefaultControllerGetDesiredSize( return readableStreamDefaultControllerGetDesiredSize(
/** @type {ReadableStreamDefaultController<O>} */ readableController, /** @type {ReadableStreamDefaultController<O>} */ readableController,
@ -5282,7 +5232,7 @@
* @returns {void} * @returns {void}
*/ */
enqueue(chunk = undefined) { enqueue(chunk = undefined) {
webidl.assertBranded(this, TransformStreamDefaultController.prototype); webidl.assertBranded(this, TransformStreamDefaultController);
if (chunk !== undefined) { if (chunk !== undefined) {
chunk = webidl.converters.any(chunk); chunk = webidl.converters.any(chunk);
} }
@ -5294,7 +5244,7 @@
* @returns {void} * @returns {void}
*/ */
error(reason = undefined) { error(reason = undefined) {
webidl.assertBranded(this, TransformStreamDefaultController.prototype); webidl.assertBranded(this, TransformStreamDefaultController);
if (reason !== undefined) { if (reason !== undefined) {
reason = webidl.converters.any(reason); reason = webidl.converters.any(reason);
} }
@ -5303,25 +5253,20 @@
/** @returns {void} */ /** @returns {void} */
terminate() { terminate() {
webidl.assertBranded(this, TransformStreamDefaultControllerPrototype); webidl.assertBranded(this, TransformStreamDefaultController);
transformStreamDefaultControllerTerminate(this); transformStreamDefaultControllerTerminate(this);
} }
[SymbolFor("Deno.customInspect")](inspect) { [SymbolFor("Deno.customInspect")](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf( evaluate: this instanceof TransformStreamDefaultController,
TransformStreamDefaultController.prototype,
this,
),
keys: ["desiredSize"], keys: ["desiredSize"],
})); }));
} }
} }
webidl.configurePrototype(TransformStreamDefaultController); webidl.configurePrototype(TransformStreamDefaultController);
const TransformStreamDefaultControllerPrototype =
TransformStreamDefaultController.prototype;
/** @template W */ /** @template W */
class WritableStream { class WritableStream {
@ -5391,7 +5336,7 @@
/** @returns {boolean} */ /** @returns {boolean} */
get locked() { get locked() {
webidl.assertBranded(this, WritableStreamPrototype); webidl.assertBranded(this, WritableStream);
return isWritableStreamLocked(this); return isWritableStreamLocked(this);
} }
@ -5401,7 +5346,7 @@
*/ */
abort(reason = undefined) { abort(reason = undefined) {
try { try {
webidl.assertBranded(this, WritableStreamPrototype); webidl.assertBranded(this, WritableStream);
} catch (err) { } catch (err) {
return PromiseReject(err); return PromiseReject(err);
} }
@ -5421,7 +5366,7 @@
/** @returns {Promise<void>} */ /** @returns {Promise<void>} */
close() { close() {
try { try {
webidl.assertBranded(this, WritableStreamPrototype); webidl.assertBranded(this, WritableStream);
} catch (err) { } catch (err) {
return PromiseReject(err); return PromiseReject(err);
} }
@ -5442,7 +5387,7 @@
/** @returns {WritableStreamDefaultWriter<W>} */ /** @returns {WritableStreamDefaultWriter<W>} */
getWriter() { getWriter() {
webidl.assertBranded(this, WritableStreamPrototype); webidl.assertBranded(this, WritableStream);
return acquireWritableStreamDefaultWriter(this); return acquireWritableStreamDefaultWriter(this);
} }
@ -5452,7 +5397,6 @@
} }
webidl.configurePrototype(WritableStream); webidl.configurePrototype(WritableStream);
const WritableStreamPrototype = WritableStream.prototype;
/** @template W */ /** @template W */
class WritableStreamDefaultWriter { class WritableStreamDefaultWriter {
@ -5482,7 +5426,7 @@
/** @returns {Promise<void>} */ /** @returns {Promise<void>} */
get closed() { get closed() {
try { try {
webidl.assertBranded(this, WritableStreamDefaultWriterPrototype); webidl.assertBranded(this, WritableStreamDefaultWriter);
} catch (err) { } catch (err) {
return PromiseReject(err); return PromiseReject(err);
} }
@ -5491,7 +5435,7 @@
/** @returns {number} */ /** @returns {number} */
get desiredSize() { get desiredSize() {
webidl.assertBranded(this, WritableStreamDefaultWriterPrototype); webidl.assertBranded(this, WritableStreamDefaultWriter);
if (this[_stream] === undefined) { if (this[_stream] === undefined) {
throw new TypeError( throw new TypeError(
"A writable stream is not associated with the writer.", "A writable stream is not associated with the writer.",
@ -5503,7 +5447,7 @@
/** @returns {Promise<void>} */ /** @returns {Promise<void>} */
get ready() { get ready() {
try { try {
webidl.assertBranded(this, WritableStreamDefaultWriterPrototype); webidl.assertBranded(this, WritableStreamDefaultWriter);
} catch (err) { } catch (err) {
return PromiseReject(err); return PromiseReject(err);
} }
@ -5516,7 +5460,7 @@
*/ */
abort(reason = undefined) { abort(reason = undefined) {
try { try {
webidl.assertBranded(this, WritableStreamDefaultWriterPrototype); webidl.assertBranded(this, WritableStreamDefaultWriter);
} catch (err) { } catch (err) {
return PromiseReject(err); return PromiseReject(err);
} }
@ -5534,7 +5478,7 @@
/** @returns {Promise<void>} */ /** @returns {Promise<void>} */
close() { close() {
try { try {
webidl.assertBranded(this, WritableStreamDefaultWriterPrototype); webidl.assertBranded(this, WritableStreamDefaultWriter);
} catch (err) { } catch (err) {
return PromiseReject(err); return PromiseReject(err);
} }
@ -5554,7 +5498,7 @@
/** @returns {void} */ /** @returns {void} */
releaseLock() { releaseLock() {
webidl.assertBranded(this, WritableStreamDefaultWriterPrototype); webidl.assertBranded(this, WritableStreamDefaultWriter);
const stream = this[_stream]; const stream = this[_stream];
if (stream === undefined) { if (stream === undefined) {
return; return;
@ -5569,7 +5513,7 @@
*/ */
write(chunk = undefined) { write(chunk = undefined) {
try { try {
webidl.assertBranded(this, WritableStreamDefaultWriterPrototype); webidl.assertBranded(this, WritableStreamDefaultWriter);
if (chunk !== undefined) { if (chunk !== undefined) {
chunk = webidl.converters.any(chunk); chunk = webidl.converters.any(chunk);
} }
@ -5587,10 +5531,7 @@
[SymbolFor("Deno.customInspect")](inspect) { [SymbolFor("Deno.customInspect")](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf( evaluate: this instanceof WritableStreamDefaultWriter,
WritableStreamDefaultWriter.prototype,
this,
),
keys: [ keys: [
"closed", "closed",
"desiredSize", "desiredSize",
@ -5601,8 +5542,6 @@
} }
webidl.configurePrototype(WritableStreamDefaultWriter); webidl.configurePrototype(WritableStreamDefaultWriter);
const WritableStreamDefaultWriterPrototype =
WritableStreamDefaultWriter.prototype;
/** @template W */ /** @template W */
class WritableStreamDefaultController { class WritableStreamDefaultController {
@ -5628,7 +5567,7 @@
[_signal]; [_signal];
get signal() { get signal() {
webidl.assertBranded(this, WritableStreamDefaultControllerPrototype); webidl.assertBranded(this, WritableStreamDefaultController);
return this[_signal]; return this[_signal];
} }
@ -5641,7 +5580,7 @@
* @returns {void} * @returns {void}
*/ */
error(e = undefined) { error(e = undefined) {
webidl.assertBranded(this, WritableStreamDefaultControllerPrototype); webidl.assertBranded(this, WritableStreamDefaultController);
if (e !== undefined) { if (e !== undefined) {
e = webidl.converters.any(e); e = webidl.converters.any(e);
} }
@ -5655,10 +5594,7 @@
[SymbolFor("Deno.customInspect")](inspect) { [SymbolFor("Deno.customInspect")](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf( evaluate: this instanceof WritableStreamDefaultController,
WritableStreamDefaultController.prototype,
this,
),
keys: [], keys: [],
})); }));
} }
@ -5679,8 +5615,6 @@
} }
webidl.configurePrototype(WritableStreamDefaultController); webidl.configurePrototype(WritableStreamDefaultController);
const WritableStreamDefaultControllerPrototype =
WritableStreamDefaultController.prototype;
/** /**
* @param {ReadableStream} stream * @param {ReadableStream} stream
@ -5690,9 +5624,9 @@
} }
webidl.converters.ReadableStream = webidl webidl.converters.ReadableStream = webidl
.createInterfaceConverter("ReadableStream", ReadableStream.prototype); .createInterfaceConverter("ReadableStream", ReadableStream);
webidl.converters.WritableStream = webidl webidl.converters.WritableStream = webidl
.createInterfaceConverter("WritableStream", WritableStream.prototype); .createInterfaceConverter("WritableStream", WritableStream);
webidl.converters.ReadableStreamType = webidl.createEnumConverter( webidl.converters.ReadableStreamType = webidl.createEnumConverter(
"ReadableStreamType", "ReadableStreamType",
@ -5853,7 +5787,6 @@
ByteLengthQueuingStrategy, ByteLengthQueuingStrategy,
CountQueuingStrategy, CountQueuingStrategy,
ReadableStream, ReadableStream,
ReadableStreamPrototype,
ReadableStreamDefaultReader, ReadableStreamDefaultReader,
TransformStream, TransformStream,
WritableStream, WritableStream,

42
ext/web/08_text_encoding.js
View file

@ -16,7 +16,6 @@
const webidl = window.__bootstrap.webidl; const webidl = window.__bootstrap.webidl;
const { const {
ArrayBufferIsView, ArrayBufferIsView,
ObjectPrototypeIsPrototypeOf,
PromiseReject, PromiseReject,
PromiseResolve, PromiseResolve,
StringPrototypeCharCodeAt, StringPrototypeCharCodeAt,
@ -60,19 +59,19 @@
/** @returns {string} */ /** @returns {string} */
get encoding() { get encoding() {
webidl.assertBranded(this, TextDecoderPrototype); webidl.assertBranded(this, TextDecoder);
return this.#encoding; return this.#encoding;
} }
/** @returns {boolean} */ /** @returns {boolean} */
get fatal() { get fatal() {
webidl.assertBranded(this, TextDecoderPrototype); webidl.assertBranded(this, TextDecoder);
return this.#fatal; return this.#fatal;
} }
/** @returns {boolean} */ /** @returns {boolean} */
get ignoreBOM() { get ignoreBOM() {
webidl.assertBranded(this, TextDecoderPrototype); webidl.assertBranded(this, TextDecoder);
return this.#ignoreBOM; return this.#ignoreBOM;
} }
@ -81,7 +80,7 @@
* @param {TextDecodeOptions} options * @param {TextDecodeOptions} options
*/ */
decode(input = new Uint8Array(), options = {}) { decode(input = new Uint8Array(), options = {}) {
webidl.assertBranded(this, TextDecoderPrototype); webidl.assertBranded(this, TextDecoder);
const prefix = "Failed to execute 'decode' on 'TextDecoder'"; const prefix = "Failed to execute 'decode' on 'TextDecoder'";
if (input !== undefined) { if (input !== undefined) {
input = webidl.converters.BufferSource(input, { input = webidl.converters.BufferSource(input, {
@ -120,12 +119,7 @@
// If the buffer is detached, just create a new empty Uint8Array. // If the buffer is detached, just create a new empty Uint8Array.
input = new Uint8Array(); input = new Uint8Array();
} }
if ( if (input.buffer instanceof SharedArrayBuffer) {
ObjectPrototypeIsPrototypeOf(
SharedArrayBuffer.prototype,
input.buffer,
)
) {
// We clone the data into a non-shared ArrayBuffer so we can pass it // We clone the data into a non-shared ArrayBuffer so we can pass it
// to Rust. // to Rust.
// `input` is now a Uint8Array, and calling the TypedArray constructor // `input` is now a Uint8Array, and calling the TypedArray constructor
@ -146,7 +140,6 @@
} }
webidl.configurePrototype(TextDecoder); webidl.configurePrototype(TextDecoder);
const TextDecoderPrototype = TextDecoder.prototype;
class TextEncoder { class TextEncoder {
constructor() { constructor() {
@ -155,7 +148,7 @@
/** @returns {string} */ /** @returns {string} */
get encoding() { get encoding() {
webidl.assertBranded(this, TextEncoderPrototype); webidl.assertBranded(this, TextEncoder);
return "utf-8"; return "utf-8";
} }
@ -164,7 +157,7 @@
* @returns {Uint8Array} * @returns {Uint8Array}
*/ */
encode(input = "") { encode(input = "") {
webidl.assertBranded(this, TextEncoderPrototype); webidl.assertBranded(this, TextEncoder);
const prefix = "Failed to execute 'encode' on 'TextEncoder'"; const prefix = "Failed to execute 'encode' on 'TextEncoder'";
// The WebIDL type of `input` is `USVString`, but `core.encode` already // The WebIDL type of `input` is `USVString`, but `core.encode` already
// converts lone surrogates to the replacement character. // converts lone surrogates to the replacement character.
@ -181,7 +174,7 @@
* @returns {TextEncoderEncodeIntoResult} * @returns {TextEncoderEncodeIntoResult}
*/ */
encodeInto(source, destination) { encodeInto(source, destination) {
webidl.assertBranded(this, TextEncoderPrototype); webidl.assertBranded(this, TextEncoder);
const prefix = "Failed to execute 'encodeInto' on 'TextEncoder'"; const prefix = "Failed to execute 'encodeInto' on 'TextEncoder'";
// The WebIDL type of `source` is `USVString`, but the ops bindings // The WebIDL type of `source` is `USVString`, but the ops bindings
// already convert lone surrogates to the replacement character. // already convert lone surrogates to the replacement character.
@ -199,7 +192,6 @@
} }
webidl.configurePrototype(TextEncoder); webidl.configurePrototype(TextEncoder);
const TextEncoderPrototype = TextEncoder.prototype;
class TextDecoderStream { class TextDecoderStream {
/** @type {TextDecoder} */ /** @type {TextDecoder} */
@ -256,37 +248,36 @@
/** @returns {string} */ /** @returns {string} */
get encoding() { get encoding() {
webidl.assertBranded(this, TextDecoderStreamPrototype); webidl.assertBranded(this, TextDecoderStream);
return this.#decoder.encoding; return this.#decoder.encoding;
} }
/** @returns {boolean} */ /** @returns {boolean} */
get fatal() { get fatal() {
webidl.assertBranded(this, TextDecoderStreamPrototype); webidl.assertBranded(this, TextDecoderStream);
return this.#decoder.fatal; return this.#decoder.fatal;
} }
/** @returns {boolean} */ /** @returns {boolean} */
get ignoreBOM() { get ignoreBOM() {
webidl.assertBranded(this, TextDecoderStreamPrototype); webidl.assertBranded(this, TextDecoderStream);
return this.#decoder.ignoreBOM; return this.#decoder.ignoreBOM;
} }
/** @returns {ReadableStream<string>} */ /** @returns {ReadableStream<string>} */
get readable() { get readable() {
webidl.assertBranded(this, TextDecoderStreamPrototype); webidl.assertBranded(this, TextDecoderStream);
return this.#transform.readable; return this.#transform.readable;
} }
/** @returns {WritableStream<BufferSource>} */ /** @returns {WritableStream<BufferSource>} */
get writable() { get writable() {
webidl.assertBranded(this, TextDecoderStreamPrototype); webidl.assertBranded(this, TextDecoderStream);
return this.#transform.writable; return this.#transform.writable;
} }
} }
webidl.configurePrototype(TextDecoderStream); webidl.configurePrototype(TextDecoderStream);
const TextDecoderStreamPrototype = TextDecoderStream.prototype;
class TextEncoderStream { class TextEncoderStream {
/** @type {string | null} */ /** @type {string | null} */
@ -341,25 +332,24 @@
/** @returns {string} */ /** @returns {string} */
get encoding() { get encoding() {
webidl.assertBranded(this, TextEncoderStreamPrototype); webidl.assertBranded(this, TextEncoderStream);
return "utf-8"; return "utf-8";
} }
/** @returns {ReadableStream<Uint8Array>} */ /** @returns {ReadableStream<Uint8Array>} */
get readable() { get readable() {
webidl.assertBranded(this, TextEncoderStreamPrototype); webidl.assertBranded(this, TextEncoderStream);
return this.#transform.readable; return this.#transform.readable;
} }
/** @returns {WritableStream<string>} */ /** @returns {WritableStream<string>} */
get writable() { get writable() {
webidl.assertBranded(this, TextEncoderStreamPrototype); webidl.assertBranded(this, TextEncoderStream);
return this.#transform.writable; return this.#transform.writable;
} }
} }
webidl.configurePrototype(TextEncoderStream); webidl.configurePrototype(TextEncoderStream);
const TextEncoderStreamPrototype = TextEncoderStream.prototype;
webidl.converters.TextDecoderOptions = webidl.createDictionaryConverter( webidl.converters.TextDecoderOptions = webidl.createDictionaryConverter(
"TextDecoderOptions", "TextDecoderOptions",

43
ext/web/09_file.js
View file

@ -15,7 +15,7 @@
const core = window.Deno.core; const core = window.Deno.core;
const webidl = window.__bootstrap.webidl; const webidl = window.__bootstrap.webidl;
const { const {
ArrayBufferPrototype, ArrayBuffer,
ArrayBufferPrototypeSlice, ArrayBufferPrototypeSlice,
ArrayBufferIsView, ArrayBufferIsView,
ArrayPrototypePush, ArrayPrototypePush,
@ -23,7 +23,6 @@
DatePrototypeGetTime, DatePrototypeGetTime,
MathMax, MathMax,
MathMin, MathMin,
ObjectPrototypeIsPrototypeOf,
RegExpPrototypeTest, RegExpPrototypeTest,
StringPrototypeCharAt, StringPrototypeCharAt,
StringPrototypeToLowerCase, StringPrototypeToLowerCase,
@ -110,7 +109,7 @@
const processedParts = []; const processedParts = [];
let size = 0; let size = 0;
for (const element of parts) { for (const element of parts) {
if (ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, element)) { if (element instanceof ArrayBuffer) {
const chunk = new Uint8Array(ArrayBufferPrototypeSlice(element, 0)); const chunk = new Uint8Array(ArrayBufferPrototypeSlice(element, 0));
ArrayPrototypePush(processedParts, BlobReference.fromUint8Array(chunk)); ArrayPrototypePush(processedParts, BlobReference.fromUint8Array(chunk));
size += element.byteLength; size += element.byteLength;
@ -122,7 +121,7 @@
); );
size += element.byteLength; size += element.byteLength;
ArrayPrototypePush(processedParts, BlobReference.fromUint8Array(chunk)); ArrayPrototypePush(processedParts, BlobReference.fromUint8Array(chunk));
} else if (ObjectPrototypeIsPrototypeOf(BlobPrototype, element)) { } else if (element instanceof Blob) {
ArrayPrototypePush(processedParts, element); ArrayPrototypePush(processedParts, element);
size += element.size; size += element.size;
} else if (typeof element === "string") { } else if (typeof element === "string") {
@ -158,7 +157,7 @@
*/ */
function getParts(blob, bag = []) { function getParts(blob, bag = []) {
for (const part of blob[_parts]) { for (const part of blob[_parts]) {
if (ObjectPrototypeIsPrototypeOf(BlobPrototype, part)) { if (part instanceof Blob) {
getParts(part, bag); getParts(part, bag);
} else { } else {
ArrayPrototypePush(bag, part._id); ArrayPrototypePush(bag, part._id);
@ -205,13 +204,13 @@
/** @returns {number} */ /** @returns {number} */
get size() { get size() {
webidl.assertBranded(this, BlobPrototype); webidl.assertBranded(this, Blob);
return this[_size]; return this[_size];
} }
/** @returns {string} */ /** @returns {string} */
get type() { get type() {
webidl.assertBranded(this, BlobPrototype); webidl.assertBranded(this, Blob);
return this[_type]; return this[_type];
} }
@ -222,7 +221,7 @@
* @returns {Blob} * @returns {Blob}
*/ */
slice(start = undefined, end = undefined, contentType = undefined) { slice(start = undefined, end = undefined, contentType = undefined) {
webidl.assertBranded(this, BlobPrototype); webidl.assertBranded(this, Blob);
const prefix = "Failed to execute 'slice' on 'Blob'"; const prefix = "Failed to execute 'slice' on 'Blob'";
if (start !== undefined) { if (start !== undefined) {
start = webidl.converters["long long"](start, { start = webidl.converters["long long"](start, {
@ -317,7 +316,7 @@
* @returns {ReadableStream<Uint8Array>} * @returns {ReadableStream<Uint8Array>}
*/ */
stream() { stream() {
webidl.assertBranded(this, BlobPrototype); webidl.assertBranded(this, Blob);
const partIterator = toIterator(this[_parts]); const partIterator = toIterator(this[_parts]);
const stream = new ReadableStream({ const stream = new ReadableStream({
type: "bytes", type: "bytes",
@ -339,7 +338,7 @@
* @returns {Promise<string>} * @returns {Promise<string>}
*/ */
async text() { async text() {
webidl.assertBranded(this, BlobPrototype); webidl.assertBranded(this, Blob);
const buffer = await this.arrayBuffer(); const buffer = await this.arrayBuffer();
return core.decode(new Uint8Array(buffer)); return core.decode(new Uint8Array(buffer));
} }
@ -348,7 +347,7 @@
* @returns {Promise<ArrayBuffer>} * @returns {Promise<ArrayBuffer>}
*/ */
async arrayBuffer() { async arrayBuffer() {
webidl.assertBranded(this, BlobPrototype); webidl.assertBranded(this, Blob);
const stream = this.stream(); const stream = this.stream();
const bytes = new Uint8Array(this.size); const bytes = new Uint8Array(this.size);
let offset = 0; let offset = 0;
@ -362,7 +361,7 @@
[SymbolFor("Deno.customInspect")](inspect) { [SymbolFor("Deno.customInspect")](inspect) {
return inspect(consoleInternal.createFilteredInspectProxy({ return inspect(consoleInternal.createFilteredInspectProxy({
object: this, object: this,
evaluate: ObjectPrototypeIsPrototypeOf(BlobPrototype, this), evaluate: this instanceof Blob,
keys: [ keys: [
"size", "size",
"type", "type",
@ -372,22 +371,15 @@
} }
webidl.configurePrototype(Blob); webidl.configurePrototype(Blob);
const BlobPrototype = Blob.prototype;
webidl.converters["Blob"] = webidl.createInterfaceConverter( webidl.converters["Blob"] = webidl.createInterfaceConverter("Blob", Blob);
"Blob",
Blob.prototype,
);
webidl.converters["BlobPart"] = (V, opts) => { webidl.converters["BlobPart"] = (V, opts) => {
// Union for ((ArrayBuffer or ArrayBufferView) or Blob or USVString) // Union for ((ArrayBuffer or ArrayBufferView) or Blob or USVString)
if (typeof V == "object") { if (typeof V == "object") {
if (ObjectPrototypeIsPrototypeOf(BlobPrototype, V)) { if (V instanceof Blob) {
return webidl.converters["Blob"](V, opts); return webidl.converters["Blob"](V, opts);
} }
if ( if (V instanceof ArrayBuffer || V instanceof SharedArrayBuffer) {
ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, V) ||
ObjectPrototypeIsPrototypeOf(SharedArrayBuffer.prototype, V)
) {
return webidl.converters["ArrayBuffer"](V, opts); return webidl.converters["ArrayBuffer"](V, opts);
} }
if (ArrayBufferIsView(V)) { if (ArrayBufferIsView(V)) {
@ -466,19 +458,18 @@
/** @returns {string} */ /** @returns {string} */
get name() { get name() {
webidl.assertBranded(this, FilePrototype); webidl.assertBranded(this, File);
return this[_Name]; return this[_Name];
} }
/** @returns {number} */ /** @returns {number} */
get lastModified() { get lastModified() {
webidl.assertBranded(this, FilePrototype); webidl.assertBranded(this, File);
return this[_LastModified]; return this[_LastModified];
} }
} }
webidl.configurePrototype(File); webidl.configurePrototype(File);
const FilePrototype = File.prototype;
webidl.converters["FilePropertyBag"] = webidl.createDictionaryConverter( webidl.converters["FilePropertyBag"] = webidl.createDictionaryConverter(
"FilePropertyBag", "FilePropertyBag",
@ -602,8 +593,6 @@
blobFromObjectUrl, blobFromObjectUrl,
getParts, getParts,
Blob, Blob,
BlobPrototype,
File, File,
FilePrototype,
}; };
})(this); })(this);

28
ext/web/10_filereader.js
View file

@ -28,14 +28,12 @@
MapPrototypeGet, MapPrototypeGet,
MapPrototypeSet, MapPrototypeSet,
ObjectDefineProperty, ObjectDefineProperty,
ObjectPrototypeIsPrototypeOf,
queueMicrotask, queueMicrotask,
StringFromCodePoint, StringFromCodePoint,
Symbol, Symbol,
TypedArrayPrototypeSet, TypedArrayPrototypeSet,
TypeError, TypeError,
Uint8Array, Uint8Array,
Uint8ArrayPrototype,
} = window.__bootstrap.primordials; } = window.__bootstrap.primordials;
const state = Symbol("[[state]]"); const state = Symbol("[[state]]");
@ -118,10 +116,7 @@
// 4. If chunkPromise is fulfilled with an object whose done property is false // 4. If chunkPromise is fulfilled with an object whose done property is false
// and whose value property is a Uint8Array object, run these steps: // and whose value property is a Uint8Array object, run these steps:
if ( if (!chunk.done && chunk.value instanceof Uint8Array) {
!chunk.done &&
ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, chunk.value)
) {
ArrayPrototypePush(chunks, chunk.value); ArrayPrototypePush(chunks, chunk.value);
// TODO(bartlomieju): (only) If roughly 50ms have passed since last progress // TODO(bartlomieju): (only) If roughly 50ms have passed since last progress
@ -265,7 +260,7 @@
} }
#getEventHandlerFor(name) { #getEventHandlerFor(name) {
webidl.assertBranded(this, FileReaderPrototype); webidl.assertBranded(this, FileReader);
const maybeMap = this[handlerSymbol]; const maybeMap = this[handlerSymbol];
if (!maybeMap) return null; if (!maybeMap) return null;
@ -274,7 +269,7 @@
} }
#setEventHandlerFor(name, value) { #setEventHandlerFor(name, value) {
webidl.assertBranded(this, FileReaderPrototype); webidl.assertBranded(this, FileReader);
if (!this[handlerSymbol]) { if (!this[handlerSymbol]) {
this[handlerSymbol] = new Map(); this[handlerSymbol] = new Map();
@ -297,7 +292,7 @@
/** @returns {number} */ /** @returns {number} */
get readyState() { get readyState() {
webidl.assertBranded(this, FileReaderPrototype); webidl.assertBranded(this, FileReader);
switch (this[state]) { switch (this[state]) {
case "empty": case "empty":
return FileReader.EMPTY; return FileReader.EMPTY;
@ -311,17 +306,17 @@
} }
get result() { get result() {
webidl.assertBranded(this, FileReaderPrototype); webidl.assertBranded(this, FileReader);
return this[result]; return this[result];
} }
get error() { get error() {
webidl.assertBranded(this, FileReaderPrototype); webidl.assertBranded(this, FileReader);
return this[error]; return this[error];
} }
abort() { abort() {
webidl.assertBranded(this, FileReaderPrototype); webidl.assertBranded(this, FileReader);
// If context object's state is "empty" or if context object's state is "done" set context object's result to null and terminate this algorithm. // If context object's state is "empty" or if context object's state is "done" set context object's result to null and terminate this algorithm.
if ( if (
this[state] === "empty" || this[state] === "empty" ||
@ -354,7 +349,7 @@
/** @param {Blob} blob */ /** @param {Blob} blob */
readAsArrayBuffer(blob) { readAsArrayBuffer(blob) {
webidl.assertBranded(this, FileReaderPrototype); webidl.assertBranded(this, FileReader);
const prefix = "Failed to execute 'readAsArrayBuffer' on 'FileReader'"; const prefix = "Failed to execute 'readAsArrayBuffer' on 'FileReader'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
this.#readOperation(blob, { kind: "ArrayBuffer" }); this.#readOperation(blob, { kind: "ArrayBuffer" });
@ -362,7 +357,7 @@
/** @param {Blob} blob */ /** @param {Blob} blob */
readAsBinaryString(blob) { readAsBinaryString(blob) {
webidl.assertBranded(this, FileReaderPrototype); webidl.assertBranded(this, FileReader);
const prefix = "Failed to execute 'readAsBinaryString' on 'FileReader'"; const prefix = "Failed to execute 'readAsBinaryString' on 'FileReader'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
// alias for readAsArrayBuffer // alias for readAsArrayBuffer
@ -371,7 +366,7 @@
/** @param {Blob} blob */ /** @param {Blob} blob */
readAsDataURL(blob) { readAsDataURL(blob) {
webidl.assertBranded(this, FileReaderPrototype); webidl.assertBranded(this, FileReader);
const prefix = "Failed to execute 'readAsDataURL' on 'FileReader'"; const prefix = "Failed to execute 'readAsDataURL' on 'FileReader'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
// alias for readAsArrayBuffer // alias for readAsArrayBuffer
@ -383,7 +378,7 @@
* @param {string} [encoding] * @param {string} [encoding]
*/ */
readAsText(blob, encoding = undefined) { readAsText(blob, encoding = undefined) {
webidl.assertBranded(this, FileReaderPrototype); webidl.assertBranded(this, FileReader);
const prefix = "Failed to execute 'readAsText' on 'FileReader'"; const prefix = "Failed to execute 'readAsText' on 'FileReader'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
if (encoding !== undefined) { if (encoding !== undefined) {
@ -440,7 +435,6 @@
} }
webidl.configurePrototype(FileReader); webidl.configurePrototype(FileReader);
const FileReaderPrototype = FileReader.prototype;
ObjectDefineProperty(FileReader, "EMPTY", { ObjectDefineProperty(FileReader, "EMPTY", {
writable: false, writable: false,

39
ext/web/13_message_port.js
View file

@ -10,21 +10,19 @@
((window) => { ((window) => {
const core = window.Deno.core; const core = window.Deno.core;
const { InterruptedPrototype } = core; const { Interrupted } = core;
const webidl = window.__bootstrap.webidl; const webidl = window.__bootstrap.webidl;
const { setEventTargetData } = window.__bootstrap.eventTarget; const { setEventTargetData } = window.__bootstrap.eventTarget;
const { defineEventHandler } = window.__bootstrap.event; const { defineEventHandler } = window.__bootstrap.event;
const { DOMException } = window.__bootstrap.domException; const { DOMException } = window.__bootstrap.domException;
const { const {
ArrayBufferPrototype, ArrayBuffer,
ArrayPrototypeFilter, ArrayPrototypeFilter,
ArrayPrototypeIncludes, ArrayPrototypeIncludes,
ArrayPrototypePush, ArrayPrototypePush,
ObjectPrototypeIsPrototypeOf,
ObjectSetPrototypeOf, ObjectSetPrototypeOf,
Symbol, Symbol,
SymbolFor, SymbolFor,
SymbolIterator,
TypeError, TypeError,
WeakSet, WeakSet,
WeakSetPrototypeAdd, WeakSetPrototypeAdd,
@ -47,12 +45,12 @@
} }
get port1() { get port1() {
webidl.assertBranded(this, MessageChannelPrototype); webidl.assertBranded(this, MessageChannel);
return this.#port1; return this.#port1;
} }
get port2() { get port2() {
webidl.assertBranded(this, MessageChannelPrototype); webidl.assertBranded(this, MessageChannel);
return this.#port2; return this.#port2;
} }
@ -64,7 +62,6 @@
} }
webidl.configurePrototype(MessageChannel); webidl.configurePrototype(MessageChannel);
const MessageChannelPrototype = MessageChannel.prototype;
const _id = Symbol("id"); const _id = Symbol("id");
const _enabled = Symbol("enabled"); const _enabled = Symbol("enabled");
@ -75,7 +72,7 @@
*/ */
function createMessagePort(id) { function createMessagePort(id) {
const port = core.createHostObject(); const port = core.createHostObject();
ObjectSetPrototypeOf(port, MessagePortPrototype); ObjectSetPrototypeOf(port, MessagePort.prototype);
port[webidl.brand] = webidl.brand; port[webidl.brand] = webidl.brand;
setEventTargetData(port); setEventTargetData(port);
port[_id] = id; port[_id] = id;
@ -98,7 +95,7 @@
* @param {object[] | StructuredSerializeOptions} transferOrOptions * @param {object[] | StructuredSerializeOptions} transferOrOptions
*/ */
postMessage(message, transferOrOptions = {}) { postMessage(message, transferOrOptions = {}) {
webidl.assertBranded(this, MessagePortPrototype); webidl.assertBranded(this, MessagePort);
const prefix = "Failed to execute 'postMessage' on 'MessagePort'"; const prefix = "Failed to execute 'postMessage' on 'MessagePort'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
message = webidl.converters.any(message); message = webidl.converters.any(message);
@ -106,7 +103,7 @@
if ( if (
webidl.type(transferOrOptions) === "Object" && webidl.type(transferOrOptions) === "Object" &&
transferOrOptions !== undefined && transferOrOptions !== undefined &&
transferOrOptions[SymbolIterator] !== undefined transferOrOptions[Symbol.iterator] !== undefined
) { ) {
const transfer = webidl.converters["sequence<object>"]( const transfer = webidl.converters["sequence<object>"](
transferOrOptions, transferOrOptions,
@ -132,7 +129,7 @@
} }
start() { start() {
webidl.assertBranded(this, MessagePortPrototype); webidl.assertBranded(this, MessagePort);
if (this[_enabled]) return; if (this[_enabled]) return;
(async () => { (async () => {
this[_enabled] = true; this[_enabled] = true;
@ -145,7 +142,7 @@
this[_id], this[_id],
); );
} catch (err) { } catch (err) {
if (ObjectPrototypeIsPrototypeOf(InterruptedPrototype, err)) break; if (err instanceof Interrupted) break;
throw err; throw err;
} }
if (data === null) break; if (data === null) break;
@ -163,7 +160,7 @@
data: message, data: message,
ports: ArrayPrototypeFilter( ports: ArrayPrototypeFilter(
transferables, transferables,
(t) => ObjectPrototypeIsPrototypeOf(MessagePortPrototype, t), (t) => t instanceof MessagePort,
), ),
}); });
this.dispatchEvent(event); this.dispatchEvent(event);
@ -173,7 +170,7 @@
} }
close() { close() {
webidl.assertBranded(this, MessagePortPrototype); webidl.assertBranded(this, MessagePort);
if (this[_id] !== null) { if (this[_id] !== null) {
core.close(this[_id]); core.close(this[_id]);
this[_id] = null; this[_id] = null;
@ -187,7 +184,6 @@
defineEventHandler(MessagePort.prototype, "messageerror"); defineEventHandler(MessagePort.prototype, "messageerror");
webidl.configurePrototype(MessagePort); webidl.configurePrototype(MessagePort);
const MessagePortPrototype = MessagePort.prototype;
/** /**
* @returns {[number, number]} * @returns {[number, number]}
@ -249,7 +245,7 @@
function serializeJsMessageData(data, transferables) { function serializeJsMessageData(data, transferables) {
const transferedArrayBuffers = ArrayPrototypeFilter( const transferedArrayBuffers = ArrayPrototypeFilter(
transferables, transferables,
(a) => ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, a), (a) => a instanceof ArrayBuffer,
); );
for (const arrayBuffer of transferedArrayBuffers) { for (const arrayBuffer of transferedArrayBuffers) {
@ -270,7 +266,7 @@
serializedData = core.serialize(data, { serializedData = core.serialize(data, {
hostObjects: ArrayPrototypeFilter( hostObjects: ArrayPrototypeFilter(
transferables, transferables,
(a) => ObjectPrototypeIsPrototypeOf(MessagePortPrototype, a), (a) => a instanceof MessagePort,
), ),
transferedArrayBuffers, transferedArrayBuffers,
}); });
@ -283,8 +279,8 @@
let arrayBufferI = 0; let arrayBufferI = 0;
for (const transferable of transferables) { for (const transferable of transferables) {
if (ObjectPrototypeIsPrototypeOf(MessagePortPrototype, transferable)) { if (transferable instanceof MessagePort) {
webidl.assertBranded(transferable, MessagePortPrototype); webidl.assertBranded(transferable, MessagePort);
const id = transferable[_id]; const id = transferable[_id];
if (id === null) { if (id === null) {
throw new DOMException( throw new DOMException(
@ -297,9 +293,7 @@
kind: "messagePort", kind: "messagePort",
data: id, data: id,
}); });
} else if ( } else if (transferable instanceof ArrayBuffer) {
ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, transferable)
) {
ArrayPrototypePush(serializedTransferables, { ArrayPrototypePush(serializedTransferables, {
kind: "arrayBuffer", kind: "arrayBuffer",
data: transferedArrayBuffers[arrayBufferI], data: transferedArrayBuffers[arrayBufferI],
@ -345,7 +339,6 @@
window.__bootstrap.messagePort = { window.__bootstrap.messagePort = {
MessageChannel, MessageChannel,
MessagePort, MessagePort,
MessagePortPrototype,
deserializeJsMessageData, deserializeJsMessageData,
serializeJsMessageData, serializeJsMessageData,
structuredClone, structuredClone,

10
ext/web/14_compression.js
View file

@ -53,18 +53,17 @@
} }
get readable() { get readable() {
webidl.assertBranded(this, CompressionStreamPrototype); webidl.assertBranded(this, CompressionStream);
return this.#transform.readable; return this.#transform.readable;
} }
get writable() { get writable() {
webidl.assertBranded(this, CompressionStreamPrototype); webidl.assertBranded(this, CompressionStream);
return this.#transform.writable; return this.#transform.writable;
} }
} }
webidl.configurePrototype(CompressionStream); webidl.configurePrototype(CompressionStream);
const CompressionStreamPrototype = CompressionStream.prototype;
class DecompressionStream { class DecompressionStream {
#transform; #transform;
@ -99,12 +98,12 @@
} }
get readable() { get readable() {
webidl.assertBranded(this, DecompressionStreamPrototype); webidl.assertBranded(this, DecompressionStream);
return this.#transform.readable; return this.#transform.readable;
} }
get writable() { get writable() {
webidl.assertBranded(this, DecompressionStreamPrototype); webidl.assertBranded(this, DecompressionStream);
return this.#transform.writable; return this.#transform.writable;
} }
} }
@ -116,7 +115,6 @@
} }
webidl.configurePrototype(DecompressionStream); webidl.configurePrototype(DecompressionStream);
const DecompressionStreamPrototype = DecompressionStream.prototype;
window.__bootstrap.compression = { window.__bootstrap.compression = {
CompressionStream, CompressionStream,

314
ext/webgpu/01_webgpu.js
View file

File diff suppressed because it is too large Load diff

68
ext/webgpu/02_idl_types.js
View file

@ -56,13 +56,13 @@
// INTERFACE: GPUSupportedLimits // INTERFACE: GPUSupportedLimits
webidl.converters.GPUSupportedLimits = webidl.createInterfaceConverter( webidl.converters.GPUSupportedLimits = webidl.createInterfaceConverter(
"GPUSupportedLimits", "GPUSupportedLimits",
GPUSupportedLimits.prototype, GPUSupportedLimits,
); );
// INTERFACE: GPUSupportedFeatures // INTERFACE: GPUSupportedFeatures
webidl.converters.GPUSupportedFeatures = webidl.createInterfaceConverter( webidl.converters.GPUSupportedFeatures = webidl.createInterfaceConverter(
"GPUSupportedFeatures", "GPUSupportedFeatures",
GPUSupportedFeatures.prototype, GPUSupportedFeatures,
); );
// ENUM: GPUPredefinedColorSpace // ENUM: GPUPredefinedColorSpace
@ -72,7 +72,7 @@
); );
// INTERFACE: GPU // INTERFACE: GPU
webidl.converters.GPU = webidl.createInterfaceConverter("GPU", GPU.prototype); webidl.converters.GPU = webidl.createInterfaceConverter("GPU", GPU);
// ENUM: GPUPowerPreference // ENUM: GPUPowerPreference
webidl.converters["GPUPowerPreference"] = webidl.createEnumConverter( webidl.converters["GPUPowerPreference"] = webidl.createEnumConverter(
@ -104,7 +104,7 @@
// INTERFACE: GPUAdapter // INTERFACE: GPUAdapter
webidl.converters.GPUAdapter = webidl.createInterfaceConverter( webidl.converters.GPUAdapter = webidl.createInterfaceConverter(
"GPUAdapter", "GPUAdapter",
GPUAdapter.prototype, GPUAdapter,
); );
// ENUM: GPUFeatureName // ENUM: GPUFeatureName
@ -178,13 +178,13 @@
// INTERFACE: GPUDevice // INTERFACE: GPUDevice
webidl.converters.GPUDevice = webidl.createInterfaceConverter( webidl.converters.GPUDevice = webidl.createInterfaceConverter(
"GPUDevice", "GPUDevice",
GPUDevice.prototype, GPUDevice,
); );
// INTERFACE: GPUBuffer // INTERFACE: GPUBuffer
webidl.converters.GPUBuffer = webidl.createInterfaceConverter( webidl.converters.GPUBuffer = webidl.createInterfaceConverter(
"GPUBuffer", "GPUBuffer",
GPUBuffer.prototype, GPUBuffer,
); );
// TYPEDEF: GPUSize64 // TYPEDEF: GPUSize64
@ -218,7 +218,7 @@
// INTERFACE: GPUBufferUsage // INTERFACE: GPUBufferUsage
webidl.converters.GPUBufferUsage = webidl.createInterfaceConverter( webidl.converters.GPUBufferUsage = webidl.createInterfaceConverter(
"GPUBufferUsage", "GPUBufferUsage",
GPUBufferUsage.prototype, GPUBufferUsage,
); );
// TYPEDEF: GPUMapModeFlags // TYPEDEF: GPUMapModeFlags
@ -228,13 +228,13 @@
// INTERFACE: GPUMapMode // INTERFACE: GPUMapMode
webidl.converters.GPUMapMode = webidl.createInterfaceConverter( webidl.converters.GPUMapMode = webidl.createInterfaceConverter(
"GPUMapMode", "GPUMapMode",
GPUMapMode.prototype, GPUMapMode,
); );
// INTERFACE: GPUTexture // INTERFACE: GPUTexture
webidl.converters.GPUTexture = webidl.createInterfaceConverter( webidl.converters.GPUTexture = webidl.createInterfaceConverter(
"GPUTexture", "GPUTexture",
GPUTexture.prototype, GPUTexture,
); );
// TYPEDEF: GPUIntegerCoordinate // TYPEDEF: GPUIntegerCoordinate
@ -444,13 +444,13 @@
// INTERFACE: GPUTextureUsage // INTERFACE: GPUTextureUsage
webidl.converters.GPUTextureUsage = webidl.createInterfaceConverter( webidl.converters.GPUTextureUsage = webidl.createInterfaceConverter(
"GPUTextureUsage", "GPUTextureUsage",
GPUTextureUsage.prototype, GPUTextureUsage,
); );
// INTERFACE: GPUTextureView // INTERFACE: GPUTextureView
webidl.converters.GPUTextureView = webidl.createInterfaceConverter( webidl.converters.GPUTextureView = webidl.createInterfaceConverter(
"GPUTextureView", "GPUTextureView",
GPUTextureView.prototype, GPUTextureView,
); );
// ENUM: GPUTextureViewDimension // ENUM: GPUTextureViewDimension
@ -517,7 +517,7 @@
// INTERFACE: GPUSampler // INTERFACE: GPUSampler
webidl.converters.GPUSampler = webidl.createInterfaceConverter( webidl.converters.GPUSampler = webidl.createInterfaceConverter(
"GPUSampler", "GPUSampler",
GPUSampler.prototype, GPUSampler,
); );
// ENUM: GPUAddressMode // ENUM: GPUAddressMode
@ -613,7 +613,7 @@
// INTERFACE: GPUBindGroupLayout // INTERFACE: GPUBindGroupLayout
webidl.converters.GPUBindGroupLayout = webidl.createInterfaceConverter( webidl.converters.GPUBindGroupLayout = webidl.createInterfaceConverter(
"GPUBindGroupLayout", "GPUBindGroupLayout",
GPUBindGroupLayout.prototype, GPUBindGroupLayout,
); );
// TYPEDEF: GPUIndex32 // TYPEDEF: GPUIndex32
@ -796,13 +796,13 @@
// INTERFACE: GPUShaderStage // INTERFACE: GPUShaderStage
webidl.converters.GPUShaderStage = webidl.createInterfaceConverter( webidl.converters.GPUShaderStage = webidl.createInterfaceConverter(
"GPUShaderStage", "GPUShaderStage",
GPUShaderStage.prototype, GPUShaderStage,
); );
// INTERFACE: GPUBindGroup // INTERFACE: GPUBindGroup
webidl.converters.GPUBindGroup = webidl.createInterfaceConverter( webidl.converters.GPUBindGroup = webidl.createInterfaceConverter(
"GPUBindGroup", "GPUBindGroup",
GPUBindGroup.prototype, GPUBindGroup,
); );
// DICTIONARY: GPUBufferBinding // DICTIONARY: GPUBufferBinding
@ -871,7 +871,7 @@
// INTERFACE: GPUPipelineLayout // INTERFACE: GPUPipelineLayout
webidl.converters.GPUPipelineLayout = webidl.createInterfaceConverter( webidl.converters.GPUPipelineLayout = webidl.createInterfaceConverter(
"GPUPipelineLayout", "GPUPipelineLayout",
GPUPipelineLayout.prototype, GPUPipelineLayout,
); );
// DICTIONARY: GPUPipelineLayoutDescriptor // DICTIONARY: GPUPipelineLayoutDescriptor
@ -894,7 +894,7 @@
// INTERFACE: GPUShaderModule // INTERFACE: GPUShaderModule
webidl.converters.GPUShaderModule = webidl.createInterfaceConverter( webidl.converters.GPUShaderModule = webidl.createInterfaceConverter(
"GPUShaderModule", "GPUShaderModule",
GPUShaderModule.prototype, GPUShaderModule,
); );
// DICTIONARY: GPUShaderModuleDescriptor // DICTIONARY: GPUShaderModuleDescriptor
@ -926,13 +926,13 @@
// // INTERFACE: GPUCompilationMessage // // INTERFACE: GPUCompilationMessage
// webidl.converters.GPUCompilationMessage = webidl.createInterfaceConverter( // webidl.converters.GPUCompilationMessage = webidl.createInterfaceConverter(
// "GPUCompilationMessage", // "GPUCompilationMessage",
// GPUCompilationMessage.prototype, // GPUCompilationMessage,
// ); // );
// // INTERFACE: GPUCompilationInfo // // INTERFACE: GPUCompilationInfo
// webidl.converters.GPUCompilationInfo = webidl.createInterfaceConverter( // webidl.converters.GPUCompilationInfo = webidl.createInterfaceConverter(
// "GPUCompilationInfo", // "GPUCompilationInfo",
// GPUCompilationInfo.prototype, // GPUCompilationInfo,
// ); // );
// DICTIONARY: GPUPipelineDescriptorBase // DICTIONARY: GPUPipelineDescriptorBase
@ -981,7 +981,7 @@
// INTERFACE: GPUComputePipeline // INTERFACE: GPUComputePipeline
webidl.converters.GPUComputePipeline = webidl.createInterfaceConverter( webidl.converters.GPUComputePipeline = webidl.createInterfaceConverter(
"GPUComputePipeline", "GPUComputePipeline",
GPUComputePipeline.prototype, GPUComputePipeline,
); );
// DICTIONARY: GPUComputePipelineDescriptor // DICTIONARY: GPUComputePipelineDescriptor
@ -1003,7 +1003,7 @@
// INTERFACE: GPURenderPipeline // INTERFACE: GPURenderPipeline
webidl.converters.GPURenderPipeline = webidl.createInterfaceConverter( webidl.converters.GPURenderPipeline = webidl.createInterfaceConverter(
"GPURenderPipeline", "GPURenderPipeline",
GPURenderPipeline.prototype, GPURenderPipeline,
); );
// ENUM: GPUVertexStepMode // ENUM: GPUVertexStepMode
@ -1476,13 +1476,13 @@
// INTERFACE: GPUColorWrite // INTERFACE: GPUColorWrite
webidl.converters.GPUColorWrite = webidl.createInterfaceConverter( webidl.converters.GPUColorWrite = webidl.createInterfaceConverter(
"GPUColorWrite", "GPUColorWrite",
GPUColorWrite.prototype, GPUColorWrite,
); );
// INTERFACE: GPUCommandBuffer // INTERFACE: GPUCommandBuffer
webidl.converters.GPUCommandBuffer = webidl.createInterfaceConverter( webidl.converters.GPUCommandBuffer = webidl.createInterfaceConverter(
"GPUCommandBuffer", "GPUCommandBuffer",
GPUCommandBuffer.prototype, GPUCommandBuffer,
); );
webidl.converters["sequence<GPUCommandBuffer>"] = webidl webidl.converters["sequence<GPUCommandBuffer>"] = webidl
.createSequenceConverter(webidl.converters["GPUCommandBuffer"]); .createSequenceConverter(webidl.converters["GPUCommandBuffer"]);
@ -1499,7 +1499,7 @@
// INTERFACE: GPUCommandEncoder // INTERFACE: GPUCommandEncoder
webidl.converters.GPUCommandEncoder = webidl.createInterfaceConverter( webidl.converters.GPUCommandEncoder = webidl.createInterfaceConverter(
"GPUCommandEncoder", "GPUCommandEncoder",
GPUCommandEncoder.prototype, GPUCommandEncoder,
); );
// DICTIONARY: GPUCommandEncoderDescriptor // DICTIONARY: GPUCommandEncoderDescriptor
@ -1654,7 +1654,7 @@
// INTERFACE: GPUComputePassEncoder // INTERFACE: GPUComputePassEncoder
webidl.converters.GPUComputePassEncoder = webidl.createInterfaceConverter( webidl.converters.GPUComputePassEncoder = webidl.createInterfaceConverter(
"GPUComputePassEncoder", "GPUComputePassEncoder",
GPUComputePassEncoder.prototype, GPUComputePassEncoder,
); );
// DICTIONARY: GPUComputePassDescriptor // DICTIONARY: GPUComputePassDescriptor
@ -1669,7 +1669,7 @@
// INTERFACE: GPURenderPassEncoder // INTERFACE: GPURenderPassEncoder
webidl.converters.GPURenderPassEncoder = webidl.createInterfaceConverter( webidl.converters.GPURenderPassEncoder = webidl.createInterfaceConverter(
"GPURenderPassEncoder", "GPURenderPassEncoder",
GPURenderPassEncoder.prototype, GPURenderPassEncoder,
); );
// ENUM: GPULoadOp // ENUM: GPULoadOp
@ -1787,7 +1787,7 @@
// INTERFACE: GPUQuerySet // INTERFACE: GPUQuerySet
webidl.converters.GPUQuerySet = webidl.createInterfaceConverter( webidl.converters.GPUQuerySet = webidl.createInterfaceConverter(
"GPUQuerySet", "GPUQuerySet",
GPUQuerySet.prototype, GPUQuerySet,
); );
// DICTIONARY: GPURenderPassDescriptor // DICTIONARY: GPURenderPassDescriptor
@ -1815,7 +1815,7 @@
// INTERFACE: GPURenderBundle // INTERFACE: GPURenderBundle
webidl.converters.GPURenderBundle = webidl.createInterfaceConverter( webidl.converters.GPURenderBundle = webidl.createInterfaceConverter(
"GPURenderBundle", "GPURenderBundle",
GPURenderBundle.prototype, GPURenderBundle,
); );
webidl.converters["sequence<GPURenderBundle>"] = webidl webidl.converters["sequence<GPURenderBundle>"] = webidl
.createSequenceConverter(webidl.converters["GPURenderBundle"]); .createSequenceConverter(webidl.converters["GPURenderBundle"]);
@ -1832,7 +1832,7 @@
// INTERFACE: GPURenderBundleEncoder // INTERFACE: GPURenderBundleEncoder
webidl.converters.GPURenderBundleEncoder = webidl.createInterfaceConverter( webidl.converters.GPURenderBundleEncoder = webidl.createInterfaceConverter(
"GPURenderBundleEncoder", "GPURenderBundleEncoder",
GPURenderBundleEncoder.prototype, GPURenderBundleEncoder,
); );
// DICTIONARY: GPURenderPassLayout // DICTIONARY: GPURenderPassLayout
@ -1885,7 +1885,7 @@
// INTERFACE: GPUQueue // INTERFACE: GPUQueue
webidl.converters.GPUQueue = webidl.createInterfaceConverter( webidl.converters.GPUQueue = webidl.createInterfaceConverter(
"GPUQueue", "GPUQueue",
GPUQueue.prototype, GPUQueue,
); );
// ENUM: GPUQueryType // ENUM: GPUQueryType
@ -1945,7 +1945,7 @@
// // INTERFACE: GPUDeviceLostInfo // // INTERFACE: GPUDeviceLostInfo
// webidl.converters.GPUDeviceLostInfo = webidl.createInterfaceConverter( // webidl.converters.GPUDeviceLostInfo = webidl.createInterfaceConverter(
// "GPUDeviceLostInfo", // "GPUDeviceLostInfo",
// GPUDeviceLostInfo.prototype, // GPUDeviceLostInfo,
// ); // );
// ENUM: GPUErrorFilter // ENUM: GPUErrorFilter
@ -1960,13 +1960,13 @@
// INTERFACE: GPUOutOfMemoryError // INTERFACE: GPUOutOfMemoryError
webidl.converters.GPUOutOfMemoryError = webidl.createInterfaceConverter( webidl.converters.GPUOutOfMemoryError = webidl.createInterfaceConverter(
"GPUOutOfMemoryError", "GPUOutOfMemoryError",
GPUOutOfMemoryError.prototype, GPUOutOfMemoryError,
); );
// INTERFACE: GPUValidationError // INTERFACE: GPUValidationError
webidl.converters.GPUValidationError = webidl.createInterfaceConverter( webidl.converters.GPUValidationError = webidl.createInterfaceConverter(
"GPUValidationError", "GPUValidationError",
GPUValidationError.prototype, GPUValidationError,
); );
// TYPEDEF: GPUError // TYPEDEF: GPUError
@ -1975,7 +1975,7 @@
// // INTERFACE: GPUUncapturedErrorEvent // // INTERFACE: GPUUncapturedErrorEvent
// webidl.converters.GPUUncapturedErrorEvent = webidl.createInterfaceConverter( // webidl.converters.GPUUncapturedErrorEvent = webidl.createInterfaceConverter(
// "GPUUncapturedErrorEvent", // "GPUUncapturedErrorEvent",
// GPUUncapturedErrorEvent.prototype, // GPUUncapturedErrorEvent,
// ); // );
// DICTIONARY: GPUUncapturedErrorEventInit // DICTIONARY: GPUUncapturedErrorEventInit

24
ext/webidl/00_webidl.js
View file

@ -11,7 +11,7 @@
((window) => { ((window) => {
const core = window.Deno.core; const core = window.Deno.core;
const { const {
ArrayBufferPrototype, ArrayBuffer,
ArrayBufferIsView, ArrayBufferIsView,
ArrayPrototypeForEach, ArrayPrototypeForEach,
ArrayPrototypePush, ArrayPrototypePush,
@ -20,6 +20,7 @@
BigInt, BigInt,
BigIntAsIntN, BigIntAsIntN,
BigIntAsUintN, BigIntAsUintN,
DataView,
Float32Array, Float32Array,
Float64Array, Float64Array,
FunctionPrototypeBind, FunctionPrototypeBind,
@ -49,7 +50,6 @@
ObjectGetOwnPropertyDescriptors, ObjectGetOwnPropertyDescriptors,
ObjectGetPrototypeOf, ObjectGetPrototypeOf,
ObjectPrototypeHasOwnProperty, ObjectPrototypeHasOwnProperty,
ObjectPrototypeIsPrototypeOf,
ObjectIs, ObjectIs,
PromisePrototypeThen, PromisePrototypeThen,
PromiseReject, PromiseReject,
@ -434,11 +434,11 @@
} }
function isNonSharedArrayBuffer(V) { function isNonSharedArrayBuffer(V) {
return ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, V); return V instanceof ArrayBuffer;
} }
function isSharedArrayBuffer(V) { function isSharedArrayBuffer(V) {
return ObjectPrototypeIsPrototypeOf(SharedArrayBuffer.prototype, V); return V instanceof SharedArrayBuffer;
} }
converters.ArrayBuffer = (V, opts = {}) => { converters.ArrayBuffer = (V, opts = {}) => {
@ -457,7 +457,7 @@
}; };
converters.DataView = (V, opts = {}) => { converters.DataView = (V, opts = {}) => {
if (!(ObjectPrototypeIsPrototypeOf(DataViewPrototype, V))) { if (!(V instanceof DataView)) {
throw makeException(TypeError, "is not a DataView", opts); throw makeException(TypeError, "is not a DataView", opts);
} }
@ -862,7 +862,7 @@
function createInterfaceConverter(name, prototype) { function createInterfaceConverter(name, prototype) {
return (V, opts) => { return (V, opts) => {
if (!ObjectPrototypeIsPrototypeOf(prototype, V) || V[brand] !== brand) { if (!(V instanceof prototype) || V[brand] !== brand) {
throw makeException(TypeError, `is not of type ${name}.`, opts); throw makeException(TypeError, `is not of type ${name}.`, opts);
} }
return V; return V;
@ -877,9 +877,7 @@
} }
function assertBranded(self, prototype) { function assertBranded(self, prototype) {
if ( if (!(self instanceof prototype) || self[brand] !== brand) {
!ObjectPrototypeIsPrototypeOf(prototype, self) || self[brand] !== brand
) {
throw new TypeError("Illegal invocation"); throw new TypeError("Illegal invocation");
} }
} }
@ -946,7 +944,7 @@
} }
function entries() { function entries() {
assertBranded(this, prototype.prototype); assertBranded(this, prototype);
return createDefaultIterator(this, "key+value"); return createDefaultIterator(this, "key+value");
} }
@ -965,7 +963,7 @@
}, },
keys: { keys: {
value: function keys() { value: function keys() {
assertBranded(this, prototype.prototype); assertBranded(this, prototype);
return createDefaultIterator(this, "key"); return createDefaultIterator(this, "key");
}, },
writable: true, writable: true,
@ -974,7 +972,7 @@
}, },
values: { values: {
value: function values() { value: function values() {
assertBranded(this, prototype.prototype); assertBranded(this, prototype);
return createDefaultIterator(this, "value"); return createDefaultIterator(this, "value");
}, },
writable: true, writable: true,
@ -983,7 +981,7 @@
}, },
forEach: { forEach: {
value: function forEach(idlCallback, thisArg = undefined) { value: function forEach(idlCallback, thisArg = undefined) {
assertBranded(this, prototype.prototype); assertBranded(this, prototype);
const prefix = `Failed to execute 'forEach' on '${name}'`; const prefix = `Failed to execute 'forEach' on '${name}'`;
requiredArguments(arguments.length, 1, { prefix }); requiredArguments(arguments.length, 1, { prefix });
idlCallback = converters["Function"](idlCallback, { idlCallback = converters["Function"](idlCallback, {

62
ext/websocket/01_websocket.js
View file

@ -10,31 +10,29 @@
const { HTTP_TOKEN_CODE_POINT_RE } = window.__bootstrap.infra; const { HTTP_TOKEN_CODE_POINT_RE } = window.__bootstrap.infra;
const { DOMException } = window.__bootstrap.domException; const { DOMException } = window.__bootstrap.domException;
const { defineEventHandler } = window.__bootstrap.event; const { defineEventHandler } = window.__bootstrap.event;
const { Blob, BlobPrototype } = globalThis.__bootstrap.file; const { Blob } = globalThis.__bootstrap.file;
const { const {
ArrayBufferPrototype, ArrayBuffer,
ArrayBufferIsView, ArrayBufferIsView,
ArrayPrototypeJoin, ArrayPrototypeJoin,
ArrayPrototypeMap,
ArrayPrototypeSome,
DataView, DataView,
ErrorPrototypeToString, ErrorPrototypeToString,
ObjectDefineProperties,
ObjectPrototypeIsPrototypeOf,
PromisePrototypeThen,
RegExpPrototypeTest,
Set, Set,
String,
StringPrototypeEndsWith,
StringPrototypeToLowerCase,
Symbol, Symbol,
SymbolIterator, String,
StringPrototypeToLowerCase,
StringPrototypeEndsWith,
RegExpPrototypeTest,
ObjectDefineProperties,
ArrayPrototypeMap,
ArrayPrototypeSome,
PromisePrototypeThen,
} = window.__bootstrap.primordials; } = window.__bootstrap.primordials;
webidl.converters["sequence<DOMString> or DOMString"] = (V, opts) => { webidl.converters["sequence<DOMString> or DOMString"] = (V, opts) => {
// Union for (sequence<DOMString> or DOMString) // Union for (sequence<DOMString> or DOMString)
if (webidl.type(V) === "Object" && V !== null) { if (webidl.type(V) === "Object" && V !== null) {
if (V[SymbolIterator] !== undefined) { if (V[Symbol.iterator] !== undefined) {
return webidl.converters["sequence<DOMString>"](V, opts); return webidl.converters["sequence<DOMString>"](V, opts);
} }
} }
@ -43,15 +41,12 @@
webidl.converters["WebSocketSend"] = (V, opts) => { webidl.converters["WebSocketSend"] = (V, opts) => {
// Union for (Blob or ArrayBufferView or ArrayBuffer or USVString) // Union for (Blob or ArrayBufferView or ArrayBuffer or USVString)
if (ObjectPrototypeIsPrototypeOf(BlobPrototype, V)) { if (V instanceof Blob) {
return webidl.converters["Blob"](V, opts); return webidl.converters["Blob"](V, opts);
} }
if (typeof V === "object") { if (typeof V === "object") {
// TODO(littledivy): use primordial for SharedArrayBuffer // TODO(littledivy): use primordial for SharedArrayBuffer
if ( if (V instanceof ArrayBuffer || V instanceof SharedArrayBuffer) {
ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, V) ||
ObjectPrototypeIsPrototypeOf(SharedArrayBuffer.prototype, V)
) {
return webidl.converters["ArrayBuffer"](V, opts); return webidl.converters["ArrayBuffer"](V, opts);
} }
if (ArrayBufferIsView(V)) { if (ArrayBufferIsView(V)) {
@ -84,52 +79,52 @@
[_readyState] = CONNECTING; [_readyState] = CONNECTING;
get readyState() { get readyState() {
webidl.assertBranded(this, WebSocketPrototype); webidl.assertBranded(this, WebSocket);
return this[_readyState]; return this[_readyState];
} }
get CONNECTING() { get CONNECTING() {
webidl.assertBranded(this, WebSocketPrototype); webidl.assertBranded(this, WebSocket);
return CONNECTING; return CONNECTING;
} }
get OPEN() { get OPEN() {
webidl.assertBranded(this, WebSocketPrototype); webidl.assertBranded(this, WebSocket);
return OPEN; return OPEN;
} }
get CLOSING() { get CLOSING() {
webidl.assertBranded(this, WebSocketPrototype); webidl.assertBranded(this, WebSocket);
return CLOSING; return CLOSING;
} }
get CLOSED() { get CLOSED() {
webidl.assertBranded(this, WebSocketPrototype); webidl.assertBranded(this, WebSocket);
return CLOSED; return CLOSED;
} }
[_extensions] = ""; [_extensions] = "";
get extensions() { get extensions() {
webidl.assertBranded(this, WebSocketPrototype); webidl.assertBranded(this, WebSocket);
return this[_extensions]; return this[_extensions];
} }
[_protocol] = ""; [_protocol] = "";
get protocol() { get protocol() {
webidl.assertBranded(this, WebSocketPrototype); webidl.assertBranded(this, WebSocket);
return this[_protocol]; return this[_protocol];
} }
[_url] = ""; [_url] = "";
get url() { get url() {
webidl.assertBranded(this, WebSocketPrototype); webidl.assertBranded(this, WebSocket);
return this[_url]; return this[_url];
} }
[_binaryType] = "blob"; [_binaryType] = "blob";
get binaryType() { get binaryType() {
webidl.assertBranded(this, WebSocketPrototype); webidl.assertBranded(this, WebSocket);
return this[_binaryType]; return this[_binaryType];
} }
set binaryType(value) { set binaryType(value) {
webidl.assertBranded(this, WebSocketPrototype); webidl.assertBranded(this, WebSocket);
value = webidl.converters.DOMString(value, { value = webidl.converters.DOMString(value, {
prefix: "Failed to set 'binaryType' on 'WebSocket'", prefix: "Failed to set 'binaryType' on 'WebSocket'",
}); });
@ -140,7 +135,7 @@
[_bufferedAmount] = 0; [_bufferedAmount] = 0;
get bufferedAmount() { get bufferedAmount() {
webidl.assertBranded(this, WebSocketPrototype); webidl.assertBranded(this, WebSocket);
return this[_bufferedAmount]; return this[_bufferedAmount];
} }
@ -272,7 +267,7 @@
} }
send(data) { send(data) {
webidl.assertBranded(this, WebSocketPrototype); webidl.assertBranded(this, WebSocket);
const prefix = "Failed to execute 'send' on 'WebSocket'"; const prefix = "Failed to execute 'send' on 'WebSocket'";
webidl.requiredArguments(arguments.length, 1, { webidl.requiredArguments(arguments.length, 1, {
@ -300,14 +295,14 @@
); );
}; };
if (ObjectPrototypeIsPrototypeOf(BlobPrototype, data)) { if (data instanceof Blob) {
PromisePrototypeThen( PromisePrototypeThen(
data.slice().arrayBuffer(), data.slice().arrayBuffer(),
(ab) => sendTypedArray(new DataView(ab)), (ab) => sendTypedArray(new DataView(ab)),
); );
} else if (ArrayBufferIsView(data)) { } else if (ArrayBufferIsView(data)) {
sendTypedArray(data); sendTypedArray(data);
} else if (ObjectPrototypeIsPrototypeOf(ArrayBufferPrototype, data)) { } else if (data instanceof ArrayBuffer) {
sendTypedArray(new DataView(data)); sendTypedArray(new DataView(data));
} else { } else {
const string = String(data); const string = String(data);
@ -326,7 +321,7 @@
} }
close(code = undefined, reason = undefined) { close(code = undefined, reason = undefined) {
webidl.assertBranded(this, WebSocketPrototype); webidl.assertBranded(this, WebSocket);
const prefix = "Failed to execute 'close' on 'WebSocket'"; const prefix = "Failed to execute 'close' on 'WebSocket'";
if (code !== undefined) { if (code !== undefined) {
@ -519,7 +514,6 @@
defineEventHandler(WebSocket.prototype, "open"); defineEventHandler(WebSocket.prototype, "open");
webidl.configurePrototype(WebSocket); webidl.configurePrototype(WebSocket);
const WebSocketPrototype = WebSocket.prototype;
window.__bootstrap.webSocket = { window.__bootstrap.webSocket = {
WebSocket, WebSocket,

31
ext/websocket/02_websocketstream.js
View file

@ -11,19 +11,18 @@
const { add, remove } = window.__bootstrap.abortSignal; const { add, remove } = window.__bootstrap.abortSignal;
const { const {
ArrayPrototypeJoin,
ArrayPrototypeMap,
Error,
ObjectPrototypeIsPrototypeOf,
PromisePrototypeCatch,
PromisePrototypeThen,
Set,
StringPrototypeEndsWith, StringPrototypeEndsWith,
StringPrototypeToLowerCase, StringPrototypeToLowerCase,
Symbol, Symbol,
SymbolFor, SymbolFor,
Set,
ArrayPrototypeMap,
ArrayPrototypeJoin,
PromisePrototypeThen,
PromisePrototypeCatch,
Uint8Array,
TypeError, TypeError,
Uint8ArrayPrototype, Error,
} = window.__bootstrap.primordials; } = window.__bootstrap.primordials;
webidl.converters.WebSocketStreamOptions = webidl.createDictionaryConverter( webidl.converters.WebSocketStreamOptions = webidl.createDictionaryConverter(
@ -71,7 +70,7 @@
[_url]; [_url];
get url() { get url() {
webidl.assertBranded(this, WebSocketStreamPrototype); webidl.assertBranded(this, WebSocketStream);
return this[_url]; return this[_url];
} }
@ -196,9 +195,7 @@
kind: "text", kind: "text",
value: chunk, value: chunk,
}); });
} else if ( } else if (chunk instanceof Uint8Array) {
ObjectPrototypeIsPrototypeOf(Uint8ArrayPrototype, chunk)
) {
await core.opAsync("op_ws_send", this[_rid], { await core.opAsync("op_ws_send", this[_rid], {
kind: "binary", kind: "binary",
value: chunk, value: chunk,
@ -299,7 +296,7 @@
} }
}, },
(err) => { (err) => {
if (ObjectPrototypeIsPrototypeOf(core.InterruptedPrototype, err)) { if (err instanceof core.Interrupted) {
// The signal was aborted. // The signal was aborted.
err = options.signal.reason; err = options.signal.reason;
} else { } else {
@ -314,19 +311,19 @@
[_connection] = new Deferred(); [_connection] = new Deferred();
get connection() { get connection() {
webidl.assertBranded(this, WebSocketStreamPrototype); webidl.assertBranded(this, WebSocketStream);
return this[_connection].promise; return this[_connection].promise;
} }
[_earlyClose] = false; [_earlyClose] = false;
[_closed] = new Deferred(); [_closed] = new Deferred();
get closed() { get closed() {
webidl.assertBranded(this, WebSocketStreamPrototype); webidl.assertBranded(this, WebSocketStream);
return this[_closed].promise; return this[_closed].promise;
} }
close(closeInfo) { close(closeInfo) {
webidl.assertBranded(this, WebSocketStreamPrototype); webidl.assertBranded(this, WebSocketStream);
closeInfo = webidl.converters.WebSocketCloseInfo(closeInfo, { closeInfo = webidl.converters.WebSocketCloseInfo(closeInfo, {
prefix: "Failed to execute 'close' on 'WebSocketStream'", prefix: "Failed to execute 'close' on 'WebSocketStream'",
context: "Argument 1", context: "Argument 1",
@ -384,7 +381,5 @@
} }
} }
const WebSocketStreamPrototype = WebSocketStream.prototype;
window.__bootstrap.webSocket.WebSocketStream = WebSocketStream; window.__bootstrap.webSocket.WebSocketStream = WebSocketStream;
})(this); })(this);

14
ext/webstorage/01_webstorage.js
View file

@ -25,12 +25,12 @@
} }
get length() { get length() {
webidl.assertBranded(this, StoragePrototype); webidl.assertBranded(this, Storage);
return core.opSync("op_webstorage_length", this[_persistent]); return core.opSync("op_webstorage_length", this[_persistent]);
} }
key(index) { key(index) {
webidl.assertBranded(this, StoragePrototype); webidl.assertBranded(this, Storage);
const prefix = "Failed to execute 'key' on 'Storage'"; const prefix = "Failed to execute 'key' on 'Storage'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
index = webidl.converters["unsigned long"](index, { index = webidl.converters["unsigned long"](index, {
@ -42,7 +42,7 @@
} }
setItem(key, value) { setItem(key, value) {
webidl.assertBranded(this, StoragePrototype); webidl.assertBranded(this, Storage);
const prefix = "Failed to execute 'setItem' on 'Storage'"; const prefix = "Failed to execute 'setItem' on 'Storage'";
webidl.requiredArguments(arguments.length, 2, { prefix }); webidl.requiredArguments(arguments.length, 2, { prefix });
key = webidl.converters.DOMString(key, { key = webidl.converters.DOMString(key, {
@ -61,7 +61,7 @@
} }
getItem(key) { getItem(key) {
webidl.assertBranded(this, StoragePrototype); webidl.assertBranded(this, Storage);
const prefix = "Failed to execute 'getItem' on 'Storage'"; const prefix = "Failed to execute 'getItem' on 'Storage'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
key = webidl.converters.DOMString(key, { key = webidl.converters.DOMString(key, {
@ -73,7 +73,7 @@
} }
removeItem(key) { removeItem(key) {
webidl.assertBranded(this, StoragePrototype); webidl.assertBranded(this, Storage);
const prefix = "Failed to execute 'removeItem' on 'Storage'"; const prefix = "Failed to execute 'removeItem' on 'Storage'";
webidl.requiredArguments(arguments.length, 1, { prefix }); webidl.requiredArguments(arguments.length, 1, { prefix });
key = webidl.converters.DOMString(key, { key = webidl.converters.DOMString(key, {
@ -85,13 +85,11 @@
} }
clear() { clear() {
webidl.assertBranded(this, StoragePrototype); webidl.assertBranded(this, Storage);
core.opSync("op_webstorage_clear", this[_persistent]); core.opSync("op_webstorage_clear", this[_persistent]);
} }
} }
const StoragePrototype = Storage.prototype;
function createStorage(persistent) { function createStorage(persistent) {
const storage = webidl.createBranded(Storage); const storage = webidl.createBranded(Storage);
storage[_persistent] = persistent; storage[_persistent] = persistent;

11
runtime/js/06_util.js
View file

@ -3,15 +3,14 @@
((window) => { ((window) => {
const { const {
decodeURIComponent,
Error,
ObjectPrototypeIsPrototypeOf,
Promise,
StringPrototypeReplace, StringPrototypeReplace,
TypeError, TypeError,
Promise,
decodeURIComponent,
Error,
} = window.__bootstrap.primordials; } = window.__bootstrap.primordials;
const { build } = window.__bootstrap.build; const { build } = window.__bootstrap.build;
const { URLPrototype } = window.__bootstrap.url; const { URL } = window.__bootstrap.url;
let logDebug = false; let logDebug = false;
let logSource = "JS"; let logSource = "JS";
@ -94,7 +93,7 @@
} }
function pathFromURL(pathOrUrl) { function pathFromURL(pathOrUrl) {
if (ObjectPrototypeIsPrototypeOf(URLPrototype, pathOrUrl)) { if (pathOrUrl instanceof URL) {
if (pathOrUrl.protocol != "file:") { if (pathOrUrl.protocol != "file:") {
throw new TypeError("Must be a file URL."); throw new TypeError("Must be a file URL.");
} }

12
runtime/js/11_workers.js
View file

@ -5,7 +5,6 @@
const core = window.Deno.core; const core = window.Deno.core;
const { const {
Error, Error,
ObjectPrototypeIsPrototypeOf,
StringPrototypeStartsWith, StringPrototypeStartsWith,
String, String,
SymbolIterator, SymbolIterator,
@ -17,11 +16,8 @@
const { serializePermissions } = window.__bootstrap.permissions; const { serializePermissions } = window.__bootstrap.permissions;
const { log } = window.__bootstrap.util; const { log } = window.__bootstrap.util;
const { defineEventHandler } = window.__bootstrap.event; const { defineEventHandler } = window.__bootstrap.event;
const { const { deserializeJsMessageData, serializeJsMessageData } =
deserializeJsMessageData, window.__bootstrap.messagePort;
serializeJsMessageData,
MessagePortPrototype,
} = window.__bootstrap.messagePort;
function createWorker( function createWorker(
specifier, specifier,
@ -203,9 +199,7 @@
const event = new MessageEvent("message", { const event = new MessageEvent("message", {
cancelable: false, cancelable: false,
data: message, data: message,
ports: transferables.filter((t) => ports: transferables.filter((t) => t instanceof MessagePort),
ObjectPrototypeIsPrototypeOf(MessagePortPrototype, t)
),
}); });
this.dispatchEvent(event); this.dispatchEvent(event);
} }

4
runtime/js/30_fs.js
View file

@ -5,9 +5,7 @@
const core = window.Deno.core; const core = window.Deno.core;
const { const {
Date, Date,
DatePrototype,
MathTrunc, MathTrunc,
ObjectPrototypeIsPrototypeOf,
SymbolAsyncIterator, SymbolAsyncIterator,
SymbolIterator, SymbolIterator,
} = window.__bootstrap.primordials; } = window.__bootstrap.primordials;
@ -279,7 +277,7 @@
} }
function toUnixTimeFromEpoch(value) { function toUnixTimeFromEpoch(value) {
if (ObjectPrototypeIsPrototypeOf(DatePrototype, value)) { if (value instanceof Date) {
const time = value.valueOf(); const time = value.valueOf();
const seconds = MathTrunc(time / 1e3); const seconds = MathTrunc(time / 1e3);
const nanoseconds = MathTrunc(time - (seconds * 1e3)) * 1e6; const nanoseconds = MathTrunc(time - (seconds * 1e3)) * 1e6;

9
runtime/js/40_fs_events.js
View file

@ -3,10 +3,9 @@
((window) => { ((window) => {
const core = window.Deno.core; const core = window.Deno.core;
const { BadResourcePrototype, InterruptedPrototype } = core; const { errors } = window.__bootstrap.errors;
const { const {
ArrayIsArray, ArrayIsArray,
ObjectPrototypeIsPrototypeOf,
PromiseResolve, PromiseResolve,
SymbolAsyncIterator, SymbolAsyncIterator,
} = window.__bootstrap.primordials; } = window.__bootstrap.primordials;
@ -29,11 +28,9 @@
? { value, done: false } ? { value, done: false }
: { value: undefined, done: true }; : { value: undefined, done: true };
} catch (error) { } catch (error) {
if (ObjectPrototypeIsPrototypeOf(BadResourcePrototype, error)) { if (error instanceof errors.BadResource) {
return { value: undefined, done: true }; return { value: undefined, done: true };
} else if ( } else if (error instanceof errors.Interrupted) {
ObjectPrototypeIsPrototypeOf(InterruptedPrototype, error)
) {
return { value: undefined, done: true }; return { value: undefined, done: true };
} }
throw error; throw error;

9
runtime/js/40_testing.js
View file

@ -9,15 +9,14 @@
const { serializePermissions } = window.__bootstrap.permissions; const { serializePermissions } = window.__bootstrap.permissions;
const { assert } = window.__bootstrap.util; const { assert } = window.__bootstrap.util;
const { const {
AggregateErrorPrototype, AggregateError,
ArrayPrototypeFilter, ArrayPrototypeFilter,
ArrayPrototypePush, ArrayPrototypePush,
ArrayPrototypeShift, ArrayPrototypeShift,
ArrayPrototypeSome, ArrayPrototypeSome,
DateNow, DateNow,
Error, Error,
FunctionPrototype, Function,
ObjectPrototypeIsPrototypeOf,
Number, Number,
ObjectKeys, ObjectKeys,
Promise, Promise,
@ -531,7 +530,7 @@ finishing test case.`;
} }
function formatError(error) { function formatError(error) {
if (ObjectPrototypeIsPrototypeOf(AggregateErrorPrototype, error)) { if (error instanceof AggregateError) {
const message = error const message = error
.errors .errors
.map((error) => .map((error) =>
@ -985,7 +984,7 @@ finishing test case.`;
/** @returns {TestStepDefinition} */ /** @returns {TestStepDefinition} */
function getDefinition() { function getDefinition() {
if (typeof nameOrTestDefinition === "string") { if (typeof nameOrTestDefinition === "string") {
if (!(ObjectPrototypeIsPrototypeOf(FunctionPrototype, fn))) { if (!(fn instanceof Function)) {
throw new TypeError("Expected function for second argument."); throw new TypeError("Expected function for second argument.");
} }
return { return {

15
runtime/js/99_main.js
View file

@ -16,7 +16,6 @@ delete Object.prototype.__proto__;
ObjectDefineProperty, ObjectDefineProperty,
ObjectDefineProperties, ObjectDefineProperties,
ObjectFreeze, ObjectFreeze,
ObjectPrototypeIsPrototypeOf,
ObjectSetPrototypeOf, ObjectSetPrototypeOf,
PromiseResolve, PromiseResolve,
Symbol, Symbol,
@ -143,9 +142,7 @@ delete Object.prototype.__proto__;
const msgEvent = new MessageEvent("message", { const msgEvent = new MessageEvent("message", {
cancelable: false, cancelable: false,
data: message, data: message,
ports: transferables.filter((t) => ports: transferables.filter((t) => t instanceof MessagePort),
ObjectPrototypeIsPrototypeOf(messagePort.MessagePortPrototype, t)
),
}); });
try { try {
@ -314,7 +311,7 @@ delete Object.prototype.__proto__;
configurable: true, configurable: true,
enumerable: true, enumerable: true,
get() { get() {
webidl.assertBranded(this, NavigatorPrototype); webidl.assertBranded(this, Navigator);
return webgpu.gpu; return webgpu.gpu;
}, },
}, },
@ -322,12 +319,11 @@ delete Object.prototype.__proto__;
configurable: true, configurable: true,
enumerable: true, enumerable: true,
get() { get() {
webidl.assertBranded(this, NavigatorPrototype); webidl.assertBranded(this, Navigator);
return numCpus; return numCpus;
}, },
}, },
}); });
const NavigatorPrototype = Navigator.prototype;
class WorkerNavigator { class WorkerNavigator {
constructor() { constructor() {
@ -346,7 +342,7 @@ delete Object.prototype.__proto__;
configurable: true, configurable: true,
enumerable: true, enumerable: true,
get() { get() {
webidl.assertBranded(this, WorkerNavigatorPrototype); webidl.assertBranded(this, WorkerNavigator);
return webgpu.gpu; return webgpu.gpu;
}, },
}, },
@ -354,12 +350,11 @@ delete Object.prototype.__proto__;
configurable: true, configurable: true,
enumerable: true, enumerable: true,
get() { get() {
webidl.assertBranded(this, WorkerNavigatorPrototype); webidl.assertBranded(this, WorkerNavigator);
return numCpus; return numCpus;
}, },
}, },
}); });
const WorkerNavigatorPrototype = WorkerNavigator.prototype;
// https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope // https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope
const windowOrWorkerGlobalScope = { const windowOrWorkerGlobalScope = {