More tightly describe name processing in the spec

[ljharb]

The spec text here needs to be better; I'm not sure how yet.

[Jamesernator]

Something I noticed is with the (existing ECMA262) spec text that says:

A reference such as %name.a.b% means, as if the "b" property of the "a" property of the intrinsic object %name% was accessed prior to any ECMAScript code being evaluated.

One thing not clear about this is what to do about getters/setters, currently the spec does specify a number of getters such as Symbol.prototype.description or RegExp.prototype.flags. There's currently no setters but it would best to be futureproof in case any are added.

There's also __proto__, but assuming we handle getters/setters appropriately (e.g. by just returning an object with get/set functions as properties or something like that), then getIntrinsic("Object.prototype.__proto__") should behave like any other getter/setter (in environments that implement __proto__ at all).

[Jamesernator]

Oh also we need to consider what happens with values that are in a prototype chain, e.g. does getIntrinsic("Array.hasOwnProperty") work? The current spec text is too vague.

By allowing it we allow potentially a lot of ways to access a given intrinsic, this may or may not be desirable.

This is particularly tricky with intrinsics that may be exposed in new ways over time, for example currently there is %IteratorPrototype%, but the iterator helpers proposal will add %Iterator% directly, which means we'd expect getIntrinsic("Iterator.prototype") === getIntrinsic("IteratorPrototype").

Because of this sort've thing, we might want to cleanup the intrinsic table a bit to be more consistent, not sure what would be best to do here but perhaps something like introducing %ConstructorPrototype% for each %Constructor% (the converse would not neccessarily exist, e.g. there's still no %StringIterator% even though there is %StringIteratorPrototype%).

[ljharb]

On Symbol methods, the intention is definitely to allow something like [Symbol.iterator]; this will also have to be thought through, since the only convention in the spec for it is eg %String.prototype[@@iterator]%, and the double-at isn’t something that should be normative.

For getters, indeed we’ll need to pull out the getter function automatically, thanks for calling that out.

Values in a prototype chain do not work, because Array.hasOwnProperty is not an intrinsic.

[ljharb]

The “FooPrototype” intrinsic notation is legacy and will not be supported by this API.

[Jamesernator]

The “FooPrototype” intrinsic notation is legacy and will not be supported by this API.

This sounds fine to me, but what should be done with APIs that have no corresponding global "constructor"?

For example while %String.prototype[@@iterator]% can be used to refer to %StringIteratorPrototype%, how would we refer to something like %IteratorPrototype% today? Would we just allow %Iterator.prototype% even though Iterator global doesn't exist (yet)?

Although Iterator/AsyncIterator are currently the only public cases, the iterator helper proposal actually exposes AsyncFromSyncIteratorPrototype objects properly to user code (e.g. in AsyncIterator.from it can return an AsyncFromSyncIteratorPrototype inheriting object) so the hazard would still exist.

[ljharb]

That's a good point. Prior to Iterator being a global, indeed we'd need to support IteratorPrototype.

Looks like I'll need to audit the entire list of intrinsics and figure out what makes sense to support or not.

[bathos]

@ljharb these partially categorized crawl results might be useful

// This crawl started with the well-known intrinsic objects (or those available
// in V8 at present) of both ECMA-262 and ECMA-402. The output used #get and
// #set as suffixes for accessors instead of the prefix syntax so that entries
// would end up (more or less) easily alphabetizable.
//
// The sweep was done in “generations” rather than depth-first (not sure what
// the formal term for that is, but I mean we’d go two levels deep all the way
// down the list, then three, then four, etc, until no new paths are left to
// follow). Some of the intrinsic-but-not-well-known objects are reachable via
// multiple paths so the list of possible strings is infinite and this was a way
// to select the shortest representation. However second references to the same
// object are included; it is just that only the first-shallowest is “expanded”.
//
// Many of the properties are not references to objects, e.g. every function can
// reach "name" and "length". Perhaps these would be omitted, but note that if
// only objects are addressable, values of properties like Math.LOG2E and
// Int8Array.BYTES_PER_ELEMENT wouldn’t be included. A primitive value cannot be
// “intrinsic” per se, but the _property_ is, so this might be surprising.
//
// After the crawl I picked over the list to separate items into subsections.
// The final section lists cases that happened to get picked up but which are
// not intrinsic. It is very likely that the main list contains things that are
// stage 3 or non-standard which I didn’t notice, though. Also SharedArrayBuffer
// was not present.

// ECMA-262 ////////////////////////////////////////////////////////////////////

