Skip to content

Instantly share code, notes, and snippets.

@andreabadesso

andreabadesso/gist:03e5617667c9456e803092a82ca249d5

Created October 23, 2024 22:02
Show Gist options
  • Save andreabadesso/03e5617667c9456e803092a82ca249d5 to your computer and use it in GitHub Desktop.
Save andreabadesso/03e5617667c9456e803092a82ca249d5 to your computer and use it in GitHub Desktop.
Download ZIP
React-native, lavamoat + re.pack
Raw
gistfile1.txt
This file has been truncated, but you can view the full file.
/*! SES sources included by LavaMoat. Do not optimize or minify. */
;
// [email protected]
'use strict';
(functors => {
const cell = (name, value = undefined) => {
const observers = [];
return Object.freeze({
get: Object.freeze(() => {
return value;
}),
set: Object.freeze((newValue) => {
value = newValue;
for (const observe of observers) {
observe(value);
}
}),
observe: Object.freeze((observe) => {
observers.push(observe);
observe(value);
}),
enumerable: true,
});
};
const cells = [
{
globalThis: cell("globalThis"),
Array: cell("Array"),
Date: cell("Date"),
FinalizationRegistry: cell("FinalizationRegistry"),
Float32Array: cell("Float32Array"),
JSON: cell("JSON"),
Map: cell("Map"),
Math: cell("Math"),
Number: cell("Number"),
Object: cell("Object"),
Promise: cell("Promise"),
Proxy: cell("Proxy"),
Reflect: cell("Reflect"),
FERAL_REG_EXP: cell("FERAL_REG_EXP"),
Set: cell("Set"),
String: cell("String"),
Symbol: cell("Symbol"),
WeakMap: cell("WeakMap"),
WeakSet: cell("WeakSet"),
FERAL_ERROR: cell("FERAL_ERROR"),
RangeError: cell("RangeError"),
ReferenceError: cell("ReferenceError"),
SyntaxError: cell("SyntaxError"),
TypeError: cell("TypeError"),
AggregateError: cell("AggregateError"),
assign: cell("assign"),
create: cell("create"),
defineProperties: cell("defineProperties"),
entries: cell("entries"),
freeze: cell("freeze"),
getOwnPropertyDescriptor: cell("getOwnPropertyDescriptor"),
getOwnPropertyDescriptors: cell("getOwnPropertyDescriptors"),
getOwnPropertyNames: cell("getOwnPropertyNames"),
getPrototypeOf: cell("getPrototypeOf"),
is: cell("is"),
isFrozen: cell("isFrozen"),
isSealed: cell("isSealed"),
isExtensible: cell("isExtensible"),
keys: cell("keys"),
objectPrototype: cell("objectPrototype"),
seal: cell("seal"),
preventExtensions: cell("preventExtensions"),
setPrototypeOf: cell("setPrototypeOf"),
values: cell("values"),
fromEntries: cell("fromEntries"),
speciesSymbol: cell("speciesSymbol"),
toStringTagSymbol: cell("toStringTagSymbol"),
iteratorSymbol: cell("iteratorSymbol"),
matchAllSymbol: cell("matchAllSymbol"),
unscopablesSymbol: cell("unscopablesSymbol"),
symbolKeyFor: cell("symbolKeyFor"),
symbolFor: cell("symbolFor"),
isInteger: cell("isInteger"),
stringifyJson: cell("stringifyJson"),
defineProperty: cell("defineProperty"),
apply: cell("apply"),
construct: cell("construct"),
reflectGet: cell("reflectGet"),
reflectGetOwnPropertyDescriptor: cell("reflectGetOwnPropertyDescriptor"),
reflectHas: cell("reflectHas"),
reflectIsExtensible: cell("reflectIsExtensible"),
ownKeys: cell("ownKeys"),
reflectPreventExtensions: cell("reflectPreventExtensions"),
reflectSet: cell("reflectSet"),
isArray: cell("isArray"),
arrayPrototype: cell("arrayPrototype"),
mapPrototype: cell("mapPrototype"),
proxyRevocable: cell("proxyRevocable"),
regexpPrototype: cell("regexpPrototype"),
setPrototype: cell("setPrototype"),
stringPrototype: cell("stringPrototype"),
weakmapPrototype: cell("weakmapPrototype"),
weaksetPrototype: cell("weaksetPrototype"),
functionPrototype: cell("functionPrototype"),
promisePrototype: cell("promisePrototype"),
generatorPrototype: cell("generatorPrototype"),
iteratorPrototype: cell("iteratorPrototype"),
typedArrayPrototype: cell("typedArrayPrototype"),
uncurryThis: cell("uncurryThis"),
objectHasOwnProperty: cell("objectHasOwnProperty"),
arrayFilter: cell("arrayFilter"),
arrayForEach: cell("arrayForEach"),
arrayIncludes: cell("arrayIncludes"),
arrayJoin: cell("arrayJoin"),
arrayMap: cell("arrayMap"),
arrayFlatMap: cell("arrayFlatMap"),
arrayPop: cell("arrayPop"),
arrayPush: cell("arrayPush"),
arraySlice: cell("arraySlice"),
arraySome: cell("arraySome"),
arraySort: cell("arraySort"),
iterateArray: cell("iterateArray"),
mapSet: cell("mapSet"),
mapGet: cell("mapGet"),
mapHas: cell("mapHas"),
mapDelete: cell("mapDelete"),
mapEntries: cell("mapEntries"),
iterateMap: cell("iterateMap"),
setAdd: cell("setAdd"),
setDelete: cell("setDelete"),
setForEach: cell("setForEach"),
setHas: cell("setHas"),
iterateSet: cell("iterateSet"),
regexpTest: cell("regexpTest"),
regexpExec: cell("regexpExec"),
matchAllRegExp: cell("matchAllRegExp"),
stringEndsWith: cell("stringEndsWith"),
stringIncludes: cell("stringIncludes"),
stringIndexOf: cell("stringIndexOf"),
stringMatch: cell("stringMatch"),
generatorNext: cell("generatorNext"),
generatorThrow: cell("generatorThrow"),
stringReplace: cell("stringReplace"),
stringSearch: cell("stringSearch"),
stringSlice: cell("stringSlice"),
stringSplit: cell("stringSplit"),
stringStartsWith: cell("stringStartsWith"),
iterateString: cell("iterateString"),
weakmapDelete: cell("weakmapDelete"),
weakmapGet: cell("weakmapGet"),
weakmapHas: cell("weakmapHas"),
weakmapSet: cell("weakmapSet"),
weaksetAdd: cell("weaksetAdd"),
weaksetHas: cell("weaksetHas"),
functionToString: cell("functionToString"),
functionBind: cell("functionBind"),
promiseAll: cell("promiseAll"),
promiseCatch: cell("promiseCatch"),
promiseThen: cell("promiseThen"),
finalizationRegistryRegister: cell("finalizationRegistryRegister"),
finalizationRegistryUnregister: cell("finalizationRegistryUnregister"),
getConstructorOf: cell("getConstructorOf"),
immutableObject: cell("immutableObject"),
isObject: cell("isObject"),
isError: cell("isError"),
FERAL_EVAL: cell("FERAL_EVAL"),
FERAL_FUNCTION: cell("FERAL_FUNCTION"),
noEvalEvaluate: cell("noEvalEvaluate"),
FERAL_STACK_GETTER: cell("FERAL_STACK_GETTER"),
FERAL_STACK_SETTER: cell("FERAL_STACK_SETTER"),
},
{
},
{
makeEnvironmentCaptor: cell("makeEnvironmentCaptor"),
getEnvironmentOption: cell("getEnvironmentOption"),
getEnvironmentOptionsList: cell("getEnvironmentOptionsList"),
environmentOptionsListHas: cell("environmentOptionsListHas"),
},
{
},
{
an: cell("an"),
bestEffortStringify: cell("bestEffortStringify"),
enJoin: cell("enJoin"),
},
{
},
{
},
{
makeLRUCacheMap: cell("makeLRUCacheMap"),
},
{
makeNoteLogArgsArrayKit: cell("makeNoteLogArgsArrayKit"),
},
{
q: cell("q"),
b: cell("b"),
X: cell("X"),
unredactedDetails: cell("unredactedDetails"),
makeError: cell("makeError"),
annotateError: cell("annotateError"),
loggedErrorHandler: cell("loggedErrorHandler"),
makeAssert: cell("makeAssert"),
assert: cell("assert"),
assertEqual: cell("assertEqual"),
sanitizeError: cell("sanitizeError"),
},
{
isTypedArray: cell("isTypedArray"),
makeHardener: cell("makeHardener"),
},
{
NativeErrors: cell("NativeErrors"),
constantProperties: cell("constantProperties"),
universalPropertyNames: cell("universalPropertyNames"),
initialGlobalPropertyNames: cell("initialGlobalPropertyNames"),
sharedGlobalPropertyNames: cell("sharedGlobalPropertyNames"),
uniqueGlobalPropertyNames: cell("uniqueGlobalPropertyNames"),
FunctionInstance: cell("FunctionInstance"),
AsyncFunctionInstance: cell("AsyncFunctionInstance"),
isAccessorPermit: cell("isAccessorPermit"),
permitted: cell("permitted"),
},
{
makeIntrinsicsCollector: cell("makeIntrinsicsCollector"),
getGlobalIntrinsics: cell("getGlobalIntrinsics"),
},
{
default: cell("default"),
},
{
default: cell("default"),
},
{
default: cell("default"),
},
{
default: cell("default"),
},
{
default: cell("default"),
},
{
minEnablements: cell("minEnablements"),
moderateEnablements: cell("moderateEnablements"),
severeEnablements: cell("severeEnablements"),
},
{
default: cell("default"),
},
{
default: cell("default"),
},
{
makeEvalFunction: cell("makeEvalFunction"),
},
{
makeFunctionConstructor: cell("makeFunctionConstructor"),
},
{
setGlobalObjectSymbolUnscopables: cell("setGlobalObjectSymbolUnscopables"),
setGlobalObjectConstantProperties: cell("setGlobalObjectConstantProperties"),
setGlobalObjectMutableProperties: cell("setGlobalObjectMutableProperties"),
setGlobalObjectEvaluators: cell("setGlobalObjectEvaluators"),
},
{
alwaysThrowHandler: cell("alwaysThrowHandler"),
strictScopeTerminatorHandler: cell("strictScopeTerminatorHandler"),
strictScopeTerminator: cell("strictScopeTerminator"),
},
{
createSloppyGlobalsScopeTerminator: cell("createSloppyGlobalsScopeTerminator"),
},
{
makeEvalScopeKit: cell("makeEvalScopeKit"),
},
{
getSourceURL: cell("getSourceURL"),
},
{
rejectHtmlComments: cell("rejectHtmlComments"),
evadeHtmlCommentTest: cell("evadeHtmlCommentTest"),
rejectImportExpressions: cell("rejectImportExpressions"),
evadeImportExpressionTest: cell("evadeImportExpressionTest"),
rejectSomeDirectEvalExpressions: cell("rejectSomeDirectEvalExpressions"),
mandatoryTransforms: cell("mandatoryTransforms"),
applyTransforms: cell("applyTransforms"),
transforms: cell("transforms"),
},
{
isValidIdentifierName: cell("isValidIdentifierName"),
getScopeConstants: cell("getScopeConstants"),
},
{
makeEvaluate: cell("makeEvaluate"),
},
{
makeSafeEvaluator: cell("makeSafeEvaluator"),
},
{
tameFunctionToString: cell("tameFunctionToString"),
},
{
tameDomains: cell("tameDomains"),
},
{
consoleLevelMethods: cell("consoleLevelMethods"),
consoleOtherMethods: cell("consoleOtherMethods"),
makeLoggingConsoleKit: cell("makeLoggingConsoleKit"),
pumpLogToConsole: cell("pumpLogToConsole"),
makeCausalConsole: cell("makeCausalConsole"),
defineCausalConsoleFromLogger: cell("defineCausalConsoleFromLogger"),
filterConsole: cell("filterConsole"),
},
{
makeRejectionHandlers: cell("makeRejectionHandlers"),
},
{
tameConsole: cell("tameConsole"),
},
{
filterFileName: cell("filterFileName"),
shortenCallSiteString: cell("shortenCallSiteString"),
tameV8ErrorConstructor: cell("tameV8ErrorConstructor"),
},
{
default: cell("default"),
},
{
makeAlias: cell("makeAlias"),
load: cell("load"),
loadNow: cell("loadNow"),
},
{
deferExports: cell("deferExports"),
getDeferredExports: cell("getDeferredExports"),
},
{
provideCompartmentEvaluator: cell("provideCompartmentEvaluator"),
compartmentEvaluate: cell("compartmentEvaluate"),
},
{
makeVirtualModuleInstance: cell("makeVirtualModuleInstance"),
makeModuleInstance: cell("makeModuleInstance"),
},
{
link: cell("link"),
instantiate: cell("instantiate"),
},
{
InertCompartment: cell("InertCompartment"),
CompartmentPrototype: cell("CompartmentPrototype"),
makeCompartmentConstructor: cell("makeCompartmentConstructor"),
},
{
getAnonymousIntrinsics: cell("getAnonymousIntrinsics"),
},
{
tameHarden: cell("tameHarden"),
},
{
tameSymbolConstructor: cell("tameSymbolConstructor"),
},
{
tameFauxDataProperty: cell("tameFauxDataProperty"),
tameFauxDataProperties: cell("tameFauxDataProperties"),
},
{
tameRegeneratorRuntime: cell("tameRegeneratorRuntime"),
},
{
repairIntrinsics: cell("repairIntrinsics"),
},
{
},
{
},
{
},
{
},
{
},
];
Object.defineProperties(cells[3], Object.getOwnPropertyDescriptors(cells[2]));
const namespaces = cells.map(cells => Object.freeze(Object.create(null, {
...cells,
// Make this appear like an ESM module namespace object.
[Symbol.toStringTag]: {
value: 'Module',
writable: false,
enumerable: false,
configurable: false,
},
})));
for (let index = 0; index < namespaces.length; index += 1) {
cells[index]['*'] = cell('*', namespaces[index]);
}
function observeImports(map, importName, importIndex) {
for (const [name, observers] of map.get(importName)) {
const cell = cells[importIndex][name];
if (cell === undefined) {
throw new ReferenceError(`Cannot import name ${name}`);
}
for (const observer of observers) {
cell.observe(observer);
}
}
}
functors[0]({
imports(entries) {
const map = new Map(entries);
},
liveVar: {
},
onceVar: {
universalThis: cells[0].globalThis.set,
Array: cells[0].Array.set,
Date: cells[0].Date.set,
FinalizationRegistry: cells[0].FinalizationRegistry.set,
Float32Array: cells[0].Float32Array.set,
JSON: cells[0].JSON.set,
Map: cells[0].Map.set,
Math: cells[0].Math.set,
Number: cells[0].Number.set,
Object: cells[0].Object.set,
Promise: cells[0].Promise.set,
Proxy: cells[0].Proxy.set,
Reflect: cells[0].Reflect.set,
FERAL_REG_EXP: cells[0].FERAL_REG_EXP.set,
Set: cells[0].Set.set,
String: cells[0].String.set,
Symbol: cells[0].Symbol.set,
WeakMap: cells[0].WeakMap.set,
WeakSet: cells[0].WeakSet.set,
FERAL_ERROR: cells[0].FERAL_ERROR.set,
RangeError: cells[0].RangeError.set,
ReferenceError: cells[0].ReferenceError.set,
SyntaxError: cells[0].SyntaxError.set,
TypeError: cells[0].TypeError.set,
AggregateError: cells[0].AggregateError.set,
assign: cells[0].assign.set,
create: cells[0].create.set,
defineProperties: cells[0].defineProperties.set,
entries: cells[0].entries.set,
freeze: cells[0].freeze.set,
getOwnPropertyDescriptor: cells[0].getOwnPropertyDescriptor.set,
getOwnPropertyDescriptors: cells[0].getOwnPropertyDescriptors.set,
getOwnPropertyNames: cells[0].getOwnPropertyNames.set,
getPrototypeOf: cells[0].getPrototypeOf.set,
is: cells[0].is.set,
isFrozen: cells[0].isFrozen.set,
isSealed: cells[0].isSealed.set,
isExtensible: cells[0].isExtensible.set,
keys: cells[0].keys.set,
objectPrototype: cells[0].objectPrototype.set,
seal: cells[0].seal.set,
preventExtensions: cells[0].preventExtensions.set,
setPrototypeOf: cells[0].setPrototypeOf.set,
values: cells[0].values.set,
fromEntries: cells[0].fromEntries.set,
speciesSymbol: cells[0].speciesSymbol.set,
toStringTagSymbol: cells[0].toStringTagSymbol.set,
iteratorSymbol: cells[0].iteratorSymbol.set,
matchAllSymbol: cells[0].matchAllSymbol.set,
unscopablesSymbol: cells[0].unscopablesSymbol.set,
symbolKeyFor: cells[0].symbolKeyFor.set,
symbolFor: cells[0].symbolFor.set,
isInteger: cells[0].isInteger.set,
stringifyJson: cells[0].stringifyJson.set,
defineProperty: cells[0].defineProperty.set,
apply: cells[0].apply.set,
construct: cells[0].construct.set,
reflectGet: cells[0].reflectGet.set,
reflectGetOwnPropertyDescriptor: cells[0].reflectGetOwnPropertyDescriptor.set,
reflectHas: cells[0].reflectHas.set,
reflectIsExtensible: cells[0].reflectIsExtensible.set,
ownKeys: cells[0].ownKeys.set,
reflectPreventExtensions: cells[0].reflectPreventExtensions.set,
reflectSet: cells[0].reflectSet.set,
isArray: cells[0].isArray.set,
arrayPrototype: cells[0].arrayPrototype.set,
mapPrototype: cells[0].mapPrototype.set,
proxyRevocable: cells[0].proxyRevocable.set,
regexpPrototype: cells[0].regexpPrototype.set,
setPrototype: cells[0].setPrototype.set,
stringPrototype: cells[0].stringPrototype.set,
weakmapPrototype: cells[0].weakmapPrototype.set,
weaksetPrototype: cells[0].weaksetPrototype.set,
functionPrototype: cells[0].functionPrototype.set,
promisePrototype: cells[0].promisePrototype.set,
generatorPrototype: cells[0].generatorPrototype.set,
iteratorPrototype: cells[0].iteratorPrototype.set,
typedArrayPrototype: cells[0].typedArrayPrototype.set,
uncurryThis: cells[0].uncurryThis.set,
objectHasOwnProperty: cells[0].objectHasOwnProperty.set,
arrayFilter: cells[0].arrayFilter.set,
arrayForEach: cells[0].arrayForEach.set,
arrayIncludes: cells[0].arrayIncludes.set,
arrayJoin: cells[0].arrayJoin.set,
arrayMap: cells[0].arrayMap.set,
arrayFlatMap: cells[0].arrayFlatMap.set,
arrayPop: cells[0].arrayPop.set,
arrayPush: cells[0].arrayPush.set,
arraySlice: cells[0].arraySlice.set,
arraySome: cells[0].arraySome.set,
arraySort: cells[0].arraySort.set,
iterateArray: cells[0].iterateArray.set,
mapSet: cells[0].mapSet.set,
mapGet: cells[0].mapGet.set,
mapHas: cells[0].mapHas.set,
mapDelete: cells[0].mapDelete.set,
mapEntries: cells[0].mapEntries.set,
iterateMap: cells[0].iterateMap.set,
setAdd: cells[0].setAdd.set,
setDelete: cells[0].setDelete.set,
setForEach: cells[0].setForEach.set,
setHas: cells[0].setHas.set,
iterateSet: cells[0].iterateSet.set,
regexpTest: cells[0].regexpTest.set,
regexpExec: cells[0].regexpExec.set,
matchAllRegExp: cells[0].matchAllRegExp.set,
stringEndsWith: cells[0].stringEndsWith.set,
stringIncludes: cells[0].stringIncludes.set,
stringIndexOf: cells[0].stringIndexOf.set,
stringMatch: cells[0].stringMatch.set,
generatorNext: cells[0].generatorNext.set,
generatorThrow: cells[0].generatorThrow.set,
stringReplace: cells[0].stringReplace.set,
stringSearch: cells[0].stringSearch.set,
stringSlice: cells[0].stringSlice.set,
stringSplit: cells[0].stringSplit.set,
stringStartsWith: cells[0].stringStartsWith.set,
iterateString: cells[0].iterateString.set,
weakmapDelete: cells[0].weakmapDelete.set,
weakmapGet: cells[0].weakmapGet.set,
weakmapHas: cells[0].weakmapHas.set,
weakmapSet: cells[0].weakmapSet.set,
weaksetAdd: cells[0].weaksetAdd.set,
weaksetHas: cells[0].weaksetHas.set,
functionToString: cells[0].functionToString.set,
functionBind: cells[0].functionBind.set,
promiseAll: cells[0].promiseAll.set,
promiseCatch: cells[0].promiseCatch.set,
promiseThen: cells[0].promiseThen.set,
finalizationRegistryRegister: cells[0].finalizationRegistryRegister.set,
finalizationRegistryUnregister: cells[0].finalizationRegistryUnregister.set,
getConstructorOf: cells[0].getConstructorOf.set,
immutableObject: cells[0].immutableObject.set,
isObject: cells[0].isObject.set,
isError: cells[0].isError.set,
FERAL_EVAL: cells[0].FERAL_EVAL.set,
FERAL_FUNCTION: cells[0].FERAL_FUNCTION.set,
noEvalEvaluate: cells[0].noEvalEvaluate.set,
FERAL_STACK_GETTER: cells[0].FERAL_STACK_GETTER.set,
FERAL_STACK_SETTER: cells[0].FERAL_STACK_SETTER.set,
},
importMeta: {},
});
functors[1]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
},
liveVar: {
},
onceVar: {
},
importMeta: {},
});
functors[2]({
imports(entries) {
const map = new Map(entries);
},
liveVar: {
},
onceVar: {
makeEnvironmentCaptor: cells[2].makeEnvironmentCaptor.set,
getEnvironmentOption: cells[2].getEnvironmentOption.set,
getEnvironmentOptionsList: cells[2].getEnvironmentOptionsList.set,
environmentOptionsListHas: cells[2].environmentOptionsListHas.set,
},
importMeta: {},
});
functors[3]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./src/env-options.js", 2);
},
liveVar: {
},
onceVar: {
},
importMeta: {},
});
functors[4]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "../commons.js", 0);
},
liveVar: {
},
onceVar: {
an: cells[4].an.set,
bestEffortStringify: cells[4].bestEffortStringify.set,
enJoin: cells[4].enJoin.set,
},
importMeta: {},
});
functors[5]({
imports(entries) {
const map = new Map(entries);
},
liveVar: {
},
onceVar: {
},
importMeta: {},
});
functors[6]({
imports(entries) {
const map = new Map(entries);
},
liveVar: {
},
onceVar: {
},
importMeta: {},
});
functors[7]({
imports(entries) {
const map = new Map(entries);
},
liveVar: {
},
onceVar: {
makeLRUCacheMap: cells[7].makeLRUCacheMap.set,
},
importMeta: {},
});
functors[8]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "../make-lru-cachemap.js", 7);
observeImports(map, "./internal-types.js", 6);
},
liveVar: {
},
onceVar: {
makeNoteLogArgsArrayKit: cells[8].makeNoteLogArgsArrayKit.set,
},
importMeta: {},
});
functors[9]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "../commons.js", 0);
observeImports(map, "./stringify-utils.js", 4);
observeImports(map, "./types.js", 5);
observeImports(map, "./internal-types.js", 6);
observeImports(map, "./note-log-args.js", 8);
},
liveVar: {
},
onceVar: {
quote: cells[9].q.set,
bare: cells[9].b.set,
redactedDetails: cells[9].X.set,
unredactedDetails: cells[9].unredactedDetails.set,
makeError: cells[9].makeError.set,
note: cells[9].annotateError.set,
loggedErrorHandler: cells[9].loggedErrorHandler.set,
makeAssert: cells[9].makeAssert.set,
assert: cells[9].assert.set,
assertEqual: cells[9].assertEqual.set,
sanitizeError: cells[9].sanitizeError.set,
},
importMeta: {},
});
functors[10]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
observeImports(map, "./error/assert.js", 9);
},
liveVar: {
},
onceVar: {
isTypedArray: cells[10].isTypedArray.set,
makeHardener: cells[10].makeHardener.set,
},
importMeta: {},
});
functors[11]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
},
liveVar: {
},
onceVar: {
NativeErrors: cells[11].NativeErrors.set,
constantProperties: cells[11].constantProperties.set,
universalPropertyNames: cells[11].universalPropertyNames.set,
initialGlobalPropertyNames: cells[11].initialGlobalPropertyNames.set,
sharedGlobalPropertyNames: cells[11].sharedGlobalPropertyNames.set,
uniqueGlobalPropertyNames: cells[11].uniqueGlobalPropertyNames.set,
FunctionInstance: cells[11].FunctionInstance.set,
AsyncFunctionInstance: cells[11].AsyncFunctionInstance.set,
isAccessorPermit: cells[11].isAccessorPermit.set,
permitted: cells[11].permitted.set,
},
importMeta: {},
});
functors[12]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
observeImports(map, "./permits.js", 11);
},
liveVar: {
},
onceVar: {
makeIntrinsicsCollector: cells[12].makeIntrinsicsCollector.set,
getGlobalIntrinsics: cells[12].getGlobalIntrinsics.set,
},
importMeta: {},
});
functors[13]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./permits.js", 11);
observeImports(map, "./commons.js", 0);
},
liveVar: {
},
onceVar: {
default: cells[13].default.set,
},
importMeta: {},
});
functors[14]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
},
liveVar: {
},
onceVar: {
default: cells[14].default.set,
},
importMeta: {},
});
functors[15]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
},
liveVar: {
},
onceVar: {
default: cells[15].default.set,
},
importMeta: {},
});
functors[16]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
},
liveVar: {
},
onceVar: {
default: cells[16].default.set,
},
importMeta: {},
});
functors[17]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
},
liveVar: {
},
onceVar: {
default: cells[17].default.set,
},
importMeta: {},
});
functors[18]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
},
liveVar: {
},
onceVar: {
minEnablements: cells[18].minEnablements.set,
moderateEnablements: cells[18].moderateEnablements.set,
severeEnablements: cells[18].severeEnablements.set,
},
importMeta: {},
});
functors[19]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
observeImports(map, "./enablements.js", 18);
},
liveVar: {
},
onceVar: {
default: cells[19].default.set,
},
importMeta: {},
});
functors[20]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
observeImports(map, "./error/assert.js", 9);
},
liveVar: {
},
onceVar: {
default: cells[20].default.set,
},
importMeta: {},
});
functors[21]({
imports(entries) {
const map = new Map(entries);
},
liveVar: {
},
onceVar: {
makeEvalFunction: cells[21].makeEvalFunction.set,
},
importMeta: {},
});
functors[22]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
observeImports(map, "./error/assert.js", 9);
},
liveVar: {
},
onceVar: {
makeFunctionConstructor: cells[22].makeFunctionConstructor.set,
},
importMeta: {},
});
functors[23]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
observeImports(map, "./make-eval-function.js", 21);
observeImports(map, "./make-function-constructor.js", 22);
observeImports(map, "./permits.js", 11);
},
liveVar: {
},
onceVar: {
setGlobalObjectSymbolUnscopables: cells[23].setGlobalObjectSymbolUnscopables.set,
setGlobalObjectConstantProperties: cells[23].setGlobalObjectConstantProperties.set,
setGlobalObjectMutableProperties: cells[23].setGlobalObjectMutableProperties.set,
setGlobalObjectEvaluators: cells[23].setGlobalObjectEvaluators.set,
},
importMeta: {},
});
functors[24]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
observeImports(map, "./error/assert.js", 9);
},
liveVar: {
},
onceVar: {
alwaysThrowHandler: cells[24].alwaysThrowHandler.set,
strictScopeTerminatorHandler: cells[24].strictScopeTerminatorHandler.set,
strictScopeTerminator: cells[24].strictScopeTerminator.set,
},
importMeta: {},
});
functors[25]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
observeImports(map, "./strict-scope-terminator.js", 24);
},
liveVar: {
},
onceVar: {
createSloppyGlobalsScopeTerminator: cells[25].createSloppyGlobalsScopeTerminator.set,
},
importMeta: {},
});
functors[26]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
observeImports(map, "./error/assert.js", 9);
},
liveVar: {
},
onceVar: {
makeEvalScopeKit: cells[26].makeEvalScopeKit.set,
},
importMeta: {},
});
functors[27]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
},
liveVar: {
},
onceVar: {
getSourceURL: cells[27].getSourceURL.set,
},
importMeta: {},
});
functors[28]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
observeImports(map, "./get-source-url.js", 27);
},
liveVar: {
},
onceVar: {
rejectHtmlComments: cells[28].rejectHtmlComments.set,
evadeHtmlCommentTest: cells[28].evadeHtmlCommentTest.set,
rejectImportExpressions: cells[28].rejectImportExpressions.set,
evadeImportExpressionTest: cells[28].evadeImportExpressionTest.set,
rejectSomeDirectEvalExpressions: cells[28].rejectSomeDirectEvalExpressions.set,
mandatoryTransforms: cells[28].mandatoryTransforms.set,
applyTransforms: cells[28].applyTransforms.set,
transforms: cells[28].transforms.set,
},
importMeta: {},
});
functors[29]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
},
liveVar: {
},
onceVar: {
isValidIdentifierName: cells[29].isValidIdentifierName.set,
getScopeConstants: cells[29].getScopeConstants.set,
},
importMeta: {},
});
functors[30]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
observeImports(map, "./scope-constants.js", 29);
},
liveVar: {
},
onceVar: {
makeEvaluate: cells[30].makeEvaluate.set,
},
importMeta: {},
});
functors[31]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
observeImports(map, "./strict-scope-terminator.js", 24);
observeImports(map, "./sloppy-globals-scope-terminator.js", 25);
observeImports(map, "./eval-scope.js", 26);
observeImports(map, "./transforms.js", 28);
observeImports(map, "./make-evaluate.js", 30);
observeImports(map, "./error/assert.js", 9);
},
liveVar: {
},
onceVar: {
makeSafeEvaluator: cells[31].makeSafeEvaluator.set,
},
importMeta: {},
});
functors[32]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
},
liveVar: {
},
onceVar: {
tameFunctionToString: cells[32].tameFunctionToString.set,
},
importMeta: {},
});
functors[33]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
},
liveVar: {
},
onceVar: {
tameDomains: cells[33].tameDomains.set,
},
importMeta: {},
});
functors[34]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "../commons.js", 0);
observeImports(map, "./types.js", 5);
observeImports(map, "./internal-types.js", 6);
},
liveVar: {
},
onceVar: {
consoleLevelMethods: cells[34].consoleLevelMethods.set,
consoleOtherMethods: cells[34].consoleOtherMethods.set,
makeLoggingConsoleKit: cells[34].makeLoggingConsoleKit.set,
pumpLogToConsole: cells[34].pumpLogToConsole.set,
makeCausalConsole: cells[34].makeCausalConsole.set,
defineCausalConsoleFromLogger: cells[34].defineCausalConsoleFromLogger.set,
filterConsole: cells[34].filterConsole.set,
},
importMeta: {},
});
functors[35]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "../commons.js", 0);
},
liveVar: {
},
onceVar: {
makeRejectionHandlers: cells[35].makeRejectionHandlers.set,
},
importMeta: {},
});
functors[36]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "../commons.js", 0);
observeImports(map, "./assert.js", 9);
observeImports(map, "./console.js", 34);
observeImports(map, "./unhandled-rejection.js", 35);
observeImports(map, "./types.js", 5);
observeImports(map, "./internal-types.js", 6);
},
liveVar: {
},
onceVar: {
tameConsole: cells[36].tameConsole.set,
},
importMeta: {},
});
functors[37]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "../commons.js", 0);
},
liveVar: {
},
onceVar: {
filterFileName: cells[37].filterFileName.set,
shortenCallSiteString: cells[37].shortenCallSiteString.set,
tameV8ErrorConstructor: cells[37].tameV8ErrorConstructor.set,
},
importMeta: {},
});
functors[38]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "../commons.js", 0);
observeImports(map, "../permits.js", 11);
observeImports(map, "./tame-v8-error-constructor.js", 37);
},
liveVar: {
},
onceVar: {
default: cells[38].default.set,
},
importMeta: {},
});
functors[39]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "@endo/env-options", 3);
observeImports(map, "./commons.js", 0);
observeImports(map, "./error/assert.js", 9);
},
liveVar: {
},
onceVar: {
makeAlias: cells[39].makeAlias.set,
load: cells[39].load.set,
loadNow: cells[39].loadNow.set,
},
importMeta: {},
});
functors[40]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./module-load.js", 39);
observeImports(map, "./commons.js", 0);
observeImports(map, "./error/assert.js", 9);
},
liveVar: {
},
onceVar: {
deferExports: cells[40].deferExports.set,
getDeferredExports: cells[40].getDeferredExports.set,
},
importMeta: {},
});
functors[41]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
observeImports(map, "./transforms.js", 28);
observeImports(map, "./make-safe-evaluator.js", 31);
},
liveVar: {
},
onceVar: {
provideCompartmentEvaluator: cells[41].provideCompartmentEvaluator.set,
compartmentEvaluate: cells[41].compartmentEvaluate.set,
},
importMeta: {},
});
functors[42]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./error/assert.js", 9);
observeImports(map, "./module-proxy.js", 40);
observeImports(map, "./commons.js", 0);
observeImports(map, "./compartment-evaluate.js", 41);
},
liveVar: {
},
onceVar: {
makeVirtualModuleInstance: cells[42].makeVirtualModuleInstance.set,
makeModuleInstance: cells[42].makeModuleInstance.set,
},
importMeta: {},
});
functors[43]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./error/assert.js", 9);
observeImports(map, "./module-instance.js", 42);
observeImports(map, "./commons.js", 0);
},
liveVar: {
},
onceVar: {
link: cells[43].link.set,
instantiate: cells[43].instantiate.set,
},
importMeta: {},
});
functors[44]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
observeImports(map, "./global-object.js", 23);
observeImports(map, "./error/assert.js", 9);
observeImports(map, "./permits.js", 11);
observeImports(map, "./module-load.js", 39);
observeImports(map, "./module-link.js", 43);
observeImports(map, "./module-proxy.js", 40);
observeImports(map, "./compartment-evaluate.js", 41);
observeImports(map, "./make-safe-evaluator.js", 31);
},
liveVar: {
},
onceVar: {
InertCompartment: cells[44].InertCompartment.set,
CompartmentPrototype: cells[44].CompartmentPrototype.set,
makeCompartmentConstructor: cells[44].makeCompartmentConstructor.set,
},
importMeta: {},
});
functors[45]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
observeImports(map, "./compartment.js", 44);
},
liveVar: {
},
onceVar: {
getAnonymousIntrinsics: cells[45].getAnonymousIntrinsics.set,
},
importMeta: {},
});
functors[46]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
},
liveVar: {
},
onceVar: {
tameHarden: cells[46].tameHarden.set,
},
importMeta: {},
});
functors[47]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
},
liveVar: {
},
onceVar: {
tameSymbolConstructor: cells[47].tameSymbolConstructor.set,
},
importMeta: {},
});
functors[48]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
},
liveVar: {
},
onceVar: {
tameFauxDataProperty: cells[48].tameFauxDataProperty.set,
tameFauxDataProperties: cells[48].tameFauxDataProperties.set,
},
importMeta: {},
});
functors[49]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
},
liveVar: {
},
onceVar: {
tameRegeneratorRuntime: cells[49].tameRegeneratorRuntime.set,
},
importMeta: {},
});
functors[50]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "@endo/env-options", 3);
observeImports(map, "./commons.js", 0);
observeImports(map, "./make-hardener.js", 10);
observeImports(map, "./intrinsics.js", 12);
observeImports(map, "./permits-intrinsics.js", 13);
observeImports(map, "./tame-function-constructors.js", 14);
observeImports(map, "./tame-date-constructor.js", 15);
observeImports(map, "./tame-math-object.js", 16);
observeImports(map, "./tame-regexp-constructor.js", 17);
observeImports(map, "./enable-property-overrides.js", 19);
observeImports(map, "./tame-locale-methods.js", 20);
observeImports(map, "./global-object.js", 23);
observeImports(map, "./make-safe-evaluator.js", 31);
observeImports(map, "./permits.js", 11);
observeImports(map, "./tame-function-tostring.js", 32);
observeImports(map, "./tame-domains.js", 33);
observeImports(map, "./error/tame-console.js", 36);
observeImports(map, "./error/tame-error-constructor.js", 38);
observeImports(map, "./error/assert.js", 9);
observeImports(map, "./get-anonymous-intrinsics.js", 45);
observeImports(map, "./compartment.js", 44);
observeImports(map, "./tame-harden.js", 46);
observeImports(map, "./tame-symbol-constructor.js", 47);
observeImports(map, "./tame-faux-data-properties.js", 48);
observeImports(map, "./tame-regenerator-runtime.js", 49);
},
liveVar: {
},
onceVar: {
repairIntrinsics: cells[50].repairIntrinsics.set,
},
importMeta: {},
});
functors[51]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./assert-sloppy-mode.js", 1);
observeImports(map, "./commons.js", 0);
observeImports(map, "./lockdown.js", 50);
},
liveVar: {
},
onceVar: {
},
importMeta: {},
});
functors[52]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
observeImports(map, "./compartment.js", 44);
observeImports(map, "./tame-function-tostring.js", 32);
observeImports(map, "./intrinsics.js", 12);
},
liveVar: {
},
onceVar: {
},
importMeta: {},
});
functors[53]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
observeImports(map, "./error/assert.js", 9);
},
liveVar: {
},
onceVar: {
},
importMeta: {},
});
functors[54]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./commons.js", 0);
observeImports(map, "./error/console.js", 34);
observeImports(map, "./error/assert.js", 9);
},
liveVar: {
},
onceVar: {
},
importMeta: {},
});
functors[55]({
imports(entries) {
const map = new Map(entries);
observeImports(map, "./src/lockdown-shim.js", 51);
observeImports(map, "./src/compartment-shim.js", 52);
observeImports(map, "./src/assert-shim.js", 53);
observeImports(map, "./src/console-shim.js", 54);
},
liveVar: {
},
onceVar: {
},
importMeta: {},
});
return cells[cells.length - 1]['*'].get();
})([// === functors[0] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; $h‍_imports([]); /* global globalThis */
/* eslint-disable no-restricted-globals */
/**
* commons.js
* Declare shorthand functions. Sharing these declarations across modules
* improves on consistency and minification. Unused declarations are
* dropped by the tree shaking process.
*
* We capture these, not just for brevity, but for security. If any code
* modifies Object to change what 'assign' points to, the Compartment shim
* would be corrupted.
*/
// We cannot use globalThis as the local name since it would capture the
// lexical name.
const universalThis= globalThis;$h‍_once.universalThis(universalThis);
const {
Array,
Date,
FinalizationRegistry,
Float32Array,
JSON,
Map,
Math,
Number,
Object,
Promise,
Proxy,
Reflect,
RegExp: FERAL_REG_EXP,
Set,
String,
Symbol,
WeakMap,
WeakSet}=
globalThis;$h‍_once.Array(Array);$h‍_once.Date(Date);$h‍_once.FinalizationRegistry(FinalizationRegistry);$h‍_once.Float32Array(Float32Array);$h‍_once.JSON(JSON);$h‍_once.Map(Map);$h‍_once.Math(Math);$h‍_once.Number(Number);$h‍_once.Object(Object);$h‍_once.Promise(Promise);$h‍_once.Proxy(Proxy);$h‍_once.Reflect(Reflect);$h‍_once.FERAL_REG_EXP(FERAL_REG_EXP);$h‍_once.Set(Set);$h‍_once.String(String);$h‍_once.Symbol(Symbol);$h‍_once.WeakMap(WeakMap);$h‍_once.WeakSet(WeakSet);
const {
// The feral Error constructor is safe for internal use, but must not be
// revealed to post-lockdown code in any compartment including the start
// compartment since in V8 at least it bears stack inspection capabilities.
Error: FERAL_ERROR,
RangeError,
ReferenceError,
SyntaxError,
TypeError,
AggregateError}=
globalThis;$h‍_once.FERAL_ERROR(FERAL_ERROR);$h‍_once.RangeError(RangeError);$h‍_once.ReferenceError(ReferenceError);$h‍_once.SyntaxError(SyntaxError);$h‍_once.TypeError(TypeError);$h‍_once.AggregateError(AggregateError);
const {
assign,
create,
defineProperties,
entries,
freeze,
getOwnPropertyDescriptor,
getOwnPropertyDescriptors,
getOwnPropertyNames,
getPrototypeOf,
is,
isFrozen,
isSealed,
isExtensible,
keys,
prototype: objectPrototype,
seal,
preventExtensions,
setPrototypeOf,
values,
fromEntries}=
Object;$h‍_once.assign(assign);$h‍_once.create(create);$h‍_once.defineProperties(defineProperties);$h‍_once.entries(entries);$h‍_once.freeze(freeze);$h‍_once.getOwnPropertyDescriptor(getOwnPropertyDescriptor);$h‍_once.getOwnPropertyDescriptors(getOwnPropertyDescriptors);$h‍_once.getOwnPropertyNames(getOwnPropertyNames);$h‍_once.getPrototypeOf(getPrototypeOf);$h‍_once.is(is);$h‍_once.isFrozen(isFrozen);$h‍_once.isSealed(isSealed);$h‍_once.isExtensible(isExtensible);$h‍_once.keys(keys);$h‍_once.objectPrototype(objectPrototype);$h‍_once.seal(seal);$h‍_once.preventExtensions(preventExtensions);$h‍_once.setPrototypeOf(setPrototypeOf);$h‍_once.values(values);$h‍_once.fromEntries(fromEntries);
const {
species: speciesSymbol,
toStringTag: toStringTagSymbol,
iterator: iteratorSymbol,
matchAll: matchAllSymbol,
unscopables: unscopablesSymbol,
keyFor: symbolKeyFor,
for: symbolFor}=
Symbol;$h‍_once.speciesSymbol(speciesSymbol);$h‍_once.toStringTagSymbol(toStringTagSymbol);$h‍_once.iteratorSymbol(iteratorSymbol);$h‍_once.matchAllSymbol(matchAllSymbol);$h‍_once.unscopablesSymbol(unscopablesSymbol);$h‍_once.symbolKeyFor(symbolKeyFor);$h‍_once.symbolFor(symbolFor);
const { isInteger}= Number;$h‍_once.isInteger(isInteger);
const { stringify: stringifyJson}= JSON;
// Needed only for the Safari bug workaround below
$h‍_once.stringifyJson(stringifyJson);const{defineProperty:originalDefineProperty}=Object;
const defineProperty= (object, prop, descriptor)=> {
// We used to do the following, until we had to reopen Safari bug
// https://bugs.webkit.org/show_bug.cgi?id=222538#c17
// Once this is fixed, we may restore it.
// // Object.defineProperty is allowed to fail silently so we use
// // Object.defineProperties instead.
// return defineProperties(object, { [prop]: descriptor });
// Instead, to workaround the Safari bug
const result= originalDefineProperty(object, prop, descriptor);
if( result!== object) {
// See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_DEFINE_PROPERTY_FAILED_SILENTLY.md
throw TypeError(
`Please report that the original defineProperty silently failed to set ${stringifyJson(
String(prop))
}. (SES_DEFINE_PROPERTY_FAILED_SILENTLY)`);
}
return result;
};$h‍_once.defineProperty(defineProperty);
const {
apply,
construct,
get: reflectGet,
getOwnPropertyDescriptor: reflectGetOwnPropertyDescriptor,
has: reflectHas,
isExtensible: reflectIsExtensible,
ownKeys,
preventExtensions: reflectPreventExtensions,
set: reflectSet}=
Reflect;$h‍_once.apply(apply);$h‍_once.construct(construct);$h‍_once.reflectGet(reflectGet);$h‍_once.reflectGetOwnPropertyDescriptor(reflectGetOwnPropertyDescriptor);$h‍_once.reflectHas(reflectHas);$h‍_once.reflectIsExtensible(reflectIsExtensible);$h‍_once.ownKeys(ownKeys);$h‍_once.reflectPreventExtensions(reflectPreventExtensions);$h‍_once.reflectSet(reflectSet);
const { isArray, prototype: arrayPrototype}= Array;$h‍_once.isArray(isArray);$h‍_once.arrayPrototype(arrayPrototype);
const { prototype: mapPrototype}= Map;$h‍_once.mapPrototype(mapPrototype);
const { revocable: proxyRevocable}= Proxy;$h‍_once.proxyRevocable(proxyRevocable);
const { prototype: regexpPrototype}= RegExp;$h‍_once.regexpPrototype(regexpPrototype);
const { prototype: setPrototype}= Set;$h‍_once.setPrototype(setPrototype);
const { prototype: stringPrototype}= String;$h‍_once.stringPrototype(stringPrototype);
const { prototype: weakmapPrototype}= WeakMap;$h‍_once.weakmapPrototype(weakmapPrototype);
const { prototype: weaksetPrototype}= WeakSet;$h‍_once.weaksetPrototype(weaksetPrototype);
const { prototype: functionPrototype}= Function;$h‍_once.functionPrototype(functionPrototype);
const { prototype: promisePrototype}= Promise;$h‍_once.promisePrototype(promisePrototype);
const { prototype: generatorPrototype}= getPrototypeOf(
// eslint-disable-next-line no-empty-function, func-names
function*() { });$h‍_once.generatorPrototype(generatorPrototype);
const iteratorPrototype= getPrototypeOf(
// eslint-disable-next-line @endo/no-polymorphic-call
getPrototypeOf(arrayPrototype.values()));$h‍_once.iteratorPrototype(iteratorPrototype);
const typedArrayPrototype= getPrototypeOf(Uint8Array.prototype);$h‍_once.typedArrayPrototype(typedArrayPrototype);
const { bind}= functionPrototype;
/**
* uncurryThis()
* Equivalent of: fn => (thisArg, ...args) => apply(fn, thisArg, args)
*
* See those reference for a complete explanation:
* http://wiki.ecmascript.org/doku.php?id=conventions:safe_meta_programming
* which only lives at
* http://web.archive.org/web/20160805225710/http://wiki.ecmascript.org/doku.php?id=conventions:safe_meta_programming
*
* @type {<F extends (this: any, ...args: any[]) => any>(fn: F) => ((thisArg: ThisParameterType<F>, ...args: Parameters<F>) => ReturnType<F>)}
*/
const uncurryThis= bind.bind(bind.call); // eslint-disable-line @endo/no-polymorphic-call
$h‍_once.uncurryThis(uncurryThis);
const objectHasOwnProperty= uncurryThis(objectPrototype.hasOwnProperty);
//
$h‍_once.objectHasOwnProperty(objectHasOwnProperty);const arrayFilter=uncurryThis(arrayPrototype.filter);$h‍_once.arrayFilter(arrayFilter);
const arrayForEach= uncurryThis(arrayPrototype.forEach);$h‍_once.arrayForEach(arrayForEach);
const arrayIncludes= uncurryThis(arrayPrototype.includes);$h‍_once.arrayIncludes(arrayIncludes);
const arrayJoin= uncurryThis(arrayPrototype.join);
/** @type {<T, U>(thisArg: readonly T[], callbackfn: (value: T, index: number, array: T[]) => U, cbThisArg?: any) => U[]} */$h‍_once.arrayJoin(arrayJoin);
const arrayMap= /** @type {any} */ uncurryThis(arrayPrototype.map);$h‍_once.arrayMap(arrayMap);
const arrayFlatMap= /** @type {any} */
uncurryThis(arrayPrototype.flatMap);$h‍_once.arrayFlatMap(arrayFlatMap);
const arrayPop= uncurryThis(arrayPrototype.pop);
/** @type {<T>(thisArg: T[], ...items: T[]) => number} */$h‍_once.arrayPop(arrayPop);
const arrayPush= uncurryThis(arrayPrototype.push);$h‍_once.arrayPush(arrayPush);
const arraySlice= uncurryThis(arrayPrototype.slice);$h‍_once.arraySlice(arraySlice);
const arraySome= uncurryThis(arrayPrototype.some);$h‍_once.arraySome(arraySome);
const arraySort= uncurryThis(arrayPrototype.sort);$h‍_once.arraySort(arraySort);
const iterateArray= uncurryThis(arrayPrototype[iteratorSymbol]);
//
$h‍_once.iterateArray(iterateArray);const mapSet=uncurryThis(mapPrototype.set);$h‍_once.mapSet(mapSet);
const mapGet= uncurryThis(mapPrototype.get);$h‍_once.mapGet(mapGet);
const mapHas= uncurryThis(mapPrototype.has);$h‍_once.mapHas(mapHas);
const mapDelete= uncurryThis(mapPrototype.delete);$h‍_once.mapDelete(mapDelete);
const mapEntries= uncurryThis(mapPrototype.entries);$h‍_once.mapEntries(mapEntries);
const iterateMap= uncurryThis(mapPrototype[iteratorSymbol]);
//
$h‍_once.iterateMap(iterateMap);const setAdd=uncurryThis(setPrototype.add);$h‍_once.setAdd(setAdd);
const setDelete= uncurryThis(setPrototype.delete);$h‍_once.setDelete(setDelete);
const setForEach= uncurryThis(setPrototype.forEach);$h‍_once.setForEach(setForEach);
const setHas= uncurryThis(setPrototype.has);$h‍_once.setHas(setHas);
const iterateSet= uncurryThis(setPrototype[iteratorSymbol]);
//
$h‍_once.iterateSet(iterateSet);const regexpTest=uncurryThis(regexpPrototype.test);$h‍_once.regexpTest(regexpTest);
const regexpExec= uncurryThis(regexpPrototype.exec);$h‍_once.regexpExec(regexpExec);
const matchAllRegExp= uncurryThis(regexpPrototype[matchAllSymbol]);
//
$h‍_once.matchAllRegExp(matchAllRegExp);const stringEndsWith=uncurryThis(stringPrototype.endsWith);$h‍_once.stringEndsWith(stringEndsWith);
const stringIncludes= uncurryThis(stringPrototype.includes);$h‍_once.stringIncludes(stringIncludes);
const stringIndexOf= uncurryThis(stringPrototype.indexOf);$h‍_once.stringIndexOf(stringIndexOf);
const stringMatch= uncurryThis(stringPrototype.match);$h‍_once.stringMatch(stringMatch);
const generatorNext= uncurryThis(generatorPrototype.next);$h‍_once.generatorNext(generatorNext);
const generatorThrow= uncurryThis(generatorPrototype.throw);
/**
* @type { &
* ((thisArg: string, searchValue: { [Symbol.replace](string: string, replaceValue: string): string; }, replaceValue: string) => string) &
* ((thisArg: string, searchValue: { [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string; }, replacer: (substring: string, ...args: any[]) => string) => string)
* }
*/$h‍_once.generatorThrow(generatorThrow);
const stringReplace= /** @type {any} */
uncurryThis(stringPrototype.replace);$h‍_once.stringReplace(stringReplace);
const stringSearch= uncurryThis(stringPrototype.search);$h‍_once.stringSearch(stringSearch);
const stringSlice= uncurryThis(stringPrototype.slice);$h‍_once.stringSlice(stringSlice);
const stringSplit=
/** @type {(thisArg: string, splitter: string | RegExp | { [Symbol.split](string: string, limit?: number): string[]; }, limit?: number) => string[]} */
uncurryThis(stringPrototype.split);$h‍_once.stringSplit(stringSplit);
const stringStartsWith= uncurryThis(stringPrototype.startsWith);$h‍_once.stringStartsWith(stringStartsWith);
const iterateString= uncurryThis(stringPrototype[iteratorSymbol]);
//
$h‍_once.iterateString(iterateString);const weakmapDelete=uncurryThis(weakmapPrototype.delete);
/** @type {<K extends {}, V>(thisArg: WeakMap<K, V>, ...args: Parameters<WeakMap<K,V>['get']>) => ReturnType<WeakMap<K,V>['get']>} */$h‍_once.weakmapDelete(weakmapDelete);
const weakmapGet= uncurryThis(weakmapPrototype.get);$h‍_once.weakmapGet(weakmapGet);
const weakmapHas= uncurryThis(weakmapPrototype.has);$h‍_once.weakmapHas(weakmapHas);
const weakmapSet= uncurryThis(weakmapPrototype.set);
//
$h‍_once.weakmapSet(weakmapSet);const weaksetAdd=uncurryThis(weaksetPrototype.add);$h‍_once.weaksetAdd(weaksetAdd);
const weaksetHas= uncurryThis(weaksetPrototype.has);
//
$h‍_once.weaksetHas(weaksetHas);const functionToString=uncurryThis(functionPrototype.toString);$h‍_once.functionToString(functionToString);
const functionBind= uncurryThis(bind);
//
$h‍_once.functionBind(functionBind);const{all}=Promise;
const promiseAll= (promises)=>apply(all, Promise, [promises]);$h‍_once.promiseAll(promiseAll);
const promiseCatch= uncurryThis(promisePrototype.catch);
/** @type {<T, TResult1 = T, TResult2 = never>(thisArg: T, onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null) => Promise<TResult1 | TResult2>} */$h‍_once.promiseCatch(promiseCatch);
const promiseThen= /** @type {any} */
uncurryThis(promisePrototype.then);
//
$h‍_once.promiseThen(promiseThen);const finalizationRegistryRegister=
FinalizationRegistry&& uncurryThis(FinalizationRegistry.prototype.register);$h‍_once.finalizationRegistryRegister(finalizationRegistryRegister);
const finalizationRegistryUnregister=
FinalizationRegistry&&
uncurryThis(FinalizationRegistry.prototype.unregister);
/**
* getConstructorOf()
* Return the constructor from an instance.
*
* @param {Function} fn
*/$h‍_once.finalizationRegistryUnregister(finalizationRegistryUnregister);
const getConstructorOf= (fn)=>
reflectGet(getPrototypeOf(fn), 'constructor');
/**
* immutableObject
* An immutable (frozen) empty object that is safe to share.
*/$h‍_once.getConstructorOf(getConstructorOf);
const immutableObject= freeze(create(null));
/**
* isObject tests whether a value is an object.
* Today, this is equivalent to:
*
* const isObject = value => {
* if (value === null) return false;
* const type = typeof value;
* return type === 'object' || type === 'function';
* };
*
* But this is not safe in the face of possible evolution of the language, for
* example new types or semantics of records and tuples.
* We use this implementation despite the unnecessary allocation implied by
* attempting to box a primitive.
*
* @param {any} value
*/$h‍_once.immutableObject(immutableObject);
const isObject= (value)=>Object(value)=== value;
/**
* isError tests whether an object inherits from the intrinsic
* `Error.prototype`.
* We capture the original error constructor as FERAL_ERROR to provide a clear
* signal for reviewers that we are handling an object with excess authority,
* like stack trace inspection, that we are carefully hiding from client code.
* Checking instanceof happens to be safe, but to avoid uttering FERAL_ERROR
* for such a trivial case outside commons.js, we provide a utility function.
*
* @param {any} value
*/$h‍_once.isObject(isObject);
const isError= (value)=>value instanceof FERAL_ERROR;
// The original unsafe untamed eval function, which must not escape.
// Sample at module initialization time, which is before lockdown can
// repair it. Use it only to build powerless abstractions.
// eslint-disable-next-line no-eval
$h‍_once.isError(isError);const FERAL_EVAL=eval;
// The original unsafe untamed Function constructor, which must not escape.
// Sample at module initialization time, which is before lockdown can
// repair it. Use it only to build powerless abstractions.
$h‍_once.FERAL_EVAL(FERAL_EVAL);const FERAL_FUNCTION=Function;$h‍_once.FERAL_FUNCTION(FERAL_FUNCTION);
const noEvalEvaluate= ()=> {
// See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_NO_EVAL.md
throw TypeError('Cannot eval with evalTaming set to "noEval" (SES_NO_EVAL)');
};
// ////////////////// FERAL_STACK_GETTER FERAL_STACK_SETTER ////////////////////
$h‍_once.noEvalEvaluate(noEvalEvaluate);
const er1StackDesc= getOwnPropertyDescriptor(Error('er1'), 'stack');
const er2StackDesc= getOwnPropertyDescriptor(TypeError('er2'), 'stack');
let feralStackGetter;
let feralStackSetter;
if( er1StackDesc&& er2StackDesc&& er1StackDesc.get) {
// We should only encounter this case on v8 because of its problematic
// error own stack accessor behavior.
// Note that FF/SpiderMonkey, Moddable/XS, and the error stack proposal
// all inherit a stack accessor property from Error.prototype, which is
// great. That case needs no heroics to secure.
if(
// In the v8 case as we understand it, all errors have an own stack
// accessor property, but within the same realm, all these accessor
// properties have the same getter and have the same setter.
// This is therefore the case that we repair.
typeof er1StackDesc.get=== 'function'&&
er1StackDesc.get=== er2StackDesc.get&&
typeof er1StackDesc.set=== 'function'&&
er1StackDesc.set=== er2StackDesc.set)
{
// Otherwise, we have own stack accessor properties that are outside
// our expectations, that therefore need to be understood better
// before we know how to repair them.
feralStackGetter= freeze(er1StackDesc.get);
feralStackSetter= freeze(er1StackDesc.set);
}else {
// See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_UNEXPECTED_ERROR_OWN_STACK_ACCESSOR.md
throw TypeError(
'Unexpected Error own stack accessor functions (SES_UNEXPECTED_ERROR_OWN_STACK_ACCESSOR)');
}
}
/**
* If on a v8 with the problematic error own stack accessor behavior,
* `FERAL_STACK_GETTER` will be the shared getter of all those accessors
* and `FERAL_STACK_SETTER` will be the shared setter. On any platform
* without this problem, `FERAL_STACK_GETTER` and `FERAL_STACK_SETTER` are
* both `undefined`.
*
* @type {(() => any) | undefined}
*/
const FERAL_STACK_GETTER= feralStackGetter;
/**
* If on a v8 with the problematic error own stack accessor behavior,
* `FERAL_STACK_GETTER` will be the shared getter of all those accessors
* and `FERAL_STACK_SETTER` will be the shared setter. On any platform
* without this problem, `FERAL_STACK_GETTER` and `FERAL_STACK_SETTER` are
* both `undefined`.
*
* @type {((newValue: any) => void) | undefined}
*/$h‍_once.FERAL_STACK_GETTER(FERAL_STACK_GETTER);
const FERAL_STACK_SETTER= feralStackSetter;$h‍_once.FERAL_STACK_SETTER(FERAL_STACK_SETTER);
})()
,
// === functors[1] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let TypeError;$h‍_imports([["./commons.js", [["TypeError", [$h‍_a => (TypeError = $h‍_a)]]]]]);
/** getThis returns globalThis in sloppy mode or undefined in strict mode. */
function getThis() {
return this;
}
if( getThis()) {
// See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_NO_SLOPPY.md
throw TypeError( `SES failed to initialize, sloppy mode (SES_NO_SLOPPY)`);
}
})()
,
// === functors[2] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; $h‍_imports([]); /* global globalThis */
// @ts-check
// `@endo/env-options` needs to be imported quite early, and so should
// avoid importing from ses or anything that depends on ses.
// /////////////////////////////////////////////////////////////////////////////
// Prelude of cheap good - enough imitations of things we'd use or
// do differently if we could depend on ses
const { freeze}= Object;
const { apply}= Reflect;
// Should be equivalent to the one in ses' commons.js even though it
// uses the other technique.
const uncurryThis=
(fn)=>
(receiver, ...args)=>
apply(fn, receiver, args);
const arrayPush= uncurryThis(Array.prototype.push);
const arrayIncludes= uncurryThis(Array.prototype.includes);
const stringSplit= uncurryThis(String.prototype.split);
const q= JSON.stringify;
const Fail= (literals, ...args)=> {
let msg= literals[0];
for( let i= 0; i< args.length; i+= 1) {
msg= `${msg}${args[i]}${literals[i+ 1] }`;
}
throw Error(msg);
};
// end prelude
// /////////////////////////////////////////////////////////////////////////////
/**
* `makeEnvironmentCaptor` provides a mechanism for getting environment
* variables, if they are needed, and a way to catalog the names of all
* the environment variables that were captured.
*
* @param {object} aGlobal
* @param {boolean} [dropNames] Defaults to false. If true, don't track
* names used.
*/
const makeEnvironmentCaptor= (aGlobal, dropNames= false)=> {
const capturedEnvironmentOptionNames= [];
/**
* Gets an environment option by name and returns the option value or the
* given default.
*
* @param {string} optionName
* @param {string} defaultSetting
* @param {string[]} [optOtherValues]
* If provided, the option value must be included or match `defaultSetting`.
* @returns {string}
*/
const getEnvironmentOption= (
optionName,
defaultSetting,
optOtherValues= undefined)=>
{
typeof optionName=== 'string'||
Fail `Environment option name ${q(optionName)} must be a string.`;
typeof defaultSetting=== 'string'||
Fail `Environment option default setting ${q(
defaultSetting)
} must be a string.`;
/** @type {string} */
let setting= defaultSetting;
const globalProcess= aGlobal.process|| undefined;
const globalEnv=
typeof globalProcess=== 'object'&& globalProcess.env|| undefined;
if( typeof globalEnv=== 'object') {
if( optionName in globalEnv) {
if( !dropNames) {
arrayPush(capturedEnvironmentOptionNames, optionName);
}
const optionValue= globalEnv[optionName];
// eslint-disable-next-line @endo/no-polymorphic-call
typeof optionValue=== 'string'||
Fail `Environment option named ${q(
optionName)
}, if present, must have a corresponding string value, got ${q(
optionValue)
}`;
setting= optionValue;
}
}
optOtherValues=== undefined||
setting=== defaultSetting||
arrayIncludes(optOtherValues, setting)||
Fail `Unrecognized ${q(optionName)} value ${q(
setting)
}. Expected one of ${q([defaultSetting,...optOtherValues]) }`;
return setting;
};
freeze(getEnvironmentOption);
/**
* @param {string} optionName
* @returns {string[]}
*/
const getEnvironmentOptionsList= (optionName)=>{
const option= getEnvironmentOption(optionName, '');
return freeze(option=== ''? []: stringSplit(option, ','));
};
freeze(getEnvironmentOptionsList);
const environmentOptionsListHas= (optionName, element)=>
arrayIncludes(getEnvironmentOptionsList(optionName), element);
const getCapturedEnvironmentOptionNames= ()=> {
return freeze([...capturedEnvironmentOptionNames]);
};
freeze(getCapturedEnvironmentOptionNames);
return freeze({
getEnvironmentOption,
getEnvironmentOptionsList,
environmentOptionsListHas,
getCapturedEnvironmentOptionNames});
};$h‍_once.makeEnvironmentCaptor(makeEnvironmentCaptor);
freeze(makeEnvironmentCaptor);
/**
* For the simple case, where the global in question is `globalThis` and no
* reporting of option names is desired.
*/
const {
getEnvironmentOption,
getEnvironmentOptionsList,
environmentOptionsListHas}=
makeEnvironmentCaptor(globalThis, true);$h‍_once.getEnvironmentOption(getEnvironmentOption);$h‍_once.getEnvironmentOptionsList(getEnvironmentOptionsList);$h‍_once.environmentOptionsListHas(environmentOptionsListHas);
})()
,
// === functors[3] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; $h‍_imports([["./src/env-options.js", []]]);
})()
,
// === functors[4] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let Set,String,isArray,arrayJoin,arraySlice,arraySort,arrayMap,keys,fromEntries,freeze,is,isError,setAdd,setHas,stringIncludes,stringStartsWith,stringifyJson,toStringTagSymbol;$h‍_imports([["../commons.js", [["Set", [$h‍_a => (Set = $h‍_a)]],["String", [$h‍_a => (String = $h‍_a)]],["isArray", [$h‍_a => (isArray = $h‍_a)]],["arrayJoin", [$h‍_a => (arrayJoin = $h‍_a)]],["arraySlice", [$h‍_a => (arraySlice = $h‍_a)]],["arraySort", [$h‍_a => (arraySort = $h‍_a)]],["arrayMap", [$h‍_a => (arrayMap = $h‍_a)]],["keys", [$h‍_a => (keys = $h‍_a)]],["fromEntries", [$h‍_a => (fromEntries = $h‍_a)]],["freeze", [$h‍_a => (freeze = $h‍_a)]],["is", [$h‍_a => (is = $h‍_a)]],["isError", [$h‍_a => (isError = $h‍_a)]],["setAdd", [$h‍_a => (setAdd = $h‍_a)]],["setHas", [$h‍_a => (setHas = $h‍_a)]],["stringIncludes", [$h‍_a => (stringIncludes = $h‍_a)]],["stringStartsWith", [$h‍_a => (stringStartsWith = $h‍_a)]],["stringifyJson", [$h‍_a => (stringifyJson = $h‍_a)]],["toStringTagSymbol", [$h‍_a => (toStringTagSymbol = $h‍_a)]]]]]);
/** @import {StringablePayload} from '../../types.js' */
/**
* Joins English terms with commas and an optional conjunction.
*
* @param {(string | StringablePayload)[]} terms
* @param {"and" | "or"} conjunction
*/
const enJoin= (terms, conjunction)=> {
if( terms.length=== 0) {
return '(none)';
}else if( terms.length=== 1) {
return terms[0];
}else if( terms.length=== 2) {
const [first, second]= terms;
return `${first} ${conjunction} ${second}`;
}else {
return `${arrayJoin(arraySlice(terms,0, -1), ', ') }, ${conjunction} ${
terms[terms.length- 1]
}`;
}
};
/**
* Prepend the correct indefinite article onto a noun, typically a typeof
* result, e.g., "an object" vs. "a number"
*
* @param {string} str The noun to prepend
* @returns {string} The noun prepended with a/an
*/$h‍_once.enJoin(enJoin);
const an= (str)=>{
str= `${str}`;
if( str.length>= 1&& stringIncludes('aeiouAEIOU', str[0])) {
return `an ${str}`;
}
return `a ${str}`;
};$h‍_once.an(an);
freeze(an);
/**
* Like `JSON.stringify` but does not blow up if given a cycle or a bigint.
* This is not
* intended to be a serialization to support any useful unserialization,
* or any programmatic use of the resulting string. The string is intended
* *only* for showing a human under benign conditions, in order to be
* informative enough for some
* logging purposes. As such, this `bestEffortStringify` has an
* imprecise specification and may change over time.
*
* The current `bestEffortStringify` possibly emits too many "seen"
* markings: Not only for cycles, but also for repeated subtrees by
* object identity.
*
* As a best effort only for diagnostic interpretation by humans,
* `bestEffortStringify` also turns various cases that normal
* `JSON.stringify` skips or errors on, like `undefined` or bigints,
* into strings that convey their meaning. To distinguish this from
* strings in the input, these synthesized strings always begin and
* end with square brackets. To distinguish those strings from an
* input string with square brackets, and input string that starts
* with an open square bracket `[` is itself placed in square brackets.
*
* @param {any} payload
* @param {(string|number)=} spaces
* @returns {string}
*/
const bestEffortStringify= (payload, spaces= undefined)=> {
const seenSet= new Set();
const replacer= (_, val)=> {
switch( typeof val){
case 'object': {
if( val=== null) {
return null;
}
if( setHas(seenSet, val)) {
return '[Seen]';
}
setAdd(seenSet, val);
if( isError(val)) {
return `[${val.name}: ${val.message}]`;
}
if( toStringTagSymbol in val) {
// For the built-ins that have or inherit a `Symbol.toStringTag`-named
// property, most of them inherit the default `toString` method,
// which will print in a similar manner: `"[object Foo]"` vs
// `"[Foo]"`. The exceptions are
// * `Symbol.prototype`, `BigInt.prototype`, `String.prototype`
// which don't matter to us since we handle primitives
// separately and we don't care about primitive wrapper objects.
// * TODO
// `Date.prototype`, `TypedArray.prototype`.
// Hmmm, we probably should make special cases for these. We're
// not using these yet, so it's not urgent. But others will run
// into these.
//
// Once #2018 is closed, the only objects in our code that have or
// inherit a `Symbol.toStringTag`-named property are remotables
// or their remote presences.
// This printing will do a good job for these without
// violating abstraction layering. This behavior makes sense
// purely in terms of JavaScript concepts. That's some of the
// motivation for choosing that representation of remotables
// and their remote presences in the first place.
return `[${val[toStringTagSymbol]}]`;
}
if( isArray(val)) {
return val;
}
const names= keys(val);
if( names.length< 2) {
return val;
}
let sorted= true;
for( let i= 1; i< names.length; i+= 1) {
if( names[i- 1]>= names[i]) {
sorted= false;
break;
}
}
if( sorted) {
return val;
}
arraySort(names);
const entries= arrayMap(names, (name)=>[name, val[name]]);
return fromEntries(entries);
}
case 'function': {
return `[Function ${val.name|| '<anon>' }]`;
}
case 'string': {
if( stringStartsWith(val, '[')) {
return `[${val}]`;
}
return val;
}
case 'undefined':
case 'symbol': {
return `[${String(val)}]`;
}
case 'bigint': {
return `[${val}n]`;
}
case 'number': {
if( is(val, NaN)) {
return '[NaN]';
}else if( val=== Infinity) {
return '[Infinity]';
}else if( val=== -Infinity) {
return '[-Infinity]';
}
return val;
}
default: {
return val;
}}
};
try {
return stringifyJson(payload, replacer, spaces);
}catch( _err) {
// Don't do anything more fancy here if there is any
// chance that might throw, unless you surround that
// with another try-catch-recovery. For example,
// the caught thing might be a proxy or other exotic
// object rather than an error. The proxy might throw
// whenever it is possible for it to.
return '[Something that failed to stringify]';
}
};$h‍_once.bestEffortStringify(bestEffortStringify);
freeze(bestEffortStringify);
})()
,
// === functors[5] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; $h‍_imports([]); // @ts-check
/** @import {GenericErrorConstructor, AssertMakeErrorOptions, DetailsToken, StringablePayload} from '../../types.js' */
/**
* @typedef {object} VirtualConsole
* @property {Console['debug']} debug
* @property {Console['log']} log
* @property {Console['info']} info
* @property {Console['warn']} warn
* @property {Console['error']} error
*
* @property {Console['trace']} trace
* @property {Console['dirxml']} dirxml
* @property {Console['group']} group
* @property {Console['groupCollapsed']} groupCollapsed
*
* @property {Console['assert']} assert
* @property {Console['timeLog']} timeLog
*
* @property {Console['clear']} clear
* @property {Console['count']} count
* @property {Console['countReset']} countReset
* @property {Console['dir']} dir
* @property {Console['groupEnd']} groupEnd
*
* @property {Console['table']} table
* @property {Console['time']} time
* @property {Console['timeEnd']} timeEnd
* @property {Console['timeStamp']} timeStamp
*/
/* This is deliberately *not* JSDoc, it is a regular comment.
*
* TODO: We'd like to add the following properties to the above
* VirtualConsole, but they currently cause conflicts where
* some Typescript implementations don't have these properties
* on the Console type.
*
* @property {Console['profile']} profile
* @property {Console['profileEnd']} profileEnd
*/
/**
* @typedef {'debug' | 'log' | 'info' | 'warn' | 'error'} LogSeverity
*/
/**
* @typedef ConsoleFilter
* @property {(severity: LogSeverity) => boolean} canLog
*/
/**
* @callback FilterConsole
* @param {VirtualConsole} baseConsole
* @param {ConsoleFilter} filter
* @param {string} [topic]
* @returns {VirtualConsole}
*/
})()
,
// === functors[6] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; $h‍_imports([]); // @ts-check
/**
* @typedef {readonly any[]} LogArgs
*
* This is an array suitable to be used as arguments of a console
* level message *after* the format string argument. It is the result of
* a `details` template string and consists of alternating literal strings
* and substitution values, starting with a literal string. At least that
* first literal string is always present.
*/
/**
* @callback NoteCallback
*
* @param {Error} error
* @param {LogArgs} noteLogArgs
* @returns {void}
*/
/**
* @callback GetStackString
* @param {Error} error
* @returns {string=}
*/
/**
* @typedef {object} LoggedErrorHandler
*
* Used to parameterize `makeCausalConsole` to give it access to potentially
* hidden information to augment the logging of errors.
*
* @property {GetStackString} getStackString
* @property {(error: Error) => string} tagError
* @property {() => void} resetErrorTagNum for debugging purposes only
* @property {(error: Error) => (LogArgs | undefined)} getMessageLogArgs
* @property {(error: Error) => (LogArgs | undefined)} takeMessageLogArgs
* @property {(error: Error, callback?: NoteCallback) => LogArgs[] } takeNoteLogArgsArray
*/
// /////////////////////////////////////////////////////////////////////////////
/**
* @typedef {readonly [string, ...any[]]} LogRecord
*/
/**
* @typedef {object} LoggingConsoleKit
* @property {VirtualConsole} loggingConsole
* @property {() => readonly LogRecord[]} takeLog
*/
/**
* @typedef {object} MakeLoggingConsoleKitOptions
* @property {boolean=} shouldResetForDebugging
*/
/**
* @callback MakeLoggingConsoleKit
*
* A logging console just accumulates the contents of all whitelisted calls,
* making them available to callers of `takeLog()`. Calling `takeLog()`
* consumes these, so later calls to `takeLog()` will only provide a log of
* calls that have happened since then.
*
* @param {LoggedErrorHandler} loggedErrorHandler
* @param {MakeLoggingConsoleKitOptions=} options
* @returns {LoggingConsoleKit}
*/
/**
* @typedef {{
* NOTE: 'ERROR_NOTE:',
* MESSAGE: 'ERROR_MESSAGE:',
* CAUSE: 'cause:',
* ERRORS: 'errors:',
* }} ErrorInfo
*/
/**
* @typedef {ErrorInfo[keyof ErrorInfo]} ErrorInfoKind
*/
/**
* @callback MakeCausalConsole
*
* Makes a causal console wrapper of a `baseConsole`, where the causal console
* calls methods of the `loggedErrorHandler` to customize how it handles logged
* errors.
*
* @param {VirtualConsole | undefined} baseConsole
* @param {LoggedErrorHandler} loggedErrorHandler
* @returns {VirtualConsole | undefined}
*/
})()
,
// === functors[7] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; $h‍_imports([]); // @ts-check
/* eslint-disable @endo/no-polymorphic-call */
// eslint-disable-next-line no-restricted-globals
const { isSafeInteger}= Number;
// eslint-disable-next-line no-restricted-globals
const { freeze}= Object;
// eslint-disable-next-line no-restricted-globals
const { toStringTag: toStringTagSymbol}= Symbol;
/**
* @template Data
* @typedef {object} DoublyLinkedCell
* A cell of a doubly-linked ring, i.e., a doubly-linked circular list.
* DoublyLinkedCells are not frozen, and so should be closely encapsulated by
* any abstraction that uses them.
* @property {DoublyLinkedCell<Data>} next
* @property {DoublyLinkedCell<Data>} prev
* @property {Data} data
*/
/**
* Makes a new self-linked cell. There are two reasons to do so:
* * To make the head sigil of a new initially-empty doubly-linked ring.
* * To make a non-sigil cell to be `spliceAfter`ed.
*
* @template Data
* @param {Data} data
* @returns {DoublyLinkedCell<Data>}
*/
const makeSelfCell= (data)=>{
/** @type {Partial<DoublyLinkedCell<Data>>} */
const incompleteCell= {
next: undefined,
prev: undefined,
data};
const selfCell= /** @type {DoublyLinkedCell<Data>} */ incompleteCell;
selfCell.next= selfCell;
selfCell.prev= selfCell;
// Not frozen!
return selfCell;
};
/**
* Splices a self-linked non-sigil cell into a ring after `prev`.
* `prev` could be the head sigil, or it could be some other non-sigil
* cell within a ring.
*
* @template Data
* @param {DoublyLinkedCell<Data>} prev
* @param {DoublyLinkedCell<Data>} selfCell
*/
const spliceAfter= (prev, selfCell)=> {
if( prev=== selfCell) {
// eslint-disable-next-line no-restricted-globals
throw TypeError('Cannot splice a cell into itself');
}
if( selfCell.next!== selfCell|| selfCell.prev!== selfCell) {
// eslint-disable-next-line no-restricted-globals
throw TypeError('Expected self-linked cell');
}
const cell= selfCell;
// rename variable cause it isn't self-linked after this point.
const next= prev.next;
cell.prev= prev;
cell.next= next;
prev.next= cell;
next.prev= cell;
// Not frozen!
return cell;
};
/**
* @template Data
* @param {DoublyLinkedCell<Data>} cell
* No-op if the cell is self-linked.
*/
const spliceOut= (cell)=>{
const { prev, next}= cell;
prev.next= next;
next.prev= prev;
cell.prev= cell;
cell.next= cell;
};
/**
* The LRUCacheMap is used within the implementation of `assert` and so
* at a layer below SES or harden. Thus, we give it a `WeakMap`-like interface
* rather than a `WeakMapStore`-like interface. To work before `lockdown`,
* the implementation must use `freeze` manually, but still exhaustively.
*
* It implements the WeakMap interface, and holds its keys weakly. Cached
* values are only held while the key is held by the user and the key/value
* bookkeeping cell has not been pushed off the end of the cache by `budget`
* number of more recently referenced cells. If the key is dropped by the user,
* the value will no longer be held by the cache, but the bookkeeping cell
* itself will stay in memory.
*
* @template {{}} K
* @template {unknown} V
* @param {number} keysBudget
* @returns {WeakMap<K,V>}
*/
const makeLRUCacheMap= (keysBudget)=>{
if( !isSafeInteger(keysBudget)|| keysBudget< 0) {
// eslint-disable-next-line no-restricted-globals
throw TypeError('keysBudget must be a safe non-negative integer number');
}
/** @typedef {DoublyLinkedCell<WeakMap<K, V> | undefined>} LRUCacheCell */
/** @type {WeakMap<K, LRUCacheCell>} */
// eslint-disable-next-line no-restricted-globals
const keyToCell= new WeakMap();
let size= 0; // `size` must remain <= `keysBudget`
// As a sigil, `head` uniquely is not in the `keyToCell` map.
/** @type {LRUCacheCell} */
const head= makeSelfCell(undefined);
const touchCell= (key)=>{
const cell= keyToCell.get(key);
if( cell=== undefined|| cell.data=== undefined) {
// Either the key was GCed, or the cell was condemned.
return undefined;
}
// Becomes most recently used
spliceOut(cell);
spliceAfter(head, cell);
return cell;
};
/**
* @param {K} key
*/
const has= (key)=>touchCell(key)!== undefined;
freeze(has);
/**
* @param {K} key
*/
// UNTIL https://github.com/endojs/endo/issues/1514
// Prefer: const get = key => touchCell(key)?.data?.get(key);
const get= (key)=>{
const cell= touchCell(key);
return cell&& cell.data&& cell.data.get(key);
};
freeze(get);
/**
* @param {K} key
* @param {V} value
*/
const set= (key, value)=> {
if( keysBudget< 1) {
// eslint-disable-next-line no-use-before-define
return lruCacheMap; // Implements WeakMap.set
}
let cell= touchCell(key);
if( cell=== undefined) {
cell= makeSelfCell(undefined);
spliceAfter(head, cell); // start most recently used
}
if( !cell.data) {
// Either a fresh cell or a reused condemned cell.
size+= 1;
// Add its data.
// eslint-disable-next-line no-restricted-globals
cell.data= new WeakMap();
// Advertise the cell for this key.
keyToCell.set(key, cell);
while( size> keysBudget) {
const condemned= head.prev;
spliceOut(condemned); // Drop least recently used
condemned.data= undefined;
size-= 1;
}
}
// Update the data.
cell.data.set(key, value);
// eslint-disable-next-line no-use-before-define
return lruCacheMap; // Implements WeakMap.set
};
freeze(set);
// "delete" is a keyword.
/**
* @param {K} key
*/
const deleteIt= (key)=>{
const cell= keyToCell.get(key);
if( cell=== undefined) {
return false;
}
spliceOut(cell);
keyToCell.delete(key);
if( cell.data=== undefined) {
// Already condemned.
return false;
}
cell.data= undefined;
size-= 1;
return true;
};
freeze(deleteIt);
const lruCacheMap= freeze({
has,
get,
set,
delete: deleteIt,
// eslint-disable-next-line jsdoc/check-types
[/** @type {typeof Symbol.toStringTag} */ toStringTagSymbol]:
'LRUCacheMap'});
return lruCacheMap;
};$h‍_once.makeLRUCacheMap(makeLRUCacheMap);
freeze(makeLRUCacheMap);
})()
,
// === functors[8] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let makeLRUCacheMap;$h‍_imports([["../make-lru-cachemap.js", [["makeLRUCacheMap", [$h‍_a => (makeLRUCacheMap = $h‍_a)]]]],["./internal-types.js", []]]);
const { freeze}= Object;
const { isSafeInteger}= Number;
const defaultLoggedErrorsBudget= 1000;
const defaultArgsPerErrorBudget= 100;
/**
* @param {number} [errorsBudget]
* @param {number} [argsPerErrorBudget]
*/
const makeNoteLogArgsArrayKit= (
errorsBudget= defaultLoggedErrorsBudget,
argsPerErrorBudget= defaultArgsPerErrorBudget)=>
{
if( !isSafeInteger(argsPerErrorBudget)|| argsPerErrorBudget< 1) {
throw TypeError(
'argsPerErrorBudget must be a safe positive integer number');
}
/**
* @type {WeakMap<Error, LogArgs[]>}
*
* Maps from an error to an array of log args, where each log args is
* remembered as an annotation on that error. This can be used, for example,
* to keep track of additional causes of the error. The elements of any
* log args may include errors which are associated with further annotations.
* An augmented console, like the causal console of `console.js`, could
* then retrieve the graph of such annotations.
*/
const noteLogArgsArrayMap= makeLRUCacheMap(errorsBudget);
/**
* @param {Error} error
* @param {LogArgs} logArgs
*/
const addLogArgs= (error, logArgs)=> {
const logArgsArray= noteLogArgsArrayMap.get(error);
if( logArgsArray!== undefined) {
if( logArgsArray.length>= argsPerErrorBudget) {
logArgsArray.shift();
}
logArgsArray.push(logArgs);
}else {
noteLogArgsArrayMap.set(error, [logArgs]);
}
};
freeze(addLogArgs);
/**
* @param {Error} error
* @returns {LogArgs[] | undefined}
*/
const takeLogArgsArray= (error)=>{
const result= noteLogArgsArrayMap.get(error);
noteLogArgsArrayMap.delete(error);
return result;
};
freeze(takeLogArgsArray);
return freeze({
addLogArgs,
takeLogArgsArray});
};$h‍_once.makeNoteLogArgsArrayKit(makeNoteLogArgsArrayKit);
freeze(makeNoteLogArgsArrayKit);
})()
,
// === functors[9] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let RangeError,TypeError,WeakMap,arrayJoin,arrayMap,arrayPop,arrayPush,assign,freeze,defineProperty,globalThis,is,isError,regexpTest,stringIndexOf,stringReplace,stringSlice,stringStartsWith,weakmapDelete,weakmapGet,weakmapHas,weakmapSet,AggregateError,getOwnPropertyDescriptors,ownKeys,create,objectPrototype,objectHasOwnProperty,an,bestEffortStringify,makeNoteLogArgsArrayKit;$h‍_imports([["../commons.js", [["RangeError", [$h‍_a => (RangeError = $h‍_a)]],["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["WeakMap", [$h‍_a => (WeakMap = $h‍_a)]],["arrayJoin", [$h‍_a => (arrayJoin = $h‍_a)]],["arrayMap", [$h‍_a => (arrayMap = $h‍_a)]],["arrayPop", [$h‍_a => (arrayPop = $h‍_a)]],["arrayPush", [$h‍_a => (arrayPush = $h‍_a)]],["assign", [$h‍_a => (assign = $h‍_a)]],["freeze", [$h‍_a => (freeze = $h‍_a)]],["defineProperty", [$h‍_a => (defineProperty = $h‍_a)]],["globalThis", [$h‍_a => (globalThis = $h‍_a)]],["is", [$h‍_a => (is = $h‍_a)]],["isError", [$h‍_a => (isError = $h‍_a)]],["regexpTest", [$h‍_a => (regexpTest = $h‍_a)]],["stringIndexOf", [$h‍_a => (stringIndexOf = $h‍_a)]],["stringReplace", [$h‍_a => (stringReplace = $h‍_a)]],["stringSlice", [$h‍_a => (stringSlice = $h‍_a)]],["stringStartsWith", [$h‍_a => (stringStartsWith = $h‍_a)]],["weakmapDelete", [$h‍_a => (weakmapDelete = $h‍_a)]],["weakmapGet", [$h‍_a => (weakmapGet = $h‍_a)]],["weakmapHas", [$h‍_a => (weakmapHas = $h‍_a)]],["weakmapSet", [$h‍_a => (weakmapSet = $h‍_a)]],["AggregateError", [$h‍_a => (AggregateError = $h‍_a)]],["getOwnPropertyDescriptors", [$h‍_a => (getOwnPropertyDescriptors = $h‍_a)]],["ownKeys", [$h‍_a => (ownKeys = $h‍_a)]],["create", [$h‍_a => (create = $h‍_a)]],["objectPrototype", [$h‍_a => (objectPrototype = $h‍_a)]],["objectHasOwnProperty", [$h‍_a => (objectHasOwnProperty = $h‍_a)]]]],["./stringify-utils.js", [["an", [$h‍_a => (an = $h‍_a)]],["bestEffortStringify", [$h‍_a => (bestEffortStringify = $h‍_a)]]]],["./types.js", []],["./internal-types.js", []],["./note-log-args.js", [["makeNoteLogArgsArrayKit", [$h‍_a => (makeNoteLogArgsArrayKit = $h‍_a)]]]]]);
/**
* @import {BaseAssert, Assert, AssertionFunctions, AssertionUtilities, StringablePayload, DetailsToken, MakeAssert} from '../../types.js'
*/
// For our internal debugging purposes, uncomment
// const internalDebugConsole = console;
// /////////////////////////////////////////////////////////////////////////////
/** @type {WeakMap<StringablePayload, any>} */
const declassifiers= new WeakMap();
/** @type {AssertionUtilities['quote']} */
const quote= (payload, spaces= undefined)=> {
const result= freeze({
toString: freeze(()=> bestEffortStringify(payload, spaces))});
weakmapSet(declassifiers, result, payload);
return result;
};$h‍_once.quote(quote);
freeze(quote);
const canBeBare= freeze(/^[\w:-]( ?[\w:-])*$/);
/**
* @type {AssertionUtilities['bare']}
*/
const bare= (payload, spaces= undefined)=> {
if( typeof payload!== 'string'|| !regexpTest(canBeBare, payload)) {
return quote(payload, spaces);
}
const result= freeze({
toString: freeze(()=> payload)});
weakmapSet(declassifiers, result, payload);
return result;
};$h‍_once.bare(bare);
freeze(bare);
// /////////////////////////////////////////////////////////////////////////////
/**
* @typedef {object} HiddenDetails
*
* Captures the arguments passed to the `details` template string tag.
*
* @property {TemplateStringsArray | string[]} template
* @property {any[]} args
*/
/**
* @type {WeakMap<DetailsToken, HiddenDetails>}
*
* Maps from a details token which a `details` template literal returned
* to a record of the contents of that template literal expression.
*/
const hiddenDetailsMap= new WeakMap();
/**
* @param {HiddenDetails} hiddenDetails
* @returns {string}
*/
const getMessageString= ({ template, args})=> {
const parts= [template[0]];
for( let i= 0; i< args.length; i+= 1) {
const arg= args[i];
let argStr;
if( weakmapHas(declassifiers, arg)) {
argStr= `${arg}`;
}else if( isError(arg)) {
argStr= `(${an(arg.name)})`;
}else {
argStr= `(${an(typeof arg)})`;
}
arrayPush(parts, argStr, template[i+ 1]);
}
return arrayJoin(parts, '');
};
/**
* Give detailsTokens a toString behavior. To minimize the overhead of
* creating new detailsTokens, we do this with an
* inherited `this` sensitive `toString` method, even though we normally
* avoid `this` sensitivity. To protect the method from inappropriate
* `this` application, it does something interesting only for objects
* registered in `redactedDetails`, which should be exactly the detailsTokens.
*
* The printing behavior must not reveal anything redacted, so we just use
* the same `getMessageString` we use to construct the redacted message
* string for a thrown assertion error.
*/
const DetailsTokenProto= freeze({
toString() {
const hiddenDetails= weakmapGet(hiddenDetailsMap, this);
if( hiddenDetails=== undefined) {
return '[Not a DetailsToken]';
}
return getMessageString(hiddenDetails);
}});
freeze(DetailsTokenProto.toString);
/**
* Normally this is the function exported as `assert.details` and often
* spelled `X`. However, if the `{errorTaming: 'unsafe'}` or
* `{errorTaming: 'unsafe-debug'}` option is
* given to `lockdown`, then `unredactedDetails` is used instead.
*
* There are some unconditional uses of `redactedDetails` in this module. All
* of them should be uses where the template literal has no redacted
* substitution values. In those cases, the two are equivalent.
*
* @type {AssertionUtilities['details']}
*/
const redactedDetails= (template, ...args)=> {
// Keep in mind that the vast majority of calls to `details` creates
// a details token that is never used, so this path must remain as fast as
// possible. Hence we store what we've got with little processing, postponing
// all the work to happen only if needed, for example, if an assertion fails.
const detailsToken= freeze({ __proto__: DetailsTokenProto});
weakmapSet(hiddenDetailsMap, detailsToken, { template, args});
return (/** @type {DetailsToken} */ /** @type {unknown} */ detailsToken);
};$h‍_once.redactedDetails(redactedDetails);
freeze(redactedDetails);
/**
* `unredactedDetails` is like `details` except that it does not redact
* anything. It acts like `details` would act if all substitution values
* were wrapped with the `quote` function above (the function normally
* spelled `q`). If the `{errorTaming: 'unsafe'}`
* or `{errorTaming: 'unsafe-debug'}` option is given to
* `lockdown`, then the lockdown-shim arranges for the global `assert` to be
* one whose `details` property is `unredactedDetails`.
* This setting optimizes the debugging and testing experience at the price
* of safety. `unredactedDetails` also sacrifices the speed of `details`,
* which is usually fine in debugging and testing.
*
* @type {AssertionUtilities['details']}
*/
const unredactedDetails= (template, ...args)=> {
args= arrayMap(args, (arg)=>
weakmapHas(declassifiers, arg)? arg: quote(arg));
return redactedDetails(template, ...args);
};$h‍_once.unredactedDetails(unredactedDetails);
freeze(unredactedDetails);
/**
* @param {HiddenDetails} hiddenDetails
* @returns {LogArgs}
*/
const getLogArgs= ({ template, args})=> {
const logArgs= [template[0]];
for( let i= 0; i< args.length; i+= 1) {
let arg= args[i];
if( weakmapHas(declassifiers, arg)) {
arg= weakmapGet(declassifiers, arg);
}
// Remove the extra spaces (since console.error puts them
// between each cause).
const priorWithoutSpace= stringReplace(arrayPop(logArgs)|| '', / $/, '');
if( priorWithoutSpace!== '') {
arrayPush(logArgs, priorWithoutSpace);
}
const nextWithoutSpace= stringReplace(template[i+ 1], /^ /, '');
arrayPush(logArgs, arg, nextWithoutSpace);
}
if( logArgs[logArgs.length- 1]=== '') {
arrayPop(logArgs);
}
return logArgs;
};
/**
* @type {WeakMap<Error, LogArgs>}
*
* Maps from an error object to the log args that are a more informative
* alternative message for that error. When logging the error, these
* log args should be preferred to `error.message`.
*/
const hiddenMessageLogArgs= new WeakMap();
// So each error tag will be unique.
let errorTagNum= 0;
/**
* @type {WeakMap<Error, string>}
*/
const errorTags= new WeakMap();
/**
* @param {Error} err
* @param {string=} optErrorName
* @returns {string}
*/
const tagError= (err, optErrorName= err.name)=> {
let errorTag= weakmapGet(errorTags, err);
if( errorTag!== undefined) {
return errorTag;
}
errorTagNum+= 1;
errorTag= `${optErrorName}#${errorTagNum}`;
weakmapSet(errorTags, err, errorTag);
return errorTag;
};
/**
* Make reasonable best efforts to make a `Passable` error.
* - `sanitizeError` will remove any "extraneous" own properties already added
* by the host,
* such as `fileName`,`lineNumber` on FireFox or `line` on Safari.
* - If any such "extraneous" properties were removed, `sanitizeError` will
* annotate
* the error with them, so they still appear on the causal console
* log output for diagnostic purposes, but not be otherwise visible.
* - `sanitizeError` will ensure that any expected properties already
* added by the host are data
* properties, converting accessor properties to data properties as needed,
* such as `stack` on v8 (Chrome, Brave, Edge?)
* - `sanitizeError` will freeze the error, preventing any correct engine from
* adding or
* altering any of the error's own properties `sanitizeError` is done.
*
* However, `sanitizeError` will not, for example, `harden`
* (i.e., deeply freeze)
* or ensure that the `cause` or `errors` property satisfy the `Passable`
* constraints. The purpose of `sanitizeError` is only to protect against
* mischief the host may have already added to the error as created,
* not to ensure that the error is actually Passable. For that,
* see `toPassableError` in `@endo/pass-style`.
*
* @param {Error} error
*/
const sanitizeError= (error)=>{
const descs= getOwnPropertyDescriptors(error);
const {
name: _nameDesc,
message: _messageDesc,
errors: _errorsDesc= undefined,
cause: _causeDesc= undefined,
stack: _stackDesc= undefined,
...restDescs}=
descs;
const restNames= ownKeys(restDescs);
if( restNames.length>= 1) {
for( const name of restNames) {
delete error[name];
}
const droppedNote= create(objectPrototype, restDescs);
// eslint-disable-next-line no-use-before-define
note(
error,
redactedDetails `originally with properties ${quote(droppedNote)}`);
}
for( const name of ownKeys(error)) {
// @ts-expect-error TS still confused by symbols as property names
const desc= descs[name];
if( desc&& objectHasOwnProperty(desc, 'get')) {
defineProperty(error, name, {
value: error[name] // invoke the getter to convert to data property
});
}
}
freeze(error);
};
/**
* @type {AssertionUtilities['error']}
*/$h‍_once.sanitizeError(sanitizeError);
const makeError= (
optDetails= redactedDetails `Assert failed`,
errConstructor= globalThis.Error,
{
errorName= undefined,
cause= undefined,
errors= undefined,
sanitize= true}=
{})=>
{
if( typeof optDetails=== 'string') {
// If it is a string, use it as the literal part of the template so
// it doesn't get quoted.
optDetails= redactedDetails([optDetails]);
}
const hiddenDetails= weakmapGet(hiddenDetailsMap, optDetails);
if( hiddenDetails=== undefined) {
throw TypeError( `unrecognized details ${quote(optDetails)}`);
}
const messageString= getMessageString(hiddenDetails);
const opts= cause&& { cause};
let error;
if(
typeof AggregateError!== 'undefined'&&
errConstructor=== AggregateError)
{
error= AggregateError(errors|| [], messageString, opts);
}else {
error= /** @type {ErrorConstructor} */ errConstructor(
messageString,
opts);
if( errors!== undefined) {
// Since we need to tolerate `errors` on an AggregateError, may as
// well tolerate it on all errors.
defineProperty(error, 'errors', {
value: errors,
writable: true,
enumerable: false,
configurable: true});
}
}
weakmapSet(hiddenMessageLogArgs, error, getLogArgs(hiddenDetails));
if( errorName!== undefined) {
tagError(error, errorName);
}
if( sanitize) {
sanitizeError(error);
}
// The next line is a particularly fruitful place to put a breakpoint.
return error;
};$h‍_once.makeError(makeError);
freeze(makeError);
// /////////////////////////////////////////////////////////////////////////////
const { addLogArgs, takeLogArgsArray}= makeNoteLogArgsArrayKit();
/**
* @type {WeakMap<Error, NoteCallback[]>}
*
* An augmented console will normally only take the hidden noteArgs array once,
* when it logs the error being annotated. Once that happens, further
* annotations of that error should go to the console immediately. We arrange
* that by accepting a note-callback function from the console as an optional
* part of that taking operation. Normally there will only be at most one
* callback per error, but that depends on console behavior which we should not
* assume. We make this an array of callbacks so multiple registrations
* are independent.
*/
const hiddenNoteCallbackArrays= new WeakMap();
/** @type {AssertionUtilities['note']} */
const note= (error, detailsNote)=> {
if( typeof detailsNote=== 'string') {
// If it is a string, use it as the literal part of the template so
// it doesn't get quoted.
detailsNote= redactedDetails([detailsNote]);
}
const hiddenDetails= weakmapGet(hiddenDetailsMap, detailsNote);
if( hiddenDetails=== undefined) {
throw TypeError( `unrecognized details ${quote(detailsNote)}`);
}
const logArgs= getLogArgs(hiddenDetails);
const callbacks= weakmapGet(hiddenNoteCallbackArrays, error);
if( callbacks!== undefined) {
for( const callback of callbacks) {
callback(error, logArgs);
}
}else {
addLogArgs(error, logArgs);
}
};$h‍_once.note(note);
freeze(note);
/**
* The unprivileged form that just uses the de facto `error.stack` property.
* The start compartment normally has a privileged `globalThis.getStackString`
* which should be preferred if present.
*
* @param {Error} error
* @returns {string}
*/
const defaultGetStackString= (error)=>{
if( !('stack'in error)) {
return '';
}
const stackString= `${error.stack}`;
const pos= stringIndexOf(stackString, '\n');
if( stringStartsWith(stackString, ' ')|| pos=== -1) {
return stackString;
}
return stringSlice(stackString, pos+ 1); // exclude the initial newline
};
/** @type {LoggedErrorHandler} */
const loggedErrorHandler= {
getStackString: globalThis.getStackString|| defaultGetStackString,
tagError: (error)=>tagError(error),
resetErrorTagNum: ()=> {
errorTagNum= 0;
},
getMessageLogArgs: (error)=>weakmapGet(hiddenMessageLogArgs, error),
takeMessageLogArgs: (error)=>{
const result= weakmapGet(hiddenMessageLogArgs, error);
weakmapDelete(hiddenMessageLogArgs, error);
return result;
},
takeNoteLogArgsArray: (error, callback)=> {
const result= takeLogArgsArray(error);
if( callback!== undefined) {
const callbacks= weakmapGet(hiddenNoteCallbackArrays, error);
if( callbacks) {
arrayPush(callbacks, callback);
}else {
weakmapSet(hiddenNoteCallbackArrays, error, [callback]);
}
}
return result|| [];
}};$h‍_once.loggedErrorHandler(loggedErrorHandler);
freeze(loggedErrorHandler);
// /////////////////////////////////////////////////////////////////////////////
/**
* @type {MakeAssert}
*/
const makeAssert= (optRaise= undefined, unredacted= false)=> {
const details= unredacted? unredactedDetails: redactedDetails;
const assertFailedDetails= details `Check failed`;
/** @type {AssertionFunctions['fail']} */
const fail= (
optDetails= assertFailedDetails,
errConstructor= undefined,
options= undefined)=>
{
const reason= makeError(optDetails, errConstructor, options);
if( optRaise!== undefined) {
// @ts-ignore returns `never` doesn't mean it isn't callable
optRaise(reason);
}
throw reason;
};
freeze(fail);
/** @type {AssertionUtilities['Fail']} */
const Fail= (template, ...args)=> fail(details(template, ...args));
// Don't freeze or export `baseAssert` until we add methods.
// TODO If I change this from a `function` function to an arrow
// function, I seem to get type errors from TypeScript. Why?
/** @type {BaseAssert} */
function baseAssert(
flag,
optDetails= undefined,
errConstructor= undefined,
options= undefined)
{
flag|| fail(optDetails, errConstructor, options);
}
/** @type {AssertionFunctions['equal']} */
const equal= (
actual,
expected,
optDetails= undefined,
errConstructor= undefined,
options= undefined)=>
{
is(actual, expected)||
fail(
optDetails|| details `Expected ${actual} is same as ${expected}`,
errConstructor|| RangeError,
options);
};
freeze(equal);
/** @type {AssertionFunctions['typeof']} */
const assertTypeof= (specimen, typename, optDetails)=> {
// This will safely fall through if typename is not a string,
// which is what we want.
// eslint-disable-next-line valid-typeof
if( typeof specimen=== typename) {
return;
}
typeof typename=== 'string'|| Fail `${quote(typename)} must be a string`;
if( optDetails=== undefined) {
// Embed the type phrase without quotes.
const typeWithDeterminer= an(typename);
optDetails= details `${specimen} must be ${bare(typeWithDeterminer)}`;
}
fail(optDetails, TypeError);
};
freeze(assertTypeof);
/** @type {AssertionFunctions['string']} */
const assertString= (specimen, optDetails= undefined)=>
assertTypeof(specimen, 'string', optDetails);
// Note that "assert === baseAssert"
/** @type {Assert} */
const assert= assign(baseAssert, {
error: makeError,
fail,
equal,
typeof: assertTypeof,
string: assertString,
note,
details,
Fail,
quote,
bare,
makeAssert});
return freeze(assert);
};$h‍_once.makeAssert(makeAssert);
freeze(makeAssert);
/** @type {Assert} */
const assert= makeAssert();$h‍_once.assert(assert);
// Internal, to obviate polymorphic dispatch, but may become rigorously
// consistent with @endo/error:
/** @type {AssertionFunctions['equal']} */
const assertEqual= assert.equal;$h‍_once.assertEqual(assertEqual);
})()
,
// === functors[10] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let Set,String,TypeError,WeakSet,globalThis,apply,arrayForEach,defineProperty,freeze,getOwnPropertyDescriptor,getOwnPropertyDescriptors,getPrototypeOf,isInteger,isObject,objectHasOwnProperty,ownKeys,preventExtensions,setAdd,setForEach,setHas,toStringTagSymbol,typedArrayPrototype,weaksetAdd,weaksetHas,FERAL_STACK_GETTER,FERAL_STACK_SETTER,isError,assert;$h‍_imports([["./commons.js", [["Set", [$h‍_a => (Set = $h‍_a)]],["String", [$h‍_a => (String = $h‍_a)]],["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["WeakSet", [$h‍_a => (WeakSet = $h‍_a)]],["globalThis", [$h‍_a => (globalThis = $h‍_a)]],["apply", [$h‍_a => (apply = $h‍_a)]],["arrayForEach", [$h‍_a => (arrayForEach = $h‍_a)]],["defineProperty", [$h‍_a => (defineProperty = $h‍_a)]],["freeze", [$h‍_a => (freeze = $h‍_a)]],["getOwnPropertyDescriptor", [$h‍_a => (getOwnPropertyDescriptor = $h‍_a)]],["getOwnPropertyDescriptors", [$h‍_a => (getOwnPropertyDescriptors = $h‍_a)]],["getPrototypeOf", [$h‍_a => (getPrototypeOf = $h‍_a)]],["isInteger", [$h‍_a => (isInteger = $h‍_a)]],["isObject", [$h‍_a => (isObject = $h‍_a)]],["objectHasOwnProperty", [$h‍_a => (objectHasOwnProperty = $h‍_a)]],["ownKeys", [$h‍_a => (ownKeys = $h‍_a)]],["preventExtensions", [$h‍_a => (preventExtensions = $h‍_a)]],["setAdd", [$h‍_a => (setAdd = $h‍_a)]],["setForEach", [$h‍_a => (setForEach = $h‍_a)]],["setHas", [$h‍_a => (setHas = $h‍_a)]],["toStringTagSymbol", [$h‍_a => (toStringTagSymbol = $h‍_a)]],["typedArrayPrototype", [$h‍_a => (typedArrayPrototype = $h‍_a)]],["weaksetAdd", [$h‍_a => (weaksetAdd = $h‍_a)]],["weaksetHas", [$h‍_a => (weaksetHas = $h‍_a)]],["FERAL_STACK_GETTER", [$h‍_a => (FERAL_STACK_GETTER = $h‍_a)]],["FERAL_STACK_SETTER", [$h‍_a => (FERAL_STACK_SETTER = $h‍_a)]],["isError", [$h‍_a => (isError = $h‍_a)]]]],["./error/assert.js", [["assert", [$h‍_a => (assert = $h‍_a)]]]]]);
/**
* @import {Harden} from '../types.js'
*/
// Obtain the string tag accessor of of TypedArray so we can indirectly use the
// TypedArray brand check it employs.
const typedArrayToStringTag= getOwnPropertyDescriptor(
typedArrayPrototype,
toStringTagSymbol);
assert(typedArrayToStringTag);
const getTypedArrayToStringTag= typedArrayToStringTag.get;
assert(getTypedArrayToStringTag);
// Exported for tests.
/**
* Duplicates packages/marshal/src/helpers/passStyle-helpers.js to avoid a dependency.
*
* @param {unknown} object
*/
const isTypedArray= (object)=>{
// The object must pass a brand check or toStringTag will return undefined.
const tag= apply(getTypedArrayToStringTag, object, []);
return tag!== undefined;
};
/**
* Tests if a property key is an integer-valued canonical numeric index.
* https://tc39.es/ecma262/#sec-canonicalnumericindexstring
*
* @param {string | symbol} propertyKey
*/$h‍_once.isTypedArray(isTypedArray);
const isCanonicalIntegerIndexString= (propertyKey)=>{
const n= +String(propertyKey);
return isInteger(n)&& String(n)=== propertyKey;
};
/**
* @template T
* @param {ArrayLike<T>} array
*/
const freezeTypedArray= (array)=>{
preventExtensions(array);
// Downgrade writable expandos to readonly, even if non-configurable.
// We get each descriptor individually rather than using
// getOwnPropertyDescriptors in order to fail safe when encountering
// an obscure GraalJS issue where getOwnPropertyDescriptor returns
// undefined for a property that does exist.
arrayForEach(ownKeys(array), (/** @type {string | symbol} */ name)=> {
const desc= getOwnPropertyDescriptor(array, name);
assert(desc);
// TypedArrays are integer-indexed exotic objects, which define special
// treatment for property names in canonical numeric form:
// integers in range are permanently writable and non-configurable.
// https://tc39.es/ecma262/#sec-integer-indexed-exotic-objects
//
// This is analogous to the data of a hardened Map or Set,
// so we carve out this exceptional behavior but make all other
// properties non-configurable.
if( !isCanonicalIntegerIndexString(name)) {
defineProperty(array, name, {
...desc,
writable: false,
configurable: false});
}
});
};
/**
* Create a `harden` function.
*
* @returns {Harden}
*/
const makeHardener= ()=> {
// Use a native hardener if possible.
if( typeof globalThis.harden=== 'function') {
const safeHarden= globalThis.harden;
return safeHarden;
}
const hardened= new WeakSet();
const { harden}= {
/**
* @template T
* @param {T} root
* @returns {T}
*/
harden(root) {
const toFreeze= new Set();
// If val is something we should be freezing but aren't yet,
// add it to toFreeze.
/**
* @param {any} val
*/
function enqueue(val) {
if( !isObject(val)) {
// ignore primitives
return;
}
const type= typeof val;
if( type!== 'object'&& type!== 'function') {
// future proof: break until someone figures out what it should do
throw TypeError( `Unexpected typeof: ${type}`);
}
if( weaksetHas(hardened, val)|| setHas(toFreeze, val)) {
// Ignore if this is an exit, or we've already visited it
return;
}
// console.warn(`adding ${val} to toFreeze`, val);
setAdd(toFreeze, val);
}
/**
* @param {any} obj
*/
const baseFreezeAndTraverse= (obj)=>{
// Now freeze the object to ensure reactive
// objects such as proxies won't add properties
// during traversal, before they get frozen.
// Object are verified before being enqueued,
// therefore this is a valid candidate.
// Throws if this fails (strict mode).
// Also throws if the object is an ArrayBuffer or any TypedArray.
if( isTypedArray(obj)) {
freezeTypedArray(obj);
}else {
freeze(obj);
}
// we rely upon certain commitments of Object.freeze and proxies here
// get stable/immutable outbound links before a Proxy has a chance to do
// something sneaky.
const descs= getOwnPropertyDescriptors(obj);
const proto= getPrototypeOf(obj);
enqueue(proto);
arrayForEach(ownKeys(descs), (/** @type {string | symbol} */ name)=> {
// The 'name' may be a symbol, and TypeScript doesn't like us to
// index arbitrary symbols on objects, so we pretend they're just
// strings.
const desc= descs[/** @type {string} */ name];
// getOwnPropertyDescriptors is guaranteed to return well-formed
// descriptors, but they still inherit from Object.prototype. If
// someone has poisoned Object.prototype to add 'value' or 'get'
// properties, then a simple 'if ("value" in desc)' or 'desc.value'
// test could be confused. We use hasOwnProperty to be sure about
// whether 'value' is present or not, which tells us for sure that
// this is a data property.
if( objectHasOwnProperty(desc, 'value')) {
enqueue(desc.value);
}else {
enqueue(desc.get);
enqueue(desc.set);
}
});
};
const freezeAndTraverse=
FERAL_STACK_GETTER=== undefined&& FERAL_STACK_SETTER=== undefined?
// On platforms without v8's error own stack accessor problem,
// don't pay for any extra overhead.
baseFreezeAndTraverse:
(obj)=>{
if( isError(obj)) {
// Only pay the overhead if it first passes this cheap isError
// check. Otherwise, it will be unrepaired, but won't be judged
// to be a passable error anyway, so will not be unsafe.
const stackDesc= getOwnPropertyDescriptor(obj, 'stack');
if(
stackDesc&&
stackDesc.get=== FERAL_STACK_GETTER&&
stackDesc.configurable)
{
// Can only repair if it is configurable. Otherwise, leave
// unrepaired, in which case it will not be judged passable,
// avoiding a safety problem.
defineProperty(obj, 'stack', {
// NOTE: Calls getter during harden, which seems dangerous.
// But we're only calling the problematic getter whose
// hazards we think we understand.
// @ts-expect-error TS should know FERAL_STACK_GETTER
// cannot be `undefined` here.
// See https://github.com/endojs/endo/pull/2232#discussion_r1575179471
value: apply(FERAL_STACK_GETTER, obj, [])});
}
}
return baseFreezeAndTraverse(obj);
};
const dequeue= ()=> {
// New values added before forEach() has finished will be visited.
setForEach(toFreeze, freezeAndTraverse);
};
/** @param {any} value */
const markHardened= (value)=>{
weaksetAdd(hardened, value);
};
const commit= ()=> {
setForEach(toFreeze, markHardened);
};
enqueue(root);
dequeue();
// console.warn("toFreeze set:", toFreeze);
commit();
return root;
}};
return harden;
};$h‍_once.makeHardener(makeHardener);
})()
,
// === functors[11] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let arrayPush;$h‍_imports([["./commons.js", [["arrayPush", [$h‍_a => (arrayPush = $h‍_a)]]]]]);
/** @import {GenericErrorConstructor} from '../types.js' */
/**
* @file Exports {@code whitelist}, a recursively defined
* JSON record enumerating all intrinsics and their properties
* according to ECMA specs.
*
* @author JF Paradis
* @author Mark S. Miller
*/
/**
* constantProperties
* non-configurable, non-writable data properties of all global objects.
* Must be powerless.
* Maps from property name to the actual value
*/
const constantProperties= {
// *** Value Properties of the Global Object
Infinity,
NaN,
undefined};
/**
* universalPropertyNames
* Properties of all global objects.
* Must be powerless.
* Maps from property name to the intrinsic name in the whitelist.
*/$h‍_once.constantProperties(constantProperties);
const universalPropertyNames= {
// *** Function Properties of the Global Object
isFinite: 'isFinite',
isNaN: 'isNaN',
parseFloat: 'parseFloat',
parseInt: 'parseInt',
decodeURI: 'decodeURI',
decodeURIComponent: 'decodeURIComponent',
encodeURI: 'encodeURI',
encodeURIComponent: 'encodeURIComponent',
// *** Constructor Properties of the Global Object
Array: 'Array',
ArrayBuffer: 'ArrayBuffer',
BigInt: 'BigInt',
BigInt64Array: 'BigInt64Array',
BigUint64Array: 'BigUint64Array',
Boolean: 'Boolean',
DataView: 'DataView',
EvalError: 'EvalError',
// https://github.com/tc39/proposal-float16array
Float16Array: 'Float16Array',
Float32Array: 'Float32Array',
Float64Array: 'Float64Array',
Int8Array: 'Int8Array',
Int16Array: 'Int16Array',
Int32Array: 'Int32Array',
Map: 'Map',
Number: 'Number',
Object: 'Object',
Promise: 'Promise',
Proxy: 'Proxy',
RangeError: 'RangeError',
ReferenceError: 'ReferenceError',
Set: 'Set',
String: 'String',
SyntaxError: 'SyntaxError',
TypeError: 'TypeError',
Uint8Array: 'Uint8Array',
Uint8ClampedArray: 'Uint8ClampedArray',
Uint16Array: 'Uint16Array',
Uint32Array: 'Uint32Array',
URIError: 'URIError',
WeakMap: 'WeakMap',
WeakSet: 'WeakSet',
// https://github.com/tc39/proposal-iterator-helpers
Iterator: 'Iterator',
// https://github.com/tc39/proposal-async-iterator-helpers
AsyncIterator: 'AsyncIterator',
// https://github.com/endojs/endo/issues/550
AggregateError: 'AggregateError',
// *** Other Properties of the Global Object
JSON: 'JSON',
Reflect: 'Reflect',
// *** Annex B
escape: 'escape',
unescape: 'unescape',
// ESNext
lockdown: 'lockdown',
harden: 'harden',
HandledPromise: 'HandledPromise' // TODO: Until Promise.delegate (see below).
};
/**
* initialGlobalPropertyNames
* Those found only on the initial global, i.e., the global of the
* start compartment, as well as any compartments created before lockdown.
* These may provide much of the power provided by the original.
* Maps from property name to the intrinsic name in the whitelist.
*/$h‍_once.universalPropertyNames(universalPropertyNames);
const initialGlobalPropertyNames= {
// *** Constructor Properties of the Global Object
Date: '%InitialDate%',
Error: '%InitialError%',
RegExp: '%InitialRegExp%',
// Omit `Symbol`, because we want the original to appear on the
// start compartment without passing through the whitelist mechanism, since
// we want to preserve all its properties, even if we never heard of them.
// Symbol: '%InitialSymbol%',
// *** Other Properties of the Global Object
Math: '%InitialMath%',
// ESNext
// From Error-stack proposal
// Only on initial global. No corresponding
// powerless form for other globals.
getStackString: '%InitialGetStackString%'
// TODO https://github.com/Agoric/SES-shim/issues/551
// Need initial WeakRef and FinalizationGroup in
// start compartment only.
};
/**
* sharedGlobalPropertyNames
* Those found only on the globals of new compartments created after lockdown,
* which must therefore be powerless.
* Maps from property name to the intrinsic name in the whitelist.
*/$h‍_once.initialGlobalPropertyNames(initialGlobalPropertyNames);
const sharedGlobalPropertyNames= {
// *** Constructor Properties of the Global Object
Date: '%SharedDate%',
Error: '%SharedError%',
RegExp: '%SharedRegExp%',
Symbol: '%SharedSymbol%',
// *** Other Properties of the Global Object
Math: '%SharedMath%'};
/**
* uniqueGlobalPropertyNames
* Those made separately for each global, including the initial global
* of the start compartment.
* Maps from property name to the intrinsic name in the whitelist
* (which is currently always the same).
*/$h‍_once.sharedGlobalPropertyNames(sharedGlobalPropertyNames);
const uniqueGlobalPropertyNames= {
// *** Value Properties of the Global Object
globalThis: '%UniqueGlobalThis%',
// *** Function Properties of the Global Object
eval: '%UniqueEval%',
// *** Constructor Properties of the Global Object
Function: '%UniqueFunction%',
// *** Other Properties of the Global Object
// ESNext
Compartment: '%UniqueCompartment%'
// According to current agreements, eventually the Realm constructor too.
// 'Realm',
};
// All the "subclasses" of Error. These are collectively represented in the
// ECMAScript spec by the meta variable NativeError.
/** @type {GenericErrorConstructor[]} */$h‍_once.uniqueGlobalPropertyNames(uniqueGlobalPropertyNames);
const NativeErrors= [
EvalError,
RangeError,
ReferenceError,
SyntaxError,
TypeError,
URIError
// https://github.com/endojs/endo/issues/550
// Commented out to accommodate platforms prior to AggregateError.
// Instead, conditional push below.
// AggregateError,
];$h‍_once.NativeErrors(NativeErrors);
if( typeof AggregateError!== 'undefined') {
// Conditional, to accommodate platforms prior to AggregateError
arrayPush(NativeErrors, AggregateError);
}
/**
* <p>Each JSON record enumerates the disposition of the properties on
* some corresponding intrinsic object.
*
* <p>All records are made of key-value pairs where the key
* is the property to process, and the value is the associated
* dispositions a.k.a. the "permit". Those permits can be:
* <ul>
* <li>The boolean value "false", in which case this property is
* blacklisted and simply removed. Properties not mentioned
* are also considered blacklisted and are removed.
* <li>A string value equal to a primitive ("number", "string", etc),
* in which case the property is whitelisted if its value property
* is typeof the given type. For example, {@code "Infinity"} leads to
* "number" and property values that fail {@code typeof "number"}.
* are removed.
* <li>A string value equal to an intinsic name ("ObjectPrototype",
* "Array", etc), in which case the property whitelisted if its
* value property is equal to the value of the corresponfing
* intrinsics. For example, {@code Map.prototype} leads to
* "MapPrototype" and the property is removed if its value is
* not equal to %MapPrototype%
* <li>Another record, in which case this property is simply
* whitelisted and that next record represents the disposition of
* the object which is its value. For example, {@code "Object"}
* leads to another record explaining what properties {@code
* "Object"} may have and how each such property should be treated.
*
* <p>Notes:
* <li>"[[Proto]]" is used to refer to the "[[Prototype]]" internal
* slot, which says which object this object inherits from.
* <li>"--proto--" is used to refer to the "__proto__" property name,
* which is the name of an accessor property on Object.prototype.
* In practice, it is used to access the [[Proto]] internal slot,
* but is distinct from the internal slot itself. We use
* "--proto--" rather than "__proto__" below because "__proto__"
* in an object literal is special syntax rather than a normal
* property definition.
* <li>"ObjectPrototype" is the default "[[Proto]]" (when not specified).
* <li>Constants "fn" and "getter" are used to keep the structure DRY.
* <li>Symbol properties are listed as follow:
* <li>Well-known symbols use the "@@name" form.
* <li>Registered symbols use the "RegisteredSymbol(key)" form.
* <li>Unique symbols use the "UniqueSymbol(description)" form.
*/
// Function Instances
const FunctionInstance= {
'[[Proto]]': '%FunctionPrototype%',
length: 'number',
name: 'string'
// Do not specify "prototype" here, since only Function instances that can
// be used as a constructor have a prototype property. For constructors,
// since prototype properties are instance-specific, we define it there.
};
// AsyncFunction Instances
$h‍_once.FunctionInstance(FunctionInstance);const AsyncFunctionInstance={
// This property is not mentioned in ECMA 262, but is present in V8 and
// necessary for lockdown to succeed.
'[[Proto]]': '%AsyncFunctionPrototype%'};
// Aliases
$h‍_once.AsyncFunctionInstance(AsyncFunctionInstance);const fn=FunctionInstance;
const asyncFn= AsyncFunctionInstance;
const getter= {
get: fn,
set: 'undefined'};
// Possible but not encountered in the specs
// export const setter = {
// get: 'undefined',
// set: fn,
// };
const accessor= {
get: fn,
set: fn};
const isAccessorPermit= (permit)=>{
return permit=== getter|| permit=== accessor;
};
// NativeError Object Structure
$h‍_once.isAccessorPermit(isAccessorPermit);function NativeError(prototype){
return {
// Properties of the NativeError Constructors
'[[Proto]]': '%SharedError%',
// NativeError.prototype
prototype};
}
function NativeErrorPrototype(constructor) {
return {
// Properties of the NativeError Prototype Objects
'[[Proto]]': '%ErrorPrototype%',
constructor,
message: 'string',
name: 'string',
// Redundantly present only on v8. Safe to remove.
toString: false,
// Superfluously present in some versions of V8.
// https://github.com/tc39/notes/blob/master/meetings/2021-10/oct-26.md#:~:text=However%2C%20Chrome%2093,and%20node%2016.11.
cause: false};
}
// The TypedArray Constructors
function TypedArray(prototype) {
return {
// Properties of the TypedArray Constructors
'[[Proto]]': '%TypedArray%',
BYTES_PER_ELEMENT: 'number',
prototype};
}
function TypedArrayPrototype(constructor) {
return {
// Properties of the TypedArray Prototype Objects
'[[Proto]]': '%TypedArrayPrototype%',
BYTES_PER_ELEMENT: 'number',
constructor};
}
// Without Math.random
const CommonMath= {
E: 'number',
LN10: 'number',
LN2: 'number',
LOG10E: 'number',
LOG2E: 'number',
PI: 'number',
SQRT1_2: 'number',
SQRT2: 'number',
'@@toStringTag': 'string',
abs: fn,
acos: fn,
acosh: fn,
asin: fn,
asinh: fn,
atan: fn,
atanh: fn,
atan2: fn,
cbrt: fn,
ceil: fn,
clz32: fn,
cos: fn,
cosh: fn,
exp: fn,
expm1: fn,
floor: fn,
fround: fn,
hypot: fn,
imul: fn,
log: fn,
log1p: fn,
log10: fn,
log2: fn,
max: fn,
min: fn,
pow: fn,
round: fn,
sign: fn,
sin: fn,
sinh: fn,
sqrt: fn,
tan: fn,
tanh: fn,
trunc: fn,
// See https://github.com/Moddable-OpenSource/moddable/issues/523
idiv: false,
// See https://github.com/Moddable-OpenSource/moddable/issues/523
idivmod: false,
// See https://github.com/Moddable-OpenSource/moddable/issues/523
imod: false,
// See https://github.com/Moddable-OpenSource/moddable/issues/523
imuldiv: false,
// See https://github.com/Moddable-OpenSource/moddable/issues/523
irem: false,
// See https://github.com/Moddable-OpenSource/moddable/issues/523
mod: false,
// See https://github.com/Moddable-OpenSource/moddable/issues/523#issuecomment-1942904505
irandom: false};
const permitted= {
// ECMA https://tc39.es/ecma262
// The intrinsics object has no prototype to avoid conflicts.
'[[Proto]]': null,
// %ThrowTypeError%
'%ThrowTypeError%': fn,
// *** The Global Object
// *** Value Properties of the Global Object
Infinity: 'number',
NaN: 'number',
undefined: 'undefined',
// *** Function Properties of the Global Object
// eval
'%UniqueEval%': fn,
isFinite: fn,
isNaN: fn,
parseFloat: fn,
parseInt: fn,
decodeURI: fn,
decodeURIComponent: fn,
encodeURI: fn,
encodeURIComponent: fn,
// *** Fundamental Objects
Object: {
// Properties of the Object Constructor
'[[Proto]]': '%FunctionPrototype%',
assign: fn,
create: fn,
defineProperties: fn,
defineProperty: fn,
entries: fn,
freeze: fn,
fromEntries: fn,
getOwnPropertyDescriptor: fn,
getOwnPropertyDescriptors: fn,
getOwnPropertyNames: fn,
getOwnPropertySymbols: fn,
getPrototypeOf: fn,
hasOwn: fn,
is: fn,
isExtensible: fn,
isFrozen: fn,
isSealed: fn,
keys: fn,
preventExtensions: fn,
prototype: '%ObjectPrototype%',
seal: fn,
setPrototypeOf: fn,
values: fn,
// https://github.com/tc39/proposal-array-grouping
groupBy: fn,
// Seen on QuickJS
__getClass: false},
'%ObjectPrototype%': {
// Properties of the Object Prototype Object
'[[Proto]]': null,
constructor: 'Object',
hasOwnProperty: fn,
isPrototypeOf: fn,
propertyIsEnumerable: fn,
toLocaleString: fn,
toString: fn,
valueOf: fn,
// Annex B: Additional Properties of the Object.prototype Object
// See note in header about the difference between [[Proto]] and --proto--
// special notations.
'--proto--': accessor,
__defineGetter__: fn,
__defineSetter__: fn,
__lookupGetter__: fn,
__lookupSetter__: fn},
'%UniqueFunction%': {
// Properties of the Function Constructor
'[[Proto]]': '%FunctionPrototype%',
prototype: '%FunctionPrototype%'},
'%InertFunction%': {
'[[Proto]]': '%FunctionPrototype%',
prototype: '%FunctionPrototype%'},
'%FunctionPrototype%': {
apply: fn,
bind: fn,
call: fn,
constructor: '%InertFunction%',
toString: fn,
'@@hasInstance': fn,
// proposed but not yet std. To be removed if there
caller: false,
// proposed but not yet std. To be removed if there
arguments: false,
// Seen on QuickJS. TODO grab getter for use by console
fileName: false,
// Seen on QuickJS. TODO grab getter for use by console
lineNumber: false},
Boolean: {
// Properties of the Boolean Constructor
'[[Proto]]': '%FunctionPrototype%',
prototype: '%BooleanPrototype%'},
'%BooleanPrototype%': {
constructor: 'Boolean',
toString: fn,
valueOf: fn},
'%SharedSymbol%': {
// Properties of the Symbol Constructor
'[[Proto]]': '%FunctionPrototype%',
asyncDispose: 'symbol',
asyncIterator: 'symbol',
dispose: 'symbol',
for: fn,
hasInstance: 'symbol',
isConcatSpreadable: 'symbol',
iterator: 'symbol',
keyFor: fn,
match: 'symbol',
matchAll: 'symbol',
prototype: '%SymbolPrototype%',
replace: 'symbol',
search: 'symbol',
species: 'symbol',
split: 'symbol',
toPrimitive: 'symbol',
toStringTag: 'symbol',
unscopables: 'symbol',
// Seen at core-js https://github.com/zloirock/core-js#ecmascript-symbol
useSimple: false,
// Seen at core-js https://github.com/zloirock/core-js#ecmascript-symbol
useSetter: false,
// Seen on QuickJS
operatorSet: false},
'%SymbolPrototype%': {
// Properties of the Symbol Prototype Object
constructor: '%SharedSymbol%',
description: getter,
toString: fn,
valueOf: fn,
'@@toPrimitive': fn,
'@@toStringTag': 'string'},
'%InitialError%': {
// Properties of the Error Constructor
'[[Proto]]': '%FunctionPrototype%',
prototype: '%ErrorPrototype%',
// Non standard, v8 only, used by tap
captureStackTrace: fn,
// Non standard, v8 only, used by tap, tamed to accessor
stackTraceLimit: accessor,
// Non standard, v8 only, used by several, tamed to accessor
prepareStackTrace: accessor},
'%SharedError%': {
// Properties of the Error Constructor
'[[Proto]]': '%FunctionPrototype%',
prototype: '%ErrorPrototype%',
// Non standard, v8 only, used by tap
captureStackTrace: fn,
// Non standard, v8 only, used by tap, tamed to accessor
stackTraceLimit: accessor,
// Non standard, v8 only, used by several, tamed to accessor
prepareStackTrace: accessor},
'%ErrorPrototype%': {
constructor: '%SharedError%',
message: 'string',
name: 'string',
toString: fn,
// proposed de-facto, assumed TODO
// Seen on FF Nightly 88.0a1
at: false,
// Seen on FF and XS
stack: accessor,
// Superfluously present in some versions of V8.
// https://github.com/tc39/notes/blob/master/meetings/2021-10/oct-26.md#:~:text=However%2C%20Chrome%2093,and%20node%2016.11.
cause: false},
// NativeError
EvalError: NativeError('%EvalErrorPrototype%'),
RangeError: NativeError('%RangeErrorPrototype%'),
ReferenceError: NativeError('%ReferenceErrorPrototype%'),
SyntaxError: NativeError('%SyntaxErrorPrototype%'),
TypeError: NativeError('%TypeErrorPrototype%'),
URIError: NativeError('%URIErrorPrototype%'),
// https://github.com/endojs/endo/issues/550
AggregateError: NativeError('%AggregateErrorPrototype%'),
'%EvalErrorPrototype%': NativeErrorPrototype('EvalError'),
'%RangeErrorPrototype%': NativeErrorPrototype('RangeError'),
'%ReferenceErrorPrototype%': NativeErrorPrototype('ReferenceError'),
'%SyntaxErrorPrototype%': NativeErrorPrototype('SyntaxError'),
'%TypeErrorPrototype%': NativeErrorPrototype('TypeError'),
'%URIErrorPrototype%': NativeErrorPrototype('URIError'),
// https://github.com/endojs/endo/issues/550
'%AggregateErrorPrototype%': NativeErrorPrototype('AggregateError'),
// *** Numbers and Dates
Number: {
// Properties of the Number Constructor
'[[Proto]]': '%FunctionPrototype%',
EPSILON: 'number',
isFinite: fn,
isInteger: fn,
isNaN: fn,
isSafeInteger: fn,
MAX_SAFE_INTEGER: 'number',
MAX_VALUE: 'number',
MIN_SAFE_INTEGER: 'number',
MIN_VALUE: 'number',
NaN: 'number',
NEGATIVE_INFINITY: 'number',
parseFloat: fn,
parseInt: fn,
POSITIVE_INFINITY: 'number',
prototype: '%NumberPrototype%'},
'%NumberPrototype%': {
// Properties of the Number Prototype Object
constructor: 'Number',
toExponential: fn,
toFixed: fn,
toLocaleString: fn,
toPrecision: fn,
toString: fn,
valueOf: fn},
BigInt: {
// Properties of the BigInt Constructor
'[[Proto]]': '%FunctionPrototype%',
asIntN: fn,
asUintN: fn,
prototype: '%BigIntPrototype%',
// See https://github.com/Moddable-OpenSource/moddable/issues/523
bitLength: false,
// See https://github.com/Moddable-OpenSource/moddable/issues/523
fromArrayBuffer: false,
// Seen on QuickJS
tdiv: false,
// Seen on QuickJS
fdiv: false,
// Seen on QuickJS
cdiv: false,
// Seen on QuickJS
ediv: false,
// Seen on QuickJS
tdivrem: false,
// Seen on QuickJS
fdivrem: false,
// Seen on QuickJS
cdivrem: false,
// Seen on QuickJS
edivrem: false,
// Seen on QuickJS
sqrt: false,
// Seen on QuickJS
sqrtrem: false,
// Seen on QuickJS
floorLog2: false,
// Seen on QuickJS
ctz: false},
'%BigIntPrototype%': {
constructor: 'BigInt',
toLocaleString: fn,
toString: fn,
valueOf: fn,
'@@toStringTag': 'string'},
'%InitialMath%': {
...CommonMath,
// `%InitialMath%.random()` has the standard unsafe behavior
random: fn},
'%SharedMath%': {
...CommonMath,
// `%SharedMath%.random()` is tamed to always throw
random: fn},
'%InitialDate%': {
// Properties of the Date Constructor
'[[Proto]]': '%FunctionPrototype%',
now: fn,
parse: fn,
prototype: '%DatePrototype%',
UTC: fn},
'%SharedDate%': {
// Properties of the Date Constructor
'[[Proto]]': '%FunctionPrototype%',
// `%SharedDate%.now()` is tamed to always throw
now: fn,
parse: fn,
prototype: '%DatePrototype%',
UTC: fn},
'%DatePrototype%': {
constructor: '%SharedDate%',
getDate: fn,
getDay: fn,
getFullYear: fn,
getHours: fn,
getMilliseconds: fn,
getMinutes: fn,
getMonth: fn,
getSeconds: fn,
getTime: fn,
getTimezoneOffset: fn,
getUTCDate: fn,
getUTCDay: fn,
getUTCFullYear: fn,
getUTCHours: fn,
getUTCMilliseconds: fn,
getUTCMinutes: fn,
getUTCMonth: fn,
getUTCSeconds: fn,
setDate: fn,
setFullYear: fn,
setHours: fn,
setMilliseconds: fn,
setMinutes: fn,
setMonth: fn,
setSeconds: fn,
setTime: fn,
setUTCDate: fn,
setUTCFullYear: fn,
setUTCHours: fn,
setUTCMilliseconds: fn,
setUTCMinutes: fn,
setUTCMonth: fn,
setUTCSeconds: fn,
toDateString: fn,
toISOString: fn,
toJSON: fn,
toLocaleDateString: fn,
toLocaleString: fn,
toLocaleTimeString: fn,
toString: fn,
toTimeString: fn,
toUTCString: fn,
valueOf: fn,
'@@toPrimitive': fn,
// Annex B: Additional Properties of the Date.prototype Object
getYear: fn,
setYear: fn,
toGMTString: fn},
// Text Processing
String: {
// Properties of the String Constructor
'[[Proto]]': '%FunctionPrototype%',
fromCharCode: fn,
fromCodePoint: fn,
prototype: '%StringPrototype%',
raw: fn,
// See https://github.com/Moddable-OpenSource/moddable/issues/523
fromArrayBuffer: false},
'%StringPrototype%': {
// Properties of the String Prototype Object
length: 'number',
at: fn,
charAt: fn,
charCodeAt: fn,
codePointAt: fn,
concat: fn,
constructor: 'String',
endsWith: fn,
includes: fn,
indexOf: fn,
lastIndexOf: fn,
localeCompare: fn,
match: fn,
matchAll: fn,
normalize: fn,
padEnd: fn,
padStart: fn,
repeat: fn,
replace: fn,
replaceAll: fn, // ES2021
search: fn,
slice: fn,
split: fn,
startsWith: fn,
substring: fn,
toLocaleLowerCase: fn,
toLocaleUpperCase: fn,
toLowerCase: fn,
toString: fn,
toUpperCase: fn,
trim: fn,
trimEnd: fn,
trimStart: fn,
valueOf: fn,
'@@iterator': fn,
// Annex B: Additional Properties of the String.prototype Object
substr: fn,
anchor: fn,
big: fn,
blink: fn,
bold: fn,
fixed: fn,
fontcolor: fn,
fontsize: fn,
italics: fn,
link: fn,
small: fn,
strike: fn,
sub: fn,
sup: fn,
trimLeft: fn,
trimRight: fn,
// See https://github.com/Moddable-OpenSource/moddable/issues/523
compare: false,
// https://github.com/tc39/proposal-is-usv-string
isWellFormed: fn,
toWellFormed: fn,
unicodeSets: fn,
// Seen on QuickJS
__quote: false},
'%StringIteratorPrototype%': {
'[[Proto]]': '%IteratorPrototype%',
next: fn,
'@@toStringTag': 'string'},
'%InitialRegExp%': {
// Properties of the RegExp Constructor
'[[Proto]]': '%FunctionPrototype%',
prototype: '%RegExpPrototype%',
'@@species': getter,
// The https://github.com/tc39/proposal-regexp-legacy-features
// are all optional, unsafe, and omitted
input: false,
$_: false,
lastMatch: false,
'$&': false,
lastParen: false,
'$+': false,
leftContext: false,
'$`': false,
rightContext: false,
"$'": false,
$1: false,
$2: false,
$3: false,
$4: false,
$5: false,
$6: false,
$7: false,
$8: false,
$9: false},
'%SharedRegExp%': {
// Properties of the RegExp Constructor
'[[Proto]]': '%FunctionPrototype%',
prototype: '%RegExpPrototype%',
'@@species': getter},
'%RegExpPrototype%': {
// Properties of the RegExp Prototype Object
constructor: '%SharedRegExp%',
exec: fn,
dotAll: getter,
flags: getter,
global: getter,
hasIndices: getter,
ignoreCase: getter,
'@@match': fn,
'@@matchAll': fn,
multiline: getter,
'@@replace': fn,
'@@search': fn,
source: getter,
'@@split': fn,
sticky: getter,
test: fn,
toString: fn,
unicode: getter,
unicodeSets: getter,
// Annex B: Additional Properties of the RegExp.prototype Object
compile: false // UNSAFE and suppressed.
},
'%RegExpStringIteratorPrototype%': {
// The %RegExpStringIteratorPrototype% Object
'[[Proto]]': '%IteratorPrototype%',
next: fn,
'@@toStringTag': 'string'},
// Indexed Collections
Array: {
// Properties of the Array Constructor
'[[Proto]]': '%FunctionPrototype%',
from: fn,
isArray: fn,
of: fn,
prototype: '%ArrayPrototype%',
'@@species': getter,
// Stage 3:
// https://tc39.es/proposal-relative-indexing-method/
at: fn,
// https://tc39.es/proposal-array-from-async/
fromAsync: fn},
'%ArrayPrototype%': {
// Properties of the Array Prototype Object
at: fn,
length: 'number',
concat: fn,
constructor: 'Array',
copyWithin: fn,
entries: fn,
every: fn,
fill: fn,
filter: fn,
find: fn,
findIndex: fn,
flat: fn,
flatMap: fn,
forEach: fn,
includes: fn,
indexOf: fn,
join: fn,
keys: fn,
lastIndexOf: fn,
map: fn,
pop: fn,
push: fn,
reduce: fn,
reduceRight: fn,
reverse: fn,
shift: fn,
slice: fn,
some: fn,
sort: fn,
splice: fn,
toLocaleString: fn,
toString: fn,
unshift: fn,
values: fn,
'@@iterator': fn,
'@@unscopables': {
'[[Proto]]': null,
copyWithin: 'boolean',
entries: 'boolean',
fill: 'boolean',
find: 'boolean',
findIndex: 'boolean',
flat: 'boolean',
flatMap: 'boolean',
includes: 'boolean',
keys: 'boolean',
values: 'boolean',
// Failed tc39 proposal
// Seen on FF Nightly 88.0a1
at: 'boolean',
// See https://github.com/tc39/proposal-array-find-from-last
findLast: 'boolean',
findLastIndex: 'boolean',
// https://github.com/tc39/proposal-change-array-by-copy
toReversed: 'boolean',
toSorted: 'boolean',
toSpliced: 'boolean',
with: 'boolean',
// https://github.com/tc39/proposal-array-grouping
group: 'boolean',
groupToMap: 'boolean',
groupBy: 'boolean'},
// See https://github.com/tc39/proposal-array-find-from-last
findLast: fn,
findLastIndex: fn,
// https://github.com/tc39/proposal-change-array-by-copy
toReversed: fn,
toSorted: fn,
toSpliced: fn,
with: fn,
// https://github.com/tc39/proposal-array-grouping
group: fn, // Not in proposal? Where?
groupToMap: fn, // Not in proposal? Where?
groupBy: fn},
'%ArrayIteratorPrototype%': {
// The %ArrayIteratorPrototype% Object
'[[Proto]]': '%IteratorPrototype%',
next: fn,
'@@toStringTag': 'string'},
// *** TypedArray Objects
'%TypedArray%': {
// Properties of the %TypedArray% Intrinsic Object
'[[Proto]]': '%FunctionPrototype%',
from: fn,
of: fn,
prototype: '%TypedArrayPrototype%',
'@@species': getter},
'%TypedArrayPrototype%': {
at: fn,
buffer: getter,
byteLength: getter,
byteOffset: getter,
constructor: '%TypedArray%',
copyWithin: fn,
entries: fn,
every: fn,
fill: fn,
filter: fn,
find: fn,
findIndex: fn,
forEach: fn,
includes: fn,
indexOf: fn,
join: fn,
keys: fn,
lastIndexOf: fn,
length: getter,
map: fn,
reduce: fn,
reduceRight: fn,
reverse: fn,
set: fn,
slice: fn,
some: fn,
sort: fn,
subarray: fn,
toLocaleString: fn,
toString: fn,
values: fn,
'@@iterator': fn,
'@@toStringTag': getter,
// See https://github.com/tc39/proposal-array-find-from-last
findLast: fn,
findLastIndex: fn,
// https://github.com/tc39/proposal-change-array-by-copy
toReversed: fn,
toSorted: fn,
with: fn},
// The TypedArray Constructors
BigInt64Array: TypedArray('%BigInt64ArrayPrototype%'),
BigUint64Array: TypedArray('%BigUint64ArrayPrototype%'),
// https://github.com/tc39/proposal-float16array
Float16Array: TypedArray('%Float16ArrayPrototype%'),
Float32Array: TypedArray('%Float32ArrayPrototype%'),
Float64Array: TypedArray('%Float64ArrayPrototype%'),
Int16Array: TypedArray('%Int16ArrayPrototype%'),
Int32Array: TypedArray('%Int32ArrayPrototype%'),
Int8Array: TypedArray('%Int8ArrayPrototype%'),
Uint16Array: TypedArray('%Uint16ArrayPrototype%'),
Uint32Array: TypedArray('%Uint32ArrayPrototype%'),
Uint8ClampedArray: TypedArray('%Uint8ClampedArrayPrototype%'),
Uint8Array: {
...TypedArray('%Uint8ArrayPrototype%'),
// https://github.com/tc39/proposal-arraybuffer-base64
fromBase64: fn,
// https://github.com/tc39/proposal-arraybuffer-base64
fromHex: fn},
'%BigInt64ArrayPrototype%': TypedArrayPrototype('BigInt64Array'),
'%BigUint64ArrayPrototype%': TypedArrayPrototype('BigUint64Array'),
// https://github.com/tc39/proposal-float16array
'%Float16ArrayPrototype%': TypedArrayPrototype('Float16Array'),
'%Float32ArrayPrototype%': TypedArrayPrototype('Float32Array'),
'%Float64ArrayPrototype%': TypedArrayPrototype('Float64Array'),
'%Int16ArrayPrototype%': TypedArrayPrototype('Int16Array'),
'%Int32ArrayPrototype%': TypedArrayPrototype('Int32Array'),
'%Int8ArrayPrototype%': TypedArrayPrototype('Int8Array'),
'%Uint16ArrayPrototype%': TypedArrayPrototype('Uint16Array'),
'%Uint32ArrayPrototype%': TypedArrayPrototype('Uint32Array'),
'%Uint8ClampedArrayPrototype%': TypedArrayPrototype('Uint8ClampedArray'),
'%Uint8ArrayPrototype%': {
...TypedArrayPrototype('Uint8Array'),
// https://github.com/tc39/proposal-arraybuffer-base64
setFromBase64: fn,
// https://github.com/tc39/proposal-arraybuffer-base64
setFromHex: fn,
// https://github.com/tc39/proposal-arraybuffer-base64
toBase64: fn,
// https://github.com/tc39/proposal-arraybuffer-base64
toHex: fn},
// *** Keyed Collections
Map: {
// Properties of the Map Constructor
'[[Proto]]': '%FunctionPrototype%',
'@@species': getter,
prototype: '%MapPrototype%',
// https://github.com/tc39/proposal-array-grouping
groupBy: fn},
'%MapPrototype%': {
clear: fn,
constructor: 'Map',
delete: fn,
entries: fn,
forEach: fn,
get: fn,
has: fn,
keys: fn,
set: fn,
size: getter,
values: fn,
'@@iterator': fn,
'@@toStringTag': 'string'},
'%MapIteratorPrototype%': {
// The %MapIteratorPrototype% Object
'[[Proto]]': '%IteratorPrototype%',
next: fn,
'@@toStringTag': 'string'},
Set: {
// Properties of the Set Constructor
'[[Proto]]': '%FunctionPrototype%',
prototype: '%SetPrototype%',
'@@species': getter,
// Seen on QuickJS
groupBy: false},
'%SetPrototype%': {
add: fn,
clear: fn,
constructor: 'Set',
delete: fn,
entries: fn,
forEach: fn,
has: fn,
keys: fn,
size: getter,
values: fn,
'@@iterator': fn,
'@@toStringTag': 'string',
// See https://github.com/tc39/proposal-set-methods
intersection: fn,
// See https://github.com/tc39/proposal-set-methods
union: fn,
// See https://github.com/tc39/proposal-set-methods
difference: fn,
// See https://github.com/tc39/proposal-set-methods
symmetricDifference: fn,
// See https://github.com/tc39/proposal-set-methods
isSubsetOf: fn,
// See https://github.com/tc39/proposal-set-methods
isSupersetOf: fn,
// See https://github.com/tc39/proposal-set-methods
isDisjointFrom: fn},
'%SetIteratorPrototype%': {
// The %SetIteratorPrototype% Object
'[[Proto]]': '%IteratorPrototype%',
next: fn,
'@@toStringTag': 'string'},
WeakMap: {
// Properties of the WeakMap Constructor
'[[Proto]]': '%FunctionPrototype%',
prototype: '%WeakMapPrototype%'},
'%WeakMapPrototype%': {
constructor: 'WeakMap',
delete: fn,
get: fn,
has: fn,
set: fn,
'@@toStringTag': 'string'},
WeakSet: {
// Properties of the WeakSet Constructor
'[[Proto]]': '%FunctionPrototype%',
prototype: '%WeakSetPrototype%'},
'%WeakSetPrototype%': {
add: fn,
constructor: 'WeakSet',
delete: fn,
has: fn,
'@@toStringTag': 'string'},
// *** Structured Data
ArrayBuffer: {
// Properties of the ArrayBuffer Constructor
'[[Proto]]': '%FunctionPrototype%',
isView: fn,
prototype: '%ArrayBufferPrototype%',
'@@species': getter,
// See https://github.com/Moddable-OpenSource/moddable/issues/523
fromString: false,
// See https://github.com/Moddable-OpenSource/moddable/issues/523
fromBigInt: false},
'%ArrayBufferPrototype%': {
byteLength: getter,
constructor: 'ArrayBuffer',
slice: fn,
'@@toStringTag': 'string',
// See https://github.com/Moddable-OpenSource/moddable/issues/523
concat: false,
// See https://github.com/tc39/proposal-resizablearraybuffer
transfer: fn,
resize: fn,
resizable: getter,
maxByteLength: getter,
// https://github.com/tc39/proposal-arraybuffer-transfer
transferToFixedLength: fn,
detached: getter},
// SharedArrayBuffer Objects
SharedArrayBuffer: false, // UNSAFE and purposely suppressed.
'%SharedArrayBufferPrototype%': false, // UNSAFE and purposely suppressed.
DataView: {
// Properties of the DataView Constructor
'[[Proto]]': '%FunctionPrototype%',
BYTES_PER_ELEMENT: 'number', // Non std but undeletable on Safari.
prototype: '%DataViewPrototype%'},
'%DataViewPrototype%': {
buffer: getter,
byteLength: getter,
byteOffset: getter,
constructor: 'DataView',
getBigInt64: fn,
getBigUint64: fn,
// https://github.com/tc39/proposal-float16array
getFloat16: fn,
getFloat32: fn,
getFloat64: fn,
getInt8: fn,
getInt16: fn,
getInt32: fn,
getUint8: fn,
getUint16: fn,
getUint32: fn,
setBigInt64: fn,
setBigUint64: fn,
// https://github.com/tc39/proposal-float16array
setFloat16: fn,
setFloat32: fn,
setFloat64: fn,
setInt8: fn,
setInt16: fn,
setInt32: fn,
setUint8: fn,
setUint16: fn,
setUint32: fn,
'@@toStringTag': 'string'},
// Atomics
Atomics: false, // UNSAFE and suppressed.
JSON: {
parse: fn,
stringify: fn,
'@@toStringTag': 'string',
// https://github.com/tc39/proposal-json-parse-with-source/
rawJSON: fn,
isRawJSON: fn},
// *** Control Abstraction Objects
// https://github.com/tc39/proposal-iterator-helpers
Iterator: {
// Properties of the Iterator Constructor
'[[Proto]]': '%FunctionPrototype%',
prototype: '%IteratorPrototype%',
from: fn},
'%IteratorPrototype%': {
// The %IteratorPrototype% Object
'@@iterator': fn,
// https://github.com/tc39/proposal-iterator-helpers
constructor: 'Iterator',
map: fn,
filter: fn,
take: fn,
drop: fn,
flatMap: fn,
reduce: fn,
toArray: fn,
forEach: fn,
some: fn,
every: fn,
find: fn,
'@@toStringTag': 'string',
// https://github.com/tc39/proposal-async-iterator-helpers
toAsync: fn,
// See https://github.com/Moddable-OpenSource/moddable/issues/523#issuecomment-1942904505
'@@dispose': false},
// https://github.com/tc39/proposal-iterator-helpers
'%WrapForValidIteratorPrototype%': {
'[[Proto]]': '%IteratorPrototype%',
next: fn,
return: fn},
// https://github.com/tc39/proposal-iterator-helpers
'%IteratorHelperPrototype%': {
'[[Proto]]': '%IteratorPrototype%',
next: fn,
return: fn,
'@@toStringTag': 'string'},
// https://github.com/tc39/proposal-async-iterator-helpers
AsyncIterator: {
// Properties of the Iterator Constructor
'[[Proto]]': '%FunctionPrototype%',
prototype: '%AsyncIteratorPrototype%',
from: fn},
'%AsyncIteratorPrototype%': {
// The %AsyncIteratorPrototype% Object
'@@asyncIterator': fn,
// https://github.com/tc39/proposal-async-iterator-helpers
constructor: 'AsyncIterator',
map: fn,
filter: fn,
take: fn,
drop: fn,
flatMap: fn,
reduce: fn,
toArray: fn,
forEach: fn,
some: fn,
every: fn,
find: fn,
'@@toStringTag': 'string',
// See https://github.com/Moddable-OpenSource/moddable/issues/523#issuecomment-1942904505
'@@asyncDispose': false},
// https://github.com/tc39/proposal-async-iterator-helpers
'%WrapForValidAsyncIteratorPrototype%': {
'[[Proto]]': '%AsyncIteratorPrototype%',
next: fn,
return: fn},
// https://github.com/tc39/proposal-async-iterator-helpers
'%AsyncIteratorHelperPrototype%': {
'[[Proto]]': '%AsyncIteratorPrototype%',
next: fn,
return: fn,
'@@toStringTag': 'string'},
'%InertGeneratorFunction%': {
// Properties of the GeneratorFunction Constructor
'[[Proto]]': '%InertFunction%',
prototype: '%Generator%'},
'%Generator%': {
// Properties of the GeneratorFunction Prototype Object
'[[Proto]]': '%FunctionPrototype%',
constructor: '%InertGeneratorFunction%',
prototype: '%GeneratorPrototype%',
'@@toStringTag': 'string'},
'%InertAsyncGeneratorFunction%': {
// Properties of the AsyncGeneratorFunction Constructor
'[[Proto]]': '%InertFunction%',
prototype: '%AsyncGenerator%'},
'%AsyncGenerator%': {
// Properties of the AsyncGeneratorFunction Prototype Object
'[[Proto]]': '%FunctionPrototype%',
constructor: '%InertAsyncGeneratorFunction%',
prototype: '%AsyncGeneratorPrototype%',
// length prop added here for React Native jsc-android
// https://github.com/endojs/endo/issues/660
// https://github.com/react-native-community/jsc-android-buildscripts/issues/181
length: 'number',
'@@toStringTag': 'string'},
'%GeneratorPrototype%': {
// Properties of the Generator Prototype Object
'[[Proto]]': '%IteratorPrototype%',
constructor: '%Generator%',
next: fn,
return: fn,
throw: fn,
'@@toStringTag': 'string'},
'%AsyncGeneratorPrototype%': {
// Properties of the AsyncGenerator Prototype Object
'[[Proto]]': '%AsyncIteratorPrototype%',
constructor: '%AsyncGenerator%',
next: fn,
return: fn,
throw: fn,
'@@toStringTag': 'string'},
// TODO: To be replaced with Promise.delegate
//
// The HandledPromise global variable shimmed by `@agoric/eventual-send/shim`
// implements an initial version of the eventual send specification at:
// https://github.com/tc39/proposal-eventual-send
//
// We will likely change this to add a property to Promise called
// Promise.delegate and put static methods on it, which will necessitate
// another whitelist change to update to the current proposed standard.
HandledPromise: {
'[[Proto]]': 'Promise',
applyFunction: fn,
applyFunctionSendOnly: fn,
applyMethod: fn,
applyMethodSendOnly: fn,
get: fn,
getSendOnly: fn,
prototype: '%PromisePrototype%',
resolve: fn},
Promise: {
// Properties of the Promise Constructor
'[[Proto]]': '%FunctionPrototype%',
all: fn,
allSettled: fn,
// https://github.com/Agoric/SES-shim/issues/550
any: fn,
prototype: '%PromisePrototype%',
race: fn,
reject: fn,
resolve: fn,
// https://github.com/tc39/proposal-promise-with-resolvers
withResolvers: fn,
'@@species': getter},
'%PromisePrototype%': {
// Properties of the Promise Prototype Object
catch: fn,
constructor: 'Promise',
finally: fn,
then: fn,
'@@toStringTag': 'string',
// Non-standard, used in node to prevent async_hooks from breaking
'UniqueSymbol(async_id_symbol)': accessor,
'UniqueSymbol(trigger_async_id_symbol)': accessor,
'UniqueSymbol(destroyed)': accessor},
'%InertAsyncFunction%': {
// Properties of the AsyncFunction Constructor
'[[Proto]]': '%InertFunction%',
prototype: '%AsyncFunctionPrototype%'},
'%AsyncFunctionPrototype%': {
// Properties of the AsyncFunction Prototype Object
'[[Proto]]': '%FunctionPrototype%',
constructor: '%InertAsyncFunction%',
// length prop added here for React Native jsc-android
// https://github.com/endojs/endo/issues/660
// https://github.com/react-native-community/jsc-android-buildscripts/issues/181
length: 'number',
'@@toStringTag': 'string'},
// Reflection
Reflect: {
// The Reflect Object
// Not a function object.
apply: fn,
construct: fn,
defineProperty: fn,
deleteProperty: fn,
get: fn,
getOwnPropertyDescriptor: fn,
getPrototypeOf: fn,
has: fn,
isExtensible: fn,
ownKeys: fn,
preventExtensions: fn,
set: fn,
setPrototypeOf: fn,
'@@toStringTag': 'string'},
Proxy: {
// Properties of the Proxy Constructor
'[[Proto]]': '%FunctionPrototype%',
revocable: fn},
// Appendix B
// Annex B: Additional Properties of the Global Object
escape: fn,
unescape: fn,
// Proposed
'%UniqueCompartment%': {
'[[Proto]]': '%FunctionPrototype%',
prototype: '%CompartmentPrototype%',
toString: fn},
'%InertCompartment%': {
'[[Proto]]': '%FunctionPrototype%',
prototype: '%CompartmentPrototype%',
toString: fn},
'%CompartmentPrototype%': {
constructor: '%InertCompartment%',
evaluate: fn,
globalThis: getter,
name: getter,
import: asyncFn,
load: asyncFn,
importNow: fn,
module: fn,
'@@toStringTag': 'string'},
lockdown: fn,
harden: { ...fn, isFake: 'boolean'},
'%InitialGetStackString%': fn};$h‍_once.permitted(permitted);
})()
,
// === functors[12] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let TypeError,WeakSet,arrayFilter,create,defineProperty,entries,freeze,getOwnPropertyDescriptor,getOwnPropertyDescriptors,globalThis,is,isObject,objectHasOwnProperty,values,weaksetHas,constantProperties,sharedGlobalPropertyNames,universalPropertyNames,permitted;$h‍_imports([["./commons.js", [["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["WeakSet", [$h‍_a => (WeakSet = $h‍_a)]],["arrayFilter", [$h‍_a => (arrayFilter = $h‍_a)]],["create", [$h‍_a => (create = $h‍_a)]],["defineProperty", [$h‍_a => (defineProperty = $h‍_a)]],["entries", [$h‍_a => (entries = $h‍_a)]],["freeze", [$h‍_a => (freeze = $h‍_a)]],["getOwnPropertyDescriptor", [$h‍_a => (getOwnPropertyDescriptor = $h‍_a)]],["getOwnPropertyDescriptors", [$h‍_a => (getOwnPropertyDescriptors = $h‍_a)]],["globalThis", [$h‍_a => (globalThis = $h‍_a)]],["is", [$h‍_a => (is = $h‍_a)]],["isObject", [$h‍_a => (isObject = $h‍_a)]],["objectHasOwnProperty", [$h‍_a => (objectHasOwnProperty = $h‍_a)]],["values", [$h‍_a => (values = $h‍_a)]],["weaksetHas", [$h‍_a => (weaksetHas = $h‍_a)]]]],["./permits.js", [["constantProperties", [$h‍_a => (constantProperties = $h‍_a)]],["sharedGlobalPropertyNames", [$h‍_a => (sharedGlobalPropertyNames = $h‍_a)]],["universalPropertyNames", [$h‍_a => (universalPropertyNames = $h‍_a)]],["permitted", [$h‍_a => (permitted = $h‍_a)]]]]]);
const isFunction= (obj)=>typeof obj=== 'function';
// Like defineProperty, but throws if it would modify an existing property.
// We use this to ensure that two conflicting attempts to define the same
// property throws, causing SES initialization to fail. Otherwise, a
// conflict between, for example, two of SES's internal whitelists might
// get masked as one overwrites the other. Accordingly, the thrown error
// complains of a "Conflicting definition".
function initProperty(obj, name, desc) {
if( objectHasOwnProperty(obj, name)) {
const preDesc= getOwnPropertyDescriptor(obj, name);
if(
!preDesc||
!is(preDesc.value, desc.value)||
preDesc.get!== desc.get||
preDesc.set!== desc.set||
preDesc.writable!== desc.writable||
preDesc.enumerable!== desc.enumerable||
preDesc.configurable!== desc.configurable)
{
throw TypeError( `Conflicting definitions of ${name}`);
}
}
defineProperty(obj, name, desc);
}
// Like defineProperties, but throws if it would modify an existing property.
// This ensures that the intrinsics added to the intrinsics collector object
// graph do not overlap.
function initProperties(obj, descs) {
for( const [name, desc]of entries(descs)) {
initProperty(obj, name, desc);
}
}
// sampleGlobals creates an intrinsics object, suitable for
// interinsicsCollector.addIntrinsics, from the named properties of a global
// object.
function sampleGlobals(globalObject, newPropertyNames) {
const newIntrinsics= { __proto__: null};
for( const [globalName, intrinsicName]of entries(newPropertyNames)) {
if( objectHasOwnProperty(globalObject, globalName)) {
newIntrinsics[intrinsicName]= globalObject[globalName];
}
}
return newIntrinsics;
}
const makeIntrinsicsCollector= ()=> {
/** @type {Record<any, any>} */
const intrinsics= create(null);
let pseudoNatives;
const addIntrinsics= (newIntrinsics)=>{
initProperties(intrinsics, getOwnPropertyDescriptors(newIntrinsics));
};
freeze(addIntrinsics);
// For each intrinsic, if it has a `.prototype` property, use the
// whitelist to find out the intrinsic name for that prototype and add it
// to the intrinsics.
const completePrototypes= ()=> {
for( const [name, intrinsic]of entries(intrinsics)) {
if( !isObject(intrinsic)) {
// eslint-disable-next-line no-continue
continue;
}
if( !objectHasOwnProperty(intrinsic, 'prototype')) {
// eslint-disable-next-line no-continue
continue;
}
const permit= permitted[name];
if( typeof permit!== 'object') {
throw TypeError( `Expected permit object at whitelist.${name}`);
}
const namePrototype= permit.prototype;
if( !namePrototype) {
throw TypeError( `${name}.prototype property not whitelisted`);
}
if(
typeof namePrototype!== 'string'||
!objectHasOwnProperty(permitted, namePrototype))
{
throw TypeError( `Unrecognized ${name}.prototype whitelist entry`);
}
const intrinsicPrototype= intrinsic.prototype;
if( objectHasOwnProperty(intrinsics, namePrototype)) {
if( intrinsics[namePrototype]!== intrinsicPrototype) {
throw TypeError( `Conflicting bindings of ${namePrototype}`);
}
// eslint-disable-next-line no-continue
continue;
}
intrinsics[namePrototype]= intrinsicPrototype;
}
};
freeze(completePrototypes);
const finalIntrinsics= ()=> {
freeze(intrinsics);
pseudoNatives= new WeakSet(arrayFilter(values(intrinsics), isFunction));
return intrinsics;
};
freeze(finalIntrinsics);
const isPseudoNative= (obj)=>{
if( !pseudoNatives) {
throw TypeError(
'isPseudoNative can only be called after finalIntrinsics');
}
return weaksetHas(pseudoNatives, obj);
};
freeze(isPseudoNative);
const intrinsicsCollector= {
addIntrinsics,
completePrototypes,
finalIntrinsics,
isPseudoNative};
freeze(intrinsicsCollector);
addIntrinsics(constantProperties);
addIntrinsics(sampleGlobals(globalThis, universalPropertyNames));
return intrinsicsCollector;
};
/**
* getGlobalIntrinsics()
* Doesn't tame, delete, or modify anything. Samples globalObject to create an
* intrinsics record containing only the whitelisted global variables, listed
* by the intrinsic names appropriate for new globals, i.e., the globals of
* newly constructed compartments.
*
* WARNING:
* If run before lockdown, the returned intrinsics record will carry the
* *original* unsafe (feral, untamed) bindings of these global variables.
*
* @param {object} globalObject
*/$h‍_once.makeIntrinsicsCollector(makeIntrinsicsCollector);
const getGlobalIntrinsics= (globalObject)=>{
const { addIntrinsics, finalIntrinsics}= makeIntrinsicsCollector();
addIntrinsics(sampleGlobals(globalObject, sharedGlobalPropertyNames));
return finalIntrinsics();
};$h‍_once.getGlobalIntrinsics(getGlobalIntrinsics);
})()
,
// === functors[13] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let permitted,FunctionInstance,isAccessorPermit,Map,String,Symbol,TypeError,arrayFilter,arrayIncludes,arrayMap,entries,getOwnPropertyDescriptor,getPrototypeOf,isObject,mapGet,objectHasOwnProperty,ownKeys,symbolKeyFor;$h‍_imports([["./permits.js", [["permitted", [$h‍_a => (permitted = $h‍_a)]],["FunctionInstance", [$h‍_a => (FunctionInstance = $h‍_a)]],["isAccessorPermit", [$h‍_a => (isAccessorPermit = $h‍_a)]]]],["./commons.js", [["Map", [$h‍_a => (Map = $h‍_a)]],["String", [$h‍_a => (String = $h‍_a)]],["Symbol", [$h‍_a => (Symbol = $h‍_a)]],["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["arrayFilter", [$h‍_a => (arrayFilter = $h‍_a)]],["arrayIncludes", [$h‍_a => (arrayIncludes = $h‍_a)]],["arrayMap", [$h‍_a => (arrayMap = $h‍_a)]],["entries", [$h‍_a => (entries = $h‍_a)]],["getOwnPropertyDescriptor", [$h‍_a => (getOwnPropertyDescriptor = $h‍_a)]],["getPrototypeOf", [$h‍_a => (getPrototypeOf = $h‍_a)]],["isObject", [$h‍_a => (isObject = $h‍_a)]],["mapGet", [$h‍_a => (mapGet = $h‍_a)]],["objectHasOwnProperty", [$h‍_a => (objectHasOwnProperty = $h‍_a)]],["ownKeys", [$h‍_a => (ownKeys = $h‍_a)]],["symbolKeyFor", [$h‍_a => (symbolKeyFor = $h‍_a)]]]]]);
/**
* whitelistIntrinsics()
* Removes all non-allowed properties found by recursively and
* reflectively walking own property chains.
*
* @param {object} intrinsics
* @param {(object) => void} markVirtualizedNativeFunction
*/
function whitelistIntrinsics(
intrinsics,
markVirtualizedNativeFunction)
{
let groupStarted= false;
const inConsoleGroup= (level, ...args)=> {
if( !groupStarted) {
// eslint-disable-next-line @endo/no-polymorphic-call
console.groupCollapsed('Removing unpermitted intrinsics');
groupStarted= true;
}
// eslint-disable-next-line @endo/no-polymorphic-call
return console[level](...args);
};
// These primitives are allowed for permits.
const primitives= ['undefined', 'boolean', 'number', 'string', 'symbol'];
// These symbols are allowed as well-known symbols
const wellKnownSymbolNames= new Map(
Symbol?
arrayMap(
arrayFilter(
entries(permitted['%SharedSymbol%']),
([name, permit])=>
permit=== 'symbol'&& typeof Symbol[name]=== 'symbol'),
([name])=> [Symbol[name], `@@${name}`]):
[]);
/**
* asStringPropertyName()
*
* @param {string} path
* @param {string | symbol} prop
*/
function asStringPropertyName(path, prop) {
if( typeof prop=== 'string') {
return prop;
}
const wellKnownSymbol= mapGet(wellKnownSymbolNames, prop);
if( typeof prop=== 'symbol') {
if( wellKnownSymbol) {
return wellKnownSymbol;
}else {
const registeredKey= symbolKeyFor(prop);
if( registeredKey!== undefined) {
return `RegisteredSymbol(${registeredKey})`;
}else {
return `Unique${String(prop)}`;
}
}
}
throw TypeError( `Unexpected property name type ${path} ${prop}`);
}
/*
* visitPrototype()
* Validate the object's [[prototype]] against a permit.
*/
function visitPrototype(path, obj, protoName) {
if( !isObject(obj)) {
throw TypeError( `Object expected: ${path}, ${obj}, ${protoName}`);
}
const proto= getPrototypeOf(obj);
// Null prototype.
if( proto=== null&& protoName=== null) {
return;
}
// Assert: protoName, if provided, is a string.
if( protoName!== undefined&& typeof protoName!== 'string') {
throw TypeError( `Malformed whitelist permit ${path}.__proto__`);
}
// If permit not specified, default to Object.prototype.
if( proto=== intrinsics[protoName|| '%ObjectPrototype%']) {
return;
}
// We can't clean [[prototype]], therefore abort.
throw TypeError( `Unexpected intrinsic ${path}.__proto__ at ${protoName}`);
}
/*
* isAllowedPropertyValue()
* Whitelist a single property value against a permit.
*/
function isAllowedPropertyValue(path, value, prop, permit) {
if( typeof permit=== 'object') {
// eslint-disable-next-line no-use-before-define
visitProperties(path, value, permit);
// The property is allowed.
return true;
}
if( permit=== false) {
// A boolan 'false' permit specifies the removal of a property.
// We require a more specific permit instead of allowing 'true'.
return false;
}
if( typeof permit=== 'string') {
// A string permit can have one of two meanings:
if( prop=== 'prototype'|| prop=== 'constructor') {
// For prototype and constructor value properties, the permit
// is the name of an intrinsic.
// Assumption: prototype and constructor cannot be primitives.
// Assert: the permit is the name of an intrinsic.
// Assert: the property value is equal to that intrinsic.
if( objectHasOwnProperty(intrinsics, permit)) {
if( value!== intrinsics[permit]) {
throw TypeError( `Does not match whitelist ${path}`);
}
return true;
}
}else {
// For all other properties, the permit is the name of a primitive.
// Assert: the permit is the name of a primitive.
// Assert: the property value type is equal to that primitive.
// eslint-disable-next-line no-lonely-if
if( arrayIncludes(primitives, permit)) {
// eslint-disable-next-line valid-typeof
if( typeof value!== permit) {
throw TypeError(
`At ${path} expected ${permit} not ${typeof value}`);
}
return true;
}
}
}
throw TypeError( `Unexpected whitelist permit ${permit} at ${path}`);
}
/*
* isAllowedProperty()
* Check whether a single property is allowed.
*/
function isAllowedProperty(path, obj, prop, permit) {
const desc= getOwnPropertyDescriptor(obj, prop);
if( !desc) {
throw TypeError( `Property ${prop} not found at ${path}`);
}
// Is this a value property?
if( objectHasOwnProperty(desc, 'value')) {
if( isAccessorPermit(permit)) {
throw TypeError( `Accessor expected at ${path}`);
}
return isAllowedPropertyValue(path, desc.value, prop, permit);
}
if( !isAccessorPermit(permit)) {
throw TypeError( `Accessor not expected at ${path}`);
}
return(
isAllowedPropertyValue( `${path}<get>`,desc.get, prop, permit.get)&&
isAllowedPropertyValue( `${path}<set>`,desc.set, prop, permit.set));
}
/*
* getSubPermit()
*/
function getSubPermit(obj, permit, prop) {
const permitProp= prop=== '__proto__'? '--proto--': prop;
if( objectHasOwnProperty(permit, permitProp)) {
return permit[permitProp];
}
if( typeof obj=== 'function') {
if( objectHasOwnProperty(FunctionInstance, permitProp)) {
return FunctionInstance[permitProp];
}
}
return undefined;
}
/*
* visitProperties()
* Visit all properties for a permit.
*/
function visitProperties(path, obj, permit) {
if( obj=== undefined|| obj=== null) {
return;
}
const protoName= permit['[[Proto]]'];
visitPrototype(path, obj, protoName);
if( typeof obj=== 'function') {
markVirtualizedNativeFunction(obj);
}
for( const prop of ownKeys(obj)) {
const propString= asStringPropertyName(path, prop);
const subPath= `${path}.${propString}`;
const subPermit= getSubPermit(obj, permit, propString);
if( !subPermit|| !isAllowedProperty(subPath, obj, prop, subPermit)) {
// Either the object lacks a permit or the object doesn't match the
// permit.
// If the permit is specifically false, not merely undefined,
// this is a property we expect to see because we know it exists in
// some environments and we have expressly decided to exclude it.
// Any other disallowed property is one we have not audited and we log
// that we are removing it so we know to look into it, as happens when
// the language evolves new features to existing intrinsics.
if( subPermit!== false) {
inConsoleGroup('warn', `Removing ${subPath}`);
}
try {
delete obj[prop];
}catch( err) {
if( prop in obj) {
if( typeof obj=== 'function'&& prop=== 'prototype') {
obj.prototype= undefined;
if( obj.prototype=== undefined) {
inConsoleGroup(
'warn',
`Tolerating undeletable ${subPath} === undefined`);
// eslint-disable-next-line no-continue
continue;
}
}
inConsoleGroup('error', `failed to delete ${subPath}`,err);
}else {
inConsoleGroup('error', `deleting ${subPath} threw`,err);
}
throw err;
}
}
}
}
try {
// Start path with 'intrinsics' to clarify that properties are not
// removed from the global object by the whitelisting operation.
visitProperties('intrinsics', intrinsics, permitted);
}finally {
if( groupStarted) {
// eslint-disable-next-line @endo/no-polymorphic-call
console.groupEnd();
}
}
}$h‍_once.default( whitelistIntrinsics);
})()
,
// === functors[14] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let FERAL_FUNCTION,SyntaxError,TypeError,defineProperties,getPrototypeOf,setPrototypeOf,freeze;$h‍_imports([["./commons.js", [["FERAL_FUNCTION", [$h‍_a => (FERAL_FUNCTION = $h‍_a)]],["SyntaxError", [$h‍_a => (SyntaxError = $h‍_a)]],["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["defineProperties", [$h‍_a => (defineProperties = $h‍_a)]],["getPrototypeOf", [$h‍_a => (getPrototypeOf = $h‍_a)]],["setPrototypeOf", [$h‍_a => (setPrototypeOf = $h‍_a)]],["freeze", [$h‍_a => (freeze = $h‍_a)]]]]]);
// This module replaces the original `Function` constructor, and the original
// `%GeneratorFunction%`, `%AsyncFunction%` and `%AsyncGeneratorFunction%`,
// with safe replacements that throw if invoked.
//
// These are all reachable via syntax, so it isn't sufficient to just
// replace global properties with safe versions. Our main goal is to prevent
// access to the `Function` constructor through these starting points.
//
// After modules block is done, the originals must no longer be reachable,
// unless a copy has been made, and functions can only be created by syntax
// (using eval) or by invoking a previously saved reference to the originals.
//
// Typically, this module will not be used directly, but via the
// [lockdown - shim] which handles all necessary repairs and taming in SES.
//
// Relation to ECMA specifications
//
// The taming of constructors really wants to be part of the standard, because
// new constructors may be added in the future, reachable from syntax, and this
// list must be updated to match.
//
// In addition, the standard needs to define four new intrinsics for the safe
// replacement functions. See [./permits-intrinsics.js].
//
// Adapted from SES/Caja
// Copyright (C) 2011 Google Inc.
// https://github.com/google/caja/blob/master/src/com/google/caja/ses/startSES.js
// https://github.com/google/caja/blob/master/src/com/google/caja/ses/repairES5.js
/**
* tameFunctionConstructors()
* This block replaces the original Function constructor, and the original
* %GeneratorFunction% %AsyncFunction% and %AsyncGeneratorFunction%, with
* safe replacements that throw if invoked.
*/
function tameFunctionConstructors() {
try {
// Verify that the method is not callable.
// eslint-disable-next-line @endo/no-polymorphic-call
FERAL_FUNCTION.prototype.constructor('return 1');
}catch( ignore) {
// Throws, no need to patch.
return freeze({});
}
const newIntrinsics= {};
/*
* The process to repair constructors:
* 1. Create an instance of the function by evaluating syntax
* 2. Obtain the prototype from the instance
* 3. Create a substitute tamed constructor
* 4. Replace the original constructor with the tamed constructor
* 5. Replace tamed constructor prototype property with the original one
* 6. Replace its [[Prototype]] slot with the tamed constructor of Function
*/
function repairFunction(name, intrinsicName, declaration) {
let FunctionInstance;
try {
// eslint-disable-next-line no-eval, no-restricted-globals
FunctionInstance= (0, eval)(declaration);
}catch( e) {
if( e instanceof SyntaxError) {
// Prevent failure on platforms where async and/or generators
// are not supported.
return;
}
// Re-throw
throw e;
}
const FunctionPrototype= getPrototypeOf(FunctionInstance);
// Prevents the evaluation of source when calling constructor on the
// prototype of functions.
// eslint-disable-next-line func-names
const InertConstructor= function() {
throw TypeError(
'Function.prototype.constructor is not a valid constructor.');
};
defineProperties(InertConstructor, {
prototype: { value: FunctionPrototype},
name: {
value: name,
writable: false,
enumerable: false,
configurable: true}});
defineProperties(FunctionPrototype, {
constructor: { value: InertConstructor}});
// Reconstructs the inheritance among the new tamed constructors
// to mirror the original specified in normal JS.
if( InertConstructor!== FERAL_FUNCTION.prototype.constructor) {
setPrototypeOf(InertConstructor, FERAL_FUNCTION.prototype.constructor);
}
newIntrinsics[intrinsicName]= InertConstructor;
}
// Here, the order of operation is important: Function needs to be repaired
// first since the other repaired constructors need to inherit from the
// tamed Function function constructor.
repairFunction('Function', '%InertFunction%', '(function(){})');
repairFunction(
'GeneratorFunction',
'%InertGeneratorFunction%',
'(function*(){})');
repairFunction(
'AsyncFunction',
'%InertAsyncFunction%',
'(async function(){})');
repairFunction(
'AsyncGeneratorFunction',
'%InertAsyncGeneratorFunction%',
'(async function*(){})');
return newIntrinsics;
}$h‍_once.default( tameFunctionConstructors);
})()
,
// === functors[15] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let Date,TypeError,apply,construct,defineProperties;$h‍_imports([["./commons.js", [["Date", [$h‍_a => (Date = $h‍_a)]],["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["apply", [$h‍_a => (apply = $h‍_a)]],["construct", [$h‍_a => (construct = $h‍_a)]],["defineProperties", [$h‍_a => (defineProperties = $h‍_a)]]]]]);
function tameDateConstructor(dateTaming= 'safe') {
if( dateTaming!== 'safe'&& dateTaming!== 'unsafe') {
throw TypeError( `unrecognized dateTaming ${dateTaming}`);
}
const OriginalDate= Date;
const DatePrototype= OriginalDate.prototype;
// Use concise methods to obtain named functions without constructors.
const tamedMethods= {
/**
* `%SharedDate%.now()` throw a `TypeError` starting with "secure mode".
* See https://github.com/endojs/endo/issues/910#issuecomment-1581855420
*/
now() {
throw TypeError('secure mode Calling %SharedDate%.now() throws');
}};
/**
* Tame the Date constructor.
* See https://github.com/endojs/endo/issues/910#issuecomment-1581855420
*
* Common behavior
* * `new Date(x)` coerces x into a number and then returns a Date
* for that number of millis since the epoch
* * `new Date(NaN)` returns a Date object which stringifies to
* 'Invalid Date'
* * `new Date(undefined)` returns a Date object which stringifies to
* 'Invalid Date'
*
* OriginalDate (normal standard) behavior preserved by
* `%InitialDate%`.
* * `Date(anything)` gives a string with the current time
* * `new Date()` returns the current time, as a Date object
*
* `%SharedDate%` behavior
* * `Date(anything)` throws a TypeError starting with "secure mode"
* * `new Date()` throws a TypeError starting with "secure mode"
*
* @param {{powers?: string}} [opts]
*/
const makeDateConstructor= ({ powers= 'none'}= {})=> {
let ResultDate;
if( powers=== 'original') {
// eslint-disable-next-line no-shadow
ResultDate= function Date(...rest) {
if( new.target=== undefined) {
return apply(OriginalDate, undefined, rest);
}
return construct(OriginalDate, rest, new.target);
};
}else {
// eslint-disable-next-line no-shadow
ResultDate= function Date(...rest) {
if( new.target=== undefined) {
throw TypeError(
'secure mode Calling %SharedDate% constructor as a function throws');
}
if( rest.length=== 0) {
throw TypeError(
'secure mode Calling new %SharedDate%() with no arguments throws');
}
return construct(OriginalDate, rest, new.target);
};
}
defineProperties(ResultDate, {
length: { value: 7},
prototype: {
value: DatePrototype,
writable: false,
enumerable: false,
configurable: false},
parse: {
value: OriginalDate.parse,
writable: true,
enumerable: false,
configurable: true},
UTC: {
value: OriginalDate.UTC,
writable: true,
enumerable: false,
configurable: true}});
return ResultDate;
};
const InitialDate= makeDateConstructor({ powers: 'original'});
const SharedDate= makeDateConstructor({ powers: 'none'});
defineProperties(InitialDate, {
now: {
value: OriginalDate.now,
writable: true,
enumerable: false,
configurable: true}});
defineProperties(SharedDate, {
now: {
value: tamedMethods.now,
writable: true,
enumerable: false,
configurable: true}});
defineProperties(DatePrototype, {
constructor: { value: SharedDate}});
return {
'%InitialDate%': InitialDate,
'%SharedDate%': SharedDate};
}$h‍_once.default( tameDateConstructor);
})()
,
// === functors[16] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let Math,TypeError,create,getOwnPropertyDescriptors,objectPrototype;$h‍_imports([["./commons.js", [["Math", [$h‍_a => (Math = $h‍_a)]],["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["create", [$h‍_a => (create = $h‍_a)]],["getOwnPropertyDescriptors", [$h‍_a => (getOwnPropertyDescriptors = $h‍_a)]],["objectPrototype", [$h‍_a => (objectPrototype = $h‍_a)]]]]]);
function tameMathObject(mathTaming= 'safe') {
if( mathTaming!== 'safe'&& mathTaming!== 'unsafe') {
throw TypeError( `unrecognized mathTaming ${mathTaming}`);
}
const originalMath= Math;
const initialMath= originalMath; // to follow the naming pattern
const { random: _, ...otherDescriptors}=
getOwnPropertyDescriptors(originalMath);
// Use concise methods to obtain named functions without constructors.
const tamedMethods= {
/**
* `%SharedMath%.random()` throws a TypeError starting with "secure mode".
* See https://github.com/endojs/endo/issues/910#issuecomment-1581855420
*/
random() {
throw TypeError('secure mode %SharedMath%.random() throws');
}};
const sharedMath= create(objectPrototype, {
...otherDescriptors,
random: {
value: tamedMethods.random,
writable: true,
enumerable: false,
configurable: true}});
return {
'%InitialMath%': initialMath,
'%SharedMath%': sharedMath};
}$h‍_once.default( tameMathObject);
})()
,
// === functors[17] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let FERAL_REG_EXP,TypeError,construct,defineProperties,getOwnPropertyDescriptor,speciesSymbol;$h‍_imports([["./commons.js", [["FERAL_REG_EXP", [$h‍_a => (FERAL_REG_EXP = $h‍_a)]],["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["construct", [$h‍_a => (construct = $h‍_a)]],["defineProperties", [$h‍_a => (defineProperties = $h‍_a)]],["getOwnPropertyDescriptor", [$h‍_a => (getOwnPropertyDescriptor = $h‍_a)]],["speciesSymbol", [$h‍_a => (speciesSymbol = $h‍_a)]]]]]);
function tameRegExpConstructor(regExpTaming= 'safe') {
if( regExpTaming!== 'safe'&& regExpTaming!== 'unsafe') {
throw TypeError( `unrecognized regExpTaming ${regExpTaming}`);
}
const RegExpPrototype= FERAL_REG_EXP.prototype;
const makeRegExpConstructor= (_= {})=> {
// RegExp has non-writable static properties we need to omit.
/**
* @param {Parameters<typeof FERAL_REG_EXP>} rest
*/
const ResultRegExp= function RegExp(...rest) {
if( new.target=== undefined) {
return FERAL_REG_EXP(...rest);
}
return construct(FERAL_REG_EXP, rest, new.target);
};
defineProperties(ResultRegExp, {
length: { value: 2},
prototype: {
value: RegExpPrototype,
writable: false,
enumerable: false,
configurable: false}});
// Hermes does not have `Symbol.species`. We should support such platforms.
if( speciesSymbol) {
const speciesDesc= getOwnPropertyDescriptor(
FERAL_REG_EXP,
speciesSymbol);
if( !speciesDesc) {
throw TypeError('no RegExp[Symbol.species] descriptor');
}
defineProperties(ResultRegExp, {
[speciesSymbol]: speciesDesc});
}
return ResultRegExp;
};
const InitialRegExp= makeRegExpConstructor();
const SharedRegExp= makeRegExpConstructor();
if( regExpTaming!== 'unsafe') {
// @ts-expect-error Deleted properties must be optional
delete RegExpPrototype.compile;
}
defineProperties(RegExpPrototype, {
constructor: { value: SharedRegExp}});
return {
'%InitialRegExp%': InitialRegExp,
'%SharedRegExp%': SharedRegExp};
}$h‍_once.default( tameRegExpConstructor);
})()
,
// === functors[18] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let toStringTagSymbol,iteratorSymbol;$h‍_imports([["./commons.js", [["toStringTagSymbol", [$h‍_a => (toStringTagSymbol = $h‍_a)]],["iteratorSymbol", [$h‍_a => (iteratorSymbol = $h‍_a)]]]]]);
/**
* @file Exports {@code enablements}, a recursively defined
* JSON record defining the optimum set of intrinsics properties
* that need to be "repaired" before hardening is applied on
* enviromments subject to the override mistake.
*
* @author JF Paradis
* @author Mark S. Miller
*/
/**
* <p>Because "repairing" replaces data properties with accessors, every
* time a repaired property is accessed, the associated getter is invoked,
* which degrades the runtime performance of all code executing in the
* repaired enviromment, compared to the non-repaired case. In order
* to maintain performance, we only repair the properties of objects
* for which hardening causes a breakage of their normal intended usage.
*
* There are three unwanted cases:
* <ul>
* <li>Overriding properties on objects typically used as records,
* namely {@code "Object"} and {@code "Array"}. In the case of arrays,
* the situation is unintentional, a given program might not be aware
* that non-numerical properties are stored on the underlying object
* instance, not on the array. When an object is typically used as a
* map, we repair all of its prototype properties.
* <li>Overriding properties on objects that provide defaults on their
* prototype and that programs typically set using an assignment, such as
* {@code "Error.prototype.message"} and {@code "Function.prototype.name"}
* (both default to "").
* <li>Setting-up a prototype chain, where a constructor is set to extend
* another one. This is typically set by assignment, for example
* {@code "Child.prototype.constructor = Child"}, instead of invoking
* Object.defineProperty();
*
* <p>Each JSON record enumerates the disposition of the properties on
* some corresponding intrinsic object.
*
* <p>For each such record, the values associated with its property
* names can be:
* <ul>
* <li>true, in which case this property is simply repaired. The
* value associated with that property is not traversed. For
* example, {@code "Function.prototype.name"} leads to true,
* meaning that the {@code "name"} property of {@code
* "Function.prototype"} should be repaired (which is needed
* when inheriting from @code{Function} and setting the subclass's
* {@code "prototype.name"} property). If the property is
* already an accessor property, it is not repaired (because
* accessors are not subject to the override mistake).
* <li>"*", in which case this property is not repaired but the
* value associated with that property are traversed and repaired.
* <li>Another record, in which case this property is not repaired
* and that next record represents the disposition of the object
* which is its value. For example,{@code "FunctionPrototype"}
* leads to another record explaining which properties {@code
* Function.prototype} need to be repaired.
*/
/**
* Minimal enablements when all the code is modern and known not to
* step into the override mistake, except for the following pervasive
* cases.
*/
const minEnablements= {
'%ObjectPrototype%': {
toString: true},
'%FunctionPrototype%': {
toString: true // set by "rollup"
},
'%ErrorPrototype%': {
name: true // set by "precond", "ava", "node-fetch"
},
'%IteratorPrototype%': {
toString: true,
// https://github.com/tc39/proposal-iterator-helpers
constructor: true,
// https://github.com/tc39/proposal-iterator-helpers
[toStringTagSymbol]: true}};
/**
* Moderate enablements are usually good enough for legacy compat.
*/$h‍_once.minEnablements(minEnablements);
const moderateEnablements= {
'%ObjectPrototype%': {
toString: true,
valueOf: true},
'%ArrayPrototype%': {
toString: true,
push: true, // set by "Google Analytics"
concat: true, // set by mobx generated code (old TS compiler?)
[iteratorSymbol]: true // set by mobx generated code (old TS compiler?)
},
// Function.prototype has no 'prototype' property to enable.
// Function instances have their own 'name' and 'length' properties
// which are configurable and non-writable. Thus, they are already
// non-assignable anyway.
'%FunctionPrototype%': {
constructor: true, // set by "regenerator-runtime"
bind: true, // set by "underscore", "express"
toString: true // set by "rollup"
},
'%ErrorPrototype%': {
constructor: true, // set by "fast-json-patch", "node-fetch"
message: true,
name: true, // set by "precond", "ava", "node-fetch", "node 14"
toString: true // set by "bluebird"
},
'%TypeErrorPrototype%': {
constructor: true, // set by "readable-stream"
message: true, // set by "tape"
name: true // set by "readable-stream", "node 14"
},
'%SyntaxErrorPrototype%': {
message: true, // to match TypeErrorPrototype.message
name: true // set by "node 14"
},
'%RangeErrorPrototype%': {
message: true, // to match TypeErrorPrototype.message
name: true // set by "node 14"
},
'%URIErrorPrototype%': {
message: true, // to match TypeErrorPrototype.message
name: true // set by "node 14"
},
'%EvalErrorPrototype%': {
message: true, // to match TypeErrorPrototype.message
name: true // set by "node 14"
},
'%ReferenceErrorPrototype%': {
message: true, // to match TypeErrorPrototype.message
name: true // set by "node 14"
},
// https://github.com/endojs/endo/issues/550
'%AggregateErrorPrototype%': {
message: true, // to match TypeErrorPrototype.message
name: true // set by "node 14"?
},
'%PromisePrototype%': {
constructor: true // set by "core-js"
},
'%TypedArrayPrototype%': '*', // set by https://github.com/feross/buffer
'%Generator%': {
constructor: true,
name: true,
toString: true},
'%IteratorPrototype%': {
toString: true,
// https://github.com/tc39/proposal-iterator-helpers
constructor: true,
// https://github.com/tc39/proposal-iterator-helpers
[toStringTagSymbol]: true}};
/**
* The 'severe' enablement are needed because of issues tracked at
* https://github.com/endojs/endo/issues/576
*
* They are like the `moderate` enablements except for the entries below.
*/$h‍_once.moderateEnablements(moderateEnablements);
const severeEnablements= {
...moderateEnablements,
/**
* Rollup (as used at least by vega) and webpack
* (as used at least by regenerator) both turn exports into assignments
* to a big `exports` object that inherits directly from
* `Object.prototype`. Some of the exported names we've seen include
* `hasOwnProperty`, `constructor`, and `toString`. But the strategy used
* by rollup and webpack potentionally turns any exported name
* into an assignment rejected by the override mistake. That's why
* the `severe` enablements takes the extreme step of enabling
* everything on `Object.prototype`.
*
* In addition, code doing inheritance manually will often override
* the `constructor` property on the new prototype by assignment. We've
* seen this several times.
*
* The cost of enabling all these is that they create a miserable debugging
* experience specifically on Node.
* https://github.com/Agoric/agoric-sdk/issues/2324
* explains how it confused the Node console.
*
* (TODO Reexamine the vscode situation. I think it may have improved
* since the following paragraph was written.)
*
* The vscode debugger's object inspector shows the own data properties of
* an object, which is typically what you want, but also shows both getter
* and setter for every accessor property whether inherited or own.
* With the `'*'` setting here, all the properties inherited from
* `Object.prototype` are accessors, creating an unusable display as seen
* at As explained at
* https://github.com/endojs/endo/blob/master/packages/ses/docs/lockdown.md#overridetaming-options
* Open the triangles at the bottom of that section.
*/
'%ObjectPrototype%': '*',
/**
* The widely used Buffer defined at https://github.com/feross/buffer
* on initialization, manually creates the equivalent of a subclass of
* `TypedArray`, which it then initializes by assignment. These assignments
* include enough of the `TypeArray` methods that here, the `severe`
* enablements just enable them all.
*/
'%TypedArrayPrototype%': '*',
/**
* Needed to work with Immer before https://github.com/immerjs/immer/pull/914
* is accepted.
*/
'%MapPrototype%': '*',
/**
* Needed to work with Immer before https://github.com/immerjs/immer/pull/914
* is accepted.
*/
'%SetPrototype%': '*'};$h‍_once.severeEnablements(severeEnablements);
})()
,
// === functors[19] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let Set,String,TypeError,arrayForEach,defineProperty,getOwnPropertyDescriptor,getOwnPropertyDescriptors,isObject,objectHasOwnProperty,ownKeys,setHas,minEnablements,moderateEnablements,severeEnablements;$h‍_imports([["./commons.js", [["Set", [$h‍_a => (Set = $h‍_a)]],["String", [$h‍_a => (String = $h‍_a)]],["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["arrayForEach", [$h‍_a => (arrayForEach = $h‍_a)]],["defineProperty", [$h‍_a => (defineProperty = $h‍_a)]],["getOwnPropertyDescriptor", [$h‍_a => (getOwnPropertyDescriptor = $h‍_a)]],["getOwnPropertyDescriptors", [$h‍_a => (getOwnPropertyDescriptors = $h‍_a)]],["isObject", [$h‍_a => (isObject = $h‍_a)]],["objectHasOwnProperty", [$h‍_a => (objectHasOwnProperty = $h‍_a)]],["ownKeys", [$h‍_a => (ownKeys = $h‍_a)]],["setHas", [$h‍_a => (setHas = $h‍_a)]]]],["./enablements.js", [["minEnablements", [$h‍_a => (minEnablements = $h‍_a)]],["moderateEnablements", [$h‍_a => (moderateEnablements = $h‍_a)]],["severeEnablements", [$h‍_a => (severeEnablements = $h‍_a)]]]]]);
/**
* For a special set of properties defined in the `enablement` whitelist,
* `enablePropertyOverrides` ensures that the effect of freezing does not
* suppress the ability to override these properties on derived objects by
* simple assignment.
*
* Because of lack of sufficient foresight at the time, ES5 unfortunately
* specified that a simple assignment to a non-existent property must fail if
* it would override an non-writable data property of the same name in the
* shadow of the prototype chain. In retrospect, this was a mistake, the
* so-called "override mistake". But it is now too late and we must live with
* the consequences.
*
* As a result, simply freezing an object to make it tamper proof has the
* unfortunate side effect of breaking previously correct code that is
* considered to have followed JS best practices, if this previous code used
* assignment to override.
*
* For the enabled properties, `enablePropertyOverrides` effectively shims what
* the assignment behavior would have been in the absence of the override
* mistake. However, the shim produces an imperfect emulation. It shims the
* behavior by turning these data properties into accessor properties, where
* the accessor's getter and setter provide the desired behavior. For
* non-reflective operations, the illusion is perfect. However, reflective
* operations like `getOwnPropertyDescriptor` see the descriptor of an accessor
* property rather than the descriptor of a data property. At the time of this
* writing, this is the best we know how to do.
*
* To the getter of the accessor we add a property named
* `'originalValue'` whose value is, as it says, the value that the
* data property had before being converted to an accessor property. We add
* this extra property to the getter for two reason:
*
* The harden algorithm walks the own properties reflectively, i.e., with
* `getOwnPropertyDescriptor` semantics, rather than `[[Get]]` semantics. When
* it sees an accessor property, it does not invoke the getter. Rather, it
* proceeds to walk both the getter and setter as part of its transitive
* traversal. Without this extra property, `enablePropertyOverrides` would have
* hidden the original data property value from `harden`, which would be bad.
* Instead, by exposing that value in an own data property on the getter,
* `harden` finds and walks it anyway.
*
* We enable a form of cooperative emulation, giving reflective code an
* opportunity to cooperate in upholding the illusion. When such cooperative
* reflective code sees an accessor property, where the accessor's getter
* has an `originalValue` property, it knows that the getter is
* alleging that it is the result of the `enablePropertyOverrides` conversion
* pattern, so it can decide to cooperatively "pretend" that it sees a data
* property with that value.
*
* @param {Record<string, any>} intrinsics
* @param {'min' | 'moderate' | 'severe'} overrideTaming
* @param {Iterable<string | symbol>} [overrideDebug]
*/
function enablePropertyOverrides(
intrinsics,
overrideTaming,
overrideDebug= [])
{
const debugProperties= new Set(overrideDebug);
function enable(path, obj, prop, desc) {
if( 'value'in desc&& desc.configurable) {
const { value}= desc;
const isDebug= setHas(debugProperties, prop);
// We use concise method syntax to be `this` sensitive, but still
// omit a prototype property or [[Construct]] behavior.
// @ts-expect-error We know there is an accessor descriptor there
const { get: getter, set: setter}= getOwnPropertyDescriptor(
{
get[ prop]() {
return value;
},
set[ prop](newValue) {
if( obj=== this) {
throw TypeError(
`Cannot assign to read only property '${String(
prop)
}' of '${path}'`);
}
if( objectHasOwnProperty(this, prop)) {
this[prop]= newValue;
}else {
if( isDebug) {
// eslint-disable-next-line @endo/no-polymorphic-call
console.error(TypeError( `Override property ${prop}`));
}
defineProperty(this, prop, {
value: newValue,
writable: true,
enumerable: true,
configurable: true});
}
}},
prop);
defineProperty(getter, 'originalValue', {
value,
writable: false,
enumerable: false,
configurable: false});
defineProperty(obj, prop, {
get: getter,
set: setter,
enumerable: desc.enumerable,
configurable: desc.configurable});
}
}
function enableProperty(path, obj, prop) {
const desc= getOwnPropertyDescriptor(obj, prop);
if( !desc) {
return;
}
enable(path, obj, prop, desc);
}
function enableAllProperties(path, obj) {
const descs= getOwnPropertyDescriptors(obj);
if( !descs) {
return;
}
// TypeScript does not allow symbols to be used as indexes because it
// cannot recokon types of symbolized properties.
arrayForEach(ownKeys(descs), (prop)=>enable(path, obj, prop, descs[prop]));
}
function enableProperties(path, obj, plan) {
for( const prop of ownKeys(plan)) {
const desc= getOwnPropertyDescriptor(obj, prop);
if( !desc|| desc.get|| desc.set) {
// No not a value property, nothing to do.
// eslint-disable-next-line no-continue
continue;
}
// In case `prop` is a symbol, we first coerce it with `String`,
// purely for diagnostic purposes.
const subPath= `${path}.${String(prop)}`;
const subPlan= plan[prop];
if( subPlan=== true) {
enableProperty(subPath, obj, prop);
}else if( subPlan=== '*') {
enableAllProperties(subPath, desc.value);
}else if( isObject(subPlan)) {
enableProperties(subPath, desc.value, subPlan);
}else {
throw TypeError( `Unexpected override enablement plan ${subPath}`);
}
}
}
let plan;
switch( overrideTaming){
case 'min': {
plan= minEnablements;
break;
}
case 'moderate': {
plan= moderateEnablements;
break;
}
case 'severe': {
plan= severeEnablements;
break;
}
default: {
throw TypeError( `unrecognized overrideTaming ${overrideTaming}`);
}}
// Do the repair.
enableProperties('root', intrinsics, plan);
}$h‍_once.default( enablePropertyOverrides);
})()
,
// === functors[20] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let Number,String,TypeError,defineProperty,getOwnPropertyNames,isObject,regexpExec,assert;$h‍_imports([["./commons.js", [["Number", [$h‍_a => (Number = $h‍_a)]],["String", [$h‍_a => (String = $h‍_a)]],["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["defineProperty", [$h‍_a => (defineProperty = $h‍_a)]],["getOwnPropertyNames", [$h‍_a => (getOwnPropertyNames = $h‍_a)]],["isObject", [$h‍_a => (isObject = $h‍_a)]],["regexpExec", [$h‍_a => (regexpExec = $h‍_a)]]]],["./error/assert.js", [["assert", [$h‍_a => (assert = $h‍_a)]]]]]);
const { Fail, quote: q}= assert;
const localePattern= /^(\w*[a-z])Locale([A-Z]\w*)$/;
// Use concise methods to obtain named functions without constructor
// behavior or `.prototype` property.
const tamedMethods= {
// See https://tc39.es/ecma262/#sec-string.prototype.localecompare
localeCompare(arg) {
if( this=== null|| this=== undefined) {
throw TypeError(
'Cannot localeCompare with null or undefined "this" value');
}
const s= `${this}`;
const that= `${arg}`;
if( s< that) {
return -1;
}
if( s> that) {
return 1;
}
s=== that|| Fail `expected ${q(s)} and ${q(that)} to compare`;
return 0;
},
toString() {
return `${this}`;
}};
const nonLocaleCompare= tamedMethods.localeCompare;
const numberToString= tamedMethods.toString;
function tameLocaleMethods(intrinsics, localeTaming= 'safe') {
if( localeTaming!== 'safe'&& localeTaming!== 'unsafe') {
throw TypeError( `unrecognized localeTaming ${localeTaming}`);
}
if( localeTaming=== 'unsafe') {
return;
}
defineProperty(String.prototype, 'localeCompare', {
value: nonLocaleCompare});
for( const intrinsicName of getOwnPropertyNames(intrinsics)) {
const intrinsic= intrinsics[intrinsicName];
if( isObject(intrinsic)) {
for( const methodName of getOwnPropertyNames(intrinsic)) {
const match= regexpExec(localePattern, methodName);
if( match) {
typeof intrinsic[methodName]=== 'function'||
Fail `expected ${q(methodName)} to be a function`;
const nonLocaleMethodName= `${match[1]}${match[2]}`;
const method= intrinsic[nonLocaleMethodName];
typeof method=== 'function'||
Fail `function ${q(nonLocaleMethodName)} not found`;
defineProperty(intrinsic, methodName, { value: method});
}
}
}
}
// Numbers are special because toString accepts a radix instead of ignoring
// all of the arguments that we would otherwise forward.
defineProperty(Number.prototype, 'toLocaleString', {
value: numberToString});
}$h‍_once.default( tameLocaleMethods);
})()
,
// === functors[21] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; $h‍_imports([]); /**
* makeEvalFunction()
* A safe version of the native eval function which relies on
* the safety of safeEvaluate for confinement.
*
* @param {Function} safeEvaluate
*/
const makeEvalFunction= (safeEvaluate)=>{
// We use the concise method syntax to create an eval without a
// [[Construct]] behavior (such that the invocation "new eval()" throws
// TypeError: eval is not a constructor"), but which still accepts a
// 'this' binding.
const newEval= {
eval(source) {
if( typeof source!== 'string') {
// As per the runtime semantic of PerformEval [ECMAScript 18.2.1.1]:
// If Type(source) is not String, return source.
// TODO Recent proposals from Mike Samuel may change this non-string
// rule. Track.
return source;
}
return safeEvaluate(source);
}}.
eval;
return newEval;
};$h‍_once.makeEvalFunction(makeEvalFunction);
})()
,
// === functors[22] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let FERAL_FUNCTION,arrayJoin,arrayPop,defineProperties,getPrototypeOf,assert;$h‍_imports([["./commons.js", [["FERAL_FUNCTION", [$h‍_a => (FERAL_FUNCTION = $h‍_a)]],["arrayJoin", [$h‍_a => (arrayJoin = $h‍_a)]],["arrayPop", [$h‍_a => (arrayPop = $h‍_a)]],["defineProperties", [$h‍_a => (defineProperties = $h‍_a)]],["getPrototypeOf", [$h‍_a => (getPrototypeOf = $h‍_a)]]]],["./error/assert.js", [["assert", [$h‍_a => (assert = $h‍_a)]]]]]);
const { Fail}= assert;
/*
* makeFunctionConstructor()
* A safe version of the native Function which relies on
* the safety of safeEvaluate for confinement.
*/
const makeFunctionConstructor= (safeEvaluate)=>{
// Define an unused parameter to ensure Function.length === 1
const newFunction= function Function(_body) {
// Sanitize all parameters at the entry point.
// eslint-disable-next-line prefer-rest-params
const bodyText= `${arrayPop(arguments)|| '' }`;
// eslint-disable-next-line prefer-rest-params
const parameters= `${arrayJoin(arguments,',') }`;
// Are parameters and bodyText valid code, or is someone
// attempting an injection attack? This will throw a SyntaxError if:
// - parameters doesn't parse as parameters
// - bodyText doesn't parse as a function body
// - either contain a call to super() or references a super property.
//
// It seems that XS may still be vulnerable to the attack explained at
// https://github.com/tc39/ecma262/pull/2374#issuecomment-813769710
// where `new Function('/*', '*/ ) {')` would incorrectly validate.
// Before we worried about this, we check the parameters and bodyText
// together in one call
// ```js
// new FERAL_FUNCTION(parameters, bodyTest);
// ```
// However, this check is vulnerable to that bug. Aside from that case,
// all engines do seem to validate the parameters, taken by themselves,
// correctly. And all engines do seem to validate the bodyText, taken
// by itself correctly. So with the following two checks, SES builds a
// correct safe `Function` constructor by composing two calls to an
// original unsafe `Function` constructor that may suffer from this bug
// but is otherwise correctly validating.
//
// eslint-disable-next-line no-new
new FERAL_FUNCTION(parameters, '');
// eslint-disable-next-line no-new
new FERAL_FUNCTION(bodyText);
// Safe to be combined. Defeat potential trailing comments.
// TODO: since we create an anonymous function, the 'this' value
// isn't bound to the global object as per specs, but set as undefined.
const src= `(function anonymous(${parameters}\n) {\n${bodyText}\n})`;
return safeEvaluate(src);
};
defineProperties(newFunction, {
// Ensure that any function created in any evaluator in a realm is an
// instance of Function in any evaluator of the same realm.
prototype: {
value: FERAL_FUNCTION.prototype,
writable: false,
enumerable: false,
configurable: false}});
// Assert identity of Function.__proto__ accross all compartments
getPrototypeOf(FERAL_FUNCTION)=== FERAL_FUNCTION.prototype||
Fail `Function prototype is the same accross compartments`;
getPrototypeOf(newFunction)=== FERAL_FUNCTION.prototype||
Fail `Function constructor prototype is the same accross compartments`;
return newFunction;
};$h‍_once.makeFunctionConstructor(makeFunctionConstructor);
})()
,
// === functors[23] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let TypeError,assign,create,defineProperty,entries,freeze,objectHasOwnProperty,unscopablesSymbol,makeEvalFunction,makeFunctionConstructor,constantProperties,universalPropertyNames;$h‍_imports([["./commons.js", [["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["assign", [$h‍_a => (assign = $h‍_a)]],["create", [$h‍_a => (create = $h‍_a)]],["defineProperty", [$h‍_a => (defineProperty = $h‍_a)]],["entries", [$h‍_a => (entries = $h‍_a)]],["freeze", [$h‍_a => (freeze = $h‍_a)]],["objectHasOwnProperty", [$h‍_a => (objectHasOwnProperty = $h‍_a)]],["unscopablesSymbol", [$h‍_a => (unscopablesSymbol = $h‍_a)]]]],["./make-eval-function.js", [["makeEvalFunction", [$h‍_a => (makeEvalFunction = $h‍_a)]]]],["./make-function-constructor.js", [["makeFunctionConstructor", [$h‍_a => (makeFunctionConstructor = $h‍_a)]]]],["./permits.js", [["constantProperties", [$h‍_a => (constantProperties = $h‍_a)]],["universalPropertyNames", [$h‍_a => (universalPropertyNames = $h‍_a)]]]]]);
/**
* The host's ordinary global object is not provided by a `with` block, so
* assigning to Symbol.unscopables has no effect.
* Since this shim uses `with` blocks to create a confined lexical scope for
* guest programs, we cannot emulate the proper behavior.
* With this shim, assigning Symbol.unscopables causes the given lexical
* names to fall through to the terminal scope proxy.
* But, we can install this setter to prevent a program from proceding on
* this false assumption.
*
* @param {object} globalObject
*/
const setGlobalObjectSymbolUnscopables= (globalObject)=>{
defineProperty(
globalObject,
unscopablesSymbol,
freeze(
assign(create(null), {
set: freeze(()=> {
throw TypeError(
`Cannot set Symbol.unscopables of a Compartment's globalThis`);
}),
enumerable: false,
configurable: false})));
};
/**
* setGlobalObjectConstantProperties()
* Initializes a new global object using a process similar to ECMA specifications
* (SetDefaultGlobalBindings). This process is split between this function and
* `setGlobalObjectMutableProperties`.
*
* @param {object} globalObject
*/$h‍_once.setGlobalObjectSymbolUnscopables(setGlobalObjectSymbolUnscopables);
const setGlobalObjectConstantProperties= (globalObject)=>{
for( const [name, constant]of entries(constantProperties)) {
defineProperty(globalObject, name, {
value: constant,
writable: false,
enumerable: false,
configurable: false});
}
};
/**
* setGlobalObjectMutableProperties()
* Create new global object using a process similar to ECMA specifications
* (portions of SetRealmGlobalObject and SetDefaultGlobalBindings).
* `newGlobalPropertyNames` should be either `initialGlobalPropertyNames` or
* `sharedGlobalPropertyNames`.
*
* @param {object} globalObject
* @param {object} args
* @param {object} args.intrinsics
* @param {object} args.newGlobalPropertyNames
* @param {Function} args.makeCompartmentConstructor
* @param {(object) => void} args.markVirtualizedNativeFunction
* @param {Compartment} [args.parentCompartment]
*/$h‍_once.setGlobalObjectConstantProperties(setGlobalObjectConstantProperties);
const setGlobalObjectMutableProperties= (
globalObject,
{
intrinsics,
newGlobalPropertyNames,
makeCompartmentConstructor,
markVirtualizedNativeFunction,
parentCompartment})=>
{
for( const [name, intrinsicName]of entries(universalPropertyNames)) {
if( objectHasOwnProperty(intrinsics, intrinsicName)) {
defineProperty(globalObject, name, {
value: intrinsics[intrinsicName],
writable: true,
enumerable: false,
configurable: true});
}
}
for( const [name, intrinsicName]of entries(newGlobalPropertyNames)) {
if( objectHasOwnProperty(intrinsics, intrinsicName)) {
defineProperty(globalObject, name, {
value: intrinsics[intrinsicName],
writable: true,
enumerable: false,
configurable: true});
}
}
const perCompartmentGlobals= {
globalThis: globalObject};
perCompartmentGlobals.Compartment= freeze(
makeCompartmentConstructor(
makeCompartmentConstructor,
intrinsics,
markVirtualizedNativeFunction,
parentCompartment));
// TODO These should still be tamed according to the whitelist before
// being made available.
for( const [name, value]of entries(perCompartmentGlobals)) {
defineProperty(globalObject, name, {
value,
writable: true,
enumerable: false,
configurable: true});
if( typeof value=== 'function') {
markVirtualizedNativeFunction(value);
}
}
};
/**
* setGlobalObjectEvaluators()
* Set the eval and the Function evaluator on the global object with given evalTaming policy.
*
* @param {object} globalObject
* @param {Function} evaluator
* @param {(object) => void} markVirtualizedNativeFunction
*/$h‍_once.setGlobalObjectMutableProperties(setGlobalObjectMutableProperties);
const setGlobalObjectEvaluators= (
globalObject,
evaluator,
markVirtualizedNativeFunction)=>
{
{
const f= freeze(makeEvalFunction(evaluator));
markVirtualizedNativeFunction(f);
defineProperty(globalObject, 'eval', {
value: f,
writable: true,
enumerable: false,
configurable: true});
}
{
const f= freeze(makeFunctionConstructor(evaluator));
markVirtualizedNativeFunction(f);
defineProperty(globalObject, 'Function', {
value: f,
writable: true,
enumerable: false,
configurable: true});
}
};$h‍_once.setGlobalObjectEvaluators(setGlobalObjectEvaluators);
})()
,
// === functors[24] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let Proxy,String,TypeError,ReferenceError,create,freeze,getOwnPropertyDescriptors,globalThis,immutableObject,assert;$h‍_imports([["./commons.js", [["Proxy", [$h‍_a => (Proxy = $h‍_a)]],["String", [$h‍_a => (String = $h‍_a)]],["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["ReferenceError", [$h‍_a => (ReferenceError = $h‍_a)]],["create", [$h‍_a => (create = $h‍_a)]],["freeze", [$h‍_a => (freeze = $h‍_a)]],["getOwnPropertyDescriptors", [$h‍_a => (getOwnPropertyDescriptors = $h‍_a)]],["globalThis", [$h‍_a => (globalThis = $h‍_a)]],["immutableObject", [$h‍_a => (immutableObject = $h‍_a)]]]],["./error/assert.js", [["assert", [$h‍_a => (assert = $h‍_a)]]]]]);
const { Fail, quote: q}= assert;
/**
* alwaysThrowHandler
* This is an object that throws if any property is called. It's used as
* a proxy handler which throws on any trap called.
* It's made from a proxy with a get trap that throws. It's safe to
* create one and share it between all Proxy handlers.
*/
const alwaysThrowHandler= new Proxy(
immutableObject,
freeze({
get(_shadow, prop) {
Fail `Please report unexpected scope handler trap: ${q(String(prop))}`;
}}));
/*
* scopeProxyHandlerProperties
* scopeTerminatorHandler manages a strictScopeTerminator Proxy which serves as
* the final scope boundary that will always return "undefined" in order
* to prevent access to "start compartment globals".
*/$h‍_once.alwaysThrowHandler(alwaysThrowHandler);
const scopeProxyHandlerProperties= {
get(_shadow, _prop) {
return undefined;
},
set(_shadow, prop, _value) {
// We should only hit this if the has() hook returned true matches the v8
// ReferenceError message "Uncaught ReferenceError: xyz is not defined"
throw ReferenceError( `${String(prop)} is not defined`);
},
has(_shadow, prop) {
// we must at least return true for all properties on the realm globalThis
return prop in globalThis;
},
// note: this is likely a bug of safari
// https://bugs.webkit.org/show_bug.cgi?id=195534
getPrototypeOf(_shadow) {
return null;
},
// See https://github.com/endojs/endo/issues/1510
// TODO: report as bug to v8 or Chrome, and record issue link here.
getOwnPropertyDescriptor(_shadow, prop) {
// Coerce with `String` in case prop is a symbol.
const quotedProp= q(String(prop));
// eslint-disable-next-line @endo/no-polymorphic-call
console.warn(
`getOwnPropertyDescriptor trap on scopeTerminatorHandler for ${quotedProp}`,
TypeError().stack);
return undefined;
},
// See https://github.com/endojs/endo/issues/1490
// TODO Report bug to JSC or Safari
ownKeys(_shadow) {
return [];
}};
// The scope handler's prototype is a proxy that throws if any trap other
// than get/set/has are run (like getOwnPropertyDescriptors, apply,
// getPrototypeOf).
const strictScopeTerminatorHandler= freeze(
create(
alwaysThrowHandler,
getOwnPropertyDescriptors(scopeProxyHandlerProperties)));$h‍_once.strictScopeTerminatorHandler(strictScopeTerminatorHandler);
const strictScopeTerminator= new Proxy(
immutableObject,
strictScopeTerminatorHandler);$h‍_once.strictScopeTerminator(strictScopeTerminator);
})()
,
// === functors[25] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let Proxy,create,freeze,getOwnPropertyDescriptors,immutableObject,reflectSet,strictScopeTerminatorHandler,alwaysThrowHandler;$h‍_imports([["./commons.js", [["Proxy", [$h‍_a => (Proxy = $h‍_a)]],["create", [$h‍_a => (create = $h‍_a)]],["freeze", [$h‍_a => (freeze = $h‍_a)]],["getOwnPropertyDescriptors", [$h‍_a => (getOwnPropertyDescriptors = $h‍_a)]],["immutableObject", [$h‍_a => (immutableObject = $h‍_a)]],["reflectSet", [$h‍_a => (reflectSet = $h‍_a)]]]],["./strict-scope-terminator.js", [["strictScopeTerminatorHandler", [$h‍_a => (strictScopeTerminatorHandler = $h‍_a)]],["alwaysThrowHandler", [$h‍_a => (alwaysThrowHandler = $h‍_a)]]]]]);
/*
* createSloppyGlobalsScopeTerminator()
* strictScopeTerminatorHandler manages a scopeTerminator Proxy which serves as
* the final scope boundary that will always return "undefined" in order
* to prevent access to "start compartment globals". When "sloppyGlobalsMode"
* is true, the Proxy will perform sets on the "globalObject".
*/
const createSloppyGlobalsScopeTerminator= (globalObject)=>{
const scopeProxyHandlerProperties= {
// inherit scopeTerminator behavior
...strictScopeTerminatorHandler,
// Redirect set properties to the globalObject.
set(_shadow, prop, value) {
return reflectSet(globalObject, prop, value);
},
// Always claim to have a potential property in order to be the recipient of a set
has(_shadow, _prop) {
return true;
}};
// The scope handler's prototype is a proxy that throws if any trap other
// than get/set/has are run (like getOwnPropertyDescriptors, apply,
// getPrototypeOf).
const sloppyGlobalsScopeTerminatorHandler= freeze(
create(
alwaysThrowHandler,
getOwnPropertyDescriptors(scopeProxyHandlerProperties)));
const sloppyGlobalsScopeTerminator= new Proxy(
immutableObject,
sloppyGlobalsScopeTerminatorHandler);
return sloppyGlobalsScopeTerminator;
};$h‍_once.createSloppyGlobalsScopeTerminator(createSloppyGlobalsScopeTerminator);
freeze(createSloppyGlobalsScopeTerminator);
})()
,
// === functors[26] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let FERAL_EVAL,create,defineProperties,freeze,assert;$h‍_imports([["./commons.js", [["FERAL_EVAL", [$h‍_a => (FERAL_EVAL = $h‍_a)]],["create", [$h‍_a => (create = $h‍_a)]],["defineProperties", [$h‍_a => (defineProperties = $h‍_a)]],["freeze", [$h‍_a => (freeze = $h‍_a)]]]],["./error/assert.js", [["assert", [$h‍_a => (assert = $h‍_a)]]]]]);
const { Fail}= assert;
// We attempt to frustrate stack bumping attacks on the safe evaluator
// (`make-safe-evaluator.js`).
// A stack bumping attack forces an API call to throw a stack overflow
// `RangeError` at an inopportune time.
// The attacker arranges for the stack to be sufficiently deep that the API
// consumes exactly enough stack frames to throw an exception.
//
// For the safe evaluator, an exception thrown between adding and then deleting
// `eval` on `evalScope` could leak the real `eval` to an attacker's lexical
// scope.
// This would be sufficiently disastrous that we guard against it twice.
// First, we delete `eval` from `evalScope` immediately before rendering it to
// the guest program's lexical scope.
//
// If the attacker manages to arrange for `eval` to throw an exception after we
// call `allowNextEvalToBeUnsafe` but before the guest program accesses `eval`,
// it would be able to access `eval` once more in its own code.
// Although they could do no harm with a direct `eval`, they would be able to
// escape to the true global scope with an indirect `eval`.
//
// prepareStack(depth, () => {
// (eval)('');
// });
// const unsafeEval = (eval);
// const safeEval = (eval);
// const realGlobal = unsafeEval('globalThis');
//
// To protect against that case, we also delete `eval` from the `evalScope` in
// a `finally` block surrounding the call to the safe evaluator.
// The only way to reach this case is if `eval` remains on `evalScope` due to
// an attack, so we assume that attack would have have invalided our isolation
// and revoke all future access to the evaluator.
//
// To defeat a stack bumping attack, we must use fewer stack frames to recover
// in that `finally` block than we used in the `try` block.
// We have no reliable guarantees about how many stack frames a block of
// JavaScript will consume.
// Function inlining, tail-call optimization, variations in the size of a stack
// frame, and block scopes may affect the depth of the stack.
// The only number of acceptable stack frames to use in the finally block is
// zero.
// We only use property assignment and deletion in the safe evaluator's
// `finally` block.
// We use `delete evalScope.eval` to withhold the evaluator.
// We assign an envelope object over `evalScopeKit.revoked` to revoke the
// evaluator.
//
// This is why we supply a meaningfully named function for
// `allowNextEvalToBeUnsafe` but do not provide a corresponding
// `revokeAccessToUnsafeEval` or even simply `revoke`.
// These recovery routines are expressed inline in the safe evaluator.
const makeEvalScopeKit= ()=> {
const evalScope= create(null);
const oneTimeEvalProperties= freeze({
eval: {
get() {
delete evalScope.eval;
return FERAL_EVAL;
},
enumerable: false,
configurable: true}});
const evalScopeKit= {
evalScope,
allowNextEvalToBeUnsafe() {
const { revoked}= evalScopeKit;
if( revoked!== null) {
Fail `a handler did not reset allowNextEvalToBeUnsafe ${revoked.err}`;
}
// Allow next reference to eval produce the unsafe FERAL_EVAL.
// We avoid defineProperty because it consumes an extra stack frame taming
// its return value.
defineProperties(evalScope, oneTimeEvalProperties);
},
/** @type {null | { err: any }} */
revoked: null};
return evalScopeKit;
};$h‍_once.makeEvalScopeKit(makeEvalScopeKit);
})()
,
// === functors[27] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let FERAL_REG_EXP,regexpExec,stringSlice;$h‍_imports([["./commons.js", [["FERAL_REG_EXP", [$h‍_a => (FERAL_REG_EXP = $h‍_a)]],["regexpExec", [$h‍_a => (regexpExec = $h‍_a)]],["stringSlice", [$h‍_a => (stringSlice = $h‍_a)]]]]]);
// Captures a key and value of the form #key=value or @key=value
const sourceMetaEntryRegExp=
'\\s*[@#]\\s*([a-zA-Z][a-zA-Z0-9]*)\\s*=\\s*([^\\s\\*]*)';
// Captures either a one-line or multi-line comment containing
// one #key=value or @key=value.
// Produces two pairs of capture groups, but the initial two may be undefined.
// On account of the mechanics of regular expressions, scanning from the end
// does not allow us to capture every pair, so getSourceURL must capture and
// trim until there are no matching comments.
const sourceMetaEntriesRegExp= new FERAL_REG_EXP(
`(?:\\s*//${sourceMetaEntryRegExp}|/\\*${sourceMetaEntryRegExp}\\s*\\*/)\\s*$`);
/**
* @param {string} src
*/
const getSourceURL= (src)=>{
let sourceURL= '<unknown>';
// Our regular expression matches the last one or two comments with key value
// pairs at the end of the source, avoiding a scan over the entire length of
// the string, but at the expense of being able to capture all the (key,
// value) pair meta comments at the end of the source, which may include
// sourceMapURL in addition to sourceURL.
// So, we sublimate the comments out of the source until no source or no
// comments remain.
while( src.length> 0) {
const match= regexpExec(sourceMetaEntriesRegExp, src);
if( match=== null) {
break;
}
src= stringSlice(src, 0, src.length- match[0].length);
// We skip $0 since it contains the entire match.
// The match contains four capture groups,
// two (key, value) pairs, the first of which
// may be undefined.
// On the off-chance someone put two sourceURL comments in their code with
// different commenting conventions, the latter has precedence.
if( match[3]=== 'sourceURL') {
sourceURL= match[4];
}else if( match[1]=== 'sourceURL') {
sourceURL= match[2];
}
}
return sourceURL;
};$h‍_once.getSourceURL(getSourceURL);
})()
,
// === functors[28] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let FERAL_REG_EXP,SyntaxError,stringReplace,stringSearch,stringSlice,stringSplit,freeze,getSourceURL;$h‍_imports([["./commons.js", [["FERAL_REG_EXP", [$h‍_a => (FERAL_REG_EXP = $h‍_a)]],["SyntaxError", [$h‍_a => (SyntaxError = $h‍_a)]],["stringReplace", [$h‍_a => (stringReplace = $h‍_a)]],["stringSearch", [$h‍_a => (stringSearch = $h‍_a)]],["stringSlice", [$h‍_a => (stringSlice = $h‍_a)]],["stringSplit", [$h‍_a => (stringSplit = $h‍_a)]],["freeze", [$h‍_a => (freeze = $h‍_a)]]]],["./get-source-url.js", [["getSourceURL", [$h‍_a => (getSourceURL = $h‍_a)]]]]]);
/**
* Find the first occurence of the given pattern and return
* the location as the approximate line number.
*
* @param {string} src
* @param {RegExp} pattern
* @returns {number}
*/
function getLineNumber(src, pattern) {
const index= stringSearch(src, pattern);
if( index< 0) {
return -1;
}
// The importPattern incidentally captures an initial \n in
// an attempt to reject a . prefix, so we need to offset
// the line number in that case.
const adjustment= src[index]=== '\n'? 1: 0;
return stringSplit(stringSlice(src, 0, index), '\n').length+ adjustment;
}
// /////////////////////////////////////////////////////////////////////////////
const htmlCommentPattern= new FERAL_REG_EXP( `(?:${'<'}!--|--${'>'})`,'g');
/**
* Conservatively reject the source text if it may contain text that some
* JavaScript parsers may treat as an html-like comment. To reject without
* parsing, `rejectHtmlComments` will also reject some other text as well.
*
* https://www.ecma-international.org/ecma-262/9.0/index.html#sec-html-like-comments
* explains that JavaScript parsers may or may not recognize html
* comment tokens "<" immediately followed by "!--" and "--"
* immediately followed by ">" in non-module source text, and treat
* them as a kind of line comment. Since otherwise both of these can
* appear in normal JavaScript source code as a sequence of operators,
* we have the terrifying possibility of the same source code parsing
* one way on one correct JavaScript implementation, and another way
* on another.
*
* This shim takes the conservative strategy of just rejecting source
* text that contains these strings anywhere. Note that this very
* source file is written strangely to avoid mentioning these
* character strings explicitly.
*
* We do not write the regexp in a straightforward way, so that an
* apparennt html comment does not appear in this file. Thus, we avoid
* rejection by the overly eager rejectDangerousSources.
*
* @param {string} src
* @returns {string}
*/
const rejectHtmlComments= (src)=>{
const lineNumber= getLineNumber(src, htmlCommentPattern);
if( lineNumber< 0) {
return src;
}
const name= getSourceURL(src);
// See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_HTML_COMMENT_REJECTED.md
throw SyntaxError(
`Possible HTML comment rejected at ${name}:${lineNumber}. (SES_HTML_COMMENT_REJECTED)`);
};
/**
* An optional transform to place ahead of `rejectHtmlComments` to evade *that*
* rejection. However, it may change the meaning of the program.
*
* This evasion replaces each alleged html comment with the space-separated
* JavaScript operator sequence that it may mean, assuming that it appears
* outside of a comment or literal string, in source code where the JS
* parser makes no special case for html comments (like module source code).
* In that case, this evasion preserves the meaning of the program, though it
* does change the souce column numbers on each effected line.
*
* If the html comment appeared in a literal (a string literal, regexp literal,
* or a template literal), then this evasion will change the meaning of the
* program by changing the text of that literal.
*
* If the html comment appeared in a JavaScript comment, then this evasion does
* not change the meaning of the program because it only changes the contents of
* those comments.
*
* @param {string} src
* @returns {string}
*/$h‍_once.rejectHtmlComments(rejectHtmlComments);
const evadeHtmlCommentTest= (src)=>{
const replaceFn= (match)=> match[0]=== '<'? '< ! --': '-- >';
return stringReplace(src, htmlCommentPattern, replaceFn);
};
// /////////////////////////////////////////////////////////////////////////////
$h‍_once.evadeHtmlCommentTest(evadeHtmlCommentTest);
const importPattern= new FERAL_REG_EXP(
'(^|[^.]|\\.\\.\\.)\\bimport(\\s*(?:\\(|/[/*]))',
'g');
/**
* Conservatively reject the source text if it may contain a dynamic
* import expression. To reject without parsing, `rejectImportExpressions` will
* also reject some other text as well.
*
* The proposed dynamic import expression is the only syntax currently
* proposed, that can appear in non-module JavaScript code, that
* enables direct access to the outside world that cannot be
* suppressed or intercepted without parsing and rewriting. Instead,
* this shim conservatively rejects any source text that seems to
* contain such an expression. To do this safely without parsing, we
* must also reject some valid programs, i.e., those containing
* apparent import expressions in literal strings or comments.
*
* The current conservative rule looks for the identifier "import"
* followed by either an open paren or something that looks like the
* beginning of a comment. We assume that we do not need to worry
* about html comment syntax because that was already rejected by
* rejectHtmlComments.
*
* this \s *must* match all kinds of syntax-defined whitespace. If e.g.
* U+2028 (LINE SEPARATOR) or U+2029 (PARAGRAPH SEPARATOR) is treated as
* whitespace by the parser, but not matched by /\s/, then this would admit
* an attack like: import\u2028('power.js') . We're trying to distinguish
* something like that from something like importnotreally('power.js') which
* is perfectly safe.
*
* @param {string} src
* @returns {string}
*/
const rejectImportExpressions= (src)=>{
const lineNumber= getLineNumber(src, importPattern);
if( lineNumber< 0) {
return src;
}
const name= getSourceURL(src);
// See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_IMPORT_REJECTED.md
throw SyntaxError(
`Possible import expression rejected at ${name}:${lineNumber}. (SES_IMPORT_REJECTED)`);
};
/**
* An optional transform to place ahead of `rejectImportExpressions` to evade
* *that* rejection. However, it may change the meaning of the program.
*
* This evasion replaces each suspicious `import` identifier with `__import__`.
* If the alleged import expression appears in a JavaScript comment, this
* evasion will not change the meaning of the program. If it appears in a
* literal (string literal, regexp literal, or a template literal), then this
* evasion will change the contents of that literal. If it appears as code
* where it would be parsed as an expression, then it might or might not change
* the meaning of the program, depending on the binding, if any, of the lexical
* variable `__import__`.
*
* @param {string} src
* @returns {string}
*/$h‍_once.rejectImportExpressions(rejectImportExpressions);
const evadeImportExpressionTest= (src)=>{
const replaceFn= (_, p1, p2)=> `${p1}__import__${p2}`;
return stringReplace(src, importPattern, replaceFn);
};
// /////////////////////////////////////////////////////////////////////////////
$h‍_once.evadeImportExpressionTest(evadeImportExpressionTest);
const someDirectEvalPattern= new FERAL_REG_EXP(
'(^|[^.])\\beval(\\s*\\()',
'g');
/**
* Heuristically reject some text that seems to contain a direct eval
* expression, with both false positives and false negavives. To reject without
* parsing, `rejectSomeDirectEvalExpressions` may will also reject some other
* text as well. It may also accept source text that contains a direct eval
* written oddly, such as `(eval)(src)`. This false negative is not a security
* vulnerability. Rather it is a compat hazard because it will execute as
* an indirect eval under the SES-shim but as a direct eval on platforms that
* support SES directly (like XS).
*
* The shim cannot correctly emulate a direct eval as explained at
* https://github.com/Agoric/realms-shim/issues/12
* If we did not reject direct eval syntax, we would
* accidentally evaluate these with an emulation of indirect eval. To
* prevent future compatibility problems, in shifting from use of the
* shim to genuine platform support for the proposal, we should
* instead statically reject code that seems to contain a direct eval
* expression.
*
* As with the dynamic import expression, to avoid a full parse, we do
* this approximately with a regexp, that will also reject strings
* that appear safely in comments or strings. Unlike dynamic import,
* if we miss some, this only creates future compat problems, not
* security problems. Thus, we are only trying to catch innocent
* occurrences, not malicious one. In particular, `(eval)(...)` is
* direct eval syntax that would not be caught by the following regexp.
*
* Exported for unit tests.
*
* @param {string} src
* @returns {string}
*/
const rejectSomeDirectEvalExpressions= (src)=>{
const lineNumber= getLineNumber(src, someDirectEvalPattern);
if( lineNumber< 0) {
return src;
}
const name= getSourceURL(src);
// See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_EVAL_REJECTED.md
throw SyntaxError(
`Possible direct eval expression rejected at ${name}:${lineNumber}. (SES_EVAL_REJECTED)`);
};
// /////////////////////////////////////////////////////////////////////////////
/**
* A transform that bundles together the transforms that must unconditionally
* happen last in order to ensure safe evaluation without parsing.
*
* @param {string} source
* @returns {string}
*/$h‍_once.rejectSomeDirectEvalExpressions(rejectSomeDirectEvalExpressions);
const mandatoryTransforms= (source)=>{
source= rejectHtmlComments(source);
source= rejectImportExpressions(source);
return source;
};
/**
* Starting with `source`, apply each transform to the result of the
* previous one, returning the result of the last transformation.
*
* @param {string} source
* @param {((str: string) => string)[]} transforms
* @returns {string}
*/$h‍_once.mandatoryTransforms(mandatoryTransforms);
const applyTransforms= (source, transforms)=> {
for( const transform of transforms) {
source= transform(source);
}
return source;
};
// export all as a frozen object
$h‍_once.applyTransforms(applyTransforms);const transforms=freeze({
rejectHtmlComments: freeze(rejectHtmlComments),
evadeHtmlCommentTest: freeze(evadeHtmlCommentTest),
rejectImportExpressions: freeze(rejectImportExpressions),
evadeImportExpressionTest: freeze(evadeImportExpressionTest),
rejectSomeDirectEvalExpressions: freeze(rejectSomeDirectEvalExpressions),
mandatoryTransforms: freeze(mandatoryTransforms),
applyTransforms: freeze(applyTransforms)});$h‍_once.transforms(transforms);
})()
,
// === functors[29] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let arrayFilter,arrayIncludes,getOwnPropertyDescriptor,getOwnPropertyNames,objectHasOwnProperty,regexpTest;$h‍_imports([["./commons.js", [["arrayFilter", [$h‍_a => (arrayFilter = $h‍_a)]],["arrayIncludes", [$h‍_a => (arrayIncludes = $h‍_a)]],["getOwnPropertyDescriptor", [$h‍_a => (getOwnPropertyDescriptor = $h‍_a)]],["getOwnPropertyNames", [$h‍_a => (getOwnPropertyNames = $h‍_a)]],["objectHasOwnProperty", [$h‍_a => (objectHasOwnProperty = $h‍_a)]],["regexpTest", [$h‍_a => (regexpTest = $h‍_a)]]]]]);
/**
* keywords
* In JavaScript you cannot use these reserved words as variables.
* See 11.6.1 Identifier Names
*/
const keywords= [
// 11.6.2.1 Keywords
'await',
'break',
'case',
'catch',
'class',
'const',
'continue',
'debugger',
'default',
'delete',
'do',
'else',
'export',
'extends',
'finally',
'for',
'function',
'if',
'import',
'in',
'instanceof',
'new',
'return',
'super',
'switch',
'this',
'throw',
'try',
'typeof',
'var',
'void',
'while',
'with',
'yield',
// Also reserved when parsing strict mode code
'let',
'static',
// 11.6.2.2 Future Reserved Words
'enum',
// Also reserved when parsing strict mode code
'implements',
'package',
'protected',
'interface',
'private',
'public',
// Reserved but not mentioned in specs
'await',
'null',
'true',
'false',
'this',
'arguments'];
/**
* identifierPattern
* Simplified validation of identifier names: may only contain alphanumeric
* characters (or "$" or "_"), and may not start with a digit. This is safe
* and does not reduces the compatibility of the shim. The motivation for
* this limitation was to decrease the complexity of the implementation,
* and to maintain a resonable level of performance.
* Note: \w is equivalent [a-zA-Z_0-9]
* See 11.6.1 Identifier Names
*/
const identifierPattern= /^[a-zA-Z_$][\w$]*$/;
/**
* isValidIdentifierName()
* What variable names might it bring into scope? These include all
* property names which can be variable names, including the names
* of inherited properties. It excludes symbols and names which are
* keywords. We drop symbols safely. Currently, this shim refuses
* service if any of the names are keywords or keyword-like. This is
* safe and only prevent performance optimization.
*
* @param {string} name
*/
const isValidIdentifierName= (name)=>{
// Ensure we have a valid identifier. We use regexpTest rather than
// /../.test() to guard against the case where RegExp has been poisoned.
return(
name!== 'eval'&&
!arrayIncludes(keywords, name)&&
regexpTest(identifierPattern, name));
};
/*
* isImmutableDataProperty
*/$h‍_once.isValidIdentifierName(isValidIdentifierName);
function isImmutableDataProperty(obj, name) {
const desc= getOwnPropertyDescriptor(obj, name);
return(
desc&&
//
// The getters will not have .writable, don't let the falsyness of
// 'undefined' trick us: test with === false, not ! . However descriptors
// inherit from the (potentially poisoned) global object, so we might see
// extra properties which weren't really there. Accessor properties have
// 'get/set/enumerable/configurable', while data properties have
// 'value/writable/enumerable/configurable'.
desc.configurable=== false&&
desc.writable=== false&&
//
// Checks for data properties because they're the only ones we can
// optimize (accessors are most likely non-constant). Descriptors can't
// can't have accessors and value properties at the same time, therefore
// this check is sufficient. Using explicit own property deal with the
// case where Object.prototype has been poisoned.
objectHasOwnProperty(desc, 'value'));
}
/**
* getScopeConstants()
* What variable names might it bring into scope? These include all
* property names which can be variable names, including the names
* of inherited properties. It excludes symbols and names which are
* keywords. We drop symbols safely. Currently, this shim refuses
* service if any of the names are keywords or keyword-like. This is
* safe and only prevent performance optimization.
*
* @param {object} globalObject
* @param {object} moduleLexicals
*/
const getScopeConstants= (globalObject, moduleLexicals= {})=> {
// getOwnPropertyNames() does ignore Symbols so we don't need to
// filter them out.
const globalObjectNames= getOwnPropertyNames(globalObject);
const moduleLexicalNames= getOwnPropertyNames(moduleLexicals);
// Collect all valid & immutable identifiers from the endowments.
const moduleLexicalConstants= arrayFilter(
moduleLexicalNames,
(name)=>
isValidIdentifierName(name)&&
isImmutableDataProperty(moduleLexicals, name));
// Collect all valid & immutable identifiers from the global that
// are also not present in the endowments (immutable or not).
const globalObjectConstants= arrayFilter(
globalObjectNames,
(name)=>
// Can't define a constant: it would prevent a
// lookup on the endowments.
!arrayIncludes(moduleLexicalNames, name)&&
isValidIdentifierName(name)&&
isImmutableDataProperty(globalObject, name));
return {
globalObjectConstants,
moduleLexicalConstants};
};$h‍_once.getScopeConstants(getScopeConstants);
})()
,
// === functors[30] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let FERAL_FUNCTION,arrayJoin,apply,getScopeConstants;$h‍_imports([["./commons.js", [["FERAL_FUNCTION", [$h‍_a => (FERAL_FUNCTION = $h‍_a)]],["arrayJoin", [$h‍_a => (arrayJoin = $h‍_a)]],["apply", [$h‍_a => (apply = $h‍_a)]]]],["./scope-constants.js", [["getScopeConstants", [$h‍_a => (getScopeConstants = $h‍_a)]]]]]);
/**
* buildOptimizer()
* Given an array of identifiers, the optimizer returns a `const` declaration
* destructuring `this.${name}`.
*
* @param {Array<string>} constants
* @param {string} name
*/
function buildOptimizer(constants, name) {
// No need to build an optimizer when there are no constants.
if( constants.length=== 0) return '';
// Use 'this' to avoid going through the scope proxy, which is unnecessary
// since the optimizer only needs references to the safe global.
// Destructure the constants from the target scope object.
return `const {${arrayJoin(constants,',') }} = this.${name};`;
}
/**
* makeEvaluate()
* Create an 'evaluate' function with the correct optimizer inserted.
*
* @param {object} context
* @param {object} context.evalScope
* @param {object} context.moduleLexicals
* @param {object} context.globalObject
* @param {object} context.scopeTerminator
*/
const makeEvaluate= (context)=>{
const { globalObjectConstants, moduleLexicalConstants}= getScopeConstants(
context.globalObject,
context.moduleLexicals);
const globalObjectOptimizer= buildOptimizer(
globalObjectConstants,
'globalObject');
const moduleLexicalOptimizer= buildOptimizer(
moduleLexicalConstants,
'moduleLexicals');
// Create a function in sloppy mode, so that we can use 'with'. It returns
// a function in strict mode that evaluates the provided code using direct
// eval, and thus in strict mode in the same scope. We must be very careful
// to not create new names in this scope
// 1: we use multiple nested 'with' to catch all free variable names. The
// `this` value of the outer sloppy function holds the different scope
// layers, from inner to outer:
// a) `evalScope` which must release the `FERAL_EVAL` as 'eval' once for
// every invocation of the inner `evaluate` function in order to
// trigger direct eval. The direct eval semantics is what allows the
// evaluated code to lookup free variable names on the other scope
// objects and not in global scope.
// b) `moduleLexicals` which provide a way to introduce free variables
// that are not available on the globalObject.
// c) `globalObject` is the global scope object of the evaluator, aka the
// Compartment's `globalThis`.
// d) `scopeTerminator` is a proxy object which prevents free variable
// lookups to escape to the start compartment's global object.
// 2: `optimizer`s catch constant variable names for speed.
// 3: The inner strict `evaluate` function should be passed two parameters:
// a) its arguments[0] is the source to be directly evaluated.
// b) its 'this' is the this binding seen by the code being
// directly evaluated (the globalObject).
// Notes:
// - The `optimizer` strings only lookup values on the `globalObject` and
// `moduleLexicals` objects by construct. Keywords like 'function' are
// reserved and cannot be used as a variable, so they are excluded from the
// optimizer. Furthermore to prevent shadowing 'eval', while a valid
// identifier, that name is also explicitly excluded.
// - when 'eval' is looked up in the `evalScope`, the powerful unsafe eval
// intrinsic is returned after automatically removing it from the
// `evalScope`. Any further reference to 'eval' in the evaluate string will
// get the tamed evaluator from the `globalObject`, if any.
// TODO https://github.com/endojs/endo/issues/816
// The optimizer currently runs under sloppy mode, and although we doubt that
// there is any vulnerability introduced just by running the optimizer
// sloppy, we are much more confident in the semantics of strict mode.
// The `evaluate` function can be and is reused across multiple evaluations.
// Since the optimizer should not be re-evaluated every time, it cannot be
// inside the `evaluate` closure. While we could potentially nest an
// intermediate layer of `() => {'use strict'; ${optimizers}; ...`, it
// doesn't seem worth the overhead and complexity.
const evaluateFactory= FERAL_FUNCTION( `
with (this.scopeTerminator) {
with (this.globalObject) {
with (this.moduleLexicals) {
with (this.evalScope) {
${globalObjectOptimizer }
${moduleLexicalOptimizer }
return function() {
'use strict';
return eval(arguments[0]);
};
}
}
}
}
`);
return apply(evaluateFactory, context, []);
};$h‍_once.makeEvaluate(makeEvaluate);
})()
,
// === functors[31] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let apply,freeze,strictScopeTerminator,createSloppyGlobalsScopeTerminator,makeEvalScopeKit,applyTransforms,mandatoryTransforms,makeEvaluate,assert;$h‍_imports([["./commons.js", [["apply", [$h‍_a => (apply = $h‍_a)]],["freeze", [$h‍_a => (freeze = $h‍_a)]]]],["./strict-scope-terminator.js", [["strictScopeTerminator", [$h‍_a => (strictScopeTerminator = $h‍_a)]]]],["./sloppy-globals-scope-terminator.js", [["createSloppyGlobalsScopeTerminator", [$h‍_a => (createSloppyGlobalsScopeTerminator = $h‍_a)]]]],["./eval-scope.js", [["makeEvalScopeKit", [$h‍_a => (makeEvalScopeKit = $h‍_a)]]]],["./transforms.js", [["applyTransforms", [$h‍_a => (applyTransforms = $h‍_a)]],["mandatoryTransforms", [$h‍_a => (mandatoryTransforms = $h‍_a)]]]],["./make-evaluate.js", [["makeEvaluate", [$h‍_a => (makeEvaluate = $h‍_a)]]]],["./error/assert.js", [["assert", [$h‍_a => (assert = $h‍_a)]]]]]);
const { Fail}= assert;
/**
* makeSafeEvaluator()
* Build the low-level operation used by all evaluators:
* eval(), Function(), Compartment.prototype.evaluate().
*
* @param {object} options
* @param {object} options.globalObject
* @param {object} [options.moduleLexicals]
* @param {Array<import('./lockdown.js').Transform>} [options.globalTransforms]
* @param {boolean} [options.sloppyGlobalsMode]
*/
const makeSafeEvaluator= ({
globalObject,
moduleLexicals= {},
globalTransforms= [],
sloppyGlobalsMode= false})=>
{
const scopeTerminator= sloppyGlobalsMode?
createSloppyGlobalsScopeTerminator(globalObject):
strictScopeTerminator;
const evalScopeKit= makeEvalScopeKit();
const { evalScope}= evalScopeKit;
const evaluateContext= freeze({
evalScope,
moduleLexicals,
globalObject,
scopeTerminator});
// Defer creating the actual evaluator to first use.
// Creating a compartment should be possible in no-eval environments
// It also allows more global constants to be captured by the optimizer
let evaluate;
const provideEvaluate= ()=> {
if( !evaluate) {
evaluate= makeEvaluate(evaluateContext);
}
};
/**
* @param {string} source
* @param {object} [options]
* @param {Array<import('./lockdown.js').Transform>} [options.localTransforms]
*/
const safeEvaluate= (source, options)=> {
const { localTransforms= []}= options|| {};
provideEvaluate();
// Execute the mandatory transforms last to ensure that any rewritten code
// meets those mandatory requirements.
source= applyTransforms(source, [
...localTransforms,
...globalTransforms,
mandatoryTransforms]);
let err;
try {
// Allow next reference to eval produce the unsafe FERAL_EVAL.
// eslint-disable-next-line @endo/no-polymorphic-call
evalScopeKit.allowNextEvalToBeUnsafe();
// Ensure that "this" resolves to the safe global.
return apply(evaluate, globalObject, [source]);
}catch( e) {
// stash the child-code error in hopes of debugging the internal failure
err= e;
throw e;
}finally {
const unsafeEvalWasStillExposed=( 'eval'in evalScope);
delete evalScope.eval;
if( unsafeEvalWasStillExposed) {
// Barring a defect in the SES shim, the evalScope should allow the
// powerful, unsafe `eval` to be used by `evaluate` exactly once, as the
// very first name that it attempts to access from the lexical scope.
// A defect in the SES shim could throw an exception after we set
// `evalScope.eval` and before `evaluate` calls `eval` internally.
// If we get here, SES is very broken.
// This condition is one where this vat is now hopelessly confused, and
// the vat as a whole should be aborted.
// No further code should run.
// All immediately reachable state should be abandoned.
// However, that is not yet possible, so we at least prevent further
// variable resolution via the scopeHandler, and throw an error with
// diagnostic info including the thrown error if any from evaluating the
// source code.
evalScopeKit.revoked= { err};
// TODO A GOOD PLACE TO PANIC(), i.e., kill the vat incarnation.
// See https://github.com/Agoric/SES-shim/issues/490
Fail `handler did not reset allowNextEvalToBeUnsafe ${err}`;
}
}
};
return { safeEvaluate};
};$h‍_once.makeSafeEvaluator(makeSafeEvaluator);
})()
,
// === functors[32] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let WeakSet,defineProperty,freeze,functionPrototype,functionToString,stringEndsWith,weaksetAdd,weaksetHas;$h‍_imports([["./commons.js", [["WeakSet", [$h‍_a => (WeakSet = $h‍_a)]],["defineProperty", [$h‍_a => (defineProperty = $h‍_a)]],["freeze", [$h‍_a => (freeze = $h‍_a)]],["functionPrototype", [$h‍_a => (functionPrototype = $h‍_a)]],["functionToString", [$h‍_a => (functionToString = $h‍_a)]],["stringEndsWith", [$h‍_a => (stringEndsWith = $h‍_a)]],["weaksetAdd", [$h‍_a => (weaksetAdd = $h‍_a)]],["weaksetHas", [$h‍_a => (weaksetHas = $h‍_a)]]]]]);
const nativeSuffix= ') { [native code] }';
// Note: Top level mutable state. Does not make anything worse, since the
// patching of `Function.prototype.toString` is also globally stateful. We
// use this top level state so that multiple calls to `tameFunctionToString` are
// idempotent, rather than creating redundant indirections.
let markVirtualizedNativeFunction;
/**
* Replace `Function.prototype.toString` with one that recognizes
* shimmed functions as honorary native functions.
*/
const tameFunctionToString= ()=> {
if( markVirtualizedNativeFunction=== undefined) {
const virtualizedNativeFunctions= new WeakSet();
const tamingMethods= {
toString() {
const str= functionToString(this);
if(
stringEndsWith(str, nativeSuffix)||
!weaksetHas(virtualizedNativeFunctions, this))
{
return str;
}
return `function ${this.name}() { [native code] }`;
}};
defineProperty(functionPrototype, 'toString', {
value: tamingMethods.toString});
markVirtualizedNativeFunction= freeze((func)=>
weaksetAdd(virtualizedNativeFunctions, func));
}
return markVirtualizedNativeFunction;
};$h‍_once.tameFunctionToString(tameFunctionToString);
})()
,
// === functors[33] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let TypeError,globalThis,getOwnPropertyDescriptor,defineProperty;$h‍_imports([["./commons.js", [["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["globalThis", [$h‍_a => (globalThis = $h‍_a)]],["getOwnPropertyDescriptor", [$h‍_a => (getOwnPropertyDescriptor = $h‍_a)]],["defineProperty", [$h‍_a => (defineProperty = $h‍_a)]]]]]);Object.defineProperty(tameDomains, 'name', {value: "tameDomains"});$h‍_once.tameDomains(tameDomains);
function tameDomains(domainTaming= 'safe') {
if( domainTaming!== 'safe'&& domainTaming!== 'unsafe') {
throw TypeError( `unrecognized domainTaming ${domainTaming}`);
}
if( domainTaming=== 'unsafe') {
return;
}
// Protect against the hazard presented by Node.js domains.
const globalProcess= globalThis.process|| undefined;
if( typeof globalProcess=== 'object') {
// Check whether domains were initialized.
const domainDescriptor= getOwnPropertyDescriptor(globalProcess, 'domain');
if( domainDescriptor!== undefined&& domainDescriptor.get!== undefined) {
// The domain descriptor on Node.js initially has value: null, which
// becomes a get, set pair after domains initialize.
// See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_NO_DOMAINS.md
throw TypeError(
`SES failed to lockdown, Node.js domains have been initialized (SES_NO_DOMAINS)`);
}
// Prevent domains from initializing.
// This is clunky because the exception thrown from the domains package does
// not direct the user's gaze toward a knowledge base about the problem.
// The domain module merely throws an exception when it attempts to define
// the domain property of the process global during its initialization.
// We have no better recourse because Node.js uses defineProperty too.
defineProperty(globalProcess, 'domain', {
value: null,
configurable: false,
writable: false,
enumerable: false});
}
}
})()
,
// === functors[34] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let WeakSet,arrayFilter,arrayFlatMap,arrayMap,arrayPop,arrayPush,defineProperty,freeze,fromEntries,isError,stringEndsWith,stringIncludes,stringSplit,weaksetAdd,weaksetHas;$h‍_imports([["../commons.js", [["WeakSet", [$h‍_a => (WeakSet = $h‍_a)]],["arrayFilter", [$h‍_a => (arrayFilter = $h‍_a)]],["arrayFlatMap", [$h‍_a => (arrayFlatMap = $h‍_a)]],["arrayMap", [$h‍_a => (arrayMap = $h‍_a)]],["arrayPop", [$h‍_a => (arrayPop = $h‍_a)]],["arrayPush", [$h‍_a => (arrayPush = $h‍_a)]],["defineProperty", [$h‍_a => (defineProperty = $h‍_a)]],["freeze", [$h‍_a => (freeze = $h‍_a)]],["fromEntries", [$h‍_a => (fromEntries = $h‍_a)]],["isError", [$h‍_a => (isError = $h‍_a)]],["stringEndsWith", [$h‍_a => (stringEndsWith = $h‍_a)]],["stringIncludes", [$h‍_a => (stringIncludes = $h‍_a)]],["stringSplit", [$h‍_a => (stringSplit = $h‍_a)]],["weaksetAdd", [$h‍_a => (weaksetAdd = $h‍_a)]],["weaksetHas", [$h‍_a => (weaksetHas = $h‍_a)]]]],["./types.js", []],["./internal-types.js", []]]);
// For our internal debugging purposes, uncomment
// const internalDebugConsole = console;
// The whitelists of console methods, from:
// Whatwg "living standard" https://console.spec.whatwg.org/
// Node https://nodejs.org/dist/latest-v14.x/docs/api/console.html
// MDN https://developer.mozilla.org/en-US/docs/Web/API/Console_API
// TypeScript https://openstapps.gitlab.io/projectmanagement/interfaces/_node_modules__types_node_globals_d_.console.html
// Chrome https://developers.google.com/web/tools/chrome-devtools/console/api
// All console level methods have parameters (fmt?, ...args)
// where the argument sequence `fmt?, ...args` formats args according to
// fmt if fmt is a format string. Otherwise, it just renders them all as values
// separated by spaces.
// https://console.spec.whatwg.org/#formatter
// https://nodejs.org/docs/latest/api/util.html#util_util_format_format_args
// For the causal console, all occurrences of `fmt, ...args` or `...args` by
// itself must check for the presence of an error to ask the
// `loggedErrorHandler` to handle.
// In theory we should do a deep inspection to detect for example an array
// containing an error. We currently do not detect these and may never.
/** @typedef {keyof VirtualConsole | 'profile' | 'profileEnd'} ConsoleProps */
/**
* Those console methods whose actual parameters are `(fmt?, ...args)`
* even if their TypeScript types claim otherwise.
*
* Each is paired with what we consider to be their log severity level.
* This is the same as the log severity of these on other
* platform console implementations when they all agree.
*
* @type {readonly [ConsoleProps, LogSeverity | undefined][]}
*/
const consoleLevelMethods= freeze([
['debug', 'debug'], // (fmt?, ...args) verbose level on Chrome
['log', 'log'], // (fmt?, ...args) info level on Chrome
['info', 'info'], // (fmt?, ...args)
['warn', 'warn'], // (fmt?, ...args)
['error', 'error'], // (fmt?, ...args)
['trace', 'log'], // (fmt?, ...args)
['dirxml', 'log'], // (fmt?, ...args) but TS typed (...data)
['group', 'log'], // (fmt?, ...args) but TS typed (...label)
['groupCollapsed', 'log'] // (fmt?, ...args) but TS typed (...label)
]);
/**
* Those console methods other than those already enumerated by
* `consoleLevelMethods`.
*
* Each is paired with what we consider to be their log severity level.
* This is the same as the log severity of these on other
* platform console implementations when they all agree.
*
* @type {readonly [ConsoleProps, LogSeverity | undefined][]}
*/$h‍_once.consoleLevelMethods(consoleLevelMethods);
const consoleOtherMethods= freeze([
['assert', 'error'], // (value, fmt?, ...args)
['timeLog', 'log'], // (label?, ...args) no fmt string
// Insensitive to whether any argument is an error. All arguments can pass
// thru to baseConsole as is.
['clear', undefined], // ()
['count', 'info'], // (label?)
['countReset', undefined], // (label?)
['dir', 'log'], // (item, options?)
['groupEnd', 'log'], // ()
// In theory tabular data may be or contain an error. However, we currently
// do not detect these and may never.
['table', 'log'], // (tabularData, properties?)
['time', 'info'], // (label?)
['timeEnd', 'info'], // (label?)
// Node Inspector only, MDN, and TypeScript, but not whatwg
['profile', undefined], // (label?)
['profileEnd', undefined], // (label?)
['timeStamp', undefined] // (label?)
]);
/** @type {readonly [ConsoleProps, LogSeverity | undefined][]} */$h‍_once.consoleOtherMethods(consoleOtherMethods);
const consoleWhitelist= freeze([
...consoleLevelMethods,
...consoleOtherMethods]);
/**
* consoleOmittedProperties is currently unused. I record and maintain it here
* with the intention that it be treated like the `false` entries in the main
* SES whitelist: that seeing these on the original console is expected, but
* seeing anything else that's outside the whitelist is surprising and should
* provide a diagnostic.
*
* const consoleOmittedProperties = freeze([
* 'memory', // Chrome
* 'exception', // FF, MDN
* '_ignoreErrors', // Node
* '_stderr', // Node
* '_stderrErrorHandler', // Node
* '_stdout', // Node
* '_stdoutErrorHandler', // Node
* '_times', // Node
* 'context', // Chrome, Node
* 'record', // Safari
* 'recordEnd', // Safari
*
* 'screenshot', // Safari
* // Symbols
* '@@toStringTag', // Chrome: "Object", Safari: "Console"
* // A variety of other symbols also seen on Node
* ]);
*/
// //////////////////////////// Logging Console ////////////////////////////////
/** @type {MakeLoggingConsoleKit} */
const makeLoggingConsoleKit= (
loggedErrorHandler,
{ shouldResetForDebugging= false}= {})=>
{
if( shouldResetForDebugging) {
// eslint-disable-next-line @endo/no-polymorphic-call
loggedErrorHandler.resetErrorTagNum();
}
// Not frozen!
let logArray= [];
const loggingConsole= fromEntries(
arrayMap(consoleWhitelist, ([name, _])=> {
// Use an arrow function so that it doesn't come with its own name in
// its printed form. Instead, we're hoping that tooling uses only
// the `.name` property set below.
/**
* @param {...any} args
*/
const method= (...args)=> {
arrayPush(logArray, [name, ...args]);
};
defineProperty(method, 'name', { value: name});
return [name, freeze(method)];
}));
freeze(loggingConsole);
const takeLog= ()=> {
const result= freeze(logArray);
logArray= [];
return result;
};
freeze(takeLog);
const typedLoggingConsole= /** @type {VirtualConsole} */ loggingConsole;
return freeze({ loggingConsole: typedLoggingConsole, takeLog});
};$h‍_once.makeLoggingConsoleKit(makeLoggingConsoleKit);
freeze(makeLoggingConsoleKit);
/**
* Makes the same calls on a `baseConsole` that were made on a
* `loggingConsole` to produce this `log`. In this way, a logging console
* can be used as a buffer to delay the application of these calls to a
* `baseConsole`.
*
* @param {LogRecord[]} log
* @param {VirtualConsole} baseConsole
*/
const pumpLogToConsole= (log, baseConsole)=> {
for( const [name, ...args]of log) {
// eslint-disable-next-line @endo/no-polymorphic-call
baseConsole[name](...args);
}
};
// //////////////////////////// Causal Console /////////////////////////////////
/** @type {ErrorInfo} */$h‍_once.pumpLogToConsole(pumpLogToConsole);
const ErrorInfo= {
NOTE: 'ERROR_NOTE:',
MESSAGE: 'ERROR_MESSAGE:',
CAUSE: 'cause:',
ERRORS: 'errors:'};
freeze(ErrorInfo);
/** @type {MakeCausalConsole} */
const makeCausalConsole= (baseConsole, loggedErrorHandler)=> {
if( !baseConsole) {
return undefined;
}
const { getStackString, tagError, takeMessageLogArgs, takeNoteLogArgsArray}=
loggedErrorHandler;
/**
* @param {ReadonlyArray<any>} logArgs
* @param {Array<any>} subErrorsSink
* @returns {any}
*/
const extractErrorArgs= (logArgs, subErrorsSink)=> {
const argTags= arrayMap(logArgs, (arg)=>{
if( isError(arg)) {
arrayPush(subErrorsSink, arg);
return `(${tagError(arg)})`;
}
return arg;
});
return argTags;
};
/**
* @param {LogSeverity} severity
* @param {Error} error
* @param {ErrorInfoKind} kind
* @param {readonly any[]} logArgs
* @param {Array<Error>} subErrorsSink
*/
const logErrorInfo= (severity, error, kind, logArgs, subErrorsSink)=> {
const errorTag= tagError(error);
const errorName=
kind=== ErrorInfo.MESSAGE? `${errorTag}:`: `${errorTag} ${kind}`;
const argTags= extractErrorArgs(logArgs, subErrorsSink);
// eslint-disable-next-line @endo/no-polymorphic-call
baseConsole[severity](errorName, ...argTags);
};
/**
* Logs the `subErrors` within a group name mentioning `optTag`.
*
* @param {LogSeverity} severity
* @param {Error[]} subErrors
* @param {string | undefined} optTag
* @returns {void}
*/
const logSubErrors= (severity, subErrors, optTag= undefined)=> {
if( subErrors.length=== 0) {
return;
}
if( subErrors.length=== 1&& optTag=== undefined) {
// eslint-disable-next-line no-use-before-define
logError(severity, subErrors[0]);
return;
}
let label;
if( subErrors.length=== 1) {
label= `Nested error`;
}else {
label= `Nested ${subErrors.length} errors`;
}
if( optTag!== undefined) {
label= `${label} under ${optTag}`;
}
// eslint-disable-next-line @endo/no-polymorphic-call
baseConsole.group(label);
try {
for( const subError of subErrors) {
// eslint-disable-next-line no-use-before-define
logError(severity, subError);
}
}finally {
// eslint-disable-next-line @endo/no-polymorphic-call
baseConsole.groupEnd();
}
};
const errorsLogged= new WeakSet();
/** @type {(severity: LogSeverity) => NoteCallback} */
const makeNoteCallback= (severity)=>(error, noteLogArgs)=> {
const subErrors= [];
// Annotation arrived after the error has already been logged,
// so just log the annotation immediately, rather than remembering it.
logErrorInfo(severity, error, ErrorInfo.NOTE, noteLogArgs, subErrors);
logSubErrors(severity, subErrors, tagError(error));
};
/**
* @param {LogSeverity} severity
* @param {Error} error
*/
const logError= (severity, error)=> {
if( weaksetHas(errorsLogged, error)) {
return;
}
const errorTag= tagError(error);
weaksetAdd(errorsLogged, error);
const subErrors= [];
const messageLogArgs= takeMessageLogArgs(error);
const noteLogArgsArray= takeNoteLogArgsArray(
error,
makeNoteCallback(severity));
// Show the error's most informative error message
if( messageLogArgs=== undefined) {
// If there is no message log args, then just show the message that
// the error itself carries.
// eslint-disable-next-line @endo/no-polymorphic-call
baseConsole[severity]( `${errorTag}:`,error.message);
}else {
// If there is one, we take it to be strictly more informative than the
// message string carried by the error, so show it *instead*.
logErrorInfo(
severity,
error,
ErrorInfo.MESSAGE,
messageLogArgs,
subErrors);
}
// After the message but before any other annotations, show the stack.
let stackString= getStackString(error);
if(
typeof stackString=== 'string'&&
stackString.length>= 1&&
!stringEndsWith(stackString, '\n'))
{
stackString+= '\n';
}
// eslint-disable-next-line @endo/no-polymorphic-call
baseConsole[severity](stackString);
// Show the other annotations on error
if( error.cause) {
logErrorInfo(severity, error, ErrorInfo.CAUSE, [error.cause], subErrors);
}
// @ts-expect-error AggregateError has an `errors` property.
if( error.errors) {
// @ts-expect-error AggregateError has an `errors` property.
logErrorInfo(severity, error, ErrorInfo.ERRORS, error.errors, subErrors);
}
for( const noteLogArgs of noteLogArgsArray) {
logErrorInfo(severity, error, ErrorInfo.NOTE, noteLogArgs, subErrors);
}
// explain all the errors seen in the messages already emitted.
logSubErrors(severity, subErrors, errorTag);
};
const levelMethods= arrayMap(consoleLevelMethods, ([level, _])=> {
/**
* @param {...any} logArgs
*/
const levelMethod= (...logArgs)=> {
const subErrors= [];
const argTags= extractErrorArgs(logArgs, subErrors);
// eslint-disable-next-line @endo/no-polymorphic-call
baseConsole[level](...argTags);
// @ts-expect-error ConsoleProp vs LogSeverity mismatch
logSubErrors(level, subErrors);
};
defineProperty(levelMethod, 'name', { value: level});
return [level, freeze(levelMethod)];
});
const otherMethodNames= arrayFilter(
consoleOtherMethods,
([name, _])=> name in baseConsole);
const otherMethods= arrayMap(otherMethodNames, ([name, _])=> {
/**
* @param {...any} args
*/
const otherMethod= (...args)=> {
// @ts-ignore
// eslint-disable-next-line @endo/no-polymorphic-call
baseConsole[name](...args);
return undefined;
};
defineProperty(otherMethod, 'name', { value: name});
return [name, freeze(otherMethod)];
});
const causalConsole= fromEntries([...levelMethods, ...otherMethods]);
return (/** @type {VirtualConsole} */ freeze(causalConsole));
};$h‍_once.makeCausalConsole(makeCausalConsole);
freeze(makeCausalConsole);
/**
* @typedef {(...args: unknown[]) => void} Logger
*/
/**
* This is a rather horrible kludge to indent the output to a logger in
* the case where some arguments are strings containing newlines. Part of
* the problem is that console-like loggers, including the one in ava,
* join the string arguments of the log message with a space.
* Because of this, there's an extra space at the beginning of each of
* the split lines. So this kludge compensated by putting an extra empty
* string at the beginning, so that the logger will add the same extra
* joiner.
* TODO: Fix this horrible kludge, and indent in a sane manner.
*
* @param {string} str
* @param {string} sep
* @param {string[]} indents
* @returns {string[]}
*/
const indentAfterAllSeps= (str, sep, indents)=> {
const [firstLine, ...restLines]= stringSplit(str, sep);
const indentedRest= arrayFlatMap(restLines, (line)=>[sep, ...indents, line]);
return ['', firstLine, ...indentedRest];
};
/**
* @param {LoggedErrorHandler} loggedErrorHandler
*/
const defineCausalConsoleFromLogger= (loggedErrorHandler)=>{
/**
* Implement the `VirtualConsole` API badly by turning all calls into
* calls on `tlogger`. We need to do this to have `console` logging
* turn into calls to Ava's `t.log`, so these console log messages
* are output in the right place.
*
* @param {Logger} tlogger
* @returns {VirtualConsole}
*/
const makeCausalConsoleFromLogger= (tlogger)=>{
const indents= [];
const logWithIndent= (...args)=> {
if( indents.length> 0) {
args= arrayFlatMap(args, (arg)=>
typeof arg=== 'string'&& stringIncludes(arg, '\n')?
indentAfterAllSeps(arg, '\n', indents):
[arg]);
args= [...indents, ...args];
}
return tlogger(...args);
};
const makeNamed= (name, fn)=>
({ [name]: (...args)=> fn(...args)})[ name];
const baseConsole= fromEntries([
...arrayMap(consoleLevelMethods, ([name])=> [
name,
makeNamed(name, logWithIndent)]),
...arrayMap(consoleOtherMethods, ([name])=> [
name,
makeNamed(name, (...args)=> logWithIndent(name, ...args))])]);
// https://console.spec.whatwg.org/#grouping
for( const name of ['group', 'groupCollapsed']) {
if( baseConsole[name]) {
baseConsole[name]= makeNamed(name, (...args)=> {
if( args.length>= 1) {
// Prefix the logged data with "group" or "groupCollapsed".
logWithIndent(...args);
}
// A single space is enough;
// the host console will separate them with additional spaces.
arrayPush(indents, ' ');
});
}
}
if( baseConsole.groupEnd) {
baseConsole.groupEnd= makeNamed('groupEnd', (...args)=> {
arrayPop(indents);
});
}
harden(baseConsole);
const causalConsole= makeCausalConsole(
/** @type {VirtualConsole} */ baseConsole,
loggedErrorHandler);
return (/** @type {VirtualConsole} */ causalConsole);
};
return freeze(makeCausalConsoleFromLogger);
};$h‍_once.defineCausalConsoleFromLogger(defineCausalConsoleFromLogger);
freeze(defineCausalConsoleFromLogger);
// ///////////////////////// Filter Console ////////////////////////////////////
/** @type {FilterConsole} */
const filterConsole= (baseConsole, filter, _topic= undefined)=> {
// TODO do something with optional topic string
const whitelist= arrayFilter(
consoleWhitelist,
([name, _])=> name in baseConsole);
const methods= arrayMap(whitelist, ([name, severity])=> {
/**
* @param {...any} args
*/
const method= (...args)=> {
// eslint-disable-next-line @endo/no-polymorphic-call
if( severity=== undefined|| filter.canLog(severity)) {
// @ts-ignore
// eslint-disable-next-line @endo/no-polymorphic-call
baseConsole[name](...args);
}
};
return [name, freeze(method)];
});
const filteringConsole= fromEntries(methods);
return (/** @type {VirtualConsole} */ freeze(filteringConsole));
};$h‍_once.filterConsole(filterConsole);
freeze(filterConsole);
})()
,
// === functors[35] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let FinalizationRegistry,Map,mapGet,mapDelete,WeakMap,mapSet,finalizationRegistryRegister,weakmapSet,weakmapGet,mapEntries,mapHas;$h‍_imports([["../commons.js", [["FinalizationRegistry", [$h‍_a => (FinalizationRegistry = $h‍_a)]],["Map", [$h‍_a => (Map = $h‍_a)]],["mapGet", [$h‍_a => (mapGet = $h‍_a)]],["mapDelete", [$h‍_a => (mapDelete = $h‍_a)]],["WeakMap", [$h‍_a => (WeakMap = $h‍_a)]],["mapSet", [$h‍_a => (mapSet = $h‍_a)]],["finalizationRegistryRegister", [$h‍_a => (finalizationRegistryRegister = $h‍_a)]],["weakmapSet", [$h‍_a => (weakmapSet = $h‍_a)]],["weakmapGet", [$h‍_a => (weakmapGet = $h‍_a)]],["mapEntries", [$h‍_a => (mapEntries = $h‍_a)]],["mapHas", [$h‍_a => (mapHas = $h‍_a)]]]]]);
/**
* Create rejection-tracking machinery compatible with Node.js and browsers.
*
* Note that modern browsers *prevent* access to the 'unhandledrejection' and
* 'rejectionhandled' events needed:
* - in cross-origin mode, like when served from file://
* - in the browser console (interactively typed-in code)
* - in the debugger
*
* Then, they just look like: `Uncaught (in promise) Error: ...` and don't
* implement the machinery.
*
* The solution is to serve your web page from an http:// or https:// web server
* and execute actual code.
*
* @param {(reason: unknown) => void} reportReason report the reason for an
* unhandled rejection.
*/
const makeRejectionHandlers= (reportReason)=>{
if( FinalizationRegistry=== undefined) {
return undefined;
}
/** @typedef {number} ReasonId */
let lastReasonId= 0;
/** @type {Map<ReasonId, unknown>} */
const idToReason= new Map();
/** @type {(() => void) | undefined} */
let cancelChecking;
const removeReasonId= (reasonId)=>{
mapDelete(idToReason, reasonId);
if( cancelChecking&& idToReason.size=== 0) {
// No more unhandled rejections to check, just cancel the check.
cancelChecking();
cancelChecking= undefined;
}
};
/** @type {WeakMap<Promise, ReasonId>} */
const promiseToReasonId= new WeakMap();
/**
* Clean up and report the reason for a GCed unhandled rejection.
*
* @param {ReasonId} heldReasonId
*/
const finalizeDroppedPromise= (heldReasonId)=>{
if( mapHas(idToReason, heldReasonId)) {
const reason= mapGet(idToReason, heldReasonId);
removeReasonId(heldReasonId);
reportReason(reason);
}
};
/** @type {FinalizationRegistry<ReasonId>} */
const promiseToReason= new FinalizationRegistry(finalizeDroppedPromise);
/**
* Track a rejected promise and its corresponding reason if there is no
* rejection handler synchronously attached.
*
* @param {unknown} reason
* @param {Promise} pr
*/
const unhandledRejectionHandler= (reason, pr)=> {
lastReasonId+= 1;
const reasonId= lastReasonId;
// Update bookkeeping.
mapSet(idToReason, reasonId, reason);
weakmapSet(promiseToReasonId, pr, reasonId);
finalizationRegistryRegister(promiseToReason, pr, reasonId, pr);
};
/**
* Deal with the addition of a handler to a previously rejected promise.
*
* Just remove it from our list. Let the FinalizationRegistry or
* processTermination report any GCed unhandled rejected promises.
*
* @param {Promise} pr
*/
const rejectionHandledHandler= (pr)=>{
const reasonId= weakmapGet(promiseToReasonId, pr);
removeReasonId(reasonId);
};
/**
* Report all the unhandled rejections, now that we are abruptly terminating
* the agent cluster.
*/
const processTerminationHandler= ()=> {
for( const [reasonId, reason]of mapEntries(idToReason)) {
removeReasonId(reasonId);
reportReason(reason);
}
};
return {
rejectionHandledHandler,
unhandledRejectionHandler,
processTerminationHandler};
};$h‍_once.makeRejectionHandlers(makeRejectionHandlers);
})()
,
// === functors[36] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let TypeError,apply,defineProperty,freeze,globalThis,defaultHandler,makeCausalConsole,makeRejectionHandlers;$h‍_imports([["../commons.js", [["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["apply", [$h‍_a => (apply = $h‍_a)]],["defineProperty", [$h‍_a => (defineProperty = $h‍_a)]],["freeze", [$h‍_a => (freeze = $h‍_a)]],["globalThis", [$h‍_a => (globalThis = $h‍_a)]]]],["./assert.js", [["loggedErrorHandler", [$h‍_a => (defaultHandler = $h‍_a)]]]],["./console.js", [["makeCausalConsole", [$h‍_a => (makeCausalConsole = $h‍_a)]]]],["./unhandled-rejection.js", [["makeRejectionHandlers", [$h‍_a => (makeRejectionHandlers = $h‍_a)]]]],["./types.js", []],["./internal-types.js", []]]);
const failFast= (message)=>{
throw TypeError(message);
};
const wrapLogger= (logger, thisArg)=>
freeze((...args)=> apply(logger, thisArg, args));
/**
* Wrap console unless suppressed.
* At the moment, the console is considered a host power in the start
* compartment, and not a primordial. Hence it is absent from the whilelist
* and bypasses the intrinsicsCollector.
*
* @param {"safe" | "unsafe"} consoleTaming
* @param {"platform" | "exit" | "abort" | "report" | "none"} [errorTrapping]
* @param {"report" | "none"} [unhandledRejectionTrapping]
* @param {GetStackString=} optGetStackString
*/
const tameConsole= (
consoleTaming= 'safe',
errorTrapping= 'platform',
unhandledRejectionTrapping= 'report',
optGetStackString= undefined)=>
{
consoleTaming=== 'safe'||
consoleTaming=== 'unsafe'||
failFast( `unrecognized consoleTaming ${consoleTaming}`);
let loggedErrorHandler;
if( optGetStackString=== undefined) {
loggedErrorHandler= defaultHandler;
}else {
loggedErrorHandler= {
...defaultHandler,
getStackString: optGetStackString};
}
// eslint-disable-next-line no-restricted-globals
const originalConsole= /** @type {VirtualConsole} */
// eslint-disable-next-line no-nested-ternary
typeof globalThis.console!== 'undefined'?
globalThis.console:
typeof globalThis.print=== 'function'?
// Make a good-enough console for eshost (including only functions that
// log at a specific level with no special argument interpretation).
// https://console.spec.whatwg.org/#logging
((p)=>freeze({ debug: p, log: p, info: p, warn: p, error: p}))(
// eslint-disable-next-line no-undef
wrapLogger(globalThis.print)):
undefined;
// Upgrade a log-only console (as in `eshost -h SpiderMonkey`).
if( originalConsole&& originalConsole.log) {
for( const methodName of ['warn', 'error']) {
if( !originalConsole[methodName]) {
defineProperty(originalConsole, methodName, {
value: wrapLogger(originalConsole.log, originalConsole)});
}
}
}
const ourConsole= /** @type {VirtualConsole} */
consoleTaming=== 'unsafe'?
originalConsole:
makeCausalConsole(originalConsole, loggedErrorHandler);
// Attach platform-specific error traps such that any error that gets thrown
// at top-of-turn (the bottom of stack) will get logged by our causal
// console, revealing the diagnostic information associated with the error,
// including the stack from when the error was created.
// In the following Node.js and web browser cases, `process` and `window` are
// spelled as `globalThis` properties to avoid the overweaning gaze of
// Parcel, which dutifully installs an unnecessary `process` shim if we ever
// utter that. That unnecessary shim forces the whole bundle into sloppy mode,
// which in turn breaks SES's strict mode invariant.
// Disable the polymorphic check for the rest of this file. It's too noisy
// when dealing with platform APIs.
/* eslint-disable @endo/no-polymorphic-call */
// Node.js
const globalProcess= globalThis.process|| undefined;
if(
errorTrapping!== 'none'&&
typeof globalProcess=== 'object'&&
typeof globalProcess.on=== 'function')
{
let terminate;
if( errorTrapping=== 'platform'|| errorTrapping=== 'exit') {
const { exit}= globalProcess;
// If there is a function-valued process.on but no function-valued process.exit,
// fail early without caring whether errorTrapping is "platform" only by default.
typeof exit=== 'function'|| failFast('missing process.exit');
terminate= ()=> exit(globalProcess.exitCode|| -1);
}else if( errorTrapping=== 'abort') {
terminate= globalProcess.abort;
typeof terminate=== 'function'|| failFast('missing process.abort');
}
globalProcess.on('uncaughtException', (error)=>{
// See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_UNCAUGHT_EXCEPTION.md
ourConsole.error('SES_UNCAUGHT_EXCEPTION:', error);
if( terminate) {
terminate();
}
});
}
if(
unhandledRejectionTrapping!== 'none'&&
typeof globalProcess=== 'object'&&
typeof globalProcess.on=== 'function')
{
const handleRejection= (reason)=>{
// See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_UNHANDLED_REJECTION.md
ourConsole.error('SES_UNHANDLED_REJECTION:', reason);
// 'platform' and 'report' just log the reason.
};
// Maybe track unhandled promise rejections.
const h= makeRejectionHandlers(handleRejection);
if( h) {
// Rejection handlers are supported.
globalProcess.on('unhandledRejection', h.unhandledRejectionHandler);
globalProcess.on('rejectionHandled', h.rejectionHandledHandler);
globalProcess.on('exit', h.processTerminationHandler);
}
}
// Browser
const globalWindow= globalThis.window|| undefined;
if(
errorTrapping!== 'none'&&
typeof globalWindow=== 'object'&&
typeof globalWindow.addEventListener=== 'function')
{
globalWindow.addEventListener('error', (event)=>{
event.preventDefault();
// See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_UNCAUGHT_EXCEPTION.md
ourConsole.error('SES_UNCAUGHT_EXCEPTION:', event.error);
// 'platform' and 'report' just log the reason.
if( errorTrapping=== 'exit'|| errorTrapping=== 'abort') {
globalWindow.location.href= `about:blank`;
}
});
}
if(
unhandledRejectionTrapping!== 'none'&&
typeof globalWindow=== 'object'&&
typeof globalWindow.addEventListener=== 'function')
{
const handleRejection= (reason)=>{
// See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_UNHANDLED_REJECTION.md
ourConsole.error('SES_UNHANDLED_REJECTION:', reason);
};
const h= makeRejectionHandlers(handleRejection);
if( h) {
// Rejection handlers are supported.
globalWindow.addEventListener('unhandledrejection', (event)=>{
event.preventDefault();
h.unhandledRejectionHandler(event.reason, event.promise);
});
globalWindow.addEventListener('rejectionhandled', (event)=>{
event.preventDefault();
h.rejectionHandledHandler(event.promise);
});
globalWindow.addEventListener('beforeunload', (_event)=>{
h.processTerminationHandler();
});
}
}
/* eslint-enable @endo/no-polymorphic-call */
return { console: ourConsole};
};$h‍_once.tameConsole(tameConsole);
})()
,
// === functors[37] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let WeakMap,WeakSet,apply,arrayFilter,arrayJoin,arrayMap,arraySlice,create,defineProperties,fromEntries,reflectSet,regexpExec,regexpTest,weakmapGet,weakmapSet,weaksetAdd,weaksetHas,TypeError;$h‍_imports([["../commons.js", [["WeakMap", [$h‍_a => (WeakMap = $h‍_a)]],["WeakSet", [$h‍_a => (WeakSet = $h‍_a)]],["apply", [$h‍_a => (apply = $h‍_a)]],["arrayFilter", [$h‍_a => (arrayFilter = $h‍_a)]],["arrayJoin", [$h‍_a => (arrayJoin = $h‍_a)]],["arrayMap", [$h‍_a => (arrayMap = $h‍_a)]],["arraySlice", [$h‍_a => (arraySlice = $h‍_a)]],["create", [$h‍_a => (create = $h‍_a)]],["defineProperties", [$h‍_a => (defineProperties = $h‍_a)]],["fromEntries", [$h‍_a => (fromEntries = $h‍_a)]],["reflectSet", [$h‍_a => (reflectSet = $h‍_a)]],["regexpExec", [$h‍_a => (regexpExec = $h‍_a)]],["regexpTest", [$h‍_a => (regexpTest = $h‍_a)]],["weakmapGet", [$h‍_a => (weakmapGet = $h‍_a)]],["weakmapSet", [$h‍_a => (weakmapSet = $h‍_a)]],["weaksetAdd", [$h‍_a => (weaksetAdd = $h‍_a)]],["weaksetHas", [$h‍_a => (weaksetHas = $h‍_a)]],["TypeError", [$h‍_a => (TypeError = $h‍_a)]]]]]);
// Whitelist names from https://v8.dev/docs/stack-trace-api
// Whitelisting only the names used by error-stack-shim/src/v8StackFrames
// callSiteToFrame to shim the error stack proposal.
const safeV8CallSiteMethodNames= [
// suppress 'getThis' definitely
'getTypeName',
// suppress 'getFunction' definitely
'getFunctionName',
'getMethodName',
'getFileName',
'getLineNumber',
'getColumnNumber',
'getEvalOrigin',
'isToplevel',
'isEval',
'isNative',
'isConstructor',
'isAsync',
// suppress 'isPromiseAll' for now
// suppress 'getPromiseIndex' for now
// Additional names found by experiment, absent from
// https://v8.dev/docs/stack-trace-api
'getPosition',
'getScriptNameOrSourceURL',
'toString' // TODO replace to use only whitelisted info
];
// TODO this is a ridiculously expensive way to attenuate callsites.
// Before that matters, we should switch to a reasonable representation.
const safeV8CallSiteFacet= (callSite)=>{
const methodEntry= (name)=>{
const method= callSite[name];
return [name, ()=> apply(method, callSite, [])];
};
const o= fromEntries(arrayMap(safeV8CallSiteMethodNames, methodEntry));
return create(o, {});
};
const safeV8SST= (sst)=>arrayMap(sst, safeV8CallSiteFacet);
// If it has `/node_modules/` anywhere in it, on Node it is likely
// to be a dependent package of the current package, and so to
// be an infrastructure frame to be dropped from concise stack traces.
const FILENAME_NODE_DEPENDENTS_CENSOR= /\/node_modules\//;
// If it begins with `internal/` or `node:internal` then it is likely
// part of the node infrustructre itself, to be dropped from concise
// stack traces.
const FILENAME_NODE_INTERNALS_CENSOR= /^(?:node:)?internal\//;
// Frames within the `assert.js` package should be dropped from
// concise stack traces, as these are just steps towards creating the
// error object in question.
const FILENAME_ASSERT_CENSOR= /\/packages\/ses\/src\/error\/assert.js$/;
// Frames within the `eventual-send` shim should be dropped so that concise
// deep stacks omit the internals of the eventual-sending mechanism causing
// asynchronous messages to be sent.
// Note that the eventual-send package will move from agoric-sdk to
// Endo, so this rule will be of general interest.
const FILENAME_EVENTUAL_SEND_CENSOR= /\/packages\/eventual-send\/src\//;
// Any stack frame whose `fileName` matches any of these censor patterns
// will be omitted from concise stacks.
// TODO Enable users to configure FILENAME_CENSORS via `lockdown` options.
const FILENAME_CENSORS= [
FILENAME_NODE_DEPENDENTS_CENSOR,
FILENAME_NODE_INTERNALS_CENSOR,
FILENAME_ASSERT_CENSOR,
FILENAME_EVENTUAL_SEND_CENSOR];
// Should a stack frame with this as its fileName be included in a concise
// stack trace?
// Exported only so it can be unit tested.
// TODO Move so that it applies not just to v8.
const filterFileName= (fileName)=>{
if( !fileName) {
// Stack frames with no fileName should appear in concise stack traces.
return true;
}
for( const filter of FILENAME_CENSORS) {
if( regexpTest(filter, fileName)) {
return false;
}
}
return true;
};
// The ad-hoc rule of the current pattern is that any likely-file-path or
// likely url-path prefix, ending in a `/.../` should get dropped.
// Anything to the left of the likely path text is kept.
// Everything to the right of `/.../` is kept. Thus
// `'Object.bar (/vat-v1/.../eventual-send/test/test-deep-send.js:13:21)'`
// simplifies to
// `'Object.bar (eventual-send/test/test-deep-send.js:13:21)'`.
//
// See thread starting at
// https://github.com/Agoric/agoric-sdk/issues/2326#issuecomment-773020389
$h‍_once.filterFileName(filterFileName);const CALLSITE_ELLIPSES_PATTERN=/^((?:.*[( ])?)[:/\w_-]*\/\.\.\.\/(.+)$/;
// The ad-hoc rule of the current pattern is that any likely-file-path or
// likely url-path prefix, ending in a `/` and prior to `package/` should get
// dropped.
// Anything to the left of the likely path prefix text is kept. `package/` and
// everything to its right is kept. Thus
// `'Object.bar (/Users/markmiller/src/ongithub/agoric/agoric-sdk/packages/eventual-send/test/test-deep-send.js:13:21)'`
// simplifies to
// `'Object.bar (packages/eventual-send/test/test-deep-send.js:13:21)'`.
// Note that `/packages/` is a convention for monorepos encouraged by
// lerna.
const CALLSITE_PACKAGES_PATTERN= /^((?:.*[( ])?)[:/\w_-]*\/(packages\/.+)$/;
// The use of these callSite patterns below assumes that any match will bind
// capture groups containing the parts of the original string we want
// to keep. The parts outside those capture groups will be dropped from concise
// stacks.
// TODO Enable users to configure CALLSITE_PATTERNS via `lockdown` options.
const CALLSITE_PATTERNS= [
CALLSITE_ELLIPSES_PATTERN,
CALLSITE_PACKAGES_PATTERN];
// For a stack frame that should be included in a concise stack trace, if
// `callSiteString` is the original stringified stack frame, return the
// possibly-shorter stringified stack frame that should be shown instead.
// Exported only so it can be unit tested.
// TODO Move so that it applies not just to v8.
const shortenCallSiteString= (callSiteString)=>{
for( const filter of CALLSITE_PATTERNS) {
const match= regexpExec(filter, callSiteString);
if( match) {
return arrayJoin(arraySlice(match, 1), '');
}
}
return callSiteString;
};$h‍_once.shortenCallSiteString(shortenCallSiteString);
const tameV8ErrorConstructor= (
OriginalError,
InitialError,
errorTaming,
stackFiltering)=>
{
if( errorTaming=== 'unsafe-debug') {
throw TypeError(
'internal: v8+unsafe-debug special case should already be done');
}
// TODO: Proper CallSite types
/** @typedef {{}} CallSite */
const originalCaptureStackTrace= OriginalError.captureStackTrace;
// const callSiteFilter = _callSite => true;
const callSiteFilter= (callSite)=>{
if( stackFiltering=== 'verbose') {
return true;
}
// eslint-disable-next-line @endo/no-polymorphic-call
return filterFileName(callSite.getFileName());
};
const callSiteStringifier= (callSite)=>{
let callSiteString= `${callSite}`;
if( stackFiltering=== 'concise') {
callSiteString= shortenCallSiteString(callSiteString);
}
return `\n at ${callSiteString}`;
};
const stackStringFromSST= (_error, sst)=>
arrayJoin(
arrayMap(arrayFilter(sst, callSiteFilter), callSiteStringifier),
'');
/**
* @typedef {object} StructuredStackInfo
* @property {CallSite[]} callSites
* @property {undefined} [stackString]
*/
/**
* @typedef {object} ParsedStackInfo
* @property {undefined} [callSites]
* @property {string} stackString
*/
// Mapping from error instance to the stack for that instance.
// The stack info is either the structured stack trace
// or the generated tamed stack string
/** @type {WeakMap<Error, ParsedStackInfo | StructuredStackInfo>} */
const stackInfos= new WeakMap();
// Use concise methods to obtain named functions without constructors.
const tamedMethods= {
// The optional `optFn` argument is for cutting off the bottom of
// the stack --- for capturing the stack only above the topmost
// call to that function. Since this isn't the "real" captureStackTrace
// but instead calls the real one, if no other cutoff is provided,
// we cut this one off.
captureStackTrace(error, optFn= tamedMethods.captureStackTrace) {
if( typeof originalCaptureStackTrace=== 'function') {
// OriginalError.captureStackTrace is only on v8
apply(originalCaptureStackTrace, OriginalError, [error, optFn]);
return;
}
reflectSet(error, 'stack', '');
},
// Shim of proposed special power, to reside by default only
// in the start compartment, for getting the stack traceback
// string associated with an error.
// See https://tc39.es/proposal-error-stacks/
getStackString(error) {
let stackInfo= weakmapGet(stackInfos, error);
if( stackInfo=== undefined) {
// The following will call `prepareStackTrace()` synchronously
// which will populate stackInfos
// eslint-disable-next-line no-void
void error.stack;
stackInfo= weakmapGet(stackInfos, error);
if( !stackInfo) {
stackInfo= { stackString: ''};
weakmapSet(stackInfos, error, stackInfo);
}
}
// prepareStackTrace() may generate the stackString
// if errorTaming === 'unsafe'
if( stackInfo.stackString!== undefined) {
return stackInfo.stackString;
}
const stackString= stackStringFromSST(error, stackInfo.callSites);
weakmapSet(stackInfos, error, { stackString});
return stackString;
},
prepareStackTrace(error, sst) {
if( errorTaming=== 'unsafe') {
const stackString= stackStringFromSST(error, sst);
weakmapSet(stackInfos, error, { stackString});
return `${error}${stackString}`;
}else {
weakmapSet(stackInfos, error, { callSites: sst});
return '';
}
}};
// A prepareFn is a prepareStackTrace function.
// An sst is a `structuredStackTrace`, which is an array of
// callsites.
// A user prepareFn is a prepareFn defined by a client of this API,
// and provided by assigning to `Error.prepareStackTrace`.
// A user prepareFn should only receive an attenuated sst, which
// is an array of attenuated callsites.
// A system prepareFn is the prepareFn created by this module to
// be installed on the real `Error` constructor, to receive
// an original sst, i.e., an array of unattenuated callsites.
// An input prepareFn is a function the user assigns to
// `Error.prepareStackTrace`, which might be a user prepareFn or
// a system prepareFn previously obtained by reading
// `Error.prepareStackTrace`.
const defaultPrepareFn= tamedMethods.prepareStackTrace;
OriginalError.prepareStackTrace= defaultPrepareFn;
// A weakset branding some functions as system prepareFns, all of which
// must be defined by this module, since they can receive an
// unattenuated sst.
const systemPrepareFnSet= new WeakSet([defaultPrepareFn]);
const systemPrepareFnFor= (inputPrepareFn)=>{
if( weaksetHas(systemPrepareFnSet, inputPrepareFn)) {
return inputPrepareFn;
}
// Use concise methods to obtain named functions without constructors.
const systemMethods= {
prepareStackTrace(error, sst) {
weakmapSet(stackInfos, error, { callSites: sst});
return inputPrepareFn(error, safeV8SST(sst));
}};
weaksetAdd(systemPrepareFnSet, systemMethods.prepareStackTrace);
return systemMethods.prepareStackTrace;
};
// Note `stackTraceLimit` accessor already defined by
// tame-error-constructor.js
defineProperties(InitialError, {
captureStackTrace: {
value: tamedMethods.captureStackTrace,
writable: true,
enumerable: false,
configurable: true},
prepareStackTrace: {
get() {
return OriginalError.prepareStackTrace;
},
set(inputPrepareStackTraceFn) {
if( typeof inputPrepareStackTraceFn=== 'function') {
const systemPrepareFn= systemPrepareFnFor(inputPrepareStackTraceFn);
OriginalError.prepareStackTrace= systemPrepareFn;
}else {
OriginalError.prepareStackTrace= defaultPrepareFn;
}
},
enumerable: false,
configurable: true}});
return tamedMethods.getStackString;
};$h‍_once.tameV8ErrorConstructor(tameV8ErrorConstructor);
})()
,
// === functors[38] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let FERAL_ERROR,TypeError,apply,construct,defineProperties,setPrototypeOf,getOwnPropertyDescriptor,defineProperty,getOwnPropertyDescriptors,NativeErrors,tameV8ErrorConstructor;$h‍_imports([["../commons.js", [["FERAL_ERROR", [$h‍_a => (FERAL_ERROR = $h‍_a)]],["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["apply", [$h‍_a => (apply = $h‍_a)]],["construct", [$h‍_a => (construct = $h‍_a)]],["defineProperties", [$h‍_a => (defineProperties = $h‍_a)]],["setPrototypeOf", [$h‍_a => (setPrototypeOf = $h‍_a)]],["getOwnPropertyDescriptor", [$h‍_a => (getOwnPropertyDescriptor = $h‍_a)]],["defineProperty", [$h‍_a => (defineProperty = $h‍_a)]],["getOwnPropertyDescriptors", [$h‍_a => (getOwnPropertyDescriptors = $h‍_a)]]]],["../permits.js", [["NativeErrors", [$h‍_a => (NativeErrors = $h‍_a)]]]],["./tame-v8-error-constructor.js", [["tameV8ErrorConstructor", [$h‍_a => (tameV8ErrorConstructor = $h‍_a)]]]]]);
// Present on at least FF and XS. Proposed by Error-proposal. The original
// is dangerous, so tameErrorConstructor replaces it with a safe one.
// We grab the original here before it gets replaced.
const stackDesc= getOwnPropertyDescriptor(FERAL_ERROR.prototype, 'stack');
const stackGetter= stackDesc&& stackDesc.get;
// Use concise methods to obtain named functions without constructors.
const tamedMethods= {
getStackString(error) {
if( typeof stackGetter=== 'function') {
return apply(stackGetter, error, []);
}else if( 'stack'in error) {
// The fallback is to just use the de facto `error.stack` if present
return `${error.stack}`;
}
return '';
}};
let initialGetStackString= tamedMethods.getStackString;
function tameErrorConstructor(
errorTaming= 'safe',
stackFiltering= 'concise')
{
if(
errorTaming!== 'safe'&&
errorTaming!== 'unsafe'&&
errorTaming!== 'unsafe-debug')
{
throw TypeError( `unrecognized errorTaming ${errorTaming}`);
}
if( stackFiltering!== 'concise'&& stackFiltering!== 'verbose') {
throw TypeError( `unrecognized stackFiltering ${stackFiltering}`);
}
const ErrorPrototype= FERAL_ERROR.prototype;
const { captureStackTrace: originalCaptureStackTrace}= FERAL_ERROR;
const platform=
typeof originalCaptureStackTrace=== 'function'? 'v8': 'unknown';
const makeErrorConstructor= (_= {})=> {
// eslint-disable-next-line no-shadow
const ResultError= function Error(...rest) {
let error;
if( new.target=== undefined) {
error= apply(FERAL_ERROR, this, rest);
}else {
error= construct(FERAL_ERROR, rest, new.target);
}
if( platform=== 'v8') {
// TODO Likely expensive!
apply(originalCaptureStackTrace, FERAL_ERROR, [error, ResultError]);
}
return error;
};
defineProperties(ResultError, {
length: { value: 1},
prototype: {
value: ErrorPrototype,
writable: false,
enumerable: false,
configurable: false}});
return ResultError;
};
const InitialError= makeErrorConstructor({ powers: 'original'});
const SharedError= makeErrorConstructor({ powers: 'none'});
defineProperties(ErrorPrototype, {
constructor: { value: SharedError}});
for( const NativeError of NativeErrors) {
setPrototypeOf(NativeError, SharedError);
}
// https://v8.dev/docs/stack-trace-api#compatibility advises that
// programmers can "always" set `Error.stackTraceLimit`
// even on non-v8 platforms. On non-v8
// it will have no effect, but this advice only makes sense
// if the assignment itself does not fail, which it would
// if `Error` were naively frozen. Hence, we add setters that
// accept but ignore the assignment on non-v8 platforms.
defineProperties(InitialError, {
stackTraceLimit: {
get() {
if( typeof FERAL_ERROR.stackTraceLimit=== 'number') {
// FERAL_ERROR.stackTraceLimit is only on v8
return FERAL_ERROR.stackTraceLimit;
}
return undefined;
},
set(newLimit) {
if( typeof newLimit!== 'number') {
// silently do nothing. This behavior doesn't precisely
// emulate v8 edge-case behavior. But given the purpose
// of this emulation, having edge cases err towards
// harmless seems the safer option.
return;
}
if( typeof FERAL_ERROR.stackTraceLimit=== 'number') {
// FERAL_ERROR.stackTraceLimit is only on v8
FERAL_ERROR.stackTraceLimit= newLimit;
// We place the useless return on the next line to ensure
// that anything we place after the if in the future only
// happens if the then-case does not.
// eslint-disable-next-line no-useless-return
return;
}
},
// WTF on v8 stackTraceLimit is enumerable
enumerable: false,
configurable: true}});
if( errorTaming=== 'unsafe-debug'&& platform=== 'v8') {
// This case is a kludge to work around
// https://github.com/endojs/endo/issues/1798
// https://github.com/endojs/endo/issues/2348
// https://github.com/Agoric/agoric-sdk/issues/8662
defineProperties(InitialError, {
prepareStackTrace: {
get() {
return FERAL_ERROR.prepareStackTrace;
},
set(newPrepareStackTrace) {
FERAL_ERROR.prepareStackTrace= newPrepareStackTrace;
},
enumerable: false,
configurable: true},
captureStackTrace: {
value: FERAL_ERROR.captureStackTrace,
writable: true,
enumerable: false,
configurable: true}});
const descs= getOwnPropertyDescriptors(InitialError);
defineProperties(SharedError, {
stackTraceLimit: descs.stackTraceLimit,
prepareStackTrace: descs.prepareStackTrace,
captureStackTrace: descs.captureStackTrace});
return {
'%InitialGetStackString%': initialGetStackString,
'%InitialError%': InitialError,
'%SharedError%': SharedError};
}
// The default SharedError much be completely powerless even on v8,
// so the lenient `stackTraceLimit` accessor does nothing on all
// platforms.
defineProperties(SharedError, {
stackTraceLimit: {
get() {
return undefined;
},
set(_newLimit) {
// do nothing
},
enumerable: false,
configurable: true}});
if( platform=== 'v8') {
// `SharedError.prepareStackTrace`, if it exists, must also be
// powerless. However, from what we've heard, depd expects to be able to
// assign to it without the assignment throwing. It is normally a function
// that returns a stack string to be magically added to error objects.
// However, as long as we're adding a lenient standin, we may as well
// accommodate any who expect to get a function they can call and get
// a string back. This prepareStackTrace is a do-nothing function that
// always returns the empty string.
defineProperties(SharedError, {
prepareStackTrace: {
get() {
return ()=> '';
},
set(_prepareFn) {
// do nothing
},
enumerable: false,
configurable: true},
captureStackTrace: {
value: (errorish, _constructorOpt)=> {
defineProperty(errorish, 'stack', {
value: ''});
},
writable: false,
enumerable: false,
configurable: true}});
}
if( platform=== 'v8') {
initialGetStackString= tameV8ErrorConstructor(
FERAL_ERROR,
InitialError,
errorTaming,
stackFiltering);
}else if( errorTaming=== 'unsafe'|| errorTaming=== 'unsafe-debug') {
// v8 has too much magic around their 'stack' own property for it to
// coexist cleanly with this accessor. So only install it on non-v8
// Error.prototype.stack property as proposed at
// https://tc39.es/proposal-error-stacks/
// with the fix proposed at
// https://github.com/tc39/proposal-error-stacks/issues/46
// On others, this still protects from the override mistake,
// essentially like enable-property-overrides.js would
// once this accessor property itself is frozen, as will happen
// later during lockdown.
//
// However, there is here a change from the intent in the current
// state of the proposal. If experience tells us whether this change
// is a good idea, we should modify the proposal accordingly. There is
// much code in the world that assumes `error.stack` is a string. So
// where the proposal accommodates secure operation by making the
// property optional, we instead accommodate secure operation by
// having the secure form always return only the stable part, the
// stringified error instance, and omitting all the frame information
// rather than omitting the property.
defineProperties(ErrorPrototype, {
stack: {
get() {
return initialGetStackString(this);
},
set(newValue) {
defineProperties(this, {
stack: {
value: newValue,
writable: true,
enumerable: true,
configurable: true}});
}}});
}else {
// v8 has too much magic around their 'stack' own property for it to
// coexist cleanly with this accessor. So only install it on non-v8
defineProperties(ErrorPrototype, {
stack: {
get() {
// https://github.com/tc39/proposal-error-stacks/issues/46
// allows this to not add an unpleasant newline. Otherwise
// we should fix this.
return `${this}`;
},
set(newValue) {
defineProperties(this, {
stack: {
value: newValue,
writable: true,
enumerable: true,
configurable: true}});
}}});
}
return {
'%InitialGetStackString%': initialGetStackString,
'%InitialError%': InitialError,
'%SharedError%': SharedError};
}$h‍_once.default( tameErrorConstructor);
})()
,
// === functors[39] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let getenv,Map,Set,TypeError,arrayJoin,arrayMap,arrayPush,create,freeze,generatorNext,generatorThrow,getOwnPropertyNames,isObject,mapGet,mapHas,mapSet,promiseThen,setAdd,values,weakmapGet,weakmapHas,makeError,annotateError,q,b,X;$h‍_imports([["@endo/env-options", [["getEnvironmentOption", [$h‍_a => (getenv = $h‍_a)]]]],["./commons.js", [["Map", [$h‍_a => (Map = $h‍_a)]],["Set", [$h‍_a => (Set = $h‍_a)]],["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["arrayJoin", [$h‍_a => (arrayJoin = $h‍_a)]],["arrayMap", [$h‍_a => (arrayMap = $h‍_a)]],["arrayPush", [$h‍_a => (arrayPush = $h‍_a)]],["create", [$h‍_a => (create = $h‍_a)]],["freeze", [$h‍_a => (freeze = $h‍_a)]],["generatorNext", [$h‍_a => (generatorNext = $h‍_a)]],["generatorThrow", [$h‍_a => (generatorThrow = $h‍_a)]],["getOwnPropertyNames", [$h‍_a => (getOwnPropertyNames = $h‍_a)]],["isObject", [$h‍_a => (isObject = $h‍_a)]],["mapGet", [$h‍_a => (mapGet = $h‍_a)]],["mapHas", [$h‍_a => (mapHas = $h‍_a)]],["mapSet", [$h‍_a => (mapSet = $h‍_a)]],["promiseThen", [$h‍_a => (promiseThen = $h‍_a)]],["setAdd", [$h‍_a => (setAdd = $h‍_a)]],["values", [$h‍_a => (values = $h‍_a)]],["weakmapGet", [$h‍_a => (weakmapGet = $h‍_a)]],["weakmapHas", [$h‍_a => (weakmapHas = $h‍_a)]]]],["./error/assert.js", [["makeError", [$h‍_a => (makeError = $h‍_a)]],["annotateError", [$h‍_a => (annotateError = $h‍_a)]],["q", [$h‍_a => (q = $h‍_a)]],["b", [$h‍_a => (b = $h‍_a)]],["X", [$h‍_a => (X = $h‍_a)]]]]]);
const noop= ()=> { };
const asyncTrampoline= async( generatorFunc, args, errorWrapper)=> {
await null;
const iterator= generatorFunc(...args);
let result= generatorNext(iterator);
while( !result.done) {
try {
// eslint-disable-next-line no-await-in-loop
const val= await result.value;
result= generatorNext(iterator, val);
}catch( error) {
result= generatorThrow(iterator, errorWrapper(error));
}
}
return result.value;
};
const syncTrampoline= (generatorFunc, args)=> {
const iterator= generatorFunc(...args);
let result= generatorNext(iterator);
while( !result.done) {
try {
result= generatorNext(iterator, result.value);
}catch( error) {
result= generatorThrow(iterator, error);
}
}
return result.value;
};
// `makeAlias` constructs compartment specifier tuples for the `aliases`
// private field of compartments.
// These aliases allow a compartment to alias an internal module specifier to a
// module specifier in an external compartment, and also to create internal
// aliases.
// Both are facilitated by the moduleMap Compartment constructor option.
const makeAlias= (compartment, specifier)=>
freeze({ compartment, specifier});
// `resolveAll` pre-computes resolutions of all imports within the compartment
// in which a module was loaded.
$h‍_once.makeAlias(makeAlias);const resolveAll=(imports,resolveHook,fullReferrerSpecifier)=>{
const resolvedImports= create(null);
for( const importSpecifier of imports) {
const fullSpecifier= resolveHook(importSpecifier, fullReferrerSpecifier);
resolvedImports[importSpecifier]= fullSpecifier;
}
return freeze(resolvedImports);
};
const loadModuleSource= (
compartmentPrivateFields,
moduleAliases,
compartment,
moduleSpecifier,
moduleSource,
enqueueJob,
selectImplementation,
moduleLoads,
importMeta)=>
{
const { resolveHook}= weakmapGet(compartmentPrivateFields, compartment);
// resolve all imports relative to this referrer module.
const resolvedImports= resolveAll(
moduleSource.imports,
resolveHook,
moduleSpecifier);
const moduleRecord= freeze({
compartment,
moduleSource,
moduleSpecifier,
resolvedImports,
importMeta});
// Enqueue jobs to load this module's shallow dependencies.
for( const fullSpecifier of values(resolvedImports)) {
// Behold: recursion.
// eslint-disable-next-line no-use-before-define
enqueueJob(memoizedLoadWithErrorAnnotation, [
compartmentPrivateFields,
moduleAliases,
compartment,
fullSpecifier,
enqueueJob,
selectImplementation,
moduleLoads]);
}
return moduleRecord;
};
function* loadWithoutErrorAnnotation(
compartmentPrivateFields,
moduleAliases,
compartment,
moduleSpecifier,
enqueueJob,
selectImplementation,
moduleLoads)
{
const {
importHook,
importNowHook,
moduleMap,
moduleMapHook,
moduleRecords,
parentCompartment}=
weakmapGet(compartmentPrivateFields, compartment);
if( mapHas(moduleRecords, moduleSpecifier)) {
return mapGet(moduleRecords, moduleSpecifier);
}
// Follow moduleMap, or moduleMapHook if present.
let moduleDescriptor= moduleMap[moduleSpecifier];
if( moduleDescriptor=== undefined&& moduleMapHook!== undefined) {
moduleDescriptor= moduleMapHook(moduleSpecifier);
}
if( moduleDescriptor=== undefined) {
const moduleHook= selectImplementation(importHook, importNowHook);
if( moduleHook=== undefined) {
const moduleHookName= selectImplementation(
'importHook',
'importNowHook');
throw makeError(
X `${b(moduleHookName)} needed to load module ${q(
moduleSpecifier)
} in compartment ${q(compartment.name)}`);
}
moduleDescriptor= moduleHook(moduleSpecifier);
// Uninitialized module namespaces throw if we attempt to coerce them into
// promises.
if( !weakmapHas(moduleAliases, moduleDescriptor)) {
moduleDescriptor= yield moduleDescriptor;
}
}
if( typeof moduleDescriptor=== 'string') {
// eslint-disable-next-line @endo/no-polymorphic-call
throw makeError(
X `Cannot map module ${q(moduleSpecifier)} to ${q(
moduleDescriptor)
} in parent compartment, use {source} module descriptor`,
TypeError);
}else if( isObject(moduleDescriptor)) {
// In this shim (and not in XS, and not in the standard we imagine), we
// allow a module namespace object to stand in for a module descriptor that
// describes its original {compartment, specifier} so that it can be used
// to create a link.
let aliasDescriptor= weakmapGet(moduleAliases, moduleDescriptor);
if( aliasDescriptor!== undefined) {
moduleDescriptor= aliasDescriptor;
}
if( moduleDescriptor.namespace!== undefined) {
// { namespace: string, compartment?: Compartment }
// Namespace module descriptors link to a module instance.
if( typeof moduleDescriptor.namespace=== 'string') {
// The default compartment is the *parent*, not this child compartment.
// This is a difference from the legacy {specifier, compartment} module
// descriptor.
const {
compartment: aliasCompartment= parentCompartment,
namespace: aliasSpecifier}=
moduleDescriptor;
if(
!isObject(aliasCompartment)||
!weakmapHas(compartmentPrivateFields, aliasCompartment))
{
throw makeError(
X `Invalid compartment in module descriptor for specifier ${q(moduleSpecifier)} in compartment ${q(compartment.name)}`);
}
// Behold: recursion.
// eslint-disable-next-line no-use-before-define
const aliasRecord= yield memoizedLoadWithErrorAnnotation(
compartmentPrivateFields,
moduleAliases,
aliasCompartment,
aliasSpecifier,
enqueueJob,
selectImplementation,
moduleLoads);
mapSet(moduleRecords, moduleSpecifier, aliasRecord);
return aliasRecord;
}
// All remaining objects must either be a module namespace, or be
// promoted into a module namespace with a virtual module source.
if( isObject(moduleDescriptor.namespace)) {
const { namespace}= moduleDescriptor;
// Brand-check SES shim module exports namespaces:
aliasDescriptor= weakmapGet(moduleAliases, namespace);
if( aliasDescriptor!== undefined) {
moduleDescriptor= aliasDescriptor;
// Fall through to processing the resulting {compartment, specifier}
// alias.
}else {
// Promote an arbitrary object to a module namespace with a virtual
// module source.
// { namespace: Object }
const exports= getOwnPropertyNames(namespace);
/** @type {import('../types.js').VirtualModuleSource} */
const moduleSource= {
imports: [],
exports,
execute(env) {
for( const name of exports) {
env[name]= namespace[name];
}
}};
const importMeta= undefined;
const moduleRecord= loadModuleSource(
compartmentPrivateFields,
moduleAliases,
compartment,
moduleSpecifier,
moduleSource,
enqueueJob,
selectImplementation,
moduleLoads,
importMeta);
mapSet(moduleRecords, moduleSpecifier, moduleRecord);
return moduleRecord;
}
}else {
throw makeError(
X `Invalid compartment in module descriptor for specifier ${q(moduleSpecifier)} in compartment ${q(compartment.name)}`);
}
}
if( moduleDescriptor.source!== undefined) {
// Module source descriptors create an instance from a module source.
// The descriptor may contain the module source, or refer to a source
// loaded in a particular compartment.
if( typeof moduleDescriptor.source=== 'string') {
// { source: string, importMeta?, specifier?: string, compartment? }
// A string source is the specifier for a different module source.
// That source may come from this compartment's parent (default), or
// from a specified compartment, and the specified compartment may be
// this compartment to make a duplicate.
const {
source: loaderSpecifier,
specifier: instanceSpecifier= moduleSpecifier,
compartment: loaderCompartment= parentCompartment,
importMeta= undefined}=
moduleDescriptor;
// Induce the compartment, possibly a different compartment
// to load a module source.
// Behold: recursion.
// eslint-disable-next-line no-use-before-define
const loaderRecord= yield memoizedLoadWithErrorAnnotation(
compartmentPrivateFields,
moduleAliases,
loaderCompartment,
loaderSpecifier,
enqueueJob,
selectImplementation,
moduleLoads);
// Extract the source of the module from the loader compartment's
// record.
const { moduleSource}= loaderRecord;
// Instantiate that source in our own compartment, possibly with a
// different specifier for resolving its own imports.
const moduleRecord= loadModuleSource(
compartmentPrivateFields,
moduleAliases,
compartment,
instanceSpecifier,
moduleSource,
enqueueJob,
selectImplementation,
moduleLoads,
importMeta);
mapSet(moduleRecords, moduleSpecifier, moduleRecord);
return moduleRecord;
}else {
// { source: ModuleSource, importMeta?, specifier?: string }
// We assume all non-string module sources are any of the supported
// kinds of module source: PrecompiledModuleSource,
// VirtualModuleSource, or a native ModuleSource.
const {
source: moduleSource,
specifier: aliasSpecifier= moduleSpecifier,
importMeta}=
moduleDescriptor;
const aliasRecord= loadModuleSource(
compartmentPrivateFields,
moduleAliases,
compartment,
aliasSpecifier,
moduleSource,
enqueueJob,
selectImplementation,
moduleLoads,
importMeta);
mapSet(moduleRecords, moduleSpecifier, aliasRecord);
return aliasRecord;
}
}
if( moduleDescriptor.archive!== undefined) {
// { archive: Archive, path: string }
// We do not support this XS-native module descriptor.
throw makeError(
X `Unsupported archive module descriptor for specifier ${q(moduleSpecifier)} in compartment ${q(compartment.name)}`);
}
// { record, specifier?, compartment?, importMeta? }
// A (legacy) module descriptor for when we find the module source (record)
// but at a different specifier than requested.
// Providing this {specifier, record} descriptor serves as an ergonomic
// short-hand for stashing the record, returning a {compartment, specifier}
// reference, bouncing the module hook, then producing the source (record)
// when module hook receives the response specifier.
if( moduleDescriptor.record!== undefined) {
const {
compartment: aliasCompartment= compartment,
specifier: aliasSpecifier= moduleSpecifier,
record: moduleSource,
importMeta}=
moduleDescriptor;
const aliasRecord= loadModuleSource(
compartmentPrivateFields,
moduleAliases,
aliasCompartment,
aliasSpecifier,
moduleSource,
enqueueJob,
selectImplementation,
moduleLoads,
importMeta);
mapSet(moduleRecords, moduleSpecifier, aliasRecord);
mapSet(moduleRecords, aliasSpecifier, aliasRecord);
return aliasRecord;
}
// { specifier: string, compartment: Compartment }
// A (legacy) module descriptor that describes a link to a module instance
// in a specified compartment.
if(
moduleDescriptor.compartment!== undefined&&
moduleDescriptor.specifier!== undefined)
{
if(
!isObject(moduleDescriptor.compartment)||
!weakmapHas(compartmentPrivateFields, moduleDescriptor.compartment)||
typeof moduleDescriptor.specifier!== 'string')
{
throw makeError(
X `Invalid compartment in module descriptor for specifier ${q(moduleSpecifier)} in compartment ${q(compartment.name)}`);
}
// Behold: recursion.
// eslint-disable-next-line no-use-before-define
const aliasRecord= yield memoizedLoadWithErrorAnnotation(
compartmentPrivateFields,
moduleAliases,
moduleDescriptor.compartment,
moduleDescriptor.specifier,
enqueueJob,
selectImplementation,
moduleLoads);
mapSet(moduleRecords, moduleSpecifier, aliasRecord);
return aliasRecord;
}
// A (legacy) behavior: If we do not recognize the module descriptor as a
// module descriptor, we assume that it is a module source (record):
const moduleSource= moduleDescriptor;
const moduleRecord= loadModuleSource(
compartmentPrivateFields,
moduleAliases,
compartment,
moduleSpecifier,
moduleSource,
enqueueJob,
selectImplementation,
moduleLoads);
// Memoize.
mapSet(moduleRecords, moduleSpecifier, moduleRecord);
return moduleRecord;
}else {
throw makeError(
X `module descriptor must be a string or object for specifier ${q(
moduleSpecifier)
} in compartment ${q(compartment.name)}`);
}
}
const memoizedLoadWithErrorAnnotation= (
compartmentPrivateFields,
moduleAliases,
compartment,
moduleSpecifier,
enqueueJob,
selectImplementation,
moduleLoads)=>
{
const { name: compartmentName}= weakmapGet(
compartmentPrivateFields,
compartment);
// Prevent data-lock from recursion into branches visited in dependent loads.
let compartmentLoading= mapGet(moduleLoads, compartment);
if( compartmentLoading=== undefined) {
compartmentLoading= new Map();
mapSet(moduleLoads, compartment, compartmentLoading);
}
let moduleLoading= mapGet(compartmentLoading, moduleSpecifier);
if( moduleLoading!== undefined) {
return moduleLoading;
}
moduleLoading= selectImplementation(asyncTrampoline, syncTrampoline)(
loadWithoutErrorAnnotation,
[
compartmentPrivateFields,
moduleAliases,
compartment,
moduleSpecifier,
enqueueJob,
selectImplementation,
moduleLoads],
(error)=>{
// eslint-disable-next-line @endo/no-polymorphic-call
annotateError(
error,
X `${error.message}, loading ${q(moduleSpecifier)} in compartment ${q(
compartmentName)
}`);
throw error;
});
mapSet(compartmentLoading, moduleSpecifier, moduleLoading);
return moduleLoading;
};
const asyncJobQueue= ()=> {
/** @type {Set<Promise<undefined>>} */
const pendingJobs= new Set();
/** @type {Array<Error>} */
const errors= [];
/**
* Enqueues a job that starts immediately but won't be awaited until drainQueue is called.
*
* @template {any[]} T
* @param {(...args: T)=>Promise<*>} func
* @param {T} args
*/
const enqueueJob= (func, args)=> {
setAdd(
pendingJobs,
promiseThen(func(...args), noop, (error)=>{
arrayPush(errors, error);
}));
};
/**
* Sequentially awaits pending jobs and returns an array of errors
*
* @returns {Promise<Array<Error>>}
*/
const drainQueue= async()=> {
await null;
for( const job of pendingJobs) {
// eslint-disable-next-line no-await-in-loop
await job;
}
return errors;
};
return { enqueueJob, drainQueue};
};
/**
* @param {object} options
* @param {Array<Error>} options.errors
* @param {string} options.errorPrefix
*/
const throwAggregateError= ({ errors, errorPrefix})=> {
// Throw an aggregate error if there were any errors.
if( errors.length> 0) {
const verbose=
getenv('COMPARTMENT_LOAD_ERRORS', '', ['verbose'])=== 'verbose';
throw TypeError(
`${errorPrefix} (${errors.length} underlying failures: ${arrayJoin(
arrayMap(errors, (error)=>error.message+( verbose? error.stack: '')),
', ')
}`);
}
};
const preferSync= (_asyncImpl, syncImpl)=> syncImpl;
const preferAsync= (asyncImpl, _syncImpl)=> asyncImpl;
/*
* `load` asynchronously gathers the module records for a module and its
* transitive dependencies.
* The module records refer to each other by a reference to the dependency's
* compartment and the specifier of the module within its own compartment.
* This graph is then ready to be synchronously linked and executed.
*/
const load= async(
compartmentPrivateFields,
moduleAliases,
compartment,
moduleSpecifier)=>
{
const { name: compartmentName}= weakmapGet(
compartmentPrivateFields,
compartment);
/** @type {Map<object, Map<string, Promise<Record<any, any>>>>} */
const moduleLoads= new Map();
const { enqueueJob, drainQueue}= asyncJobQueue();
enqueueJob(memoizedLoadWithErrorAnnotation, [
compartmentPrivateFields,
moduleAliases,
compartment,
moduleSpecifier,
enqueueJob,
preferAsync,
moduleLoads]);
// Drain pending jobs queue and throw an aggregate error
const errors= await drainQueue();
throwAggregateError({
errors,
errorPrefix: `Failed to load module ${q(moduleSpecifier)} in package ${q(
compartmentName)
}`});
};
/*
* `loadNow` synchronously gathers the module records for a specified module
* and its transitive dependencies.
* The module records refer to each other by a reference to the dependency's
* compartment and the specifier of the module within its own compartment.
* This graph is then ready to be synchronously linked and executed.
*/$h‍_once.load(load);
const loadNow= (
compartmentPrivateFields,
moduleAliases,
compartment,
moduleSpecifier)=>
{
const { name: compartmentName}= weakmapGet(
compartmentPrivateFields,
compartment);
/** @type {Map<object, Map<string, Promise<Record<any, any>>>>} */
const moduleLoads= new Map();
/** @type {Array<Error>} */
const errors= [];
const enqueueJob= (func, args)=> {
try {
func(...args);
}catch( error) {
arrayPush(errors, error);
}
};
enqueueJob(memoizedLoadWithErrorAnnotation, [
compartmentPrivateFields,
moduleAliases,
compartment,
moduleSpecifier,
enqueueJob,
preferSync,
moduleLoads]);
throwAggregateError({
errors,
errorPrefix: `Failed to load module ${q(moduleSpecifier)} in package ${q(
compartmentName)
}`});
};$h‍_once.loadNow(loadNow);
})()
,
// === functors[40] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let makeAlias,Proxy,TypeError,create,freeze,mapGet,mapHas,mapSet,ownKeys,reflectGet,reflectGetOwnPropertyDescriptor,reflectHas,reflectIsExtensible,reflectPreventExtensions,toStringTagSymbol,weakmapSet,assert;$h‍_imports([["./module-load.js", [["makeAlias", [$h‍_a => (makeAlias = $h‍_a)]]]],["./commons.js", [["Proxy", [$h‍_a => (Proxy = $h‍_a)]],["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["create", [$h‍_a => (create = $h‍_a)]],["freeze", [$h‍_a => (freeze = $h‍_a)]],["mapGet", [$h‍_a => (mapGet = $h‍_a)]],["mapHas", [$h‍_a => (mapHas = $h‍_a)]],["mapSet", [$h‍_a => (mapSet = $h‍_a)]],["ownKeys", [$h‍_a => (ownKeys = $h‍_a)]],["reflectGet", [$h‍_a => (reflectGet = $h‍_a)]],["reflectGetOwnPropertyDescriptor", [$h‍_a => (reflectGetOwnPropertyDescriptor = $h‍_a)]],["reflectHas", [$h‍_a => (reflectHas = $h‍_a)]],["reflectIsExtensible", [$h‍_a => (reflectIsExtensible = $h‍_a)]],["reflectPreventExtensions", [$h‍_a => (reflectPreventExtensions = $h‍_a)]],["toStringTagSymbol", [$h‍_a => (toStringTagSymbol = $h‍_a)]],["weakmapSet", [$h‍_a => (weakmapSet = $h‍_a)]]]],["./error/assert.js", [["assert", [$h‍_a => (assert = $h‍_a)]]]]]);
const { quote: q}= assert;
// `deferExports` creates a module's exports proxy, proxied exports, and
// activator.
// A `Compartment` can create a module for any module specifier, regardless of
// whether it is loadable or executable, and use that object as a token that
// can be fed into another compartment's module map.
// Only after the specified module has been analyzed is it possible for the
// module namespace proxy to behave properly, so it throws exceptions until
// after the compartment has begun executing the module.
// The module instance must freeze the proxied exports and activate the exports
// proxy before executing the module.
//
// The module exports proxy's behavior differs from the ECMAScript 262
// specification for "module namespace exotic objects" only in that according
// to the specification value property descriptors have a non-writable "value"
// and this implementation models all properties with accessors.
//
// https://tc39.es/ecma262/#sec-module-namespace-exotic-objects
//
const deferExports= ()=> {
let active= false;
const exportsTarget= create(null, {
// Make this appear like an ESM module namespace object.
[toStringTagSymbol]: {
value: 'Module',
writable: false,
enumerable: false,
configurable: false}});
return freeze({
activate() {
active= true;
},
exportsTarget,
exportsProxy: new Proxy(exportsTarget, {
get(_target, name, receiver) {
if( !active) {
throw TypeError(
`Cannot get property ${q(
name)
} of module exports namespace, the module has not yet begun to execute`);
}
return reflectGet(exportsTarget, name, receiver);
},
set(_target, name, _value) {
throw TypeError(
`Cannot set property ${q(name)} of module exports namespace`);
},
has(_target, name) {
if( !active) {
throw TypeError(
`Cannot check property ${q(
name)
}, the module has not yet begun to execute`);
}
return reflectHas(exportsTarget, name);
},
deleteProperty(_target, name) {
throw TypeError(
`Cannot delete property ${q(name)}s of module exports namespace`);
},
ownKeys(_target) {
if( !active) {
throw TypeError(
'Cannot enumerate keys, the module has not yet begun to execute');
}
return ownKeys(exportsTarget);
},
getOwnPropertyDescriptor(_target, name) {
if( !active) {
throw TypeError(
`Cannot get own property descriptor ${q(
name)
}, the module has not yet begun to execute`);
}
return reflectGetOwnPropertyDescriptor(exportsTarget, name);
},
preventExtensions(_target) {
if( !active) {
throw TypeError(
'Cannot prevent extensions of module exports namespace, the module has not yet begun to execute');
}
return reflectPreventExtensions(exportsTarget);
},
isExtensible() {
if( !active) {
throw TypeError(
'Cannot check extensibility of module exports namespace, the module has not yet begun to execute');
}
return reflectIsExtensible(exportsTarget);
},
getPrototypeOf(_target) {
return null;
},
setPrototypeOf(_target, _proto) {
throw TypeError('Cannot set prototype of module exports namespace');
},
defineProperty(_target, name, _descriptor) {
throw TypeError(
`Cannot define property ${q(name)} of module exports namespace`);
},
apply(_target, _thisArg, _args) {
throw TypeError(
'Cannot call module exports namespace, it is not a function');
},
construct(_target, _args) {
throw TypeError(
'Cannot construct module exports namespace, it is not a constructor');
}})});
};
/**
* @typedef {object} DeferredExports
* @property {Record<string, any>} exportsTarget - The object to which a
* module's exports will be added.
* @property {Record<string, any>} exportsProxy - A proxy over the `exportsTarget`,
* used to expose its "exports" to other compartments.
* @property {() => void} activate - Activate the `exportsProxy` such that it can
* be used as a module namespace object.
*/
/**
* Memoizes the creation of a deferred module exports namespace proxy for any
* arbitrary full specifier in a compartment. It also records the compartment
* and specifier affiliated with that module exports namespace proxy so it
* can be used as an alias into another compartment when threaded through
* a compartment's `moduleMap` argument.
*
* @param {*} compartment - The compartment to retrieve deferred exports from.
* @param {*} compartmentPrivateFields - The private fields of the compartment.
* @param {*} moduleAliases - The module aliases of the compartment.
* @param {string} specifier - The module specifier to retrieve deferred exports for.
* @returns {DeferredExports} - The deferred exports for the module specifier of
* the compartment.
*/$h‍_once.deferExports(deferExports);
const getDeferredExports= (
compartment,
compartmentPrivateFields,
moduleAliases,
specifier)=>
{
const { deferredExports}= compartmentPrivateFields;
if( !mapHas(deferredExports, specifier)) {
const deferred= deferExports();
weakmapSet(
moduleAliases,
deferred.exportsProxy,
makeAlias(compartment, specifier));
mapSet(deferredExports, specifier, deferred);
}
return mapGet(deferredExports, specifier);
};$h‍_once.getDeferredExports(getDeferredExports);
})()
,
// === functors[41] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let TypeError,arrayPush,create,getOwnPropertyDescriptors,evadeHtmlCommentTest,evadeImportExpressionTest,rejectSomeDirectEvalExpressions,makeSafeEvaluator;$h‍_imports([["./commons.js", [["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["arrayPush", [$h‍_a => (arrayPush = $h‍_a)]],["create", [$h‍_a => (create = $h‍_a)]],["getOwnPropertyDescriptors", [$h‍_a => (getOwnPropertyDescriptors = $h‍_a)]]]],["./transforms.js", [["evadeHtmlCommentTest", [$h‍_a => (evadeHtmlCommentTest = $h‍_a)]],["evadeImportExpressionTest", [$h‍_a => (evadeImportExpressionTest = $h‍_a)]],["rejectSomeDirectEvalExpressions", [$h‍_a => (rejectSomeDirectEvalExpressions = $h‍_a)]]]],["./make-safe-evaluator.js", [["makeSafeEvaluator", [$h‍_a => (makeSafeEvaluator = $h‍_a)]]]]]);
const provideCompartmentEvaluator= (compartmentFields, options)=> {
const { sloppyGlobalsMode= false, __moduleShimLexicals__= undefined}=
options;
let safeEvaluate;
if( __moduleShimLexicals__=== undefined&& !sloppyGlobalsMode) {
({ safeEvaluate}= compartmentFields);
}else {
// The scope proxy or global lexicals are different from the
// shared evaluator so we need to build a new one
let { globalTransforms}= compartmentFields;
const { globalObject}= compartmentFields;
let moduleLexicals;
if( __moduleShimLexicals__!== undefined) {
// When using `evaluate` for ESM modules, as should only occur from the
// module-shim's module-instance.js, we do not reveal the SES-shim's
// module-to-program translation, as this is not standardizable behavior.
// However, the `localTransforms` will come from the `__shimTransforms__`
// Compartment option in this case, which is a non-standardizable escape
// hatch so programs designed specifically for the SES-shim
// implementation may opt-in to use the same transforms for `evaluate`
// and `import`, at the expense of being tightly coupled to SES-shim.
globalTransforms= undefined;
moduleLexicals= create(
null,
getOwnPropertyDescriptors(__moduleShimLexicals__));
}
({ safeEvaluate}= makeSafeEvaluator({
globalObject,
moduleLexicals,
globalTransforms,
sloppyGlobalsMode}));
}
return { safeEvaluate};
};$h‍_once.provideCompartmentEvaluator(provideCompartmentEvaluator);
const compartmentEvaluate= (compartmentFields, source, options)=> {
// Perform this check first to avoid unnecessary sanitizing.
// TODO Maybe relax string check and coerce instead:
// https://github.com/tc39/proposal-dynamic-code-brand-checks
if( typeof source!== 'string') {
throw TypeError('first argument of evaluate() must be a string');
}
// Extract options, and shallow-clone transforms.
const {
transforms= [],
__evadeHtmlCommentTest__= false,
__evadeImportExpressionTest__= false,
__rejectSomeDirectEvalExpressions__= true // Note default on
}= options;
const localTransforms= [...transforms];
if( __evadeHtmlCommentTest__=== true) {
arrayPush(localTransforms, evadeHtmlCommentTest);
}
if( __evadeImportExpressionTest__=== true) {
arrayPush(localTransforms, evadeImportExpressionTest);
}
if( __rejectSomeDirectEvalExpressions__=== true) {
arrayPush(localTransforms, rejectSomeDirectEvalExpressions);
}
const { safeEvaluate}= provideCompartmentEvaluator(
compartmentFields,
options);
return safeEvaluate(source, {
localTransforms});
};$h‍_once.compartmentEvaluate(compartmentEvaluate);
})()
,
// === functors[42] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let assert,getDeferredExports,ReferenceError,SyntaxError,TypeError,arrayForEach,arrayIncludes,arrayPush,arraySome,arraySort,create,defineProperty,entries,freeze,isArray,keys,mapGet,weakmapGet,reflectHas,assign,compartmentEvaluate;$h‍_imports([["./error/assert.js", [["assert", [$h‍_a => (assert = $h‍_a)]]]],["./module-proxy.js", [["getDeferredExports", [$h‍_a => (getDeferredExports = $h‍_a)]]]],["./commons.js", [["ReferenceError", [$h‍_a => (ReferenceError = $h‍_a)]],["SyntaxError", [$h‍_a => (SyntaxError = $h‍_a)]],["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["arrayForEach", [$h‍_a => (arrayForEach = $h‍_a)]],["arrayIncludes", [$h‍_a => (arrayIncludes = $h‍_a)]],["arrayPush", [$h‍_a => (arrayPush = $h‍_a)]],["arraySome", [$h‍_a => (arraySome = $h‍_a)]],["arraySort", [$h‍_a => (arraySort = $h‍_a)]],["create", [$h‍_a => (create = $h‍_a)]],["defineProperty", [$h‍_a => (defineProperty = $h‍_a)]],["entries", [$h‍_a => (entries = $h‍_a)]],["freeze", [$h‍_a => (freeze = $h‍_a)]],["isArray", [$h‍_a => (isArray = $h‍_a)]],["keys", [$h‍_a => (keys = $h‍_a)]],["mapGet", [$h‍_a => (mapGet = $h‍_a)]],["weakmapGet", [$h‍_a => (weakmapGet = $h‍_a)]],["reflectHas", [$h‍_a => (reflectHas = $h‍_a)]],["assign", [$h‍_a => (assign = $h‍_a)]]]],["./compartment-evaluate.js", [["compartmentEvaluate", [$h‍_a => (compartmentEvaluate = $h‍_a)]]]]]);
const { quote: q}= assert;
const makeVirtualModuleInstance= (
compartmentPrivateFields,
moduleSource,
compartment,
moduleAliases,
moduleSpecifier,
resolvedImports)=>
{
const { exportsProxy, exportsTarget, activate}= getDeferredExports(
compartment,
weakmapGet(compartmentPrivateFields, compartment),
moduleAliases,
moduleSpecifier);
const notifiers= create(null);
if( moduleSource.exports) {
if(
!isArray(moduleSource.exports)||
arraySome(moduleSource.exports, (name)=>typeof name!== 'string'))
{
throw TypeError(
`SES virtual module source "exports" property must be an array of strings for module ${moduleSpecifier}`);
}
arrayForEach(moduleSource.exports, (name)=>{
let value= exportsTarget[name];
const updaters= [];
const get= ()=> value;
const set= (newValue)=>{
value= newValue;
for( const updater of updaters) {
updater(newValue);
}
};
defineProperty(exportsTarget, name, {
get,
set,
enumerable: true,
configurable: false});
notifiers[name]= (update)=>{
arrayPush(updaters, update);
update(value);
};
});
// This is enough to support import * from cjs - the '*' field doesn't need to be in exports nor exportsTarget because import will only ever access it via notifiers
notifiers['*']= (update)=>{
update(exportsTarget);
};
}
const localState= {
activated: false};
return freeze({
notifiers,
exportsProxy,
execute() {
if( reflectHas(localState, 'errorFromExecute')) {
throw localState.errorFromExecute;
}
if( !localState.activated) {
activate();
localState.activated= true;
try {
// eslint-disable-next-line @endo/no-polymorphic-call
moduleSource.execute(exportsTarget, compartment, resolvedImports);
}catch( err) {
localState.errorFromExecute= err;
throw err;
}
}
}});
};
// `makeModuleInstance` takes a module's compartment record, the live import
// namespace, and a global object; and produces a module instance.
// The module instance carries the proxied module exports namespace (the
// "exports"), notifiers to update the module's internal import namespace, and
// an idempotent execute function.
// The module exports namespace is a proxy to the proxied exports namespace
// that the execution of the module instance populates.
$h‍_once.makeVirtualModuleInstance(makeVirtualModuleInstance);const makeModuleInstance=(
privateFields,
moduleAliases,
moduleRecord,
importedInstances)=>
{
const {
compartment,
moduleSpecifier,
moduleSource,
importMeta: moduleRecordMeta}=
moduleRecord;
const {
reexports: exportAlls= [],
__syncModuleProgram__: functorSource,
__fixedExportMap__: fixedExportMap= {},
__liveExportMap__: liveExportMap= {},
__reexportMap__: reexportMap= {},
__needsImportMeta__: needsImportMeta= false,
__syncModuleFunctor__}=
moduleSource;
const compartmentFields= weakmapGet(privateFields, compartment);
const { __shimTransforms__, importMetaHook}= compartmentFields;
const { exportsProxy, exportsTarget, activate}= getDeferredExports(
compartment,
compartmentFields,
moduleAliases,
moduleSpecifier);
// {_exportName_: getter} module exports namespace
// object (eventually proxied).
const exportsProps= create(null);
// {_localName_: accessor} proxy traps for moduleLexicals and live bindings.
// The moduleLexicals object is frozen and the corresponding properties of
// moduleLexicals must be immutable, so we copy the descriptors.
const moduleLexicals= create(null);
// {_localName_: init(initValue) -> initValue} used by the
// rewritten code to initialize exported fixed bindings.
const onceVar= create(null);
// {_localName_: update(newValue)} used by the rewritten code to
// both initialize and update live bindings.
const liveVar= create(null);
const importMeta= create(null);
if( moduleRecordMeta) {
assign(importMeta, moduleRecordMeta);
}
if( needsImportMeta&& importMetaHook) {
importMetaHook(moduleSpecifier, importMeta);
}
// {_localName_: [{get, set, notify}]} used to merge all the export updaters.
const localGetNotify= create(null);
// {[importName: string]: notify(update(newValue))} Used by code that imports
// one of this module's exports, so that their update function will
// be notified when this binding is initialized or updated.
const notifiers= create(null);
arrayForEach(entries(fixedExportMap), ([fixedExportName, [localName]])=> {
let fixedGetNotify= localGetNotify[localName];
if( !fixedGetNotify) {
// fixed binding state
let value;
let tdz= true;
/** @type {null | Array<(value: any) => void>} */
let optUpdaters= [];
// tdz sensitive getter
const get= ()=> {
if( tdz) {
throw ReferenceError( `binding ${q(localName)} not yet initialized`);
}
return value;
};
// leave tdz once
const init= freeze((initValue)=>{
// init with initValue of a declared const binding, and return
// it.
if( !tdz) {
throw TypeError(
`Internal: binding ${q(localName)} already initialized`);
}
value= initValue;
const updaters= optUpdaters;
optUpdaters= null;
tdz= false;
for( const updater of updaters|| []) {
updater(initValue);
}
return initValue;
});
// If still tdz, register update for notification later.
// Otherwise, update now.
const notify= (updater)=>{
if( updater=== init) {
// Prevent recursion.
return;
}
if( tdz) {
arrayPush(optUpdaters|| [], updater);
}else {
updater(value);
}
};
// Need these for additional exports of the local variable.
fixedGetNotify= {
get,
notify};
localGetNotify[localName]= fixedGetNotify;
onceVar[localName]= init;
}
exportsProps[fixedExportName]= {
get: fixedGetNotify.get,
set: undefined,
enumerable: true,
configurable: false};
notifiers[fixedExportName]= fixedGetNotify.notify;
});
arrayForEach(
entries(liveExportMap),
([liveExportName, [localName, setProxyTrap]])=> {
let liveGetNotify= localGetNotify[localName];
if( !liveGetNotify) {
// live binding state
let value;
let tdz= true;
const updaters= [];
// tdz sensitive getter
const get= ()=> {
if( tdz) {
throw ReferenceError(
`binding ${q(liveExportName)} not yet initialized`);
}
return value;
};
// This must be usable locally for the translation of initializing
// a declared local live binding variable.
//
// For reexported variable, this is also an update function to
// register for notification with the downstream import, which we
// must assume to be live. Thus, it can be called independent of
// tdz but always leaves tdz. Such reexporting creates a tree of
// bindings. This lets the tree be hooked up even if the imported
// module instance isn't initialized yet, as may happen in cycles.
const update= freeze((newValue)=>{
value= newValue;
tdz= false;
for( const updater of updaters) {
updater(newValue);
}
});
// tdz sensitive setter
const set= (newValue)=>{
if( tdz) {
throw ReferenceError( `binding ${q(localName)} not yet initialized`);
}
value= newValue;
for( const updater of updaters) {
updater(newValue);
}
};
// Always register the updater function.
// If not in tdz, also update now.
const notify= (updater)=>{
if( updater=== update) {
// Prevent recursion.
return;
}
arrayPush(updaters, updater);
if( !tdz) {
updater(value);
}
};
liveGetNotify= {
get,
notify};
localGetNotify[localName]= liveGetNotify;
if( setProxyTrap) {
defineProperty(moduleLexicals, localName, {
get,
set,
enumerable: true,
configurable: false});
}
liveVar[localName]= update;
}
exportsProps[liveExportName]= {
get: liveGetNotify.get,
set: undefined,
enumerable: true,
configurable: false};
notifiers[liveExportName]= liveGetNotify.notify;
});
const notifyStar= (update)=>{
update(exportsTarget);
};
notifiers['*']= notifyStar;
// Per the calling convention for the moduleFunctor generated from
// an ESM, the `imports` function gets called once up front
// to populate or arrange the population of imports and reexports.
// The generated code produces an `updateRecord`: the means for
// the linker to update the imports and exports of the module.
// The updateRecord must conform to moduleAnalysis.imports
// updateRecord = Map<specifier, importUpdaters>
// importUpdaters = Map<importName, [update(newValue)*]>
function imports(updateRecord) {
// By the time imports is called, the importedInstances should already be
// initialized with module instances that satisfy
// imports.
// importedInstances = Map[_specifier_, { notifiers, module, execute }]
// notifiers = { [importName: string]: notify(update(newValue))}
// export * cannot export default.
const candidateAll= create(null);
candidateAll.default= false;
for( const [specifier, importUpdaters]of updateRecord) {
const instance= mapGet(importedInstances, specifier);
// The module instance object is an internal literal, does not bind this,
// and never revealed outside the SES shim.
// There are two instantiation sites for instances and they are both in
// this module.
// eslint-disable-next-line @endo/no-polymorphic-call
instance.execute(); // bottom up cycle tolerant
const { notifiers: importNotifiers}= instance;
for( const [importName, updaters]of importUpdaters) {
const importNotify= importNotifiers[importName];
if( !importNotify) {
throw SyntaxError(
`The requested module '${specifier}' does not provide an export named '${importName}'`);
}
for( const updater of updaters) {
importNotify(updater);
}
}
if( arrayIncludes(exportAlls, specifier)) {
// Make all these imports candidates.
// Note names don't change in reexporting all
for( const [importAndExportName, importNotify]of entries(
importNotifiers))
{
if( candidateAll[importAndExportName]=== undefined) {
candidateAll[importAndExportName]= importNotify;
}else {
// Already a candidate: remove ambiguity.
candidateAll[importAndExportName]= false;
}
}
}
if( reexportMap[specifier]) {
// Make named reexports candidates too.
for( const [localName, exportedName]of reexportMap[specifier]) {
candidateAll[exportedName]= importNotifiers[localName];
}
}
}
for( const [exportName, notify]of entries(candidateAll)) {
if( !notifiers[exportName]&& notify!== false) {
notifiers[exportName]= notify;
// exported live binding state
let value;
const update= (newValue)=> value= newValue;
notify(update);
exportsProps[exportName]= {
get() {
return value;
},
set: undefined,
enumerable: true,
configurable: false};
}
}
// Sort the module exports namespace as per spec.
// The module exports namespace will be wrapped in a module namespace
// exports proxy which will serve as a "module exports namespace exotic
// object".
// Sorting properties is not generally reliable because some properties may
// be symbols, and symbols do not have an inherent relative order, but
// since all properties of the exports namespace must be keyed by a string
// and the string must correspond to a valid identifier, sorting these
// properties works for this specific case.
arrayForEach(arraySort(keys(exportsProps)), (k)=>
defineProperty(exportsTarget, k, exportsProps[k]));
freeze(exportsTarget);
activate();
}
let optFunctor;
if( __syncModuleFunctor__!== undefined) {
optFunctor= __syncModuleFunctor__;
}else {
optFunctor= compartmentEvaluate(compartmentFields, functorSource, {
globalObject: compartment.globalThis,
transforms: __shimTransforms__,
__moduleShimLexicals__: moduleLexicals});
}
let didThrow= false;
let thrownError;
function execute() {
if( optFunctor) {
// uninitialized
const functor= optFunctor;
optFunctor= null;
// initializing - call with `this` of `undefined`.
try {
functor(
freeze({
imports: freeze(imports),
onceVar: freeze(onceVar),
liveVar: freeze(liveVar),
importMeta}));
}catch( e) {
didThrow= true;
thrownError= e;
}
// initialized
}
if( didThrow) {
throw thrownError;
}
}
return freeze({
notifiers,
exportsProxy,
execute});
};$h‍_once.makeModuleInstance(makeModuleInstance);
})()
,
// === functors[43] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let assert,makeModuleInstance,makeVirtualModuleInstance,Map,ReferenceError,TypeError,entries,isArray,isObject,mapGet,mapHas,mapSet,weakmapGet;$h‍_imports([["./error/assert.js", [["assert", [$h‍_a => (assert = $h‍_a)]]]],["./module-instance.js", [["makeModuleInstance", [$h‍_a => (makeModuleInstance = $h‍_a)]],["makeVirtualModuleInstance", [$h‍_a => (makeVirtualModuleInstance = $h‍_a)]]]],["./commons.js", [["Map", [$h‍_a => (Map = $h‍_a)]],["ReferenceError", [$h‍_a => (ReferenceError = $h‍_a)]],["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["entries", [$h‍_a => (entries = $h‍_a)]],["isArray", [$h‍_a => (isArray = $h‍_a)]],["isObject", [$h‍_a => (isObject = $h‍_a)]],["mapGet", [$h‍_a => (mapGet = $h‍_a)]],["mapHas", [$h‍_a => (mapHas = $h‍_a)]],["mapSet", [$h‍_a => (mapSet = $h‍_a)]],["weakmapGet", [$h‍_a => (weakmapGet = $h‍_a)]]]]]);
const { Fail, quote: q}= assert;
// `link` creates `ModuleInstances` and `ModuleNamespaces` for a module and its
// transitive dependencies and connects their imports and exports.
// After linking, the resulting working set is ready to be executed.
// The linker only concerns itself with module namespaces that are objects with
// property descriptors for their exports, which the Compartment proxies with
// the actual `ModuleNamespace`.
const link= (
compartmentPrivateFields,
moduleAliases,
compartment,
moduleSpecifier)=>
{
const { name: compartmentName, moduleRecords}= weakmapGet(
compartmentPrivateFields,
compartment);
const moduleRecord= mapGet(moduleRecords, moduleSpecifier);
if( moduleRecord=== undefined) {
throw ReferenceError(
`Missing link to module ${q(moduleSpecifier)} from compartment ${q(
compartmentName)
}`);
}
// Mutual recursion so there's no confusion about which
// compartment is in context: the module record may be in another
// compartment, denoted by moduleRecord.compartment.
// eslint-disable-next-line no-use-before-define
return instantiate(compartmentPrivateFields, moduleAliases, moduleRecord);
};$h‍_once.link(link);
function mayBePrecompiledModuleSource(moduleSource) {
return typeof moduleSource.__syncModuleProgram__=== 'string';
}
function validatePrecompiledModuleSource(moduleSource, moduleSpecifier) {
const { __fixedExportMap__, __liveExportMap__}= moduleSource;
isObject(__fixedExportMap__)||
Fail `Property '__fixedExportMap__' of a precompiled module source must be an object, got ${q(
__fixedExportMap__)
}, for module ${q(moduleSpecifier)}`;
isObject(__liveExportMap__)||
Fail `Property '__liveExportMap__' of a precompiled module source must be an object, got ${q(
__liveExportMap__)
}, for module ${q(moduleSpecifier)}`;
}
function mayBeVirtualModuleSource(moduleSource) {
return typeof moduleSource.execute=== 'function';
}
function validateVirtualModuleSource(moduleSource, moduleSpecifier) {
const { exports}= moduleSource;
isArray(exports)||
Fail `Property 'exports' of a third-party module source must be an array, got ${q(
exports)
}, for module ${q(moduleSpecifier)}`;
}
function validateModuleSource(moduleSource, moduleSpecifier) {
isObject(moduleSource)||
Fail `Module sources must be of type object, got ${q(
moduleSource)
}, for module ${q(moduleSpecifier)}`;
const { imports, exports, reexports= []}= moduleSource;
isArray(imports)||
Fail `Property 'imports' of a module source must be an array, got ${q(
imports)
}, for module ${q(moduleSpecifier)}`;
isArray(exports)||
Fail `Property 'exports' of a precompiled module source must be an array, got ${q(
exports)
}, for module ${q(moduleSpecifier)}`;
isArray(reexports)||
Fail `Property 'reexports' of a precompiled module source must be an array if present, got ${q(
reexports)
}, for module ${q(moduleSpecifier)}`;
}
const instantiate= (
compartmentPrivateFields,
moduleAliases,
moduleRecord)=>
{
const { compartment, moduleSpecifier, resolvedImports, moduleSource}=
moduleRecord;
const { instances}= weakmapGet(compartmentPrivateFields, compartment);
// Memoize.
if( mapHas(instances, moduleSpecifier)) {
return mapGet(instances, moduleSpecifier);
}
validateModuleSource(moduleSource, moduleSpecifier);
const importedInstances= new Map();
let moduleInstance;
if( mayBePrecompiledModuleSource(moduleSource)) {
validatePrecompiledModuleSource(moduleSource, moduleSpecifier);
moduleInstance= makeModuleInstance(
compartmentPrivateFields,
moduleAliases,
moduleRecord,
importedInstances);
}else if( mayBeVirtualModuleSource(moduleSource)) {
validateVirtualModuleSource(moduleSource, moduleSpecifier);
moduleInstance= makeVirtualModuleInstance(
compartmentPrivateFields,
moduleSource,
compartment,
moduleAliases,
moduleSpecifier,
resolvedImports);
}else {
throw TypeError(
`importHook must provide a module source, got ${q(moduleSource)}`);
}
// Memoize.
mapSet(instances, moduleSpecifier, moduleInstance);
// Link dependency modules.
for( const [importSpecifier, resolvedSpecifier]of entries(resolvedImports)) {
const importedInstance= link(
compartmentPrivateFields,
moduleAliases,
compartment,
resolvedSpecifier);
mapSet(importedInstances, importSpecifier, importedInstance);
}
return moduleInstance;
};$h‍_once.instantiate(instantiate);
})()
,
// === functors[44] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let Map,TypeError,WeakMap,assign,defineProperties,promiseThen,toStringTagSymbol,weakmapGet,weakmapSet,setGlobalObjectSymbolUnscopables,setGlobalObjectConstantProperties,setGlobalObjectMutableProperties,setGlobalObjectEvaluators,assertEqual,sharedGlobalPropertyNames,load,loadNow,link,getDeferredExports,compartmentEvaluate,makeSafeEvaluator;$h‍_imports([["./commons.js", [["Map", [$h‍_a => (Map = $h‍_a)]],["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["WeakMap", [$h‍_a => (WeakMap = $h‍_a)]],["assign", [$h‍_a => (assign = $h‍_a)]],["defineProperties", [$h‍_a => (defineProperties = $h‍_a)]],["promiseThen", [$h‍_a => (promiseThen = $h‍_a)]],["toStringTagSymbol", [$h‍_a => (toStringTagSymbol = $h‍_a)]],["weakmapGet", [$h‍_a => (weakmapGet = $h‍_a)]],["weakmapSet", [$h‍_a => (weakmapSet = $h‍_a)]]]],["./global-object.js", [["setGlobalObjectSymbolUnscopables", [$h‍_a => (setGlobalObjectSymbolUnscopables = $h‍_a)]],["setGlobalObjectConstantProperties", [$h‍_a => (setGlobalObjectConstantProperties = $h‍_a)]],["setGlobalObjectMutableProperties", [$h‍_a => (setGlobalObjectMutableProperties = $h‍_a)]],["setGlobalObjectEvaluators", [$h‍_a => (setGlobalObjectEvaluators = $h‍_a)]]]],["./error/assert.js", [["assertEqual", [$h‍_a => (assertEqual = $h‍_a)]]]],["./permits.js", [["sharedGlobalPropertyNames", [$h‍_a => (sharedGlobalPropertyNames = $h‍_a)]]]],["./module-load.js", [["load", [$h‍_a => (load = $h‍_a)]],["loadNow", [$h‍_a => (loadNow = $h‍_a)]]]],["./module-link.js", [["link", [$h‍_a => (link = $h‍_a)]]]],["./module-proxy.js", [["getDeferredExports", [$h‍_a => (getDeferredExports = $h‍_a)]]]],["./compartment-evaluate.js", [["compartmentEvaluate", [$h‍_a => (compartmentEvaluate = $h‍_a)]]]],["./make-safe-evaluator.js", [["makeSafeEvaluator", [$h‍_a => (makeSafeEvaluator = $h‍_a)]]]]]);
/** @import {ModuleDescriptor} from '../types.js' */
// moduleAliases associates every public module exports namespace with its
// corresponding compartment and specifier so they can be used to link modules
// across compartments.
// The mechanism to thread an alias is to use the compartment.module function
// to obtain the exports namespace of a foreign module and pass it into another
// compartment's moduleMap constructor option.
const moduleAliases= new WeakMap();
// privateFields captures the private state for each compartment.
const privateFields= new WeakMap();
const InertCompartment= function Compartment(
_endowments= {},
_modules= {},
_options= {})
{
throw TypeError(
'Compartment.prototype.constructor is not a valid constructor.');
};
/**
* @param {Compartment} compartment
* @param {string} specifier
*/$h‍_once.InertCompartment(InertCompartment);
const compartmentImportNow= (compartment, specifier)=> {
const { execute, exportsProxy}= link(
privateFields,
moduleAliases,
compartment,
specifier);
execute();
return exportsProxy;
};
const CompartmentPrototype= {
constructor: InertCompartment,
get globalThis() {
return weakmapGet(privateFields, this).globalObject;
},
get name() {
return weakmapGet(privateFields, this).name;
},
/**
* @param {string} source is a JavaScript program grammar construction.
* @param {object} [options]
* @param {Array<import('./lockdown-shim').Transform>} [options.transforms]
* @param {boolean} [options.sloppyGlobalsMode]
* @param {object} [options.__moduleShimLexicals__]
* @param {boolean} [options.__evadeHtmlCommentTest__]
* @param {boolean} [options.__evadeImportExpressionTest__]
* @param {boolean} [options.__rejectSomeDirectEvalExpressions__]
*/
evaluate(source, options= {}) {
const compartmentFields= weakmapGet(privateFields, this);
return compartmentEvaluate(compartmentFields, source, options);
},
module(specifier) {
if( typeof specifier!== 'string') {
throw TypeError('first argument of module() must be a string');
}
const { exportsProxy}= getDeferredExports(
this,
weakmapGet(privateFields, this),
moduleAliases,
specifier);
return exportsProxy;
},
async import(specifier){
const { noNamespaceBox}= weakmapGet(privateFields, this);
if( typeof specifier!== 'string') {
throw TypeError('first argument of import() must be a string');
}
return promiseThen(
load(privateFields, moduleAliases, this, specifier),
()=> {
// The namespace box is a contentious design and likely to be a breaking
// change in an appropriately numbered future version.
const namespace= compartmentImportNow(
/** @type {Compartment} */ this,
specifier);
if( noNamespaceBox) {
return namespace;
}
// Legacy behavior: box the namespace object so that thenable modules
// do not get coerced into a promise accidentally.
return { namespace};
});
},
async load(specifier){
if( typeof specifier!== 'string') {
throw TypeError('first argument of load() must be a string');
}
return load(privateFields, moduleAliases, this, specifier);
},
importNow(specifier) {
if( typeof specifier!== 'string') {
throw TypeError('first argument of importNow() must be a string');
}
loadNow(privateFields, moduleAliases, this, specifier);
return compartmentImportNow(/** @type {Compartment} */ this, specifier);
}};
// This causes `String(new Compartment())` to evaluate to `[object Compartment]`.
// The descriptor follows the conventions of other globals with @@toStringTag
// properties, e.g. Math.
$h‍_once.CompartmentPrototype(CompartmentPrototype);defineProperties(CompartmentPrototype,{
[toStringTagSymbol]: {
value: 'Compartment',
writable: false,
enumerable: false,
configurable: true}});
defineProperties(InertCompartment, {
prototype: { value: CompartmentPrototype}});
/**
* @callback MakeCompartmentConstructor
* @param {MakeCompartmentConstructor} targetMakeCompartmentConstructor
* @param {Record<string, any>} intrinsics
* @param {(object: object) => void} markVirtualizedNativeFunction
* @param {Compartment} [parentCompartment]
* @returns {Compartment['constructor']}
*/
// In order to facilitate migration from the deprecated signature
// of the compartment constructor,
// new Compartent(globals?, modules?, options?)
// to the new signature:
// new Compartment(options?)
// where globals and modules are expressed in the options bag instead of
// positional arguments, this function detects the temporary sigil __options__
// on the first argument and coerces compartments arguments into a single
// compartments object.
const compartmentOptions= (...args)=> {
if( args.length=== 0) {
return {};
}
if(
args.length=== 1&&
typeof args[0]=== 'object'&&
args[0]!== null&&
'__options__'in args[0])
{
const { __options__, ...options}= args[0];
assert(
__options__=== true,
`Compartment constructor only supports true __options__ sigil, got ${__options__}`);
return options;
}else {
const [
globals= /** @type {Map<string, any>} */ {},
modules= /** @type {Map<string, ModuleDescriptor>} */ {},
options= {}]=
args;
assertEqual(
options.modules,
undefined,
`Compartment constructor must receive either a module map argument or modules option, not both`);
assertEqual(
options.globals,
undefined,
`Compartment constructor must receive either globals argument or option, not both`);
return {
...options,
globals,
modules};
}
};
/** @type {MakeCompartmentConstructor} */
const makeCompartmentConstructor= (
targetMakeCompartmentConstructor,
intrinsics,
markVirtualizedNativeFunction,
parentCompartment= undefined)=>
{
function Compartment(...args) {
if( new.target=== undefined) {
throw TypeError(
"Class constructor Compartment cannot be invoked without 'new'");
}
// Extract options, and shallow-clone transforms.
const {
name= '<unknown>',
transforms= [],
__shimTransforms__= [],
globals: endowmentsOption= {},
modules: moduleMapOption= {},
resolveHook,
importHook,
importNowHook,
moduleMapHook,
importMetaHook,
__noNamespaceBox__: noNamespaceBox= false}=
compartmentOptions(...args);
const globalTransforms= [...transforms, ...__shimTransforms__];
const endowments= { __proto__: null, ...endowmentsOption};
const moduleMap= { __proto__: null, ...moduleMapOption};
// Map<FullSpecifier, ModuleCompartmentRecord>
const moduleRecords= new Map();
// Map<FullSpecifier, ModuleInstance>
const instances= new Map();
// Map<FullSpecifier, {ExportsProxy, ProxiedExports, activate()}>
const deferredExports= new Map();
const globalObject= {};
setGlobalObjectSymbolUnscopables(globalObject);
// We must initialize all constant properties first because
// `makeSafeEvaluator` may use them to create optimized bindings
// in the evaluator.
// TODO: consider merging into a single initialization if internal
// evaluator is no longer eagerly created
setGlobalObjectConstantProperties(globalObject);
const { safeEvaluate}= makeSafeEvaluator({
globalObject,
globalTransforms,
sloppyGlobalsMode: false});
setGlobalObjectMutableProperties(globalObject, {
intrinsics,
newGlobalPropertyNames: sharedGlobalPropertyNames,
makeCompartmentConstructor: targetMakeCompartmentConstructor,
parentCompartment: this,
markVirtualizedNativeFunction});
// TODO: maybe add evalTaming to the Compartment constructor 3rd options?
setGlobalObjectEvaluators(
globalObject,
safeEvaluate,
markVirtualizedNativeFunction);
assign(globalObject, endowments);
weakmapSet(privateFields, this, {
name: `${name}`,
globalTransforms,
globalObject,
safeEvaluate,
resolveHook,
importHook,
importNowHook,
moduleMap,
moduleMapHook,
importMetaHook,
moduleRecords,
__shimTransforms__,
deferredExports,
instances,
parentCompartment,
noNamespaceBox});
}
Compartment.prototype= CompartmentPrototype;
return Compartment;
};$h‍_once.makeCompartmentConstructor(makeCompartmentConstructor);
})()
,
// === functors[45] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let FERAL_FUNCTION,Float32Array,Map,Set,String,getOwnPropertyDescriptor,getPrototypeOf,iterateArray,iterateMap,iterateSet,iterateString,matchAllRegExp,matchAllSymbol,regexpPrototype,globalThis,InertCompartment;$h‍_imports([["./commons.js", [["FERAL_FUNCTION", [$h‍_a => (FERAL_FUNCTION = $h‍_a)]],["Float32Array", [$h‍_a => (Float32Array = $h‍_a)]],["Map", [$h‍_a => (Map = $h‍_a)]],["Set", [$h‍_a => (Set = $h‍_a)]],["String", [$h‍_a => (String = $h‍_a)]],["getOwnPropertyDescriptor", [$h‍_a => (getOwnPropertyDescriptor = $h‍_a)]],["getPrototypeOf", [$h‍_a => (getPrototypeOf = $h‍_a)]],["iterateArray", [$h‍_a => (iterateArray = $h‍_a)]],["iterateMap", [$h‍_a => (iterateMap = $h‍_a)]],["iterateSet", [$h‍_a => (iterateSet = $h‍_a)]],["iterateString", [$h‍_a => (iterateString = $h‍_a)]],["matchAllRegExp", [$h‍_a => (matchAllRegExp = $h‍_a)]],["matchAllSymbol", [$h‍_a => (matchAllSymbol = $h‍_a)]],["regexpPrototype", [$h‍_a => (regexpPrototype = $h‍_a)]],["globalThis", [$h‍_a => (globalThis = $h‍_a)]]]],["./compartment.js", [["InertCompartment", [$h‍_a => (InertCompartment = $h‍_a)]]]]]);
/**
* Object.getConstructorOf()
* Helper function to improve readability, similar to Object.getPrototypeOf().
*
* @param {object} obj
*/
function getConstructorOf(obj) {
return getPrototypeOf(obj).constructor;
}
// getAnonymousIntrinsics uses a utility function to construct an arguments
// object, since it cannot have one of its own and also be a const export.
function makeArguments() {
// eslint-disable-next-line prefer-rest-params
return arguments;
}
/**
* getAnonymousIntrinsics()
* Get the intrinsics not otherwise reachable by named own property
* traversal from the global object.
*
* @returns {object}
*/
const getAnonymousIntrinsics= ()=> {
const InertFunction= FERAL_FUNCTION.prototype.constructor;
// 9.2.4.1 %ThrowTypeError%
const argsCalleeDesc= getOwnPropertyDescriptor(makeArguments(), 'callee');
const ThrowTypeError= argsCalleeDesc&& argsCalleeDesc.get;
// 21.1.5.2 The %StringIteratorPrototype% Object
// eslint-disable-next-line no-new-wrappers
const StringIteratorObject= iterateString(new String());
const StringIteratorPrototype= getPrototypeOf(StringIteratorObject);
// 21.2.7.1 The %RegExpStringIteratorPrototype% Object
const RegExpStringIterator=
regexpPrototype[matchAllSymbol]&& matchAllRegExp(/./);
const RegExpStringIteratorPrototype=
RegExpStringIterator&& getPrototypeOf(RegExpStringIterator);
// 22.1.5.2 The %ArrayIteratorPrototype% Object
// eslint-disable-next-line no-array-constructor
const ArrayIteratorObject= iterateArray([]);
const ArrayIteratorPrototype= getPrototypeOf(ArrayIteratorObject);
// 22.2.1 The %TypedArray% Intrinsic Object
const TypedArray= getPrototypeOf(Float32Array);
// 23.1.5.2 The %MapIteratorPrototype% Object
const MapIteratorObject= iterateMap(new Map());
const MapIteratorPrototype= getPrototypeOf(MapIteratorObject);
// 23.2.5.2 The %SetIteratorPrototype% Object
const SetIteratorObject= iterateSet(new Set());
const SetIteratorPrototype= getPrototypeOf(SetIteratorObject);
// 25.1.2 The %IteratorPrototype% Object
const IteratorPrototype= getPrototypeOf(ArrayIteratorPrototype);
// 25.2.1 The GeneratorFunction Constructor
// eslint-disable-next-line no-empty-function
function* GeneratorFunctionInstance() { }
const GeneratorFunction= getConstructorOf(GeneratorFunctionInstance);
// 25.2.3 Properties of the GeneratorFunction Prototype Object
const Generator= GeneratorFunction.prototype;
// 25.3.1 The AsyncGeneratorFunction Constructor
// eslint-disable-next-line no-empty-function
async function* AsyncGeneratorFunctionInstance() { }
const AsyncGeneratorFunction= getConstructorOf(
AsyncGeneratorFunctionInstance);
// 25.3.2.2 AsyncGeneratorFunction.prototype
const AsyncGenerator= AsyncGeneratorFunction.prototype;
// 25.5.1 Properties of the AsyncGenerator Prototype Object
const AsyncGeneratorPrototype= AsyncGenerator.prototype;
const AsyncIteratorPrototype= getPrototypeOf(AsyncGeneratorPrototype);
// 25.7.1 The AsyncFunction Constructor
// eslint-disable-next-line no-empty-function
async function AsyncFunctionInstance() { }
const AsyncFunction= getConstructorOf(AsyncFunctionInstance);
const intrinsics= {
'%InertFunction%': InertFunction,
'%ArrayIteratorPrototype%': ArrayIteratorPrototype,
'%InertAsyncFunction%': AsyncFunction,
'%AsyncGenerator%': AsyncGenerator,
'%InertAsyncGeneratorFunction%': AsyncGeneratorFunction,
'%AsyncGeneratorPrototype%': AsyncGeneratorPrototype,
'%AsyncIteratorPrototype%': AsyncIteratorPrototype,
'%Generator%': Generator,
'%InertGeneratorFunction%': GeneratorFunction,
'%IteratorPrototype%': IteratorPrototype,
'%MapIteratorPrototype%': MapIteratorPrototype,
'%RegExpStringIteratorPrototype%': RegExpStringIteratorPrototype,
'%SetIteratorPrototype%': SetIteratorPrototype,
'%StringIteratorPrototype%': StringIteratorPrototype,
'%ThrowTypeError%': ThrowTypeError,
'%TypedArray%': TypedArray,
'%InertCompartment%': InertCompartment};
if( globalThis.Iterator) {
intrinsics['%IteratorHelperPrototype%']= getPrototypeOf(
// eslint-disable-next-line @endo/no-polymorphic-call
globalThis.Iterator.from([]).take(0));
intrinsics['%WrapForValidIteratorPrototype%']= getPrototypeOf(
// eslint-disable-next-line @endo/no-polymorphic-call
globalThis.Iterator.from({
next() {
return { value: undefined};
}}));
}
if( globalThis.AsyncIterator) {
intrinsics['%AsyncIteratorHelperPrototype%']= getPrototypeOf(
// eslint-disable-next-line @endo/no-polymorphic-call
globalThis.AsyncIterator.from([]).take(0));
intrinsics['%WrapForValidAsyncIteratorPrototype%']= getPrototypeOf(
// eslint-disable-next-line @endo/no-polymorphic-call
globalThis.AsyncIterator.from({ next() { }}));
}
return intrinsics;
};$h‍_once.getAnonymousIntrinsics(getAnonymousIntrinsics);
})()
,
// === functors[46] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let TypeError,freeze;$h‍_imports([["./commons.js", [["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["freeze", [$h‍_a => (freeze = $h‍_a)]]]]]);
/** @import {Harden} from '../types.js'; */
/** @type {(safeHarden: Harden, hardenTaming: 'safe' | 'unsafe') => Harden} */
const tameHarden= (safeHarden, hardenTaming)=> {
if( hardenTaming!== 'safe'&& hardenTaming!== 'unsafe') {
throw TypeError( `unrecognized fakeHardenOption ${hardenTaming}`);
}
if( hardenTaming=== 'safe') {
return safeHarden;
}
// In on the joke
Object.isExtensible= ()=> false;
Object.isFrozen= ()=> true;
Object.isSealed= ()=> true;
Reflect.isExtensible= ()=> false;
// @ts-expect-error secret property
if( safeHarden.isFake) {
// The "safe" hardener is already a fake hardener.
// Just use it.
return safeHarden;
}
const fakeHarden= (arg)=>arg;
fakeHarden.isFake= true;
return freeze(fakeHarden);
};$h‍_once.tameHarden(tameHarden);
freeze(tameHarden);
})()
,
// === functors[47] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let Symbol,entries,fromEntries,getOwnPropertyDescriptors,defineProperties,arrayMap,functionBind;$h‍_imports([["./commons.js", [["Symbol", [$h‍_a => (Symbol = $h‍_a)]],["entries", [$h‍_a => (entries = $h‍_a)]],["fromEntries", [$h‍_a => (fromEntries = $h‍_a)]],["getOwnPropertyDescriptors", [$h‍_a => (getOwnPropertyDescriptors = $h‍_a)]],["defineProperties", [$h‍_a => (defineProperties = $h‍_a)]],["arrayMap", [$h‍_a => (arrayMap = $h‍_a)]],["functionBind", [$h‍_a => (functionBind = $h‍_a)]]]]]);
/**
* This taming provides a tamed alternative to the original `Symbol` constructor
* that starts off identical, except that all its properties are "temporarily"
* configurable. The original `Symbol` constructor remains unmodified on
* the start compartment's global. The tamed alternative is used as the shared
* `Symbol` constructor on constructed compartments.
*
* Starting these properties as configurable assumes two succeeding phases of
* processing: A whitelisting phase, that
* removes all properties not on the whitelist (which requires them to be
* configurable) and a global hardening step that freezes all primordials,
* returning these properties to their expected non-configurable status.
*
* The ses shim is constructed to eventually enable vetted shims to run between
* repair and global hardening. However, such vetted shims would normally
* run in the start compartment, which continues to use the original unmodified
* `Symbol`, so they should not normally be affected by the temporary
* configurability of these properties.
*
* Note that the spec refers to the global `Symbol` function as the
* ["Symbol Constructor"](https://tc39.es/ecma262/multipage/fundamental-objects.html#sec-symbol-constructor)
* even though it has a call behavior (can be called as a function) and does not
* not have a construct behavior (cannot be called with `new`). Accordingly,
* to tame it, we must replace it with a function without a construct
* behavior.
*/
const tameSymbolConstructor= ()=> {
const OriginalSymbol= Symbol;
const SymbolPrototype= OriginalSymbol.prototype;
// Bypass Hermes bug, fixed in: https://github.com/facebook/hermes/commit/00f18c89c720e1c34592bb85a1a8d311e6e99599
// Make a "copy" of the primordial [Symbol "constructor"](https://tc39.es/ecma262/#sec-symbol-description) which maintains all observable behavior. The primordial explicitly throws on `[[Construct]]` and has a `[[Call]]` which ignores the receiver. Binding also maintains the `toString` source as a native function. The `name` is restored below when copying own properties.
const SharedSymbol= functionBind(Symbol, undefined);
defineProperties(SymbolPrototype, {
constructor: {
value: SharedSymbol
// leave other `constructor` attributes as is
}});
const originalDescsEntries= entries(
getOwnPropertyDescriptors(OriginalSymbol));
const descs= fromEntries(
arrayMap(originalDescsEntries, ([name, desc])=> [
name,
{ ...desc, configurable: true}]));
defineProperties(SharedSymbol, descs);
return { '%SharedSymbol%': SharedSymbol};
};$h‍_once.tameSymbolConstructor(tameSymbolConstructor);
})()
,
// === functors[48] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let getOwnPropertyDescriptor,apply,defineProperty,toStringTagSymbol;$h‍_imports([["./commons.js", [["getOwnPropertyDescriptor", [$h‍_a => (getOwnPropertyDescriptor = $h‍_a)]],["apply", [$h‍_a => (apply = $h‍_a)]],["defineProperty", [$h‍_a => (defineProperty = $h‍_a)]],["toStringTagSymbol", [$h‍_a => (toStringTagSymbol = $h‍_a)]]]]]);
const throws= (thunk)=>{
try {
thunk();
return false;
}catch( er) {
return true;
}
};
/**
* Exported for convenience of unit testing. Harmless, but not expected
* to be useful by itself.
*
* @param {any} obj
* @param {string|symbol} prop
* @param {any} expectedValue
* @returns {boolean}
* Returns whether `tameFauxDataProperty` turned the property in question
* from an apparent faux data property into the actual data property it
* seemed to emulate.
* If this function returns `false`, then we hope no effects happened.
* However, sniffing out if an accessor property seems to be a faux data
* property requires invoking the getter and setter functions that might
* possibly have side effects.
* `tameFauxDataProperty` is not in a position to tell.
*/
const tameFauxDataProperty= (obj, prop, expectedValue)=> {
if( obj=== undefined) {
// The object does not exist in this version of the platform
return false;
}
const desc= getOwnPropertyDescriptor(obj, prop);
if( !desc|| 'value'in desc) {
// The property either doesn't exist, or is already an actual data property.
return false;
}
const { get, set}= desc;
if( typeof get!== 'function'|| typeof set!== 'function') {
// A faux data property has both a getter and a setter
return false;
}
if( get()!== expectedValue) {
// The getter called by itself should produce the expectedValue
return false;
}
if( apply(get, obj, [])!== expectedValue) {
// The getter called with `this === obj` should also return the
// expectedValue.
return false;
}
const testValue= 'Seems to be a setter';
const subject1= { __proto__: null};
apply(set, subject1, [testValue]);
if( subject1[prop]!== testValue) {
// The setter called with an unrelated object as `this` should
// set the property on the object.
return false;
}
const subject2= { __proto__: obj};
apply(set, subject2, [testValue]);
if( subject2[prop]!== testValue) {
// The setter called on an object that inherits from `obj` should
// override the property from `obj` as if by assignment.
return false;
}
if( !throws(()=> apply(set, obj, [expectedValue]))) {
// The setter called with `this === obj` should throw without having
// caused any effect.
// This is the test that has the greatest danger of leaving behind some
// persistent side effect. The most obvious one is to emulate a
// successful assignment to the property. That's why this test
// uses `expectedValue`, so that case is likely not to actually
// change anything.
return false;
}
if( 'originalValue'in get) {
// The ses-shim uniquely, as far as we know, puts an `originalValue`
// property on the getter, so that reflect property tranversal algorithms,
// like `harden`, will traverse into the enulated value without
// calling the getter. That does not happen until `permits-intrinsics.js`
// which is much later. So if we see one this early, we should
// not assume we understand what's going on.
return false;
}
// We assume that this code runs before any untrusted code runs, so
// we do not need to worry about the above conditions passing because of
// malicious intent. In fact, it runs even before vetted shims are supposed
// to run, between repair and hardening. Given that, after all these tests
// pass, we have adequately validated that the property in question is
// an accessor function whose purpose is suppressing the override mistake,
// i.e., enabling a non-writable property to be overridden by assignment.
// In that case, here we *temporarily* turn it into the data property
// it seems to emulate, but writable so that it does not trigger the
// override mistake while in this temporary state.
// For those properties that are also listed in `enablements.js`,
// that phase will re-enable override for these properties, but
// via accessor functions that SES controls, so we know what they are
// doing. In addition, the getter functions installed by
// `enable-property-overrides.js` have an `originalValue` field
// enabling meta-traversal code like harden to visit the original value
// without calling the getter.
if( desc.configurable=== false) {
// Even though it seems to be a faux data property, we're unable to fix it.
return false;
}
// Many of the `return false;` cases above plausibly should be turned into
// errors, or an least generate warnings. However, for those, the checks
// following this phase are likely to signal an error anyway.
// At this point, we have passed all our sniff checks for validating that
// it seems to be a faux data property with the expected value. Turn
// it into the actual data property it emulates, but writable so there is
// not yet an override mistake problem.
defineProperty(obj, prop, {
value: expectedValue,
writable: true,
enumerable: desc.enumerable,
configurable: true});
return true;
};
/**
* In JavaScript, the so-called "override mistake" is the inability to
* override an inherited non-writable data property by assignment. A common
* workaround is to instead define an accessor property that acts like
* a non-writable data property, except that it allows an object that
* inherits this property to override it by assignment. Let's call
* an access property that acts this way a "faux data property". In this
* ses-shim, `enable-property-overrides.js` makes the properties listed in
* `enablements.js` into faux data properties.
*
* But the ses-shim is not alone in use of this trick. Starting with the
* [Iterator Helpers proposal](https://github.com/tc39/proposal-iterator-helpers),
* some properties are defined as (what we call) faux data properties.
* Some of these are new properties (`Interator.prototype.constructor`) and
* some are old data properties converted to accessor properties
* (`Iterator.prototype[String.toStringTag]`). So the ses-shim needs to be
* prepared for some enumerated set of properties to already be faux data
* properties in the platform prior to our initialization.
*
* For these possible faux data properties, it is important that
* `permits.js` describe each as a data property, so that it can further
* constrain the apparent value (that allegedly would be returned by the
* getter) according to its own permits.
*
* However, at the time of this writing, the precise behavior specified
* by the iterator-helpers proposal for these faux data properties is
* novel. We should not be too confident that all further such platform
* additions do what we would now expect. So, for each of these possible
* faux data properties, we do some sniffing to see if it behaves as we
* currently expect a faux data property to act. If not, then
* `tameFauxDataProperties` tries not to modify it, leaving it to later
* checks, especially `permits-intrinsics.js`, to error when it sees an
* unexpected accessor.
*
* If one of these enumerated accessor properties does seem to be
* a faithful faux data property, then `tameFauxDataProperties` itself
* *tempoarily* turns it into the actual data property that it seems to emulate.
* This data property starts as writable, so that in this state it will
* not trigger the override mistake, i.e., assignment to an object inheriting
* this property is allowed to succeed at overriding this property.
*
* For those properties that should be a faux data property rather than an
* actual one, such as those from the iterator-helpers proposal,
* they should be listed as such in `enablements.js`, so
* `enable-property-overrides.js` will turn it back into a faux data property.
* But one controlled by the ses-shim, whose behavior we understand.
*
* `tameFauxDataProperties`, which turns these into actual data properties,
* happens during the `repairIntrinsics` phase
* of `lockdown`, before even vetted shim are supposed to run.
* `enable-property-overrides.js` runs after vetted shims, turning the
* appropriate ones back into faux data properties. Thus vetted shims
* can observe the possibly non-conforming state where these are temporarily
* actual data properties, rather than faux data properties.
*
* Coordinate the property enumeration here
* with `enablements.js`, so the appropriate properties are
* turned back to faux data properties.
*
* @param {Record<any,any>} intrinsics
*/$h‍_once.tameFauxDataProperty(tameFauxDataProperty);
const tameFauxDataProperties= (intrinsics)=>{
// https://github.com/tc39/proposal-iterator-helpers
tameFauxDataProperty(
intrinsics['%IteratorPrototype%'],
'constructor',
intrinsics.Iterator);
// https://github.com/tc39/proposal-iterator-helpers
tameFauxDataProperty(
intrinsics['%IteratorPrototype%'],
toStringTagSymbol,
'Iterator');
};$h‍_once.tameFauxDataProperties(tameFauxDataProperties);
})()
,
// === functors[49] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let defineProperty,iteratorPrototype,iteratorSymbol,objectHasOwnProperty;$h‍_imports([["./commons.js", [["defineProperty", [$h‍_a => (defineProperty = $h‍_a)]],["iteratorPrototype", [$h‍_a => (iteratorPrototype = $h‍_a)]],["iteratorSymbol", [$h‍_a => (iteratorSymbol = $h‍_a)]],["objectHasOwnProperty", [$h‍_a => (objectHasOwnProperty = $h‍_a)]]]]]);
const tameRegeneratorRuntime= ()=> {
const iter= iteratorPrototype[iteratorSymbol];
defineProperty(iteratorPrototype, iteratorSymbol, {
configurable: true,
get() {
return iter;
},
set(value) {
// ignore the assignment on IteratorPrototype
if( this=== iteratorPrototype) return;
if( objectHasOwnProperty(this, iteratorSymbol)) {
this[iteratorSymbol]= value;
}
defineProperty(this, iteratorSymbol, {
value,
writable: true,
enumerable: true,
configurable: true});
}});
};$h‍_once.tameRegeneratorRuntime(tameRegeneratorRuntime);
})()
,
// === functors[50] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let getenv,FERAL_FUNCTION,FERAL_EVAL,TypeError,arrayFilter,globalThis,is,ownKeys,stringSplit,noEvalEvaluate,getOwnPropertyNames,getPrototypeOf,makeHardener,makeIntrinsicsCollector,whitelistIntrinsics,tameFunctionConstructors,tameDateConstructor,tameMathObject,tameRegExpConstructor,enablePropertyOverrides,tameLocaleMethods,setGlobalObjectConstantProperties,setGlobalObjectMutableProperties,setGlobalObjectEvaluators,makeSafeEvaluator,initialGlobalPropertyNames,tameFunctionToString,tameDomains,tameConsole,tameErrorConstructor,assert,makeAssert,getAnonymousIntrinsics,makeCompartmentConstructor,tameHarden,tameSymbolConstructor,tameFauxDataProperties,tameRegeneratorRuntime;$h‍_imports([["@endo/env-options", [["getEnvironmentOption", [$h‍_a => (getenv = $h‍_a)]]]],["./commons.js", [["FERAL_FUNCTION", [$h‍_a => (FERAL_FUNCTION = $h‍_a)]],["FERAL_EVAL", [$h‍_a => (FERAL_EVAL = $h‍_a)]],["TypeError", [$h‍_a => (TypeError = $h‍_a)]],["arrayFilter", [$h‍_a => (arrayFilter = $h‍_a)]],["globalThis", [$h‍_a => (globalThis = $h‍_a)]],["is", [$h‍_a => (is = $h‍_a)]],["ownKeys", [$h‍_a => (ownKeys = $h‍_a)]],["stringSplit", [$h‍_a => (stringSplit = $h‍_a)]],["noEvalEvaluate", [$h‍_a => (noEvalEvaluate = $h‍_a)]],["getOwnPropertyNames", [$h‍_a => (getOwnPropertyNames = $h‍_a)]],["getPrototypeOf", [$h‍_a => (getPrototypeOf = $h‍_a)]]]],["./make-hardener.js", [["makeHardener", [$h‍_a => (makeHardener = $h‍_a)]]]],["./intrinsics.js", [["makeIntrinsicsCollector", [$h‍_a => (makeIntrinsicsCollector = $h‍_a)]]]],["./permits-intrinsics.js", [["default", [$h‍_a => (whitelistIntrinsics = $h‍_a)]]]],["./tame-function-constructors.js", [["default", [$h‍_a => (tameFunctionConstructors = $h‍_a)]]]],["./tame-date-constructor.js", [["default", [$h‍_a => (tameDateConstructor = $h‍_a)]]]],["./tame-math-object.js", [["default", [$h‍_a => (tameMathObject = $h‍_a)]]]],["./tame-regexp-constructor.js", [["default", [$h‍_a => (tameRegExpConstructor = $h‍_a)]]]],["./enable-property-overrides.js", [["default", [$h‍_a => (enablePropertyOverrides = $h‍_a)]]]],["./tame-locale-methods.js", [["default", [$h‍_a => (tameLocaleMethods = $h‍_a)]]]],["./global-object.js", [["setGlobalObjectConstantProperties", [$h‍_a => (setGlobalObjectConstantProperties = $h‍_a)]],["setGlobalObjectMutableProperties", [$h‍_a => (setGlobalObjectMutableProperties = $h‍_a)]],["setGlobalObjectEvaluators", [$h‍_a => (setGlobalObjectEvaluators = $h‍_a)]]]],["./make-safe-evaluator.js", [["makeSafeEvaluator", [$h‍_a => (makeSafeEvaluator = $h‍_a)]]]],["./permits.js", [["initialGlobalPropertyNames", [$h‍_a => (initialGlobalPropertyNames = $h‍_a)]]]],["./tame-function-tostring.js", [["tameFunctionToString", [$h‍_a => (tameFunctionToString = $h‍_a)]]]],["./tame-domains.js", [["tameDomains", [$h‍_a => (tameDomains = $h‍_a)]]]],["./error/tame-console.js", [["tameConsole", [$h‍_a => (tameConsole = $h‍_a)]]]],["./error/tame-error-constructor.js", [["default", [$h‍_a => (tameErrorConstructor = $h‍_a)]]]],["./error/assert.js", [["assert", [$h‍_a => (assert = $h‍_a)]],["makeAssert", [$h‍_a => (makeAssert = $h‍_a)]]]],["./get-anonymous-intrinsics.js", [["getAnonymousIntrinsics", [$h‍_a => (getAnonymousIntrinsics = $h‍_a)]]]],["./compartment.js", [["makeCompartmentConstructor", [$h‍_a => (makeCompartmentConstructor = $h‍_a)]]]],["./tame-harden.js", [["tameHarden", [$h‍_a => (tameHarden = $h‍_a)]]]],["./tame-symbol-constructor.js", [["tameSymbolConstructor", [$h‍_a => (tameSymbolConstructor = $h‍_a)]]]],["./tame-faux-data-properties.js", [["tameFauxDataProperties", [$h‍_a => (tameFauxDataProperties = $h‍_a)]]]],["./tame-regenerator-runtime.js", [["tameRegeneratorRuntime", [$h‍_a => (tameRegeneratorRuntime = $h‍_a)]]]]]);
/** @import {LockdownOptions} from '../types.js' */
const { Fail, details: X, quote: q}= assert;
/** @type {Error=} */
let priorRepairIntrinsics;
/** @type {Error=} */
let priorHardenIntrinsics;
// Build a harden() with an empty fringe.
// Gate it on lockdown.
/**
* @template T
* @param {T} ref
* @returns {T}
*/
const safeHarden= makeHardener();
/**
* @callback Transform
* @param {string} source
* @returns {string}
*/
/**
* @callback CompartmentConstructor
* @param {object} endowments
* @param {object} moduleMap
* @param {object} [options]
* @param {Array<Transform>} [options.transforms]
* @param {Array<Transform>} [options.__shimTransforms__]
*/
// TODO https://github.com/endojs/endo/issues/814
// Lockdown currently allows multiple calls provided that the specified options
// of every call agree. With experience, we have observed that lockdown should
// only ever need to be called once and that simplifying lockdown will improve
// the quality of audits.
const assertDirectEvalAvailable= ()=> {
let allowed= false;
try {
allowed= FERAL_FUNCTION(
'eval',
'SES_changed',
`\
eval("SES_changed = true");
return SES_changed;
`)(
FERAL_EVAL, false);
// If we get here and SES_changed stayed false, that means the eval was sloppy
// and indirect, which generally creates a new global.
// We are going to throw an exception for failing to initialize SES, but
// good neighbors clean up.
if( !allowed) {
delete globalThis.SES_changed;
}
}catch( _error) {
// We reach here if eval is outright forbidden by a Content Security Policy.
// We allow this for SES usage that delegates the responsibility to isolate
// guest code to production code generation.
allowed= true;
}
if( !allowed) {
// See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_DIRECT_EVAL.md
throw TypeError(
`SES cannot initialize unless 'eval' is the original intrinsic 'eval', suitable for direct-eval (dynamically scoped eval) (SES_DIRECT_EVAL)`);
}
};
/**
* @param {LockdownOptions} [options]
*/
const repairIntrinsics= (options= {})=> {
// First time, absent options default to 'safe'.
// Subsequent times, absent options default to first options.
// Thus, all present options must agree with first options.
// Reconstructing `option` here also ensures that it is a well
// behaved record, with only own data properties.
//
// The `overrideTaming` is not a safety issue. Rather it is a tradeoff
// between code compatibility, which is better with the `'moderate'`
// setting, and tool compatibility, which is better with the `'min'`
// setting. See
// https://github.com/Agoric/SES-shim/blob/master/packages/ses/README.md#enabling-override-by-assignment)
// for an explanation of when to use which.
//
// The `stackFiltering` is not a safety issue. Rather it is a tradeoff
// between relevance and completeness of the stack frames shown on the
// console. Setting`stackFiltering` to `'verbose'` applies no filters, providing
// the raw stack frames that can be quite versbose. Setting
// `stackFrameFiltering` to`'concise'` limits the display to the stack frame
// information most likely to be relevant, eliminating distracting frames
// such as those from the infrastructure. However, the bug you're trying to
// track down might be in the infrastrure, in which case the `'verbose'` setting
// is useful. See
// [`stackFiltering` options](https://github.com/Agoric/SES-shim/blob/master/packages/ses/docs/lockdown.md#stackfiltering-options)
// for an explanation.
const {
errorTaming= getenv('LOCKDOWN_ERROR_TAMING', 'safe'),
errorTrapping= /** @type {"platform" | "none" | "report" | "abort" | "exit" | undefined} */
getenv('LOCKDOWN_ERROR_TRAPPING', 'platform'),
unhandledRejectionTrapping= /** @type {"none" | "report" | undefined} */
getenv('LOCKDOWN_UNHANDLED_REJECTION_TRAPPING', 'report'),
regExpTaming= getenv('LOCKDOWN_REGEXP_TAMING', 'safe'),
localeTaming= getenv('LOCKDOWN_LOCALE_TAMING', 'safe'),
consoleTaming= /** @type {'unsafe' | 'safe' | undefined} */
getenv('LOCKDOWN_CONSOLE_TAMING', 'safe'),
overrideTaming= getenv('LOCKDOWN_OVERRIDE_TAMING', 'moderate'),
stackFiltering= getenv('LOCKDOWN_STACK_FILTERING', 'concise'),
domainTaming= getenv('LOCKDOWN_DOMAIN_TAMING', 'safe'),
evalTaming= getenv('LOCKDOWN_EVAL_TAMING', 'safeEval'),
overrideDebug= arrayFilter(
stringSplit(getenv('LOCKDOWN_OVERRIDE_DEBUG', ''), ','),
/** @param {string} debugName */
(debugName)=>debugName!== ''),
legacyRegeneratorRuntimeTaming= getenv(
'LOCKDOWN_LEGACY_REGENERATOR_RUNTIME_TAMING',
'safe'),
__hardenTaming__= getenv('LOCKDOWN_HARDEN_TAMING', 'safe'),
dateTaming= 'safe', // deprecated
mathTaming= 'safe', // deprecated
...extraOptions}=
options;
legacyRegeneratorRuntimeTaming=== 'safe'||
legacyRegeneratorRuntimeTaming=== 'unsafe-ignore'||
Fail `lockdown(): non supported option legacyRegeneratorRuntimeTaming: ${q(legacyRegeneratorRuntimeTaming)}`;
evalTaming=== 'unsafeEval'||
evalTaming=== 'safeEval'||
evalTaming=== 'noEval'||
Fail `lockdown(): non supported option evalTaming: ${q(evalTaming)}`;
// Assert that only supported options were passed.
// Use Reflect.ownKeys to reject symbol-named properties as well.
const extraOptionsNames= ownKeys(extraOptions);
extraOptionsNames.length=== 0||
Fail `lockdown(): non supported option ${q(extraOptionsNames)}`;
priorRepairIntrinsics=== undefined||
// eslint-disable-next-line @endo/no-polymorphic-call
assert.fail(
X `Already locked down at ${priorRepairIntrinsics} (SES_ALREADY_LOCKED_DOWN)`,
TypeError);
// See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_ALREADY_LOCKED_DOWN.md
priorRepairIntrinsics= TypeError('Prior lockdown (SES_ALREADY_LOCKED_DOWN)');
// Tease V8 to generate the stack string and release the closures the stack
// trace retained:
priorRepairIntrinsics.stack;
assertDirectEvalAvailable();
/**
* Because of packagers and bundlers, etc, multiple invocations of lockdown
* might happen in separate instantiations of the source of this module.
* In that case, each one sees its own `firstOptions` variable, so the test
* above will not detect that lockdown has already happened. We
* unreliably test some telltale signs that lockdown has run, to avoid
* trying to lock down a locked down environment. Although the test is
* unreliable, this is consistent with the SES threat model. SES provides
* security only if it runs first in a given realm, or if everything that
* runs before it is SES-aware and cooperative. Neither SES nor anything
* can protect itself from corrupting code that runs first. For these
* purposes, code that turns a realm into something that passes these
* tests without actually locking down counts as corrupting code.
*
* The specifics of what this tests for may change over time, but it
* should be consistent with any setting of the lockdown options.
*/
const seemsToBeLockedDown= ()=> {
return(
globalThis.Function.prototype.constructor!== globalThis.Function&&
// @ts-ignore harden is absent on globalThis type def.
typeof globalThis.harden=== 'function'&&
// @ts-ignore lockdown is absent on globalThis type def.
typeof globalThis.lockdown=== 'function'&&
globalThis.Date.prototype.constructor!== globalThis.Date&&
typeof globalThis.Date.now=== 'function'&&
// @ts-ignore does not recognize that Date constructor is a special
// Function.
// eslint-disable-next-line @endo/no-polymorphic-call
is(globalThis.Date.prototype.constructor.now(), NaN));
};
if( seemsToBeLockedDown()) {
// See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_MULTIPLE_INSTANCES.md
throw TypeError(
`Already locked down but not by this SES instance (SES_MULTIPLE_INSTANCES)`);
}
/**
* 1. TAME powers & gather intrinsics first.
*/
tameDomains(domainTaming);
// Replace Function.prototype.toString with one that recognizes
// shimmed functions as honorary native functions.
const markVirtualizedNativeFunction= tameFunctionToString();
const { addIntrinsics, completePrototypes, finalIntrinsics}=
makeIntrinsicsCollector();
// @ts-expect-error __hardenTaming__ could be any string
const tamedHarden= tameHarden(safeHarden, __hardenTaming__);
addIntrinsics({ harden: tamedHarden});
addIntrinsics(tameFunctionConstructors());
addIntrinsics(tameDateConstructor(dateTaming));
addIntrinsics(tameErrorConstructor(errorTaming, stackFiltering));
addIntrinsics(tameMathObject(mathTaming));
addIntrinsics(tameRegExpConstructor(regExpTaming));
addIntrinsics(tameSymbolConstructor());
addIntrinsics(getAnonymousIntrinsics());
completePrototypes();
const intrinsics= finalIntrinsics();
const hostIntrinsics= { __proto__: null};
// The Node.js Buffer is a derived class of Uint8Array, and as such is often
// passed around where a Uint8Array is expected.
if( typeof globalThis.Buffer=== 'function') {
hostIntrinsics.Buffer= globalThis.Buffer;
}
/**
* Wrap console unless suppressed.
* At the moment, the console is considered a host power in the start
* compartment, and not a primordial. Hence it is absent from the whilelist
* and bypasses the intrinsicsCollector.
*
* @type {((error: any) => string | undefined) | undefined}
*/
let optGetStackString;
if( errorTaming=== 'safe') {
optGetStackString= intrinsics['%InitialGetStackString%'];
}
const consoleRecord= tameConsole(
consoleTaming,
errorTrapping,
unhandledRejectionTrapping,
optGetStackString);
globalThis.console= /** @type {Console} */ consoleRecord.console;
// The untamed Node.js console cannot itself be hardened as it has mutable
// internal properties, but some of these properties expose internal versions
// of classes from node's "primordials" concept.
// eslint-disable-next-line no-underscore-dangle
if( typeof /** @type {any} */ consoleRecord.console. _times=== 'object') {
// SafeMap is a derived Map class used internally by Node
// There doesn't seem to be a cleaner way to reach it.
hostIntrinsics.SafeMap= getPrototypeOf(
// eslint-disable-next-line no-underscore-dangle
/** @type {any} */ consoleRecord.console. _times);
}
// @ts-ignore assert is absent on globalThis type def.
if(
(errorTaming=== 'unsafe'|| errorTaming=== 'unsafe-debug')&&
globalThis.assert=== assert)
{
// If errorTaming is 'unsafe' or 'unsafe-debug' we replace the
// global assert with
// one whose `details` template literal tag does not redact
// unmarked substitution values. IOW, it blabs information that
// was supposed to be secret from callers, as an aid to debugging
// at a further cost in safety.
// @ts-ignore assert is absent on globalThis type def.
globalThis.assert= makeAssert(undefined, true);
}
// Replace *Locale* methods with their non-locale equivalents
tameLocaleMethods(intrinsics, localeTaming);
tameFauxDataProperties(intrinsics);
/**
* 2. WHITELIST to standardize the environment.
*/
// Remove non-standard properties.
// All remaining function encountered during whitelisting are
// branded as honorary native functions.
whitelistIntrinsics(intrinsics, markVirtualizedNativeFunction);
// Initialize the powerful initial global, i.e., the global of the
// start compartment, from the intrinsics.
setGlobalObjectConstantProperties(globalThis);
setGlobalObjectMutableProperties(globalThis, {
intrinsics,
newGlobalPropertyNames: initialGlobalPropertyNames,
makeCompartmentConstructor,
markVirtualizedNativeFunction});
if( evalTaming=== 'noEval') {
setGlobalObjectEvaluators(
globalThis,
noEvalEvaluate,
markVirtualizedNativeFunction);
}else if( evalTaming=== 'safeEval') {
const { safeEvaluate}= makeSafeEvaluator({ globalObject: globalThis});
setGlobalObjectEvaluators(
globalThis,
safeEvaluate,
markVirtualizedNativeFunction);
}else if( evalTaming=== 'unsafeEval') {
// Leave eval function and Function constructor of the initial compartment in-tact.
// Other compartments will not have access to these evaluators unless a guest program
// escapes containment.
}
/**
* 3. HARDEN to share the intrinsics.
*
* We define hardenIntrinsics here so that options are in scope, but return
* it to the caller because we intend to eventually allow vetted shims to run
* between repairs and the hardening of intrinsics and so we can benchmark
* repair separately from hardening.
*/
const hardenIntrinsics= ()=> {
priorHardenIntrinsics=== undefined||
// eslint-disable-next-line @endo/no-polymorphic-call
assert.fail(
X `Already locked down at ${priorHardenIntrinsics} (SES_ALREADY_LOCKED_DOWN)`,
TypeError);
// See https://github.com/endojs/endo/blob/master/packages/ses/error-codes/SES_ALREADY_LOCKED_DOWN.md
priorHardenIntrinsics= TypeError(
'Prior lockdown (SES_ALREADY_LOCKED_DOWN)');
// Tease V8 to generate the stack string and release the closures the stack
// trace retained:
priorHardenIntrinsics.stack;
// Circumvent the override mistake.
// TODO consider moving this to the end of the repair phase, and
// therefore before vetted shims rather than afterwards. It is not
// clear yet which is better.
// @ts-ignore enablePropertyOverrides does its own input validation
enablePropertyOverrides(intrinsics, overrideTaming, overrideDebug);
if( legacyRegeneratorRuntimeTaming=== 'unsafe-ignore') {
tameRegeneratorRuntime();
}
// Finally register and optionally freeze all the intrinsics. This
// must be the operation that modifies the intrinsics.
const toHarden= {
intrinsics,
hostIntrinsics,
globals: {
// Harden evaluators
Function: globalThis.Function,
eval: globalThis.eval,
// @ts-ignore Compartment does exist on globalThis
Compartment: globalThis.Compartment,
// Harden Symbol
Symbol: globalThis.Symbol}};
// Harden Symbol and properties for initialGlobalPropertyNames in the host realm
for( const prop of getOwnPropertyNames(initialGlobalPropertyNames)) {
toHarden.globals[prop]= globalThis[prop];
}
tamedHarden(toHarden);
return tamedHarden;
};
return hardenIntrinsics;
};$h‍_once.repairIntrinsics(repairIntrinsics);
})()
,
// === functors[51] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let globalThis,repairIntrinsics;$h‍_imports([["./assert-sloppy-mode.js", []],["./commons.js", [["globalThis", [$h‍_a => (globalThis = $h‍_a)]]]],["./lockdown.js", [["repairIntrinsics", [$h‍_a => (repairIntrinsics = $h‍_a)]]]]]);
/** @import {LockdownOptions} from '../types.js' */
/**
* @param {LockdownOptions} [options]
*/
globalThis.lockdown= (options)=>{
const hardenIntrinsics= repairIntrinsics(options);
globalThis.harden= hardenIntrinsics();
};
/**
* @param {LockdownOptions} [options]
*/
globalThis.repairIntrinsics= (options)=>{
const hardenIntrinsics= repairIntrinsics(options);
// Reveal hardenIntrinsics after repairs.
globalThis.hardenIntrinsics= ()=> {
// Reveal harden after hardenIntrinsics.
// Harden is dangerous before hardenIntrinsics because hardening just
// about anything will inadvertently render intrinsics irreparable.
// Also, for modules that must work both before or after lockdown (code
// that is portable between JS and SES), the existence of harden in global
// scope signals whether such code should attempt to use harden in the
// defense of its own API.
// @ts-ignore harden not yet recognized on globalThis.
globalThis.harden= hardenIntrinsics();
};
};
})()
,
// === functors[52] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let globalThis,makeCompartmentConstructor,tameFunctionToString,getGlobalIntrinsics;$h‍_imports([["./commons.js", [["globalThis", [$h‍_a => (globalThis = $h‍_a)]]]],["./compartment.js", [["makeCompartmentConstructor", [$h‍_a => (makeCompartmentConstructor = $h‍_a)]]]],["./tame-function-tostring.js", [["tameFunctionToString", [$h‍_a => (tameFunctionToString = $h‍_a)]]]],["./intrinsics.js", [["getGlobalIntrinsics", [$h‍_a => (getGlobalIntrinsics = $h‍_a)]]]]]);
const markVirtualizedNativeFunction= tameFunctionToString();
// @ts-ignore Compartment is definitely on globalThis.
globalThis.Compartment= makeCompartmentConstructor(
makeCompartmentConstructor,
getGlobalIntrinsics(globalThis),
markVirtualizedNativeFunction);
})()
,
// === functors[53] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let globalThis,assert;$h‍_imports([["./commons.js", [["globalThis", [$h‍_a => (globalThis = $h‍_a)]]]],["./error/assert.js", [["assert", [$h‍_a => (assert = $h‍_a)]]]]]);
globalThis.assert= assert;
})()
,
// === functors[54] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; let symbolFor,globalThis,defineCausalConsoleFromLogger,loggedErrorHandler;$h‍_imports([["./commons.js", [["symbolFor", [$h‍_a => (symbolFor = $h‍_a)]],["globalThis", [$h‍_a => (globalThis = $h‍_a)]]]],["./error/console.js", [["defineCausalConsoleFromLogger", [$h‍_a => (defineCausalConsoleFromLogger = $h‍_a)]]]],["./error/assert.js", [["loggedErrorHandler", [$h‍_a => (loggedErrorHandler = $h‍_a)]]]]]);
// TODO possible additional exports. Some are privileged.
// export { loggedErrorHandler };
// export {
// makeCausalConsole,
// consoleLevelMethods,
// consoleOtherMethods,
// makeLoggingConsoleKit,
// filterConsole,
// pumpLogToConsole,
// } from './src/error/console.js';
// export { assertLogs, throwsAndLogs } from './src/error/throws-and-logs.js';
/**
* Makes a Console like the
* [SES causal `console`](https://github.com/endojs/endo/blob/master/packages/ses/src/error/README.md)
* but whose output is redirected to the supplied `logger` function.
*/
const makeCausalConsoleFromLoggerForSesAva=
defineCausalConsoleFromLogger(loggedErrorHandler);
/**
*`makeCausalConsoleFromLoggerForSesAva` is privileged because it exposes
* unredacted error info onto the `Logger` provided by the caller. It
* should not be made available to non-privileged code.
*
* Further, we consider this particular API choice to be experimental
* and may change in the future. It is currently only intended for use by
* `@endo/ses-ava`, with which it will be co-maintained.
*
* Thus, this `console-shim.js` makes `makeCausalConsoleFromLoggerForSesAva`
* available on `globalThis` which it *assumes* is the global of the start
* compartment and is therefore allowed to hold powers that should not be
* available in constructed compartments. It makes it available as the value of
* a global property named by a registered symbol named
* `MAKE_CAUSAL_CONSOLE_FROM_LOGGER_KEY_FOR_SES_AVA`.
*
* Anyone accessing this, including `@endo/ses-ava`, should feature test for
* this and be tolerant of its absence. It may indeed disappear from later
* versions of the ses-shim.
*/
const MAKE_CAUSAL_CONSOLE_FROM_LOGGER_KEY_FOR_SES_AVA= symbolFor(
'MAKE_CAUSAL_CONSOLE_FROM_LOGGER_KEY_FOR_SES_AVA');
globalThis[MAKE_CAUSAL_CONSOLE_FROM_LOGGER_KEY_FOR_SES_AVA]=
makeCausalConsoleFromLoggerForSesAva;
})()
,
// === functors[55] ===
({ imports: $h‍_imports, liveVar: $h‍_live, onceVar: $h‍_once, importMeta: $h‍____meta, }) => (function () { 'use strict'; $h‍_imports([["./src/lockdown-shim.js", []],["./src/compartment-shim.js", []],["./src/assert-shim.js", []],["./src/console-shim.js", []]]);
})()
,
]);
;/*! end SES */
/******/ var self = self || this || new Function("return this")() || ({}); // repackGlobal'
/******/
/******/ (function() { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ 4478:
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _getDevServerLocation2=__webpack_require__(4925);var _getDevServerLocation=(0,_getDevServerLocation2.getDevServerLocation)(),hostname=_getDevServerLocation.hostname;__webpack_require__.p=__webpack_require__.p.replace('localhost',hostname);
};
}
}
}
}).call(__webpack_require__._LM_("2", { __webpack_require__}))()
/***/ }),
/***/ 4925:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports.getDevServerLocation=getDevServerLocation;var _getDevServer2=_interopRequireDefault(__webpack_require__(2050));var location;function getDevServerLocation(){if(!location){var _getDevServer=(0,_getDevServer2.default)(),url=_getDevServer.url;var origin=url.replace(/\/$/,'');var host=origin.replace(/https?:\/\//,'');location={host:host,hostname:host.split(':')[0],href:url,origin:origin,pathname:url.split(host)[1],port:host.split(':')[1],protocol:(url.match(/^([a-z])+:\/\//)||[undefined,undefined])[1]};}return location;}
};
}
}
}
}).call(__webpack_require__._LM_("2", { exports,__webpack_require__}))()
/***/ }),
/***/ 5568:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var androidScaleSuffix={'0.75':'ldpi','1':'mdpi','1.5':'hdpi','2':'xhdpi','3':'xxhdpi','4':'xxxhdpi'};var ANDROID_BASE_DENSITY=160;function getAndroidAssetSuffix(scale){if(scale.toString()in androidScaleSuffix){return androidScaleSuffix[scale.toString()];}if(Number.isFinite(scale)&&scale>0){return Math.round(scale*ANDROID_BASE_DENSITY)+'dpi';}throw new Error('no such scale '+scale.toString());}var drawableFileTypes=new Set(['gif','jpeg','jpg','ktx','png','svg','webp','xml']);function getAndroidResourceFolderName(asset,scale){if(!drawableFileTypes.has(asset.type)){return'raw';}var suffix=getAndroidAssetSuffix(scale);if(!suffix){throw new Error("Don't know which android drawable suffix to use for scale: "+scale+'\nAsset: '+JSON.stringify(asset,null,'\t')+'\nPossible scales are:'+JSON.stringify(androidScaleSuffix,null,'\t'));}return'drawable-'+suffix;}function getAndroidResourceIdentifier(asset){return(getBasePath(asset)+'/'+asset.name).toLowerCase().replace(/\//g,'_').replace(/([^a-z0-9_])/g,'').replace(/^assets_/,'');}function getBasePath(asset){var basePath=asset.httpServerLocation;return basePath.startsWith('/')?basePath.substr(1):basePath;}module.exports={getAndroidResourceFolderName:getAndroidResourceFolderName,getAndroidResourceIdentifier:getAndroidResourceIdentifier,getBasePath:getBasePath};
};
}
}
}
}).call(__webpack_require__._LM_("undefined", { module,__webpack_require__}))()
/***/ }),
/***/ 914:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var assets=[];function registerAsset(asset){return assets.push(asset);}function getAssetByID(assetId){return assets[assetId-1];}module.exports={registerAsset:registerAsset,getAssetByID:getAssetByID};
};
}
}
}
}).call(__webpack_require__._LM_("undefined", { module,__webpack_require__}))()
/***/ }),
/***/ 1839:
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
(function(){'use strict';var hasOwnProperty=Object.prototype.hasOwnProperty;if(typeof Object.entries!=='function'){Object.entries=function(object){if(object==null){throw new TypeError('Object.entries called on non-object');}var entries=[];for(var key in object){if(hasOwnProperty.call(object,key)){entries.push([key,object[key]]);}}return entries;};}if(typeof Object.values!=='function'){Object.values=function(object){if(object==null){throw new TypeError('Object.values called on non-object');}var values=[];for(var key in object){if(hasOwnProperty.call(object,key)){values.push(object[key]);}}return values;};}})();
};
}
}
}
}).call(__webpack_require__._LM_("5", { __webpack_require__}))()
/***/ }),
/***/ 9781:
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var inspect=function(){function inspect(obj,opts){var ctx={seen:[],formatValueCalls:0,stylize:stylizeNoColor};return formatValue(ctx,obj,opts.depth);}function stylizeNoColor(str,styleType){return str;}function arrayToHash(array){var hash={};array.forEach(function(val,idx){hash[val]=true;});return hash;}function formatValue(ctx,value,recurseTimes){ctx.formatValueCalls++;if(ctx.formatValueCalls>200){return`[TOO BIG formatValueCalls ${ctx.formatValueCalls} exceeded limit of 200]`;}var primitive=formatPrimitive(ctx,value);if(primitive){return primitive;}var keys=Object.keys(value);var visibleKeys=arrayToHash(keys);if(isError(value)&&(keys.indexOf('message')>=0||keys.indexOf('description')>=0)){return formatError(value);}if(keys.length===0){if(isFunction(value)){var name=value.name?': '+value.name:'';return ctx.stylize('[Function'+name+']','special');}if(isRegExp(value)){return ctx.stylize(RegExp.prototype.toString.call(value),'regexp');}if(isDate(value)){return ctx.stylize(Date.prototype.toString.call(value),'date');}if(isError(value)){return formatError(value);}}var base='',array=false,braces=['{','}'];if(isArray(value)){array=true;braces=['[',']'];}if(isFunction(value)){var n=value.name?': '+value.name:'';base=' [Function'+n+']';}if(isRegExp(value)){base=' '+RegExp.prototype.toString.call(value);}if(isDate(value)){base=' '+Date.prototype.toUTCString.call(value);}if(isError(value)){base=' '+formatError(value);}if(keys.length===0&&(!array||value.length==0)){return braces[0]+base+braces[1];}if(recurseTimes<0){if(isRegExp(value)){return ctx.stylize(RegExp.prototype.toString.call(value),'regexp');}else{return ctx.stylize('[Object]','special');}}ctx.seen.push(value);var output;if(array){output=formatArray(ctx,value,recurseTimes,visibleKeys,keys);}else{output=keys.map(function(key){return formatProperty(ctx,value,recurseTimes,visibleKeys,key,array);});}ctx.seen.pop();return reduceToSingleString(output,base,braces);}function formatPrimitive(ctx,value){if(isUndefined(value))return ctx.stylize('undefined','undefined');if(isString(value)){var simple="'"+JSON.stringify(value).replace(/^"|"$/g,'').replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return ctx.stylize(simple,'string');}if(isNumber(value))return ctx.stylize(''+value,'number');if(isBoolean(value))return ctx.stylize(''+value,'boolean');if(isNull(value))return ctx.stylize('null','null');}function formatError(value){return'['+Error.prototype.toString.call(value)+']';}function formatArray(ctx,value,recurseTimes,visibleKeys,keys){var output=[];for(var i=0,l=value.length;i<l;++i){if(hasOwnProperty(value,String(i))){output.push(formatProperty(ctx,value,recurseTimes,visibleKeys,String(i),true));}else{output.push('');}}keys.forEach(function(key){if(!key.match(/^\d+$/)){output.push(formatProperty(ctx,value,recurseTimes,visibleKeys,key,true));}});return output;}function formatProperty(ctx,value,recurseTimes,visibleKeys,key,array){var name,str,desc;desc=Object.getOwnPropertyDescriptor(value,key)||{value:value[key]};if(desc.get){if(desc.set){str=ctx.stylize('[Getter/Setter]','special');}else{str=ctx.stylize('[Getter]','special');}}else{if(desc.set){str=ctx.stylize('[Setter]','special');}}if(!hasOwnProperty(visibleKeys,key)){name='['+key+']';}if(!str){if(ctx.seen.indexOf(desc.value)<0){if(isNull(recurseTimes)){str=formatValue(ctx,desc.value,null);}else{str=formatValue(ctx,desc.value,recurseTimes-1);}if(str.indexOf('\n')>-1){if(array){str=str.split('\n').map(function(line){return' '+line;}).join('\n').substr(2);}else{str='\n'+str.split('\n').map(function(line){return' '+line;}).join('\n');}}}else{str=ctx.stylize('[Circular]','special');}}if(isUndefined(name)){if(array&&key.match(/^\d+$/)){return str;}name=JSON.stringify(''+key);if(name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)){name=name.substr(1,name.length-2);name=ctx.stylize(name,'name');}else{name=name.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'");name=ctx.stylize(name,'string');}}return name+': '+str;}function reduceToSingleString(output,base,braces){var numLinesEst=0;var length=output.reduce(function(prev,cur){numLinesEst++;if(cur.indexOf('\n')>=0)numLinesEst++;return prev+cur.replace(/\u001b\[\d\d?m/g,'').length+1;},0);if(length>60){return braces[0]+(base===''?'':base+'\n ')+' '+output.join(',\n ')+' '+braces[1];}return braces[0]+base+' '+output.join(', ')+' '+braces[1];}function isArray(ar){return Array.isArray(ar);}function isBoolean(arg){return typeof arg==='boolean';}function isNull(arg){return arg===null;}function isNullOrUndefined(arg){return arg==null;}function isNumber(arg){return typeof arg==='number';}function isString(arg){return typeof arg==='string';}function isSymbol(arg){return typeof arg==='symbol';}function isUndefined(arg){return arg===void 0;}function isRegExp(re){return isObject(re)&&objectToString(re)==='[object RegExp]';}function isObject(arg){return typeof arg==='object'&&arg!==null;}function isDate(d){return isObject(d)&&objectToString(d)==='[object Date]';}function isError(e){return isObject(e)&&(objectToString(e)==='[object Error]'||e instanceof Error);}function isFunction(arg){return typeof arg==='function';}function objectToString(o){return Object.prototype.toString.call(o);}function hasOwnProperty(obj,prop){return Object.prototype.hasOwnProperty.call(obj,prop);}return inspect;}();var OBJECT_COLUMN_NAME='(index)';var LOG_LEVELS={trace:0,info:1,warn:2,error:3};var INSPECTOR_LEVELS=[];INSPECTOR_LEVELS[LOG_LEVELS.trace]='debug';INSPECTOR_LEVELS[LOG_LEVELS.info]='log';INSPECTOR_LEVELS[LOG_LEVELS.warn]='warning';INSPECTOR_LEVELS[LOG_LEVELS.error]='error';var INSPECTOR_FRAMES_TO_SKIP= false?0:1;function getNativeLogFunction(level){return function(){var str;if(arguments.length===1&&typeof arguments[0]==='string'){str=arguments[0];}else{str=Array.prototype.map.call(arguments,function(arg){return inspect(arg,{depth:10});}).join(', ');}var firstArg=arguments[0];var logLevel=level;if(typeof firstArg==='string'&&firstArg.slice(0,9)==='Warning: '&&logLevel>=LOG_LEVELS.error){logLevel=LOG_LEVELS.warn;}if(__webpack_require__.g.__inspectorLog){__webpack_require__.g.__inspectorLog(INSPECTOR_LEVELS[logLevel],str,[].slice.call(arguments),INSPECTOR_FRAMES_TO_SKIP);}if(groupStack.length){str=groupFormat('',str);}__webpack_require__.g.nativeLoggingHook(str,logLevel);};}function repeat(element,n){return Array.apply(null,Array(n)).map(function(){return element;});}function consoleTablePolyfill(rows){if(!Array.isArray(rows)){var data=rows;rows=[];for(var key in data){if(data.hasOwnProperty(key)){var row=data[key];row[OBJECT_COLUMN_NAME]=key;rows.push(row);}}}if(rows.length===0){__webpack_require__.g.nativeLoggingHook('',LOG_LEVELS.info);return;}var columns=Object.keys(rows[0]).sort();var stringRows=[];var columnWidths=[];columns.forEach(function(k,i){columnWidths[i]=k.length;for(var j=0;j<rows.length;j++){var cellStr=(rows[j][k]||'?').toString();stringRows[j]=stringRows[j]||[];stringRows[j][i]=cellStr;columnWidths[i]=Math.max(columnWidths[i],cellStr.length);}});function joinRow(row,space){var cells=row.map(function(cell,i){var extraSpaces=repeat(' ',columnWidths[i]-cell.length).join('');return cell+extraSpaces;});space=space||' ';return cells.join(space+'|'+space);}var separators=columnWidths.map(function(columnWidth){return repeat('-',columnWidth).join('');});var separatorRow=joinRow(separators,'-');var header=joinRow(columns);var table=[header,separatorRow];for(var i=0;i<rows.length;i++){table.push(joinRow(stringRows[i]));}__webpack_require__.g.nativeLoggingHook('\n'+table.join('\n'),LOG_LEVELS.info);}var GROUP_PAD="\u2502";var GROUP_OPEN="\u2510";var GROUP_CLOSE="\u2518";var groupStack=[];function groupFormat(prefix,msg){return groupStack.join('')+prefix+' '+(msg||'');}function consoleGroupPolyfill(label){__webpack_require__.g.nativeLoggingHook(groupFormat(GROUP_OPEN,label),LOG_LEVELS.info);groupStack.push(GROUP_PAD);}function consoleGroupCollapsedPolyfill(label){__webpack_require__.g.nativeLoggingHook(groupFormat(GROUP_CLOSE,label),LOG_LEVELS.info);groupStack.push(GROUP_PAD);}function consoleGroupEndPolyfill(){groupStack.pop();__webpack_require__.g.nativeLoggingHook(groupFormat(GROUP_CLOSE),LOG_LEVELS.info);}function consoleAssertPolyfill(expression,label){if(!expression){__webpack_require__.g.nativeLoggingHook('Assertion failed: '+label,LOG_LEVELS.error);}}if(__webpack_require__.g.nativeLoggingHook){var originalConsole=__webpack_require__.g.console;if(false){ var descriptor; }__webpack_require__.g.console={error:getNativeLogFunction(LOG_LEVELS.error),info:getNativeLogFunction(LOG_LEVELS.info),log:getNativeLogFunction(LOG_LEVELS.info),warn:getNativeLogFunction(LOG_LEVELS.warn),trace:getNativeLogFunction(LOG_LEVELS.trace),debug:getNativeLogFunction(LOG_LEVELS.trace),table:consoleTablePolyfill,group:consoleGroupPolyfill,groupEnd:consoleGroupEndPolyfill,groupCollapsed:consoleGroupCollapsedPolyfill,assert:consoleAssertPolyfill};Object.defineProperty(console,'_isPolyfilled',{value:true,enumerable:false});if(false){}}else if(!__webpack_require__.g.console){function stub(){}var log=__webpack_require__.g.print||stub;__webpack_require__.g.console={debug:log,error:log,info:log,log:log,trace:log,warn:log,assert:function assert(expression,label){if(!expression){log('Assertion failed: '+label);}},clear:stub,dir:stub,dirxml:stub,group:stub,groupCollapsed:stub,groupEnd:stub,profile:stub,profileEnd:stub,table:stub};Object.defineProperty(console,'_isPolyfilled',{value:true,enumerable:false});}
};
}
}
}
}).call(__webpack_require__._LM_("5", { __webpack_require__}))()
/***/ }),
/***/ 3330:
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _inGuard=0;var _globalHandler=function onError(e,isFatal){throw e;};var ErrorUtils={setGlobalHandler:function setGlobalHandler(fun){_globalHandler=fun;},getGlobalHandler:function getGlobalHandler(){return _globalHandler;},reportError:function reportError(error){_globalHandler&&_globalHandler(error,false);},reportFatalError:function reportFatalError(error){_globalHandler&&_globalHandler(error,true);},applyWithGuard:function applyWithGuard(fun,context,args,unused_onError,unused_name){try{_inGuard++;return fun.apply(context,args);}catch(e){ErrorUtils.reportError(e);}finally{_inGuard--;}return null;},applyWithGuardIfNeeded:function applyWithGuardIfNeeded(fun,context,args){if(ErrorUtils.inGuard()){return fun.apply(context,args);}else{ErrorUtils.applyWithGuard(fun,context,args);}return null;},inGuard:function inGuard(){return!!_inGuard;},guard:function guard(fun,name,context){var _ref;if(typeof fun!=='function'){console.warn('A function must be passed to ErrorUtils.guard, got ',fun);return null;}var guardName=(_ref=name!=null?name:fun.name)!=null?_ref:'<generated guard>';function guarded(){for(var _len=arguments.length,args=new Array(_len),_key=0;_key<_len;_key++){args[_key]=arguments[_key];}return ErrorUtils.applyWithGuard(fun,context!=null?context:this,args,null,guardName);}return guarded;}};__webpack_require__.g.ErrorUtils=ErrorUtils;
};
}
}
}
}).call(__webpack_require__._LM_("5", { __webpack_require__}))()
/***/ }),
/***/ 4108:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
function normalizeColor(color){if(typeof color==='number'){if(color>>>0===color&&color>=0&&color<=0xffffffff){return color;}return null;}if(typeof color!=='string'){return null;}var matchers=getMatchers();var match;if(match=matchers.hex6.exec(color)){return parseInt(match[1]+'ff',16)>>>0;}var colorFromKeyword=normalizeKeyword(color);if(colorFromKeyword!=null){return colorFromKeyword;}if(match=matchers.rgb.exec(color)){return(parse255(match[1])<<24|parse255(match[2])<<16|parse255(match[3])<<8|0x000000ff)>>>0;}if(match=matchers.rgba.exec(color)){if(match[6]!==undefined){return(parse255(match[6])<<24|parse255(match[7])<<16|parse255(match[8])<<8|parse1(match[9]))>>>0;}return(parse255(match[2])<<24|parse255(match[3])<<16|parse255(match[4])<<8|parse1(match[5]))>>>0;}if(match=matchers.hex3.exec(color)){return parseInt(match[1]+match[1]+match[2]+match[2]+match[3]+match[3]+'ff',16)>>>0;}if(match=matchers.hex8.exec(color)){return parseInt(match[1],16)>>>0;}if(match=matchers.hex4.exec(color)){return parseInt(match[1]+match[1]+match[2]+match[2]+match[3]+match[3]+match[4]+match[4],16)>>>0;}if(match=matchers.hsl.exec(color)){return(hslToRgb(parse360(match[1]),parsePercentage(match[2]),parsePercentage(match[3]))|0x000000ff)>>>0;}if(match=matchers.hsla.exec(color)){if(match[6]!==undefined){return(hslToRgb(parse360(match[6]),parsePercentage(match[7]),parsePercentage(match[8]))|parse1(match[9]))>>>0;}return(hslToRgb(parse360(match[2]),parsePercentage(match[3]),parsePercentage(match[4]))|parse1(match[5]))>>>0;}if(match=matchers.hwb.exec(color)){return(hwbToRgb(parse360(match[1]),parsePercentage(match[2]),parsePercentage(match[3]))|0x000000ff)>>>0;}return null;}function hue2rgb(p,q,t){if(t<0){t+=1;}if(t>1){t-=1;}if(t<1/6){return p+(q-p)*6*t;}if(t<1/2){return q;}if(t<2/3){return p+(q-p)*(2/3-t)*6;}return p;}function hslToRgb(h,s,l){var q=l<0.5?l*(1+s):l+s-l*s;var p=2*l-q;var r=hue2rgb(p,q,h+1/3);var g=hue2rgb(p,q,h);var b=hue2rgb(p,q,h-1/3);return Math.round(r*255)<<24|Math.round(g*255)<<16|Math.round(b*255)<<8;}function hwbToRgb(h,w,b){if(w+b>=1){var gray=Math.round(w*255/(w+b));return gray<<24|gray<<16|gray<<8;}var red=hue2rgb(0,1,h+1/3)*(1-w-b)+w;var green=hue2rgb(0,1,h)*(1-w-b)+w;var blue=hue2rgb(0,1,h-1/3)*(1-w-b)+w;return Math.round(red*255)<<24|Math.round(green*255)<<16|Math.round(blue*255)<<8;}var NUMBER='[-+]?\\d*\\.?\\d+';var PERCENTAGE=NUMBER+'%';function call(){for(var _len=arguments.length,args=new Array(_len),_key=0;_key<_len;_key++){args[_key]=arguments[_key];}return'\\(\\s*('+args.join(')\\s*,?\\s*(')+')\\s*\\)';}function callWithSlashSeparator(){for(var _len2=arguments.length,args=new Array(_len2),_key2=0;_key2<_len2;_key2++){args[_key2]=arguments[_key2];}return'\\(\\s*('+args.slice(0,args.length-1).join(')\\s*,?\\s*(')+')\\s*/\\s*('+args[args.length-1]+')\\s*\\)';}function commaSeparatedCall(){for(var _len3=arguments.length,args=new Array(_len3),_key3=0;_key3<_len3;_key3++){args[_key3]=arguments[_key3];}return'\\(\\s*('+args.join(')\\s*,\\s*(')+')\\s*\\)';}var cachedMatchers;function getMatchers(){if(cachedMatchers===undefined){cachedMatchers={rgb:new RegExp('rgb'+call(NUMBER,NUMBER,NUMBER)),rgba:new RegExp('rgba('+commaSeparatedCall(NUMBER,NUMBER,NUMBER,NUMBER)+'|'+callWithSlashSeparator(NUMBER,NUMBER,NUMBER,NUMBER)+')'),hsl:new RegExp('hsl'+call(NUMBER,PERCENTAGE,PERCENTAGE)),hsla:new RegExp('hsla('+commaSeparatedCall(NUMBER,PERCENTAGE,PERCENTAGE,NUMBER)+'|'+callWithSlashSeparator(NUMBER,PERCENTAGE,PERCENTAGE,NUMBER)+')'),hwb:new RegExp('hwb'+call(NUMBER,PERCENTAGE,PERCENTAGE)),hex3:/^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,hex4:/^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,hex6:/^#([0-9a-fA-F]{6})$/,hex8:/^#([0-9a-fA-F]{8})$/};}return cachedMatchers;}function parse255(str){var int=parseInt(str,10);if(int<0){return 0;}if(int>255){return 255;}return int;}function parse360(str){var int=parseFloat(str);return(int%360+360)%360/360;}function parse1(str){var num=parseFloat(str);if(num<0){return 0;}if(num>1){return 255;}return Math.round(num*255);}function parsePercentage(str){var int=parseFloat(str);if(int<0){return 0;}if(int>100){return 1;}return int/100;}function normalizeKeyword(name){switch(name){case'transparent':return 0x00000000;case'aliceblue':return 0xf0f8ffff;case'antiquewhite':return 0xfaebd7ff;case'aqua':return 0x00ffffff;case'aquamarine':return 0x7fffd4ff;case'azure':return 0xf0ffffff;case'beige':return 0xf5f5dcff;case'bisque':return 0xffe4c4ff;case'black':return 0x000000ff;case'blanchedalmond':return 0xffebcdff;case'blue':return 0x0000ffff;case'blueviolet':return 0x8a2be2ff;case'brown':return 0xa52a2aff;case'burlywood':return 0xdeb887ff;case'burntsienna':return 0xea7e5dff;case'cadetblue':return 0x5f9ea0ff;case'chartreuse':return 0x7fff00ff;case'chocolate':return 0xd2691eff;case'coral':return 0xff7f50ff;case'cornflowerblue':return 0x6495edff;case'cornsilk':return 0xfff8dcff;case'crimson':return 0xdc143cff;case'cyan':return 0x00ffffff;case'darkblue':return 0x00008bff;case'darkcyan':return 0x008b8bff;case'darkgoldenrod':return 0xb8860bff;case'darkgray':return 0xa9a9a9ff;case'darkgreen':return 0x006400ff;case'darkgrey':return 0xa9a9a9ff;case'darkkhaki':return 0xbdb76bff;case'darkmagenta':return 0x8b008bff;case'darkolivegreen':return 0x556b2fff;case'darkorange':return 0xff8c00ff;case'darkorchid':return 0x9932ccff;case'darkred':return 0x8b0000ff;case'darksalmon':return 0xe9967aff;case'darkseagreen':return 0x8fbc8fff;case'darkslateblue':return 0x483d8bff;case'darkslategray':return 0x2f4f4fff;case'darkslategrey':return 0x2f4f4fff;case'darkturquoise':return 0x00ced1ff;case'darkviolet':return 0x9400d3ff;case'deeppink':return 0xff1493ff;case'deepskyblue':return 0x00bfffff;case'dimgray':return 0x696969ff;case'dimgrey':return 0x696969ff;case'dodgerblue':return 0x1e90ffff;case'firebrick':return 0xb22222ff;case'floralwhite':return 0xfffaf0ff;case'forestgreen':return 0x228b22ff;case'fuchsia':return 0xff00ffff;case'gainsboro':return 0xdcdcdcff;case'ghostwhite':return 0xf8f8ffff;case'gold':return 0xffd700ff;case'goldenrod':return 0xdaa520ff;case'gray':return 0x808080ff;case'green':return 0x008000ff;case'greenyellow':return 0xadff2fff;case'grey':return 0x808080ff;case'honeydew':return 0xf0fff0ff;case'hotpink':return 0xff69b4ff;case'indianred':return 0xcd5c5cff;case'indigo':return 0x4b0082ff;case'ivory':return 0xfffff0ff;case'khaki':return 0xf0e68cff;case'lavender':return 0xe6e6faff;case'lavenderblush':return 0xfff0f5ff;case'lawngreen':return 0x7cfc00ff;case'lemonchiffon':return 0xfffacdff;case'lightblue':return 0xadd8e6ff;case'lightcoral':return 0xf08080ff;case'lightcyan':return 0xe0ffffff;case'lightgoldenrodyellow':return 0xfafad2ff;case'lightgray':return 0xd3d3d3ff;case'lightgreen':return 0x90ee90ff;case'lightgrey':return 0xd3d3d3ff;case'lightpink':return 0xffb6c1ff;case'lightsalmon':return 0xffa07aff;case'lightseagreen':return 0x20b2aaff;case'lightskyblue':return 0x87cefaff;case'lightslategray':return 0x778899ff;case'lightslategrey':return 0x778899ff;case'lightsteelblue':return 0xb0c4deff;case'lightyellow':return 0xffffe0ff;case'lime':return 0x00ff00ff;case'limegreen':return 0x32cd32ff;case'linen':return 0xfaf0e6ff;case'magenta':return 0xff00ffff;case'maroon':return 0x800000ff;case'mediumaquamarine':return 0x66cdaaff;case'mediumblue':return 0x0000cdff;case'mediumorchid':return 0xba55d3ff;case'mediumpurple':return 0x9370dbff;case'mediumseagreen':return 0x3cb371ff;case'mediumslateblue':return 0x7b68eeff;case'mediumspringgreen':return 0x00fa9aff;case'mediumturquoise':return 0x48d1ccff;case'mediumvioletred':return 0xc71585ff;case'midnightblue':return 0x191970ff;case'mintcream':return 0xf5fffaff;case'mistyrose':return 0xffe4e1ff;case'moccasin':return 0xffe4b5ff;case'navajowhite':return 0xffdeadff;case'navy':return 0x000080ff;case'oldlace':return 0xfdf5e6ff;case'olive':return 0x808000ff;case'olivedrab':return 0x6b8e23ff;case'orange':return 0xffa500ff;case'orangered':return 0xff4500ff;case'orchid':return 0xda70d6ff;case'palegoldenrod':return 0xeee8aaff;case'palegreen':return 0x98fb98ff;case'paleturquoise':return 0xafeeeeff;case'palevioletred':return 0xdb7093ff;case'papayawhip':return 0xffefd5ff;case'peachpuff':return 0xffdab9ff;case'peru':return 0xcd853fff;case'pink':return 0xffc0cbff;case'plum':return 0xdda0ddff;case'powderblue':return 0xb0e0e6ff;case'purple':return 0x800080ff;case'rebeccapurple':return 0x663399ff;case'red':return 0xff0000ff;case'rosybrown':return 0xbc8f8fff;case'royalblue':return 0x4169e1ff;case'saddlebrown':return 0x8b4513ff;case'salmon':return 0xfa8072ff;case'sandybrown':return 0xf4a460ff;case'seagreen':return 0x2e8b57ff;case'seashell':return 0xfff5eeff;case'sienna':return 0xa0522dff;case'silver':return 0xc0c0c0ff;case'skyblue':return 0x87ceebff;case'slateblue':return 0x6a5acdff;case'slategray':return 0x708090ff;case'slategrey':return 0x708090ff;case'snow':return 0xfffafaff;case'springgreen':return 0x00ff7fff;case'steelblue':return 0x4682b4ff;case'tan':return 0xd2b48cff;case'teal':return 0x008080ff;case'thistle':return 0xd8bfd8ff;case'tomato':return 0xff6347ff;case'turquoise':return 0x40e0d0ff;case'violet':return 0xee82eeff;case'wheat':return 0xf5deb3ff;case'white':return 0xffffffff;case'whitesmoke':return 0xf5f5f5ff;case'yellow':return 0xffff00ff;case'yellowgreen':return 0x9acd32ff;}return null;}module.exports=normalizeColor;
};
}
}
}
}).call(__webpack_require__._LM_("undefined", { module,__webpack_require__}))()
/***/ }),
/***/ 6131:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _require=__webpack_require__(8773),InteractionManager=_require.InteractionManager;var Batchinator=function(){function Batchinator(callback,delayMS){(0,_classCallCheck2.default)(this,Batchinator);this._delay=delayMS;this._callback=callback;}return(0,_createClass2.default)(Batchinator,[{key:"dispose",value:function dispose(){var options=arguments.length>0&&arguments[0]!==undefined?arguments[0]:{abort:false};if(this._taskHandle){this._taskHandle.cancel();if(!options.abort){this._callback();}this._taskHandle=null;}}},{key:"schedule",value:function schedule(){var _this=this;if(this._taskHandle){return;}var timeoutHandle=setTimeout(function(){_this._taskHandle=InteractionManager.runAfterInteractions(function(){_this._taskHandle=null;_this._callback();});},this._delay);this._taskHandle={cancel:function cancel(){return clearTimeout(timeoutHandle);}};}}]);}();module.exports=Batchinator;
};
}
}
}
}).call(__webpack_require__._LM_("6", { module,__webpack_require__}))()
/***/ }),
/***/ 8817:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports.CellRenderMask=void 0;var _toConsumableArray2=_interopRequireDefault(__webpack_require__(1132));var _slicedToArray2=_interopRequireDefault(__webpack_require__(5715));var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _invariant=_interopRequireDefault(__webpack_require__(311));var CellRenderMask=exports.CellRenderMask=function(){function CellRenderMask(numCells){(0,_classCallCheck2.default)(this,CellRenderMask);(0,_invariant.default)(numCells>=0,'CellRenderMask must contain a non-negative number os cells');this._numCells=numCells;if(numCells===0){this._regions=[];}else{this._regions=[{first:0,last:numCells-1,isSpacer:true}];}}return(0,_createClass2.default)(CellRenderMask,[{key:"enumerateRegions",value:function enumerateRegions(){return this._regions;}},{key:"addCells",value:function addCells(cells){var _this$_regions;(0,_invariant.default)(cells.first>=0&&cells.first<this._numCells&&cells.last>=-1&&cells.last<this._numCells&&cells.last>=cells.first-1,'CellRenderMask.addCells called with invalid cell range');if(cells.last<cells.first){return;}var _this$_findRegion=this._findRegion(cells.first),_this$_findRegion2=(0,_slicedToArray2.default)(_this$_findRegion,2),firstIntersect=_this$_findRegion2[0],firstIntersectIdx=_this$_findRegion2[1];var _this$_findRegion3=this._findRegion(cells.last),_this$_findRegion4=(0,_slicedToArray2.default)(_this$_findRegion3,2),lastIntersect=_this$_findRegion4[0],lastIntersectIdx=_this$_findRegion4[1];if(firstIntersectIdx===lastIntersectIdx&&!firstIntersect.isSpacer){return;}var newLeadRegion=[];var newTailRegion=[];var newMainRegion=Object.assign({},cells,{isSpacer:false});if(firstIntersect.first<newMainRegion.first){if(firstIntersect.isSpacer){newLeadRegion.push({first:firstIntersect.first,last:newMainRegion.first-1,isSpacer:true});}else{newMainRegion.first=firstIntersect.first;}}if(lastIntersect.last>newMainRegion.last){if(lastIntersect.isSpacer){newTailRegion.push({first:newMainRegion.last+1,last:lastIntersect.last,isSpacer:true});}else{newMainRegion.last=lastIntersect.last;}}var replacementRegions=[].concat(newLeadRegion,[newMainRegion],newTailRegion);var numRegionsToDelete=lastIntersectIdx-firstIntersectIdx+1;(_this$_regions=this._regions).splice.apply(_this$_regions,[firstIntersectIdx,numRegionsToDelete].concat((0,_toConsumableArray2.default)(replacementRegions)));}},{key:"numCells",value:function numCells(){return this._numCells;}},{key:"equals",value:function equals(other){return this._numCells===other._numCells&&this._regions.length===other._regions.length&&this._regions.every(function(region,i){return region.first===other._regions[i].first&&region.last===other._regions[i].last&&region.isSpacer===other._regions[i].isSpacer;});}},{key:"_findRegion",value:function _findRegion(cellIdx){var firstIdx=0;var lastIdx=this._regions.length-1;while(firstIdx<=lastIdx){var middleIdx=Math.floor((firstIdx+lastIdx)/2);var middleRegion=this._regions[middleIdx];if(cellIdx>=middleRegion.first&&cellIdx<=middleRegion.last){return[middleRegion,middleIdx];}else if(cellIdx<middleRegion.first){lastIdx=middleIdx-1;}else if(cellIdx>middleRegion.last){firstIdx=middleIdx+1;}}(0,_invariant.default)(false,`A region was not found containing cellIdx ${cellIdx}`);}}]);}();
};
}
}
}
}).call(__webpack_require__._LM_("6", { exports,__webpack_require__}))()
/***/ }),
/***/ 6883:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _invariant=_interopRequireDefault(__webpack_require__(311));var ChildListCollection=exports["default"]=function(){function ChildListCollection(){(0,_classCallCheck2.default)(this,ChildListCollection);this._cellKeyToChildren=new Map();this._childrenToCellKey=new Map();}return(0,_createClass2.default)(ChildListCollection,[{key:"add",value:function add(list,cellKey){var _this$_cellKeyToChild;(0,_invariant.default)(!this._childrenToCellKey.has(list),'Trying to add already present child list');var cellLists=(_this$_cellKeyToChild=this._cellKeyToChildren.get(cellKey))!=null?_this$_cellKeyToChild:new Set();cellLists.add(list);this._cellKeyToChildren.set(cellKey,cellLists);this._childrenToCellKey.set(list,cellKey);}},{key:"remove",value:function remove(list){var cellKey=this._childrenToCellKey.get(list);(0,_invariant.default)(cellKey!=null,'Trying to remove non-present child list');this._childrenToCellKey.delete(list);var cellLists=this._cellKeyToChildren.get(cellKey);(0,_invariant.default)(cellLists,'_cellKeyToChildren should contain cellKey');cellLists.delete(list);if(cellLists.size===0){this._cellKeyToChildren.delete(cellKey);}}},{key:"forEach",value:function forEach(fn){for(var listSet of this._cellKeyToChildren.values()){for(var list of listSet){fn(list);}}}},{key:"forEachInCell",value:function forEachInCell(cellKey,fn){var _this$_cellKeyToChild2;var listSet=(_this$_cellKeyToChild2=this._cellKeyToChildren.get(cellKey))!=null?_this$_cellKeyToChild2:[];for(var list of listSet){fn(list);}}},{key:"anyInCell",value:function anyInCell(cellKey,fn){var _this$_cellKeyToChild3;var listSet=(_this$_cellKeyToChild3=this._cellKeyToChildren.get(cellKey))!=null?_this$_cellKeyToChild3:[];for(var list of listSet){if(fn(list)){return true;}}return false;}},{key:"size",value:function size(){return this._childrenToCellKey.size;}}]);}();
};
}
}
}
}).call(__webpack_require__._LM_("6", { exports,__webpack_require__}))()
/***/ }),
/***/ 4382:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var Info=(0,_createClass2.default)(function Info(){(0,_classCallCheck2.default)(this,Info);this.any_blank_count=0;this.any_blank_ms=0;this.any_blank_speed_sum=0;this.mostly_blank_count=0;this.mostly_blank_ms=0;this.pixels_blank=0;this.pixels_sampled=0;this.pixels_scrolled=0;this.total_time_spent=0;this.sample_count=0;});var DEBUG=false;var _listeners=[];var _minSampleCount=10;var _sampleRate=DEBUG?1:null;var FillRateHelper=function(){function FillRateHelper(getFrameMetrics){(0,_classCallCheck2.default)(this,FillRateHelper);this._anyBlankStartTime=null;this._enabled=false;this._info=new Info();this._mostlyBlankStartTime=null;this._samplesStartTime=null;this._getFrameMetrics=getFrameMetrics;this._enabled=(_sampleRate||0)>Math.random();this._resetData();}return(0,_createClass2.default)(FillRateHelper,[{key:"activate",value:function activate(){if(this._enabled&&this._samplesStartTime==null){DEBUG&&console.debug('FillRateHelper: activate');this._samplesStartTime=__webpack_require__.g.performance.now();}}},{key:"deactivateAndFlush",value:function deactivateAndFlush(){if(!this._enabled){return;}var start=this._samplesStartTime;if(start==null){DEBUG&&console.debug('FillRateHelper: bail on deactivate with no start time');return;}if(this._info.sample_count<_minSampleCount){this._resetData();return;}var total_time_spent=__webpack_require__.g.performance.now()-start;var info=Object.assign({},this._info,{total_time_spent:total_time_spent});if(DEBUG){var derived={avg_blankness:this._info.pixels_blank/this._info.pixels_sampled,avg_speed:this._info.pixels_scrolled/(total_time_spent/1000),avg_speed_when_any_blank:this._info.any_blank_speed_sum/this._info.any_blank_count,any_blank_per_min:this._info.any_blank_count/(total_time_spent/1000/60),any_blank_time_frac:this._info.any_blank_ms/total_time_spent,mostly_blank_per_min:this._info.mostly_blank_count/(total_time_spent/1000/60),mostly_blank_time_frac:this._info.mostly_blank_ms/total_time_spent};for(var key in derived){derived[key]=Math.round(1000*derived[key])/1000;}console.debug('FillRateHelper deactivateAndFlush: ',{derived:derived,info:info});}_listeners.forEach(function(listener){return listener(info);});this._resetData();}},{key:"computeBlankness",value:function computeBlankness(props,cellsAroundViewport,scrollMetrics){if(!this._enabled||props.getItemCount(props.data)===0||cellsAroundViewport.last<cellsAroundViewport.first||this._samplesStartTime==null){return 0;}var dOffset=scrollMetrics.dOffset,offset=scrollMetrics.offset,velocity=scrollMetrics.velocity,visibleLength=scrollMetrics.visibleLength;this._info.sample_count++;this._info.pixels_sampled+=Math.round(visibleLength);this._info.pixels_scrolled+=Math.round(Math.abs(dOffset));var scrollSpeed=Math.round(Math.abs(velocity)*1000);var now=__webpack_require__.g.performance.now();if(this._anyBlankStartTime!=null){this._info.any_blank_ms+=now-this._anyBlankStartTime;}this._anyBlankStartTime=null;if(this._mostlyBlankStartTime!=null){this._info.mostly_blank_ms+=now-this._mostlyBlankStartTime;}this._mostlyBlankStartTime=null;var blankTop=0;var first=cellsAroundViewport.first;var firstFrame=this._getFrameMetrics(first,props);while(first<=cellsAroundViewport.last&&(!firstFrame||!firstFrame.inLayout)){firstFrame=this._getFrameMetrics(first,props);first++;}if(firstFrame&&first>0){blankTop=Math.min(visibleLength,Math.max(0,firstFrame.offset-offset));}var blankBottom=0;var last=cellsAroundViewport.last;var lastFrame=this._getFrameMetrics(last,props);while(last>=cellsAroundViewport.first&&(!lastFrame||!lastFrame.inLayout)){lastFrame=this._getFrameMetrics(last,props);last--;}if(lastFrame&&last<props.getItemCount(props.data)-1){var bottomEdge=lastFrame.offset+lastFrame.length;blankBottom=Math.min(visibleLength,Math.max(0,offset+visibleLength-bottomEdge));}var pixels_blank=Math.round(blankTop+blankBottom);var blankness=pixels_blank/visibleLength;if(blankness>0){this._anyBlankStartTime=now;this._info.any_blank_speed_sum+=scrollSpeed;this._info.any_blank_count++;this._info.pixels_blank+=pixels_blank;if(blankness>0.5){this._mostlyBlankStartTime=now;this._info.mostly_blank_count++;}}else if(scrollSpeed<0.01||Math.abs(dOffset)<1){this.deactivateAndFlush();}return blankness;}},{key:"enabled",value:function enabled(){return this._enabled;}},{key:"_resetData",value:function _resetData(){this._anyBlankStartTime=null;this._info=new Info();this._mostlyBlankStartTime=null;this._samplesStartTime=null;}}],[{key:"addListener",value:function addListener(callback){if(_sampleRate===null){console.warn('Call `FillRateHelper.setSampleRate` before `addListener`.');}_listeners.push(callback);return{remove:function remove(){_listeners=_listeners.filter(function(listener){return callback!==listener;});}};}},{key:"setSampleRate",value:function setSampleRate(sampleRate){_sampleRate=sampleRate;}},{key:"setMinSampleCount",value:function setMinSampleCount(minSampleCount){_minSampleCount=minSampleCount;}}]);}();module.exports=FillRateHelper;
};
}
}
}
}).call(__webpack_require__._LM_("6", { module,__webpack_require__}))()
/***/ }),
/***/ 6336:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _invariant=_interopRequireDefault(__webpack_require__(311));var React=_interopRequireWildcard(__webpack_require__(6540));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}var StateSafePureComponent=exports["default"]=function(_React$PureComponent){function StateSafePureComponent(props){var _this;(0,_classCallCheck2.default)(this,StateSafePureComponent);_this=_callSuper(this,StateSafePureComponent,[props]);_this._inAsyncStateUpdate=false;_this._installSetStateHooks();return _this;}(0,_inherits2.default)(StateSafePureComponent,_React$PureComponent);return(0,_createClass2.default)(StateSafePureComponent,[{key:"setState",value:function setState(partialState,callback){var _this2=this;if(typeof partialState==='function'){_superPropGet(StateSafePureComponent,"setState",this,3)([function(state,props){_this2._inAsyncStateUpdate=true;var ret;try{ret=partialState(state,props);}catch(err){throw err;}finally{_this2._inAsyncStateUpdate=false;}return ret;},callback]);}else{_superPropGet(StateSafePureComponent,"setState",this,3)([partialState,callback]);}}},{key:"_installSetStateHooks",value:function _installSetStateHooks(){var that=this;var props=this.props,state=this.state;Object.defineProperty(this,'props',{get:function get(){(0,_invariant.default)(!that._inAsyncStateUpdate,'"this.props" should not be accessed during state updates');return props;},set:function set(newProps){props=newProps;}});Object.defineProperty(this,'state',{get:function get(){(0,_invariant.default)(!that._inAsyncStateUpdate,'"this.state" should not be acceessed during state updates');return state;},set:function set(newState){state=newState;}});}}]);}(React.PureComponent);
};
}
}
}
}).call(__webpack_require__._LM_("6", { exports,__webpack_require__}))()
/***/ }),
/***/ 6064:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _slicedToArray2=_interopRequireDefault(__webpack_require__(5715));var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var invariant=__webpack_require__(311);var ViewabilityHelper=function(){function ViewabilityHelper(){var config=arguments.length>0&&arguments[0]!==undefined?arguments[0]:{viewAreaCoveragePercentThreshold:0};(0,_classCallCheck2.default)(this,ViewabilityHelper);this._hasInteracted=false;this._timers=new Set();this._viewableIndices=[];this._viewableItems=new Map();this._config=config;}return(0,_createClass2.default)(ViewabilityHelper,[{key:"dispose",value:function dispose(){this._timers.forEach(clearTimeout);}},{key:"computeViewableItems",value:function computeViewableItems(props,scrollOffset,viewportHeight,getFrameMetrics,renderRange){var itemCount=props.getItemCount(props.data);var _this$_config=this._config,itemVisiblePercentThreshold=_this$_config.itemVisiblePercentThreshold,viewAreaCoveragePercentThreshold=_this$_config.viewAreaCoveragePercentThreshold;var viewAreaMode=viewAreaCoveragePercentThreshold!=null;var viewablePercentThreshold=viewAreaMode?viewAreaCoveragePercentThreshold:itemVisiblePercentThreshold;invariant(viewablePercentThreshold!=null&&itemVisiblePercentThreshold!=null!==(viewAreaCoveragePercentThreshold!=null),'Must set exactly one of itemVisiblePercentThreshold or viewAreaCoveragePercentThreshold');var viewableIndices=[];if(itemCount===0){return viewableIndices;}var firstVisible=-1;var _ref=renderRange||{first:0,last:itemCount-1},first=_ref.first,last=_ref.last;if(last>=itemCount){console.warn('Invalid render range computing viewability '+JSON.stringify({renderRange:renderRange,itemCount:itemCount}));return[];}for(var idx=first;idx<=last;idx++){var metrics=getFrameMetrics(idx,props);if(!metrics){continue;}var top=metrics.offset-scrollOffset;var bottom=top+metrics.length;if(top<viewportHeight&&bottom>0){firstVisible=idx;if(_isViewable(viewAreaMode,viewablePercentThreshold,top,bottom,viewportHeight,metrics.length)){viewableIndices.push(idx);}}else if(firstVisible>=0){break;}}return viewableIndices;}},{key:"onUpdate",value:function onUpdate(props,scrollOffset,viewportHeight,getFrameMetrics,createViewToken,onViewableItemsChanged,renderRange){var _this=this;var itemCount=props.getItemCount(props.data);if(this._config.waitForInteraction&&!this._hasInteracted||itemCount===0||!getFrameMetrics(0,props)){return;}var viewableIndices=[];if(itemCount){viewableIndices=this.computeViewableItems(props,scrollOffset,viewportHeight,getFrameMetrics,renderRange);}if(this._viewableIndices.length===viewableIndices.length&&this._viewableIndices.every(function(v,ii){return v===viewableIndices[ii];})){return;}this._viewableIndices=viewableIndices;if(this._config.minimumViewTime){var handle=setTimeout(function(){_this._timers.delete(handle);_this._onUpdateSync(props,viewableIndices,onViewableItemsChanged,createViewToken);},this._config.minimumViewTime);this._timers.add(handle);}else{this._onUpdateSync(props,viewableIndices,onViewableItemsChanged,createViewToken);}}},{key:"resetViewableIndices",value:function resetViewableIndices(){this._viewableIndices=[];}},{key:"recordInteraction",value:function recordInteraction(){this._hasInteracted=true;}},{key:"_onUpdateSync",value:function _onUpdateSync(props,viewableIndicesToCheck,onViewableItemsChanged,createViewToken){var _this2=this;viewableIndicesToCheck=viewableIndicesToCheck.filter(function(ii){return _this2._viewableIndices.includes(ii);});var prevItems=this._viewableItems;var nextItems=new Map(viewableIndicesToCheck.map(function(ii){var viewable=createViewToken(ii,true,props);return[viewable.key,viewable];}));var changed=[];for(var _ref2 of nextItems){var _ref3=(0,_slicedToArray2.default)(_ref2,2);var key=_ref3[0];var viewable=_ref3[1];if(!prevItems.has(key)){changed.push(viewable);}}for(var _ref4 of prevItems){var _ref5=(0,_slicedToArray2.default)(_ref4,2);var _key=_ref5[0];var _viewable=_ref5[1];if(!nextItems.has(_key)){changed.push(Object.assign({},_viewable,{isViewable:false}));}}if(changed.length>0){this._viewableItems=nextItems;onViewableItemsChanged({viewableItems:Array.from(nextItems.values()),changed:changed,viewabilityConfig:this._config});}}}]);}();function _isViewable(viewAreaMode,viewablePercentThreshold,top,bottom,viewportHeight,itemLength){if(_isEntirelyVisible(top,bottom,viewportHeight)){return true;}else{var pixels=_getPixelsVisible(top,bottom,viewportHeight);var percent=100*(viewAreaMode?pixels/viewportHeight:pixels/itemLength);return percent>=viewablePercentThreshold;}}function _getPixelsVisible(top,bottom,viewportHeight){var visibleHeight=Math.min(bottom,viewportHeight)-Math.max(top,0);return Math.max(0,visibleHeight);}function _isEntirelyVisible(top,bottom,viewportHeight){return top>=0&&bottom<=viewportHeight&&bottom>top;}module.exports=ViewabilityHelper;
};
}
}
}
}).call(__webpack_require__._LM_("6", { module,__webpack_require__}))()
/***/ }),
/***/ 1269:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports.computeWindowedRenderLimits=computeWindowedRenderLimits;exports.elementsThatOverlapOffsets=elementsThatOverlapOffsets;exports.keyExtractor=keyExtractor;exports.newRangeCount=newRangeCount;var _slicedToArray2=_interopRequireDefault(__webpack_require__(5715));function elementsThatOverlapOffsets(offsets,props,getFrameMetrics){var zoomScale=arguments.length>3&&arguments[3]!==undefined?arguments[3]:1;var itemCount=props.getItemCount(props.data);var result=[];for(var offsetIndex=0;offsetIndex<offsets.length;offsetIndex++){var currentOffset=offsets[offsetIndex];var left=0;var right=itemCount-1;while(left<=right){var mid=left+(right-left>>>1);var frame=getFrameMetrics(mid,props);var scaledOffsetStart=frame.offset*zoomScale;var scaledOffsetEnd=(frame.offset+frame.length)*zoomScale;if(mid===0&&currentOffset<scaledOffsetStart||mid!==0&&currentOffset<=scaledOffsetStart){right=mid-1;}else if(currentOffset>scaledOffsetEnd){left=mid+1;}else{result[offsetIndex]=mid;break;}}}return result;}function newRangeCount(prev,next){return next.last-next.first+1-Math.max(0,1+Math.min(next.last,prev.last)-Math.max(next.first,prev.first));}function computeWindowedRenderLimits(props,maxToRenderPerBatch,windowSize,prev,getFrameMetricsApprox,scrollMetrics){var itemCount=props.getItemCount(props.data);if(itemCount===0){return{first:0,last:-1};}var offset=scrollMetrics.offset,velocity=scrollMetrics.velocity,visibleLength=scrollMetrics.visibleLength,_scrollMetrics$zoomSc=scrollMetrics.zoomScale,zoomScale=_scrollMetrics$zoomSc===void 0?1:_scrollMetrics$zoomSc;var visibleBegin=Math.max(0,offset);var visibleEnd=visibleBegin+visibleLength;var overscanLength=(windowSize-1)*visibleLength;var leadFactor=0.5;var fillPreference=velocity>1?'after':velocity<-1?'before':'none';var overscanBegin=Math.max(0,visibleBegin-(1-leadFactor)*overscanLength);var overscanEnd=Math.max(0,visibleEnd+leadFactor*overscanLength);var lastItemOffset=getFrameMetricsApprox(itemCount-1,props).offset*zoomScale;if(lastItemOffset<overscanBegin){return{first:Math.max(0,itemCount-1-maxToRenderPerBatch),last:itemCount-1};}var _elementsThatOverlapO=elementsThatOverlapOffsets([overscanBegin,visibleBegin,visibleEnd,overscanEnd],props,getFrameMetricsApprox,zoomScale),_elementsThatOverlapO2=(0,_slicedToArray2.default)(_elementsThatOverlapO,4),overscanFirst=_elementsThatOverlapO2[0],first=_elementsThatOverlapO2[1],last=_elementsThatOverlapO2[2],overscanLast=_elementsThatOverlapO2[3];overscanFirst=overscanFirst==null?0:overscanFirst;first=first==null?Math.max(0,overscanFirst):first;overscanLast=overscanLast==null?itemCount-1:overscanLast;last=last==null?Math.min(overscanLast,first+maxToRenderPerBatch-1):last;var visible={first:first,last:last};var newCellCount=newRangeCount(prev,visible);while(true){if(first<=overscanFirst&&last>=overscanLast){break;}var maxNewCells=newCellCount>=maxToRenderPerBatch;var firstWillAddMore=first<=prev.first||first>prev.last;var firstShouldIncrement=first>overscanFirst&&(!maxNewCells||!firstWillAddMore);var lastWillAddMore=last>=prev.last||last<prev.first;var lastShouldIncrement=last<overscanLast&&(!maxNewCells||!lastWillAddMore);if(maxNewCells&&!firstShouldIncrement&&!lastShouldIncrement){break;}if(firstShouldIncrement&&!(fillPreference==='after'&&lastShouldIncrement&&lastWillAddMore)){if(firstWillAddMore){newCellCount++;}first--;}if(lastShouldIncrement&&!(fillPreference==='before'&&firstShouldIncrement&&firstWillAddMore)){if(lastWillAddMore){newCellCount++;}last++;}}if(!(last>=first&&first>=0&&last<itemCount&&first>=overscanFirst&&last<=overscanLast&&first<=visible.first&&last>=visible.last)){throw new Error('Bad window calculation '+JSON.stringify({first:first,last:last,itemCount:itemCount,overscanFirst:overscanFirst,overscanLast:overscanLast,visible:visible}));}return{first:first,last:last};}function keyExtractor(item,index){if(typeof item==='object'&&(item==null?void 0:item.key)!=null){return item.key;}if(typeof item==='object'&&(item==null?void 0:item.id)!=null){return item.id;}return String(index);}
};
}
}
}
}).call(__webpack_require__._LM_("6", { exports,__webpack_require__}))()
/***/ }),
/***/ 6348:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _toConsumableArray2=_interopRequireDefault(__webpack_require__(1132));var _defineProperty2=_interopRequireDefault(__webpack_require__(3693));var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _reactNative=__webpack_require__(8773);var _Batchinator=_interopRequireDefault(__webpack_require__(6131));var _clamp=_interopRequireDefault(__webpack_require__(3695));var _infoLog=_interopRequireDefault(__webpack_require__(2758));var _CellRenderMask=__webpack_require__(8817);var _ChildListCollection=_interopRequireDefault(__webpack_require__(6883));var _FillRateHelper=_interopRequireDefault(__webpack_require__(4382));var _StateSafePureComponent=_interopRequireDefault(__webpack_require__(6336));var _ViewabilityHelper=_interopRequireDefault(__webpack_require__(6064));var _VirtualizedListCellRenderer=_interopRequireDefault(__webpack_require__(5827));var _VirtualizedListContext=__webpack_require__(9121);var _VirtualizeUtils=__webpack_require__(1269);var _invariant=_interopRequireDefault(__webpack_require__(311));var _nullthrows=_interopRequireDefault(__webpack_require__(801));var React=_interopRequireWildcard(__webpack_require__(6540));var _jsxRuntime=__webpack_require__(4848);function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}var ON_EDGE_REACHED_EPSILON=0.001;var _usedIndexForKey=false;var _keylessItemComponentName='';function horizontalOrDefault(horizontal){return horizontal!=null?horizontal:false;}function initialNumToRenderOrDefault(initialNumToRender){return initialNumToRender!=null?initialNumToRender:10;}function maxToRenderPerBatchOrDefault(maxToRenderPerBatch){return maxToRenderPerBatch!=null?maxToRenderPerBatch:10;}function onStartReachedThresholdOrDefault(onStartReachedThreshold){return onStartReachedThreshold!=null?onStartReachedThreshold:2;}function onEndReachedThresholdOrDefault(onEndReachedThreshold){return onEndReachedThreshold!=null?onEndReachedThreshold:2;}function getScrollingThreshold(threshold,visibleLength){return threshold*visibleLength/2;}function scrollEventThrottleOrDefault(scrollEventThrottle){return scrollEventThrottle!=null?scrollEventThrottle:50;}function windowSizeOrDefault(windowSize){return windowSize!=null?windowSize:21;}function findLastWhere(arr,predicate){for(var i=arr.length-1;i>=0;i--){if(predicate(arr[i])){return arr[i];}}return null;}var VirtualizedList=function(_StateSafePureCompone){function VirtualizedList(_props){var _this$props$updateCel,_this$props$maintainV,_this$props$maintainV2;var _this;(0,_classCallCheck2.default)(this,VirtualizedList);_this=_callSuper(this,VirtualizedList,[_props]);_this._getScrollMetrics=function(){return _this._scrollMetrics;};_this._getOutermostParentListRef=function(){if(_this._isNestedWithSameOrientation()){return _this.context.getOutermostParentListRef();}else{return _this;}};_this._registerAsNestedChild=function(childList){_this._nestedChildLists.add(childList.ref,childList.cellKey);if(_this._hasInteracted){childList.ref.recordInteraction();}};_this._unregisterAsNestedChild=function(childList){_this._nestedChildLists.remove(childList.ref);};_this._onUpdateSeparators=function(keys,newProps){keys.forEach(function(key){var ref=key!=null&&_this._cellRefs[key];ref&&ref.updateSeparatorProps(newProps);});};_this._getSpacerKey=function(isVertical){return isVertical?'height':'width';};_this._averageCellLength=0;_this._cellRefs={};_this._frames={};_this._footerLength=0;_this._hasTriggeredInitialScrollToIndex=false;_this._hasInteracted=false;_this._hasMore=false;_this._hasWarned={};_this._headerLength=0;_this._hiPriInProgress=false;_this._highestMeasuredFrameIndex=0;_this._indicesToKeys=new Map();_this._lastFocusedCellKey=null;_this._nestedChildLists=new _ChildListCollection.default();_this._offsetFromParentVirtualizedList=0;_this._prevParentOffset=0;_this._scrollMetrics={contentLength:0,dOffset:0,dt:10,offset:0,timestamp:0,velocity:0,visibleLength:0,zoomScale:1};_this._scrollRef=null;_this._sentStartForContentLength=0;_this._sentEndForContentLength=0;_this._totalCellLength=0;_this._totalCellsMeasured=0;_this._viewabilityTuples=[];_this._captureScrollRef=function(ref){_this._scrollRef=ref;};_this._defaultRenderScrollComponent=function(props){var onRefresh=props.onRefresh;if(_this._isNestedWithSameOrientation()){return(0,_jsxRuntime.jsx)(_reactNative.View,Object.assign({},props));}else if(onRefresh){var _props$refreshing;(0,_invariant.default)(typeof props.refreshing==='boolean','`refreshing` prop must be set as a boolean in order to use `onRefresh`, but got `'+JSON.stringify((_props$refreshing=props.refreshing)!=null?_props$refreshing:'undefined')+'`');return((0,_jsxRuntime.jsx)(_reactNative.ScrollView,Object.assign({},props,{refreshControl:props.refreshControl==null?(0,_jsxRuntime.jsx)(_reactNative.RefreshControl,{refreshing:props.refreshing,onRefresh:onRefresh,progressViewOffset:props.progressViewOffset}):props.refreshControl})));}else{return(0,_jsxRuntime.jsx)(_reactNative.ScrollView,Object.assign({},props));}};_this._onCellLayout=function(e,cellKey,index){var layout=e.nativeEvent.layout;var next={offset:_this._selectOffset(layout),length:_this._selectLength(layout),index:index,inLayout:true};var curr=_this._frames[cellKey];if(!curr||next.offset!==curr.offset||next.length!==curr.length||index!==curr.index){_this._totalCellLength+=next.length-(curr?curr.length:0);_this._totalCellsMeasured+=curr?0:1;_this._averageCellLength=_this._totalCellLength/_this._totalCellsMeasured;_this._frames[cellKey]=next;_this._highestMeasuredFrameIndex=Math.max(_this._highestMeasuredFrameIndex,index);_this._scheduleCellsToRenderUpdate();}else{_this._frames[cellKey].inLayout=true;}_this._triggerRemeasureForChildListsInCell(cellKey);_this._computeBlankness();_this._updateViewableItems(_this.props,_this.state.cellsAroundViewport);};_this._onCellUnmount=function(cellKey){delete _this._cellRefs[cellKey];var curr=_this._frames[cellKey];if(curr){_this._frames[cellKey]=Object.assign({},curr,{inLayout:false});}};_this._onLayout=function(e){if(_this._isNestedWithSameOrientation()){_this.measureLayoutRelativeToContainingList();}else{_this._scrollMetrics.visibleLength=_this._selectLength(e.nativeEvent.layout);}_this.props.onLayout&&_this.props.onLayout(e);_this._scheduleCellsToRenderUpdate();_this._maybeCallOnEdgeReached();};_this._onLayoutEmpty=function(e){_this.props.onLayout&&_this.props.onLayout(e);};_this._onLayoutFooter=function(e){_this._triggerRemeasureForChildListsInCell(_this._getFooterCellKey());_this._footerLength=_this._selectLength(e.nativeEvent.layout);};_this._onLayoutHeader=function(e){_this._headerLength=_this._selectLength(e.nativeEvent.layout);};_this._onContentSizeChange=function(width,height){if(width>0&&height>0&&_this.props.initialScrollIndex!=null&&_this.props.initialScrollIndex>0&&!_this._hasTriggeredInitialScrollToIndex){if(_this.props.contentOffset==null){if(_this.props.initialScrollIndex<_this.props.getItemCount(_this.props.data)){_this.scrollToIndex({animated:false,index:(0,_nullthrows.default)(_this.props.initialScrollIndex)});}else{_this.scrollToEnd({animated:false});}}_this._hasTriggeredInitialScrollToIndex=true;}if(_this.props.onContentSizeChange){_this.props.onContentSizeChange(width,height);}_this._scrollMetrics.contentLength=_this._selectLength({height:height,width:width});_this._scheduleCellsToRenderUpdate();_this._maybeCallOnEdgeReached();};_this._convertParentScrollMetrics=function(metrics){var offset=metrics.offset-_this._offsetFromParentVirtualizedList;var visibleLength=metrics.visibleLength;var dOffset=offset-_this._scrollMetrics.offset;var contentLength=_this._scrollMetrics.contentLength;return{visibleLength:visibleLength,contentLength:contentLength,offset:offset,dOffset:dOffset};};_this._onScroll=function(e){_this._nestedChildLists.forEach(function(childList){childList._onScroll(e);});if(_this.props.onScroll){_this.props.onScroll(e);}var timestamp=e.timeStamp;var visibleLength=_this._selectLength(e.nativeEvent.layoutMeasurement);var contentLength=_this._selectLength(e.nativeEvent.contentSize);var offset=_this._selectOffset(e.nativeEvent.contentOffset);var dOffset=offset-_this._scrollMetrics.offset;if(_this._isNestedWithSameOrientation()){if(_this._scrollMetrics.contentLength===0){return;}var _this$_convertParentS=_this._convertParentScrollMetrics({visibleLength:visibleLength,offset:offset});visibleLength=_this$_convertParentS.visibleLength;contentLength=_this$_convertParentS.contentLength;offset=_this$_convertParentS.offset;dOffset=_this$_convertParentS.dOffset;}var dt=_this._scrollMetrics.timestamp?Math.max(1,timestamp-_this._scrollMetrics.timestamp):1;var velocity=dOffset/dt;if(dt>500&&_this._scrollMetrics.dt>500&&contentLength>5*visibleLength&&!_this._hasWarned.perf){(0,_infoLog.default)('VirtualizedList: You have a large list that is slow to update - make sure your '+'renderItem function renders components that follow React performance best practices '+'like PureComponent, shouldComponentUpdate, etc.',{dt:dt,prevDt:_this._scrollMetrics.dt,contentLength:contentLength});_this._hasWarned.perf=true;}var zoomScale=e.nativeEvent.zoomScale<0?1:e.nativeEvent.zoomScale;_this._scrollMetrics={contentLength:contentLength,dt:dt,dOffset:dOffset,offset:offset,timestamp:timestamp,velocity:velocity,visibleLength:visibleLength,zoomScale:zoomScale};if(_this.state.pendingScrollUpdateCount>0){_this.setState(function(state){return{pendingScrollUpdateCount:state.pendingScrollUpdateCount-1};});}_this._updateViewableItems(_this.props,_this.state.cellsAroundViewport);if(!_this.props){return;}_this._maybeCallOnEdgeReached();if(velocity!==0){_this._fillRateHelper.activate();}_this._computeBlankness();_this._scheduleCellsToRenderUpdate();};_this._onScrollBeginDrag=function(e){_this._nestedChildLists.forEach(function(childList){childList._onScrollBeginDrag(e);});_this._viewabilityTuples.forEach(function(tuple){tuple.viewabilityHelper.recordInteraction();});_this._hasInteracted=true;_this.props.onScrollBeginDrag&&_this.props.onScrollBeginDrag(e);};_this._onScrollEndDrag=function(e){_this._nestedChildLists.forEach(function(childList){childList._onScrollEndDrag(e);});var velocity=e.nativeEvent.velocity;if(velocity){_this._scrollMetrics.velocity=_this._selectOffset(velocity);}_this._computeBlankness();_this.props.onScrollEndDrag&&_this.props.onScrollEndDrag(e);};_this._onMomentumScrollBegin=function(e){_this._nestedChildLists.forEach(function(childList){childList._onMomentumScrollBegin(e);});_this.props.onMomentumScrollBegin&&_this.props.onMomentumScrollBegin(e);};_this._onMomentumScrollEnd=function(e){_this._nestedChildLists.forEach(function(childList){childList._onMomentumScrollEnd(e);});_this._scrollMetrics.velocity=0;_this._computeBlankness();_this.props.onMomentumScrollEnd&&_this.props.onMomentumScrollEnd(e);};_this._updateCellsToRender=function(){_this._updateViewableItems(_this.props,_this.state.cellsAroundViewport);_this.setState(function(state,props){var cellsAroundViewport=_this._adjustCellsAroundViewport(props,state.cellsAroundViewport,state.pendingScrollUpdateCount);var renderMask=VirtualizedList._createRenderMask(props,cellsAroundViewport,_this._getNonViewportRenderRegions(props));if(cellsAroundViewport.first===state.cellsAroundViewport.first&&cellsAroundViewport.last===state.cellsAroundViewport.last&&renderMask.equals(state.renderMask)){return null;}return{cellsAroundViewport:cellsAroundViewport,renderMask:renderMask};});};_this._createViewToken=function(index,isViewable,props){var data=props.data,getItem=props.getItem;var item=getItem(data,index);return{index:index,item:item,key:VirtualizedList._keyExtractor(item,index,props),isViewable:isViewable};};_this._getOffsetApprox=function(index,props){if(Number.isInteger(index)){return _this.__getFrameMetricsApprox(index,props).offset;}else{var frameMetrics=_this.__getFrameMetricsApprox(Math.floor(index),props);var remainder=index-Math.floor(index);return frameMetrics.offset+remainder*frameMetrics.length;}};_this.__getFrameMetricsApprox=function(index,props){var frame=_this._getFrameMetrics(index,props);if(frame&&frame.index===index){return frame;}else{var data=props.data,getItemCount=props.getItemCount,getItemLayout=props.getItemLayout;(0,_invariant.default)(index>=0&&index<getItemCount(data),'Tried to get frame for out of range index '+index);(0,_invariant.default)(!getItemLayout,'Should not have to estimate frames when a measurement metrics function is provided');return{length:_this._averageCellLength,offset:_this._averageCellLength*index};}};_this._getFrameMetrics=function(index,props){var data=props.data,getItemCount=props.getItemCount,getItemLayout=props.getItemLayout;(0,_invariant.default)(index>=0&&index<getItemCount(data),'Tried to get frame for out of range index '+index);var frame=_this._frames[VirtualizedList._getItemKey(props,index)];if(!frame||frame.index!==index){if(getItemLayout){return getItemLayout(data,index);}}return frame;};_this._getNonViewportRenderRegions=function(props){if(!(_this._lastFocusedCellKey&&_this._cellRefs[_this._lastFocusedCellKey])){return[];}var lastFocusedCellRenderer=_this._cellRefs[_this._lastFocusedCellKey];var focusedCellIndex=lastFocusedCellRenderer.props.index;var itemCount=props.getItemCount(props.data);if(focusedCellIndex>=itemCount||VirtualizedList._getItemKey(props,focusedCellIndex)!==_this._lastFocusedCellKey){return[];}var first=focusedCellIndex;var heightOfCellsBeforeFocused=0;for(var i=first-1;i>=0&&heightOfCellsBeforeFocused<_this._scrollMetrics.visibleLength;i--){first--;heightOfCellsBeforeFocused+=_this.__getFrameMetricsApprox(i,props).length;}var last=focusedCellIndex;var heightOfCellsAfterFocused=0;for(var _i=last+1;_i<itemCount&&heightOfCellsAfterFocused<_this._scrollMetrics.visibleLength;_i++){last++;heightOfCellsAfterFocused+=_this.__getFrameMetricsApprox(_i,props).length;}return[{first:first,last:last}];};_this._checkProps(_props);_this._fillRateHelper=new _FillRateHelper.default(_this._getFrameMetrics);_this._updateCellsToRenderBatcher=new _Batchinator.default(_this._updateCellsToRender,(_this$props$updateCel=_this.props.updateCellsBatchingPeriod)!=null?_this$props$updateCel:50);if(_this.props.viewabilityConfigCallbackPairs){_this._viewabilityTuples=_this.props.viewabilityConfigCallbackPairs.map(function(pair){return{viewabilityHelper:new _ViewabilityHelper.default(pair.viewabilityConfig),onViewableItemsChanged:pair.onViewableItemsChanged};});}else{var _this$props=_this.props,onViewableItemsChanged=_this$props.onViewableItemsChanged,viewabilityConfig=_this$props.viewabilityConfig;if(onViewableItemsChanged){_this._viewabilityTuples.push({viewabilityHelper:new _ViewabilityHelper.default(viewabilityConfig),onViewableItemsChanged:onViewableItemsChanged});}}var initialRenderRegion=VirtualizedList._initialRenderRegion(_props);var minIndexForVisible=(_this$props$maintainV=(_this$props$maintainV2=_this.props.maintainVisibleContentPosition)==null?void 0:_this$props$maintainV2.minIndexForVisible)!=null?_this$props$maintainV:0;_this.state={cellsAroundViewport:initialRenderRegion,renderMask:VirtualizedList._createRenderMask(_props,initialRenderRegion),firstVisibleItemKey:_this.props.getItemCount(_this.props.data)>minIndexForVisible?VirtualizedList._getItemKey(_this.props,minIndexForVisible):null,pendingScrollUpdateCount:_this.props.initialScrollIndex!=null&&_this.props.initialScrollIndex>0?1:0};return _this;}(0,_inherits2.default)(VirtualizedList,_StateSafePureCompone);return(0,_createClass2.default)(VirtualizedList,[{key:"scrollToEnd",value:function scrollToEnd(params){var animated=params?params.animated:true;var veryLast=this.props.getItemCount(this.props.data)-1;if(veryLast<0){return;}var frame=this.__getFrameMetricsApprox(veryLast,this.props);var offset=Math.max(0,frame.offset+frame.length+this._footerLength-this._scrollMetrics.visibleLength);if(this._scrollRef==null){return;}if(this._scrollRef.scrollTo==null){console.warn('No scrollTo method provided. This may be because you have two nested '+'VirtualizedLists with the same orientation, or because you are '+'using a custom component that does not implement scrollTo.');return;}this._scrollRef.scrollTo(horizontalOrDefault(this.props.horizontal)?{x:offset,animated:animated}:{y:offset,animated:animated});}},{key:"scrollToIndex",value:function scrollToIndex(params){var _this$props2=this.props,data=_this$props2.data,horizontal=_this$props2.horizontal,getItemCount=_this$props2.getItemCount,getItemLayout=_this$props2.getItemLayout,onScrollToIndexFailed=_this$props2.onScrollToIndexFailed;var animated=params.animated,index=params.index,viewOffset=params.viewOffset,viewPosition=params.viewPosition;(0,_invariant.default)(index>=0,`scrollToIndex out of range: requested index ${index} but minimum is 0`);(0,_invariant.default)(getItemCount(data)>=1,`scrollToIndex out of range: item length ${getItemCount(data)} but minimum is 1`);(0,_invariant.default)(index<getItemCount(data),`scrollToIndex out of range: requested index ${index} is out of 0 to ${getItemCount(data)-1}`);if(!getItemLayout&&index>this._highestMeasuredFrameIndex){(0,_invariant.default)(!!onScrollToIndexFailed,'scrollToIndex should be used in conjunction with getItemLayout or onScrollToIndexFailed, '+'otherwise there is no way to know the location of offscreen indices or handle failures.');onScrollToIndexFailed({averageItemLength:this._averageCellLength,highestMeasuredFrameIndex:this._highestMeasuredFrameIndex,index:index});return;}var frame=this.__getFrameMetricsApprox(Math.floor(index),this.props);var offset=Math.max(0,this._getOffsetApprox(index,this.props)-(viewPosition||0)*(this._scrollMetrics.visibleLength-frame.length))-(viewOffset||0);if(this._scrollRef==null){return;}if(this._scrollRef.scrollTo==null){console.warn('No scrollTo method provided. This may be because you have two nested '+'VirtualizedLists with the same orientation, or because you are '+'using a custom component that does not implement scrollTo.');return;}this._scrollRef.scrollTo(horizontal?{x:offset,animated:animated}:{y:offset,animated:animated});}},{key:"scrollToItem",value:function scrollToItem(params){var item=params.item;var _this$props3=this.props,data=_this$props3.data,getItem=_this$props3.getItem,getItemCount=_this$props3.getItemCount;var itemCount=getItemCount(data);for(var _index=0;_index<itemCount;_index++){if(getItem(data,_index)===item){this.scrollToIndex(Object.assign({},params,{index:_index}));break;}}}},{key:"scrollToOffset",value:function scrollToOffset(params){var animated=params.animated,offset=params.offset;if(this._scrollRef==null){return;}if(this._scrollRef.scrollTo==null){console.warn('No scrollTo method provided. This may be because you have two nested '+'VirtualizedLists with the same orientation, or because you are '+'using a custom component that does not implement scrollTo.');return;}this._scrollRef.scrollTo(horizontalOrDefault(this.props.horizontal)?{x:offset,animated:animated}:{y:offset,animated:animated});}},{key:"recordInteraction",value:function recordInteraction(){this._nestedChildLists.forEach(function(childList){childList.recordInteraction();});this._viewabilityTuples.forEach(function(t){t.viewabilityHelper.recordInteraction();});this._updateViewableItems(this.props,this.state.cellsAroundViewport);}},{key:"flashScrollIndicators",value:function flashScrollIndicators(){if(this._scrollRef==null){return;}this._scrollRef.flashScrollIndicators();}},{key:"getScrollResponder",value:function getScrollResponder(){if(this._scrollRef&&this._scrollRef.getScrollResponder){return this._scrollRef.getScrollResponder();}}},{key:"getScrollableNode",value:function getScrollableNode(){if(this._scrollRef&&this._scrollRef.getScrollableNode){return this._scrollRef.getScrollableNode();}else{return(0,_reactNative.findNodeHandle)(this._scrollRef);}}},{key:"getScrollRef",value:function getScrollRef(){if(this._scrollRef&&this._scrollRef.getScrollRef){return this._scrollRef.getScrollRef();}else{return this._scrollRef;}}},{key:"setNativeProps",value:function setNativeProps(props){if(this._scrollRef){this._scrollRef.setNativeProps(props);}}},{key:"_getCellKey",value:function _getCellKey(){var _this$context;return((_this$context=this.context)==null?void 0:_this$context.cellKey)||'rootList';}},{key:"hasMore",value:function hasMore(){return this._hasMore;}},{key:"_checkProps",value:function _checkProps(props){var onScroll=props.onScroll,windowSize=props.windowSize,getItemCount=props.getItemCount,data=props.data,initialScrollIndex=props.initialScrollIndex;(0,_invariant.default)(!onScroll||!onScroll.__isNative,'Components based on VirtualizedList must be wrapped with Animated.createAnimatedComponent '+'to support native onScroll events with useNativeDriver');(0,_invariant.default)(windowSizeOrDefault(windowSize)>0,'VirtualizedList: The windowSize prop must be present and set to a value greater than 0.');(0,_invariant.default)(getItemCount,'VirtualizedList: The "getItemCount" prop must be provided');var itemCount=getItemCount(data);if(initialScrollIndex!=null&&!this._hasTriggeredInitialScrollToIndex&&(initialScrollIndex<0||itemCount>0&&initialScrollIndex>=itemCount)&&!this._hasWarned.initialScrollIndex){console.warn(`initialScrollIndex "${initialScrollIndex}" is not valid (list has ${itemCount} items)`);this._hasWarned.initialScrollIndex=true;}if(false){ var flatStyles; }}},{key:"_adjustCellsAroundViewport",value:function _adjustCellsAroundViewport(props,cellsAroundViewport,pendingScrollUpdateCount){var data=props.data,getItemCount=props.getItemCount;var onEndReachedThreshold=onEndReachedThresholdOrDefault(props.onEndReachedThreshold);var _this$_scrollMetrics=this._scrollMetrics,contentLength=_this$_scrollMetrics.contentLength,offset=_this$_scrollMetrics.offset,visibleLength=_this$_scrollMetrics.visibleLength;var distanceFromEnd=contentLength-visibleLength-offset;if(visibleLength<=0||contentLength<=0){return cellsAroundViewport.last>=getItemCount(data)?VirtualizedList._constrainToItemCount(cellsAroundViewport,props):cellsAroundViewport;}var newCellsAroundViewport;if(props.disableVirtualization){var renderAhead=distanceFromEnd<onEndReachedThreshold*visibleLength?maxToRenderPerBatchOrDefault(props.maxToRenderPerBatch):0;newCellsAroundViewport={first:0,last:Math.min(cellsAroundViewport.last+renderAhead,getItemCount(data)-1)};}else{if(pendingScrollUpdateCount>0){return cellsAroundViewport.last>=getItemCount(data)?VirtualizedList._constrainToItemCount(cellsAroundViewport,props):cellsAroundViewport;}newCellsAroundViewport=(0,_VirtualizeUtils.computeWindowedRenderLimits)(props,maxToRenderPerBatchOrDefault(props.maxToRenderPerBatch),windowSizeOrDefault(props.windowSize),cellsAroundViewport,this.__getFrameMetricsApprox,this._scrollMetrics);(0,_invariant.default)(newCellsAroundViewport.last<getItemCount(data),'computeWindowedRenderLimits() should return range in-bounds');}if(this._nestedChildLists.size()>0){var childIdx=this._findFirstChildWithMore(newCellsAroundViewport.first,newCellsAroundViewport.last);newCellsAroundViewport.last=childIdx!=null?childIdx:newCellsAroundViewport.last;}return newCellsAroundViewport;}},{key:"_findFirstChildWithMore",value:function _findFirstChildWithMore(first,last){for(var ii=first;ii<=last;ii++){var cellKeyForIndex=this._indicesToKeys.get(ii);if(cellKeyForIndex!=null&&this._nestedChildLists.anyInCell(cellKeyForIndex,function(childList){return childList.hasMore();})){return ii;}}return null;}},{key:"componentDidMount",value:function componentDidMount(){if(this._isNestedWithSameOrientation()){this.context.registerAsNestedChild({ref:this,cellKey:this.context.cellKey});}}},{key:"componentWillUnmount",value:function componentWillUnmount(){if(this._isNestedWithSameOrientation()){this.context.unregisterAsNestedChild({ref:this});}this._updateCellsToRenderBatcher.dispose({abort:true});this._viewabilityTuples.forEach(function(tuple){tuple.viewabilityHelper.dispose();});this._fillRateHelper.deactivateAndFlush();}},{key:"_pushCells",value:function _pushCells(cells,stickyHeaderIndices,stickyIndicesFromProps,first,last,inversionStyle){var _this2=this;var _this$props4=this.props,CellRendererComponent=_this$props4.CellRendererComponent,ItemSeparatorComponent=_this$props4.ItemSeparatorComponent,ListHeaderComponent=_this$props4.ListHeaderComponent,ListItemComponent=_this$props4.ListItemComponent,data=_this$props4.data,debug=_this$props4.debug,getItem=_this$props4.getItem,getItemCount=_this$props4.getItemCount,getItemLayout=_this$props4.getItemLayout,horizontal=_this$props4.horizontal,renderItem=_this$props4.renderItem;var stickyOffset=ListHeaderComponent?1:0;var end=getItemCount(data)-1;var prevCellKey;last=Math.min(end,last);var _loop=function _loop(){var item=getItem(data,ii);var key=VirtualizedList._keyExtractor(item,ii,_this2.props);_this2._indicesToKeys.set(ii,key);if(stickyIndicesFromProps.has(ii+stickyOffset)){stickyHeaderIndices.push(cells.length);}var shouldListenForLayout=getItemLayout==null||debug||_this2._fillRateHelper.enabled();cells.push((0,_jsxRuntime.jsx)(_VirtualizedListCellRenderer.default,Object.assign({CellRendererComponent:CellRendererComponent,ItemSeparatorComponent:ii<end?ItemSeparatorComponent:undefined,ListItemComponent:ListItemComponent,cellKey:key,horizontal:horizontal,index:ii,inversionStyle:inversionStyle,item:item,prevCellKey:prevCellKey,onUpdateSeparators:_this2._onUpdateSeparators,onCellFocusCapture:function onCellFocusCapture(e){return _this2._onCellFocusCapture(key);},onUnmount:_this2._onCellUnmount,ref:function ref(_ref){_this2._cellRefs[key]=_ref;},renderItem:renderItem},shouldListenForLayout&&{onCellLayout:_this2._onCellLayout}),key));prevCellKey=key;};for(var ii=first;ii<=last;ii++){_loop();}}},{key:"_isNestedWithSameOrientation",value:function _isNestedWithSameOrientation(){var nestedContext=this.context;return!!(nestedContext&&!!nestedContext.horizontal===horizontalOrDefault(this.props.horizontal));}},{key:"render",value:function render(){var _this3=this;this._checkProps(this.props);var _this$props5=this.props,ListEmptyComponent=_this$props5.ListEmptyComponent,ListFooterComponent=_this$props5.ListFooterComponent,ListHeaderComponent=_this$props5.ListHeaderComponent;var _this$props6=this.props,data=_this$props6.data,horizontal=_this$props6.horizontal;var inversionStyle=this.props.inverted?horizontalOrDefault(this.props.horizontal)?styles.horizontallyInverted:styles.verticallyInverted:null;var cells=[];var stickyIndicesFromProps=new Set(this.props.stickyHeaderIndices);var stickyHeaderIndices=[];if(ListHeaderComponent){if(stickyIndicesFromProps.has(0)){stickyHeaderIndices.push(0);}var _element=React.isValidElement(ListHeaderComponent)?ListHeaderComponent:(0,_jsxRuntime.jsx)(ListHeaderComponent,{});cells.push((0,_jsxRuntime.jsx)(_VirtualizedListContext.VirtualizedListCellContextProvider,{cellKey:this._getCellKey()+'-header',children:(0,_jsxRuntime.jsx)(_reactNative.View,{collapsable:false,onLayout:this._onLayoutHeader,style:_reactNative.StyleSheet.compose(inversionStyle,this.props.ListHeaderComponentStyle),children:_element})},"$header"));}var itemCount=this.props.getItemCount(data);if(itemCount===0&&ListEmptyComponent){var _element2=React.isValidElement(ListEmptyComponent)?ListEmptyComponent:(0,_jsxRuntime.jsx)(ListEmptyComponent,{});cells.push((0,_jsxRuntime.jsx)(_VirtualizedListContext.VirtualizedListCellContextProvider,{cellKey:this._getCellKey()+'-empty',children:React.cloneElement(_element2,{onLayout:function onLayout(event){_this3._onLayoutEmpty(event);if(_element2.props.onLayout){_element2.props.onLayout(event);}},style:_reactNative.StyleSheet.compose(inversionStyle,_element2.props.style)})},"$empty"));}if(itemCount>0){_usedIndexForKey=false;_keylessItemComponentName='';var spacerKey=this._getSpacerKey(!horizontal);var renderRegions=this.state.renderMask.enumerateRegions();var lastSpacer=findLastWhere(renderRegions,function(r){return r.isSpacer;});for(var section of renderRegions){if(section.isSpacer){if(this.props.disableVirtualization){continue;}var isLastSpacer=section===lastSpacer;var constrainToMeasured=isLastSpacer&&!this.props.getItemLayout;var last=constrainToMeasured?(0,_clamp.default)(section.first-1,section.last,this._highestMeasuredFrameIndex):section.last;var firstMetrics=this.__getFrameMetricsApprox(section.first,this.props);var lastMetrics=this.__getFrameMetricsApprox(last,this.props);var spacerSize=lastMetrics.offset+lastMetrics.length-firstMetrics.offset;cells.push((0,_jsxRuntime.jsx)(_reactNative.View,{style:(0,_defineProperty2.default)({},spacerKey,spacerSize)},`$spacer-${section.first}`));}else{this._pushCells(cells,stickyHeaderIndices,stickyIndicesFromProps,section.first,section.last,inversionStyle);}}if(!this._hasWarned.keys&&_usedIndexForKey){console.warn('VirtualizedList: missing keys for items, make sure to specify a key or id property on each '+'item or provide a custom keyExtractor.',_keylessItemComponentName);this._hasWarned.keys=true;}}if(ListFooterComponent){var _element3=React.isValidElement(ListFooterComponent)?ListFooterComponent:(0,_jsxRuntime.jsx)(ListFooterComponent,{});cells.push((0,_jsxRuntime.jsx)(_VirtualizedListContext.VirtualizedListCellContextProvider,{cellKey:this._getFooterCellKey(),children:(0,_jsxRuntime.jsx)(_reactNative.View,{onLayout:this._onLayoutFooter,style:_reactNative.StyleSheet.compose(inversionStyle,this.props.ListFooterComponentStyle),children:_element3})},"$footer"));}var scrollProps=Object.assign({},this.props,{onContentSizeChange:this._onContentSizeChange,onLayout:this._onLayout,onScroll:this._onScroll,onScrollBeginDrag:this._onScrollBeginDrag,onScrollEndDrag:this._onScrollEndDrag,onMomentumScrollBegin:this._onMomentumScrollBegin,onMomentumScrollEnd:this._onMomentumScrollEnd,scrollEventThrottle:scrollEventThrottleOrDefault(this.props.scrollEventThrottle),invertStickyHeaders:this.props.invertStickyHeaders!==undefined?this.props.invertStickyHeaders:this.props.inverted,stickyHeaderIndices:stickyHeaderIndices,style:inversionStyle?[inversionStyle,this.props.style]:this.props.style,isInvertedVirtualizedList:this.props.inverted,maintainVisibleContentPosition:this.props.maintainVisibleContentPosition!=null?Object.assign({},this.props.maintainVisibleContentPosition,{minIndexForVisible:this.props.maintainVisibleContentPosition.minIndexForVisible+(this.props.ListHeaderComponent?1:0)}):undefined});this._hasMore=this.state.cellsAroundViewport.last<itemCount-1;var innerRet=(0,_jsxRuntime.jsx)(_VirtualizedListContext.VirtualizedListContextProvider,{value:{cellKey:null,getScrollMetrics:this._getScrollMetrics,horizontal:horizontalOrDefault(this.props.horizontal),getOutermostParentListRef:this._getOutermostParentListRef,registerAsNestedChild:this._registerAsNestedChild,unregisterAsNestedChild:this._unregisterAsNestedChild},children:React.cloneElement((this.props.renderScrollComponent||this._defaultRenderScrollComponent)(scrollProps),{ref:this._captureScrollRef},cells)});var ret=innerRet;if(false){}if(this.props.debug){return(0,_jsxRuntime.jsxs)(_reactNative.View,{style:styles.debug,children:[ret,this._renderDebugOverlay()]});}else{return ret;}}},{key:"componentDidUpdate",value:function componentDidUpdate(prevProps){var _this$props7=this.props,data=_this$props7.data,extraData=_this$props7.extraData;if(data!==prevProps.data||extraData!==prevProps.extraData){this._viewabilityTuples.forEach(function(tuple){tuple.viewabilityHelper.resetViewableIndices();});}var hiPriInProgress=this._hiPriInProgress;this._scheduleCellsToRenderUpdate();if(hiPriInProgress){this._hiPriInProgress=false;}}},{key:"_computeBlankness",value:function _computeBlankness(){this._fillRateHelper.computeBlankness(this.props,this.state.cellsAroundViewport,this._scrollMetrics);}},{key:"_onCellFocusCapture",value:function _onCellFocusCapture(cellKey){this._lastFocusedCellKey=cellKey;this._updateCellsToRender();}},{key:"_triggerRemeasureForChildListsInCell",value:function _triggerRemeasureForChildListsInCell(cellKey){this._nestedChildLists.forEachInCell(cellKey,function(childList){childList.measureLayoutRelativeToContainingList();});}},{key:"measureLayoutRelativeToContainingList",value:function measureLayoutRelativeToContainingList(){var _this4=this;try{if(!this._scrollRef){return;}this._scrollRef.measureLayout(this.context.getOutermostParentListRef().getScrollRef(),function(x,y,width,height){_this4._offsetFromParentVirtualizedList=_this4._selectOffset({x:x,y:y});_this4._scrollMetrics.contentLength=_this4._selectLength({width:width,height:height});var scrollMetrics=_this4._convertParentScrollMetrics(_this4.context.getScrollMetrics());var metricsChanged=_this4._scrollMetrics.visibleLength!==scrollMetrics.visibleLength||_this4._scrollMetrics.offset!==scrollMetrics.offset;if(metricsChanged){_this4._scrollMetrics.visibleLength=scrollMetrics.visibleLength;_this4._scrollMetrics.offset=scrollMetrics.offset;_this4._nestedChildLists.forEach(function(childList){childList.measureLayoutRelativeToContainingList();});}},function(error){console.warn("VirtualizedList: Encountered an error while measuring a list's"+' offset from its containing VirtualizedList.');});}catch(error){console.warn('measureLayoutRelativeToContainingList threw an error',error.stack);}}},{key:"_getFooterCellKey",value:function _getFooterCellKey(){return this._getCellKey()+'-footer';}},{key:"_renderDebugOverlay",value:function _renderDebugOverlay(){var normalize=this._scrollMetrics.visibleLength/(this._scrollMetrics.contentLength||1);var framesInLayout=[];var itemCount=this.props.getItemCount(this.props.data);for(var ii=0;ii<itemCount;ii++){var frame=this.__getFrameMetricsApprox(ii,this.props);if(frame.inLayout){framesInLayout.push(frame);}}var windowTop=this.__getFrameMetricsApprox(this.state.cellsAroundViewport.first,this.props).offset;var frameLast=this.__getFrameMetricsApprox(this.state.cellsAroundViewport.last,this.props);var windowLen=frameLast.offset+frameLast.length-windowTop;var visTop=this._scrollMetrics.offset;var visLen=this._scrollMetrics.visibleLength;return(0,_jsxRuntime.jsxs)(_reactNative.View,{style:[styles.debugOverlayBase,styles.debugOverlay],children:[framesInLayout.map(function(f,ii){return(0,_jsxRuntime.jsx)(_reactNative.View,{style:[styles.debugOverlayBase,styles.debugOverlayFrame,{top:f.offset*normalize,height:f.length*normalize}]},'f'+ii);}),(0,_jsxRuntime.jsx)(_reactNative.View,{style:[styles.debugOverlayBase,styles.debugOverlayFrameLast,{top:windowTop*normalize,height:windowLen*normalize}]}),(0,_jsxRuntime.jsx)(_reactNative.View,{style:[styles.debugOverlayBase,styles.debugOverlayFrameVis,{top:visTop*normalize,height:visLen*normalize}]})]});}},{key:"_selectLength",value:function _selectLength(metrics){return!horizontalOrDefault(this.props.horizontal)?metrics.height:metrics.width;}},{key:"_selectOffset",value:function _selectOffset(metrics){return!horizontalOrDefault(this.props.horizontal)?metrics.y:metrics.x;}},{key:"_maybeCallOnEdgeReached",value:function _maybeCallOnEdgeReached(){var _this$props8=this.props,data=_this$props8.data,getItemCount=_this$props8.getItemCount,onStartReached=_this$props8.onStartReached,onStartReachedThreshold=_this$props8.onStartReachedThreshold,onEndReached=_this$props8.onEndReached,onEndReachedThreshold=_this$props8.onEndReachedThreshold;if(this.state.pendingScrollUpdateCount>0){return;}var _this$_scrollMetrics2=this._scrollMetrics,contentLength=_this$_scrollMetrics2.contentLength,visibleLength=_this$_scrollMetrics2.visibleLength,offset=_this$_scrollMetrics2.offset;var distanceFromStart=offset;var distanceFromEnd=contentLength-visibleLength-offset;if(distanceFromStart<ON_EDGE_REACHED_EPSILON){distanceFromStart=0;}if(distanceFromEnd<ON_EDGE_REACHED_EPSILON){distanceFromEnd=0;}var DEFAULT_THRESHOLD_PX=2;var startThreshold=onStartReachedThreshold!=null?onStartReachedThreshold*visibleLength:DEFAULT_THRESHOLD_PX;var endThreshold=onEndReachedThreshold!=null?onEndReachedThreshold*visibleLength:DEFAULT_THRESHOLD_PX;var isWithinStartThreshold=distanceFromStart<=startThreshold;var isWithinEndThreshold=distanceFromEnd<=endThreshold;if(onEndReached&&this.state.cellsAroundViewport.last===getItemCount(data)-1&&isWithinEndThreshold&&this._scrollMetrics.contentLength!==this._sentEndForContentLength){this._sentEndForContentLength=this._scrollMetrics.contentLength;onEndReached({distanceFromEnd:distanceFromEnd});}else if(onStartReached!=null&&this.state.cellsAroundViewport.first===0&&isWithinStartThreshold&&this._scrollMetrics.contentLength!==this._sentStartForContentLength){this._sentStartForContentLength=this._scrollMetrics.contentLength;onStartReached({distanceFromStart:distanceFromStart});}else{this._sentStartForContentLength=isWithinStartThreshold?this._sentStartForContentLength:0;this._sentEndForContentLength=isWithinEndThreshold?this._sentEndForContentLength:0;}}},{key:"_scheduleCellsToRenderUpdate",value:function _scheduleCellsToRenderUpdate(){var _this$state$cellsArou=this.state.cellsAroundViewport,first=_this$state$cellsArou.first,last=_this$state$cellsArou.last;var _this$_scrollMetrics3=this._scrollMetrics,offset=_this$_scrollMetrics3.offset,visibleLength=_this$_scrollMetrics3.visibleLength,velocity=_this$_scrollMetrics3.velocity;var itemCount=this.props.getItemCount(this.props.data);var hiPri=false;var onStartReachedThreshold=onStartReachedThresholdOrDefault(this.props.onStartReachedThreshold);var onEndReachedThreshold=onEndReachedThresholdOrDefault(this.props.onEndReachedThreshold);if(first>0){var distTop=offset-this.__getFrameMetricsApprox(first,this.props).offset;hiPri=distTop<0||velocity<-2&&distTop<getScrollingThreshold(onStartReachedThreshold,visibleLength);}if(!hiPri&&last>=0&&last<itemCount-1){var distBottom=this.__getFrameMetricsApprox(last,this.props).offset-(offset+visibleLength);hiPri=distBottom<0||velocity>2&&distBottom<getScrollingThreshold(onEndReachedThreshold,visibleLength);}if(hiPri&&(this._averageCellLength||this.props.getItemLayout)&&!this._hiPriInProgress){this._hiPriInProgress=true;this._updateCellsToRenderBatcher.dispose({abort:true});this._updateCellsToRender();return;}else{this._updateCellsToRenderBatcher.schedule();}}},{key:"_updateViewableItems",value:function _updateViewableItems(props,cellsAroundViewport){var _this5=this;if(this.state.pendingScrollUpdateCount>0){return;}this._viewabilityTuples.forEach(function(tuple){tuple.viewabilityHelper.onUpdate(props,_this5._scrollMetrics.offset,_this5._scrollMetrics.visibleLength,_this5._getFrameMetrics,_this5._createViewToken,tuple.onViewableItemsChanged,cellsAroundViewport);});}}],[{key:"_findItemIndexWithKey",value:function _findItemIndexWithKey(props,key,hint){var itemCount=props.getItemCount(props.data);if(hint!=null&&hint>=0&&hint<itemCount){var curKey=VirtualizedList._getItemKey(props,hint);if(curKey===key){return hint;}}for(var ii=0;ii<itemCount;ii++){var _curKey=VirtualizedList._getItemKey(props,ii);if(_curKey===key){return ii;}}return null;}},{key:"_getItemKey",value:function _getItemKey(props,index){var item=props.getItem(props.data,index);return VirtualizedList._keyExtractor(item,index,props);}},{key:"_createRenderMask",value:function _createRenderMask(props,cellsAroundViewport,additionalRegions){var itemCount=props.getItemCount(props.data);(0,_invariant.default)(cellsAroundViewport.first>=0&&cellsAroundViewport.last>=cellsAroundViewport.first-1&&cellsAroundViewport.last<itemCount,`Invalid cells around viewport "[${cellsAroundViewport.first}, ${cellsAroundViewport.last}]" was passed to VirtualizedList._createRenderMask`);var renderMask=new _CellRenderMask.CellRenderMask(itemCount);if(itemCount>0){var allRegions=[cellsAroundViewport].concat((0,_toConsumableArray2.default)(additionalRegions!=null?additionalRegions:[]));for(var region of allRegions){renderMask.addCells(region);}if(props.initialScrollIndex==null||props.initialScrollIndex<=0){var initialRegion=VirtualizedList._initialRenderRegion(props);renderMask.addCells(initialRegion);}var stickyIndicesSet=new Set(props.stickyHeaderIndices);VirtualizedList._ensureClosestStickyHeader(props,stickyIndicesSet,renderMask,cellsAroundViewport.first);}return renderMask;}},{key:"_initialRenderRegion",value:function _initialRenderRegion(props){var _props$initialScrollI;var itemCount=props.getItemCount(props.data);var firstCellIndex=Math.max(0,Math.min(itemCount-1,Math.floor((_props$initialScrollI=props.initialScrollIndex)!=null?_props$initialScrollI:0)));var lastCellIndex=Math.min(itemCount,firstCellIndex+initialNumToRenderOrDefault(props.initialNumToRender))-1;return{first:firstCellIndex,last:lastCellIndex};}},{key:"_ensureClosestStickyHeader",value:function _ensureClosestStickyHeader(props,stickyIndicesSet,renderMask,cellIdx){var stickyOffset=props.ListHeaderComponent?1:0;for(var itemIdx=cellIdx-1;itemIdx>=0;itemIdx--){if(stickyIndicesSet.has(itemIdx+stickyOffset)){renderMask.addCells({first:itemIdx,last:itemIdx});break;}}}},{key:"getDerivedStateFromProps",value:function getDerivedStateFromProps(newProps,prevState){var _newProps$maintainVis,_newProps$maintainVis2;var itemCount=newProps.getItemCount(newProps.data);if(itemCount===prevState.renderMask.numCells()){return prevState;}var maintainVisibleContentPositionAdjustment=null;var prevFirstVisibleItemKey=prevState.firstVisibleItemKey;var minIndexForVisible=(_newProps$maintainVis=(_newProps$maintainVis2=newProps.maintainVisibleContentPosition)==null?void 0:_newProps$maintainVis2.minIndexForVisible)!=null?_newProps$maintainVis:0;var newFirstVisibleItemKey=newProps.getItemCount(newProps.data)>minIndexForVisible?VirtualizedList._getItemKey(newProps,minIndexForVisible):null;if(newProps.maintainVisibleContentPosition!=null&&prevFirstVisibleItemKey!=null&&newFirstVisibleItemKey!=null){if(newFirstVisibleItemKey!==prevFirstVisibleItemKey){var hint=itemCount-prevState.renderMask.numCells()+minIndexForVisible;var firstVisibleItemIndex=VirtualizedList._findItemIndexWithKey(newProps,prevFirstVisibleItemKey,hint);maintainVisibleContentPositionAdjustment=firstVisibleItemIndex!=null?firstVisibleItemIndex-minIndexForVisible:null;}else{maintainVisibleContentPositionAdjustment=null;}}var constrainedCells=VirtualizedList._constrainToItemCount(maintainVisibleContentPositionAdjustment!=null?{first:prevState.cellsAroundViewport.first+maintainVisibleContentPositionAdjustment,last:prevState.cellsAroundViewport.last+maintainVisibleContentPositionAdjustment}:prevState.cellsAroundViewport,newProps);return{cellsAroundViewport:constrainedCells,renderMask:VirtualizedList._createRenderMask(newProps,constrainedCells),firstVisibleItemKey:newFirstVisibleItemKey,pendingScrollUpdateCount:maintainVisibleContentPositionAdjustment!=null?prevState.pendingScrollUpdateCount+1:prevState.pendingScrollUpdateCount};}},{key:"_constrainToItemCount",value:function _constrainToItemCount(cells,props){var itemCount=props.getItemCount(props.data);var last=Math.min(itemCount-1,cells.last);var maxToRenderPerBatch=maxToRenderPerBatchOrDefault(props.maxToRenderPerBatch);return{first:(0,_clamp.default)(0,itemCount-1-maxToRenderPerBatch,cells.first),last:last};}},{key:"_keyExtractor",value:function _keyExtractor(item,index,props){if(props.keyExtractor!=null){return props.keyExtractor(item,index);}var key=(0,_VirtualizeUtils.keyExtractor)(item,index);if(key===String(index)){_usedIndexForKey=true;if(item.type&&item.type.displayName){_keylessItemComponentName=item.type.displayName;}}return key;}}]);}(_StateSafePureComponent.default);VirtualizedList.contextType=_VirtualizedListContext.VirtualizedListContext;var styles=_reactNative.StyleSheet.create({verticallyInverted:_reactNative.Platform.OS==='android'?{transform:[{scale:-1}]}:{transform:[{scaleY:-1}]},horizontallyInverted:{transform:[{scaleX:-1}]},debug:{flex:1},debugOverlayBase:{position:'absolute',top:0,right:0},debugOverlay:{bottom:0,width:20,borderColor:'blue',borderWidth:1},debugOverlayFrame:{left:0,backgroundColor:'orange'},debugOverlayFrameLast:{left:0,borderColor:'green',borderWidth:2},debugOverlayFrameVis:{left:0,borderColor:'red',borderWidth:2}});module.exports=VirtualizedList;
};
}
}
}
}).call(__webpack_require__._LM_("6", { module,__webpack_require__}))()
/***/ }),
/***/ 5827:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _reactNative=__webpack_require__(8773);var _VirtualizedListContext=__webpack_require__(9121);var _invariant=_interopRequireDefault(__webpack_require__(311));var React=_interopRequireWildcard(__webpack_require__(6540));var _jsxRuntime=__webpack_require__(4848);function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}var CellRenderer=exports["default"]=function(_React$Component){function CellRenderer(){var _this;(0,_classCallCheck2.default)(this,CellRenderer);for(var _len=arguments.length,args=new Array(_len),_key=0;_key<_len;_key++){args[_key]=arguments[_key];}_this=_callSuper(this,CellRenderer,[].concat(args));_this.state={separatorProps:{highlighted:false,leadingItem:_this.props.item}};_this._separators={highlight:function highlight(){var _this$props=_this.props,cellKey=_this$props.cellKey,prevCellKey=_this$props.prevCellKey;_this.props.onUpdateSeparators([cellKey,prevCellKey],{highlighted:true});},unhighlight:function unhighlight(){var _this$props2=_this.props,cellKey=_this$props2.cellKey,prevCellKey=_this$props2.prevCellKey;_this.props.onUpdateSeparators([cellKey,prevCellKey],{highlighted:false});},updateProps:function updateProps(select,newProps){var _this$props3=_this.props,cellKey=_this$props3.cellKey,prevCellKey=_this$props3.prevCellKey;_this.props.onUpdateSeparators([select==='leading'?prevCellKey:cellKey],newProps);}};_this._onLayout=function(nativeEvent){_this.props.onCellLayout&&_this.props.onCellLayout(nativeEvent,_this.props.cellKey,_this.props.index);};return _this;}(0,_inherits2.default)(CellRenderer,_React$Component);return(0,_createClass2.default)(CellRenderer,[{key:"updateSeparatorProps",value:function updateSeparatorProps(newProps){this.setState(function(state){return{separatorProps:Object.assign({},state.separatorProps,newProps)};});}},{key:"componentWillUnmount",value:function componentWillUnmount(){this.props.onUnmount(this.props.cellKey);}},{key:"_renderElement",value:function _renderElement(renderItem,ListItemComponent,item,index){if(renderItem&&ListItemComponent){console.warn('VirtualizedList: Both ListItemComponent and renderItem props are present. ListItemComponent will take'+' precedence over renderItem.');}if(ListItemComponent){return React.createElement(ListItemComponent,{item:item,index:index,separators:this._separators});}if(renderItem){return renderItem({item:item,index:index,separators:this._separators});}(0,_invariant.default)(false,'VirtualizedList: Either ListItemComponent or renderItem props are required but none were found.');}},{key:"render",value:function render(){var _this$props4=this.props,CellRendererComponent=_this$props4.CellRendererComponent,ItemSeparatorComponent=_this$props4.ItemSeparatorComponent,ListItemComponent=_this$props4.ListItemComponent,cellKey=_this$props4.cellKey,horizontal=_this$props4.horizontal,item=_this$props4.item,index=_this$props4.index,inversionStyle=_this$props4.inversionStyle,onCellFocusCapture=_this$props4.onCellFocusCapture,onCellLayout=_this$props4.onCellLayout,renderItem=_this$props4.renderItem;var element=this._renderElement(renderItem,ListItemComponent,item,index);var itemSeparator=React.isValidElement(ItemSeparatorComponent)?ItemSeparatorComponent:ItemSeparatorComponent&&(0,_jsxRuntime.jsx)(ItemSeparatorComponent,Object.assign({},this.state.separatorProps));var cellStyle=inversionStyle?horizontal?[styles.rowReverse,inversionStyle]:[styles.columnReverse,inversionStyle]:horizontal?[styles.row,inversionStyle]:inversionStyle;var result=!CellRendererComponent?(0,_jsxRuntime.jsxs)(_reactNative.View,Object.assign({style:cellStyle,onFocusCapture:onCellFocusCapture},onCellLayout&&{onLayout:this._onLayout},{children:[element,itemSeparator]})):(0,_jsxRuntime.jsxs)(CellRendererComponent,Object.assign({cellKey:cellKey,index:index,item:item,style:cellStyle,onFocusCapture:onCellFocusCapture},onCellLayout&&{onLayout:this._onLayout},{children:[element,itemSeparator]}));return(0,_jsxRuntime.jsx)(_VirtualizedListContext.VirtualizedListCellContextProvider,{cellKey:this.props.cellKey,children:result});}}],[{key:"getDerivedStateFromProps",value:function getDerivedStateFromProps(props,prevState){return{separatorProps:Object.assign({},prevState.separatorProps,{leadingItem:props.item})};}}]);}(React.Component);var styles=_reactNative.StyleSheet.create({row:{flexDirection:'row'},rowReverse:{flexDirection:'row-reverse'},columnReverse:{flexDirection:'column-reverse'}});
};
}
}
}
}).call(__webpack_require__._LM_("6", { exports,__webpack_require__}))()
/***/ }),
/***/ 9121:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports.VirtualizedListCellContextProvider=VirtualizedListCellContextProvider;exports.VirtualizedListContext=void 0;exports.VirtualizedListContextProvider=VirtualizedListContextProvider;exports.VirtualizedListContextResetter=VirtualizedListContextResetter;var _react=_interopRequireWildcard(__webpack_require__(6540));var React=_react;var _jsxRuntime=__webpack_require__(4848);function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var VirtualizedListContext=exports.VirtualizedListContext=React.createContext(null);if(false){}function VirtualizedListContextResetter(_ref){var children=_ref.children;return(0,_jsxRuntime.jsx)(VirtualizedListContext.Provider,{value:null,children:children});}function VirtualizedListContextProvider(_ref2){var children=_ref2.children,value=_ref2.value;var context=(0,_react.useMemo)(function(){return{cellKey:null,getScrollMetrics:value.getScrollMetrics,horizontal:value.horizontal,getOutermostParentListRef:value.getOutermostParentListRef,registerAsNestedChild:value.registerAsNestedChild,unregisterAsNestedChild:value.unregisterAsNestedChild};},[value.getScrollMetrics,value.horizontal,value.getOutermostParentListRef,value.registerAsNestedChild,value.unregisterAsNestedChild]);return(0,_jsxRuntime.jsx)(VirtualizedListContext.Provider,{value:context,children:children});}function VirtualizedListCellContextProvider(_ref3){var cellKey=_ref3.cellKey,children=_ref3.children;var currContext=(0,_react.useContext)(VirtualizedListContext);var context=(0,_react.useMemo)(function(){return currContext==null?null:Object.assign({},currContext,{cellKey:cellKey});},[currContext,cellKey]);return(0,_jsxRuntime.jsx)(VirtualizedListContext.Provider,{value:context,children:children});}
};
}
}
}
}).call(__webpack_require__._LM_("6", { exports,__webpack_require__}))()
/***/ }),
/***/ 3105:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _slicedToArray2=_interopRequireDefault(__webpack_require__(5715));var _objectWithoutProperties2=_interopRequireDefault(__webpack_require__(1847));var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _reactNative=__webpack_require__(8773);var _VirtualizedList=_interopRequireDefault(__webpack_require__(6348));var _VirtualizeUtils=__webpack_require__(1269);var _invariant=_interopRequireDefault(__webpack_require__(311));var React=_interopRequireWildcard(__webpack_require__(6540));var _jsxRuntime=__webpack_require__(4848);var _excluded=["ItemSeparatorComponent","SectionSeparatorComponent","renderItem","renderSectionFooter","renderSectionHeader","sections","stickySectionHeadersEnabled"];function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}var VirtualizedSectionList=function(_React$PureComponent){function VirtualizedSectionList(){var _this;(0,_classCallCheck2.default)(this,VirtualizedSectionList);for(var _len=arguments.length,args=new Array(_len),_key=0;_key<_len;_key++){args[_key]=arguments[_key];}_this=_callSuper(this,VirtualizedSectionList,[].concat(args));_this._keyExtractor=function(item,index){var info=_this._subExtractor(index);return info&&info.key||String(index);};_this._convertViewable=function(viewable){var _info$index;(0,_invariant.default)(viewable.index!=null,'Received a broken ViewToken');var info=_this._subExtractor(viewable.index);if(!info){return null;}var keyExtractorWithNullableIndex=info.section.keyExtractor;var keyExtractorWithNonNullableIndex=_this.props.keyExtractor||_VirtualizeUtils.keyExtractor;var key=keyExtractorWithNullableIndex!=null?keyExtractorWithNullableIndex(viewable.item,info.index):keyExtractorWithNonNullableIndex(viewable.item,(_info$index=info.index)!=null?_info$index:0);return Object.assign({},viewable,{index:info.index,key:key,section:info.section});};_this._onViewableItemsChanged=function(_ref){var viewableItems=_ref.viewableItems,changed=_ref.changed;var onViewableItemsChanged=_this.props.onViewableItemsChanged;if(onViewableItemsChanged!=null){onViewableItemsChanged({viewableItems:viewableItems.map(_this._convertViewable,_this).filter(Boolean),changed:changed.map(_this._convertViewable,_this).filter(Boolean)});}};_this._renderItem=function(listItemCount){return(function(_ref2){var item=_ref2.item,index=_ref2.index;var info=_this._subExtractor(index);if(!info){return null;}var infoIndex=info.index;if(infoIndex==null){var section=info.section;if(info.header===true){var renderSectionHeader=_this.props.renderSectionHeader;return renderSectionHeader?renderSectionHeader({section:section}):null;}else{var renderSectionFooter=_this.props.renderSectionFooter;return renderSectionFooter?renderSectionFooter({section:section}):null;}}else{var renderItem=info.section.renderItem||_this.props.renderItem;var SeparatorComponent=_this._getSeparatorComponent(index,info,listItemCount);(0,_invariant.default)(renderItem,'no renderItem!');return(0,_jsxRuntime.jsx)(ItemWithSeparator,{SeparatorComponent:SeparatorComponent,LeadingSeparatorComponent:infoIndex===0?_this.props.SectionSeparatorComponent:undefined,cellKey:info.key,index:infoIndex,item:item,leadingItem:info.leadingItem,leadingSection:info.leadingSection,prevCellKey:(_this._subExtractor(index-1)||{}).key,setSelfHighlightCallback:_this._setUpdateHighlightFor,setSelfUpdatePropsCallback:_this._setUpdatePropsFor,updateHighlightFor:_this._updateHighlightFor,updatePropsFor:_this._updatePropsFor,renderItem:renderItem,section:info.section,trailingItem:info.trailingItem,trailingSection:info.trailingSection,inverted:!!_this.props.inverted});}});};_this._updatePropsFor=function(cellKey,value){var updateProps=_this._updatePropsMap[cellKey];if(updateProps!=null){updateProps(value);}};_this._updateHighlightFor=function(cellKey,value){var updateHighlight=_this._updateHighlightMap[cellKey];if(updateHighlight!=null){updateHighlight(value);}};_this._setUpdateHighlightFor=function(cellKey,updateHighlightFn){if(updateHighlightFn!=null){_this._updateHighlightMap[cellKey]=updateHighlightFn;}else{delete _this._updateHighlightFor[cellKey];}};_this._setUpdatePropsFor=function(cellKey,updatePropsFn){if(updatePropsFn!=null){_this._updatePropsMap[cellKey]=updatePropsFn;}else{delete _this._updatePropsMap[cellKey];}};_this._updateHighlightMap={};_this._updatePropsMap={};_this._captureRef=function(ref){_this._listRef=ref;};return _this;}(0,_inherits2.default)(VirtualizedSectionList,_React$PureComponent);return(0,_createClass2.default)(VirtualizedSectionList,[{key:"scrollToLocation",value:function scrollToLocation(params){var index=params.itemIndex;for(var i=0;i<params.sectionIndex;i++){index+=this.props.getItemCount(this.props.sections[i].data)+2;}var viewOffset=params.viewOffset||0;if(this._listRef==null){return;}if(params.itemIndex>0&&this.props.stickySectionHeadersEnabled){var frame=this._listRef.__getFrameMetricsApprox(index-params.itemIndex,this._listRef.props);viewOffset+=frame.length;}var toIndexParams=Object.assign({},params,{viewOffset:viewOffset,index:index});this._listRef.scrollToIndex(toIndexParams);}},{key:"getListRef",value:function getListRef(){return this._listRef;}},{key:"render",value:function render(){var _this2=this;var _this$props=this.props,ItemSeparatorComponent=_this$props.ItemSeparatorComponent,SectionSeparatorComponent=_this$props.SectionSeparatorComponent,_renderItem=_this$props.renderItem,renderSectionFooter=_this$props.renderSectionFooter,renderSectionHeader=_this$props.renderSectionHeader,_sections=_this$props.sections,stickySectionHeadersEnabled=_this$props.stickySectionHeadersEnabled,passThroughProps=(0,_objectWithoutProperties2.default)(_this$props,_excluded);var listHeaderOffset=this.props.ListHeaderComponent?1:0;var stickyHeaderIndices=this.props.stickySectionHeadersEnabled?[]:undefined;var itemCount=0;for(var section of this.props.sections){if(stickyHeaderIndices!=null){stickyHeaderIndices.push(itemCount+listHeaderOffset);}itemCount+=2;itemCount+=this.props.getItemCount(section.data);}var renderItem=this._renderItem(itemCount);return(0,_jsxRuntime.jsx)(_VirtualizedList.default,Object.assign({},passThroughProps,{keyExtractor:this._keyExtractor,stickyHeaderIndices:stickyHeaderIndices,renderItem:renderItem,data:this.props.sections,getItem:function getItem(sections,index){return _this2._getItem(_this2.props,sections,index);},getItemCount:function getItemCount(){return itemCount;},onViewableItemsChanged:this.props.onViewableItemsChanged?this._onViewableItemsChanged:undefined,ref:this._captureRef}));}},{key:"_getItem",value:function _getItem(props,sections,index){if(!sections){return null;}var itemIdx=index-1;for(var i=0;i<sections.length;i++){var section=sections[i];var sectionData=section.data;var itemCount=props.getItemCount(sectionData);if(itemIdx===-1||itemIdx===itemCount){return section;}else if(itemIdx<itemCount){return props.getItem(sectionData,itemIdx);}else{itemIdx-=itemCount+2;}}return null;}},{key:"_subExtractor",value:function _subExtractor(index){var itemIndex=index;var _this$props2=this.props,getItem=_this$props2.getItem,getItemCount=_this$props2.getItemCount,keyExtractor=_this$props2.keyExtractor,sections=_this$props2.sections;for(var i=0;i<sections.length;i++){var section=sections[i];var sectionData=section.data;var key=section.key||String(i);itemIndex-=1;if(itemIndex>=getItemCount(sectionData)+1){itemIndex-=getItemCount(sectionData)+1;}else if(itemIndex===-1){return{section:section,key:key+':header',index:null,header:true,trailingSection:sections[i+1]};}else if(itemIndex===getItemCount(sectionData)){return{section:section,key:key+':footer',index:null,header:false,trailingSection:sections[i+1]};}else{var extractor=section.keyExtractor||keyExtractor||_VirtualizeUtils.keyExtractor;return{section:section,key:key+':'+extractor(getItem(sectionData,itemIndex),itemIndex),index:itemIndex,leadingItem:getItem(sectionData,itemIndex-1),leadingSection:sections[i-1],trailingItem:getItem(sectionData,itemIndex+1),trailingSection:sections[i+1]};}}}},{key:"_getSeparatorComponent",value:function _getSeparatorComponent(index,info,listItemCount){info=info||this._subExtractor(index);if(!info){return null;}var ItemSeparatorComponent=info.section.ItemSeparatorComponent||this.props.ItemSeparatorComponent;var SectionSeparatorComponent=this.props.SectionSeparatorComponent;var isLastItemInList=index===listItemCount-1;var isLastItemInSection=info.index===this.props.getItemCount(info.section.data)-1;if(SectionSeparatorComponent&&isLastItemInSection){return SectionSeparatorComponent;}if(ItemSeparatorComponent&&!isLastItemInSection&&!isLastItemInList){return ItemSeparatorComponent;}return null;}}]);}(React.PureComponent);function ItemWithSeparator(props){var LeadingSeparatorComponent=props.LeadingSeparatorComponent,SeparatorComponent=props.SeparatorComponent,cellKey=props.cellKey,prevCellKey=props.prevCellKey,setSelfHighlightCallback=props.setSelfHighlightCallback,updateHighlightFor=props.updateHighlightFor,setSelfUpdatePropsCallback=props.setSelfUpdatePropsCallback,updatePropsFor=props.updatePropsFor,item=props.item,index=props.index,section=props.section,inverted=props.inverted;var _React$useState=React.useState(false),_React$useState2=(0,_slicedToArray2.default)(_React$useState,2),leadingSeparatorHiglighted=_React$useState2[0],setLeadingSeparatorHighlighted=_React$useState2[1];var _React$useState3=React.useState(false),_React$useState4=(0,_slicedToArray2.default)(_React$useState3,2),separatorHighlighted=_React$useState4[0],setSeparatorHighlighted=_React$useState4[1];var _React$useState5=React.useState({leadingItem:props.leadingItem,leadingSection:props.leadingSection,section:props.section,trailingItem:props.item,trailingSection:props.trailingSection}),_React$useState6=(0,_slicedToArray2.default)(_React$useState5,2),leadingSeparatorProps=_React$useState6[0],setLeadingSeparatorProps=_React$useState6[1];var _React$useState7=React.useState({leadingItem:props.item,leadingSection:props.leadingSection,section:props.section,trailingItem:props.trailingItem,trailingSection:props.trailingSection}),_React$useState8=(0,_slicedToArray2.default)(_React$useState7,2),separatorProps=_React$useState8[0],setSeparatorProps=_React$useState8[1];React.useEffect(function(){setSelfHighlightCallback(cellKey,setSeparatorHighlighted);setSelfUpdatePropsCallback(cellKey,setSeparatorProps);return function(){setSelfUpdatePropsCallback(cellKey,null);setSelfHighlightCallback(cellKey,null);};},[cellKey,setSelfHighlightCallback,setSeparatorProps,setSelfUpdatePropsCallback]);var separators={highlight:function highlight(){setLeadingSeparatorHighlighted(true);setSeparatorHighlighted(true);if(prevCellKey!=null){updateHighlightFor(prevCellKey,true);}},unhighlight:function unhighlight(){setLeadingSeparatorHighlighted(false);setSeparatorHighlighted(false);if(prevCellKey!=null){updateHighlightFor(prevCellKey,false);}},updateProps:function updateProps(select,newProps){if(select==='leading'){if(LeadingSeparatorComponent!=null){setLeadingSeparatorProps(Object.assign({},leadingSeparatorProps,newProps));}else if(prevCellKey!=null){updatePropsFor(prevCellKey,Object.assign({},leadingSeparatorProps,newProps));}}else if(select==='trailing'&&SeparatorComponent!=null){setSeparatorProps(Object.assign({},separatorProps,newProps));}}};var element=props.renderItem({item:item,index:index,section:section,separators:separators});var leadingSeparator=LeadingSeparatorComponent!=null&&(0,_jsxRuntime.jsx)(LeadingSeparatorComponent,Object.assign({highlighted:leadingSeparatorHiglighted},leadingSeparatorProps));var separator=SeparatorComponent!=null&&(0,_jsxRuntime.jsx)(SeparatorComponent,Object.assign({highlighted:separatorHighlighted},separatorProps));return leadingSeparator||separator?(0,_jsxRuntime.jsxs)(_reactNative.View,{children:[inverted===false?leadingSeparator:separator,element,inverted===false?separator:leadingSeparator]}):element;}module.exports=VirtualizedSectionList;
};
}
}
}
}).call(__webpack_require__._LM_("6", { module,__webpack_require__}))()
/***/ }),
/***/ 3695:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
function clamp(min,value,max){if(value<min){return min;}if(value>max){return max;}return value;}module.exports=clamp;
};
}
}
}
}).call(__webpack_require__._LM_("6", { module,__webpack_require__}))()
/***/ }),
/***/ 2758:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
function infoLog(){var _console;return(_console=console).log.apply(_console,arguments);}module.exports=infoLog;
};
}
}
}
}).call(__webpack_require__._LM_("6", { module,__webpack_require__}))()
/***/ }),
/***/ 1843:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _VirtualizeUtils=__webpack_require__(1269);module.exports={keyExtractor:_VirtualizeUtils.keyExtractor,get VirtualizedList(){return __webpack_require__(6348);},get VirtualizedSectionList(){return __webpack_require__(3105);},get VirtualizedListContextResetter(){var VirtualizedListContext=__webpack_require__(9121);return VirtualizedListContext.VirtualizedListContextResetter;},get ViewabilityHelper(){return __webpack_require__(6064);},get FillRateHelper(){return __webpack_require__(4382);}};
};
}
}
}
}).call(__webpack_require__._LM_("6", { module,__webpack_require__}))()
/***/ }),
/***/ 2866:
/***/ (function(module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _inherits2=_interopRequireDefault(__webpack_require__(9511));function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}Object.defineProperty(exports, "__esModule", ({value:true}));var eventTargetShim=__webpack_require__(4988);var AbortSignal=function(_eventTargetShim$Even){function AbortSignal(){var _this;(0,_classCallCheck2.default)(this,AbortSignal);_this=_callSuper(this,AbortSignal);throw new TypeError("AbortSignal cannot be constructed directly");return _this;}(0,_inherits2.default)(AbortSignal,_eventTargetShim$Even);return(0,_createClass2.default)(AbortSignal,[{key:"aborted",get:function get(){var aborted=abortedFlags.get(this);if(typeof aborted!=="boolean"){throw new TypeError(`Expected 'this' to be an 'AbortSignal' object, but got ${this===null?"null":typeof this}`);}return aborted;}}]);}(eventTargetShim.EventTarget);eventTargetShim.defineEventAttribute(AbortSignal.prototype,"abort");function createAbortSignal(){var signal=Object.create(AbortSignal.prototype);eventTargetShim.EventTarget.call(signal);abortedFlags.set(signal,false);return signal;}function abortSignal(signal){if(abortedFlags.get(signal)!==false){return;}abortedFlags.set(signal,true);signal.dispatchEvent({type:"abort"});}var abortedFlags=new WeakMap();Object.defineProperties(AbortSignal.prototype,{aborted:{enumerable:true}});if(typeof Symbol==="function"&&typeof Symbol.toStringTag==="symbol"){Object.defineProperty(AbortSignal.prototype,Symbol.toStringTag,{configurable:true,value:"AbortSignal"});}var AbortController=function(){function AbortController(){(0,_classCallCheck2.default)(this,AbortController);signals.set(this,createAbortSignal());}return(0,_createClass2.default)(AbortController,[{key:"signal",get:function get(){return getSignal(this);}},{key:"abort",value:function abort(){abortSignal(getSignal(this));}}]);}();var signals=new WeakMap();function getSignal(controller){var signal=signals.get(controller);if(signal==null){throw new TypeError(`Expected 'this' to be an 'AbortController' object, but got ${controller===null?"null":typeof controller}`);}return signal;}Object.defineProperties(AbortController.prototype,{signal:{enumerable:true},abort:{enumerable:true}});if(typeof Symbol==="function"&&typeof Symbol.toStringTag==="symbol"){Object.defineProperty(AbortController.prototype,Symbol.toStringTag,{configurable:true,value:"AbortController"});}exports.AbortController=AbortController;exports.AbortSignal=AbortSignal;exports["default"]=AbortController;module.exports=AbortController;module.exports.AbortController=module.exports["default"]=AbortController;module.exports.AbortSignal=AbortSignal;
};
}
}
}
}).call(__webpack_require__._LM_("7", { exports,module,__webpack_require__}))()
/***/ }),
/***/ 2989:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
function normalizeColor(color){if(typeof color==='number'){if(color>>>0===color&&color>=0&&color<=0xffffffff){return color;}return null;}if(typeof color!=='string'){return null;}var matchers=getMatchers();var match;if(match=matchers.hex6.exec(color)){return parseInt(match[1]+'ff',16)>>>0;}var colorFromKeyword=normalizeKeyword(color);if(colorFromKeyword!=null){return colorFromKeyword;}if(match=matchers.rgb.exec(color)){return(parse255(match[1])<<24|parse255(match[2])<<16|parse255(match[3])<<8|0x000000ff)>>>0;}if(match=matchers.rgba.exec(color)){if(match[6]!==undefined){return(parse255(match[6])<<24|parse255(match[7])<<16|parse255(match[8])<<8|parse1(match[9]))>>>0;}return(parse255(match[2])<<24|parse255(match[3])<<16|parse255(match[4])<<8|parse1(match[5]))>>>0;}if(match=matchers.hex3.exec(color)){return parseInt(match[1]+match[1]+match[2]+match[2]+match[3]+match[3]+'ff',16)>>>0;}if(match=matchers.hex8.exec(color)){return parseInt(match[1],16)>>>0;}if(match=matchers.hex4.exec(color)){return parseInt(match[1]+match[1]+match[2]+match[2]+match[3]+match[3]+match[4]+match[4],16)>>>0;}if(match=matchers.hsl.exec(color)){return(hslToRgb(parse360(match[1]),parsePercentage(match[2]),parsePercentage(match[3]))|0x000000ff)>>>0;}if(match=matchers.hsla.exec(color)){if(match[6]!==undefined){return(hslToRgb(parse360(match[6]),parsePercentage(match[7]),parsePercentage(match[8]))|parse1(match[9]))>>>0;}return(hslToRgb(parse360(match[2]),parsePercentage(match[3]),parsePercentage(match[4]))|parse1(match[5]))>>>0;}if(match=matchers.hwb.exec(color)){return(hwbToRgb(parse360(match[1]),parsePercentage(match[2]),parsePercentage(match[3]))|0x000000ff)>>>0;}return null;}function hue2rgb(p,q,t){if(t<0){t+=1;}if(t>1){t-=1;}if(t<1/6){return p+(q-p)*6*t;}if(t<1/2){return q;}if(t<2/3){return p+(q-p)*(2/3-t)*6;}return p;}function hslToRgb(h,s,l){var q=l<0.5?l*(1+s):l+s-l*s;var p=2*l-q;var r=hue2rgb(p,q,h+1/3);var g=hue2rgb(p,q,h);var b=hue2rgb(p,q,h-1/3);return Math.round(r*255)<<24|Math.round(g*255)<<16|Math.round(b*255)<<8;}function hwbToRgb(h,w,b){if(w+b>=1){var gray=Math.round(w*255/(w+b));return gray<<24|gray<<16|gray<<8;}var red=hue2rgb(0,1,h+1/3)*(1-w-b)+w;var green=hue2rgb(0,1,h)*(1-w-b)+w;var blue=hue2rgb(0,1,h-1/3)*(1-w-b)+w;return Math.round(red*255)<<24|Math.round(green*255)<<16|Math.round(blue*255)<<8;}var NUMBER='[-+]?\\d*\\.?\\d+';var PERCENTAGE=NUMBER+'%';function call(){for(var _len=arguments.length,args=new Array(_len),_key=0;_key<_len;_key++){args[_key]=arguments[_key];}return'\\(\\s*('+args.join(')\\s*,?\\s*(')+')\\s*\\)';}function callWithSlashSeparator(){for(var _len2=arguments.length,args=new Array(_len2),_key2=0;_key2<_len2;_key2++){args[_key2]=arguments[_key2];}return'\\(\\s*('+args.slice(0,args.length-1).join(')\\s*,?\\s*(')+')\\s*/\\s*('+args[args.length-1]+')\\s*\\)';}function commaSeparatedCall(){for(var _len3=arguments.length,args=new Array(_len3),_key3=0;_key3<_len3;_key3++){args[_key3]=arguments[_key3];}return'\\(\\s*('+args.join(')\\s*,\\s*(')+')\\s*\\)';}var cachedMatchers;function getMatchers(){if(cachedMatchers===undefined){cachedMatchers={rgb:new RegExp('rgb'+call(NUMBER,NUMBER,NUMBER)),rgba:new RegExp('rgba('+commaSeparatedCall(NUMBER,NUMBER,NUMBER,NUMBER)+'|'+callWithSlashSeparator(NUMBER,NUMBER,NUMBER,NUMBER)+')'),hsl:new RegExp('hsl'+call(NUMBER,PERCENTAGE,PERCENTAGE)),hsla:new RegExp('hsla('+commaSeparatedCall(NUMBER,PERCENTAGE,PERCENTAGE,NUMBER)+'|'+callWithSlashSeparator(NUMBER,PERCENTAGE,PERCENTAGE,NUMBER)+')'),hwb:new RegExp('hwb'+call(NUMBER,PERCENTAGE,PERCENTAGE)),hex3:/^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,hex4:/^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,hex6:/^#([0-9a-fA-F]{6})$/,hex8:/^#([0-9a-fA-F]{8})$/};}return cachedMatchers;}function parse255(str){var int=parseInt(str,10);if(int<0){return 0;}if(int>255){return 255;}return int;}function parse360(str){var int=parseFloat(str);return(int%360+360)%360/360;}function parse1(str){var num=parseFloat(str);if(num<0){return 0;}if(num>1){return 255;}return Math.round(num*255);}function parsePercentage(str){var int=parseFloat(str);if(int<0){return 0;}if(int>100){return 1;}return int/100;}function normalizeKeyword(name){switch(name){case'transparent':return 0x00000000;case'aliceblue':return 0xf0f8ffff;case'antiquewhite':return 0xfaebd7ff;case'aqua':return 0x00ffffff;case'aquamarine':return 0x7fffd4ff;case'azure':return 0xf0ffffff;case'beige':return 0xf5f5dcff;case'bisque':return 0xffe4c4ff;case'black':return 0x000000ff;case'blanchedalmond':return 0xffebcdff;case'blue':return 0x0000ffff;case'blueviolet':return 0x8a2be2ff;case'brown':return 0xa52a2aff;case'burlywood':return 0xdeb887ff;case'burntsienna':return 0xea7e5dff;case'cadetblue':return 0x5f9ea0ff;case'chartreuse':return 0x7fff00ff;case'chocolate':return 0xd2691eff;case'coral':return 0xff7f50ff;case'cornflowerblue':return 0x6495edff;case'cornsilk':return 0xfff8dcff;case'crimson':return 0xdc143cff;case'cyan':return 0x00ffffff;case'darkblue':return 0x00008bff;case'darkcyan':return 0x008b8bff;case'darkgoldenrod':return 0xb8860bff;case'darkgray':return 0xa9a9a9ff;case'darkgreen':return 0x006400ff;case'darkgrey':return 0xa9a9a9ff;case'darkkhaki':return 0xbdb76bff;case'darkmagenta':return 0x8b008bff;case'darkolivegreen':return 0x556b2fff;case'darkorange':return 0xff8c00ff;case'darkorchid':return 0x9932ccff;case'darkred':return 0x8b0000ff;case'darksalmon':return 0xe9967aff;case'darkseagreen':return 0x8fbc8fff;case'darkslateblue':return 0x483d8bff;case'darkslategray':return 0x2f4f4fff;case'darkslategrey':return 0x2f4f4fff;case'darkturquoise':return 0x00ced1ff;case'darkviolet':return 0x9400d3ff;case'deeppink':return 0xff1493ff;case'deepskyblue':return 0x00bfffff;case'dimgray':return 0x696969ff;case'dimgrey':return 0x696969ff;case'dodgerblue':return 0x1e90ffff;case'firebrick':return 0xb22222ff;case'floralwhite':return 0xfffaf0ff;case'forestgreen':return 0x228b22ff;case'fuchsia':return 0xff00ffff;case'gainsboro':return 0xdcdcdcff;case'ghostwhite':return 0xf8f8ffff;case'gold':return 0xffd700ff;case'goldenrod':return 0xdaa520ff;case'gray':return 0x808080ff;case'green':return 0x008000ff;case'greenyellow':return 0xadff2fff;case'grey':return 0x808080ff;case'honeydew':return 0xf0fff0ff;case'hotpink':return 0xff69b4ff;case'indianred':return 0xcd5c5cff;case'indigo':return 0x4b0082ff;case'ivory':return 0xfffff0ff;case'khaki':return 0xf0e68cff;case'lavender':return 0xe6e6faff;case'lavenderblush':return 0xfff0f5ff;case'lawngreen':return 0x7cfc00ff;case'lemonchiffon':return 0xfffacdff;case'lightblue':return 0xadd8e6ff;case'lightcoral':return 0xf08080ff;case'lightcyan':return 0xe0ffffff;case'lightgoldenrodyellow':return 0xfafad2ff;case'lightgray':return 0xd3d3d3ff;case'lightgreen':return 0x90ee90ff;case'lightgrey':return 0xd3d3d3ff;case'lightpink':return 0xffb6c1ff;case'lightsalmon':return 0xffa07aff;case'lightseagreen':return 0x20b2aaff;case'lightskyblue':return 0x87cefaff;case'lightslategray':return 0x778899ff;case'lightslategrey':return 0x778899ff;case'lightsteelblue':return 0xb0c4deff;case'lightyellow':return 0xffffe0ff;case'lime':return 0x00ff00ff;case'limegreen':return 0x32cd32ff;case'linen':return 0xfaf0e6ff;case'magenta':return 0xff00ffff;case'maroon':return 0x800000ff;case'mediumaquamarine':return 0x66cdaaff;case'mediumblue':return 0x0000cdff;case'mediumorchid':return 0xba55d3ff;case'mediumpurple':return 0x9370dbff;case'mediumseagreen':return 0x3cb371ff;case'mediumslateblue':return 0x7b68eeff;case'mediumspringgreen':return 0x00fa9aff;case'mediumturquoise':return 0x48d1ccff;case'mediumvioletred':return 0xc71585ff;case'midnightblue':return 0x191970ff;case'mintcream':return 0xf5fffaff;case'mistyrose':return 0xffe4e1ff;case'moccasin':return 0xffe4b5ff;case'navajowhite':return 0xffdeadff;case'navy':return 0x000080ff;case'oldlace':return 0xfdf5e6ff;case'olive':return 0x808000ff;case'olivedrab':return 0x6b8e23ff;case'orange':return 0xffa500ff;case'orangered':return 0xff4500ff;case'orchid':return 0xda70d6ff;case'palegoldenrod':return 0xeee8aaff;case'palegreen':return 0x98fb98ff;case'paleturquoise':return 0xafeeeeff;case'palevioletred':return 0xdb7093ff;case'papayawhip':return 0xffefd5ff;case'peachpuff':return 0xffdab9ff;case'peru':return 0xcd853fff;case'pink':return 0xffc0cbff;case'plum':return 0xdda0ddff;case'powderblue':return 0xb0e0e6ff;case'purple':return 0x800080ff;case'rebeccapurple':return 0x663399ff;case'red':return 0xff0000ff;case'rosybrown':return 0xbc8f8fff;case'royalblue':return 0x4169e1ff;case'saddlebrown':return 0x8b4513ff;case'salmon':return 0xfa8072ff;case'sandybrown':return 0xf4a460ff;case'seagreen':return 0x2e8b57ff;case'seashell':return 0xfff5eeff;case'sienna':return 0xa0522dff;case'silver':return 0xc0c0c0ff;case'skyblue':return 0x87ceebff;case'slateblue':return 0x6a5acdff;case'slategray':return 0x708090ff;case'slategrey':return 0x708090ff;case'snow':return 0xfffafaff;case'springgreen':return 0x00ff7fff;case'steelblue':return 0x4682b4ff;case'tan':return 0xd2b48cff;case'teal':return 0x008080ff;case'thistle':return 0xd8bfd8ff;case'tomato':return 0xff6347ff;case'turquoise':return 0x40e0d0ff;case'violet':return 0xee82eeff;case'wheat':return 0xf5deb3ff;case'white':return 0xffffffff;case'whitesmoke':return 0xf5f5f5ff;case'yellow':return 0xffff00ff;case'yellowgreen':return 0x9acd32ff;}return null;}module.exports=normalizeColor;
};
}
}
}
}).call(__webpack_require__._LM_("undefined", { module,__webpack_require__}))()
/***/ }),
/***/ 572:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _objectWithoutProperties2=_interopRequireDefault(__webpack_require__(1847));var _NativeActionSheetManager=_interopRequireDefault(__webpack_require__(281));var _excluded=["tintColor","cancelButtonTintColor","destructiveButtonIndex"];var processColor=(__webpack_require__(5372)["default"]);var invariant=__webpack_require__(311);var ActionSheetIOS={showActionSheetWithOptions:function showActionSheetWithOptions(options,callback){invariant(typeof options==='object'&&options!==null,'Options must be a valid object');invariant(typeof callback==='function','Must provide a valid callback');invariant(_NativeActionSheetManager.default,"ActionSheetManager doesn't exist");var tintColor=options.tintColor,cancelButtonTintColor=options.cancelButtonTintColor,destructiveButtonIndex=options.destructiveButtonIndex,remainingOptions=(0,_objectWithoutProperties2.default)(options,_excluded);var destructiveButtonIndices=null;if(Array.isArray(destructiveButtonIndex)){destructiveButtonIndices=destructiveButtonIndex;}else if(typeof destructiveButtonIndex==='number'){destructiveButtonIndices=[destructiveButtonIndex];}var processedTintColor=processColor(tintColor);var processedCancelButtonTintColor=processColor(cancelButtonTintColor);invariant(processedTintColor==null||typeof processedTintColor==='number','Unexpected color given for ActionSheetIOS.showActionSheetWithOptions tintColor');invariant(processedCancelButtonTintColor==null||typeof processedCancelButtonTintColor==='number','Unexpected color given for ActionSheetIOS.showActionSheetWithOptions cancelButtonTintColor');_NativeActionSheetManager.default.showActionSheetWithOptions(Object.assign({},remainingOptions,{tintColor:processedTintColor,cancelButtonTintColor:processedCancelButtonTintColor,destructiveButtonIndices:destructiveButtonIndices}),callback);},showShareActionSheetWithOptions:function showShareActionSheetWithOptions(options,failureCallback,successCallback){invariant(typeof options==='object'&&options!==null,'Options must be a valid object');invariant(typeof failureCallback==='function','Must provide a valid failureCallback');invariant(typeof successCallback==='function','Must provide a valid successCallback');invariant(_NativeActionSheetManager.default,"ActionSheetManager doesn't exist");_NativeActionSheetManager.default.showShareActionSheetWithOptions(Object.assign({},options,{tintColor:processColor(options.tintColor)}),failureCallback,successCallback);},dismissActionSheet:function dismissActionSheet(){invariant(_NativeActionSheetManager.default,"ActionSheetManager doesn't exist");if(typeof _NativeActionSheetManager.default.dismissActionSheet==='function'){_NativeActionSheetManager.default.dismissActionSheet();}}};module.exports=ActionSheetIOS;
};
}
}
}
}).call(__webpack_require__._LM_("4", { __webpack_require__,module}))()
/***/ }),
/***/ 281:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var TurboModuleRegistry=_interopRequireWildcard(__webpack_require__(5333));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var _default=exports["default"]=TurboModuleRegistry.get('ActionSheetManager');
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 1422:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _Platform=_interopRequireDefault(__webpack_require__(8192));var _RCTAlertManager=_interopRequireDefault(__webpack_require__(8523));var Alert=function(){function Alert(){(0,_classCallCheck2.default)(this,Alert);}return(0,_createClass2.default)(Alert,null,[{key:"alert",value:function alert(title,message,buttons,options){if(_Platform.default.OS==='ios'){Alert.prompt(title,message,buttons,'default',undefined,undefined,options);}else if(_Platform.default.OS==='android'){var NativeDialogManagerAndroid=(__webpack_require__(3992)["default"]);if(!NativeDialogManagerAndroid){return;}var constants=NativeDialogManagerAndroid.getConstants();var config={title:title||'',message:message||'',cancelable:false};if(options&&options.cancelable){config.cancelable=options.cancelable;}var defaultPositiveText='OK';var validButtons=buttons?buttons.slice(0,3):[{text:defaultPositiveText}];var buttonPositive=validButtons.pop();var buttonNegative=validButtons.pop();var buttonNeutral=validButtons.pop();if(buttonNeutral){config.buttonNeutral=buttonNeutral.text||'';}if(buttonNegative){config.buttonNegative=buttonNegative.text||'';}if(buttonPositive){config.buttonPositive=buttonPositive.text||defaultPositiveText;}var onAction=function onAction(action,buttonKey){if(action===constants.buttonClicked){if(buttonKey===constants.buttonNeutral){buttonNeutral.onPress&&buttonNeutral.onPress();}else if(buttonKey===constants.buttonNegative){buttonNegative.onPress&&buttonNegative.onPress();}else if(buttonKey===constants.buttonPositive){buttonPositive.onPress&&buttonPositive.onPress();}}else if(action===constants.dismissed){options&&options.onDismiss&&options.onDismiss();}};var onError=function onError(errorMessage){return console.warn(errorMessage);};NativeDialogManagerAndroid.showAlert(config,onError,onAction);}}},{key:"prompt",value:function prompt(title,message,callbackOrButtons){var type=arguments.length>3&&arguments[3]!==undefined?arguments[3]:'plain-text';var defaultValue=arguments.length>4?arguments[4]:undefined;var keyboardType=arguments.length>5?arguments[5]:undefined;var options=arguments.length>6?arguments[6]:undefined;if(_Platform.default.OS==='ios'){var callbacks=[];var buttons=[];var cancelButtonKey;var destructiveButtonKey;var preferredButtonKey;if(typeof callbackOrButtons==='function'){callbacks=[callbackOrButtons];}else if(Array.isArray(callbackOrButtons)){callbackOrButtons.forEach(function(btn,index){callbacks[index]=btn.onPress;if(btn.style==='cancel'){cancelButtonKey=String(index);}else if(btn.style==='destructive'){destructiveButtonKey=String(index);}if(btn.isPreferred){preferredButtonKey=String(index);}if(btn.text||index<(callbackOrButtons||[]).length-1){var btnDef={};btnDef[index]=btn.text||'';buttons.push(btnDef);}});}_RCTAlertManager.default.alertWithArgs({title:title||'',message:message||undefined,buttons:buttons,type:type||undefined,defaultValue:defaultValue,cancelButtonKey:cancelButtonKey,destructiveButtonKey:destructiveButtonKey,preferredButtonKey:preferredButtonKey,keyboardType:keyboardType,userInterfaceStyle:(options==null?void 0:options.userInterfaceStyle)||undefined},function(id,value){var cb=callbacks[id];cb&&cb(value);});}}}]);}();module.exports=Alert;
};
}
}
}
}).call(__webpack_require__._LM_("4", { __webpack_require__,module}))()
/***/ }),
/***/ 5968:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var TurboModuleRegistry=_interopRequireWildcard(__webpack_require__(5333));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var _default=exports["default"]=TurboModuleRegistry.get('AlertManager');
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 8523:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _NativeAlertManager=_interopRequireDefault(__webpack_require__(5968));module.exports={alertWithArgs:function alertWithArgs(args,callback){if(_NativeAlertManager.default==null){return;}_NativeAlertManager.default.alertWithArgs(args,callback);}};
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 8886:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _Platform=_interopRequireDefault(__webpack_require__(8192));var _AnimatedImplementation=_interopRequireDefault(__webpack_require__(9860));var _AnimatedMock=_interopRequireDefault(__webpack_require__(6128));var Animated=_Platform.default.isTesting?_AnimatedMock.default:_AnimatedImplementation.default;var _default=exports["default"]=Object.assign({get FlatList(){return (__webpack_require__(3000)/* ["default"] */ .A);},get Image(){return (__webpack_require__(5554)/* ["default"] */ .A);},get ScrollView(){return (__webpack_require__(9975)/* ["default"] */ .A);},get SectionList(){return (__webpack_require__(9216)/* ["default"] */ .A);},get Text(){return (__webpack_require__(7576)/* ["default"] */ .A);},get View(){return (__webpack_require__(7598)/* ["default"] */ .A);}},Animated);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 8844:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports.AnimatedEvent=void 0;exports.attachNativeEvent=attachNativeEvent;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _RendererProxy=__webpack_require__(8907);var _NativeAnimatedHelper=_interopRequireDefault(__webpack_require__(6681));var _AnimatedValue=_interopRequireDefault(__webpack_require__(9579));var _AnimatedValueXY=_interopRequireDefault(__webpack_require__(4420));var _invariant=_interopRequireDefault(__webpack_require__(311));function attachNativeEvent(viewRef,eventName,argMapping,platformConfig){var eventMappings=[];var _traverse=function traverse(value,path){if(value instanceof _AnimatedValue.default){value.__makeNative(platformConfig);eventMappings.push({nativeEventPath:path,animatedValueTag:value.__getNativeTag()});}else if(value instanceof _AnimatedValueXY.default){_traverse(value.x,path.concat('x'));_traverse(value.y,path.concat('y'));}else if(typeof value==='object'){for(var _key in value){_traverse(value[_key],path.concat(_key));}}};(0,_invariant.default)(argMapping[0]&&argMapping[0].nativeEvent,'Native driven events only support animated values contained inside `nativeEvent`.');_traverse(argMapping[0].nativeEvent,[]);var viewTag=(0,_RendererProxy.findNodeHandle)(viewRef);if(viewTag!=null){eventMappings.forEach(function(mapping){_NativeAnimatedHelper.default.API.addAnimatedEventToView(viewTag,eventName,mapping);});}return{detach:function detach(){if(viewTag!=null){eventMappings.forEach(function(mapping){_NativeAnimatedHelper.default.API.removeAnimatedEventFromView(viewTag,eventName,mapping.animatedValueTag);});}}};}function validateMapping(argMapping,args){var _validate=function validate(recMapping,recEvt,key){if(recMapping instanceof _AnimatedValue.default){(0,_invariant.default)(typeof recEvt==='number','Bad mapping of event key '+key+', should be number but got '+typeof recEvt);return;}if(recMapping instanceof _AnimatedValueXY.default){(0,_invariant.default)(typeof recEvt.x==='number'&&typeof recEvt.y==='number','Bad mapping of event key '+key+', should be XY but got '+recEvt);return;}if(typeof recEvt==='number'){(0,_invariant.default)(recMapping instanceof _AnimatedValue.default,'Bad mapping of type '+typeof recMapping+' for key '+key+', event value must map to AnimatedValue');return;}(0,_invariant.default)(typeof recMapping==='object','Bad mapping of type '+typeof recMapping+' for key '+key);(0,_invariant.default)(typeof recEvt==='object','Bad event of type '+typeof recEvt+' for key '+key);for(var mappingKey in recMapping){_validate(recMapping[mappingKey],recEvt[mappingKey],mappingKey);}};(0,_invariant.default)(args.length>=argMapping.length,'Event has less arguments than mapping');argMapping.forEach(function(mapping,idx){_validate(mapping,args[idx],'arg'+idx);});}var AnimatedEvent=exports.AnimatedEvent=function(){function AnimatedEvent(argMapping,config){var _this=this;(0,_classCallCheck2.default)(this,AnimatedEvent);this._listeners=[];this._callListeners=function(){for(var _len=arguments.length,args=new Array(_len),_key2=0;_key2<_len;_key2++){args[_key2]=arguments[_key2];}_this._listeners.forEach(function(listener){return listener.apply(void 0,args);});};this._argMapping=argMapping;if(config==null){console.warn('Animated.event now requires a second argument for options');config={useNativeDriver:false};}if(config.listener){this.__addListener(config.listener);}this._attachedEvent=null;this.__isNative=_NativeAnimatedHelper.default.shouldUseNativeDriver(config);this.__platformConfig=config.platformConfig;}return(0,_createClass2.default)(AnimatedEvent,[{key:"__addListener",value:function __addListener(callback){this._listeners.push(callback);}},{key:"__removeListener",value:function __removeListener(callback){this._listeners=this._listeners.filter(function(listener){return listener!==callback;});}},{key:"__attach",value:function __attach(viewRef,eventName){(0,_invariant.default)(this.__isNative,'Only native driven events need to be attached.');this._attachedEvent=attachNativeEvent(viewRef,eventName,this._argMapping,this.__platformConfig);}},{key:"__detach",value:function __detach(viewTag,eventName){(0,_invariant.default)(this.__isNative,'Only native driven events need to be detached.');this._attachedEvent&&this._attachedEvent.detach();}},{key:"__getHandler",value:function __getHandler(){var _this2=this;if(this.__isNative){if(false){ var _validatedMapping; }else{return this._callListeners;}}var validatedMapping=false;return function(){for(var _len3=arguments.length,args=new Array(_len3),_key4=0;_key4<_len3;_key4++){args[_key4]=arguments[_key4];}if(false){}var _traverse2=function traverse(recMapping,recEvt){if(recMapping instanceof _AnimatedValue.default){if(typeof recEvt==='number'){recMapping.setValue(recEvt);}}else if(recMapping instanceof _AnimatedValueXY.default){if(typeof recEvt==='object'){_traverse2(recMapping.x,recEvt.x);_traverse2(recMapping.y,recEvt.y);}}else if(typeof recMapping==='object'){for(var mappingKey in recMapping){_traverse2(recMapping[mappingKey],recEvt[mappingKey]);}}};_this2._argMapping.forEach(function(mapping,idx){_traverse2(mapping,args[idx]);});_this2._callListeners.apply(_this2,args);};}}]);}();
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 9860:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _AnimatedEvent=__webpack_require__(8844);var _DecayAnimation=_interopRequireDefault(__webpack_require__(5383));var _SpringAnimation=_interopRequireDefault(__webpack_require__(4242));var _TimingAnimation=_interopRequireDefault(__webpack_require__(6931));var _createAnimatedComponent=_interopRequireDefault(__webpack_require__(3315));var _AnimatedAddition=_interopRequireDefault(__webpack_require__(4536));var _AnimatedColor=_interopRequireDefault(__webpack_require__(1265));var _AnimatedDiffClamp=_interopRequireDefault(__webpack_require__(3272));var _AnimatedDivision=_interopRequireDefault(__webpack_require__(8247));var _AnimatedInterpolation=_interopRequireDefault(__webpack_require__(3636));var _AnimatedModulo=_interopRequireDefault(__webpack_require__(3866));var _AnimatedMultiplication=_interopRequireDefault(__webpack_require__(1938));var _AnimatedNode=_interopRequireDefault(__webpack_require__(244));var _AnimatedSubtraction=_interopRequireDefault(__webpack_require__(8116));var _AnimatedTracking=_interopRequireDefault(__webpack_require__(1397));var _AnimatedValue=_interopRequireDefault(__webpack_require__(9579));var _AnimatedValueXY=_interopRequireDefault(__webpack_require__(4420));var add=function add(a,b){return new _AnimatedAddition.default(a,b);};var subtract=function subtract(a,b){return new _AnimatedSubtraction.default(a,b);};var divide=function divide(a,b){return new _AnimatedDivision.default(a,b);};var multiply=function multiply(a,b){return new _AnimatedMultiplication.default(a,b);};var modulo=function modulo(a,modulus){return new _AnimatedModulo.default(a,modulus);};var diffClamp=function diffClamp(a,min,max){return new _AnimatedDiffClamp.default(a,min,max);};var _combineCallbacks=function _combineCallbacks(callback,config){if(callback&&config.onComplete){return function(){config.onComplete&&config.onComplete.apply(config,arguments);callback&&callback.apply(void 0,arguments);};}else{return callback||config.onComplete;}};var maybeVectorAnim=function maybeVectorAnim(value,config,anim){if(value instanceof _AnimatedValueXY.default){var configX=Object.assign({},config);var configY=Object.assign({},config);for(var key in config){var _config$key=config[key],x=_config$key.x,y=_config$key.y;if(x!==undefined&&y!==undefined){configX[key]=x;configY[key]=y;}}var aX=anim(value.x,configX);var aY=anim(value.y,configY);return parallel([aX,aY],{stopTogether:false});}else if(value instanceof _AnimatedColor.default){var configR=Object.assign({},config);var configG=Object.assign({},config);var configB=Object.assign({},config);var configA=Object.assign({},config);for(var _key in config){var _config$_key=config[_key],r=_config$_key.r,g=_config$_key.g,b=_config$_key.b,a=_config$_key.a;if(r!==undefined&&g!==undefined&&b!==undefined&&a!==undefined){configR[_key]=r;configG[_key]=g;configB[_key]=b;configA[_key]=a;}}var aR=anim(value.r,configR);var aG=anim(value.g,configG);var aB=anim(value.b,configB);var aA=anim(value.a,configA);return parallel([aR,aG,aB,aA],{stopTogether:false});}return null;};var _spring=function spring(value,config){var _start=function start(animatedValue,configuration,callback){callback=_combineCallbacks(callback,configuration);var singleValue=animatedValue;var singleConfig=configuration;singleValue.stopTracking();if(configuration.toValue instanceof _AnimatedNode.default){singleValue.track(new _AnimatedTracking.default(singleValue,configuration.toValue,_SpringAnimation.default,singleConfig,callback));}else{singleValue.animate(new _SpringAnimation.default(singleConfig),callback);}};return maybeVectorAnim(value,config,_spring)||{start:function start(callback){_start(value,config,callback);},stop:function stop(){value.stopAnimation();},reset:function reset(){value.resetAnimation();},_startNativeLoop:function _startNativeLoop(iterations){var singleConfig=Object.assign({},config,{iterations:iterations});_start(value,singleConfig);},_isUsingNativeDriver:function _isUsingNativeDriver(){return config.useNativeDriver||false;}};};var _timing=function timing(value,config){var _start2=function start(animatedValue,configuration,callback){callback=_combineCallbacks(callback,configuration);var singleValue=animatedValue;var singleConfig=configuration;singleValue.stopTracking();if(configuration.toValue instanceof _AnimatedNode.default){singleValue.track(new _AnimatedTracking.default(singleValue,configuration.toValue,_TimingAnimation.default,singleConfig,callback));}else{singleValue.animate(new _TimingAnimation.default(singleConfig),callback);}};return maybeVectorAnim(value,config,_timing)||{start:function start(callback){_start2(value,config,callback);},stop:function stop(){value.stopAnimation();},reset:function reset(){value.resetAnimation();},_startNativeLoop:function _startNativeLoop(iterations){var singleConfig=Object.assign({},config,{iterations:iterations});_start2(value,singleConfig);},_isUsingNativeDriver:function _isUsingNativeDriver(){return config.useNativeDriver||false;}};};var _decay=function decay(value,config){var _start3=function start(animatedValue,configuration,callback){callback=_combineCallbacks(callback,configuration);var singleValue=animatedValue;var singleConfig=configuration;singleValue.stopTracking();singleValue.animate(new _DecayAnimation.default(singleConfig),callback);};return maybeVectorAnim(value,config,_decay)||{start:function start(callback){_start3(value,config,callback);},stop:function stop(){value.stopAnimation();},reset:function reset(){value.resetAnimation();},_startNativeLoop:function _startNativeLoop(iterations){var singleConfig=Object.assign({},config,{iterations:iterations});_start3(value,singleConfig);},_isUsingNativeDriver:function _isUsingNativeDriver(){return config.useNativeDriver||false;}};};var sequence=function sequence(animations){var current=0;return{start:function start(callback){var _onComplete=function onComplete(result){if(!result.finished){callback&&callback(result);return;}current++;if(current===animations.length){callback&&callback(result);return;}animations[current].start(_onComplete);};if(animations.length===0){callback&&callback({finished:true});}else{animations[current].start(_onComplete);}},stop:function stop(){if(current<animations.length){animations[current].stop();}},reset:function reset(){animations.forEach(function(animation,idx){if(idx<=current){animation.reset();}});current=0;},_startNativeLoop:function _startNativeLoop(){throw new Error('Loops run using the native driver cannot contain Animated.sequence animations');},_isUsingNativeDriver:function _isUsingNativeDriver(){return false;}};};var parallel=function parallel(animations,config){var doneCount=0;var hasEnded={};var stopTogether=!(config&&config.stopTogether===false);var result={start:function start(callback){if(doneCount===animations.length){callback&&callback({finished:true});return;}animations.forEach(function(animation,idx){var cb=function cb(endResult){hasEnded[idx]=true;doneCount++;if(doneCount===animations.length){doneCount=0;callback&&callback(endResult);return;}if(!endResult.finished&&stopTogether){result.stop();}};if(!animation){cb({finished:true});}else{animation.start(cb);}});},stop:function stop(){animations.forEach(function(animation,idx){!hasEnded[idx]&&animation.stop();hasEnded[idx]=true;});},reset:function reset(){animations.forEach(function(animation,idx){animation.reset();hasEnded[idx]=false;doneCount=0;});},_startNativeLoop:function _startNativeLoop(){throw new Error('Loops run using the native driver cannot contain Animated.parallel animations');},_isUsingNativeDriver:function _isUsingNativeDriver(){return false;}};return result;};var delay=function delay(time){return _timing(new _AnimatedValue.default(0),{toValue:0,delay:time,duration:0,useNativeDriver:false});};var stagger=function stagger(time,animations){return parallel(animations.map(function(animation,i){return sequence([delay(time*i),animation]);}));};var loop=function loop(animation){var _ref=arguments.length>1&&arguments[1]!==undefined?arguments[1]:{},_ref$iterations=_ref.iterations,iterations=_ref$iterations===void 0?-1:_ref$iterations,_ref$resetBeforeItera=_ref.resetBeforeIteration,resetBeforeIteration=_ref$resetBeforeItera===void 0?true:_ref$resetBeforeItera;var isFinished=false;var iterationsSoFar=0;return{start:function start(callback){var _restart=function restart(){var result=arguments.length>0&&arguments[0]!==undefined?arguments[0]:{finished:true};if(isFinished||iterationsSoFar===iterations||result.finished===false){callback&&callback(result);}else{iterationsSoFar++;resetBeforeIteration&&animation.reset();animation.start(_restart);}};if(!animation||iterations===0){callback&&callback({finished:true});}else{if(animation._isUsingNativeDriver()){animation._startNativeLoop(iterations);}else{_restart();}}},stop:function stop(){isFinished=true;animation.stop();},reset:function reset(){iterationsSoFar=0;isFinished=false;animation.reset();},_startNativeLoop:function _startNativeLoop(){throw new Error('Loops run using the native driver cannot contain Animated.loop animations');},_isUsingNativeDriver:function _isUsingNativeDriver(){return animation._isUsingNativeDriver();}};};function forkEvent(event,listener){if(!event){return listener;}else if(event instanceof _AnimatedEvent.AnimatedEvent){event.__addListener(listener);return event;}else{return function(){typeof event==='function'&&event.apply(void 0,arguments);listener.apply(void 0,arguments);};}}function unforkEvent(event,listener){if(event&&event instanceof _AnimatedEvent.AnimatedEvent){event.__removeListener(listener);}}var event=function event(argMapping,config){var animatedEvent=new _AnimatedEvent.AnimatedEvent(argMapping,config);if(animatedEvent.__isNative){return animatedEvent;}else{return animatedEvent.__getHandler();}};var _default=exports["default"]={Value:_AnimatedValue.default,ValueXY:_AnimatedValueXY.default,Color:_AnimatedColor.default,Interpolation:_AnimatedInterpolation.default,Node:_AnimatedNode.default,decay:_decay,timing:_timing,spring:_spring,add:add,subtract:subtract,divide:divide,multiply:multiply,modulo:modulo,diffClamp:diffClamp,delay:delay,sequence:sequence,parallel:parallel,stagger:stagger,loop:loop,event:event,createAnimatedComponent:_createAnimatedComponent.default,attachNativeEvent:_AnimatedEvent.attachNativeEvent,forkEvent:forkEvent,unforkEvent:unforkEvent,Event:_AnimatedEvent.AnimatedEvent};
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 6128:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _AnimatedEvent=__webpack_require__(8844);var _AnimatedImplementation=_interopRequireDefault(__webpack_require__(9860));var _createAnimatedComponent=_interopRequireDefault(__webpack_require__(3315));var _AnimatedColor=_interopRequireDefault(__webpack_require__(1265));var _AnimatedInterpolation=_interopRequireDefault(__webpack_require__(3636));var _AnimatedNode=_interopRequireDefault(__webpack_require__(244));var _AnimatedValue=_interopRequireDefault(__webpack_require__(9579));var _AnimatedValueXY=_interopRequireDefault(__webpack_require__(4420));var inAnimationCallback=false;function mockAnimationStart(start){return function(callback){var guardedCallback=callback==null?callback:function(){if(inAnimationCallback){console.warn('Ignoring recursive animation callback when running mock animations');return;}inAnimationCallback=true;try{callback.apply(void 0,arguments);}finally{inAnimationCallback=false;}};start(guardedCallback);};}var emptyAnimation={start:function start(){},stop:function stop(){},reset:function reset(){},_startNativeLoop:function _startNativeLoop(){},_isUsingNativeDriver:function _isUsingNativeDriver(){return false;}};var mockCompositeAnimation=function mockCompositeAnimation(animations){return Object.assign({},emptyAnimation,{start:mockAnimationStart(function(callback){animations.forEach(function(animation){return animation.start();});callback==null?void 0:callback({finished:true});})});};var spring=function spring(value,config){var anyValue=value;return Object.assign({},emptyAnimation,{start:mockAnimationStart(function(callback){anyValue.setValue(config.toValue);callback==null?void 0:callback({finished:true});})});};var timing=function timing(value,config){var anyValue=value;return Object.assign({},emptyAnimation,{start:mockAnimationStart(function(callback){anyValue.setValue(config.toValue);callback==null?void 0:callback({finished:true});})});};var decay=function decay(value,config){return emptyAnimation;};var sequence=function sequence(animations){return mockCompositeAnimation(animations);};var parallel=function parallel(animations,config){return mockCompositeAnimation(animations);};var delay=function delay(time){return emptyAnimation;};var stagger=function stagger(time,animations){return mockCompositeAnimation(animations);};var loop=function loop(animation){var _ref=arguments.length>1&&arguments[1]!==undefined?arguments[1]:{},_ref$iterations=_ref.iterations,iterations=_ref$iterations===void 0?-1:_ref$iterations;return emptyAnimation;};var _default=exports["default"]={Value:_AnimatedValue.default,ValueXY:_AnimatedValueXY.default,Color:_AnimatedColor.default,Interpolation:_AnimatedInterpolation.default,Node:_AnimatedNode.default,decay:decay,timing:timing,spring:spring,add:_AnimatedImplementation.default.add,subtract:_AnimatedImplementation.default.subtract,divide:_AnimatedImplementation.default.divide,multiply:_AnimatedImplementation.default.multiply,modulo:_AnimatedImplementation.default.modulo,diffClamp:_AnimatedImplementation.default.diffClamp,delay:delay,sequence:sequence,parallel:parallel,stagger:stagger,loop:loop,event:_AnimatedImplementation.default.event,createAnimatedComponent:_createAnimatedComponent.default,attachNativeEvent:_AnimatedEvent.attachNativeEvent,forkEvent:_AnimatedImplementation.default.forkEvent,unforkEvent:_AnimatedImplementation.default.unforkEvent,Event:_AnimatedEvent.AnimatedEvent};
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 5250:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _ease;var Easing={step0:function step0(n){return n>0?1:0;},step1:function step1(n){return n>=1?1:0;},linear:function linear(t){return t;},ease:function ease(t){if(!_ease){_ease=Easing.bezier(0.42,0,1,1);}return _ease(t);},quad:function quad(t){return t*t;},cubic:function cubic(t){return t*t*t;},poly:function poly(n){return function(t){return Math.pow(t,n);};},sin:function sin(t){return 1-Math.cos(t*Math.PI/2);},circle:function circle(t){return 1-Math.sqrt(1-t*t);},exp:function exp(t){return Math.pow(2,10*(t-1));},elastic:function elastic(){var bounciness=arguments.length>0&&arguments[0]!==undefined?arguments[0]:1;var p=bounciness*Math.PI;return function(t){return 1-Math.pow(Math.cos(t*Math.PI/2),3)*Math.cos(t*p);};},back:function back(){var s=arguments.length>0&&arguments[0]!==undefined?arguments[0]:1.70158;return function(t){return t*t*((s+1)*t-s);};},bounce:function bounce(t){if(t<1/2.75){return 7.5625*t*t;}if(t<2/2.75){var _t=t-1.5/2.75;return 7.5625*_t*_t+0.75;}if(t<2.5/2.75){var _t2=t-2.25/2.75;return 7.5625*_t2*_t2+0.9375;}var t2=t-2.625/2.75;return 7.5625*t2*t2+0.984375;},bezier:function bezier(x1,y1,x2,y2){var _bezier=(__webpack_require__(6824)/* ["default"] */ .A);return _bezier(x1,y1,x2,y2);},in:function _in(easing){return easing;},out:function out(easing){return function(t){return 1-easing(1-t);};},inOut:function inOut(easing){return function(t){if(t<0.5){return easing(t*2)/2;}return 1-easing((1-t)*2)/2;};}};var _default=exports["default"]=Easing;
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 6681:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _NativeEventEmitter=_interopRequireDefault(__webpack_require__(6107));var _RCTDeviceEventEmitter=_interopRequireDefault(__webpack_require__(7181));var _ReactNativeFeatureFlags=_interopRequireDefault(__webpack_require__(3535));var _Platform=_interopRequireDefault(__webpack_require__(8192));var _NativeAnimatedModule=_interopRequireDefault(__webpack_require__(649));var _NativeAnimatedTurboModule=_interopRequireDefault(__webpack_require__(1757));var _invariant=_interopRequireDefault(__webpack_require__(311));var NativeAnimatedModule=_Platform.default.OS==='ios'&&__webpack_require__.g.RN$Bridgeless===true?_NativeAnimatedTurboModule.default:_NativeAnimatedModule.default;var __nativeAnimatedNodeTagCount=1;var __nativeAnimationIdCount=1;var nativeEventEmitter;var waitingForQueuedOperations=new Set();var queueOperations=false;var queue=[];var singleOpQueue=[];var useSingleOpBatching=_Platform.default.OS==='android'&&!!(NativeAnimatedModule!=null&&NativeAnimatedModule.queueAndExecuteBatchedOperations)&&_ReactNativeFeatureFlags.default.animatedShouldUseSingleOp();var flushQueueTimeout=null;var eventListenerGetValueCallbacks={};var eventListenerAnimationFinishedCallbacks={};var globalEventEmitterGetValueListener=null;var globalEventEmitterAnimationFinishedListener=null;var nativeOps=useSingleOpBatching?function(){var apis=['createAnimatedNode','updateAnimatedNodeConfig','getValue','startListeningToAnimatedNodeValue','stopListeningToAnimatedNodeValue','connectAnimatedNodes','disconnectAnimatedNodes','startAnimatingNode','stopAnimation','setAnimatedNodeValue','setAnimatedNodeOffset','flattenAnimatedNodeOffset','extractAnimatedNodeOffset','connectAnimatedNodeToView','disconnectAnimatedNodeFromView','restoreDefaultValues','dropAnimatedNode','addAnimatedEventToView','removeAnimatedEventFromView','addListener','removeListener'];return apis.reduce(function(acc,functionName,i){acc[functionName]=i+1;return acc;},{});}():NativeAnimatedModule;var API={getValue:function getValue(tag,saveValueCallback){(0,_invariant.default)(nativeOps,'Native animated module is not available');if(useSingleOpBatching){if(saveValueCallback){eventListenerGetValueCallbacks[tag]=saveValueCallback;}API.queueOperation(nativeOps.getValue,tag);}else{API.queueOperation(nativeOps.getValue,tag,saveValueCallback);}},setWaitingForIdentifier:function setWaitingForIdentifier(id){waitingForQueuedOperations.add(id);queueOperations=true;if(_ReactNativeFeatureFlags.default.animatedShouldDebounceQueueFlush()&&flushQueueTimeout){clearTimeout(flushQueueTimeout);}},unsetWaitingForIdentifier:function unsetWaitingForIdentifier(id){waitingForQueuedOperations.delete(id);if(waitingForQueuedOperations.size===0){queueOperations=false;API.disableQueue();}},disableQueue:function disableQueue(){(0,_invariant.default)(nativeOps,'Native animated module is not available');if(_ReactNativeFeatureFlags.default.animatedShouldDebounceQueueFlush()){var prevTimeout=flushQueueTimeout;clearImmediate(prevTimeout);flushQueueTimeout=setImmediate(API.flushQueue);}else{API.flushQueue();}},flushQueue:function flushQueue(){(0,_invariant.default)(NativeAnimatedModule||"production"==='test','Native animated module is not available');flushQueueTimeout=null;if(useSingleOpBatching&&singleOpQueue.length===0){return;}if(!useSingleOpBatching&&queue.length===0){return;}if(useSingleOpBatching){if(!globalEventEmitterGetValueListener||!globalEventEmitterAnimationFinishedListener){setupGlobalEventEmitterListeners();}NativeAnimatedModule==null?void 0:NativeAnimatedModule.queueAndExecuteBatchedOperations==null?void 0:NativeAnimatedModule.queueAndExecuteBatchedOperations(singleOpQueue);singleOpQueue.length=0;}else{_Platform.default.OS==='android'&&(NativeAnimatedModule==null?void 0:NativeAnimatedModule.startOperationBatch==null?void 0:NativeAnimatedModule.startOperationBatch());for(var q=0,l=queue.length;q<l;q++){queue[q]();}queue.length=0;_Platform.default.OS==='android'&&(NativeAnimatedModule==null?void 0:NativeAnimatedModule.finishOperationBatch==null?void 0:NativeAnimatedModule.finishOperationBatch());}},queueOperation:function queueOperation(fn){for(var _len=arguments.length,args=new Array(_len>1?_len-1:0),_key=1;_key<_len;_key++){args[_key-1]=arguments[_key];}if(useSingleOpBatching){singleOpQueue.push.apply(singleOpQueue,[fn].concat(args));return;}if(queueOperations||queue.length!==0){queue.push(function(){return fn.apply(void 0,args);});}else{fn.apply(void 0,args);}},createAnimatedNode:function createAnimatedNode(tag,config){(0,_invariant.default)(nativeOps,'Native animated module is not available');API.queueOperation(nativeOps.createAnimatedNode,tag,config);},updateAnimatedNodeConfig:function updateAnimatedNodeConfig(tag,config){(0,_invariant.default)(nativeOps,'Native animated module is not available');if(nativeOps.updateAnimatedNodeConfig){API.queueOperation(nativeOps.updateAnimatedNodeConfig,tag,config);}},startListeningToAnimatedNodeValue:function startListeningToAnimatedNodeValue(tag){(0,_invariant.default)(nativeOps,'Native animated module is not available');API.queueOperation(nativeOps.startListeningToAnimatedNodeValue,tag);},stopListeningToAnimatedNodeValue:function stopListeningToAnimatedNodeValue(tag){(0,_invariant.default)(nativeOps,'Native animated module is not available');API.queueOperation(nativeOps.stopListeningToAnimatedNodeValue,tag);},connectAnimatedNodes:function connectAnimatedNodes(parentTag,childTag){(0,_invariant.default)(nativeOps,'Native animated module is not available');API.queueOperation(nativeOps.connectAnimatedNodes,parentTag,childTag);},disconnectAnimatedNodes:function disconnectAnimatedNodes(parentTag,childTag){(0,_invariant.default)(nativeOps,'Native animated module is not available');API.queueOperation(nativeOps.disconnectAnimatedNodes,parentTag,childTag);},startAnimatingNode:function startAnimatingNode(animationId,nodeTag,config,endCallback){(0,_invariant.default)(nativeOps,'Native animated module is not available');if(useSingleOpBatching){if(endCallback){eventListenerAnimationFinishedCallbacks[animationId]=endCallback;}API.queueOperation(nativeOps.startAnimatingNode,animationId,nodeTag,config);}else{API.queueOperation(nativeOps.startAnimatingNode,animationId,nodeTag,config,endCallback);}},stopAnimation:function stopAnimation(animationId){(0,_invariant.default)(nativeOps,'Native animated module is not available');API.queueOperation(nativeOps.stopAnimation,animationId);},setAnimatedNodeValue:function setAnimatedNodeValue(nodeTag,value){(0,_invariant.default)(nativeOps,'Native animated module is not available');API.queueOperation(nativeOps.setAnimatedNodeValue,nodeTag,value);},setAnimatedNodeOffset:function setAnimatedNodeOffset(nodeTag,offset){(0,_invariant.default)(nativeOps,'Native animated module is not available');API.queueOperation(nativeOps.setAnimatedNodeOffset,nodeTag,offset);},flattenAnimatedNodeOffset:function flattenAnimatedNodeOffset(nodeTag){(0,_invariant.default)(nativeOps,'Native animated module is not available');API.queueOperation(nativeOps.flattenAnimatedNodeOffset,nodeTag);},extractAnimatedNodeOffset:function extractAnimatedNodeOffset(nodeTag){(0,_invariant.default)(nativeOps,'Native animated module is not available');API.queueOperation(nativeOps.extractAnimatedNodeOffset,nodeTag);},connectAnimatedNodeToView:function connectAnimatedNodeToView(nodeTag,viewTag){(0,_invariant.default)(nativeOps,'Native animated module is not available');API.queueOperation(nativeOps.connectAnimatedNodeToView,nodeTag,viewTag);},disconnectAnimatedNodeFromView:function disconnectAnimatedNodeFromView(nodeTag,viewTag){(0,_invariant.default)(nativeOps,'Native animated module is not available');API.queueOperation(nativeOps.disconnectAnimatedNodeFromView,nodeTag,viewTag);},restoreDefaultValues:function restoreDefaultValues(nodeTag){(0,_invariant.default)(nativeOps,'Native animated module is not available');if(nativeOps.restoreDefaultValues!=null){API.queueOperation(nativeOps.restoreDefaultValues,nodeTag);}},dropAnimatedNode:function dropAnimatedNode(tag){(0,_invariant.default)(nativeOps,'Native animated module is not available');API.queueOperation(nativeOps.dropAnimatedNode,tag);},addAnimatedEventToView:function addAnimatedEventToView(viewTag,eventName,eventMapping){(0,_invariant.default)(nativeOps,'Native animated module is not available');API.queueOperation(nativeOps.addAnimatedEventToView,viewTag,eventName,eventMapping);},removeAnimatedEventFromView:function removeAnimatedEventFromView(viewTag,eventName,animatedNodeTag){(0,_invariant.default)(nativeOps,'Native animated module is not available');API.queueOperation(nativeOps.removeAnimatedEventFromView,viewTag,eventName,animatedNodeTag);}};function setupGlobalEventEmitterListeners(){globalEventEmitterGetValueListener=_RCTDeviceEventEmitter.default.addListener('onNativeAnimatedModuleGetValue',function(params){var tag=params.tag;var callback=eventListenerGetValueCallbacks[tag];if(!callback){return;}callback(params.value);delete eventListenerGetValueCallbacks[tag];});globalEventEmitterAnimationFinishedListener=_RCTDeviceEventEmitter.default.addListener('onNativeAnimatedModuleAnimationFinished',function(params){var animationId=params.animationId;var callback=eventListenerAnimationFinishedCallbacks[animationId];if(!callback){return;}callback(params);delete eventListenerAnimationFinishedCallbacks[animationId];});}var SUPPORTED_COLOR_STYLES={backgroundColor:true,borderBottomColor:true,borderColor:true,borderEndColor:true,borderLeftColor:true,borderRightColor:true,borderStartColor:true,borderTopColor:true,color:true,tintColor:true};var SUPPORTED_STYLES=Object.assign({},SUPPORTED_COLOR_STYLES,{borderBottomEndRadius:true,borderBottomLeftRadius:true,borderBottomRightRadius:true,borderBottomStartRadius:true,borderEndEndRadius:true,borderEndStartRadius:true,borderRadius:true,borderTopEndRadius:true,borderTopLeftRadius:true,borderTopRightRadius:true,borderTopStartRadius:true,borderStartEndRadius:true,borderStartStartRadius:true,elevation:true,opacity:true,transform:true,zIndex:true,shadowOpacity:true,shadowRadius:true,scaleX:true,scaleY:true,translateX:true,translateY:true});var SUPPORTED_TRANSFORMS={translateX:true,translateY:true,scale:true,scaleX:true,scaleY:true,rotate:true,rotateX:true,rotateY:true,rotateZ:true,perspective:true};var SUPPORTED_INTERPOLATION_PARAMS={inputRange:true,outputRange:true,extrapolate:true,extrapolateRight:true,extrapolateLeft:true};function addWhitelistedStyleProp(prop){SUPPORTED_STYLES[prop]=true;}function addWhitelistedTransformProp(prop){SUPPORTED_TRANSFORMS[prop]=true;}function addWhitelistedInterpolationParam(param){SUPPORTED_INTERPOLATION_PARAMS[param]=true;}function isSupportedColorStyleProp(prop){return SUPPORTED_COLOR_STYLES.hasOwnProperty(prop);}function isSupportedStyleProp(prop){return SUPPORTED_STYLES.hasOwnProperty(prop);}function isSupportedTransformProp(prop){return SUPPORTED_TRANSFORMS.hasOwnProperty(prop);}function isSupportedInterpolationParam(param){return SUPPORTED_INTERPOLATION_PARAMS.hasOwnProperty(param);}function validateTransform(configs){configs.forEach(function(config){if(!isSupportedTransformProp(config.property)){throw new Error(`Property '${config.property}' is not supported by native animated module`);}});}function validateStyles(styles){for(var _key2 in styles){if(!isSupportedStyleProp(_key2)){throw new Error(`Style property '${_key2}' is not supported by native animated module`);}}}function validateInterpolation(config){for(var _key3 in config){if(!isSupportedInterpolationParam(_key3)){throw new Error(`Interpolation property '${_key3}' is not supported by native animated module`);}}}function generateNewNodeTag(){return __nativeAnimatedNodeTagCount++;}function generateNewAnimationId(){return __nativeAnimationIdCount++;}function assertNativeAnimatedModule(){(0,_invariant.default)(NativeAnimatedModule,'Native animated module is not available');}var _warnedMissingNativeAnimated=false;function shouldUseNativeDriver(config){if(config.useNativeDriver==null){console.warn('Animated: `useNativeDriver` was not specified. This is a required '+'option and must be explicitly set to `true` or `false`');}if(config.useNativeDriver===true&&!NativeAnimatedModule){if(true){if(!_warnedMissingNativeAnimated){console.warn('Animated: `useNativeDriver` is not supported because the native '+'animated module is missing. Falling back to JS-based animation. To '+'resolve this, add `RCTAnimation` module to this app, or remove '+'`useNativeDriver`. '+'Make sure to run `bundle exec pod install` first. Read more about autolinking: https://github.com/react-native-community/cli/blob/master/docs/autolinking.md');_warnedMissingNativeAnimated=true;}}return false;}return config.useNativeDriver||false;}function transformDataType(value){if(typeof value!=='string'){return value;}if(/deg$/.test(value)){var degrees=parseFloat(value)||0;var radians=degrees*Math.PI/180.0;return radians;}else{return value;}}var _default=exports["default"]={API:API,isSupportedColorStyleProp:isSupportedColorStyleProp,isSupportedStyleProp:isSupportedStyleProp,isSupportedTransformProp:isSupportedTransformProp,isSupportedInterpolationParam:isSupportedInterpolationParam,addWhitelistedStyleProp:addWhitelistedStyleProp,addWhitelistedTransformProp:addWhitelistedTransformProp,addWhitelistedInterpolationParam:addWhitelistedInterpolationParam,validateStyles:validateStyles,validateTransform:validateTransform,validateInterpolation:validateInterpolation,generateNewNodeTag:generateNewNodeTag,generateNewAnimationId:generateNewAnimationId,assertNativeAnimatedModule:assertNativeAnimatedModule,shouldUseNativeDriver:shouldUseNativeDriver,transformDataType:transformDataType,get nativeEventEmitter(){if(!nativeEventEmitter){nativeEventEmitter=new _NativeEventEmitter.default(_Platform.default.OS!=='ios'?null:NativeAnimatedModule);}return nativeEventEmitter;}};
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 649:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var TurboModuleRegistry=_interopRequireWildcard(__webpack_require__(5333));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var _default=exports["default"]=TurboModuleRegistry.get('NativeAnimatedModule');
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 1757:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var TurboModuleRegistry=_interopRequireWildcard(__webpack_require__(5333));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var _default=exports["default"]=TurboModuleRegistry.get('NativeAnimatedTurboModule');
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 2496:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports.fromBouncinessAndSpeed=fromBouncinessAndSpeed;exports.fromOrigamiTensionAndFriction=fromOrigamiTensionAndFriction;function stiffnessFromOrigamiValue(oValue){return(oValue-30)*3.62+194;}function dampingFromOrigamiValue(oValue){return(oValue-8)*3+25;}function fromOrigamiTensionAndFriction(tension,friction){return{stiffness:stiffnessFromOrigamiValue(tension),damping:dampingFromOrigamiValue(friction)};}function fromBouncinessAndSpeed(bounciness,speed){function normalize(value,startValue,endValue){return(value-startValue)/(endValue-startValue);}function projectNormal(n,start,end){return start+n*(end-start);}function linearInterpolation(t,start,end){return t*end+(1-t)*start;}function quadraticOutInterpolation(t,start,end){return linearInterpolation(2*t-t*t,start,end);}function b3Friction1(x){return 0.0007*Math.pow(x,3)-0.031*Math.pow(x,2)+0.64*x+1.28;}function b3Friction2(x){return 0.000044*Math.pow(x,3)-0.006*Math.pow(x,2)+0.36*x+2;}function b3Friction3(x){return 0.00000045*Math.pow(x,3)-0.000332*Math.pow(x,2)+0.1078*x+5.84;}function b3Nobounce(tension){if(tension<=18){return b3Friction1(tension);}else if(tension>18&&tension<=44){return b3Friction2(tension);}else{return b3Friction3(tension);}}var b=normalize(bounciness/1.7,0,20);b=projectNormal(b,0,0.8);var s=normalize(speed/1.7,0,20);var bouncyTension=projectNormal(s,0.5,200);var bouncyFriction=quadraticOutInterpolation(b,b3Nobounce(bouncyTension),0.01);return{stiffness:stiffnessFromOrigamiValue(bouncyTension),damping:dampingFromOrigamiValue(bouncyFriction)};}
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 7714:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _NativeAnimatedHelper=_interopRequireDefault(__webpack_require__(6681));var startNativeAnimationNextId=1;var Animation=exports["default"]=function(){function Animation(){(0,_classCallCheck2.default)(this,Animation);}return(0,_createClass2.default)(Animation,[{key:"start",value:function start(fromValue,onUpdate,onEnd,previousAnimation,animatedValue){}},{key:"stop",value:function stop(){if(this.__nativeId){_NativeAnimatedHelper.default.API.stopAnimation(this.__nativeId);}}},{key:"__getNativeAnimationConfig",value:function __getNativeAnimationConfig(){throw new Error('This animation type cannot be offloaded to native');}},{key:"__debouncedOnEnd",value:function __debouncedOnEnd(result){var onEnd=this.__onEnd;this.__onEnd=null;onEnd&&onEnd(result);}},{key:"__startNativeAnimation",value:function __startNativeAnimation(animatedValue){var startNativeAnimationWaitId=`${startNativeAnimationNextId}:startAnimation`;startNativeAnimationNextId+=1;_NativeAnimatedHelper.default.API.setWaitingForIdentifier(startNativeAnimationWaitId);try{var config=this.__getNativeAnimationConfig();animatedValue.__makeNative(config.platformConfig);this.__nativeId=_NativeAnimatedHelper.default.generateNewAnimationId();_NativeAnimatedHelper.default.API.startAnimatingNode(this.__nativeId,animatedValue.__getNativeTag(),config,this.__debouncedOnEnd.bind(this));}catch(e){throw e;}finally{_NativeAnimatedHelper.default.API.unsetWaitingForIdentifier(startNativeAnimationWaitId);}}}]);}();
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 5383:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _NativeAnimatedHelper=_interopRequireDefault(__webpack_require__(6681));var _Animation2=_interopRequireDefault(__webpack_require__(7714));function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}var DecayAnimation=exports["default"]=function(_Animation){function DecayAnimation(config){var _config$deceleration,_config$isInteraction,_config$iterations;var _this;(0,_classCallCheck2.default)(this,DecayAnimation);_this=_callSuper(this,DecayAnimation);_this._deceleration=(_config$deceleration=config.deceleration)!=null?_config$deceleration:0.998;_this._velocity=config.velocity;_this._useNativeDriver=_NativeAnimatedHelper.default.shouldUseNativeDriver(config);_this._platformConfig=config.platformConfig;_this.__isInteraction=(_config$isInteraction=config.isInteraction)!=null?_config$isInteraction:!_this._useNativeDriver;_this.__iterations=(_config$iterations=config.iterations)!=null?_config$iterations:1;return _this;}(0,_inherits2.default)(DecayAnimation,_Animation);return(0,_createClass2.default)(DecayAnimation,[{key:"__getNativeAnimationConfig",value:function __getNativeAnimationConfig(){return{type:'decay',deceleration:this._deceleration,velocity:this._velocity,iterations:this.__iterations,platformConfig:this._platformConfig};}},{key:"start",value:function start(fromValue,onUpdate,onEnd,previousAnimation,animatedValue){this.__active=true;this._lastValue=fromValue;this._fromValue=fromValue;this._onUpdate=onUpdate;this.__onEnd=onEnd;this._startTime=Date.now();if(this._useNativeDriver){this.__startNativeAnimation(animatedValue);}else{this._animationFrame=requestAnimationFrame(this.onUpdate.bind(this));}}},{key:"onUpdate",value:function onUpdate(){var now=Date.now();var value=this._fromValue+this._velocity/(1-this._deceleration)*(1-Math.exp(-(1-this._deceleration)*(now-this._startTime)));this._onUpdate(value);if(Math.abs(this._lastValue-value)<0.1){this.__debouncedOnEnd({finished:true});return;}this._lastValue=value;if(this.__active){this._animationFrame=requestAnimationFrame(this.onUpdate.bind(this));}}},{key:"stop",value:function stop(){_superPropGet(DecayAnimation,"stop",this,3)([]);this.__active=false;__webpack_require__.g.cancelAnimationFrame(this._animationFrame);this.__debouncedOnEnd({finished:false});}}]);}(_Animation2.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 4242:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _readOnlyError2=_interopRequireDefault(__webpack_require__(5407));var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _NativeAnimatedHelper=_interopRequireDefault(__webpack_require__(6681));var _AnimatedColor=_interopRequireDefault(__webpack_require__(1265));var SpringConfig=_interopRequireWildcard(__webpack_require__(2496));var _Animation2=_interopRequireDefault(__webpack_require__(7714));var _invariant=_interopRequireDefault(__webpack_require__(311));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}var SpringAnimation=exports["default"]=function(_Animation){function SpringAnimation(config){var _config$overshootClam,_config$restDisplacem,_config$restSpeedThre,_config$velocity,_config$velocity2,_config$delay,_config$isInteraction,_config$iterations;var _this;(0,_classCallCheck2.default)(this,SpringAnimation);_this=_callSuper(this,SpringAnimation);_this._overshootClamping=(_config$overshootClam=config.overshootClamping)!=null?_config$overshootClam:false;_this._restDisplacementThreshold=(_config$restDisplacem=config.restDisplacementThreshold)!=null?_config$restDisplacem:0.001;_this._restSpeedThreshold=(_config$restSpeedThre=config.restSpeedThreshold)!=null?_config$restSpeedThre:0.001;_this._initialVelocity=(_config$velocity=config.velocity)!=null?_config$velocity:0;_this._lastVelocity=(_config$velocity2=config.velocity)!=null?_config$velocity2:0;_this._toValue=config.toValue;_this._delay=(_config$delay=config.delay)!=null?_config$delay:0;_this._useNativeDriver=_NativeAnimatedHelper.default.shouldUseNativeDriver(config);_this._platformConfig=config.platformConfig;_this.__isInteraction=(_config$isInteraction=config.isInteraction)!=null?_config$isInteraction:!_this._useNativeDriver;_this.__iterations=(_config$iterations=config.iterations)!=null?_config$iterations:1;if(config.stiffness!==undefined||config.damping!==undefined||config.mass!==undefined){var _config$stiffness,_config$damping,_config$mass;(0,_invariant.default)(config.bounciness===undefined&&config.speed===undefined&&config.tension===undefined&&config.friction===undefined,'You can define one of bounciness/speed, tension/friction, or stiffness/damping/mass, but not more than one');_this._stiffness=(_config$stiffness=config.stiffness)!=null?_config$stiffness:100;_this._damping=(_config$damping=config.damping)!=null?_config$damping:10;_this._mass=(_config$mass=config.mass)!=null?_config$mass:1;}else if(config.bounciness!==undefined||config.speed!==undefined){var _config$bounciness,_config$speed;(0,_invariant.default)(config.tension===undefined&&config.friction===undefined&&config.stiffness===undefined&&config.damping===undefined&&config.mass===undefined,'You can define one of bounciness/speed, tension/friction, or stiffness/damping/mass, but not more than one');var springConfig=SpringConfig.fromBouncinessAndSpeed((_config$bounciness=config.bounciness)!=null?_config$bounciness:8,(_config$speed=config.speed)!=null?_config$speed:12);_this._stiffness=springConfig.stiffness;_this._damping=springConfig.damping;_this._mass=1;}else{var _config$tension,_config$friction;var _springConfig=SpringConfig.fromOrigamiTensionAndFriction((_config$tension=config.tension)!=null?_config$tension:40,(_config$friction=config.friction)!=null?_config$friction:7);_this._stiffness=_springConfig.stiffness;_this._damping=_springConfig.damping;_this._mass=1;}(0,_invariant.default)(_this._stiffness>0,'Stiffness value must be greater than 0');(0,_invariant.default)(_this._damping>0,'Damping value must be greater than 0');(0,_invariant.default)(_this._mass>0,'Mass value must be greater than 0');return _this;}(0,_inherits2.default)(SpringAnimation,_Animation);return(0,_createClass2.default)(SpringAnimation,[{key:"__getNativeAnimationConfig",value:function __getNativeAnimationConfig(){var _this$_initialVelocit;return{type:'spring',overshootClamping:this._overshootClamping,restDisplacementThreshold:this._restDisplacementThreshold,restSpeedThreshold:this._restSpeedThreshold,stiffness:this._stiffness,damping:this._damping,mass:this._mass,initialVelocity:(_this$_initialVelocit=this._initialVelocity)!=null?_this$_initialVelocit:this._lastVelocity,toValue:this._toValue,iterations:this.__iterations,platformConfig:this._platformConfig};}},{key:"start",value:function start(fromValue,onUpdate,onEnd,previousAnimation,animatedValue){var _this2=this;this.__active=true;this._startPosition=fromValue;this._lastPosition=this._startPosition;this._onUpdate=onUpdate;this.__onEnd=onEnd;this._lastTime=Date.now();this._frameTime=0.0;if(previousAnimation instanceof SpringAnimation){var internalState=previousAnimation.getInternalState();this._lastPosition=internalState.lastPosition;this._lastVelocity=internalState.lastVelocity;this._initialVelocity=this._lastVelocity;this._lastTime=internalState.lastTime;}var start=function start(){if(_this2._useNativeDriver){_this2.__startNativeAnimation(animatedValue);}else{_this2.onUpdate();}};if(this._delay){this._timeout=setTimeout(start,this._delay);}else{start();}}},{key:"getInternalState",value:function getInternalState(){return{lastPosition:this._lastPosition,lastVelocity:this._lastVelocity,lastTime:this._lastTime};}},{key:"onUpdate",value:function onUpdate(){var MAX_STEPS=64;var now=Date.now();if(now>this._lastTime+MAX_STEPS){now=this._lastTime+MAX_STEPS;}var deltaTime=(now-this._lastTime)/1000;this._frameTime+=deltaTime;var c=this._damping;var m=this._mass;var k=this._stiffness;var v0=-this._initialVelocity;var zeta=c/(2*Math.sqrt(k*m));var omega0=Math.sqrt(k/m);var omega1=omega0*Math.sqrt(1.0-zeta*zeta);var x0=this._toValue-this._startPosition;var position=0.0;var velocity=0.0;var t=this._frameTime;if(zeta<1){var envelope=Math.exp(-zeta*omega0*t);position=this._toValue-envelope*((v0+zeta*omega0*x0)/omega1*Math.sin(omega1*t)+x0*Math.cos(omega1*t));velocity=zeta*omega0*envelope*(Math.sin(omega1*t)*(v0+zeta*omega0*x0)/omega1+x0*Math.cos(omega1*t))-envelope*(Math.cos(omega1*t)*(v0+zeta*omega0*x0)-omega1*x0*Math.sin(omega1*t));}else{var _envelope=Math.exp(-omega0*t);position=this._toValue-_envelope*(x0+(v0+omega0*x0)*t);velocity=_envelope*(v0*(t*omega0-1)+t*x0*(omega0*omega0));}this._lastTime=now;this._lastPosition=position;this._lastVelocity=velocity;this._onUpdate(position);if(!this.__active){return;}var isOvershooting=false;if(this._overshootClamping&&this._stiffness!==0){if(this._startPosition<this._toValue){isOvershooting=position>this._toValue;}else{isOvershooting=position<this._toValue;}}var isVelocity=Math.abs(velocity)<=this._restSpeedThreshold;var isDisplacement=true;if(this._stiffness!==0){isDisplacement=Math.abs(this._toValue-position)<=this._restDisplacementThreshold;}if(isOvershooting||isVelocity&&isDisplacement){if(this._stiffness!==0){this._lastPosition=this._toValue;this._lastVelocity=0;this._onUpdate(this._toValue);}this.__debouncedOnEnd({finished:true});return;}this._animationFrame=requestAnimationFrame(this.onUpdate.bind(this));}},{key:"stop",value:function stop(){_superPropGet(SpringAnimation,"stop",this,3)([]);this.__active=false;clearTimeout(this._timeout);__webpack_require__.g.cancelAnimationFrame(this._animationFrame);this.__debouncedOnEnd({finished:false});}}]);}(_Animation2.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 6931:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _readOnlyError2=_interopRequireDefault(__webpack_require__(5407));var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _NativeAnimatedHelper=_interopRequireDefault(__webpack_require__(6681));var _AnimatedColor=_interopRequireDefault(__webpack_require__(1265));var _Animation2=_interopRequireDefault(__webpack_require__(7714));function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}var _easeInOut;function easeInOut(){if(!_easeInOut){var Easing=(__webpack_require__(5250)["default"]);_easeInOut=Easing.inOut(Easing.ease);}return _easeInOut;}var TimingAnimation=exports["default"]=function(_Animation){function TimingAnimation(config){var _config$easing,_config$duration,_config$delay,_config$iterations,_config$isInteraction;var _this;(0,_classCallCheck2.default)(this,TimingAnimation);_this=_callSuper(this,TimingAnimation);_this._toValue=config.toValue;_this._easing=(_config$easing=config.easing)!=null?_config$easing:easeInOut();_this._duration=(_config$duration=config.duration)!=null?_config$duration:500;_this._delay=(_config$delay=config.delay)!=null?_config$delay:0;_this.__iterations=(_config$iterations=config.iterations)!=null?_config$iterations:1;_this._useNativeDriver=_NativeAnimatedHelper.default.shouldUseNativeDriver(config);_this._platformConfig=config.platformConfig;_this.__isInteraction=(_config$isInteraction=config.isInteraction)!=null?_config$isInteraction:!_this._useNativeDriver;return _this;}(0,_inherits2.default)(TimingAnimation,_Animation);return(0,_createClass2.default)(TimingAnimation,[{key:"__getNativeAnimationConfig",value:function __getNativeAnimationConfig(){var frameDuration=1000.0/60.0;var frames=[];var numFrames=Math.round(this._duration/frameDuration);for(var frame=0;frame<numFrames;frame++){frames.push(this._easing(frame/numFrames));}frames.push(this._easing(1));return{type:'frames',frames:frames,toValue:this._toValue,iterations:this.__iterations,platformConfig:this._platformConfig};}},{key:"start",value:function start(fromValue,onUpdate,onEnd,previousAnimation,animatedValue){var _this2=this;this.__active=true;this._fromValue=fromValue;this._onUpdate=onUpdate;this.__onEnd=onEnd;var start=function start(){if(_this2._duration===0&&!_this2._useNativeDriver){_this2._onUpdate(_this2._toValue);_this2.__debouncedOnEnd({finished:true});}else{_this2._startTime=Date.now();if(_this2._useNativeDriver){_this2.__startNativeAnimation(animatedValue);}else{_this2._animationFrame=requestAnimationFrame(_this2.onUpdate.bind(_this2));}}};if(this._delay){this._timeout=setTimeout(start,this._delay);}else{start();}}},{key:"onUpdate",value:function onUpdate(){var now=Date.now();if(now>=this._startTime+this._duration){if(this._duration===0){this._onUpdate(this._toValue);}else{this._onUpdate(this._fromValue+this._easing(1)*(this._toValue-this._fromValue));}this.__debouncedOnEnd({finished:true});return;}this._onUpdate(this._fromValue+this._easing((now-this._startTime)/this._duration)*(this._toValue-this._fromValue));if(this.__active){this._animationFrame=requestAnimationFrame(this.onUpdate.bind(this));}}},{key:"stop",value:function stop(){_superPropGet(TimingAnimation,"stop",this,3)([]);this.__active=false;clearTimeout(this._timeout);__webpack_require__.g.cancelAnimationFrame(this._animationFrame);this.__debouncedOnEnd({finished:false});}}]);}(_Animation2.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 6824:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var __webpack_unused_export__;
__webpack_unused_export__ = ({value:true});exports.A=bezier;var NEWTON_ITERATIONS=4;var NEWTON_MIN_SLOPE=0.001;var SUBDIVISION_PRECISION=0.0000001;var SUBDIVISION_MAX_ITERATIONS=10;var kSplineTableSize=11;var kSampleStepSize=1.0/(kSplineTableSize-1.0);var float32ArraySupported=typeof Float32Array==='function';function A(aA1,aA2){return 1.0-3.0*aA2+3.0*aA1;}function B(aA1,aA2){return 3.0*aA2-6.0*aA1;}function C(aA1){return 3.0*aA1;}function calcBezier(aT,aA1,aA2){return((A(aA1,aA2)*aT+B(aA1,aA2))*aT+C(aA1))*aT;}function getSlope(aT,aA1,aA2){return 3.0*A(aA1,aA2)*aT*aT+2.0*B(aA1,aA2)*aT+C(aA1);}function binarySubdivide(aX,_aA,_aB,mX1,mX2){var currentX,currentT,i=0,aA=_aA,aB=_aB;do{currentT=aA+(aB-aA)/2.0;currentX=calcBezier(currentT,mX1,mX2)-aX;if(currentX>0.0){aB=currentT;}else{aA=currentT;}}while(Math.abs(currentX)>SUBDIVISION_PRECISION&&++i<SUBDIVISION_MAX_ITERATIONS);return currentT;}function newtonRaphsonIterate(aX,_aGuessT,mX1,mX2){var aGuessT=_aGuessT;for(var i=0;i<NEWTON_ITERATIONS;++i){var currentSlope=getSlope(aGuessT,mX1,mX2);if(currentSlope===0.0){return aGuessT;}var currentX=calcBezier(aGuessT,mX1,mX2)-aX;aGuessT-=currentX/currentSlope;}return aGuessT;}function bezier(mX1,mY1,mX2,mY2){if(!(mX1>=0&&mX1<=1&&mX2>=0&&mX2<=1)){throw new Error('bezier x values must be in [0, 1] range');}var sampleValues=float32ArraySupported?new Float32Array(kSplineTableSize):new Array(kSplineTableSize);if(mX1!==mY1||mX2!==mY2){for(var i=0;i<kSplineTableSize;++i){sampleValues[i]=calcBezier(i*kSampleStepSize,mX1,mX2);}}function getTForX(aX){var intervalStart=0.0;var currentSample=1;var lastSample=kSplineTableSize-1;for(;currentSample!==lastSample&&sampleValues[currentSample]<=aX;++currentSample){intervalStart+=kSampleStepSize;}--currentSample;var dist=(aX-sampleValues[currentSample])/(sampleValues[currentSample+1]-sampleValues[currentSample]);var guessForT=intervalStart+dist*kSampleStepSize;var initialSlope=getSlope(guessForT,mX1,mX2);if(initialSlope>=NEWTON_MIN_SLOPE){return newtonRaphsonIterate(aX,guessForT,mX1,mX2);}else if(initialSlope===0.0){return guessForT;}else{return binarySubdivide(aX,intervalStart,intervalStart+kSampleStepSize,mX1,mX2);}}return function BezierEasing(x){if(mX1===mY1&&mX2===mY2){return x;}if(x===0){return 0;}if(x===1){return 1;}return calcBezier(getTForX(x),mY1,mY2);};}
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 3000:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var __webpack_unused_export__;
var _interopRequireDefault=__webpack_require__(4994);__webpack_unused_export__ = ({value:true});exports.A=void 0;var _FlatList=_interopRequireDefault(__webpack_require__(592));var _createAnimatedComponent=_interopRequireDefault(__webpack_require__(3315));var React=_interopRequireWildcard(__webpack_require__(6540));var _jsxRuntime=__webpack_require__(4848);function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var FlatListWithEventThrottle=React.forwardRef(function(props,ref){return(0,_jsxRuntime.jsx)(_FlatList.default,Object.assign({scrollEventThrottle:0.0001},props,{ref:ref}));});var _default=exports.A=(0,_createAnimatedComponent.default)(FlatListWithEventThrottle);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 5554:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var __webpack_unused_export__;
var _interopRequireDefault=__webpack_require__(4994);__webpack_unused_export__ = ({value:true});exports.A=void 0;var _Image=_interopRequireDefault(__webpack_require__(5545));var _createAnimatedComponent=_interopRequireDefault(__webpack_require__(3315));var React=_interopRequireWildcard(__webpack_require__(6540));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var _default=exports.A=(0,_createAnimatedComponent.default)(_Image.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 9975:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var __webpack_unused_export__;
var _interopRequireDefault=__webpack_require__(4994);__webpack_unused_export__ = ({value:true});exports.A=void 0;var _slicedToArray2=_interopRequireDefault(__webpack_require__(5715));var _RefreshControl=_interopRequireDefault(__webpack_require__(3043));var _ScrollView=_interopRequireDefault(__webpack_require__(8699));var _flattenStyle=_interopRequireDefault(__webpack_require__(9259));var _splitLayoutProps2=_interopRequireDefault(__webpack_require__(1284));var _StyleSheet=_interopRequireDefault(__webpack_require__(6556));var _Platform=_interopRequireDefault(__webpack_require__(8192));var _useMergeRefs=_interopRequireDefault(__webpack_require__(9443));var _createAnimatedComponent=_interopRequireDefault(__webpack_require__(3315));var _useAnimatedProps5=_interopRequireDefault(__webpack_require__(5567));var _react=_interopRequireWildcard(__webpack_require__(6540));var React=_react;var _jsxRuntime=__webpack_require__(4848);function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var AnimatedScrollView=React.forwardRef(function(props,forwardedRef){if(_Platform.default.OS==='android'&&props.refreshControl!=null&&props.style!=null){return(0,_jsxRuntime.jsx)(AnimatedScrollViewWithInvertedRefreshControl,Object.assign({scrollEventThrottle:0.0001},props,{ref:forwardedRef,refreshControl:props.refreshControl}));}else{return(0,_jsxRuntime.jsx)(AnimatedScrollViewWithoutInvertedRefreshControl,Object.assign({scrollEventThrottle:0.0001},props,{ref:forwardedRef}));}});var AnimatedScrollViewWithInvertedRefreshControl=React.forwardRef(function(props,forwardedRef){var _useMemo=(0,_react.useMemo)(function(){var _splitLayoutProps=(0,_splitLayoutProps2.default)((0,_flattenStyle.default)(props.style)),outer=_splitLayoutProps.outer,inner=_splitLayoutProps.inner;return{intermediatePropsForRefreshControl:{style:outer},intermediatePropsForScrollView:Object.assign({},props,{style:inner})};},[props]),intermediatePropsForRefreshControl=_useMemo.intermediatePropsForRefreshControl,intermediatePropsForScrollView=_useMemo.intermediatePropsForScrollView;var _useAnimatedProps=(0,_useAnimatedProps5.default)(intermediatePropsForRefreshControl),_useAnimatedProps2=(0,_slicedToArray2.default)(_useAnimatedProps,2),refreshControlAnimatedProps=_useAnimatedProps2[0],refreshControlRef=_useAnimatedProps2[1];var refreshControl=React.cloneElement(props.refreshControl,Object.assign({},refreshControlAnimatedProps,{ref:refreshControlRef}));var _useAnimatedProps3=(0,_useAnimatedProps5.default)(intermediatePropsForScrollView),_useAnimatedProps4=(0,_slicedToArray2.default)(_useAnimatedProps3,2),scrollViewAnimatedProps=_useAnimatedProps4[0],scrollViewRef=_useAnimatedProps4[1];var ref=(0,_useMergeRefs.default)(scrollViewRef,forwardedRef);return((0,_jsxRuntime.jsx)(_ScrollView.default,Object.assign({},scrollViewAnimatedProps,{ref:ref,refreshControl:refreshControl,style:_StyleSheet.default.compose(scrollViewAnimatedProps.style,refreshControlAnimatedProps.style)})));});var AnimatedScrollViewWithoutInvertedRefreshControl=(0,_createAnimatedComponent.default)(_ScrollView.default);var _default=exports.A=AnimatedScrollView;
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 9216:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var __webpack_unused_export__;
var _interopRequireDefault=__webpack_require__(4994);__webpack_unused_export__ = ({value:true});exports.A=void 0;var _SectionList=_interopRequireDefault(__webpack_require__(2120));var _createAnimatedComponent=_interopRequireDefault(__webpack_require__(3315));var React=_interopRequireWildcard(__webpack_require__(6540));var _jsxRuntime=__webpack_require__(4848);function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var SectionListWithEventThrottle=React.forwardRef(function(props,ref){return(0,_jsxRuntime.jsx)(_SectionList.default,Object.assign({scrollEventThrottle:0.0001},props,{ref:ref}));});var _default=exports.A=(0,_createAnimatedComponent.default)(SectionListWithEventThrottle);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 7576:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var __webpack_unused_export__;
var _interopRequireDefault=__webpack_require__(4994);__webpack_unused_export__ = ({value:true});exports.A=void 0;var _Text=_interopRequireDefault(__webpack_require__(7766));var _createAnimatedComponent=_interopRequireDefault(__webpack_require__(3315));var React=_interopRequireWildcard(__webpack_require__(6540));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var _default=exports.A=(0,_createAnimatedComponent.default)(_Text.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 7598:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var __webpack_unused_export__;
var _interopRequireDefault=__webpack_require__(4994);__webpack_unused_export__ = ({value:true});exports.A=void 0;var _View=_interopRequireDefault(__webpack_require__(101));var _createAnimatedComponent=_interopRequireDefault(__webpack_require__(3315));var React=_interopRequireWildcard(__webpack_require__(6540));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var _default=exports.A=(0,_createAnimatedComponent.default)(_View.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 3315:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=createAnimatedComponent;var _objectWithoutProperties2=_interopRequireDefault(__webpack_require__(1847));var _slicedToArray2=_interopRequireDefault(__webpack_require__(5715));var _View=_interopRequireDefault(__webpack_require__(101));var _useMergeRefs=_interopRequireDefault(__webpack_require__(9443));var _useAnimatedProps3=_interopRequireDefault(__webpack_require__(5567));var React=_interopRequireWildcard(__webpack_require__(6540));var _jsxRuntime=__webpack_require__(4848);var _excluded=["style"];function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}function createAnimatedComponent(Component){return React.forwardRef(function(props,forwardedRef){var _useAnimatedProps=(0,_useAnimatedProps3.default)(props),_useAnimatedProps2=(0,_slicedToArray2.default)(_useAnimatedProps,2),reducedProps=_useAnimatedProps2[0],callbackRef=_useAnimatedProps2[1];var ref=(0,_useMergeRefs.default)(callbackRef,forwardedRef);var passthroughAnimatedPropExplicitValues=reducedProps.passthroughAnimatedPropExplicitValues,style=reducedProps.style;var _ref=passthroughAnimatedPropExplicitValues!=null?passthroughAnimatedPropExplicitValues:{},passthroughStyle=_ref.style,passthroughProps=(0,_objectWithoutProperties2.default)(_ref,_excluded);var mergedStyle=Object.assign({},style,passthroughStyle);return(0,_jsxRuntime.jsx)(Component,Object.assign({},reducedProps,passthroughProps,{style:mergedStyle,ref:ref}));});}
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 4536:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _AnimatedInterpolation=_interopRequireDefault(__webpack_require__(3636));var _AnimatedValue=_interopRequireDefault(__webpack_require__(9579));var _AnimatedWithChildren2=_interopRequireDefault(__webpack_require__(6023));function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}var AnimatedAddition=exports["default"]=function(_AnimatedWithChildren){function AnimatedAddition(a,b){var _this;(0,_classCallCheck2.default)(this,AnimatedAddition);_this=_callSuper(this,AnimatedAddition);_this._a=typeof a==='number'?new _AnimatedValue.default(a):a;_this._b=typeof b==='number'?new _AnimatedValue.default(b):b;return _this;}(0,_inherits2.default)(AnimatedAddition,_AnimatedWithChildren);return(0,_createClass2.default)(AnimatedAddition,[{key:"__makeNative",value:function __makeNative(platformConfig){this._a.__makeNative(platformConfig);this._b.__makeNative(platformConfig);_superPropGet(AnimatedAddition,"__makeNative",this,3)([platformConfig]);}},{key:"__getValue",value:function __getValue(){return this._a.__getValue()+this._b.__getValue();}},{key:"interpolate",value:function interpolate(config){return new _AnimatedInterpolation.default(this,config);}},{key:"__attach",value:function __attach(){this._a.__addChild(this);this._b.__addChild(this);}},{key:"__detach",value:function __detach(){this._a.__removeChild(this);this._b.__removeChild(this);_superPropGet(AnimatedAddition,"__detach",this,3)([]);}},{key:"__getNativeConfig",value:function __getNativeConfig(){return{type:'addition',input:[this._a.__getNativeTag(),this._b.__getNativeTag()]};}}]);}(_AnimatedWithChildren2.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 1265:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _normalizeColor=_interopRequireDefault(__webpack_require__(7298));var _PlatformColorValueTypes=__webpack_require__(5161);var _NativeAnimatedHelper=_interopRequireDefault(__webpack_require__(6681));var _AnimatedValue=_interopRequireWildcard(__webpack_require__(9579));var _AnimatedWithChildren2=_interopRequireDefault(__webpack_require__(6023));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}var NativeAnimatedAPI=_NativeAnimatedHelper.default.API;var defaultColor={r:0,g:0,b:0,a:1.0};function processColor(color){if(color===undefined||color===null){return null;}if(isRgbaValue(color)){return color;}var normalizedColor=(0,_normalizeColor.default)(color);if(normalizedColor===undefined||normalizedColor===null){return null;}if(typeof normalizedColor==='object'){var processedColorObj=(0,_PlatformColorValueTypes.processColorObject)(normalizedColor);if(processedColorObj!=null){return processedColorObj;}}else if(typeof normalizedColor==='number'){var r=(normalizedColor&0xff000000)>>>24;var g=(normalizedColor&0x00ff0000)>>>16;var b=(normalizedColor&0x0000ff00)>>>8;var a=(normalizedColor&0x000000ff)/255;return{r:r,g:g,b:b,a:a};}return null;}function isRgbaValue(value){return value&&typeof value.r==='number'&&typeof value.g==='number'&&typeof value.b==='number'&&typeof value.a==='number';}function isRgbaAnimatedValue(value){return value&&value.r instanceof _AnimatedValue.default&&value.g instanceof _AnimatedValue.default&&value.b instanceof _AnimatedValue.default&&value.a instanceof _AnimatedValue.default;}var AnimatedColor=exports["default"]=function(_AnimatedWithChildren){function AnimatedColor(valueIn,config){var _this;(0,_classCallCheck2.default)(this,AnimatedColor);_this=_callSuper(this,AnimatedColor);_this._suspendCallbacks=0;var value=valueIn!=null?valueIn:defaultColor;if(isRgbaAnimatedValue(value)){var rgbaAnimatedValue=value;_this.r=rgbaAnimatedValue.r;_this.g=rgbaAnimatedValue.g;_this.b=rgbaAnimatedValue.b;_this.a=rgbaAnimatedValue.a;}else{var _processColor;var processedColor=(_processColor=processColor(value))!=null?_processColor:defaultColor;var initColor=defaultColor;if(isRgbaValue(processedColor)){initColor=processedColor;}else{_this.nativeColor=processedColor;}_this.r=new _AnimatedValue.default(initColor.r);_this.g=new _AnimatedValue.default(initColor.g);_this.b=new _AnimatedValue.default(initColor.b);_this.a=new _AnimatedValue.default(initColor.a);}if(config!=null&&config.useNativeDriver){_this.__makeNative();}return _this;}(0,_inherits2.default)(AnimatedColor,_AnimatedWithChildren);return(0,_createClass2.default)(AnimatedColor,[{key:"setValue",value:function setValue(value){var _processColor2,_this2=this;var shouldUpdateNodeConfig=false;if(this.__isNative){var nativeTag=this.__getNativeTag();NativeAnimatedAPI.setWaitingForIdentifier(nativeTag.toString());}var processedColor=(_processColor2=processColor(value))!=null?_processColor2:defaultColor;this._withSuspendedCallbacks(function(){if(isRgbaValue(processedColor)){var rgbaValue=processedColor;_this2.r.setValue(rgbaValue.r);_this2.g.setValue(rgbaValue.g);_this2.b.setValue(rgbaValue.b);_this2.a.setValue(rgbaValue.a);if(_this2.nativeColor!=null){_this2.nativeColor=null;shouldUpdateNodeConfig=true;}}else{var nativeColor=processedColor;if(_this2.nativeColor!==nativeColor){_this2.nativeColor=nativeColor;shouldUpdateNodeConfig=true;}}});if(this.__isNative){var _nativeTag=this.__getNativeTag();if(shouldUpdateNodeConfig){NativeAnimatedAPI.updateAnimatedNodeConfig(_nativeTag,this.__getNativeConfig());}NativeAnimatedAPI.unsetWaitingForIdentifier(_nativeTag.toString());}else{(0,_AnimatedValue.flushValue)(this);}this.__callListeners(this.__getValue());}},{key:"setOffset",value:function setOffset(offset){this.r.setOffset(offset.r);this.g.setOffset(offset.g);this.b.setOffset(offset.b);this.a.setOffset(offset.a);}},{key:"flattenOffset",value:function flattenOffset(){this.r.flattenOffset();this.g.flattenOffset();this.b.flattenOffset();this.a.flattenOffset();}},{key:"extractOffset",value:function extractOffset(){this.r.extractOffset();this.g.extractOffset();this.b.extractOffset();this.a.extractOffset();}},{key:"stopAnimation",value:function stopAnimation(callback){this.r.stopAnimation();this.g.stopAnimation();this.b.stopAnimation();this.a.stopAnimation();callback&&callback(this.__getValue());}},{key:"resetAnimation",value:function resetAnimation(callback){this.r.resetAnimation();this.g.resetAnimation();this.b.resetAnimation();this.a.resetAnimation();callback&&callback(this.__getValue());}},{key:"__getValue",value:function __getValue(){if(this.nativeColor!=null){return this.nativeColor;}else{return`rgba(${this.r.__getValue()}, ${this.g.__getValue()}, ${this.b.__getValue()}, ${this.a.__getValue()})`;}}},{key:"__attach",value:function __attach(){this.r.__addChild(this);this.g.__addChild(this);this.b.__addChild(this);this.a.__addChild(this);_superPropGet(AnimatedColor,"__attach",this,3)([]);}},{key:"__detach",value:function __detach(){this.r.__removeChild(this);this.g.__removeChild(this);this.b.__removeChild(this);this.a.__removeChild(this);_superPropGet(AnimatedColor,"__detach",this,3)([]);}},{key:"_withSuspendedCallbacks",value:function _withSuspendedCallbacks(callback){this._suspendCallbacks++;callback();this._suspendCallbacks--;}},{key:"__callListeners",value:function __callListeners(value){if(this._suspendCallbacks===0){_superPropGet(AnimatedColor,"__callListeners",this,3)([value]);}}},{key:"__makeNative",value:function __makeNative(platformConfig){this.r.__makeNative(platformConfig);this.g.__makeNative(platformConfig);this.b.__makeNative(platformConfig);this.a.__makeNative(platformConfig);_superPropGet(AnimatedColor,"__makeNative",this,3)([platformConfig]);}},{key:"__getNativeConfig",value:function __getNativeConfig(){return{type:'color',r:this.r.__getNativeTag(),g:this.g.__getNativeTag(),b:this.b.__getNativeTag(),a:this.a.__getNativeTag(),nativeColor:this.nativeColor};}}]);}(_AnimatedWithChildren2.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 3272:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _AnimatedInterpolation=_interopRequireDefault(__webpack_require__(3636));var _AnimatedWithChildren2=_interopRequireDefault(__webpack_require__(6023));function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}var AnimatedDiffClamp=exports["default"]=function(_AnimatedWithChildren){function AnimatedDiffClamp(a,min,max){var _this;(0,_classCallCheck2.default)(this,AnimatedDiffClamp);_this=_callSuper(this,AnimatedDiffClamp);_this._a=a;_this._min=min;_this._max=max;_this._value=_this._lastValue=_this._a.__getValue();return _this;}(0,_inherits2.default)(AnimatedDiffClamp,_AnimatedWithChildren);return(0,_createClass2.default)(AnimatedDiffClamp,[{key:"__makeNative",value:function __makeNative(platformConfig){this._a.__makeNative(platformConfig);_superPropGet(AnimatedDiffClamp,"__makeNative",this,3)([platformConfig]);}},{key:"interpolate",value:function interpolate(config){return new _AnimatedInterpolation.default(this,config);}},{key:"__getValue",value:function __getValue(){var value=this._a.__getValue();var diff=value-this._lastValue;this._lastValue=value;this._value=Math.min(Math.max(this._value+diff,this._min),this._max);return this._value;}},{key:"__attach",value:function __attach(){this._a.__addChild(this);}},{key:"__detach",value:function __detach(){this._a.__removeChild(this);_superPropGet(AnimatedDiffClamp,"__detach",this,3)([]);}},{key:"__getNativeConfig",value:function __getNativeConfig(){return{type:'diffclamp',input:this._a.__getNativeTag(),min:this._min,max:this._max};}}]);}(_AnimatedWithChildren2.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 8247:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _AnimatedInterpolation=_interopRequireDefault(__webpack_require__(3636));var _AnimatedNode=_interopRequireDefault(__webpack_require__(244));var _AnimatedValue=_interopRequireDefault(__webpack_require__(9579));var _AnimatedWithChildren2=_interopRequireDefault(__webpack_require__(6023));function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}var AnimatedDivision=exports["default"]=function(_AnimatedWithChildren){function AnimatedDivision(a,b){var _this;(0,_classCallCheck2.default)(this,AnimatedDivision);_this=_callSuper(this,AnimatedDivision);_this._warnedAboutDivideByZero=false;if(b===0||b instanceof _AnimatedNode.default&&b.__getValue()===0){console.error('Detected potential division by zero in AnimatedDivision');}_this._a=typeof a==='number'?new _AnimatedValue.default(a):a;_this._b=typeof b==='number'?new _AnimatedValue.default(b):b;return _this;}(0,_inherits2.default)(AnimatedDivision,_AnimatedWithChildren);return(0,_createClass2.default)(AnimatedDivision,[{key:"__makeNative",value:function __makeNative(platformConfig){this._a.__makeNative(platformConfig);this._b.__makeNative(platformConfig);_superPropGet(AnimatedDivision,"__makeNative",this,3)([platformConfig]);}},{key:"__getValue",value:function __getValue(){var a=this._a.__getValue();var b=this._b.__getValue();if(b===0){if(!this._warnedAboutDivideByZero){console.error('Detected division by zero in AnimatedDivision');this._warnedAboutDivideByZero=true;}return 0;}this._warnedAboutDivideByZero=false;return a/b;}},{key:"interpolate",value:function interpolate(config){return new _AnimatedInterpolation.default(this,config);}},{key:"__attach",value:function __attach(){this._a.__addChild(this);this._b.__addChild(this);}},{key:"__detach",value:function __detach(){this._a.__removeChild(this);this._b.__removeChild(this);_superPropGet(AnimatedDivision,"__detach",this,3)([]);}},{key:"__getNativeConfig",value:function __getNativeConfig(){return{type:'division',input:[this._a.__getNativeTag(),this._b.__getNativeTag()]};}}]);}(_AnimatedWithChildren2.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 3636:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _normalizeColor=_interopRequireDefault(__webpack_require__(7298));var _processColor=_interopRequireDefault(__webpack_require__(5372));var _Easing=_interopRequireDefault(__webpack_require__(5250));var _NativeAnimatedHelper=_interopRequireDefault(__webpack_require__(6681));var _AnimatedWithChildren2=_interopRequireDefault(__webpack_require__(6023));var _invariant=_interopRequireDefault(__webpack_require__(311));function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}function createNumericInterpolation(config){var outputRange=config.outputRange;var inputRange=config.inputRange;var easing=config.easing||_Easing.default.linear;var extrapolateLeft='extend';if(config.extrapolateLeft!==undefined){extrapolateLeft=config.extrapolateLeft;}else if(config.extrapolate!==undefined){extrapolateLeft=config.extrapolate;}var extrapolateRight='extend';if(config.extrapolateRight!==undefined){extrapolateRight=config.extrapolateRight;}else if(config.extrapolate!==undefined){extrapolateRight=config.extrapolate;}return function(input){(0,_invariant.default)(typeof input==='number','Cannot interpolation an input which is not a number');var range=findRange(input,inputRange);return interpolate(input,inputRange[range],inputRange[range+1],outputRange[range],outputRange[range+1],easing,extrapolateLeft,extrapolateRight);};}function interpolate(input,inputMin,inputMax,outputMin,outputMax,easing,extrapolateLeft,extrapolateRight){var result=input;if(result<inputMin){if(extrapolateLeft==='identity'){return result;}else if(extrapolateLeft==='clamp'){result=inputMin;}else if(extrapolateLeft==='extend'){}}if(result>inputMax){if(extrapolateRight==='identity'){return result;}else if(extrapolateRight==='clamp'){result=inputMax;}else if(extrapolateRight==='extend'){}}if(outputMin===outputMax){return outputMin;}if(inputMin===inputMax){if(input<=inputMin){return outputMin;}return outputMax;}if(inputMin===-Infinity){result=-result;}else if(inputMax===Infinity){result=result-inputMin;}else{result=(result-inputMin)/(inputMax-inputMin);}result=easing(result);if(outputMin===-Infinity){result=-result;}else if(outputMax===Infinity){result=result+outputMin;}else{result=result*(outputMax-outputMin)+outputMin;}return result;}var numericComponentRegex=/[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/g;function mapStringToNumericComponents(input){var normalizedColor=(0,_normalizeColor.default)(input);(0,_invariant.default)(normalizedColor==null||typeof normalizedColor!=='object','PlatformColors are not supported');if(typeof normalizedColor==='number'){normalizedColor=normalizedColor||0;var r=(normalizedColor&0xff000000)>>>24;var g=(normalizedColor&0x00ff0000)>>>16;var b=(normalizedColor&0x0000ff00)>>>8;var a=(normalizedColor&0x000000ff)/255;return{isColor:true,components:[r,g,b,a]};}else{var components=[];var lastMatchEnd=0;var match;while((match=numericComponentRegex.exec(input))!=null){if(match.index>lastMatchEnd){components.push(input.substring(lastMatchEnd,match.index));}components.push(parseFloat(match[0]));lastMatchEnd=match.index+match[0].length;}(0,_invariant.default)(components.length>0,'outputRange must contain color or value with numeric component');if(lastMatchEnd<input.length){components.push(input.substring(lastMatchEnd,input.length));}return{isColor:false,components:components};}}function createStringInterpolation(config){(0,_invariant.default)(config.outputRange.length>=2,'Bad output range');var outputRange=config.outputRange.map(mapStringToNumericComponents);var isColor=outputRange[0].isColor;if(false){ var firstOutput; }var numericComponents=outputRange.map(function(output){return isColor?output.components:output.components.filter(function(c){return typeof c==='number';});});var interpolations=numericComponents[0].map(function(_,i){return createNumericInterpolation(Object.assign({},config,{outputRange:numericComponents.map(function(components){return components[i];})}));});if(!isColor){return function(input){var values=interpolations.map(function(interpolation){return interpolation(input);});var i=0;return outputRange[0].components.map(function(c){return typeof c==='number'?values[i++]:c;}).join('');};}else{return function(input){var result=interpolations.map(function(interpolation,i){var value=interpolation(input);return i<3?Math.round(value):Math.round(value*1000)/1000;});return`rgba(${result[0]}, ${result[1]}, ${result[2]}, ${result[3]})`;};}}function findRange(input,inputRange){var i;for(i=1;i<inputRange.length-1;++i){if(inputRange[i]>=input){break;}}return i-1;}function checkValidRanges(inputRange,outputRange){checkInfiniteRange('outputRange',outputRange);checkInfiniteRange('inputRange',inputRange);checkValidInputRange(inputRange);(0,_invariant.default)(inputRange.length===outputRange.length,'inputRange ('+inputRange.length+') and outputRange ('+outputRange.length+') must have the same length');}function checkValidInputRange(arr){(0,_invariant.default)(arr.length>=2,'inputRange must have at least 2 elements');var message='inputRange must be monotonically non-decreasing '+String(arr);for(var i=1;i<arr.length;++i){(0,_invariant.default)(arr[i]>=arr[i-1],message);}}function checkInfiniteRange(name,arr){(0,_invariant.default)(arr.length>=2,name+' must have at least 2 elements');(0,_invariant.default)(arr.length!==2||arr[0]!==-Infinity||arr[1]!==Infinity,name+'cannot be ]-infinity;+infinity[ '+arr);}var AnimatedInterpolation=exports["default"]=function(_AnimatedWithChildren){function AnimatedInterpolation(parent,config){var _this;(0,_classCallCheck2.default)(this,AnimatedInterpolation);_this=_callSuper(this,AnimatedInterpolation);_this._parent=parent;_this._config=config;if(false){}return _this;}(0,_inherits2.default)(AnimatedInterpolation,_AnimatedWithChildren);return(0,_createClass2.default)(AnimatedInterpolation,[{key:"_getInterpolation",value:function _getInterpolation(){if(!this._interpolation){var config=this._config;if(config.outputRange&&typeof config.outputRange[0]==='string'){this._interpolation=createStringInterpolation(config);}else{this._interpolation=createNumericInterpolation(config);}}return this._interpolation;}},{key:"__makeNative",value:function __makeNative(platformConfig){this._parent.__makeNative(platformConfig);_superPropGet(AnimatedInterpolation,"__makeNative",this,3)([platformConfig]);}},{key:"__getValue",value:function __getValue(){var parentValue=this._parent.__getValue();(0,_invariant.default)(typeof parentValue==='number','Cannot interpolate an input which is not a number.');return this._getInterpolation()(parentValue);}},{key:"interpolate",value:function interpolate(config){return new AnimatedInterpolation(this,config);}},{key:"__attach",value:function __attach(){this._parent.__addChild(this);}},{key:"__detach",value:function __detach(){this._parent.__removeChild(this);_superPropGet(AnimatedInterpolation,"__detach",this,3)([]);}},{key:"__getNativeConfig",value:function __getNativeConfig(){if(false){}var outputRange=this._config.outputRange;var outputType=null;if(typeof outputRange[0]==='string'){outputRange=outputRange.map(function(value){var processedColor=(0,_processColor.default)(value);if(typeof processedColor==='number'){outputType='color';return processedColor;}else{return _NativeAnimatedHelper.default.transformDataType(value);}});}return{inputRange:this._config.inputRange,outputRange:outputRange,outputType:outputType,extrapolateLeft:this._config.extrapolateLeft||this._config.extrapolate||'extend',extrapolateRight:this._config.extrapolateRight||this._config.extrapolate||'extend',type:'interpolation'};}}]);}(_AnimatedWithChildren2.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 3866:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _AnimatedInterpolation=_interopRequireDefault(__webpack_require__(3636));var _AnimatedWithChildren2=_interopRequireDefault(__webpack_require__(6023));function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}var AnimatedModulo=exports["default"]=function(_AnimatedWithChildren){function AnimatedModulo(a,modulus){var _this;(0,_classCallCheck2.default)(this,AnimatedModulo);_this=_callSuper(this,AnimatedModulo);_this._a=a;_this._modulus=modulus;return _this;}(0,_inherits2.default)(AnimatedModulo,_AnimatedWithChildren);return(0,_createClass2.default)(AnimatedModulo,[{key:"__makeNative",value:function __makeNative(platformConfig){this._a.__makeNative(platformConfig);_superPropGet(AnimatedModulo,"__makeNative",this,3)([platformConfig]);}},{key:"__getValue",value:function __getValue(){return(this._a.__getValue()%this._modulus+this._modulus)%this._modulus;}},{key:"interpolate",value:function interpolate(config){return new _AnimatedInterpolation.default(this,config);}},{key:"__attach",value:function __attach(){this._a.__addChild(this);}},{key:"__detach",value:function __detach(){this._a.__removeChild(this);_superPropGet(AnimatedModulo,"__detach",this,3)([]);}},{key:"__getNativeConfig",value:function __getNativeConfig(){return{type:'modulus',input:this._a.__getNativeTag(),modulus:this._modulus};}}]);}(_AnimatedWithChildren2.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 1938:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _AnimatedInterpolation=_interopRequireDefault(__webpack_require__(3636));var _AnimatedValue=_interopRequireDefault(__webpack_require__(9579));var _AnimatedWithChildren2=_interopRequireDefault(__webpack_require__(6023));function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}var AnimatedMultiplication=exports["default"]=function(_AnimatedWithChildren){function AnimatedMultiplication(a,b){var _this;(0,_classCallCheck2.default)(this,AnimatedMultiplication);_this=_callSuper(this,AnimatedMultiplication);_this._a=typeof a==='number'?new _AnimatedValue.default(a):a;_this._b=typeof b==='number'?new _AnimatedValue.default(b):b;return _this;}(0,_inherits2.default)(AnimatedMultiplication,_AnimatedWithChildren);return(0,_createClass2.default)(AnimatedMultiplication,[{key:"__makeNative",value:function __makeNative(platformConfig){this._a.__makeNative(platformConfig);this._b.__makeNative(platformConfig);_superPropGet(AnimatedMultiplication,"__makeNative",this,3)([platformConfig]);}},{key:"__getValue",value:function __getValue(){return this._a.__getValue()*this._b.__getValue();}},{key:"interpolate",value:function interpolate(config){return new _AnimatedInterpolation.default(this,config);}},{key:"__attach",value:function __attach(){this._a.__addChild(this);this._b.__addChild(this);}},{key:"__detach",value:function __detach(){this._a.__removeChild(this);this._b.__removeChild(this);_superPropGet(AnimatedMultiplication,"__detach",this,3)([]);}},{key:"__getNativeConfig",value:function __getNativeConfig(){return{type:'multiplication',input:[this._a.__getNativeTag(),this._b.__getNativeTag()]};}}]);}(_AnimatedWithChildren2.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 244:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _NativeAnimatedHelper=_interopRequireDefault(__webpack_require__(6681));var _invariant=_interopRequireDefault(__webpack_require__(311));var NativeAnimatedAPI=_NativeAnimatedHelper.default.API;var _uniqueId=1;var AnimatedNode=exports["default"]=function(){function AnimatedNode(){(0,_classCallCheck2.default)(this,AnimatedNode);this._listeners={};}return(0,_createClass2.default)(AnimatedNode,[{key:"__attach",value:function __attach(){}},{key:"__detach",value:function __detach(){this.removeAllListeners();if(this.__isNative&&this.__nativeTag!=null){_NativeAnimatedHelper.default.API.dropAnimatedNode(this.__nativeTag);this.__nativeTag=undefined;}}},{key:"__getValue",value:function __getValue(){}},{key:"__getAnimatedValue",value:function __getAnimatedValue(){return this.__getValue();}},{key:"__addChild",value:function __addChild(child){}},{key:"__removeChild",value:function __removeChild(child){}},{key:"__getChildren",value:function __getChildren(){return[];}},{key:"__makeNative",value:function __makeNative(platformConfig){if(!this.__isNative){throw new Error('This node cannot be made a "native" animated node');}this._platformConfig=platformConfig;if(this.hasListeners()){this._startListeningToNativeValueUpdates();}}},{key:"addListener",value:function addListener(callback){var id=String(_uniqueId++);this._listeners[id]=callback;if(this.__isNative){this._startListeningToNativeValueUpdates();}return id;}},{key:"removeListener",value:function removeListener(id){delete this._listeners[id];if(this.__isNative&&!this.hasListeners()){this._stopListeningForNativeValueUpdates();}}},{key:"removeAllListeners",value:function removeAllListeners(){this._listeners={};if(this.__isNative){this._stopListeningForNativeValueUpdates();}}},{key:"hasListeners",value:function hasListeners(){return!!Object.keys(this._listeners).length;}},{key:"_startListeningToNativeValueUpdates",value:function _startListeningToNativeValueUpdates(){var _this=this;if(this.__nativeAnimatedValueListener&&!this.__shouldUpdateListenersForNewNativeTag){return;}if(this.__shouldUpdateListenersForNewNativeTag){this.__shouldUpdateListenersForNewNativeTag=false;this._stopListeningForNativeValueUpdates();}NativeAnimatedAPI.startListeningToAnimatedNodeValue(this.__getNativeTag());this.__nativeAnimatedValueListener=_NativeAnimatedHelper.default.nativeEventEmitter.addListener('onAnimatedValueUpdate',function(data){if(data.tag!==_this.__getNativeTag()){return;}_this.__onAnimatedValueUpdateReceived(data.value);});}},{key:"__onAnimatedValueUpdateReceived",value:function __onAnimatedValueUpdateReceived(value){this.__callListeners(value);}},{key:"__callListeners",value:function __callListeners(value){for(var _key in this._listeners){this._listeners[_key]({value:value});}}},{key:"_stopListeningForNativeValueUpdates",value:function _stopListeningForNativeValueUpdates(){if(!this.__nativeAnimatedValueListener){return;}this.__nativeAnimatedValueListener.remove();this.__nativeAnimatedValueListener=null;NativeAnimatedAPI.stopListeningToAnimatedNodeValue(this.__getNativeTag());}},{key:"__getNativeTag",value:function __getNativeTag(){var _this$__nativeTag;_NativeAnimatedHelper.default.assertNativeAnimatedModule();(0,_invariant.default)(this.__isNative,'Attempt to get native tag from node not marked as "native"');var nativeTag=(_this$__nativeTag=this.__nativeTag)!=null?_this$__nativeTag:_NativeAnimatedHelper.default.generateNewNodeTag();if(this.__nativeTag==null){this.__nativeTag=nativeTag;var config=this.__getNativeConfig();if(this._platformConfig){config.platformConfig=this._platformConfig;}_NativeAnimatedHelper.default.API.createAnimatedNode(nativeTag,config);this.__shouldUpdateListenersForNewNativeTag=true;}return nativeTag;}},{key:"__getNativeConfig",value:function __getNativeConfig(){throw new Error('This JS animated node type cannot be used as native animated node');}},{key:"toJSON",value:function toJSON(){return this.__getValue();}},{key:"__getPlatformConfig",value:function __getPlatformConfig(){return this._platformConfig;}},{key:"__setPlatformConfig",value:function __setPlatformConfig(platformConfig){this._platformConfig=platformConfig;}}]);}();
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 3728:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _RendererProxy=__webpack_require__(8907);var _AnimatedEvent=__webpack_require__(8844);var _NativeAnimatedHelper=_interopRequireDefault(__webpack_require__(6681));var _AnimatedNode2=_interopRequireDefault(__webpack_require__(244));var _AnimatedStyle=_interopRequireDefault(__webpack_require__(3815));var _invariant=_interopRequireDefault(__webpack_require__(311));function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}var AnimatedProps=exports["default"]=function(_AnimatedNode){function AnimatedProps(props,callback){var _this;(0,_classCallCheck2.default)(this,AnimatedProps);_this=_callSuper(this,AnimatedProps);if(props.style){props=Object.assign({},props,{style:new _AnimatedStyle.default(props.style)});}_this._props=props;_this._callback=callback;return _this;}(0,_inherits2.default)(AnimatedProps,_AnimatedNode);return(0,_createClass2.default)(AnimatedProps,[{key:"__getValue",value:function __getValue(){var props={};for(var key in this._props){var value=this._props[key];if(value instanceof _AnimatedNode2.default){props[key]=value.__getValue();}else if(value instanceof _AnimatedEvent.AnimatedEvent){props[key]=value.__getHandler();}else{props[key]=value;}}return props;}},{key:"__getAnimatedValue",value:function __getAnimatedValue(){var props={};for(var key in this._props){var value=this._props[key];if(value instanceof _AnimatedNode2.default){props[key]=value.__getAnimatedValue();}}return props;}},{key:"__attach",value:function __attach(){for(var key in this._props){var value=this._props[key];if(value instanceof _AnimatedNode2.default){value.__addChild(this);}}}},{key:"__detach",value:function __detach(){if(this.__isNative&&this._animatedView){this.__disconnectAnimatedView();}for(var key in this._props){var value=this._props[key];if(value instanceof _AnimatedNode2.default){value.__removeChild(this);}}_superPropGet(AnimatedProps,"__detach",this,3)([]);}},{key:"update",value:function update(){this._callback();}},{key:"__makeNative",value:function __makeNative(platformConfig){for(var key in this._props){var value=this._props[key];if(value instanceof _AnimatedNode2.default){value.__makeNative(platformConfig);}}if(!this.__isNative){this.__isNative=true;_superPropGet(AnimatedProps,"__setPlatformConfig",this,3)([platformConfig]);if(this._animatedView){this.__connectAnimatedView();}}}},{key:"setNativeView",value:function setNativeView(animatedView){if(this._animatedView===animatedView){return;}this._animatedView=animatedView;if(this.__isNative){this.__connectAnimatedView();}}},{key:"__connectAnimatedView",value:function __connectAnimatedView(){(0,_invariant.default)(this.__isNative,'Expected node to be marked as "native"');var nativeViewTag=(0,_RendererProxy.findNodeHandle)(this._animatedView);(0,_invariant.default)(nativeViewTag!=null,'Unable to locate attached view in the native tree');_NativeAnimatedHelper.default.API.connectAnimatedNodeToView(this.__getNativeTag(),nativeViewTag);}},{key:"__disconnectAnimatedView",value:function __disconnectAnimatedView(){(0,_invariant.default)(this.__isNative,'Expected node to be marked as "native"');var nativeViewTag=(0,_RendererProxy.findNodeHandle)(this._animatedView);(0,_invariant.default)(nativeViewTag!=null,'Unable to locate attached view in the native tree');_NativeAnimatedHelper.default.API.disconnectAnimatedNodeFromView(this.__getNativeTag(),nativeViewTag);}},{key:"__restoreDefaultValues",value:function __restoreDefaultValues(){if(this.__isNative){_NativeAnimatedHelper.default.API.restoreDefaultValues(this.__getNativeTag());}}},{key:"__getNativeConfig",value:function __getNativeConfig(){var propsConfig={};for(var propKey in this._props){var value=this._props[propKey];if(value instanceof _AnimatedNode2.default){value.__makeNative(this.__getPlatformConfig());propsConfig[propKey]=value.__getNativeTag();}}return{type:'props',props:propsConfig};}}]);}(_AnimatedNode2.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 3815:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _flattenStyle=_interopRequireDefault(__webpack_require__(9259));var _Platform=_interopRequireDefault(__webpack_require__(8192));var _NativeAnimatedHelper=_interopRequireDefault(__webpack_require__(6681));var _AnimatedNode=_interopRequireDefault(__webpack_require__(244));var _AnimatedTransform=_interopRequireDefault(__webpack_require__(1922));var _AnimatedWithChildren2=_interopRequireDefault(__webpack_require__(6023));function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}function createAnimatedStyle(inputStyle){var style=(0,_flattenStyle.default)(inputStyle);var animatedStyles={};for(var key in style){var value=style[key];if(key==='transform'){animatedStyles[key]=new _AnimatedTransform.default(value);}else if(value instanceof _AnimatedNode.default){animatedStyles[key]=value;}else if(value&&!Array.isArray(value)&&typeof value==='object'){animatedStyles[key]=createAnimatedStyle(value);}}return animatedStyles;}function createStyleWithAnimatedTransform(inputStyle){var style=(0,_flattenStyle.default)(inputStyle)||{};if(style.transform){style=Object.assign({},style,{transform:new _AnimatedTransform.default(style.transform)});}return style;}var AnimatedStyle=exports["default"]=function(_AnimatedWithChildren){function AnimatedStyle(style){var _this;(0,_classCallCheck2.default)(this,AnimatedStyle);_this=_callSuper(this,AnimatedStyle);if(_Platform.default.OS==='web'){_this._inputStyle=style;_this._style=createAnimatedStyle(style);}else{_this._style=createStyleWithAnimatedTransform(style);}return _this;}(0,_inherits2.default)(AnimatedStyle,_AnimatedWithChildren);return(0,_createClass2.default)(AnimatedStyle,[{key:"_walkStyleAndGetValues",value:function _walkStyleAndGetValues(style){var updatedStyle={};for(var key in style){var value=style[key];if(value instanceof _AnimatedNode.default){updatedStyle[key]=value.__getValue();}else if(value&&!Array.isArray(value)&&typeof value==='object'){updatedStyle[key]=this._walkStyleAndGetValues(value);}else{updatedStyle[key]=value;}}return updatedStyle;}},{key:"__getValue",value:function __getValue(){if(_Platform.default.OS==='web'){return[this._inputStyle,this._walkStyleAndGetValues(this._style)];}return this._walkStyleAndGetValues(this._style);}},{key:"_walkStyleAndGetAnimatedValues",value:function _walkStyleAndGetAnimatedValues(style){var updatedStyle={};for(var key in style){var value=style[key];if(value instanceof _AnimatedNode.default){updatedStyle[key]=value.__getAnimatedValue();}else if(value&&!Array.isArray(value)&&typeof value==='object'){updatedStyle[key]=this._walkStyleAndGetAnimatedValues(value);}}return updatedStyle;}},{key:"__getAnimatedValue",value:function __getAnimatedValue(){return this._walkStyleAndGetAnimatedValues(this._style);}},{key:"__attach",value:function __attach(){for(var key in this._style){var value=this._style[key];if(value instanceof _AnimatedNode.default){value.__addChild(this);}}}},{key:"__detach",value:function __detach(){for(var key in this._style){var value=this._style[key];if(value instanceof _AnimatedNode.default){value.__removeChild(this);}}_superPropGet(AnimatedStyle,"__detach",this,3)([]);}},{key:"__makeNative",value:function __makeNative(platformConfig){for(var key in this._style){var value=this._style[key];if(value instanceof _AnimatedNode.default){value.__makeNative(platformConfig);}}_superPropGet(AnimatedStyle,"__makeNative",this,3)([platformConfig]);}},{key:"__getNativeConfig",value:function __getNativeConfig(){var styleConfig={};for(var styleKey in this._style){if(this._style[styleKey]instanceof _AnimatedNode.default){var style=this._style[styleKey];style.__makeNative(this.__getPlatformConfig());styleConfig[styleKey]=style.__getNativeTag();}}_NativeAnimatedHelper.default.validateStyles(styleConfig);return{type:'style',style:styleConfig};}}]);}(_AnimatedWithChildren2.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 8116:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _AnimatedInterpolation=_interopRequireDefault(__webpack_require__(3636));var _AnimatedValue=_interopRequireDefault(__webpack_require__(9579));var _AnimatedWithChildren2=_interopRequireDefault(__webpack_require__(6023));function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}var AnimatedSubtraction=exports["default"]=function(_AnimatedWithChildren){function AnimatedSubtraction(a,b){var _this;(0,_classCallCheck2.default)(this,AnimatedSubtraction);_this=_callSuper(this,AnimatedSubtraction);_this._a=typeof a==='number'?new _AnimatedValue.default(a):a;_this._b=typeof b==='number'?new _AnimatedValue.default(b):b;return _this;}(0,_inherits2.default)(AnimatedSubtraction,_AnimatedWithChildren);return(0,_createClass2.default)(AnimatedSubtraction,[{key:"__makeNative",value:function __makeNative(platformConfig){this._a.__makeNative(platformConfig);this._b.__makeNative(platformConfig);_superPropGet(AnimatedSubtraction,"__makeNative",this,3)([platformConfig]);}},{key:"__getValue",value:function __getValue(){return this._a.__getValue()-this._b.__getValue();}},{key:"interpolate",value:function interpolate(config){return new _AnimatedInterpolation.default(this,config);}},{key:"__attach",value:function __attach(){this._a.__addChild(this);this._b.__addChild(this);}},{key:"__detach",value:function __detach(){this._a.__removeChild(this);this._b.__removeChild(this);_superPropGet(AnimatedSubtraction,"__detach",this,3)([]);}},{key:"__getNativeConfig",value:function __getNativeConfig(){return{type:'subtraction',input:[this._a.__getNativeTag(),this._b.__getNativeTag()]};}}]);}(_AnimatedWithChildren2.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 1397:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _NativeAnimatedHelper=_interopRequireDefault(__webpack_require__(6681));var _AnimatedNode2=_interopRequireDefault(__webpack_require__(244));function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}var AnimatedTracking=exports["default"]=function(_AnimatedNode){function AnimatedTracking(value,parent,animationClass,animationConfig,callback){var _this;(0,_classCallCheck2.default)(this,AnimatedTracking);_this=_callSuper(this,AnimatedTracking);_this._value=value;_this._parent=parent;_this._animationClass=animationClass;_this._animationConfig=animationConfig;_this._useNativeDriver=_NativeAnimatedHelper.default.shouldUseNativeDriver(animationConfig);_this._callback=callback;_this.__attach();return _this;}(0,_inherits2.default)(AnimatedTracking,_AnimatedNode);return(0,_createClass2.default)(AnimatedTracking,[{key:"__makeNative",value:function __makeNative(platformConfig){this.__isNative=true;this._parent.__makeNative(platformConfig);_superPropGet(AnimatedTracking,"__makeNative",this,3)([platformConfig]);this._value.__makeNative(platformConfig);}},{key:"__getValue",value:function __getValue(){return this._parent.__getValue();}},{key:"__attach",value:function __attach(){this._parent.__addChild(this);if(this._useNativeDriver){var platformConfig=this._animationConfig.platformConfig;this.__makeNative(platformConfig);}}},{key:"__detach",value:function __detach(){this._parent.__removeChild(this);_superPropGet(AnimatedTracking,"__detach",this,3)([]);}},{key:"update",value:function update(){this._value.animate(new this._animationClass(Object.assign({},this._animationConfig,{toValue:this._animationConfig.toValue.__getValue()})),this._callback);}},{key:"__getNativeConfig",value:function __getNativeConfig(){var animation=new this._animationClass(Object.assign({},this._animationConfig,{toValue:undefined}));var animationConfig=animation.__getNativeAnimationConfig();return{type:'tracking',animationId:_NativeAnimatedHelper.default.generateNewAnimationId(),animationConfig:animationConfig,toValue:this._parent.__getNativeTag(),value:this._value.__getNativeTag()};}}]);}(_AnimatedNode2.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 1922:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _slicedToArray2=_interopRequireDefault(__webpack_require__(5715));var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _NativeAnimatedHelper=_interopRequireDefault(__webpack_require__(6681));var _AnimatedNode=_interopRequireDefault(__webpack_require__(244));var _AnimatedWithChildren2=_interopRequireDefault(__webpack_require__(6023));function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}var AnimatedTransform=exports["default"]=function(_AnimatedWithChildren){function AnimatedTransform(transforms){var _this;(0,_classCallCheck2.default)(this,AnimatedTransform);_this=_callSuper(this,AnimatedTransform);_this._transforms=transforms;return _this;}(0,_inherits2.default)(AnimatedTransform,_AnimatedWithChildren);return(0,_createClass2.default)(AnimatedTransform,[{key:"__makeNative",value:function __makeNative(platformConfig){this._transforms.forEach(function(transform){for(var key in transform){var value=transform[key];if(value instanceof _AnimatedNode.default){value.__makeNative(platformConfig);}}});_superPropGet(AnimatedTransform,"__makeNative",this,3)([platformConfig]);}},{key:"__getValue",value:function __getValue(){return this._get(function(animatedNode){return animatedNode.__getValue();});}},{key:"__getAnimatedValue",value:function __getAnimatedValue(){return this._get(function(animatedNode){return animatedNode.__getAnimatedValue();});}},{key:"__attach",value:function __attach(){var _this2=this;this._transforms.forEach(function(transform){for(var key in transform){var value=transform[key];if(value instanceof _AnimatedNode.default){value.__addChild(_this2);}}});}},{key:"__detach",value:function __detach(){var _this3=this;this._transforms.forEach(function(transform){for(var key in transform){var value=transform[key];if(value instanceof _AnimatedNode.default){value.__removeChild(_this3);}}});_superPropGet(AnimatedTransform,"__detach",this,3)([]);}},{key:"__getNativeConfig",value:function __getNativeConfig(){var transConfigs=[];this._transforms.forEach(function(transform){for(var key in transform){var value=transform[key];if(value instanceof _AnimatedNode.default){transConfigs.push({type:'animated',property:key,nodeTag:value.__getNativeTag()});}else{transConfigs.push({type:'static',property:key,value:_NativeAnimatedHelper.default.transformDataType(value)});}}});_NativeAnimatedHelper.default.validateTransform(transConfigs);return{type:'transform',transforms:transConfigs};}},{key:"_get",value:function _get(getter){return this._transforms.map(function(transform){var result={};for(var key in transform){var value=transform[key];if(value instanceof _AnimatedNode.default){result[key]=getter(value);}else if(Array.isArray(value)){result[key]=value.map(function(element){if(element instanceof _AnimatedNode.default){return getter(element);}else{return element;}});}else if(typeof value==='object'){result[key]={};for(var _ref of Object.entries(value)){var _ref2=(0,_slicedToArray2.default)(_ref,2);var nestedKey=_ref2[0];var nestedValue=_ref2[1];if(nestedValue instanceof _AnimatedNode.default){result[key][nestedKey]=getter(nestedValue);}else{result[key][nestedKey]=nestedValue;}}}else{result[key]=value;}}return result;});}}]);}(_AnimatedWithChildren2.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 9579:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;exports.flushValue=flushValue;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _InteractionManager=_interopRequireDefault(__webpack_require__(4999));var _NativeAnimatedHelper=_interopRequireDefault(__webpack_require__(6681));var _AnimatedInterpolation=_interopRequireDefault(__webpack_require__(3636));var _AnimatedWithChildren2=_interopRequireDefault(__webpack_require__(6023));function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}var NativeAnimatedAPI=_NativeAnimatedHelper.default.API;function flushValue(rootNode){var leaves=new Set();function findAnimatedStyles(node){if(typeof node.update==='function'){leaves.add(node);}else{node.__getChildren().forEach(findAnimatedStyles);}}findAnimatedStyles(rootNode);leaves.forEach(function(leaf){return leaf.update();});}function _executeAsAnimatedBatch(id,operation){NativeAnimatedAPI.setWaitingForIdentifier(id);operation();NativeAnimatedAPI.unsetWaitingForIdentifier(id);}var AnimatedValue=exports["default"]=function(_AnimatedWithChildren){function AnimatedValue(value,config){var _this;(0,_classCallCheck2.default)(this,AnimatedValue);_this=_callSuper(this,AnimatedValue);if(typeof value!=='number'){throw new Error('AnimatedValue: Attempting to set value to undefined');}_this._startingValue=_this._value=value;_this._offset=0;_this._animation=null;if(config&&config.useNativeDriver){_this.__makeNative();}return _this;}(0,_inherits2.default)(AnimatedValue,_AnimatedWithChildren);return(0,_createClass2.default)(AnimatedValue,[{key:"__detach",value:function __detach(){var _this2=this;if(this.__isNative){NativeAnimatedAPI.getValue(this.__getNativeTag(),function(value){_this2._value=value-_this2._offset;});}this.stopAnimation();_superPropGet(AnimatedValue,"__detach",this,3)([]);}},{key:"__getValue",value:function __getValue(){return this._value+this._offset;}},{key:"setValue",value:function setValue(value){var _this3=this;if(this._animation){this._animation.stop();this._animation=null;}this._updateValue(value,!this.__isNative);if(this.__isNative){_executeAsAnimatedBatch(this.__getNativeTag().toString(),function(){return NativeAnimatedAPI.setAnimatedNodeValue(_this3.__getNativeTag(),value);});}}},{key:"setOffset",value:function setOffset(offset){this._offset=offset;if(this.__isNative){NativeAnimatedAPI.setAnimatedNodeOffset(this.__getNativeTag(),offset);}}},{key:"flattenOffset",value:function flattenOffset(){this._value+=this._offset;this._offset=0;if(this.__isNative){NativeAnimatedAPI.flattenAnimatedNodeOffset(this.__getNativeTag());}}},{key:"extractOffset",value:function extractOffset(){this._offset+=this._value;this._value=0;if(this.__isNative){NativeAnimatedAPI.extractAnimatedNodeOffset(this.__getNativeTag());}}},{key:"stopAnimation",value:function stopAnimation(callback){this.stopTracking();this._animation&&this._animation.stop();this._animation=null;if(callback){if(this.__isNative){NativeAnimatedAPI.getValue(this.__getNativeTag(),callback);}else{callback(this.__getValue());}}}},{key:"resetAnimation",value:function resetAnimation(callback){this.stopAnimation(callback);this._value=this._startingValue;if(this.__isNative){NativeAnimatedAPI.setAnimatedNodeValue(this.__getNativeTag(),this._startingValue);}}},{key:"__onAnimatedValueUpdateReceived",value:function __onAnimatedValueUpdateReceived(value){this._updateValue(value,false);}},{key:"interpolate",value:function interpolate(config){return new _AnimatedInterpolation.default(this,config);}},{key:"animate",value:function animate(animation,callback){var _this4=this;var handle=null;if(animation.__isInteraction){handle=_InteractionManager.default.createInteractionHandle();}var previousAnimation=this._animation;this._animation&&this._animation.stop();this._animation=animation;animation.start(this._value,function(value){_this4._updateValue(value,true);},function(result){_this4._animation=null;if(handle!==null){_InteractionManager.default.clearInteractionHandle(handle);}callback&&callback(result);},previousAnimation,this);}},{key:"stopTracking",value:function stopTracking(){this._tracking&&this._tracking.__detach();this._tracking=null;}},{key:"track",value:function track(tracking){this.stopTracking();this._tracking=tracking;this._tracking&&this._tracking.update();}},{key:"_updateValue",value:function _updateValue(value,flush){if(value===undefined){throw new Error('AnimatedValue: Attempting to set value to undefined');}this._value=value;if(flush){flushValue(this);}this.__callListeners(this.__getValue());}},{key:"__getNativeConfig",value:function __getNativeConfig(){return{type:'value',value:this._value,offset:this._offset};}}]);}(_AnimatedWithChildren2.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 4420:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _AnimatedValue=_interopRequireDefault(__webpack_require__(9579));var _AnimatedWithChildren2=_interopRequireDefault(__webpack_require__(6023));var _invariant=_interopRequireDefault(__webpack_require__(311));function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}var _uniqueId=1;var AnimatedValueXY=exports["default"]=function(_AnimatedWithChildren){function AnimatedValueXY(valueIn,config){var _this;(0,_classCallCheck2.default)(this,AnimatedValueXY);_this=_callSuper(this,AnimatedValueXY);var value=valueIn||{x:0,y:0};if(typeof value.x==='number'&&typeof value.y==='number'){_this.x=new _AnimatedValue.default(value.x);_this.y=new _AnimatedValue.default(value.y);}else{(0,_invariant.default)(value.x instanceof _AnimatedValue.default&&value.y instanceof _AnimatedValue.default,'AnimatedValueXY must be initialized with an object of numbers or '+'AnimatedValues.');_this.x=value.x;_this.y=value.y;}_this._listeners={};if(config&&config.useNativeDriver){_this.__makeNative();}return _this;}(0,_inherits2.default)(AnimatedValueXY,_AnimatedWithChildren);return(0,_createClass2.default)(AnimatedValueXY,[{key:"setValue",value:function setValue(value){this.x.setValue(value.x);this.y.setValue(value.y);}},{key:"setOffset",value:function setOffset(offset){this.x.setOffset(offset.x);this.y.setOffset(offset.y);}},{key:"flattenOffset",value:function flattenOffset(){this.x.flattenOffset();this.y.flattenOffset();}},{key:"extractOffset",value:function extractOffset(){this.x.extractOffset();this.y.extractOffset();}},{key:"__getValue",value:function __getValue(){return{x:this.x.__getValue(),y:this.y.__getValue()};}},{key:"resetAnimation",value:function resetAnimation(callback){this.x.resetAnimation();this.y.resetAnimation();callback&&callback(this.__getValue());}},{key:"stopAnimation",value:function stopAnimation(callback){this.x.stopAnimation();this.y.stopAnimation();callback&&callback(this.__getValue());}},{key:"addListener",value:function addListener(callback){var _this2=this;var id=String(_uniqueId++);var jointCallback=function jointCallback(_ref){var number=_ref.value;callback(_this2.__getValue());};this._listeners[id]={x:this.x.addListener(jointCallback),y:this.y.addListener(jointCallback)};return id;}},{key:"removeListener",value:function removeListener(id){this.x.removeListener(this._listeners[id].x);this.y.removeListener(this._listeners[id].y);delete this._listeners[id];}},{key:"removeAllListeners",value:function removeAllListeners(){this.x.removeAllListeners();this.y.removeAllListeners();this._listeners={};}},{key:"getLayout",value:function getLayout(){return{left:this.x,top:this.y};}},{key:"getTranslateTransform",value:function getTranslateTransform(){return[{translateX:this.x},{translateY:this.y}];}},{key:"__attach",value:function __attach(){this.x.__addChild(this);this.y.__addChild(this);_superPropGet(AnimatedValueXY,"__attach",this,3)([]);}},{key:"__detach",value:function __detach(){this.x.__removeChild(this);this.y.__removeChild(this);_superPropGet(AnimatedValueXY,"__detach",this,3)([]);}},{key:"__makeNative",value:function __makeNative(platformConfig){this.x.__makeNative(platformConfig);this.y.__makeNative(platformConfig);_superPropGet(AnimatedValueXY,"__makeNative",this,3)([platformConfig]);}}]);}(_AnimatedWithChildren2.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 6023:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _get2=_interopRequireDefault(__webpack_require__(2395));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _NativeAnimatedHelper=_interopRequireDefault(__webpack_require__(6681));var _AnimatedNode2=_interopRequireDefault(__webpack_require__(244));function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function _superPropGet(t,e,o,r){var p=(0,_get2.default)((0,_getPrototypeOf2.default)(1&r?t.prototype:t),e,o);return 2&r&&"function"==typeof p?function(t){return p.apply(o,t);}:p;}var AnimatedWithChildren=exports["default"]=function(_AnimatedNode){function AnimatedWithChildren(){var _this;(0,_classCallCheck2.default)(this,AnimatedWithChildren);_this=_callSuper(this,AnimatedWithChildren);_this._children=[];return _this;}(0,_inherits2.default)(AnimatedWithChildren,_AnimatedNode);return(0,_createClass2.default)(AnimatedWithChildren,[{key:"__makeNative",value:function __makeNative(platformConfig){if(!this.__isNative){this.__isNative=true;for(var child of this._children){child.__makeNative(platformConfig);_NativeAnimatedHelper.default.API.connectAnimatedNodes(this.__getNativeTag(),child.__getNativeTag());}}_superPropGet(AnimatedWithChildren,"__makeNative",this,3)([platformConfig]);}},{key:"__addChild",value:function __addChild(child){if(this._children.length===0){this.__attach();}this._children.push(child);if(this.__isNative){child.__makeNative(this.__getPlatformConfig());_NativeAnimatedHelper.default.API.connectAnimatedNodes(this.__getNativeTag(),child.__getNativeTag());}}},{key:"__removeChild",value:function __removeChild(child){var index=this._children.indexOf(child);if(index===-1){console.warn("Trying to remove a child that doesn't exist");return;}if(this.__isNative&&child.__isNative){_NativeAnimatedHelper.default.API.disconnectAnimatedNodes(this.__getNativeTag(),child.__getNativeTag());}this._children.splice(index,1);if(this._children.length===0){this.__detach();}}},{key:"__getChildren",value:function __getChildren(){return this._children;}},{key:"__callListeners",value:function __callListeners(value){_superPropGet(AnimatedWithChildren,"__callListeners",this,3)([value]);if(!this.__isNative){for(var child of this._children){if(child.__getValue){child.__callListeners(child.__getValue());}}}}}]);}(_AnimatedNode2.default);
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 5567:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=useAnimatedProps;var _slicedToArray2=_interopRequireDefault(__webpack_require__(5715));var _ReactFabricPublicInstanceUtils=__webpack_require__(7218);var _useRefEffect=_interopRequireDefault(__webpack_require__(2234));var _AnimatedEvent=__webpack_require__(8844);var _NativeAnimatedHelper=_interopRequireDefault(__webpack_require__(6681));var _AnimatedProps=_interopRequireDefault(__webpack_require__(3728));var _react=__webpack_require__(6540);function useAnimatedProps(props){var _useReducer=(0,_react.useReducer)(function(count){return count+1;},0),_useReducer2=(0,_slicedToArray2.default)(_useReducer,2),scheduleUpdate=_useReducer2[1];var onUpdateRef=(0,_react.useRef)(null);var node=(0,_react.useMemo)(function(){return new _AnimatedProps.default(props,function(){return onUpdateRef.current==null?void 0:onUpdateRef.current();});},[props]);useAnimatedPropsLifecycle(node);var refEffect=(0,_react.useCallback)(function(instance){node.setNativeView(instance);onUpdateRef.current=function(){if( false||typeof instance!=='object'||typeof(instance==null?void 0:instance.setNativeProps)!=='function'||isFabricInstance(instance)){scheduleUpdate();}else if(!node.__isNative){instance.setNativeProps(node.__getAnimatedValue());}else{throw new Error('Attempting to run JS driven animation on animated node '+'that has been moved to "native" earlier by starting an '+'animation with `useNativeDriver: true`');}};var target=getEventTarget(instance);var events=[];for(var propName in props){var propValue=props[propName];if(propValue instanceof _AnimatedEvent.AnimatedEvent&&propValue.__isNative){propValue.__attach(target,propName);events.push([propName,propValue]);}}return function(){onUpdateRef.current=null;for(var _ref of events){var _ref2=(0,_slicedToArray2.default)(_ref,2);var _propName=_ref2[0];var _propValue=_ref2[1];_propValue.__detach(target,_propName);}};},[props,node]);var callbackRef=(0,_useRefEffect.default)(refEffect);return[reduceAnimatedProps(node),callbackRef];}function reduceAnimatedProps(node){return Object.assign({},node.__getValue(),{collapsable:false});}function useAnimatedPropsLifecycle(node){var prevNodeRef=(0,_react.useRef)(null);var isUnmountingRef=(0,_react.useRef)(false);(0,_react.useEffect)(function(){_NativeAnimatedHelper.default.API.flushQueue();});(0,_react.useLayoutEffect)(function(){isUnmountingRef.current=false;return function(){isUnmountingRef.current=true;};},[]);(0,_react.useLayoutEffect)(function(){node.__attach();if(prevNodeRef.current!=null){var prevNode=prevNodeRef.current;prevNode.__restoreDefaultValues();prevNode.__detach();prevNodeRef.current=null;}return function(){if(isUnmountingRef.current){node.__detach();}else{prevNodeRef.current=node;}};},[node]);}function getEventTarget(instance){return typeof instance==='object'&&typeof(instance==null?void 0:instance.getScrollableNode)==='function'?instance.getScrollableNode():instance;}function isFabricInstance(instance){var _instance$getScrollRe;return(0,_ReactFabricPublicInstanceUtils.isPublicInstance)(instance)||(0,_ReactFabricPublicInstanceUtils.isPublicInstance)(instance==null?void 0:instance.getNativeScrollRef==null?void 0:instance.getNativeScrollRef())||(0,_ReactFabricPublicInstanceUtils.isPublicInstance)(instance==null?void 0:instance.getScrollResponder==null?void 0:(_instance$getScrollRe=instance.getScrollResponder())==null?void 0:_instance$getScrollRe.getNativeScrollRef==null?void 0:_instance$getScrollRe.getNativeScrollRef());}
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 176:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var __webpack_unused_export__;
var _interopRequireDefault=__webpack_require__(4994);__webpack_unused_export__ = ({value:true});exports.A=useAnimatedValue;var _Animated=_interopRequireDefault(__webpack_require__(8886));var _react=__webpack_require__(6540);function useAnimatedValue(initialValue,config){var ref=(0,_react.useRef)(null);if(ref.current==null){ref.current=new _Animated.default.Value(initialValue,config);}return ref.current;}
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 9800:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _NativeEventEmitter=_interopRequireDefault(__webpack_require__(6107));var _logError=_interopRequireDefault(__webpack_require__(7556));var _Platform=_interopRequireDefault(__webpack_require__(8192));var _NativeAppState=_interopRequireDefault(__webpack_require__(3835));var AppState=function(){function AppState(){var _this=this;(0,_classCallCheck2.default)(this,AppState);this.currentState=null;if(_NativeAppState.default==null){this.isAvailable=false;}else{this.isAvailable=true;var emitter=new _NativeEventEmitter.default(_Platform.default.OS!=='ios'?null:_NativeAppState.default);this._emitter=emitter;this.currentState=_NativeAppState.default.getConstants().initialAppState;var eventUpdated=false;emitter.addListener('appStateDidChange',function(appStateData){eventUpdated=true;_this.currentState=appStateData.app_state;});_NativeAppState.default.getCurrentAppState(function(appStateData){if(!eventUpdated&&_this.currentState!==appStateData.app_state){_this.currentState=appStateData.app_state;emitter.emit('appStateDidChange',appStateData);}},_logError.default);}}return(0,_createClass2.default)(AppState,[{key:"addEventListener",value:function addEventListener(type,handler){var emitter=this._emitter;if(emitter==null){throw new Error('Cannot use AppState when `isAvailable` is false.');}switch(type){case'change':var changeHandler=handler;return emitter.addListener('appStateDidChange',function(appStateData){changeHandler(appStateData.app_state);});case'memoryWarning':var memoryWarningHandler=handler;return emitter.addListener('memoryWarning',memoryWarningHandler);case'blur':case'focus':var focusOrBlurHandler=handler;return emitter.addListener('appStateFocusChange',function(hasFocus){if(type==='blur'&&!hasFocus){focusOrBlurHandler();}if(type==='focus'&&hasFocus){focusOrBlurHandler();}});}throw new Error('Trying to subscribe to unknown event: '+type);}}]);}();module.exports=new AppState();
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 3835:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var TurboModuleRegistry=_interopRequireWildcard(__webpack_require__(5333));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var _default=exports["default"]=TurboModuleRegistry.getEnforcing('AppState');
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 1270:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var MessageQueue=__webpack_require__(242);var BatchedBridge=new MessageQueue();Object.defineProperty(__webpack_require__.g,'__fbBatchedBridge',{configurable:true,value:BatchedBridge});module.exports=BatchedBridge;
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 242:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _toConsumableArray2=_interopRequireDefault(__webpack_require__(1132));var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var Systrace=__webpack_require__(8040);var deepFreezeAndThrowOnMutationInDev=__webpack_require__(6676);var stringifySafe=(__webpack_require__(3130)/* ["default"] */ .Ay);var warnOnce=__webpack_require__(485);var ErrorUtils=__webpack_require__(5775);var invariant=__webpack_require__(311);var TO_JS=0;var TO_NATIVE=1;var MODULE_IDS=0;var METHOD_IDS=1;var PARAMS=2;var MIN_TIME_BETWEEN_FLUSHES_MS=5;var TRACE_TAG_REACT_APPS=(/* unused pure expression or super */ null && (1<<17));var DEBUG_INFO_LIMIT=32;var MessageQueue=function(){function MessageQueue(){(0,_classCallCheck2.default)(this,MessageQueue);this._lazyCallableModules={};this._queue=[[],[],[],0];this._successCallbacks=new Map();this._failureCallbacks=new Map();this._callID=0;this._lastFlush=0;this._eventLoopStartTime=Date.now();this._reactNativeMicrotasksCallback=null;if(false){}this.callFunctionReturnFlushedQueue=this.callFunctionReturnFlushedQueue.bind(this);this.flushedQueue=this.flushedQueue.bind(this);this.invokeCallbackAndReturnFlushedQueue=this.invokeCallbackAndReturnFlushedQueue.bind(this);}return(0,_createClass2.default)(MessageQueue,[{key:"callFunctionReturnFlushedQueue",value:function callFunctionReturnFlushedQueue(module,method,args){var _this=this;this.__guard(function(){_this.__callFunction(module,method,args);});return this.flushedQueue();}},{key:"invokeCallbackAndReturnFlushedQueue",value:function invokeCallbackAndReturnFlushedQueue(cbID,args){var _this2=this;this.__guard(function(){_this2.__invokeCallback(cbID,args);});return this.flushedQueue();}},{key:"flushedQueue",value:function flushedQueue(){var _this3=this;this.__guard(function(){_this3.__callReactNativeMicrotasks();});var queue=this._queue;this._queue=[[],[],[],this._callID];return queue[0].length?queue:null;}},{key:"getEventLoopRunningTime",value:function getEventLoopRunningTime(){return Date.now()-this._eventLoopStartTime;}},{key:"registerCallableModule",value:function registerCallableModule(name,module){this._lazyCallableModules[name]=function(){return module;};}},{key:"registerLazyCallableModule",value:function registerLazyCallableModule(name,factory){var module;var getValue=factory;this._lazyCallableModules[name]=function(){if(getValue){module=getValue();getValue=null;}return module;};}},{key:"getCallableModule",value:function getCallableModule(name){var getValue=this._lazyCallableModules[name];return getValue?getValue():null;}},{key:"callNativeSyncHook",value:function callNativeSyncHook(moduleID,methodID,params,onFail,onSucc){if(false){}this.processCallbacks(moduleID,methodID,params,onFail,onSucc);return __webpack_require__.g.nativeCallSyncHook(moduleID,methodID,params);}},{key:"processCallbacks",value:function processCallbacks(moduleID,methodID,params,onFail,onSucc){var _this4=this;if(onFail||onSucc){if(false){ var info; }onFail&&params.push(this._callID<<1);onSucc&&params.push(this._callID<<1|1);this._successCallbacks.set(this._callID,onSucc);this._failureCallbacks.set(this._callID,onFail);}if(false){}this._callID++;}},{key:"enqueueNativeCall",value:function enqueueNativeCall(moduleID,methodID,params,onFail,onSucc){this.processCallbacks(moduleID,methodID,params,onFail,onSucc);this._queue[MODULE_IDS].push(moduleID);this._queue[METHOD_IDS].push(methodID);if(false){ var replacer, _isValidArgument; }this._queue[PARAMS].push(params);var now=Date.now();if(__webpack_require__.g.nativeFlushQueueImmediate&&now-this._lastFlush>=MIN_TIME_BETWEEN_FLUSHES_MS){var queue=this._queue;this._queue=[[],[],[],this._callID];this._lastFlush=now;__webpack_require__.g.nativeFlushQueueImmediate(queue);}Systrace.counterEvent('pending_js_to_native_queue',this._queue[0].length);if(false){}else if(this.__spy){this.__spy({type:TO_NATIVE,module:moduleID+'',method:methodID,args:params});}}},{key:"createDebugLookup",value:function createDebugLookup(moduleID,name,methods){if(false){}}},{key:"setReactNativeMicrotasksCallback",value:function setReactNativeMicrotasksCallback(fn){this._reactNativeMicrotasksCallback=fn;}},{key:"__guard",value:function __guard(fn){if(this.__shouldPauseOnThrow()){fn();}else{try{fn();}catch(error){ErrorUtils.reportFatalError(error);}}}},{key:"__shouldPauseOnThrow",value:function __shouldPauseOnThrow(){return(typeof DebuggerInternal!=='undefined'&&DebuggerInternal.shouldPauseOnThrow===true);}},{key:"__callReactNativeMicrotasks",value:function __callReactNativeMicrotasks(){Systrace.beginEvent('JSTimers.callReactNativeMicrotasks()');if(this._reactNativeMicrotasksCallback!=null){this._reactNativeMicrotasksCallback();}Systrace.endEvent();}},{key:"__callFunction",value:function __callFunction(module,method,args){this._lastFlush=Date.now();this._eventLoopStartTime=this._lastFlush;if( false||this.__spy){Systrace.beginEvent(`${module}.${method}(${stringifySafe(args)})`);}else{Systrace.beginEvent(`${module}.${method}(...)`);}if(this.__spy){this.__spy({type:TO_JS,module:module,method:method,args:args});}var moduleMethods=this.getCallableModule(module);if(!moduleMethods){var callableModuleNames=Object.keys(this._lazyCallableModules);var n=callableModuleNames.length;var callableModuleNameList=callableModuleNames.join(', ');var isBridgelessMode=__webpack_require__.g.RN$Bridgeless===true?'true':'false';invariant(false,`Failed to call into JavaScript module method ${module}.${method}(). Module has not been registered as callable. Bridgeless Mode: ${isBridgelessMode}. Registered callable JavaScript modules (n = ${n}): ${callableModuleNameList}.
A frequent cause of the error is that the application entry file path is incorrect. This can also happen when the JS bundle is corrupt or there is an early initialization error when loading React Native.`);}if(!moduleMethods[method]){invariant(false,`Failed to call into JavaScript module method ${module}.${method}(). Module exists, but the method is undefined.`);}moduleMethods[method].apply(moduleMethods,args);Systrace.endEvent();}},{key:"__invokeCallback",value:function __invokeCallback(cbID,args){this._lastFlush=Date.now();this._eventLoopStartTime=this._lastFlush;var callID=cbID>>>1;var isSuccess=cbID&1;var callback=isSuccess?this._successCallbacks.get(callID):this._failureCallbacks.get(callID);if(false){ var profileName, method, _module, debug; }if(!callback){return;}this._successCallbacks.delete(callID);this._failureCallbacks.delete(callID);callback.apply(void 0,(0,_toConsumableArray2.default)(args));if(false){}}}],[{key:"spy",value:function spy(spyOrToggle){if(spyOrToggle===true){MessageQueue.prototype.__spy=function(info){console.log(`${info.type===TO_JS?'N->JS':'JS->N'} : `+`${info.module!=null?info.module+'.':''}${info.method}`+`(${JSON.stringify(info.args)})`);};}else if(spyOrToggle===false){MessageQueue.prototype.__spy=null;}else{MessageQueue.prototype.__spy=spyOrToggle;}}}]);}();module.exports=MessageQueue;
};
}
}
}
}).call(__webpack_require__._LM_("4", { __webpack_require__,module}))()
/***/ }),
/***/ 4558:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _slicedToArray2=_interopRequireDefault(__webpack_require__(5715));var BatchedBridge=__webpack_require__(1270);var invariant=__webpack_require__(311);function genModule(config,moduleID){if(!config){return null;}var _config=(0,_slicedToArray2.default)(config,5),moduleName=_config[0],constants=_config[1],methods=_config[2],promiseMethods=_config[3],syncMethods=_config[4];invariant(!moduleName.startsWith('RCT')&&!moduleName.startsWith('RK'),"Module name prefixes should've been stripped by the native side "+"but wasn't for "+moduleName);if(!constants&&!methods){return{name:moduleName};}var module={};methods&&methods.forEach(function(methodName,methodID){var isPromise=promiseMethods&&arrayContains(promiseMethods,methodID)||false;var isSync=syncMethods&&arrayContains(syncMethods,methodID)||false;invariant(!isPromise||!isSync,'Cannot have a method that is both async and a sync hook');var methodType=isPromise?'promise':isSync?'sync':'async';module[methodName]=genMethod(moduleID,methodID,methodType);});Object.assign(module,constants);if(module.getConstants==null){module.getConstants=function(){return constants||Object.freeze({});};}else{console.warn(`Unable to define method 'getConstants()' on NativeModule '${moduleName}'. NativeModule '${moduleName}' already has a constant or method called 'getConstants'. Please remove it.`);}if(false){}return{name:moduleName,module:module};}__webpack_require__.g.__fbGenNativeModule=genModule;function loadModule(name,moduleID){invariant(__webpack_require__.g.nativeRequireModuleConfig,"Can't lazily create module without nativeRequireModuleConfig");var config=__webpack_require__.g.nativeRequireModuleConfig(name);var info=genModule(config,moduleID);return info&&info.module;}function genMethod(moduleID,methodID,type){var fn=null;if(type==='promise'){fn=function promiseMethodWrapper(){for(var _len=arguments.length,args=new Array(_len),_key=0;_key<_len;_key++){args[_key]=arguments[_key];}var enqueueingFrameError=new Error();return new Promise(function(resolve,reject){BatchedBridge.enqueueNativeCall(moduleID,methodID,args,function(data){return resolve(data);},function(errorData){return reject(updateErrorWithErrorData(errorData,enqueueingFrameError));});});};}else{fn=function nonPromiseMethodWrapper(){for(var _len2=arguments.length,args=new Array(_len2),_key2=0;_key2<_len2;_key2++){args[_key2]=arguments[_key2];}var lastArg=args.length>0?args[args.length-1]:null;var secondLastArg=args.length>1?args[args.length-2]:null;var hasSuccessCallback=typeof lastArg==='function';var hasErrorCallback=typeof secondLastArg==='function';hasErrorCallback&&invariant(hasSuccessCallback,'Cannot have a non-function arg after a function arg.');var onSuccess=hasSuccessCallback?lastArg:null;var onFail=hasErrorCallback?secondLastArg:null;var callbackCount=hasSuccessCallback+hasErrorCallback;var newArgs=args.slice(0,args.length-callbackCount);if(type==='sync'){return BatchedBridge.callNativeSyncHook(moduleID,methodID,newArgs,onFail,onSuccess);}else{BatchedBridge.enqueueNativeCall(moduleID,methodID,newArgs,onFail,onSuccess);}};}fn.type=type;return fn;}function arrayContains(array,value){return array.indexOf(value)!==-1;}function updateErrorWithErrorData(errorData,error){return Object.assign(error,errorData||{});}var NativeModules={};if(__webpack_require__.g.nativeModuleProxy){NativeModules=__webpack_require__.g.nativeModuleProxy;}else if(!__webpack_require__.g.nativeExtensions){var bridgeConfig=__webpack_require__.g.__fbBatchedBridgeConfig;invariant(bridgeConfig,'__fbBatchedBridgeConfig is not set, cannot invoke native modules');var defineLazyObjectProperty=__webpack_require__(2775);(bridgeConfig.remoteModuleConfig||[]).forEach(function(config,moduleID){var info=genModule(config,moduleID);if(!info){return;}if(info.module){NativeModules[info.name]=info.module;}else{defineLazyObjectProperty(NativeModules,info.name,{get:function get(){return loadModule(info.name,moduleID);}});}});}module.exports=NativeModules;
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 9398:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var Blob=function(){function Blob(){var parts=arguments.length>0&&arguments[0]!==undefined?arguments[0]:[];var options=arguments.length>1?arguments[1]:undefined;(0,_classCallCheck2.default)(this,Blob);var BlobManager=__webpack_require__(6379);this.data=BlobManager.createFromParts(parts,options).data;}return(0,_createClass2.default)(Blob,[{key:"data",get:function get(){if(!this._data){throw new Error('Blob has been closed and is no longer available');}return this._data;},set:function set(data){this._data=data;}},{key:"slice",value:function slice(start,end){var BlobManager=__webpack_require__(6379);var _this$data=this.data,offset=_this$data.offset,size=_this$data.size;if(typeof start==='number'){if(start>size){start=size;}offset+=start;size-=start;if(typeof end==='number'){if(end<0){end=this.size+end;}if(end>this.size){end=this.size;}size=end-start;}}return BlobManager.createFromOptions({blobId:this.data.blobId,offset:offset,size:size,__collector:this.data.__collector});}},{key:"close",value:function close(){var BlobManager=__webpack_require__(6379);BlobManager.release(this.data.blobId);this.data=null;}},{key:"size",get:function get(){return this.data.size;}},{key:"type",get:function get(){return this.data.type||'';}}]);}();module.exports=Blob;
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 6379:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _NativeBlobModule=_interopRequireDefault(__webpack_require__(3037));var _invariant=_interopRequireDefault(__webpack_require__(311));var Blob=__webpack_require__(9398);var BlobRegistry=__webpack_require__(8849);function uuidv4(){return'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g,function(c){var r=Math.random()*16|0,v=c=='x'?r:r&0x3|0x8;return v.toString(16);});}function createBlobCollector(blobId){if(__webpack_require__.g.__blobCollectorProvider==null){return null;}else{return __webpack_require__.g.__blobCollectorProvider(blobId);}}var BlobManager=function(){function BlobManager(){(0,_classCallCheck2.default)(this,BlobManager);}return(0,_createClass2.default)(BlobManager,null,[{key:"createFromParts",value:function createFromParts(parts,options){(0,_invariant.default)(_NativeBlobModule.default,'NativeBlobModule is available.');var blobId=uuidv4();var items=parts.map(function(part){if(part instanceof ArrayBuffer||__webpack_require__.g.ArrayBufferView&&part instanceof __webpack_require__.g.ArrayBufferView){throw new Error("Creating blobs from 'ArrayBuffer' and 'ArrayBufferView' are not supported");}if(part instanceof Blob){return{data:part.data,type:'blob'};}else{return{data:String(part),type:'string'};}});var size=items.reduce(function(acc,curr){if(curr.type==='string'){return acc+__webpack_require__.g.unescape(encodeURI(curr.data)).length;}else{return acc+curr.data.size;}},0);_NativeBlobModule.default.createFromParts(items,blobId);return BlobManager.createFromOptions({blobId:blobId,offset:0,size:size,type:options?options.type:'',lastModified:options?options.lastModified:Date.now()});}},{key:"createFromOptions",value:function createFromOptions(options){BlobRegistry.register(options.blobId);return Object.assign(Object.create(Blob.prototype),{data:options.__collector==null?Object.assign({},options,{__collector:createBlobCollector(options.blobId)}):options});}},{key:"release",value:function release(blobId){(0,_invariant.default)(_NativeBlobModule.default,'NativeBlobModule is available.');BlobRegistry.unregister(blobId);if(BlobRegistry.has(blobId)){return;}_NativeBlobModule.default.release(blobId);}},{key:"addNetworkingHandler",value:function addNetworkingHandler(){(0,_invariant.default)(_NativeBlobModule.default,'NativeBlobModule is available.');_NativeBlobModule.default.addNetworkingHandler();}},{key:"addWebSocketHandler",value:function addWebSocketHandler(socketId){(0,_invariant.default)(_NativeBlobModule.default,'NativeBlobModule is available.');_NativeBlobModule.default.addWebSocketHandler(socketId);}},{key:"removeWebSocketHandler",value:function removeWebSocketHandler(socketId){(0,_invariant.default)(_NativeBlobModule.default,'NativeBlobModule is available.');_NativeBlobModule.default.removeWebSocketHandler(socketId);}},{key:"sendOverSocket",value:function sendOverSocket(blob,socketId){(0,_invariant.default)(_NativeBlobModule.default,'NativeBlobModule is available.');_NativeBlobModule.default.sendOverSocket(blob.data,socketId);}}]);}();BlobManager.isAvailable=!!_NativeBlobModule.default;module.exports=BlobManager;
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 8849:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var registry={};var register=function register(id){if(registry[id]){registry[id]++;}else{registry[id]=1;}};var unregister=function unregister(id){if(registry[id]){registry[id]--;if(registry[id]<=0){delete registry[id];}}};var has=function has(id){return registry[id]&&registry[id]>0;};module.exports={register:register,unregister:unregister,has:has};
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 5999:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _inherits2=_interopRequireDefault(__webpack_require__(9511));function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}var Blob=__webpack_require__(9398);var invariant=__webpack_require__(311);var File=function(_Blob){function File(parts,name,options){var _this;(0,_classCallCheck2.default)(this,File);invariant(parts!=null&&name!=null,'Failed to construct `File`: Must pass both `parts` and `name` arguments.');_this=_callSuper(this,File,[parts,options]);_this.data.name=name;return _this;}(0,_inherits2.default)(File,_Blob);return(0,_createClass2.default)(File,[{key:"name",get:function get(){invariant(this.data.name!=null,'Files must have a name set.');return this.data.name;}},{key:"lastModified",get:function get(){return this.data.lastModified||0;}}]);}(Blob);module.exports=File;
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 7104:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _NativeFileReaderModule=_interopRequireDefault(__webpack_require__(9959));var _base64Js=__webpack_require__(7526);function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}var EventTarget=__webpack_require__(4988);var READER_EVENTS=['abort','error','load','loadstart','loadend','progress'];var EMPTY=0;var LOADING=1;var DONE=2;var FileReader=function(_ref){function FileReader(){var _this;(0,_classCallCheck2.default)(this,FileReader);_this=_callSuper(this,FileReader);_this.EMPTY=EMPTY;_this.LOADING=LOADING;_this.DONE=DONE;_this._aborted=false;_this._reset();return _this;}(0,_inherits2.default)(FileReader,_ref);return(0,_createClass2.default)(FileReader,[{key:"_reset",value:function _reset(){this._readyState=EMPTY;this._error=null;this._result=null;}},{key:"_setReadyState",value:function _setReadyState(newState){this._readyState=newState;this.dispatchEvent({type:'readystatechange'});if(newState===DONE){if(this._aborted){this.dispatchEvent({type:'abort'});}else if(this._error){this.dispatchEvent({type:'error'});}else{this.dispatchEvent({type:'load'});}this.dispatchEvent({type:'loadend'});}}},{key:"readAsArrayBuffer",value:function readAsArrayBuffer(blob){var _this2=this;this._aborted=false;if(blob==null){throw new TypeError("Failed to execute 'readAsArrayBuffer' on 'FileReader': parameter 1 is not of type 'Blob'");}_NativeFileReaderModule.default.readAsDataURL(blob.data).then(function(text){if(_this2._aborted){return;}var base64=text.split(',')[1];var typedArray=(0,_base64Js.toByteArray)(base64);_this2._result=typedArray.buffer;_this2._setReadyState(DONE);},function(error){if(_this2._aborted){return;}_this2._error=error;_this2._setReadyState(DONE);});}},{key:"readAsDataURL",value:function readAsDataURL(blob){var _this3=this;this._aborted=false;if(blob==null){throw new TypeError("Failed to execute 'readAsDataURL' on 'FileReader': parameter 1 is not of type 'Blob'");}_NativeFileReaderModule.default.readAsDataURL(blob.data).then(function(text){if(_this3._aborted){return;}_this3._result=text;_this3._setReadyState(DONE);},function(error){if(_this3._aborted){return;}_this3._error=error;_this3._setReadyState(DONE);});}},{key:"readAsText",value:function readAsText(blob){var _this4=this;var encoding=arguments.length>1&&arguments[1]!==undefined?arguments[1]:'UTF-8';this._aborted=false;if(blob==null){throw new TypeError("Failed to execute 'readAsText' on 'FileReader': parameter 1 is not of type 'Blob'");}_NativeFileReaderModule.default.readAsText(blob.data,encoding).then(function(text){if(_this4._aborted){return;}_this4._result=text;_this4._setReadyState(DONE);},function(error){if(_this4._aborted){return;}_this4._error=error;_this4._setReadyState(DONE);});}},{key:"abort",value:function abort(){this._aborted=true;if(this._readyState!==EMPTY&&this._readyState!==DONE){this._reset();this._setReadyState(DONE);}this._reset();}},{key:"readyState",get:function get(){return this._readyState;}},{key:"error",get:function get(){return this._error;}},{key:"result",get:function get(){return this._result;}}]);}(EventTarget.apply(void 0,READER_EVENTS));FileReader.EMPTY=EMPTY;FileReader.LOADING=LOADING;FileReader.DONE=DONE;module.exports=FileReader;
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 3037:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var TurboModuleRegistry=_interopRequireWildcard(__webpack_require__(5333));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var NativeModule=TurboModuleRegistry.get('BlobModule');var constants=null;var NativeBlobModule=null;if(NativeModule!=null){NativeBlobModule={getConstants:function getConstants(){if(constants==null){constants=NativeModule.getConstants();}return constants;},addNetworkingHandler:function addNetworkingHandler(){NativeModule.addNetworkingHandler();},addWebSocketHandler:function addWebSocketHandler(id){NativeModule.addWebSocketHandler(id);},removeWebSocketHandler:function removeWebSocketHandler(id){NativeModule.removeWebSocketHandler(id);},sendOverSocket:function sendOverSocket(blob,socketID){NativeModule.sendOverSocket(blob,socketID);},createFromParts:function createFromParts(parts,withId){NativeModule.createFromParts(parts,withId);},release:function release(blobId){NativeModule.release(blobId);}};}var _default=exports["default"]=NativeBlobModule;
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 9959:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var TurboModuleRegistry=_interopRequireWildcard(__webpack_require__(5333));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var _default=exports["default"]=TurboModuleRegistry.getEnforcing('FileReaderModule');
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 1028:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var __webpack_unused_export__;
var _interopRequireDefault=__webpack_require__(4994);__webpack_unused_export__ = ({value:true});exports.Ip=exports.k=void 0;var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _NativeBlobModule=_interopRequireDefault(__webpack_require__(3037));var BLOB_URL_PREFIX=null;if(_NativeBlobModule.default&&typeof _NativeBlobModule.default.getConstants().BLOB_URI_SCHEME==='string'){var constants=_NativeBlobModule.default.getConstants();BLOB_URL_PREFIX=constants.BLOB_URI_SCHEME+':';if(typeof constants.BLOB_URI_HOST==='string'){BLOB_URL_PREFIX+=`//${constants.BLOB_URI_HOST}/`;}}var URLSearchParams=exports.Ip=function(){function URLSearchParams(params){var _this=this;(0,_classCallCheck2.default)(this,URLSearchParams);this._searchParams=[];if(typeof params==='object'){Object.keys(params).forEach(function(key){return _this.append(key,params[key]);});}}return(0,_createClass2.default)(URLSearchParams,[{key:"append",value:function append(key,value){this._searchParams.push([key,value]);}},{key:"delete",value:function _delete(name){throw new Error('URLSearchParams.delete is not implemented');}},{key:"get",value:function get(name){throw new Error('URLSearchParams.get is not implemented');}},{key:"getAll",value:function getAll(name){throw new Error('URLSearchParams.getAll is not implemented');}},{key:"has",value:function has(name){throw new Error('URLSearchParams.has is not implemented');}},{key:"set",value:function set(name,value){throw new Error('URLSearchParams.set is not implemented');}},{key:"sort",value:function sort(){throw new Error('URLSearchParams.sort is not implemented');}},{key:Symbol.iterator,value:function value(){return this._searchParams[Symbol.iterator]();}},{key:"toString",value:function toString(){if(this._searchParams.length===0){return'';}var last=this._searchParams.length-1;return this._searchParams.reduce(function(acc,curr,index){return acc+encodeURIComponent(curr[0])+'='+encodeURIComponent(curr[1])+(index===last?'':'&');},'');}}]);}();function validateBaseUrl(url){return /^(?:(?:(?:https?|ftp):)?\/\/)(?:(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u00a1-\uffff][a-z0-9\u00a1-\uffff_-]{0,62})?[a-z0-9\u00a1-\uffff]\.)*(?:[a-z\u00a1-\uffff]{2,}\.?))(?::\d{2,5})?(?:[/?#]\S*)?$/.test(url);}var URL=exports.k=function(){function URL(url,base){(0,_classCallCheck2.default)(this,URL);this._searchParamsInstance=null;var baseUrl=null;if(!base||validateBaseUrl(url)){this._url=url;if(!this._url.endsWith('/')){this._url+='/';}}else{if(typeof base==='string'){baseUrl=base;if(!validateBaseUrl(baseUrl)){throw new TypeError(`Invalid base URL: ${baseUrl}`);}}else{baseUrl=base.toString();}if(baseUrl.endsWith('/')){baseUrl=baseUrl.slice(0,baseUrl.length-1);}if(!url.startsWith('/')){url=`/${url}`;}if(baseUrl.endsWith(url)){url='';}this._url=`${baseUrl}${url}`;}}return(0,_createClass2.default)(URL,[{key:"hash",get:function get(){throw new Error('URL.hash is not implemented');}},{key:"host",get:function get(){throw new Error('URL.host is not implemented');}},{key:"hostname",get:function get(){throw new Error('URL.hostname is not implemented');}},{key:"href",get:function get(){return this.toString();}},{key:"origin",get:function get(){throw new Error('URL.origin is not implemented');}},{key:"password",get:function get(){throw new Error('URL.password is not implemented');}},{key:"pathname",get:function get(){throw new Error('URL.pathname not implemented');}},{key:"port",get:function get(){throw new Error('URL.port is not implemented');}},{key:"protocol",get:function get(){throw new Error('URL.protocol is not implemented');}},{key:"search",get:function get(){throw new Error('URL.search is not implemented');}},{key:"searchParams",get:function get(){if(this._searchParamsInstance==null){this._searchParamsInstance=new URLSearchParams();}return this._searchParamsInstance;}},{key:"toJSON",value:function toJSON(){return this.toString();}},{key:"toString",value:function toString(){if(this._searchParamsInstance===null){return this._url;}var instanceString=this._searchParamsInstance.toString();var separator=this._url.indexOf('?')>-1?'&':'?';return this._url+separator+instanceString;}},{key:"username",get:function get(){throw new Error('URL.username is not implemented');}}],[{key:"createObjectURL",value:function createObjectURL(blob){if(BLOB_URL_PREFIX===null){throw new Error('Cannot create URL for blob!');}return`${BLOB_URL_PREFIX}${blob.data.blobId}?offset=${blob.data.offset}&size=${blob.size}`;}},{key:"revokeObjectURL",value:function revokeObjectURL(url){}}]);}();
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 2288:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _slicedToArray2=_interopRequireDefault(__webpack_require__(5715));var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _RCTDeviceEventEmitter=_interopRequireDefault(__webpack_require__(7181));var _NativeRedBox=_interopRequireDefault(__webpack_require__(8962));var _NativeBugReporting=_interopRequireDefault(__webpack_require__(7595));function defaultExtras(){BugReporting.addFileSource('react_hierarchy.txt',function(){return __webpack_require__(9159)();});}var BugReporting=function(){function BugReporting(){(0,_classCallCheck2.default)(this,BugReporting);}return(0,_createClass2.default)(BugReporting,null,[{key:"_maybeInit",value:function _maybeInit(){if(!BugReporting._subscription){BugReporting._subscription=_RCTDeviceEventEmitter.default.addListener('collectBugExtraData',BugReporting.collectExtraData,null);defaultExtras();}if(!BugReporting._redboxSubscription){BugReporting._redboxSubscription=_RCTDeviceEventEmitter.default.addListener('collectRedBoxExtraData',BugReporting.collectExtraData,null);}}},{key:"addSource",value:function addSource(key,callback){return this._addSource(key,callback,BugReporting._extraSources);}},{key:"addFileSource",value:function addFileSource(key,callback){return this._addSource(key,callback,BugReporting._fileSources);}},{key:"_addSource",value:function _addSource(key,callback,source){BugReporting._maybeInit();if(source.has(key)){console.warn(`BugReporting.add* called multiple times for same key '${key}'`);}source.set(key,callback);return{remove:function remove(){source.delete(key);}};}},{key:"collectExtraData",value:function collectExtraData(){var extraData={};for(var _ref of BugReporting._extraSources){var _ref2=(0,_slicedToArray2.default)(_ref,2);var _key=_ref2[0];var callback=_ref2[1];extraData[_key]=callback();}var fileData={};for(var _ref3 of BugReporting._fileSources){var _ref4=(0,_slicedToArray2.default)(_ref3,2);var _key2=_ref4[0];var _callback=_ref4[1];fileData[_key2]=_callback();}if(_NativeBugReporting.default!=null&&_NativeBugReporting.default.setExtraData!=null){_NativeBugReporting.default.setExtraData(extraData,fileData);}if(_NativeRedBox.default!=null&&_NativeRedBox.default.setExtraData!=null){_NativeRedBox.default.setExtraData(extraData,'From BugReporting.js');}return{extras:extraData,files:fileData};}}]);}();BugReporting._extraSources=new Map();BugReporting._fileSources=new Map();BugReporting._subscription=null;BugReporting._redboxSubscription=null;module.exports=BugReporting;
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 7595:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var TurboModuleRegistry=_interopRequireWildcard(__webpack_require__(5333));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var _default=exports["default"]=TurboModuleRegistry.get('BugReporting');
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 9159:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
function dumpReactTree(){try{return getReactTree();}catch(e){return'Failed to dump react tree: '+e;}}function getReactTree(){return'React tree dumps have been temporarily disabled while React is '+'upgraded to Fiber.';}module.exports=dumpReactTree;
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 9853:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _RCTDeviceEventEmitter=_interopRequireDefault(__webpack_require__(7181));var _RendererProxy=__webpack_require__(8907);var _Platform=_interopRequireDefault(__webpack_require__(8192));var _legacySendAccessibilityEvent=_interopRequireDefault(__webpack_require__(7415));var _NativeAccessibilityInfo=_interopRequireDefault(__webpack_require__(9584));var _NativeAccessibilityManager=_interopRequireDefault(__webpack_require__(497));var EventNames=_Platform.default.OS==='android'?new Map([['change','touchExplorationDidChange'],['reduceMotionChanged','reduceMotionDidChange'],['screenReaderChanged','touchExplorationDidChange'],['accessibilityServiceChanged','accessibilityServiceDidChange']]):new Map([['announcementFinished','announcementFinished'],['boldTextChanged','boldTextChanged'],['change','screenReaderChanged'],['grayscaleChanged','grayscaleChanged'],['invertColorsChanged','invertColorsChanged'],['reduceMotionChanged','reduceMotionChanged'],['reduceTransparencyChanged','reduceTransparencyChanged'],['screenReaderChanged','screenReaderChanged']]);var AccessibilityInfo={isBoldTextEnabled:function isBoldTextEnabled(){if(_Platform.default.OS==='android'){return Promise.resolve(false);}else{return new Promise(function(resolve,reject){if(_NativeAccessibilityManager.default!=null){_NativeAccessibilityManager.default.getCurrentBoldTextState(resolve,reject);}else{reject(null);}});}},isGrayscaleEnabled:function isGrayscaleEnabled(){if(_Platform.default.OS==='android'){return Promise.resolve(false);}else{return new Promise(function(resolve,reject){if(_NativeAccessibilityManager.default!=null){_NativeAccessibilityManager.default.getCurrentGrayscaleState(resolve,reject);}else{reject(null);}});}},isInvertColorsEnabled:function isInvertColorsEnabled(){if(_Platform.default.OS==='android'){return Promise.resolve(false);}else{return new Promise(function(resolve,reject){if(_NativeAccessibilityManager.default!=null){_NativeAccessibilityManager.default.getCurrentInvertColorsState(resolve,reject);}else{reject(null);}});}},isReduceMotionEnabled:function isReduceMotionEnabled(){return new Promise(function(resolve,reject){if(_Platform.default.OS==='android'){if(_NativeAccessibilityInfo.default!=null){_NativeAccessibilityInfo.default.isReduceMotionEnabled(resolve);}else{reject(null);}}else{if(_NativeAccessibilityManager.default!=null){_NativeAccessibilityManager.default.getCurrentReduceMotionState(resolve,reject);}else{reject(null);}}});},prefersCrossFadeTransitions:function prefersCrossFadeTransitions(){return new Promise(function(resolve,reject){if(_Platform.default.OS==='android'){return Promise.resolve(false);}else{if((_NativeAccessibilityManager.default==null?void 0:_NativeAccessibilityManager.default.getCurrentPrefersCrossFadeTransitionsState)!=null){_NativeAccessibilityManager.default.getCurrentPrefersCrossFadeTransitionsState(resolve,reject);}else{reject(null);}}});},isReduceTransparencyEnabled:function isReduceTransparencyEnabled(){if(_Platform.default.OS==='android'){return Promise.resolve(false);}else{return new Promise(function(resolve,reject){if(_NativeAccessibilityManager.default!=null){_NativeAccessibilityManager.default.getCurrentReduceTransparencyState(resolve,reject);}else{reject(null);}});}},isScreenReaderEnabled:function isScreenReaderEnabled(){return new Promise(function(resolve,reject){if(_Platform.default.OS==='android'){if(_NativeAccessibilityInfo.default!=null){_NativeAccessibilityInfo.default.isTouchExplorationEnabled(resolve);}else{reject(null);}}else{if(_NativeAccessibilityManager.default!=null){_NativeAccessibilityManager.default.getCurrentVoiceOverState(resolve,reject);}else{reject(null);}}});},isAccessibilityServiceEnabled:function isAccessibilityServiceEnabled(){return new Promise(function(resolve,reject){if(_Platform.default.OS==='android'){if(_NativeAccessibilityInfo.default!=null&&_NativeAccessibilityInfo.default.isAccessibilityServiceEnabled!=null){_NativeAccessibilityInfo.default.isAccessibilityServiceEnabled(resolve);}else{reject(null);}}else{reject(null);}});},addEventListener:function addEventListener(eventName,handler){var deviceEventName=EventNames.get(eventName);return deviceEventName==null?{remove:function remove(){}}:_RCTDeviceEventEmitter.default.addListener(deviceEventName,handler);},setAccessibilityFocus:function setAccessibilityFocus(reactTag){(0,_legacySendAccessibilityEvent.default)(reactTag,'focus');},sendAccessibilityEvent:function sendAccessibilityEvent(handle,eventType){if(_Platform.default.OS==='ios'&&eventType==='click'){return;}(0,_RendererProxy.sendAccessibilityEvent)(handle,eventType);},announceForAccessibility:function announceForAccessibility(announcement){if(_Platform.default.OS==='android'){_NativeAccessibilityInfo.default==null?void 0:_NativeAccessibilityInfo.default.announceForAccessibility(announcement);}else{_NativeAccessibilityManager.default==null?void 0:_NativeAccessibilityManager.default.announceForAccessibility(announcement);}},announceForAccessibilityWithOptions:function announceForAccessibilityWithOptions(announcement,options){if(_Platform.default.OS==='android'){_NativeAccessibilityInfo.default==null?void 0:_NativeAccessibilityInfo.default.announceForAccessibility(announcement);}else{if(_NativeAccessibilityManager.default!=null&&_NativeAccessibilityManager.default.announceForAccessibilityWithOptions){_NativeAccessibilityManager.default==null?void 0:_NativeAccessibilityManager.default.announceForAccessibilityWithOptions(announcement,options);}else{_NativeAccessibilityManager.default==null?void 0:_NativeAccessibilityManager.default.announceForAccessibility(announcement);}}},getRecommendedTimeoutMillis:function getRecommendedTimeoutMillis(originalTimeout){if(_Platform.default.OS==='android'){return new Promise(function(resolve,reject){if(_NativeAccessibilityInfo.default!=null&&_NativeAccessibilityInfo.default.getRecommendedTimeoutMillis){_NativeAccessibilityInfo.default.getRecommendedTimeoutMillis(originalTimeout,resolve);}else{resolve(originalTimeout);}});}else{return Promise.resolve(originalTimeout);}}};var _default=exports["default"]=AccessibilityInfo;
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 9584:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var TurboModuleRegistry=_interopRequireWildcard(__webpack_require__(5333));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var _default=exports["default"]=TurboModuleRegistry.get('AccessibilityInfo');
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 497:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var TurboModuleRegistry=_interopRequireWildcard(__webpack_require__(5333));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var _default=exports["default"]=TurboModuleRegistry.get('AccessibilityManager');
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 7415:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _NativeAccessibilityManager=_interopRequireDefault(__webpack_require__(497));function legacySendAccessibilityEvent(reactTag,eventType){if(eventType==='focus'&&_NativeAccessibilityManager.default){_NativeAccessibilityManager.default.setAccessibilityFocus(reactTag);}}module.exports=legacySendAccessibilityEvent;
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 5485:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var __webpack_unused_export__;
var _interopRequireDefault=__webpack_require__(4994);__webpack_unused_export__ = ({value:true});exports.A=void 0;var _objectWithoutProperties2=_interopRequireDefault(__webpack_require__(1847));var _StyleSheet=_interopRequireDefault(__webpack_require__(6556));var _Platform=_interopRequireDefault(__webpack_require__(8192));var _View=_interopRequireDefault(__webpack_require__(101));var React=_interopRequireWildcard(__webpack_require__(6540));var _jsxRuntime=__webpack_require__(4848);var _excluded=["animating","color","hidesWhenStopped","onLayout","size","style"];function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var PlatformActivityIndicator=_Platform.default.OS==='android'?__webpack_require__(3178):(__webpack_require__(2660)/* ["default"] */ .A);var GRAY='#999999';var ActivityIndicator=function ActivityIndicator(_ref,forwardedRef){var _ref$animating=_ref.animating,animating=_ref$animating===void 0?true:_ref$animating,_ref$color=_ref.color,color=_ref$color===void 0?_Platform.default.OS==='ios'?GRAY:null:_ref$color,_ref$hidesWhenStopped=_ref.hidesWhenStopped,hidesWhenStopped=_ref$hidesWhenStopped===void 0?true:_ref$hidesWhenStopped,onLayout=_ref.onLayout,_ref$size=_ref.size,size=_ref$size===void 0?'small':_ref$size,style=_ref.style,restProps=(0,_objectWithoutProperties2.default)(_ref,_excluded);var sizeStyle;var sizeProp;switch(size){case'small':sizeStyle=styles.sizeSmall;sizeProp='small';break;case'large':sizeStyle=styles.sizeLarge;sizeProp='large';break;default:sizeStyle={height:size,width:size};break;}var nativeProps=Object.assign({animating:animating,color:color,hidesWhenStopped:hidesWhenStopped},restProps,{ref:forwardedRef,style:sizeStyle,size:sizeProp});var androidProps={styleAttr:'Normal',indeterminate:true};return(0,_jsxRuntime.jsx)(_View.default,{onLayout:onLayout,style:_StyleSheet.default.compose(styles.container,style),children:_Platform.default.OS==='android'?(0,_jsxRuntime.jsx)(PlatformActivityIndicator,Object.assign({},nativeProps,androidProps)):(0,_jsxRuntime.jsx)(PlatformActivityIndicator,Object.assign({},nativeProps))});};var ActivityIndicatorWithRef=React.forwardRef(ActivityIndicator);ActivityIndicatorWithRef.displayName='ActivityIndicator';var styles=_StyleSheet.default.create({container:{alignItems:'center',justifyContent:'center'},sizeSmall:{width:20,height:20},sizeLarge:{width:36,height:36}});var _default=exports.A=ActivityIndicatorWithRef;
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 2660:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var __webpack_unused_export__;
var _interopRequireDefault=__webpack_require__(4994);__webpack_unused_export__ = ({value:true});exports.A=void 0;var _codegenNativeComponent=_interopRequireDefault(__webpack_require__(9021));var _default=exports.A=(0,_codegenNativeComponent.default)('ActivityIndicatorView',{paperComponentName:'RCTActivityIndicatorView'});
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 1772:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _StyleSheet=_interopRequireDefault(__webpack_require__(6556));var _Text=_interopRequireDefault(__webpack_require__(7766));var _Platform=_interopRequireDefault(__webpack_require__(8192));var _TouchableNativeFeedback=_interopRequireDefault(__webpack_require__(4781));var _TouchableOpacity=_interopRequireDefault(__webpack_require__(8048));var _View=_interopRequireDefault(__webpack_require__(101));var _invariant=_interopRequireDefault(__webpack_require__(311));var React=_interopRequireWildcard(__webpack_require__(6540));var _jsxRuntime=__webpack_require__(4848);function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}var Button=function(_React$Component){function Button(){(0,_classCallCheck2.default)(this,Button);return _callSuper(this,Button,arguments);}(0,_inherits2.default)(Button,_React$Component);return(0,_createClass2.default)(Button,[{key:"render",value:function render(){var _accessibilityState2,_accessibilityState3;var _this$props=this.props,accessibilityLabel=_this$props.accessibilityLabel,accessibilityState=_this$props.accessibilityState,ariaBusy=_this$props['aria-busy'],ariaChecked=_this$props['aria-checked'],ariaDisabled=_this$props['aria-disabled'],ariaExpanded=_this$props['aria-expanded'],ariaLabel=_this$props['aria-label'],ariaSelected=_this$props['aria-selected'],importantForAccessibility=_this$props.importantForAccessibility,color=_this$props.color,onPress=_this$props.onPress,touchSoundDisabled=_this$props.touchSoundDisabled,title=_this$props.title,hasTVPreferredFocus=_this$props.hasTVPreferredFocus,nextFocusDown=_this$props.nextFocusDown,nextFocusForward=_this$props.nextFocusForward,nextFocusLeft=_this$props.nextFocusLeft,nextFocusRight=_this$props.nextFocusRight,nextFocusUp=_this$props.nextFocusUp,testID=_this$props.testID,accessible=_this$props.accessible,accessibilityActions=_this$props.accessibilityActions,accessibilityHint=_this$props.accessibilityHint,accessibilityLanguage=_this$props.accessibilityLanguage,onAccessibilityAction=_this$props.onAccessibilityAction;var buttonStyles=[styles.button];var textStyles=[styles.text];if(color){if(_Platform.default.OS==='ios'){textStyles.push({color:color});}else{buttonStyles.push({backgroundColor:color});}}var _accessibilityState={busy:ariaBusy!=null?ariaBusy:accessibilityState==null?void 0:accessibilityState.busy,checked:ariaChecked!=null?ariaChecked:accessibilityState==null?void 0:accessibilityState.checked,disabled:ariaDisabled!=null?ariaDisabled:accessibilityState==null?void 0:accessibilityState.disabled,expanded:ariaExpanded!=null?ariaExpanded:accessibilityState==null?void 0:accessibilityState.expanded,selected:ariaSelected!=null?ariaSelected:accessibilityState==null?void 0:accessibilityState.selected};var disabled=this.props.disabled!=null?this.props.disabled:(_accessibilityState2=_accessibilityState)==null?void 0:_accessibilityState2.disabled;_accessibilityState=disabled!==((_accessibilityState3=_accessibilityState)==null?void 0:_accessibilityState3.disabled)?Object.assign({},_accessibilityState,{disabled:disabled}):_accessibilityState;if(disabled){buttonStyles.push(styles.buttonDisabled);textStyles.push(styles.textDisabled);}(0,_invariant.default)(typeof title==='string','The title prop of a Button must be a string');var formattedTitle=_Platform.default.OS==='android'?title.toUpperCase():title;var Touchable=_Platform.default.OS==='android'?_TouchableNativeFeedback.default:_TouchableOpacity.default;var _importantForAccessibility=importantForAccessibility==='no'?'no-hide-descendants':importantForAccessibility;return(0,_jsxRuntime.jsx)(Touchable,{accessible:accessible,accessibilityActions:accessibilityActions,onAccessibilityAction:onAccessibilityAction,accessibilityLabel:ariaLabel||accessibilityLabel,accessibilityHint:accessibilityHint,accessibilityLanguage:accessibilityLanguage,accessibilityRole:"button",accessibilityState:_accessibilityState,importantForAccessibility:_importantForAccessibility,hasTVPreferredFocus:hasTVPreferredFocus,nextFocusDown:nextFocusDown,nextFocusForward:nextFocusForward,nextFocusLeft:nextFocusLeft,nextFocusRight:nextFocusRight,nextFocusUp:nextFocusUp,testID:testID,disabled:disabled,onPress:onPress,touchSoundDisabled:touchSoundDisabled,children:(0,_jsxRuntime.jsx)(_View.default,{style:buttonStyles,children:(0,_jsxRuntime.jsx)(_Text.default,{style:textStyles,disabled:disabled,children:formattedTitle})})});}}]);}(React.Component);var styles=_StyleSheet.default.create({button:_Platform.default.select({ios:{},android:{elevation:4,backgroundColor:'#2196F3',borderRadius:2}}),text:Object.assign({textAlign:'center',margin:8},_Platform.default.select({ios:{color:'#007AFF',fontSize:18},android:{color:'white',fontWeight:'500'}})),buttonDisabled:_Platform.default.select({ios:{},android:{elevation:0,backgroundColor:'#dfdfdf'}}),textDisabled:_Platform.default.select({ios:{color:'#cdcdcd'},android:{color:'#a1a1a1'}})});module.exports=Button;
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 393:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _NativeClipboard=_interopRequireDefault(__webpack_require__(5736));module.exports={getString:function getString(){return _NativeClipboard.default.getString();},setString:function setString(content){_NativeClipboard.default.setString(content);}};
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 5736:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var TurboModuleRegistry=_interopRequireWildcard(__webpack_require__(5333));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var _default=exports["default"]=TurboModuleRegistry.getEnforcing('Clipboard');
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 1708:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
module.exports = __webpack_require__(4742);
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 9829:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _NativeEventEmitter=_interopRequireDefault(__webpack_require__(6107));var _LayoutAnimation=_interopRequireDefault(__webpack_require__(1234));var _dismissKeyboard=_interopRequireDefault(__webpack_require__(3491));var _Platform=_interopRequireDefault(__webpack_require__(8192));var _NativeKeyboardObserver=_interopRequireDefault(__webpack_require__(2100));var Keyboard=function(){function Keyboard(){var _this=this;(0,_classCallCheck2.default)(this,Keyboard);this._emitter=new _NativeEventEmitter.default(_Platform.default.OS!=='ios'?null:_NativeKeyboardObserver.default);this.addListener('keyboardDidShow',function(ev){_this._currentlyShowing=ev;});this.addListener('keyboardDidHide',function(_ev){_this._currentlyShowing=null;});}return(0,_createClass2.default)(Keyboard,[{key:"addListener",value:function addListener(eventType,listener,context){return this._emitter.addListener(eventType,listener);}},{key:"removeAllListeners",value:function removeAllListeners(eventType){this._emitter.removeAllListeners(eventType);}},{key:"dismiss",value:function dismiss(){(0,_dismissKeyboard.default)();}},{key:"isVisible",value:function isVisible(){return!!this._currentlyShowing;}},{key:"metrics",value:function metrics(){var _this$_currentlyShowi;return(_this$_currentlyShowi=this._currentlyShowing)==null?void 0:_this$_currentlyShowi.endCoordinates;}},{key:"scheduleLayoutAnimation",value:function scheduleLayoutAnimation(event){var duration=event.duration,easing=event.easing;if(duration!=null&&duration!==0){_LayoutAnimation.default.configureNext({duration:duration,update:{duration:duration,type:easing!=null&&_LayoutAnimation.default.Types[easing]||'keyboard'}});}}}]);}();module.exports=new Keyboard();
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 4239:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var __webpack_unused_export__;
var _interopRequireDefault=__webpack_require__(4994);__webpack_unused_export__ = ({value:true});exports.A=void 0;var _objectWithoutProperties2=_interopRequireDefault(__webpack_require__(1847));var _asyncToGenerator2=_interopRequireDefault(__webpack_require__(9293));var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _LayoutAnimation=_interopRequireDefault(__webpack_require__(1234));var _StyleSheet=_interopRequireDefault(__webpack_require__(6556));var _Platform=_interopRequireDefault(__webpack_require__(8192));var _AccessibilityInfo=_interopRequireDefault(__webpack_require__(9853));var _View=_interopRequireDefault(__webpack_require__(101));var _Keyboard=_interopRequireDefault(__webpack_require__(9829));var React=_interopRequireWildcard(__webpack_require__(6540));var _jsxRuntime=__webpack_require__(4848);var _excluded=["behavior","children","contentContainerStyle","enabled","keyboardVerticalOffset","style","onLayout"];function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}var KeyboardAvoidingView=function(_React$Component){function KeyboardAvoidingView(props){var _this;(0,_classCallCheck2.default)(this,KeyboardAvoidingView);_this=_callSuper(this,KeyboardAvoidingView,[props]);_this._frame=null;_this._keyboardEvent=null;_this._subscriptions=[];_this._initialFrameHeight=0;_this._onKeyboardChange=function(event){_this._keyboardEvent=event;_this._updateBottomIfNecessary();};_this._onLayout=function(){var _ref=(0,_asyncToGenerator2.default)(function*(event){var wasFrameNull=_this._frame==null;_this._frame=event.nativeEvent.layout;if(!_this._initialFrameHeight){_this._initialFrameHeight=_this._frame.height;}if(wasFrameNull){yield _this._updateBottomIfNecessary();}if(_this.props.onLayout){_this.props.onLayout(event);}});return function(_x){return _ref.apply(this,arguments);};}();_this._updateBottomIfNecessary=(0,_asyncToGenerator2.default)(function*(){if(_this._keyboardEvent==null){_this.setState({bottom:0});return;}var _this$_keyboardEvent=_this._keyboardEvent,duration=_this$_keyboardEvent.duration,easing=_this$_keyboardEvent.easing,endCoordinates=_this$_keyboardEvent.endCoordinates;var height=yield _this._relativeKeyboardHeight(endCoordinates);if(_this.state.bottom===height){return;}if(duration&&easing){_LayoutAnimation.default.configureNext({duration:duration>10?duration:10,update:{duration:duration>10?duration:10,type:_LayoutAnimation.default.Types[easing]||'keyboard'}});}_this.setState({bottom:height});});_this.state={bottom:0};_this.viewRef=React.createRef();return _this;}(0,_inherits2.default)(KeyboardAvoidingView,_React$Component);return(0,_createClass2.default)(KeyboardAvoidingView,[{key:"_relativeKeyboardHeight",value:function(){var _relativeKeyboardHeight2=(0,_asyncToGenerator2.default)(function*(keyboardFrame){var _this$props$keyboardV;var frame=this._frame;if(!frame||!keyboardFrame){return 0;}if(_Platform.default.OS==='ios'&&keyboardFrame.screenY===0&&(yield _AccessibilityInfo.default.prefersCrossFadeTransitions())){return 0;}var keyboardY=keyboardFrame.screenY-((_this$props$keyboardV=this.props.keyboardVerticalOffset)!=null?_this$props$keyboardV:0);if(this.props.behavior==='height'){return Math.max(this.state.bottom+frame.y+frame.height-keyboardY,0);}return Math.max(frame.y+frame.height-keyboardY,0);});function _relativeKeyboardHeight(_x2){return _relativeKeyboardHeight2.apply(this,arguments);}return _relativeKeyboardHeight;}()},{key:"componentDidMount",value:function componentDidMount(){if(_Platform.default.OS==='ios'){this._subscriptions=[_Keyboard.default.addListener('keyboardWillChangeFrame',this._onKeyboardChange)];}else{this._subscriptions=[_Keyboard.default.addListener('keyboardDidHide',this._onKeyboardChange),_Keyboard.default.addListener('keyboardDidShow',this._onKeyboardChange)];}}},{key:"componentWillUnmount",value:function componentWillUnmount(){this._subscriptions.forEach(function(subscription){subscription.remove();});}},{key:"render",value:function render(){var _this$props=this.props,behavior=_this$props.behavior,children=_this$props.children,contentContainerStyle=_this$props.contentContainerStyle,_this$props$enabled=_this$props.enabled,enabled=_this$props$enabled===void 0?true:_this$props$enabled,_this$props$keyboardV2=_this$props.keyboardVerticalOffset,keyboardVerticalOffset=_this$props$keyboardV2===void 0?0:_this$props$keyboardV2,style=_this$props.style,onLayout=_this$props.onLayout,props=(0,_objectWithoutProperties2.default)(_this$props,_excluded);var bottomHeight=enabled===true?this.state.bottom:0;switch(behavior){case'height':var heightStyle;if(this._frame!=null&&this.state.bottom>0){heightStyle={height:this._initialFrameHeight-bottomHeight,flex:0};}return(0,_jsxRuntime.jsx)(_View.default,Object.assign({ref:this.viewRef,style:_StyleSheet.default.compose(style,heightStyle),onLayout:this._onLayout},props,{children:children}));case'position':return(0,_jsxRuntime.jsx)(_View.default,Object.assign({ref:this.viewRef,style:style,onLayout:this._onLayout},props,{children:(0,_jsxRuntime.jsx)(_View.default,{style:_StyleSheet.default.compose(contentContainerStyle,{bottom:bottomHeight}),children:children})}));case'padding':return(0,_jsxRuntime.jsx)(_View.default,Object.assign({ref:this.viewRef,style:_StyleSheet.default.compose(style,{paddingBottom:bottomHeight}),onLayout:this._onLayout},props,{children:children}));default:return(0,_jsxRuntime.jsx)(_View.default,Object.assign({ref:this.viewRef,onLayout:this._onLayout,style:style},props,{children:children}));}}}]);}(React.Component);var _default=exports.A=KeyboardAvoidingView;
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 2100:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var TurboModuleRegistry=_interopRequireWildcard(__webpack_require__(5333));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var _default=exports["default"]=TurboModuleRegistry.get('KeyboardObserver');
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 677:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var __webpack_unused_export__;
var _interopRequireDefault=__webpack_require__(4994);__webpack_unused_export__ = ({value:true});exports.A=void 0;var _slicedToArray2=_interopRequireDefault(__webpack_require__(5715));var _objectWithoutProperties2=_interopRequireDefault(__webpack_require__(1847));var _PressabilityDebug=__webpack_require__(831);var _usePressability=_interopRequireDefault(__webpack_require__(2861));var _View=_interopRequireDefault(__webpack_require__(101));var _useAndroidRippleForView=_interopRequireDefault(__webpack_require__(7560));var _react=_interopRequireWildcard(__webpack_require__(6540));var React=_react;var _jsxRuntime=__webpack_require__(4848);var _excluded=["accessible","accessibilityState","aria-live","android_disableSound","android_ripple","aria-busy","aria-checked","aria-disabled","aria-expanded","aria-label","aria-selected","cancelable","children","delayHoverIn","delayHoverOut","delayLongPress","disabled","focusable","hitSlop","onHoverIn","onHoverOut","onLongPress","onPress","onPressIn","onPressOut","pressRetentionOffset","style","testOnly_pressed","unstable_pressDelay"];function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}function Pressable(props,forwardedRef){var _props$ariaValuemax,_props$accessibilityV,_props$ariaValuemin,_props$accessibilityV2,_props$ariaValuenow,_props$accessibilityV3,_props$ariaValuetext,_props$accessibilityV4,_restProps$ariaModal;var accessible=props.accessible,accessibilityState=props.accessibilityState,ariaLive=props['aria-live'],android_disableSound=props.android_disableSound,android_ripple=props.android_ripple,ariaBusy=props['aria-busy'],ariaChecked=props['aria-checked'],ariaDisabled=props['aria-disabled'],ariaExpanded=props['aria-expanded'],ariaLabel=props['aria-label'],ariaSelected=props['aria-selected'],cancelable=props.cancelable,children=props.children,delayHoverIn=props.delayHoverIn,delayHoverOut=props.delayHoverOut,delayLongPress=props.delayLongPress,disabled=props.disabled,focusable=props.focusable,hitSlop=props.hitSlop,onHoverIn=props.onHoverIn,onHoverOut=props.onHoverOut,onLongPress=props.onLongPress,onPress=props.onPress,_onPressIn=props.onPressIn,_onPressOut=props.onPressOut,pressRetentionOffset=props.pressRetentionOffset,style=props.style,testOnly_pressed=props.testOnly_pressed,unstable_pressDelay=props.unstable_pressDelay,restProps=(0,_objectWithoutProperties2.default)(props,_excluded);var viewRef=(0,_react.useRef)(null);(0,_react.useImperativeHandle)(forwardedRef,function(){return viewRef.current;});var android_rippleConfig=(0,_useAndroidRippleForView.default)(android_ripple,viewRef);var _usePressState=usePressState(testOnly_pressed===true),_usePressState2=(0,_slicedToArray2.default)(_usePressState,2),pressed=_usePressState2[0],setPressed=_usePressState2[1];var _accessibilityState={busy:ariaBusy!=null?ariaBusy:accessibilityState==null?void 0:accessibilityState.busy,checked:ariaChecked!=null?ariaChecked:accessibilityState==null?void 0:accessibilityState.checked,disabled:ariaDisabled!=null?ariaDisabled:accessibilityState==null?void 0:accessibilityState.disabled,expanded:ariaExpanded!=null?ariaExpanded:accessibilityState==null?void 0:accessibilityState.expanded,selected:ariaSelected!=null?ariaSelected:accessibilityState==null?void 0:accessibilityState.selected};_accessibilityState=disabled!=null?Object.assign({},_accessibilityState,{disabled:disabled}):_accessibilityState;var accessibilityValue={max:(_props$ariaValuemax=props['aria-valuemax'])!=null?_props$ariaValuemax:(_props$accessibilityV=props.accessibilityValue)==null?void 0:_props$accessibilityV.max,min:(_props$ariaValuemin=props['aria-valuemin'])!=null?_props$ariaValuemin:(_props$accessibilityV2=props.accessibilityValue)==null?void 0:_props$accessibilityV2.min,now:(_props$ariaValuenow=props['aria-valuenow'])!=null?_props$ariaValuenow:(_props$accessibilityV3=props.accessibilityValue)==null?void 0:_props$accessibilityV3.now,text:(_props$ariaValuetext=props['aria-valuetext'])!=null?_props$ariaValuetext:(_props$accessibilityV4=props.accessibilityValue)==null?void 0:_props$accessibilityV4.text};var accessibilityLiveRegion=ariaLive==='off'?'none':ariaLive!=null?ariaLive:props.accessibilityLiveRegion;var accessibilityLabel=ariaLabel!=null?ariaLabel:props.accessibilityLabel;var restPropsWithDefaults=Object.assign({},restProps,android_rippleConfig==null?void 0:android_rippleConfig.viewProps,{accessible:accessible!==false,accessibilityViewIsModal:(_restProps$ariaModal=restProps['aria-modal'])!=null?_restProps$ariaModal:restProps.accessibilityViewIsModal,accessibilityLiveRegion:accessibilityLiveRegion,accessibilityLabel:accessibilityLabel,accessibilityState:_accessibilityState,focusable:focusable!==false,accessibilityValue:accessibilityValue,hitSlop:hitSlop});var config=(0,_react.useMemo)(function(){return{cancelable:cancelable,disabled:disabled,hitSlop:hitSlop,pressRectOffset:pressRetentionOffset,android_disableSound:android_disableSound,delayHoverIn:delayHoverIn,delayHoverOut:delayHoverOut,delayLongPress:delayLongPress,delayPressIn:unstable_pressDelay,onHoverIn:onHoverIn,onHoverOut:onHoverOut,onLongPress:onLongPress,onPress:onPress,onPressIn:function onPressIn(event){if(android_rippleConfig!=null){android_rippleConfig.onPressIn(event);}setPressed(true);if(_onPressIn!=null){_onPressIn(event);}},onPressMove:android_rippleConfig==null?void 0:android_rippleConfig.onPressMove,onPressOut:function onPressOut(event){if(android_rippleConfig!=null){android_rippleConfig.onPressOut(event);}setPressed(false);if(_onPressOut!=null){_onPressOut(event);}}};},[android_disableSound,android_rippleConfig,cancelable,delayHoverIn,delayHoverOut,delayLongPress,disabled,hitSlop,onHoverIn,onHoverOut,onLongPress,onPress,_onPressIn,_onPressOut,pressRetentionOffset,setPressed,unstable_pressDelay]);var eventHandlers=(0,_usePressability.default)(config);return(0,_jsxRuntime.jsxs)(_View.default,Object.assign({},restPropsWithDefaults,eventHandlers,{ref:viewRef,style:typeof style==='function'?style({pressed:pressed}):style,collapsable:false,children:[typeof children==='function'?children({pressed:pressed}):children, false?0:null]}));}function usePressState(forcePressed){var _useState=(0,_react.useState)(false),_useState2=(0,_slicedToArray2.default)(_useState,2),pressed=_useState2[0],setPressed=_useState2[1];return[pressed||forcePressed,setPressed];}var MemoedPressable=React.memo(React.forwardRef(Pressable));MemoedPressable.displayName='Pressable';var _default=exports.A=MemoedPressable;
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 7560:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=useAndroidRippleForView;var _processColor=_interopRequireDefault(__webpack_require__(5372));var _Platform=_interopRequireDefault(__webpack_require__(8192));var _View=_interopRequireDefault(__webpack_require__(101));var _ViewNativeComponent=__webpack_require__(9447);var _invariant=_interopRequireDefault(__webpack_require__(311));var _react=_interopRequireWildcard(__webpack_require__(6540));var React=(/* unused pure expression or super */ null && (_react));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}function useAndroidRippleForView(rippleConfig,viewRef){var _ref=rippleConfig!=null?rippleConfig:{},color=_ref.color,borderless=_ref.borderless,radius=_ref.radius,foreground=_ref.foreground;return(0,_react.useMemo)(function(){if(_Platform.default.OS==='android'&&_Platform.default.Version>=21&&(color!=null||borderless!=null||radius!=null)){var processedColor=(0,_processColor.default)(color);(0,_invariant.default)(processedColor==null||typeof processedColor==='number','Unexpected color given for Ripple color');var nativeRippleValue={type:'RippleAndroid',color:processedColor,borderless:borderless===true,rippleRadius:radius};return{viewProps:foreground===true?{nativeForegroundAndroid:nativeRippleValue}:{nativeBackgroundAndroid:nativeRippleValue},onPressIn:function onPressIn(event){var view=viewRef.current;if(view!=null){var _event$nativeEvent$lo,_event$nativeEvent$lo2;_ViewNativeComponent.Commands.hotspotUpdate(view,(_event$nativeEvent$lo=event.nativeEvent.locationX)!=null?_event$nativeEvent$lo:0,(_event$nativeEvent$lo2=event.nativeEvent.locationY)!=null?_event$nativeEvent$lo2:0);_ViewNativeComponent.Commands.setPressed(view,true);}},onPressMove:function onPressMove(event){var view=viewRef.current;if(view!=null){var _event$nativeEvent$lo3,_event$nativeEvent$lo4;_ViewNativeComponent.Commands.hotspotUpdate(view,(_event$nativeEvent$lo3=event.nativeEvent.locationX)!=null?_event$nativeEvent$lo3:0,(_event$nativeEvent$lo4=event.nativeEvent.locationY)!=null?_event$nativeEvent$lo4:0);}},onPressOut:function onPressOut(event){var view=viewRef.current;if(view!=null){_ViewNativeComponent.Commands.setPressed(view,false);}}};}return null;},[borderless,color,foreground,radius,viewRef]);}
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 3178:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
module.exports = __webpack_require__(4742);
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 4429:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=exports.Commands=void 0;var _codegenNativeCommands=_interopRequireDefault(__webpack_require__(7830));var _codegenNativeComponent=_interopRequireDefault(__webpack_require__(9021));var React=_interopRequireWildcard(__webpack_require__(6540));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var Commands=exports.Commands=(0,_codegenNativeCommands.default)({supportedCommands:['setNativeRefreshing']});var _default=exports["default"]=(0,_codegenNativeComponent.default)('AndroidSwipeRefreshLayout');
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 6821:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=exports.Commands=void 0;var _codegenNativeCommands=_interopRequireDefault(__webpack_require__(7830));var _codegenNativeComponent=_interopRequireDefault(__webpack_require__(9021));var React=_interopRequireWildcard(__webpack_require__(6540));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var Commands=exports.Commands=(0,_codegenNativeCommands.default)({supportedCommands:['setNativeRefreshing']});var _default=exports["default"]=(0,_codegenNativeComponent.default)('PullToRefreshView',{paperComponentName:'RCTRefreshControl',excludedPlatforms:['android']});
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 3043:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _objectWithoutProperties2=_interopRequireDefault(__webpack_require__(1847));var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _AndroidSwipeRefreshLayoutNativeComponent=_interopRequireWildcard(__webpack_require__(4429));var _PullToRefreshViewNativeComponent=_interopRequireWildcard(__webpack_require__(6821));var _jsxRuntime=__webpack_require__(4848);var _excluded=["enabled","colors","progressBackgroundColor","size"],_excluded2=["tintColor","titleColor","title"];function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}var Platform=__webpack_require__(8192);var React=__webpack_require__(6540);var RefreshControl=function(_React$Component){function RefreshControl(){var _this;(0,_classCallCheck2.default)(this,RefreshControl);for(var _len=arguments.length,args=new Array(_len),_key=0;_key<_len;_key++){args[_key]=arguments[_key];}_this=_callSuper(this,RefreshControl,[].concat(args));_this._lastNativeRefreshing=false;_this._onRefresh=function(){_this._lastNativeRefreshing=true;_this.props.onRefresh&&_this.props.onRefresh();_this.forceUpdate();};_this._setNativeRef=function(ref){_this._nativeRef=ref;};return _this;}(0,_inherits2.default)(RefreshControl,_React$Component);return(0,_createClass2.default)(RefreshControl,[{key:"componentDidMount",value:function componentDidMount(){this._lastNativeRefreshing=this.props.refreshing;}},{key:"componentDidUpdate",value:function componentDidUpdate(prevProps){if(this.props.refreshing!==prevProps.refreshing){this._lastNativeRefreshing=this.props.refreshing;}else if(this.props.refreshing!==this._lastNativeRefreshing&&this._nativeRef){if(Platform.OS==='android'){_AndroidSwipeRefreshLayoutNativeComponent.Commands.setNativeRefreshing(this._nativeRef,this.props.refreshing);}else{_PullToRefreshViewNativeComponent.Commands.setNativeRefreshing(this._nativeRef,this.props.refreshing);}this._lastNativeRefreshing=this.props.refreshing;}}},{key:"render",value:function render(){if(Platform.OS==='ios'){var _this$props=this.props,enabled=_this$props.enabled,colors=_this$props.colors,progressBackgroundColor=_this$props.progressBackgroundColor,size=_this$props.size,props=(0,_objectWithoutProperties2.default)(_this$props,_excluded);return(0,_jsxRuntime.jsx)(_PullToRefreshViewNativeComponent.default,Object.assign({},props,{ref:this._setNativeRef,onRefresh:this._onRefresh}));}else{var _this$props2=this.props,tintColor=_this$props2.tintColor,titleColor=_this$props2.titleColor,title=_this$props2.title,_props=(0,_objectWithoutProperties2.default)(_this$props2,_excluded2);return(0,_jsxRuntime.jsx)(_AndroidSwipeRefreshLayoutNativeComponent.default,Object.assign({},_props,{ref:this._setNativeRef,onRefresh:this._onRefresh}));}}}]);}(React.Component);module.exports=RefreshControl;
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 6194:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var __webpack_unused_export__;
var _interopRequireDefault=__webpack_require__(4994);__webpack_unused_export__ = ({value:true});exports.A=void 0;var _codegenNativeComponent=_interopRequireDefault(__webpack_require__(9021));var _default=exports.A=(0,_codegenNativeComponent.default)('SafeAreaView',{paperComponentName:'RCTSafeAreaView',interfaceOnly:true});
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 1701:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var __webpack_unused_export__;
var _interopRequireDefault=__webpack_require__(4994);__webpack_unused_export__ = ({value:true});exports.A=void 0;var _Platform=_interopRequireDefault(__webpack_require__(8192));var _View=_interopRequireDefault(__webpack_require__(101));var React=_interopRequireWildcard(__webpack_require__(6540));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var exported;if(_Platform.default.OS==='android'){exported=_View.default;}else{exported=(__webpack_require__(6194)/* ["default"] */ .A);}var _default=exports.A=exported;
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 3239:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _codegenNativeComponent=_interopRequireDefault(__webpack_require__(9021));var _default=exports["default"]=(0,_codegenNativeComponent.default)('AndroidHorizontalScrollContentView');
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 4752:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=exports.__INTERNAL_VIEW_CONFIG=void 0;var NativeComponentRegistry=_interopRequireWildcard(__webpack_require__(1153));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var __INTERNAL_VIEW_CONFIG=exports.__INTERNAL_VIEW_CONFIG={uiViewClassName:'AndroidHorizontalScrollView',bubblingEventTypes:{},directEventTypes:{},validAttributes:{decelerationRate:true,disableIntervalMomentum:true,endFillColor:{process:(__webpack_require__(5372)["default"])},fadingEdgeLength:true,nestedScrollEnabled:true,overScrollMode:true,pagingEnabled:true,persistentScrollbar:true,scrollEnabled:true,scrollPerfTag:true,sendMomentumEvents:true,showsHorizontalScrollIndicator:true,snapToAlignment:true,snapToEnd:true,snapToInterval:true,snapToStart:true,snapToOffsets:true,contentOffset:true,borderBottomLeftRadius:true,borderBottomRightRadius:true,borderRadius:true,borderStyle:true,borderRightColor:{process:(__webpack_require__(5372)["default"])},borderColor:{process:(__webpack_require__(5372)["default"])},borderBottomColor:{process:(__webpack_require__(5372)["default"])},borderTopLeftRadius:true,borderTopColor:{process:(__webpack_require__(5372)["default"])},removeClippedSubviews:true,borderTopRightRadius:true,borderLeftColor:{process:(__webpack_require__(5372)["default"])},pointerEvents:true}};var AndroidHorizontalScrollViewNativeComponent=NativeComponentRegistry.get('AndroidHorizontalScrollView',function(){return __INTERNAL_VIEW_CONFIG;});var _default=exports["default"]=AndroidHorizontalScrollViewNativeComponent;
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 9896:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=exports.__INTERNAL_VIEW_CONFIG=void 0;var NativeComponentRegistry=_interopRequireWildcard(__webpack_require__(1153));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var __INTERNAL_VIEW_CONFIG=exports.__INTERNAL_VIEW_CONFIG={uiViewClassName:'RCTScrollContentView',bubblingEventTypes:{},directEventTypes:{},validAttributes:{}};var ScrollContentViewNativeComponent=NativeComponentRegistry.get('RCTScrollContentView',function(){return __INTERNAL_VIEW_CONFIG;});var _default=exports["default"]=ScrollContentViewNativeComponent;
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 8699:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _slicedToArray2=_interopRequireDefault(__webpack_require__(5715));var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _AnimatedImplementation=_interopRequireDefault(__webpack_require__(9860));var _FrameRateLogger=_interopRequireDefault(__webpack_require__(5001));var _RendererProxy=__webpack_require__(8907);var _UIManager=_interopRequireDefault(__webpack_require__(1855));var _flattenStyle=_interopRequireDefault(__webpack_require__(9259));var _splitLayoutProps2=_interopRequireDefault(__webpack_require__(1284));var _StyleSheet=_interopRequireDefault(__webpack_require__(6556));var _Dimensions=_interopRequireDefault(__webpack_require__(6345));var _dismissKeyboard=_interopRequireDefault(__webpack_require__(3491));var _Platform=_interopRequireDefault(__webpack_require__(8192));var _Keyboard=_interopRequireDefault(__webpack_require__(9829));var _TextInputState=_interopRequireDefault(__webpack_require__(4080));var _View=_interopRequireDefault(__webpack_require__(101));var _AndroidHorizontalScrollContentViewNativeComponent=_interopRequireDefault(__webpack_require__(3239));var _AndroidHorizontalScrollViewNativeComponent=_interopRequireDefault(__webpack_require__(4752));var _processDecelerationRate=_interopRequireDefault(__webpack_require__(243));var _ScrollContentViewNativeComponent=_interopRequireDefault(__webpack_require__(9896));var _ScrollViewCommands=_interopRequireDefault(__webpack_require__(4005));var _ScrollViewContext=_interopRequireWildcard(__webpack_require__(9092));var _ScrollViewNativeComponent=_interopRequireDefault(__webpack_require__(3773));var _ScrollViewStickyHeader=_interopRequireDefault(__webpack_require__(7913));var _invariant=_interopRequireDefault(__webpack_require__(311));var _memoizeOne=_interopRequireDefault(__webpack_require__(8250));var _nullthrows=_interopRequireDefault(__webpack_require__(801));var React=_interopRequireWildcard(__webpack_require__(6540));var _jsxRuntime=__webpack_require__(4848);function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}if(_Platform.default.OS==='ios'){__webpack_require__(2556);}var _ref=_Platform.default.OS==='android'?{NativeHorizontalScrollViewTuple:[_AndroidHorizontalScrollViewNativeComponent.default,_AndroidHorizontalScrollContentViewNativeComponent.default],NativeVerticalScrollViewTuple:[_ScrollViewNativeComponent.default,_View.default]}:{NativeHorizontalScrollViewTuple:[_ScrollViewNativeComponent.default,_ScrollContentViewNativeComponent.default],NativeVerticalScrollViewTuple:[_ScrollViewNativeComponent.default,_ScrollContentViewNativeComponent.default]},NativeHorizontalScrollViewTuple=_ref.NativeHorizontalScrollViewTuple,NativeVerticalScrollViewTuple=_ref.NativeVerticalScrollViewTuple;var IS_ANIMATING_TOUCH_START_THRESHOLD_MS=16;var ScrollView=function(_React$Component){function ScrollView(props){var _this$props$contentOf,_this$props$contentOf2,_this$props$contentIn,_this$props$contentIn2;var _this;(0,_classCallCheck2.default)(this,ScrollView);_this=_callSuper(this,ScrollView,[props]);_this._scrollAnimatedValueAttachment=null;_this._stickyHeaderRefs=new Map();_this._headerLayoutYs=new Map();_this._keyboardMetrics=null;_this._additionalScrollOffset=0;_this._isTouching=false;_this._lastMomentumScrollBeginTime=0;_this._lastMomentumScrollEndTime=0;_this._observedScrollSinceBecomingResponder=false;_this._becameResponderWhileAnimating=false;_this._preventNegativeScrollOffset=null;_this._animated=null;_this._subscriptionKeyboardWillShow=null;_this._subscriptionKeyboardWillHide=null;_this._subscriptionKeyboardDidShow=null;_this._subscriptionKeyboardDidHide=null;_this.state={layoutHeight:null};_this.getScrollResponder=function(){return _this;};_this.getScrollableNode=function(){return(0,_RendererProxy.findNodeHandle)(_this._scrollView.nativeInstance);};_this.getInnerViewNode=function(){return(0,_RendererProxy.findNodeHandle)(_this._innerView.nativeInstance);};_this.getInnerViewRef=function(){return _this._innerView.nativeInstance;};_this.getNativeScrollRef=function(){return _this._scrollView.nativeInstance;};_this.scrollTo=function(options,deprecatedX,deprecatedAnimated){var x,y,animated;if(typeof options==='number'){console.warn('`scrollTo(y, x, animated)` is deprecated. Use `scrollTo({x: 5, y: 5, '+'animated: true})` instead.');y=options;x=deprecatedX;animated=deprecatedAnimated;}else if(options){y=options.y;x=options.x;animated=options.animated;}if(_this._scrollView.nativeInstance==null){return;}_ScrollViewCommands.default.scrollTo(_this._scrollView.nativeInstance,x||0,y||0,animated!==false);};_this.scrollToEnd=function(options){var animated=(options&&options.animated)!==false;if(_this._scrollView.nativeInstance==null){return;}_ScrollViewCommands.default.scrollToEnd(_this._scrollView.nativeInstance,animated);};_this.flashScrollIndicators=function(){if(_this._scrollView.nativeInstance==null){return;}_ScrollViewCommands.default.flashScrollIndicators(_this._scrollView.nativeInstance);};_this.scrollResponderScrollNativeHandleToKeyboard=function(nodeHandle,additionalOffset,preventNegativeScrollOffset){_this._additionalScrollOffset=additionalOffset||0;_this._preventNegativeScrollOffset=!!preventNegativeScrollOffset;if(_this._innerView.nativeInstance==null){return;}if(typeof nodeHandle==='number'){_UIManager.default.measureLayout(nodeHandle,(0,_nullthrows.default)((0,_RendererProxy.findNodeHandle)(_this)),_this._textInputFocusError,_this._inputMeasureAndScrollToKeyboard);}else{nodeHandle.measureLayout(_this._innerView.nativeInstance,_this._inputMeasureAndScrollToKeyboard,_this._textInputFocusError);}};_this.scrollResponderZoomTo=function(rect,animated){(0,_invariant.default)(_Platform.default.OS==='ios','zoomToRect is not implemented');if('animated'in rect){_this._animated=rect.animated;delete rect.animated;}else if(typeof animated!=='undefined'){console.warn('`scrollResponderZoomTo` `animated` argument is deprecated. Use `options.animated` instead');}if(_this._scrollView.nativeInstance==null){return;}_ScrollViewCommands.default.zoomToRect(_this._scrollView.nativeInstance,rect,animated!==false);};_this._inputMeasureAndScrollToKeyboard=function(left,top,width,height){var keyboardScreenY=_Dimensions.default.get('window').height;var scrollTextInputIntoVisibleRect=function scrollTextInputIntoVisibleRect(){if(_this._keyboardMetrics!=null){keyboardScreenY=_this._keyboardMetrics.screenY;}var scrollOffsetY=top-keyboardScreenY+height+_this._additionalScrollOffset;if(_this._preventNegativeScrollOffset===true){scrollOffsetY=Math.max(0,scrollOffsetY);}_this.scrollTo({x:0,y:scrollOffsetY,animated:true});_this._additionalScrollOffset=0;_this._preventNegativeScrollOffset=false;};if(_this._keyboardMetrics==null){setTimeout(function(){scrollTextInputIntoVisibleRect();},0);}else{scrollTextInputIntoVisibleRect();}};_this._handleScroll=function(e){if(false){}_this._observedScrollSinceBecomingResponder=true;_this.props.onScroll&&_this.props.onScroll(e);};_this._handleLayout=function(e){if(_this.props.invertStickyHeaders===true){_this.setState({layoutHeight:e.nativeEvent.layout.height});}if(_this.props.onLayout){_this.props.onLayout(e);}};_this._handleContentOnLayout=function(e){var _e$nativeEvent$layout=e.nativeEvent.layout,width=_e$nativeEvent$layout.width,height=_e$nativeEvent$layout.height;_this.props.onContentSizeChange&&_this.props.onContentSizeChange(width,height);};_this._innerView=createRefForwarder(function(instance){return instance;});_this._scrollView=createRefForwarder(function(nativeInstance){var publicInstance=Object.assign(nativeInstance,{getScrollResponder:_this.getScrollResponder,getScrollableNode:_this.getScrollableNode,getInnerViewNode:_this.getInnerViewNode,getInnerViewRef:_this.getInnerViewRef,getNativeScrollRef:_this.getNativeScrollRef,scrollTo:_this.scrollTo,scrollToEnd:_this.scrollToEnd,flashScrollIndicators:_this.flashScrollIndicators,scrollResponderZoomTo:_this.scrollResponderZoomTo,scrollResponderScrollNativeHandleToKeyboard:_this.scrollResponderScrollNativeHandleToKeyboard});return publicInstance;});_this.scrollResponderKeyboardWillShow=function(e){_this._keyboardMetrics=e.endCoordinates;_this.props.onKeyboardWillShow&&_this.props.onKeyboardWillShow(e);};_this.scrollResponderKeyboardWillHide=function(e){_this._keyboardMetrics=null;_this.props.onKeyboardWillHide&&_this.props.onKeyboardWillHide(e);};_this.scrollResponderKeyboardDidShow=function(e){_this._keyboardMetrics=e.endCoordinates;_this.props.onKeyboardDidShow&&_this.props.onKeyboardDidShow(e);};_this.scrollResponderKeyboardDidHide=function(e){_this._keyboardMetrics=null;_this.props.onKeyboardDidHide&&_this.props.onKeyboardDidHide(e);};_this._handleMomentumScrollBegin=function(e){_this._lastMomentumScrollBeginTime=__webpack_require__.g.performance.now();_this.props.onMomentumScrollBegin&&_this.props.onMomentumScrollBegin(e);};_this._handleMomentumScrollEnd=function(e){_FrameRateLogger.default.endScroll();_this._lastMomentumScrollEndTime=__webpack_require__.g.performance.now();_this.props.onMomentumScrollEnd&&_this.props.onMomentumScrollEnd(e);};_this._handleScrollBeginDrag=function(e){_FrameRateLogger.default.beginScroll();if(_Platform.default.OS==='android'&&_this.props.keyboardDismissMode==='on-drag'){(0,_dismissKeyboard.default)();}_this.props.onScrollBeginDrag&&_this.props.onScrollBeginDrag(e);};_this._handleScrollEndDrag=function(e){var velocity=e.nativeEvent.velocity;if(!_this._isAnimating()&&(!velocity||velocity.x===0&&velocity.y===0)){_FrameRateLogger.default.endScroll();}_this.props.onScrollEndDrag&&_this.props.onScrollEndDrag(e);};_this._isAnimating=function(){var now=__webpack_require__.g.performance.now();var timeSinceLastMomentumScrollEnd=now-_this._lastMomentumScrollEndTime;var isAnimating=timeSinceLastMomentumScrollEnd<IS_ANIMATING_TOUCH_START_THRESHOLD_MS||_this._lastMomentumScrollEndTime<_this._lastMomentumScrollBeginTime;return isAnimating;};_this._handleResponderGrant=function(e){_this._observedScrollSinceBecomingResponder=false;_this.props.onResponderGrant&&_this.props.onResponderGrant(e);_this._becameResponderWhileAnimating=_this._isAnimating();};_this._handleResponderReject=function(){};_this._handleResponderRelease=function(e){_this._isTouching=e.nativeEvent.touches.length!==0;_this.props.onResponderRelease&&_this.props.onResponderRelease(e);if(typeof e.target==='number'){if(false){}return;}var currentlyFocusedTextInput=_TextInputState.default.currentlyFocusedInput();if(currentlyFocusedTextInput!=null&&_this.props.keyboardShouldPersistTaps!==true&&_this.props.keyboardShouldPersistTaps!=='always'&&_this._keyboardIsDismissible()&&e.target!==currentlyFocusedTextInput&&!_this._observedScrollSinceBecomingResponder&&!_this._becameResponderWhileAnimating){_TextInputState.default.blurTextInput(currentlyFocusedTextInput);}};_this._handleResponderTerminationRequest=function(){return!_this._observedScrollSinceBecomingResponder;};_this._handleScrollShouldSetResponder=function(){if(_this.props.disableScrollViewPanResponder===true){return false;}return _this._isTouching;};_this._handleStartShouldSetResponder=function(e){if(_this.props.disableScrollViewPanResponder===true){return false;}var currentlyFocusedInput=_TextInputState.default.currentlyFocusedInput();if(_this.props.keyboardShouldPersistTaps==='handled'&&_this._keyboardIsDismissible()&&e.target!==currentlyFocusedInput){return true;}return false;};_this._handleStartShouldSetResponderCapture=function(e){if(_this._isAnimating()){return true;}if(_this.props.disableScrollViewPanResponder===true){return false;}var keyboardShouldPersistTaps=_this.props.keyboardShouldPersistTaps;var keyboardNeverPersistTaps=!keyboardShouldPersistTaps||keyboardShouldPersistTaps==='never';if(typeof e.target==='number'){if(false){}return false;}if(_this._softKeyboardIsDetached()){return false;}if(keyboardNeverPersistTaps&&_this._keyboardIsDismissible()&&e.target!=null&&!_TextInputState.default.isTextInput(e.target)){return true;}return false;};_this._keyboardIsDismissible=function(){var currentlyFocusedInput=_TextInputState.default.currentlyFocusedInput();var hasFocusedTextInput=currentlyFocusedInput!=null&&_TextInputState.default.isTextInput(currentlyFocusedInput);var softKeyboardMayBeOpen=_this._keyboardMetrics!=null||_this._keyboardEventsAreUnreliable();return hasFocusedTextInput&&softKeyboardMayBeOpen;};_this._softKeyboardIsDetached=function(){return _this._keyboardMetrics!=null&&_this._keyboardMetrics.height===0;};_this._keyboardEventsAreUnreliable=function(){return _Platform.default.OS==='android'&&_Platform.default.Version<30;};_this._handleTouchEnd=function(e){var nativeEvent=e.nativeEvent;_this._isTouching=nativeEvent.touches.length!==0;var keyboardShouldPersistTaps=_this.props.keyboardShouldPersistTaps;var keyboardNeverPersistsTaps=!keyboardShouldPersistTaps||keyboardShouldPersistTaps==='never';var currentlyFocusedTextInput=_TextInputState.default.currentlyFocusedInput();if(currentlyFocusedTextInput!=null&&e.target!==currentlyFocusedTextInput&&_this._softKeyboardIsDetached()&&_this._keyboardIsDismissible()&&keyboardNeverPersistsTaps){_TextInputState.default.blurTextInput(currentlyFocusedTextInput);}_this.props.onTouchEnd&&_this.props.onTouchEnd(e);};_this._handleTouchCancel=function(e){_this._isTouching=false;_this.props.onTouchCancel&&_this.props.onTouchCancel(e);};_this._handleTouchStart=function(e){_this._isTouching=true;_this.props.onTouchStart&&_this.props.onTouchStart(e);};_this._handleTouchMove=function(e){_this.props.onTouchMove&&_this.props.onTouchMove(e);};_this._scrollAnimatedValue=new _AnimatedImplementation.default.Value((_this$props$contentOf=(_this$props$contentOf2=_this.props.contentOffset)==null?void 0:_this$props$contentOf2.y)!=null?_this$props$contentOf:0);_this._scrollAnimatedValue.setOffset((_this$props$contentIn=(_this$props$contentIn2=_this.props.contentInset)==null?void 0:_this$props$contentIn2.top)!=null?_this$props$contentIn:0);return _this;}(0,_inherits2.default)(ScrollView,_React$Component);return(0,_createClass2.default)(ScrollView,[{key:"componentDidMount",value:function componentDidMount(){if(typeof this.props.keyboardShouldPersistTaps==='boolean'){console.warn(`'keyboardShouldPersistTaps={${this.props.keyboardShouldPersistTaps===true?'true':'false'}}' is deprecated. `+`Use 'keyboardShouldPersistTaps="${this.props.keyboardShouldPersistTaps?'always':'never'}"' instead`);}this._keyboardMetrics=_Keyboard.default.metrics();this._additionalScrollOffset=0;this._subscriptionKeyboardWillShow=_Keyboard.default.addListener('keyboardWillShow',this.scrollResponderKeyboardWillShow);this._subscriptionKeyboardWillHide=_Keyboard.default.addListener('keyboardWillHide',this.scrollResponderKeyboardWillHide);this._subscriptionKeyboardDidShow=_Keyboard.default.addListener('keyboardDidShow',this.scrollResponderKeyboardDidShow);this._subscriptionKeyboardDidHide=_Keyboard.default.addListener('keyboardDidHide',this.scrollResponderKeyboardDidHide);this._updateAnimatedNodeAttachment();}},{key:"componentDidUpdate",value:function componentDidUpdate(prevProps){var prevContentInsetTop=prevProps.contentInset?prevProps.contentInset.top:0;var newContentInsetTop=this.props.contentInset?this.props.contentInset.top:0;if(prevContentInsetTop!==newContentInsetTop){this._scrollAnimatedValue.setOffset(newContentInsetTop||0);}this._updateAnimatedNodeAttachment();}},{key:"componentWillUnmount",value:function componentWillUnmount(){if(this._subscriptionKeyboardWillShow!=null){this._subscriptionKeyboardWillShow.remove();}if(this._subscriptionKeyboardWillHide!=null){this._subscriptionKeyboardWillHide.remove();}if(this._subscriptionKeyboardDidShow!=null){this._subscriptionKeyboardDidShow.remove();}if(this._subscriptionKeyboardDidHide!=null){this._subscriptionKeyboardDidHide.remove();}if(this._scrollAnimatedValueAttachment){this._scrollAnimatedValueAttachment.detach();}}},{key:"_textInputFocusError",value:function _textInputFocusError(){console.warn('Error measuring text field.');}},{key:"_getKeyForIndex",value:function _getKeyForIndex(index,childArray){var child=childArray[index];return child&&child.key;}},{key:"_updateAnimatedNodeAttachment",value:function _updateAnimatedNodeAttachment(){if(this._scrollAnimatedValueAttachment){this._scrollAnimatedValueAttachment.detach();}if(this.props.stickyHeaderIndices&&this.props.stickyHeaderIndices.length>0){this._scrollAnimatedValueAttachment=_AnimatedImplementation.default.attachNativeEvent(this._scrollView.nativeInstance,'onScroll',[{nativeEvent:{contentOffset:{y:this._scrollAnimatedValue}}}]);}}},{key:"_setStickyHeaderRef",value:function _setStickyHeaderRef(key,ref){if(ref){this._stickyHeaderRefs.set(key,ref);}else{this._stickyHeaderRefs.delete(key);}}},{key:"_onStickyHeaderLayout",value:function _onStickyHeaderLayout(index,event,key){var stickyHeaderIndices=this.props.stickyHeaderIndices;if(!stickyHeaderIndices){return;}var childArray=React.Children.toArray(this.props.children);if(key!==this._getKeyForIndex(index,childArray)){return;}var layoutY=event.nativeEvent.layout.y;this._headerLayoutYs.set(key,layoutY);var indexOfIndex=stickyHeaderIndices.indexOf(index);var previousHeaderIndex=stickyHeaderIndices[indexOfIndex-1];if(previousHeaderIndex!=null){var previousHeader=this._stickyHeaderRefs.get(this._getKeyForIndex(previousHeaderIndex,childArray));previousHeader&&previousHeader.setNextHeaderY&&previousHeader.setNextHeaderY(layoutY);}}},{key:"render",value:function render(){var _this2=this;var _ref2=this.props.horizontal===true?NativeHorizontalScrollViewTuple:NativeVerticalScrollViewTuple,_ref3=(0,_slicedToArray2.default)(_ref2,2),NativeDirectionalScrollView=_ref3[0],NativeDirectionalScrollContentView=_ref3[1];var contentContainerStyle=[this.props.horizontal===true&&styles.contentContainerHorizontal,this.props.contentContainerStyle];if(false){ var childLayoutProps, style; }var contentSizeChangeProps=this.props.onContentSizeChange==null?null:{onLayout:this._handleContentOnLayout};var stickyHeaderIndices=this.props.stickyHeaderIndices;var children=this.props.children;if(stickyHeaderIndices!=null&&stickyHeaderIndices.length>0){var childArray=React.Children.toArray(this.props.children);children=childArray.map(function(child,index){var indexOfIndex=child?stickyHeaderIndices.indexOf(index):-1;if(indexOfIndex>-1){var key=child.key;var nextIndex=stickyHeaderIndices[indexOfIndex+1];var StickyHeaderComponent=_this2.props.StickyHeaderComponent||_ScrollViewStickyHeader.default;return(0,_jsxRuntime.jsx)(StickyHeaderComponent,{nativeID:'StickyHeader-'+key,ref:function ref(_ref4){return _this2._setStickyHeaderRef(key,_ref4);},nextHeaderLayoutY:_this2._headerLayoutYs.get(_this2._getKeyForIndex(nextIndex,childArray)),onLayout:function onLayout(event){return _this2._onStickyHeaderLayout(index,event,key);},scrollAnimatedValue:_this2._scrollAnimatedValue,inverted:_this2.props.invertStickyHeaders,hiddenOnScroll:_this2.props.stickyHeaderHiddenOnScroll,scrollViewHeight:_this2.state.layoutHeight,children:child},key);}else{return child;}});}children=(0,_jsxRuntime.jsx)(_ScrollViewContext.default.Provider,{value:this.props.horizontal===true?_ScrollViewContext.HORIZONTAL:_ScrollViewContext.VERTICAL,children:children});var hasStickyHeaders=Array.isArray(stickyHeaderIndices)&&stickyHeaderIndices.length>0;var contentContainer=(0,_jsxRuntime.jsx)(NativeDirectionalScrollContentView,Object.assign({},contentSizeChangeProps,{ref:this._innerView.getForwardingRef(this.props.innerViewRef),style:contentContainerStyle,removeClippedSubviews:_Platform.default.OS==='android'&&hasStickyHeaders?false:this.props.removeClippedSubviews,collapsable:false,children:children}));var alwaysBounceHorizontal=this.props.alwaysBounceHorizontal!==undefined?this.props.alwaysBounceHorizontal:this.props.horizontal;var alwaysBounceVertical=this.props.alwaysBounceVertical!==undefined?this.props.alwaysBounceVertical:!this.props.horizontal;var baseStyle=this.props.horizontal===true?styles.baseHorizontal:styles.baseVertical;var props=Object.assign({},this.props,{alwaysBounceHorizontal:alwaysBounceHorizontal,alwaysBounceVertical:alwaysBounceVertical,style:_StyleSheet.default.compose(baseStyle,this.props.style),onContentSizeChange:null,onLayout:this._handleLayout,onMomentumScrollBegin:this._handleMomentumScrollBegin,onMomentumScrollEnd:this._handleMomentumScrollEnd,onResponderGrant:this._handleResponderGrant,onResponderReject:this._handleResponderReject,onResponderRelease:this._handleResponderRelease,onResponderTerminationRequest:this._handleResponderTerminationRequest,onScrollBeginDrag:this._handleScrollBeginDrag,onScrollEndDrag:this._handleScrollEndDrag,onScrollShouldSetResponder:this._handleScrollShouldSetResponder,onStartShouldSetResponder:this._handleStartShouldSetResponder,onStartShouldSetResponderCapture:this._handleStartShouldSetResponderCapture,onTouchEnd:this._handleTouchEnd,onTouchMove:this._handleTouchMove,onTouchStart:this._handleTouchStart,onTouchCancel:this._handleTouchCancel,onScroll:this._handleScroll,scrollEventThrottle:hasStickyHeaders?1:this.props.scrollEventThrottle,sendMomentumEvents:this.props.onMomentumScrollBegin||this.props.onMomentumScrollEnd?true:false,snapToStart:this.props.snapToStart!==false,snapToEnd:this.props.snapToEnd!==false,pagingEnabled:_Platform.default.select({ios:this.props.pagingEnabled===true&&this.props.snapToInterval==null&&this.props.snapToOffsets==null,android:this.props.pagingEnabled===true||this.props.snapToInterval!=null||this.props.snapToOffsets!=null})});var decelerationRate=this.props.decelerationRate;if(decelerationRate!=null){props.decelerationRate=(0,_processDecelerationRate.default)(decelerationRate);}var refreshControl=this.props.refreshControl;var scrollViewRef=this._scrollView.getForwardingRef(this.props.scrollViewRef);if(refreshControl){if(_Platform.default.OS==='ios'){return(0,_jsxRuntime.jsxs)(NativeDirectionalScrollView,Object.assign({},props,{ref:scrollViewRef,children:[refreshControl,contentContainer]}));}else if(_Platform.default.OS==='android'){var _splitLayoutProps=(0,_splitLayoutProps2.default)((0,_flattenStyle.default)(props.style)),outer=_splitLayoutProps.outer,inner=_splitLayoutProps.inner;return React.cloneElement(refreshControl,{style:_StyleSheet.default.compose(baseStyle,outer)},(0,_jsxRuntime.jsx)(NativeDirectionalScrollView,Object.assign({},props,{style:_StyleSheet.default.compose(baseStyle,inner),ref:scrollViewRef,children:contentContainer})));}}return(0,_jsxRuntime.jsx)(NativeDirectionalScrollView,Object.assign({},props,{ref:scrollViewRef,children:contentContainer}));}}]);}(React.Component);ScrollView.Context=_ScrollViewContext.default;var styles=_StyleSheet.default.create({baseVertical:{flexGrow:1,flexShrink:1,flexDirection:'column',overflow:'scroll'},baseHorizontal:{flexGrow:1,flexShrink:1,flexDirection:'row',overflow:'scroll'},contentContainerHorizontal:{flexDirection:'row'}});function createRefForwarder(mutator){var state={getForwardingRef:(0,_memoizeOne.default)(function(forwardedRef){return function(nativeInstance){var publicInstance=nativeInstance==null?null:mutator(nativeInstance);state.nativeInstance=nativeInstance;state.publicInstance=publicInstance;if(forwardedRef!=null){if(typeof forwardedRef==='function'){forwardedRef(publicInstance);}else{forwardedRef.current=publicInstance;}}};}),nativeInstance:null,publicInstance:null};return state;}function Wrapper(props,ref){return(0,_jsxRuntime.jsx)(ScrollView,Object.assign({},props,{scrollViewRef:ref}));}Wrapper.displayName='ScrollView';var ForwardedScrollView=React.forwardRef(Wrapper);ForwardedScrollView.Context=_ScrollViewContext.default;ForwardedScrollView.displayName='ScrollView';module.exports=ForwardedScrollView;
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 4005:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _codegenNativeCommands=_interopRequireDefault(__webpack_require__(7830));var React=_interopRequireWildcard(__webpack_require__(6540));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var _default=exports["default"]=(0,_codegenNativeCommands.default)({supportedCommands:['flashScrollIndicators','scrollTo','scrollToEnd','zoomToRect']});
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 9092:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=exports.VERTICAL=exports.HORIZONTAL=void 0;var React=_interopRequireWildcard(__webpack_require__(6540));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var ScrollViewContext=React.createContext(null);if(false){}var _default=exports["default"]=ScrollViewContext;var HORIZONTAL=exports.HORIZONTAL=Object.freeze({horizontal:true});var VERTICAL=exports.VERTICAL=Object.freeze({horizontal:false});
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 3773:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=exports.__INTERNAL_VIEW_CONFIG=void 0;var NativeComponentRegistry=_interopRequireWildcard(__webpack_require__(1153));var _ViewConfigIgnore=__webpack_require__(4987);var _Platform=_interopRequireDefault(__webpack_require__(8192));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var __INTERNAL_VIEW_CONFIG=exports.__INTERNAL_VIEW_CONFIG=_Platform.default.OS==='android'?{uiViewClassName:'RCTScrollView',bubblingEventTypes:{},directEventTypes:{topMomentumScrollBegin:{registrationName:'onMomentumScrollBegin'},topMomentumScrollEnd:{registrationName:'onMomentumScrollEnd'},topScroll:{registrationName:'onScroll'},topScrollBeginDrag:{registrationName:'onScrollBeginDrag'},topScrollEndDrag:{registrationName:'onScrollEndDrag'}},validAttributes:{contentOffset:{diff:__webpack_require__(9764)},decelerationRate:true,disableIntervalMomentum:true,pagingEnabled:true,scrollEnabled:true,showsVerticalScrollIndicator:true,snapToAlignment:true,snapToEnd:true,snapToInterval:true,snapToOffsets:true,snapToStart:true,borderBottomLeftRadius:true,borderBottomRightRadius:true,sendMomentumEvents:true,borderRadius:true,nestedScrollEnabled:true,borderStyle:true,borderRightColor:{process:(__webpack_require__(5372)["default"])},borderColor:{process:(__webpack_require__(5372)["default"])},borderBottomColor:{process:(__webpack_require__(5372)["default"])},persistentScrollbar:true,endFillColor:{process:(__webpack_require__(5372)["default"])},fadingEdgeLength:true,overScrollMode:true,borderTopLeftRadius:true,scrollPerfTag:true,borderTopColor:{process:(__webpack_require__(5372)["default"])},removeClippedSubviews:true,borderTopRightRadius:true,borderLeftColor:{process:(__webpack_require__(5372)["default"])},pointerEvents:true}}:{uiViewClassName:'RCTScrollView',bubblingEventTypes:{},directEventTypes:{topMomentumScrollBegin:{registrationName:'onMomentumScrollBegin'},topMomentumScrollEnd:{registrationName:'onMomentumScrollEnd'},topScroll:{registrationName:'onScroll'},topScrollBeginDrag:{registrationName:'onScrollBeginDrag'},topScrollEndDrag:{registrationName:'onScrollEndDrag'},topScrollToTop:{registrationName:'onScrollToTop'}},validAttributes:Object.assign({alwaysBounceHorizontal:true,alwaysBounceVertical:true,automaticallyAdjustContentInsets:true,automaticallyAdjustKeyboardInsets:true,automaticallyAdjustsScrollIndicatorInsets:true,bounces:true,bouncesZoom:true,canCancelContentTouches:true,centerContent:true,contentInset:{diff:__webpack_require__(3473)},contentOffset:{diff:__webpack_require__(9764)},contentInsetAdjustmentBehavior:true,decelerationRate:true,directionalLockEnabled:true,disableIntervalMomentum:true,indicatorStyle:true,inverted:true,keyboardDismissMode:true,maintainVisibleContentPosition:true,maximumZoomScale:true,minimumZoomScale:true,pagingEnabled:true,pinchGestureEnabled:true,scrollEnabled:true,scrollEventThrottle:true,scrollIndicatorInsets:{diff:__webpack_require__(3473)},scrollToOverflowEnabled:true,scrollsToTop:true,showsHorizontalScrollIndicator:true,showsVerticalScrollIndicator:true,snapToAlignment:true,snapToEnd:true,snapToInterval:true,snapToOffsets:true,snapToStart:true,zoomScale:true},(0,_ViewConfigIgnore.ConditionallyIgnoredEventHandlers)({onScrollBeginDrag:true,onMomentumScrollEnd:true,onScrollEndDrag:true,onMomentumScrollBegin:true,onScrollToTop:true,onScroll:true}))};var ScrollViewNativeComponent=NativeComponentRegistry.get('RCTScrollView',function(){return __INTERNAL_VIEW_CONFIG;});var _default=exports["default"]=ScrollViewNativeComponent;
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 7913:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _slicedToArray2=_interopRequireDefault(__webpack_require__(5715));var _Animated=_interopRequireDefault(__webpack_require__(8886));var _ReactFabricPublicInstanceUtils=__webpack_require__(7218);var _StyleSheet=_interopRequireDefault(__webpack_require__(6556));var _Platform=_interopRequireDefault(__webpack_require__(8192));var _useMergeRefs=_interopRequireDefault(__webpack_require__(9443));var _react=_interopRequireWildcard(__webpack_require__(6540));var React=_react;var _jsxRuntime=__webpack_require__(4848);function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var ScrollViewStickyHeaderWithForwardedRef=React.forwardRef(function ScrollViewStickyHeader(props,forwardedRef){var inverted=props.inverted,scrollViewHeight=props.scrollViewHeight,hiddenOnScroll=props.hiddenOnScroll,scrollAnimatedValue=props.scrollAnimatedValue,_nextHeaderLayoutY=props.nextHeaderLayoutY;var _useState=(0,_react.useState)(false),_useState2=(0,_slicedToArray2.default)(_useState,2),measured=_useState2[0],setMeasured=_useState2[1];var _useState3=(0,_react.useState)(0),_useState4=(0,_slicedToArray2.default)(_useState3,2),layoutY=_useState4[0],setLayoutY=_useState4[1];var _useState5=(0,_react.useState)(0),_useState6=(0,_slicedToArray2.default)(_useState5,2),layoutHeight=_useState6[0],setLayoutHeight=_useState6[1];var _useState7=(0,_react.useState)(null),_useState8=(0,_slicedToArray2.default)(_useState7,2),translateY=_useState8[0],setTranslateY=_useState8[1];var _useState9=(0,_react.useState)(_nextHeaderLayoutY),_useState10=(0,_slicedToArray2.default)(_useState9,2),nextHeaderLayoutY=_useState10[0],setNextHeaderLayoutY=_useState10[1];var _useState11=(0,_react.useState)(false),_useState12=(0,_slicedToArray2.default)(_useState11,2),isFabric=_useState12[0],setIsFabric=_useState12[1];var callbackRef=function callbackRef(ref){if(ref==null){return;}ref.setNextHeaderY=function(value){setNextHeaderLayoutY(value);};setIsFabric((0,_ReactFabricPublicInstanceUtils.isPublicInstance)(ref));};var ref=(0,_useMergeRefs.default)(callbackRef,forwardedRef);var offset=(0,_react.useMemo)(function(){return hiddenOnScroll===true?_Animated.default.diffClamp(scrollAnimatedValue.interpolate({extrapolateLeft:'clamp',inputRange:[layoutY,layoutY+1],outputRange:[0,1]}).interpolate({inputRange:[0,1],outputRange:[0,-1]}),-layoutHeight,0):null;},[scrollAnimatedValue,layoutHeight,layoutY,hiddenOnScroll]);var _useState13=(0,_react.useState)(function(){var inputRange=[-1,0];var outputRange=[0,0];var initialTranslateY=scrollAnimatedValue.interpolate({inputRange:inputRange,outputRange:outputRange});if(offset!=null){return _Animated.default.add(initialTranslateY,offset);}return initialTranslateY;}),_useState14=(0,_slicedToArray2.default)(_useState13,2),animatedTranslateY=_useState14[0],setAnimatedTranslateY=_useState14[1];var _haveReceivedInitialZeroTranslateY=(0,_react.useRef)(true);var _timer=(0,_react.useRef)(null);(0,_react.useEffect)(function(){if(translateY!==0&&translateY!=null){_haveReceivedInitialZeroTranslateY.current=false;}},[translateY]);var animatedValueListener=(0,_react.useCallback)(function(_ref){var value=_ref.value;var _debounceTimeout=_Platform.default.OS==='android'?15:64;if(value===0&&!_haveReceivedInitialZeroTranslateY.current){_haveReceivedInitialZeroTranslateY.current=true;return;}if(_timer.current!=null){clearTimeout(_timer.current);}_timer.current=setTimeout(function(){if(value!==translateY){setTranslateY(value);}},_debounceTimeout);},[translateY]);(0,_react.useEffect)(function(){var inputRange=[-1,0];var outputRange=[0,0];if(measured){if(inverted===true){if(scrollViewHeight!=null){var stickStartPoint=layoutY+layoutHeight-scrollViewHeight;if(stickStartPoint>0){inputRange.push(stickStartPoint);outputRange.push(0);inputRange.push(stickStartPoint+1);outputRange.push(1);var collisionPoint=(nextHeaderLayoutY||0)-layoutHeight-scrollViewHeight;if(collisionPoint>stickStartPoint){inputRange.push(collisionPoint,collisionPoint+1);outputRange.push(collisionPoint-stickStartPoint,collisionPoint-stickStartPoint);}}}}else{inputRange.push(layoutY);outputRange.push(0);var _collisionPoint=(nextHeaderLayoutY||0)-layoutHeight;if(_collisionPoint>=layoutY){inputRange.push(_collisionPoint,_collisionPoint+1);outputRange.push(_collisionPoint-layoutY,_collisionPoint-layoutY);}else{inputRange.push(layoutY+1);outputRange.push(1);}}}var newAnimatedTranslateY=scrollAnimatedValue.interpolate({inputRange:inputRange,outputRange:outputRange});if(offset!=null){newAnimatedTranslateY=_Animated.default.add(newAnimatedTranslateY,offset);}var animatedListenerId;if(isFabric){animatedListenerId=newAnimatedTranslateY.addListener(animatedValueListener);}setAnimatedTranslateY(newAnimatedTranslateY);return function(){if(animatedListenerId){newAnimatedTranslateY.removeListener(animatedListenerId);}if(_timer.current!=null){clearTimeout(_timer.current);}};},[nextHeaderLayoutY,measured,layoutHeight,layoutY,scrollViewHeight,scrollAnimatedValue,inverted,offset,animatedValueListener,isFabric]);var _onLayout=function _onLayout(event){setLayoutY(event.nativeEvent.layout.y);setLayoutHeight(event.nativeEvent.layout.height);setMeasured(true);props.onLayout(event);var child=React.Children.only(props.children);if(child.props.onLayout){child.props.onLayout(event);}};var child=React.Children.only(props.children);var passthroughAnimatedPropExplicitValues=isFabric&&translateY!=null?{style:{transform:[{translateY:translateY}]}}:null;return((0,_jsxRuntime.jsx)(_Animated.default.View,{collapsable:false,nativeID:props.nativeID,onLayout:_onLayout,ref:ref,style:[child.props.style,styles.header,{transform:[{translateY:animatedTranslateY}]}],passthroughAnimatedPropExplicitValues:passthroughAnimatedPropExplicitValues,children:React.cloneElement(child,{style:styles.fill,onLayout:undefined})}));});var styles=_StyleSheet.default.create({header:{zIndex:10,position:'relative'},fill:{flex:1}});var _default=exports["default"]=ScrollViewStickyHeaderWithForwardedRef;
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 243:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _Platform=_interopRequireDefault(__webpack_require__(8192));function processDecelerationRate(decelerationRate){if(decelerationRate==='normal'){return _Platform.default.select({ios:0.998,android:0.985});}else if(decelerationRate==='fast'){return _Platform.default.select({ios:0.99,android:0.9});}return decelerationRate;}module.exports=processDecelerationRate;
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 9977:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var TurboModuleRegistry=_interopRequireWildcard(__webpack_require__(5333));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var _default=exports["default"]=TurboModuleRegistry.get('SoundManager');
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 6698:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _NativeSoundManager=_interopRequireDefault(__webpack_require__(9977));var SoundManager={playTouchSound:function playTouchSound(){if(_NativeSoundManager.default){_NativeSoundManager.default.playTouchSound();}}};module.exports=SoundManager;
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 9602:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var TurboModuleRegistry=_interopRequireWildcard(__webpack_require__(5333));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var NativeModule=TurboModuleRegistry.getEnforcing('StatusBarManager');var constants=null;var NativeStatusBarManager={getConstants:function getConstants(){if(constants==null){constants=NativeModule.getConstants();}return constants;},setColor:function setColor(color,animated){NativeModule.setColor(color,animated);},setTranslucent:function setTranslucent(translucent){NativeModule.setTranslucent(translucent);},setStyle:function setStyle(statusBarStyle){NativeModule.setStyle(statusBarStyle);},setHidden:function setHidden(hidden){NativeModule.setHidden(hidden);}};var _default=exports["default"]=NativeStatusBarManager;
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 6328:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var TurboModuleRegistry=_interopRequireWildcard(__webpack_require__(5333));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var NativeModule=TurboModuleRegistry.getEnforcing('StatusBarManager');var constants=null;var NativeStatusBarManager={getConstants:function getConstants(){if(constants==null){constants=NativeModule.getConstants();}return constants;},getHeight:function getHeight(callback){NativeModule.getHeight(callback);},setNetworkActivityIndicatorVisible:function setNetworkActivityIndicatorVisible(visible){NativeModule.setNetworkActivityIndicatorVisible(visible);},addListener:function addListener(eventType){NativeModule.addListener(eventType);},removeListeners:function removeListeners(count){NativeModule.removeListeners(count);},setStyle:function setStyle(statusBarStyle,animated){NativeModule.setStyle(statusBarStyle,animated);},setHidden:function setHidden(hidden,withAnimation){NativeModule.setHidden(hidden,withAnimation);}};var _default=exports["default"]=NativeStatusBarManager;
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 5421:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _processColor=_interopRequireDefault(__webpack_require__(5372));var _Platform=_interopRequireDefault(__webpack_require__(8192));var _NativeStatusBarManagerAndroid=_interopRequireDefault(__webpack_require__(9602));var _NativeStatusBarManagerIOS=_interopRequireDefault(__webpack_require__(6328));var _invariant=_interopRequireDefault(__webpack_require__(311));var React=_interopRequireWildcard(__webpack_require__(6540));var _StatusBar,_NativeStatusBarManag;function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}function mergePropsStack(propsStack,defaultValues){return propsStack.reduce(function(prev,cur){for(var prop in cur){if(cur[prop]!=null){prev[prop]=cur[prop];}}return prev;},Object.assign({},defaultValues));}function createStackEntry(props){var _props$animated,_props$showHideTransi;var animated=(_props$animated=props.animated)!=null?_props$animated:false;var showHideTransition=(_props$showHideTransi=props.showHideTransition)!=null?_props$showHideTransi:'fade';return{backgroundColor:props.backgroundColor!=null?{value:props.backgroundColor,animated:animated}:null,barStyle:props.barStyle!=null?{value:props.barStyle,animated:animated}:null,translucent:props.translucent,hidden:props.hidden!=null?{value:props.hidden,animated:animated,transition:showHideTransition}:null,networkActivityIndicatorVisible:props.networkActivityIndicatorVisible};}var StatusBar=function(_React$Component){function StatusBar(){var _this;(0,_classCallCheck2.default)(this,StatusBar);for(var _len=arguments.length,args=new Array(_len),_key=0;_key<_len;_key++){args[_key]=arguments[_key];}_this=_callSuper(this,StatusBar,[].concat(args));_this._stackEntry=null;return _this;}(0,_inherits2.default)(StatusBar,_React$Component);return(0,_createClass2.default)(StatusBar,[{key:"componentDidMount",value:function componentDidMount(){this._stackEntry=StatusBar.pushStackEntry(this.props);}},{key:"componentWillUnmount",value:function componentWillUnmount(){StatusBar.popStackEntry(this._stackEntry);}},{key:"componentDidUpdate",value:function componentDidUpdate(){this._stackEntry=StatusBar.replaceStackEntry(this._stackEntry,this.props);}},{key:"render",value:function render(){return null;}}],[{key:"setHidden",value:function setHidden(hidden,animation){animation=animation||'none';StatusBar._defaultProps.hidden.value=hidden;if(_Platform.default.OS==='ios'){_NativeStatusBarManagerIOS.default.setHidden(hidden,animation);}else if(_Platform.default.OS==='android'){_NativeStatusBarManagerAndroid.default.setHidden(hidden);}}},{key:"setBarStyle",value:function setBarStyle(style,animated){animated=animated||false;StatusBar._defaultProps.barStyle.value=style;if(_Platform.default.OS==='ios'){_NativeStatusBarManagerIOS.default.setStyle(style,animated);}else if(_Platform.default.OS==='android'){_NativeStatusBarManagerAndroid.default.setStyle(style);}}},{key:"setNetworkActivityIndicatorVisible",value:function setNetworkActivityIndicatorVisible(visible){if(_Platform.default.OS!=='ios'){console.warn('`setNetworkActivityIndicatorVisible` is only available on iOS');return;}StatusBar._defaultProps.networkActivityIndicatorVisible=visible;_NativeStatusBarManagerIOS.default.setNetworkActivityIndicatorVisible(visible);}},{key:"setBackgroundColor",value:function setBackgroundColor(color,animated){if(_Platform.default.OS!=='android'){console.warn('`setBackgroundColor` is only available on Android');return;}animated=animated||false;StatusBar._defaultProps.backgroundColor.value=color;var processedColor=(0,_processColor.default)(color);if(processedColor==null){console.warn(`\`StatusBar.setBackgroundColor\`: Color ${color} parsed to null or undefined`);return;}(0,_invariant.default)(typeof processedColor==='number','Unexpected color given for StatusBar.setBackgroundColor');_NativeStatusBarManagerAndroid.default.setColor(processedColor,animated);}},{key:"setTranslucent",value:function setTranslucent(translucent){if(_Platform.default.OS!=='android'){console.warn('`setTranslucent` is only available on Android');return;}StatusBar._defaultProps.translucent=translucent;_NativeStatusBarManagerAndroid.default.setTranslucent(translucent);}},{key:"pushStackEntry",value:function pushStackEntry(props){var entry=createStackEntry(props);StatusBar._propsStack.push(entry);StatusBar._updatePropsStack();return entry;}},{key:"popStackEntry",value:function popStackEntry(entry){var index=StatusBar._propsStack.indexOf(entry);if(index!==-1){StatusBar._propsStack.splice(index,1);}StatusBar._updatePropsStack();}},{key:"replaceStackEntry",value:function replaceStackEntry(entry,props){var newEntry=createStackEntry(props);var index=StatusBar._propsStack.indexOf(entry);if(index!==-1){StatusBar._propsStack[index]=newEntry;}StatusBar._updatePropsStack();return newEntry;}}]);}(React.Component);_StatusBar=StatusBar;StatusBar._propsStack=[];StatusBar._defaultProps=createStackEntry({backgroundColor:_Platform.default.OS==='android'?(_NativeStatusBarManag=_NativeStatusBarManagerAndroid.default.getConstants().DEFAULT_BACKGROUND_COLOR)!=null?_NativeStatusBarManag:'black':'black',barStyle:'default',translucent:false,hidden:false,networkActivityIndicatorVisible:false});StatusBar._updateImmediate=null;StatusBar._currentValues=null;StatusBar.currentHeight=_Platform.default.OS==='android'?_NativeStatusBarManagerAndroid.default.getConstants().HEIGHT:null;StatusBar._updatePropsStack=function(){clearImmediate(_StatusBar._updateImmediate);_StatusBar._updateImmediate=setImmediate(function(){var oldProps=_StatusBar._currentValues;var mergedProps=mergePropsStack(_StatusBar._propsStack,_StatusBar._defaultProps);if(_Platform.default.OS==='ios'){if(!oldProps||oldProps.barStyle.value!==mergedProps.barStyle.value){_NativeStatusBarManagerIOS.default.setStyle(mergedProps.barStyle.value,mergedProps.barStyle.animated||false);}if(!oldProps||oldProps.hidden.value!==mergedProps.hidden.value){_NativeStatusBarManagerIOS.default.setHidden(mergedProps.hidden.value,mergedProps.hidden.animated?mergedProps.hidden.transition:'none');}if(!oldProps||oldProps.networkActivityIndicatorVisible!==mergedProps.networkActivityIndicatorVisible){_NativeStatusBarManagerIOS.default.setNetworkActivityIndicatorVisible(mergedProps.networkActivityIndicatorVisible);}}else if(_Platform.default.OS==='android'){_NativeStatusBarManagerAndroid.default.setStyle(mergedProps.barStyle.value);var processedColor=(0,_processColor.default)(mergedProps.backgroundColor.value);if(processedColor==null){console.warn(`\`StatusBar._updatePropsStack\`: Color ${mergedProps.backgroundColor.value} parsed to null or undefined`);}else{(0,_invariant.default)(typeof processedColor==='number','Unexpected color given in StatusBar._updatePropsStack');_NativeStatusBarManagerAndroid.default.setColor(processedColor,mergedProps.backgroundColor.animated);}if(!oldProps||oldProps.hidden.value!==mergedProps.hidden.value){_NativeStatusBarManagerAndroid.default.setHidden(mergedProps.hidden.value);}if(!oldProps||oldProps.translucent!==mergedProps.translucent||mergedProps.translucent){_NativeStatusBarManagerAndroid.default.setTranslucent(mergedProps.translucent);}}_StatusBar._currentValues=mergedProps;});};module.exports=StatusBar;
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 4136:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=exports.Commands=void 0;var _codegenNativeCommands=_interopRequireDefault(__webpack_require__(7830));var _codegenNativeComponent=_interopRequireDefault(__webpack_require__(9021));var React=_interopRequireWildcard(__webpack_require__(6540));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var Commands=exports.Commands=(0,_codegenNativeCommands.default)({supportedCommands:['setNativeValue']});var _default=exports["default"]=(0,_codegenNativeComponent.default)('AndroidSwitch',{interfaceOnly:true});
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 7163:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var __webpack_unused_export__;
var _interopRequireDefault=__webpack_require__(4994);__webpack_unused_export__ = ({value:true});exports.A=void 0;var _slicedToArray2=_interopRequireDefault(__webpack_require__(5715));var _objectWithoutProperties2=_interopRequireDefault(__webpack_require__(1847));var _StyleSheet=_interopRequireDefault(__webpack_require__(6556));var _Platform=_interopRequireDefault(__webpack_require__(8192));var _useMergeRefs=_interopRequireDefault(__webpack_require__(9443));var _AndroidSwitchNativeComponent=_interopRequireWildcard(__webpack_require__(4136));var _SwitchNativeComponent=_interopRequireWildcard(__webpack_require__(9533));var React=_interopRequireWildcard(__webpack_require__(6540));var _jsxRuntime=__webpack_require__(4848);var _excluded=["disabled","ios_backgroundColor","onChange","onValueChange","style","thumbColor","trackColor","value"];function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var returnsFalse=function returnsFalse(){return false;};var returnsTrue=function returnsTrue(){return true;};var SwitchWithForwardedRef=React.forwardRef(function Switch(props,forwardedRef){var disabled=props.disabled,ios_backgroundColor=props.ios_backgroundColor,onChange=props.onChange,onValueChange=props.onValueChange,style=props.style,thumbColor=props.thumbColor,trackColor=props.trackColor,value=props.value,restProps=(0,_objectWithoutProperties2.default)(props,_excluded);var trackColorForFalse=trackColor==null?void 0:trackColor.false;var trackColorForTrue=trackColor==null?void 0:trackColor.true;var nativeSwitchRef=React.useRef(null);var ref=(0,_useMergeRefs.default)(nativeSwitchRef,forwardedRef);var _React$useState=React.useState({value:null}),_React$useState2=(0,_slicedToArray2.default)(_React$useState,2),native=_React$useState2[0],setNative=_React$useState2[1];var handleChange=function handleChange(event){onChange==null?void 0:onChange(event);onValueChange==null?void 0:onValueChange(event.nativeEvent.value);setNative({value:event.nativeEvent.value});};React.useLayoutEffect(function(){var _nativeSwitchRef$curr;var jsValue=value===true;var shouldUpdateNativeSwitch=native.value!=null&&native.value!==jsValue;if(shouldUpdateNativeSwitch&&((_nativeSwitchRef$curr=nativeSwitchRef.current)==null?void 0:_nativeSwitchRef$curr.setNativeProps)!=null){if(_Platform.default.OS==='android'){_AndroidSwitchNativeComponent.Commands.setNativeValue(nativeSwitchRef.current,jsValue);}else{_SwitchNativeComponent.Commands.setValue(nativeSwitchRef.current,jsValue);}}},[value,native]);if(_Platform.default.OS==='android'){var _props$accessibilityR;var accessibilityState=restProps.accessibilityState;var _disabled=disabled!=null?disabled:accessibilityState==null?void 0:accessibilityState.disabled;var _accessibilityState=_disabled!==(accessibilityState==null?void 0:accessibilityState.disabled)?Object.assign({},accessibilityState,{disabled:_disabled}):accessibilityState;var platformProps={accessibilityState:_accessibilityState,enabled:_disabled!==true,on:value===true,style:style,thumbTintColor:thumbColor,trackColorForFalse:trackColorForFalse,trackColorForTrue:trackColorForTrue,trackTintColor:value===true?trackColorForTrue:trackColorForFalse};return(0,_jsxRuntime.jsx)(_AndroidSwitchNativeComponent.default,Object.assign({},restProps,platformProps,{accessibilityRole:(_props$accessibilityR=props.accessibilityRole)!=null?_props$accessibilityR:'switch',onChange:handleChange,onResponderTerminationRequest:returnsFalse,onStartShouldSetResponder:returnsTrue,ref:ref}));}else{var _props$accessibilityR2;var _platformProps={disabled:disabled,onTintColor:trackColorForTrue,style:_StyleSheet.default.compose({height:31,width:51},_StyleSheet.default.compose(style,ios_backgroundColor==null?null:{backgroundColor:ios_backgroundColor,borderRadius:16})),thumbTintColor:thumbColor,tintColor:trackColorForFalse,value:value===true};return(0,_jsxRuntime.jsx)(_SwitchNativeComponent.default,Object.assign({},restProps,_platformProps,{accessibilityRole:(_props$accessibilityR2=props.accessibilityRole)!=null?_props$accessibilityR2:'switch',onChange:handleChange,onResponderTerminationRequest:returnsFalse,onStartShouldSetResponder:returnsTrue,ref:ref}));}});var _default=exports.A=SwitchWithForwardedRef;
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 9533:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=exports.Commands=void 0;var _codegenNativeCommands=_interopRequireDefault(__webpack_require__(7830));var _codegenNativeComponent=_interopRequireDefault(__webpack_require__(9021));var React=_interopRequireWildcard(__webpack_require__(6540));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var Commands=exports.Commands=(0,_codegenNativeCommands.default)({supportedCommands:['setValue']});var _default=exports["default"]=(0,_codegenNativeComponent.default)('Switch',{paperComponentName:'RCTSwitch',excludedPlatforms:['android']});
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 9786:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=exports.__INTERNAL_VIEW_CONFIG=exports.Commands=void 0;var NativeComponentRegistry=_interopRequireWildcard(__webpack_require__(1153));var _codegenNativeCommands=_interopRequireDefault(__webpack_require__(7830));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var Commands=exports.Commands=(0,_codegenNativeCommands.default)({supportedCommands:['focus','blur','setTextAndSelection']});var __INTERNAL_VIEW_CONFIG=exports.__INTERNAL_VIEW_CONFIG={uiViewClassName:'AndroidTextInput',bubblingEventTypes:{topBlur:{phasedRegistrationNames:{bubbled:'onBlur',captured:'onBlurCapture'}},topEndEditing:{phasedRegistrationNames:{bubbled:'onEndEditing',captured:'onEndEditingCapture'}},topFocus:{phasedRegistrationNames:{bubbled:'onFocus',captured:'onFocusCapture'}},topKeyPress:{phasedRegistrationNames:{bubbled:'onKeyPress',captured:'onKeyPressCapture'}},topSubmitEditing:{phasedRegistrationNames:{bubbled:'onSubmitEditing',captured:'onSubmitEditingCapture'}},topTextInput:{phasedRegistrationNames:{bubbled:'onTextInput',captured:'onTextInputCapture'}}},directEventTypes:{topScroll:{registrationName:'onScroll'}},validAttributes:{maxFontSizeMultiplier:true,adjustsFontSizeToFit:true,minimumFontScale:true,autoFocus:true,placeholder:true,inlineImagePadding:true,contextMenuHidden:true,textShadowColor:{process:(__webpack_require__(5372)["default"])},maxLength:true,selectTextOnFocus:true,textShadowRadius:true,underlineColorAndroid:{process:(__webpack_require__(5372)["default"])},textDecorationLine:true,submitBehavior:true,textAlignVertical:true,fontStyle:true,textShadowOffset:true,selectionColor:{process:(__webpack_require__(5372)["default"])},placeholderTextColor:{process:(__webpack_require__(5372)["default"])},importantForAutofill:true,lineHeight:true,textTransform:true,returnKeyType:true,keyboardType:true,multiline:true,color:{process:(__webpack_require__(5372)["default"])},autoComplete:true,numberOfLines:true,letterSpacing:true,returnKeyLabel:true,fontSize:true,onKeyPress:true,cursorColor:{process:(__webpack_require__(5372)["default"])},text:true,showSoftInputOnFocus:true,textAlign:true,autoCapitalize:true,autoCorrect:true,caretHidden:true,secureTextEntry:true,textBreakStrategy:true,onScroll:true,onContentSizeChange:true,disableFullscreenUI:true,includeFontPadding:true,fontWeight:true,fontFamily:true,allowFontScaling:true,onSelectionChange:true,mostRecentEventCount:true,inlineImageLeft:true,editable:true,fontVariant:true,borderBottomRightRadius:true,borderBottomColor:{process:(__webpack_require__(5372)["default"])},borderRadius:true,borderRightColor:{process:(__webpack_require__(5372)["default"])},borderColor:{process:(__webpack_require__(5372)["default"])},borderTopRightRadius:true,borderStyle:true,borderBottomLeftRadius:true,borderLeftColor:{process:(__webpack_require__(5372)["default"])},borderTopLeftRadius:true,borderTopColor:{process:(__webpack_require__(5372)["default"])}}};var AndroidTextInputNativeComponent=NativeComponentRegistry.get('AndroidTextInput',function(){return __INTERNAL_VIEW_CONFIG;});var _default=exports["default"]=AndroidTextInputNativeComponent;
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 2829:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _classCallCheck2=_interopRequireDefault(__webpack_require__(7383));var _createClass2=_interopRequireDefault(__webpack_require__(4579));var _possibleConstructorReturn2=_interopRequireDefault(__webpack_require__(8452));var _getPrototypeOf2=_interopRequireDefault(__webpack_require__(3072));var _inherits2=_interopRequireDefault(__webpack_require__(9511));var _StyleSheet=_interopRequireDefault(__webpack_require__(6556));var _Platform=_interopRequireDefault(__webpack_require__(8192));var _RCTInputAccessoryViewNativeComponent=_interopRequireDefault(__webpack_require__(3198));var React=_interopRequireWildcard(__webpack_require__(6540));var _jsxRuntime=__webpack_require__(4848);function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}function _callSuper(t,o,e){return o=(0,_getPrototypeOf2.default)(o),(0,_possibleConstructorReturn2.default)(t,_isNativeReflectConstruct()?Reflect.construct(o,e||[],(0,_getPrototypeOf2.default)(t).constructor):o.apply(t,e));}function _isNativeReflectConstruct(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}));}catch(t){}return(_isNativeReflectConstruct=function _isNativeReflectConstruct(){return!!t;})();}var InputAccessoryView=function(_React$Component){function InputAccessoryView(){(0,_classCallCheck2.default)(this,InputAccessoryView);return _callSuper(this,InputAccessoryView,arguments);}(0,_inherits2.default)(InputAccessoryView,_React$Component);return(0,_createClass2.default)(InputAccessoryView,[{key:"render",value:function render(){if(_Platform.default.OS==='ios'){if(React.Children.count(this.props.children)===0){return null;}return(0,_jsxRuntime.jsx)(_RCTInputAccessoryViewNativeComponent.default,{style:[this.props.style,styles.container],nativeID:this.props.nativeID,backgroundColor:this.props.backgroundColor,children:this.props.children});}else{console.warn('<InputAccessoryView> is only supported on iOS.');return null;}}}]);}(React.Component);var styles=_StyleSheet.default.create({container:{position:'absolute'}});module.exports=InputAccessoryView;
};
}
}
}
}).call(__webpack_require__._LM_("4", { module,__webpack_require__}))()
/***/ }),
/***/ 3198:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=void 0;var _codegenNativeComponent=_interopRequireDefault(__webpack_require__(9021));var _default=exports["default"]=(0,_codegenNativeComponent.default)('InputAccessory',{interfaceOnly:true,paperComponentName:'RCTInputAccessoryView',excludedPlatforms:['android']});
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 5015:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var __webpack_unused_export__;
var _interopRequireDefault=__webpack_require__(4994);__webpack_unused_export__ = ({value:true});exports.Ay=__webpack_unused_export__=exports.Ts=void 0;var NativeComponentRegistry=_interopRequireWildcard(__webpack_require__(1153));var _codegenNativeCommands=_interopRequireDefault(__webpack_require__(7830));var _RCTTextInputViewConfig=_interopRequireDefault(__webpack_require__(2615));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var Commands=exports.Ts=(0,_codegenNativeCommands.default)({supportedCommands:['focus','blur','setTextAndSelection']});var __INTERNAL_VIEW_CONFIG=__webpack_unused_export__=Object.assign({uiViewClassName:'RCTMultilineTextInputView'},_RCTTextInputViewConfig.default,{validAttributes:Object.assign({},_RCTTextInputViewConfig.default.validAttributes,{dataDetectorTypes:true})});var MultilineTextInputNativeComponent=NativeComponentRegistry.get('RCTMultilineTextInputView',function(){return __INTERNAL_VIEW_CONFIG;});var _default=exports.Ay=MultilineTextInputNativeComponent;
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 8980:
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);Object.defineProperty(exports, "__esModule", ({value:true}));exports["default"]=exports.__INTERNAL_VIEW_CONFIG=exports.Commands=void 0;var NativeComponentRegistry=_interopRequireWildcard(__webpack_require__(1153));var _codegenNativeCommands=_interopRequireDefault(__webpack_require__(7830));var _RCTTextInputViewConfig=_interopRequireDefault(__webpack_require__(2615));function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var Commands=exports.Commands=(0,_codegenNativeCommands.default)({supportedCommands:['focus','blur','setTextAndSelection']});var __INTERNAL_VIEW_CONFIG=exports.__INTERNAL_VIEW_CONFIG=Object.assign({uiViewClassName:'RCTSinglelineTextInputView'},_RCTTextInputViewConfig.default);var SinglelineTextInputNativeComponent=NativeComponentRegistry.get('RCTSinglelineTextInputView',function(){return __INTERNAL_VIEW_CONFIG;});var _default=exports["default"]=SinglelineTextInputNativeComponent;
};
}
}
}
}).call(__webpack_require__._LM_("4", { exports,__webpack_require__}))()
/***/ }),
/***/ 2615:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _ViewConfigIgnore=__webpack_require__(4987);var RCTTextInputViewConfig={bubblingEventTypes:{topBlur:{phasedRegistrationNames:{bubbled:'onBlur',captured:'onBlurCapture'}},topChange:{phasedRegistrationNames:{bubbled:'onChange',captured:'onChangeCapture'}},topContentSizeChange:{phasedRegistrationNames:{captured:'onContentSizeChangeCapture',bubbled:'onContentSizeChange'}},topEndEditing:{phasedRegistrationNames:{bubbled:'onEndEditing',captured:'onEndEditingCapture'}},topFocus:{phasedRegistrationNames:{bubbled:'onFocus',captured:'onFocusCapture'}},topKeyPress:{phasedRegistrationNames:{bubbled:'onKeyPress',captured:'onKeyPressCapture'}},topSubmitEditing:{phasedRegistrationNames:{bubbled:'onSubmitEditing',captured:'onSubmitEditingCapture'}},topTouchCancel:{phasedRegistrationNames:{bubbled:'onTouchCancel',captured:'onTouchCancelCapture'}},topTouchEnd:{phasedRegistrationNames:{bubbled:'onTouchEnd',captured:'onTouchEndCapture'}},topTouchMove:{phasedRegistrationNames:{bubbled:'onTouchMove',captured:'onTouchMoveCapture'}}},directEventTypes:{topTextInput:{registrationName:'onTextInput'},topKeyPressSync:{registrationName:'onKeyPressSync'},topScroll:{registrationName:'onScroll'},topSelectionChange:{registrationName:'onSelectionChange'},topChangeSync:{registrationName:'onChangeSync'}},validAttributes:Object.assign({fontSize:true,fontWeight:true,fontVariant:true,textShadowOffset:{diff:__webpack_require__(8061)},allowFontScaling:true,fontStyle:true,textTransform:true,textAlign:true,fontFamily:true,lineHeight:true,isHighlighted:true,writingDirection:true,textDecorationLine:true,textShadowRadius:true,letterSpacing:true,textDecorationStyle:true,textDecorationColor:{process:(__webpack_require__(5372)["default"])},color:{process:(__webpack_require__(5372)["default"])},maxFontSizeMultiplier:true,textShadowColor:{process:(__webpack_require__(5372)["default"])},editable:true,inputAccessoryViewID:true,caretHidden:true,enablesReturnKeyAutomatically:true,placeholderTextColor:{process:(__webpack_require__(5372)["default"])},clearButtonMode:true,keyboardType:true,selection:true,returnKeyType:true,submitBehavior:true,mostRecentEventCount:true,scrollEnabled:true,selectionColor:{process:(__webpack_require__(5372)["default"])},contextMenuHidden:true,secureTextEntry:true,placeholder:true,autoCorrect:true,multiline:true,textContentType:true,maxLength:true,autoCapitalize:true,keyboardAppearance:true,passwordRules:true,spellCheck:true,selectTextOnFocus:true,text:true,clearTextOnFocus:true,showSoftInputOnFocus:true,autoFocus:true,lineBreakStrategyIOS:true},(0,_ViewConfigIgnore.ConditionallyIgnoredEventHandlers)({onChange:true,onSelectionChange:true,onContentSizeChange:true,onScroll:true,onChangeSync:true,onKeyPressSync:true,onTextInput:true}))};module.exports=RCTTextInputViewConfig;
};
}
}
}
}).call(__webpack_require__._LM_("4", { __webpack_require__,module}))()
/***/ }),
/***/ 7729:
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
(function(){
if (!this.ST) return ()=>{};
with (this.ST) {
with (this.RH) {
with (this.G) {
return function() { 'use strict';
var _interopRequireDefault=__webpack_require__(4994);var _slicedToArray2=_interopRequireDefault(__webpack_require__(5715));var _objectWithoutProperties2=_interopRequireDefault(__webpack_require__(1847));var _usePressability=_interopRequireDefault(__webpack_require__(2861));var _flattenStyle=_interopRequireDefault(__webpack_require__(9259));var _StyleSheet=_interopRequireDefault(__webpack_require__(6556));var _Text=_interopRequireDefault(__webpack_require__(7766));var _TextAncestor=_interopRequireDefault(__webpack_require__(3999));var _Platform=_interopRequireDefault(__webpack_require__(8192));var _useMergeRefs=_interopRequireDefault(__webpack_require__(9443));var _TextInputState=_interopRequireDefault(__webpack_require__(4080));var _invariant=_interopRequireDefault(__webpack_require__(311));var _nullthrows=_interopRequireDefault(__webpack_require__(801));var _react=_interopRequireWildcard(__webpack_require__(6540));var React=_react;var _jsxRuntime=__webpack_require__(4848);var _excluded=["aria-busy","aria-checked","aria-disabled","aria-expanded","aria-selected","accessibilityState","id","tabIndex","selection"],_excluded2=["onBlur","onFocus"],_excluded3=["allowFontScaling","rejectResponderTermination","underlineColorAndroid","autoComplete","textContentType","readOnly","editable","enterKeyHint","returnKeyType","inputMode","showSoftInputOnFocus","keyboardType"];function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var r=new WeakMap(),t=new WeakMap();return(_getRequireWildcardCache=function _getRequireWildcardCache(e){return e?t:r;})(e);}function _interopRequireWildcard(e,r){if(!r&&e&&e.__esModule)return e;if(null===e||"object"!=typeof e&&"function"!=typeof e)return{default:e};var t=_getRequireWildcardCache(r);if(t&&t.has(e))return t.get(e);var n={__proto__:null},a=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var u in e)if("default"!==u&&{}.hasOwnProperty.call(e,u)){var i=a?Object.getOwnPropertyDescriptor(e,u):null;i&&(i.get||i.set)?Object.defineProperty(n,u,i):n[u]=e[u];}return n.default=e,t&&t.set(e,n),n;}var AndroidTextInput;var AndroidTextInputCommands;var RCTSinglelineTextInputView;var RCTSinglelineTextInputNativeCommands;var RCTMultilineTextInputView;var RCTMultilineTextInputNativeCommands;if(_Platform.default.OS==='android'){AndroidTextInput=(__webpack_require__(9786)["default"]);AndroidTextInputCommands=(__webpack_require__(9786).Commands);}else if(_Platform.default.OS==='ios'){RCTSinglelineTextInputView=(__webpack_require__(8980)["default"]);RCTSinglelineTextInputNativeCommands=(__webpack_require__(8980).Commands);RCTMultilineTextInputView=(__webpack_require__(5015)/* ["default"] */ .Ay);RCTMultilineTextInputNativeCommands=(__webpack_require__(5015)/* .Commands */ .Ts);}var emptyFunctionThatReturnsTrue=function emptyFunctionThatReturnsTrue(){return true;};function InternalTextInput(props){var _propsSelection$end,_props$multiline;var ariaBusy=props['aria-busy'],ariaChecked=props['aria-checked'],ariaDisabled=props['aria-disabled'],ariaExpanded=props['aria-expanded'],ariaSelected=props['aria-selected'],accessibilityState=props.accessibilityState,id=props.id,tabIndex=props.tabIndex,propsSelection=props.selection,otherProps=(0,_objectWithoutProperties2.default)(props,_excluded);var inputRef=(0,_react.useRef)(null);var selection=propsSelection==null?null:{start:propsSelection.start,end:(_propsSelection$end=propsSelection.end)!=null?_propsSelection$end:propsSelection.start};var _useState=(0,_react.useState)(0),_useState2=(0,_slicedToArray2.default)(_useState,2),mostRecentEventCount=_useState2[0],setMostRecentEventCount=_useState2[1];var _useState3=(0,_react.useState)(props.value),_useState4=(0,_slicedToArray2.default)(_useState3,2),lastNativeText=_useState4[0],setLastNativeText=_useState4[1];var _useState5=(0,_react.useState)({selection:selection,mostRecentEventCount:mostRecentEventCount}),_useState6=(0,_slicedToArray2.default)(_useState5,2),lastNativeSelectionState=_useState6[0],setLastNativeSelection=_useState6[1];var lastNativeSelection=lastNativeSelectionState.selection;var viewCommands;if(AndroidTextInputCommands){viewCommands=AndroidTextInputCommands;}else{viewCommands=props.multiline===true?RCTMultilineTextInputNativeCommands:RCTSinglelineTextInputNativeCommands;}var text=typeof props.value==='string'?props.value:typeof props.defaultValue==='string'?props.defaultValue:'';(0,_react.useLayoutEffect)(function(){var nativeUpdate={};if(lastNativeText!==props.value&&typeof props.value==='string'){nativeUpdate.text=props.value;setLastNativeText(props.value);}if(selection&&lastNativeSelection&&(lastNativeSelection.start!==selection.start||lastNativeSelection.end!==selection.end)){nativeUpdate.selection=selection;setLastNativeSelection({selection:selection,mostRecentEventCount:mostRecentEventCount});}if(Object.keys(nativeUpdate).length===0){return;}if(inputRef.current!=null){var _selection$start,_selection$end;viewCommands.setTextAndSelection(inputRef.current,mostRecentEventCount,text,(_selection$start=selection==null?void 0:selection.start)!=null?_selection$start:-1,(_selection$end=selection==null?void 0:selection.end)!=null?_selection$end:-1);}},[mostRecentEventCount,inputRef,props.value,props.defaultValue,lastNativeText,selection,lastNativeSelection,text,viewCommands]);(0,_react.useLayoutEffect)(function(){var inputRefValue=inputRef.current;if(inputRefValue!=null){_TextInputState.default.registerInput(inputRefValue);return function(){_TextInputState.default.unregisterInput(inputRefValue);if(_TextInputState.default.currentlyFocusedInput()===inputRefValue){(0,_nullthrows.default)(inputRefValue).blur();}};}},[inputRef]);var setLocalRef=(0,_react.useCallback)(function(instance){inputRef.current=instance;if(instance!=null){Object.assign(instance,{clear:function clear(){if(inputRef.current!=null){viewCommands.setTextAndSelection(inputRef.current,mostRecentEventCount,'',0,0);}},isFocused:function isFocused(){return _TextInputState.default.currentlyFocusedInput()===inputRef.current;},getNativeRef:function getNativeRef(){return inputRef.current;},setSelection:function setSelection(start,end){if(inputRef.current!=null){viewCommands.setTextAndSelection(inputRef.current,mostRecentEventCount,null,start,end);}}});}},[mostRecentEventCount,viewCommands]);var ref=(0,_useMergeRefs.default)(setLocalRef,props.forwardedRef);var _onChange=function _onChange(event){var currentText=event.nativeEvent.text;props.onChange&&props.onChange(event);props.onChangeText&&props.onChangeText(currentText);if(inputRef.current==null){return;}setLastNativeText(currentText);setMostRecentEventCount(event.nativeEvent.eventCount);};var _onChangeSync=function _onChangeSync(event){var currentText=event.nativeEvent.text;props.unstable_onChangeSync&&props.unstable_onChangeSync(event);props.unstable_onChangeTextSync&&props.unstable_onChangeTextSync(currentText);if(inputRef.current==null){return;}setLastNativeText(currentText);setMostRecentEventCount(event.nativeEvent.eventCount);};var _onSelectionChange=function _onSelectionChange(event){props.onSelectionChange&&props.onSelectionChange(event);if(inputRef.current==null){return;}setLastNativeSelection({selection:event.nativeEvent.selection,mostRecentEventCount:mostRecentEventCount});};var _onFocus=function _onFocus(event){_TextInputState.default.focusInput(inputRef.current);if(props.onFocus){props.onFocus(event);}};var _onBlur=function _onBlur(event){_TextInputState.default.blurInput(inputRef.current);if(props.onBlur){props.onBlur(event);}};var _onScroll=function _onScroll(event){props.onScroll&&props.onScroll(event);};var textInput=null;var multiline=(_props$multiline=props.multiline)!=null?_props$mul
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment