fix(forms): share bounded native pattern validity across documents

This commit is contained in:
ldm0
2026-11-22 02:02:05 +08:00
parent 2ae32eeb8a
commit bc1f764c14
10 changed files with 375 additions and 73 deletions
@@ -33,7 +33,7 @@ impl DocumentRuntime {
self.query_selector_with_optional_validity_states(root, selector, Some(validity_states))
}
fn query_selector_with_optional_validity_states(
pub(crate) fn query_selector_with_optional_validity_states(
&self,
root: Option<DomHandle>,
selector: &str,
@@ -106,7 +106,7 @@ impl DocumentRuntime {
self.query_selector_all_with_optional_validity_states(root, selector, Some(validity_states))
}
fn query_selector_all_with_optional_validity_states(
pub(crate) fn query_selector_all_with_optional_validity_states(
&self,
root: Option<DomHandle>,
selector: &str,
@@ -153,7 +153,7 @@ impl DocumentRuntime {
self.matches_with_optional_validity_states(node, selector, Some(validity_states))
}
fn matches_with_optional_validity_states(
pub(crate) fn matches_with_optional_validity_states(
&self,
node: DomHandle,
selector: &str,
@@ -13,6 +13,7 @@ use crate::native_bridge::document::{
detached_native_handle_for_runtime, detached_native_object_for_handle, detached_node_type,
detached_owner_document_object, detached_parent_node_object,
};
use crate::native_bridge::element::selector_validity_states;
use crate::native_bridge::node::throw_native_selector_error_for_selector;
use crate::native_bridge::{
collections,
@@ -330,14 +331,7 @@ fn detached_native_query_selector_objects<'s>(
find_all: bool,
) -> Option<Result<Vec<v8::Local<'s, v8::Object>>, crate::selector::SelectorError>> {
let runtime_ptr = context_host_ptr_from_global_bridge(scope)?;
let root_handle = detached_native_handle_for_runtime(scope, runtime_ptr, root)?;
let handles = if find_all {
unsafe { &*runtime_ptr }.query_selector_all(Some(root_handle), selector)
} else {
unsafe { &*runtime_ptr }
.query_selector(Some(root_handle), selector)
.map(|handle| handle.into_iter().collect())
};
let handles = detached_native_query_selector_handles(scope, root, selector, find_all)?;
Some(handles.map(|handles: Vec<DomHandle>| {
handles
.into_iter()
@@ -350,10 +344,27 @@ fn detached_native_query_selector_handles<'s>(
scope: &mut v8::PinScope<'s, '_>,
root: v8::Local<'s, v8::Object>,
selector: &str,
find_all: bool,
) -> Option<Result<Vec<DomHandle>, crate::selector::SelectorError>> {
let runtime_ptr = context_host_ptr_from_global_bridge(scope)?;
let root_handle = detached_native_handle_for_runtime(scope, runtime_ptr, root)?;
Some(unsafe { &*runtime_ptr }.query_selector_all(Some(root_handle), selector))
let validity_states = selector_validity_states(scope, runtime_ptr, selector);
let runtime = unsafe { &*runtime_ptr };
Some(if find_all {
runtime.query_selector_all_with_optional_validity_states(
Some(root_handle),
selector,
validity_states.as_ref(),
)
} else {
runtime
.query_selector_with_optional_validity_states(
Some(root_handle),
selector,
validity_states.as_ref(),
)
.map(|handle| handle.into_iter().collect())
})
}
fn detached_native_matches_selector<'s>(
@@ -363,7 +374,14 @@ fn detached_native_matches_selector<'s>(
) -> Option<Result<bool, crate::selector::SelectorError>> {
let runtime_ptr = context_host_ptr_from_global_bridge(scope)?;
let handle = detached_native_handle_for_runtime(scope, runtime_ptr, node)?;
Some(unsafe { &*runtime_ptr }.matches(handle, selector))
let validity_states = selector_validity_states(scope, runtime_ptr, selector);
Some(
unsafe { &*runtime_ptr }.matches_with_optional_validity_states(
handle,
selector,
validity_states.as_ref(),
),
)
}
fn detached_native_element_by_id_object<'s>(
@@ -539,7 +557,9 @@ pub(in crate::native_bridge) fn bridge_detached_query_selector_all_callback<'a>(
else {
return;
};
if let Some(result) = detached_native_query_selector_handles(scope, root, &parsed.selectors) {
if let Some(result) =
detached_native_query_selector_handles(scope, root, &parsed.selectors, true)
{
match result {
Ok(handles) => {
let context = root
@@ -606,6 +626,17 @@ pub(in crate::native_bridge) fn bridge_detached_matches_callback<'a>(
rv.set(value);
return;
}
// Native nodes use the same computed state for every selector, including
// combinations of :defined with constraint-validation pseudo-classes.
if let Some(result) = detached_native_matches_selector(scope, node, &parsed.selectors) {
match result {
Ok(is_match) => rv.set_bool(is_match),
Err(error) => {
throw_native_selector_error_for_selector(scope, &parsed.selectors, &error)
}
}
return;
}
match detached_stylo_matches_selector_if_uses_defined_pseudo(scope, node, &parsed.selectors) {
Ok(Some(is_match)) => {
rv.set_bool(is_match);
@@ -617,15 +648,6 @@ pub(in crate::native_bridge) fn bridge_detached_matches_callback<'a>(
return;
}
}
if let Some(result) = detached_native_matches_selector(scope, node, &parsed.selectors) {
match result {
Ok(is_match) => rv.set_bool(is_match),
Err(error) => {
throw_native_selector_error_for_selector(scope, &parsed.selectors, &error)
}
}
return;
}
match detached_stylo_matches_selector(scope, node, &parsed.selectors) {
Ok(is_match) => rv.set_bool(is_match),
Err(error) => throw_native_selector_error_for_selector(scope, &parsed.selectors, &error),
@@ -649,6 +649,7 @@ pub(super) use popover::{
node_hide_popover_callback, node_popover_getter_function, node_popover_setter_function,
node_show_popover_callback, node_toggle_popover_callback,
};
pub(in crate::native_bridge) use query::selector_validity_states;
pub(super) use query::{
node_closest_callback, node_get_elements_by_class_name_callback,
node_get_elements_by_name_callback, node_get_elements_by_tag_name_callback,
@@ -11,6 +11,7 @@ use moli_dom::forms::{
text_control_suffers_too_long as form_text_control_suffers_too_long,
text_control_suffers_too_short as form_text_control_suffers_too_short,
};
use moli_v8_util::NativeRegExp;
use moli_webapi::validity_state::ValidityStateDeclaration;
use super::super::{
@@ -362,7 +363,7 @@ fn control_validity(
ControlValidity {
value_missing: control_suffers_required_value_missing(runtime, handle, element),
type_mismatch: control_suffers_type_mismatch(runtime, handle, element),
pattern_mismatch: control_suffers_pattern_mismatch(scope, runtime, handle, element),
pattern_mismatch: control_suffers_pattern_mismatch(scope, element),
too_long: control_suffers_too_long(runtime, handle, element),
too_short: control_suffers_too_short(runtime, handle, element),
range_underflow: control_suffers_range_underflow(runtime, handle, element),
@@ -539,12 +540,7 @@ fn control_suffers_type_mismatch(
)
}
fn control_suffers_pattern_mismatch(
scope: &mut v8::PinScope<'_, '_>,
_runtime: &PageScriptHost,
_handle: DomHandle,
element: &Element,
) -> bool {
fn control_suffers_pattern_mismatch(scope: &mut v8::PinScope<'_, '_>, element: &Element) -> bool {
if !element.is_html_input()
|| !element_type_supports_intrinsic_validation(element)
|| !element.input_type().supports_pattern()
@@ -558,58 +554,43 @@ fn control_suffers_pattern_mismatch(
if value.is_empty() {
return false;
}
let Some(pattern) = compile_html_pattern(scope, pattern) else {
return false;
};
if element.input_type() == InputType::Email && element.has_attribute("multiple") {
return v8_pattern_is_usable(scope, pattern).is_some_and(|()| {
value
.split(',')
.map(str::trim)
.any(|part| !v8_pattern_matches_entire_value(scope, pattern, part).unwrap_or(true))
});
return value
.split(',')
.map(str::trim)
.any(|part| pattern_mismatches_value(scope, &pattern, part));
}
v8_pattern_is_usable(scope, pattern).is_some_and(|()| {
v8_pattern_matches_entire_value(scope, pattern, &value).is_some_and(|matched| !matched)
})
pattern_mismatches_value(scope, &pattern, &value)
}
pub(crate) fn v8_pattern_is_usable(scope: &mut v8::PinScope<'_, '_>, pattern: &str) -> Option<()> {
let try_catch = std::pin::pin!(v8::TryCatch::new(scope));
let mut scope = try_catch.init();
let pattern = v8_string(&scope, pattern)?;
if v8::RegExp::new(&scope, pattern, RegExpCreationFlags::UNICODE_SETS).is_none() {
scope.reset();
return None;
}
Some(())
let pattern = v8_string(scope, pattern)?;
NativeRegExp::new(scope, pattern, RegExpCreationFlags::UNICODE_SETS).map(|_| ())
}
fn v8_pattern_matches_entire_value(
scope: &mut v8::PinScope<'_, '_>,
fn compile_html_pattern<'s>(
scope: &mut v8::PinScope<'s, '_>,
pattern: &str,
value: &str,
) -> Option<bool> {
let try_catch = std::pin::pin!(v8::TryCatch::new(scope));
let mut scope = try_catch.init();
// HTML pattern validation is implicitly anchored; run it through V8 so
// backreferences, lookaheads, and other ECMAScript regexp syntax match the
// JavaScript engine instead of a Rust-side approximation.
) -> Option<NativeRegExp<'s>> {
// HTML validates the standalone source before anchoring it; invalid source
// must not become usable merely because the wrapper balances its groups.
v8_pattern_is_usable(scope, pattern)?;
let anchored_pattern = format!("^(?:{pattern})$");
let pattern = v8_string(&scope, &anchored_pattern)?;
let subject = v8_string(&scope, value)?;
let Some(regex) = v8::RegExp::new(&scope, pattern, RegExpCreationFlags::UNICODE_SETS) else {
// Invalid HTML pattern values are ignored by constraint validation, so
// swallow V8's SyntaxError instead of leaking it through input.validity.
scope.reset();
return None;
};
let pattern = v8_string(scope, &anchored_pattern)?;
NativeRegExp::new(scope, pattern, RegExpCreationFlags::UNICODE_SETS)
}
let Some(result) = regex.exec(&scope, subject) else {
// Exec should only be empty for exceptional cases; constraint
// validation treats those like an unusable pattern and continues.
scope.reset();
return None;
};
Some(!result.is_null())
fn pattern_mismatches_value(
scope: &mut v8::PinScope<'_, '_>,
pattern: &NativeRegExp<'_>,
value: &str,
) -> bool {
v8_string(scope, value)
.and_then(|subject| pattern.is_match(scope, subject))
.is_some_and(|matched| !matched)
}
fn control_suffers_too_long(
@@ -376,7 +376,7 @@ pub(in crate::native_bridge) fn node_closest_callback<'s>(
}
}
fn selector_validity_states(
pub(in crate::native_bridge) fn selector_validity_states(
scope: &mut v8::PinScope<'_, '_>,
runtime_ptr: *mut PageScriptHost,
selector: &str,
@@ -0,0 +1,22 @@
use super::*;
#[test]
fn input_patterns_use_bounded_native_regexps_without_changing_author_state() {
let mut vm = new_parsed_test_vm(
"https://input-pattern-matching.test/",
"<!doctype html><iframe id=child></iframe>",
);
let result = vm
.eval(include_str!(
"../../../../tests/fixtures/input-pattern-matching.js"
))
.expect("input pattern matrix should complete");
assert_eq!(vm.eval("__uiEventResults.total").unwrap(), "3824");
assert_eq!(
result,
"true",
"{}",
vm.eval("JSON.stringify(__uiEventResults.rows.filter(row => !row.passed))")
.unwrap(),
);
}
@@ -80,6 +80,7 @@ mod idle_detection;
mod images;
mod input_event_init;
mod joint_history_child_pushes;
mod input_patterns;
mod interaction_event_init;
mod keyboard_event_init;
mod legacy_event_init;
@@ -0,0 +1,143 @@
(() => {
const rows = [], H = 'http://www.w3.org/1999/xhtml';
const realms = [['main', globalThis], ['child', document.querySelector('#child').contentWindow]];
const originals = realms.map(([name, win]) => ({name, ctor: win.RegExp, exec: win.RegExp.prototype.exec}));
const statics = ['input', 'lastMatch', 'lastParen', 'leftContext', 'rightContext', '$1', '$2', '$3', '$4', '$5', '$6', '$7', '$8', '$9'];
const seed = () => {
for (const {name, ctor, exec} of originals) exec.call(new ctor('(sentinel)-('+name+')'), 'before-sentinel-'+name+'-after');
return originals.map(({ctor}) => statics.map(key => ctor[key]));
};
const unchanged = before => originals.every(({ctor}, index) => statics.every((key, field) => ctor[key] === before[index][field]));
const same = (a, b) => a.length === b.length && a.every((value, index) => value === b[index]);
const check = (name, body) => {
try {rows.push({name, passed: body() === true});}
catch (error) {rows.push({name, passed: false, error: String(error)});}
};
const cases = [
['digits match', '\\d+', '123', false],
['full value', '\\d+', 'x123', true],
['nested rejection', '(\\d+)*$', '12345678901234567890123456789123456789z', true],
['nested match', '(\\d+)*$', '12345678901234567890123456789123456789', false],
['backreference match', '([a-z])\\1', 'aa', false],
['backreference rejection', '([a-z])\\1', 'ab', true],
['lookahead match', '(?=.*[0-9]).+', 'abc1', false],
['lookahead rejection', '(?=.*[0-9]).+', 'abc', true],
['unicode intersection', '[\\p{ASCII}&&\\p{Letter}]+', 'abc', false],
['unicode intersection rejection', '[\\p{ASCII}&&\\p{Letter}]+', '\u00e9', true],
['unicode string set', '[\\q{ab|cd}]', 'ab', false],
['unicode string set rejection', '[\\q{ab|cd}]', 'a', true],
['invalid class', '[', 'x', false],
['invalid standalone source balanced by wrapper', ')abc(', 'x', false],
['empty pattern', '', 'x', true],
['empty value', '\\d+', '', false],
['supplementary character', '\\p{Emoji}', '\ud83d\ude00', false],
['escaped punctuation', 'a\\.b', 'a.b', false],
['invalid unicode-set punctuation', '[()]', 'x', false],
['absent pattern', null, 'anything', false],
];
const methods = ['validity', 'checkValidity', 'reportValidity', 'validationMessage', 'matches', 'closest', 'elementQuery', 'documentQuery', 'formValidity'];
for (const [ownerName, owner] of realms) for (const flavor of ['live', 'html', 'parsed', 'xml']) {
const doc = flavor === 'live' ? owner.document : flavor === 'html' ? owner.document.implementation.createHTMLDocument('patterns') :
flavor === 'parsed' ? new owner.DOMParser().parseFromString('<!doctype html><body>', 'text/html') :
owner.document.implementation.createDocument(H, 'html');
const holder = (doc.body || doc.documentElement).appendChild(doc.createElementNS(H, 'div'));
const form = holder.appendChild(doc.createElementNS(H, 'form'));
const input = form.appendChild(doc.createElementNS(H, 'input'));
let invalidEvents = 0;
input.addEventListener('invalid', event => {invalidEvents++;event.preventDefault();});
try {
for (const [calleeName, callee] of realms) {
for (const [caseName, pattern, value, expected] of cases) {
input.type = 'text';input.multiple = false;
if (pattern === null) input.removeAttribute('pattern'); else input.pattern = pattern;
input.value = value;
for (const method of methods) {
check(`${ownerName}/${flavor}/${calleeName}/${caseName}/${method}`, () => {
invalidEvents = 0;
const before = seed();
let result;
if (method === 'validity') {
const state = Object.getOwnPropertyDescriptor(callee.HTMLInputElement.prototype, 'validity').get.call(input);
result = state.patternMismatch === expected && state.valid !== expected;
} else if (method === 'checkValidity' || method === 'reportValidity') result = callee.HTMLInputElement.prototype[method].call(input) !== expected;
else if (method === 'validationMessage') result = (Object.getOwnPropertyDescriptor(callee.HTMLInputElement.prototype, 'validationMessage').get.call(input) !== '') === expected;
else if (method === 'matches') result = callee.Element.prototype.matches.call(input, ':invalid') === expected;
else if (method === 'closest') result = callee.Element.prototype.closest.call(input, ':invalid') === (expected ? input : null);
else if (method === 'elementQuery') result = same([...callee.Element.prototype.querySelectorAll.call(holder, 'input:invalid')], expected ? [input] : []);
else if (method === 'documentQuery') result = same([...callee.Document.prototype.querySelectorAll.call(doc, 'input:invalid')], expected ? [input] : []);
else result = callee.HTMLFormElement.prototype.checkValidity.call(form) !== expected;
const fires = expected && ['checkValidity', 'reportValidity', 'formValidity'].includes(method);
return result && invalidEvents === Number(fires) && unchanged(before);
});
}
}
input.type = 'text';input.multiple = false;input.pattern = '(a)\\1';input.value = 'ab';
const selectorCases = [
['input:defined:invalid', true],
['input:is(:defined):invalid', true],
['input:where(:invalid):defined', true],
['input:not(:valid):defined', true],
['input:defined:not(:invalid)', false],
['input:is(:defined,:invalid)', true],
];
for (const [selector, expected] of selectorCases) {
for (const method of ['matches', 'closest', 'elementQuery', 'documentQuery', 'elementQueryAll', 'documentQueryAll']) {
check(`${ownerName}/${flavor}/${calleeName}/selectors/${selector}/${method}`, () => {
invalidEvents = 0;
const before = seed();
let result;
if (method === 'matches') result = callee.Element.prototype.matches.call(input, selector) === expected;
else if (method === 'closest') result = callee.Element.prototype.closest.call(input, selector) === (expected ? input : null);
else if (method === 'elementQuery') result = callee.Element.prototype.querySelector.call(holder, selector) === (expected ? input : null);
else if (method === 'documentQuery') result = callee.Document.prototype.querySelector.call(doc, selector) === (expected ? input : null);
else if (method === 'elementQueryAll') result = same([...callee.Element.prototype.querySelectorAll.call(holder, selector)], expected ? [input] : []);
else result = same([...callee.Document.prototype.querySelectorAll.call(doc, selector)], expected ? [input] : []);
return result && invalidEvents === 0 && unchanged(before);
});
}
}
const unknown = holder.appendChild(doc.createElementNS(H, 'pattern-unknown'));
for (const selector of ['pattern-unknown:defined', 'pattern-unknown:is(:defined,:invalid)']) {
check(`${ownerName}/${flavor}/${calleeName}/undefined/${selector}`, () => {
const before = seed();
return callee.Element.prototype.matches.call(unknown, selector) === false && unchanged(before);
});
}
unknown.remove();
const typed = [
...['text', 'search', 'tel', 'password'].flatMap(type => [[type, '(a)\\1', 'aa', false], [type, '(a)\\1', 'ab', true]]),
['url', 'https://example\\.test/', 'https://example.test/', false],
['url', 'https://example\\.test/', 'https://other.test/', true],
['email', '[a-z]+@example\\.test', 'a@example.test', false],
['email', '[a-z]+@example\\.test', 'a@other.test', true],
...[['number', '123'], ['date', '2026-10-22'], ['color', '#ff0000'], ['range', '50'], ['checkbox', 'x'], ['hidden', 'x']].map(([type, value]) => [type, 'never-matches', value, false]),
];
for (const [type, pattern, value, expected] of typed) {
input.type = type;input.multiple = false;input.pattern = pattern;input.value = value;
check(`${ownerName}/${flavor}/${calleeName}/type/${type}/${value}`, () => {
const before = seed();
const state = Object.getOwnPropertyDescriptor(callee.HTMLInputElement.prototype, 'validity').get.call(input);
return state.patternMismatch === expected && state.valid !== expected &&
callee.HTMLInputElement.prototype.checkValidity.call(input) !== expected && unchanged(before);
});
}
input.type = 'email';input.multiple = true;input.pattern = '[a-z]+@example\\.test';
for (const [value, expected] of [['a@example.test,b@example.test', false], ['a@example.test, b@other.test', true], ['', false]]) {
input.value = value;
check(`${ownerName}/${flavor}/${calleeName}/multiple/${value}`, () => {
const before = seed();
const state = Object.getOwnPropertyDescriptor(callee.HTMLInputElement.prototype, 'validity').get.call(input);
return state.patternMismatch === expected && state.valid !== expected &&
callee.HTMLInputElement.prototype.checkValidity.call(input) !== expected && unchanged(before);
});
}
}
} finally {
// Orphan nodes can remain in a native arena; leave a cheap pattern for
// later selector scans, instead of carrying an adversarial expression.
input.type = 'text';input.multiple = false;input.pattern = '.*';input.value = 'cleanup';holder.remove();
}
}
globalThis.__uiEventResults = {complete: true, total: rows.length, passed: rows.filter(row => row.passed).length, rows};
return rows.every(row => row.passed);
})()
+2
View File
@@ -9,6 +9,7 @@ mod microtasks;
mod object_readers;
mod promises;
mod properties;
mod regexp;
mod strings;
mod symbols;
@@ -23,6 +24,7 @@ pub use microtasks::*;
pub use object_readers::*;
pub use promises::*;
pub use properties::*;
pub use regexp::*;
pub use strings::*;
pub use symbols::*;
+130
View File
@@ -0,0 +1,130 @@
use v8::{Context, Global, Local, PinScope, RegExp, RegExpCreationFlags};
// Blink's ScriptRegexp uses the same budget for user-agent regular expressions.
const NATIVE_REGEXP_BACKTRACK_LIMIT: u32 = 1_000_000;
struct NativeRegExpContext(Global<Context>);
fn native_regexp_context<'s>(scope: &mut PinScope<'s, '_>) -> Local<'s, Context> {
if let Some(context) = scope.get_slot::<NativeRegExpContext>() {
return Local::new(scope, &context.0);
}
// This context contains no author objects. Keeping it in an isolate slot
// shares it across host matches without retaining a page's realm graph.
let context = Context::new(scope, Default::default());
let retained = Global::new(scope, context);
scope.set_slot(NativeRegExpContext(retained));
context
}
/// A bounded user-agent regular expression, isolated from author intrinsics
/// and the observable legacy RegExp statics of every author realm.
pub struct NativeRegExp<'s> {
context: Local<'s, Context>,
regexp: Local<'s, RegExp>,
}
impl<'s> NativeRegExp<'s> {
/// Compile without exposing syntax errors to the surrounding script.
pub fn new(
scope: &mut PinScope<'s, '_>,
pattern: Local<v8::String>,
flags: RegExpCreationFlags,
) -> Option<Self> {
let context = native_regexp_context(scope);
let scope = &mut v8::ContextScope::new(scope, context);
let try_catch = std::pin::pin!(v8::TryCatch::new(scope));
let mut scope = try_catch.init();
let regexp =
RegExp::new_with_backtrack_limit(&scope, pattern, flags, NATIVE_REGEXP_BACKTRACK_LIMIT);
if regexp.is_none() {
scope.reset();
}
regexp.map(|regexp| Self { context, regexp })
}
/// `Some(false)` includes exhausted backtracking budgets. `None` indicates
/// an exceptional execution failure, distinct from a failed match.
pub fn is_match(
&self,
scope: &mut PinScope<'_, '_>,
subject: Local<v8::String>,
) -> Option<bool> {
let scope = &mut v8::ContextScope::new(scope, self.context);
let try_catch = std::pin::pin!(v8::TryCatch::new(scope));
let mut scope = try_catch.init();
let result = self.regexp.exec(&scope, subject);
if result.is_none() {
scope.reset();
}
result.map(|value| !value.is_null())
}
}
#[cfg(test)]
mod tests {
use std::pin::pin;
use super::*;
fn eval<'s>(scope: &mut PinScope<'s, '_>, source: &str) -> Local<'s, v8::Value> {
let source = v8::String::new(scope, source).unwrap();
v8::Script::compile(scope, source, None)
.unwrap()
.run(scope)
.unwrap()
}
#[test]
fn native_regexp_bounds_backtracking_and_keeps_invalid_patterns_distinct() {
moli_v8_test_util::ensure_v8();
let mut isolate = v8::Isolate::new(v8::CreateParams::default());
let scope = pin!(v8::HandleScope::new(&mut isolate));
let scope = &mut scope.init();
let context = Context::new(scope, Default::default());
let scope = &mut v8::ContextScope::new(scope, context);
let source = v8::String::new(scope, "^(?:(\\d+)*)$").unwrap();
let regexp = NativeRegExp::new(scope, source, RegExpCreationFlags::UNICODE_SETS).unwrap();
let matching = v8::String::new(scope, "12345678901234567890123456789123456789").unwrap();
let rejecting = v8::String::new(scope, "12345678901234567890123456789123456789z").unwrap();
assert_eq!(regexp.is_match(scope, matching), Some(true));
assert_eq!(regexp.is_match(scope, rejecting), Some(false));
let invalid = v8::String::new(scope, "[").unwrap();
assert!(NativeRegExp::new(scope, invalid, RegExpCreationFlags::UNICODE_SETS).is_none());
assert!(eval(scope, "true").is_true());
assert_eq!(scope.get_current_context(), context);
}
#[test]
fn native_regexp_does_not_read_author_intrinsics_or_change_realm_statics() {
moli_v8_test_util::ensure_v8();
let mut isolate = v8::Isolate::new(v8::CreateParams::default());
let scope = pin!(v8::HandleScope::new(&mut isolate));
let scope = &mut scope.init();
let contexts = [
Context::new(scope, Default::default()),
Context::new(scope, Default::default()),
];
for context in contexts {
let scope = &mut v8::ContextScope::new(scope, context);
eval(
scope,
r#"
globalThis.originalRegExp = RegExp;
/(sentinel)/.exec('sentinel');
RegExp.prototype.exec = () => { throw new Error('author exec'); };
Object.defineProperty(globalThis, 'RegExp', {
get() { throw new Error('author RegExp'); }
});
"#,
);
let source = v8::String::new(scope, "(different)").unwrap();
let subject = v8::String::new(scope, "different").unwrap();
let regexp =
NativeRegExp::new(scope, source, RegExpCreationFlags::UNICODE_SETS).unwrap();
assert_eq!(regexp.is_match(scope, subject), Some(true));
assert_eq!(scope.get_current_context(), context);
assert!(eval(scope, "originalRegExp.$1 === 'sentinel'").is_true());
}
}
}