%AggregateError%
%AggregateError%.length
%AggregateError%.name
%AggregateError%.prototype
%AggregateError%.prototype.constructor
%AggregateError%.prototype.message
%AggregateError%.prototype.name
%Array%
%Array%.from
%Array%.from.length
%Array%.from.name
%Array%.isArray
%Array%.isArray.length
%Array%.isArray.name
%Array%.length
%Array%.name
%Array%.of
%Array%.of.length
%Array%.of.name
%Array%.prototype
%Array%.prototype.at
%Array%.prototype.at.length
%Array%.prototype.at.name
%Array%.prototype.concat
%Array%.prototype.concat.length
%Array%.prototype.concat.name
%Array%.prototype.constructor
%Array%.prototype.copyWithin
%Array%.prototype.copyWithin.length
%Array%.prototype.copyWithin.name
%Array%.prototype.entries
%Array%.prototype.entries.length
%Array%.prototype.entries.name
%Array%.prototype.every
%Array%.prototype.every.length
%Array%.prototype.every.name
%Array%.prototype.fill
%Array%.prototype.fill.length
%Array%.prototype.fill.name
%Array%.prototype.filter
%Array%.prototype.filter.length
%Array%.prototype.filter.name
%Array%.prototype.find
%Array%.prototype.find.length
%Array%.prototype.find.name
%Array%.prototype.findIndex
%Array%.prototype.findIndex.length
%Array%.prototype.findIndex.name
%Array%.prototype.findLast
%Array%.prototype.findLast.length
%Array%.prototype.findLast.name
%Array%.prototype.findLastIndex
%Array%.prototype.findLastIndex.length
%Array%.prototype.findLastIndex.name
%Array%.prototype.flat
%Array%.prototype.flat.length
%Array%.prototype.flat.name
%Array%.prototype.flatMap
%Array%.prototype.flatMap.length
%Array%.prototype.flatMap.name
%Array%.prototype.forEach
%Array%.prototype.forEach.length
%Array%.prototype.forEach.name
%Array%.prototype.includes
%Array%.prototype.includes.length
%Array%.prototype.includes.name
%Array%.prototype.indexOf
%Array%.prototype.indexOf.length
%Array%.prototype.indexOf.name
%Array%.prototype.join
%Array%.prototype.join.length
%Array%.prototype.join.name
%Array%.prototype.keys
%Array%.prototype.keys.length
%Array%.prototype.keys.name
%Array%.prototype.lastIndexOf
%Array%.prototype.lastIndexOf.length
%Array%.prototype.lastIndexOf.name
%Array%.prototype.length
%Array%.prototype.map
%Array%.prototype.map.length
%Array%.prototype.map.name
%Array%.prototype.pop
%Array%.prototype.pop.length
%Array%.prototype.pop.name
%Array%.prototype.push
%Array%.prototype.push.length
%Array%.prototype.push.name
%Array%.prototype.reduce
%Array%.prototype.reduce.length
%Array%.prototype.reduce.name
%Array%.prototype.reduceRight
%Array%.prototype.reduceRight.length
%Array%.prototype.reduceRight.name
%Array%.prototype.reverse
%Array%.prototype.reverse.length
%Array%.prototype.reverse.name
%Array%.prototype.shift
%Array%.prototype.shift.length
%Array%.prototype.shift.name
%Array%.prototype.slice
%Array%.prototype.slice.length
%Array%.prototype.slice.name
%Array%.prototype.some
%Array%.prototype.some.length
%Array%.prototype.some.name
%Array%.prototype.sort
%Array%.prototype.sort.length
%Array%.prototype.sort.name
%Array%.prototype.splice
%Array%.prototype.splice.length
%Array%.prototype.splice.name
%Array%.prototype.toLocaleString
%Array%.prototype.toLocaleString.length
%Array%.prototype.toLocaleString.name
%Array%.prototype.toString
%Array%.prototype.toString.length
%Array%.prototype.toString.name
%Array%.prototype.unshift
%Array%.prototype.unshift.length
%Array%.prototype.unshift.name
%Array%.prototype.values
%Array%.prototype.values.length
%Array%.prototype.values.name
%Array%.prototype[Symbol.iterator]
%Array%.prototype[Symbol.unscopables]
%Array%.prototype[Symbol.unscopables].at
%Array%.prototype[Symbol.unscopables].copyWithin
%Array%.prototype[Symbol.unscopables].entries
%Array%.prototype[Symbol.unscopables].fill
%Array%.prototype[Symbol.unscopables].find
%Array%.prototype[Symbol.unscopables].findIndex
%Array%.prototype[Symbol.unscopables].findLast
%Array%.prototype[Symbol.unscopables].findLastIndex
%Array%.prototype[Symbol.unscopables].flat
%Array%.prototype[Symbol.unscopables].flatMap
%Array%.prototype[Symbol.unscopables].includes
%Array%.prototype[Symbol.unscopables].keys
%Array%.prototype[Symbol.unscopables].values
%Array%[Symbol.species].#get
%Array%[Symbol.species].#get.length
%Array%[Symbol.species].#get.name
%ArrayBuffer%
%ArrayBuffer%.isView
%ArrayBuffer%.isView.length
%ArrayBuffer%.isView.name
%ArrayBuffer%.length
%ArrayBuffer%.name
%ArrayBuffer%.prototype
%ArrayBuffer%.prototype.byteLength.#get
%ArrayBuffer%.prototype.byteLength.#get.length
%ArrayBuffer%.prototype.byteLength.#get.name
%ArrayBuffer%.prototype.constructor
%ArrayBuffer%.prototype.slice
%ArrayBuffer%.prototype.slice.length
%ArrayBuffer%.prototype.slice.name
%ArrayBuffer%.prototype[Symbol.toStringTag]
%ArrayBuffer%[Symbol.species].#get
%ArrayBuffer%[Symbol.species].#get.length
%ArrayBuffer%[Symbol.species].#get.name
%ArrayIteratorPrototype%
%ArrayIteratorPrototype%.next
%ArrayIteratorPrototype%.next.length
%ArrayIteratorPrototype%.next.name
%ArrayIteratorPrototype%[Symbol.toStringTag]
%AsyncFunction%
%AsyncFunction%.length
%AsyncFunction%.name
%AsyncFunction%.prototype
%AsyncFunction%.prototype.constructor
%AsyncFunction%.prototype[Symbol.toStringTag]
%AsyncGeneratorFunction%
%AsyncGeneratorFunction%.length
%AsyncGeneratorFunction%.name
%AsyncGeneratorFunction%.prototype
%AsyncGeneratorFunction%.prototype.constructor
%AsyncGeneratorFunction%.prototype.prototype
%AsyncGeneratorFunction%.prototype.prototype.constructor
%AsyncGeneratorFunction%.prototype.prototype.next
%AsyncGeneratorFunction%.prototype.prototype.next.length
%AsyncGeneratorFunction%.prototype.prototype.next.name
%AsyncGeneratorFunction%.prototype.prototype.return
%AsyncGeneratorFunction%.prototype.prototype.return.length
%AsyncGeneratorFunction%.prototype.prototype.return.name
%AsyncGeneratorFunction%.prototype.prototype.throw
%AsyncGeneratorFunction%.prototype.prototype.throw.length
%AsyncGeneratorFunction%.prototype.prototype.throw.name
%AsyncGeneratorFunction%.prototype.prototype[Symbol.toStringTag]
%AsyncGeneratorFunction%.prototype[Symbol.toStringTag]
%AsyncIteratorPrototype%
%AsyncIteratorPrototype%[Symbol.asyncIterator]
%AsyncIteratorPrototype%[Symbol.asyncIterator].length
%AsyncIteratorPrototype%[Symbol.asyncIterator].name
%Atomics%
%Atomics%.add
%Atomics%.add.length
%Atomics%.add.name
%Atomics%.and
%Atomics%.and.length
%Atomics%.and.name
%Atomics%.compareExchange
%Atomics%.compareExchange.length
%Atomics%.compareExchange.name
%Atomics%.exchange
%Atomics%.exchange.length
%Atomics%.exchange.name
%Atomics%.isLockFree
%Atomics%.isLockFree.length
%Atomics%.isLockFree.name
%Atomics%.load
%Atomics%.load.length
%Atomics%.load.name
%Atomics%.notify
%Atomics%.notify.length
%Atomics%.notify.name
%Atomics%.or
%Atomics%.or.length
%Atomics%.or.name
%Atomics%.store
%Atomics%.store.length
%Atomics%.store.name
%Atomics%.sub
%Atomics%.sub.length
%Atomics%.sub.name
%Atomics%.wait
%Atomics%.wait.length
%Atomics%.wait.name
%Atomics%.waitAsync
%Atomics%.waitAsync.length
%Atomics%.waitAsync.name
%Atomics%.xor
%Atomics%.xor.length
%Atomics%.xor.name
%Atomics%[Symbol.toStringTag]
%BigInt%
%BigInt%.asIntN
%BigInt%.asIntN.length
%BigInt%.asIntN.name
%BigInt%.asUintN
%BigInt%.asUintN.length
%BigInt%.asUintN.name
%BigInt%.length
%BigInt%.name
%BigInt%.prototype
%BigInt%.prototype.constructor
%BigInt%.prototype.toLocaleString
%BigInt%.prototype.toLocaleString.length
%BigInt%.prototype.toLocaleString.name
%BigInt%.prototype.toString
%BigInt%.prototype.toString.length
%BigInt%.prototype.toString.name
%BigInt%.prototype.valueOf
%BigInt%.prototype.valueOf.length
%BigInt%.prototype.valueOf.name
%BigInt%.prototype[Symbol.toStringTag]
%BigInt64Array%
%BigInt64Array%.BYTES_PER_ELEMENT
%BigInt64Array%.length
%BigInt64Array%.name
%BigInt64Array%.prototype
%BigInt64Array%.prototype.BYTES_PER_ELEMENT
%BigInt64Array%.prototype.constructor
%BigUint64Array%
%BigUint64Array%.BYTES_PER_ELEMENT
%BigUint64Array%.length
%BigUint64Array%.name
%BigUint64Array%.prototype
%BigUint64Array%.prototype.BYTES_PER_ELEMENT
%BigUint64Array%.prototype.constructor
%Boolean%
%Boolean%.length
%Boolean%.name
%Boolean%.prototype
%Boolean%.prototype.constructor
%Boolean%.prototype.toString
%Boolean%.prototype.toString.length
%Boolean%.prototype.toString.name
%Boolean%.prototype.valueOf
%Boolean%.prototype.valueOf.length
%Boolean%.prototype.valueOf.name
%DataView%
%DataView%.length
%DataView%.name
%DataView%.prototype
%DataView%.prototype.buffer.#get
%DataView%.prototype.buffer.#get.length
%DataView%.prototype.buffer.#get.name
%DataView%.prototype.byteLength.#get
%DataView%.prototype.byteLength.#get.length
%DataView%.prototype.byteLength.#get.name
%DataView%.prototype.byteOffset.#get
%DataView%.prototype.byteOffset.#get.length
%DataView%.prototype.byteOffset.#get.name
%DataView%.prototype.constructor
%DataView%.prototype.getBigInt64
%DataView%.prototype.getBigInt64.length
%DataView%.prototype.getBigInt64.name
%DataView%.prototype.getBigUint64
%DataView%.prototype.getBigUint64.length
%DataView%.prototype.getBigUint64.name
%DataView%.prototype.getFloat32
%DataView%.prototype.getFloat32.length
%DataView%.prototype.getFloat32.name
%DataView%.prototype.getFloat64
%DataView%.prototype.getFloat64.length
%DataView%.prototype.getFloat64.name
%DataView%.prototype.getInt16
%DataView%.prototype.getInt16.length
%DataView%.prototype.getInt16.name
%DataView%.prototype.getInt32
%DataView%.prototype.getInt32.length
%DataView%.prototype.getInt32.name
%DataView%.prototype.getInt8
%DataView%.prototype.getInt8.length
%DataView%.prototype.getInt8.name
%DataView%.prototype.getUint16
%DataView%.prototype.getUint16.length
%DataView%.prototype.getUint16.name
%DataView%.prototype.getUint32
%DataView%.prototype.getUint32.length
%DataView%.prototype.getUint32.name
%DataView%.prototype.getUint8
%DataView%.prototype.getUint8.length
%DataView%.prototype.getUint8.name
%DataView%.prototype.setBigInt64
%DataView%.prototype.setBigInt64.length
%DataView%.prototype.setBigInt64.name
%DataView%.prototype.setBigUint64
%DataView%.prototype.setBigUint64.length
%DataView%.prototype.setBigUint64.name
%DataView%.prototype.setFloat32
%DataView%.prototype.setFloat32.length
%DataView%.prototype.setFloat32.name
%DataView%.prototype.setFloat64
%DataView%.prototype.setFloat64.length
%DataView%.prototype.setFloat64.name
%DataView%.prototype.setInt16
%DataView%.prototype.setInt16.length
%DataView%.prototype.setInt16.name
%DataView%.prototype.setInt32
%DataView%.prototype.setInt32.length
%DataView%.prototype.setInt32.name
%DataView%.prototype.setInt8
%DataView%.prototype.setInt8.length
%DataView%.prototype.setInt8.name
%DataView%.prototype.setUint16
%DataView%.prototype.setUint16.length
%DataView%.prototype.setUint16.name
%DataView%.prototype.setUint32
%DataView%.prototype.setUint32.length
%DataView%.prototype.setUint32.name
%DataView%.prototype.setUint8
%DataView%.prototype.setUint8.length
%DataView%.prototype.setUint8.name
%DataView%.prototype[Symbol.toStringTag]
%Date%
%Date%.UTC
%Date%.UTC.length
%Date%.UTC.name
%Date%.length
%Date%.name
%Date%.now
%Date%.now.length
%Date%.now.name
%Date%.parse
%Date%.parse.length
%Date%.parse.name
%Date%.prototype
%Date%.prototype.constructor
%Date%.prototype.getDate
%Date%.prototype.getDate.length
%Date%.prototype.getDate.name
%Date%.prototype.getDay
%Date%.prototype.getDay.length
%Date%.prototype.getDay.name
%Date%.prototype.getFullYear
%Date%.prototype.getFullYear.length
%Date%.prototype.getFullYear.name
%Date%.prototype.getHours
%Date%.prototype.getHours.length
%Date%.prototype.getHours.name
%Date%.prototype.getMilliseconds
%Date%.prototype.getMilliseconds.length
%Date%.prototype.getMilliseconds.name
%Date%.prototype.getMinutes
%Date%.prototype.getMinutes.length
%Date%.prototype.getMinutes.name
%Date%.prototype.getMonth
%Date%.prototype.getMonth.length
%Date%.prototype.getMonth.name
%Date%.prototype.getSeconds
%Date%.prototype.getSeconds.length
%Date%.prototype.getSeconds.name
%Date%.prototype.getTime
%Date%.prototype.getTime.length
%Date%.prototype.getTime.name
%Date%.prototype.getTimezoneOffset
%Date%.prototype.getTimezoneOffset.length
%Date%.prototype.getTimezoneOffset.name
%Date%.prototype.getUTCDate
%Date%.prototype.getUTCDate.length
%Date%.prototype.getUTCDate.name
%Date%.prototype.getUTCDay
%Date%.prototype.getUTCDay.length
%Date%.prototype.getUTCDay.name
%Date%.prototype.getUTCFullYear
%Date%.prototype.getUTCFullYear.length
%Date%.prototype.getUTCFullYear.name
%Date%.prototype.getUTCHours
%Date%.prototype.getUTCHours.length
%Date%.prototype.getUTCHours.name
%Date%.prototype.getUTCMilliseconds
%Date%.prototype.getUTCMilliseconds.length
%Date%.prototype.getUTCMilliseconds.name
%Date%.prototype.getUTCMinutes
%Date%.prototype.getUTCMinutes.length
%Date%.prototype.getUTCMinutes.name
%Date%.prototype.getUTCMonth
%Date%.prototype.getUTCMonth.length
%Date%.prototype.getUTCMonth.name
%Date%.prototype.getUTCSeconds
%Date%.prototype.getUTCSeconds.length
%Date%.prototype.getUTCSeconds.name
%Date%.prototype.setDate
%Date%.prototype.setDate.length
%Date%.prototype.setDate.name
%Date%.prototype.setFullYear
%Date%.prototype.setFullYear.length
%Date%.prototype.setFullYear.name
%Date%.prototype.setHours
%Date%.prototype.setHours.length
%Date%.prototype.setHours.name
%Date%.prototype.setMilliseconds
%Date%.prototype.setMilliseconds.length
%Date%.prototype.setMilliseconds.name
%Date%.prototype.setMinutes
%Date%.prototype.setMinutes.length
%Date%.prototype.setMinutes.name
%Date%.prototype.setMonth
%Date%.prototype.setMonth.length
%Date%.prototype.setMonth.name
%Date%.prototype.setSeconds
%Date%.prototype.setSeconds.length
%Date%.prototype.setSeconds.name
%Date%.prototype.setTime
%Date%.prototype.setTime.length
%Date%.prototype.setTime.name
%Date%.prototype.setUTCDate
%Date%.prototype.setUTCDate.length
%Date%.prototype.setUTCDate.name
%Date%.prototype.setUTCFullYear
%Date%.prototype.setUTCFullYear.length
%Date%.prototype.setUTCFullYear.name
%Date%.prototype.setUTCHours
%Date%.prototype.setUTCHours.length
%Date%.prototype.setUTCHours.name
%Date%.prototype.setUTCMilliseconds
%Date%.prototype.setUTCMilliseconds.length
%Date%.prototype.setUTCMilliseconds.name
%Date%.prototype.setUTCMinutes
%Date%.prototype.setUTCMinutes.length
%Date%.prototype.setUTCMinutes.name
%Date%.prototype.setUTCMonth
%Date%.prototype.setUTCMonth.length
%Date%.prototype.setUTCMonth.name
%Date%.prototype.setUTCSeconds
%Date%.prototype.setUTCSeconds.length
%Date%.prototype.setUTCSeconds.name
%Date%.prototype.toDateString
%Date%.prototype.toDateString.length
%Date%.prototype.toDateString.name
%Date%.prototype.toISOString
%Date%.prototype.toISOString.length
%Date%.prototype.toISOString.name
%Date%.prototype.toJSON
%Date%.prototype.toJSON.length
%Date%.prototype.toJSON.name
%Date%.prototype.toLocaleDateString
%Date%.prototype.toLocaleDateString.length
%Date%.prototype.toLocaleDateString.name
%Date%.prototype.toLocaleString
%Date%.prototype.toLocaleString.length
%Date%.prototype.toLocaleString.name
%Date%.prototype.toLocaleTimeString
%Date%.prototype.toLocaleTimeString.length
%Date%.prototype.toLocaleTimeString.name
%Date%.prototype.toString
%Date%.prototype.toString.length
%Date%.prototype.toString.name
%Date%.prototype.toTimeString
%Date%.prototype.toTimeString.length
%Date%.prototype.toTimeString.name
%Date%.prototype.toUTCString
%Date%.prototype.toUTCString.length
%Date%.prototype.toUTCString.name
%Date%.prototype.valueOf
%Date%.prototype.valueOf.length
%Date%.prototype.valueOf.name
%Date%.prototype[Symbol.toPrimitive]
%Date%.prototype[Symbol.toPrimitive].length
%Date%.prototype[Symbol.toPrimitive].name
%Error%
%Error%.length
%Error%.name
%Error%.prototype
%Error%.prototype.constructor
%Error%.prototype.message
%Error%.prototype.name
%Error%.prototype.toString
%Error%.prototype.toString.length
%Error%.prototype.toString.name
%EvalError%
%EvalError%.length
%EvalError%.name
%EvalError%.prototype
%EvalError%.prototype.constructor
%EvalError%.prototype.message
%EvalError%.prototype.name
%FinalizationRegistry%
%FinalizationRegistry%.length
%FinalizationRegistry%.name
%FinalizationRegistry%.prototype
%FinalizationRegistry%.prototype.constructor
%FinalizationRegistry%.prototype.register
%FinalizationRegistry%.prototype.register.length
%FinalizationRegistry%.prototype.register.name
%FinalizationRegistry%.prototype.unregister
%FinalizationRegistry%.prototype.unregister.length
%FinalizationRegistry%.prototype.unregister.name
%FinalizationRegistry%.prototype[Symbol.toStringTag]
%Float32Array%
%Float32Array%.BYTES_PER_ELEMENT
%Float32Array%.length
%Float32Array%.name
%Float32Array%.prototype
%Float32Array%.prototype.BYTES_PER_ELEMENT
%Float32Array%.prototype.constructor
%Float64Array%
%Float64Array%.BYTES_PER_ELEMENT
%Float64Array%.length
%Float64Array%.name
%Float64Array%.prototype
%Float64Array%.prototype.BYTES_PER_ELEMENT
%Float64Array%.prototype.constructor
%Function%
%Function%.length
%Function%.name
%Function%.prototype
%Function%.prototype.apply
%Function%.prototype.apply.length
%Function%.prototype.apply.name
%Function%.prototype.arguments.#get
%Function%.prototype.arguments.#set
%Function%.prototype.bind
%Function%.prototype.bind.length
%Function%.prototype.bind.name
%Function%.prototype.call
%Function%.prototype.call.length
%Function%.prototype.call.name
%Function%.prototype.caller.#get
%Function%.prototype.caller.#set
%Function%.prototype.constructor
%Function%.prototype.length
%Function%.prototype.name
%Function%.prototype.toString
%Function%.prototype.toString.length
%Function%.prototype.toString.name
%Function%.prototype[Symbol.hasInstance]
%Function%.prototype[Symbol.hasInstance].length
%Function%.prototype[Symbol.hasInstance].name
%GeneratorFunction%
%GeneratorFunction%.length
%GeneratorFunction%.name
%GeneratorFunction%.prototype
%GeneratorFunction%.prototype.constructor
%GeneratorFunction%.prototype.prototype
%GeneratorFunction%.prototype.prototype.constructor
%GeneratorFunction%.prototype.prototype.next
%GeneratorFunction%.prototype.prototype.next.length
%GeneratorFunction%.prototype.prototype.next.name
%GeneratorFunction%.prototype.prototype.return
%GeneratorFunction%.prototype.prototype.return.length
%GeneratorFunction%.prototype.prototype.return.name
%GeneratorFunction%.prototype.prototype.throw
%GeneratorFunction%.prototype.prototype.throw.length
%GeneratorFunction%.prototype.prototype.throw.name
%GeneratorFunction%.prototype.prototype[Symbol.toStringTag]
%GeneratorFunction%.prototype[Symbol.toStringTag]
%Int16Array%
%Int16Array%.BYTES_PER_ELEMENT
%Int16Array%.length
%Int16Array%.name
%Int16Array%.prototype
%Int16Array%.prototype.BYTES_PER_ELEMENT
%Int16Array%.prototype.constructor
%Int32Array%
%Int32Array%.BYTES_PER_ELEMENT
%Int32Array%.length
%Int32Array%.name
%Int32Array%.prototype
%Int32Array%.prototype.BYTES_PER_ELEMENT
%Int32Array%.prototype.constructor
%Int8Array%
%Int8Array%.BYTES_PER_ELEMENT
%Int8Array%.length
%Int8Array%.name
%Int8Array%.prototype
%Int8Array%.prototype.BYTES_PER_ELEMENT
%Int8Array%.prototype.constructor
%IteratorPrototype%
%IteratorPrototype%[Symbol.iterator]
%IteratorPrototype%[Symbol.iterator].length
%IteratorPrototype%[Symbol.iterator].name
%JSON%
%JSON%.parse
%JSON%.parse.length
%JSON%.parse.name
%JSON%.stringify
%JSON%.stringify.length
%JSON%.stringify.name
%JSON%[Symbol.toStringTag]
%Map%
%Map%.length
%Map%.name
%Map%.prototype
%Map%.prototype.clear
%Map%.prototype.clear.length
%Map%.prototype.clear.name
%Map%.prototype.constructor
%Map%.prototype.delete
%Map%.prototype.delete.length
%Map%.prototype.delete.name
%Map%.prototype.entries
%Map%.prototype.entries.length
%Map%.prototype.entries.name
%Map%.prototype.forEach
%Map%.prototype.forEach.length
%Map%.prototype.forEach.name
%Map%.prototype.get
%Map%.prototype.get.length
%Map%.prototype.get.name
%Map%.prototype.has
%Map%.prototype.has.length
%Map%.prototype.has.name
%Map%.prototype.keys
%Map%.prototype.keys.length
%Map%.prototype.keys.name
%Map%.prototype.set
%Map%.prototype.set.length
%Map%.prototype.set.name
%Map%.prototype.size.#get
%Map%.prototype.size.#get.length
%Map%.prototype.size.#get.name
%Map%.prototype.values
%Map%.prototype.values.length
%Map%.prototype.values.name
%Map%.prototype[Symbol.iterator]
%Map%.prototype[Symbol.toStringTag]
%Map%[Symbol.species].#get
%Map%[Symbol.species].#get.length
%Map%[Symbol.species].#get.name
%MapIteratorPrototype%
%MapIteratorPrototype%.next
%MapIteratorPrototype%.next.length
%MapIteratorPrototype%.next.name
%MapIteratorPrototype%[Symbol.toStringTag]
%Math%
%Math%.E
%Math%.LN10
%Math%.LN2
%Math%.LOG10E
%Math%.LOG2E
%Math%.PI
%Math%.SQRT1_2
%Math%.SQRT2
%Math%.abs
%Math%.abs.length
%Math%.abs.name
%Math%.acos
%Math%.acos.length
%Math%.acos.name
%Math%.acosh
%Math%.acosh.length
%Math%.acosh.name
%Math%.asin
%Math%.asin.length
%Math%.asin.name
%Math%.asinh
%Math%.asinh.length
%Math%.asinh.name
%Math%.atan
%Math%.atan.length
%Math%.atan.name
%Math%.atan2
%Math%.atan2.length
%Math%.atan2.name
%Math%.atanh
%Math%.atanh.length
%Math%.atanh.name
%Math%.cbrt
%Math%.cbrt.length
%Math%.cbrt.name
%Math%.ceil
%Math%.ceil.length
%Math%.ceil.name
%Math%.clz32
%Math%.clz32.length
%Math%.clz32.name
%Math%.cos
%Math%.cos.length
%Math%.cos.name
%Math%.cosh
%Math%.cosh.length
%Math%.cosh.name
%Math%.exp
%Math%.exp.length
%Math%.exp.name
%Math%.expm1
%Math%.expm1.length
%Math%.expm1.name
%Math%.floor
%Math%.floor.length
%Math%.floor.name
%Math%.fround
%Math%.fround.length
%Math%.fround.name
%Math%.hypot
%Math%.hypot.length
%Math%.hypot.name
%Math%.imul
%Math%.imul.length
%Math%.imul.name
%Math%.log
%Math%.log.length
%Math%.log.name
%Math%.log10
%Math%.log10.length
%Math%.log10.name
%Math%.log1p
%Math%.log1p.length
%Math%.log1p.name
%Math%.log2
%Math%.log2.length
%Math%.log2.name
%Math%.max
%Math%.max.length
%Math%.max.name
%Math%.min
%Math%.min.length
%Math%.min.name
%Math%.pow
%Math%.pow.length
%Math%.pow.name
%Math%.random
%Math%.random.length
%Math%.random.name
%Math%.round
%Math%.round.length
%Math%.round.name
%Math%.sign
%Math%.sign.length
%Math%.sign.name
%Math%.sin
%Math%.sin.length
%Math%.sin.name
%Math%.sinh
%Math%.sinh.length
%Math%.sinh.name
%Math%.sqrt
%Math%.sqrt.length
%Math%.sqrt.name
%Math%.tan
%Math%.tan.length
%Math%.tan.name
%Math%.tanh
%Math%.tanh.length
%Math%.tanh.name
%Math%.trunc
%Math%.trunc.length
%Math%.trunc.name
%Math%[Symbol.toStringTag]
%Number%
%Number%.EPSILON
%Number%.MAX_SAFE_INTEGER
%Number%.MAX_VALUE
%Number%.MIN_SAFE_INTEGER
%Number%.MIN_VALUE
%Number%.NEGATIVE_INFINITY
%Number%.NaN
%Number%.POSITIVE_INFINITY
%Number%.isFinite
%Number%.isFinite.length
%Number%.isFinite.name
%Number%.isInteger
%Number%.isInteger.length
%Number%.isInteger.name
%Number%.isNaN
%Number%.isNaN.length
%Number%.isNaN.name
%Number%.isSafeInteger
%Number%.isSafeInteger.length
%Number%.isSafeInteger.name
%Number%.length
%Number%.name
%Number%.parseFloat
%Number%.parseInt
%Number%.prototype
%Number%.prototype.constructor
%Number%.prototype.toExponential
%Number%.prototype.toExponential.length
%Number%.prototype.toExponential.name
%Number%.prototype.toFixed
%Number%.prototype.toFixed.length
%Number%.prototype.toFixed.name
%Number%.prototype.toLocaleString
%Number%.prototype.toLocaleString.length
%Number%.prototype.toLocaleString.name
%Number%.prototype.toPrecision
%Number%.prototype.toPrecision.length
%Number%.prototype.toPrecision.name
%Number%.prototype.toString
%Number%.prototype.toString.length
%Number%.prototype.toString.name
%Number%.prototype.valueOf
%Number%.prototype.valueOf.length
%Number%.prototype.valueOf.name
%Object%
%Object%.assign
%Object%.assign.length
%Object%.assign.name
%Object%.create
%Object%.create.length
%Object%.create.name
%Object%.defineProperties
%Object%.defineProperties.length
%Object%.defineProperties.name
%Object%.defineProperty
%Object%.defineProperty.length
%Object%.defineProperty.name
%Object%.entries
%Object%.entries.length
%Object%.entries.name
%Object%.freeze
%Object%.freeze.length
%Object%.freeze.name
%Object%.fromEntries
%Object%.fromEntries.length
%Object%.fromEntries.name
%Object%.getOwnPropertyDescriptor
%Object%.getOwnPropertyDescriptor.length
%Object%.getOwnPropertyDescriptor.name
%Object%.getOwnPropertyDescriptors
%Object%.getOwnPropertyDescriptors.length
%Object%.getOwnPropertyDescriptors.name
%Object%.getOwnPropertyNames
%Object%.getOwnPropertyNames.length
%Object%.getOwnPropertyNames.name
%Object%.getOwnPropertySymbols
%Object%.getOwnPropertySymbols.length
%Object%.getOwnPropertySymbols.name
%Object%.getPrototypeOf
%Object%.getPrototypeOf.length
%Object%.getPrototypeOf.name
%Object%.hasOwn
%Object%.hasOwn.length
%Object%.hasOwn.name
%Object%.is
%Object%.is.length
%Object%.is.name
%Object%.isExtensible
%Object%.isExtensible.length
%Object%.isExtensible.name
%Object%.isFrozen
%Object%.isFrozen.length
%Object%.isFrozen.name
%Object%.isSealed
%Object%.isSealed.length
%Object%.isSealed.name
%Object%.keys
%Object%.keys.length
%Object%.keys.name
%Object%.length
%Object%.name
%Object%.preventExtensions
%Object%.preventExtensions.length
%Object%.preventExtensions.name
%Object%.prototype
%Object%.prototype.constructor
%Object%.prototype.hasOwnProperty
%Object%.prototype.hasOwnProperty.length
%Object%.prototype.hasOwnProperty.name
%Object%.prototype.isPrototypeOf
%Object%.prototype.isPrototypeOf.length
%Object%.prototype.isPrototypeOf.name
%Object%.prototype.propertyIsEnumerable
%Object%.prototype.propertyIsEnumerable.length
%Object%.prototype.propertyIsEnumerable.name
%Object%.prototype.toLocaleString
%Object%.prototype.toLocaleString.length
%Object%.prototype.toLocaleString.name
%Object%.prototype.toString
%Object%.prototype.toString.length
%Object%.prototype.toString.name
%Object%.prototype.valueOf
%Object%.prototype.valueOf.length
%Object%.prototype.valueOf.name
%Object%.seal
%Object%.seal.length
%Object%.seal.name
%Object%.setPrototypeOf
%Object%.setPrototypeOf.length
%Object%.setPrototypeOf.name
%Object%.values
%Object%.values.length
%Object%.values.name
%Promise%
%Promise%.all
%Promise%.all.length
%Promise%.all.name
%Promise%.allSettled
%Promise%.allSettled.length
%Promise%.allSettled.name
%Promise%.any
%Promise%.any.length
%Promise%.any.name
%Promise%.length
%Promise%.name
%Promise%.prototype
%Promise%.prototype.catch
%Promise%.prototype.catch.length
%Promise%.prototype.catch.name
%Promise%.prototype.constructor
%Promise%.prototype.finally
%Promise%.prototype.finally.length
%Promise%.prototype.finally.name
%Promise%.prototype.then
%Promise%.prototype.then.length
%Promise%.prototype.then.name
%Promise%.prototype[Symbol.toStringTag]
%Promise%.race
%Promise%.race.length
%Promise%.race.name
%Promise%.reject
%Promise%.reject.length
%Promise%.reject.name
%Promise%.resolve
%Promise%.resolve.length
%Promise%.resolve.name
%Promise%[Symbol.species].#get
%Promise%[Symbol.species].#get.length
%Promise%[Symbol.species].#get.name
%Proxy%
%Proxy%.length
%Proxy%.name
%Proxy%.revocable
%Proxy%.revocable.length
%Proxy%.revocable.name
%RangeError%
%RangeError%.length
%RangeError%.name
%RangeError%.prototype
%RangeError%.prototype.constructor
%RangeError%.prototype.message
%RangeError%.prototype.name
%ReferenceError%
%ReferenceError%.length
%ReferenceError%.name
%ReferenceError%.prototype
%ReferenceError%.prototype.constructor
%ReferenceError%.prototype.message
%ReferenceError%.prototype.name
%Reflect%
%Reflect%.apply
%Reflect%.apply.length
%Reflect%.apply.name
%Reflect%.construct
%Reflect%.construct.length
%Reflect%.construct.name
%Reflect%.defineProperty
%Reflect%.defineProperty.length
%Reflect%.defineProperty.name
%Reflect%.deleteProperty
%Reflect%.deleteProperty.length
%Reflect%.deleteProperty.name
%Reflect%.get
%Reflect%.get.length
%Reflect%.get.name
%Reflect%.getOwnPropertyDescriptor
%Reflect%.getOwnPropertyDescriptor.length
%Reflect%.getOwnPropertyDescriptor.name
%Reflect%.getPrototypeOf
%Reflect%.getPrototypeOf.length
%Reflect%.getPrototypeOf.name
%Reflect%.has
%Reflect%.has.length
%Reflect%.has.name
%Reflect%.isExtensible
%Reflect%.isExtensible.length
%Reflect%.isExtensible.name
%Reflect%.ownKeys
%Reflect%.ownKeys.length
%Reflect%.ownKeys.name
%Reflect%.preventExtensions
%Reflect%.preventExtensions.length
%Reflect%.preventExtensions.name
%Reflect%.set
%Reflect%.set.length
%Reflect%.set.name
%Reflect%.setPrototypeOf
%Reflect%.setPrototypeOf.length
%Reflect%.setPrototypeOf.name
%Reflect%[Symbol.toStringTag]
%RegExp%
%RegExp%.length
%RegExp%.name
%RegExp%.prototype
%RegExp%.prototype.constructor
%RegExp%.prototype.dotAll.#get
%RegExp%.prototype.dotAll.#get.length
%RegExp%.prototype.dotAll.#get.name
%RegExp%.prototype.exec
%RegExp%.prototype.exec.length
%RegExp%.prototype.exec.name
%RegExp%.prototype.flags.#get
%RegExp%.prototype.flags.#get.length
%RegExp%.prototype.flags.#get.name
%RegExp%.prototype.global.#get
%RegExp%.prototype.global.#get.length
%RegExp%.prototype.global.#get.name
%RegExp%.prototype.hasIndices.#get
%RegExp%.prototype.hasIndices.#get.length
%RegExp%.prototype.hasIndices.#get.name
%RegExp%.prototype.ignoreCase.#get
%RegExp%.prototype.ignoreCase.#get.length
%RegExp%.prototype.ignoreCase.#get.name
%RegExp%.prototype.multiline.#get
%RegExp%.prototype.multiline.#get.length
%RegExp%.prototype.multiline.#get.name
%RegExp%.prototype.source.#get
%RegExp%.prototype.source.#get.length
%RegExp%.prototype.source.#get.name
%RegExp%.prototype.sticky.#get
%RegExp%.prototype.sticky.#get.length
%RegExp%.prototype.sticky.#get.name
%RegExp%.prototype.test
%RegExp%.prototype.test.length
%RegExp%.prototype.test.name
%RegExp%.prototype.toString
%RegExp%.prototype.toString.length
%RegExp%.prototype.toString.name
%RegExp%.prototype.unicode.#get
%RegExp%.prototype.unicode.#get.length
%RegExp%.prototype.unicode.#get.name
%RegExp%.prototype[Symbol.matchAll]
%RegExp%.prototype[Symbol.matchAll].length
%RegExp%.prototype[Symbol.matchAll].name
%RegExp%.prototype[Symbol.match]
%RegExp%.prototype[Symbol.match].length
%RegExp%.prototype[Symbol.match].name
%RegExp%.prototype[Symbol.replace]
%RegExp%.prototype[Symbol.replace].length
%RegExp%.prototype[Symbol.replace].name
%RegExp%.prototype[Symbol.search]
%RegExp%.prototype[Symbol.search].length
%RegExp%.prototype[Symbol.search].name
%RegExp%.prototype[Symbol.split]
%RegExp%.prototype[Symbol.split].length
%RegExp%.prototype[Symbol.split].name
%RegExp%[Symbol.species].#get
%RegExp%[Symbol.species].#get.length
%RegExp%[Symbol.species].#get.name
%RegExpStringIteratorPrototype%
%RegExpStringIteratorPrototype%.next
%RegExpStringIteratorPrototype%.next.length
%RegExpStringIteratorPrototype%.next.name
%RegExpStringIteratorPrototype%[Symbol.toStringTag]
%Set%
%Set%.length
%Set%.name
%Set%.prototype
%Set%.prototype.add
%Set%.prototype.add.length
%Set%.prototype.add.name
%Set%.prototype.clear
%Set%.prototype.clear.length
%Set%.prototype.clear.name
%Set%.prototype.constructor
%Set%.prototype.delete
%Set%.prototype.delete.length
%Set%.prototype.delete.name
%Set%.prototype.entries
%Set%.prototype.entries.length
%Set%.prototype.entries.name
%Set%.prototype.forEach
%Set%.prototype.forEach.length
%Set%.prototype.forEach.name
%Set%.prototype.has
%Set%.prototype.has.length
%Set%.prototype.has.name
%Set%.prototype.keys
%Set%.prototype.size.#get
%Set%.prototype.size.#get.length
%Set%.prototype.size.#get.name
%Set%.prototype.values
%Set%.prototype.values.length
%Set%.prototype.values.name
%Set%.prototype[Symbol.iterator]
%Set%.prototype[Symbol.toStringTag]
%Set%[Symbol.species].#get
%Set%[Symbol.species].#get.length
%Set%[Symbol.species].#get.name
%SetIteratorPrototype%
%SetIteratorPrototype%.next
%SetIteratorPrototype%.next.length
%SetIteratorPrototype%.next.name
%SetIteratorPrototype%[Symbol.toStringTag]
%String%
%String%.fromCharCode
%String%.fromCharCode.length
%String%.fromCharCode.name
%String%.fromCodePoint
%String%.fromCodePoint.length
%String%.fromCodePoint.name
%String%.length
%String%.name
%String%.prototype
%String%.prototype.at
%String%.prototype.at.length
%String%.prototype.at.name
%String%.prototype.charAt
%String%.prototype.charAt.length
%String%.prototype.charAt.name
%String%.prototype.charCodeAt
%String%.prototype.charCodeAt.length
%String%.prototype.charCodeAt.name
%String%.prototype.codePointAt
%String%.prototype.codePointAt.length
%String%.prototype.codePointAt.name
%String%.prototype.concat
%String%.prototype.concat.length
%String%.prototype.concat.name
%String%.prototype.constructor
%String%.prototype.endsWith
%String%.prototype.endsWith.length
%String%.prototype.endsWith.name
%String%.prototype.includes
%String%.prototype.includes.length
%String%.prototype.includes.name
%String%.prototype.indexOf
%String%.prototype.indexOf.length
%String%.prototype.indexOf.name
%String%.prototype.lastIndexOf
%String%.prototype.lastIndexOf.length
%String%.prototype.lastIndexOf.name
%String%.prototype.length
%String%.prototype.localeCompare
%String%.prototype.localeCompare.length
%String%.prototype.localeCompare.name
%String%.prototype.match
%String%.prototype.match.length
%String%.prototype.match.name
%String%.prototype.matchAll
%String%.prototype.matchAll.length
%String%.prototype.matchAll.name
%String%.prototype.normalize
%String%.prototype.normalize.length
%String%.prototype.normalize.name
%String%.prototype.padEnd
%String%.prototype.padEnd.length
%String%.prototype.padEnd.name
%String%.prototype.padStart
%String%.prototype.padStart.length
%String%.prototype.padStart.name
%String%.prototype.repeat
%String%.prototype.repeat.length
%String%.prototype.repeat.name
%String%.prototype.replace
%String%.prototype.replace.length
%String%.prototype.replace.name
%String%.prototype.replaceAll
%String%.prototype.replaceAll.length
%String%.prototype.replaceAll.name
%String%.prototype.search
%String%.prototype.search.length
%String%.prototype.search.name
%String%.prototype.slice
%String%.prototype.slice.length
%String%.prototype.slice.name
%String%.prototype.split
%String%.prototype.split.length
%String%.prototype.split.name
%String%.prototype.startsWith
%String%.prototype.startsWith.length
%String%.prototype.startsWith.name
%String%.prototype.substr
%String%.prototype.substr.length
%String%.prototype.substr.name
%String%.prototype.substring
%String%.prototype.substring.length
%String%.prototype.substring.name
%String%.prototype.toLocaleLowerCase
%String%.prototype.toLocaleLowerCase.length
%String%.prototype.toLocaleLowerCase.name
%String%.prototype.toLocaleUpperCase
%String%.prototype.toLocaleUpperCase.length
%String%.prototype.toLocaleUpperCase.name
%String%.prototype.toLowerCase
%String%.prototype.toLowerCase.length
%String%.prototype.toLowerCase.name
%String%.prototype.toString
%String%.prototype.toString.length
%String%.prototype.toString.name
%String%.prototype.toUpperCase
%String%.prototype.toUpperCase.length
%String%.prototype.toUpperCase.name
%String%.prototype.trim
%String%.prototype.trim.length
%String%.prototype.trim.name
%String%.prototype.trimEnd
%String%.prototype.trimEnd.length
%String%.prototype.trimEnd.name
%String%.prototype.trimStart
%String%.prototype.trimStart.length
%String%.prototype.trimStart.name
%String%.prototype.valueOf
%String%.prototype.valueOf.length
%String%.prototype.valueOf.name
%String%.prototype[Symbol.iterator]
%String%.prototype[Symbol.iterator].length
%String%.prototype[Symbol.iterator].name
%String%.raw
%String%.raw.length
%String%.raw.name
%StringIteratorPrototype%
%StringIteratorPrototype%.next
%StringIteratorPrototype%.next.length
%StringIteratorPrototype%.next.name
%StringIteratorPrototype%[Symbol.toStringTag]
%Symbol%
%Symbol%.asyncIterator
%Symbol%.for
%Symbol%.for.length
%Symbol%.for.name
%Symbol%.hasInstance
%Symbol%.isConcatSpreadable
%Symbol%.iterator
%Symbol%.keyFor
%Symbol%.keyFor.length
%Symbol%.keyFor.name
%Symbol%.length
%Symbol%.match
%Symbol%.matchAll
%Symbol%.name
%Symbol%.prototype
%Symbol%.prototype.constructor
%Symbol%.prototype.description.#get
%Symbol%.prototype.description.#get.length
%Symbol%.prototype.description.#get.name
%Symbol%.prototype.toString
%Symbol%.prototype.toString.length
%Symbol%.prototype.toString.name
%Symbol%.prototype.valueOf
%Symbol%.prototype.valueOf.length
%Symbol%.prototype.valueOf.name
%Symbol%.prototype[Symbol.toPrimitive]
%Symbol%.prototype[Symbol.toPrimitive].length
%Symbol%.prototype[Symbol.toPrimitive].name
%Symbol%.prototype[Symbol.toStringTag]
%Symbol%.replace
%Symbol%.search
%Symbol%.species
%Symbol%.split
%Symbol%.toPrimitive
%Symbol%.toStringTag
%Symbol%.unscopables
%SyntaxError%
%SyntaxError%.length
%SyntaxError%.name
%SyntaxError%.prototype
%SyntaxError%.prototype.constructor
%SyntaxError%.prototype.message
%SyntaxError%.prototype.name
%ThrowTypeError%
%ThrowTypeError%.length
%ThrowTypeError%.name
%TypeError%
%TypeError%.length
%TypeError%.name
%TypeError%.prototype
%TypeError%.prototype.constructor
%TypeError%.prototype.message
%TypeError%.prototype.name
%TypedArray%
%TypedArray%.from
%TypedArray%.from.length
%TypedArray%.from.name
%TypedArray%.length
%TypedArray%.name
%TypedArray%.of
%TypedArray%.of.length
%TypedArray%.of.name
%TypedArray%.prototype
%TypedArray%.prototype.at
%TypedArray%.prototype.at.length
%TypedArray%.prototype.at.name
%TypedArray%.prototype.buffer.#get
%TypedArray%.prototype.buffer.#get.length
%TypedArray%.prototype.buffer.#get.name
%TypedArray%.prototype.byteLength.#get
%TypedArray%.prototype.byteLength.#get.length
%TypedArray%.prototype.byteLength.#get.name
%TypedArray%.prototype.byteOffset.#get
%TypedArray%.prototype.byteOffset.#get.length
%TypedArray%.prototype.byteOffset.#get.name
%TypedArray%.prototype.constructor
%TypedArray%.prototype.copyWithin
%TypedArray%.prototype.copyWithin.length
%TypedArray%.prototype.copyWithin.name
%TypedArray%.prototype.entries
%TypedArray%.prototype.entries.length
%TypedArray%.prototype.entries.name
%TypedArray%.prototype.every
%TypedArray%.prototype.every.length
%TypedArray%.prototype.every.name
%TypedArray%.prototype.fill
%TypedArray%.prototype.fill.length
%TypedArray%.prototype.fill.name
%TypedArray%.prototype.filter
%TypedArray%.prototype.filter.length
%TypedArray%.prototype.filter.name
%TypedArray%.prototype.find
%TypedArray%.prototype.find.length
%TypedArray%.prototype.find.name
%TypedArray%.prototype.findIndex
%TypedArray%.prototype.findIndex.length
%TypedArray%.prototype.findIndex.name
%TypedArray%.prototype.findLast
%TypedArray%.prototype.findLast.length
%TypedArray%.prototype.findLast.name
%TypedArray%.prototype.findLastIndex
%TypedArray%.prototype.findLastIndex.length
%TypedArray%.prototype.findLastIndex.name
%TypedArray%.prototype.forEach
%TypedArray%.prototype.forEach.length
%TypedArray%.prototype.forEach.name
%TypedArray%.prototype.includes
%TypedArray%.prototype.includes.length
%TypedArray%.prototype.includes.name
%TypedArray%.prototype.indexOf
%TypedArray%.prototype.indexOf.length
%TypedArray%.prototype.indexOf.name
%TypedArray%.prototype.join
%TypedArray%.prototype.join.length
%TypedArray%.prototype.join.name
%TypedArray%.prototype.keys
%TypedArray%.prototype.keys.length
%TypedArray%.prototype.keys.name
%TypedArray%.prototype.lastIndexOf
%TypedArray%.prototype.lastIndexOf.length
%TypedArray%.prototype.lastIndexOf.name
%TypedArray%.prototype.length.#get
%TypedArray%.prototype.length.#get.length
%TypedArray%.prototype.length.#get.name
%TypedArray%.prototype.map
%TypedArray%.prototype.map.length
%TypedArray%.prototype.map.name
%TypedArray%.prototype.reduce
%TypedArray%.prototype.reduce.length
%TypedArray%.prototype.reduce.name
%TypedArray%.prototype.reduceRight
%TypedArray%.prototype.reduceRight.length
%TypedArray%.prototype.reduceRight.name
%TypedArray%.prototype.reverse
%TypedArray%.prototype.reverse.length
%TypedArray%.prototype.reverse.name
%TypedArray%.prototype.set
%TypedArray%.prototype.set.length
%TypedArray%.prototype.set.name
%TypedArray%.prototype.slice
%TypedArray%.prototype.slice.length
%TypedArray%.prototype.slice.name
%TypedArray%.prototype.some
%TypedArray%.prototype.some.length
%TypedArray%.prototype.some.name
%TypedArray%.prototype.sort
%TypedArray%.prototype.sort.length
%TypedArray%.prototype.sort.name
%TypedArray%.prototype.subarray
%TypedArray%.prototype.subarray.length
%TypedArray%.prototype.subarray.name
%TypedArray%.prototype.toLocaleString
%TypedArray%.prototype.toLocaleString.length
%TypedArray%.prototype.toLocaleString.name
%TypedArray%.prototype.toString
%TypedArray%.prototype.values
%TypedArray%.prototype.values.length
%TypedArray%.prototype.values.name
%TypedArray%.prototype[Symbol.iterator]
%TypedArray%.prototype[Symbol.toStringTag].#get
%TypedArray%.prototype[Symbol.toStringTag].#get.length
%TypedArray%.prototype[Symbol.toStringTag].#get.name
%TypedArray%[Symbol.species].#get
%TypedArray%[Symbol.species].#get.length
%TypedArray%[Symbol.species].#get.name
%URIError%
%URIError%.length
%URIError%.name
%URIError%.prototype
%URIError%.prototype.constructor
%URIError%.prototype.message
%URIError%.prototype.name
%Uint16Array%
%Uint16Array%.BYTES_PER_ELEMENT
%Uint16Array%.length
%Uint16Array%.name
%Uint16Array%.prototype
%Uint16Array%.prototype.BYTES_PER_ELEMENT
%Uint16Array%.prototype.constructor
%Uint32Array%
%Uint32Array%.BYTES_PER_ELEMENT
%Uint32Array%.length
%Uint32Array%.name
%Uint32Array%.prototype
%Uint32Array%.prototype.BYTES_PER_ELEMENT
%Uint32Array%.prototype.constructor
%Uint8Array%
%Uint8Array%.BYTES_PER_ELEMENT
%Uint8Array%.length
%Uint8Array%.name
%Uint8Array%.prototype
%Uint8Array%.prototype.BYTES_PER_ELEMENT
%Uint8Array%.prototype.constructor
%Uint8ClampedArray%
%Uint8ClampedArray%.BYTES_PER_ELEMENT
%Uint8ClampedArray%.length
%Uint8ClampedArray%.name
%Uint8ClampedArray%.prototype
%Uint8ClampedArray%.prototype.BYTES_PER_ELEMENT
%Uint8ClampedArray%.prototype.constructor
%WeakMap%
%WeakMap%.length
%WeakMap%.name
%WeakMap%.prototype
%WeakMap%.prototype.constructor
%WeakMap%.prototype.delete
%WeakMap%.prototype.delete.length
%WeakMap%.prototype.delete.name
%WeakMap%.prototype.get
%WeakMap%.prototype.get.length
%WeakMap%.prototype.get.name
%WeakMap%.prototype.has
%WeakMap%.prototype.has.length
%WeakMap%.prototype.has.name
%WeakMap%.prototype.set
%WeakMap%.prototype.set.length
%WeakMap%.prototype.set.name
%WeakMap%.prototype[Symbol.toStringTag]
%WeakRef%
%WeakRef%.length
%WeakRef%.name
%WeakRef%.prototype
%WeakRef%.prototype.deref
%WeakRef%.prototype.deref.length
%WeakRef%.prototype.deref.name
%WeakRef%.prototype[Symbol.toStringTag]
%WeakSet%
%WeakSet%.length
%WeakSet%.name
%WeakSet%.prototype
%WeakSet%.prototype.add
%WeakSet%.prototype.add.length
%WeakSet%.prototype.add.name
%WeakSet%.prototype.constructor
%WeakSet%.prototype.delete
%WeakSet%.prototype.delete.length
%WeakSet%.prototype.delete.name
%WeakSet%.prototype.has
%WeakSet%.prototype.has.length
%WeakSet%.prototype.has.name
%WeakSet%.prototype[Symbol.toStringTag]
%decodeURI%
%decodeURI%.length
%decodeURI%.name
%decodeURIComponent%
%decodeURIComponent%.length
%decodeURIComponent%.name
%encodeURI%
%encodeURI%.length
%encodeURI%.name
%encodeURIComponent%
%encodeURIComponent%.length
%encodeURIComponent%.name
%isFinite%
%isFinite%.length
%isFinite%.name
%isNaN%
%isNaN%.length
%isNaN%.name
%parseFloat%
%parseFloat%.length
%parseFloat%.name
%parseInt%
%parseInt%.length
%parseInt%.name

