AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

[Intl] Add quarter, dayPeriod and fractionalSecondDigits options

Browse Source 
quarter option- see https://github.com/tc39/ecma402/pull/345
dayPeriod option- see https://github.com/tc39/ecma402/pull/346
fractionalSecondDigits option- see https://github.com/tc39/ecma402/pull/347
2019-6-5 TC39 presentation- http://shorturl.at/mtB12
test262: https://github.com/tc39/test262/pull/2194
I2I: http://shorturl.at/beCNV (for quarter)
I2I: http://shorturl.at/bekrZ (for dayPeriod)
I2I: http://shorturl.at/flwF5 (for fractionalSecondDigits)

Bug: v8:9282,v8:9283,v8:9284

Change-Id: I99f4c0f861507c7451497b735a276780bb8aead6
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1621445
Commit-Queue: Frank Tang <ftang@chromium.org>
Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
Cr-Commit-Position: refs/heads/master@{#62041}
This commit is contained in:
Frank Tang 2019-06-06 13:03:12 -07:00 committed by Commit Bot
parent 64ec1e480a
commit 2d43679007
7 changed files with 192 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/flags/flag-definitions.h
View File

@ -209,7 +209,13 @@ DEFINE_IMPLICATION(harmony_import_meta, harmony_dynamic_import)
V(harmony_weak_refs, "harmony weak references")
#ifdef V8_INTL_SUPPORT
#define HARMONY_INPROGRESS(V) HARMONY_INPROGRESS_BASE(V)
#define HARMONY_INPROGRESS(V) \
HARMONY_INPROGRESS_BASE(V) \
V(harmony_intl_dateformat_day_period, \
"Add dayPeriod option to DateTimeFormat") \
V(harmony_intl_dateformat_fractional_second_digits, \
"Add fractionalSecondDigits option to DateTimeFormat") \
V(harmony_intl_dateformat_quarter, "Add quarter option to DateTimeFormat")
#else
#define HARMONY_INPROGRESS(V) HARMONY_INPROGRESS_BASE(V)
#endif

4
src/init/bootstrapper.cc
View File

@ -4236,6 +4236,10 @@ EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_hashbang)
#ifdef V8_INTL_SUPPORT
EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_intl_add_calendar_numbering_system)
EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_intl_bigint)
EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_intl_dateformat_day_period)
EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(
harmony_intl_dateformat_fractional_second_digits)
EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_intl_dateformat_quarter)
EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_intl_datetime_style)
EMPTY_INITIALIZE_GLOBAL_FOR_FEATURE(harmony_intl_numberformat_unified)
#endif // V8_INTL_SUPPORT

2
src/init/heap-symbols.h
View File

@ -31,11 +31,13 @@
V(_, era_string, "era") \
V(_, first_string, "first") \
V(_, format_string, "format") \
V(_, fractionalSecond_string, "fractionalSecond") \
V(_, except_zero_string, "except-zero") \
V(_, exponentInteger_string, "exponentInteger") \
V(_, exponentMinusSign_string, "exponentMinusSign") \
V(_, exponentSeparator_string, "exponentSeparator") \
V(_, fraction_string, "fraction") \
V(_, fractionalSecondDigits_string, "fractionalSecondDigits") \
V(_, full_string, "full") \
V(_, granularity_string, "granularity") \
V(_, grapheme_string, "grapheme") \

38
src/objects/intl-objects.cc
View File

