+
diff --git a/tests/wpt/web-platform-tests/html/cross-origin-opener/new_window_same_origin.tentative.html.headers b/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/coop-sandbox.https.html.headers
similarity index 100%
rename from tests/wpt/web-platform-tests/html/cross-origin-opener/new_window_same_origin.tentative.html.headers
rename to tests/wpt/web-platform-tests/html/cross-origin-opener-policy/coop-sandbox.https.html.headers
diff --git a/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/no-https.html b/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/no-https.html
new file mode 100644
index 000000000000..da9efdce777c
--- /dev/null
+++ b/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/no-https.html
@@ -0,0 +1,18 @@
+
+
+
Cross-Origin-Opener-Policy requires secure contexts
+
+
+
diff --git a/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/no-https.html.headers b/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/no-https.html.headers
new file mode 100644
index 000000000000..46ad58d83bf6
--- /dev/null
+++ b/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/no-https.html.headers
@@ -0,0 +1 @@
+Cross-Origin-Opener-Policy: same-origin
diff --git a/tests/wpt/web-platform-tests/html/cross-origin-opener/new_window_null.tentative.html b/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/popup-none.https.html
similarity index 93%
rename from tests/wpt/web-platform-tests/html/cross-origin-opener/new_window_null.tentative.html
rename to tests/wpt/web-platform-tests/html/cross-origin-opener-policy/popup-none.https.html
index 35a42fd2f096..62633457d3f5 100644
--- a/tests/wpt/web-platform-tests/html/cross-origin-opener/new_window_null.tentative.html
+++ b/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/popup-none.https.html
@@ -3,8 +3,7 @@
-
-
+
diff --git a/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/popup-same-origin-non-initial-about-blank.https.html b/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/popup-same-origin-non-initial-about-blank.https.html
new file mode 100644
index 000000000000..65ec3b26aa0c
--- /dev/null
+++ b/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/popup-same-origin-non-initial-about-blank.https.html
@@ -0,0 +1,15 @@
+
+
Cross-Origin-Opener-Policy: about:blank
+
+
+
diff --git a/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/popup-same-origin-non-initial-about-blank.https.html.headers b/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/popup-same-origin-non-initial-about-blank.https.html.headers
new file mode 100644
index 000000000000..46ad58d83bf6
--- /dev/null
+++ b/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/popup-same-origin-non-initial-about-blank.https.html.headers
@@ -0,0 +1 @@
+Cross-Origin-Opener-Policy: same-origin
diff --git a/tests/wpt/web-platform-tests/html/cross-origin-opener/new_window_same_origin_unsafe_allow_outgoing.tentative.html b/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/popup-same-origin-unsafe-allow-outgoing.https.html
similarity index 96%
rename from tests/wpt/web-platform-tests/html/cross-origin-opener/new_window_same_origin_unsafe_allow_outgoing.tentative.html
rename to tests/wpt/web-platform-tests/html/cross-origin-opener-policy/popup-same-origin-unsafe-allow-outgoing.https.html
index bbd55130d7a9..2f8ebc3be3fc 100644
--- a/tests/wpt/web-platform-tests/html/cross-origin-opener/new_window_same_origin_unsafe_allow_outgoing.tentative.html
+++ b/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/popup-same-origin-unsafe-allow-outgoing.https.html
@@ -3,8 +3,7 @@
-
-
+
-
-
+
-
-
+
-
-
+
+
+
+"""
diff --git a/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/resources/postback.html b/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/resources/postback.html
new file mode 100644
index 000000000000..cf3c93bbe1d3
--- /dev/null
+++ b/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/resources/postback.html
@@ -0,0 +1,10 @@
+
+
+
diff --git a/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/resources/postback.html.headers b/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/resources/postback.html.headers
new file mode 100644
index 000000000000..6604450991a1
--- /dev/null
+++ b/tests/wpt/web-platform-tests/html/cross-origin-opener-policy/resources/postback.html.headers
@@ -0,0 +1 @@
+Cross-Origin-Embedder-Policy: require-corp
diff --git a/tests/wpt/web-platform-tests/html/cross-origin-opener/common.sub.js b/tests/wpt/web-platform-tests/html/cross-origin-opener/common.sub.js
deleted file mode 100644
index a73a95aba862..000000000000
--- a/tests/wpt/web-platform-tests/html/cross-origin-opener/common.sub.js
+++ /dev/null
@@ -1,28 +0,0 @@
-const SAME_ORIGIN = {origin: get_host_info().HTTP_ORIGIN, name: "SAME_ORIGIN"};
-const SAME_SITE = {origin: get_host_info().HTTP_REMOTE_ORIGIN, name: "SAME_SITE"};
-const CROSS_ORIGIN = {origin: get_host_info().HTTP_NOTSAMESITE_ORIGIN, name: "CROSS_ORIGIN"}
-
-function coop_test(t, host, coop, channelName, hasOpener) {
- let bc = new BroadcastChannel(channelName);
- bc.onmessage = t.step_func_done((event) => {
- let payload = event.data;
- assert_equals(payload.name, hasOpener ? channelName : "");
- assert_equals(payload.opener, hasOpener);
- });
-
- let w = window.open(`${host.origin}/html/cross-origin-opener/resources/coop_window.py?path=window.sub.html&coop=${escape(coop)}&channel=${channelName}`, channelName);
-
- // w will be closed by its postback iframe. When out of process,
- // window.close() does not work.
- t.add_cleanup(() => w.close());
-}
-
-function run_coop_tests(mainTest, testArray) {
- for (let test of tests) {
- async_test(t => {
- coop_test(t, test[0], test[1],
- `${mainTest}_to_${test[0].name}_${test[1].replace(/ /g,"-")}`,
- test[2]);
- }, `${mainTest} document opening popup to ${test[0].origin} with COOP: "${test[1]}"`);
- }
-}
diff --git a/tests/wpt/web-platform-tests/html/cross-origin-opener/resources/coop_window.py b/tests/wpt/web-platform-tests/html/cross-origin-opener/resources/coop_window.py
deleted file mode 100644
index b24d6d55a9a3..000000000000
--- a/tests/wpt/web-platform-tests/html/cross-origin-opener/resources/coop_window.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import urllib
-import os.path
-
-def main(request, response):
- coop = request.GET.first('coop')
- if coop:
- response.headers.set('Cross-Origin-Opener-Policy', urllib.unquote(coop))
-
- path = os.path.join(os.path.dirname(__file__), request.GET.first('path'))
- response.content = open(path, mode='rb').read()
diff --git a/tests/wpt/web-platform-tests/html/cross-origin-opener/resources/postback.sub.html b/tests/wpt/web-platform-tests/html/cross-origin-opener/resources/postback.sub.html
deleted file mode 100644
index ee08bab4d55e..000000000000
--- a/tests/wpt/web-platform-tests/html/cross-origin-opener/resources/postback.sub.html
+++ /dev/null
@@ -1,13 +0,0 @@
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/html/cross-origin-opener/resources/window.sub.html b/tests/wpt/web-platform-tests/html/cross-origin-opener/resources/window.sub.html
deleted file mode 100644
index 524efe2588d0..000000000000
--- a/tests/wpt/web-platform-tests/html/cross-origin-opener/resources/window.sub.html
+++ /dev/null
@@ -1,18 +0,0 @@
-
-
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/html/cross-origin-opener/resources/window.sub.html.headers b/tests/wpt/web-platform-tests/html/cross-origin-opener/resources/window.sub.html.headers
deleted file mode 100644
index 34bd099a302f..000000000000
--- a/tests/wpt/web-platform-tests/html/cross-origin-opener/resources/window.sub.html.headers
+++ /dev/null
@@ -1 +0,0 @@
-Cross-Origin-Opener-Policy: same-site
diff --git a/tests/wpt/web-platform-tests/html/cross-origin/anonymous.tentative.html b/tests/wpt/web-platform-tests/html/cross-origin/anonymous.tentative.html
deleted file mode 100644
index ef9b9bb7b878..000000000000
--- a/tests/wpt/web-platform-tests/html/cross-origin/anonymous.tentative.html
+++ /dev/null
@@ -1,219 +0,0 @@
-
-
-
Cross-Origin header and nested navigable resource without such header
-
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/html/cross-origin/anonymous.tentative.html.headers b/tests/wpt/web-platform-tests/html/cross-origin/anonymous.tentative.html.headers
deleted file mode 100644
index a76b601291ec..000000000000
--- a/tests/wpt/web-platform-tests/html/cross-origin/anonymous.tentative.html.headers
+++ /dev/null
@@ -1 +0,0 @@
-Cross-Origin: anonymous
diff --git a/tests/wpt/web-platform-tests/html/cross-origin/null.tentative.html b/tests/wpt/web-platform-tests/html/cross-origin/null.tentative.html
deleted file mode 100644
index ae871c4a2735..000000000000
--- a/tests/wpt/web-platform-tests/html/cross-origin/null.tentative.html
+++ /dev/null
@@ -1,103 +0,0 @@
-
-
-
Cross-Origin header and nested navigable resource without such header
-
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/html/cross-origin/null.tentative.html.headers b/tests/wpt/web-platform-tests/html/cross-origin/null.tentative.html.headers
deleted file mode 100644
index fd34f127d558..000000000000
--- a/tests/wpt/web-platform-tests/html/cross-origin/null.tentative.html.headers
+++ /dev/null
@@ -1 +0,0 @@
-Cross-Origin: unknown-should-be-parsed-as-null
diff --git a/tests/wpt/web-platform-tests/html/cross-origin/resources/navigate_anonymous.sub.html.headers b/tests/wpt/web-platform-tests/html/cross-origin/resources/navigate_anonymous.sub.html.headers
deleted file mode 100644
index a76b601291ec..000000000000
--- a/tests/wpt/web-platform-tests/html/cross-origin/resources/navigate_anonymous.sub.html.headers
+++ /dev/null
@@ -1 +0,0 @@
-Cross-Origin: anonymous
diff --git a/tests/wpt/web-platform-tests/html/cross-origin/resources/navigate_usecredentials.sub.html b/tests/wpt/web-platform-tests/html/cross-origin/resources/navigate_usecredentials.sub.html
deleted file mode 100644
index 1008f70ff123..000000000000
--- a/tests/wpt/web-platform-tests/html/cross-origin/resources/navigate_usecredentials.sub.html
+++ /dev/null
@@ -1,18 +0,0 @@
-
-
diff --git a/tests/wpt/web-platform-tests/html/cross-origin/resources/navigate_usecredentials.sub.html.headers b/tests/wpt/web-platform-tests/html/cross-origin/resources/navigate_usecredentials.sub.html.headers
deleted file mode 100644
index a84d3782037e..000000000000
--- a/tests/wpt/web-platform-tests/html/cross-origin/resources/navigate_usecredentials.sub.html.headers
+++ /dev/null
@@ -1 +0,0 @@
-Cross-Origin: use-credentials
diff --git a/tests/wpt/web-platform-tests/html/cross-origin/resources/nothing.txt b/tests/wpt/web-platform-tests/html/cross-origin/resources/nothing.txt
deleted file mode 100644
index 9dafe9be2099..000000000000
--- a/tests/wpt/web-platform-tests/html/cross-origin/resources/nothing.txt
+++ /dev/null
@@ -1 +0,0 @@
-nothing
diff --git a/tests/wpt/web-platform-tests/html/cross-origin/resources/nothing.txt.headers b/tests/wpt/web-platform-tests/html/cross-origin/resources/nothing.txt.headers
deleted file mode 100644
index cb762eff8068..000000000000
--- a/tests/wpt/web-platform-tests/html/cross-origin/resources/nothing.txt.headers
+++ /dev/null
@@ -1 +0,0 @@
-Access-Control-Allow-Origin: *
diff --git a/tests/wpt/web-platform-tests/html/cross-origin/resources/popup_and_close.sub.html b/tests/wpt/web-platform-tests/html/cross-origin/resources/popup_and_close.sub.html
deleted file mode 100644
index 2489fa8d2470..000000000000
--- a/tests/wpt/web-platform-tests/html/cross-origin/resources/popup_and_close.sub.html
+++ /dev/null
@@ -1,18 +0,0 @@
-
-
diff --git a/tests/wpt/web-platform-tests/html/cross-origin/resources/popup_and_close.sub.html.headers b/tests/wpt/web-platform-tests/html/cross-origin/resources/popup_and_close.sub.html.headers
deleted file mode 100644
index a76b601291ec..000000000000
--- a/tests/wpt/web-platform-tests/html/cross-origin/resources/popup_and_close.sub.html.headers
+++ /dev/null
@@ -1 +0,0 @@
-Cross-Origin: anonymous
diff --git a/tests/wpt/web-platform-tests/html/cross-origin/usecredentials.tentative.html b/tests/wpt/web-platform-tests/html/cross-origin/usecredentials.tentative.html
deleted file mode 100644
index 55c0f2235db2..000000000000
--- a/tests/wpt/web-platform-tests/html/cross-origin/usecredentials.tentative.html
+++ /dev/null
@@ -1,54 +0,0 @@
-
-
-
Cross-Origin header and nested navigable resource without such header
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/html/cross-origin/usecredentials.tentative.html.headers b/tests/wpt/web-platform-tests/html/cross-origin/usecredentials.tentative.html.headers
deleted file mode 100644
index a84d3782037e..000000000000
--- a/tests/wpt/web-platform-tests/html/cross-origin/usecredentials.tentative.html.headers
+++ /dev/null
@@ -1 +0,0 @@
-Cross-Origin: use-credentials
diff --git a/tests/wpt/web-platform-tests/html/dom/interfaces.https.html b/tests/wpt/web-platform-tests/html/dom/interfaces.https.html
index 7745e4c68e25..0d3f1160d281 100644
--- a/tests/wpt/web-platform-tests/html/dom/interfaces.https.html
+++ b/tests/wpt/web-platform-tests/html/dom/interfaces.https.html
@@ -223,6 +223,7 @@
HTML IDL tests
HTMLFrameElement: ['document.createElement("frame")'],
HTMLDirectoryElement: ['document.createElement("dir")'],
HTMLFontElement: ['document.createElement("font")'],
+ DOMStringList: ['location.ancestorOrigins'],
});
idlArray.prevent_multiple_testing('HTMLElement');
await waitForLoad;
diff --git a/tests/wpt/web-platform-tests/html/infrastructure/common-dom-interfaces/collections/domstringlist-interface.html b/tests/wpt/web-platform-tests/html/infrastructure/common-dom-interfaces/collections/domstringlist-interface.html
deleted file mode 100644
index e991e19f059e..000000000000
--- a/tests/wpt/web-platform-tests/html/infrastructure/common-dom-interfaces/collections/domstringlist-interface.html
+++ /dev/null
@@ -1,32 +0,0 @@
-
-
-
DOMStringList IDL tests
-
-
-
-
-
-
DOMStringList IDL tests
-
-
-
diff --git a/tests/wpt/web-platform-tests/html/infrastructure/common-dom-interfaces/collections/domstringlist-interface.worker.js b/tests/wpt/web-platform-tests/html/infrastructure/common-dom-interfaces/collections/domstringlist-interface.worker.js
deleted file mode 100644
index e957b9e9b500..000000000000
--- a/tests/wpt/web-platform-tests/html/infrastructure/common-dom-interfaces/collections/domstringlist-interface.worker.js
+++ /dev/null
@@ -1,24 +0,0 @@
-"use strict";
-
-importScripts("/resources/testharness.js");
-importScripts("/resources/WebIDLParser.js", "/resources/idlharness.js");
-
-async_test(function(t) {
- var request = new XMLHttpRequest();
- request.open("GET", "/interfaces/html.idl");
- request.send();
- request.onload = t.step_func(function() {
- var idlArray = new IdlArray();
- var idls = request.responseText;
-
- idlArray.add_idls(idls, { only: ["DOMStringList"] });
-
- idlArray.add_objects({
- DOMStringList: [],
- });
- idlArray.test();
- t.done();
- });
-});
-
-done();
diff --git a/tests/wpt/web-platform-tests/html/interaction/focus/sequential-focus-navigation-and-the-tabindex-attribute/tabindex-getter.html b/tests/wpt/web-platform-tests/html/interaction/focus/sequential-focus-navigation-and-the-tabindex-attribute/tabindex-getter.html
new file mode 100644
index 000000000000..773739804b3a
--- /dev/null
+++ b/tests/wpt/web-platform-tests/html/interaction/focus/sequential-focus-navigation-and-the-tabindex-attribute/tabindex-getter.html
@@ -0,0 +1,74 @@
+
+
+
HTML Test: tabIndex getter return value
+
+
+
+
+
+
+
+
+
+
a
+
a
+
+
+
+
+
+
+
+
+
+
+
+
summary
second summary
details
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/html/rendering/replaced-elements/the-select-element/select-1-block-size-001-2.html b/tests/wpt/web-platform-tests/html/rendering/replaced-elements/the-select-element/select-1-block-size-001-2.html
new file mode 100644
index 000000000000..5f03a761dc87
--- /dev/null
+++ b/tests/wpt/web-platform-tests/html/rendering/replaced-elements/the-select-element/select-1-block-size-001-2.html
@@ -0,0 +1,29 @@
+
+
Select block size when line-height is specified
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/html/rendering/replaced-elements/the-select-element/select-1-block-size-001-ref-2.html b/tests/wpt/web-platform-tests/html/rendering/replaced-elements/the-select-element/select-1-block-size-001-ref-2.html
new file mode 100644
index 000000000000..385c2a75d427
--- /dev/null
+++ b/tests/wpt/web-platform-tests/html/rendering/replaced-elements/the-select-element/select-1-block-size-001-ref-2.html
@@ -0,0 +1,24 @@
+
+
CSS Test Reference
+
+
+
+
+
A
+
A
diff --git a/tests/wpt/web-platform-tests/html/rendering/replaced-elements/the-select-element/select-1-block-size-001-ref.html b/tests/wpt/web-platform-tests/html/rendering/replaced-elements/the-select-element/select-1-block-size-001-ref.html
new file mode 100644
index 000000000000..ad504846dfa2
--- /dev/null
+++ b/tests/wpt/web-platform-tests/html/rendering/replaced-elements/the-select-element/select-1-block-size-001-ref.html
@@ -0,0 +1,23 @@
+
+
CSS Test Reference
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/html/rendering/replaced-elements/the-select-element/select-1-block-size-001.html b/tests/wpt/web-platform-tests/html/rendering/replaced-elements/the-select-element/select-1-block-size-001.html
new file mode 100644
index 000000000000..5dc0fc15dc52
--- /dev/null
+++ b/tests/wpt/web-platform-tests/html/rendering/replaced-elements/the-select-element/select-1-block-size-001.html
@@ -0,0 +1,24 @@
+
+
Select block size when line-height is specified
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/html/webappapis/animation-frames/idlharness.html b/tests/wpt/web-platform-tests/html/webappapis/animation-frames/idlharness.html
deleted file mode 100644
index 3a9d1d9b583a..000000000000
--- a/tests/wpt/web-platform-tests/html/webappapis/animation-frames/idlharness.html
+++ /dev/null
@@ -1,50 +0,0 @@
-
-
-
-
-
idlharness test
-
-
-
-
-
-
-
-
-
idlharness test
-
This test validates the WebIDL included in the Timing control for script-based animations specification.
-
-
-[Global=Window, Exposed=Window]
-interface Window {
-};
-
-
-
-partial interface Window {
- long requestAnimationFrame(FrameRequestCallback callback);
- void cancelAnimationFrame(long handle);
-};
-
-callback FrameRequestCallback = void (DOMHighResTimeStamp time);
-
-
-
-
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/import-maps/imported/parsing-addresses.tentative.html b/tests/wpt/web-platform-tests/import-maps/imported/parsing-addresses.tentative.html
new file mode 100644
index 000000000000..ddb3b724bb64
--- /dev/null
+++ b/tests/wpt/web-platform-tests/import-maps/imported/parsing-addresses.tentative.html
@@ -0,0 +1,11 @@
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/import-maps/imported/parsing-schema.tentative.html b/tests/wpt/web-platform-tests/import-maps/imported/parsing-schema.tentative.html
new file mode 100644
index 000000000000..6b7c0e5b0eb4
--- /dev/null
+++ b/tests/wpt/web-platform-tests/import-maps/imported/parsing-schema.tentative.html
@@ -0,0 +1,11 @@
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/import-maps/imported/parsing-scope-keys.tentative.html b/tests/wpt/web-platform-tests/import-maps/imported/parsing-scope-keys.tentative.html
new file mode 100644
index 000000000000..601ac37720d7
--- /dev/null
+++ b/tests/wpt/web-platform-tests/import-maps/imported/parsing-scope-keys.tentative.html
@@ -0,0 +1,11 @@
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/import-maps/imported/parsing-specifier-keys.tentative.html b/tests/wpt/web-platform-tests/import-maps/imported/parsing-specifier-keys.tentative.html
new file mode 100644
index 000000000000..dd547f01d1df
--- /dev/null
+++ b/tests/wpt/web-platform-tests/import-maps/imported/parsing-specifier-keys.tentative.html
@@ -0,0 +1,11 @@
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/import-maps/imported/resolving-builtins.tentative.html b/tests/wpt/web-platform-tests/import-maps/imported/resolving-builtins.tentative.html
new file mode 100644
index 000000000000..c1395c175c77
--- /dev/null
+++ b/tests/wpt/web-platform-tests/import-maps/imported/resolving-builtins.tentative.html
@@ -0,0 +1,11 @@
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/import-maps/imported/resolving-not-yet-implemented.tentative.html b/tests/wpt/web-platform-tests/import-maps/imported/resolving-not-yet-implemented.tentative.html
new file mode 100644
index 000000000000..7db5f29f8929
--- /dev/null
+++ b/tests/wpt/web-platform-tests/import-maps/imported/resolving-not-yet-implemented.tentative.html
@@ -0,0 +1,11 @@
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/import-maps/imported/resolving-scopes.tentative.html b/tests/wpt/web-platform-tests/import-maps/imported/resolving-scopes.tentative.html
new file mode 100644
index 000000000000..4985249f4e29
--- /dev/null
+++ b/tests/wpt/web-platform-tests/import-maps/imported/resolving-scopes.tentative.html
@@ -0,0 +1,11 @@
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/import-maps/imported/resolving.tentative.html b/tests/wpt/web-platform-tests/import-maps/imported/resolving.tentative.html
new file mode 100644
index 000000000000..339026259b0f
--- /dev/null
+++ b/tests/wpt/web-platform-tests/import-maps/imported/resolving.tentative.html
@@ -0,0 +1,11 @@
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/import-maps/imported/resources/helpers/parsing.js b/tests/wpt/web-platform-tests/import-maps/imported/resources/helpers/parsing.js
new file mode 100644
index 000000000000..5c22f6de710e
--- /dev/null
+++ b/tests/wpt/web-platform-tests/import-maps/imported/resources/helpers/parsing.js
@@ -0,0 +1,50 @@
+'use strict';
+const { parseFromString } = require('../../lib/parser.js');
+
+// Local modifications from upstream:
+// Currently warnings and scopes are not checked in expectSpecifierMap().
+exports.expectSpecifierMap = (input, baseURL, output, warnings = []) => {
+ expect(parseFromString(`{ "imports": ${input} }`, baseURL))
+ .toEqual({ imports: output, scopes: {} });
+};
+
+exports.expectScopes = (inputArray, baseURL, outputArray, warnings = []) => {
+ const checkWarnings = testWarningHandler(warnings);
+
+ const inputScopesAsStrings = inputArray.map(scopePrefix => `${JSON.stringify(scopePrefix)}: {}`);
+ const inputString = `{ "scopes": { ${inputScopesAsStrings.join(', ')} } }`;
+
+ const outputScopesObject = {};
+ for (const outputScopePrefix of outputArray) {
+ outputScopesObject[outputScopePrefix] = {};
+ }
+
+ expect(parseFromString(inputString, baseURL)).toEqual({ imports: {}, scopes: outputScopesObject });
+
+ checkWarnings();
+};
+
+exports.expectBad = (input, baseURL, warnings = []) => {
+ const checkWarnings = testWarningHandler(warnings);
+ expect(() => parseFromString(input, baseURL)).toThrow(TypeError);
+ checkWarnings();
+};
+
+exports.expectWarnings = (input, baseURL, output, warnings = []) => {
+ const checkWarnings = testWarningHandler(warnings);
+ expect(parseFromString(input, baseURL)).toEqual(output);
+
+ checkWarnings();
+};
+
+function testWarningHandler(expectedWarnings) {
+ const warnings = [];
+ const { warn } = console;
+ console.warn = warning => {
+ warnings.push(warning);
+ };
+ return () => {
+ console.warn = warn;
+ expect(warnings).toEqual(expectedWarnings);
+ };
+}
diff --git a/tests/wpt/web-platform-tests/import-maps/imported/resources/parsing-addresses.js b/tests/wpt/web-platform-tests/import-maps/imported/resources/parsing-addresses.js
new file mode 100644
index 000000000000..0f5fc73506b1
--- /dev/null
+++ b/tests/wpt/web-platform-tests/import-maps/imported/resources/parsing-addresses.js
@@ -0,0 +1,351 @@
+'use strict';
+const { expectSpecifierMap } = require('./helpers/parsing.js');
+const { BUILT_IN_MODULE_SCHEME } = require('../lib/utils.js');
+
+describe('Relative URL-like addresses', () => {
+ it('should accept strings prefixed with ./, ../, or /', () => {
+ expectSpecifierMap(
+ `{
+ "dotSlash": "./foo",
+ "dotDotSlash": "../foo",
+ "slash": "/foo"
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ dotSlash: [expect.toMatchURL('https://base.example/path1/path2/foo')],
+ dotDotSlash: [expect.toMatchURL('https://base.example/path1/foo')],
+ slash: [expect.toMatchURL('https://base.example/foo')]
+ }
+ );
+ });
+
+ it('should not accept strings prefixed with ./, ../, or / for data: base URLs', () => {
+ expectSpecifierMap(
+ `{
+ "dotSlash": "./foo",
+ "dotDotSlash": "../foo",
+ "slash": "/foo"
+ }`,
+ 'data:text/html,test',
+ {
+ dotSlash: [],
+ dotDotSlash: [],
+ slash: []
+ },
+ [
+ `Invalid address "./foo" for the specifier key "dotSlash".`,
+ `Invalid address "../foo" for the specifier key "dotDotSlash".`,
+ `Invalid address "/foo" for the specifier key "slash".`
+ ]
+ );
+ });
+
+ it('should accept the literal strings ./, ../, or / with no suffix', () => {
+ expectSpecifierMap(
+ `{
+ "dotSlash": "./",
+ "dotDotSlash": "../",
+ "slash": "/"
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ dotSlash: [expect.toMatchURL('https://base.example/path1/path2/')],
+ dotDotSlash: [expect.toMatchURL('https://base.example/path1/')],
+ slash: [expect.toMatchURL('https://base.example/')]
+ }
+ );
+ });
+
+ it('should ignore percent-encoded variants of ./, ../, or /', () => {
+ expectSpecifierMap(
+ `{
+ "dotSlash1": "%2E/",
+ "dotDotSlash1": "%2E%2E/",
+ "dotSlash2": ".%2F",
+ "dotDotSlash2": "..%2F",
+ "slash2": "%2F",
+ "dotSlash3": "%2E%2F",
+ "dotDotSlash3": "%2E%2E%2F"
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ dotSlash1: [],
+ dotDotSlash1: [],
+ dotSlash2: [],
+ dotDotSlash2: [],
+ slash2: [],
+ dotSlash3: [],
+ dotDotSlash3: []
+ },
+ [
+ `Invalid address "%2E/" for the specifier key "dotSlash1".`,
+ `Invalid address "%2E%2E/" for the specifier key "dotDotSlash1".`,
+ `Invalid address ".%2F" for the specifier key "dotSlash2".`,
+ `Invalid address "..%2F" for the specifier key "dotDotSlash2".`,
+ `Invalid address "%2F" for the specifier key "slash2".`,
+ `Invalid address "%2E%2F" for the specifier key "dotSlash3".`,
+ `Invalid address "%2E%2E%2F" for the specifier key "dotDotSlash3".`
+ ]
+ );
+ });
+});
+
+describe('Built-in module addresses', () => {
+ it('should accept URLs using the built-in module scheme', () => {
+ expectSpecifierMap(
+ `{
+ "foo": "${BUILT_IN_MODULE_SCHEME}:foo"
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ foo: [expect.toMatchURL(`${BUILT_IN_MODULE_SCHEME}:foo`)]
+ }
+ );
+ });
+
+ it('should ignore percent-encoded variants of the built-in module scheme', () => {
+ expectSpecifierMap(
+ `{
+ "foo": "${encodeURIComponent(BUILT_IN_MODULE_SCHEME + ':')}foo"
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ foo: []
+ },
+ [`Invalid address "${encodeURIComponent(BUILT_IN_MODULE_SCHEME + ':')}foo" for the specifier key "foo".`]
+ );
+ });
+
+ it('should allow built-in module URLs that contain "/" or "\\"', () => {
+ expectSpecifierMap(
+ `{
+ "slashEnd": "${BUILT_IN_MODULE_SCHEME}:foo/",
+ "slashMiddle": "${BUILT_IN_MODULE_SCHEME}:foo/bar",
+ "backslash": "${BUILT_IN_MODULE_SCHEME}:foo\\\\baz"
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ slashEnd: [expect.toMatchURL(`${BUILT_IN_MODULE_SCHEME}:foo/`)],
+ slashMiddle: [expect.toMatchURL(`${BUILT_IN_MODULE_SCHEME}:foo/bar`)],
+ backslash: [expect.toMatchURL(`${BUILT_IN_MODULE_SCHEME}:foo\\baz`)]
+ }
+ );
+ });
+});
+
+describe('Absolute URL addresses', () => {
+ it('should only accept absolute URL addresses with fetch schemes', () => {
+ expectSpecifierMap(
+ `{
+ "about": "about:good",
+ "blob": "blob:good",
+ "data": "data:good",
+ "file": "file:///good",
+ "filesystem": "filesystem:good",
+ "http": "http://good/",
+ "https": "https://good/",
+ "ftp": "ftp://good/",
+ "import": "import:bad",
+ "mailto": "mailto:bad",
+ "javascript": "javascript:bad",
+ "wss": "wss:bad"
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ about: [expect.toMatchURL('about:good')],
+ blob: [expect.toMatchURL('blob:good')],
+ data: [expect.toMatchURL('data:good')],
+ file: [expect.toMatchURL('file:///good')],
+ filesystem: [expect.toMatchURL('filesystem:good')],
+ http: [expect.toMatchURL('http://good/')],
+ https: [expect.toMatchURL('https://good/')],
+ ftp: [expect.toMatchURL('ftp://good/')],
+ import: [],
+ mailto: [],
+ javascript: [],
+ wss: []
+ },
+ [
+ `Invalid address "import:bad" for the specifier key "import".`,
+ `Invalid address "mailto:bad" for the specifier key "mailto".`,
+ `Invalid address "javascript:bad" for the specifier key "javascript".`,
+ `Invalid address "wss:bad" for the specifier key "wss".`
+ ]
+ );
+ });
+
+ it('should only accept absolute URL addresses with fetch schemes inside arrays', () => {
+ expectSpecifierMap(
+ `{
+ "about": ["about:good"],
+ "blob": ["blob:good"],
+ "data": ["data:good"],
+ "file": ["file:///good"],
+ "filesystem": ["filesystem:good"],
+ "http": ["http://good/"],
+ "https": ["https://good/"],
+ "ftp": ["ftp://good/"],
+ "import": ["import:bad"],
+ "mailto": ["mailto:bad"],
+ "javascript": ["javascript:bad"],
+ "wss": ["wss:bad"]
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ about: [expect.toMatchURL('about:good')],
+ blob: [expect.toMatchURL('blob:good')],
+ data: [expect.toMatchURL('data:good')],
+ file: [expect.toMatchURL('file:///good')],
+ filesystem: [expect.toMatchURL('filesystem:good')],
+ http: [expect.toMatchURL('http://good/')],
+ https: [expect.toMatchURL('https://good/')],
+ ftp: [expect.toMatchURL('ftp://good/')],
+ import: [],
+ mailto: [],
+ javascript: [],
+ wss: []
+ },
+ [
+ `Invalid address "import:bad" for the specifier key "import".`,
+ `Invalid address "mailto:bad" for the specifier key "mailto".`,
+ `Invalid address "javascript:bad" for the specifier key "javascript".`,
+ `Invalid address "wss:bad" for the specifier key "wss".`
+ ]
+ );
+ });
+
+ it('should parse absolute URLs, ignoring unparseable ones', () => {
+ expectSpecifierMap(
+ `{
+ "unparseable1": "https://ex ample.org/",
+ "unparseable2": "https://example.com:demo",
+ "unparseable3": "http://[www.example.com]/",
+ "invalidButParseable1": "https:example.org",
+ "invalidButParseable2": "https://///example.com///",
+ "prettyNormal": "https://example.net",
+ "percentDecoding": "https://ex%41mple.com/",
+ "noPercentDecoding": "https://example.com/%41"
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ unparseable1: [],
+ unparseable2: [],
+ unparseable3: [],
+ invalidButParseable1: [expect.toMatchURL('https://example.org/')],
+ invalidButParseable2: [expect.toMatchURL('https://example.com///')],
+ prettyNormal: [expect.toMatchURL('https://example.net/')],
+ percentDecoding: [expect.toMatchURL('https://example.com/')],
+ noPercentDecoding: [expect.toMatchURL('https://example.com/%41')]
+ },
+ [
+ `Invalid address "https://ex ample.org/" for the specifier key "unparseable1".`,
+ `Invalid address "https://example.com:demo" for the specifier key "unparseable2".`,
+ `Invalid address "http://[www.example.com]/" for the specifier key "unparseable3".`
+ ]
+ );
+ });
+
+ it('should parse absolute URLs, ignoring unparseable ones inside arrays', () => {
+ expectSpecifierMap(
+ `{
+ "unparseable1": ["https://ex ample.org/"],
+ "unparseable2": ["https://example.com:demo"],
+ "unparseable3": ["http://[www.example.com]/"],
+ "invalidButParseable1": ["https:example.org"],
+ "invalidButParseable2": ["https://///example.com///"],
+ "prettyNormal": ["https://example.net"],
+ "percentDecoding": ["https://ex%41mple.com/"],
+ "noPercentDecoding": ["https://example.com/%41"]
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ unparseable1: [],
+ unparseable2: [],
+ unparseable3: [],
+ invalidButParseable1: [expect.toMatchURL('https://example.org/')],
+ invalidButParseable2: [expect.toMatchURL('https://example.com///')],
+ prettyNormal: [expect.toMatchURL('https://example.net/')],
+ percentDecoding: [expect.toMatchURL('https://example.com/')],
+ noPercentDecoding: [expect.toMatchURL('https://example.com/%41')]
+ },
+ [
+ `Invalid address "https://ex ample.org/" for the specifier key "unparseable1".`,
+ `Invalid address "https://example.com:demo" for the specifier key "unparseable2".`,
+ `Invalid address "http://[www.example.com]/" for the specifier key "unparseable3".`
+ ]
+ );
+ });
+});
+
+describe('Failing addresses: mismatched trailing slashes', () => {
+ it('should warn for the simple case', () => {
+ expectSpecifierMap(
+ `{
+ "trailer/": "/notrailer",
+ "${BUILT_IN_MODULE_SCHEME}:trailer/": "/bim-notrailer"
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ 'trailer/': [],
+ [`${BUILT_IN_MODULE_SCHEME}:trailer/`]: []
+ },
+ [
+ `Invalid address "https://base.example/notrailer" for package specifier key "trailer/". Package addresses must end with "/".`,
+ `Invalid address "https://base.example/bim-notrailer" for package specifier key "${BUILT_IN_MODULE_SCHEME}:trailer/". Package addresses must end with "/".`
+ ]
+ );
+ });
+
+ it('should warn for a mismatch alone in an array', () => {
+ expectSpecifierMap(
+ `{
+ "trailer/": ["/notrailer"],
+ "${BUILT_IN_MODULE_SCHEME}:trailer/": ["/bim-notrailer"]
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ 'trailer/': [],
+ [`${BUILT_IN_MODULE_SCHEME}:trailer/`]: []
+ },
+ [
+ `Invalid address "https://base.example/notrailer" for package specifier key "trailer/". Package addresses must end with "/".`,
+ `Invalid address "https://base.example/bim-notrailer" for package specifier key "${BUILT_IN_MODULE_SCHEME}:trailer/". Package addresses must end with "/".`
+ ]
+ );
+ });
+
+ it('should warn for a mismatch alongside non-mismatches in an array', () => {
+ expectSpecifierMap(
+ `{
+ "trailer/": ["/atrailer/", "/notrailer"],
+ "${BUILT_IN_MODULE_SCHEME}:trailer/": ["/bim-atrailer/", "/bim-notrailer"]
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ 'trailer/': [expect.toMatchURL('https://base.example/atrailer/')],
+ [`${BUILT_IN_MODULE_SCHEME}:trailer/`]: [expect.toMatchURL('https://base.example/bim-atrailer/')]
+ },
+ [
+ `Invalid address "https://base.example/notrailer" for package specifier key "trailer/". Package addresses must end with "/".`,
+ `Invalid address "https://base.example/bim-notrailer" for package specifier key "${BUILT_IN_MODULE_SCHEME}:trailer/". Package addresses must end with "/".`
+ ]
+ );
+ });
+});
+
+describe('Other invalid addresses', () => {
+ it('should ignore unprefixed strings that are not absolute URLs', () => {
+ for (const bad of ['bar', '\\bar', '~bar', '#bar', '?bar']) {
+ expectSpecifierMap(
+ `{
+ "foo": ${JSON.stringify(bad)}
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ foo: []
+ },
+ [`Invalid address "${bad}" for the specifier key "foo".`]
+ );
+ }
+ });
+});
diff --git a/tests/wpt/web-platform-tests/import-maps/imported/resources/parsing-schema.js b/tests/wpt/web-platform-tests/import-maps/imported/resources/parsing-schema.js
new file mode 100644
index 000000000000..695034533c7f
--- /dev/null
+++ b/tests/wpt/web-platform-tests/import-maps/imported/resources/parsing-schema.js
@@ -0,0 +1,139 @@
+'use strict';
+const { parseFromString } = require('../lib/parser.js');
+const { expectBad, expectWarnings, expectSpecifierMap } = require('./helpers/parsing.js');
+
+const nonObjectStrings = ['null', 'true', '1', '"foo"', '[]'];
+
+test('Invalid JSON', () => {
+ expect(() => parseFromString('{ imports: {} }', 'https://base.example/')).toThrow(SyntaxError);
+});
+
+describe('Mismatching the top-level schema', () => {
+ it('should throw for top-level non-objects', () => {
+ for (const nonObject of nonObjectStrings) {
+ expectBad(nonObject, 'https://base.example/');
+ }
+ });
+
+ it('should throw if imports is a non-object', () => {
+ for (const nonObject of nonObjectStrings) {
+ expectBad(`{ "imports": ${nonObject} }`, 'https://base.example/');
+ }
+ });
+
+ it('should throw if scopes is a non-object', () => {
+ for (const nonObject of nonObjectStrings) {
+ expectBad(`{ "scopes": ${nonObject} }`, 'https://base.example/');
+ }
+ });
+
+ it('should ignore unspecified top-level entries', () => {
+ expectWarnings(
+ `{
+ "imports": {},
+ "new-feature": {},
+ "scops": {}
+ }`,
+ 'https://base.example/',
+ { imports: {}, scopes: {} },
+ [
+ `Invalid top-level key "new-feature". Only "imports" and "scopes" can be present.`,
+ `Invalid top-level key "scops". Only "imports" and "scopes" can be present.`
+ ]
+ );
+ });
+});
+
+describe('Mismatching the specifier map schema', () => {
+ const invalidAddressStrings = ['true', '1', '{}'];
+ const invalidInsideArrayStrings = ['null', 'true', '1', '{}', '[]'];
+
+ it('should ignore entries where the address is not a string, array, or null', () => {
+ for (const invalid of invalidAddressStrings) {
+ expectSpecifierMap(
+ `{
+ "foo": ${invalid},
+ "bar": ["https://example.com/"]
+ }`,
+ 'https://base.example/',
+ {
+ bar: [expect.toMatchURL('https://example.com/')]
+ },
+ [
+ `Invalid address ${invalid} for the specifier key "foo". ` +
+ `Addresses must be strings, arrays, or null.`
+ ]
+ );
+ }
+ });
+
+ it('should ignore entries where the specifier key is an empty string', () => {
+ expectSpecifierMap(
+ `{
+ "": ["https://example.com/"]
+ }`,
+ 'https://base.example/',
+ {},
+ [`Invalid empty string specifier key.`]
+ );
+ });
+
+ it('should ignore members of an address array that are not strings', () => {
+ for (const invalid of invalidInsideArrayStrings) {
+ expectSpecifierMap(
+ `{
+ "foo": ["https://example.com/", ${invalid}],
+ "bar": ["https://example.com/"]
+ }`,
+ 'https://base.example/',
+ {
+ foo: [expect.toMatchURL('https://example.com/')],
+ bar: [expect.toMatchURL('https://example.com/')]
+ },
+ [
+ `Invalid address ${invalid} inside the address array for the specifier key "foo". ` +
+ `Address arrays must only contain strings.`
+ ]
+ );
+ }
+ });
+
+ it('should throw if a scope\'s value is not an object', () => {
+ for (const invalid of nonObjectStrings) {
+ expectBad(`{ "scopes": { "https://scope.example/": ${invalid} } }`, 'https://base.example/');
+ }
+ });
+});
+
+describe('Normalization', () => {
+ it('should normalize empty import maps to have imports and scopes keys', () => {
+ expect(parseFromString(`{}`, 'https://base.example/'))
+ .toEqual({ imports: {}, scopes: {} });
+ });
+
+ it('should normalize an import map without imports to have imports', () => {
+ expect(parseFromString(`{ "scopes": {} }`, 'https://base.example/'))
+ .toEqual({ imports: {}, scopes: {} });
+ });
+
+ it('should normalize an import map without scopes to have scopes', () => {
+ expect(parseFromString(`{ "imports": {} }`, 'https://base.example/'))
+ .toEqual({ imports: {}, scopes: {} });
+ });
+
+ it('should normalize addresses to arrays', () => {
+ expectSpecifierMap(
+ `{
+ "foo": "https://example.com/1",
+ "bar": ["https://example.com/2"],
+ "baz": null
+ }`,
+ 'https://base.example/',
+ {
+ foo: [expect.toMatchURL('https://example.com/1')],
+ bar: [expect.toMatchURL('https://example.com/2')],
+ baz: []
+ }
+ );
+ });
+});
diff --git a/tests/wpt/web-platform-tests/import-maps/imported/resources/parsing-scope-keys.js b/tests/wpt/web-platform-tests/import-maps/imported/resources/parsing-scope-keys.js
new file mode 100644
index 000000000000..cd1d9b348909
--- /dev/null
+++ b/tests/wpt/web-platform-tests/import-maps/imported/resources/parsing-scope-keys.js
@@ -0,0 +1,145 @@
+'use strict';
+const { expectScopes } = require('./helpers/parsing.js');
+
+describe('Relative URL scope keys', () => {
+ it('should work with no prefix', () => {
+ expectScopes(
+ ['foo'],
+ 'https://base.example/path1/path2/path3',
+ ['https://base.example/path1/path2/foo']
+ );
+ });
+
+ it('should work with ./, ../, and / prefixes', () => {
+ expectScopes(
+ ['./foo', '../foo', '/foo'],
+ 'https://base.example/path1/path2/path3',
+ [
+ 'https://base.example/path1/path2/foo',
+ 'https://base.example/path1/foo',
+ 'https://base.example/foo'
+ ]
+ );
+ });
+
+ it('should work with /s, ?s, and #s', () => {
+ expectScopes(
+ ['foo/bar?baz#qux'],
+ 'https://base.example/path1/path2/path3',
+ ['https://base.example/path1/path2/foo/bar?baz#qux']
+ );
+ });
+
+ it('should work with an empty string scope key', () => {
+ expectScopes(
+ [''],
+ 'https://base.example/path1/path2/path3',
+ ['https://base.example/path1/path2/path3']
+ );
+ });
+
+ it('should work with / suffixes', () => {
+ expectScopes(
+ ['foo/', './foo/', '../foo/', '/foo/', '/foo//'],
+ 'https://base.example/path1/path2/path3',
+ [
+ 'https://base.example/path1/path2/foo/',
+ 'https://base.example/path1/path2/foo/',
+ 'https://base.example/path1/foo/',
+ 'https://base.example/foo/',
+ 'https://base.example/foo//'
+ ]
+ );
+ });
+
+ it('should deduplicate based on URL parsing rules', () => {
+ expectScopes(
+ ['foo/\\', 'foo//', 'foo\\\\'],
+ 'https://base.example/path1/path2/path3',
+ ['https://base.example/path1/path2/foo//']
+ );
+ });
+});
+
+describe('Absolute URL scope keys', () => {
+ it('should only accept absolute URL scope keys with fetch schemes', () => {
+ expectScopes(
+ [
+ 'about:good',
+ 'blob:good',
+ 'data:good',
+ 'file:///good',
+ 'filesystem:good',
+ 'http://good/',
+ 'https://good/',
+ 'ftp://good/',
+ 'import:bad',
+ 'mailto:bad',
+ 'javascript:bad',
+ 'wss:ba'
+ ],
+ 'https://base.example/path1/path2/path3',
+ [
+ 'about:good',
+ 'blob:good',
+ 'data:good',
+ 'file:///good',
+ 'filesystem:good',
+ 'http://good/',
+ 'https://good/',
+ 'ftp://good/'
+ ],
+ [
+ 'Invalid scope "import:bad". Scope URLs must have a fetch scheme.',
+ 'Invalid scope "mailto:bad". Scope URLs must have a fetch scheme.',
+ 'Invalid scope "javascript:bad". Scope URLs must have a fetch scheme.',
+ 'Invalid scope "wss://ba/". Scope URLs must have a fetch scheme.'
+ ]
+ );
+ });
+
+ it('should parse absolute URL scope keys, ignoring unparseable ones', () => {
+ expectScopes(
+ [
+ 'https://ex ample.org/',
+ 'https://example.com:demo',
+ 'http://[www.example.com]/',
+ 'https:example.org',
+ 'https://///example.com///',
+ 'https://example.net',
+ 'https://ex%41mple.com/foo/',
+ 'https://example.com/%41'
+ ],
+ 'https://base.example/path1/path2/path3',
+ [
+ 'https://base.example/path1/path2/example.org', // tricky case! remember we have a base URL
+ 'https://example.com///',
+ 'https://example.net/',
+ 'https://example.com/foo/',
+ 'https://example.com/%41'
+ ],
+ [
+ 'Invalid scope "https://ex ample.org/" (parsed against base URL "https://base.example/path1/path2/path3").',
+ 'Invalid scope "https://example.com:demo" (parsed against base URL "https://base.example/path1/path2/path3").',
+ 'Invalid scope "http://[www.example.com]/" (parsed against base URL "https://base.example/path1/path2/path3").'
+ ]
+ );
+ });
+
+ it('should ignore relative URL scope keys when the base URL is a data: URL', () => {
+ expectScopes(
+ [
+ './foo',
+ '../foo',
+ '/foo'
+ ],
+ 'data:text/html,test',
+ [],
+ [
+ 'Invalid scope "./foo" (parsed against base URL "data:text/html,test").',
+ 'Invalid scope "../foo" (parsed against base URL "data:text/html,test").',
+ 'Invalid scope "/foo" (parsed against base URL "data:text/html,test").'
+ ]
+ );
+ });
+});
diff --git a/tests/wpt/web-platform-tests/import-maps/imported/resources/parsing-specifier-keys.js b/tests/wpt/web-platform-tests/import-maps/imported/resources/parsing-specifier-keys.js
new file mode 100644
index 000000000000..9eb423a19eb1
--- /dev/null
+++ b/tests/wpt/web-platform-tests/import-maps/imported/resources/parsing-specifier-keys.js
@@ -0,0 +1,159 @@
+'use strict';
+const { expectSpecifierMap } = require('./helpers/parsing.js');
+const { BUILT_IN_MODULE_SCHEME } = require('../lib/utils.js');
+
+const BLANK = `${BUILT_IN_MODULE_SCHEME}:blank`;
+
+describe('Relative URL-like specifier keys', () => {
+ it('should absolutize strings prefixed with ./, ../, or / into the corresponding URLs', () => {
+ expectSpecifierMap(
+ `{
+ "./foo": "/dotslash",
+ "../foo": "/dotdotslash",
+ "/foo": "/slash"
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ 'https://base.example/path1/path2/foo': [expect.toMatchURL('https://base.example/dotslash')],
+ 'https://base.example/path1/foo': [expect.toMatchURL('https://base.example/dotdotslash')],
+ 'https://base.example/foo': [expect.toMatchURL('https://base.example/slash')]
+ }
+ );
+ });
+
+ it('should not absolutize strings prefixed with ./, ../, or / with a data: URL base', () => {
+ expectSpecifierMap(
+ `{
+ "./foo": "https://example.com/dotslash",
+ "../foo": "https://example.com/dotdotslash",
+ "/foo": "https://example.com/slash"
+ }`,
+ 'data:text/html,test',
+ {
+ './foo': [expect.toMatchURL('https://example.com/dotslash')],
+ '../foo': [expect.toMatchURL('https://example.com/dotdotslash')],
+ '/foo': [expect.toMatchURL('https://example.com/slash')]
+ }
+ );
+ });
+
+ it('should absolutize the literal strings ./, ../, or / with no suffix', () => {
+ expectSpecifierMap(
+ `{
+ "./": "/dotslash/",
+ "../": "/dotdotslash/",
+ "/": "/slash/"
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ 'https://base.example/path1/path2/': [expect.toMatchURL('https://base.example/dotslash/')],
+ 'https://base.example/path1/': [expect.toMatchURL('https://base.example/dotdotslash/')],
+ 'https://base.example/': [expect.toMatchURL('https://base.example/slash/')]
+ }
+ );
+ });
+
+ it('should treat percent-encoded variants of ./, ../, or / as bare specifiers', () => {
+ expectSpecifierMap(
+ `{
+ "%2E/": "/dotSlash1/",
+ "%2E%2E/": "/dotDotSlash1/",
+ ".%2F": "/dotSlash2",
+ "..%2F": "/dotDotSlash2",
+ "%2F": "/slash2",
+ "%2E%2F": "/dotSlash3",
+ "%2E%2E%2F": "/dotDotSlash3"
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ '%2E/': [expect.toMatchURL('https://base.example/dotSlash1/')],
+ '%2E%2E/': [expect.toMatchURL('https://base.example/dotDotSlash1/')],
+ '.%2F': [expect.toMatchURL('https://base.example/dotSlash2')],
+ '..%2F': [expect.toMatchURL('https://base.example/dotDotSlash2')],
+ '%2F': [expect.toMatchURL('https://base.example/slash2')],
+ '%2E%2F': [expect.toMatchURL('https://base.example/dotSlash3')],
+ '%2E%2E%2F': [expect.toMatchURL('https://base.example/dotDotSlash3')]
+ }
+ );
+ });
+});
+
+describe('Absolute URL specifier keys', () => {
+ it('should only accept absolute URL specifier keys with fetch schemes, treating others as bare specifiers', () => {
+ expectSpecifierMap(
+ `{
+ "about:good": "/about",
+ "blob:good": "/blob",
+ "data:good": "/data",
+ "file:///good": "/file",
+ "filesystem:good": "/filesystem",
+ "http://good/": "/http/",
+ "https://good/": "/https/",
+ "ftp://good/": "/ftp/",
+ "import:bad": "/import",
+ "mailto:bad": "/mailto",
+ "javascript:bad": "/javascript",
+ "wss:bad": "/wss"
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ 'about:good': [expect.toMatchURL('https://base.example/about')],
+ 'blob:good': [expect.toMatchURL('https://base.example/blob')],
+ 'data:good': [expect.toMatchURL('https://base.example/data')],
+ 'file:///good': [expect.toMatchURL('https://base.example/file')],
+ 'filesystem:good': [expect.toMatchURL('https://base.example/filesystem')],
+ 'http://good/': [expect.toMatchURL('https://base.example/http/')],
+ 'https://good/': [expect.toMatchURL('https://base.example/https/')],
+ 'ftp://good/': [expect.toMatchURL('https://base.example/ftp/')],
+ 'import:bad': [expect.toMatchURL('https://base.example/import')],
+ 'mailto:bad': [expect.toMatchURL('https://base.example/mailto')],
+ 'javascript:bad': [expect.toMatchURL('https://base.example/javascript')],
+ 'wss:bad': [expect.toMatchURL('https://base.example/wss')]
+ }
+ );
+ });
+
+ it('should parse absolute URLs, treating unparseable ones as bare specifiers', () => {
+ expectSpecifierMap(
+ `{
+ "https://ex ample.org/": "/unparseable1/",
+ "https://example.com:demo": "/unparseable2",
+ "http://[www.example.com]/": "/unparseable3/",
+ "https:example.org": "/invalidButParseable1/",
+ "https://///example.com///": "/invalidButParseable2/",
+ "https://example.net": "/prettyNormal/",
+ "https://ex%41mple.com/": "/percentDecoding/",
+ "https://example.com/%41": "/noPercentDecoding"
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ 'https://ex ample.org/': [expect.toMatchURL('https://base.example/unparseable1/')],
+ 'https://example.com:demo': [expect.toMatchURL('https://base.example/unparseable2')],
+ 'http://[www.example.com]/': [expect.toMatchURL('https://base.example/unparseable3/')],
+ 'https://example.org/': [expect.toMatchURL('https://base.example/invalidButParseable1/')],
+ 'https://example.com///': [expect.toMatchURL('https://base.example/invalidButParseable2/')],
+ 'https://example.net/': [expect.toMatchURL('https://base.example/prettyNormal/')],
+ 'https://example.com/': [expect.toMatchURL('https://base.example/percentDecoding/')],
+ 'https://example.com/%41': [expect.toMatchURL('https://base.example/noPercentDecoding')]
+ }
+ );
+ });
+
+ it('should parse built-in module specifier keys, including with a "/"', () => {
+ expectSpecifierMap(
+ `{
+ "${BLANK}": "/blank",
+ "${BLANK}/": "/blank/",
+ "${BLANK}/foo": "/blank/foo",
+ "${BLANK}\\\\foo": "/blank/backslashfoo"
+ }`,
+ 'https://base.example/path1/path2/path3',
+ {
+ [BLANK]: [expect.toMatchURL('https://base.example/blank')],
+ [`${BLANK}/`]: [expect.toMatchURL('https://base.example/blank/')],
+ [`${BLANK}/foo`]: [expect.toMatchURL('https://base.example/blank/foo')],
+ [`${BLANK}\\foo`]: [expect.toMatchURL('https://base.example/blank/backslashfoo')]
+ }
+ );
+ });
+});
diff --git a/tests/wpt/web-platform-tests/import-maps/imported/resources/resolving-builtins.js b/tests/wpt/web-platform-tests/import-maps/imported/resources/resolving-builtins.js
new file mode 100644
index 000000000000..a9383df843d4
--- /dev/null
+++ b/tests/wpt/web-platform-tests/import-maps/imported/resources/resolving-builtins.js
@@ -0,0 +1,158 @@
+'use strict';
+const { URL } = require('url');
+const { parseFromString } = require('../lib/parser.js');
+const { resolve } = require('../lib/resolver.js');
+const { BUILT_IN_MODULE_SCHEME } = require('../lib/utils.js');
+
+const mapBaseURL = new URL('https://example.com/app/index.html');
+const scriptURL = new URL('https://example.com/js/app.mjs');
+
+const BLANK = `${BUILT_IN_MODULE_SCHEME}:blank`;
+const NONE = `${BUILT_IN_MODULE_SCHEME}:none`;
+
+function makeResolveUnderTest(mapString) {
+ const map = parseFromString(mapString, mapBaseURL);
+ return specifier => resolve(specifier, map, scriptURL);
+}
+
+describe('Unmapped built-in module specifiers', () => {
+ const resolveUnderTest = makeResolveUnderTest(`{}`);
+
+ it(`should resolve "${BLANK}" to "${BLANK}"`, () => {
+ expect(resolveUnderTest(BLANK)).toMatchURL(BLANK);
+ });
+
+ it(`should error resolving "${NONE}"`, () => {
+ expect(() => resolveUnderTest(NONE)).toThrow(TypeError);
+ });
+});
+
+describe('Remapping built-in module specifiers', () => {
+ it('should remap built-in modules', () => {
+ const resolveUnderTest = makeResolveUnderTest(`{
+ "imports": {
+ "${BLANK}": "./blank.mjs",
+ "${NONE}": "./none.mjs"
+ }
+ }`);
+
+ expect(resolveUnderTest(BLANK)).toMatchURL('https://example.com/app/blank.mjs');
+ expect(resolveUnderTest(NONE)).toMatchURL('https://example.com/app/none.mjs');
+ });
+
+ it('should remap built-in modules with slashes', () => {
+ const resolveUnderTest = makeResolveUnderTest(`{
+ "imports": {
+ "${BLANK}/": "./blank-slash/",
+ "${BLANK}/foo": "./blank-foo.mjs",
+ "${NONE}/": "./none-slash/",
+ "${NONE}/foo": "./none-foo.mjs"
+ }
+ }`);
+
+ expect(resolveUnderTest(`${BLANK}/`)).toMatchURL('https://example.com/app/blank-slash/');
+ expect(resolveUnderTest(`${BLANK}/foo`)).toMatchURL('https://example.com/app/blank-foo.mjs');
+ expect(resolveUnderTest(`${BLANK}/bar`)).toMatchURL('https://example.com/app/blank-slash/bar');
+ expect(resolveUnderTest(`${NONE}/`)).toMatchURL('https://example.com/app/none-slash/');
+ expect(resolveUnderTest(`${NONE}/foo`)).toMatchURL('https://example.com/app/none-foo.mjs');
+ expect(resolveUnderTest(`${NONE}/bar`)).toMatchURL('https://example.com/app/none-slash/bar');
+ });
+
+ it('should remap built-in modules with fallbacks', () => {
+ const resolveUnderTest = makeResolveUnderTest(`{
+ "imports": {
+ "${BLANK}": ["${BLANK}", "./blank.mjs"],
+ "${NONE}": ["${NONE}", "./none.mjs"]
+ }
+ }`);
+
+ expect(resolveUnderTest(BLANK)).toMatchURL(BLANK);
+ expect(resolveUnderTest(NONE)).toMatchURL('https://example.com/app/none.mjs');
+ });
+
+ it('should remap built-in modules with slashes and fallbacks', () => {
+ // NOTE: `${BLANK}/for-testing` is not per spec, just for these tests.
+ // See resolver.js.
+ const resolveUnderTest = makeResolveUnderTest(`{
+ "imports": {
+ "${BLANK}/": ["${BLANK}/", "./blank/"],
+ "${BLANK}/for-testing": ["${BLANK}/for-testing", "./blank-for-testing-special"],
+ "${NONE}/": ["${NONE}/", "./none/"],
+ "${NONE}/foo": ["${NONE}/foo", "./none-foo-special"]
+ }
+ }`);
+
+ // Built-in modules only resolve for exact matches, so this will trigger the fallback.
+ expect(resolveUnderTest(`${BLANK}/`)).toMatchURL('https://example.com/app/blank/');
+ expect(resolveUnderTest(`${BLANK}/foo`)).toMatchURL('https://example.com/app/blank/foo');
+
+ // This would fall back in a real implementation; it's only because we've gone against
+ // spec in the reference implementation (to make this testable) that this maps.
+ expect(resolveUnderTest(`${BLANK}/for-testing`)).toMatchURL(`${BLANK}/for-testing`);
+
+ expect(resolveUnderTest(`${NONE}/`)).toMatchURL('https://example.com/app/none/');
+ expect(resolveUnderTest(`${NONE}/bar`)).toMatchURL('https://example.com/app/none/bar');
+ expect(resolveUnderTest(`${NONE}/foo`)).toMatchURL('https://example.com/app/none-foo-special');
+ });
+});
+
+describe('Remapping to built-in modules', () => {
+ const resolveUnderTest = makeResolveUnderTest(`{
+ "imports": {
+ "blank": "${BLANK}",
+ "/blank": "${BLANK}",
+ "/blank/": "${BLANK}/",
+ "/blank-for-testing": "${BLANK}/for-testing",
+ "none": "${NONE}",
+ "/none": "${NONE}"
+ }
+ }`);
+
+ it(`should remap to "${BLANK}"`, () => {
+ expect(resolveUnderTest('blank')).toMatchURL(BLANK);
+ expect(resolveUnderTest('/blank')).toMatchURL(BLANK);
+ });
+
+ it(`should fail when remapping to "${BLANK}/"`, () => {
+ expect(() => resolveUnderTest('/blank/')).toThrow(TypeError);
+ });
+
+ it(`should remap to "${BLANK}/for-testing"`, () => {
+ expect(resolveUnderTest('/blank/for-testing')).toMatchURL(`${BLANK}/for-testing`);
+ expect(resolveUnderTest('/blank-for-testing')).toMatchURL(`${BLANK}/for-testing`);
+ });
+
+ it(`should remap to "${BLANK}" for URL-like specifiers`, () => {
+ expect(resolveUnderTest('/blank')).toMatchURL(BLANK);
+ expect(resolveUnderTest('https://example.com/blank')).toMatchURL(BLANK);
+ expect(resolveUnderTest('https://///example.com/blank')).toMatchURL(BLANK);
+ });
+
+ it(`should fail when remapping to "${NONE}"`, () => {
+ expect(() => resolveUnderTest('none')).toThrow(TypeError);
+ expect(() => resolveUnderTest('/none')).toThrow(TypeError);
+ });
+});
+
+describe('Fallbacks with built-in module addresses', () => {
+ const resolveUnderTest = makeResolveUnderTest(`{
+ "imports": {
+ "blank": [
+ "${BLANK}",
+ "./blank-fallback.mjs"
+ ],
+ "none": [
+ "${NONE}",
+ "./none-fallback.mjs"
+ ]
+ }
+ }`);
+
+ it(`should resolve to "${BLANK}"`, () => {
+ expect(resolveUnderTest('blank')).toMatchURL(BLANK);
+ });
+
+ it(`should fall back past "${NONE}"`, () => {
+ expect(resolveUnderTest('none')).toMatchURL('https://example.com/app/none-fallback.mjs');
+ });
+});
diff --git a/tests/wpt/web-platform-tests/import-maps/imported/resources/resolving-not-yet-implemented.js b/tests/wpt/web-platform-tests/import-maps/imported/resources/resolving-not-yet-implemented.js
new file mode 100644
index 000000000000..93d782fdad83
--- /dev/null
+++ b/tests/wpt/web-platform-tests/import-maps/imported/resources/resolving-not-yet-implemented.js
@@ -0,0 +1,47 @@
+'use strict';
+const { URL } = require('url');
+const { parseFromString } = require('../lib/parser.js');
+const { resolve } = require('../lib/resolver.js');
+const { BUILT_IN_MODULE_SCHEME } = require('../lib/utils.js');
+
+const mapBaseURL = new URL('https://example.com/app/index.html');
+const scriptURL = new URL('https://example.com/js/app.mjs');
+
+const BLANK = `${BUILT_IN_MODULE_SCHEME}:blank`;
+
+function makeResolveUnderTest(mapString) {
+ const map = parseFromString(mapString, mapBaseURL);
+ return specifier => resolve(specifier, map, scriptURL);
+}
+
+describe('Fallbacks that are not [built-in, fetch scheme]', () => {
+ const resolveUnderTest = makeResolveUnderTest(`{
+ "imports": {
+ "bad1": [
+ "${BLANK}",
+ "${BLANK}"
+ ],
+ "bad2": [
+ "${BLANK}",
+ "/bad2-1.mjs",
+ "/bad2-2.mjs"
+ ],
+ "bad3": [
+ "/bad3-1.mjs",
+ "/bad3-2.mjs"
+ ]
+ }
+ }`);
+
+ it('should fail for [built-in, built-in]', () => {
+ expect(() => resolveUnderTest('bad1')).toThrow(/not yet implemented/);
+ });
+
+ it('should fail for [built-in, fetch scheme, fetch scheme]', () => {
+ expect(() => resolveUnderTest('bad2')).toThrow(/not yet implemented/);
+ });
+
+ it('should fail for [fetch scheme, fetch scheme]', () => {
+ expect(() => resolveUnderTest('bad3')).toThrow(/not yet implemented/);
+ });
+});
diff --git a/tests/wpt/web-platform-tests/import-maps/imported/resources/resolving-scopes.js b/tests/wpt/web-platform-tests/import-maps/imported/resources/resolving-scopes.js
new file mode 100644
index 000000000000..ca19a6684060
--- /dev/null
+++ b/tests/wpt/web-platform-tests/import-maps/imported/resources/resolving-scopes.js
@@ -0,0 +1,230 @@
+'use strict';
+const { URL } = require('url');
+const { parseFromString } = require('../lib/parser.js');
+const { resolve } = require('../lib/resolver.js');
+
+const mapBaseURL = new URL('https://example.com/app/index.html');
+
+function makeResolveUnderTest(mapString) {
+ const map = parseFromString(mapString, mapBaseURL);
+ return (specifier, baseURL) => resolve(specifier, map, baseURL);
+}
+
+describe('Mapped using scope instead of "imports"', () => {
+ const jsNonDirURL = new URL('https://example.com/js');
+ const jsPrefixedURL = new URL('https://example.com/jsiscool');
+ const inJSDirURL = new URL('https://example.com/js/app.mjs');
+ const topLevelURL = new URL('https://example.com/app.mjs');
+
+ it('should fail when the mapping is to an empty array', () => {
+ const resolveUnderTest = makeResolveUnderTest(`{
+ "scopes": {
+ "/js/": {
+ "moment": null,
+ "lodash": []
+ }
+ }
+ }`);
+
+ expect(() => resolveUnderTest('moment', inJSDirURL)).toThrow(TypeError);
+ expect(() => resolveUnderTest('lodash', inJSDirURL)).toThrow(TypeError);
+ });
+
+ describe('Exact vs. prefix based matching', () => {
+ it('should match correctly when both are in the map', () => {
+ const resolveUnderTest = makeResolveUnderTest(`{
+ "scopes": {
+ "/js": {
+ "moment": "/only-triggered-by-exact/moment",
+ "moment/": "/only-triggered-by-exact/moment/"
+ },
+ "/js/": {
+ "moment": "/triggered-by-any-subpath/moment",
+ "moment/": "/triggered-by-any-subpath/moment/"
+ }
+ }
+ }`);
+
+ expect(resolveUnderTest('moment', jsNonDirURL)).toMatchURL('https://example.com/only-triggered-by-exact/moment');
+ expect(resolveUnderTest('moment/foo', jsNonDirURL)).toMatchURL('https://example.com/only-triggered-by-exact/moment/foo');
+
+ expect(resolveUnderTest('moment', inJSDirURL)).toMatchURL('https://example.com/triggered-by-any-subpath/moment');
+ expect(resolveUnderTest('moment/foo', inJSDirURL)).toMatchURL('https://example.com/triggered-by-any-subpath/moment/foo');
+
+ expect(() => resolveUnderTest('moment', jsPrefixedURL)).toThrow(TypeError);
+ expect(() => resolveUnderTest('moment/foo', jsPrefixedURL)).toThrow(TypeError);
+ });
+
+ it('should match correctly when only an exact match is in the map', () => {
+ const resolveUnderTest = makeResolveUnderTest(`{
+ "scopes": {
+ "/js": {
+ "moment": "/only-triggered-by-exact/moment",
+ "moment/": "/only-triggered-by-exact/moment/"
+ }
+ }
+ }`);
+
+ expect(resolveUnderTest('moment', jsNonDirURL)).toMatchURL('https://example.com/only-triggered-by-exact/moment');
+ expect(resolveUnderTest('moment/foo', jsNonDirURL)).toMatchURL('https://example.com/only-triggered-by-exact/moment/foo');
+
+ expect(() => resolveUnderTest('moment', inJSDirURL)).toThrow(TypeError);
+ expect(() => resolveUnderTest('moment/foo', inJSDirURL)).toThrow(TypeError);
+
+ expect(() => resolveUnderTest('moment', jsPrefixedURL)).toThrow(TypeError);
+ expect(() => resolveUnderTest('moment/foo', jsPrefixedURL)).toThrow(TypeError);
+ });
+
+ it('should match correctly when only a prefix match is in the map', () => {
+ const resolveUnderTest = makeResolveUnderTest(`{
+ "scopes": {
+ "/js/": {
+ "moment": "/triggered-by-any-subpath/moment",
+ "moment/": "/triggered-by-any-subpath/moment/"
+ }
+ }
+ }`);
+
+ expect(() => resolveUnderTest('moment', jsNonDirURL)).toThrow(TypeError);
+ expect(() => resolveUnderTest('moment/foo', jsNonDirURL)).toThrow(TypeError);
+
+ expect(resolveUnderTest('moment', inJSDirURL)).toMatchURL('https://example.com/triggered-by-any-subpath/moment');
+ expect(resolveUnderTest('moment/foo', inJSDirURL)).toMatchURL('https://example.com/triggered-by-any-subpath/moment/foo');
+
+ expect(() => resolveUnderTest('moment', jsPrefixedURL)).toThrow(TypeError);
+ expect(() => resolveUnderTest('moment/foo', jsPrefixedURL)).toThrow(TypeError);
+ });
+ });
+
+ describe('Package-like scenarios', () => {
+ const resolveUnderTest = makeResolveUnderTest(`{
+ "imports": {
+ "moment": "/node_modules/moment/src/moment.js",
+ "moment/": "/node_modules/moment/src/",
+ "lodash-dot": "./node_modules/lodash-es/lodash.js",
+ "lodash-dot/": "./node_modules/lodash-es/",
+ "lodash-dotdot": "../node_modules/lodash-es/lodash.js",
+ "lodash-dotdot/": "../node_modules/lodash-es/"
+ },
+ "scopes": {
+ "/": {
+ "moment": "/node_modules_3/moment/src/moment.js",
+ "vue": "/node_modules_3/vue/dist/vue.runtime.esm.js"
+ },
+ "/js/": {
+ "lodash-dot": "./node_modules_2/lodash-es/lodash.js",
+ "lodash-dot/": "./node_modules_2/lodash-es/",
+ "lodash-dotdot": "../node_modules_2/lodash-es/lodash.js",
+ "lodash-dotdot/": "../node_modules_2/lodash-es/"
+ }
+ }
+ }`);
+
+ it('should resolve scoped', () => {
+ expect(resolveUnderTest('lodash-dot', inJSDirURL)).toMatchURL('https://example.com/app/node_modules_2/lodash-es/lodash.js');
+ expect(resolveUnderTest('lodash-dotdot', inJSDirURL)).toMatchURL('https://example.com/node_modules_2/lodash-es/lodash.js');
+ expect(resolveUnderTest('lodash-dot/foo', inJSDirURL)).toMatchURL('https://example.com/app/node_modules_2/lodash-es/foo');
+ expect(resolveUnderTest('lodash-dotdot/foo', inJSDirURL)).toMatchURL('https://example.com/node_modules_2/lodash-es/foo');
+ });
+
+ it('should apply best scope match', () => {
+ expect(resolveUnderTest('moment', topLevelURL)).toMatchURL('https://example.com/node_modules_3/moment/src/moment.js');
+ expect(resolveUnderTest('moment', inJSDirURL)).toMatchURL('https://example.com/node_modules_3/moment/src/moment.js');
+ expect(resolveUnderTest('vue', inJSDirURL)).toMatchURL('https://example.com/node_modules_3/vue/dist/vue.runtime.esm.js');
+ });
+
+ it('should fallback to "imports"', () => {
+ expect(resolveUnderTest('moment/foo', topLevelURL)).toMatchURL('https://example.com/node_modules/moment/src/foo');
+ expect(resolveUnderTest('moment/foo', inJSDirURL)).toMatchURL('https://example.com/node_modules/moment/src/foo');
+ expect(resolveUnderTest('lodash-dot', topLevelURL)).toMatchURL('https://example.com/app/node_modules/lodash-es/lodash.js');
+ expect(resolveUnderTest('lodash-dotdot', topLevelURL)).toMatchURL('https://example.com/node_modules/lodash-es/lodash.js');
+ expect(resolveUnderTest('lodash-dot/foo', topLevelURL)).toMatchURL('https://example.com/app/node_modules/lodash-es/foo');
+ expect(resolveUnderTest('lodash-dotdot/foo', topLevelURL)).toMatchURL('https://example.com/node_modules/lodash-es/foo');
+ });
+
+ it('should still fail for package-like specifiers that are not declared', () => {
+ expect(() => resolveUnderTest('underscore/', inJSDirURL)).toThrow(TypeError);
+ expect(() => resolveUnderTest('underscore/foo', inJSDirURL)).toThrow(TypeError);
+ });
+ });
+
+ describe('The scope inheritance example from the README', () => {
+ const resolveUnderTest = makeResolveUnderTest(`{
+ "imports": {
+ "a": "/a-1.mjs",
+ "b": "/b-1.mjs",
+ "c": "/c-1.mjs"
+ },
+ "scopes": {
+ "/scope2/": {
+ "a": "/a-2.mjs"
+ },
+ "/scope2/scope3/": {
+ "b": "/b-3.mjs"
+ }
+ }
+ }`);
+
+ const scope1URL = new URL('https://example.com/scope1/foo.mjs');
+ const scope2URL = new URL('https://example.com/scope2/foo.mjs');
+ const scope3URL = new URL('https://example.com/scope2/scope3/foo.mjs');
+
+ it('should fall back to "imports" when none match', () => {
+ expect(resolveUnderTest('a', scope1URL)).toMatchURL('https://example.com/a-1.mjs');
+ expect(resolveUnderTest('b', scope1URL)).toMatchURL('https://example.com/b-1.mjs');
+ expect(resolveUnderTest('c', scope1URL)).toMatchURL('https://example.com/c-1.mjs');
+ });
+
+ it('should use a direct scope override', () => {
+ expect(resolveUnderTest('a', scope2URL)).toMatchURL('https://example.com/a-2.mjs');
+ expect(resolveUnderTest('b', scope2URL)).toMatchURL('https://example.com/b-1.mjs');
+ expect(resolveUnderTest('c', scope2URL)).toMatchURL('https://example.com/c-1.mjs');
+ });
+
+ it('should use an indirect scope override', () => {
+ expect(resolveUnderTest('a', scope3URL)).toMatchURL('https://example.com/a-2.mjs');
+ expect(resolveUnderTest('b', scope3URL)).toMatchURL('https://example.com/b-3.mjs');
+ expect(resolveUnderTest('c', scope3URL)).toMatchURL('https://example.com/c-1.mjs');
+ });
+ });
+
+ describe('Relative URL scope keys', () => {
+ const resolveUnderTest = makeResolveUnderTest(`{
+ "imports": {
+ "a": "/a-1.mjs",
+ "b": "/b-1.mjs",
+ "c": "/c-1.mjs"
+ },
+ "scopes": {
+ "": {
+ "a": "/a-empty-string.mjs"
+ },
+ "./": {
+ "b": "/b-dot-slash.mjs"
+ },
+ "../": {
+ "c": "/c-dot-dot-slash.mjs"
+ }
+ }
+ }`);
+ const inSameDirAsMap = new URL('./foo.mjs', mapBaseURL);
+ const inDirAboveMap = new URL('../foo.mjs', mapBaseURL);
+
+ it('should resolve an empty string scope using the import map URL', () => {
+ expect(resolveUnderTest('a', mapBaseURL)).toMatchURL('https://example.com/a-empty-string.mjs');
+ expect(resolveUnderTest('a', inSameDirAsMap)).toMatchURL('https://example.com/a-1.mjs');
+ });
+
+ it('should resolve a ./ scope using the import map URL\'s directory', () => {
+ expect(resolveUnderTest('b', mapBaseURL)).toMatchURL('https://example.com/b-dot-slash.mjs');
+ expect(resolveUnderTest('b', inSameDirAsMap)).toMatchURL('https://example.com/b-dot-slash.mjs');
+ });
+
+ it('should resolve a ../ scope using the import map URL\'s directory', () => {
+ expect(resolveUnderTest('c', mapBaseURL)).toMatchURL('https://example.com/c-dot-dot-slash.mjs');
+ expect(resolveUnderTest('c', inSameDirAsMap)).toMatchURL('https://example.com/c-dot-dot-slash.mjs');
+ expect(resolveUnderTest('c', inDirAboveMap)).toMatchURL('https://example.com/c-dot-dot-slash.mjs');
+ });
+ });
+});
+
diff --git a/tests/wpt/web-platform-tests/import-maps/resources/resolving.js b/tests/wpt/web-platform-tests/import-maps/imported/resources/resolving.js
similarity index 77%
rename from tests/wpt/web-platform-tests/import-maps/resources/resolving.js
rename to tests/wpt/web-platform-tests/import-maps/imported/resources/resolving.js
index 0409962e4d79..29ee31ccbc93 100644
--- a/tests/wpt/web-platform-tests/import-maps/resources/resolving.js
+++ b/tests/wpt/web-platform-tests/import-maps/imported/resources/resolving.js
@@ -1,9 +1,4 @@
'use strict';
-
-// Imported from:
-// https://github.com/WICG/import-maps/blob/master/reference-implementation/__tests__/resolving.js
-// TODO: Upstream local changes.
-
const { URL } = require('url');
const { parseFromString } = require('../lib/parser.js');
const { resolve } = require('../lib/resolver.js');
@@ -89,7 +84,8 @@ describe('Mapped using the "imports" key only (no scopes)', () => {
"lodash-dot": "./node_modules/lodash-es/lodash.js",
"lodash-dot/": "./node_modules/lodash-es/",
"lodash-dotdot": "../node_modules/lodash-es/lodash.js",
- "lodash-dotdot/": "../node_modules/lodash-es/"
+ "lodash-dotdot/": "../node_modules/lodash-es/",
+ "nowhere/": []
}
}`);
@@ -114,6 +110,10 @@ describe('Mapped using the "imports" key only (no scopes)', () => {
expect(() => resolveUnderTest('underscore/')).toThrow(TypeError);
expect(() => resolveUnderTest('underscore/foo')).toThrow(TypeError);
});
+
+ it('should fail for package submodules that map to nowhere', () => {
+ expect(() => resolveUnderTest('nowhere/foo')).toThrow(TypeError);
+ });
});
describe('Tricky specifiers', () => {
@@ -149,7 +149,7 @@ describe('Mapped using the "imports" key only (no scopes)', () => {
describe('URL-like specifiers', () => {
const resolveUnderTest = makeResolveUnderTest(`{
"imports": {
- "/node_modules/als-polyfill/index.mjs": "@std/kv-storage",
+ "/node_modules/als-polyfill/index.mjs": "std:kv-storage",
"/lib/foo.mjs": "./more/bar.mjs",
"./dotrelative/foo.mjs": "/lib/dot.mjs",
@@ -158,20 +158,17 @@ describe('Mapped using the "imports" key only (no scopes)', () => {
"/lib/no.mjs": null,
"./dotrelative/no.mjs": [],
- "/": "/lib/slash-only.mjs",
- "./": "/lib/dotslash-only.mjs",
+ "/": "/lib/slash-only/",
+ "./": "/lib/dotslash-only/",
+
+ "/test/": "/lib/url-trailing-slash/",
+ "./test/": "/lib/url-trailing-slash-dot/",
"/test": "/lib/test1.mjs",
"../test": "/lib/test2.mjs"
}
}`);
- it('should remap to built-in modules', () => {
- expect(resolveUnderTest('/node_modules/als-polyfill/index.mjs')).toMatchURL('import:@std/kv-storage');
- expect(resolveUnderTest('https://example.com/node_modules/als-polyfill/index.mjs')).toMatchURL('import:@std/kv-storage');
- expect(resolveUnderTest('https://///example.com/node_modules/als-polyfill/index.mjs')).toMatchURL('import:@std/kv-storage');
- });
-
it('should remap to other URLs', () => {
expect(resolveUnderTest('https://example.com/lib/foo.mjs')).toMatchURL('https://example.com/app/more/bar.mjs');
expect(resolveUnderTest('https://///example.com/lib/foo.mjs')).toMatchURL('https://example.com/app/more/bar.mjs');
@@ -195,13 +192,18 @@ describe('Mapped using the "imports" key only (no scopes)', () => {
});
it('should remap URLs that are just composed from / and .', () => {
- expect(resolveUnderTest('https://example.com/')).toMatchURL('https://example.com/lib/slash-only.mjs');
- expect(resolveUnderTest('/')).toMatchURL('https://example.com/lib/slash-only.mjs');
- expect(resolveUnderTest('../')).toMatchURL('https://example.com/lib/slash-only.mjs');
+ expect(resolveUnderTest('https://example.com/')).toMatchURL('https://example.com/lib/slash-only/');
+ expect(resolveUnderTest('/')).toMatchURL('https://example.com/lib/slash-only/');
+ expect(resolveUnderTest('../')).toMatchURL('https://example.com/lib/slash-only/');
+
+ expect(resolveUnderTest('https://example.com/app/')).toMatchURL('https://example.com/lib/dotslash-only/');
+ expect(resolveUnderTest('/app/')).toMatchURL('https://example.com/lib/dotslash-only/');
+ expect(resolveUnderTest('../app/')).toMatchURL('https://example.com/lib/dotslash-only/');
+ });
- expect(resolveUnderTest('https://example.com/app/')).toMatchURL('https://example.com/lib/dotslash-only.mjs');
- expect(resolveUnderTest('/app/')).toMatchURL('https://example.com/lib/dotslash-only.mjs');
- expect(resolveUnderTest('../app/')).toMatchURL('https://example.com/lib/dotslash-only.mjs');
+ it('should remap URLs that are prefix-matched by keys with trailing slashes', () => {
+ expect(resolveUnderTest('/test/foo.mjs')).toMatchURL('https://example.com/lib/url-trailing-slash/foo.mjs');
+ expect(resolveUnderTest('https://example.com/app/test/foo.mjs')).toMatchURL('https://example.com/lib/url-trailing-slash-dot/foo.mjs');
});
it('should use the last entry\'s address when URL-like specifiers parse to the same absolute URL', () => {
@@ -209,22 +211,60 @@ describe('Mapped using the "imports" key only (no scopes)', () => {
});
});
- describe('overlapping entries with trailing slashes', () => {
- const resolveUnderTest = makeResolveUnderTest(`{
- "imports": {
- "a": "/1",
- "a/": "/2/",
- "a/b": "/3",
- "a/b/": "/4/"
- }
- }`);
+ describe('Overlapping entries with trailing slashes', () => {
+ it('should favor the most-specific key (no empty arrays)', () => {
+ const resolveUnderTest = makeResolveUnderTest(`{
+ "imports": {
+ "a": "/1",
+ "a/": "/2/",
+ "a/b": "/3",
+ "a/b/": "/4/"
+ }
+ }`);
- it('most-specific wins', () => {
expect(resolveUnderTest('a')).toMatchURL('https://example.com/1');
expect(resolveUnderTest('a/')).toMatchURL('https://example.com/2/');
expect(resolveUnderTest('a/b')).toMatchURL('https://example.com/3');
expect(resolveUnderTest('a/b/')).toMatchURL('https://example.com/4/');
expect(resolveUnderTest('a/b/c')).toMatchURL('https://example.com/4/c');
});
+
+ it('should favor the most-specific key when empty arrays are involved for less-specific keys', () => {
+ const resolveUnderTest = makeResolveUnderTest(`{
+ "imports": {
+ "a": [],
+ "a/": [],
+ "a/b": "/3",
+ "a/b/": "/4/"
+ }
+ }`);
+
+ expect(() => resolveUnderTest('a')).toThrow(TypeError);
+ expect(() => resolveUnderTest('a/')).toThrow(TypeError);
+ expect(() => resolveUnderTest('a/x')).toThrow(TypeError);
+ expect(resolveUnderTest('a/b')).toMatchURL('https://example.com/3');
+ expect(resolveUnderTest('a/b/')).toMatchURL('https://example.com/4/');
+ expect(resolveUnderTest('a/b/c')).toMatchURL('https://example.com/4/c');
+ expect(() => resolveUnderTest('a/x/c')).toThrow(TypeError);
+ });
+
+ it('should favor the most-specific key when empty arrays are involved for more-specific keys', () => {
+ const resolveUnderTest = makeResolveUnderTest(`{
+ "imports": {
+ "a": "/1",
+ "a/": "/2/",
+ "a/b": [],
+ "a/b/": []
+ }
+ }`);
+
+ expect(resolveUnderTest('a')).toMatchURL('https://example.com/1');
+ expect(resolveUnderTest('a/')).toMatchURL('https://example.com/2/');
+ expect(resolveUnderTest('a/x')).toMatchURL('https://example.com/2/x');
+ expect(() => resolveUnderTest('a/b')).toThrow(TypeError);
+ expect(() => resolveUnderTest('a/b/')).toThrow(TypeError);
+ expect(() => resolveUnderTest('a/b/c')).toThrow(TypeError);
+ expect(resolveUnderTest('a/x/c')).toMatchURL('https://example.com/2/x/c');
+ });
});
});
diff --git a/tests/wpt/web-platform-tests/import-maps/resolving.tentative.html b/tests/wpt/web-platform-tests/import-maps/resources/jest-test-helper.js
similarity index 56%
rename from tests/wpt/web-platform-tests/import-maps/resolving.tentative.html
rename to tests/wpt/web-platform-tests/import-maps/resources/jest-test-helper.js
index f2b09a7ae024..86556ed3dd95 100644
--- a/tests/wpt/web-platform-tests/import-maps/resolving.tentative.html
+++ b/tests/wpt/web-platform-tests/import-maps/resources/jest-test-helper.js
@@ -1,27 +1,56 @@
-
-
-
-
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/interfaces/element-timing.idl b/tests/wpt/web-platform-tests/interfaces/element-timing.idl
index dc3b886cfe5b..cf56426fb6ea 100644
--- a/tests/wpt/web-platform-tests/interfaces/element-timing.idl
+++ b/tests/wpt/web-platform-tests/interfaces/element-timing.idl
@@ -13,6 +13,7 @@ interface PerformanceElementTiming : PerformanceEntry {
readonly attribute DOMString id;
readonly attribute Element? element;
readonly attribute DOMString url;
+ [Default] object toJSON();
};
partial interface Element {
diff --git a/tests/wpt/web-platform-tests/interfaces/event-timing.idl b/tests/wpt/web-platform-tests/interfaces/event-timing.idl
index c6790e16e3db..e8475d31922f 100644
--- a/tests/wpt/web-platform-tests/interfaces/event-timing.idl
+++ b/tests/wpt/web-platform-tests/interfaces/event-timing.idl
@@ -8,6 +8,7 @@ interface PerformanceEventTiming : PerformanceEntry {
readonly attribute DOMHighResTimeStamp processingStart;
readonly attribute DOMHighResTimeStamp processingEnd;
readonly attribute boolean cancelable;
+ [Default] object toJSON();
};
[Exposed=Window]
diff --git a/tests/wpt/web-platform-tests/interfaces/largest-contentful-paint.idl b/tests/wpt/web-platform-tests/interfaces/largest-contentful-paint.idl
index f16a7ff812c9..d2c69c475755 100644
--- a/tests/wpt/web-platform-tests/interfaces/largest-contentful-paint.idl
+++ b/tests/wpt/web-platform-tests/interfaces/largest-contentful-paint.idl
@@ -10,4 +10,5 @@ interface LargestContentfulPaint : PerformanceEntry {
readonly attribute DOMString id;
readonly attribute DOMString url;
readonly attribute Element? element;
+ [Default] object toJSON();
};
diff --git a/tests/wpt/web-platform-tests/interfaces/layout-instability.idl b/tests/wpt/web-platform-tests/interfaces/layout-instability.idl
index 1bacea77bcef..c46151a923dd 100644
--- a/tests/wpt/web-platform-tests/interfaces/layout-instability.idl
+++ b/tests/wpt/web-platform-tests/interfaces/layout-instability.idl
@@ -7,4 +7,5 @@ interface LayoutShift : PerformanceEntry {
readonly attribute long value;
readonly attribute boolean hadRecentInput;
readonly attribute DOMHighResTimeStamp lastInputTime;
+ [Default] object toJSON();
};
diff --git a/tests/wpt/web-platform-tests/interfaces/webrtc-stats.idl b/tests/wpt/web-platform-tests/interfaces/webrtc-stats.idl
index 48ebc187bc48..e92533a226e9 100644
--- a/tests/wpt/web-platform-tests/interfaces/webrtc-stats.idl
+++ b/tests/wpt/web-platform-tests/interfaces/webrtc-stats.idl
@@ -70,8 +70,12 @@ dictionary RTCInboundRtpStreamStats : RTCReceivedRtpStreamStats {
DOMString remoteId;
unsigned long framesDecoded;
unsigned long keyFramesDecoded;
+ unsigned long frameWidth;
+ unsigned long frameHeight;
+ double framesPerSecond;
unsigned long long qpSum;
double totalDecodeTime;
+ boolean voiceActivityFlag;
DOMHighResTimeStamp lastPacketReceivedTimestamp;
double averageRtcpInterval;
unsigned long fecPacketsReceived;
@@ -84,6 +88,22 @@ dictionary RTCInboundRtpStreamStats : RTCReceivedRtpStreamStats {
unsigned long firCount;
unsigned long pliCount;
unsigned long sliCount;
+ DOMHighResTimeStamp estimatedPlayoutTimestamp;
+ double jitterBufferDelay;
+ unsigned long long jitterBufferEmittedCount;
+ unsigned long long totalSamplesReceived;
+ unsigned long long concealedSamples;
+ unsigned long long silentConcealedSamples;
+ unsigned long long concealmentEvents;
+ unsigned long long insertedSamplesForDeceleration;
+ unsigned long long removedSamplesForAcceleration;
+ double audioLevel;
+ double totalAudioEnergy;
+ double totalSamplesDuration;
+ unsigned long framesReceived;
+ unsigned long framesDropped;
+ unsigned long partialFramesLost;
+ unsigned long fullFramesLost;
};
dictionary RTCRemoteInboundRtpStreamStats : RTCReceivedRtpStreamStats {
@@ -110,9 +130,16 @@ dictionary RTCOutboundRtpStreamStats : RTCSentRtpStreamStats {
unsigned long long retransmittedBytesSent;
double targetBitrate;
unsigned long long totalEncodedBytesTarget;
+ unsigned long frameWidth;
+ unsigned long frameHeight;
+ double framesPerSecond;
+ unsigned long framesSent;
+ unsigned long hugeFramesSent;
unsigned long framesEncoded;
unsigned long keyFramesEncoded;
unsigned long long qpSum;
+ unsigned long long totalSamplesSent;
+ boolean voiceActivityFlag;
double totalEncodeTime;
double totalPacketSendDelay;
double averageRtcpInterval;
@@ -146,6 +173,8 @@ dictionary RTCAudioSourceStats : RTCMediaSourceStats {
double audioLevel;
double totalAudioEnergy;
double totalSamplesDuration;
+ double echoReturnLoss;
+ double echoReturnLossEnhancement;
};
dictionary RTCVideoSourceStats : RTCMediaSourceStats {
@@ -183,59 +212,29 @@ dictionary RTCMediaHandlerStats : RTCStats {
};
dictionary RTCVideoHandlerStats : RTCMediaHandlerStats {
- unsigned long frameWidth;
- unsigned long frameHeight;
- double framesPerSecond;
};
dictionary RTCVideoSenderStats : RTCVideoHandlerStats {
DOMString mediaSourceId;
- unsigned long framesCaptured;
- unsigned long framesSent;
- unsigned long hugeFramesSent;
};
dictionary RTCSenderVideoTrackAttachmentStats : RTCVideoSenderStats {
};
dictionary RTCVideoReceiverStats : RTCVideoHandlerStats {
- DOMHighResTimeStamp estimatedPlayoutTimestamp;
- double jitterBufferDelay;
- unsigned long long jitterBufferEmittedCount;
- unsigned long framesReceived;
- unsigned long framesDecoded;
- unsigned long framesDropped;
- unsigned long partialFramesLost;
- unsigned long fullFramesLost;
};
dictionary RTCAudioHandlerStats : RTCMediaHandlerStats {
- boolean voiceActivityFlag;
};
dictionary RTCAudioSenderStats : RTCAudioHandlerStats {
DOMString mediaSourceId;
- double echoReturnLoss;
- double echoReturnLossEnhancement;
- unsigned long long totalSamplesSent;
};
dictionary RTCSenderAudioTrackAttachmentStats : RTCAudioSenderStats {
};
dictionary RTCAudioReceiverStats : RTCAudioHandlerStats {
- DOMHighResTimeStamp estimatedPlayoutTimestamp;
- double jitterBufferDelay;
- unsigned long long jitterBufferEmittedCount;
- unsigned long long totalSamplesReceived;
- unsigned long long concealedSamples;
- unsigned long long silentConcealedSamples;
- unsigned long long concealmentEvents;
- unsigned long long insertedSamplesForDeceleration;
- unsigned long long removedSamplesForAcceleration;
- double audioLevel;
- double totalAudioEnergy;
- double totalSamplesDuration;
};
dictionary RTCDataChannelStats : RTCStats {
@@ -367,12 +366,51 @@ partial dictionary RTCAudioHandlerStats {
double audioLevel;
double totalAudioEnergy;
double totalSamplesDuration;
+ boolean voiceActivityFlag;
+};
+
+partial dictionary RTCAudioSenderStats {
+ unsigned long long totalSamplesSent;
+ double echoReturnLoss;
+ double echoReturnLossEnhancement;
+};
+
+partial dictionary RTCAudioReceiverStats {
+ DOMHighResTimeStamp estimatedPlayoutTimestamp;
+ double jitterBufferDelay;
+ unsigned long long jitterBufferEmittedCount;
+ unsigned long long totalSamplesReceived;
+ unsigned long long concealedSamples;
+ unsigned long long silentConcealedSamples;
+ unsigned long long concealmentEvents;
+ unsigned long long insertedSamplesForDeceleration;
+ unsigned long long removedSamplesForAcceleration;
+ double audioLevel;
+ double totalAudioEnergy;
+ double totalSamplesDuration;
+};
+
+partial dictionary RTCVideoHandlerStats {
+ unsigned long frameWidth;
+ unsigned long frameHeight;
+ double framesPerSecond;
};
partial dictionary RTCVideoSenderStats {
unsigned long keyFramesSent;
+ unsigned long framesCaptured;
+ unsigned long framesSent;
+ unsigned long hugeFramesSent;
};
partial dictionary RTCVideoReceiverStats {
unsigned long keyFramesReceived;
+ DOMHighResTimeStamp estimatedPlayoutTimestamp;
+ double jitterBufferDelay;
+ unsigned long long jitterBufferEmittedCount;
+ unsigned long framesReceived;
+ unsigned long framesDecoded;
+ unsigned long framesDropped;
+ unsigned long partialFramesLost;
+ unsigned long fullFramesLost;
};
diff --git a/tests/wpt/web-platform-tests/largest-contentful-paint/first-letter-background.html b/tests/wpt/web-platform-tests/largest-contentful-paint/first-letter-background.html
new file mode 100644
index 000000000000..19544c8edeed
--- /dev/null
+++ b/tests/wpt/web-platform-tests/largest-contentful-paint/first-letter-background.html
@@ -0,0 +1,48 @@
+
+
+
Largest Contentful Paint: observe element with background image in its first letter
+
+
+
+
+
+
+
A
+
diff --git a/tests/wpt/web-platform-tests/largest-contentful-paint/observe-after-untrusted-scroll.html b/tests/wpt/web-platform-tests/largest-contentful-paint/observe-after-untrusted-scroll.html
index abe753fc14a3..b551e7632b5c 100644
--- a/tests/wpt/web-platform-tests/largest-contentful-paint/observe-after-untrusted-scroll.html
+++ b/tests/wpt/web-platform-tests/largest-contentful-paint/observe-after-untrusted-scroll.html
@@ -19,7 +19,7 @@
'The rendering timestamp should occur after script starts running.');
assert_greater_than_equal(performance.now(), entry.renderTime,
'The rendering timestamp should occur before the entry is dispatched to the observer.');
- assert_equals(entry.startTime, 0);
+ assert_equals(entry.startTime, entry.renderTime, 'startTime should equal renderTime');
assert_equals(entry.duration, 0);
// blue.png is 133 x 106.
assert_equals(entry.size, 14098);
diff --git a/tests/wpt/web-platform-tests/largest-contentful-paint/toJSON.html b/tests/wpt/web-platform-tests/largest-contentful-paint/toJSON.html
new file mode 100644
index 000000000000..7defcce1b6f9
--- /dev/null
+++ b/tests/wpt/web-platform-tests/largest-contentful-paint/toJSON.html
@@ -0,0 +1,42 @@
+
+
+
Largest Contentful Paint: toJSON
+
+
+
+
Text!
+
+
diff --git a/tests/wpt/web-platform-tests/layout-instability/toJSON.html b/tests/wpt/web-platform-tests/layout-instability/toJSON.html
new file mode 100644
index 000000000000..3d39d623e133
--- /dev/null
+++ b/tests/wpt/web-platform-tests/layout-instability/toJSON.html
@@ -0,0 +1,42 @@
+
+
+
Layout Instability: toJSON
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/lint.whitelist b/tests/wpt/web-platform-tests/lint.whitelist
index c344c3a83444..669038166ab3 100644
--- a/tests/wpt/web-platform-tests/lint.whitelist
+++ b/tests/wpt/web-platform-tests/lint.whitelist
@@ -309,6 +309,8 @@ SET TIMEOUT: css/css-fonts/font-display/font-display-feature-policy-01.tentative
SET TIMEOUT: css/css-fonts/font-display/font-display-feature-policy-02.tentative.html
SET TIMEOUT: css/css-fonts/font-display/font-display-preload.html
SET TIMEOUT: html/browsers/windows/auxiliary-browsing-contexts/resources/close-opener.html
+SET TIMEOUT: html/cross-origin-embedder-policy/resources/navigate-none.sub.html
+SET TIMEOUT: html/cross-origin-embedder-policy/resources/navigate-require-corp.sub.html
SET TIMEOUT: html/dom/documents/dom-tree-accessors/Document.currentScript.html
SET TIMEOUT: html/webappapis/timers/*
SET TIMEOUT: resources/chromium/*
@@ -808,7 +810,7 @@ MISSING-LINK: css/filter-effects/*.any.js
# Tests that use WebKit/Blink testing APIs
LAYOUTTESTS APIS: css/css-regions/interactivity/*
-LAYOUTTESTS APIS: import-maps/resolving.tentative.html
+LAYOUTTESTS APIS: import-maps/resources/jest-test-helper.js
LAYOUTTESTS APIS: permissions/test-background-fetch-permission.html
LAYOUTTESTS APIS: resources/chromium/generic_sensor_mocks.js
LAYOUTTESTS APIS: resources/chromium/webxr-test.js
diff --git a/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-006-ref.html b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-006-ref.html
new file mode 100644
index 000000000000..39e6dabdfb19
--- /dev/null
+++ b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-006-ref.html
@@ -0,0 +1,74 @@
+
+
+
+
+
RTL mtable and mtable with frame
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-006.html b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-006.html
new file mode 100644
index 000000000000..904e7d3fed8c
--- /dev/null
+++ b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-006.html
@@ -0,0 +1,79 @@
+
+
+
+
+
RTL mtable and mtable with frame
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-007-ref.html b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-007-ref.html
new file mode 100644
index 000000000000..5c77395f2008
--- /dev/null
+++ b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-007-ref.html
@@ -0,0 +1,42 @@
+
+
+
+
+
mo and embellished mrow/munderover (lspace=1em rspace=2em)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-007.html b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-007.html
new file mode 100644
index 000000000000..7137e2640fa4
--- /dev/null
+++ b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-007.html
@@ -0,0 +1,50 @@
+
+
+
+
+
mo and embellished mrow/munderover (lspace=1em rspace=2em)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-008-ref.html b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-008-ref.html
new file mode 100644
index 000000000000..492fa9539ae8
--- /dev/null
+++ b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-008-ref.html
@@ -0,0 +1,27 @@
+
+
+
+
+
embellished mfrac (lspace=1em rspace=2em)
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-008.html b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-008.html
new file mode 100644
index 000000000000..5c98b0741007
--- /dev/null
+++ b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-008.html
@@ -0,0 +1,33 @@
+
+
+
+
+
embellished mfrac (lspace=1em rspace=2em)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-009-ref.html b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-009-ref.html
new file mode 100644
index 000000000000..7ed4796814a7
--- /dev/null
+++ b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-009-ref.html
@@ -0,0 +1,21 @@
+
+
+
+
+
RTL ms lquote="X" rquote="p"
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-009.html b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-009.html
new file mode 100644
index 000000000000..bf8caf16aed2
--- /dev/null
+++ b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-009.html
@@ -0,0 +1,27 @@
+
+
+
+
+
RTL ms lquote="X" rquote="p"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-010-ref.html b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-010-ref.html
new file mode 100644
index 000000000000..4f595ed49f69
--- /dev/null
+++ b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-010-ref.html
@@ -0,0 +1,44 @@
+
+
+
+
+
dir="rtl" VS direction: rtl on math/mrow/mstyle
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-010.html b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-010.html
new file mode 100644
index 000000000000..6dc095ac1fd4
--- /dev/null
+++ b/tests/wpt/web-platform-tests/mathml/presentation-markup/direction/direction-010.html
@@ -0,0 +1,51 @@
+
+
+
+
+
dir="rtl" VS direction: rtl on math/mrow/mstyle
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/mathml/relations/css-styling/mathvariant-case-sensitivity-ref.html b/tests/wpt/web-platform-tests/mathml/relations/css-styling/mathvariant-case-sensitivity-ref.html
new file mode 100644
index 000000000000..28d9acc1f4c2
--- /dev/null
+++ b/tests/wpt/web-platform-tests/mathml/relations/css-styling/mathvariant-case-sensitivity-ref.html
@@ -0,0 +1,163 @@
+
+
+
+
+
mathvariant case sensitivity
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/mathml/relations/css-styling/mathvariant-case-sensitivity.html b/tests/wpt/web-platform-tests/mathml/relations/css-styling/mathvariant-case-sensitivity.html
new file mode 100644
index 000000000000..0d3e706d961e
--- /dev/null
+++ b/tests/wpt/web-platform-tests/mathml/relations/css-styling/mathvariant-case-sensitivity.html
@@ -0,0 +1,168 @@
+
+
+
+
+
mathvariant case sensitivity
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/pointerevents/inheritance.html b/tests/wpt/web-platform-tests/pointerevents/inheritance.html
new file mode 100644
index 000000000000..0bf39bcb4ddc
--- /dev/null
+++ b/tests/wpt/web-platform-tests/pointerevents/inheritance.html
@@ -0,0 +1,21 @@
+
+
+
+
+
Inheritance of touch-action
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/pointerevents/parsing/touch-action-computed.html b/tests/wpt/web-platform-tests/pointerevents/parsing/touch-action-computed.html
new file mode 100644
index 000000000000..59255bec4550
--- /dev/null
+++ b/tests/wpt/web-platform-tests/pointerevents/parsing/touch-action-computed.html
@@ -0,0 +1,24 @@
+
+
+
+
+
Pointer Events: getComputedStyle().touchAction
+
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/pointerevents/parsing/touch-action-invalid.html b/tests/wpt/web-platform-tests/pointerevents/parsing/touch-action-invalid.html
new file mode 100644
index 000000000000..979dc252d3fe
--- /dev/null
+++ b/tests/wpt/web-platform-tests/pointerevents/parsing/touch-action-invalid.html
@@ -0,0 +1,18 @@
+
+
+
+
Pointer Events: parsing touch-action with invalid values
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/pointerevents/parsing/touch-action-valid.html b/tests/wpt/web-platform-tests/pointerevents/parsing/touch-action-valid.html
new file mode 100644
index 000000000000..9bb5d023edcf
--- /dev/null
+++ b/tests/wpt/web-platform-tests/pointerevents/parsing/touch-action-valid.html
@@ -0,0 +1,23 @@
+
+
+
+
Pointer Events: parsing touch-action with valid values
+
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/quirks/dd-dl-firefox-001-ref.html b/tests/wpt/web-platform-tests/quirks/dd-dl-firefox-001-ref.html
new file mode 100644
index 000000000000..46a4d7d156f6
--- /dev/null
+++ b/tests/wpt/web-platform-tests/quirks/dd-dl-firefox-001-ref.html
@@ -0,0 +1,8 @@
+
+
CSS Test Reference
+
Prevent quirky dl margin from messing up with us
+
+ - One
+ Two
+
+
ThreeFour
diff --git a/tests/wpt/web-platform-tests/quirks/dd-dl-firefox-001.html b/tests/wpt/web-platform-tests/quirks/dd-dl-firefox-001.html
new file mode 100644
index 000000000000..96fc76f08f45
--- /dev/null
+++ b/tests/wpt/web-platform-tests/quirks/dd-dl-firefox-001.html
@@ -0,0 +1,18 @@
+
+
dd and dl don't have weird text-indent quirks
+
+
+
+
+
+
Prevent quirky dl margin from messing up with us
+
+ - One
+ Two
+
+
ThreeFour
diff --git a/tests/wpt/web-platform-tests/referrer-policy/generic/referrer-policy-test-case.sub.js b/tests/wpt/web-platform-tests/referrer-policy/generic/referrer-policy-test-case.sub.js
index 0c0f38195309..d1cb469b3dfb 100644
--- a/tests/wpt/web-platform-tests/referrer-policy/generic/referrer-policy-test-case.sub.js
+++ b/tests/wpt/web-platform-tests/referrer-policy/generic/referrer-policy-test-case.sub.js
@@ -129,6 +129,12 @@ function ReferrerPolicyTestCase(scenario, testDescription, sanityChecker) {
const expectedReferrer =
referrerUrlResolver[scenario.referrer_url](currentURL);
+ function asyncResolve(result) {
+ return new Promise((resolve, reject) => {
+ step_timeout(() => resolve(result), 0);
+ });
+ }
+
// Request in the top-level document.
promise_test(_ => {
return invokeRequest(subresource, [])
@@ -146,7 +152,8 @@ function ReferrerPolicyTestCase(scenario, testDescription, sanityChecker) {
subresource.url += "&-1";
return invokeRequest(subresource, [])
.then(result => checkResult(location.href, result))
- .finally(_ => history.back());
+ .then(_ => history.back())
+ .then(asyncResolve);
}, "`Referer` header with length < 4k is not stripped to an origin.");
promise_test(_ => {
@@ -157,7 +164,8 @@ function ReferrerPolicyTestCase(scenario, testDescription, sanityChecker) {
subresource.url += "&0";
return invokeRequest(subresource, [])
.then(result => checkResult(expectedReferrer, result))
- .finally(_ => history.back());
+ .then(_ => history.back())
+ .then(asyncResolve);
}, "`Referer` header with length == 4k is not stripped to an origin.");
promise_test(_ => {
@@ -168,7 +176,8 @@ function ReferrerPolicyTestCase(scenario, testDescription, sanityChecker) {
subresource.url += "&+1";
return invokeRequest(subresource, [])
.then(result => checkResult(originString, result))
- .finally(_ => history.back());
+ .then(_ => history.back())
+ .then(asyncResolve);
}, "`Referer` header with length > 4k is stripped to an origin.");
}
diff --git a/tests/wpt/web-platform-tests/resources/chromium/nfc-mock.js b/tests/wpt/web-platform-tests/resources/chromium/nfc-mock.js
new file mode 100644
index 000000000000..83bd6b8a0dea
--- /dev/null
+++ b/tests/wpt/web-platform-tests/resources/chromium/nfc-mock.js
@@ -0,0 +1,415 @@
+'use strict';
+
+function toMojoNDEFRecordType(type) {
+ switch (type) {
+ case 'text':
+ return device.mojom.NDEFRecordType.TEXT;
+ case 'url':
+ return device.mojom.NDEFRecordType.URL;
+ case 'json':
+ return device.mojom.NDEFRecordType.JSON;
+ case 'opaque':
+ return device.mojom.NDEFRecordType.OPAQUE_RECORD;
+ }
+
+ return device.mojom.NDEFRecordType.EMPTY;
+}
+
+function toMojoNFCPushTarget(target) {
+ switch (target) {
+ case 'peer':
+ return device.mojom.NFCPushTarget.PEER;
+ case 'tag':
+ return device.mojom.NFCPushTarget.TAG;
+ }
+
+ return device.mojom.NFCPushTarget.ANY;
+}
+
+function toMojoNDEFCompatibility(compatibility) {
+ if (compatibility === 'nfc-forum')
+ return device.mojom.NDEFCompatibility.NFC_FORUM;
+ if (compatibility === 'vendor')
+ return device.mojom.NDEFCompatibility.VENDOR;
+ return device.mojom.NDEFCompatibility.ANY;
+}
+
+// Converts between NDEFMessageInit https://w3c.github.io/web-nfc/#dom-ndefmessage
+// and mojom.NDEFMessage structure, so that watch function can be tested.
+function toMojoNDEFMessage(message) {
+ let ndefMessage = new device.mojom.NDEFMessage();
+ ndefMessage.url = message.url;
+ ndefMessage.data = [];
+ for (let record of message.records) {
+ ndefMessage.data.push(toMojoNDEFRecord(record));
+ }
+ return ndefMessage;
+}
+
+function toMojoNDEFRecord(record) {
+ let nfcRecord = new device.mojom.NDEFRecord();
+ nfcRecord.recordType = toMojoNDEFRecordType(record.recordType);
+ nfcRecord.mediaType = record.mediaType;
+ nfcRecord.data = toByteArray(record.data);
+ return nfcRecord;
+}
+
+function toByteArray(data) {
+ // Convert JS objects to byte array
+ let byteArray = new Uint8Array(0);
+ let tmpData = data;
+
+ if (tmpData instanceof ArrayBuffer)
+ byteArray = new Uint8Array(tmpData);
+ else if (typeof tmpData === 'object' || typeof tmpData === 'number')
+ tmpData = JSON.stringify(tmpData);
+
+ if (typeof tmpData === 'string')
+ byteArray = new TextEncoder('utf-8').encode(tmpData);
+
+ return byteArray;
+}
+
+// Compares NDEFRecords that were provided / received by the mock service.
+// TODO: Use different getters to get received record data,
+// see spec changes at https://github.com/w3c/web-nfc/pull/243
+function compareNDEFRecords(providedRecord, receivedRecord) {
+ assert_equals(toMojoNDEFRecordType(providedRecord.recordType),
+ receivedRecord.recordType);
+
+ // Compare media types without charset.
+ // Charset should be compared when watch method is implemented, in order
+ // to check that written and read strings are equal.
+ assert_equals(providedRecord.mediaType,
+ receivedRecord.mediaType.substring(0, providedRecord.mediaType.length));
+
+ assert_false(toMojoNDEFRecordType(providedRecord.recordType) ==
+ device.mojom.NDEFRecordType.EMPTY);
+
+ assert_array_equals(toByteArray(providedRecord.data),
+ new Uint8Array(receivedRecord.data));
+}
+
+// Compares NFCPushOptions structures that were provided to API and
+// received by the mock mojo service.
+function assertNFCPushOptionsEqual(provided, received) {
+ if (provided.ignoreRead !== undefined)
+ assert_equals(provided.ignoreRead, !!received.ignoreRead);
+ else
+ assert_equals(!!received.ignore_read, true);
+
+ if (provided.timeout !== undefined)
+ assert_equals(provided.timeout, received.timeout);
+ else
+ assert_equals(received.timeout, Infinity);
+
+ if (provided.target !== undefined)
+ assert_equals(toMojoNFCPushTarget(provided.target), received.target);
+ else
+ assert_equals(received.target, device.mojom.NFCPushTarget.ANY);
+
+ if (provided.compatibility !== undefined) {
+ assert_equals(toMojoNDEFCompatibility(provided.compatibility),
+ received.compatibility);
+ } else {
+ assert_equals(received.compatibility,
+ device.mojom.NDEFCompatibility.NFC_FORUM);
+ }
+}
+
+// Compares NFCReaderOptions structures that were provided to API and
+// received by the mock mojo service.
+function assertNFCReaderOptionsEqual(provided, received) {
+ if (provided.url !== undefined)
+ assert_equals(provided.url, received.url);
+ else
+ assert_equals(received.url, '');
+
+ if (provided.mediaType !== undefined)
+ assert_equals(provided.mediaType, received.mediaType);
+ else
+ assert_equals(received.mediaType, '');
+
+ if (provided.compatibility !== undefined) {
+ assert_equals(toMojoNDEFCompatibility(provided.compatibility),
+ received.compatibility);
+ } else {
+ assert_equals(received.compatibility,
+ device.mojom.NDEFCompatibility.NFC_FORUM);
+ }
+
+ if (provided.recordType !== undefined) {
+ assert_equals(!+received.record_filter, true);
+ assert_equals(toMojoNDEFRecordType(provided.recordType),
+ received.recordFilter.recordType);
+ }
+}
+
+// Checks whether NFCReaderOptions are matched with given message
+// and mock nfc's compatibility
+function matchesWatchOptions(message, compatibility, options) {
+ // Filter by NDEFCompatibility
+ if (options.compatibility !== toMojoNDEFCompatibility("any")
+ && options.compatibility !== compatibility) {
+ return false;
+ }
+
+ // Filter by Web NFC id
+ if (!matchesWebNfcId(message.url, options.url)) return false;
+
+ // Matches any record / media type.
+ if ((options.mediaType == null || options.mediaType === "")
+ && options.recordFilter == null) {
+ return true;
+ }
+
+ // Filter by mediaType and recordType
+ for (let record of message.records) {
+ if (options.mediaType != null && options.mediaType !== ""
+ && options.mediaType !== record.mediaType) {
+ return false;
+ }
+ if (options.recordFilter != null
+ && options.recordFilter.recordType
+ !== toMojoNDEFRecordType(record.recordType)) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Web NFC id match algorithm.
+// https://w3c.github.io/web-nfc/#url-pattern-match-algorithm
+function matchesWebNfcId(id, pattern) {
+ if (id != null && id !== "" && pattern != null && pattern !== "") {
+ const id_url = new URL(id);
+ const pattern_url = new URL(pattern);
+
+ if (id_url.protocol !== pattern_url.protocol) return false;
+ if (!id_url.host.endsWith("." + pattern_url.host)
+ && id_url.host !== pattern_url.host) {
+ return false;
+ }
+ if (pattern_url.pathname === "/*") return true;
+ if (id_url.pathname.startsWith(pattern_url.pathname)) return true;
+
+ return false;
+ }
+
+ return true;
+}
+
+function createNFCError(type) {
+ return { error: type ?
+ new device.mojom.NFCError({ errorType: type }) : null };
+}
+
+var WebNFCTest = (() => {
+ class MockNFC {
+ constructor() {
+ this.bindingSet_ = new mojo.BindingSet(device.mojom.NFC);
+
+ this.interceptor_ = new MojoInterfaceInterceptor(
+ device.mojom.NFC.name);
+ this.interceptor_.oninterfacerequest =
+ e => this.bindingSet_.addBinding(this, e.handle);
+ this.interceptor_.start();
+
+ this.hw_status_ = NFCHWStatus.ENABLED;
+ this.pushed_message_ = null;
+ this.push_options_ = null;
+ this.pending_promise_func_ = null;
+ this.push_completed_ = true;
+ this.push_should_timeout_ = false;
+ this.client_ = null;
+ this.watchers_ = [];
+ this.reading_messages_ = [];
+ }
+
+ // NFC delegate functions
+ async push(message, options) {
+ let error = this.getHWError();
+ if (error)
+ return error;
+
+ this.pushed_message_ = message;
+ this.push_options_ = options;
+
+ return new Promise(resolve => {
+ this.pending_promise_func_ = resolve;
+ if (options.timeout && options.timeout !== Infinity &&
+ !this.push_completed_) {
+ // Resolve with TimeoutError, else pending push operation.
+ if (this.push_should_timeout_) {
+ resolve(
+ createNFCError(device.mojom.NFCErrorType.TIMER_EXPIRED));
+ }
+ } else {
+ resolve(createNFCError(null));
+ }
+ });
+ }
+
+ async cancelPush(target) {
+ if (this.push_options_ && ((target === device.mojom.NFCPushTarget.ANY) ||
+ (this.push_options_.target === target))) {
+ this.cancelPendingPushOperation();
+ }
+
+ return createNFCError(null);
+ }
+
+ setClient(client) {
+ this.client_ = client;
+ }
+
+ async watch(options, id) {
+ assert_true(id > 0);
+ let error = this.getHWError();
+ if (error) {
+ return error;
+ }
+
+ this.watchers_.push({id: id, options: options});
+ // Triggers onWatch if the new watcher matches existing messages
+ if (this.reading_messages_.length !== 0) {
+ for(let message of this.reading_messages_) {
+ if (matchesWatchOptions(message.message,
+ message.compatibility, options)) {
+ this.client_.onWatch([id], fake_tag_serial_number,
+ toMojoNDEFMessage(message.message));
+ }
+ }
+ }
+
+ return createNFCError(null);
+ }
+
+ async cancelWatch(id) {
+ let index = this.watchers_.findIndex(value => value.id === id);
+ if (index === -1) {
+ return createNFCError(device.mojom.NFCErrorType.NOT_FOUND);
+ }
+
+ this.watchers_.splice(index, 1);
+ return createNFCError(null);
+ }
+
+ async cancelAllWatches() {
+ if (this.watchers_.length === 0) {
+ return createNFCError(device.mojom.NFCErrorType.NOT_FOUND);
+ }
+
+ this.watchers_.splice(0, this.watchers_.length);
+ return createNFCError(null);
+ }
+
+ getHWError() {
+ if (this.hw_status_ === NFCHWStatus.DISABLED)
+ return createNFCError(device.mojom.NFCErrorType.NOT_READABLE);
+ if (this.hw_status_ === NFCHWStatus.NOT_SUPPORTED)
+ return createNFCError(device.mojom.NFCErrorType.NOT_SUPPORTED);
+ return null;
+ }
+
+ setHWStatus(status) {
+ this.hw_status_ = status;
+ }
+
+ pushedMessage() {
+ return this.pushed_message_;
+ }
+
+ pushOptions() {
+ return this.push_options_;
+ }
+
+ watchOptions() {
+ assert_not_equals(this.watchers_.length, 0);
+ return this.watchers_[this.watchers_.length - 1].options;
+ }
+
+ setPendingPushCompleted(result) {
+ this.push_completed_ = result;
+ }
+
+ reset() {
+ this.hw_status_ = NFCHWStatus.ENABLED;
+ this.push_completed_ = true;
+ this.watchers_ = [];
+ this.reading_messages_ = [];
+ this.cancelPendingPushOperation();
+ this.bindingSet_.closeAllBindings();
+ this.interceptor_.stop();
+ }
+
+ cancelPendingPushOperation() {
+ if (this.pending_promise_func_) {
+ this.pending_promise_func_(
+ createNFCError(device.mojom.NFCErrorType.OPERATION_CANCELLED));
+ }
+
+ this.pushed_message_ = null;
+ this.push_options_ = null;
+ this.pending_promise_func_ = null;
+ this.push_should_timeout_ = false;
+ }
+
+ // Sets message that is used to deliver NFC reading updates
+ // with a specific NDEFCompatibility.
+ setReadingMessage(message, compatibility = 'nfc-forum') {
+ this.reading_messages_.push({message: message,
+ compatibility: toMojoNDEFCompatibility(compatibility)});
+ // Triggers onWatch if the new message matches existing watchers
+ if (this.watchers_.length !== 0) {
+ for (let watcher of this.watchers_) {
+ if (matchesWatchOptions(message,
+ message.compatibility, watcher.options)) {
+ this.client_.onWatch([watcher.id], fake_tag_serial_number,
+ toMojoNDEFMessage(message.message));
+ }
+ }
+ }
+ }
+
+ setPushShouldTimeout(result) {
+ this.push_should_timeout_ = result;
+ }
+ }
+
+ let testInternal = {
+ initialized: false,
+ mockNFC: null
+ }
+
+ class NFCTestChromium {
+ constructor() {
+ Object.freeze(this); // Make it immutable.
+ }
+
+ initialize() {
+ if (testInternal.initialized)
+ throw new Error('Call reset() before initialize().');
+
+ testInternal.mockNFC = new MockNFC;
+ testInternal.initialized = true;
+ }
+ // Resets state of nfc mocks between test runs.
+ async reset() {
+ if (!testInternal.initialized)
+ throw new Error('Call initialize() before reset().');
+ testInternal.mockNFC.reset();
+ testInternal.mockNFC = null;
+ testInternal.initialized = false;
+
+ await new Promise(resolve => setTimeout(resolve, 0));
+ }
+
+ getMockNFC() {
+ return testInternal.mockNFC;
+ }
+ }
+
+ return NFCTestChromium;
+})();
diff --git a/tests/wpt/web-platform-tests/resources/webidl2/lib/README.md b/tests/wpt/web-platform-tests/resources/webidl2/lib/README.md
index 3f9d75f57ba8..1bd583269d29 100644
--- a/tests/wpt/web-platform-tests/resources/webidl2/lib/README.md
+++ b/tests/wpt/web-platform-tests/resources/webidl2/lib/README.md
@@ -1,4 +1,4 @@
This directory contains a built version of the [webidl2.js library](https://github.com/w3c/webidl2.js).
-It is built by running `npx webpack --mode none` at the root of that repository.
+It is built by running `npm run build-debug` at the root of that repository.
The `webidl2.js.headers` file is a local addition to ensure the script is interpreted as UTF-8.
diff --git a/tests/wpt/web-platform-tests/resources/webidl2/lib/webidl2.js b/tests/wpt/web-platform-tests/resources/webidl2/lib/webidl2.js
index 9cb975a8bb30..900694b095df 100644
--- a/tests/wpt/web-platform-tests/resources/webidl2/lib/webidl2.js
+++ b/tests/wpt/web-platform-tests/resources/webidl2/lib/webidl2.js
@@ -103,10 +103,10 @@ __webpack_require__.r(__webpack_exports__);
/* harmony import */ var _lib_webidl2_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "parse", function() { return _lib_webidl2_js__WEBPACK_IMPORTED_MODULE_0__["parse"]; });
-/* harmony import */ var _lib_writer_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(14);
+/* harmony import */ var _lib_writer_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(29);
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "write", function() { return _lib_writer_js__WEBPACK_IMPORTED_MODULE_1__["write"]; });
-/* harmony import */ var _lib_validator_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(15);
+/* harmony import */ var _lib_validator_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(30);
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "validate", function() { return _lib_validator_js__WEBPACK_IMPORTED_MODULE_2__["validate"]; });
@@ -121,14 +121,20 @@ __webpack_require__.r(__webpack_exports__);
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parse", function() { return parse; });
-/* harmony import */ var _productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
-/* harmony import */ var _tokeniser_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
-/* harmony import */ var _productions_base_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(4);
-/* harmony import */ var _productions_default_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(8);
-/* harmony import */ var _productions_enum_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(12);
-/* harmony import */ var _productions_includes_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(13);
-/* harmony import */ var _productions_type_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(3);
-/* harmony import */ var _productions_extended_attributes_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(9);
+/* harmony import */ var _tokeniser_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
+/* harmony import */ var _productions_enum_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4);
+/* harmony import */ var _productions_includes_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(16);
+/* harmony import */ var _productions_extended_attributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(11);
+/* harmony import */ var _productions_typedef_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(17);
+/* harmony import */ var _productions_callback_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(18);
+/* harmony import */ var _productions_interface_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(19);
+/* harmony import */ var _productions_mixin_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(24);
+/* harmony import */ var _productions_dictionary_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(25);
+/* harmony import */ var _productions_namespace_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(27);
+/* harmony import */ var _productions_callback_interface_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(28);
+
+
+
@@ -148,469 +154,57 @@ __webpack_require__.r(__webpack_exports__);
function parseByTokens(tokeniser, options) {
const source = tokeniser.source;
- const ID = "identifier";
-
function error(str) {
tokeniser.error(str);
}
- function probe(type) {
- return tokeniser.probe(type);
- }
-
function consume(...candidates) {
return tokeniser.consume(...candidates);
}
- function unconsume(position) {
- return tokeniser.unconsume(position);
- }
-
- class Constant extends _productions_base_js__WEBPACK_IMPORTED_MODULE_2__["Base"] {
- static parse() {
- const tokens = {};
- tokens.base = consume("const");
- if (!tokens.base) {
- return;
- }
- let idlType = Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["primitive_type"])(tokeniser);
- if (!idlType) {
- const base = consume(ID) || error("No type for const");
- idlType = new _productions_type_js__WEBPACK_IMPORTED_MODULE_6__["Type"]({ source, tokens: { base } });
- }
- if (probe("?")) {
- error("Unexpected nullable constant type");
- }
- idlType.type = "const-type";
- tokens.name = consume(ID) || error("No name for const");
- tokens.assign = consume("=") || error("No value assignment for const");
- tokens.value = Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["const_value"])(tokeniser) || error("No value for const");
- tokens.termination = consume(";") || error("Unterminated const");
- const ret = new Constant({ source, tokens });
- ret.idlType = idlType;
- return ret;
- }
-
- get type() {
- return "const";
- }
- get name() {
- return Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["unescape"])(this.tokens.name.value);
- }
- get value() {
- return Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["const_data"])(this.tokens.value);
- }
- }
-
- class CallbackFunction extends _productions_base_js__WEBPACK_IMPORTED_MODULE_2__["Base"] {
- static parse(base) {
- const tokens = { base };
- const ret = new CallbackFunction({ source, tokens });
- tokens.name = consume(ID) || error("No name for callback");
- tokeniser.current = ret;
- tokens.assign = consume("=") || error("No assignment in callback");
- ret.idlType = Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["return_type"])(tokeniser) || error("Missing return type");
- tokens.open = consume("(") || error("No arguments in callback");
- ret.arguments = Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["argument_list"])(tokeniser);
- tokens.close = consume(")") || error("Unterminated callback");
- tokens.termination = consume(";") || error("Unterminated callback");
- return ret;
- }
-
- get type() {
- return "callback";
- }
- get name() {
- return Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["unescape"])(this.tokens.name.value);
- }
- }
-
function callback() {
const callback = consume("callback");
if (!callback) return;
- const tok = consume("interface");
- if (tok) {
- return Interface.parse(tok, { callback });
- }
- return CallbackFunction.parse(callback);
- }
-
- class Attribute extends _productions_base_js__WEBPACK_IMPORTED_MODULE_2__["Base"] {
- static parse({ special, noInherit = false, readonly = false } = {}) {
- const start_position = tokeniser.position;
- const tokens = { special };
- const ret = new Attribute({ source, tokens });
- if (!special && !noInherit) {
- tokens.special = consume("inherit");
- }
- if (ret.special === "inherit" && probe("readonly")) {
- error("Inherited attributes cannot be read-only");
- }
- tokens.readonly = consume("readonly");
- if (readonly && !tokens.readonly && probe("attribute")) {
- error("Attributes must be readonly in this context");
- }
- tokens.base = consume("attribute");
- if (!tokens.base) {
- unconsume(start_position);
- return;
- }
- ret.idlType = Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["type_with_extended_attributes"])(tokeniser, "attribute-type") || error("No type in attribute");
- switch (ret.idlType.generic) {
- case "sequence":
- case "record": error(`Attributes cannot accept ${ret.idlType.generic} types`);
- }
- tokens.name = consume(ID, "required") || error("No name in attribute");
- tokens.termination = consume(";") || error("Unterminated attribute");
- return ret;
- }
-
- get type() {
- return "attribute";
- }
- get special() {
- if (!this.tokens.special) {
- return "";
- }
- return this.tokens.special.value;
- }
- get readonly() {
- return !!this.tokens.readonly;
- }
- get name() {
- return Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["unescape"])(this.tokens.name.value);
- }
- }
-
- class Operation extends _productions_base_js__WEBPACK_IMPORTED_MODULE_2__["Base"] {
- static parse({ special, regular } = {}) {
- const tokens = { special };
- const ret = new Operation({ source, tokens });
- if (special && special.value === "stringifier") {
- tokens.termination = consume(";");
- if (tokens.termination) {
- ret.arguments = [];
- return ret;
- }
- }
- if (!special && !regular) {
- tokens.special = consume("getter", "setter", "deleter");
- }
- ret.idlType = Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["return_type"])(tokeniser) || error("Missing return type");
- tokens.name = consume(ID);
- tokens.open = consume("(") || error("Invalid operation");
- ret.arguments = Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["argument_list"])(tokeniser);
- tokens.close = consume(")") || error("Unterminated operation");
- tokens.termination = consume(";") || error("Unterminated attribute");
- return ret;
- }
-
- get type() {
- return "operation";
- }
- get name() {
- const { name } = this.tokens;
- if (!name) {
- return "";
- }
- return Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["unescape"])(name.value);
- }
- get special() {
- if (!this.tokens.special) {
- return "";
- }
- return this.tokens.special.value;
- }
- }
-
- function static_member() {
- const special = consume("static");
- if (!special) return;
- const member = Attribute.parse({ special }) ||
- Operation.parse({ special }) ||
- error("No body in static member");
- return member;
- }
-
- function stringifier() {
- const special = consume("stringifier");
- if (!special) return;
- const member = Attribute.parse({ special }) ||
- Operation.parse({ special }) ||
- error("Unterminated stringifier");
- return member;
- }
-
- class IterableLike extends _productions_base_js__WEBPACK_IMPORTED_MODULE_2__["Base"] {
- static parse() {
- const start_position = tokeniser.position;
- const tokens = {};
- const ret = new IterableLike({ source, tokens });
- tokens.readonly = consume("readonly");
- tokens.base = tokens.readonly ?
- consume("maplike", "setlike") :
- consume("iterable", "maplike", "setlike");
- if (!tokens.base) {
- unconsume(start_position);
- return;
- }
-
- const { type } = ret;
- const secondTypeRequired = type === "maplike";
- const secondTypeAllowed = secondTypeRequired || type === "iterable";
-
- tokens.open = consume("<") || error(`Error parsing ${type} declaration`);
- const first = Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["type_with_extended_attributes"])(tokeniser) || error(`Error parsing ${type} declaration`);
- ret.idlType = [first];
- if (secondTypeAllowed) {
- first.tokens.separator = consume(",");
- if (first.tokens.separator) {
- ret.idlType.push(Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["type_with_extended_attributes"])(tokeniser));
- }
- else if (secondTypeRequired)
- error(`Missing second type argument in ${type} declaration`);
- }
- tokens.close = consume(">") || error(`Unterminated ${type} declaration`);
- tokens.termination = consume(";") || error(`Missing semicolon after ${type} declaration`);
-
- return ret;
- }
-
- get type() {
- return this.tokens.base.value;
- }
- get readonly() {
- return !!this.tokens.readonly;
- }
- }
-
- function inheritance() {
- const colon = consume(":");
- if (!colon) {
- return {};
- }
- const inheritance = consume(ID) || error("No type in inheritance");
- return { colon, inheritance };
- }
-
- class Container extends _productions_base_js__WEBPACK_IMPORTED_MODULE_2__["Base"] {
- static parse(instance, { type, inheritable, allowedMembers }) {
- const { tokens } = instance;
- tokens.name = consume(ID) || error("No name for interface");
- tokeniser.current = instance;
- if (inheritable) {
- Object.assign(tokens, inheritance());
- }
- tokens.open = consume("{") || error(`Bodyless ${type}`);
- instance.members = [];
- while (true) {
- tokens.close = consume("}");
- if (tokens.close) {
- tokens.termination = consume(";") || error(`Missing semicolon after ${type}`);
- return instance;
- }
- const ea = _productions_extended_attributes_js__WEBPACK_IMPORTED_MODULE_7__["ExtendedAttributes"].parse(tokeniser);
- let mem;
- for (const [parser, ...args] of allowedMembers) {
- mem = parser(...args);
- if (mem) {
- break;
- }
- }
- if (!mem) {
- error("Unknown member");
- }
- mem.extAttrs = ea;
- instance.members.push(mem);
- }
- }
-
- get partial() {
- return !!this.tokens.partial;
- }
- get name() {
- return Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["unescape"])(this.tokens.name.value);
- }
- get inheritance() {
- if (!this.tokens.inheritance) {
- return null;
- }
- return Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["unescape"])(this.tokens.inheritance.value);
- }
- }
-
- class Interface extends Container {
- static parse(base, { callback = null, partial = null } = {}) {
- const tokens = { callback, partial, base };
- return Container.parse(new Interface({ source, tokens }), {
- type: "interface",
- inheritable: !partial,
- allowedMembers: [
- [Constant.parse],
- [static_member],
- [stringifier],
- [IterableLike.parse],
- [Attribute.parse],
- [Operation.parse]
- ]
- });
- }
-
- get type() {
- if (this.tokens.callback) {
- return "callback interface";
- }
- return "interface";
- }
- }
-
- class Mixin extends Container {
- static parse(base, { partial } = {}) {
- const tokens = { partial, base };
- tokens.mixin = consume("mixin");
- if (!tokens.mixin) {
- return;
- }
- return Container.parse(new Mixin({ source, tokens }), {
- type: "interface mixin",
- allowedMembers: [
- [Constant.parse],
- [stringifier],
- [Attribute.parse, { noInherit: true }],
- [Operation.parse, { regular: true }]
- ]
- });
- }
-
- get type() {
- return "interface mixin";
+ if (tokeniser.probe("interface")) {
+ return _productions_callback_interface_js__WEBPACK_IMPORTED_MODULE_10__["CallbackInterface"].parse(tokeniser, callback);
}
+ return _productions_callback_js__WEBPACK_IMPORTED_MODULE_5__["CallbackFunction"].parse(tokeniser, callback);
}
function interface_(opts) {
const base = consume("interface");
if (!base) return;
- const ret = Mixin.parse(base, opts) ||
- Interface.parse(base, opts) ||
+ const ret = _productions_mixin_js__WEBPACK_IMPORTED_MODULE_7__["Mixin"].parse(tokeniser, base, opts) ||
+ _productions_interface_js__WEBPACK_IMPORTED_MODULE_6__["Interface"].parse(tokeniser, base, opts) ||
error("Interface has no proper body");
return ret;
}
- class Namespace extends Container {
- static parse({ partial } = {}) {
- const tokens = { partial };
- tokens.base = consume("namespace");
- if (!tokens.base) {
- return;
- }
- return Container.parse(new Namespace({ source, tokens }), {
- type: "namespace",
- allowedMembers: [
- [Attribute.parse, { noInherit: true, readonly: true }],
- [Operation.parse, { regular: true }]
- ]
- });
- }
-
- get type() {
- return "namespace";
- }
- }
-
function partial() {
const partial = consume("partial");
if (!partial) return;
- return Dictionary.parse({ partial }) ||
+ return _productions_dictionary_js__WEBPACK_IMPORTED_MODULE_8__["Dictionary"].parse(tokeniser, { partial }) ||
interface_({ partial }) ||
- Namespace.parse({ partial }) ||
+ _productions_namespace_js__WEBPACK_IMPORTED_MODULE_9__["Namespace"].parse(tokeniser, { partial }) ||
error("Partial doesn't apply to anything");
}
- class Dictionary extends Container {
- static parse({ partial } = {}) {
- const tokens = { partial };
- tokens.base = consume("dictionary");
- if (!tokens.base) {
- return;
- }
- return Container.parse(new Dictionary({ source, tokens }), {
- type: "dictionary",
- inheritable: !partial,
- allowedMembers: [
- [Field.parse],
- ]
- });
- }
-
- get type() {
- return "dictionary";
- }
- }
-
- class Field extends _productions_base_js__WEBPACK_IMPORTED_MODULE_2__["Base"] {
- static parse() {
- const tokens = {};
- const ret = new Field({ source, tokens });
- ret.extAttrs = _productions_extended_attributes_js__WEBPACK_IMPORTED_MODULE_7__["ExtendedAttributes"].parse(tokeniser);
- tokens.required = consume("required");
- ret.idlType = Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["type_with_extended_attributes"])(tokeniser, "dictionary-type") || error("No type for dictionary member");
- tokens.name = consume(ID) || error("No name for dictionary member");
- ret.default = _productions_default_js__WEBPACK_IMPORTED_MODULE_3__["Default"].parse(tokeniser);
- if (tokens.required && ret.default) error("Required member must not have a default");
- tokens.termination = consume(";") || error("Unterminated dictionary member");
- return ret;
- }
-
- get type() {
- return "field";
- }
- get name() {
- return Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["unescape"])(this.tokens.name.value);
- }
- get required() {
- return !!this.tokens.required;
- }
- }
-
- class Typedef extends _productions_base_js__WEBPACK_IMPORTED_MODULE_2__["Base"] {
- static parse() {
- const tokens = {};
- const ret = new Typedef({ source, tokens });
- tokens.base = consume("typedef");
- if (!tokens.base) {
- return;
- }
- ret.idlType = Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["type_with_extended_attributes"])(tokeniser, "typedef-type") || error("No type in typedef");
- tokens.name = consume(ID) || error("No name in typedef");
- tokeniser.current = ret;
- tokens.termination = consume(";") || error("Unterminated typedef");
- return ret;
- }
-
- get type() {
- return "typedef";
- }
- get name() {
- return Object(_productions_helpers_js__WEBPACK_IMPORTED_MODULE_0__["unescape"])(this.tokens.name.value);
- }
- }
-
function definition() {
return callback() ||
interface_() ||
partial() ||
- Dictionary.parse() ||
- _productions_enum_js__WEBPACK_IMPORTED_MODULE_4__["Enum"].parse(tokeniser) ||
- Typedef.parse() ||
- _productions_includes_js__WEBPACK_IMPORTED_MODULE_5__["Includes"].parse(tokeniser) ||
- Namespace.parse();
+ _productions_dictionary_js__WEBPACK_IMPORTED_MODULE_8__["Dictionary"].parse(tokeniser) ||
+ _productions_enum_js__WEBPACK_IMPORTED_MODULE_1__["Enum"].parse(tokeniser) ||
+ _productions_typedef_js__WEBPACK_IMPORTED_MODULE_4__["Typedef"].parse(tokeniser) ||
+ _productions_includes_js__WEBPACK_IMPORTED_MODULE_2__["Includes"].parse(tokeniser) ||
+ _productions_namespace_js__WEBPACK_IMPORTED_MODULE_9__["Namespace"].parse(tokeniser);
}
function definitions() {
if (!source.length) return [];
const defs = [];
while (true) {
- const ea = _productions_extended_attributes_js__WEBPACK_IMPORTED_MODULE_7__["ExtendedAttributes"].parse(tokeniser);
+ const ea = _productions_extended_attributes_js__WEBPACK_IMPORTED_MODULE_3__["ExtendedAttributes"].parse(tokeniser);
const def = definition();
if (!def) {
if (ea.length) error("Stray extended attributes");
@@ -631,7 +225,10 @@ function parseByTokens(tokeniser, options) {
}
function parse(str, options = {}) {
- const tokeniser = new _tokeniser_js__WEBPACK_IMPORTED_MODULE_1__["Tokeniser"](str);
+ const tokeniser = new _tokeniser_js__WEBPACK_IMPORTED_MODULE_0__["Tokeniser"](str);
+ if (typeof options.sourceName !== "undefined") {
+ tokeniser.source.name = options.sourceName;
+ }
return parseByTokens(tokeniser, options);
}
@@ -642,170 +239,245 @@ function parse(str, options = {}) {
"use strict";
__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "unescape", function() { return unescape; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "list", function() { return list; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "const_value", function() { return const_value; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "const_data", function() { return const_data; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "primitive_type", function() { return primitive_type; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "identifiers", function() { return identifiers; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "argument_list", function() { return argument_list; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "type_with_extended_attributes", function() { return type_with_extended_attributes; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "return_type", function() { return return_type; });
-/* harmony import */ var _type_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3);
-/* harmony import */ var _argument_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
-/* harmony import */ var _token_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(11);
-/* harmony import */ var _extended_attributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(9);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "stringTypes", function() { return stringTypes; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "argumentNameKeywords", function() { return argumentNameKeywords; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Tokeniser", function() { return Tokeniser; });
+/* harmony import */ var _error_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3);
+// These regular expressions use the sticky flag so they will only match at
+// the current location (ie. the offset of lastIndex).
+const tokenRe = {
+ // This expression uses a lookahead assertion to catch false matches
+ // against integers early.
+ "decimal": /-?(?=[0-9]*\.|[0-9]+[eE])(([0-9]+\.[0-9]*|[0-9]*\.[0-9]+)([Ee][-+]?[0-9]+)?|[0-9]+[Ee][-+]?[0-9]+)/y,
+ "integer": /-?(0([Xx][0-9A-Fa-f]+|[0-7]*)|[1-9][0-9]*)/y,
+ "identifier": /[_-]?[A-Za-z][0-9A-Z_a-z-]*/y,
+ "string": /"[^"]*"/y,
+ "whitespace": /[\t\n\r ]+/y,
+ "comment": /((\/(\/.*|\*([^*]|\*[^/])*\*\/)[\t\n\r ]*)+)/y,
+ "other": /[^\t\n\r 0-9A-Za-z]/y
+};
+
+const stringTypes = [
+ "ByteString",
+ "DOMString",
+ "USVString"
+];
+const argumentNameKeywords = [
+ "async",
+ "attribute",
+ "callback",
+ "const",
+ "deleter",
+ "dictionary",
+ "enum",
+ "getter",
+ "includes",
+ "inherit",
+ "interface",
+ "iterable",
+ "maplike",
+ "namespace",
+ "partial",
+ "required",
+ "setlike",
+ "setter",
+ "static",
+ "stringifier",
+ "typedef",
+ "unrestricted"
+];
+const nonRegexTerminals = [
+ "-Infinity",
+ "FrozenArray",
+ "Infinity",
+ "NaN",
+ "Promise",
+ "async",
+ "boolean",
+ "byte",
+ "double",
+ "false",
+ "float",
+ "long",
+ "mixin",
+ "null",
+ "octet",
+ "optional",
+ "or",
+ "readonly",
+ "record",
+ "sequence",
+ "short",
+ "true",
+ "unsigned",
+ "void"
+].concat(argumentNameKeywords, stringTypes);
-/**
- * @param {string} identifier
- */
-function unescape(identifier) {
- return identifier.startsWith('_') ? identifier.slice(1) : identifier;
-}
+const punctuations = [
+ "(",
+ ")",
+ ",",
+ "...",
+ ":",
+ ";",
+ "<",
+ "=",
+ ">",
+ "?",
+ "[",
+ "]",
+ "{",
+ "}"
+];
/**
- * Parses comma-separated list
- * @param {import("../tokeniser").Tokeniser} tokeniser
- * @param {object} args
- * @param {Function} args.parser parser function for each item
- * @param {boolean} [args.allowDangler] whether to allow dangling comma
- * @param {string} [args.listName] the name to be shown on error messages
+ * @param {string} str
*/
-function list(tokeniser, { parser, allowDangler, listName = "list" }) {
- const first = parser(tokeniser);
- if (!first) {
- return [];
- }
- first.tokens.separator = tokeniser.consume(",");
- const items = [first];
- while (first.tokens.separator) {
- const item = parser(tokeniser);
- if (!item) {
- if (!allowDangler) {
- tokeniser.error(`Trailing comma in ${listName}`);
+function tokenise(str) {
+ const tokens = [];
+ let lastCharIndex = 0;
+ let trivia = "";
+ let line = 1;
+ let index = 0;
+ while (lastCharIndex < str.length) {
+ const nextChar = str.charAt(lastCharIndex);
+ let result = -1;
+
+ if (/[\t\n\r ]/.test(nextChar)) {
+ result = attemptTokenMatch("whitespace", { noFlushTrivia: true });
+ } else if (nextChar === '/') {
+ result = attemptTokenMatch("comment", { noFlushTrivia: true });
+ }
+
+ if (result !== -1) {
+ const currentTrivia = tokens.pop().value;
+ line += (currentTrivia.match(/\n/g) || []).length;
+ trivia += currentTrivia;
+ index -= 1;
+ } else if (/[-0-9.A-Z_a-z]/.test(nextChar)) {
+ result = attemptTokenMatch("decimal");
+ if (result === -1) {
+ result = attemptTokenMatch("integer");
}
- break;
+ if (result === -1) {
+ result = attemptTokenMatch("identifier");
+ const token = tokens[tokens.length - 1];
+ if (result !== -1 && nonRegexTerminals.includes(token.value)) {
+ token.type = token.value;
+ }
+ }
+ } else if (nextChar === '"') {
+ result = attemptTokenMatch("string");
}
- item.tokens.separator = tokeniser.consume(",");
- items.push(item);
- if (!item.tokens.separator) break;
+
+ for (const punctuation of punctuations) {
+ if (str.startsWith(punctuation, lastCharIndex)) {
+ tokens.push({ type: punctuation, value: punctuation, trivia, line, index });
+ trivia = "";
+ lastCharIndex += punctuation.length;
+ result = lastCharIndex;
+ break;
+ }
+ }
+
+ // other as the last try
+ if (result === -1) {
+ result = attemptTokenMatch("other");
+ }
+ if (result === -1) {
+ throw new Error("Token stream not progressing");
+ }
+ lastCharIndex = result;
+ index += 1;
}
- return items;
-}
-/**
- * @param {import("../tokeniser").Tokeniser} tokeniser
- */
-function const_value(tokeniser) {
- return tokeniser.consume("true", "false", "Infinity", "-Infinity", "NaN", "decimal", "integer");
-}
+ // remaining trivia as eof
+ tokens.push({
+ type: "eof",
+ value: "",
+ trivia
+ });
-/**
- * @param {object} token
- * @param {string} token.type
- * @param {string} token.value
- */
-function const_data({ type, value }) {
- switch (type) {
- case "true":
- case "false":
- return { type: "boolean", value: type === "true" };
- case "Infinity":
- case "-Infinity":
- return { type: "Infinity", negative: type.startsWith("-") };
- case "[":
- return { type: "sequence", value: [] };
- case "{":
- return { type: "dictionary" };
- case "decimal":
- case "integer":
- return { type: "number", value };
- case "string":
- return { type: "string", value: value.slice(1, -1) };
- default:
- return { type };
+ return tokens;
+
+ /**
+ * @param {keyof tokenRe} type
+ * @param {object} [options]
+ * @param {boolean} [options.noFlushTrivia]
+ */
+ function attemptTokenMatch(type, { noFlushTrivia } = {}) {
+ const re = tokenRe[type];
+ re.lastIndex = lastCharIndex;
+ const result = re.exec(str);
+ if (result) {
+ tokens.push({ type, value: result[0], trivia, line, index });
+ if (!noFlushTrivia) {
+ trivia = "";
+ }
+ return re.lastIndex;
+ }
+ return -1;
}
}
-/**
- * @param {import("../tokeniser").Tokeniser} tokeniser
- */
-function primitive_type(tokeniser) {
- function integer_type() {
- const prefix = tokeniser.consume("unsigned");
- const base = tokeniser.consume("short", "long");
- if (base) {
- const postfix = tokeniser.consume("long");
- return new _type_js__WEBPACK_IMPORTED_MODULE_0__["Type"]({ source, tokens: { prefix, base, postfix } });
- }
- if (prefix) tokeniser.error("Failed to parse integer type");
+class Tokeniser {
+ /**
+ * @param {string} idl
+ */
+ constructor(idl) {
+ this.source = tokenise(idl);
+ this.position = 0;
}
- function decimal_type() {
- const prefix = tokeniser.consume("unrestricted");
- const base = tokeniser.consume("float", "double");
- if (base) {
- return new _type_js__WEBPACK_IMPORTED_MODULE_0__["Type"]({ source, tokens: { prefix, base } });
- }
- if (prefix) tokeniser.error("Failed to parse float type");
+ /**
+ * @param {string} message
+ */
+ error(message) {
+ throw new WebIDLParseError(Object(_error_js__WEBPACK_IMPORTED_MODULE_0__["syntaxError"])(this.source, this.position, this.current, message));
}
- const { source } = tokeniser;
- const num_type = integer_type(tokeniser) || decimal_type(tokeniser);
- if (num_type) return num_type;
- const base = tokeniser.consume("boolean", "byte", "octet");
- if (base) {
- return new _type_js__WEBPACK_IMPORTED_MODULE_0__["Type"]({ source, tokens: { base } });
+ /**
+ * @param {string} type
+ */
+ probe(type) {
+ return this.source.length > this.position && this.source[this.position].type === type;
}
-}
-/**
- * @param {import("../tokeniser").Tokeniser} tokeniser
- */
-function identifiers(tokeniser) {
- const ids = list(tokeniser, { parser: _token_js__WEBPACK_IMPORTED_MODULE_2__["Token"].parser(tokeniser, "identifier"), listName: "identifier list" });
- if (!ids.length) {
- tokeniser.error("Expected identifiers but none found");
+ /**
+ * @param {...string} candidates
+ */
+ consume(...candidates) {
+ for (const type of candidates) {
+ if (!this.probe(type)) continue;
+ const token = this.source[this.position];
+ this.position++;
+ return token;
+ }
}
- return ids;
-}
-/**
- * @param {import("../tokeniser").Tokeniser} tokeniser
- */
-function argument_list(tokeniser) {
- return list(tokeniser, { parser: _argument_js__WEBPACK_IMPORTED_MODULE_1__["Argument"].parse, listName: "arguments list" });
+ /**
+ * @param {number} position
+ */
+ unconsume(position) {
+ this.position = position;
+ }
}
-/**
- * @param {import("../tokeniser").Tokeniser} tokeniser
- * @param {string} typeName
- */
-function type_with_extended_attributes(tokeniser, typeName) {
- const extAttrs = _extended_attributes_js__WEBPACK_IMPORTED_MODULE_3__["ExtendedAttributes"].parse(tokeniser);
- const ret = _type_js__WEBPACK_IMPORTED_MODULE_0__["Type"].parse(tokeniser, typeName);
- if (ret) ret.extAttrs = extAttrs;
- return ret;
-}
+class WebIDLParseError extends Error {
+ constructor({ message, bareMessage, context, line, sourceName, input, tokens }) {
+ super(message);
-/**
- * @param {import("../tokeniser").Tokeniser} tokeniser
- * @param {string} typeName
- */
-function return_type(tokeniser, typeName) {
- const typ = _type_js__WEBPACK_IMPORTED_MODULE_0__["Type"].parse(tokeniser, typeName || "return-type");
- if (typ) {
- return typ;
- }
- const voidToken = tokeniser.consume("void");
- if (voidToken) {
- const ret = new _type_js__WEBPACK_IMPORTED_MODULE_0__["Type"]({ source: tokeniser.source, tokens: { base: voidToken } });
- ret.type = "return-type";
- return ret;
+ this.name = "WebIDLParseError"; // not to be mangled
+ this.bareMessage = bareMessage;
+ this.context = context;
+ this.line = line;
+ this.sourceName = sourceName;
+ this.input = input;
+ this.tokens = tokens;
}
}
@@ -816,903 +488,1774 @@ function return_type(tokeniser, typeName) {
"use strict";
__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Type", function() { return Type; });
-/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4);
-/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2);
-/* harmony import */ var _tokeniser_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5);
-
-
-
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "syntaxError", function() { return syntaxError; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "validationError", function() { return validationError; });
+/**
+ * @param {string} text
+ */
+function lastLine(text) {
+ const splitted = text.split("\n");
+ return splitted[splitted.length - 1];
+}
/**
- * @param {import("../tokeniser").Tokeniser} tokeniser
- * @param {string} typeName
+ * @typedef {object} WebIDL2ErrorOptions
+ * @property {"error" | "warning"} level
+ *
+ * @param {string} message error message
+ * @param {"Syntax" | "Validation"} kind error type
+ * @param {WebIDL2ErrorOptions} [options]
*/
-function generic_type(tokeniser, typeName) {
- const base = tokeniser.consume("FrozenArray", "Promise", "sequence", "record");
- if (!base) {
- return;
+function error(source, position, current, message, kind, { level = "error" } = {}) {
+ /**
+ * @param {number} count
+ */
+ function sliceTokens(count) {
+ return count > 0 ?
+ source.slice(position, position + count) :
+ source.slice(Math.max(position + count, 0), position);
}
- const ret = new Type({ source: tokeniser.source, tokens: { base } });
- ret.tokens.open = tokeniser.consume("<") || tokeniser.error(`No opening bracket after ${base.type}`);
- switch (base.type) {
- case "Promise": {
- if (tokeniser.probe("[")) tokeniser.error("Promise type cannot have extended attribute");
- const subtype = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["return_type"])(tokeniser, typeName) || tokeniser.error("Missing Promise subtype");
- ret.subtype.push(subtype);
- break;
- }
- case "sequence":
- case "FrozenArray": {
- const subtype = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["type_with_extended_attributes"])(tokeniser, typeName) || tokeniser.error(`Missing ${base.type} subtype`);
- ret.subtype.push(subtype);
- break;
+
+ function tokensToText(inputs, { precedes } = {}) {
+ const text = inputs.map(t => t.trivia + t.value).join("");
+ const nextToken = source[position];
+ if (nextToken.type === "eof") {
+ return text;
}
- case "record": {
- if (tokeniser.probe("[")) tokeniser.error("Record key cannot have extended attribute");
- const keyType = tokeniser.consume(..._tokeniser_js__WEBPACK_IMPORTED_MODULE_2__["stringTypes"]) || tokeniser.error(`Record key must be one of: ${_tokeniser_js__WEBPACK_IMPORTED_MODULE_2__["stringTypes"].join(", ")}`);
- const keyIdlType = new Type({ source: tokeniser.source, tokens: { base: keyType }});
- keyIdlType.tokens.separator = tokeniser.consume(",") || tokeniser.error("Missing comma after record key type");
- keyIdlType.type = typeName;
- const valueType = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["type_with_extended_attributes"])(tokeniser, typeName) || tokeniser.error("Error parsing generic type record");
- ret.subtype.push(keyIdlType, valueType);
- break;
+ if (precedes) {
+ return text + nextToken.trivia;
}
+ return text.slice(nextToken.trivia.length);
}
- if (!ret.idlType) tokeniser.error(`Error parsing generic type ${base.type}`);
- ret.tokens.close = tokeniser.consume(">") || tokeniser.error(`Missing closing bracket after ${base.type}`);
- return ret;
-}
-/**
- * @param {import("../tokeniser").Tokeniser} tokeniser
- */
-function type_suffix(tokeniser, obj) {
- const nullable = tokeniser.consume("?");
- if (nullable) {
- obj.tokens.nullable = nullable;
- }
- if (tokeniser.probe("?")) tokeniser.error("Can't nullable more than once");
+ const maxTokens = 5; // arbitrary but works well enough
+ const line =
+ source[position].type !== "eof" ? source[position].line :
+ source.length > 1 ? source[position - 1].line :
+ 1;
+
+ const precedingLastLine = lastLine(
+ tokensToText(sliceTokens(-maxTokens), { precedes: true })
+ );
+
+ const subsequentTokens = sliceTokens(maxTokens);
+ const subsequentText = tokensToText(subsequentTokens);
+ const subsequentFirstLine = subsequentText.split("\n")[0];
+
+ const spaced = " ".repeat(precedingLastLine.length) + "^";
+ const sourceContext = precedingLastLine + subsequentFirstLine + "\n" + spaced;
+
+ const contextType = kind === "Syntax" ? "since" : "inside";
+ const inSourceName = source.name ? ` in ${source.name}` : "";
+ const grammaticalContext = (current && current.name) ? `, ${contextType} \`${current.partial ? "partial " : ""}${current.type} ${current.name}\`` : "";
+ const context = `${kind} error at line ${line}${inSourceName}${grammaticalContext}:\n${sourceContext}`;
+ return {
+ message: `${context} ${message}`,
+ bareMessage: message,
+ context,
+ line,
+ sourceName: source.name,
+ level,
+ input: subsequentText,
+ tokens: subsequentTokens
+ };
}
/**
- * @param {import("../tokeniser").Tokeniser} tokeniser
- * @param {string} typeName
+ * @param {string} message error message
*/
-function single_type(tokeniser, typeName) {
- let ret = generic_type(tokeniser, typeName) || Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["primitive_type"])(tokeniser);
- if (!ret) {
- const base = tokeniser.consume("identifier", ..._tokeniser_js__WEBPACK_IMPORTED_MODULE_2__["stringTypes"]);
- if (!base) {
- return;
- }
- ret = new Type({ source: tokeniser.source, tokens: { base } });
- if (tokeniser.probe("<")) tokeniser.error(`Unsupported generic type ${base.value}`);
- }
- if (ret.generic === "Promise" && tokeniser.probe("?")) {
- tokeniser.error("Promise type cannot be nullable");
- }
- ret.type = typeName || null;
- type_suffix(tokeniser, ret);
- if (ret.nullable && ret.idlType === "any") tokeniser.error("Type `any` cannot be made nullable");
- return ret;
+function syntaxError(source, position, current, message) {
+ return error(source, position, current, message, "Syntax");
}
/**
- * @param {import("../tokeniser").Tokeniser} tokeniser
- * @param {string} type
+ * @param {string} message error message
+ * @param {WebIDL2ErrorOptions} [options]
*/
-function union_type(tokeniser, type) {
- const tokens = {};
- tokens.open = tokeniser.consume("(");
- if (!tokens.open) return;
- const ret = new Type({ source: tokeniser.source, tokens });
- ret.type = type || null;
- while (true) {
- const typ = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["type_with_extended_attributes"])(tokeniser) || tokeniser.error("No type after open parenthesis or 'or' in union type");
- if (typ.idlType === "any") tokeniser.error("Type `any` cannot be included in a union type");
- ret.subtype.push(typ);
- const or = tokeniser.consume("or");
- if (or) {
- typ.tokens.separator = or;
- }
- else break;
- }
- if (ret.idlType.length < 2) {
- tokeniser.error("At least two types are expected in a union type but found less");
- }
- tokens.close = tokeniser.consume(")") || tokeniser.error("Unterminated union type");
- type_suffix(tokeniser, ret);
- return ret;
+function validationError(source, token, current, message, options) {
+ return error(source, token.index, current, message, "Validation", options);
}
-class Type extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
+
+/***/ }),
+/* 4 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Enum", function() { return Enum; });
+/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5);
+/* harmony import */ var _token_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(13);
+/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(7);
+
+
+
+
+class EnumValue extends _token_js__WEBPACK_IMPORTED_MODULE_1__["Token"] {
/**
* @param {import("../tokeniser").Tokeniser} tokeniser
- * @param {string} typeName
*/
- static parse(tokeniser, typeName) {
- return single_type(tokeniser, typeName) || union_type(tokeniser, typeName);
+ static parse(tokeniser) {
+ const value = tokeniser.consume("string");
+ if (value) {
+ return new EnumValue({ source: tokeniser.source, tokens: { value } });
+ }
}
- constructor({ source, tokens }) {
- super({ source, tokens });
- Object.defineProperty(this, "subtype", { value: [] });
- this.extAttrs = [];
+ get type() {
+ return "enum-value";
+ }
+ get value() {
+ return super.value.slice(1, -1);
}
+}
- get generic() {
- if (this.subtype.length && this.tokens.base) {
- return this.tokens.base.value;
+class Enum extends _base_js__WEBPACK_IMPORTED_MODULE_2__["Base"] {
+ /**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ */
+ static parse(tokeniser) {
+ const tokens = {};
+ tokens.base = tokeniser.consume("enum");
+ if (!tokens.base) {
+ return;
}
- return "";
- }
- get nullable() {
- return Boolean(this.tokens.nullable);
+ tokens.name = tokeniser.consume("identifier") || tokeniser.error("No name for enum");
+ const ret = tokeniser.current = new Enum({ source: tokeniser.source, tokens });
+ tokens.open = tokeniser.consume("{") || tokeniser.error("Bodyless enum");
+ ret.values = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_0__["list"])(tokeniser, {
+ parser: EnumValue.parse,
+ allowDangler: true,
+ listName: "enumeration"
+ });
+ if (tokeniser.probe("string")) {
+ tokeniser.error("No comma between enum values");
+ }
+ tokens.close = tokeniser.consume("}") || tokeniser.error("Unexpected value in enum");
+ if (!ret.values.length) {
+ tokeniser.error("No value in enum");
+ }
+ tokens.termination = tokeniser.consume(";") || tokeniser.error("No semicolon after enum");
+ return ret;
}
- get union() {
- return Boolean(this.subtype.length) && !this.tokens.base;
+
+ get type() {
+ return "enum";
}
- get idlType() {
- if (this.subtype.length) {
- return this.subtype;
- }
- // Adding prefixes/postfixes for "unrestricted float", etc.
- const name = [
- this.tokens.prefix,
- this.tokens.base,
- this.tokens.postfix
- ].filter(t => t).map(t => t.value).join(" ");
- return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["unescape"])(name);
+ get name() {
+ return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_0__["unescape"])(this.tokens.name.value);
}
}
/***/ }),
-/* 4 */
+/* 5 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Base", function() { return Base; });
-class Base {
- constructor({ source, tokens }) {
- Object.defineProperties(this, {
- source: { value: source },
- tokens: { value: tokens }
- });
- }
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "unescape", function() { return unescape; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "list", function() { return list; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "const_value", function() { return const_value; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "const_data", function() { return const_data; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "primitive_type", function() { return primitive_type; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "identifiers", function() { return identifiers; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "argument_list", function() { return argument_list; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "type_with_extended_attributes", function() { return type_with_extended_attributes; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "return_type", function() { return return_type; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "stringifier", function() { return stringifier; });
+/* harmony import */ var _type_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
+/* harmony import */ var _argument_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9);
+/* harmony import */ var _token_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(13);
+/* harmony import */ var _extended_attributes_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(11);
+/* harmony import */ var _operation_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(14);
+/* harmony import */ var _attribute_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(15);
- toJSON() {
- const json = { type: undefined, name: undefined, inheritance: undefined };
- let proto = this;
- while (proto !== Object.prototype) {
- const descMap = Object.getOwnPropertyDescriptors(proto);
- for (const [key, value] of Object.entries(descMap)) {
- if (value.enumerable || value.get) {
- json[key] = this[key];
- }
- }
- proto = Object.getPrototypeOf(proto);
- }
- return json;
- }
-}
-/***/ }),
-/* 5 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "stringTypes", function() { return stringTypes; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "argumentNameKeywords", function() { return argumentNameKeywords; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Tokeniser", function() { return Tokeniser; });
-/* harmony import */ var _error_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
-// These regular expressions use the sticky flag so they will only match at
-// the current location (ie. the offset of lastIndex).
-const tokenRe = {
- // This expression uses a lookahead assertion to catch false matches
- // against integers early.
- "decimal": /-?(?=[0-9]*\.|[0-9]+[eE])(([0-9]+\.[0-9]*|[0-9]*\.[0-9]+)([Ee][-+]?[0-9]+)?|[0-9]+[Ee][-+]?[0-9]+)/y,
- "integer": /-?(0([Xx][0-9A-Fa-f]+|[0-7]*)|[1-9][0-9]*)/y,
- "identifier": /[_-]?[A-Za-z][0-9A-Z_a-z-]*/y,
- "string": /"[^"]*"/y,
- "whitespace": /[\t\n\r ]+/y,
- "comment": /((\/(\/.*|\*([^*]|\*[^/])*\*\/)[\t\n\r ]*)+)/y,
- "other": /[^\t\n\r 0-9A-Za-z]/y
-};
-const stringTypes = [
- "ByteString",
- "DOMString",
- "USVString"
-];
+/**
+ * @param {string} identifier
+ */
+function unescape(identifier) {
+ return identifier.startsWith('_') ? identifier.slice(1) : identifier;
+}
-const argumentNameKeywords = [
- "attribute",
- "callback",
- "const",
- "deleter",
- "dictionary",
- "enum",
- "getter",
- "includes",
- "inherit",
- "interface",
- "iterable",
- "maplike",
- "namespace",
- "partial",
- "required",
- "setlike",
- "setter",
- "static",
- "stringifier",
- "typedef",
- "unrestricted"
-];
+/**
+ * Parses comma-separated list
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ * @param {object} args
+ * @param {Function} args.parser parser function for each item
+ * @param {boolean} [args.allowDangler] whether to allow dangling comma
+ * @param {string} [args.listName] the name to be shown on error messages
+ */
+function list(tokeniser, { parser, allowDangler, listName = "list" }) {
+ const first = parser(tokeniser);
+ if (!first) {
+ return [];
+ }
+ first.tokens.separator = tokeniser.consume(",");
+ const items = [first];
+ while (first.tokens.separator) {
+ const item = parser(tokeniser);
+ if (!item) {
+ if (!allowDangler) {
+ tokeniser.error(`Trailing comma in ${listName}`);
+ }
+ break;
+ }
+ item.tokens.separator = tokeniser.consume(",");
+ items.push(item);
+ if (!item.tokens.separator) break;
+ }
+ return items;
+}
+
+/**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ */
+function const_value(tokeniser) {
+ return tokeniser.consume("true", "false", "Infinity", "-Infinity", "NaN", "decimal", "integer");
+}
+
+/**
+ * @param {object} token
+ * @param {string} token.type
+ * @param {string} token.value
+ */
+function const_data({ type, value }) {
+ switch (type) {
+ case "true":
+ case "false":
+ return { type: "boolean", value: type === "true" };
+ case "Infinity":
+ case "-Infinity":
+ return { type: "Infinity", negative: type.startsWith("-") };
+ case "[":
+ return { type: "sequence", value: [] };
+ case "{":
+ return { type: "dictionary" };
+ case "decimal":
+ case "integer":
+ return { type: "number", value };
+ case "string":
+ return { type: "string", value: value.slice(1, -1) };
+ default:
+ return { type };
+ }
+}
+
+/**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ */
+function primitive_type(tokeniser) {
+ function integer_type() {
+ const prefix = tokeniser.consume("unsigned");
+ const base = tokeniser.consume("short", "long");
+ if (base) {
+ const postfix = tokeniser.consume("long");
+ return new _type_js__WEBPACK_IMPORTED_MODULE_0__["Type"]({ source, tokens: { prefix, base, postfix } });
+ }
+ if (prefix) tokeniser.error("Failed to parse integer type");
+ }
+
+ function decimal_type() {
+ const prefix = tokeniser.consume("unrestricted");
+ const base = tokeniser.consume("float", "double");
+ if (base) {
+ return new _type_js__WEBPACK_IMPORTED_MODULE_0__["Type"]({ source, tokens: { prefix, base } });
+ }
+ if (prefix) tokeniser.error("Failed to parse float type");
+ }
+
+ const { source } = tokeniser;
+ const num_type = integer_type(tokeniser) || decimal_type(tokeniser);
+ if (num_type) return num_type;
+ const base = tokeniser.consume("boolean", "byte", "octet");
+ if (base) {
+ return new _type_js__WEBPACK_IMPORTED_MODULE_0__["Type"]({ source, tokens: { base } });
+ }
+}
+
+/**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ */
+function identifiers(tokeniser) {
+ const ids = list(tokeniser, { parser: _token_js__WEBPACK_IMPORTED_MODULE_2__["Token"].parser(tokeniser, "identifier"), listName: "identifier list" });
+ if (!ids.length) {
+ tokeniser.error("Expected identifiers but none found");
+ }
+ return ids;
+}
+
+/**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ */
+function argument_list(tokeniser) {
+ return list(tokeniser, { parser: _argument_js__WEBPACK_IMPORTED_MODULE_1__["Argument"].parse, listName: "arguments list" });
+}
+
+/**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ * @param {string} typeName
+ */
+function type_with_extended_attributes(tokeniser, typeName) {
+ const extAttrs = _extended_attributes_js__WEBPACK_IMPORTED_MODULE_3__["ExtendedAttributes"].parse(tokeniser);
+ const ret = _type_js__WEBPACK_IMPORTED_MODULE_0__["Type"].parse(tokeniser, typeName);
+ if (ret) ret.extAttrs = extAttrs;
+ return ret;
+}
+
+/**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ * @param {string} typeName
+ */
+function return_type(tokeniser, typeName) {
+ const typ = _type_js__WEBPACK_IMPORTED_MODULE_0__["Type"].parse(tokeniser, typeName || "return-type");
+ if (typ) {
+ return typ;
+ }
+ const voidToken = tokeniser.consume("void");
+ if (voidToken) {
+ const ret = new _type_js__WEBPACK_IMPORTED_MODULE_0__["Type"]({ source: tokeniser.source, tokens: { base: voidToken } });
+ ret.type = "return-type";
+ return ret;
+ }
+}
+
+/**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ */
+function stringifier(tokeniser) {
+ const special = tokeniser.consume("stringifier");
+ if (!special) return;
+ const member = _attribute_js__WEBPACK_IMPORTED_MODULE_5__["Attribute"].parse(tokeniser, { special }) ||
+ _operation_js__WEBPACK_IMPORTED_MODULE_4__["Operation"].parse(tokeniser, { special }) ||
+ tokeniser.error("Unterminated stringifier");
+ return member;
+}
+
+
+/***/ }),
+/* 6 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Type", function() { return Type; });
+/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7);
+/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
+/* harmony import */ var _tokeniser_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2);
+/* harmony import */ var _error_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(3);
+/* harmony import */ var _validators_helpers_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(8);
+
+
+
+
+
+
+/**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ * @param {string} typeName
+ */
+function generic_type(tokeniser, typeName) {
+ const base = tokeniser.consume("FrozenArray", "Promise", "sequence", "record");
+ if (!base) {
+ return;
+ }
+ const ret = new Type({ source: tokeniser.source, tokens: { base } });
+ ret.tokens.open = tokeniser.consume("<") || tokeniser.error(`No opening bracket after ${base.type}`);
+ switch (base.type) {
+ case "Promise": {
+ if (tokeniser.probe("[")) tokeniser.error("Promise type cannot have extended attribute");
+ const subtype = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["return_type"])(tokeniser, typeName) || tokeniser.error("Missing Promise subtype");
+ ret.subtype.push(subtype);
+ break;
+ }
+ case "sequence":
+ case "FrozenArray": {
+ const subtype = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["type_with_extended_attributes"])(tokeniser, typeName) || tokeniser.error(`Missing ${base.type} subtype`);
+ ret.subtype.push(subtype);
+ break;
+ }
+ case "record": {
+ if (tokeniser.probe("[")) tokeniser.error("Record key cannot have extended attribute");
+ const keyType = tokeniser.consume(..._tokeniser_js__WEBPACK_IMPORTED_MODULE_2__["stringTypes"]) || tokeniser.error(`Record key must be one of: ${_tokeniser_js__WEBPACK_IMPORTED_MODULE_2__["stringTypes"].join(", ")}`);
+ const keyIdlType = new Type({ source: tokeniser.source, tokens: { base: keyType }});
+ keyIdlType.tokens.separator = tokeniser.consume(",") || tokeniser.error("Missing comma after record key type");
+ keyIdlType.type = typeName;
+ const valueType = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["type_with_extended_attributes"])(tokeniser, typeName) || tokeniser.error("Error parsing generic type record");
+ ret.subtype.push(keyIdlType, valueType);
+ break;
+ }
+ }
+ if (!ret.idlType) tokeniser.error(`Error parsing generic type ${base.type}`);
+ ret.tokens.close = tokeniser.consume(">") || tokeniser.error(`Missing closing bracket after ${base.type}`);
+ return ret;
+}
+
+/**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ */
+function type_suffix(tokeniser, obj) {
+ const nullable = tokeniser.consume("?");
+ if (nullable) {
+ obj.tokens.nullable = nullable;
+ }
+ if (tokeniser.probe("?")) tokeniser.error("Can't nullable more than once");
+}
+
+/**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ * @param {string} typeName
+ */
+function single_type(tokeniser, typeName) {
+ let ret = generic_type(tokeniser, typeName) || Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["primitive_type"])(tokeniser);
+ if (!ret) {
+ const base = tokeniser.consume("identifier", ..._tokeniser_js__WEBPACK_IMPORTED_MODULE_2__["stringTypes"]);
+ if (!base) {
+ return;
+ }
+ ret = new Type({ source: tokeniser.source, tokens: { base } });
+ if (tokeniser.probe("<")) tokeniser.error(`Unsupported generic type ${base.value}`);
+ }
+ if (ret.generic === "Promise" && tokeniser.probe("?")) {
+ tokeniser.error("Promise type cannot be nullable");
+ }
+ ret.type = typeName || null;
+ type_suffix(tokeniser, ret);
+ if (ret.nullable && ret.idlType === "any") tokeniser.error("Type `any` cannot be made nullable");
+ return ret;
+}
+
+/**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ * @param {string} type
+ */
+function union_type(tokeniser, type) {
+ const tokens = {};
+ tokens.open = tokeniser.consume("(");
+ if (!tokens.open) return;
+ const ret = new Type({ source: tokeniser.source, tokens });
+ ret.type = type || null;
+ while (true) {
+ const typ = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["type_with_extended_attributes"])(tokeniser) || tokeniser.error("No type after open parenthesis or 'or' in union type");
+ if (typ.idlType === "any") tokeniser.error("Type `any` cannot be included in a union type");
+ ret.subtype.push(typ);
+ const or = tokeniser.consume("or");
+ if (or) {
+ typ.tokens.separator = or;
+ }
+ else break;
+ }
+ if (ret.idlType.length < 2) {
+ tokeniser.error("At least two types are expected in a union type but found less");
+ }
+ tokens.close = tokeniser.consume(")") || tokeniser.error("Unterminated union type");
+ type_suffix(tokeniser, ret);
+ return ret;
+}
+
+class Type extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
+ /**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ * @param {string} typeName
+ */
+ static parse(tokeniser, typeName) {
+ return single_type(tokeniser, typeName) || union_type(tokeniser, typeName);
+ }
+
+ constructor({ source, tokens }) {
+ super({ source, tokens });
+ Object.defineProperty(this, "subtype", { value: [] });
+ this.extAttrs = [];
+ }
+
+ get generic() {
+ if (this.subtype.length && this.tokens.base) {
+ return this.tokens.base.value;
+ }
+ return "";
+ }
+ get nullable() {
+ return Boolean(this.tokens.nullable);
+ }
+ get union() {
+ return Boolean(this.subtype.length) && !this.tokens.base;
+ }
+ get idlType() {
+ if (this.subtype.length) {
+ return this.subtype;
+ }
+ // Adding prefixes/postfixes for "unrestricted float", etc.
+ const name = [
+ this.tokens.prefix,
+ this.tokens.base,
+ this.tokens.postfix
+ ].filter(t => t).map(t => t.value).join(" ");
+ return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["unescape"])(name);
+ }
+
+ *validate(defs) {
+ /*
+ * If a union is nullable, its subunions cannot include a dictionary
+ * If not, subunions may include dictionaries if each union is not nullable
+ */
+ const typedef = !this.union && defs.unique.get(this.idlType);
+ const target =
+ this.union ? this :
+ (typedef && typedef.type === "typedef") ? typedef.idlType :
+ undefined;
+ if (target && this.nullable) {
+ // do not allow any dictionary
+ const reference = Object(_validators_helpers_js__WEBPACK_IMPORTED_MODULE_4__["idlTypeIncludesDictionary"])(target, defs);
+ if (reference) {
+ const targetToken = (this.union ? reference : this).tokens.base;
+ const message = `Nullable union cannot include a dictionary type`;
+ yield Object(_error_js__WEBPACK_IMPORTED_MODULE_3__["validationError"])(this.source, targetToken, this, message);
+ }
+ } else {
+ // allow some dictionary
+ for (const subtype of this.subtype) {
+ yield* subtype.validate(defs);
+ }
+ }
+ }
+}
+
+
+/***/ }),
+/* 7 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Base", function() { return Base; });
+class Base {
+ constructor({ source, tokens }) {
+ Object.defineProperties(this, {
+ source: { value: source },
+ tokens: { value: tokens }
+ });
+ }
+
+ toJSON() {
+ const json = { type: undefined, name: undefined, inheritance: undefined };
+ let proto = this;
+ while (proto !== Object.prototype) {
+ const descMap = Object.getOwnPropertyDescriptors(proto);
+ for (const [key, value] of Object.entries(descMap)) {
+ if (value.enumerable || value.get) {
+ json[key] = this[key];
+ }
+ }
+ proto = Object.getPrototypeOf(proto);
+ }
+ return json;
+ }
+}
-const nonRegexTerminals = [
- "-Infinity",
- "FrozenArray",
- "Infinity",
- "NaN",
- "Promise",
- "boolean",
- "byte",
- "double",
- "false",
- "float",
- "implements",
- "legacyiterable",
- "long",
- "mixin",
- "null",
- "octet",
- "optional",
- "or",
- "readonly",
- "record",
- "sequence",
- "short",
- "true",
- "unsigned",
- "void"
-].concat(argumentNameKeywords, stringTypes);
-const punctuations = [
- "(",
- ")",
- ",",
- "...",
- ":",
- ";",
- "<",
- "=",
- ">",
- "?",
- "[",
- "]",
- "{",
- "}"
-];
+/***/ }),
+/* 8 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "dictionaryWithinUnion", function() { return dictionaryWithinUnion; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "idlTypeIncludesDictionary", function() { return idlTypeIncludesDictionary; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "referencesTypedef", function() { return referencesTypedef; });
+/**
+ * Yields direct references to dictionary within union.
+ */
+function* dictionaryWithinUnion(subtypes, defs) {
+ for (const subtype of subtypes) {
+ const def = defs.unique.get(subtype.idlType);
+ if (def && def.type === "dictionary") {
+ yield subtype;
+ }
+ }
+}
+
+/**
+ * @return the type reference that ultimately includes dictionary.
+ */
+function idlTypeIncludesDictionary(idlType, defs) {
+ if (!idlType.union) {
+ const def = defs.unique.get(idlType.idlType);
+ if (!def) {
+ return;
+ }
+ if (def.type === "typedef") {
+ const { typedefIncludesDictionary} = defs.cache;
+ if (typedefIncludesDictionary.has(def)) {
+ // Note that this also halts when it met indeterminate state
+ // to prevent infinite recursion
+ return typedefIncludesDictionary.get(def);
+ }
+ defs.cache.typedefIncludesDictionary.set(def, undefined); // indeterminate state
+ const result = idlTypeIncludesDictionary(def.idlType, defs);
+ defs.cache.typedefIncludesDictionary.set(def, result);
+ if (result) {
+ return idlType;
+ }
+ }
+ if (def.type === "dictionary") {
+ return idlType;
+ }
+ }
+ for (const subtype of idlType.subtype) {
+ const result = idlTypeIncludesDictionary(subtype, defs);
+ if (result) {
+ if (subtype.union) {
+ return result;
+ }
+ return subtype;
+ }
+ }
+}
+
+/**
+ * @return true if the idlType directly references a typedef.
+ */
+function referencesTypedef(idlType, defs) {
+ const result = defs.unique.get(idlType.idlType);
+ return result && result.type === "typedef";
+}
+
+
+/***/ }),
+/* 9 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Argument", function() { return Argument; });
+/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7);
+/* harmony import */ var _default_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(10);
+/* harmony import */ var _extended_attributes_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(11);
+/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5);
+/* harmony import */ var _tokeniser_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(2);
+/* harmony import */ var _error_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(3);
+/* harmony import */ var _validators_helpers_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(8);
+
+
+
+
+
+
+
+
+class Argument extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
+ /**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ */
+ static parse(tokeniser) {
+ const start_position = tokeniser.position;
+ const tokens = {};
+ const ret = new Argument({ source: tokeniser.source, tokens });
+ ret.extAttrs = _extended_attributes_js__WEBPACK_IMPORTED_MODULE_2__["ExtendedAttributes"].parse(tokeniser);
+ tokens.optional = tokeniser.consume("optional");
+ ret.idlType = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_3__["type_with_extended_attributes"])(tokeniser, "argument-type");
+ if (!ret.idlType) {
+ return tokeniser.unconsume(start_position);
+ }
+ if (!tokens.optional) {
+ tokens.variadic = tokeniser.consume("...");
+ }
+ tokens.name = tokeniser.consume("identifier", ..._tokeniser_js__WEBPACK_IMPORTED_MODULE_4__["argumentNameKeywords"]);
+ if (!tokens.name) {
+ return tokeniser.unconsume(start_position);
+ }
+ ret.default = tokens.optional ? _default_js__WEBPACK_IMPORTED_MODULE_1__["Default"].parse(tokeniser) : null;
+ return ret;
+ }
+
+ get type() {
+ return "argument";
+ }
+ get optional() {
+ return !!this.tokens.optional;
+ }
+ get variadic() {
+ return !!this.tokens.variadic;
+ }
+ get name() {
+ return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_3__["unescape"])(this.tokens.name.value);
+ }
+
+ *validate(defs) {
+ yield* this.idlType.validate(defs);
+ if (Object(_validators_helpers_js__WEBPACK_IMPORTED_MODULE_6__["idlTypeIncludesDictionary"])(this.idlType, defs)) {
+ if (this.optional && !this.default) {
+ const message = `Optional dictionary arguments must have a default value of \`{}\`.`;
+ yield Object(_error_js__WEBPACK_IMPORTED_MODULE_5__["validationError"])(this.source, this.tokens.name, this, message);
+ }
+ if (this.idlType.nullable) {
+ const message = `Dictionary arguments cannot be nullable.`;
+ yield Object(_error_js__WEBPACK_IMPORTED_MODULE_5__["validationError"])(this.source, this.tokens.name, this, message);
+ }
+ }
+ }
+}
+
+
+/***/ }),
+/* 10 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Default", function() { return Default; });
+/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7);
+/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
+
+
+
+class Default extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
+ /**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ */
+ static parse(tokeniser) {
+ const assign = tokeniser.consume("=");
+ if (!assign) {
+ return null;
+ }
+ const def = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["const_value"])(tokeniser) || tokeniser.consume("string", "null", "[", "{") || tokeniser.error("No value for default");
+ const expression = [def];
+ if (def.type === "[") {
+ const close = tokeniser.consume("]") || tokeniser.error("Default sequence value must be empty");
+ expression.push(close);
+ } else if (def.type === "{") {
+ const close = tokeniser.consume("}") || tokeniser.error("Default dictionary value must be empty");
+ expression.push(close);
+ }
+ return new Default({ source: tokeniser.source, tokens: { assign }, expression });
+ }
+
+ constructor({ source, tokens, expression }) {
+ super({ source, tokens });
+ Object.defineProperty(this, "expression", { value: expression });
+ }
+
+ get type() {
+ return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["const_data"])(this.expression[0]).type;
+ }
+ get value() {
+ return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["const_data"])(this.expression[0]).value;
+ }
+ get negative() {
+ return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["const_data"])(this.expression[0]).negative;
+ }
+}
+
+
+/***/ }),
+/* 11 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ExtendedAttributes", function() { return ExtendedAttributes; });
+/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7);
+/* harmony import */ var _array_base_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(12);
+/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5);
+/* harmony import */ var _error_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(3);
+
+
+
+
+
+class ExtendedAttributeParameters extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
+ /**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ */
+ static parse(tokeniser) {
+ const tokens = { assign: tokeniser.consume("=") };
+ const ret = new ExtendedAttributeParameters({ source: tokeniser.source, tokens });
+ if (tokens.assign) {
+ tokens.secondaryName = tokeniser.consume("identifier", "decimal", "integer", "string");
+ }
+ tokens.open = tokeniser.consume("(");
+ if (tokens.open) {
+ ret.list = ret.rhsType === "identifier-list" ?
+ // [Exposed=(Window,Worker)]
+ Object(_helpers_js__WEBPACK_IMPORTED_MODULE_2__["identifiers"])(tokeniser) :
+ // [NamedConstructor=Audio(DOMString src)] or [Constructor(DOMString str)]
+ Object(_helpers_js__WEBPACK_IMPORTED_MODULE_2__["argument_list"])(tokeniser);
+ tokens.close = tokeniser.consume(")") || tokeniser.error("Unexpected token in extended attribute argument list");
+ } else if (ret.hasRhs && !tokens.secondaryName) {
+ tokeniser.error("No right hand side to extended attribute assignment");
+ }
+ return ret;
+ }
+
+ get rhsType() {
+ return !this.tokens.assign ? null :
+ !this.tokens.secondaryName ? "identifier-list" :
+ this.tokens.secondaryName.type;
+ }
+}
+
+class SimpleExtendedAttribute extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
+ /**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ */
+ static parse(tokeniser) {
+ const name = tokeniser.consume("identifier");
+ if (name) {
+ return new SimpleExtendedAttribute({
+ source: tokeniser.source,
+ tokens: { name },
+ params: ExtendedAttributeParameters.parse(tokeniser)
+ });
+ }
+ }
+
+ constructor({ source, tokens, params }) {
+ super({ source, tokens });
+ Object.defineProperty(this, "params", { value: params });
+ }
+
+ get type() {
+ return "extended-attribute";
+ }
+ get name() {
+ return this.tokens.name.value;
+ }
+ get rhs() {
+ const { rhsType: type, tokens, list } = this.params;
+ if (!type) {
+ return null;
+ }
+ const value = type === "identifier-list" ? list : tokens.secondaryName.value;
+ return { type, value };
+ }
+ get arguments() {
+ const { rhsType, list } = this.params;
+ if (!list || rhsType === "identifier-list") {
+ return [];
+ }
+ return list;
+ }
+
+ *validate(defs) {
+ if (this.name === "NoInterfaceObject") {
+ const message = `\`[NoInterfaceObject]\` extended attribute is an \
+undesirable feature that may be removed from Web IDL in the future. Refer to the \
+[relevant upstream PR](https://github.com/heycam/webidl/pull/609) for more \
+information.`;
+ yield Object(_error_js__WEBPACK_IMPORTED_MODULE_3__["validationError"])(this.source, this.tokens.name, this, message, { level: "warning" });
+ }
+ for (const arg of this.arguments) {
+ yield* arg.validate(defs);
+ }
+ }
+}
-/**
- * @param {string} str
- */
-function tokenise(str) {
- const tokens = [];
- let lastCharIndex = 0;
- let trivia = "";
- let line = 1;
- let index = 0;
- while (lastCharIndex < str.length) {
- const nextChar = str.charAt(lastCharIndex);
- let result = -1;
+// Note: we parse something simpler than the official syntax. It's all that ever
+// seems to be used
+class ExtendedAttributes extends _array_base_js__WEBPACK_IMPORTED_MODULE_1__["ArrayBase"] {
+ /**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ */
+ static parse(tokeniser) {
+ const tokens = {};
+ tokens.open = tokeniser.consume("[");
+ if (!tokens.open) return new ExtendedAttributes({});
+ const ret = new ExtendedAttributes({ source: tokeniser.source, tokens });
+ ret.push(...Object(_helpers_js__WEBPACK_IMPORTED_MODULE_2__["list"])(tokeniser, {
+ parser: SimpleExtendedAttribute.parse,
+ listName: "extended attribute"
+ }));
+ tokens.close = tokeniser.consume("]") || tokeniser.error("Unexpected closing token of extended attribute");
+ if (!ret.length) {
+ tokeniser.error("Found an empty extended attribute");
+ }
+ if (tokeniser.probe("[")) {
+ tokeniser.error("Illegal double extended attribute lists, consider merging them");
+ }
+ return ret;
+ }
- if (/[\t\n\r ]/.test(nextChar)) {
- result = attemptTokenMatch("whitespace", { noFlushTrivia: true });
- } else if (nextChar === '/') {
- result = attemptTokenMatch("comment", { noFlushTrivia: true });
+ *validate(defs) {
+ for (const extAttr of this) {
+ yield* extAttr.validate(defs);
}
+ }
+}
- if (result !== -1) {
- const currentTrivia = tokens.pop().value;
- line += (currentTrivia.match(/\n/g) || []).length;
- trivia += currentTrivia;
- index -= 1;
- } else if (/[-0-9.A-Z_a-z]/.test(nextChar)) {
- result = attemptTokenMatch("decimal");
- if (result === -1) {
- result = attemptTokenMatch("integer");
+
+/***/ }),
+/* 12 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ArrayBase", function() { return ArrayBase; });
+class ArrayBase extends Array {
+ constructor({ source, tokens }) {
+ super();
+ Object.defineProperties(this, {
+ source: { value: source },
+ tokens: { value: tokens }
+ });
+ }
+}
+
+
+/***/ }),
+/* 13 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Token", function() { return Token; });
+/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7);
+
+
+class Token extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
+ /**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ * @param {string} type
+ */
+ static parser(tokeniser, type) {
+ return () => {
+ const value = tokeniser.consume(type);
+ if (value) {
+ return new Token({ source: tokeniser.source, tokens: { value } });
}
- if (result === -1) {
- result = attemptTokenMatch("identifier");
- const token = tokens[tokens.length - 1];
- if (result !== -1 && nonRegexTerminals.includes(token.value)) {
- token.type = token.value;
- }
+ };
+ }
+
+ get value() {
+ return this.tokens.value.value;
+ }
+}
+
+
+/***/ }),
+/* 14 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Operation", function() { return Operation; });
+/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7);
+/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
+
+
+
+class Operation extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
+ /**
+ * @param {import("../tokeniser.js").Tokeniser} tokeniser
+ */
+ static parse(tokeniser, { special, regular } = {}) {
+ const tokens = { special };
+ const ret = new Operation({ source: tokeniser.source, tokens });
+ if (special && special.value === "stringifier") {
+ tokens.termination = tokeniser.consume(";");
+ if (tokens.termination) {
+ ret.arguments = [];
+ return ret;
}
- } else if (nextChar === '"') {
- result = attemptTokenMatch("string");
}
+ if (!special && !regular) {
+ tokens.special = tokeniser.consume("getter", "setter", "deleter");
+ }
+ ret.idlType = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["return_type"])(tokeniser) || tokeniser.error("Missing return type");
+ tokens.name = tokeniser.consume("identifier", "includes");
+ tokens.open = tokeniser.consume("(") || tokeniser.error("Invalid operation");
+ ret.arguments = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["argument_list"])(tokeniser);
+ tokens.close = tokeniser.consume(")") || tokeniser.error("Unterminated operation");
+ tokens.termination = tokeniser.consume(";") || tokeniser.error("Unterminated operation, expected `;`");
+ return ret;
+ }
- for (const punctuation of punctuations) {
- if (str.startsWith(punctuation, lastCharIndex)) {
- tokens.push({ type: punctuation, value: punctuation, trivia, line, index });
- trivia = "";
- lastCharIndex += punctuation.length;
- result = lastCharIndex;
- break;
- }
+ get type() {
+ return "operation";
+ }
+ get name() {
+ const { name } = this.tokens;
+ if (!name) {
+ return "";
+ }
+ return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["unescape"])(name.value);
+ }
+ get special() {
+ if (!this.tokens.special) {
+ return "";
}
+ return this.tokens.special.value;
+ }
- // other as the last try
- if (result === -1) {
- result = attemptTokenMatch("other");
+ *validate(defs) {
+ if (this.idlType) {
+ yield* this.idlType.validate(defs);
}
- if (result === -1) {
- throw new Error("Token stream not progressing");
+ for (const argument of this.arguments) {
+ yield* argument.validate(defs);
}
- lastCharIndex = result;
- index += 1;
}
+}
- // remaining trivia as eof
- tokens.push({
- type: "eof",
- value: "",
- trivia
- });
- return tokens;
+/***/ }),
+/* 15 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Attribute", function() { return Attribute; });
+/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7);
+/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
+
+
+class Attribute extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
/**
- * @param {keyof tokenRe} type
- * @param {object} [options]
- * @param {boolean} [options.noFlushTrivia]
+ * @param {import("../tokeniser.js").Tokeniser} tokeniser
*/
- function attemptTokenMatch(type, { noFlushTrivia } = {}) {
- const re = tokenRe[type];
- re.lastIndex = lastCharIndex;
- const result = re.exec(str);
- if (result) {
- tokens.push({ type, value: result[0], trivia, line, index });
- if (!noFlushTrivia) {
- trivia = "";
- }
- return re.lastIndex;
+ static parse(tokeniser, { special, noInherit = false, readonly = false } = {}) {
+ const start_position = tokeniser.position;
+ const tokens = { special };
+ const ret = new Attribute({ source: tokeniser.source, tokens });
+ if (!special && !noInherit) {
+ tokens.special = tokeniser.consume("inherit");
}
- return -1;
+ if (ret.special === "inherit" && tokeniser.probe("readonly")) {
+ tokeniser.error("Inherited attributes cannot be read-only");
+ }
+ tokens.readonly = tokeniser.consume("readonly");
+ if (readonly && !tokens.readonly && tokeniser.probe("attribute")) {
+ tokeniser.error("Attributes must be readonly in this context");
+ }
+ tokens.base = tokeniser.consume("attribute");
+ if (!tokens.base) {
+ tokeniser.unconsume(start_position);
+ return;
+ }
+ ret.idlType = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["type_with_extended_attributes"])(tokeniser, "attribute-type") || tokeniser.error("Attribute lacks a type");
+ switch (ret.idlType.generic) {
+ case "sequence":
+ case "record": tokeniser.error(`Attributes cannot accept ${ret.idlType.generic} types`);
+ }
+ tokens.name = tokeniser.consume("identifier", "async", "required") || tokeniser.error("Attribute lacks a name");
+ tokens.termination = tokeniser.consume(";") || tokeniser.error("Unterminated attribute, expected `;`");
+ return ret;
+ }
+
+ get type() {
+ return "attribute";
+ }
+ get special() {
+ if (!this.tokens.special) {
+ return "";
+ }
+ return this.tokens.special.value;
+ }
+ get readonly() {
+ return !!this.tokens.readonly;
+ }
+ get name() {
+ return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["unescape"])(this.tokens.name.value);
+ }
+
+ *validate(defs) {
+ yield* this.idlType.validate(defs);
}
}
-class Tokeniser {
+
+/***/ }),
+/* 16 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Includes", function() { return Includes; });
+/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7);
+/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
+
+
+
+class Includes extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
/**
- * @param {string} idl
+ * @param {import("../tokeniser").Tokeniser} tokeniser
*/
- constructor(idl) {
- this.source = tokenise(idl);
- this.position = 0;
+ static parse(tokeniser) {
+ const target = tokeniser.consume("identifier");
+ if (!target) {
+ return;
+ }
+ const tokens = { target };
+ tokens.includes = tokeniser.consume("includes");
+ if (!tokens.includes) {
+ tokeniser.unconsume(target.index);
+ return;
+ }
+ tokens.mixin = tokeniser.consume("identifier") || tokeniser.error("Incomplete includes statement");
+ tokens.termination = tokeniser.consume(";") || tokeniser.error("No terminating ; for includes statement");
+ return new Includes({ source: tokeniser.source, tokens });
+ }
+
+ get type() {
+ return "includes";
+ }
+ get target() {
+ return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["unescape"])(this.tokens.target.value);
+ }
+ get includes() {
+ return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["unescape"])(this.tokens.mixin.value);
}
+}
+
+
+/***/ }),
+/* 17 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Typedef", function() { return Typedef; });
+/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7);
+/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
- /**
- * @param {string} message
- */
- error(message) {
- throw new WebIDLParseError(Object(_error_js__WEBPACK_IMPORTED_MODULE_0__["syntaxError"])(this.source, this.position, this.current, message));
- }
- /**
- * @param {string} type
- */
- probe(type) {
- return this.source.length > this.position && this.source[this.position].type === type;
- }
+class Typedef extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
/**
- * @param {...string} candidates
+ * @param {import("../tokeniser").Tokeniser} tokeniser
*/
- consume(...candidates) {
- for (const type of candidates) {
- if (!this.probe(type)) continue;
- const token = this.source[this.position];
- this.position++;
- return token;
+ static parse(tokeniser) {
+ const tokens = {};
+ const ret = new Typedef({ source: tokeniser.source, tokens });
+ tokens.base = tokeniser.consume("typedef");
+ if (!tokens.base) {
+ return;
}
+ ret.idlType = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["type_with_extended_attributes"])(tokeniser, "typedef-type") || tokeniser.error("Typedef lacks a type");
+ tokens.name = tokeniser.consume("identifier") || tokeniser.error("Typedef lacks a name");
+ tokeniser.current = ret;
+ tokens.termination = tokeniser.consume(";") || tokeniser.error("Unterminated typedef, expected `;`");
+ return ret;
}
- /**
- * @param {number} position
- */
- unconsume(position) {
- this.position = position;
+ get type() {
+ return "typedef";
+ }
+ get name() {
+ return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["unescape"])(this.tokens.name.value);
}
-}
-class WebIDLParseError extends Error {
- constructor({ message, line, input, tokens }) {
- super(message);
- this.name = "WebIDLParseError"; // not to be mangled
- this.line = line;
- this.input = input;
- this.tokens = tokens;
+ *validate(defs) {
+ yield* this.idlType.validate(defs);
}
}
/***/ }),
-/* 6 */
+/* 18 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "syntaxError", function() { return syntaxError; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "validationError", function() { return validationError; });
-/**
- * @param {string} text
- */
-function lastLine(text) {
- const splitted = text.split("\n");
- return splitted[splitted.length - 1];
-}
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CallbackFunction", function() { return CallbackFunction; });
+/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7);
+/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
-/**
- * @param {string} message error message
- * @param {"Syntax" | "Validation"} type error type
- */
-function error(source, position, current, message, type) {
+
+
+class CallbackFunction extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
/**
- * @param {number} count
+ * @param {import("../tokeniser.js").Tokeniser} tokeniser
*/
- function sliceTokens(count) {
- return count > 0 ?
- source.slice(position, position + count) :
- source.slice(Math.max(position + count, 0), position);
+ static parse(tokeniser, base) {
+ const tokens = { base };
+ const ret = new CallbackFunction({ source: tokeniser.source, tokens });
+ tokens.name = tokeniser.consume("identifier") || tokeniser.error("Callback lacks a name");
+ tokeniser.current = ret;
+ tokens.assign = tokeniser.consume("=") || tokeniser.error("Callback lacks an assignment");
+ ret.idlType = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["return_type"])(tokeniser) || tokeniser.error("Callback lacks a return type");
+ tokens.open = tokeniser.consume("(") || tokeniser.error("Callback lacks parentheses for arguments");
+ ret.arguments = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["argument_list"])(tokeniser);
+ tokens.close = tokeniser.consume(")") || tokeniser.error("Unterminated callback");
+ tokens.termination = tokeniser.consume(";") || tokeniser.error("Unterminated callback, expected `;`");
+ return ret;
}
- function tokensToText(inputs, { precedes } = {}) {
- const text = inputs.map(t => t.trivia + t.value).join("");
- const nextToken = source[position];
- if (nextToken.type === "eof") {
- return text;
- }
- if (precedes) {
- return text + nextToken.trivia;
- }
- return text.slice(nextToken.trivia.length);
+ get type() {
+ return "callback";
+ }
+ get name() {
+ return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["unescape"])(this.tokens.name.value);
}
- const maxTokens = 5; // arbitrary but works well enough
- const line =
- source[position].type !== "eof" ? source[position].line :
- source.length > 1 ? source[position - 1].line :
- 1;
-
- const precedingLine = lastLine(
- tokensToText(sliceTokens(-maxTokens), { precedes: true })
- );
-
- const subsequentTokens = sliceTokens(maxTokens);
- const subsequentText = tokensToText(subsequentTokens);
- const sobsequentLine = subsequentText.split("\n")[0];
-
- const spaced = " ".repeat(precedingLine.length) + "^ " + message;
- const contextualMessage = precedingLine + sobsequentLine + "\n" + spaced;
-
- const contextType = type === "Syntax" ? "since" : "inside";
- const grammaticalContext = current ? `, ${contextType} \`${current.partial ? "partial " : ""}${current.type} ${current.name}\`` : "";
- return {
- message: `${type} error at line ${line}${grammaticalContext}:\n${contextualMessage}`,
- line,
- input: subsequentText,
- tokens: subsequentTokens
- };
-}
-
-/**
- * @param {string} message error message
- */
-function syntaxError(source, position, current, message) {
- return error(source, position, current, message, "Syntax");
-}
-
-/**
- * @param {string} message error message
- */
-function validationError(source, token, current, message) {
- return error(source, token.index, current, message, "Validation").message;
+ *validate(defs) {
+ yield* this.idlType.validate(defs);
+ }
}
/***/ }),
-/* 7 */
+/* 19 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Argument", function() { return Argument; });
-/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4);
-/* harmony import */ var _default_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(8);
-/* harmony import */ var _extended_attributes_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9);
-/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(2);
-/* harmony import */ var _tokeniser_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(5);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Interface", function() { return Interface; });
+/* harmony import */ var _container_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(20);
+/* harmony import */ var _attribute_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(15);
+/* harmony import */ var _operation_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(14);
+/* harmony import */ var _constant_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(21);
+/* harmony import */ var _iterable_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(22);
+/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(5);
+/* harmony import */ var _error_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(3);
+/* harmony import */ var _validators_interface_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(23);
-class Argument extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
+
+
+
+/**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ */
+function static_member(tokeniser) {
+ const special = tokeniser.consume("static");
+ if (!special) return;
+ const member = _attribute_js__WEBPACK_IMPORTED_MODULE_1__["Attribute"].parse(tokeniser, { special }) ||
+ _operation_js__WEBPACK_IMPORTED_MODULE_2__["Operation"].parse(tokeniser, { special }) ||
+ tokeniser.error("No body in static member");
+ return member;
+}
+
+class Interface extends _container_js__WEBPACK_IMPORTED_MODULE_0__["Container"] {
/**
* @param {import("../tokeniser").Tokeniser} tokeniser
*/
- static parse(tokeniser) {
- const start_position = tokeniser.position;
- const tokens = {};
- const ret = new Argument({ source: tokeniser.source, tokens });
- ret.extAttrs = _extended_attributes_js__WEBPACK_IMPORTED_MODULE_2__["ExtendedAttributes"].parse(tokeniser);
- tokens.optional = tokeniser.consume("optional");
- ret.idlType = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_3__["type_with_extended_attributes"])(tokeniser, "argument-type");
- if (!ret.idlType) {
- return tokeniser.unconsume(start_position);
- }
- if (!tokens.optional) {
- tokens.variadic = tokeniser.consume("...");
- }
- tokens.name = tokeniser.consume("identifier", ..._tokeniser_js__WEBPACK_IMPORTED_MODULE_4__["argumentNameKeywords"]);
- if (!tokens.name) {
- return tokeniser.unconsume(start_position);
- }
- ret.default = tokens.optional ? _default_js__WEBPACK_IMPORTED_MODULE_1__["Default"].parse(tokeniser) : null;
- return ret;
+ static parse(tokeniser, base, { partial = null } = {}) {
+ const tokens = { partial, base };
+ return _container_js__WEBPACK_IMPORTED_MODULE_0__["Container"].parse(tokeniser, new Interface({ source: tokeniser.source, tokens }), {
+ type: "interface",
+ inheritable: !partial,
+ allowedMembers: [
+ [_constant_js__WEBPACK_IMPORTED_MODULE_3__["Constant"].parse],
+ [static_member],
+ [_helpers_js__WEBPACK_IMPORTED_MODULE_5__["stringifier"]],
+ [_iterable_js__WEBPACK_IMPORTED_MODULE_4__["IterableLike"].parse],
+ [_attribute_js__WEBPACK_IMPORTED_MODULE_1__["Attribute"].parse],
+ [_operation_js__WEBPACK_IMPORTED_MODULE_2__["Operation"].parse]
+ ]
+ });
}
- get optional() {
- return !!this.tokens.optional;
- }
- get variadic() {
- return !!this.tokens.variadic;
+ get type() {
+ return "interface";
}
- get name() {
- return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_3__["unescape"])(this.tokens.name.value);
+
+ *validate(defs) {
+ yield* this.extAttrs.validate(defs);
+ if (
+ !this.partial &&
+ this.extAttrs.every(extAttr => extAttr.name !== "Exposed") &&
+ this.extAttrs.every(extAttr => extAttr.name !== "NoInterfaceObject")
+ ) {
+ const message = `Interfaces must have \`[Exposed]\` extended attribute. \
+To fix, add, for example, \`[Exposed=Window]\`. Please also consider carefully \
+if your interface should also be exposed in a Worker scope. Refer to the \
+[WebIDL spec section on Exposed](https://heycam.github.io/webidl/#Exposed) \
+for more information.`;
+ yield Object(_error_js__WEBPACK_IMPORTED_MODULE_6__["validationError"])(this.source, this.tokens.name, this, message);
+ }
+
+ yield* super.validate(defs);
+ if (!this.partial) {
+ yield* Object(_validators_interface_js__WEBPACK_IMPORTED_MODULE_7__["checkInterfaceMemberDuplication"])(defs, this);
+ }
}
}
/***/ }),
-/* 8 */
+/* 20 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Default", function() { return Default; });
-/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4);
-/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Container", function() { return Container; });
+/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7);
+/* harmony import */ var _extended_attributes_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(11);
+/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5);
-class Default extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
- /**
- * @param {import("../tokeniser").Tokeniser} tokeniser
- */
- static parse(tokeniser) {
- const assign = tokeniser.consume("=");
- if (!assign) {
- return null;
- }
- const def = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["const_value"])(tokeniser) || tokeniser.consume("string", "null", "[", "{") || tokeniser.error("No value for default");
- const expression = [def];
- if (def.type === "[") {
- const close = tokeniser.consume("]") || tokeniser.error("Default sequence value must be empty");
- expression.push(close);
- } else if (def.type === "{") {
- const close = tokeniser.consume("}") || tokeniser.error("Default dictionary value must be empty");
- expression.push(close);
- }
- return new Default({ source: tokeniser.source, tokens: { assign }, expression });
- }
- constructor({ source, tokens, expression }) {
- super({ source, tokens });
- Object.defineProperty(this, "expression", { value: expression });
+/**
+ * @param {import("../tokeniser.js").Tokeniser} tokeniser
+ */
+function inheritance(tokeniser) {
+ const colon = tokeniser.consume(":");
+ if (!colon) {
+ return {};
}
+ const inheritance = tokeniser.consume("identifier") || tokeniser.error("Inheritance lacks a type");
+ return { colon, inheritance };
+}
- get type() {
- return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["const_data"])(this.expression[0]).type;
- }
- get value() {
- return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["const_data"])(this.expression[0]).value;
- }
- get negative() {
- return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["const_data"])(this.expression[0]).negative;
+class Container extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
+ /**
+ * @param {import("../tokeniser.js").Tokeniser} tokeniser
+ * @param {*} instance
+ * @param {*} args
+ */
+ static parse(tokeniser, instance, { type, inheritable, allowedMembers }) {
+ const { tokens } = instance;
+ tokens.name = tokeniser.consume("identifier") || tokeniser.error(`Missing name in ${instance.type}`);
+ tokeniser.current = instance;
+ if (inheritable) {
+ Object.assign(tokens, inheritance(tokeniser));
+ }
+ tokens.open = tokeniser.consume("{") || tokeniser.error(`Bodyless ${type}`);
+ instance.members = [];
+ while (true) {
+ tokens.close = tokeniser.consume("}");
+ if (tokens.close) {
+ tokens.termination = tokeniser.consume(";") || tokeniser.error(`Missing semicolon after ${type}`);
+ return instance;
+ }
+ const ea = _extended_attributes_js__WEBPACK_IMPORTED_MODULE_1__["ExtendedAttributes"].parse(tokeniser);
+ let mem;
+ for (const [parser, ...args] of allowedMembers) {
+ mem = parser(tokeniser, ...args);
+ if (mem) {
+ break;
+ }
+ }
+ if (!mem) {
+ tokeniser.error("Unknown member");
+ }
+ mem.extAttrs = ea;
+ instance.members.push(mem);
+ }
+ }
+
+ get partial() {
+ return !!this.tokens.partial;
+ }
+ get name() {
+ return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_2__["unescape"])(this.tokens.name.value);
+ }
+ get inheritance() {
+ if (!this.tokens.inheritance) {
+ return null;
+ }
+ return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_2__["unescape"])(this.tokens.inheritance.value);
+ }
+
+ *validate(defs) {
+ for (const member of this.members) {
+ if (member.validate) {
+ yield* member.validate(defs);
+ }
+ }
+ }
}
-}
/***/ }),
-/* 9 */
+/* 21 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ExtendedAttributes", function() { return ExtendedAttributes; });
-/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4);
-/* harmony import */ var _array_base_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(10);
-/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Constant", function() { return Constant; });
+/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7);
+/* harmony import */ var _type_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6);
+/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5);
-class ExtendedAttributeParameters extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
+class Constant extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
/**
- * @param {import("../tokeniser").Tokeniser} tokeniser
+ * @param {import("../tokeniser.js").Tokeniser} tokeniser
*/
static parse(tokeniser) {
- const tokens = { assign: tokeniser.consume("=") };
- const ret = new ExtendedAttributeParameters({ source: tokeniser.source, tokens });
- if (tokens.assign) {
- tokens.secondaryName = tokeniser.consume("identifier", "decimal", "integer", "string");
- }
- tokens.open = tokeniser.consume("(");
- if (tokens.open) {
- ret.list = ret.rhsType === "identifier-list" ?
- // [Exposed=(Window,Worker)]
- Object(_helpers_js__WEBPACK_IMPORTED_MODULE_2__["identifiers"])(tokeniser) :
- // [NamedConstructor=Audio(DOMString src)] or [Constructor(DOMString str)]
- Object(_helpers_js__WEBPACK_IMPORTED_MODULE_2__["argument_list"])(tokeniser);
- tokens.close = tokeniser.consume(")") || tokeniser.error("Unexpected token in extended attribute argument list");
- } else if (ret.hasRhs && !tokens.secondaryName) {
- tokeniser.error("No right hand side to extended attribute assignment");
+ const tokens = {};
+ tokens.base = tokeniser.consume("const");
+ if (!tokens.base) {
+ return;
}
+ let idlType = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_2__["primitive_type"])(tokeniser);
+ if (!idlType) {
+ const base = tokeniser.consume("identifier") || tokeniser.error("Const lacks a type");
+ idlType = new _type_js__WEBPACK_IMPORTED_MODULE_1__["Type"]({ source: tokeniser.source, tokens: { base } });
+ }
+ if (tokeniser.probe("?")) {
+ tokeniser.error("Unexpected nullable constant type");
+ }
+ idlType.type = "const-type";
+ tokens.name = tokeniser.consume("identifier") || tokeniser.error("Const lacks a name");
+ tokens.assign = tokeniser.consume("=") || tokeniser.error("Const lacks value assignment");
+ tokens.value = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_2__["const_value"])(tokeniser) || tokeniser.error("Const lacks a value");
+ tokens.termination = tokeniser.consume(";") || tokeniser.error("Unterminated const, expected `;`");
+ const ret = new Constant({ source: tokeniser.source, tokens });
+ ret.idlType = idlType;
return ret;
}
- get rhsType() {
- return !this.tokens.assign ? null :
- !this.tokens.secondaryName ? "identifier-list" :
- this.tokens.secondaryName.type;
+ get type() {
+ return "const";
+ }
+ get name() {
+ return unescape(this.tokens.name.value);
+ }
+ get value() {
+ return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_2__["const_data"])(this.tokens.value);
}
}
-class SimpleExtendedAttribute extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
+
+/***/ }),
+/* 22 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "IterableLike", function() { return IterableLike; });
+/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7);
+/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
+
+
+
+class IterableLike extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
/**
- * @param {import("../tokeniser").Tokeniser} tokeniser
+ * @param {import("../tokeniser.js").Tokeniser} tokeniser
*/
static parse(tokeniser) {
- const name = tokeniser.consume("identifier");
- if (name) {
- return new SimpleExtendedAttribute({
- tokens: { name },
- params: ExtendedAttributeParameters.parse(tokeniser)
- });
+ const start_position = tokeniser.position;
+ const tokens = {};
+ const ret = new IterableLike({ source: tokeniser.source, tokens });
+ tokens.readonly = tokeniser.consume("readonly");
+ if (!tokens.readonly) {
+ tokens.async = tokeniser.consume("async");
+ }
+ tokens.base =
+ tokens.readonly ? tokeniser.consume("maplike", "setlike") :
+ tokens.async ? tokeniser.consume("iterable") :
+ tokeniser.consume("iterable", "maplike", "setlike");
+ if (!tokens.base) {
+ tokeniser.unconsume(start_position);
+ return;
}
- }
- constructor({ source, tokens, params }) {
- super({ source, tokens });
- Object.defineProperty(this, "params", { value: params });
+ const { type } = ret;
+ const secondTypeRequired = type === "maplike" || ret.async;
+ const secondTypeAllowed = secondTypeRequired || type === "iterable";
+
+ tokens.open = tokeniser.consume("<") || tokeniser.error(`Missing less-than sign \`<\` in ${type} declaration`);
+ const first = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["type_with_extended_attributes"])(tokeniser) || tokeniser.error(`Missing a type argument in ${type} declaration`);
+ ret.idlType = [first];
+ if (secondTypeAllowed) {
+ first.tokens.separator = tokeniser.consume(",");
+ if (first.tokens.separator) {
+ ret.idlType.push(Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["type_with_extended_attributes"])(tokeniser));
+ }
+ else if (secondTypeRequired) {
+ tokeniser.error(`Missing second type argument in ${type} declaration`);
+ }
+ }
+ tokens.close = tokeniser.consume(">") || tokeniser.error(`Missing greater-than sign \`>\` in ${type} declaration`);
+ tokens.termination = tokeniser.consume(";") || tokeniser.error(`Missing semicolon after ${type} declaration`);
+
+ return ret;
}
get type() {
- return "extended-attribute";
+ return this.tokens.base.value;
}
- get name() {
- return this.tokens.name.value;
- }
- get rhs() {
- const { rhsType: type, tokens, list } = this.params;
- if (!type) {
- return null;
- }
- const value = type === "identifier-list" ? list : tokens.secondaryName.value;
- return { type, value };
+ get readonly() {
+ return !!this.tokens.readonly;
}
- get arguments() {
- const { rhsType, list } = this.params;
- if (!list || rhsType === "identifier-list") {
- return [];
- }
- return list;
+ get async() {
+ return !!this.tokens.async;
}
}
-// Note: we parse something simpler than the official syntax. It's all that ever
-// seems to be used
-class ExtendedAttributes extends _array_base_js__WEBPACK_IMPORTED_MODULE_1__["ArrayBase"] {
- /**
- * @param {import("../tokeniser").Tokeniser} tokeniser
- */
- static parse(tokeniser) {
- const tokens = {};
- tokens.open = tokeniser.consume("[");
- if (!tokens.open) return [];
- const ret = new ExtendedAttributes({ source: tokeniser.source, tokens });
- ret.push(...Object(_helpers_js__WEBPACK_IMPORTED_MODULE_2__["list"])(tokeniser, {
- parser: SimpleExtendedAttribute.parse,
- listName: "extended attribute"
- }));
- tokens.close = tokeniser.consume("]") || tokeniser.error("Unexpected closing token of extended attribute");
- if (!ret.length) {
- tokeniser.error("Found an empty extended attribute");
+
+/***/ }),
+/* 23 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "checkInterfaceMemberDuplication", function() { return checkInterfaceMemberDuplication; });
+/* harmony import */ var _error_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3);
+
+
+function* checkInterfaceMemberDuplication(defs, i) {
+ const opNames = new Set(getOperations(i).map(op => op.name));
+ const partials = defs.partials.get(i.name) || [];
+ const mixins = defs.mixinMap.get(i.name) || [];
+ for (const ext of [...partials, ...mixins]) {
+ const additions = getOperations(ext);
+ yield* forEachExtension(additions, opNames, ext, i);
+ for (const addition of additions) {
+ opNames.add(addition.name);
}
- if (tokeniser.probe("[")) {
- tokeniser.error("Illegal double extended attribute lists, consider merging them");
+ }
+
+ function* forEachExtension(additions, existings, ext, base) {
+ for (const addition of additions) {
+ const { name } = addition;
+ if (name && existings.has(name)) {
+ const message = `The operation "${name}" has already been defined for the base interface "${base.name}" either in itself or in a mixin`;
+ yield Object(_error_js__WEBPACK_IMPORTED_MODULE_0__["validationError"])(ext.source, addition.tokens.name, ext, message);
+ }
}
- return ret;
+ }
+
+ function getOperations(i) {
+ return i.members
+ .filter(({type}) => type === "operation");
}
}
/***/ }),
-/* 10 */
+/* 24 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ArrayBase", function() { return ArrayBase; });
-class ArrayBase extends Array {
- constructor({ source, tokens }) {
- super();
- Object.defineProperties(this, {
- source: { value: source },
- tokens: { value: tokens }
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Mixin", function() { return Mixin; });
+/* harmony import */ var _container_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(20);
+/* harmony import */ var _constant_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(21);
+/* harmony import */ var _attribute_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(15);
+/* harmony import */ var _operation_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(14);
+/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(5);
+
+
+
+
+
+
+class Mixin extends _container_js__WEBPACK_IMPORTED_MODULE_0__["Container"] {
+ /**
+ * @param {import("../tokeniser").Tokeniser} tokeniser
+ */
+ static parse(tokeniser, base, { partial } = {}) {
+ const tokens = { partial, base };
+ tokens.mixin = tokeniser.consume("mixin");
+ if (!tokens.mixin) {
+ return;
+ }
+ return _container_js__WEBPACK_IMPORTED_MODULE_0__["Container"].parse(tokeniser, new Mixin({ source: tokeniser.source, tokens }), {
+ type: "interface mixin",
+ allowedMembers: [
+ [_constant_js__WEBPACK_IMPORTED_MODULE_1__["Constant"].parse],
+ [_helpers_js__WEBPACK_IMPORTED_MODULE_4__["stringifier"]],
+ [_attribute_js__WEBPACK_IMPORTED_MODULE_2__["Attribute"].parse, { noInherit: true }],
+ [_operation_js__WEBPACK_IMPORTED_MODULE_3__["Operation"].parse, { regular: true }]
+ ]
});
}
+
+ get type() {
+ return "interface mixin";
+ }
}
/***/ }),
-/* 11 */
+/* 25 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Token", function() { return Token; });
-/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Dictionary", function() { return Dictionary; });
+/* harmony import */ var _container_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(20);
+/* harmony import */ var _field_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(26);
-class Token extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
+
+class Dictionary extends _container_js__WEBPACK_IMPORTED_MODULE_0__["Container"] {
/**
* @param {import("../tokeniser").Tokeniser} tokeniser
- * @param {string} type
*/
- static parser(tokeniser, type) {
- return () => {
- const value = tokeniser.consume(type);
- if (value) {
- return new Token({ source: tokeniser.source, tokens: { value } });
- }
- };
+ static parse(tokeniser, { partial } = {}) {
+ const tokens = { partial };
+ tokens.base = tokeniser.consume("dictionary");
+ if (!tokens.base) {
+ return;
+ }
+ return _container_js__WEBPACK_IMPORTED_MODULE_0__["Container"].parse(tokeniser, new Dictionary({ source: tokeniser.source, tokens }), {
+ type: "dictionary",
+ inheritable: !partial,
+ allowedMembers: [
+ [_field_js__WEBPACK_IMPORTED_MODULE_1__["Field"].parse],
+ ]
+ });
}
- get value() {
- return this.tokens.value.value;
+ get type() {
+ return "dictionary";
}
}
/***/ }),
-/* 12 */
+/* 26 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Enum", function() { return Enum; });
-/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
-/* harmony import */ var _token_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(11);
-/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(4);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Field", function() { return Field; });
+/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7);
+/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
+/* harmony import */ var _extended_attributes_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(11);
+/* harmony import */ var _default_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(10);
-class EnumValue extends _token_js__WEBPACK_IMPORTED_MODULE_1__["Token"] {
+
+class Field extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
/**
* @param {import("../tokeniser").Tokeniser} tokeniser
*/
static parse(tokeniser) {
- const value = tokeniser.consume("string");
- if (value) {
- return new EnumValue({ source: tokeniser.source, tokens: { value } });
- }
+ const tokens = {};
+ const ret = new Field({ source: tokeniser.source, tokens });
+ ret.extAttrs = _extended_attributes_js__WEBPACK_IMPORTED_MODULE_2__["ExtendedAttributes"].parse(tokeniser);
+ tokens.required = tokeniser.consume("required");
+ ret.idlType = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["type_with_extended_attributes"])(tokeniser, "dictionary-type") || tokeniser.error("Dictionary member lacks a type");
+ tokens.name = tokeniser.consume("identifier") || tokeniser.error("Dictionary member lacks a name");
+ ret.default = _default_js__WEBPACK_IMPORTED_MODULE_3__["Default"].parse(tokeniser);
+ if (tokens.required && ret.default) tokeniser.error("Required member must not have a default");
+ tokens.termination = tokeniser.consume(";") || tokeniser.error("Unterminated dictionary member, expected `;`");
+ return ret;
}
get type() {
- return "enum-value";
+ return "field";
}
- get value() {
- return super.value.slice(1, -1);
+ get name() {
+ return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["unescape"])(this.tokens.name.value);
+ }
+ get required() {
+ return !!this.tokens.required;
+ }
+
+ *validate(defs) {
+ yield* this.idlType.validate(defs);
}
}
-class Enum extends _base_js__WEBPACK_IMPORTED_MODULE_2__["Base"] {
+
+/***/ }),
+/* 27 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Namespace", function() { return Namespace; });
+/* harmony import */ var _container_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(20);
+/* harmony import */ var _attribute_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(15);
+/* harmony import */ var _operation_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(14);
+/* harmony import */ var _error_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(3);
+
+
+
+
+
+class Namespace extends _container_js__WEBPACK_IMPORTED_MODULE_0__["Container"] {
/**
* @param {import("../tokeniser").Tokeniser} tokeniser
*/
- static parse(tokeniser) {
- const tokens = {};
- tokens.base = tokeniser.consume("enum");
+ static parse(tokeniser, { partial } = {}) {
+ const tokens = { partial };
+ tokens.base = tokeniser.consume("namespace");
if (!tokens.base) {
return;
}
- tokens.name = tokeniser.consume("identifier") || tokeniser.error("No name for enum");
- const ret = tokeniser.current = new Enum({ source: tokeniser.source, tokens });
- tokens.open = tokeniser.consume("{") || tokeniser.error("Bodyless enum");
- ret.values = Object(_helpers_js__WEBPACK_IMPORTED_MODULE_0__["list"])(tokeniser, {
- parser: EnumValue.parse,
- allowDangler: true,
- listName: "enumeration"
+ return _container_js__WEBPACK_IMPORTED_MODULE_0__["Container"].parse(tokeniser, new Namespace({ source: tokeniser.source, tokens }), {
+ type: "namespace",
+ allowedMembers: [
+ [_attribute_js__WEBPACK_IMPORTED_MODULE_1__["Attribute"].parse, { noInherit: true, readonly: true }],
+ [_operation_js__WEBPACK_IMPORTED_MODULE_2__["Operation"].parse, { regular: true }]
+ ]
});
- if (tokeniser.probe("string")) {
- tokeniser.error("No comma between enum values");
- }
- tokens.close = tokeniser.consume("}") || tokeniser.error("Unexpected value in enum");
- if (!ret.values.length) {
- tokeniser.error("No value in enum");
- }
- tokens.termination = tokeniser.consume(";") || tokeniser.error("No semicolon after enum");
- return ret;
}
get type() {
- return "enum";
+ return "namespace";
}
- get name() {
- return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_0__["unescape"])(this.tokens.name.value);
+
+ *validate(defs) {
+ if (!this.partial && this.extAttrs.every(extAttr => extAttr.name !== "Exposed")) {
+ const message = `Namespaces must have [Exposed] extended attribute. \
+To fix, add, for example, [Exposed=Window]. Please also consider carefully \
+if your namespace should also be exposed in a Worker scope. Refer to the \
+[WebIDL spec section on Exposed](https://heycam.github.io/webidl/#Exposed) \
+for more information.`;
+ yield Object(_error_js__WEBPACK_IMPORTED_MODULE_3__["validationError"])(this.source, this.tokens.name, this, message);
+ }
+ yield* super.validate(defs);
}
}
/***/ }),
-/* 13 */
+/* 28 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Includes", function() { return Includes; });
-/* harmony import */ var _base_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4);
-/* harmony import */ var _helpers_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CallbackInterface", function() { return CallbackInterface; });
+/* harmony import */ var _container_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(20);
+/* harmony import */ var _operation_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(14);
+/* harmony import */ var _constant_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(21);
-class Includes extends _base_js__WEBPACK_IMPORTED_MODULE_0__["Base"] {
+
+
+class CallbackInterface extends _container_js__WEBPACK_IMPORTED_MODULE_0__["Container"] {
/**
* @param {import("../tokeniser").Tokeniser} tokeniser
*/
- static parse(tokeniser) {
- const target = tokeniser.consume("identifier");
- if (!target) {
- return;
- }
- const tokens = { target };
- tokens.includes = tokeniser.consume("includes");
- if (!tokens.includes) {
- tokeniser.unconsume(target.index);
+ static parse(tokeniser, callback, { partial = null } = {}) {
+ const tokens = { callback };
+ tokens.base = tokeniser.consume("interface");
+ if (!tokens.base) {
return;
}
- tokens.mixin = tokeniser.consume("identifier") || tokeniser.error("Incomplete includes statement");
- tokens.termination = tokeniser.consume(";") || tokeniser.error("No terminating ; for includes statement");
- return new Includes({ source: tokeniser.source, tokens });
+ return _container_js__WEBPACK_IMPORTED_MODULE_0__["Container"].parse(tokeniser, new CallbackInterface({ source: tokeniser.source, tokens }), {
+ type: "callback interface",
+ inheritable: !partial,
+ allowedMembers: [
+ [_constant_js__WEBPACK_IMPORTED_MODULE_2__["Constant"].parse],
+ [_operation_js__WEBPACK_IMPORTED_MODULE_1__["Operation"].parse, { regular: true }]
+ ]
+ });
}
get type() {
- return "includes";
- }
- get target() {
- return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["unescape"])(this.tokens.target.value);
- }
- get includes() {
- return Object(_helpers_js__WEBPACK_IMPORTED_MODULE_1__["unescape"])(this.tokens.mixin.value);
+ return "callback interface";
}
}
/***/ }),
-/* 14 */
+/* 29 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
@@ -1977,6 +2520,7 @@ function write(ast, { templates: ts = templates } = {}) {
return ts.definition(ts.wrap([
extended_attributes(it.extAttrs),
token(it.tokens.readonly),
+ token(it.tokens.async),
token(it.tokens.base, ts.generic),
token(it.tokens.open),
ts.wrap(it.idlType.map(type)),
@@ -2026,17 +2570,35 @@ function write(ast, { templates: ts = templates } = {}) {
/***/ }),
-/* 15 */
+/* 30 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "validate", function() { return validate; });
-/* harmony import */ var _error_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6);
+/* harmony import */ var _error_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3);
+function getMixinMap(all, unique) {
+ const map = new Map();
+ const includes = all.filter(def => def.type === "includes");
+ for (const include of includes) {
+ const mixin = unique.get(include.includes);
+ if (!mixin) {
+ continue;
+ }
+ const array = map.get(include.target);
+ if (array) {
+ array.push(mixin);
+ } else {
+ map.set(include.target, [mixin]);
+ }
+ }
+ return map;
+}
+
function groupDefinitions(all) {
const unique = new Map();
const duplicates = new Set();
@@ -2060,7 +2622,16 @@ function groupDefinitions(all) {
duplicates.add(def);
}
}
- return { all, unique, partials, duplicates };
+ return {
+ all,
+ unique,
+ partials,
+ duplicates,
+ mixinMap: getMixinMap(all, unique),
+ cache: {
+ typedefIncludesDictionary: new WeakMap()
+ },
+ };
}
function* checkDuplicatedNames({ unique, duplicates }) {
@@ -2071,67 +2642,29 @@ function* checkDuplicatedNames({ unique, duplicates }) {
}
}
-function* checkInterfaceMemberDuplication(defs) {
- const interfaces = [...defs.unique.values()].filter(def => def.type === "interface");
- const includesMap = getIncludesMap();
-
- for (const i of interfaces) {
- yield* forEachInterface(i);
- }
-
- function* forEachInterface(i) {
- const opNames = new Set(getOperations(i).map(op => op.name));
- const partials = defs.partials.get(i.name) || [];
- const mixins = includesMap.get(i.name) || [];
- for (const ext of [...partials, ...mixins]) {
- const additions = getOperations(ext);
- yield* forEachExtension(additions, opNames, ext, i);
- for (const addition of additions) {
- opNames.add(addition.name);
- }
- }
- }
-
- function* forEachExtension(additions, existings, ext, base) {
- for (const addition of additions) {
- const { name } = addition;
- if (name && existings.has(name)) {
- const message = `The operation "${name}" has already been defined for the base interface "${base.name}" either in itself or in a mixin`;
- yield Object(_error_js__WEBPACK_IMPORTED_MODULE_0__["validationError"])(ext.source, addition.tokens.name, ext, message);
- }
+function* validateIterable(ast) {
+ const defs = groupDefinitions(ast);
+ for (const def of defs.all) {
+ if (def.validate) {
+ yield* def.validate(defs);
}
}
+ yield* checkDuplicatedNames(defs);
+}
- function getOperations(i) {
- return i.members
- .filter(({type}) => type === "operation");
- }
-
- function getIncludesMap() {
- const map = new Map();
- const includes = defs.all.filter(def => def.type === "includes");
- for (const include of includes) {
- const array = map.get(include.target);
- const mixin = defs.unique.get(include.includes);
- if (!mixin) {
- continue;
- }
- if (array) {
- array.push(mixin);
- } else {
- map.set(include.target, [mixin]);
- }
- }
- return map;
+// Remove this once all of our support targets expose `.flat()` by default
+function flatten(array) {
+ if (array.flat) {
+ return array.flat();
}
+ return [].concat(...array);
}
+/**
+ * @param {*} ast AST or array of ASTs
+ */
function validate(ast) {
- const defs = groupDefinitions(ast);
- return [
- ...checkDuplicatedNames(defs),
- ...checkInterfaceMemberDuplication(defs)
- ];
+ return [...validateIterable(flatten(ast))];
}
diff --git a/tests/wpt/web-platform-tests/service-workers/service-worker/resources/update-during-installation-worker.js b/tests/wpt/web-platform-tests/service-workers/service-worker/resources/update-during-installation-worker.js
index 3f89881c0438..f1997bd824e8 100644
--- a/tests/wpt/web-platform-tests/service-workers/service-worker/resources/update-during-installation-worker.js
+++ b/tests/wpt/web-platform-tests/service-workers/service-worker/resources/update-during-installation-worker.js
@@ -14,6 +14,9 @@ addEventListener('install', event => {
});
addEventListener('message', event => {
+ let resolveWaitUntil;
+ event.waitUntil(new Promise(resolve => { resolveWaitUntil = resolve; }));
+
// Use a dedicated MessageChannel for every request so senders can wait for
// individual requests to finish, and concurrent requests (to different
// workers) don't cause race conditions.
@@ -23,13 +26,13 @@ addEventListener('message', event => {
case 'awaitInstallEvent':
installEventFired.then(() => {
port.postMessage('installEventFired');
- });
+ }).finally(resolveWaitUntil);
break;
case 'finishInstall':
installFinished.then(() => {
port.postMessage('installFinished');
- });
+ }).finally(resolveWaitUntil);
finishInstall();
break;
@@ -44,13 +47,14 @@ addEventListener('message', event => {
success: false,
exception: exception.name,
});
- });
+ }).finally(resolveWaitUntil);
port.postMessage(channel.port1, [channel.port1]);
break;
}
default:
port.postMessage('Unexpected command ' + event.data);
+ resolveWaitUntil();
break;
}
};
diff --git a/tests/wpt/web-platform-tests/shadow-dom/focus/DocumentOrShadowRoot-activeElement.html b/tests/wpt/web-platform-tests/shadow-dom/focus/DocumentOrShadowRoot-activeElement.html
new file mode 100644
index 000000000000..20456b057e1e
--- /dev/null
+++ b/tests/wpt/web-platform-tests/shadow-dom/focus/DocumentOrShadowRoot-activeElement.html
@@ -0,0 +1,92 @@
+
+
+
HTML Test: DocumentOrShadowRoot.activeElement
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-negative.html b/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-negative.html
new file mode 100644
index 000000000000..ab25ea829bd1
--- /dev/null
+++ b/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-negative.html
@@ -0,0 +1,34 @@
+
+
+
HTML Test: focus - the sequential focus navigation order with shadow dom and negative tabindex in shadow scope
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-slot-one.html b/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-slot-one.html
new file mode 100644
index 000000000000..3c9e70867c58
--- /dev/null
+++ b/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-slot-one.html
@@ -0,0 +1,37 @@
+
+
+
HTML Test: focus - the sequential focus navigation order with shadow dom and all tabindex=0 except for one of the slot
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-varying-tabindex.html b/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-varying-tabindex.html
new file mode 100644
index 000000000000..875e5b6814a9
--- /dev/null
+++ b/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-varying-tabindex.html
@@ -0,0 +1,36 @@
+
+
+
HTML Test: focus - the sequential focus navigation order with shadow dom with varying tabindex values
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-zero-host-negative.html b/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-zero-host-negative.html
new file mode 100644
index 000000000000..b491c7d237c2
--- /dev/null
+++ b/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-zero-host-negative.html
@@ -0,0 +1,35 @@
+
+
+
HTML Test: focus - the sequential focus navigation order with shadow dom and negative host tabindex
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-zero-host-not-set.html b/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-zero-host-not-set.html
new file mode 100644
index 000000000000..f25726147718
--- /dev/null
+++ b/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-zero-host-not-set.html
@@ -0,0 +1,37 @@
+
+
+
HTML Test: focus - the sequential focus navigation order with shadow dom and non-focusable host
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-zero-host-one.html b/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-zero-host-one.html
new file mode 100644
index 000000000000..1aa5292997a3
--- /dev/null
+++ b/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-zero-host-one.html
@@ -0,0 +1,37 @@
+
+
+
HTML Test: focus - the sequential focus navigation order with shadow dom and all tabindex=0 except host (tabindex=1)
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-zero.html b/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-zero.html
new file mode 100644
index 000000000000..d8b12ed8ac6e
--- /dev/null
+++ b/tests/wpt/web-platform-tests/shadow-dom/focus/focus-tabindex-order-shadow-zero.html
@@ -0,0 +1,35 @@
+
+
+
HTML Test: focus - the sequential focus navigation order with shadow dom and all tabindex=0
+
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/shadow-dom/focus/resources/shadow-utils.js b/tests/wpt/web-platform-tests/shadow-dom/focus/resources/shadow-utils.js
new file mode 100644
index 000000000000..6ea372afdf18
--- /dev/null
+++ b/tests/wpt/web-platform-tests/shadow-dom/focus/resources/shadow-utils.js
@@ -0,0 +1,79 @@
+// Structure:
+//
+//
+// #shadowRoot
+//
+//
+// (slotted)
+//
+// (slotted)
+//
+//
+function prepareDOM(container, delegatesFocus) {
+
+ const aboveHost = document.createElement("div");
+ aboveHost.innerText = "aboveHost";
+ const host = document.createElement("div");
+ host.id = "host";
+ const slottedBelow = document.createElement("div");
+ slottedBelow.innerText = "slotted below";
+ slottedBelow.slot = "below";
+ const slottedAbove = document.createElement("div");
+ slottedAbove.innerText = "slotted above";
+ slottedAbove.slot = "above";
+
+ const belowHost = document.createElement("div");
+ belowHost.innerText = "belowHost";
+ container.appendChild(aboveHost);
+ container.appendChild(host);
+ container.appendChild(belowHost);
+ host.appendChild(slottedBelow);
+ host.appendChild(slottedAbove);
+ const shadowRoot = host.attachShadow({ mode: "open", delegatesFocus: delegatesFocus});
+ const aboveSlot = document.createElement("div");
+ aboveSlot.innerText = "aboveSlot";
+
+ const slotAbove = document.createElement("slot");
+ slotAbove.name = "above";
+ const slotBelow = document.createElement("slot");
+ slotBelow.name = "below";
+
+ const belowSlot = document.createElement("div");
+ belowSlot.innerText = "belowSlot";
+ shadowRoot.appendChild(aboveSlot);
+ shadowRoot.appendChild(slotAbove);
+ shadowRoot.appendChild(slotBelow);
+ shadowRoot.appendChild(belowSlot);
+
+ return [aboveHost, host, aboveSlot, slotAbove, slottedAbove, slotBelow, slottedBelow, belowSlot, belowHost];
+}
+
+function setTabIndex(elements, value) {
+ for (const el of elements) {
+ el.tabIndex = value;
+ }
+}
+
+function removeTabIndex(elements) {
+ for (const el of elements) {
+ el.removeAttribute("tabindex");
+ }
+}
+
+function resetFocus() {
+ document.body.focus();
+}
+
+function navigateFocusForward() {
+ // TAB = '\ue004'
+ return test_driver.send_keys(document.body, "\ue004");
+}
+
+async function assertFocusOrder(expectedOrder) {
+ const shadowRoot = document.getElementById("host").shadowRoot;
+ for (const el of expectedOrder) {
+ await navigateFocusForward();
+ const focused = shadowRoot.activeElement ? shadowRoot.activeElement : document.activeElement;
+ assert_equals(focused, el);
+ }
+}
diff --git a/tests/wpt/web-platform-tests/sms/README.md b/tests/wpt/web-platform-tests/sms/README.md
new file mode 100644
index 000000000000..7cd98964c249
--- /dev/null
+++ b/tests/wpt/web-platform-tests/sms/README.md
@@ -0,0 +1,3 @@
+# SMS Receiver API
+
+This directory contains Web platform tests of the SMS Receiver API. For more details, refer to [this README file](https://cs.chromium.org/chromium/src/content/browser/sms/README.md).
diff --git a/tests/wpt/web-platform-tests/streams/readable-streams/patched-global.any.js b/tests/wpt/web-platform-tests/streams/readable-streams/patched-global.any.js
index 500979f5b37a..813dd42e68aa 100644
--- a/tests/wpt/web-platform-tests/streams/readable-streams/patched-global.any.js
+++ b/tests/wpt/web-platform-tests/streams/readable-streams/patched-global.any.js
@@ -107,3 +107,35 @@ promise_test(async t => {
// stream should be cancelled
await reader.closed;
}, 'ReadableStream getIterator() should use the original values of getReader() and ReadableStreamDefaultReader methods');
+
+test(t => {
+ const oldPromiseThen = Promise.prototype.then;
+ Promise.prototype.then = () => {
+ throw new Error('patched then() called');
+ };
+ t.add_cleanup(() => {
+ Promise.prototype.then = oldPromiseThen;
+ });
+ const [branch1, branch2] = new ReadableStream().tee();
+ assert_true(isReadableStream(branch1), 'branch1 should be a ReadableStream');
+ assert_true(isReadableStream(branch2), 'branch2 should be a ReadableStream');
+}, 'tee() should not call Promise.prototype.then()');
+
+test(t => {
+ const oldPromiseThen = Promise.prototype.then;
+ Promise.prototype.then = () => {
+ throw new Error('patched then() called');
+ };
+ t.add_cleanup(() => {
+ Promise.prototype.then = oldPromiseThen;
+ });
+ let readableController;
+ const rs = new ReadableStream({
+ start(c) {
+ readableController = c;
+ }
+ });
+ const ws = new WritableStream();
+ rs.pipeTo(ws);
+ readableController.close();
+}, 'pipeTo() should not call Promise.prototype.then()');
diff --git a/tests/wpt/web-platform-tests/svg/animations/accumulate-values-width-animation.html b/tests/wpt/web-platform-tests/svg/animations/accumulate-values-width-animation.html
new file mode 100644
index 000000000000..7813494a6a2c
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/accumulate-values-width-animation.html
@@ -0,0 +1,110 @@
+
+
+
+
This tests values animation and accumulate='sum'
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/additive-from-to-width-animation.html b/tests/wpt/web-platform-tests/svg/animations/additive-from-to-width-animation.html
new file mode 100644
index 000000000000..0899f5e0b531
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/additive-from-to-width-animation.html
@@ -0,0 +1,61 @@
+
+
+
+
This tests multiple additive='sum' animations running at the same time
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/additive-type-by-animation.html b/tests/wpt/web-platform-tests/svg/animations/additive-type-by-animation.html
new file mode 100644
index 000000000000..2dc7732dd6ef
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/additive-type-by-animation.html
@@ -0,0 +1,275 @@
+
+
+
+
This by animation for all XML property types
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/additive-values-width-animation.html b/tests/wpt/web-platform-tests/svg/animations/additive-values-width-animation.html
new file mode 100644
index 000000000000..5b874f5a4f83
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/additive-values-width-animation.html
@@ -0,0 +1,83 @@
+
+
+
+
This tests values animation and additive='sum'
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-calcMode-spline-by.html b/tests/wpt/web-platform-tests/svg/animations/animate-calcMode-spline-by.html
new file mode 100644
index 000000000000..5ce9bcc763e5
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-calcMode-spline-by.html
@@ -0,0 +1,70 @@
+
+
+
+
Test calcMode spline with by animation. You should see a green 100x100 rect and only PASS messages
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-calcMode-spline-from-by.html b/tests/wpt/web-platform-tests/svg/animations/animate-calcMode-spline-from-by.html
new file mode 100644
index 000000000000..1f15760c7d84
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-calcMode-spline-from-by.html
@@ -0,0 +1,71 @@
+
+
+
+
Test calcMode spline with from-by animation. You should see a green 100x100 rect and only PASS messages
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-calcMode-spline-from-to.html b/tests/wpt/web-platform-tests/svg/animations/animate-calcMode-spline-from-to.html
new file mode 100644
index 000000000000..4d6080083148
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-calcMode-spline-from-to.html
@@ -0,0 +1,71 @@
+
+
+
+
Test calcMode spline with from-to animation. You should see a green 100x100 rect and only PASS messages
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-calcMode-spline-to.html b/tests/wpt/web-platform-tests/svg/animations/animate-calcMode-spline-to.html
new file mode 100644
index 000000000000..4a26cd716ed5
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-calcMode-spline-to.html
@@ -0,0 +1,70 @@
+
+
+
+
Test calcMode spline with to animation. You should see a green 100x100 rect and only PASS messages
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-calcMode-spline-values.html b/tests/wpt/web-platform-tests/svg/animations/animate-calcMode-spline-values.html
new file mode 100644
index 000000000000..46952aa45db5
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-calcMode-spline-values.html
@@ -0,0 +1,70 @@
+
+
+
+
Test calcMode spline with values animation. You should see a green 100x100 rect and only PASS messages
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-color-calcMode-discrete.html b/tests/wpt/web-platform-tests/svg/animations/animate-color-calcMode-discrete.html
new file mode 100644
index 000000000000..980f39282e33
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-color-calcMode-discrete.html
@@ -0,0 +1,63 @@
+
+
+
+
Test calcMode discrete with from-to animation on colors. You should see a green 100x100 rect and only PASS messages
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-color-fill-currentColor.html b/tests/wpt/web-platform-tests/svg/animations/animate-color-fill-currentColor.html
new file mode 100644
index 000000000000..2780ce2ac9a8
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-color-fill-currentColor.html
@@ -0,0 +1,63 @@
+
+
+
+
Tests animation on 'currentColor'.
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-color-fill-from-by.html b/tests/wpt/web-platform-tests/svg/animations/animate-color-fill-from-by.html
new file mode 100644
index 000000000000..410b27b75a73
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-color-fill-from-by.html
@@ -0,0 +1,63 @@
+
+
+
+
Tests animation on 'currentColor'.
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-color-transparent.html b/tests/wpt/web-platform-tests/svg/animations/animate-color-transparent.html
new file mode 100644
index 000000000000..e2a946cfb0b1
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-color-transparent.html
@@ -0,0 +1,53 @@
+
+
+
+
Tests that 'transparent' is treated as a valid color.
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-css-xml-attributeType.html b/tests/wpt/web-platform-tests/svg/animations/animate-css-xml-attributeType.html
new file mode 100644
index 000000000000..4494eb773693
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-css-xml-attributeType.html
@@ -0,0 +1,88 @@
+
+
+
+
Tests that XML and CSS attributeTypes can be switched between.
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-currentColor.html b/tests/wpt/web-platform-tests/svg/animations/animate-currentColor.html
new file mode 100644
index 000000000000..a8b3c1f16f25
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-currentColor.html
@@ -0,0 +1,63 @@
+
+
+
+
Tests animation on 'currentColor'.
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-dynamic-update-attributeName.html b/tests/wpt/web-platform-tests/svg/animations/animate-dynamic-update-attributeName.html
new file mode 100644
index 000000000000..47ca52526ae1
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-dynamic-update-attributeName.html
@@ -0,0 +1,71 @@
+
+
+
+
Test behavior on dynamic-update of attributeName
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-elem-02-t-drt.html b/tests/wpt/web-platform-tests/svg/animations/animate-elem-02-t-drt.html
new file mode 100644
index 000000000000..31f34ce56f8b
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-elem-02-t-drt.html
@@ -0,0 +1,183 @@
+
+
+
+
A copy of the corresponding W3C-SVG-1.1 test, which dumps the animation at certain times
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-elem-14-t-drt.html b/tests/wpt/web-platform-tests/svg/animations/animate-elem-14-t-drt.html
new file mode 100644
index 000000000000..64fc35f596fd
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-elem-14-t-drt.html
@@ -0,0 +1,140 @@
+
+
+
+
A copy of the corresponding W3C-SVG-1.1 test, which dumps the animation at certain times
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-elem-15-t-drt.html b/tests/wpt/web-platform-tests/svg/animations/animate-elem-15-t-drt.html
new file mode 100644
index 000000000000..9d5cb1b437bc
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-elem-15-t-drt.html
@@ -0,0 +1,136 @@
+
+
+
+
A copy of the corresponding W3C-SVG-1.1 test, which dumps the animation at certain times
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-elem-16-t-drt.html b/tests/wpt/web-platform-tests/svg/animations/animate-elem-16-t-drt.html
new file mode 100644
index 000000000000..0ac98e2fc80f
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-elem-16-t-drt.html
@@ -0,0 +1,136 @@
+
+
+
+
A copy of the corresponding W3C-SVG-1.1 test, which dumps the animation at certain times
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-elem-17-t-drt.html b/tests/wpt/web-platform-tests/svg/animations/animate-elem-17-t-drt.html
new file mode 100644
index 000000000000..1b101491953b
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-elem-17-t-drt.html
@@ -0,0 +1,136 @@
+
+
+
+
A copy of the corresponding W3C-SVG-1.1 test, which dumps the animation at certain times
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-elem-18-t-drt.html b/tests/wpt/web-platform-tests/svg/animations/animate-elem-18-t-drt.html
new file mode 100644
index 000000000000..4f9dbb776581
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-elem-18-t-drt.html
@@ -0,0 +1,137 @@
+
+
+
+
A copy of the corresponding W3C-SVG-1.1 test, which dumps the animation at certain times
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-elem-19-t-drt.html b/tests/wpt/web-platform-tests/svg/animations/animate-elem-19-t-drt.html
new file mode 100644
index 000000000000..9b9d61c90bdd
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-elem-19-t-drt.html
@@ -0,0 +1,136 @@
+
+
+
+
A copy of the corresponding W3C-SVG-1.1 test, which dumps the animation at certain times
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-end-attribute-numeric-precision.html b/tests/wpt/web-platform-tests/svg/animations/animate-end-attribute-numeric-precision.html
new file mode 100644
index 000000000000..d0515ac850e8
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-end-attribute-numeric-precision.html
@@ -0,0 +1,57 @@
+
+
+
+
Tests end conditions are respected properly near the limits of float numeric precision
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-fill-freeze-with-repeatDur.html b/tests/wpt/web-platform-tests/svg/animations/animate-fill-freeze-with-repeatDur.html
new file mode 100644
index 000000000000..aab9eacff26b
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-fill-freeze-with-repeatDur.html
@@ -0,0 +1,47 @@
+
+
+
+
Test for animation freeze when repeatDur is not a multiple of dur
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-from-to-keyTimes.html b/tests/wpt/web-platform-tests/svg/animations/animate-from-to-keyTimes.html
new file mode 100644
index 000000000000..7295bcdb630f
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-from-to-keyTimes.html
@@ -0,0 +1,60 @@
+
+
+
+
Tests discrete from-to-keyTimes animations
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-gradient-transform.html b/tests/wpt/web-platform-tests/svg/animations/animate-gradient-transform.html
new file mode 100644
index 000000000000..ddb9946fda6b
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-gradient-transform.html
@@ -0,0 +1,103 @@
+
+
+
+
Tests if gradientTransform of a gradient is animateable.
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-inherit-css-property.html b/tests/wpt/web-platform-tests/svg/animations/animate-inherit-css-property.html
new file mode 100644
index 000000000000..a8b56bab2bfa
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-inherit-css-property.html
@@ -0,0 +1,69 @@
+
+
+
+
Tests animation with 'inherit'.
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-insert-begin.html b/tests/wpt/web-platform-tests/svg/animations/animate-insert-begin.html
new file mode 100644
index 000000000000..5155391a9123
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-insert-begin.html
@@ -0,0 +1,59 @@
+
+
+
+
Test behavior of dynamically inserting animate with begin attribute
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-insert-no-begin.html b/tests/wpt/web-platform-tests/svg/animations/animate-insert-no-begin.html
new file mode 100644
index 000000000000..3db406ecd482
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-insert-no-begin.html
@@ -0,0 +1,58 @@
+
+
+
+
Test behavior of dynamically inserting animate without begin attribute
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-keySplines.html b/tests/wpt/web-platform-tests/svg/animations/animate-keySplines.html
new file mode 100644
index 000000000000..0b02f71d3fa4
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-keySplines.html
@@ -0,0 +1,75 @@
+
+
+
+
Testing correct parsing of keySplines.
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/animate-marker-orient-from-angle-to-angle.html b/tests/wpt/web-platform-tests/svg/animations/animate-marker-orient-from-angle-to-angle.html
new file mode 100644
index 000000000000..a9c16740e632
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/animate-marker-orient-from-angle-to-angle.html
@@ -0,0 +1,104 @@
+
+
+
+
Animate SVGMarkerElement orientAttr from an angle to an angle
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/tests/wpt/web-platform-tests/svg/animations/syncbase-remove-add-while-running.html b/tests/wpt/web-platform-tests/svg/animations/syncbase-remove-add-while-running.html
new file mode 100644
index 000000000000..bebd53725015
--- /dev/null
+++ b/tests/wpt/web-platform-tests/svg/animations/syncbase-remove-add-while-running.html
@@ -0,0 +1,44 @@
+
+
+
+
Remove/Add syncbase while animation is running
+
+
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/tools/ci/manifest_build.py b/tests/wpt/web-platform-tests/tools/ci/manifest_build.py
index 98e7ce75e512..de17089214ed 100644
--- a/tests/wpt/web-platform-tests/tools/ci/manifest_build.py
+++ b/tests/wpt/web-platform-tests/tools/ci/manifest_build.py
@@ -21,7 +21,7 @@
class Status(object):
SUCCESS = 0
FAIL = 1
- NEUTRAL = 78
+ NEUTRAL = 0
def run(cmd, return_stdout=False, **kwargs):
diff --git a/tests/wpt/web-platform-tests/tools/ci/tests/test_update_pr_preview.py b/tests/wpt/web-platform-tests/tools/ci/tests/test_update_pr_preview.py
index 08e46b9a63ee..3202a1a2df6a 100644
--- a/tests/wpt/web-platform-tests/tools/ci/tests/test_update_pr_preview.py
+++ b/tests/wpt/web-platform-tests/tools/ci/tests/test_update_pr_preview.py
@@ -66,7 +66,7 @@ def assert_success(returncode):
def assert_neutral(returncode):
- assert returncode == 78
+ assert returncode == 0
def assert_fail(returncode):
diff --git a/tests/wpt/web-platform-tests/tools/ci/update_pr_preview.py b/tests/wpt/web-platform-tests/tools/ci/update_pr_preview.py
index 9b104c66bb6a..eca4a30678cf 100644
--- a/tests/wpt/web-platform-tests/tools/ci/update_pr_preview.py
+++ b/tests/wpt/web-platform-tests/tools/ci/update_pr_preview.py
@@ -41,7 +41,7 @@
class Status(object):
SUCCESS = 0
FAIL = 1
- NEUTRAL = 78
+ NEUTRAL = 0
def request(url, method_name, data=None, json_data=None, ignore_body=False):
diff --git a/tests/wpt/web-platform-tests/tools/ci/website_build.sh b/tests/wpt/web-platform-tests/tools/ci/website_build.sh
index aadfcbd6a212..e99fcb0cc9fb 100755
--- a/tests/wpt/web-platform-tests/tools/ci/website_build.sh
+++ b/tests/wpt/web-platform-tests/tools/ci/website_build.sh
@@ -2,7 +2,7 @@
set -ex
-neutral_status=78
+neutral_status=0
source_revision=$(git rev-parse HEAD)
# The token available in the `GITHUB_TOKEN` variable may be used to push to the
# repository, but GitHub Pages will not rebuild the website in response to such
diff --git a/tests/wpt/web-platform-tests/user-timing/mark-measure-return-objects.any.js b/tests/wpt/web-platform-tests/user-timing/mark-measure-return-objects.any.js
index fa45388d7b11..bb15c5839818 100644
--- a/tests/wpt/web-platform-tests/user-timing/mark-measure-return-objects.any.js
+++ b/tests/wpt/web-platform-tests/user-timing/mark-measure-return-objects.any.js
@@ -8,7 +8,7 @@ async_test(function (t) {
async_test(function (t) {
self.performance.clearMeasures();
const measure = self.performance.measure("measure2",
- { startTime: 12, endTime:23 });
+ { start: 12, end: 23 });
assert_true(measure instanceof PerformanceMeasure);
t.done();
}, "L3: performance.measure(name, param1) should return an entry.");
diff --git a/tests/wpt/web-platform-tests/user-timing/measure-with-dict.any.js b/tests/wpt/web-platform-tests/user-timing/measure-with-dict.any.js
index 99a2fe4d7984..95160fea8941 100644
--- a/tests/wpt/web-platform-tests/user-timing/measure-with-dict.any.js
+++ b/tests/wpt/web-platform-tests/user-timing/measure-with-dict.any.js
@@ -30,10 +30,12 @@ async_test(function (t) {
{ entryType: "measure", name: "measure15", detail: null, startTime: timeStamp1, duration: timeStamp2 - timeStamp1 },
{ entryType: "measure", name: "measure16", detail: null, startTime: timeStamp1 },
{ entryType: "measure", name: "measure17", detail: { customInfo: 159 }, startTime: timeStamp3, duration: timeStamp2 - timeStamp3 },
- { entryType: "measure", name: "measure18", detail: null, startTime: 0 },
- { entryType: "measure", name: "measure19", detail: null, startTime: 0 },
+ { entryType: "measure", name: "measure18", detail: null, startTime: timeStamp1, duration: timeStamp2 - timeStamp1 },
+ { entryType: "measure", name: "measure19", detail: null, startTime: timeStamp1, duration: timeStamp2 - timeStamp1 },
{ entryType: "measure", name: "measure20", detail: null, startTime: 0 },
- { entryType: "measure", name: "measure21", detail: null, startTime: 0 }];
+ { entryType: "measure", name: "measure21", detail: null, startTime: 0 },
+ { entryType: "measure", name: "measure22", detail: null, startTime: 0 },
+ { entryType: "measure", name: "measure23", detail: null, startTime: 0 }];
const observer = new PerformanceObserver(
t.step_func(function (entryList, obs) {
measureEntries =
@@ -80,11 +82,15 @@ async_test(function (t) {
self.performance.measure("measure16", { start: 'mark1', end: undefined, detail: null }));
returnedEntries.push(
self.performance.measure("measure17", { start: timeStamp3, end: 'mark2', detail: { customInfo: 159 }}));
+ returnedEntries.push(
+ self.performance.measure("measure18", { start: timeStamp1, duration: timeStamp2 - timeStamp1 }));
+ returnedEntries.push(
+ self.performance.measure("measure19", { duration: timeStamp2 - timeStamp1, end: timeStamp2 }));
// {}, null, undefined, invalid-dict passed to startOrOptions are interpreted as start time being 0.
- returnedEntries.push(self.performance.measure("measure18", {}, 'mark1'));
- returnedEntries.push(self.performance.measure("measure19", null, 'mark1'));
- returnedEntries.push(self.performance.measure("measure20", undefined, 'mark1'));
- returnedEntries.push(self.performance.measure("measure21", { invalidDict:1 }, 'mark1'));
+ returnedEntries.push(self.performance.measure("measure20", {}, 'mark1'));
+ returnedEntries.push(self.performance.measure("measure21", null, 'mark1'));
+ returnedEntries.push(self.performance.measure("measure22", undefined, 'mark1'));
+ returnedEntries.push(self.performance.measure("measure23", { invalidDict:1 }, 'mark1'));
checkEntries(returnedEntries, expectedEntries);
}, "measure entries' detail and start/end are customizable");
diff --git a/tests/wpt/web-platform-tests/user-timing/measure_exception.html b/tests/wpt/web-platform-tests/user-timing/measure_exception.html
index 8783ff7e2267..df674d931f48 100644
--- a/tests/wpt/web-platform-tests/user-timing/measure_exception.html
+++ b/tests/wpt/web-platform-tests/user-timing/measure_exception.html
@@ -27,6 +27,8 @@
Description
test_method_throw_exception('performance.measure("Exception5", "ExistMark", "NonExistMark1")', 'SYNTAX_ERR');
test_method_throw_exception('performance.measure("Exception6", "NonExistMark1", "NonExistMark2")', 'SYNTAX_ERR');
test_method_throw_exception('performance.measure("Exception7", "redirectStart")', 'INVALID_ACCESS_ERR');
+test_method_throw_exception('performance.measure("Exception8", {"detail": "non-empty"})', TypeError());
+test_method_throw_exception('performance.measure("Exception9", {"start": 1, "duration": 2, "end": 3})', TypeError());
diff --git a/tests/wpt/web-platform-tests/user-timing/structured-serialize-detail.any.js b/tests/wpt/web-platform-tests/user-timing/structured-serialize-detail.any.js
index 55cbd9246f9c..0c4be9a3bcb0 100644
--- a/tests/wpt/web-platform-tests/user-timing/structured-serialize-detail.any.js
+++ b/tests/wpt/web-platform-tests/user-timing/structured-serialize-detail.any.js
@@ -30,14 +30,14 @@ test(function() {
test(function() {
performance.clearMeasures();
const detail = { randomInfo: 123 }
- const measureEntry = performance.measure("A", { detail });
+ const measureEntry = performance.measure("A", { start: 0, detail });
assert_not_equals(measureEntry.detail, detail);
}, "The detail property in the measure method should be structured-clone.");
test(function() {
performance.clearMeasures();
const detail = { randomInfo: 123 }
- const measureEntry = performance.measure("A", { detail });
+ const measureEntry = performance.measure("A", { start: 0, detail });
assert_equals(measureEntry.detail, measureEntry.detail);
}, "The detail property in the measure method should be the same reference.");
@@ -51,7 +51,7 @@ test(function() {
performance.clearMeasures();
const detail = { unserializable: Symbol() };
assert_throws("DataCloneError", ()=>{
- performance.measure("A", { detail });
+ performance.measure("A", { start: 0, detail });
}, "Trying to structured-serialize a Symbol.");
}, "Measure: Throw an exception when the detail property cannot be structured-serialized.");
diff --git a/tests/wpt/web-platform-tests/web-animations/animation-model/animation-types/property-list.js b/tests/wpt/web-platform-tests/web-animations/animation-model/animation-types/property-list.js
index 7b14797d962d..3c1750f1f266 100644
--- a/tests/wpt/web-platform-tests/web-animations/animation-model/animation-types/property-list.js
+++ b/tests/wpt/web-platform-tests/web-animations/animation-model/animation-types/property-list.js
@@ -1305,7 +1305,7 @@ const gCSSProperties = {
'text-emphasis-style': {
// http://dev.w3.org/csswg/css-text-decor-3/#propdef-text-emphasis-style
types: [
- { type: 'discrete', options: [ [ 'filled circle', 'open dot' ] ] }
+ { type: 'discrete', options: [ [ 'circle', 'open dot' ] ] }
]
},
'text-indent': {
diff --git a/tests/wpt/web-platform-tests/web-nfc/NDEFMessage_constructor.https.html b/tests/wpt/web-platform-tests/web-nfc/NDEFMessage_constructor.https.html
index 73bbb4f8ab51..5be4571493ad 100644
--- a/tests/wpt/web-platform-tests/web-nfc/NDEFMessage_constructor.https.html
+++ b/tests/wpt/web-platform-tests/web-nfc/NDEFMessage_constructor.https.html
@@ -3,7 +3,7 @@
-
+
-
+
-
-
-
-
Tap an NFC tag to the test device with NFC support.
-
-
Note: All the actions need to be done in 60 seconds, otherwise it will get TIMEOUT.
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/web-nfc/NFCReader.https.html b/tests/wpt/web-platform-tests/web-nfc/NFCReader.https.html
index 3032b652edfb..4488097d6ebe 100644
--- a/tests/wpt/web-platform-tests/web-nfc/NFCReader.https.html
+++ b/tests/wpt/web-platform-tests/web-nfc/NFCReader.https.html
@@ -5,9 +5,7 @@
-
-
-
+
diff --git a/tests/wpt/web-platform-tests/web-nfc/NFCReader_options.https.html b/tests/wpt/web-platform-tests/web-nfc/NFCReader_options.https.html
new file mode 100644
index 000000000000..ebda3859834c
--- /dev/null
+++ b/tests/wpt/web-platform-tests/web-nfc/NFCReader_options.https.html
@@ -0,0 +1,160 @@
+
+
+
Web NFC: NFCReader option tests
+
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_mediaType-manual.https.html b/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_mediaType-manual.https.html
deleted file mode 100644
index faaf8f39a77f..000000000000
--- a/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_mediaType-manual.https.html
+++ /dev/null
@@ -1,31 +0,0 @@
-
-
-
Web NFC Test: NFCReader NFCReaderOptions mediaType test
-
-
-
-
-
-
-
-
-
Tap an NFC tag to the test device with NFC support.
-
-
Note: All the actions need to be done in 60 seconds, otherwise it will get TIMEOUT.
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_recordType_empty-manual.https.html b/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_recordType_empty-manual.https.html
deleted file mode 100644
index 995072b260d8..000000000000
--- a/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_recordType_empty-manual.https.html
+++ /dev/null
@@ -1,31 +0,0 @@
-
-
-
Web NFC Test: write and read empty records
-
-
-
-
-
-
-
-
-
Tap an NFC tag to the test device with NFC support.
-
-
Note: All the actions need to be done in 60 seconds, otherwise it will get TIMEOUT.
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_recordType_json-manual.https.html b/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_recordType_json-manual.https.html
deleted file mode 100644
index 4120bc72f308..000000000000
--- a/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_recordType_json-manual.https.html
+++ /dev/null
@@ -1,31 +0,0 @@
-
-
-
Web NFC Test: write and read json records
-
-
-
-
-
-
-
-
-
Tap an NFC tag to the test device with NFC support.
-
-
Note: All the actions need to be done in 60 seconds, otherwise it will get TIMEOUT.
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_recordType_opaque-manual.https.html b/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_recordType_opaque-manual.https.html
deleted file mode 100644
index 94ded3e8a0fc..000000000000
--- a/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_recordType_opaque-manual.https.html
+++ /dev/null
@@ -1,31 +0,0 @@
-
-
-
Web NFC Test: write and read opaque records
-
-
-
-
-
-
-
-
-
Tap an NFC tag to the test device with NFC support.
-
-
Note: All the actions need to be done in 60 seconds, otherwise it will get TIMEOUT.
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_recordType_text-manual.https.html b/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_recordType_text-manual.https.html
deleted file mode 100644
index 72ca3e70d430..000000000000
--- a/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_recordType_text-manual.https.html
+++ /dev/null
@@ -1,31 +0,0 @@
-
-
-
Web NFC Test: write and read text records
-
-
-
-
-
-
-
-
-
Tap an NFC tag to the test device with NFC support.
-
-
Note: All the actions need to be done in 60 seconds, otherwise it will get TIMEOUT.
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_recordType_url-manual.https.html b/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_recordType_url-manual.https.html
deleted file mode 100644
index af57610c285a..000000000000
--- a/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_recordType_url-manual.https.html
+++ /dev/null
@@ -1,31 +0,0 @@
-
-
-
Web NFC Test: write and read url records
-
-
-
-
-
-
-
-
-
Tap an NFC tag to the test device with NFC support.
-
-
Note: All the actions need to be done in 60 seconds, otherwise it will get TIMEOUT.
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_url-manual.https.html b/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_url-manual.https.html
deleted file mode 100644
index aa0e72b089a1..000000000000
--- a/tests/wpt/web-platform-tests/web-nfc/NFCReader_options_url-manual.https.html
+++ /dev/null
@@ -1,34 +0,0 @@
-
-
-
Web NFC Test: NFCReader NFCReaderOptions url test
-
-
-
-
-
-
-
-
-
Tap an NFC tag to the test device with NFC support.
-
-
Note: All the actions need to be done in 60 seconds, otherwise it will get TIMEOUT.
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/web-nfc/NFCReadingEvent_constructor.https.html b/tests/wpt/web-platform-tests/web-nfc/NFCReadingEvent_constructor.https.html
index 172b0a619c2b..c2f9cef6e505 100644
--- a/tests/wpt/web-platform-tests/web-nfc/NFCReadingEvent_constructor.https.html
+++ b/tests/wpt/web-platform-tests/web-nfc/NFCReadingEvent_constructor.https.html
@@ -3,7 +3,7 @@
-
+
diff --git a/tests/wpt/web-platform-tests/web-nfc/NFCWriter_push.https.html b/tests/wpt/web-platform-tests/web-nfc/NFCWriter_push.https.html
index 0b804615930b..33471a18d8e1 100644
--- a/tests/wpt/web-platform-tests/web-nfc/NFCWriter_push.https.html
+++ b/tests/wpt/web-platform-tests/web-nfc/NFCWriter_push.https.html
@@ -5,10 +5,7 @@
-
-
-
-
+
diff --git a/tests/wpt/web-platform-tests/web-nfc/NFCWriter_push_signal-manual.https.html b/tests/wpt/web-platform-tests/web-nfc/NFCWriter_push_signal-manual.https.html
deleted file mode 100644
index f45d0bbbd498..000000000000
--- a/tests/wpt/web-platform-tests/web-nfc/NFCWriter_push_signal-manual.https.html
+++ /dev/null
@@ -1,45 +0,0 @@
-
-
-
Web NFC Test: NFCWriter signal test
-
-
-
-
-
-
-
-
-
Tap an NFC tag to the test device with NFC support.
-
-
Note: All the actions need to be done in 60 seconds, otherwise it will get TIMEOUT.
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/web-nfc/README.md b/tests/wpt/web-platform-tests/web-nfc/README.md
new file mode 100644
index 000000000000..8ae597e36fd1
--- /dev/null
+++ b/tests/wpt/web-platform-tests/web-nfc/README.md
@@ -0,0 +1,28 @@
+The `nfc-helpers.js` requires an implementation of
+the `WebNFCTest` interfaces, which should emulate platform Web NFC backends.
+
+The `WebNFCTest` interface is defined as:
+
+```
+ class NFCTestChromium {
+ initialize(); // Sets up the testing environment.
+ async reset(); // Frees the resources.
+ getMockNFC(); // Returns `MockNFC` interface.
+ };
+
+ class MockNFC {
+ setHWStatus(number status); // Sets the hardware status.
+ setCompatibility(NDEFCompatibility compatibility); // Sets NDEF accepted compatible devices
+ setReadingMessage(NDEFMessageInit message, NDEFCompatibility compatibility); // Sets message that is used to deliver NFC reading updates with a specific NDEFCompatibility.
+ setPendingPushCompleted(boolean result); // Sets if the pending push is completed.
+ setPushShouldTimeout(boolean result); // Sets flag to trigger the pending push to timeout.
+ pushedMessage(); // Gets the pushed `NDEFMessageSource`.
+ pushOptions(); // Gets the pushed `NFCPushOptions`.
+ };
+```
+
+The Chromium implementation of the `WebNFCTest` interface is located in
+[nfc-mock.js](../resources/chromium/nfc-mock.js).
+
+Other browser vendors should provide their own implementations of
+the `WebNFCTest` interfaces.
diff --git a/tests/wpt/web-platform-tests/web-nfc/nfc_hw_disabled-manual.https.html b/tests/wpt/web-platform-tests/web-nfc/nfc_hw_disabled-manual.https.html
deleted file mode 100644
index bb2cd42f1e65..000000000000
--- a/tests/wpt/web-platform-tests/web-nfc/nfc_hw_disabled-manual.https.html
+++ /dev/null
@@ -1,37 +0,0 @@
-
-
-
Web NFC Test: NFC HW Disabled
-
-
-
-
-
-
-
-
Precondition
-
- -
- Disable the NFC module or run test on a device without NFC module.
-
-
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/web-nfc/nfc_insecure_context.html b/tests/wpt/web-platform-tests/web-nfc/nfc_insecure_context.html
index 0e5764e6ebca..f883f0473b7c 100644
--- a/tests/wpt/web-platform-tests/web-nfc/nfc_insecure_context.html
+++ b/tests/wpt/web-platform-tests/web-nfc/nfc_insecure_context.html
@@ -5,7 +5,6 @@
-
Note
-
diff --git a/tests/wpt/web-platform-tests/web-nfc/nfc_push_ArrayBuffer-manual.https.html b/tests/wpt/web-platform-tests/web-nfc/nfc_push_ArrayBuffer-manual.https.html
deleted file mode 100644
index 90a356f9b264..000000000000
--- a/tests/wpt/web-platform-tests/web-nfc/nfc_push_ArrayBuffer-manual.https.html
+++ /dev/null
@@ -1,38 +0,0 @@
-
-
-Web NFC Test: push ArrayBuffer message
-
-
-
-
-
-
-
-
-
Tap an NFC tag to the test device with NFC support.
-
-Note: All the actions need to be done in 60 seconds, otherwise it will get TIMEOUT.
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/web-nfc/nfc_push_DOMString-manual.https.html b/tests/wpt/web-platform-tests/web-nfc/nfc_push_DOMString-manual.https.html
deleted file mode 100644
index 15e1da50fb3a..000000000000
--- a/tests/wpt/web-platform-tests/web-nfc/nfc_push_DOMString-manual.https.html
+++ /dev/null
@@ -1,36 +0,0 @@
-
-
-Web NFC Test: push DOMString message
-
-
-
-
-
-
-
-
-Tap an NFC tag to the test device with NFC support.
-
-Note: All the actions need to be done in 60 seconds, otherwise it will get TIMEOUT.
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/web-nfc/resources/nfc-helpers.js b/tests/wpt/web-platform-tests/web-nfc/resources/nfc-helpers.js
new file mode 100644
index 000000000000..fc72fa2de89f
--- /dev/null
+++ b/tests/wpt/web-platform-tests/web-nfc/resources/nfc-helpers.js
@@ -0,0 +1,206 @@
+'use strict';
+// These tests rely on the User Agent providing an implementation of
+// platform nfc backends.
+//
+// In Chromium-based browsers this implementation is provided by a polyfill
+// in order to reduce the amount of test-only code shipped to users. To enable
+// these tests the browser must be run with these options:
+//
+// --enable-blink-features=MojoJS,MojoJSTest
+let loadChromiumResources = Promise.resolve().then(() => {
+ if (!window.MojoInterfaceInterceptor) {
+ // Do nothing on non-Chromium-based browsers or when the Mojo bindings are
+ // not present in the global namespace.
+ return;
+ }
+
+ let chain = Promise.resolve();
+ [
+ '/gen/layout_test_data/mojo/public/js/mojo_bindings.js',
+ '/gen/services/device/public/mojom/nfc.mojom.js',
+ '/resources/chromium/nfc-mock.js',
+ ].forEach(path => {
+ let script = document.createElement('script');
+ script.src = path;
+ script.async = false;
+ chain = chain.then(() => new Promise(resolve => {
+ script.onload = resolve;
+ }));
+ document.head.appendChild(script);
+ });
+
+ return chain;
+});
+
+async function initialize_nfc_tests() {
+ if (typeof WebNFCTest === 'undefined') {
+ await loadChromiumResources;
+ }
+ assert_true(
+ typeof WebNFCTest !== 'undefined',
+ 'WebNFC testing interface is not available.'
+ );
+ let NFCTest = new WebNFCTest();
+ await NFCTest.initialize();
+ return NFCTest;
+}
+
+function nfc_test(func, name, properties) {
+ promise_test(async t => {
+ let NFCTest = await initialize_nfc_tests();
+ let mockTest = NFCTest.getMockNFC();
+ try {
+ await func(t, mockTest);
+ } finally {
+ await NFCTest.reset();
+ };
+ }, name, properties);
+}
+
+const test_text_data = 'Test text data.';
+const test_text_byte_array = new TextEncoder('utf-8').encode(test_text_data);
+const test_number_data = 42;
+const test_json_data = {level: 1, score: 100, label: 'Game'};
+const test_url_data = 'https://w3c.github.io/web-nfc/';
+const test_message_origin = 'https://127.0.0.1:8443';
+const test_buffer_data = new ArrayBuffer(test_text_byte_array.length);
+const test_buffer_view =
+ new Uint8Array(test_buffer_data).set(test_text_byte_array);
+const fake_tag_serial_number = 'c0:45:00:02';
+
+const NFCHWStatus = {};
+// OS-level NFC setting is ON
+NFCHWStatus.ENABLED = 1;
+// no NFC chip
+NFCHWStatus.NOT_SUPPORTED = NFCHWStatus.ENABLED + 1;
+// OS-level NFC setting OFF
+NFCHWStatus.DISABLED = NFCHWStatus.NOT_SUPPORTED + 1;
+
+function createMessage(records) {
+ if (records !== undefined) {
+ let message = {};
+ message.records = records;
+ return message;
+ }
+}
+
+function createRecord(recordType, mediaType, data) {
+ let record = {};
+ if (recordType !== undefined)
+ record.recordType = recordType;
+ if (mediaType !== undefined)
+ record.mediaType = mediaType;
+ if (data !== undefined)
+ record.data = data;
+ return record;
+}
+
+function createTextRecord(text) {
+ return createRecord('text', 'text/plain', text);
+}
+
+function createJsonRecord(json) {
+ return createRecord('json', 'application/json', json);
+}
+
+function createOpaqueRecord(buffer) {
+ return createRecord('opaque', 'application/octet-stream', buffer);
+}
+
+function createUrlRecord(url) {
+ return createRecord('url', 'text/plain', url);
+}
+
+function createNFCPushOptions(target, timeout, ignoreRead, compatibility) {
+ return { target, timeout, ignoreRead, compatibility};
+}
+
+// Compares NDEFMessageSource that was provided to the API
+// (e.g. NFCWriter.push), and NDEFMessage that was received by the
+// mock NFC service.
+function assertNDEFMessagesEqual(providedMessage, receivedMessage) {
+ // If simple data type is passed, e.g. String or ArrayBuffer, convert it
+ // to NDEFMessage before comparing.
+ // https://w3c.github.io/web-nfc/#dom-ndefmessagesource
+ let provided = providedMessage;
+ if (providedMessage instanceof ArrayBuffer)
+ provided = createMessage([createOpaqueRecord(providedMessage)]);
+ else if (typeof providedMessage === 'string')
+ provided = createMessage([createTextRecord(providedMessage)]);
+
+ assert_equals(provided.records.length, receivedMessage.data.length,
+ 'NDEFMessages must have same number of NDEFRecords');
+
+ // Compare contents of each individual NDEFRecord
+ for (let i = 0; i < provided.records.length; ++i)
+ compareNDEFRecords(provided.records[i], receivedMessage.data[i]);
+}
+
+// Used to compare two WebNFC messages, one that is provided to mock NFC
+// service and another that is received from NFCWriter.onreading() EventHandler.
+function assertWebNDEFMessagesEqual(a, b) {
+ if (b.url) assert_equals(a.url, b.url);
+ assert_equals(a.records.length, b.records.length);
+ for(let i in a.records) {
+ let recordA = a.records[i];
+ let recordB = b.records[i];
+ assert_equals(recordA.recordType, recordB.recordType);
+ assert_equals(recordA.mediaType, recordB.mediaType);
+ if (recordA.data() == null) {
+ assert_true(recordB.data == null);
+ } else if (recordA.data() instanceof ArrayBuffer) {
+ assert_array_equals(new Uint8Array(recordA.data()),
+ new Uint8Array(recordB.data));
+ } else if (typeof recordA.data() === 'object') {
+ assert_object_equals(recordA.data(), recordB.data);
+ } else if (typeof recordA.data() === 'number'
+ || typeof recordA.data() === 'string') {
+ assert_true(recordA.data() == recordB.data);
+ }
+ }
+}
+
+function testNFCReaderOptions(message, readOptions, unmatchedReadOptions, desc) {
+ nfc_test(async (t, mockNFC) => {
+ const reader1 = new NFCReader(unmatchedReadOptions);
+ const reader2 = new NFCReader(readOptions);
+
+ mockNFC.setReadingMessage(message, readOptions.compatibility);
+
+ // Reading from unmatched reader will not be triggered
+ reader1.onreading = t.unreached_func("reading event should not be fired.");
+ reader1.start();
+
+ const readerWatcher = new EventWatcher(t, reader2, ["reading", "error"]);
+
+ const promise = readerWatcher.wait_for("reading").then(event => {
+ reader1.stop();
+ reader2.stop();
+ assertWebNDEFMessagesEqual(event.message, message);
+ });
+ // NFCReader#start() asynchronously dispatches the onreading event.
+ reader2.start();
+ await promise;
+ }, desc);
+}
+
+function testReadingMultiMessages(message, readOptions, unmatchedMessage,
+ unmatchedCompatibility, desc) {
+ nfc_test(async (t, mockNFC) => {
+ const reader = new NFCReader(readOptions);
+ const readerWatcher = new EventWatcher(t, reader, ["reading", "error"]);
+
+ const promise = readerWatcher.wait_for("reading").then(event => {
+ reader.stop();
+ assertWebNDEFMessagesEqual(event.message, message);
+ });
+ // NFCReader#start() asynchronously dispatches the onreading event.
+ reader.start();
+
+ // Unmatched message will not be read
+ mockNFC.setReadingMessage(unmatchedMessage, unmatchedCompatibility);
+ mockNFC.setReadingMessage(message);
+
+ await promise;
+ }, desc);
+}
diff --git a/tests/wpt/web-platform-tests/web-nfc/resources/nfc_help.js b/tests/wpt/web-platform-tests/web-nfc/resources/nfc_help.js
deleted file mode 100644
index 67fd5af381c9..000000000000
--- a/tests/wpt/web-platform-tests/web-nfc/resources/nfc_help.js
+++ /dev/null
@@ -1,86 +0,0 @@
-'use strict';
-
-const test_text_data = "Test text data.";
-const test_text_byte_array = new TextEncoder('utf-8').encode(test_text_data);
-const test_number_data = 42;
-const test_json_data = {level: 1, score: 100, label: 'Game'};
-const test_url_data = "https://w3c.github.io/web-nfc";
-const test_buffer_data = new ArrayBuffer(test_text_byte_array.length);
-const test_buffer_view = new Uint8Array(test_buffer_data).set(test_text_byte_array);
-
-function noop() {};
-
-function createMessage(records) {
- if (records !== undefined) {
- let message = {};
- message.records = records;
- return message;
- }
-}
-
-function createRecord(recordType, mediaType, data) {
- let record = {};
- if (recordType !== undefined) {
- record.recordType = recordType;
- }
- if (mediaType !== undefined) {
- record.mediaType = mediaType;
- }
- if (data !== undefined) {
- record.data = data;
- }
- return record;
-}
-
-function createTextRecord(text) {
- return createRecord('text', 'text/plain', text);
-}
-
-function createJsonRecord(json) {
- return createRecord('json', 'application/json', json);
-}
-
-function createOpaqueRecord(buffer) {
- return createRecord('opaque', 'application/octet-stream', buffer);
-}
-
-function createUrlRecord(url) {
- return createRecord('url', 'text/plain', url);
-}
-
-function assertWebNDEFMessagesEqual(a, b) {
- if (b.url) assert_equals(a.url, `${location.origin}${b.url}`);
- assert_equals(a.records.length, b.records.length);
- for(let i in a.records) {
- let recordA = a.records[i];
- let recordB = b.records[i];
- assert_equals(recordA.recordType, recordB.recordType);
- assert_equals(recordA.mediaType, recordB.mediaType);
- if (recordA.data() instanceof ArrayBuffer) {
- assert_array_equals(new Uint8Array(recordA.data()),
- new Uint8Array(recordB.data()));
- } else if (typeof recordA.data() === 'object') {
- assert_object_equals(recordA.data(), recordB.data());
- } else if (typeof recordA.data() === 'number'
- || typeof recordA.data() === 'string') {
- assert_true(recordA.data() == recordB.data());
- }
- }
-}
-
-function testNFCReaderOptions(pushedMessage, readOptions, unacceptableReadOptions, desc) {
- promise_test(async t => {
- const writer = new NFCWriter();
- const reader1 = new NFCReader(unacceptableReadOptions);
- const reader2 = new NFCReader(readOptions);
- await writer.push(pushedMessage);
-
- reader1.onreading = t.unreached_func("reading event should not be fired.");
- reader1.start();
-
- const readerWatcher = new EventWatcher(t, reader2, ["reading", "error"]);
- reader2.start();
- const event = await readerWatcher.wait_for("reading");
- assertWebNDEFMessagesEqual(event.message, pushedMessage);
- }, desc);
-}