beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 07:30:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Libraries/LibJS/Runtime/CommonPropertyNames.h

661 lines
30 KiB
C
Raw Permalink Normal View History

LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
/*
Meta: Update my e-mail address everywhere
2024-10-04 11:19:50 +00:00
* Copyright (c) 2020, Andreas Kling <andreas@ladybird.org>
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00:00
* SPDX-License-Identifier: BSD-2-Clause
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
*/
#pragma once
AK+Everywhere: Rename FlyString to DeprecatedFlyString DeprecatedFlyString relies heavily on DeprecatedString's StringImpl, so let's rename it to A) match the name of DeprecatedString, B) write a new FlyString class that is tied to String.
2023-01-09 00:23:00 +00:00
#include <AK/DeprecatedFlyString.h>
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
#include <LibJS/Forward.h>
LibJS: Rename PropertyName to PropertyKey Let's use the same name as the spec. :^)
2021-10-24 14:01:24 +00:00
#include <LibJS/Runtime/PropertyKey.h>
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
namespace JS {
#define ENUMERATE_STANDARD_PROPERTY_NAMES(P) \
LibJS: Add the Object.prototype.__proto__ native accessor property This is part of the Annex B extension of the specification.
2021-06-17 11:12:38 +00:00
P(__proto__) \
LibJS: Add the Object.prototype.__define{Getter, Setter}__ methods These are a part of the Annex B extension of the specification.
2021-06-17 11:14:09 +00:00
P(__defineGetter__) \
P(__defineSetter__) \
LibJS: Add the Object.prototype.__lookup{Getter, Setter}__ methods These are a part of the Annex B extension of the specification.
2021-06-17 11:15:14 +00:00
P(__lookupGetter__) \
P(__lookupSetter__) \
LibJS: Implement RegExp legacy static properties RegExp legacy static properties Spec url is https://github.com/tc39/proposal-regexp-legacy-features
2022-10-17 00:59:27 +00:00
P($1) \
P($2) \
P($3) \
P($4) \
P($5) \
P($6) \
P($7) \
P($8) \
P($9) \
LibJS: Begin implementing Atomics This adds the Atomics object to the global object and sets up only its @@toStringTag property.
2021-07-11 02:53:54 +00:00
P(Atomics) \
LibJS: Add TypedArray.BYTES_PER_ELEMENT
2020-12-02 09:58:48 +00:00
P(BYTES_PER_ELEMENT) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(BigInt) \
P(Boolean) \
P(E) \
P(EPSILON) \
LibJS: Rename Function => FunctionObject
2021-06-27 19:48:34 +00:00
P(Function) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(Infinity) \
LibJS: Add the Intl namespace object :^) This is the start of implementing ECMA-402 in LibJS, better known as the ECMAScript Internationalization API. Much like Temporal this gets its own subdirectory (Runtime/Intl/) as well as a new C++ namespace (JS::Intl) so we don't have to prefix all the files and classes with "Intl". https://tc39.es/ecma402/
2021-08-08 17:27:28 +00:00
P(Intl) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(JSON) \
P(LN10) \
P(LN2) \
P(LOG10E) \
P(LOG2E) \
P(MAX_SAFE_INTEGER) \
LibJS: Add the Number.{MAX, MIN}_VALUE constants
2021-06-04 21:56:43 +00:00
P(MAX_VALUE) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(MIN_SAFE_INTEGER) \
LibJS: Add the Number.{MAX, MIN}_VALUE constants
2021-06-04 21:56:43 +00:00
P(MIN_VALUE) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(Math) \
P(NEGATIVE_INFINITY) \
P(NaN) \
LibJS: Rename Temporal.now => Temporal.Now See: - https://github.com/tc39/proposal-temporal/commit/d0acb66 - https://github.com/tc39/proposal-temporal/commit/0097fdd
2021-07-18 23:25:22 +00:00
P(Now) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(Number) \
P(PI) \
P(POSITIVE_INFINITY) \
P(Proxy) \
P(Reflect) \
P(RegExp) \
P(SQRT1_2) \
P(SQRT2) \
P(String) \
P(Symbol) \
LibJS: Add the Temporal namespace object :^) Currently empty, but we gotta start somewhere! This is the start of implementing the Temporal proposal (currently stage 3). I have decided to start a new subdirectory (Runtime/Temporal/) as well as a new C++ namespace (JS::Temporal) for this so we don't have to prefix all the files and classes with "Temporal" - there will be a lot. https://tc39.es/proposal-temporal/
2021-07-06 18:14:47 +00:00
P(Temporal) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(UTC) \
P(abs) \
LibJS: Add Math.acos() and Math.asin()
2020-12-08 15:22:07 +00:00
P(acos) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(acosh) \
LibJS: Add most of the Set.prototype methods Specifically all aside from "values" and "entries" which require an implementation of the SetIterator object.
2021-06-08 21:14:08 +00:00
P(add) \
LibJS: Add DisposableStack{, Prototype, Constructor} Since the async parts of the spec are not stage 3 at this point we don't add AsyncDisposableStack.
2022-12-21 10:48:14 +00:00
P(adopt) \
LibJS: Add initial support for Promises Almost a year after first working on this, it's finally done: an implementation of Promises for LibJS! :^) The core functionality is working and closely following the spec [1]. I mostly took the pseudo code and transformed it into C++ - if you read and understand it, you will know how the spec implements Promises; and if you read the spec first, the code will look very familiar. Implemented functions are: - Promise() constructor - Promise.prototype.then() - Promise.prototype.catch() - Promise.prototype.finally() - Promise.resolve() - Promise.reject() For the tests I added a new function to test-js's global object, runQueuedPromiseJobs(), which calls vm.run_queued_promise_jobs(). By design, queued jobs normally only run after the script was fully executed, making it improssible to test handlers in individual test() calls by default [2]. Subsequent commits include integrations into LibWeb and js(1) - pretty-printing, running queued promise jobs when necessary. This has an unusual amount of dbgln() statements, all hidden behind the PROMISE_DEBUG flag - I'm leaving them in for now as they've been very useful while debugging this, things can get quite complex with so many asynchronously executed functions. I've not extensively explored use of these APIs for promise-based functionality in LibWeb (fetch(), Notification.requestPermission() etc.), but we'll get there in due time. [1]: https://tc39.es/ecma262/#sec-promise-objects [2]: https://tc39.es/ecma262/#sec-jobs-and-job-queues
2021-04-01 20:13:29 +00:00
P(all) \
P(allSettled) \
LibJS: Implement Uint8Array.prototype.toBase64
2024-07-15 14:59:29 +00:00
P(alphabet) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-29 22:44:18 +00:00
P(anchor) \
LibJS: Add initial support for Promises Almost a year after first working on this, it's finally done: an implementation of Promises for LibJS! :^) The core functionality is working and closely following the spec [1]. I mostly took the pseudo code and transformed it into C++ - if you read and understand it, you will know how the spec implements Promises; and if you read the spec first, the code will look very familiar. Implemented functions are: - Promise() constructor - Promise.prototype.then() - Promise.prototype.catch() - Promise.prototype.finally() - Promise.resolve() - Promise.reject() For the tests I added a new function to test-js's global object, runQueuedPromiseJobs(), which calls vm.run_queued_promise_jobs(). By design, queued jobs normally only run after the script was fully executed, making it improssible to test handlers in individual test() calls by default [2]. Subsequent commits include integrations into LibWeb and js(1) - pretty-printing, running queued promise jobs when necessary. This has an unusual amount of dbgln() statements, all hidden behind the PROMISE_DEBUG flag - I'm leaving them in for now as they've been very useful while debugging this, things can get quite complex with so many asynchronously executed functions. I've not extensively explored use of these APIs for promise-based functionality in LibWeb (fetch(), Notification.requestPermission() etc.), but we'll get there in due time. [1]: https://tc39.es/ecma262/#sec-promise-objects [2]: https://tc39.es/ecma262/#sec-jobs-and-job-queues
2021-04-01 20:13:29 +00:00
P(any) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(apply) \
LibJS: Implement a very hackish "arguments" object We now lazily create an "arguments" array inside functions when code tries to access it. This doesn't follow the spec at all but still covers a lot of the basic uses of arguments, i.e "arguments.length" and "arguments[n]"
2020-12-05 15:38:29 +00:00
P(arguments) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(asIntN) \
P(asUintN) \
LibJS: Add Math.acos() and Math.asin()
2020-12-08 15:22:07 +00:00
P(asin) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(asinh) \
LibJS: Implement console.assert()
2021-04-18 15:08:14 +00:00
P(assert) \
LibJS: Implement Object.assign()
2021-06-12 10:35:53 +00:00
P(assign) \
LibJS: Implement 'Relative Indexing Method' proposal (.at()) Still stage 3, but already implemented in major engines and unlikely to change - there isn't much to change here anyway. :^) See: - https://github.com/tc39/proposal-relative-indexing-method - https://tc39.es/proposal-relative-indexing-method/ - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at
2021-03-12 17:13:12 +00:00
P(at) \
LibJS: Add Math.atan()
2020-12-08 08:52:33 +00:00
P(atan) \
LibJS: Add almost all Math functions
2020-12-28 14:34:51 +00:00
P(atan2) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(atanh) \
LibJS: Implement Intl.Locale.prototype.baseName
2021-09-02 02:39:40 +00:00
P(baseName) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-29 22:44:18 +00:00
P(big) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(bind) \
LibJS: Implement Temporal.Duration.prototype.blank
2021-07-15 23:15:56 +00:00
P(blank) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-29 22:44:18 +00:00
P(blink) \
P(bold) \
LibJS: Expose TypedArray.prototype.buffer
2021-05-21 20:26:18 +00:00
P(buffer) \
LibJS: Add ArrayBuffer
2020-12-02 20:49:31 +00:00
P(byteLength) \
LibJS: Expose TypedArray.prototype.byteOffset
2021-05-21 20:45:47 +00:00
P(byteOffset) \
LibJS: Start implementing Temporal.PlainDate This commit adds the PlainDate object itself, its constructor and prototype (currently empty), and several required abstract operations.
2021-07-18 21:29:26 +00:00
P(calendar) \
LibJS: Adds calendar_id identifier
2024-10-25 10:47:08 +00:00
P(calendarId) \
LibJS: Implement Temporal.PlainDate.prototype.toString()
2021-08-18 20:15:04 +00:00
P(calendarName) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(call) \
LibJS: Add arguments.callee to our hack arguments object arguments.callee refers to the currently executing function.
2021-03-14 15:41:00 +00:00
P(callee) \
LibJS: Add and use the %ThrowTypeError% intrinsic
2021-06-28 00:53:35 +00:00
P(caller) \
LibJS: Implement the Intl.Locale constructor
2021-09-02 02:08:15 +00:00
P(caseFirst) \
LibJS: Implement the Error Cause proposal Currently stage 3. https://github.com/tc39/proposal-error-cause
2021-06-11 19:40:08 +00:00
P(cause) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(cbrt) \
P(ceil) \
P(charAt) \
P(charCodeAt) \
LibJS: Add all of the FinalizationRegistry.prototype methods More specifically: cleanupSome, register & unregister. FinalizationRegistery.prototype.cleanupSome is actually still a stage 2 proposal, but since test262 test cases already exist for it, i decided to go for it :)
2021-06-15 19:21:24 +00:00
P(cleanupSome) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-13 22:03:58 +00:00
P(clear) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(clz32) \
LibJS: Add the String.prototype.codePointAt() method This commit also brings charAt & charCodeAt closer to the specification
2021-06-16 14:30:41 +00:00
P(codePointAt) \
LibJS: Implement the Intl.Locale constructor
2021-09-02 02:08:15 +00:00
P(collation) \
LibJS: Implement the Intl.NumberFormat constructor
2021-09-10 15:04:54 +00:00
P(compactDisplay) \
LibJS: Implement Atomics.compareExchange
2021-07-12 12:59:34 +00:00
P(compareExchange) \
LibJS: Implement RegExp.prototype.compile This is an Annex B extension to RegExp.prototype.
2021-08-20 14:41:27 +00:00
P(compile) \
LibWeb: Implement KeyframeEffect::{get,set}_keyframes
2024-02-12 13:51:36 +00:00
P(composite) \
P(computedOffset) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(concat) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-13 22:03:58 +00:00
P(configurable) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(console) \
P(construct) \
P(constructor) \
LibJS: Implement Intl %SegmentsPrototype%.containing
2022-01-30 19:12:42 +00:00
P(containing) \
LibJS: Add Temporal.Instant.compare()
2021-07-11 18:18:48 +00:00
P(compare) \
LibJS: Implement Array.prototype.copyWithin generically
2021-06-13 16:09:34 +00:00
P(copyWithin) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(cos) \
LibJS: Add almost all Math functions
2020-12-28 14:34:51 +00:00
P(cosh) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-13 22:03:58 +00:00
P(count) \
P(countReset) \
LibJS: Implement Object.create()
2021-04-10 16:40:12 +00:00
P(create) \
LibJS: Implement the Intl.NumberFormat constructor
2021-09-10 15:04:54 +00:00
P(currency) \
P(currencyDisplay) \
P(currencySign) \
LibJS: Implement Temporal.Calendar.prototype.dateAdd()
2021-08-30 19:44:05 +00:00
P(dateAdd) \
LibJS: Add Temporal.Calendar.prototype.dateFromFields & required AOs This is required for implementing the DateFromFields PlainDate AO.
2021-07-21 19:17:40 +00:00
P(dateFromFields) \
LibJS+LibUnicode: Implement the Intl.DateTimeFormat constructor
2021-11-28 22:55:47 +00:00
P(dateStyle) \
LibJS: Implement Temporal.Calendar.prototype.dateUntil()
2021-10-10 21:46:10 +00:00
P(dateUntil) \
LibJS: Add Temporal.Calendar.prototype.dateFromFields & required AOs This is required for implementing the DateFromFields PlainDate AO.
2021-07-21 19:17:40 +00:00
P(day) \
LibJS: Implement Temporal.Calendar.prototype.dayOfWeek
2021-07-23 14:46:20 +00:00
P(dayOfWeek) \
LibJS: Implement Temporal.Calendar.prototype.dayOfYear
2021-07-23 14:58:44 +00:00
P(dayOfYear) \
LibJS+LibUnicode: Implement the Intl.DateTimeFormat constructor
2021-11-28 22:55:47 +00:00
P(dayPeriod) \
LibJS: Implement Temporal.Duration.prototype.days
2021-07-15 22:47:04 +00:00
P(days) \
LibJS: Implement Intl.DurationFormat.prototype.resolvedOptions
2022-06-29 22:52:52 +00:00
P(daysDisplay) \
LibJS: Implement Temporal.Calendar.prototype.daysInMonth
2021-07-23 15:36:34 +00:00
P(daysInMonth) \
LibJS: Implement Temporal.Calendar.prototype.daysInWeek
2021-07-23 15:27:47 +00:00
P(daysInWeek) \
LibJS: Implement Temporal.Calendar.prototype.daysInYear
2021-07-23 15:46:49 +00:00
P(daysInYear) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-13 22:03:58 +00:00
P(debug) \
LibJS: Implement the encode/decodeURI(Component) family of functions These are generally useful and in particular needed for twitter.com
2021-04-13 19:50:29 +00:00
P(decodeURI) \
P(decodeURIComponent) \
LibJS: Add DisposableStack{, Prototype, Constructor} Since the async parts of the spec are not stage 3 at this point we don't add AsyncDisposableStack.
2022-12-21 10:48:14 +00:00
P(defer) \
LibJS: Implement Object.defineProperties()
2021-04-10 16:39:11 +00:00
P(defineProperties) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(defineProperty) \
P(deleteProperty) \
LibJS: Add the WeakRef built-in object
2021-06-12 14:38:34 +00:00
P(deref) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(description) \
LibJS: Implement the ArrayBuffer.prototype.detached getter
2023-06-29 20:24:40 +00:00
P(detached) \
LibJS: Implement Set.prototype.difference
2022-12-01 20:33:26 +00:00
P(difference) \
LibJS: Begin implementing console.dir The intent of the spec is that the output of console.dir is interactable within the console. Our Printer implementation currently just prints the provided object as a string, and doesn't check the provided `options` argument. But having console.dir defined prevents exceptions from being thrown on real websites.
2023-06-22 01:29:24 +00:00
P(dir) \
LibJS: Implement Intl.Locale.prototype.textInfo property
2022-07-05 23:50:24 +00:00
P(direction) \
LibJS: Implement Temporal.TimeZone.prototype.getInstantFor()
2021-11-01 13:20:06 +00:00
P(disambiguation) \
LibJS: Add DisposableStack{, Prototype, Constructor} Since the async parts of the spec are not stage 3 at this point we don't add AsyncDisposableStack.
2022-12-21 10:48:14 +00:00
P(disposed) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(done) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-18 22:20:00 +00:00
P(dotAll) \
LibJS: Implement Iterator.prototype.drop
2023-06-25 16:20:00 +00:00
P(drop) \
LibWeb: Implement KeyframeEffect::{get,set}_keyframes
2024-02-12 13:51:36 +00:00
P(easing) \
LibJS: Implement the encode/decodeURI(Component) family of functions These are generally useful and in particular needed for twitter.com
2021-04-13 19:50:29 +00:00
P(encodeURI) \
P(encodeURIComponent) \
LibJS: Implement String.prototype.endsWith()
2020-12-25 01:58:34 +00:00
P(endsWith) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(entries) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-13 22:03:58 +00:00
P(enumerable) \
LibJS: Implement Temporal.Instant.prototype.epochMicroseconds
2021-07-08 21:11:51 +00:00
P(epochMicroseconds) \
LibJS: Implement Temporal.Instant.prototype.epochMilliseconds
2021-07-08 20:56:03 +00:00
P(epochMilliseconds) \
LibJS: Implement Temporal.Instant.prototype.epochNanoseconds
2021-07-08 21:20:49 +00:00
P(epochNanoseconds) \
LibJS: Implement Temporal.Instant.prototype.epochSeconds
2021-07-08 20:47:28 +00:00
P(epochSeconds) \
LibJS: Add Temporal.Instant.prototype.equals()
2021-07-11 18:23:38 +00:00
P(equals) \
LibJS: Implement Temporal.Calendar.prototype.era()
2021-08-27 18:45:10 +00:00
P(era) \
LibJS: Implement Temporal.Calendar.prototype.eraYear()
2021-08-27 18:52:41 +00:00
P(eraYear) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-13 22:03:58 +00:00
P(error) \
LibJS: Implement AggregateError
2021-06-11 17:06:20 +00:00
P(errors) \
LibJS: Add the global escape() & unescape() methods
2021-06-05 16:21:15 +00:00
P(escape) \
LibJS: Add naive implementation of eval() :^) This parses and executes a code string in the caller's lexical scope.
2021-03-14 15:20:01 +00:00
P(eval) \
LibJS: Implement ShadowRealm.prototype.evaluate()
2021-10-13 20:40:33 +00:00
P(evaluate) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(every) \
LibJS: Implement Atomics.exchange
2021-07-12 12:08:13 +00:00
P(exchange) \
LibJS: Implement `RegExpPrototype::exec()' This implements *only* the builtin exec() function.
2020-11-22 10:48:49 +00:00
P(exec) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(exp) \
P(expm1) \
LibJS: Implement the Intl.DisplayNames constructor There is notably FIXME notations in this commit regarding Unicode locale extensions. We are not parsing extensions (or private use extensions) at all yet.
2021-08-25 02:58:45 +00:00
P(fallback) \
LibJS: Implement the ToTemporalDate Abstract Operation This is required by most Temporal.PlainDate.prototype methods.
2021-07-21 19:20:57 +00:00
P(fields) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(fill) \
P(filter) \
LibJS: Add initial support for Promises Almost a year after first working on this, it's finally done: an implementation of Promises for LibJS! :^) The core functionality is working and closely following the spec [1]. I mostly took the pseudo code and transformed it into C++ - if you read and understand it, you will know how the spec implements Promises; and if you read the spec first, the code will look very familiar. Implemented functions are: - Promise() constructor - Promise.prototype.then() - Promise.prototype.catch() - Promise.prototype.finally() - Promise.resolve() - Promise.reject() For the tests I added a new function to test-js's global object, runQueuedPromiseJobs(), which calls vm.run_queued_promise_jobs(). By design, queued jobs normally only run after the script was fully executed, making it improssible to test handlers in individual test() calls by default [2]. Subsequent commits include integrations into LibWeb and js(1) - pretty-printing, running queued promise jobs when necessary. This has an unusual amount of dbgln() statements, all hidden behind the PROMISE_DEBUG flag - I'm leaving them in for now as they've been very useful while debugging this, things can get quite complex with so many asynchronously executed functions. I've not extensively explored use of these APIs for promise-based functionality in LibWeb (fetch(), Notification.requestPermission() etc.), but we'll get there in due time. [1]: https://tc39.es/ecma262/#sec-promise-objects [2]: https://tc39.es/ecma262/#sec-jobs-and-job-queues
2021-04-01 20:13:29 +00:00
P(finally) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(find) \
LibJS: Implement proposed Array.prototype.findLast{,Index} Proposal: https://tc39.es/proposal-array-find-from-last/
2021-08-03 12:12:47 +00:00
P(findLast) \
P(findLastIndex) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(findIndex) \
LibJS: Implement Intl.Locale.prototype.weekInfo property
2022-07-06 12:30:53 +00:00
P(firstDay) \
LibJS: Implement Intl.Locale.prototype.firstDayOfWeek This is a normative change in the Intl Locale Info spec. See: https://github.com/tc39/proposal-intl-locale-info/commit/f03a814
2023-10-03 14:18:18 +00:00
P(firstDayOfWeek) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-29 22:44:18 +00:00
P(fixed) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-18 22:20:00 +00:00
P(flags) \
LibJS: Implement Array.prototype.flat
2021-02-16 20:16:13 +00:00
P(flat) \
LibJS: Implement Array.prototype.flatMap Also made recursive_array_flat more compliant with the spec So renamed it to flatten_into_array
2021-06-13 14:21:59 +00:00
P(flatMap) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(floor) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-29 22:44:18 +00:00
P(fontcolor) \
P(fontsize) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(forEach) \
LibJS: Implement Intl.ListFormat.prototype.format
2021-09-06 18:37:23 +00:00
P(format) \
LibJS+LibUnicode: Implement the Intl.DateTimeFormat constructor
2021-11-28 22:55:47 +00:00
P(formatMatcher) \
LibJS: Implement Intl.DateTimeFormat.prototype.formatRange
2021-12-09 00:57:21 +00:00
P(formatRange) \
LibJS: Implement Intl.DateTimeFormat.prototype.formatRangeToParts
2021-12-09 18:35:59 +00:00
P(formatRangeToParts) \
LibJS: Implement Intl.ListFormat.prototype.formatToParts
2021-09-06 18:57:57 +00:00
P(formatToParts) \
LibJS: Start implementing the stage 3 Intl.DurationFormat proposal
2022-06-29 21:58:40 +00:00
P(fractionalDigits) \
LibJS: Implement Temporal.Instant.prototype.toString()
2021-08-30 23:15:36 +00:00
P(fractionalSecondDigits) \
LibJS: Implement Object.freeze() and Object.seal()
2021-04-06 20:06:11 +00:00
P(freeze) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(from) \
LibJS: Implement Array.fromAsync
2023-07-15 10:37:22 +00:00
P(fromAsync) \
LibJS: Implement Uint8Array.fromBase64 Note that we can currently only use simdutf for Base64 decoding if the provided stopBeforePartial option is loose, which is the default. There is an open issue for simdutf to implement strict and stop-before-partial options. Until then, for those options, we implement a slow decoder that is written exactly as the spec steps dictate. See: https://github.com/simdutf/simdutf/issues/440
2024-08-31 13:05:40 +00:00
P(fromBase64) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(fromCharCode) \
LibJS: Add the String.fromCodePoint() method
2021-06-16 08:36:23 +00:00
P(fromCodePoint) \
LibJS: Add the Object.fromEntries method
2021-06-15 09:46:14 +00:00
P(fromEntries) \
LibJS: Implement Temporal.Instant.fromEpochMicroseconds()
2021-07-09 11:10:16 +00:00
P(fromEpochMicroseconds) \
LibJS: Implement Temporal.Instant.fromEpochMilliseconds()
2021-07-09 11:00:31 +00:00
P(fromEpochMilliseconds) \
LibJS: Implement Temporal.Instant.fromEpochNanoseconds()
2021-07-09 11:20:11 +00:00
P(fromEpochNanoseconds) \
LibJS: Implement Temporal.Instant.fromEpochSeconds()
2021-07-09 10:51:23 +00:00
P(fromEpochSeconds) \
LibJS: Implement Uint8Array.fromHex
2024-09-01 22:37:12 +00:00
P(fromHex) \
LibJS: Add almost all Math functions
2020-12-28 14:34:51 +00:00
P(fround) \
LibJS: Add support for Float16Array Implements TC39 stage three proposal for Float16Arrays: https://tc39.es/proposal-float16array
2024-11-09 21:29:03 +00:00
P(f16round) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(gc) \
P(get) \
LibJS: Add all of the DataView.prototype.get* methods
2021-06-13 22:57:15 +00:00
P(getBigInt64) \
P(getBigUint64) \
LibJS: Change Intl.Locale info APIs from property getters to methods This is a normative change in the Intl Locale Info spec. See: https://github.com/tc39/proposal-intl-locale-info/commit/e550152
2023-11-13 15:18:25 +00:00
P(getCalendars) \
LibJS: Implement Intl.getCanonicalLocales
2021-08-25 13:41:25 +00:00
P(getCanonicalLocales) \
LibJS: Change Intl.Locale info APIs from property getters to methods This is a normative change in the Intl Locale Info spec. See: https://github.com/tc39/proposal-intl-locale-info/commit/e550152
2023-11-13 15:18:25 +00:00
P(getCollations) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(getDate) \
P(getDay) \
LibJS: Add support for Float16Array Implements TC39 stage three proposal for Float16Arrays: https://tc39.es/proposal-float16array
2024-11-09 21:29:03 +00:00
P(getFloat16) \
LibJS: Add all of the DataView.prototype.get* methods
2021-06-13 22:57:15 +00:00
P(getFloat32) \
P(getFloat64) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(getFullYear) \
LibJS: Change Intl.Locale info APIs from property getters to methods This is a normative change in the Intl Locale Info spec. See: https://github.com/tc39/proposal-intl-locale-info/commit/e550152
2023-11-13 15:18:25 +00:00
P(getHourCycles) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(getHours) \
LibJS: Implement Temporal.TimeZone.prototype.getInstantFor()
2021-11-01 13:20:06 +00:00
P(getInstantFor) \
LibJS: Add all of the DataView.prototype.get* methods
2021-06-13 22:57:15 +00:00
P(getInt8) \
P(getInt16) \
P(getInt32) \
LibJS: Implement Temporal.PlainDateTime.prototype.getISOFields()
2021-07-23 00:04:10 +00:00
P(getISOFields) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(getMilliseconds) \
P(getMinutes) \
P(getMonth) \
LibJS: Implement Temporal.TimeZone.prototype.getNextTransition()
2021-10-30 08:26:42 +00:00
P(getNextTransition) \
LibJS: Change Intl.Locale info APIs from property getters to methods This is a normative change in the Intl Locale Info spec. See: https://github.com/tc39/proposal-intl-locale-info/commit/e550152
2023-11-13 15:18:25 +00:00
P(getNumberingSystems) \
LibJS: Implement Temporal.TimeZone.prototype.getOffsetNanosecondsFor()
2021-07-25 19:19:37 +00:00
P(getOffsetNanosecondsFor) \
LibJS: Implement Temporal.TimeZone.prototype.getOffsetStringFor()
2021-07-31 20:54:35 +00:00
P(getOffsetStringFor) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(getOwnPropertyDescriptor) \
LibJS: Implement Object.getOwnPropertyDescriptors()
2021-07-06 16:41:54 +00:00
P(getOwnPropertyDescriptors) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(getOwnPropertyNames) \
LibJS: Add the Object.getOwnPropertySymbols method
2021-06-12 14:41:13 +00:00
P(getOwnPropertySymbols) \
LibJS: Implement Temporal.TimeZone.prototype.getPlainDateTimeFor()
2021-07-31 21:21:53 +00:00
P(getPlainDateTimeFor) \
LibJS: Implement Temporal.TimeZone.prototype.getPossibleInstantsFor()
2021-10-30 08:22:19 +00:00
P(getPossibleInstantsFor) \
LibJS: Implement Temporal.TimeZone.prototype.getPreviousTransition()
2021-10-30 08:28:12 +00:00
P(getPreviousTransition) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(getPrototypeOf) \
P(getSeconds) \
LibJS: Change Intl.Locale info APIs from property getters to methods This is a normative change in the Intl Locale Info spec. See: https://github.com/tc39/proposal-intl-locale-info/commit/e550152
2023-11-13 15:18:25 +00:00
P(getTextInfo) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(getTime) \
LibJS: Stub out Date.prototype.getTimezoneOffset() We only support UTC currently, so this always returns 0 as long as the date is not invalid.
2021-06-06 12:53:52 +00:00
P(getTimezoneOffset) \
LibJS: Change Intl.Locale info APIs from property getters to methods This is a normative change in the Intl Locale Info spec. See: https://github.com/tc39/proposal-intl-locale-info/commit/e550152
2023-11-13 15:18:25 +00:00
P(getTimeZones) \
LibJS: Add all of the DataView.prototype.get* methods
2021-06-13 22:57:15 +00:00
P(getUint8) \
P(getUint16) \
P(getUint32) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(getUTCDate) \
P(getUTCDay) \
P(getUTCFullYear) \
P(getUTCHours) \
P(getUTCMilliseconds) \
P(getUTCMinutes) \
P(getUTCMonth) \
P(getUTCSeconds) \
LibJS: Change Intl.Locale info APIs from property getters to methods This is a normative change in the Intl Locale Info spec. See: https://github.com/tc39/proposal-intl-locale-info/commit/e550152
2023-11-13 15:18:25 +00:00
P(getWeekInfo) \
LibJS: Add Date.prototype.{get, set}Year()
2021-05-29 20:52:17 +00:00
P(getYear) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-18 22:20:00 +00:00
P(global) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(globalThis) \
LibJS: Start implementing Intl.Segmenter
2022-01-29 21:47:29 +00:00
P(granularity) \
LibJS+WebContent+Browser+js: Implement console.group() methods This implements: - console.group() - console.groupCollapsed() - console.groupEnd() In the Browser, we use `<details>` for the groups, which is not actually implemented yet, so groups are always open. In the REPL, groups are non-interactive, but still indent any output. This looks weird since the console prompt and return values remain on the far left, but this matches what Node does so it's probably fine. :^) I expect `console.group()` is not used much outside of browsers.
2021-12-22 12:32:15 +00:00
P(group) \
LibJS: Re-implement the Array Grouping proposal as static methods Closes #19495.
2023-07-11 14:23:00 +00:00
P(groupBy) \
LibJS+WebContent+Browser+js: Implement console.group() methods This implements: - console.group() - console.groupCollapsed() - console.groupEnd() In the Browser, we use `<details>` for the groups, which is not actually implemented yet, so groups are always open. In the REPL, groups are non-interactive, but still indent any output. This looks weird since the console prompt and return values remain on the far left, but this matches what Node does so it's probably fine. :^) I expect `console.group()` is not used much outside of browsers.
2021-12-22 12:32:15 +00:00
P(groupCollapsed) \
P(groupEnd) \
LibJS: Implement `RegExpPrototype::exec()' This implements *only* the builtin exec() function.
2020-11-22 10:48:49 +00:00
P(groups) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(has) \
LibJS: Parse the RegExp.prototype.hasIndices flag
2021-07-09 20:10:17 +00:00
P(hasIndices) \
LibJS: Implement Object.hasOwn() :^) This is currently a TC39 Stage 2 proposal, but let's go for it! https://github.com/tc39/proposal-accessible-object-hasownproperty I wrote the C++, @linusg found bugs and wrote the test.
2021-05-18 09:15:49 +00:00
P(hasOwn) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(hasOwnProperty) \
LibJS: Implement Temporal.PlainTime.prototype.hour
2021-07-28 17:53:05 +00:00
P(hour) \
LibJS+LibUnicode: Implement the Intl.DateTimeFormat constructor
2021-11-28 22:55:47 +00:00
P(hour12) \
LibJS: Implement the Intl.Locale constructor
2021-09-02 02:08:15 +00:00
P(hourCycle) \
LibJS: Implement Temporal.Duration.prototype.hours
2021-07-15 22:48:59 +00:00
P(hours) \
LibJS: Implement Intl.DurationFormat.prototype.resolvedOptions
2022-06-29 22:52:52 +00:00
P(hoursDisplay) \
LibJS: Implement Temporal.ZonedDateTime.prototype.hoursInDay
2021-11-03 16:21:58 +00:00
P(hoursInDay) \
LibJS: Add almost all Math functions
2020-12-28 14:34:51 +00:00
P(hypot) \
LibJS: Implement Temporal.TimeZone.prototype.id
2021-07-08 19:51:57 +00:00
P(id) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-18 22:20:00 +00:00
P(ignoreCase) \
LibJS: Implement the Intl.Collator constructor
2022-01-29 16:31:39 +00:00
P(ignorePunctuation) \
LibJS: Add almost all Math functions
2020-12-28 14:34:51 +00:00
P(imul) \
LibJS: Implement ShadowRealm.prototype.importValue() Well... sort of. This adds the function itself and all the scaffolding from the ShadowRealm API (and basically completes its implementation). However, we do not nearly have enough support for modules and imports, so we currently pretend whatever was attempted to be imported failed - once we have HostImportModuleDynamically it should be relatively easy to complete the implementation.
2021-10-15 00:10:05 +00:00
P(importValue) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(includes) \
LibJS: Implement `RegExpPrototype::exec()' This implements *only* the builtin exec() function.
2020-11-22 10:48:49 +00:00
P(index) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(indexOf) \
LibJS: Implement RegExp.prototype.hasIndices proposal https://tc39.es/proposal-regexp-match-indices/
2021-07-09 23:51:56 +00:00
P(indices) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-13 22:03:58 +00:00
P(info) \
LibJS: Implement Temporal.Calendar.prototype.inLeapYear
2021-07-23 16:03:19 +00:00
P(inLeapYear) \
LibJS: Implement `RegExpPrototype::exec()' This implements *only* the builtin exec() function.
2020-11-22 10:48:49 +00:00
P(input) \
LibJS: Implement Temporal.now.instant()
2021-07-07 16:42:21 +00:00
P(instant) \
LibJS: Implement Set.prototype.intersection
2022-12-01 20:17:43 +00:00
P(intersection) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(is) \
P(isArray) \
LibJS: Implement Set.prototype.isDisjointFrom
2022-12-01 21:00:44 +00:00
P(isDisjointFrom) \
LibJS: Implement Error.isError Implementing the stage 2.7 proposal: https://github.com/tc39/proposal-is-error
2024-11-09 16:59:08 +00:00
P(isError) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(isExtensible) \
P(isFinite) \
LibJS: Implement Object.isFrozen() and Object.isSealed()
2021-04-06 20:45:12 +00:00
P(isFrozen) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(isInteger) \
LibJS: Implement Atomics.isLockFree
2021-07-12 14:35:14 +00:00
P(isLockFree) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(isNaN) \
LibJS: Implement Object.prototype.isPrototypeOf Spec: https://tc39.es/ecma262/#sec-object.prototype.isprototypeof
2020-12-28 01:22:38 +00:00
P(isPrototypeOf) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(isSafeInteger) \
LibJS: Implement Object.isFrozen() and Object.isSealed()
2021-04-06 20:45:12 +00:00
P(isSealed) \
LibJS: Implement Set.prototype.isSubsetOf
2022-12-01 20:49:50 +00:00
P(isSubsetOf) \
LibJS: Implement Set.prototype.isSupersetOf
2022-12-01 20:54:43 +00:00
P(isSupersetOf) \
LibJS: Add ArrayBuffer
2020-12-02 20:49:31 +00:00
P(isView) \
LibJS: Implement Temporal.PlainDateTime.prototype.getISOFields()
2021-07-23 00:04:10 +00:00
P(isoDay) \
P(isoHour) \
P(isoMicrosecond) \
P(isoMillisecond) \
P(isoMinute) \
P(isoMonth) \
P(isoNanosecond) \
P(isoSecond) \
P(isoYear) \
LibJS: Implement String.prototype.isWellFormed
2022-12-01 15:36:44 +00:00
P(isWellFormed) \
LibJS: Implement the Intl CreateSegmentDataObject AO
2022-01-30 18:50:23 +00:00
P(isWordLike) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-29 22:44:18 +00:00
P(italics) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(join) \
P(keyFor) \
P(keys) \
LibJS: Implement the Intl.Locale constructor
2021-09-02 02:08:15 +00:00
P(language) \
LibJS: Parse new Intl.DisplayNames "type" and "languageDisplay" options Intl.DisplayNames v2 adds "calendar" and "dateTimeField" types, as well as a "languageDisplay" option for the "language" type. This just adds these options to the constructor.
2022-01-12 18:52:51 +00:00
P(languageDisplay) \
LibJS: Add a bunch of Temporal Abstract Operations These will allow us to (partially) implement Temporal.Instant.prototype.{until, since}
2021-09-06 18:21:57 +00:00
P(largestUnit) \
LibJS: Implement Uint8Array.fromBase64 Note that we can currently only use simdutf for Base64 decoding if the provided stopBeforePartial option is loose, which is the default. There is an open issue for simdutf to implement strict and stop-before-partial options. Until then, for those options, we implement a slow decoder that is written exactly as the spec steps dictate. See: https://github.com/simdutf/simdutf/issues/440
2024-08-31 13:05:40 +00:00
P(lastChunkHandling) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-18 22:20:00 +00:00
P(lastIndex) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(lastIndexOf) \
P(length) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-29 22:44:18 +00:00
P(link) \
LibJS: Implement Atomics.load
2021-07-11 15:45:21 +00:00
P(load) \
LibJS: Implement Intl.DisplayNames.prototype.resolvedOptions
2021-08-25 03:26:44 +00:00
P(locale) \
LibJS: Implement a naive String.prototype.localeCompare
2021-07-25 22:23:39 +00:00
P(localeCompare) \
LibJS: Implement the Intl.DisplayNames constructor There is notably FIXME notations in this commit regarding Unicode locale extensions. We are not parsing extensions (or private use extensions) at all yet.
2021-08-25 02:58:45 +00:00
P(localeMatcher) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-13 22:03:58 +00:00
P(log) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(log1p) \
LibJS: Add almost all Math functions
2020-12-28 14:34:51 +00:00
P(log2) \
P(log10) \
LibJS: Implement RegExp legacy static properties RegExp legacy static properties Spec url is https://github.com/tc39/proposal-regexp-legacy-features
2022-10-17 00:59:27 +00:00
P(lastMatch) \
P(lastParen) \
P(leftContext) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(map) \
P(max) \
LibJS: Partially implement resizable ArrayBuffer objects This is (part of) a normative change in the ECMA-262 spec. See: https://github.com/tc39/ecma262/commit/a9ae96e This implements just support for resizing ArrayBuffer objects. This does not implement the SharedArrayBuffer changes, as we do not have enough support to do so.
2023-10-14 23:10:55 +00:00
P(maxByteLength) \
LibJS: Implement Intl.Locale.prototype.maximize
2021-09-02 23:03:41 +00:00
P(maximize) \
LibJS: Implement Temporal.Calendar.prototype.mergeFields()
2021-08-16 21:23:52 +00:00
P(mergeFields) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(message) \
LibJS: Implement Temporal.PlainTime.prototype.microsecond
2021-07-28 18:05:30 +00:00
P(microsecond) \
LibJS: Implement Temporal.Duration.prototype.microseconds
2021-07-15 22:57:07 +00:00
P(microseconds) \
LibJS: Implement Intl.DurationFormat.prototype.resolvedOptions
2022-06-29 22:52:52 +00:00
P(microsecondsDisplay) \
LibJS: Implement Temporal.PlainTime.prototype.millisecond
2021-07-28 18:02:44 +00:00
P(millisecond) \
LibJS: Implement Temporal.Duration.prototype.milliseconds
2021-07-15 22:54:58 +00:00
P(milliseconds) \
LibJS: Implement Intl.DurationFormat.prototype.resolvedOptions
2022-06-29 22:52:52 +00:00
P(millisecondsDisplay) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(min) \
LibJS: Implement Intl.Locale.prototype.weekInfo property
2022-07-06 12:30:53 +00:00
P(minimalDays) \
LibJS: Implement Intl.Locale.prototype.minimize
2021-09-03 01:45:42 +00:00
P(minimize) \
LibJS: Implement the Intl.NumberFormat constructor
2021-09-10 15:04:54 +00:00
P(maximumFractionDigits) \
P(maximumSignificantDigits) \
P(minimumFractionDigits) \
P(minimumIntegerDigits) \
P(minimumSignificantDigits) \
LibJS: Implement Temporal.PlainTime.prototype.minute
2021-07-28 17:55:29 +00:00
P(minute) \
LibJS: Implement Temporal.Duration.prototype.minutes
2021-07-15 22:51:02 +00:00
P(minutes) \
LibJS: Implement Intl.DurationFormat.prototype.resolvedOptions
2022-06-29 22:52:52 +00:00
P(minutesDisplay) \
LibJS: Add Temporal.Calendar.prototype.dateFromFields & required AOs This is required for implementing the DateFromFields PlainDate AO.
2021-07-21 19:17:40 +00:00
P(month) \
P(monthCode) \
LibJS: Implement Temporal.Calendar.prototype.monthDayFromFields()
2021-08-16 17:04:58 +00:00
P(monthDayFromFields) \
LibJS: Implement Temporal.Duration.prototype.months
2021-07-15 22:41:55 +00:00
P(months) \
LibJS: Implement Intl.DurationFormat.prototype.resolvedOptions
2022-06-29 22:52:52 +00:00
P(monthsDisplay) \
LibJS: Implement Temporal.Calendar.prototype.monthsInYear
2021-07-23 15:52:55 +00:00
P(monthsInYear) \
LibJS: Add DisposableStack{, Prototype, Constructor} Since the async parts of the spec are not stage 3 at this point we don't add AsyncDisposableStack.
2022-12-21 10:48:14 +00:00
P(move) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-18 22:20:00 +00:00
P(multiline) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(name) \
LibJS: Implement Temporal.PlainTime.prototype.nanosecond
2021-07-28 18:07:29 +00:00
P(nanosecond) \
LibJS: Implement Temporal.Duration.prototype.nanoseconds
2021-07-15 23:07:49 +00:00
P(nanoseconds) \
LibJS: Implement Intl.DurationFormat.prototype.resolvedOptions
2022-06-29 22:52:52 +00:00
P(nanosecondsDisplay) \
LibJS: Implement Temporal.Duration.prototype.negated()
2021-07-16 18:41:37 +00:00
P(negated) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-13 22:03:58 +00:00
P(next) \
LibJS: Stub out String.prototype.normalize
2022-06-01 23:37:15 +00:00
P(normalize) \
LibJS: Implement the Intl.NumberFormat constructor
2021-09-10 15:04:54 +00:00
P(notation) \
LibJS: Stub out Atomics.notify We don't have the facilities to implement this method fully (namely, a fully realized SharedArrayBuffer). But we can implement enough to validate the values passed in by the user.
2023-11-15 21:19:15 +00:00
P(notify) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(now) \
LibJS: Implement the Intl.Locale constructor
2021-09-02 02:08:15 +00:00
P(numberingSystem) \
P(numeric) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(of) \
LibJS: Implement Temporal.ZonedDateTime.prototype.offset
2021-08-04 22:18:19 +00:00
P(offset) \
LibJS: Implement Temporal.ZonedDateTime.prototype.offsetNanoseconds
2021-08-04 22:17:07 +00:00
P(offsetNanoseconds) \
LibJS: Implement Uint8Array.prototype.toBase64
2024-07-15 14:59:29 +00:00
P(omitPadding) \
LibJS: Make Temporal's get_option() take a PropertyName directly Instead of constructing a String and converting that to a PropertyName on the fly, we can just leverage CommonPropertyNames, add a couple more and directly pass ready-to-use PropertyNames with pre-allocated Strings.
2021-08-18 19:27:44 +00:00
P(overflow) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(ownKeys) \
P(padEnd) \
P(padStart) \
P(parse) \
P(parseFloat) \
LibJS: Implement parseInt() Here's a reasonably faithful implementation of ECMAScript 2021 18.2.5. Some corner cases are not covered, I've left them as FIXME's in the included unit test. Also I had to tweak JS::Value::to_i32() to always convert infinity to zero, which is in accordance with ToInt32 AFAICT.
2020-12-05 12:51:09 +00:00
P(parseInt) \
LibJS: Implement `tc39/proposal-atomics-microwait` (Atomics.pause) Implements the https://github.com/tc39/proposal-atomics-microwait proposal which has recently hit Stage 3. This commit passes all relevant tests in `test262`.
2024-11-01 23:09:07 +00:00
P(pause) \
LibJS: Implement Temporal.Now.plainDate() ...and ten required AOs we didn't have yet: - BalanceISODate - BalanceISODateTime - BalanceISOYearMonth - BalanceTime - BuiltinTimeZoneGetPlainDateTimeFor - GetISOPartsFromEpoch - GetOffsetNanosecondsFor - ParseTemporalTimeZone - SystemDateTime - ToTemporalTimeZone
2021-07-26 23:21:16 +00:00
P(plainDate) \
LibJS: Implement Temporal.Now.plainDateISO()
2021-07-26 23:30:10 +00:00
P(plainDateISO) \
LibJS: Implement Temporal.Now.plainDateTime()
2021-07-26 23:49:52 +00:00
P(plainDateTime) \
LibJS: Implement Temporal.Now.plainDateTimeISO()
2021-07-26 23:58:57 +00:00
P(plainDateTimeISO) \
LibJS: Implement Temporal.PlainDate.prototype.toZonedDateTime()
2021-11-02 16:47:23 +00:00
P(plainTime) \
LibJS: Implement Temporal.Now.plainTimeISO()
2021-07-28 18:29:16 +00:00
P(plainTimeISO) \
LibJS: Implement Intl.PluralRules.prototype.resolvedOptions
2022-01-28 18:42:20 +00:00
P(pluralCategories) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(pop) \
P(pow) \
P(preventExtensions) \
LibJS: Implement the Promise.withResolvers proposal https://github.com/tc39/proposal-promise-with-resolvers
2023-07-12 19:28:03 +00:00
P(promise) \
LibJS: Implement Object.prototype.propertyIsEnumerable Spec: https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable This is used by core-js, which is used by frameworks such as Vue.
2020-12-24 17:51:28 +00:00
P(propertyIsEnumerable) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(prototype) \
LibJS: Implement Proxy.revocable()
2021-06-08 20:48:43 +00:00
P(proxy) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(push) \
LibJS: Add initial support for Promises Almost a year after first working on this, it's finally done: an implementation of Promises for LibJS! :^) The core functionality is working and closely following the spec [1]. I mostly took the pseudo code and transformed it into C++ - if you read and understand it, you will know how the spec implements Promises; and if you read the spec first, the code will look very familiar. Implemented functions are: - Promise() constructor - Promise.prototype.then() - Promise.prototype.catch() - Promise.prototype.finally() - Promise.resolve() - Promise.reject() For the tests I added a new function to test-js's global object, runQueuedPromiseJobs(), which calls vm.run_queued_promise_jobs(). By design, queued jobs normally only run after the script was fully executed, making it improssible to test handlers in individual test() calls by default [2]. Subsequent commits include integrations into LibWeb and js(1) - pretty-printing, running queued promise jobs when necessary. This has an unusual amount of dbgln() statements, all hidden behind the PROMISE_DEBUG flag - I'm leaving them in for now as they've been very useful while debugging this, things can get quite complex with so many asynchronously executed functions. I've not extensively explored use of these APIs for promise-based functionality in LibWeb (fetch(), Notification.requestPermission() etc.), but we'll get there in due time. [1]: https://tc39.es/ecma262/#sec-promise-objects [2]: https://tc39.es/ecma262/#sec-jobs-and-job-queues
2021-04-01 20:13:29 +00:00
P(race) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(random) \
P(raw) \
LibJS: Implement Uint8Array.prototype.setFromBase64
2024-08-31 14:24:01 +00:00
P(read) \
LibJS: Implement Promise.allSettled on the Promise constructor
2021-08-21 21:00:48 +00:00
P(reason) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(reduce) \
P(reduceRight) \
LibJS: Implement the Intl.Locale constructor
2021-09-02 02:08:15 +00:00
P(region) \
LibJS: Add initial support for Promises Almost a year after first working on this, it's finally done: an implementation of Promises for LibJS! :^) The core functionality is working and closely following the spec [1]. I mostly took the pseudo code and transformed it into C++ - if you read and understand it, you will know how the spec implements Promises; and if you read the spec first, the code will look very familiar. Implemented functions are: - Promise() constructor - Promise.prototype.then() - Promise.prototype.catch() - Promise.prototype.finally() - Promise.resolve() - Promise.reject() For the tests I added a new function to test-js's global object, runQueuedPromiseJobs(), which calls vm.run_queued_promise_jobs(). By design, queued jobs normally only run after the script was fully executed, making it improssible to test handlers in individual test() calls by default [2]. Subsequent commits include integrations into LibWeb and js(1) - pretty-printing, running queued promise jobs when necessary. This has an unusual amount of dbgln() statements, all hidden behind the PROMISE_DEBUG flag - I'm leaving them in for now as they've been very useful while debugging this, things can get quite complex with so many asynchronously executed functions. I've not extensively explored use of these APIs for promise-based functionality in LibWeb (fetch(), Notification.requestPermission() etc.), but we'll get there in due time. [1]: https://tc39.es/ecma262/#sec-promise-objects [2]: https://tc39.es/ecma262/#sec-jobs-and-job-queues
2021-04-01 20:13:29 +00:00
P(reject) \
LibJS: Implement the required AOs for Temporal.Duration.compare
2021-11-09 17:19:28 +00:00
P(relativeTo) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(repeat) \
LibJS: Partially implement resizable ArrayBuffer objects This is (part of) a normative change in the ECMA-262 spec. See: https://github.com/tc39/ecma262/commit/a9ae96e This implements just support for resizing ArrayBuffer objects. This does not implement the SharedArrayBuffer changes, as we do not have enough support to do so.
2023-10-14 23:10:55 +00:00
P(resizable) \
P(resize) \
LibJS: Add initial support for Promises Almost a year after first working on this, it's finally done: an implementation of Promises for LibJS! :^) The core functionality is working and closely following the spec [1]. I mostly took the pseudo code and transformed it into C++ - if you read and understand it, you will know how the spec implements Promises; and if you read the spec first, the code will look very familiar. Implemented functions are: - Promise() constructor - Promise.prototype.then() - Promise.prototype.catch() - Promise.prototype.finally() - Promise.resolve() - Promise.reject() For the tests I added a new function to test-js's global object, runQueuedPromiseJobs(), which calls vm.run_queued_promise_jobs(). By design, queued jobs normally only run after the script was fully executed, making it improssible to test handlers in individual test() calls by default [2]. Subsequent commits include integrations into LibWeb and js(1) - pretty-printing, running queued promise jobs when necessary. This has an unusual amount of dbgln() statements, all hidden behind the PROMISE_DEBUG flag - I'm leaving them in for now as they've been very useful while debugging this, things can get quite complex with so many asynchronously executed functions. I've not extensively explored use of these APIs for promise-based functionality in LibWeb (fetch(), Notification.requestPermission() etc.), but we'll get there in due time. [1]: https://tc39.es/ecma262/#sec-promise-objects [2]: https://tc39.es/ecma262/#sec-jobs-and-job-queues
2021-04-01 20:13:29 +00:00
P(resolve) \
LibJS: Implement Intl.DisplayNames.prototype.resolvedOptions
2021-08-25 03:26:44 +00:00
P(resolvedOptions) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(reverse) \
LibJS: Implement Proxy.revocable()
2021-06-08 20:48:43 +00:00
P(revocable) \
P(revoke) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(round) \
LibJS: Make Temporal's get_option() take a PropertyName directly Instead of constructing a String and converting that to a PropertyName on the fly, we can just leverage CommonPropertyNames, add a couple more and directly pass ready-to-use PropertyNames with pre-allocated Strings.
2021-08-18 19:27:44 +00:00
P(roundingIncrement) \
P(roundingMode) \
LibJS+js: Parse new constructor options from Intl.NumberFormat V3 This contains minimal changes to parse newly added and modified options from the Intl.NumberFormat V3 proposal, while maintaining main spec behavior in Intl.NumberFormat.prototype.format. The parsed options are reflected only in Intl.NumberFormat.prototype.resolvedOptions and the js REPL.
2022-07-12 17:18:23 +00:00
P(roundingPriority) \
LibJS: Implement RegExp legacy static properties RegExp legacy static properties Spec url is https://github.com/tc39/proposal-regexp-legacy-features
2022-10-17 00:59:27 +00:00
P(rightContext) \
LibJS: Implement the Intl.Locale constructor
2021-09-02 02:08:15 +00:00
P(script) \
LibJS: Implement Object.freeze() and Object.seal()
2021-04-06 20:06:11 +00:00
P(seal) \
LibJS: Implement Temporal.PlainTime.prototype.second
2021-07-28 17:59:27 +00:00
P(second) \
LibJS: Implement Temporal.Duration.prototype.seconds
2021-07-15 22:53:19 +00:00
P(seconds) \
LibJS: Implement Intl.DurationFormat.prototype.resolvedOptions
2022-06-29 22:52:52 +00:00
P(secondsDisplay) \
LibJS: Implement Intl.Segmenter.prototype.segment
2022-01-29 23:31:59 +00:00
P(segment) \
LibJS: Implement Intl.PluralRules.prototype.select
2022-07-07 14:01:00 +00:00
P(select) \
LibJS: Implement Intl.PluralRules.prototype.selectRange
2022-07-11 15:28:10 +00:00
P(selectRange) \
LibJS: Implement the Intl.Collator constructor
2022-01-29 16:31:39 +00:00
P(sensitivity) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(set) \
LibJS: Add all of the DataView.prototype.set* methods
2021-06-13 23:02:53 +00:00
P(setBigInt64) \
P(setBigUint64) \
LibJS: Add Date.prototype.setDate()
2021-06-06 13:25:33 +00:00
P(setDate) \
LibJS: Add support for Float16Array Implements TC39 stage three proposal for Float16Arrays: https://tc39.es/proposal-float16array
2024-11-09 21:29:03 +00:00
P(setFloat16) \
LibJS: Add all of the DataView.prototype.set* methods
2021-06-13 23:02:53 +00:00
P(setFloat32) \
P(setFloat64) \
LibJS: Implement Uint8Array.prototype.setFromBase64
2024-08-31 14:24:01 +00:00
P(setFromBase64) \
LibJS: Implement Uint8Array.prototype.setFromHex
2024-09-01 22:44:39 +00:00
P(setFromHex) \
LibJS: Partial support for Date.prototype.setFullYear()
2021-03-14 15:23:46 +00:00
P(setFullYear) \
LibJS: Add Date methods: setHours, setMinutes, setSeconds, setMilliseconds
2021-03-19 19:12:08 +00:00
P(setHours) \
LibJS: Add all of the DataView.prototype.set* methods
2021-06-13 23:02:53 +00:00
P(setInt8) \
P(setInt16) \
P(setInt32) \
LibJS: Add Date methods: setHours, setMinutes, setSeconds, setMilliseconds
2021-03-19 19:12:08 +00:00
P(setMilliseconds) \
P(setMinutes) \
LibJS: Add Date.prototype.setMonth()
2021-06-06 13:26:29 +00:00
P(setMonth) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(setPrototypeOf) \
LibJS: Add Date methods: setHours, setMinutes, setSeconds, setMilliseconds
2021-03-19 19:12:08 +00:00
P(setSeconds) \
LibJS: Add Date.prototype.setTime()
2021-06-06 13:27:21 +00:00
P(setTime) \
LibJS: Add all of the DataView.prototype.set* methods
2021-06-13 23:02:53 +00:00
P(setUint8) \
P(setUint16) \
P(setUint32) \
LibJS: Add Date.setUTC{Date, Month, Hours, ...}() aliases These are a bit hacky, since they are supposed to be separate methods, but since serenity only supports UTC currently, they are equivalent.
2021-06-06 14:34:04 +00:00
P(setUTCDate) \
P(setUTCFullYear) \
P(setUTCHours) \
P(setUTCMilliseconds) \
P(setUTCMinutes) \
P(setUTCMonth) \
P(setUTCSeconds) \
LibJS: Add Date.prototype.{get, set}Year()
2021-05-29 20:52:17 +00:00
P(setYear) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(shift) \
P(sign) \
LibJS: Implement the Intl.NumberFormat constructor
2021-09-10 15:04:54 +00:00
P(signDisplay) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(sin) \
LibJS: Implement Temporal.Instant.prototype.since
2021-09-06 18:36:54 +00:00
P(since) \
LibJS: Add almost all Math functions
2020-12-28 14:34:51 +00:00
P(sinh) \
LibJS: Add the Set built-in object
2021-06-08 21:08:47 +00:00
P(size) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(slice) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-29 22:44:18 +00:00
P(small) \
LibJS: Make Temporal's get_option() take a PropertyName directly Instead of constructing a String and converting that to a PropertyName on the fly, we can just leverage CommonPropertyNames, add a couple more and directly pass ready-to-use PropertyNames with pre-allocated Strings.
2021-08-18 19:27:44 +00:00
P(smallestUnit) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(some) \
LibJS: Implement Array.prototype.sort()
2020-12-26 11:14:14 +00:00
P(sort) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-18 22:20:00 +00:00
P(source) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(splice) \
P(sqrt) \
LibJS: Implement non standard error.stack attribute All other browser already support this feature. There is a Stage 1 proposal to standardize this, but it does not seem to be active.
2022-02-06 16:00:28 +00:00
P(stack) \
LibJS: Implement Temporal.ZonedDateTime.prototype.startOfDay
2021-11-03 20:22:55 +00:00
P(startOfDay) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(startsWith) \
LibJS: Implement Promise.allSettled on the Promise constructor
2021-08-21 21:00:48 +00:00
P(status) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-18 22:20:00 +00:00
P(sticky) \
LibJS: Implement Atomics.store
2021-07-11 18:37:54 +00:00
P(store) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-29 22:44:18 +00:00
P(strike) \
LibJS: Add a basic implementation of String.prototype.substr()
2020-11-29 19:28:10 +00:00
P(stringify) \
LibJS: Implement the Intl.DisplayNames constructor There is notably FIXME notations in this commit regarding Unicode locale extensions. We are not parsing extensions (or private use extensions) at all yet.
2021-08-25 02:58:45 +00:00
P(style) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-29 22:44:18 +00:00
P(sub) \
LibJS: Add %TypedArray%.prototype.subarray
2021-07-09 14:17:10 +00:00
P(subarray) \
LibJS: Add a basic implementation of String.prototype.substr()
2020-11-29 19:28:10 +00:00
P(substr) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(substring) \
LibJS: Implement Temporal.Instant.prototype.subtract()
2021-08-06 23:38:21 +00:00
P(subtract) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-29 22:44:18 +00:00
P(sup) \
LibJS: Add SuppressedError{, Prototype, Constructor}
2022-12-06 01:10:01 +00:00
P(suppressed) \
LibJS: Implement Intl.DisplayNames.supportedLocalesOf()
2021-09-04 16:08:57 +00:00
P(supportedLocalesOf) \
LibJS: Implement Intl.supportedValuesOf This is a stage 3 ECMA-402 proposal: https://tc39.es/proposal-intl-enumeration/
2022-01-30 22:36:23 +00:00
P(supportedValuesOf) \
LibJS: Implement Set.prototype.symmetricDifference
2022-12-01 20:44:04 +00:00
P(symmetricDifference) \
LibJS+WebContent: Implement console.table - Expose table from console object - Add new Table log level - Create a JS object that represents table rows and columns - Print table as HTML using WebContentConsoleClient
2024-08-09 21:24:26 +00:00
P(table) \
LibJS: Implement Iterator.prototype.take
2023-06-25 15:45:52 +00:00
P(take) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(tan) \
LibJS: Add almost all Math functions
2020-12-28 14:34:51 +00:00
P(tanh) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-18 22:20:00 +00:00
P(test) \
LibJS: Add initial support for Promises Almost a year after first working on this, it's finally done: an implementation of Promises for LibJS! :^) The core functionality is working and closely following the spec [1]. I mostly took the pseudo code and transformed it into C++ - if you read and understand it, you will know how the spec implements Promises; and if you read the spec first, the code will look very familiar. Implemented functions are: - Promise() constructor - Promise.prototype.then() - Promise.prototype.catch() - Promise.prototype.finally() - Promise.resolve() - Promise.reject() For the tests I added a new function to test-js's global object, runQueuedPromiseJobs(), which calls vm.run_queued_promise_jobs(). By design, queued jobs normally only run after the script was fully executed, making it improssible to test handlers in individual test() calls by default [2]. Subsequent commits include integrations into LibWeb and js(1) - pretty-printing, running queued promise jobs when necessary. This has an unusual amount of dbgln() statements, all hidden behind the PROMISE_DEBUG flag - I'm leaving them in for now as they've been very useful while debugging this, things can get quite complex with so many asynchronously executed functions. I've not extensively explored use of these APIs for promise-based functionality in LibWeb (fetch(), Notification.requestPermission() etc.), but we'll get there in due time. [1]: https://tc39.es/ecma262/#sec-promise-objects [2]: https://tc39.es/ecma262/#sec-jobs-and-job-queues
2021-04-01 20:13:29 +00:00
P(then) \
LibJS: Implement console.time/timeLog/timeEnd() methods
2021-12-22 16:40:57 +00:00
P(time) \
P(timeEnd) \
P(timeLog) \
LibJS+LibUnicode: Implement the Intl.DateTimeFormat constructor
2021-11-28 22:55:47 +00:00
P(timeStyle) \
LibJS: Implement Temporal.now.timeZone()
2021-07-06 22:54:53 +00:00
P(timeZone) \
LibJS: Implement the required AOs for ZonedDateTime stringifiers
2021-11-10 00:14:16 +00:00
P(timeZoneName) \
LibJS: Implement Iterator.prototype.toArray
2023-06-25 17:49:46 +00:00
P(toArray) \
LibJS: Implement Uint8Array.prototype.toBase64
2024-07-15 14:59:29 +00:00
P(toBase64) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(toDateString) \
LibJS: Implement Number.prototype.toExponential
2022-01-04 00:48:44 +00:00
P(toExponential) \
LibJS: Add the Number.prototype.toFixed method
2021-06-19 14:02:42 +00:00
P(toFixed) \
LibJS: Add Date.prototype.toGMTString()
2021-03-14 15:40:41 +00:00
P(toGMTString) \
LibJS: Implement Uint8Array.prototype.toHex
2024-07-15 16:30:26 +00:00
P(toHex) \
LibJS: Implement Temporal.ZonedDateTime.prototype.toInstant()
2021-08-05 20:48:23 +00:00
P(toInstant) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(toISOString) \
P(toJSON) \
P(toLocaleDateString) \
LibJS: Implement non-ECMA-402 String.prototype.toLocale{Lower,Upper}Case In implementations without ECMA-402, these methods are to behave like their non-locale equivalents.
2021-07-27 20:35:25 +00:00
P(toLocaleLowerCase) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(toLocaleString) \
P(toLocaleTimeString) \
LibJS: Implement non-ECMA-402 String.prototype.toLocale{Lower,Upper}Case In implementations without ECMA-402, these methods are to behave like their non-locale equivalents.
2021-07-27 20:35:25 +00:00
P(toLocaleUpperCase) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(toLowerCase) \
LibJS: Implement Temporal.PlainDateTime.prototype.toPlainDate()
2021-07-22 23:39:18 +00:00
P(toPlainDate) \
LibJS: Implement Temporal.PlainTime.prototype.toPlainDateTime
2021-07-29 21:28:04 +00:00
P(toPlainDateTime) \
LibJS: Implement Temporal.PlainDate.prototype.toPlainMonthDay()
2021-08-16 17:13:47 +00:00
P(toPlainMonthDay) \
LibJS: Implement Temporal.PlainDateTime.prototype.toPlainTime
2021-07-30 22:44:31 +00:00
P(toPlainTime) \
LibJS: Implement Temporal.PlainDate.prototype.toPlainYearMonth()
2021-08-15 23:42:01 +00:00
P(toPlainYearMonth) \
LibJS: Implement Number.prototype.toPrecision As noted in the prototype comments, this implementation becomes less accurate as the precision approaches the limit of 100. For example: (3).toPrecision(100) Should result in "3." followed by 99 "0"s. However, due to the loss of accuracy in the floating point computations, we currently result in "2.9999999...".
2022-01-03 04:06:51 +00:00
P(toPrecision) \
LibJS: Implement Array.prototype.toReversed()
2022-06-13 06:57:38 +00:00
P(toReversed) \
LibJS: Implement Array.prototype.toSorted()
2022-06-13 06:59:19 +00:00
P(toSorted) \
LibJS: Implement Array.prototype.toSpliced()
2022-06-13 07:00:29 +00:00
P(toSpliced) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(toString) \
LibJS: Implement Temporal.Duration.prototype.total()
2021-11-13 17:38:00 +00:00
P(total) \
LibJS: Implement Date.prototype.toTemporalInstant()
2021-07-07 23:31:49 +00:00
P(toTemporalInstant) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(toTimeString) \
P(toUpperCase) \
LibJS Date: Added toUTCString() toGMTString() is deprecated but is kept for compatibility's sake, but because HTTP Dates are always expressed in GMT, it should be safe to call toUTCString() in toGMTString().
2021-03-16 13:36:32 +00:00
P(toUTCString) \
LibJS: Implement String.prototype.toWellFormed
2022-12-01 15:52:10 +00:00
P(toWellFormed) \
LibJS: Implement Temporal.Instant.prototype.toZonedDateTime()
2021-09-08 23:27:19 +00:00
P(toZonedDateTime) \
LibJS: Implement Temporal.Instant.prototype.toZonedDateTimeISO()
2021-09-08 23:35:24 +00:00
P(toZonedDateTimeISO) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-13 22:03:58 +00:00
P(trace) \
LibJS+js: Parse new constructor options from Intl.NumberFormat V3 This contains minimal changes to parse newly added and modified options from the Intl.NumberFormat V3 proposal, while maintaining main spec behavior in Intl.NumberFormat.prototype.format. The parsed options are reflected only in Intl.NumberFormat.prototype.resolvedOptions and the js REPL.
2022-07-12 17:18:23 +00:00
P(trailingZeroDisplay) \
LibJS: Implement ArrayBuffer.prototype.transfer & transferToFixedLength
2023-06-30 17:00:56 +00:00
P(transfer) \
P(transferToFixedLength) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(trim) \
P(trimEnd) \
LibJS: Add the String.prototype.trim{Left, Right} aliases These are the same as trim{Start, End} respectively.
2021-06-01 21:59:15 +00:00
P(trimLeft) \
P(trimRight) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(trimStart) \
P(trunc) \
LibJS: Implement the Intl.DisplayNames constructor There is notably FIXME notations in this commit regarding Unicode locale extensions. We are not parsing extensions (or private use extensions) at all yet.
2021-08-25 02:58:45 +00:00
P(type) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(undefined) \
LibJS: Add the global escape() & unescape() methods
2021-06-05 16:21:15 +00:00
P(unescape) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-18 22:20:00 +00:00
P(unicode) \
LibJS: Hook up the 'v' (unicodeSets) RegExp flag
2022-07-16 05:44:03 +00:00
P(unicodeSets) \
LibJS: Implement the Intl.NumberFormat constructor
2021-09-10 15:04:54 +00:00
P(unit) \
P(unitDisplay) \
LibJS: Add all of the FinalizationRegistry.prototype methods More specifically: cleanupSome, register & unregister. FinalizationRegistery.prototype.cleanupSome is actually still a stage 2 proposal, but since test262 test cases already exist for it, i decided to go for it :)
2021-06-15 19:21:24 +00:00
P(unregister) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(unshift) \
LibJS: Hook up the 'v' (unicodeSets) RegExp flag
2022-07-16 05:44:03 +00:00
P(until) \
LibJS: Implement the Intl.Collator constructor
2022-01-29 16:31:39 +00:00
P(usage) \
LibJS: Add DisposableStack{, Prototype, Constructor} Since the async parts of the spec are not stage 3 at this point we don't add AsyncDisposableStack.
2022-12-21 10:48:14 +00:00
P(use) \
LibJS: Implement the Intl.NumberFormat constructor
2021-09-10 15:04:54 +00:00
P(useGrouping) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
P(value) \
P(valueOf) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-13 22:03:58 +00:00
P(values) \
LibJS: Stub out Atomics.wait and Atomics.waitAsync We don't have the facilities to implement these methods fully (namely, a fully realized SharedArrayBuffer). But we can implement enough to validate the values passed in by the user.
2023-11-15 21:03:27 +00:00
P(wait) \
P(waitAsync) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-13 22:03:58 +00:00
P(warn) \
LibJS: Implement Temporal.Calendar.prototype.weekOfYear
2021-07-23 15:19:45 +00:00
P(weekOfYear) \
LibJS+LibUnicode: Implement the Intl.DateTimeFormat constructor
2021-11-28 22:55:47 +00:00
P(weekday) \
LibJS: Implement Intl.Locale.prototype.weekInfo property
2022-07-06 12:30:53 +00:00
P(weekend) \
LibJS: Implement Temporal.Duration.prototype.weeks
2021-07-15 22:43:55 +00:00
P(weeks) \
LibJS: Implement Intl.DurationFormat.prototype.resolvedOptions
2022-06-29 22:52:52 +00:00
P(weeksDisplay) \
LibJS: Implement Temporal.Duration.prototype.with()
2021-07-16 18:30:52 +00:00
P(with) \
LibJS: Implement Temporal.PlainDate.prototype.withCalendar
2021-07-23 12:01:40 +00:00
P(withCalendar) \
LibJS: Implement Temporal.PlainDateTime.prototype.withPlainDate
2021-07-30 22:39:36 +00:00
P(withPlainDate) \
LibJS: Implement Temporal.PlainDateTime.prototype.withPlainTime()
2021-08-27 16:05:16 +00:00
P(withPlainTime) \
LibJS: Implement the Promise.withResolvers proposal https://github.com/tc39/proposal-promise-with-resolvers
2023-07-12 19:28:03 +00:00
P(withResolvers) \
LibJS: Implement Temporal.ZonedDateTime.prototype.withTimeZone
2021-11-05 01:35:23 +00:00
P(withTimeZone) \
LibJS: Implement Temporal.Duration.prototype.years
2021-07-15 22:34:53 +00:00
P(writable) \
LibJS: Implement Uint8Array.prototype.setFromBase64
2024-08-31 14:24:01 +00:00
P(written) \
LibJS: Add Temporal.Calendar.prototype.dateFromFields & required AOs This is required for implementing the DateFromFields PlainDate AO.
2021-07-21 19:17:40 +00:00
P(year) \
LibJS: Implement Temporal.Calendar.prototype.yearMonthFromFields()
2021-08-15 23:35:05 +00:00
P(yearMonthFromFields) \
LibJS: Add yearOfWeek calendar methods and properties This is a normative change in the Temporal spec. See: - https://github.com/tc39/proposal-temporal/commit/7fa4d18 - https://github.com/tc39/proposal-temporal/commit/caa941d
2022-12-26 00:58:43 +00:00
P(yearOfWeek) \
LibJS: Implement Temporal.Now.zonedDateTime()
2021-08-01 17:31:56 +00:00
P(years) \
LibJS: Implement Intl.DurationFormat.prototype.resolvedOptions
2022-06-29 22:52:52 +00:00
P(yearsDisplay) \
LibJS: Implement Temporal.Now.zonedDateTimeISO()
2021-08-01 17:36:15 +00:00
P(zonedDateTime) \
P(zonedDateTimeISO)
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
struct CommonPropertyNames {
LibJS: Rename PropertyName to PropertyKey Let's use the same name as the spec. :^)
2021-10-24 14:01:24 +00:00
PropertyKey and_ { "and", PropertyKey::StringMayBeNumber::No };
PropertyKey catch_ { "catch", PropertyKey::StringMayBeNumber::No };
PropertyKey delete_ { "delete", PropertyKey::StringMayBeNumber::No };
PropertyKey for_ { "for", PropertyKey::StringMayBeNumber::No };
PropertyKey or_ { "or", PropertyKey::StringMayBeNumber::No };
PropertyKey register_ { "register", PropertyKey::StringMayBeNumber::No };
PropertyKey return_ { "return", PropertyKey::StringMayBeNumber::No };
PropertyKey throw_ { "throw", PropertyKey::StringMayBeNumber::No };
LibJS: Implement Promise.try() See: https://github.com/tc39/proposal-promise-try
2024-04-09 06:02:15 +00:00
PropertyKey try_ { "try", PropertyKey::StringMayBeNumber::No };
LibJS: Implement Set.prototype.union
2022-12-01 21:04:30 +00:00
PropertyKey union_ { "union", PropertyKey::StringMayBeNumber::No };
LibJS: Rename PropertyName to PropertyKey Let's use the same name as the spec. :^)
2021-10-24 14:01:24 +00:00
PropertyKey xor_ { "xor", PropertyKey::StringMayBeNumber::No };
LibJS: Implement RegExp legacy static properties RegExp legacy static properties Spec url is https://github.com/tc39/proposal-regexp-legacy-features
2022-10-17 00:59:27 +00:00
PropertyKey inputAlias { "$_", PropertyKey::StringMayBeNumber::No };
PropertyKey lastMatchAlias { "$&", PropertyKey::StringMayBeNumber::No };
PropertyKey lastParenAlias { "$+", PropertyKey::StringMayBeNumber::No };
PropertyKey leftContextAlias { "$`", PropertyKey::StringMayBeNumber::No };
PropertyKey rightContextAlias { "$'", PropertyKey::StringMayBeNumber::No };
LibJS: Rename PropertyName to PropertyKey Let's use the same name as the spec. :^)
2021-10-24 14:01:24 +00:00
#define __ENUMERATE(x) PropertyKey x { #x, PropertyKey::StringMayBeNumber::No };
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
ENUMERATE_STANDARD_PROPERTY_NAMES(__ENUMERATE)
#undef __ENUMERATE
LibJS: Rename PropertyName to PropertyKey Let's use the same name as the spec. :^)
2021-10-24 14:01:24 +00:00
#define __JS_ENUMERATE(x, a, b, c, t) PropertyKey x { #x, PropertyKey::StringMayBeNumber::No };
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
JS_ENUMERATE_BUILTIN_TYPES
#undef __JS_ENUMERATE
LibJS: Rename PropertyName to PropertyKey Let's use the same name as the spec. :^)
2021-10-24 14:01:24 +00:00
#define __JS_ENUMERATE(x, a, b, c) PropertyKey x { #x, PropertyKey::StringMayBeNumber::No };
LibJS: Add preparation for Intl constructors and prototypes Add a JS_ENUMERATE_INTL_OBJECTS macro and use it to generate: - Forward declarations - CommonPropertyNames class name members - Constructor and prototype GlobalObject members, getters, visitors, and initialize_constructor() calls
2021-08-08 17:35:29 +00:00
JS_ENUMERATE_INTL_OBJECTS
#undef __JS_ENUMERATE
LibJS: Rename PropertyName to PropertyKey Let's use the same name as the spec. :^)
2021-10-24 14:01:24 +00:00
#define __JS_ENUMERATE(x, a, b, c) PropertyKey x { #x, PropertyKey::StringMayBeNumber::No };
LibJS: Add preparation for Temporal constructors and prototypes Add a JS_ENUMERATE_TEMPORAL_OBJECTS macro and use it to generate: - Forward declarations - CommonPropertyNames class name members - Constructor and prototype GlobalObject members, getters, visitors, and initialize_constructor() calls
2021-07-06 19:39:55 +00:00
JS_ENUMERATE_TEMPORAL_OBJECTS
#undef __JS_ENUMERATE
LibJS: Rename PropertyName to PropertyKey Let's use the same name as the spec. :^)
2021-10-24 14:01:24 +00:00
#define __JS_ENUMERATE(x, a) PropertyKey x { #x, PropertyKey::StringMayBeNumber::No };
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
JS_ENUMERATE_WELL_KNOWN_SYMBOLS
#undef __JS_ENUMERATE
};
}
Reference in a new issue Copy permalink