@ -1117,10 +1117,12 @@ Maybe<int> DefaultNumberOption(Isolate* isolate, Handle<Object> value, int min,
return Just(FastD2I(floor(value_num->Number())));
}
} // namespace
// ecma402/#sec-getnumberoption
Maybe<int> GetNumberOption(Isolate* isolate, Handle<JSReceiver> options,
Handle<String> property, int min, int max,
int fallback) {
Maybe<int> Intl::GetNumberOption(Isolate* isolate, Handle<JSReceiver> options,
Handle<String> property, int min, int max,
int fallback) {
// 1. Let value be ? Get(options, property).
Handle<Object> value;
ASSIGN_RETURN_ON_EXCEPTION_VALUE(
@ -1131,25 +1133,17 @@ Maybe<int> GetNumberOption(Isolate* isolate, Handle<JSReceiver> options,
return DefaultNumberOption(isolate, value, min, max, fallback, property);
}
Maybe<int> GetNumberOption(Isolate* isolate, Handle<JSReceiver> options,
const char* property, int min, int max,
int fallback) {
Handle<String> property_str =
isolate->factory()->NewStringFromAsciiChecked(property);
return GetNumberOption(isolate, options, property_str, min, max, fallback);
}
} // namespace
Maybe<Intl::NumberFormatDigitOptions> Intl::SetNumberFormatDigitOptions(
Isolate* isolate, Handle<JSReceiver> options, int mnfd_default,
int mxfd_default) {
Factory* factory = isolate->factory();
Intl::NumberFormatDigitOptions digit_options;
// 5. Let mnid be ? GetNumberOption(options, "minimumIntegerDigits,", 1, 21,
// 1).
int mnid;
if (!GetNumberOption(isolate, options, "minimumIntegerDigits", 1, 21, 1)
if (!Intl::GetNumberOption(isolate, options,
factory->minimumIntegerDigits_string(), 1, 21, 1)
.To(&mnid)) {
return Nothing<NumberFormatDigitOptions>();
}
@ -1157,8 +1151,9 @@ Maybe<Intl::NumberFormatDigitOptions> Intl::SetNumberFormatDigitOptions(
// 6. Let mnfd be ? GetNumberOption(options, "minimumFractionDigits", 0, 20,
// mnfdDefault).
int mnfd;
if (!GetNumberOption(isolate, options, "minimumFractionDigits", 0, 20,
mnfd_default)
if (!Intl::GetNumberOption(isolate, options,
factory->minimumFractionDigits_string(), 0, 20,
mnfd_default)
.To(&mnfd)) {
return Nothing<NumberFormatDigitOptions>();
}
@ -1169,24 +1164,23 @@ Maybe<Intl::NumberFormatDigitOptions> Intl::SetNumberFormatDigitOptions(
// 8. Let mxfd be ? GetNumberOption(options,
// "maximumFractionDigits", mnfd, 20, mxfdActualDefault).
int mxfd;
if (!GetNumberOption(isolate, options, "maximumFractionDigits", mnfd, 20,
mxfd_actual_default)
if (!Intl::GetNumberOption(isolate, options,
factory->maximumFractionDigits_string(), mnfd, 20,
mxfd_actual_default)
.To(&mxfd)) {
return Nothing<NumberFormatDigitOptions>();
}
// 9. Let mnsd be ? Get(options, "minimumSignificantDigits").
Handle<Object> mnsd_obj;
Handle<String> mnsd_str =
isolate->factory()->minimumSignificantDigits_string();
Handle<String> mnsd_str = factory->minimumSignificantDigits_string();
ASSIGN_RETURN_ON_EXCEPTION_VALUE(
isolate, mnsd_obj, JSReceiver::GetProperty(isolate, options, mnsd_str),
Nothing<NumberFormatDigitOptions>());
// 10. Let mxsd be ? Get(options, "maximumSignificantDigits").
Handle<Object> mxsd_obj;
Handle<String> mxsd_str =
isolate->factory()->maximumSignificantDigits_string();
Handle<String> mxsd_str = factory->maximumSignificantDigits_string();
ASSIGN_RETURN_ON_EXCEPTION_VALUE(
isolate, mxsd_obj, JSReceiver::GetProperty(isolate, options, mxsd_str),
Nothing<NumberFormatDigitOptions>());

4
src/objects/intl-objects.h
View File

@ -126,6 +126,10 @@ class Intl {
Isolate* isolate, Handle<JSReceiver> options, const char* property,
const char* service, bool* result);
V8_EXPORT_PRIVATE V8_WARN_UNUSED_RESULT static Maybe<int> GetNumberOption(
Isolate* isolate, Handle<JSReceiver> options, Handle<String> property,
int min, int max, int fallback);
// Canonicalize the locale.
// https://tc39.github.io/ecma402/#sec-canonicalizelanguagetag,
// including type check and structural validity check.

160
src/objects/js-date-time-format.cc
View File

@ -56,13 +56,13 @@ class PatternItem {
std::vector<const char*> allowed_values;
};
static const std::vector<PatternItem> BuildPatternItems() {
static std::vector<PatternItem> BuildPatternItems() {
const std::vector<const char*> kLongShort = {"long", "short"};
const std::vector<const char*> kNarrowLongShort = {"narrow", "long", "short"};
const std::vector<const char*> k2DigitNumeric = {"2-digit", "numeric"};
const std::vector<const char*> kNarrowLongShort2DigitNumeric = {
"narrow", "long", "short", "2-digit", "numeric"};
const std::vector<PatternItem> kPatternItems = {
std::vector<PatternItem> items = {
PatternItem("weekday",
{{"EEEEE", "narrow"},
{"EEEE", "long"},
@ -75,38 +75,59 @@ static const std::vector<PatternItem> BuildPatternItems() {
{{"GGGGG", "narrow"}, {"GGGG", "long"}, {"GGG", "short"}},
kNarrowLongShort),
PatternItem("year", {{"yy", "2-digit"}, {"y", "numeric"}},
k2DigitNumeric),
// Sometimes we get L instead of M for month - standalone name.
PatternItem("month",
{{"MMMMM", "narrow"},
{"MMMM", "long"},
{"MMM", "short"},
{"MM", "2-digit"},
{"M", "numeric"},
{"LLLLL", "narrow"},
{"LLLL", "long"},
{"LLL", "short"},
{"LL", "2-digit"},
{"L", "numeric"}},
kNarrowLongShort2DigitNumeric),
PatternItem("day", {{"dd", "2-digit"}, {"d", "numeric"}}, k2DigitNumeric),
PatternItem("hour",
{{"HH", "2-digit"},
{"H", "numeric"},
{"hh", "2-digit"},
{"h", "numeric"},
{"kk", "2-digit"},
{"k", "numeric"},
{"KK", "2-digit"},
{"K", "numeric"}},
k2DigitNumeric),
PatternItem("minute", {{"mm", "2-digit"}, {"m", "numeric"}},
k2DigitNumeric),
PatternItem("second", {{"ss", "2-digit"}, {"s", "numeric"}},
k2DigitNumeric),
PatternItem("timeZoneName", {{"zzzz", "long"}, {"z", "short"}},
kLongShort)};
return kPatternItems;
k2DigitNumeric)};
if (FLAG_harmony_intl_dateformat_quarter) {
items.push_back(PatternItem("quarter",
{{"QQQQQ", "narrow"},
{"QQQQ", "long"},
{"QQQ", "short"},
{"qqqqq", "narrow"},
{"qqqq", "long"},
{"qqq", "short"}},
kNarrowLongShort));
}
// Sometimes we get L instead of M for month - standalone name.
items.push_back(PatternItem("month",
{{"MMMMM", "narrow"},
{"MMMM", "long"},
{"MMM", "short"},
{"MM", "2-digit"},
{"M", "numeric"},
{"LLLLL", "narrow"},
{"LLLL", "long"},
{"LLL", "short"},
{"LL", "2-digit"},
{"L", "numeric"}},
kNarrowLongShort2DigitNumeric));
items.push_back(PatternItem("day", {{"dd", "2-digit"}, {"d", "numeric"}},
k2DigitNumeric));
if (FLAG_harmony_intl_dateformat_day_period) {
items.push_back(PatternItem("dayPeriod",
{{"BBBBB", "narrow"},
{"bbbbb", "narrow"},
{"BBBB", "long"},
{"bbbb", "long"},
{"B", "short"},
{"b", "short"}},
kNarrowLongShort));
}
items.push_back(PatternItem("hour",
{{"HH", "2-digit"},
{"H", "numeric"},
{"hh", "2-digit"},
{"h", "numeric"},
{"kk", "2-digit"},
{"k", "numeric"},
{"KK", "2-digit"},
{"K", "numeric"}},
k2DigitNumeric));
items.push_back(PatternItem("minute", {{"mm", "2-digit"}, {"m", "numeric"}},
k2DigitNumeric));
items.push_back(PatternItem("second", {{"ss", "2-digit"}, {"s", "numeric"}},
k2DigitNumeric));
items.push_back(PatternItem("timeZoneName",
{{"zzzz", "long"}, {"z", "short"}}, kLongShort));
return items;
}
class PatternItems {
@ -348,6 +369,16 @@ Handle<String> DateTimeStyleAsString(Isolate* isolate,
}
}
int FractionalSecondDigitsFromPattern(const std::string& pattern) {
int result = 0;
for (size_t i = 0; i < pattern.length() && result < 3; i++) {
if (pattern[i] == 'S') {
result++;
}
}
return result;
}
} // namespace
// ecma402 #sec-intl.datetimeformat.prototype.resolvedoptions
@ -532,6 +563,13 @@ MaybeHandle<JSObject> JSDateTimeFormat::ResolvedOptions(
Just(kDontThrow))
.FromJust());
}
if (FLAG_harmony_intl_dateformat_fractional_second_digits) {
int fsd = FractionalSecondDigitsFromPattern(pattern);
CHECK(JSReceiver::CreateDataProperty(
isolate, options, factory->fractionalSecondDigits_string(),
factory->NewNumberFromInt(fsd), Just(kDontThrow))
.FromJust());
}
return options;
}
@ -669,27 +707,23 @@ MaybeHandle<String> JSDateTimeFormat::ToLocaleDateTime(
namespace {
Maybe<bool> IsPropertyUndefined(Isolate* isolate, Handle<JSObject> options,
const char* property) {
Factory* factory = isolate->factory();
Handle<String> property) {
// i. Let prop be the property name.
// ii. Let value be ? Get(options, prop).
Handle<Object> value;
ASSIGN_RETURN_ON_EXCEPTION_VALUE(
isolate, value,
Object::GetPropertyOrElement(
isolate, options, factory->NewStringFromAsciiChecked(property)),
isolate, value, Object::GetPropertyOrElement(isolate, options, property),
Nothing<bool>());
return Just(value->IsUndefined(isolate));
}
Maybe<bool> NeedsDefault(Isolate* isolate, Handle<JSObject> options,
const std::vector<std::string>& props) {
const std::vector<Handle<String>>& props) {
bool needs_default = true;
for (const auto& prop : props) {
// i. Let prop be the property name.
// ii. Let value be ? Get(options, prop)
Maybe<bool> maybe_undefined =
IsPropertyUndefined(isolate, options, prop.c_str());
Maybe<bool> maybe_undefined = IsPropertyUndefined(isolate, options, prop);
MAYBE_RETURN(maybe_undefined, Nothing<bool>());
// iii. If value is not undefined, let needDefaults be false.
if (!maybe_undefined.FromJust()) {
@ -741,8 +775,15 @@ MaybeHandle<JSObject> JSDateTimeFormat::ToDateTimeOptions(
// 4. If required is "date" or "any", then
if (required == RequiredOption::kAny || required == RequiredOption::kDate) {
// a. For each of the property names "weekday", "year", "month", "day", do
const std::vector<std::string> list({"weekday", "year", "month", "day"});
// a. For each of the property names "weekday", "year", "quarter", "month",
// "day", do
std::vector<Handle<String>> list(
{factory->weekday_string(), factory->year_string()});
if (FLAG_harmony_intl_dateformat_quarter) {
list.push_back(factory->quarter_string());
}
list.push_back(factory->month_string());
list.push_back(factory->day_string());
Maybe<bool> maybe_needs_default = NeedsDefault(isolate, options, list);
MAYBE_RETURN(maybe_needs_default, Handle<JSObject>());
needs_default = maybe_needs_default.FromJust();
@ -750,8 +791,18 @@ MaybeHandle<JSObject> JSDateTimeFormat::ToDateTimeOptions(
// 5. If required is "time" or "any", then
if (required == RequiredOption::kAny || required == RequiredOption::kTime) {
// a. For each of the property names "hour", "minute", "second", do
const std::vector<std::string> list({"hour", "minute", "second"});
// a. For each of the property names "dayPeriod", "hour", "minute",
// "second", "fractionalSecondDigits", do
std::vector<Handle<String>> list;
if (FLAG_harmony_intl_dateformat_day_period) {
list.push_back(factory->dayPeriod_string());
}
list.push_back(factory->hour_string());
list.push_back(factory->minute_string());
list.push_back(factory->second_string());
if (FLAG_harmony_intl_dateformat_fractional_second_digits) {
list.push_back(factory->fractionalSecondDigits_string());
}
Maybe<bool> maybe_needs_default = NeedsDefault(isolate, options, list);
MAYBE_RETURN(maybe_needs_default, Handle<JSObject>());
needs_default &= maybe_needs_default.FromJust();
@ -1419,6 +1470,16 @@ MaybeHandle<JSDateTimeFormat> JSDateTimeFormat::Initialize(
skeleton += item.map.find(input.get())->second;
}
}
if (FLAG_harmony_intl_dateformat_fractional_second_digits) {
Maybe<int> maybe_fsd = Intl::GetNumberOption(
isolate, options, factory->fractionalSecondDigits_string(), 0, 3, 0);
MAYBE_RETURN(maybe_fsd, MaybeHandle<JSDateTimeFormat>());
// Convert fractionalSecondDigits to skeleton.
int fsd = maybe_fsd.FromJust();
for (int i = 0; i < fsd; i++) {
skeleton += "S";
}
}
enum FormatMatcherOption { kBestFit, kBasic };
// We implement only best fit algorithm, but still need to check
@ -1516,6 +1577,9 @@ Handle<String> IcuDateFieldIdToDateType(int32_t field_id, Isolate* isolate) {
case UDAT_EXTENDED_YEAR_FIELD:
case UDAT_YEAR_NAME_FIELD:
return isolate->factory()->year_string();
case UDAT_QUARTER_FIELD:
case UDAT_STANDALONE_QUARTER_FIELD:
return isolate->factory()->quarter_string();
case UDAT_MONTH_FIELD:
case UDAT_STANDALONE_MONTH_FIELD:
return isolate->factory()->month_string();
@ -1535,6 +1599,8 @@ Handle<String> IcuDateFieldIdToDateType(int32_t field_id, Isolate* isolate) {
case UDAT_STANDALONE_DAY_FIELD:
return isolate->factory()->weekday_string();
case UDAT_AM_PM_FIELD:
case UDAT_AM_PM_MIDNIGHT_NOON_FIELD:
case UDAT_FLEXIBLE_DAY_PERIOD_FIELD:
return isolate->factory()->dayPeriod_string();
case UDAT_TIMEZONE_FIELD:
case UDAT_TIMEZONE_RFC_FIELD:
@ -1546,6 +1612,8 @@ Handle<String> IcuDateFieldIdToDateType(int32_t field_id, Isolate* isolate) {
return isolate->factory()->timeZoneName_string();
case UDAT_ERA_FIELD:
return isolate->factory()->era_string();
case UDAT_FRACTIONAL_SECOND_FIELD:
return isolate->factory()->fractionalSecond_string();
default:
// Other UDAT_*_FIELD's cannot show up because there is no way to specify
// them via options of Intl.DateTimeFormat.

90
tools/v8heapconst.py
View File

@ -286,51 +286,51 @@ KNOWN_MAPS = {
("read_only_space", 0x02371): (87, "EnumCacheMap"),
("read_only_space", 0x02411): (105, "ArrayBoilerplateDescriptionMap"),
("read_only_space", 0x02601): (90, "InterceptorInfoMap"),
("read_only_space", 0x04d99): (78, "AccessCheckInfoMap"),
("read_only_space", 0x04de9): (79, "AccessorInfoMap"),
("read_only_space", 0x04e39): (80, "AccessorPairMap"),
("read_only_space", 0x04e89): (81, "AliasedArgumentsEntryMap"),
("read_only_space", 0x04ed9): (82, "AllocationMementoMap"),
("read_only_space", 0x04f29): (83, "AsmWasmDataMap"),
("read_only_space", 0x04f79): (84, "AsyncGeneratorRequestMap"),
("read_only_space", 0x04fc9): (85, "ClassPositionsMap"),
("read_only_space", 0x05019): (86, "DebugInfoMap"),
("read_only_space", 0x05069): (88, "FunctionTemplateInfoMap"),
("read_only_space", 0x050b9): (89, "FunctionTemplateRareDataMap"),
("read_only_space", 0x05109): (91, "InterpreterDataMap"),
("read_only_space", 0x05159): (92, "ModuleInfoEntryMap"),
("read_only_space", 0x051a9): (93, "ModuleMap"),
("read_only_space", 0x051f9): (94, "ObjectTemplateInfoMap"),
("read_only_space", 0x05249): (95, "PromiseCapabilityMap"),
("read_only_space", 0x05299): (96, "PromiseReactionMap"),
("read_only_space", 0x052e9): (97, "PrototypeInfoMap"),
("read_only_space", 0x05339): (98, "ScriptMap"),
("read_only_space", 0x05389): (99, "SourcePositionTableWithFrameCacheMap"),
("read_only_space", 0x053d9): (100, "StackFrameInfoMap"),
("read_only_space", 0x05429): (101, "StackTraceFrameMap"),
("read_only_space", 0x05479): (102, "TemplateObjectDescriptionMap"),
("read_only_space", 0x054c9): (103, "Tuple2Map"),
("read_only_space", 0x05519): (104, "Tuple3Map"),
("read_only_space", 0x05569): (106, "WasmCapiFunctionDataMap"),
("read_only_space", 0x055b9): (107, "WasmDebugInfoMap"),
("read_only_space", 0x05609): (108, "WasmExceptionTagMap"),
("read_only_space", 0x05659): (109, "WasmExportedFunctionDataMap"),
("read_only_space", 0x056a9): (110, "WasmJSFunctionDataMap"),
("read_only_space", 0x056f9): (111, "CallableTaskMap"),
("read_only_space", 0x05749): (112, "CallbackTaskMap"),
("read_only_space", 0x05799): (113, "PromiseFulfillReactionJobTaskMap"),
("read_only_space", 0x057e9): (114, "PromiseRejectReactionJobTaskMap"),
("read_only_space", 0x05839): (115, "PromiseResolveThenableJobTaskMap"),
("read_only_space", 0x05889): (116, "FinalizationGroupCleanupJobTaskMap"),
("read_only_space", 0x058d9): (117, "AllocationSiteWithWeakNextMap"),
("read_only_space", 0x05929): (117, "AllocationSiteWithoutWeakNextMap"),
("read_only_space", 0x05979): (152, "LoadHandler1Map"),
("read_only_space", 0x059c9): (152, "LoadHandler2Map"),
("read_only_space", 0x05a19): (152, "LoadHandler3Map"),
("read_only_space", 0x05a69): (160, "StoreHandler0Map"),
("read_only_space", 0x05ab9): (160, "StoreHandler1Map"),
("read_only_space", 0x05b09): (160, "StoreHandler2Map"),
("read_only_space", 0x05b59): (160, "StoreHandler3Map"),
("read_only_space", 0x04de1): (78, "AccessCheckInfoMap"),
("read_only_space", 0x04e31): (79, "AccessorInfoMap"),
("read_only_space", 0x04e81): (80, "AccessorPairMap"),
("read_only_space", 0x04ed1): (81, "AliasedArgumentsEntryMap"),
("read_only_space", 0x04f21): (82, "AllocationMementoMap"),
("read_only_space", 0x04f71): (83, "AsmWasmDataMap"),
("read_only_space", 0x04fc1): (84, "AsyncGeneratorRequestMap"),
("read_only_space", 0x05011): (85, "ClassPositionsMap"),
("read_only_space", 0x05061): (86, "DebugInfoMap"),
("read_only_space", 0x050b1): (88, "FunctionTemplateInfoMap"),
("read_only_space", 0x05101): (89, "FunctionTemplateRareDataMap"),
("read_only_space", 0x05151): (91, "InterpreterDataMap"),
("read_only_space", 0x051a1): (92, "ModuleInfoEntryMap"),
("read_only_space", 0x051f1): (93, "ModuleMap"),
("read_only_space", 0x05241): (94, "ObjectTemplateInfoMap"),
("read_only_space", 0x05291): (95, "PromiseCapabilityMap"),
("read_only_space", 0x052e1): (96, "PromiseReactionMap"),
("read_only_space", 0x05331): (97, "PrototypeInfoMap"),
("read_only_space", 0x05381): (98, "ScriptMap"),
("read_only_space", 0x053d1): (99, "SourcePositionTableWithFrameCacheMap"),
("read_only_space", 0x05421): (100, "StackFrameInfoMap"),
("read_only_space", 0x05471): (101, "StackTraceFrameMap"),
("read_only_space", 0x054c1): (102, "TemplateObjectDescriptionMap"),
("read_only_space", 0x05511): (103, "Tuple2Map"),
("read_only_space", 0x05561): (104, "Tuple3Map"),
("read_only_space", 0x055b1): (106, "WasmCapiFunctionDataMap"),
("read_only_space", 0x05601): (107, "WasmDebugInfoMap"),
("read_only_space", 0x05651): (108, "WasmExceptionTagMap"),
("read_only_space", 0x056a1): (109, "WasmExportedFunctionDataMap"),
("read_only_space", 0x056f1): (110, "WasmJSFunctionDataMap"),
("read_only_space", 0x05741): (111, "CallableTaskMap"),
("read_only_space", 0x05791): (112, "CallbackTaskMap"),
("read_only_space", 0x057e1): (113, "PromiseFulfillReactionJobTaskMap"),
("read_only_space", 0x05831): (114, "PromiseRejectReactionJobTaskMap"),
("read_only_space", 0x05881): (115, "PromiseResolveThenableJobTaskMap"),
("read_only_space", 0x058d1): (116, "FinalizationGroupCleanupJobTaskMap"),
("read_only_space", 0x05921): (117, "AllocationSiteWithWeakNextMap"),
("read_only_space", 0x05971): (117, "AllocationSiteWithoutWeakNextMap"),
("read_only_space", 0x059c1): (152, "LoadHandler1Map"),
("read_only_space", 0x05a11): (152, "LoadHandler2Map"),
("read_only_space", 0x05a61): (152, "LoadHandler3Map"),
("read_only_space", 0x05ab1): (160, "StoreHandler0Map"),
("read_only_space", 0x05b01): (160, "StoreHandler1Map"),
("read_only_space", 0x05b51): (160, "StoreHandler2Map"),
("read_only_space", 0x05ba1): (160, "StoreHandler3Map"),
("map_space", 0x00139): (1057, "ExternalMap"),
("map_space", 0x00189): (1073, "JSMessageObjectMap"),
}