58f8093689
- Updated all component headers and documentation
- Changed navbar and footer branding
- Updated homepage hero badge
- Modified page title in index.html
- Simplified footer text to 'Built with ❤️'
- Consistent V2 capitalization across all references
2778 lines
86 KiB
JavaScript
2778 lines
86 KiB
JavaScript
// ../../node_modules/@tanstack/query-devtools/build/chunk/CXOMC62J.js
|
|
var sharedConfig = {
|
|
context: void 0,
|
|
registry: void 0,
|
|
effects: void 0,
|
|
done: false,
|
|
getContextId() {
|
|
return getContextId(this.context.count);
|
|
},
|
|
getNextContextId() {
|
|
return getContextId(this.context.count++);
|
|
}
|
|
};
|
|
function getContextId(count) {
|
|
const num = String(count), len = num.length - 1;
|
|
return sharedConfig.context.id + (len ? String.fromCharCode(96 + len) : "") + num;
|
|
}
|
|
function setHydrateContext(context) {
|
|
sharedConfig.context = context;
|
|
}
|
|
function nextHydrateContext() {
|
|
return {
|
|
...sharedConfig.context,
|
|
id: sharedConfig.getNextContextId(),
|
|
count: 0
|
|
};
|
|
}
|
|
var IS_DEV = false;
|
|
var equalFn = (a, b) => a === b;
|
|
var $PROXY = Symbol("solid-proxy");
|
|
var SUPPORTS_PROXY = typeof Proxy === "function";
|
|
var $TRACK = Symbol("solid-track");
|
|
var signalOptions = {
|
|
equals: equalFn
|
|
};
|
|
var ERROR = null;
|
|
var runEffects = runQueue;
|
|
var STALE = 1;
|
|
var PENDING = 2;
|
|
var UNOWNED = {
|
|
owned: null,
|
|
cleanups: null,
|
|
context: null,
|
|
owner: null
|
|
};
|
|
var NO_INIT = {};
|
|
var Owner = null;
|
|
var Transition = null;
|
|
var Scheduler = null;
|
|
var ExternalSourceConfig = null;
|
|
var Listener = null;
|
|
var Updates = null;
|
|
var Effects = null;
|
|
var 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 s = {
|
|
value,
|
|
observers: null,
|
|
observerSlots: null,
|
|
comparator: options.equals || void 0
|
|
};
|
|
const setter = (value2) => {
|
|
if (typeof value2 === "function") {
|
|
if (Transition && Transition.running && Transition.sources.has(s)) value2 = value2(s.tValue);
|
|
else value2 = value2(s.value);
|
|
}
|
|
return writeSignal(s, value2);
|
|
};
|
|
return [readSignal.bind(s), setter];
|
|
}
|
|
function createComputed(fn, value, options) {
|
|
const c = createComputation(fn, value, true, STALE);
|
|
if (Scheduler && Transition && Transition.running) Updates.push(c);
|
|
else updateComputation(c);
|
|
}
|
|
function createRenderEffect(fn, value, options) {
|
|
const c = createComputation(fn, value, false, STALE);
|
|
if (Scheduler && Transition && Transition.running) Updates.push(c);
|
|
else updateComputation(c);
|
|
}
|
|
function createEffect(fn, value, options) {
|
|
runEffects = runUserEffects;
|
|
const c = createComputation(fn, value, false, STALE), s = SuspenseContext && useContext(SuspenseContext);
|
|
if (s) c.suspense = s;
|
|
if (!options || !options.render) c.user = true;
|
|
Effects ? Effects.push(c) : updateComputation(c);
|
|
}
|
|
function createMemo(fn, value, options) {
|
|
options = options ? Object.assign({}, signalOptions, options) : signalOptions;
|
|
const c = createComputation(fn, value, true, 0);
|
|
c.observers = null;
|
|
c.observerSlots = null;
|
|
c.comparator = options.equals || void 0;
|
|
if (Scheduler && Transition && Transition.running) {
|
|
c.tState = STALE;
|
|
Updates.push(c);
|
|
} else updateComputation(c);
|
|
return readSignal.bind(c);
|
|
}
|
|
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, id = null, loadedUnderTransition = false, 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");
|
|
if (sharedConfig.context) {
|
|
id = sharedConfig.getNextContextId();
|
|
if (options.ssrLoadFrom === "initial") initP = options.initialValue;
|
|
else if (sharedConfig.load && sharedConfig.has(id)) initP = sharedConfig.load(id);
|
|
}
|
|
function loadEnd(p, v, error2, key) {
|
|
if (pr === p) {
|
|
pr = null;
|
|
key !== void 0 && (resolved = true);
|
|
if ((p === initP || v === initP) && options.onHydrated) queueMicrotask(() => options.onHydrated(key, {
|
|
value: v
|
|
}));
|
|
initP = NO_INIT;
|
|
if (Transition && p && loadedUnderTransition) {
|
|
Transition.promises.delete(p);
|
|
loadedUnderTransition = false;
|
|
runUpdates(() => {
|
|
Transition.running = true;
|
|
completeLoad(v, error2);
|
|
}, false);
|
|
} else 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 c of contexts.keys()) c.decrement();
|
|
contexts.clear();
|
|
}, false);
|
|
}
|
|
function read() {
|
|
const c = SuspenseContext && useContext(SuspenseContext), v = value(), err = error();
|
|
if (err !== void 0 && !pr) throw err;
|
|
if (Listener && !Listener.user && c) {
|
|
createComputed(() => {
|
|
track();
|
|
if (pr) {
|
|
if (c.resolved && Transition && loadedUnderTransition) Transition.promises.add(pr);
|
|
else if (!contexts.has(c)) {
|
|
c.increment();
|
|
contexts.add(c);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return v;
|
|
}
|
|
function load(refetching = true) {
|
|
if (refetching !== false && scheduled) return;
|
|
scheduled = false;
|
|
const lookup = dynamic ? dynamic() : source;
|
|
loadedUnderTransition = Transition && Transition.running;
|
|
if (lookup == null || lookup === false) {
|
|
loadEnd(pr, untrack(value));
|
|
return;
|
|
}
|
|
if (Transition && pr) Transition.promises.delete(pr);
|
|
let error2;
|
|
const p = 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(p)) {
|
|
loadEnd(pr, p, void 0, lookup);
|
|
return p;
|
|
}
|
|
pr = p;
|
|
if ("v" in p) {
|
|
if (p.s === 1) loadEnd(pr, p.v, void 0, lookup);
|
|
else loadEnd(pr, void 0, castError(p.v), lookup);
|
|
return p;
|
|
}
|
|
scheduled = true;
|
|
queueMicrotask(() => scheduled = false);
|
|
runUpdates(() => {
|
|
setState(resolved ? "refreshing" : "pending");
|
|
trigger();
|
|
}, false);
|
|
return p.then((v) => loadEnd(p, v, void 0, lookup), (e) => loadEnd(p, void 0, castError(e), lookup));
|
|
}
|
|
Object.defineProperties(read, {
|
|
state: {
|
|
get: () => state()
|
|
},
|
|
error: {
|
|
get: () => error()
|
|
},
|
|
loading: {
|
|
get() {
|
|
const s = state();
|
|
return s === "pending" || s === "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 (!ExternalSourceConfig && Listener === null) return fn();
|
|
const listener = Listener;
|
|
Listener = null;
|
|
try {
|
|
if (ExternalSourceConfig) return ExternalSourceConfig.untrack(fn);
|
|
return fn();
|
|
} finally {
|
|
Listener = listener;
|
|
}
|
|
}
|
|
function on(deps, fn, options) {
|
|
const isArray3 = Array.isArray(deps);
|
|
let prevInput;
|
|
let defer = options && options.defer;
|
|
return (prevValue) => {
|
|
let input;
|
|
if (isArray3) {
|
|
input = Array(deps.length);
|
|
for (let i = 0; i < deps.length; i++) input[i] = deps[i]();
|
|
} else input = deps();
|
|
if (defer) {
|
|
defer = false;
|
|
return prevValue;
|
|
}
|
|
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 getOwner() {
|
|
return Owner;
|
|
}
|
|
function runWithOwner(o, fn) {
|
|
const prev = Owner;
|
|
const prevListener = Listener;
|
|
Owner = o;
|
|
Listener = null;
|
|
try {
|
|
return runUpdates(fn, true);
|
|
} catch (err) {
|
|
handleError(err);
|
|
} finally {
|
|
Owner = prev;
|
|
Listener = prevListener;
|
|
}
|
|
}
|
|
function startTransition(fn) {
|
|
if (Transition && Transition.running) {
|
|
fn();
|
|
return Transition.done;
|
|
}
|
|
const l = Listener;
|
|
const o = Owner;
|
|
return Promise.resolve().then(() => {
|
|
Listener = l;
|
|
Owner = o;
|
|
let t;
|
|
if (Scheduler || SuspenseContext) {
|
|
t = Transition || (Transition = {
|
|
sources: /* @__PURE__ */ new Set(),
|
|
effects: [],
|
|
promises: /* @__PURE__ */ new Set(),
|
|
disposed: /* @__PURE__ */ new Set(),
|
|
queue: /* @__PURE__ */ new Set(),
|
|
running: true
|
|
});
|
|
t.done || (t.done = new Promise((res) => t.resolve = res));
|
|
t.running = true;
|
|
}
|
|
runUpdates(fn, false);
|
|
Listener = Owner = null;
|
|
return t ? t.done : void 0;
|
|
});
|
|
}
|
|
var [transPending, setTransPending] = 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 c = memo2();
|
|
return Array.isArray(c) ? c : c != null ? [c] : [];
|
|
};
|
|
return memo2;
|
|
}
|
|
var SuspenseContext;
|
|
function readSignal() {
|
|
const runningTransition = Transition && Transition.running;
|
|
if (this.sources && (runningTransition ? this.tState : this.state)) {
|
|
if ((runningTransition ? this.tState : 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);
|
|
}
|
|
}
|
|
if (runningTransition && Transition.sources.has(this)) return this.tValue;
|
|
return this.value;
|
|
}
|
|
function writeSignal(node, value, isComp) {
|
|
let current = Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value;
|
|
if (!node.comparator || !node.comparator(current, value)) {
|
|
if (Transition) {
|
|
const TransitionRunning = Transition.running;
|
|
if (TransitionRunning || !isComp && Transition.sources.has(node)) {
|
|
Transition.sources.add(node);
|
|
node.tValue = value;
|
|
}
|
|
if (!TransitionRunning) node.value = value;
|
|
} else node.value = value;
|
|
if (node.observers && node.observers.length) {
|
|
runUpdates(() => {
|
|
for (let i = 0; i < node.observers.length; i += 1) {
|
|
const o = node.observers[i];
|
|
const TransitionRunning = Transition && Transition.running;
|
|
if (TransitionRunning && Transition.disposed.has(o)) continue;
|
|
if (TransitionRunning ? !o.tState : !o.state) {
|
|
if (o.pure) Updates.push(o);
|
|
else Effects.push(o);
|
|
if (o.observers) markDownstream(o);
|
|
}
|
|
if (!TransitionRunning) o.state = STALE;
|
|
else o.tState = 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, Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value, time);
|
|
if (Transition && !Transition.running && Transition.sources.has(node)) {
|
|
queueMicrotask(() => {
|
|
runUpdates(() => {
|
|
Transition && (Transition.running = true);
|
|
Listener = Owner = node;
|
|
runComputation(node, node.tValue, time);
|
|
Listener = Owner = null;
|
|
}, false);
|
|
});
|
|
}
|
|
}
|
|
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) {
|
|
if (Transition && Transition.running) {
|
|
node.tState = STALE;
|
|
node.tOwned && node.tOwned.forEach(cleanNode);
|
|
node.tOwned = void 0;
|
|
} else {
|
|
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, true);
|
|
} else if (Transition && Transition.running && node.pure) {
|
|
Transition.sources.add(node);
|
|
node.tValue = nextValue;
|
|
} else node.value = nextValue;
|
|
node.updatedAt = time;
|
|
}
|
|
}
|
|
function createComputation(fn, init, pure, state = STALE, options) {
|
|
const c = {
|
|
fn,
|
|
state,
|
|
updatedAt: null,
|
|
owned: null,
|
|
sources: null,
|
|
sourceSlots: null,
|
|
cleanups: null,
|
|
value: init,
|
|
owner: Owner,
|
|
context: Owner ? Owner.context : null,
|
|
pure
|
|
};
|
|
if (Transition && Transition.running) {
|
|
c.state = 0;
|
|
c.tState = state;
|
|
}
|
|
if (Owner === null) ;
|
|
else if (Owner !== UNOWNED) {
|
|
if (Transition && Transition.running && Owner.pure) {
|
|
if (!Owner.tOwned) Owner.tOwned = [c];
|
|
else Owner.tOwned.push(c);
|
|
} else {
|
|
if (!Owner.owned) Owner.owned = [c];
|
|
else Owner.owned.push(c);
|
|
}
|
|
}
|
|
if (ExternalSourceConfig && c.fn) {
|
|
const [track, trigger] = createSignal(void 0, {
|
|
equals: false
|
|
});
|
|
const ordinary = ExternalSourceConfig.factory(c.fn, trigger);
|
|
onCleanup(() => ordinary.dispose());
|
|
const triggerInTransition = () => startTransition(trigger).then(() => inTransition.dispose());
|
|
const inTransition = ExternalSourceConfig.factory(c.fn, triggerInTransition);
|
|
c.fn = (x) => {
|
|
track();
|
|
return Transition && Transition.running ? inTransition.track(x) : ordinary.track(x);
|
|
};
|
|
}
|
|
return c;
|
|
}
|
|
function runTop(node) {
|
|
const runningTransition = Transition && Transition.running;
|
|
if ((runningTransition ? node.tState : node.state) === 0) return;
|
|
if ((runningTransition ? node.tState : 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 (runningTransition && Transition.disposed.has(node)) return;
|
|
if (runningTransition ? node.tState : node.state) ancestors.push(node);
|
|
}
|
|
for (let i = ancestors.length - 1; i >= 0; i--) {
|
|
node = ancestors[i];
|
|
if (runningTransition) {
|
|
let top = node, prev = ancestors[i + 1];
|
|
while ((top = top.owner) && top !== prev) {
|
|
if (Transition.disposed.has(top)) return;
|
|
}
|
|
}
|
|
if ((runningTransition ? node.tState : node.state) === STALE) {
|
|
updateComputation(node);
|
|
} else if ((runningTransition ? node.tState : 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) {
|
|
if (Scheduler && Transition && Transition.running) scheduleQueue(Updates);
|
|
else runQueue(Updates);
|
|
Updates = null;
|
|
}
|
|
if (wait) return;
|
|
let res;
|
|
if (Transition) {
|
|
if (!Transition.promises.size && !Transition.queue.size) {
|
|
const sources = Transition.sources;
|
|
const disposed = Transition.disposed;
|
|
Effects.push.apply(Effects, Transition.effects);
|
|
res = Transition.resolve;
|
|
for (const e2 of Effects) {
|
|
"tState" in e2 && (e2.state = e2.tState);
|
|
delete e2.tState;
|
|
}
|
|
Transition = null;
|
|
runUpdates(() => {
|
|
for (const d of disposed) cleanNode(d);
|
|
for (const v of sources) {
|
|
v.value = v.tValue;
|
|
if (v.owned) {
|
|
for (let i = 0, len = v.owned.length; i < len; i++) cleanNode(v.owned[i]);
|
|
}
|
|
if (v.tOwned) v.owned = v.tOwned;
|
|
delete v.tValue;
|
|
delete v.tOwned;
|
|
v.tState = 0;
|
|
}
|
|
setTransPending(false);
|
|
}, false);
|
|
} else if (Transition.running) {
|
|
Transition.running = false;
|
|
Transition.effects.push.apply(Transition.effects, Effects);
|
|
Effects = null;
|
|
setTransPending(true);
|
|
return;
|
|
}
|
|
}
|
|
const e = Effects;
|
|
Effects = null;
|
|
if (e.length) runUpdates(() => runEffects(e), false);
|
|
if (res) res();
|
|
}
|
|
function runQueue(queue) {
|
|
for (let i = 0; i < queue.length; i++) runTop(queue[i]);
|
|
}
|
|
function scheduleQueue(queue) {
|
|
for (let i = 0; i < queue.length; i++) {
|
|
const item = queue[i];
|
|
const tasks = Transition.queue;
|
|
if (!tasks.has(item)) {
|
|
tasks.add(item);
|
|
Scheduler(() => {
|
|
tasks.delete(item);
|
|
runUpdates(() => {
|
|
Transition.running = true;
|
|
runTop(item);
|
|
}, false);
|
|
Transition && (Transition.running = false);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
function runUserEffects(queue) {
|
|
let i, userLength = 0;
|
|
for (i = 0; i < queue.length; i++) {
|
|
const e = queue[i];
|
|
if (!e.user) runTop(e);
|
|
else queue[userLength++] = e;
|
|
}
|
|
if (sharedConfig.context) {
|
|
if (sharedConfig.count) {
|
|
sharedConfig.effects || (sharedConfig.effects = []);
|
|
sharedConfig.effects.push(...queue.slice(0, userLength));
|
|
return;
|
|
}
|
|
setHydrateContext();
|
|
}
|
|
if (sharedConfig.effects && (sharedConfig.done || !sharedConfig.count)) {
|
|
queue = [...sharedConfig.effects, ...queue];
|
|
userLength += sharedConfig.effects.length;
|
|
delete sharedConfig.effects;
|
|
}
|
|
for (i = 0; i < userLength; i++) runTop(queue[i]);
|
|
}
|
|
function lookUpstream(node, ignore) {
|
|
const runningTransition = Transition && Transition.running;
|
|
if (runningTransition) node.tState = 0;
|
|
else node.state = 0;
|
|
for (let i = 0; i < node.sources.length; i += 1) {
|
|
const source = node.sources[i];
|
|
if (source.sources) {
|
|
const state = runningTransition ? source.tState : 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) {
|
|
const runningTransition = Transition && Transition.running;
|
|
for (let i = 0; i < node.observers.length; i += 1) {
|
|
const o = node.observers[i];
|
|
if (runningTransition ? !o.tState : !o.state) {
|
|
if (runningTransition) o.tState = PENDING;
|
|
else o.state = PENDING;
|
|
if (o.pure) Updates.push(o);
|
|
else Effects.push(o);
|
|
o.observers && markDownstream(o);
|
|
}
|
|
}
|
|
}
|
|
function cleanNode(node) {
|
|
let i;
|
|
if (node.sources) {
|
|
while (node.sources.length) {
|
|
const source = node.sources.pop(), index = node.sourceSlots.pop(), obs = source.observers;
|
|
if (obs && obs.length) {
|
|
const n = obs.pop(), s = source.observerSlots.pop();
|
|
if (index < obs.length) {
|
|
n.sourceSlots[s] = index;
|
|
obs[index] = n;
|
|
source.observerSlots[index] = s;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (node.tOwned) {
|
|
for (i = node.tOwned.length - 1; i >= 0; i--) cleanNode(node.tOwned[i]);
|
|
delete node.tOwned;
|
|
}
|
|
if (Transition && Transition.running && node.pure) {
|
|
reset(node, true);
|
|
} else if (node.owned) {
|
|
for (i = node.owned.length - 1; i >= 0; i--) cleanNode(node.owned[i]);
|
|
node.owned = null;
|
|
}
|
|
if (node.cleanups) {
|
|
for (i = node.cleanups.length - 1; i >= 0; i--) node.cleanups[i]();
|
|
node.cleanups = null;
|
|
}
|
|
if (Transition && Transition.running) node.tState = 0;
|
|
else node.state = 0;
|
|
}
|
|
function reset(node, top) {
|
|
if (!top) {
|
|
node.tState = 0;
|
|
Transition.disposed.add(node);
|
|
}
|
|
if (node.owned) {
|
|
for (let i = 0; i < node.owned.length; i++) reset(node.owned[i]);
|
|
}
|
|
}
|
|
function castError(err) {
|
|
if (err instanceof Error) return err;
|
|
return new Error(typeof err === "string" ? err : "Unknown error", {
|
|
cause: err
|
|
});
|
|
}
|
|
function runErrors(err, fns, owner) {
|
|
try {
|
|
for (const f of fns) f(err);
|
|
} catch (e) {
|
|
handleError(e, owner && owner.owner || null);
|
|
}
|
|
}
|
|
function handleError(err, owner = Owner) {
|
|
const fns = ERROR && owner && owner.context && owner.context[ERROR];
|
|
const error = castError(err);
|
|
if (!fns) throw error;
|
|
if (Effects) Effects.push({
|
|
fn() {
|
|
runErrors(error, fns, owner);
|
|
},
|
|
state: STALE
|
|
});
|
|
else runErrors(error, fns, owner);
|
|
}
|
|
function resolveChildren(children2) {
|
|
if (typeof children2 === "function" && !children2.length) return resolveChildren(children2());
|
|
if (Array.isArray(children2)) {
|
|
const results = [];
|
|
for (let i = 0; i < children2.length; i++) {
|
|
const result = resolveChildren(children2[i]);
|
|
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 = {
|
|
...Owner.context,
|
|
[id]: props.value
|
|
};
|
|
return children(() => props.children);
|
|
}), void 0);
|
|
return res;
|
|
};
|
|
}
|
|
var FALLBACK = Symbol("fallback");
|
|
function dispose(d) {
|
|
for (let i = 0; i < d.length; i++) d[i]();
|
|
}
|
|
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, i, 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];
|
|
i = newIndices.get(item);
|
|
newIndicesNext[j] = i === void 0 ? -1 : i;
|
|
newIndices.set(item, j);
|
|
}
|
|
for (i = start; i <= end; i++) {
|
|
item = items[i];
|
|
j = newIndices.get(item);
|
|
if (j !== void 0 && j !== -1) {
|
|
temp[j] = mapped[i];
|
|
tempdisposers[j] = disposers[i];
|
|
indexes && (tempIndexes[j] = indexes[i]);
|
|
j = newIndicesNext[j];
|
|
newIndices.set(item, j);
|
|
} else disposers[i]();
|
|
}
|
|
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 [s, set] = createSignal(j);
|
|
indexes[j] = set;
|
|
return mapFn(newItems[j], s);
|
|
}
|
|
return mapFn(newItems[j]);
|
|
}
|
|
};
|
|
}
|
|
function indexArray(list, mapFn, options = {}) {
|
|
let items = [], mapped = [], disposers = [], signals = [], len = 0, i;
|
|
onCleanup(() => dispose(disposers));
|
|
return () => {
|
|
const newItems = list() || [], newLen = newItems.length;
|
|
newItems[$TRACK];
|
|
return untrack(() => {
|
|
if (newLen === 0) {
|
|
if (len !== 0) {
|
|
dispose(disposers);
|
|
disposers = [];
|
|
items = [];
|
|
mapped = [];
|
|
len = 0;
|
|
signals = [];
|
|
}
|
|
if (options.fallback) {
|
|
items = [FALLBACK];
|
|
mapped[0] = createRoot((disposer) => {
|
|
disposers[0] = disposer;
|
|
return options.fallback();
|
|
});
|
|
len = 1;
|
|
}
|
|
return mapped;
|
|
}
|
|
if (items[0] === FALLBACK) {
|
|
disposers[0]();
|
|
disposers = [];
|
|
items = [];
|
|
mapped = [];
|
|
len = 0;
|
|
}
|
|
for (i = 0; i < newLen; i++) {
|
|
if (i < items.length && items[i] !== newItems[i]) {
|
|
signals[i](() => newItems[i]);
|
|
} else if (i >= items.length) {
|
|
mapped[i] = createRoot(mapper);
|
|
}
|
|
}
|
|
for (; i < items.length; i++) {
|
|
disposers[i]();
|
|
}
|
|
len = signals.length = disposers.length = newLen;
|
|
items = newItems.slice(0);
|
|
return mapped = mapped.slice(0, len);
|
|
});
|
|
function mapper(disposer) {
|
|
disposers[i] = disposer;
|
|
const [s, set] = createSignal(newItems[i]);
|
|
signals[i] = set;
|
|
return mapFn(s, i);
|
|
}
|
|
};
|
|
}
|
|
var hydrationEnabled = false;
|
|
function createComponent(Comp, props) {
|
|
if (hydrationEnabled) {
|
|
if (sharedConfig.context) {
|
|
const c = sharedConfig.context;
|
|
setHydrateContext(nextHydrateContext());
|
|
const r = untrack(() => Comp(props || {}));
|
|
setHydrateContext(c);
|
|
return r;
|
|
}
|
|
}
|
|
return untrack(() => Comp(props || {}));
|
|
}
|
|
function trueFn() {
|
|
return true;
|
|
}
|
|
var 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(s) {
|
|
return !(s = typeof s === "function" ? s() : s) ? {} : s;
|
|
}
|
|
function resolveSources() {
|
|
for (let i = 0, length = this.length; i < length; ++i) {
|
|
const v = this[i]();
|
|
if (v !== void 0) return v;
|
|
}
|
|
}
|
|
function mergeProps(...sources) {
|
|
let proxy = false;
|
|
for (let i = 0; i < sources.length; i++) {
|
|
const s = sources[i];
|
|
proxy = proxy || !!s && $PROXY in s;
|
|
sources[i] = typeof s === "function" ? (proxy = true, createMemo(s)) : s;
|
|
}
|
|
if (SUPPORTS_PROXY && proxy) {
|
|
return new Proxy({
|
|
get(property) {
|
|
for (let i = sources.length - 1; i >= 0; i--) {
|
|
const v = resolveSource(sources[i])[property];
|
|
if (v !== void 0) return v;
|
|
}
|
|
},
|
|
has(property) {
|
|
for (let i = sources.length - 1; i >= 0; i--) {
|
|
if (property in resolveSource(sources[i])) return true;
|
|
}
|
|
return false;
|
|
},
|
|
keys() {
|
|
const keys = [];
|
|
for (let i = 0; i < sources.length; i++) keys.push(...Object.keys(resolveSource(sources[i])));
|
|
return [...new Set(keys)];
|
|
}
|
|
}, propTraps);
|
|
}
|
|
const sourcesMap = {};
|
|
const defined = /* @__PURE__ */ Object.create(null);
|
|
for (let i = sources.length - 1; i >= 0; i--) {
|
|
const source = sources[i];
|
|
if (!source) continue;
|
|
const sourceKeys = Object.getOwnPropertyNames(source);
|
|
for (let i2 = sourceKeys.length - 1; i2 >= 0; i2--) {
|
|
const key = sourceKeys[i2];
|
|
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 i = definedKeys.length - 1; i >= 0; i--) {
|
|
const key = definedKeys[i], 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];
|
|
}
|
|
function lazy(fn) {
|
|
let comp;
|
|
let p;
|
|
const wrap = (props) => {
|
|
const ctx = sharedConfig.context;
|
|
if (ctx) {
|
|
const [s, set] = createSignal();
|
|
sharedConfig.count || (sharedConfig.count = 0);
|
|
sharedConfig.count++;
|
|
(p || (p = fn())).then((mod) => {
|
|
!sharedConfig.done && setHydrateContext(ctx);
|
|
sharedConfig.count--;
|
|
set(() => mod.default);
|
|
setHydrateContext();
|
|
});
|
|
comp = s;
|
|
} else if (!comp) {
|
|
const [s] = createResource(() => (p || (p = fn())).then((mod) => mod.default));
|
|
comp = s;
|
|
}
|
|
let Comp;
|
|
return createMemo(() => (Comp = comp()) ? untrack(() => {
|
|
if (IS_DEV) ;
|
|
if (!ctx || sharedConfig.done) return Comp(props);
|
|
const c = sharedConfig.context;
|
|
setHydrateContext(ctx);
|
|
const r = Comp(props);
|
|
setHydrateContext(c);
|
|
return r;
|
|
}) : "");
|
|
};
|
|
wrap.preload = () => p || ((p = fn()).then((mod) => comp = () => mod.default), p);
|
|
return wrap;
|
|
}
|
|
var counter = 0;
|
|
function createUniqueId() {
|
|
const ctx = sharedConfig.context;
|
|
return ctx ? sharedConfig.getNextContextId() : `cl-${counter++}`;
|
|
}
|
|
var 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 Index(props) {
|
|
const fallback = "fallback" in props && {
|
|
fallback: () => props.fallback
|
|
};
|
|
return createMemo(indexArray(() => 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: (a, b) => !a === !b
|
|
});
|
|
return createMemo(() => {
|
|
const c = condition();
|
|
if (c) {
|
|
const child = props.children;
|
|
const fn = typeof child === "function" && child.length > 0;
|
|
return fn ? untrack(() => child(keyed ? c : () => {
|
|
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 i = 0; i < mps.length; i++) {
|
|
const index = i;
|
|
const mp = mps[i];
|
|
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: (a, b) => !a === !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 _a;
|
|
if (((_a = untrack(switchFunc)()) == null ? void 0 : _a[0]) !== index) throw narrowedError("Match");
|
|
return conditionValue();
|
|
})) : child;
|
|
}, void 0, void 0);
|
|
}
|
|
function Match(props) {
|
|
return props;
|
|
}
|
|
var DEV = void 0;
|
|
var 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"];
|
|
var Properties = /* @__PURE__ */ new Set(["className", "value", "readOnly", "noValidate", "formNoValidate", "isMap", "noModule", "playsInline", ...booleans]);
|
|
var ChildProperties = /* @__PURE__ */ new Set(["innerHTML", "textContent", "innerText", "children"]);
|
|
var Aliases = Object.assign(/* @__PURE__ */ Object.create(null), {
|
|
className: "class",
|
|
htmlFor: "for"
|
|
});
|
|
var PropAliases = 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 a = PropAliases[prop];
|
|
return typeof a === "object" ? a[tagName] ? a["$"] : void 0 : a;
|
|
}
|
|
var 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"]);
|
|
var 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"
|
|
]);
|
|
var SVGNamespace = {
|
|
xlink: "http://www.w3.org/1999/xlink",
|
|
xml: "http://www.w3.org/XML/1998/namespace"
|
|
};
|
|
var memo = (fn) => createMemo(() => fn());
|
|
function reconcileArrays(parentNode, a, b) {
|
|
let bLength = b.length, aEnd = a.length, bEnd = bLength, aStart = 0, bStart = 0, after = a[aEnd - 1].nextSibling, map = null;
|
|
while (aStart < aEnd || bStart < bEnd) {
|
|
if (a[aStart] === b[bStart]) {
|
|
aStart++;
|
|
bStart++;
|
|
continue;
|
|
}
|
|
while (a[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(a[aStart])) a[aStart].remove();
|
|
aStart++;
|
|
}
|
|
} else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
|
|
const node = a[--aEnd].nextSibling;
|
|
parentNode.insertBefore(b[bStart++], a[aStart++].nextSibling);
|
|
parentNode.insertBefore(b[--bEnd], node);
|
|
a[aEnd] = b[bEnd];
|
|
} else {
|
|
if (!map) {
|
|
map = /* @__PURE__ */ new Map();
|
|
let i = bStart;
|
|
while (i < bEnd) map.set(b[i], i++);
|
|
}
|
|
const index = map.get(a[aStart]);
|
|
if (index != null) {
|
|
if (bStart < index && index < bEnd) {
|
|
let i = aStart, sequence = 1, t;
|
|
while (++i < aEnd && i < bEnd) {
|
|
if ((t = map.get(a[i])) == null || t !== index + sequence) break;
|
|
sequence++;
|
|
}
|
|
if (sequence > index - bStart) {
|
|
const node = a[aStart];
|
|
while (bStart < index) parentNode.insertBefore(b[bStart++], node);
|
|
} else parentNode.replaceChild(b[bStart++], a[aStart++]);
|
|
} else aStart++;
|
|
} else a[aStart++].remove();
|
|
}
|
|
}
|
|
}
|
|
var $$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(html, isImportNode, isSVG, isMathML) {
|
|
let node;
|
|
const create = () => {
|
|
const t = isMathML ? document.createElementNS("http://www.w3.org/1998/Math/MathML", "template") : document.createElement("template");
|
|
t.innerHTML = html;
|
|
return isSVG ? t.content.firstChild.firstChild : isMathML ? t.firstChild : t.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 e = document2[$$EVENTS] || (document2[$$EVENTS] = /* @__PURE__ */ new Set());
|
|
for (let i = 0, l = eventNames.length; i < l; i++) {
|
|
const name = eventNames[i];
|
|
if (!e.has(name)) {
|
|
e.add(name);
|
|
document2.addEventListener(name, eventHandler);
|
|
}
|
|
}
|
|
}
|
|
function clearDelegatedEvents(document2 = window.document) {
|
|
if (document2[$$EVENTS]) {
|
|
for (let name of document2[$$EVENTS].keys()) document2.removeEventListener(name, eventHandler);
|
|
delete document2[$$EVENTS];
|
|
}
|
|
}
|
|
function setAttribute(node, name, value) {
|
|
if (isHydrating(node)) return;
|
|
if (value == null) node.removeAttribute(name);
|
|
else node.setAttribute(name, value);
|
|
}
|
|
function setAttributeNS(node, namespace, name, value) {
|
|
if (isHydrating(node)) return;
|
|
if (value == null) node.removeAttributeNS(namespace, name);
|
|
else node.setAttributeNS(namespace, name, value);
|
|
}
|
|
function setBoolAttribute(node, name, value) {
|
|
if (isHydrating(node)) return;
|
|
value ? node.setAttribute(name, "") : node.removeAttribute(name);
|
|
}
|
|
function className(node, value) {
|
|
if (isHydrating(node)) return;
|
|
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] = (e) => handlerFn.call(node, handler[1], e));
|
|
} else node.addEventListener(name, handler, typeof handler !== "function" && handler);
|
|
}
|
|
function classList(node, value, prev = {}) {
|
|
const classKeys = Object.keys(value || {}), prevKeys = Object.keys(prev);
|
|
let i, len;
|
|
for (i = 0, len = prevKeys.length; i < len; i++) {
|
|
const key = prevKeys[i];
|
|
if (!key || key === "undefined" || value[key]) continue;
|
|
toggleClassKey(node, key, false);
|
|
delete prev[key];
|
|
}
|
|
for (i = 0, len = classKeys.length; i < len; i++) {
|
|
const key = classKeys[i], 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, s;
|
|
for (s in prev) {
|
|
value[s] == null && nodeStyle.removeProperty(s);
|
|
delete prev[s];
|
|
}
|
|
for (s in value) {
|
|
v = value[s];
|
|
if (v !== prev[s]) {
|
|
nodeStyle.setProperty(s, v);
|
|
prev[s] = v;
|
|
}
|
|
}
|
|
return prev;
|
|
}
|
|
function spread(node, props = {}, isSVG, skipChildren) {
|
|
const prevProps = {};
|
|
if (!skipChildren) {
|
|
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 getNextElement(template2) {
|
|
let node, key, hydrating = isHydrating();
|
|
if (!hydrating || !(node = sharedConfig.registry.get(key = getHydrationKey()))) {
|
|
return template2();
|
|
}
|
|
if (sharedConfig.completed) sharedConfig.completed.add(node);
|
|
sharedConfig.registry.delete(key);
|
|
return node;
|
|
}
|
|
function isHydrating(node) {
|
|
return !!sharedConfig.context && !sharedConfig.done && (!node || node.isConnected);
|
|
}
|
|
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 i = 0, nameLen = classNames.length; i < nameLen; i++) node.classList.toggle(classNames[i], 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 e = prop.slice(3);
|
|
prev && node.removeEventListener(e, prev, typeof prev !== "function" && prev);
|
|
value && node.addEventListener(e, value, typeof value !== "function" && value);
|
|
} else if (prop.slice(0, 10) === "oncapture:") {
|
|
const e = prop.slice(10);
|
|
prev && node.removeEventListener(e, prev, true);
|
|
value && node.addEventListener(e, value, true);
|
|
} else if (prop.slice(0, 2) === "on") {
|
|
const name = prop.slice(2).toLowerCase();
|
|
const delegate = DelegatedEvents.has(name);
|
|
if (!delegate && prev) {
|
|
const h = Array.isArray(prev) ? prev[0] : prev;
|
|
node.removeEventListener(name, h);
|
|
}
|
|
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;
|
|
} else if (isHydrating(node)) return value;
|
|
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(e) {
|
|
if (sharedConfig.registry && sharedConfig.events) {
|
|
if (sharedConfig.events.find(([el, ev]) => ev === e)) return;
|
|
}
|
|
let node = e.target;
|
|
const key = `$$${e.type}`;
|
|
const oriTarget = e.target;
|
|
const oriCurrentTarget = e.currentTarget;
|
|
const retarget = (value) => Object.defineProperty(e, "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, e) : handler.call(node, e);
|
|
if (e.cancelBubble) return;
|
|
}
|
|
node.host && typeof node.host !== "string" && !node.host._$host && node.contains(e.target) && retarget(node.host);
|
|
return true;
|
|
};
|
|
const walkUpTree = () => {
|
|
while (handleNode() && (node = node._$host || node.parentNode || node.host)) ;
|
|
};
|
|
Object.defineProperty(e, "currentTarget", {
|
|
configurable: true,
|
|
get() {
|
|
return node || document;
|
|
}
|
|
});
|
|
if (sharedConfig.registry && !sharedConfig.done) sharedConfig.done = _$HY.done = true;
|
|
if (e.composedPath) {
|
|
const path = e.composedPath();
|
|
retarget(path[0]);
|
|
for (let i = 0; i < path.length - 2; i++) {
|
|
node = path[i];
|
|
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) {
|
|
const hydrating = isHydrating(parent);
|
|
if (hydrating) {
|
|
!current && (current = [...parent.childNodes]);
|
|
let cleaned = [];
|
|
for (let i = 0; i < current.length; i++) {
|
|
const node = current[i];
|
|
if (node.nodeType === 8 && node.data.slice(0, 2) === "!$") node.remove();
|
|
else cleaned.push(node);
|
|
}
|
|
current = cleaned;
|
|
}
|
|
while (typeof current === "function") current = current();
|
|
if (value === current) return current;
|
|
const t = typeof value, multi = marker !== void 0;
|
|
parent = multi && current[0] && current[0].parentNode || parent;
|
|
if (t === "string" || t === "number") {
|
|
if (hydrating) return current;
|
|
if (t === "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 || t === "boolean") {
|
|
if (hydrating) return current;
|
|
current = cleanChildren(parent, current, marker);
|
|
} else if (t === "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 (hydrating) {
|
|
if (!array.length) return current;
|
|
if (marker === void 0) return current = [...parent.childNodes];
|
|
let node = array[0];
|
|
if (node.parentNode !== parent) return current;
|
|
const nodes = [node];
|
|
while ((node = node.nextSibling) !== marker) nodes.push(node);
|
|
return current = nodes;
|
|
}
|
|
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 (hydrating && value.parentNode) return current = multi ? [value] : value;
|
|
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, unwrap) {
|
|
let dynamic = false;
|
|
for (let i = 0, len = array.length; i < len; i++) {
|
|
let item = array[i], prev = current && current[normalized.length], t;
|
|
if (item == null || item === true || item === false) ;
|
|
else if ((t = typeof item) === "object" && item.nodeType) {
|
|
normalized.push(item);
|
|
} else if (Array.isArray(item)) {
|
|
dynamic = normalizeIncomingArray(normalized, item, prev) || dynamic;
|
|
} else if (t === "function") {
|
|
if (unwrap) {
|
|
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 i = 0, len = array.length; i < len; i++) parent.insertBefore(array[i], 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 i = current.length - 1; i >= 0; i--) {
|
|
const el = current[i];
|
|
if (node !== el) {
|
|
const isParent = el.parentNode === parent;
|
|
if (!inserted && !i) isParent ? parent.replaceChild(node, el) : parent.insertBefore(node, marker);
|
|
else isParent && el.remove();
|
|
} else inserted = true;
|
|
}
|
|
} else parent.insertBefore(node, marker);
|
|
return [node];
|
|
}
|
|
function getHydrationKey() {
|
|
return sharedConfig.getNextContextId();
|
|
}
|
|
var isServer = false;
|
|
var 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;
|
|
let hydrating = !!sharedConfig.context;
|
|
createEffect(() => {
|
|
if (hydrating) getOwner().user = hydrating = false;
|
|
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: !hydrating
|
|
});
|
|
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 = sharedConfig.context ? getNextElement() : createElement(component2, isSvg);
|
|
spread(el, props, isSvg);
|
|
return el;
|
|
}
|
|
});
|
|
}
|
|
function Dynamic(props) {
|
|
const [, others] = splitProps(props, ["component"]);
|
|
return createDynamic(() => props.component, others);
|
|
}
|
|
var DoubleIndexedKV = class {
|
|
constructor() {
|
|
this.keyToValue = /* @__PURE__ */ new Map();
|
|
this.valueToKey = /* @__PURE__ */ new Map();
|
|
}
|
|
set(key, value) {
|
|
this.keyToValue.set(key, value);
|
|
this.valueToKey.set(value, key);
|
|
}
|
|
getByKey(key) {
|
|
return this.keyToValue.get(key);
|
|
}
|
|
getByValue(value) {
|
|
return this.valueToKey.get(value);
|
|
}
|
|
clear() {
|
|
this.keyToValue.clear();
|
|
this.valueToKey.clear();
|
|
}
|
|
};
|
|
var Registry = class {
|
|
constructor(generateIdentifier) {
|
|
this.generateIdentifier = generateIdentifier;
|
|
this.kv = new DoubleIndexedKV();
|
|
}
|
|
register(value, identifier) {
|
|
if (this.kv.getByValue(value)) {
|
|
return;
|
|
}
|
|
if (!identifier) {
|
|
identifier = this.generateIdentifier(value);
|
|
}
|
|
this.kv.set(identifier, value);
|
|
}
|
|
clear() {
|
|
this.kv.clear();
|
|
}
|
|
getIdentifier(value) {
|
|
return this.kv.getByValue(value);
|
|
}
|
|
getValue(identifier) {
|
|
return this.kv.getByKey(identifier);
|
|
}
|
|
};
|
|
var ClassRegistry = class extends Registry {
|
|
constructor() {
|
|
super((c) => c.name);
|
|
this.classToAllowedProps = /* @__PURE__ */ new Map();
|
|
}
|
|
register(value, options) {
|
|
if (typeof options === "object") {
|
|
if (options.allowProps) {
|
|
this.classToAllowedProps.set(value, options.allowProps);
|
|
}
|
|
super.register(value, options.identifier);
|
|
} else {
|
|
super.register(value, options);
|
|
}
|
|
}
|
|
getAllowedProps(value) {
|
|
return this.classToAllowedProps.get(value);
|
|
}
|
|
};
|
|
function valuesOfObj(record) {
|
|
if ("values" in Object) {
|
|
return Object.values(record);
|
|
}
|
|
const values = [];
|
|
for (const key in record) {
|
|
if (record.hasOwnProperty(key)) {
|
|
values.push(record[key]);
|
|
}
|
|
}
|
|
return values;
|
|
}
|
|
function find(record, predicate) {
|
|
const values = valuesOfObj(record);
|
|
if ("find" in values) {
|
|
return values.find(predicate);
|
|
}
|
|
const valuesNotNever = values;
|
|
for (let i = 0; i < valuesNotNever.length; i++) {
|
|
const value = valuesNotNever[i];
|
|
if (predicate(value)) {
|
|
return value;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function forEach(record, run) {
|
|
Object.entries(record).forEach(([key, value]) => run(value, key));
|
|
}
|
|
function includes(arr, value) {
|
|
return arr.indexOf(value) !== -1;
|
|
}
|
|
function findArr(record, predicate) {
|
|
for (let i = 0; i < record.length; i++) {
|
|
const value = record[i];
|
|
if (predicate(value)) {
|
|
return value;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
var CustomTransformerRegistry = class {
|
|
constructor() {
|
|
this.transfomers = {};
|
|
}
|
|
register(transformer) {
|
|
this.transfomers[transformer.name] = transformer;
|
|
}
|
|
findApplicable(v) {
|
|
return find(this.transfomers, (transformer) => transformer.isApplicable(v));
|
|
}
|
|
findByName(name) {
|
|
return this.transfomers[name];
|
|
}
|
|
};
|
|
var getType = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
|
|
var isUndefined = (payload) => typeof payload === "undefined";
|
|
var isNull = (payload) => payload === null;
|
|
var isPlainObject = (payload) => {
|
|
if (typeof payload !== "object" || payload === null)
|
|
return false;
|
|
if (payload === Object.prototype)
|
|
return false;
|
|
if (Object.getPrototypeOf(payload) === null)
|
|
return true;
|
|
return Object.getPrototypeOf(payload) === Object.prototype;
|
|
};
|
|
var isEmptyObject = (payload) => isPlainObject(payload) && Object.keys(payload).length === 0;
|
|
var isArray = (payload) => Array.isArray(payload);
|
|
var isString = (payload) => typeof payload === "string";
|
|
var isNumber = (payload) => typeof payload === "number" && !isNaN(payload);
|
|
var isBoolean = (payload) => typeof payload === "boolean";
|
|
var isRegExp = (payload) => payload instanceof RegExp;
|
|
var isMap = (payload) => payload instanceof Map;
|
|
var isSet = (payload) => payload instanceof Set;
|
|
var isSymbol = (payload) => getType(payload) === "Symbol";
|
|
var isDate = (payload) => payload instanceof Date && !isNaN(payload.valueOf());
|
|
var isError = (payload) => payload instanceof Error;
|
|
var isNaNValue = (payload) => typeof payload === "number" && isNaN(payload);
|
|
var isPrimitive = (payload) => isBoolean(payload) || isNull(payload) || isUndefined(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
|
|
var isBigint = (payload) => typeof payload === "bigint";
|
|
var isInfinite = (payload) => payload === Infinity || payload === -Infinity;
|
|
var isTypedArray = (payload) => ArrayBuffer.isView(payload) && !(payload instanceof DataView);
|
|
var isURL = (payload) => payload instanceof URL;
|
|
var escapeKey = (key) => key.replace(/\./g, "\\.");
|
|
var stringifyPath = (path) => path.map(String).map(escapeKey).join(".");
|
|
var parsePath = (string) => {
|
|
const result = [];
|
|
let segment = "";
|
|
for (let i = 0; i < string.length; i++) {
|
|
let char = string.charAt(i);
|
|
const isEscapedDot = char === "\\" && string.charAt(i + 1) === ".";
|
|
if (isEscapedDot) {
|
|
segment += ".";
|
|
i++;
|
|
continue;
|
|
}
|
|
const isEndOfSegment = char === ".";
|
|
if (isEndOfSegment) {
|
|
result.push(segment);
|
|
segment = "";
|
|
continue;
|
|
}
|
|
segment += char;
|
|
}
|
|
const lastSegment = segment;
|
|
result.push(lastSegment);
|
|
return result;
|
|
};
|
|
function simpleTransformation(isApplicable, annotation, transform, untransform) {
|
|
return {
|
|
isApplicable,
|
|
annotation,
|
|
transform,
|
|
untransform
|
|
};
|
|
}
|
|
var simpleRules = [
|
|
simpleTransformation(isUndefined, "undefined", () => null, () => void 0),
|
|
simpleTransformation(isBigint, "bigint", (v) => v.toString(), (v) => {
|
|
if (typeof BigInt !== "undefined") {
|
|
return BigInt(v);
|
|
}
|
|
console.error("Please add a BigInt polyfill.");
|
|
return v;
|
|
}),
|
|
simpleTransformation(isDate, "Date", (v) => v.toISOString(), (v) => new Date(v)),
|
|
simpleTransformation(isError, "Error", (v, superJson) => {
|
|
const baseError = {
|
|
name: v.name,
|
|
message: v.message
|
|
};
|
|
superJson.allowedErrorProps.forEach((prop) => {
|
|
baseError[prop] = v[prop];
|
|
});
|
|
return baseError;
|
|
}, (v, superJson) => {
|
|
const e = new Error(v.message);
|
|
e.name = v.name;
|
|
e.stack = v.stack;
|
|
superJson.allowedErrorProps.forEach((prop) => {
|
|
e[prop] = v[prop];
|
|
});
|
|
return e;
|
|
}),
|
|
simpleTransformation(isRegExp, "regexp", (v) => "" + v, (regex) => {
|
|
const body = regex.slice(1, regex.lastIndexOf("/"));
|
|
const flags = regex.slice(regex.lastIndexOf("/") + 1);
|
|
return new RegExp(body, flags);
|
|
}),
|
|
simpleTransformation(
|
|
isSet,
|
|
"set",
|
|
// (sets only exist in es6+)
|
|
// eslint-disable-next-line es5/no-es6-methods
|
|
(v) => [...v.values()],
|
|
(v) => new Set(v)
|
|
),
|
|
simpleTransformation(isMap, "map", (v) => [...v.entries()], (v) => new Map(v)),
|
|
simpleTransformation((v) => isNaNValue(v) || isInfinite(v), "number", (v) => {
|
|
if (isNaNValue(v)) {
|
|
return "NaN";
|
|
}
|
|
if (v > 0) {
|
|
return "Infinity";
|
|
} else {
|
|
return "-Infinity";
|
|
}
|
|
}, Number),
|
|
simpleTransformation((v) => v === 0 && 1 / v === -Infinity, "number", () => {
|
|
return "-0";
|
|
}, Number),
|
|
simpleTransformation(isURL, "URL", (v) => v.toString(), (v) => new URL(v))
|
|
];
|
|
function compositeTransformation(isApplicable, annotation, transform, untransform) {
|
|
return {
|
|
isApplicable,
|
|
annotation,
|
|
transform,
|
|
untransform
|
|
};
|
|
}
|
|
var symbolRule = compositeTransformation((s, superJson) => {
|
|
if (isSymbol(s)) {
|
|
const isRegistered = !!superJson.symbolRegistry.getIdentifier(s);
|
|
return isRegistered;
|
|
}
|
|
return false;
|
|
}, (s, superJson) => {
|
|
const identifier = superJson.symbolRegistry.getIdentifier(s);
|
|
return ["symbol", identifier];
|
|
}, (v) => v.description, (_, a, superJson) => {
|
|
const value = superJson.symbolRegistry.getValue(a[1]);
|
|
if (!value) {
|
|
throw new Error("Trying to deserialize unknown symbol");
|
|
}
|
|
return value;
|
|
});
|
|
var constructorToName = [
|
|
Int8Array,
|
|
Uint8Array,
|
|
Int16Array,
|
|
Uint16Array,
|
|
Int32Array,
|
|
Uint32Array,
|
|
Float32Array,
|
|
Float64Array,
|
|
Uint8ClampedArray
|
|
].reduce((obj, ctor) => {
|
|
obj[ctor.name] = ctor;
|
|
return obj;
|
|
}, {});
|
|
var typedArrayRule = compositeTransformation(isTypedArray, (v) => ["typed-array", v.constructor.name], (v) => [...v], (v, a) => {
|
|
const ctor = constructorToName[a[1]];
|
|
if (!ctor) {
|
|
throw new Error("Trying to deserialize unknown typed array");
|
|
}
|
|
return new ctor(v);
|
|
});
|
|
function isInstanceOfRegisteredClass(potentialClass, superJson) {
|
|
if (potentialClass == null ? void 0 : potentialClass.constructor) {
|
|
const isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
|
|
return isRegistered;
|
|
}
|
|
return false;
|
|
}
|
|
var classRule = compositeTransformation(isInstanceOfRegisteredClass, (clazz, superJson) => {
|
|
const identifier = superJson.classRegistry.getIdentifier(clazz.constructor);
|
|
return ["class", identifier];
|
|
}, (clazz, superJson) => {
|
|
const allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
|
|
if (!allowedProps) {
|
|
return { ...clazz };
|
|
}
|
|
const result = {};
|
|
allowedProps.forEach((prop) => {
|
|
result[prop] = clazz[prop];
|
|
});
|
|
return result;
|
|
}, (v, a, superJson) => {
|
|
const clazz = superJson.classRegistry.getValue(a[1]);
|
|
if (!clazz) {
|
|
throw new Error(`Trying to deserialize unknown class '${a[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
|
|
}
|
|
return Object.assign(Object.create(clazz.prototype), v);
|
|
});
|
|
var customRule = compositeTransformation((value, superJson) => {
|
|
return !!superJson.customTransformerRegistry.findApplicable(value);
|
|
}, (value, superJson) => {
|
|
const transformer = superJson.customTransformerRegistry.findApplicable(value);
|
|
return ["custom", transformer.name];
|
|
}, (value, superJson) => {
|
|
const transformer = superJson.customTransformerRegistry.findApplicable(value);
|
|
return transformer.serialize(value);
|
|
}, (v, a, superJson) => {
|
|
const transformer = superJson.customTransformerRegistry.findByName(a[1]);
|
|
if (!transformer) {
|
|
throw new Error("Trying to deserialize unknown custom value");
|
|
}
|
|
return transformer.deserialize(v);
|
|
});
|
|
var compositeRules = [classRule, symbolRule, customRule, typedArrayRule];
|
|
var transformValue = (value, superJson) => {
|
|
const applicableCompositeRule = findArr(compositeRules, (rule) => rule.isApplicable(value, superJson));
|
|
if (applicableCompositeRule) {
|
|
return {
|
|
value: applicableCompositeRule.transform(value, superJson),
|
|
type: applicableCompositeRule.annotation(value, superJson)
|
|
};
|
|
}
|
|
const applicableSimpleRule = findArr(simpleRules, (rule) => rule.isApplicable(value, superJson));
|
|
if (applicableSimpleRule) {
|
|
return {
|
|
value: applicableSimpleRule.transform(value, superJson),
|
|
type: applicableSimpleRule.annotation
|
|
};
|
|
}
|
|
return void 0;
|
|
};
|
|
var simpleRulesByAnnotation = {};
|
|
simpleRules.forEach((rule) => {
|
|
simpleRulesByAnnotation[rule.annotation] = rule;
|
|
});
|
|
var untransformValue = (json, type, superJson) => {
|
|
if (isArray(type)) {
|
|
switch (type[0]) {
|
|
case "symbol":
|
|
return symbolRule.untransform(json, type, superJson);
|
|
case "class":
|
|
return classRule.untransform(json, type, superJson);
|
|
case "custom":
|
|
return customRule.untransform(json, type, superJson);
|
|
case "typed-array":
|
|
return typedArrayRule.untransform(json, type, superJson);
|
|
default:
|
|
throw new Error("Unknown transformation: " + type);
|
|
}
|
|
} else {
|
|
const transformation = simpleRulesByAnnotation[type];
|
|
if (!transformation) {
|
|
throw new Error("Unknown transformation: " + type);
|
|
}
|
|
return transformation.untransform(json, superJson);
|
|
}
|
|
};
|
|
var getNthKey = (value, n) => {
|
|
if (n > value.size)
|
|
throw new Error("index out of bounds");
|
|
const keys = value.keys();
|
|
while (n > 0) {
|
|
keys.next();
|
|
n--;
|
|
}
|
|
return keys.next().value;
|
|
};
|
|
function validatePath(path) {
|
|
if (includes(path, "__proto__")) {
|
|
throw new Error("__proto__ is not allowed as a property");
|
|
}
|
|
if (includes(path, "prototype")) {
|
|
throw new Error("prototype is not allowed as a property");
|
|
}
|
|
if (includes(path, "constructor")) {
|
|
throw new Error("constructor is not allowed as a property");
|
|
}
|
|
}
|
|
var getDeep = (object, path) => {
|
|
validatePath(path);
|
|
for (let i = 0; i < path.length; i++) {
|
|
const key = path[i];
|
|
if (isSet(object)) {
|
|
object = getNthKey(object, +key);
|
|
} else if (isMap(object)) {
|
|
const row = +key;
|
|
const type = +path[++i] === 0 ? "key" : "value";
|
|
const keyOfRow = getNthKey(object, row);
|
|
switch (type) {
|
|
case "key":
|
|
object = keyOfRow;
|
|
break;
|
|
case "value":
|
|
object = object.get(keyOfRow);
|
|
break;
|
|
}
|
|
} else {
|
|
object = object[key];
|
|
}
|
|
}
|
|
return object;
|
|
};
|
|
var setDeep = (object, path, mapper) => {
|
|
validatePath(path);
|
|
if (path.length === 0) {
|
|
return mapper(object);
|
|
}
|
|
let parent = object;
|
|
for (let i = 0; i < path.length - 1; i++) {
|
|
const key = path[i];
|
|
if (isArray(parent)) {
|
|
const index = +key;
|
|
parent = parent[index];
|
|
} else if (isPlainObject(parent)) {
|
|
parent = parent[key];
|
|
} else if (isSet(parent)) {
|
|
const row = +key;
|
|
parent = getNthKey(parent, row);
|
|
} else if (isMap(parent)) {
|
|
const isEnd = i === path.length - 2;
|
|
if (isEnd) {
|
|
break;
|
|
}
|
|
const row = +key;
|
|
const type = +path[++i] === 0 ? "key" : "value";
|
|
const keyOfRow = getNthKey(parent, row);
|
|
switch (type) {
|
|
case "key":
|
|
parent = keyOfRow;
|
|
break;
|
|
case "value":
|
|
parent = parent.get(keyOfRow);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
const lastKey = path[path.length - 1];
|
|
if (isArray(parent)) {
|
|
parent[+lastKey] = mapper(parent[+lastKey]);
|
|
} else if (isPlainObject(parent)) {
|
|
parent[lastKey] = mapper(parent[lastKey]);
|
|
}
|
|
if (isSet(parent)) {
|
|
const oldValue = getNthKey(parent, +lastKey);
|
|
const newValue = mapper(oldValue);
|
|
if (oldValue !== newValue) {
|
|
parent.delete(oldValue);
|
|
parent.add(newValue);
|
|
}
|
|
}
|
|
if (isMap(parent)) {
|
|
const row = +path[path.length - 2];
|
|
const keyToRow = getNthKey(parent, row);
|
|
const type = +lastKey === 0 ? "key" : "value";
|
|
switch (type) {
|
|
case "key": {
|
|
const newKey = mapper(keyToRow);
|
|
parent.set(newKey, parent.get(keyToRow));
|
|
if (newKey !== keyToRow) {
|
|
parent.delete(keyToRow);
|
|
}
|
|
break;
|
|
}
|
|
case "value": {
|
|
parent.set(keyToRow, mapper(parent.get(keyToRow)));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return object;
|
|
};
|
|
function traverse(tree, walker2, origin = []) {
|
|
if (!tree) {
|
|
return;
|
|
}
|
|
if (!isArray(tree)) {
|
|
forEach(tree, (subtree, key) => traverse(subtree, walker2, [...origin, ...parsePath(key)]));
|
|
return;
|
|
}
|
|
const [nodeValue, children2] = tree;
|
|
if (children2) {
|
|
forEach(children2, (child, key) => {
|
|
traverse(child, walker2, [...origin, ...parsePath(key)]);
|
|
});
|
|
}
|
|
walker2(nodeValue, origin);
|
|
}
|
|
function applyValueAnnotations(plain, annotations, superJson) {
|
|
traverse(annotations, (type, path) => {
|
|
plain = setDeep(plain, path, (v) => untransformValue(v, type, superJson));
|
|
});
|
|
return plain;
|
|
}
|
|
function applyReferentialEqualityAnnotations(plain, annotations) {
|
|
function apply(identicalPaths, path) {
|
|
const object = getDeep(plain, parsePath(path));
|
|
identicalPaths.map(parsePath).forEach((identicalObjectPath) => {
|
|
plain = setDeep(plain, identicalObjectPath, () => object);
|
|
});
|
|
}
|
|
if (isArray(annotations)) {
|
|
const [root, other] = annotations;
|
|
root.forEach((identicalPath) => {
|
|
plain = setDeep(plain, parsePath(identicalPath), () => plain);
|
|
});
|
|
if (other) {
|
|
forEach(other, apply);
|
|
}
|
|
} else {
|
|
forEach(annotations, apply);
|
|
}
|
|
return plain;
|
|
}
|
|
var isDeep = (object, superJson) => isPlainObject(object) || isArray(object) || isMap(object) || isSet(object) || isInstanceOfRegisteredClass(object, superJson);
|
|
function addIdentity(object, path, identities) {
|
|
const existingSet = identities.get(object);
|
|
if (existingSet) {
|
|
existingSet.push(path);
|
|
} else {
|
|
identities.set(object, [path]);
|
|
}
|
|
}
|
|
function generateReferentialEqualityAnnotations(identitites, dedupe) {
|
|
const result = {};
|
|
let rootEqualityPaths = void 0;
|
|
identitites.forEach((paths) => {
|
|
if (paths.length <= 1) {
|
|
return;
|
|
}
|
|
if (!dedupe) {
|
|
paths = paths.map((path) => path.map(String)).sort((a, b) => a.length - b.length);
|
|
}
|
|
const [representativePath, ...identicalPaths] = paths;
|
|
if (representativePath.length === 0) {
|
|
rootEqualityPaths = identicalPaths.map(stringifyPath);
|
|
} else {
|
|
result[stringifyPath(representativePath)] = identicalPaths.map(stringifyPath);
|
|
}
|
|
});
|
|
if (rootEqualityPaths) {
|
|
if (isEmptyObject(result)) {
|
|
return [rootEqualityPaths];
|
|
} else {
|
|
return [rootEqualityPaths, result];
|
|
}
|
|
} else {
|
|
return isEmptyObject(result) ? void 0 : result;
|
|
}
|
|
}
|
|
var walker = (object, identities, superJson, dedupe, path = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
|
|
const primitive = isPrimitive(object);
|
|
if (!primitive) {
|
|
addIdentity(object, path, identities);
|
|
const seen = seenObjects.get(object);
|
|
if (seen) {
|
|
return dedupe ? {
|
|
transformedValue: null
|
|
} : seen;
|
|
}
|
|
}
|
|
if (!isDeep(object, superJson)) {
|
|
const transformed2 = transformValue(object, superJson);
|
|
const result2 = transformed2 ? {
|
|
transformedValue: transformed2.value,
|
|
annotations: [transformed2.type]
|
|
} : {
|
|
transformedValue: object
|
|
};
|
|
if (!primitive) {
|
|
seenObjects.set(object, result2);
|
|
}
|
|
return result2;
|
|
}
|
|
if (includes(objectsInThisPath, object)) {
|
|
return {
|
|
transformedValue: null
|
|
};
|
|
}
|
|
const transformationResult = transformValue(object, superJson);
|
|
const transformed = (transformationResult == null ? void 0 : transformationResult.value) ?? object;
|
|
const transformedValue = isArray(transformed) ? [] : {};
|
|
const innerAnnotations = {};
|
|
forEach(transformed, (value, index) => {
|
|
if (index === "__proto__" || index === "constructor" || index === "prototype") {
|
|
throw new Error(`Detected property ${index}. This is a prototype pollution risk, please remove it from your object.`);
|
|
}
|
|
const recursiveResult = walker(value, identities, superJson, dedupe, [...path, index], [...objectsInThisPath, object], seenObjects);
|
|
transformedValue[index] = recursiveResult.transformedValue;
|
|
if (isArray(recursiveResult.annotations)) {
|
|
innerAnnotations[index] = recursiveResult.annotations;
|
|
} else if (isPlainObject(recursiveResult.annotations)) {
|
|
forEach(recursiveResult.annotations, (tree, key) => {
|
|
innerAnnotations[escapeKey(index) + "." + key] = tree;
|
|
});
|
|
}
|
|
});
|
|
const result = isEmptyObject(innerAnnotations) ? {
|
|
transformedValue,
|
|
annotations: !!transformationResult ? [transformationResult.type] : void 0
|
|
} : {
|
|
transformedValue,
|
|
annotations: !!transformationResult ? [transformationResult.type, innerAnnotations] : innerAnnotations
|
|
};
|
|
if (!primitive) {
|
|
seenObjects.set(object, result);
|
|
}
|
|
return result;
|
|
};
|
|
function getType2(payload) {
|
|
return Object.prototype.toString.call(payload).slice(8, -1);
|
|
}
|
|
function isArray2(payload) {
|
|
return getType2(payload) === "Array";
|
|
}
|
|
function isPlainObject2(payload) {
|
|
if (getType2(payload) !== "Object")
|
|
return false;
|
|
const prototype = Object.getPrototypeOf(payload);
|
|
return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
|
|
}
|
|
function assignProp2(carry, key, newVal, originalObject, includeNonenumerable) {
|
|
const propType = {}.propertyIsEnumerable.call(originalObject, key) ? "enumerable" : "nonenumerable";
|
|
if (propType === "enumerable")
|
|
carry[key] = newVal;
|
|
if (includeNonenumerable && propType === "nonenumerable") {
|
|
Object.defineProperty(carry, key, {
|
|
value: newVal,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
}
|
|
}
|
|
function copy(target, options = {}) {
|
|
if (isArray2(target)) {
|
|
return target.map((item) => copy(item, options));
|
|
}
|
|
if (!isPlainObject2(target)) {
|
|
return target;
|
|
}
|
|
const props = Object.getOwnPropertyNames(target);
|
|
const symbols = Object.getOwnPropertySymbols(target);
|
|
return [...props, ...symbols].reduce((carry, key) => {
|
|
if (isArray2(options.props) && !options.props.includes(key)) {
|
|
return carry;
|
|
}
|
|
const val = target[key];
|
|
const newVal = copy(val, options);
|
|
assignProp2(carry, key, newVal, target, options.nonenumerable);
|
|
return carry;
|
|
}, {});
|
|
}
|
|
var SuperJSON = class {
|
|
/**
|
|
* @param dedupeReferentialEqualities If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
|
|
*/
|
|
constructor({ dedupe = false } = {}) {
|
|
this.classRegistry = new ClassRegistry();
|
|
this.symbolRegistry = new Registry((s) => s.description ?? "");
|
|
this.customTransformerRegistry = new CustomTransformerRegistry();
|
|
this.allowedErrorProps = [];
|
|
this.dedupe = dedupe;
|
|
}
|
|
serialize(object) {
|
|
const identities = /* @__PURE__ */ new Map();
|
|
const output = walker(object, identities, this, this.dedupe);
|
|
const res = {
|
|
json: output.transformedValue
|
|
};
|
|
if (output.annotations) {
|
|
res.meta = {
|
|
...res.meta,
|
|
values: output.annotations
|
|
};
|
|
}
|
|
const equalityAnnotations = generateReferentialEqualityAnnotations(identities, this.dedupe);
|
|
if (equalityAnnotations) {
|
|
res.meta = {
|
|
...res.meta,
|
|
referentialEqualities: equalityAnnotations
|
|
};
|
|
}
|
|
return res;
|
|
}
|
|
deserialize(payload) {
|
|
const { json, meta } = payload;
|
|
let result = copy(json);
|
|
if (meta == null ? void 0 : meta.values) {
|
|
result = applyValueAnnotations(result, meta.values, this);
|
|
}
|
|
if (meta == null ? void 0 : meta.referentialEqualities) {
|
|
result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities);
|
|
}
|
|
return result;
|
|
}
|
|
stringify(object) {
|
|
return JSON.stringify(this.serialize(object));
|
|
}
|
|
parse(string) {
|
|
return this.deserialize(JSON.parse(string));
|
|
}
|
|
registerClass(v, options) {
|
|
this.classRegistry.register(v, options);
|
|
}
|
|
registerSymbol(v, identifier) {
|
|
this.symbolRegistry.register(v, identifier);
|
|
}
|
|
registerCustom(transformer, name) {
|
|
this.customTransformerRegistry.register({
|
|
name,
|
|
...transformer
|
|
});
|
|
}
|
|
allowErrorProps(...props) {
|
|
this.allowedErrorProps.push(...props);
|
|
}
|
|
};
|
|
SuperJSON.defaultInstance = new SuperJSON();
|
|
SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);
|
|
SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);
|
|
SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);
|
|
SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);
|
|
SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);
|
|
SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
|
|
SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
|
|
SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
|
|
var serialize = SuperJSON.serialize;
|
|
SuperJSON.deserialize;
|
|
var stringify = SuperJSON.stringify;
|
|
SuperJSON.parse;
|
|
SuperJSON.registerClass;
|
|
SuperJSON.registerCustom;
|
|
SuperJSON.registerSymbol;
|
|
SuperJSON.allowErrorProps;
|
|
function getQueryStatusLabel(query) {
|
|
return query.state.fetchStatus === "fetching" ? "fetching" : !query.getObserversCount() ? "inactive" : query.state.fetchStatus === "paused" ? "paused" : query.isStale() ? "stale" : "fresh";
|
|
}
|
|
function getSidedProp(prop, side) {
|
|
return `${prop}${side.charAt(0).toUpperCase() + side.slice(1)}`;
|
|
}
|
|
function getQueryStatusColor({
|
|
queryState,
|
|
observerCount,
|
|
isStale
|
|
}) {
|
|
return queryState.fetchStatus === "fetching" ? "blue" : !observerCount ? "gray" : queryState.fetchStatus === "paused" ? "purple" : isStale ? "yellow" : "green";
|
|
}
|
|
function getMutationStatusColor({
|
|
status,
|
|
isPaused
|
|
}) {
|
|
return isPaused ? "purple" : status === "error" ? "red" : status === "pending" ? "yellow" : status === "success" ? "green" : "gray";
|
|
}
|
|
function getQueryStatusColorByLabel(label) {
|
|
return label === "fresh" ? "green" : label === "stale" ? "yellow" : label === "paused" ? "purple" : label === "inactive" ? "gray" : "blue";
|
|
}
|
|
var displayValue = (value, beautify = false) => {
|
|
const {
|
|
json
|
|
} = serialize(value);
|
|
return JSON.stringify(json, null, beautify ? 2 : void 0);
|
|
};
|
|
var getStatusRank = (q) => q.state.fetchStatus !== "idle" ? 0 : !q.getObserversCount() ? 3 : q.isStale() ? 2 : 1;
|
|
var queryHashSort = (a, b) => a.queryHash.localeCompare(b.queryHash);
|
|
var dateSort = (a, b) => a.state.dataUpdatedAt < b.state.dataUpdatedAt ? 1 : -1;
|
|
var statusAndDateSort = (a, b) => {
|
|
if (getStatusRank(a) === getStatusRank(b)) {
|
|
return dateSort(a, b);
|
|
}
|
|
return getStatusRank(a) > getStatusRank(b) ? 1 : -1;
|
|
};
|
|
var sortFns = {
|
|
status: statusAndDateSort,
|
|
"query hash": queryHashSort,
|
|
"last updated": dateSort
|
|
};
|
|
var getMutationStatusRank = (m) => m.state.isPaused ? 0 : m.state.status === "error" ? 2 : m.state.status === "pending" ? 1 : 3;
|
|
var mutationDateSort = (a, b) => a.state.submittedAt < b.state.submittedAt ? 1 : -1;
|
|
var mutationStatusSort = (a, b) => {
|
|
if (getMutationStatusRank(a) === getMutationStatusRank(b)) {
|
|
return mutationDateSort(a, b);
|
|
}
|
|
return getMutationStatusRank(a) > getMutationStatusRank(b) ? 1 : -1;
|
|
};
|
|
var mutationSortFns = {
|
|
status: mutationStatusSort,
|
|
"last updated": mutationDateSort
|
|
};
|
|
var convertRemToPixels = (rem) => {
|
|
return rem * parseFloat(getComputedStyle(document.documentElement).fontSize);
|
|
};
|
|
var getPreferredColorScheme = () => {
|
|
const [colorScheme, setColorScheme] = createSignal("dark");
|
|
onMount(() => {
|
|
const query = window.matchMedia("(prefers-color-scheme: dark)");
|
|
setColorScheme(query.matches ? "dark" : "light");
|
|
const listener = (e) => {
|
|
setColorScheme(e.matches ? "dark" : "light");
|
|
};
|
|
query.addEventListener("change", listener);
|
|
onCleanup(() => query.removeEventListener("change", listener));
|
|
});
|
|
return colorScheme;
|
|
};
|
|
var updateNestedDataByPath = (oldData, updatePath, value) => {
|
|
if (updatePath.length === 0) {
|
|
return value;
|
|
}
|
|
if (oldData instanceof Map) {
|
|
const newData = new Map(oldData);
|
|
if (updatePath.length === 1) {
|
|
newData.set(updatePath[0], value);
|
|
return newData;
|
|
}
|
|
const [head, ...tail] = updatePath;
|
|
newData.set(head, updateNestedDataByPath(newData.get(head), tail, value));
|
|
return newData;
|
|
}
|
|
if (oldData instanceof Set) {
|
|
const setAsArray = updateNestedDataByPath(Array.from(oldData), updatePath, value);
|
|
return new Set(setAsArray);
|
|
}
|
|
if (Array.isArray(oldData)) {
|
|
const newData = [...oldData];
|
|
if (updatePath.length === 1) {
|
|
newData[updatePath[0]] = value;
|
|
return newData;
|
|
}
|
|
const [head, ...tail] = updatePath;
|
|
newData[head] = updateNestedDataByPath(newData[head], tail, value);
|
|
return newData;
|
|
}
|
|
if (oldData instanceof Object) {
|
|
const newData = {
|
|
...oldData
|
|
};
|
|
if (updatePath.length === 1) {
|
|
newData[updatePath[0]] = value;
|
|
return newData;
|
|
}
|
|
const [head, ...tail] = updatePath;
|
|
newData[head] = updateNestedDataByPath(newData[head], tail, value);
|
|
return newData;
|
|
}
|
|
return oldData;
|
|
};
|
|
var deleteNestedDataByPath = (oldData, deletePath) => {
|
|
if (oldData instanceof Map) {
|
|
const newData = new Map(oldData);
|
|
if (deletePath.length === 1) {
|
|
newData.delete(deletePath[0]);
|
|
return newData;
|
|
}
|
|
const [head, ...tail] = deletePath;
|
|
newData.set(head, deleteNestedDataByPath(newData.get(head), tail));
|
|
return newData;
|
|
}
|
|
if (oldData instanceof Set) {
|
|
const setAsArray = deleteNestedDataByPath(Array.from(oldData), deletePath);
|
|
return new Set(setAsArray);
|
|
}
|
|
if (Array.isArray(oldData)) {
|
|
const newData = [...oldData];
|
|
if (deletePath.length === 1) {
|
|
return newData.filter((_, idx) => idx.toString() !== deletePath[0]);
|
|
}
|
|
const [head, ...tail] = deletePath;
|
|
newData[head] = deleteNestedDataByPath(newData[head], tail);
|
|
return newData;
|
|
}
|
|
if (oldData instanceof Object) {
|
|
const newData = {
|
|
...oldData
|
|
};
|
|
if (deletePath.length === 1) {
|
|
delete newData[deletePath[0]];
|
|
return newData;
|
|
}
|
|
const [head, ...tail] = deletePath;
|
|
newData[head] = deleteNestedDataByPath(newData[head], tail);
|
|
return newData;
|
|
}
|
|
return oldData;
|
|
};
|
|
var setupStyleSheet = (nonce, target) => {
|
|
if (!nonce) return;
|
|
const styleExists = document.querySelector("#_goober") || (target == null ? void 0 : target.querySelector("#_goober"));
|
|
if (styleExists) return;
|
|
const styleTag = document.createElement("style");
|
|
const textNode = document.createTextNode("");
|
|
styleTag.appendChild(textNode);
|
|
styleTag.id = "_goober";
|
|
styleTag.setAttribute("nonce", nonce);
|
|
if (target) {
|
|
target.appendChild(styleTag);
|
|
} else {
|
|
document.head.appendChild(styleTag);
|
|
}
|
|
};
|
|
|
|
export {
|
|
$TRACK,
|
|
createRoot,
|
|
createSignal,
|
|
createComputed,
|
|
createRenderEffect,
|
|
createEffect,
|
|
createMemo,
|
|
batch,
|
|
untrack,
|
|
on,
|
|
onMount,
|
|
onCleanup,
|
|
getOwner,
|
|
useTransition,
|
|
createContext,
|
|
useContext,
|
|
createComponent,
|
|
mergeProps,
|
|
splitProps,
|
|
lazy,
|
|
createUniqueId,
|
|
For,
|
|
Index,
|
|
Show,
|
|
Switch,
|
|
Match,
|
|
DEV,
|
|
memo,
|
|
render,
|
|
template,
|
|
delegateEvents,
|
|
clearDelegatedEvents,
|
|
setAttribute,
|
|
className,
|
|
addEventListener,
|
|
spread,
|
|
use,
|
|
insert,
|
|
isServer,
|
|
Portal,
|
|
Dynamic,
|
|
serialize,
|
|
stringify,
|
|
getQueryStatusLabel,
|
|
getSidedProp,
|
|
getQueryStatusColor,
|
|
getMutationStatusColor,
|
|
getQueryStatusColorByLabel,
|
|
displayValue,
|
|
sortFns,
|
|
mutationSortFns,
|
|
convertRemToPixels,
|
|
getPreferredColorScheme,
|
|
updateNestedDataByPath,
|
|
deleteNestedDataByPath,
|
|
setupStyleSheet
|
|
};
|
|
//# sourceMappingURL=chunk-Y4ZU6YGQ.js.map
|