// ECMA-262: NORMATIVE OPTIONAL ////////////////////////////////////////////////
//
// Note that even though it isn’t described as “normative optional”, prose text
// also states that %SharedArrayBuffer% is omissable.

%WeakRef%.prototype.constructor

// ECMA-262: NORMATIVE OPTIONAL, LEGACY ////////////////////////////////////////

%Object%.prototype.__defineGetter__
%Object%.prototype.__defineGetter__.length
%Object%.prototype.__defineGetter__.name
%Object%.prototype.__defineSetter__
%Object%.prototype.__defineSetter__.length
%Object%.prototype.__defineSetter__.name
%Object%.prototype.__lookupGetter__
%Object%.prototype.__lookupGetter__.length
%Object%.prototype.__lookupGetter__.name
%Object%.prototype.__lookupSetter__
%Object%.prototype.__lookupSetter__.length
%Object%.prototype.__lookupSetter__.name
%Object%.prototype.__proto__.#get
%Object%.prototype.__proto__.#get.length
%Object%.prototype.__proto__.#get.name
%Object%.prototype.__proto__.#set
%Object%.prototype.__proto__.#set.length
%Object%.prototype.__proto__.#set.name

// ECMA-262: ANNEX B ///////////////////////////////////////////////////////////

%Date%.prototype.getYear
%Date%.prototype.getYear.length
%Date%.prototype.getYear.name
%Date%.prototype.setYear
%Date%.prototype.setYear.length
%Date%.prototype.setYear.name
%Date%.prototype.toGMTString
%RegExp%.prototype.compile
%RegExp%.prototype.compile.length
%RegExp%.prototype.compile.name
%String%.prototype.anchor
%String%.prototype.anchor.length
%String%.prototype.anchor.name
%String%.prototype.big
%String%.prototype.big.length
%String%.prototype.big.name
%String%.prototype.blink
%String%.prototype.blink.length
%String%.prototype.blink.name
%String%.prototype.bold
%String%.prototype.bold.length
%String%.prototype.bold.name
%String%.prototype.fixed
%String%.prototype.fixed.length
%String%.prototype.fixed.name
%String%.prototype.fontcolor
%String%.prototype.fontcolor.length
%String%.prototype.fontcolor.name
%String%.prototype.fontsize
%String%.prototype.fontsize.length
%String%.prototype.fontsize.name
%String%.prototype.italics
%String%.prototype.italics.length
%String%.prototype.italics.name
%String%.prototype.link
%String%.prototype.link.length
%String%.prototype.link.name
%String%.prototype.small
%String%.prototype.small.length
%String%.prototype.small.name
%String%.prototype.strike
%String%.prototype.strike.length
%String%.prototype.strike.name
%String%.prototype.sub
%String%.prototype.sub.length
%String%.prototype.sub.name
%String%.prototype.sup
%String%.prototype.sup.length
%String%.prototype.sup.name
%String%.prototype.trimLeft
%String%.prototype.trimRight
%escape%
%escape%.length
%escape%.name
%unescape%
%unescape%.length
%unescape%.name

