@tonconnect/ui
Version:
TonConnect UI is a UI kit for TonConnect SDK. Use it to connect your app to TON wallets via TonConnect protocol.
1,513 lines • 496 kB
JavaScript
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a2, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a2, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a2, prop, b[prop]);
}
return a2;
};
var __spreadProps = (a2, b) => __defProps(a2, __getOwnPropDescs(b));
var __objRest = (source, exclude) => {
var target = {};
for (var prop in source)
if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
target[prop] = source[prop];
if (source != null && __getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(source)) {
if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
target[prop] = source[prop];
}
return target;
};
var __async = (__this, __arguments, generator) => {
return new Promise((resolve, reject) => {
var fulfilled = (value) => {
try {
step(generator.next(value));
} catch (e2) {
reject(e2);
}
};
var rejected = (value) => {
try {
step(generator.throw(value));
} catch (e2) {
reject(e2);
}
};
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
step((generator = generator.apply(__this, __arguments)).next());
});
};
var _a, _b, _c, _d, _e, _f, _g, _h;
import { TonConnectError, isWalletInfoCurrentlyInjected, toUserFriendlyAddress, CHAIN, TonConnect, isTelegramUrl, encodeTelegramUrlParameters, WalletMissingRequiredFeaturesError, isWalletInfoRemote, checkRequiredWalletFeatures, isWalletInfoCurrentlyEmbedded, BrowserEventDispatcher, createVersionInfo, createResponseVersionEvent, createRequestVersionEvent, createConnectionStartedEvent, createConnectionCompletedEvent, createConnectionErrorEvent, createConnectionRestoringStartedEvent, createConnectionRestoringCompletedEvent, createConnectionRestoringErrorEvent, createDisconnectionEvent, createTransactionSentForSignatureEvent, createTransactionSignedEvent, createTransactionSigningFailedEvent, createDataSentForSignatureEvent, createDataSignedEvent, createDataSigningFailedEvent, WalletNotSupportFeatureError, SessionCrypto } from "@tonconnect/sdk";
export * from "@tonconnect/sdk";
import UAParser from "ua-parser-js";
import deepmerge from "deepmerge";
import cn from "classnames";
const IS_DEV = false;
const equalFn = (a2, b) => a2 === b;
const $PROXY = Symbol("solid-proxy");
const SUPPORTS_PROXY = typeof Proxy === "function";
const $TRACK = Symbol("solid-track");
const signalOptions = {
equals: equalFn
};
let runEffects = runQueue;
const STALE = 1;
const PENDING = 2;
const UNOWNED = {
owned: null,
cleanups: null,
context: null,
owner: null
};
const NO_INIT = {};
var Owner = null;
let Transition$1 = null;
let ExternalSourceConfig = null;
let Listener = null;
let Updates = null;
let Effects = null;
let ExecCount = 0;
function createRoot(fn, detachedOwner) {
const listener = Listener, owner = Owner, unowned = fn.length === 0, current = detachedOwner === void 0 ? owner : detachedOwner, root = unowned ? UNOWNED : {
owned: null,
cleanups: null,
context: current ? current.context : null,
owner: current
}, updateFn = unowned ? fn : () => fn(() => untrack(() => cleanNode(root)));
Owner = root;
Listener = null;
try {
return runUpdates(updateFn, true);
} finally {
Listener = listener;
Owner = owner;
}
}
function createSignal(value, options) {
options = options ? Object.assign({}, signalOptions, options) : signalOptions;
const s2 = {
value,
observers: null,
observerSlots: null,
comparator: options.equals || void 0
};
const setter = (value2) => {
if (typeof value2 === "function") {
value2 = value2(s2.value);
}
return writeSignal(s2, value2);
};
return [readSignal.bind(s2), setter];
}
function createComputed(fn, value, options) {
const c2 = createComputation(fn, value, true, STALE);
updateComputation(c2);
}
function createRenderEffect(fn, value, options) {
const c2 = createComputation(fn, value, false, STALE);
updateComputation(c2);
}
function createEffect(fn, value, options) {
runEffects = runUserEffects;
const c2 = createComputation(fn, value, false, STALE);
if (!options || !options.render) c2.user = true;
Effects ? Effects.push(c2) : updateComputation(c2);
}
function createMemo(fn, value, options) {
options = options ? Object.assign({}, signalOptions, options) : signalOptions;
const c2 = createComputation(fn, value, true, 0);
c2.observers = null;
c2.observerSlots = null;
c2.comparator = options.equals || void 0;
updateComputation(c2);
return readSignal.bind(c2);
}
function isPromise(v) {
return v && typeof v === "object" && "then" in v;
}
function createResource(pSource, pFetcher, pOptions) {
let source;
let fetcher;
let options;
{
source = true;
fetcher = pSource;
options = {};
}
let pr = null, initP = NO_INIT, scheduled = false, resolved = "initialValue" in options, dynamic = typeof source === "function" && createMemo(source);
const contexts = /* @__PURE__ */ new Set(), [value, setValue] = (options.storage || createSignal)(options.initialValue), [error, setError] = createSignal(void 0), [track, trigger] = createSignal(void 0, {
equals: false
}), [state, setState] = createSignal(resolved ? "ready" : "unresolved");
function loadEnd(p2, v, error2, key) {
if (pr === p2) {
pr = null;
key !== void 0 && (resolved = true);
if ((p2 === initP || v === initP) && options.onHydrated) queueMicrotask(() => options.onHydrated(key, {
value: v
}));
initP = NO_INIT;
completeLoad(v, error2);
}
return v;
}
function completeLoad(v, err) {
runUpdates(() => {
if (err === void 0) setValue(() => v);
setState(err !== void 0 ? "errored" : resolved ? "ready" : "unresolved");
setError(err);
for (const c2 of contexts.keys()) c2.decrement();
contexts.clear();
}, false);
}
function read() {
const c2 = SuspenseContext, v = value(), err = error();
if (err !== void 0 && !pr) throw err;
if (Listener && !Listener.user && c2) ;
return v;
}
function load(refetching = true) {
if (refetching !== false && scheduled) return;
scheduled = false;
const lookup = dynamic ? dynamic() : source;
if (lookup == null || lookup === false) {
loadEnd(pr, untrack(value));
return;
}
let error2;
const p2 = initP !== NO_INIT ? initP : untrack(() => {
try {
return fetcher(lookup, {
value: value(),
refetching
});
} catch (fetcherError) {
error2 = fetcherError;
}
});
if (error2 !== void 0) {
loadEnd(pr, void 0, castError(error2), lookup);
return;
} else if (!isPromise(p2)) {
loadEnd(pr, p2, void 0, lookup);
return p2;
}
pr = p2;
if ("v" in p2) {
if (p2.s === 1) loadEnd(pr, p2.v, void 0, lookup);
else loadEnd(pr, void 0, castError(p2.v), lookup);
return p2;
}
scheduled = true;
queueMicrotask(() => scheduled = false);
runUpdates(() => {
setState(resolved ? "refreshing" : "pending");
trigger();
}, false);
return p2.then((v) => loadEnd(p2, v, void 0, lookup), (e2) => loadEnd(p2, void 0, castError(e2), lookup));
}
Object.defineProperties(read, {
state: {
get: () => state()
},
error: {
get: () => error()
},
loading: {
get() {
const s2 = state();
return s2 === "pending" || s2 === "refreshing";
}
},
latest: {
get() {
if (!resolved) return read();
const err = error();
if (err && !pr) throw err;
return value();
}
}
});
let owner = Owner;
if (dynamic) createComputed(() => (owner = Owner, load(false)));
else load(false);
return [read, {
refetch: (info) => runWithOwner(owner, () => load(info)),
mutate: setValue
}];
}
function batch(fn) {
return runUpdates(fn, false);
}
function untrack(fn) {
if (Listener === null) return fn();
const listener = Listener;
Listener = null;
try {
if (ExternalSourceConfig) ;
return fn();
} finally {
Listener = listener;
}
}
function on(deps, fn, options) {
const isArray = Array.isArray(deps);
let prevInput;
return (prevValue) => {
let input;
if (isArray) {
input = Array(deps.length);
for (let i2 = 0; i2 < deps.length; i2++) input[i2] = deps[i2]();
} else input = deps();
const result = untrack(() => fn(input, prevInput, prevValue));
prevInput = input;
return result;
};
}
function onMount(fn) {
createEffect(() => untrack(fn));
}
function onCleanup(fn) {
if (Owner === null) ;
else if (Owner.cleanups === null) Owner.cleanups = [fn];
else Owner.cleanups.push(fn);
return fn;
}
function getListener() {
return Listener;
}
function getOwner() {
return Owner;
}
function runWithOwner(o2, fn) {
const prev = Owner;
const prevListener = Listener;
Owner = o2;
Listener = null;
try {
return runUpdates(fn, true);
} catch (err) {
handleError(err);
} finally {
Owner = prev;
Listener = prevListener;
}
}
function startTransition(fn) {
const l2 = Listener;
const o2 = Owner;
return Promise.resolve().then(() => {
Listener = l2;
Owner = o2;
runUpdates(fn, false);
Listener = Owner = null;
return void 0;
});
}
const [transPending, setTransPending] = /* @__PURE__ */ createSignal(false);
function useTransition() {
return [transPending, startTransition];
}
function createContext(defaultValue, options) {
const id = Symbol("context");
return {
id,
Provider: createProvider(id),
defaultValue
};
}
function useContext(context) {
let value;
return Owner && Owner.context && (value = Owner.context[context.id]) !== void 0 ? value : context.defaultValue;
}
function children(fn) {
const children2 = createMemo(fn);
const memo2 = createMemo(() => resolveChildren(children2()));
memo2.toArray = () => {
const c2 = memo2();
return Array.isArray(c2) ? c2 : c2 != null ? [c2] : [];
};
return memo2;
}
let SuspenseContext;
function readSignal() {
if (this.sources && this.state) {
if (this.state === STALE) updateComputation(this);
else {
const updates = Updates;
Updates = null;
runUpdates(() => lookUpstream(this), false);
Updates = updates;
}
}
if (Listener) {
const sSlot = this.observers ? this.observers.length : 0;
if (!Listener.sources) {
Listener.sources = [this];
Listener.sourceSlots = [sSlot];
} else {
Listener.sources.push(this);
Listener.sourceSlots.push(sSlot);
}
if (!this.observers) {
this.observers = [Listener];
this.observerSlots = [Listener.sources.length - 1];
} else {
this.observers.push(Listener);
this.observerSlots.push(Listener.sources.length - 1);
}
}
return this.value;
}
function writeSignal(node, value, isComp) {
let current = node.value;
if (!node.comparator || !node.comparator(current, value)) {
node.value = value;
if (node.observers && node.observers.length) {
runUpdates(() => {
for (let i2 = 0; i2 < node.observers.length; i2 += 1) {
const o2 = node.observers[i2];
const TransitionRunning = Transition$1 && Transition$1.running;
if (TransitionRunning && Transition$1.disposed.has(o2)) ;
if (TransitionRunning ? !o2.tState : !o2.state) {
if (o2.pure) Updates.push(o2);
else Effects.push(o2);
if (o2.observers) markDownstream(o2);
}
if (!TransitionRunning) o2.state = STALE;
}
if (Updates.length > 1e6) {
Updates = [];
if (IS_DEV) ;
throw new Error();
}
}, false);
}
}
return value;
}
function updateComputation(node) {
if (!node.fn) return;
cleanNode(node);
const time = ExecCount;
runComputation(node, node.value, time);
}
function runComputation(node, value, time) {
let nextValue;
const owner = Owner, listener = Listener;
Listener = Owner = node;
try {
nextValue = node.fn(value);
} catch (err) {
if (node.pure) {
{
node.state = STALE;
node.owned && node.owned.forEach(cleanNode);
node.owned = null;
}
}
node.updatedAt = time + 1;
return handleError(err);
} finally {
Listener = listener;
Owner = owner;
}
if (!node.updatedAt || node.updatedAt <= time) {
if (node.updatedAt != null && "observers" in node) {
writeSignal(node, nextValue);
} else node.value = nextValue;
node.updatedAt = time;
}
}
function createComputation(fn, init, pure, state = STALE, options) {
const c2 = {
fn,
state,
updatedAt: null,
owned: null,
sources: null,
sourceSlots: null,
cleanups: null,
value: init,
owner: Owner,
context: Owner ? Owner.context : null,
pure
};
if (Owner === null) ;
else if (Owner !== UNOWNED) {
{
if (!Owner.owned) Owner.owned = [c2];
else Owner.owned.push(c2);
}
}
return c2;
}
function runTop(node) {
if (node.state === 0) return;
if (node.state === PENDING) return lookUpstream(node);
if (node.suspense && untrack(node.suspense.inFallback)) return node.suspense.effects.push(node);
const ancestors = [node];
while ((node = node.owner) && (!node.updatedAt || node.updatedAt < ExecCount)) {
if (node.state) ancestors.push(node);
}
for (let i2 = ancestors.length - 1; i2 >= 0; i2--) {
node = ancestors[i2];
if (node.state === STALE) {
updateComputation(node);
} else if (node.state === PENDING) {
const updates = Updates;
Updates = null;
runUpdates(() => lookUpstream(node, ancestors[0]), false);
Updates = updates;
}
}
}
function runUpdates(fn, init) {
if (Updates) return fn();
let wait = false;
if (!init) Updates = [];
if (Effects) wait = true;
else Effects = [];
ExecCount++;
try {
const res = fn();
completeUpdates(wait);
return res;
} catch (err) {
if (!wait) Effects = null;
Updates = null;
handleError(err);
}
}
function completeUpdates(wait) {
if (Updates) {
runQueue(Updates);
Updates = null;
}
if (wait) return;
const e2 = Effects;
Effects = null;
if (e2.length) runUpdates(() => runEffects(e2), false);
}
function runQueue(queue) {
for (let i2 = 0; i2 < queue.length; i2++) runTop(queue[i2]);
}
function runUserEffects(queue) {
let i2, userLength = 0;
for (i2 = 0; i2 < queue.length; i2++) {
const e2 = queue[i2];
if (!e2.user) runTop(e2);
else queue[userLength++] = e2;
}
for (i2 = 0; i2 < userLength; i2++) runTop(queue[i2]);
}
function lookUpstream(node, ignore) {
node.state = 0;
for (let i2 = 0; i2 < node.sources.length; i2 += 1) {
const source = node.sources[i2];
if (source.sources) {
const state = source.state;
if (state === STALE) {
if (source !== ignore && (!source.updatedAt || source.updatedAt < ExecCount)) runTop(source);
} else if (state === PENDING) lookUpstream(source, ignore);
}
}
}
function markDownstream(node) {
for (let i2 = 0; i2 < node.observers.length; i2 += 1) {
const o2 = node.observers[i2];
if (!o2.state) {
o2.state = PENDING;
if (o2.pure) Updates.push(o2);
else Effects.push(o2);
o2.observers && markDownstream(o2);
}
}
}
function cleanNode(node) {
let i2;
if (node.sources) {
while (node.sources.length) {
const source = node.sources.pop(), index = node.sourceSlots.pop(), obs = source.observers;
if (obs && obs.length) {
const n2 = obs.pop(), s2 = source.observerSlots.pop();
if (index < obs.length) {
n2.sourceSlots[s2] = index;
obs[index] = n2;
source.observerSlots[index] = s2;
}
}
}
}
if (node.tOwned) {
for (i2 = node.tOwned.length - 1; i2 >= 0; i2--) cleanNode(node.tOwned[i2]);
delete node.tOwned;
}
if (node.owned) {
for (i2 = node.owned.length - 1; i2 >= 0; i2--) cleanNode(node.owned[i2]);
node.owned = null;
}
if (node.cleanups) {
for (i2 = node.cleanups.length - 1; i2 >= 0; i2--) node.cleanups[i2]();
node.cleanups = null;
}
node.state = 0;
}
function castError(err) {
if (err instanceof Error) return err;
return new Error(typeof err === "string" ? err : "Unknown error", {
cause: err
});
}
function handleError(err, owner = Owner) {
const error = castError(err);
throw error;
}
function resolveChildren(children2) {
if (typeof children2 === "function" && !children2.length) return resolveChildren(children2());
if (Array.isArray(children2)) {
const results = [];
for (let i2 = 0; i2 < children2.length; i2++) {
const result = resolveChildren(children2[i2]);
Array.isArray(result) ? results.push.apply(results, result) : results.push(result);
}
return results;
}
return children2;
}
function createProvider(id, options) {
return function provider(props) {
let res;
createRenderEffect(() => res = untrack(() => {
Owner.context = __spreadProps(__spreadValues({}, Owner.context), {
[id]: props.value
});
return children(() => props.children);
}), void 0);
return res;
};
}
const FALLBACK = Symbol("fallback");
function dispose(d) {
for (let i2 = 0; i2 < d.length; i2++) d[i2]();
}
function mapArray(list, mapFn, options = {}) {
let items = [], mapped = [], disposers = [], len = 0, indexes = mapFn.length > 1 ? [] : null;
onCleanup(() => dispose(disposers));
return () => {
let newItems = list() || [], newLen = newItems.length, i2, j;
newItems[$TRACK];
return untrack(() => {
let newIndices, newIndicesNext, temp, tempdisposers, tempIndexes, start, end, newEnd, item;
if (newLen === 0) {
if (len !== 0) {
dispose(disposers);
disposers = [];
items = [];
mapped = [];
len = 0;
indexes && (indexes = []);
}
if (options.fallback) {
items = [FALLBACK];
mapped[0] = createRoot((disposer) => {
disposers[0] = disposer;
return options.fallback();
});
len = 1;
}
} else if (len === 0) {
mapped = new Array(newLen);
for (j = 0; j < newLen; j++) {
items[j] = newItems[j];
mapped[j] = createRoot(mapper);
}
len = newLen;
} else {
temp = new Array(newLen);
tempdisposers = new Array(newLen);
indexes && (tempIndexes = new Array(newLen));
for (start = 0, end = Math.min(len, newLen); start < end && items[start] === newItems[start]; start++) ;
for (end = len - 1, newEnd = newLen - 1; end >= start && newEnd >= start && items[end] === newItems[newEnd]; end--, newEnd--) {
temp[newEnd] = mapped[end];
tempdisposers[newEnd] = disposers[end];
indexes && (tempIndexes[newEnd] = indexes[end]);
}
newIndices = /* @__PURE__ */ new Map();
newIndicesNext = new Array(newEnd + 1);
for (j = newEnd; j >= start; j--) {
item = newItems[j];
i2 = newIndices.get(item);
newIndicesNext[j] = i2 === void 0 ? -1 : i2;
newIndices.set(item, j);
}
for (i2 = start; i2 <= end; i2++) {
item = items[i2];
j = newIndices.get(item);
if (j !== void 0 && j !== -1) {
temp[j] = mapped[i2];
tempdisposers[j] = disposers[i2];
indexes && (tempIndexes[j] = indexes[i2]);
j = newIndicesNext[j];
newIndices.set(item, j);
} else disposers[i2]();
}
for (j = start; j < newLen; j++) {
if (j in temp) {
mapped[j] = temp[j];
disposers[j] = tempdisposers[j];
if (indexes) {
indexes[j] = tempIndexes[j];
indexes[j](j);
}
} else mapped[j] = createRoot(mapper);
}
mapped = mapped.slice(0, len = newLen);
items = newItems.slice(0);
}
return mapped;
});
function mapper(disposer) {
disposers[j] = disposer;
if (indexes) {
const [s2, set] = createSignal(j);
indexes[j] = set;
return mapFn(newItems[j], s2);
}
return mapFn(newItems[j]);
}
};
}
function createComponent(Comp, props) {
return untrack(() => Comp(props || {}));
}
function trueFn() {
return true;
}
const propTraps = {
get(_, property, receiver) {
if (property === $PROXY) return receiver;
return _.get(property);
},
has(_, property) {
if (property === $PROXY) return true;
return _.has(property);
},
set: trueFn,
deleteProperty: trueFn,
getOwnPropertyDescriptor(_, property) {
return {
configurable: true,
enumerable: true,
get() {
return _.get(property);
},
set: trueFn,
deleteProperty: trueFn
};
},
ownKeys(_) {
return _.keys();
}
};
function resolveSource(s2) {
return !(s2 = typeof s2 === "function" ? s2() : s2) ? {} : s2;
}
function resolveSources() {
for (let i2 = 0, length = this.length; i2 < length; ++i2) {
const v = this[i2]();
if (v !== void 0) return v;
}
}
function mergeProps(...sources) {
let proxy = false;
for (let i2 = 0; i2 < sources.length; i2++) {
const s2 = sources[i2];
proxy = proxy || !!s2 && $PROXY in s2;
sources[i2] = typeof s2 === "function" ? (proxy = true, createMemo(s2)) : s2;
}
if (SUPPORTS_PROXY && proxy) {
return new Proxy({
get(property) {
for (let i2 = sources.length - 1; i2 >= 0; i2--) {
const v = resolveSource(sources[i2])[property];
if (v !== void 0) return v;
}
},
has(property) {
for (let i2 = sources.length - 1; i2 >= 0; i2--) {
if (property in resolveSource(sources[i2])) return true;
}
return false;
},
keys() {
const keys = [];
for (let i2 = 0; i2 < sources.length; i2++) keys.push(...Object.keys(resolveSource(sources[i2])));
return [...new Set(keys)];
}
}, propTraps);
}
const sourcesMap = {};
const defined = /* @__PURE__ */ Object.create(null);
for (let i2 = sources.length - 1; i2 >= 0; i2--) {
const source = sources[i2];
if (!source) continue;
const sourceKeys = Object.getOwnPropertyNames(source);
for (let i3 = sourceKeys.length - 1; i3 >= 0; i3--) {
const key = sourceKeys[i3];
if (key === "__proto__" || key === "constructor") continue;
const desc = Object.getOwnPropertyDescriptor(source, key);
if (!defined[key]) {
defined[key] = desc.get ? {
enumerable: true,
configurable: true,
get: resolveSources.bind(sourcesMap[key] = [desc.get.bind(source)])
} : desc.value !== void 0 ? desc : void 0;
} else {
const sources2 = sourcesMap[key];
if (sources2) {
if (desc.get) sources2.push(desc.get.bind(source));
else if (desc.value !== void 0) sources2.push(() => desc.value);
}
}
}
}
const target = {};
const definedKeys = Object.keys(defined);
for (let i2 = definedKeys.length - 1; i2 >= 0; i2--) {
const key = definedKeys[i2], desc = defined[key];
if (desc && desc.get) Object.defineProperty(target, key, desc);
else target[key] = desc ? desc.value : void 0;
}
return target;
}
function splitProps(props, ...keys) {
if (SUPPORTS_PROXY && $PROXY in props) {
const blocked = new Set(keys.length > 1 ? keys.flat() : keys[0]);
const res = keys.map((k) => {
return new Proxy({
get(property) {
return k.includes(property) ? props[property] : void 0;
},
has(property) {
return k.includes(property) && property in props;
},
keys() {
return k.filter((property) => property in props);
}
}, propTraps);
});
res.push(new Proxy({
get(property) {
return blocked.has(property) ? void 0 : props[property];
},
has(property) {
return blocked.has(property) ? false : property in props;
},
keys() {
return Object.keys(props).filter((k) => !blocked.has(k));
}
}, propTraps));
return res;
}
const otherObject = {};
const objects = keys.map(() => ({}));
for (const propName of Object.getOwnPropertyNames(props)) {
const desc = Object.getOwnPropertyDescriptor(props, propName);
const isDefaultDesc = !desc.get && !desc.set && desc.enumerable && desc.writable && desc.configurable;
let blocked = false;
let objectIndex = 0;
for (const k of keys) {
if (k.includes(propName)) {
blocked = true;
isDefaultDesc ? objects[objectIndex][propName] = desc.value : Object.defineProperty(objects[objectIndex], propName, desc);
}
++objectIndex;
}
if (!blocked) {
isDefaultDesc ? otherObject[propName] = desc.value : Object.defineProperty(otherObject, propName, desc);
}
}
return [...objects, otherObject];
}
const narrowedError = (name) => `Stale read from <${name}>.`;
function For(props) {
const fallback = "fallback" in props && {
fallback: () => props.fallback
};
return createMemo(mapArray(() => props.each, props.children, fallback || void 0));
}
function Show(props) {
const keyed = props.keyed;
const conditionValue = createMemo(() => props.when, void 0, void 0);
const condition = keyed ? conditionValue : createMemo(conditionValue, void 0, {
equals: (a2, b) => !a2 === !b
});
return createMemo(() => {
const c2 = condition();
if (c2) {
const child = props.children;
const fn = typeof child === "function" && child.length > 0;
return fn ? untrack(() => child(keyed ? c2 : () => {
if (!untrack(condition)) throw narrowedError("Show");
return conditionValue();
})) : child;
}
return props.fallback;
}, void 0, void 0);
}
function Switch(props) {
const chs = children(() => props.children);
const switchFunc = createMemo(() => {
const ch = chs();
const mps = Array.isArray(ch) ? ch : [ch];
let func = () => void 0;
for (let i2 = 0; i2 < mps.length; i2++) {
const index = i2;
const mp = mps[i2];
const prevFunc = func;
const conditionValue = createMemo(() => prevFunc() ? void 0 : mp.when, void 0, void 0);
const condition = mp.keyed ? conditionValue : createMemo(conditionValue, void 0, {
equals: (a2, b) => !a2 === !b
});
func = () => prevFunc() || (condition() ? [index, conditionValue, mp] : void 0);
}
return func;
});
return createMemo(() => {
const sel = switchFunc()();
if (!sel) return props.fallback;
const [index, conditionValue, mp] = sel;
const child = mp.children;
const fn = typeof child === "function" && child.length > 0;
return fn ? untrack(() => child(mp.keyed ? conditionValue() : () => {
var _a2;
if (((_a2 = untrack(switchFunc)()) == null ? void 0 : _a2[0]) !== index) throw narrowedError("Match");
return conditionValue();
})) : child;
}, void 0, void 0);
}
function Match(props) {
return props;
}
const booleans = ["allowfullscreen", "async", "autofocus", "autoplay", "checked", "controls", "default", "disabled", "formnovalidate", "hidden", "indeterminate", "inert", "ismap", "loop", "multiple", "muted", "nomodule", "novalidate", "open", "playsinline", "readonly", "required", "reversed", "seamless", "selected"];
const Properties = /* @__PURE__ */ new Set(["className", "value", "readOnly", "noValidate", "formNoValidate", "isMap", "noModule", "playsInline", ...booleans]);
const ChildProperties = /* @__PURE__ */ new Set(["innerHTML", "textContent", "innerText", "children"]);
const Aliases = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(null), {
className: "class",
htmlFor: "for"
});
const PropAliases = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(null), {
class: "className",
novalidate: {
$: "noValidate",
FORM: 1
},
formnovalidate: {
$: "formNoValidate",
BUTTON: 1,
INPUT: 1
},
ismap: {
$: "isMap",
IMG: 1
},
nomodule: {
$: "noModule",
SCRIPT: 1
},
playsinline: {
$: "playsInline",
VIDEO: 1
},
readonly: {
$: "readOnly",
INPUT: 1,
TEXTAREA: 1
}
});
function getPropAlias(prop, tagName) {
const a2 = PropAliases[prop];
return typeof a2 === "object" ? a2[tagName] ? a2["$"] : void 0 : a2;
}
const DelegatedEvents = /* @__PURE__ */ new Set(["beforeinput", "click", "dblclick", "contextmenu", "focusin", "focusout", "input", "keydown", "keyup", "mousedown", "mousemove", "mouseout", "mouseover", "mouseup", "pointerdown", "pointermove", "pointerout", "pointerover", "pointerup", "touchend", "touchmove", "touchstart"]);
const SVGElements = /* @__PURE__ */ new Set([
"altGlyph",
"altGlyphDef",
"altGlyphItem",
"animate",
"animateColor",
"animateMotion",
"animateTransform",
"circle",
"clipPath",
"color-profile",
"cursor",
"defs",
"desc",
"ellipse",
"feBlend",
"feColorMatrix",
"feComponentTransfer",
"feComposite",
"feConvolveMatrix",
"feDiffuseLighting",
"feDisplacementMap",
"feDistantLight",
"feDropShadow",
"feFlood",
"feFuncA",
"feFuncB",
"feFuncG",
"feFuncR",
"feGaussianBlur",
"feImage",
"feMerge",
"feMergeNode",
"feMorphology",
"feOffset",
"fePointLight",
"feSpecularLighting",
"feSpotLight",
"feTile",
"feTurbulence",
"filter",
"font",
"font-face",
"font-face-format",
"font-face-name",
"font-face-src",
"font-face-uri",
"foreignObject",
"g",
"glyph",
"glyphRef",
"hkern",
"image",
"line",
"linearGradient",
"marker",
"mask",
"metadata",
"missing-glyph",
"mpath",
"path",
"pattern",
"polygon",
"polyline",
"radialGradient",
"rect",
"set",
"stop",
"svg",
"switch",
"symbol",
"text",
"textPath",
"tref",
"tspan",
"use",
"view",
"vkern"
]);
const SVGNamespace = {
xlink: "http://www.w3.org/1999/xlink",
xml: "http://www.w3.org/XML/1998/namespace"
};
const memo = (fn) => createMemo(() => fn());
function reconcileArrays(parentNode, a2, b) {
let bLength = b.length, aEnd = a2.length, bEnd = bLength, aStart = 0, bStart = 0, after = a2[aEnd - 1].nextSibling, map = null;
while (aStart < aEnd || bStart < bEnd) {
if (a2[aStart] === b[bStart]) {
aStart++;
bStart++;
continue;
}
while (a2[aEnd - 1] === b[bEnd - 1]) {
aEnd--;
bEnd--;
}
if (aEnd === aStart) {
const node = bEnd < bLength ? bStart ? b[bStart - 1].nextSibling : b[bEnd - bStart] : after;
while (bStart < bEnd) parentNode.insertBefore(b[bStart++], node);
} else if (bEnd === bStart) {
while (aStart < aEnd) {
if (!map || !map.has(a2[aStart])) a2[aStart].remove();
aStart++;
}
} else if (a2[aStart] === b[bEnd - 1] && b[bStart] === a2[aEnd - 1]) {
const node = a2[--aEnd].nextSibling;
parentNode.insertBefore(b[bStart++], a2[aStart++].nextSibling);
parentNode.insertBefore(b[--bEnd], node);
a2[aEnd] = b[bEnd];
} else {
if (!map) {
map = /* @__PURE__ */ new Map();
let i2 = bStart;
while (i2 < bEnd) map.set(b[i2], i2++);
}
const index = map.get(a2[aStart]);
if (index != null) {
if (bStart < index && index < bEnd) {
let i2 = aStart, sequence = 1, t2;
while (++i2 < aEnd && i2 < bEnd) {
if ((t2 = map.get(a2[i2])) == null || t2 !== index + sequence) break;
sequence++;
}
if (sequence > index - bStart) {
const node = a2[aStart];
while (bStart < index) parentNode.insertBefore(b[bStart++], node);
} else parentNode.replaceChild(b[bStart++], a2[aStart++]);
} else aStart++;
} else a2[aStart++].remove();
}
}
}
const $$EVENTS = "_$DX_DELEGATE";
function render(code, element, init, options = {}) {
let disposer;
createRoot((dispose2) => {
disposer = dispose2;
element === document ? code() : insert(element, code(), element.firstChild ? null : void 0, init);
}, options.owner);
return () => {
disposer();
element.textContent = "";
};
}
function template$1(html, isImportNode, isSVG, isMathML) {
let node;
const create = () => {
const t2 = isMathML ? document.createElementNS("http://www.w3.org/1998/Math/MathML", "template") : document.createElement("template");
t2.innerHTML = html;
return isSVG ? t2.content.firstChild.firstChild : isMathML ? t2.firstChild : t2.content.firstChild;
};
const fn = isImportNode ? () => untrack(() => document.importNode(node || (node = create()), true)) : () => (node || (node = create())).cloneNode(true);
fn.cloneNode = fn;
return fn;
}
function delegateEvents(eventNames, document2 = window.document) {
const e2 = document2[$$EVENTS] || (document2[$$EVENTS] = /* @__PURE__ */ new Set());
for (let i2 = 0, l2 = eventNames.length; i2 < l2; i2++) {
const name = eventNames[i2];
if (!e2.has(name)) {
e2.add(name);
document2.addEventListener(name, eventHandler);
}
}
}
function setAttribute(node, name, value) {
if (value == null) node.removeAttribute(name);
else node.setAttribute(name, value);
}
function setAttributeNS(node, namespace, name, value) {
if (value == null) node.removeAttributeNS(namespace, name);
else node.setAttributeNS(namespace, name, value);
}
function setBoolAttribute(node, name, value) {
value ? node.setAttribute(name, "") : node.removeAttribute(name);
}
function className(node, value) {
if (value == null) node.removeAttribute("class");
else node.className = value;
}
function addEventListener(node, name, handler, delegate) {
if (delegate) {
if (Array.isArray(handler)) {
node[`$$${name}`] = handler[0];
node[`$$${name}Data`] = handler[1];
} else node[`$$${name}`] = handler;
} else if (Array.isArray(handler)) {
const handlerFn = handler[0];
node.addEventListener(name, handler[0] = (e2) => handlerFn.call(node, handler[1], e2));
} else node.addEventListener(name, handler, typeof handler !== "function" && handler);
}
function classList(node, value, prev = {}) {
const classKeys = Object.keys(value || {}), prevKeys = Object.keys(prev);
let i2, len;
for (i2 = 0, len = prevKeys.length; i2 < len; i2++) {
const key = prevKeys[i2];
if (!key || key === "undefined" || value[key]) continue;
toggleClassKey(node, key, false);
delete prev[key];
}
for (i2 = 0, len = classKeys.length; i2 < len; i2++) {
const key = classKeys[i2], classValue = !!value[key];
if (!key || key === "undefined" || prev[key] === classValue || !classValue) continue;
toggleClassKey(node, key, true);
prev[key] = classValue;
}
return prev;
}
function style(node, value, prev) {
if (!value) return prev ? setAttribute(node, "style") : value;
const nodeStyle = node.style;
if (typeof value === "string") return nodeStyle.cssText = value;
typeof prev === "string" && (nodeStyle.cssText = prev = void 0);
prev || (prev = {});
value || (value = {});
let v, s2;
for (s2 in prev) {
value[s2] == null && nodeStyle.removeProperty(s2);
delete prev[s2];
}
for (s2 in value) {
v = value[s2];
if (v !== prev[s2]) {
nodeStyle.setProperty(s2, v);
prev[s2] = v;
}
}
return prev;
}
function spread(node, props = {}, isSVG, skipChildren) {
const prevProps = {};
{
createRenderEffect(() => prevProps.children = insertExpression(node, props.children, prevProps.children));
}
createRenderEffect(() => typeof props.ref === "function" && use(props.ref, node));
createRenderEffect(() => assign(node, props, isSVG, true, prevProps, true));
return prevProps;
}
function use(fn, element, arg) {
return untrack(() => fn(element, arg));
}
function insert(parent, accessor, marker, initial) {
if (marker !== void 0 && !initial) initial = [];
if (typeof accessor !== "function") return insertExpression(parent, accessor, initial, marker);
createRenderEffect((current) => insertExpression(parent, accessor(), current, marker), initial);
}
function assign(node, props, isSVG, skipChildren, prevProps = {}, skipRef = false) {
props || (props = {});
for (const prop in prevProps) {
if (!(prop in props)) {
if (prop === "children") continue;
prevProps[prop] = assignProp(node, prop, null, prevProps[prop], isSVG, skipRef, props);
}
}
for (const prop in props) {
if (prop === "children") {
continue;
}
const value = props[prop];
prevProps[prop] = assignProp(node, prop, value, prevProps[prop], isSVG, skipRef, props);
}
}
function toPropertyName(name) {
return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
}
function toggleClassKey(node, key, value) {
const classNames = key.trim().split(/\s+/);
for (let i2 = 0, nameLen = classNames.length; i2 < nameLen; i2++) node.classList.toggle(classNames[i2], value);
}
function assignProp(node, prop, value, prev, isSVG, skipRef, props) {
let isCE, isProp, isChildProp, propAlias, forceProp;
if (prop === "style") return style(node, value, prev);
if (prop === "classList") return classList(node, value, prev);
if (value === prev) return prev;
if (prop === "ref") {
if (!skipRef) value(node);
} else if (prop.slice(0, 3) === "on:") {
const e2 = prop.slice(3);
prev && node.removeEventListener(e2, prev, typeof prev !== "function" && prev);
value && node.addEventListener(e2, value, typeof value !== "function" && value);
} else if (prop.slice(0, 10) === "oncapture:") {
const e2 = prop.slice(10);
prev && node.removeEventListener(e2, prev, true);
value && node.addEventListener(e2, value, true);
} else if (prop.slice(0, 2) === "on") {
const name = prop.slice(2).toLowerCase();
const delegate = DelegatedEvents.has(name);
if (!delegate && prev) {
const h2 = Array.isArray(prev) ? prev[0] : prev;
node.removeEventListener(name, h2);
}
if (delegate || value) {
addEventListener(node, name, value, delegate);
delegate && delegateEvents([name]);
}
} else if (prop.slice(0, 5) === "attr:") {
setAttribute(node, prop.slice(5), value);
} else if (prop.slice(0, 5) === "bool:") {
setBoolAttribute(node, prop.slice(5), value);
} else if ((forceProp = prop.slice(0, 5) === "prop:") || (isChildProp = ChildProperties.has(prop)) || !isSVG && ((propAlias = getPropAlias(prop, node.tagName)) || (isProp = Properties.has(prop))) || (isCE = node.nodeName.includes("-") || "is" in props)) {
if (forceProp) {
prop = prop.slice(5);
isProp = true;
}
if (prop === "class" || prop === "className") className(node, value);
else if (isCE && !isProp && !isChildProp) node[toPropertyName(prop)] = value;
else node[propAlias || prop] = value;
} else {
const ns = isSVG && prop.indexOf(":") > -1 && SVGNamespace[prop.split(":")[0]];
if (ns) setAttributeNS(node, ns, prop, value);
else setAttribute(node, Aliases[prop] || prop, value);
}
return value;
}
function eventHandler(e2) {
let node = e2.target;
const key = `$$${e2.type}`;
const oriTarget = e2.target;
const oriCurrentTarget = e2.currentTarget;
const retarget = (value) => Object.defineProperty(e2, "target", {
configurable: true,
value
});
const handleNode = () => {
const handler = node[key];
if (handler && !node.disabled) {
const data = node[`${key}Data`];
data !== void 0 ? handler.call(node, data, e2) : handler.call(node, e2);
if (e2.cancelBubble) return;
}
node.host && typeof node.host !== "string" && !node.host._$host && node.contains(e2.target) && retarget(node.host);
return true;
};
const walkUpTree = () => {
while (handleNode() && (node = node._$host || node.parentNode || node.host)) ;
};
Object.defineProperty(e2, "currentTarget", {
configurable: true,
get() {
return node || document;
}
});
if (e2.composedPath) {
const path = e2.composedPath();
retarget(path[0]);
for (let i2 = 0; i2 < path.length - 2; i2++) {
node = path[i2];
if (!handleNode()) break;
if (node._$host) {
node = node._$host;
walkUpTree();
break;
}
if (node.parentNode === oriCurrentTarget) {
break;
}
}
} else walkUpTree();
retarget(oriTarget);
}
function insertExpression(parent, value, current, marker, unwrapArray) {
while (typeof current === "function") current = current();
if (value === current) return current;
const t2 = typeof value, multi = marker !== void 0;
parent = multi && current[0] && current[0].parentNode || parent;
if (t2 === "string" || t2 === "number") {
if (t2 === "number") {
value = value.toString();
if (value === current) return current;
}
if (multi) {
let node = current[0];
if (node && node.nodeType === 3) {
node.data !== value && (node.data = value);
} else node = document.createTextNode(value);
current = cleanChildren(parent, current, marker, node);
} else {
if (current !== "" && typeof current === "string") {
current = parent.firstChild.data = value;
} else current = parent.textContent = value;
}
} else if (value == null || t2 === "boolean") {
current = cleanChildren(parent, current, marker);
} else if (t2 === "function") {
createRenderEffect(() => {
let v = value();
while (typeof v === "function") v = v();
current = insertExpression(parent, v, current, marker);
});
return () => current;
} else if (Array.isArray(value)) {
const array = [];
const currentArray = current && Array.isArray(current);
if (normalizeIncomingArray(array, value, current, unwrapArray)) {
createRenderEffect(() => current = insertExpression(parent, array, current, marker, true));
return () => current;
}
if (array.length === 0) {
current = cleanChildren(parent, current, marker);
if (multi) return current;
} else if (currentArray) {
if (current.length === 0) {
appendNodes(parent, array, marker);
} else reconcileArrays(parent, current, array);
} else {
current && cleanChildren(parent);
appendNodes(parent, array);
}
current = array;
} else if (value.nodeType) {
if (Array.isArray(current)) {
if (multi) return current = cleanChildren(parent, current, marker, value);
cleanChildren(parent, current, null, value);
} else if (current == null || current === "" || !parent.firstChild) {
parent.appendChild(value);
} else parent.replaceChild(value, parent.firstChild);
current = value;
} else ;
return current;
}
function normalizeIncomingArray(normalized, array, current, unwrap2) {
let dynamic = false;
for (let i2 = 0, len = array.length; i2 < len; i2++) {
let item = array[i2], prev = current && current[normalized.length], t2;
if (item == null || item === true || item === false) ;
else if ((t2 = typeof item) === "object" && item.nodeType) {
normalized.push(item);
} else if (Array.isArray(item)) {
dynamic = normalizeIncomingArray(normalized, item, prev) || dynamic;
} else if (t2 === "function") {
if (unwrap2) {
while (typeof item === "function") item = item();
dynamic = normalizeIncomingArray(normalized, Array.isArray(item) ? item : [item], Array.isArray(prev) ? prev : [prev]) || dynamic;
} else {
normalized.push(item);
dynamic = true;
}
} else {
const value = String(item);
if (prev && prev.nodeType === 3 && prev.data === value) normalized.push(prev);
else normalized.push(document.createTextNode(value));
}
}
return dynamic;
}
function appendNodes(parent, array, marker = null) {
for (let i2 = 0, len = array.length; i2 < len; i2++) parent.insertBefore(array[i2], marker);
}
function cleanChildren(parent, current, marker, replacement) {
if (marker === void 0) return parent.textContent = "";
const node = replacement || document.createTextNode("");
if (current.length) {
let inserted = false;
for (let i2 = current.length - 1; i2 >= 0; i2--) {
const el = current[i2];
if (node !== el) {
const isParent = el.parentNode === parent;
if (!inserted && !i2) isParent ? parent.replaceChild(node, el) : parent.insertBefore(node, marker);
else isParent && el.remove();
} else inserted = true;
}
} else parent.insertBefore(node, marker);
return [node];
}
const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
function createElement(tagName, isSVG = false) {
return isSVG ? document.createElementNS(SVG_NAMESPACE, tagName) : document.createElement(tagName);
}
function Portal(props) {
const {
useShadow
} = props, marker = document.createTextNode(""), mount = () => props.mount || document.body, owner = getOwner();
let content;
createEffect(() => {
content || (content = runWithOwner(owner, () => createMemo(() => props.children)));
const el = mount();
if (el instanceof HTMLHeadElement) {
const [clean, setClean] = createSignal(false);
const cleanup = () => setClean(true);
createRoot((dispose2) => insert(el, () => !clean() ? content() : dispose2(), null));
onCleanup(cleanup);
} else {
const container = createElement(props.isSVG ? "g" : "div", props.isSVG), renderRoot = useShadow && container.attachShadow ? container.attachShadow({
mode: "open"
}) : container;
Object.defineProperty(container, "_$host", {
get() {
return marker.parentNode;
},
configurable: true
});
insert(renderRoot, content);
el.appendChild(container);
props.ref && props.ref(container);
onCleanup(() => el.removeChild(container));
}
}, void 0, {
render: true
});
return marker;
}
function createDynamic(component, props) {
const cached = createMemo(component);
return createMemo(() => {
const component2 = cached();
switch (typeof component2) {
case "function":
return untrack(() => component2(props));
case "string":
const isSvg = SVGElements.has(component2);
const el = createElement(component2, isSvg);
spread(el, props, isSvg);
return el;
}
});
}
function Dynamic(props) {
const [, others] = splitProps(props, ["component"]);
return createDynamic(() => props.component, others);
}
var THEME = /* @__PURE__ */ ((THEME2) => {
THEME2["DARK"] = "DARK";
THEME2["LIGHT"] = "LIGHT";
return THEME2;
})(THEME || {});
let e = { data: "" }, t = (t2) => "object" == typeof window ? ((t2 ? t2.querySelector("#_goober") : window._goober) || Object.assign((t2 || document.head).appendChild(document.createElement("style")), { innerHTML: " ", id: "_goober" })).firstChild : t2 || e, l = /(?:([\u0080-\uFFFF\w-%@]+) *:? *([^{;]+?);|([^;}{]*?) *{)|(}\s*)/g, a = /\/\*[^]*?\*\/| +/g, n = /\n+/g, o = (e2, t2) => {
let r = "", l2 = "", a2 = "";
for (let n2 in e2) {
let c2 = e2[n2];
"@" == n2[0] ? "i" == n2[1] ? r = n2 + " " + c2 + ";" : l2 += "f" == n2[1] ? o(c2, n2) : n2 + "{" + o(c2, "k" == n2[1] ? "" : t2) + "}" : "object" == typeof c2 ? l2 += o(c2, t2 ? t2.replace(/([^,])+/g, (e3) => n2.replace(/(^:.*)|([^,])+/g, (t3) => /&/.test(t3) ? t3.replace(/&/g, e3) : e3 ? e3 + " " + t3 : t3)) : n2) : null != c2 && (n2 = /^--/.test(n2) ? n2 : n2.replace(/[A-Z]/g, "-$&").toLowerCase(), a2 += o.p ? o.p(n2, c2) : n2 + ":" + c2 + ";");
}
return r + (t2 && a2 ? t2 + "{" + a2 + "}" : a2) + l2;
}, c = {}, s = (e2) => {
if ("object" == typeof e2) {
let t2 = "";
for (let r in e2) t2 += r + s(e2[r]);
return t2;
}
return e2;
}, i = (e2, t2, r, i2, p2) => {
let u2 = s(e2), d = c[u2] || (c[u2] = ((e3) => {
let t3 = 0, r2 = 11;
for (; t3 < e3.length; ) r2 = 101 * r2 + e3.charCodeAt(t3++) >>> 0;
return "go" + r2;
})(u2));
if (!c[d]) {
let t3 = u2 !== e2 ? e2 : ((e3) => {
let t4, r2, o2 = [{}];
for (; t4 = l.exec(e3.replace(a, "")); ) t4[4] ? o2.shift() : t4[3] ? (r2 = t4[3].replace(n, " ").trim(), o2.unshift(o2[0][r2] = o2[0][r2] || {})) : o2[0][t4[1]] = t4[2].replace(n, " ").trim();
return o2[0];
})(e2);
c[d] = o(p2 ? { ["@keyframes " + d]: t3 } : t3, r ? "" : "." + d);
}
let f = r && c.g ? c.g : null;
return r && (c.g = c[d]), ((e3, t3, r2, l2) => {
l2 ? t3.data = t3.data.replace(l2, e3) : -1 === t3.data.indexOf(e3) && (t3.data = r2 ? e3 + t3.data : t3.data + e3);
})(c[d], t2, i2, f), d;
}, p = (e2, t2, r) => e2.reduce((e3, l2, a2) => {
let n2 = t2[a2];
if (n2 && n2.call) {
let e4 = n2(r), t3 = e4 && e4.props && e4.props.className || /^go/.test(e4) && e4;
n2 = t3 ? "." + t3 : e4 && "object" == typeof e4 ? e4.props ? "" : o(e4, "") : false === e4 ? "" : e4;
}
return e3 + l2 + (null == n2 ? "" : n2);
}, "");
function u(e2) {
let r = this || {}, l2 = e2.call ? e2(r.p) : e2;
return i(l2.unshift ? l2.raw ? p(l2, [].slice.call(arguments, 1), r.p) : l2.reduce((e3