@askrjs/askr 0.0.52 → 0.0.54

package/dist/component-internal-D9PLuFUc.js

@@ -0,0 +1,614 @@
+import { r as markEagerControlPrimitive } from "./control-DhFRTIoE.js";
+import { b as isDevelopmentEnvironment, n as enqueueRuntimeTask, o as getRuntimeRenderer, v as logger, x as isProductionEnvironment } from "./access-Bg4RJNC8.js";
+import { r as tryRuntimeFastLaneSync, s as finalizeReadableSubscriptions } from "./fastlane-Dw8SOBr9.js";
+import { r as STATIC_CHILDREN, t as ELEMENT_TYPE } from "./jsx-CUpRxrLH.js";
+import { C as restoreRenderScopedComponent, S as restoreInlineRenderTracking, _ as getSignalForInstance, b as restoreDomCommitScope, c as enterDomCommitScope, f as getCurrentComponentInstance, l as enterRenderScopedComponent, m as getCurrentPortalScope, n as captureInlineComponentScope, o as clearRenderTracking, p as getCurrentInstance, r as captureInlineRenderTracking, s as enterComponentExecutionScope, t as beginRenderTracking, u as exitComponentExecutionScope, v as resetRenderState, x as restoreInlineComponentScope } from "./component-scope-CC3cojX9.js";
+import { a as captureInlineRenderSnapshot$1, c as finalizeInlineReadSubscriptions, i as beginLifecycleCommitBatch, l as flushLifecycleCommitBatch, m as isPromiseLike, n as commitRenderedComponent$1, o as discardLifecycleCommitBatch, p as discardCommitOperations, r as registerCommitOperationForInstance, t as commitLifecycleForInstance } from "./component-lifecycle-C7lnU9Bt.js";
+//#region src/runtime/context.ts
+const ROOT_EXECUTION_FRAME = {
+	parent: null,
+	values: null
+};
+const executionFramesByParent = /* @__PURE__ */ new WeakMap();
+/** @internal Reuse immutable empty wrappers for the same provider snapshot. */
+function getExecutionContextFrame(parent) {
+	if (!parent) return ROOT_EXECUTION_FRAME;
+	let frame = executionFramesByParent.get(parent);
+	if (!frame) {
+		frame = {
+			parent,
+			values: null
+		};
+		executionFramesByParent.set(parent, frame);
+	}
+	return frame;
+}
+const CONTEXT_FRAME_SYMBOL = Symbol("__tempoContextFrame__");
+const vnodeContextFrames = /* @__PURE__ */ new WeakMap();
+function getVNodeContextFrame(node) {
+	if (typeof node !== "object" || node === null) return;
+	const objectNode = node;
+	return vnodeContextFrames.get(node) ?? objectNode[CONTEXT_FRAME_SYMBOL];
+}
+function markVNodeWithContextFrame(node, frame, overwrite = false) {
+	if (typeof node !== "object" || node === null) return;
+	if (!overwrite && getVNodeContextFrame(node)) return;
+	const objectNode = node;
+	if (Object.prototype.hasOwnProperty.call(node, CONTEXT_FRAME_SYMBOL)) try {
+		objectNode[CONTEXT_FRAME_SYMBOL] = frame;
+		return;
+	} catch {}
+	if (Object.isExtensible(node)) try {
+		Object.defineProperty(node, CONTEXT_FRAME_SYMBOL, {
+			value: frame,
+			writable: true,
+			enumerable: true,
+			configurable: true
+		});
+		return;
+	} catch {}
+	vnodeContextFrames.set(node, frame);
+}
+function isVNodeLike(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const objectValue = value;
+	if (objectValue.$$typeof === ELEMENT_TYPE) return true;
+	return "type" in objectValue && ("props" in objectValue || "children" in objectValue);
+}
+function markContextPropValue(value, frame, overwrite) {
+	if (Array.isArray(value)) {
+		for (const item of value) markContextPropValue(item, frame, overwrite);
+		return;
+	}
+	if (isVNodeLike(value)) markVNodeTreeWithContextFrame(value, frame, overwrite);
+}
+function markVNodeTreeWithContextFrame(node, frame, overwrite = false) {
+	if (!frame) return node;
+	if (Array.isArray(node)) {
+		for (const child of node) markVNodeTreeWithContextFrame(child, frame, overwrite);
+		return node;
+	}
+	if (typeof node !== "object" || node === null) return node;
+	markVNodeWithContextFrame(node, frame, overwrite);
+	const objectNode = node;
+	const props = typeof objectNode.props === "object" && objectNode.props !== null ? objectNode.props : null;
+	const children = props?.children ?? objectNode.children;
+	if (Array.isArray(children)) for (const child of children) markVNodeTreeWithContextFrame(child, frame, overwrite);
+	else if (children) markVNodeTreeWithContextFrame(children, frame, overwrite);
+	if (props) {
+		for (const key in props) if (key !== "children") markContextPropValue(props[key], frame, overwrite);
+	}
+	return node;
+}
+let currentContextFrame = null;
+let currentAsyncResourceFrame = null;
+/**
+* Execute a function within a specific context frame.
+*
+* CORE PRIMITIVE for context restoration:
+* - Saves the current context
+* - Sets the provided frame as current
+* - Executes the function
+* - Restores the previous context in finally
+*
+* This ensures no context frame remains globally active across await.
+*/
+function withContext(frame, fn) {
+	const oldFrame = currentContextFrame;
+	currentContextFrame = frame;
+	try {
+		return fn();
+	} finally {
+		currentContextFrame = oldFrame;
+	}
+}
+/** @internal Invoke a two-argument function without allocating a wrapper. */
+function callWithContext(frame, fn, args, context) {
+	const oldFrame = currentContextFrame;
+	currentContextFrame = frame;
+	try {
+		return fn(args, context);
+	} finally {
+		currentContextFrame = oldFrame;
+	}
+}
+/**
+* Execute an async resource step within its frozen context snapshot.
+*
+* CRITICAL: This wrapper is applied only to synchronous execution steps of
+* an async resource (the initial call). We intentionally DO NOT restore
+* the resource frame for post-await continuations — continuations must not
+* observe or rely on a live resource frame. This keeps semantics simple and
+* deterministic: async resources see only their creation-time snapshot.
+*/
+function withAsyncResourceContext(frame, fn) {
+	const oldFrame = currentAsyncResourceFrame;
+	currentAsyncResourceFrame = frame;
+	try {
+		return fn();
+	} finally {
+		currentAsyncResourceFrame = oldFrame;
+	}
+}
+function defineScope(defaultValue) {
+	const key = Symbol("AskrContext");
+	const scope = markEagerControlPrimitive((props) => ({
+		$$typeof: ELEMENT_TYPE,
+		type: ContextScopeComponent,
+		props: {
+			key,
+			value: props.value,
+			children: props.children
+		},
+		key: null
+	}));
+	return Object.assign(scope, {
+		key,
+		defaultValue
+	});
+}
+function preserveStaticChildrenMarker(source, target) {
+	if (source[STATIC_CHILDREN] === true) Object.defineProperty(target, STATIC_CHILDREN, {
+		value: true,
+		enumerable: false,
+		configurable: true
+	});
+	return target;
+}
+function isPresentRenderable(value) {
+	return value !== null && value !== void 0 && value !== false;
+}
+function readScope(context) {
+	const frame = currentContextFrame || currentAsyncResourceFrame;
+	if (!frame) throw new Error("readScope() can only be called during component render or async resource execution. Ensure you are calling this from inside your component or resource function.");
+	let current = frame;
+	while (current) {
+		const values = current.values;
+		if (values && values.has(context.key)) return values.get(context.key);
+		current = current.parent;
+	}
+	return context.defaultValue;
+}
+/**
+* Internal component that manages context frame
+* Used by a scope component to provide a shadowed value to its children.
+*/
+function ContextScopeComponent(props) {
+	const key = props["key"];
+	const value = props["value"];
+	const children = props["children"];
+	const instance = getCurrentComponentInstance();
+	const newFrame = {
+		parent: (() => {
+			if (currentContextFrame) return currentContextFrame;
+			if (instance && instance.ownerFrame) return instance.ownerFrame;
+			return null;
+		})(),
+		values: /* @__PURE__ */ new Map([[key, value]])
+	};
+	function createFunctionChildInvoker(fn, frame, owner) {
+		return {
+			type: ContextFunctionChildInvoker,
+			props: {
+				fn,
+				__frame: frame,
+				__owner: owner
+			}
+		};
+	}
+	if (Array.isArray(children)) return preserveStaticChildrenMarker(children, children.map((child) => {
+		if (typeof child === "function") return createFunctionChildInvoker(child, newFrame, getCurrentComponentInstance());
+		return markWithFrame(child, newFrame);
+	}));
+	else if (typeof children === "function") return createFunctionChildInvoker(children, newFrame, getCurrentComponentInstance());
+	else if (isPresentRenderable(children)) return markWithFrame(children, newFrame);
+	return null;
+}
+/**
+* Internal: Mark a vnode with a context frame
+* The renderer will restore this frame before executing component functions
+*/
+function markWithFrame(node, frame) {
+	return markVNodeTreeWithContextFrame(node, frame, true);
+}
+/**
+* Internal helper component: executes a function-child lazily inside the
+* provided frame and marks the returned subtree with that frame so later
+* component executions will restore the correct context frame.
+*
+* SNAPSHOT SEMANTIC: The frame passed here is the snapshot captured at render
+* time. Any resources created during this execution will observe this frozen
+* snapshot, ensuring deterministic behavior.
+*/
+function ContextFunctionChildInvoker(props) {
+	const { fn, __frame } = props;
+	const res = withContext(__frame, () => fn());
+	if (isPresentRenderable(res)) return markWithFrame(res, __frame);
+	return null;
+}
+/**
+* Get the current context frame for inspection (used by tests/diagnostics only)
+*/
+function getCurrentContextFrame() {
+	return currentContextFrame;
+}
+//#endregion
+//#region src/runtime/component-commit.ts
+function runScheduledComponent(instance, host) {
+	const ownershipGeneration = instance._ownershipGeneration;
+	const evaluationGeneration = instance.evaluationGeneration;
+	instance.notifyUpdate = instance._enqueueRun;
+	beginRenderTracking(instance);
+	let result;
+	try {
+		result = host.execute(instance);
+	} catch (err) {
+		discardCommitOperations(instance);
+		throw err;
+	}
+	if (isPromiseLike(result)) throw new Error("Async components are not supported. Components must be synchronous.");
+	try {
+		if (tryRuntimeFastLaneSync(instance, result)) {
+			host.warnUnusedStateReads(instance);
+			return;
+		}
+	} catch (err) {
+		if (isDevelopmentEnvironment()) throw err;
+	}
+	enqueueRuntimeTask(() => {
+		if (instance._ownershipGeneration !== ownershipGeneration || instance.evaluationGeneration !== evaluationGeneration) return;
+		if (!instance.target && instance._placeholder) {
+			commitPlaceholderReplacement(instance, result, host);
+			return;
+		}
+		if (instance.target) commitToTarget(instance, result, host);
+	});
+}
+function commitPlaceholderReplacement(instance, result, host) {
+	if (result === null || result === void 0) {
+		host.finalizeReadSubscriptions(instance);
+		host.warnUnusedStateReads(instance);
+		host.commitRenderedComponent(instance);
+		return;
+	}
+	const placeholder = instance._placeholder;
+	const parent = placeholder.parentNode;
+	if (!parent) {
+		logger.warn("[Askr] placeholder no longer in DOM, cannot render component");
+		return;
+	}
+	const renderer = getRuntimeRenderer();
+	const hostElement = document.createElement("div");
+	const executionFrame = getExecutionContextFrame(instance.ownerFrame);
+	const oldInstance = enterDomCommitScope(instance);
+	const lifecycleBatch = beginLifecycleCommitBatch();
+	try {
+		try {
+			withContext(executionFrame, () => {
+				renderer.evaluate(result, hostElement);
+			});
+			const onlyChild = hostElement.childNodes.length === 1 ? hostElement.firstChild : null;
+			const replacement = onlyChild instanceof Element ? onlyChild : hostElement;
+			if (replacement === hostElement) hostElement.__ASKR_WRAPPER_HOST = true;
+			parent.replaceChild(replacement, placeholder);
+			instance.target = replacement;
+			const instanceHost = replacement;
+			const instances = instanceHost.__ASKR_INSTANCES ?? [];
+			if (!instances.includes(instance)) instances.push(instance);
+			instanceHost.__ASKR_INSTANCES = instances;
+			instanceHost.__ASKR_INSTANCE = instances[0] ?? instance;
+		} catch (err) {
+			discardLifecycleCommitBatch(lifecycleBatch);
+			throw err;
+		}
+		instance._placeholder = void 0;
+		host.finalizeReadSubscriptions(instance);
+		host.warnUnusedStateReads(instance);
+		host.commitRenderedComponent(instance);
+		flushLifecycleCommitBatch(lifecycleBatch);
+	} finally {
+		restoreDomCommitScope(oldInstance);
+	}
+}
+function commitToTarget(instance, result, host) {
+	const renderer = getRuntimeRenderer();
+	const target = instance.target;
+	let oldChildren = [];
+	let restoredOldChildren = false;
+	try {
+		const wasFirstMount = !instance.mounted;
+		const oldInstance = enterDomCommitScope(instance);
+		const executionFrame = getExecutionContextFrame(instance.ownerFrame);
+		oldChildren = Array.from(target.childNodes);
+		const lifecycleBatch = beginLifecycleCommitBatch();
+		try {
+			try {
+				withContext(executionFrame, () => {
+					renderer.evaluate(result, target, void 0, instance);
+				});
+			} catch (err) {
+				discardLifecycleCommitBatch(lifecycleBatch);
+				throw err;
+			}
+		} catch (err) {
+			cleanupFailedCommitChildren(renderer, target, oldChildren);
+			try {
+				(/* @__PURE__ */ new Error()).stack;
+			} catch (devErr) {}
+			target.replaceChildren(...oldChildren);
+			restoredOldChildren = true;
+			throw err;
+		} finally {
+			restoreDomCommitScope(oldInstance);
+		}
+		host.finalizeReadSubscriptions(instance);
+		host.warnUnusedStateReads(instance);
+		instance.mounted = true;
+		commitLifecycleForInstance(instance, wasFirstMount);
+		flushLifecycleCommitBatch(lifecycleBatch);
+	} catch (renderError) {
+		discardCommitOperations(instance);
+		cleanupRollbackChildren(renderer, target, oldChildren, restoredOldChildren);
+		const rollbackErrors = [];
+		try {
+			(/* @__PURE__ */ new Error()).stack;
+			target.replaceChildren(...oldChildren);
+		} catch (rollbackError) {
+			rollbackErrors.push(rollbackError);
+		}
+		if (rollbackErrors.length > 0) logger.error("[Askr] component rollback failed after render error:", new AggregateError(rollbackErrors, "Component rollback failed"));
+		throw renderError;
+	}
+}
+function cleanupFailedCommitChildren(renderer, target, oldChildren) {
+	try {
+		const newChildren = Array.from(target.childNodes);
+		const preservedChildren = new Set(oldChildren);
+		for (const node of newChildren) {
+			if (preservedChildren.has(node)) continue;
+			try {
+				renderer.cleanupInstancesUnder(node);
+			} catch (err) {
+				logger.warn("[Askr] error cleaning up failed commit children:", err);
+			}
+		}
+	} catch (err) {}
+}
+function cleanupRollbackChildren(renderer, target, oldChildren, restoredOldChildren) {
+	try {
+		const currentChildren = Array.from(target.childNodes);
+		const preservedChildren = restoredOldChildren ? new Set(oldChildren) : null;
+		for (const node of currentChildren) {
+			if (preservedChildren?.has(node)) continue;
+			try {
+				renderer.cleanupInstancesUnder(node);
+			} catch (err) {
+				logger.warn("[Askr] error cleaning up partial children during rollback:", err);
+			}
+		}
+	} catch (err) {}
+}
+//#endregion
+//#region src/runtime/component-internal.ts
+const PRODUCTION_BUILD_ENABLED = isProductionEnvironment();
+function ensurePendingRunTask(instance) {
+	const existing = instance._pendingRunTask;
+	if (existing) return existing;
+	const task = () => {
+		instance.hasPendingUpdate = false;
+		if (instance.notifyUpdate === null) return;
+		runScheduledComponent(instance, {
+			execute: executeComponentSync,
+			finalizeReadSubscriptions,
+			warnUnusedStateReads,
+			commitRenderedComponent
+		});
+	};
+	instance._pendingRunTask = task;
+	if (!instance._pendingFlushTask) instance._pendingFlushTask = task;
+	return task;
+}
+function enqueueComponentRun() {
+	if (this.hasPendingUpdate) return;
+	this.hasPendingUpdate = true;
+	enqueueRuntimeTask(ensurePendingRunTask(this));
+}
+var ComponentExecutionContext = class {
+	constructor(instance) {
+		this.instance = instance;
+	}
+	get signal() {
+		return getSignalForInstance(this.instance);
+	}
+};
+function createComponentInstance(id, fn, props, target) {
+	const parentInstance = getCurrentInstance();
+	const instance = {
+		id,
+		fn,
+		props,
+		target,
+		parentInstance,
+		portalScope: parentInstance?.portalScope ?? getCurrentPortalScope() ?? null,
+		mounted: false,
+		abortController: null,
+		stateValues: void 0,
+		evaluationGeneration: 0,
+		notifyUpdate: null,
+		_pendingFlushTask: void 0,
+		_pendingRunTask: void 0,
+		_enqueueRun: void 0,
+		stateIndexCheck: -1,
+		expectedStateIndices: void 0,
+		firstRenderComplete: false,
+		mountOperations: void 0,
+		commitOperations: void 0,
+		lifecycleSlots: void 0,
+		lifecycleGeneration: 0,
+		hasPendingUpdate: false,
+		ownerFrame: null,
+		ssr: false,
+		cleanupStrict: false,
+		_ownershipGeneration: {},
+		isRoot: false,
+		_currentRenderToken: void 0,
+		lastRenderToken: 0,
+		_pendingReadSources: void 0,
+		_pendingReadSourceVersions: void 0,
+		_lastReadSources: void 0,
+		devWarningsEmitted: void 0
+	};
+	instance._enqueueRun = enqueueComponentRun;
+	return instance;
+}
+/**
+* Register a mount operation that will run after the component is mounted
+* Used by operations (task, on, timer, etc) to execute after render completes
+*/
+function captureInlineRenderSnapshot(instance) {
+	captureInlineRenderSnapshot$1(instance);
+}
+function registerCommitOperation(operation) {
+	registerCommitOperationForInstance(getCurrentComponentInstance(), operation);
+}
+function commitRenderedComponent(instance) {
+	commitRenderedComponent$1(instance);
+}
+function mountInstanceInline(instance, target) {
+	instance.target = target;
+	try {
+		if (target instanceof Element) {
+			const host = target;
+			const instances = host.__ASKR_INSTANCES;
+			if (!instances) {
+				host.__ASKR_INSTANCES = [instance];
+				host.__ASKR_INSTANCE = instance;
+			} else if (instances[instances.length - 1] !== instance) {
+				const nextInstances = instances.indexOf(instance) === -1 ? instances.slice() : instances.filter((entry) => entry !== instance);
+				nextInstances.push(instance);
+				host.__ASKR_INSTANCES = nextInstances;
+				host.__ASKR_INSTANCE = nextInstances[0] ?? instance;
+			}
+		}
+	} catch (err) {}
+	instance.notifyUpdate = instance._enqueueRun;
+	const wasFirstMount = !instance.mounted;
+	instance.mounted = true;
+	commitLifecycleForInstance(instance, wasFirstMount);
+}
+/**
+* Run a component synchronously: execute function, handle result
+* This is the internal workhorse that manages async continuations and generation tracking.
+* Must always be called through the scheduler.
+*
+* ACTOR INVARIANT: This function is enqueued as a task, never called directly.
+*/
+function renderScopedComponent(instance, startStateIndex, render) {
+	instance.notifyUpdate = instance._enqueueRun;
+	resetRenderState(instance);
+	beginRenderTracking(instance);
+	const savedScope = enterRenderScopedComponent(instance, startStateIndex);
+	let didComplete = false;
+	try {
+		const result = withContext(getExecutionContextFrame(instance.ownerFrame), render);
+		didComplete = true;
+		return result;
+	} finally {
+		if (!didComplete) clearRenderTracking(instance);
+		restoreRenderScopedComponent(savedScope);
+	}
+}
+/**
+* Execute a component's render function synchronously.
+* Returns either a vnode/promise immediately (does NOT render).
+* Rendering happens separately through the scheduled commit helper.
+*/
+function renderComponentInline(instance) {
+	instance.notifyUpdate = instance._enqueueRun;
+	const trackingSnapshot = captureInlineRenderTracking(instance);
+	const scopeSnapshot = captureInlineComponentScope();
+	const hadToken = trackingSnapshot.currentRenderToken !== void 0;
+	if (!hadToken) beginRenderTracking(instance);
+	try {
+		const result = executeComponentSync(instance);
+		if (!hadToken) finalizeInlineReadSubscriptions(instance, instance._currentRenderToken, instance._pendingReadSources, instance._pendingReadSourceVersions);
+		commitRenderedComponent(instance);
+		return result;
+	} finally {
+		restoreInlineRenderTracking(instance, trackingSnapshot);
+		restoreInlineComponentScope(scopeSnapshot);
+	}
+}
+function warnUnusedStateReads(instance) {
+	const stateValues = instance.stateValues;
+	if (!stateValues) return;
+	for (let i = 0; i < stateValues.length; i++) {
+		const state = stateValues[i];
+		const hasCommittedUsage = (state?._readers?.size ?? 0) > 0 || (state?._derivedSubscribers?.size ?? 0) > 0;
+		if (state && !state._hasBeenRead && !state._hasEverBeenRead && !hasCommittedUsage) try {
+			const name = instance.fn?.name || "<anonymous>";
+			warnInstanceOnce(instance, `unused-state:${i}`, `[askr] Unused state variable detected in ${name} at index ${i}. State should be read during render or removed.`);
+		} catch {
+			warnInstanceOnce(instance, `unused-state:${i}`, `[askr] Unused state variable detected. State should be read during render or removed.`);
+		}
+	}
+}
+function executeComponentSync(instance) {
+	resetRenderState(instance);
+	const savedPortalScope = enterComponentExecutionScope(instance);
+	let didComplete = false;
+	try {
+		const trackRenderTime = !PRODUCTION_BUILD_ENABLED && isDevelopmentEnvironment();
+		const renderStartTime = trackRenderTime ? Date.now() : 0;
+		const context = new ComponentExecutionContext(instance);
+		const result = callWithContext(getExecutionContextFrame(instance.ownerFrame), instance.fn, instance.props, context);
+		if (trackRenderTime) {
+			const renderTime = Date.now() - renderStartTime;
+			if (renderTime > 5) warnInstanceOnce(instance, "slow-render", `[askr] Slow render detected: ${renderTime}ms. Consider optimizing component performance.`);
+		}
+		if (!instance.firstRenderComplete) instance.firstRenderComplete = true;
+		didComplete = true;
+		return result;
+	} finally {
+		if (!didComplete) discardCommitOperations(instance);
+		exitComponentExecutionScope(savedPortalScope);
+	}
+}
+/**
+* Public entry point: Execute component with full lifecycle (execute + render)
+* Handles both initial mount and re-execution. Always enqueues through scheduler.
+* Single entry point to avoid lifecycle divergence.
+*/
+function executeComponent(instance) {
+	instance.abortController = null;
+	instance.notifyUpdate = instance._enqueueRun;
+	enqueueRuntimeTask(ensurePendingRunTask(instance));
+}
+/**
+* Finalize read subscriptions for an instance after a successful commit.
+* - Update per-state readers map to point to this instance's last committed token
+* - Remove this instance from states it no longer reads
+* This is deterministic and runs synchronously with commit to ensure
+* subscribers are only notified when they actually read a state in their
+* last committed render.
+*/
+function finalizeReadSubscriptions(instance) {
+	finalizeReadableSubscriptions(instance);
+}
+/**
+* Mount a component instance.
+* This is just an alias to executeComponent() to maintain API compatibility.
+* All lifecycle logic is unified in executeComponent().
+*/
+function mountComponent(instance) {
+	executeComponent(instance);
+}
+function warnInstanceOnce(instance, key, message) {
+	if (isProductionEnvironment()) return;
+	const warnings = instance.devWarningsEmitted ??= /* @__PURE__ */ new Set();
+	if (warnings.has(key)) return;
+	warnings.add(key);
+	logger.warn(message);
+}
+//#endregion
+export { withContext as _, registerCommitOperation as a, warnUnusedStateReads as c, getCurrentContextFrame as d, getExecutionContextFrame as f, withAsyncResourceContext as g, readScope as h, mountInstanceInline as i, callWithContext as l, markVNodeTreeWithContextFrame as m, createComponentInstance as n, renderComponentInline as o, getVNodeContextFrame as p, mountComponent as r, renderScopedComponent as s, captureInlineRenderSnapshot as t, defineScope as u };