// ECMA-402 ////////////////////////////////////////////////////////////////////
//
// The Intl spec specifies that each of the Intl.Foo constructors is itself a
// WKIO. This seems reasonable but note that the Temporal proposal does not
// follow the same pattern, instead only considering the %Temporal% namespace
// object (not present in this output) a WKIO.
//
// Since 402 also (re?) specifies toLocaleString methods, it’s fuzzy where to
// group those.

%Collator%
%Collator%.length
%Collator%.name
%Collator%.prototype
%Collator%.prototype.compare.#get
%Collator%.prototype.compare.#get.length
%Collator%.prototype.compare.#get.name
%Collator%.prototype.constructor
%Collator%.prototype.resolvedOptions
%Collator%.prototype.resolvedOptions.length
%Collator%.prototype.resolvedOptions.name
%Collator%.prototype[Symbol.toStringTag]
%Collator%.supportedLocalesOf
%Collator%.supportedLocalesOf.length
%Collator%.supportedLocalesOf.name
%DateTimeFormat%
%DateTimeFormat%.length
%DateTimeFormat%.name
%DateTimeFormat%.prototype
%DateTimeFormat%.prototype.constructor
%DateTimeFormat%.prototype.format.#get
%DateTimeFormat%.prototype.format.#get.length
%DateTimeFormat%.prototype.format.#get.name
%DateTimeFormat%.prototype.formatRange
%DateTimeFormat%.prototype.formatRange.length
%DateTimeFormat%.prototype.formatRange.name
%DateTimeFormat%.prototype.formatRangeToParts
%DateTimeFormat%.prototype.formatRangeToParts.length
%DateTimeFormat%.prototype.formatRangeToParts.name
%DateTimeFormat%.prototype.formatToParts
%DateTimeFormat%.prototype.formatToParts.length
%DateTimeFormat%.prototype.formatToParts.name
%DateTimeFormat%.prototype.resolvedOptions
%DateTimeFormat%.prototype.resolvedOptions.length
%DateTimeFormat%.prototype.resolvedOptions.name
%DateTimeFormat%.prototype[Symbol.toStringTag]
%DateTimeFormat%.supportedLocalesOf
%DateTimeFormat%.supportedLocalesOf.length
%DateTimeFormat%.supportedLocalesOf.name
%DisplayNames%
%DisplayNames%.length
%DisplayNames%.name
%DisplayNames%.prototype
%DisplayNames%.prototype.constructor
%DisplayNames%.prototype.of
%DisplayNames%.prototype.of.length
%DisplayNames%.prototype.of.name
%DisplayNames%.prototype.resolvedOptions
%DisplayNames%.prototype.resolvedOptions.length
%DisplayNames%.prototype.resolvedOptions.name
%DisplayNames%.prototype[Symbol.toStringTag]
%DisplayNames%.supportedLocalesOf
%DisplayNames%.supportedLocalesOf.length
%DisplayNames%.supportedLocalesOf.name
%Intl%
%Intl%.Collator
%Intl%.DateTimeFormat
%Intl%.DisplayNames
%Intl%.ListFormat
%Intl%.Locale
%Intl%.NumberFormat
%Intl%.PluralRules
%Intl%.RelativeTimeFormat
%Intl%.Segmenter
%Intl%.getCanonicalLocales
%Intl%.getCanonicalLocales.length
%Intl%.getCanonicalLocales.name
%Intl%.supportedValuesOf
%Intl%.supportedValuesOf.length
%Intl%.supportedValuesOf.name
%Intl%[Symbol.toStringTag]
%ListFormat%
%ListFormat%.length
%ListFormat%.name
%ListFormat%.prototype
%ListFormat%.prototype.constructor
%ListFormat%.prototype.format
%ListFormat%.prototype.format.length
%ListFormat%.prototype.format.name
%ListFormat%.prototype.formatToParts
%ListFormat%.prototype.formatToParts.length
%ListFormat%.prototype.formatToParts.name
%ListFormat%.prototype.resolvedOptions
%ListFormat%.prototype.resolvedOptions.length
%ListFormat%.prototype.resolvedOptions.name
%ListFormat%.prototype[Symbol.toStringTag]
%ListFormat%.supportedLocalesOf
%ListFormat%.supportedLocalesOf.length
%ListFormat%.supportedLocalesOf.name
%Locale%
%Locale%.length
%Locale%.name
%Locale%.prototype
%Locale%.prototype.baseName.#get
%Locale%.prototype.baseName.#get.length
%Locale%.prototype.baseName.#get.name
%Locale%.prototype.calendar.#get
%Locale%.prototype.calendar.#get.length
%Locale%.prototype.calendar.#get.name
%Locale%.prototype.calendars.#get
%Locale%.prototype.calendars.#get.length
%Locale%.prototype.calendars.#get.name
%Locale%.prototype.caseFirst.#get
%Locale%.prototype.caseFirst.#get.length
%Locale%.prototype.caseFirst.#get.name
%Locale%.prototype.collation.#get
%Locale%.prototype.collation.#get.length
%Locale%.prototype.collation.#get.name
%Locale%.prototype.collations.#get
%Locale%.prototype.collations.#get.length
%Locale%.prototype.collations.#get.name
%Locale%.prototype.constructor
%Locale%.prototype.hourCycle.#get
%Locale%.prototype.hourCycle.#get.length
%Locale%.prototype.hourCycle.#get.name
%Locale%.prototype.hourCycles.#get
%Locale%.prototype.hourCycles.#get.length
%Locale%.prototype.hourCycles.#get.name
%Locale%.prototype.language.#get
%Locale%.prototype.language.#get.length
%Locale%.prototype.language.#get.name
%Locale%.prototype.maximize
%Locale%.prototype.maximize.length
%Locale%.prototype.maximize.name
%Locale%.prototype.minimize
%Locale%.prototype.minimize.length
%Locale%.prototype.minimize.name
%Locale%.prototype.numberingSystem.#get
%Locale%.prototype.numberingSystem.#get.length
%Locale%.prototype.numberingSystem.#get.name
%Locale%.prototype.numberingSystems.#get
%Locale%.prototype.numberingSystems.#get.length
%Locale%.prototype.numberingSystems.#get.name
%Locale%.prototype.numeric.#get
%Locale%.prototype.numeric.#get.length
%Locale%.prototype.numeric.#get.name
%Locale%.prototype.region.#get
%Locale%.prototype.region.#get.length
%Locale%.prototype.region.#get.name
%Locale%.prototype.script.#get
%Locale%.prototype.script.#get.length
%Locale%.prototype.script.#get.name
%Locale%.prototype.textInfo.#get
%Locale%.prototype.textInfo.#get.length
%Locale%.prototype.textInfo.#get.name
%Locale%.prototype.timeZones.#get
%Locale%.prototype.timeZones.#get.length
%Locale%.prototype.timeZones.#get.name
%Locale%.prototype.toString
%Locale%.prototype.toString.length
%Locale%.prototype.toString.name
%Locale%.prototype.weekInfo.#get
%Locale%.prototype.weekInfo.#get.length
%Locale%.prototype.weekInfo.#get.name
%Locale%.prototype[Symbol.toStringTag]
%NumberFormat%
%NumberFormat%.length
%NumberFormat%.name
%NumberFormat%.prototype
%NumberFormat%.prototype.constructor
%NumberFormat%.prototype.format.#get
%NumberFormat%.prototype.format.#get.length
%NumberFormat%.prototype.format.#get.name
%NumberFormat%.prototype.formatToParts
%NumberFormat%.prototype.formatToParts.length
%NumberFormat%.prototype.formatToParts.name
%NumberFormat%.prototype.resolvedOptions
%NumberFormat%.prototype.resolvedOptions.length
%NumberFormat%.prototype.resolvedOptions.name
%NumberFormat%.prototype[Symbol.toStringTag]
%NumberFormat%.supportedLocalesOf
%NumberFormat%.supportedLocalesOf.length
%NumberFormat%.supportedLocalesOf.name
%PluralRules%
%PluralRules%.length
%PluralRules%.name
%PluralRules%.prototype
%PluralRules%.prototype.constructor
%PluralRules%.prototype.resolvedOptions
%PluralRules%.prototype.resolvedOptions.length
%PluralRules%.prototype.resolvedOptions.name
%PluralRules%.prototype.select
%PluralRules%.prototype.select.length
%PluralRules%.prototype.select.name
%PluralRules%.prototype[Symbol.toStringTag]
%PluralRules%.supportedLocalesOf
%PluralRules%.supportedLocalesOf.length
%PluralRules%.supportedLocalesOf.name
%RelativeTimeFormat%
%RelativeTimeFormat%.length
%RelativeTimeFormat%.name
%RelativeTimeFormat%.prototype
%RelativeTimeFormat%.prototype.constructor
%RelativeTimeFormat%.prototype.format
%RelativeTimeFormat%.prototype.format.length
%RelativeTimeFormat%.prototype.format.name
%RelativeTimeFormat%.prototype.formatToParts
%RelativeTimeFormat%.prototype.formatToParts.length
%RelativeTimeFormat%.prototype.formatToParts.name
%RelativeTimeFormat%.prototype.resolvedOptions
%RelativeTimeFormat%.prototype.resolvedOptions.length
%RelativeTimeFormat%.prototype.resolvedOptions.name
%RelativeTimeFormat%.prototype[Symbol.toStringTag]
%RelativeTimeFormat%.supportedLocalesOf
%RelativeTimeFormat%.supportedLocalesOf.length
%RelativeTimeFormat%.supportedLocalesOf.name

