marko/dist/dom.mjs

Optimized runtime for Marko templates.

let empty = [], rest = Symbol(), classIdToBranch = /* @__PURE__ */ new Map(), classEventResolver, scopesByRender = /* @__PURE__ */ new WeakMap(), getRenderScopes = ($global) => {
	init($global.runtimeId);
	let render = self[$global.runtimeId]?.[$global.renderId], scopes = render && scopesByRender.get(render);
	return render && !scopes && scopesByRender.set(render, scopes = {}), scopes;
}, compat = {
	patchDynamicTag,
	queueEffect,
	init(warp10Noop) {
		_resume("$C_s", (scope) => {
			if (getRenderScopes(scope.$)[scope.L] = scope, scope.m5c && classIdToBranch.set(scope.m5c, scope), classEventResolver) for (let key in scope) {
				let resolved = classEventResolver(scope[key], scope);
				resolved !== scope[key] && (scope[key] = resolved);
			}
		}), _resume("$C_b", warp10Noop);
	},
	setClassEventResolver(fn) {
		classEventResolver = fn;
	},
	resumeClassFunction(id, build) {
		_resume(id, build);
	},
	getScope($global, scopeId) {
		return getRenderScopes($global)?.[scopeId];
	},
	setRendererId(renderer, id) {
		renderer.a = id;
	},
	isRenderer(renderer) {
		return renderer.b;
	},
	getStartNode(branch) {
		return branch.S;
	},
	getEndNode(branch) {
		return branch.K;
	},
	setScopeNodes(branch, startNode, endNode) {
		branch.S = startNode, branch.K = endNode;
	},
	runComponentEffects() {
		this.effects && runEffects(this.effects);
	},
	runComponentDestroy() {
		this.scope && destroyBranch(this.scope);
	},
	resolveRegistered(value, $global) {
		return Array.isArray(value) && typeof value[0] == "string" ? getRegisteredWithScope(value[0], getRenderScopes($global)?.[value[1]]) : value;
	},
	createRenderer(params, clone) {
		let renderer = _content("", 0, 0, 0, params)();
		return renderer.b = (branch) => {
			let cloned = clone();
			branch.S = cloned.startNode, branch.K = cloned.endNode;
		}, renderer;
	},
	render(out, component, renderer, args) {
		init(out.global.runtimeId);
		let branch = component.scope, created = 0;
		if (!branch && (branch = classIdToBranch.get(component.id)) && (component.scope = branch, classIdToBranch.delete(component.id)), args[0] && typeof args[0] == "object" && "renderBody" in args[0]) {
			let input = args[0], normalizedInput = args[0] = {};
			for (let key in input) normalizedInput[key === "renderBody" ? "content" : key] = input[key];
		}
		if (component.effects = prepareEffects(() => {
			branch ||= (created = 1, component.scope = createAndSetupBranch(out.global, renderer, renderer.e, document.body)), renderer.d?.(branch, renderer._ ? args[0] : args);
		}), created) return toInsertNode(branch.S, branch.K);
	}
}, _template = (id, template, walks, setup, inputSignal) => {
	let renderer = _content(id, template, walks, setup, inputSignal)();
	return renderer.mount = mount, renderer._ = renderer, _resume(id, renderer);
}, _load_template = /*@__PURE__*/ withLazy((id, load) => {
	let pending, lazyTemplate = _template(id, 0, 0, (branch) => {
		let awaitCounter = addAwaitCounter(branch);
		branch.X ||= /* @__PURE__ */ new Map(), (pending ||= load()).then((renderer) => {
			Object.assign(lazyTemplate, renderer), queueAsyncRender(branch, (branch) => insertLoaded(renderer, branch, branch.S, awaitCounter));
		}, loadFailed(branch, awaitCounter));
	}, _load_signal(() => (pending ||= load()).then((r) => ({ _: r.d }))));
	return lazyTemplate;
}), _load_setup = /*@__PURE__*/ withLazy((nodeAccessor, childScopeAccessor, load) => {
	nodeAccessor = decodeAccessor(nodeAccessor), childScopeAccessor = decodeAccessor(childScopeAccessor);
	let pending, renderer, insertCached = (child, marker) => insertLoaded(renderer, child, marker);
	return (owner) => {
		let child = owner[childScopeAccessor];
		if (renderer) queueRender(child, insertCached, -1, owner[nodeAccessor]);
		else {
			let awaitCounter = addAwaitCounter(owner);
			child.X ||= /* @__PURE__ */ new Map(), (pending ||= load()).then((mod) => {
				renderer = _content("", ...mod._)(), queueAsyncRender(child, (child) => insertLoaded(renderer, child, owner[nodeAccessor], awaitCounter));
			}, loadFailed(child, awaitCounter));
		}
	};
}), _load_signal = /*@__PURE__*/ withLazy((load) => {
	let pending, apply = (scope, value) => {
		pending ||= load(), scope.X || !("X" in scope) && scope.H === runId ? (scope.X ||= /* @__PURE__ */ new Map()).set(pending, [value, apply]) : apply._ ? apply._(scope, value) : pending.then((mod) => queueAsyncRender(scope, apply._ = mod._, value), () => 0);
	};
	return apply;
});
import { $ as _attrs_script, A as _attr_input_value_script, At as _for_closure, B as _attr, Bt as _return, C as _attr_input_checkedValue_script, D as _attr_input_value_attribute_default, Dt as _closure_get, E as _attr_input_value, Et as _closure, F as _controllable_open, Ft as _id, G as _attr_nonce, Gt as _assert_init, H as _attr_class_item, Ht as _script, I as _controllable_select, It as _if_closure, J as _attr_style_items, Jt as removeAndDestroyBranch, K as _attr_style, Kt as destroyBranch, L as _controllable_textarea, Lt as _let, M as _attr_select_value_default, Mt as _global_read, N as _attr_select_value_script, Nt as _hoist, O as _attr_input_value_default, Ot as _const, P as _controllable_input, Pt as _hoist_resume, Q as _attrs_partial_content, Qt as $signalReset, Rt as _let_change, S as _attr_input_checkedValue_default, St as readyFailed, T as _attr_input_checked_script, Tt as _child_setup, U as _attr_class_items, Ut as _var, V as _attr_class, Vt as _return_change, W as _attr_content, Wt as _var_change, X as _attrs_content, Xt as _on, Y as _attrs, Yt as syncGen, Z as _attrs_partial, Zt as $signal, _ as _attr_details_or_dialog_open, _t as _var_resume, a as _for_in, an as queueRender, at as _text_content, b as _attr_input_checked, bt as initEmbedded, c as _for_until, cn as runId, ct as toInsertNode, d as _show, dn as forTo, dt as _content_resume, et as _html, f as _try, fn as forUntil, ft as createAndSetupBranch, g as renderCatch, gn as decodeAccessor, gt as _resume, h as patchDynamicTag, hn as _call, ht as _el, i as _dynamic_tag_content, in as queueEffect, it as _text, j as _attr_select_value, jt as _for_selector, k as _attr_input_value_dynamic_default, kt as _el_read, l as _if, ln as forIn, lt as _content, mn as _hoist_read_error, mt as setupBranch, n as _await_promise, nn as prepareEffects, nt as _style_rule_item, o as _for_of, on as run, ot as _to_text, p as addAwaitCounter, pn as _assert_hoist, pt as createBranch, q as _attr_style_item, qt as insertBranchBefore, r as _dynamic_tag, rn as queueAsyncRender, rt as _style_shell, s as _for_to, sn as runEffects, st as insertChildNodes, t as _await_content, tt as _lifecycle, u as _resume_dynamic_tag, un as forOf, ut as _content_closures, v as _attr_details_or_dialog_open_default, vt as getRegisteredWithScope, w as _attr_input_checked_default, wt as withLazy, x as _attr_input_checkedValue, xt as ready, y as _attr_details_or_dialog_open_script, yt as init, zt as _or } from "./dom-BsAS26Ze.mjs";
//#region src/common/attr-tag.ts
function attrTag(attrs) {
	return attrs[Symbol.iterator] = attrTagIterator, attrs[rest] = empty, attrs;
}
function attrTags(first, attrs) {
	return first ? (first[rest] === empty ? first[rest] = [attrs] : first[rest].push(attrs), first) : attrTag(attrs);
}
function* attrTagIterator() {
	yield this, yield* this[rest];
}
//#endregion
//#region src/common/compat-meta.ts
//#endregion
//#region src/dom/compat.ts
//#endregion
//#region src/dom/template.ts
function mount(input = {}, reference, position) {
	let branch, parentNode = reference, nextSibling = null, { $global } = input;
	switch ($global ? ({$global, ...input} = input, $global = {
		runtimeId: "M",
		renderId: "_",
		...$global
	}) : $global = {
		runtimeId: "M",
		renderId: "_"
	}, position) {
		case "beforebegin":
			parentNode = reference.parentNode, nextSibling = reference;
			break;
		case "afterbegin":
			nextSibling = reference.firstChild;
			break;
		case "afterend":
			parentNode = reference.parentNode, nextSibling = reference.nextSibling;
			break;
	}
	let curValue, args = this.d, effects = prepareEffects(() => {
		branch = createBranch($global, this, void 0, parentNode), branch.T = (newValue) => {
			curValue = newValue;
		}, this.c?.(branch), args?.(branch, input);
	});
	return insertChildNodes(parentNode, nextSibling, branch.S, branch.K), runEffects(effects), {
		get value() {
			return curValue;
		},
		set value(newValue) {
			_var_change(branch, newValue);
		},
		update(newInput = {}) {
			args && (newInput.$global && ({$global, ...newInput} = newInput), runEffects(prepareEffects(() => {
				args(branch, newInput);
			})));
		},
		destroy() {
			removeAndDestroyBranch(branch);
		}
	};
}
//#endregion
//#region src/dom/load.ts
function insertLoaded(renderer, branch, marker, awaitCounter) {
	let parent = marker.parentNode, values = branch.X, clone = () => {
		syncGen(branch), renderer.b(branch, parent.namespaceURI), branch.X = 0;
	}, insert = () => {
		insertBranchBefore(branch, parent, marker), marker.remove(), awaitCounter?.c();
	}, remaining;
	if (remaining = values?.size) {
		let fail = loadFailed(branch, awaitCounter);
		values.forEach(([, apply], promise) => promise.then((mod) => (apply._ = mod._) && !--remaining && queueAsyncRender(branch, (branch) => {
			clone(), renderer.c?.(branch), values.forEach(([value, apply]) => apply(branch, value)), insert();
		}), (error) => remaining > 0 && (remaining = 0, fail(error))));
	} else clone(), setupBranch(renderer, branch), insert();
}
function loadFailed(scope, awaitCounter) {
	return (error) => {
		awaitCounter && (awaitCounter.m ? awaitCounter.i = 0 : awaitCounter.c()), queueAsyncRender(scope, renderCatch, error);
	};
}
function _load_visible_trigger(selector, options) {
	let pending, el;
	return (load) => () => (pending ||= new Promise((resolve) => (el = getSelectorOrResolve(selector, resolve)) && new IntersectionObserver((entries, io) => entries.some((entry) => entry.isIntersecting) && resolve(io.disconnect()), options).observe(el))).then(load);
}
function _load_idle_trigger(options) {
	let pending;
	return (load) => () => (pending ||= new Promise((resolve) => (self.requestIdleCallback || resolve)(resolve, options))).then(load);
}
function _load_event_trigger(event, selector) {
	let pending;
	return (load) => () => (pending ||= new Promise((resolve) => getSelectorOrResolve(selector, resolve)?.addEventListener(event, resolve, { once: !0 }))).then(load);
}
function _load_media_trigger(query) {
	let pending, mql;
	return (load) => () => (pending ||= new Promise((resolve) => (mql = matchMedia(query)).matches ? resolve() : mql.addEventListener("change", resolve, { once: !0 }))).then(load);
}
function _load_race_trigger(...triggers) {
	let noop = () => Promise.resolve(), pending;
	return (load) => () => (pending ||= Promise.race(triggers.map((t) => t(noop)()))).then(load);
}
function getSelectorOrResolve(selector, resolve) {
	return document.querySelector(selector) || resolve();
}
//#endregion
export { $signal, $signalReset, _assert_hoist, _assert_init, _attr, _attr_class, _attr_class_item, _attr_class_items, _attr_content, _attr_details_or_dialog_open as _attr_details_open, _attr_details_or_dialog_open as _attr_dialog_open, _attr_details_or_dialog_open_default as _attr_details_open_default, _attr_details_or_dialog_open_default as _attr_dialog_open_default, _attr_details_or_dialog_open_script as _attr_details_open_script, _attr_details_or_dialog_open_script as _attr_dialog_open_script, _attr_input_checked, _attr_input_checkedValue, _attr_input_checkedValue_default, _attr_input_checkedValue_script, _attr_input_checked_default, _attr_input_checked_script, _attr_input_value, _attr_input_value as _attr_textarea_value, _attr_input_value_attribute_default, _attr_input_value_default, _attr_input_value_default as _attr_textarea_value_default, _attr_input_value_dynamic_default, _attr_input_value_script, _attr_input_value_script as _attr_textarea_value_script, _attr_nonce, _attr_select_value, _attr_select_value_default, _attr_select_value_script, _attr_style, _attr_style_item, _attr_style_items, _attrs, _attrs_content, _attrs_partial, _attrs_partial_content, _attrs_script, _await_content, _await_promise, _call, _child_setup, _closure, _closure_get, _const, _content, _content_closures, _content_resume, _controllable_input, _controllable_open, _controllable_select, _controllable_textarea, _dynamic_tag, _dynamic_tag_content, _el, _el_read, _for_closure, _for_in, _for_of, _for_selector, _for_to, _for_until, _global_read, _hoist, _hoist_read_error, _hoist_resume, _html, _id, _if, _if_closure, _let, _let_change, _lifecycle, _load_event_trigger, _load_idle_trigger, _load_media_trigger, _load_race_trigger, _load_setup, _load_signal, _load_template, _load_visible_trigger, _on, _or, _resume, _resume_dynamic_tag, _return, _return_change, _script, _show, _style_rule_item, _style_shell, _template, _text, _text_content, _to_text, _try, _var, _var_change, _var_resume, attrTag, attrTags, compat, forIn, forOf, forTo, forUntil, init, initEmbedded, ready, readyFailed, run };