// ECMA-402 STAGE 3 PROPOSAL ///////////////////////////////////////////////////
//
// This was retrievable as it is already implemented in V8. Note that the
// proposal introduces a new WKIO that isn’t reachable with Get() alone,
// %SegmentIteratorPrototype%.
//
// Other new root WKIOs that may be introduced in the near-ish future include
// %Record%, %ShadowRealm%, %Tuple%.

%Segmenter%
%Segmenter%.length
%Segmenter%.name
%Segmenter%.prototype
%Segmenter%.prototype.constructor
%Segmenter%.prototype.resolvedOptions
%Segmenter%.prototype.resolvedOptions.length
%Segmenter%.prototype.resolvedOptions.name
%Segmenter%.prototype.segment
%Segmenter%.prototype.segment.length
%Segmenter%.prototype.segment.name
%Segmenter%.prototype[Symbol.toStringTag]
%Segmenter%.supportedLocalesOf
%Segmenter%.supportedLocalesOf.length
%Segmenter%.supportedLocalesOf.name
%SegmentIteratorPrototype%
%SegmentIteratorPrototype%.containing
%SegmentIteratorPrototype%.containing.length
%SegmentIteratorPrototype%.containing.name
%SegmentIteratorPrototype%[Symbol.iterator]
%SegmentIteratorPrototype%[Symbol.iterator].length
%SegmentIteratorPrototype%[Symbol.iterator].name

// NONSTANDARD REACHABLES FROM INTRINSIC OBJECTS IN V8  ////////////////////////
//
// These were hit during the crawl but are not standardized. The RegExp cases
// are unfortunate web reality while the v8BreakIterator is, naturally, specific
// to v8. I’m including these here just to show that they’re hit during a naive
// crawl — I would guess that they specifically shouldn’t be reachable with the
// getIntrinsic API, though.

%Error%.captureStackTrace
%Error%.captureStackTrace.length
%Error%.captureStackTrace.name
%Error%.stackTraceLimit
%Intl%.v8BreakIterator
%Intl%.v8BreakIterator.length
%Intl%.v8BreakIterator.name
%Intl%.v8BreakIterator.prototype
%Intl%.v8BreakIterator.prototype.adoptText.#get
%Intl%.v8BreakIterator.prototype.adoptText.#get.length
%Intl%.v8BreakIterator.prototype.adoptText.#get.name
%Intl%.v8BreakIterator.prototype.breakType.#get
%Intl%.v8BreakIterator.prototype.breakType.#get.length
%Intl%.v8BreakIterator.prototype.breakType.#get.name
%Intl%.v8BreakIterator.prototype.constructor
%Intl%.v8BreakIterator.prototype.current.#get
%Intl%.v8BreakIterator.prototype.current.#get.length
%Intl%.v8BreakIterator.prototype.current.#get.name
%Intl%.v8BreakIterator.prototype.first.#get
%Intl%.v8BreakIterator.prototype.first.#get.length
%Intl%.v8BreakIterator.prototype.first.#get.name
%Intl%.v8BreakIterator.prototype.next.#get
%Intl%.v8BreakIterator.prototype.next.#get.length
%Intl%.v8BreakIterator.prototype.next.#get.name
%Intl%.v8BreakIterator.prototype.resolvedOptions
%Intl%.v8BreakIterator.prototype.resolvedOptions.length
%Intl%.v8BreakIterator.prototype.resolvedOptions.name
%Intl%.v8BreakIterator.prototype[Symbol.toStringTag]
%Intl%.v8BreakIterator.supportedLocalesOf
%Intl%.v8BreakIterator.supportedLocalesOf.length
%Intl%.v8BreakIterator.supportedLocalesOf.name
%RegExp%.$1.#get
%RegExp%.$1.#get.length
%RegExp%.$1.#get.name
%RegExp%.$1.#set
%RegExp%.$1.#set.length
%RegExp%.$1.#set.name
%RegExp%.$2.#get
%RegExp%.$2.#get.length
%RegExp%.$2.#get.name
%RegExp%.$2.#set
%RegExp%.$2.#set.length
%RegExp%.$2.#set.name
%RegExp%.$3.#get
%RegExp%.$3.#get.length
%RegExp%.$3.#get.name
%RegExp%.$3.#set
%RegExp%.$3.#set.length
%RegExp%.$3.#set.name
%RegExp%.$4.#get
%RegExp%.$4.#get.length
%RegExp%.$4.#get.name
%RegExp%.$4.#set
%RegExp%.$4.#set.length
%RegExp%.$4.#set.name
%RegExp%.$5.#get
%RegExp%.$5.#get.length
%RegExp%.$5.#get.name
%RegExp%.$5.#set
%RegExp%.$5.#set.length
%RegExp%.$5.#set.name
%RegExp%.$6.#get
%RegExp%.$6.#get.length
%RegExp%.$6.#get.name
%RegExp%.$6.#set
%RegExp%.$6.#set.length
%RegExp%.$6.#set.name
%RegExp%.$7.#get
%RegExp%.$7.#get.length
%RegExp%.$7.#get.name
%RegExp%.$7.#set
%RegExp%.$7.#set.length
%RegExp%.$7.#set.name
%RegExp%.$8.#get
%RegExp%.$8.#get.length
%RegExp%.$8.#get.name
%RegExp%.$8.#set
%RegExp%.$8.#set.length
%RegExp%.$8.#set.name
%RegExp%.$9.#get
%RegExp%.$9.#get.length
%RegExp%.$9.#get.name
%RegExp%.$9.#set
%RegExp%.$9.#set.length
%RegExp%.$9.#set.name
%RegExp%.$_.#get
%RegExp%.$_.#get.length
%RegExp%.$_.#get.name
%RegExp%.$_.#set
%RegExp%.$_.#set.length
%RegExp%.$_.#set.name
%RegExp%.input.#get
%RegExp%.input.#get.length
%RegExp%.input.#get.name
%RegExp%.input.#set
%RegExp%.input.#set.length
%RegExp%.input.#set.name
%RegExp%.lastMatch.#get
%RegExp%.lastMatch.#get.length
%RegExp%.lastMatch.#get.name
%RegExp%.lastMatch.#set
%RegExp%.lastMatch.#set.length
%RegExp%.lastMatch.#set.name
%RegExp%.lastParen.#get
%RegExp%.lastParen.#get.length
%RegExp%.lastParen.#get.name
%RegExp%.lastParen.#set
%RegExp%.lastParen.#set.length
%RegExp%.lastParen.#set.name
%RegExp%.leftContext.#get
%RegExp%.leftContext.#get.length
%RegExp%.leftContext.#get.name
%RegExp%.leftContext.#set
%RegExp%.leftContext.#set.length
%RegExp%.leftContext.#set.name
%RegExp%.rightContext.#get
%RegExp%.rightContext.#get.length
%RegExp%.rightContext.#get.name
%RegExp%.rightContext.#set
%RegExp%.rightContext.#set.length
%RegExp%.rightContext.#set.name
%RegExp%["$&"].#get
%RegExp%["$&"].#get.length
%RegExp%["$&"].#get.name
%RegExp%["$&"].#set
%RegExp%["$&"].#set.length
%RegExp%["$&"].#set.name
%RegExp%["$'"].#get
%RegExp%["$'"].#get.length
%RegExp%["$'"].#get.name
%RegExp%["$'"].#set
%RegExp%["$'"].#set.length
%RegExp%["$'"].#set.name
%RegExp%["$+"].#get
%RegExp%["$+"].#get.length
%RegExp%["$+"].#get.name
%RegExp%["$+"].#set
%RegExp%["$+"].#set.length
%RegExp%["$+"].#set.name
%RegExp%["$`"].#get
%RegExp%["$`"].#get.length
%RegExp%["$`"].#get.name
%RegExp%["$`"].#set
%RegExp%["$`"].#set.length
%RegExp%["$`"].#set.name

[ljharb]

All the lengths and names, we don’t need to worry about.

[bathos]

That makes sense, I figured they wouldn’t be included. The list is showing every distinct path except for those which, if followed further, would cycle infinitely (in which case it only expands the shortest+alphabetically earliest). I didn’t know if primitive-value data properties would be considered addressable or if they would be but only selectively:

// Many of the properties are not references to objects, e.g. every function can
// reach "name" and "length". Perhaps these would be omitted, but note that if
// only objects are addressable, values of properties like Math.LOG2E and
// Int8Array.BYTES_PER_ELEMENT wouldn’t be included. A primitive value cannot be
// “intrinsic” per se, but the _property_ is, so this might be surprising.

[ljharb]

Properties of top-level namespaces are all included, but otherwise i don’t think any intrinsics are non-objects.

We’d also not traverse through any .constructor or .__proto__ properties (and probably wouldn’t support dunder proto at all)

[bathos]

Cool — I assumed no __proto__ traversal, but more broadly I assumed there’d be no “accessing accessors” with Get() at all (i.e. you can get the getter or setter, but cannot execute the getter). Most of those would throw TypeErrors anyway.

Is it possible/desirable for there to just be a finite set of “addresses”? It seems there are currently around ~600 unique intrinsic objects. With traversing constructor (and __proto__) out, so are the great majority of possible graph reentries. Even if objects/values don’t have a single “canonical” name (cause of e.g. values vs Symbol.iterator), it seems you can still end up with a static “collection” that doesn’t require actual parsing because there’s only so many possible keys (w/ most being 1:1).

[ljharb]

I'd prefer to find an algorithmic way of describing the list, rather than hardcoding it.

[bathos]

That makes sense — but afaict, an algorithmic explanation for what addresses exist can still produce a finite set of possible keys, obviating the need for (an implementation) to really parse & interpret the input as a DSL (even though it would act like one).

[ljharb]

So the rules perhaps could be:

1. Any accessor property is the end of the chain, and is not executed
2. Only own properties are included
3. A function's name, and a function's, string's, or array's length are not included.

Traversal is:

1. Any explicit top-level intrinsic in the table is included
2. Any own property initially available on those is included
3. Any object not accessed through "constructor" can be traversed into.

Thoughts?

[bathos]

Sounds great! Later I’ll try adjusting the traversal script I used to verify that it still reaches all of the same objects as it did with the more naive pass (modulo non-standard members) when those rules are (effectively) in play — but I’m pretty sure what you described does the trick. The resulting set of address keys should be both intuitive & “incidentally” finite.

[mhofman]

For reference, Endo/SES has some logic to crawl the global and remove anything that isn't in an allowlist which takes a similar form to a registry of intrinsics.