@oscarpalmer/abydon 0.15.0 → 0.17.0

package/dist/abydon.full.mjs

@@ -0,0 +1,1443 @@
+//#region node_modules/@oscarpalmer/mora/dist/constants.js
+const ACTIVE = {};
+const BATCH = {
+	depth: 0,
+	handlers: /* @__PURE__ */ new Set()
+};
+const METHODS_AFFECTING_LENGTH = new Set([
+	"pop",
+	"push",
+	"shift",
+	"unshift"
+]);
+const METHODS_UPDATE = new Set([
+	...METHODS_AFFECTING_LENGTH,
+	"copyWithin",
+	"fill",
+	"reverse",
+	"sort",
+	"splice"
+]);
+const NAME_ARRAY = "array";
+const NAME_COMPUTED = "computed";
+const NAME_EFFECT = "effect";
+const NAME_MORA = "$mora";
+const NAME_SIGNAL = "signal";
+const NAME_STORE = "store";
+const NAME_ALL = new Set([
+	NAME_ARRAY,
+	NAME_COMPUTED,
+	NAME_SIGNAL,
+	NAME_STORE
+]);
+//#endregion
+//#region node_modules/@oscarpalmer/mora/dist/effect.js
+var Effect = class {
+	constructor(callback) {
+		Object.defineProperty(this, NAME_MORA, { value: NAME_EFFECT });
+		this.state = { callback };
+		runEffect(this);
+	}
+};
+function runEffect(effect$1) {
+	const previousEffect = ACTIVE.effect;
+	ACTIVE.effect = effect$1;
+	try {
+		effect$1.state.callback();
+	} finally {
+		ACTIVE.effect = previousEffect;
+	}
+}
+function effect(callback) {
+	return typeof callback === "function" ? new Effect(callback) : void 0;
+}
+//#endregion
+//#region node_modules/@oscarpalmer/mora/dist/helpers/is.js
+function isArray(value) {
+	return isMora(value, NAME_ARRAY);
+}
+function isComputed(value) {
+	return isMora(value, NAME_COMPUTED);
+}
+function isEffect(value) {
+	return isMora(value, NAME_EFFECT);
+}
+function isMora(value, name) {
+	return typeof value === "object" && value != null && "$mora" in value && (typeof name === "string" ? value["$mora"] === name : name.has(value["$mora"]));
+}
+function isReactive(value) {
+	return isMora(value, NAME_ALL);
+}
+function isSignal(value) {
+	return isMora(value, NAME_SIGNAL);
+}
+//#endregion
+//#region node_modules/@oscarpalmer/mora/dist/batch.js
+function flushHandlers() {
+	while (BATCH.depth === 0 && BATCH.handlers.size > 0) {
+		const handlers = [...BATCH.handlers];
+		BATCH.handlers.clear();
+		for (const handler of handlers) if (isEffect(handler)) runEffect(handler);
+		else handler.callback(handler.state.value);
+	}
+}
+function startBatch() {
+	BATCH.depth += 1;
+}
+function stopBatch() {
+	if (BATCH.depth > 0) BATCH.depth -= 1;
+	flushHandlers();
+}
+//#endregion
+//#region node_modules/@oscarpalmer/mora/dist/subscription.js
+var Subscription = class {
+	callback;
+	state;
+	constructor(state, callback) {
+		this.state = state;
+		this.callback = callback;
+		callback(state.value);
+	}
+	destroy() {
+		this.callback = noop$1;
+		this.state = void 0;
+	}
+};
+function noop$1() {}
+function subscribe(state, callback) {
+	if (typeof callback !== "function" || state.subscriptions.has(callback)) return noop$1;
+	state.subscriptions.set(callback, new Subscription(state, callback));
+	return () => {
+		unsubscribe(state, callback);
+	};
+}
+function unsubscribe(state, callback) {
+	state.subscriptions.get(callback)?.destroy();
+	state.subscriptions.delete(callback);
+}
+//#endregion
+//#region node_modules/@oscarpalmer/mora/dist/value/reactive.js
+var Reactive = class {
+	state = {
+		computeds: /* @__PURE__ */ new Set(),
+		effects: /* @__PURE__ */ new Set(),
+		equal: Object.is,
+		subscriptions: /* @__PURE__ */ new Map(),
+		value: void 0
+	};
+	constructor(name, value, options) {
+		this.state.value = value;
+		if (typeof options === "object" && typeof options.equal === "function") this.state.equal = options.equal;
+		Object.defineProperty(this, NAME_MORA, { value: name });
+	}
+	peek() {
+		return this.state.value;
+	}
+	subscribe(callback) {
+		return subscribe(this.state, callback);
+	}
+	toJSON() {
+		return this.get();
+	}
+	toString() {
+		return String(this.get());
+	}
+	unsubscribe(callback) {
+		unsubscribe(this.state, callback);
+	}
+};
+//#endregion
+//#region node_modules/@oscarpalmer/mora/dist/value/computed.js
+var Computed = class extends Reactive {
+	effect = {
+		dirty: true,
+		instance: void 0
+	};
+	constructor(callback, options) {
+		super(NAME_COMPUTED, void 0, options);
+		this.effect.instance = effect(() => {
+			if (!this.effect.dirty) return;
+			const previousComputed = ACTIVE.computed;
+			ACTIVE.computed = this;
+			const value = callback();
+			ACTIVE.computed = previousComputed;
+			if (!this.state.equal(this.state.value, value)) {
+				this.state.value = value;
+				for (const computed$1 of this.state.computeds) computed$1.effect.dirty = true;
+				for (const effect$1 of this.state.effects) BATCH.handlers.add(effect$1);
+				for (const [, subscription] of this.state.subscriptions) subscription.callback(value);
+			}
+			this.effect.dirty = false;
+		});
+	}
+	get() {
+		if (ACTIVE.computed != null && this !== ACTIVE.computed) this.state.computeds.add(ACTIVE.computed);
+		if (ACTIVE.effect != null && ACTIVE.effect !== this.effect.instance) this.state.effects.add(ACTIVE.effect);
+		if (this.effect.dirty && BATCH.depth === 0) runEffect(this.effect.instance);
+		return this.state.value;
+	}
+};
+function computed(callback, options) {
+	return new Computed(callback, options);
+}
+//#endregion
+//#region node_modules/@oscarpalmer/mora/dist/helpers/value.js
+function emitValue(state) {
+	for (const computed of state.computeds) computed.effect.dirty = true;
+	for (const effect of state.effects) BATCH.handlers.add(effect);
+	for (const [, subscription] of state.subscriptions) BATCH.handlers.add(subscription);
+	if (BATCH.depth === 0) flushHandlers();
+}
+function equalArrays(state, first, second) {
+	let { length } = first;
+	if (length !== second.length) return false;
+	let offset = 0;
+	if (length >= 100) {
+		offset = Math.round(length / 10);
+		offset = offset > 25 ? 25 : offset;
+		for (let index = 0; index < offset; index += 1) if (!state.equal(first[index], second[index])) return false;
+	}
+	length -= offset;
+	for (let index = offset; index < length; index += 1) if (!state.equal(first[index], second[index])) return false;
+	return true;
+}
+function getValue$1(state) {
+	if (ACTIVE.computed != null) state.computeds.add(ACTIVE.computed);
+	if (ACTIVE.effect != null) state.effects.add(ACTIVE.effect);
+	return state.value;
+}
+//#endregion
+//#region node_modules/@oscarpalmer/mora/dist/value/signal.js
+var Signal = class extends Reactive {
+	constructor(value, options) {
+		super(NAME_SIGNAL, value, options);
+	}
+	get() {
+		return getValue$1(this.state);
+	}
+	set(value) {
+		if (!this.state.equal(this.state.value, value)) {
+			this.state.value = value;
+			emitValue(this.state);
+		}
+	}
+	update(callback) {
+		this.set(callback(this.state.value));
+	}
+};
+function signal(value, options) {
+	return new Signal(value, options);
+}
+//#endregion
+//#region node_modules/@oscarpalmer/mora/dist/helpers/proxy.js
+function emityProxyValues(state, mapped) {
+	const values = [...mapped.values()];
+	const { length } = values;
+	for (let index = 0; index < length; index += 1) values[index].effect.dirty = true;
+	emitValue(state);
+}
+function getReactiveValueInProxy(reactive, mapped, key, isArray) {
+	let item = mapped.get(key);
+	if (item == null) {
+		item = computed(() => isArray ? reactive.get().at(key) : reactive.get()[key]);
+		mapped.set(key, item);
+	}
+	return item;
+}
+function setProxyValue(proxy, value) {
+	startBatch();
+	const proxyKeys = Object.keys(proxy);
+	const valueKeys = Object.keys(value);
+	let { length } = proxyKeys;
+	for (let index = 0; index < length; index += 1) {
+		const key = proxyKeys[index];
+		proxy[key] = valueKeys.includes(key) ? value[key] : void 0;
+	}
+	length = valueKeys.length;
+	for (let index = 0; index < length; index += 1) {
+		const key = valueKeys[index];
+		if (!proxyKeys.includes(key)) proxy[key] = value[key];
+	}
+	stopBatch();
+}
+function setValueInProxy(parameters) {
+	const { isArray, length, property, state, target, value } = parameters;
+	if (isArray) {
+		if (!(!Number.isNaN(Number(property)) || property === "length")) return Reflect.set(target, property, value);
+	}
+	const previous = Reflect.get(target, property);
+	if (!state.equal(previous, value)) {
+		Reflect.set(target, property, value);
+		emitValue(state);
+		if (isArray) length?.set(target.length);
+	}
+	return true;
+}
+//#endregion
+//#region node_modules/@oscarpalmer/mora/dist/value/array.js
+var ReactiveArray = class extends Reactive {
+	#indiced = /* @__PURE__ */ new Map();
+	#size = signal(0);
+	get length() {
+		return this.#size.get();
+	}
+	set length(value) {
+		if (typeof value === "number" && value >= 0 && value !== this.state.value.length) this.get().length = value;
+	}
+	constructor(value, options) {
+		super(NAME_ARRAY, new Proxy(value, {
+			get: (target, property) => METHODS_UPDATE.has(property) ? updateArray(property, target, this.state, this.#size) : Reflect.get(target, property),
+			set: (target, property, value$1) => setValueInProxy({
+				property,
+				target,
+				value: value$1,
+				isArray: true,
+				state: this.state,
+				length: this.#size
+			})
+		}), options);
+		this.#size.set(value.length);
+	}
+	clear() {
+		this.length = 0;
+	}
+	filter(callback) {
+		return computed(() => this.get().filter(callback));
+	}
+	get(first) {
+		if (typeof first === "number") return getReactiveValueInProxy(this, this.#indiced, first, true).get();
+		return first === "length" ? this.length : getValue$1(this.state);
+	}
+	map(callback) {
+		return computed(() => this.get().map(callback));
+	}
+	notify() {
+		emityProxyValues(this.state, this.#indiced);
+	}
+	peek(value) {
+		if (value === "length") return this.#size.peek();
+		return typeof value === "number" ? this.state.value.at(value) : [...this.state.value];
+	}
+	pop() {
+		return this.state.value.pop();
+	}
+	push(...items) {
+		return this.state.value.push(...items);
+	}
+	set(first, second) {
+		if (first == null || Array.isArray(first)) this.state.value.splice(0, this.state.value.length, ...first ?? []);
+		else if (first === "length") this.length = second;
+		else if (typeof first === "number" && !Number.isNaN(first)) setAtIndex(this.state.value, first, second);
+	}
+	shift() {
+		return this.state.value.shift();
+	}
+	splice(from, to, ...items) {
+		return this.state.value.splice(from, to ?? this.state.value.length, ...items);
+	}
+	subscribe(first, second) {
+		if (typeof first === "number" && typeof second === "function") return getReactiveValueInProxy(this, this.#indiced, first, true).subscribe(second);
+		return typeof first === "function" ? subscribe(this.state, first) : noop$1;
+	}
+	unshift(...items) {
+		return this.state.value.unshift(...items);
+	}
+	update(callback) {
+		const updated = callback(this.state.value);
+		if (updated == null || Array.isArray(updated)) this.set(updated);
+	}
+};
+function array(value, options) {
+	return new ReactiveArray(Array.isArray(value) ? value : [], options);
+}
+function updateArray(type, array$1, state, length) {
+	const affectsLength = METHODS_AFFECTING_LENGTH.has(type);
+	const previousArray = affectsLength ? [] : [...array$1];
+	const previousLength = array$1.length;
+	return (...args) => {
+		const result = array$1[type](...args);
+		if (affectsLength ? array$1.length !== previousLength : !equalArrays(state, previousArray, array$1)) {
+			emitValue(state);
+			length.set(array$1.length);
+		}
+		return result;
+	};
+}
+function setAtIndex(array$1, index, value) {
+	const actual = index < 0 ? array$1.length + index : index;
+	if (actual > -1) array$1[actual] = value;
+}
+//#endregion
+//#region node_modules/@oscarpalmer/mora/node_modules/@oscarpalmer/atoms/dist/internal/is.js
+function isKey(value) {
+	return typeof value === "number" || typeof value === "string";
+}
+function isPlainObject$1(value) {
+	if (value === null || typeof value !== "object") return false;
+	if (Symbol.toStringTag in value || Symbol.iterator in value) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+}
+//#endregion
+//#region node_modules/@oscarpalmer/mora/dist/value/store.js
+var Store = class extends Reactive {
+	#keyed = /* @__PURE__ */ new Map();
+	constructor(value, options) {
+		super(NAME_STORE, new Proxy(value, { set: (target, property, value$1) => setValueInProxy({
+			target,
+			property,
+			value: value$1,
+			isArray: false,
+			state: this.state
+		}) }), options);
+	}
+	get(key) {
+		return isKey(key) ? getReactiveValueInProxy(this, this.#keyed, key, false).get() : getValue$1(this.state);
+	}
+	notify() {
+		emityProxyValues(this.state, this.#keyed);
+	}
+	peek(key) {
+		return isKey(key) ? this.state.value[key] : { ...this.state.value };
+	}
+	set(first, second) {
+		if (isKey(first)) this.state.value[first] = second;
+		else if (first == null || isPlainObject$1(first)) setProxyValue(this.state.value, first ?? {});
+	}
+	subscribe(first, second) {
+		if (isKey(first) && typeof second === "function") return getReactiveValueInProxy(this, this.#keyed, first, false).subscribe(second);
+		return typeof first === "function" ? subscribe(this.state, first) : noop$1;
+	}
+	update(callback) {
+		const updated = callback({ ...this.state.value });
+		if (updated == null || isPlainObject$1(updated)) setProxyValue(this.state.value, updated ?? {});
+	}
+};
+function store(value, options) {
+	return new Store(isPlainObject$1(value) ? value : {}, options);
+}
+//#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/internal/is.mjs
+/**
+* Is the value a plain object?
+* @param value Value to check
+* @returns `true` if the value is a plain object, otherwise `false`
+*/
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	if (Symbol.toStringTag in value || Symbol.iterator in value) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+}
+//#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/internal/string.mjs
+/**
+* Get the string value from any value
+* @param value Original value
+* @returns String representation of the value
+*/
+function getString(value) {
+	if (typeof value === "string") return value;
+	if (value == null) return "";
+	if (typeof value === "function") return getString(value());
+	if (typeof value !== "object") return String(value);
+	const asString = String(value.valueOf?.() ?? value);
+	return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
+}
+//#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/is.mjs
+/**
+* Is the value `undefined`, `null`, or a whitespace-only string?
+* @param value Value to check
+* @returns `true` if the value is nullable or a whitespace-only string, otherwise `false`
+*/
+function isNullableOrWhitespace(value) {
+	return value == null || EXPRESSION_WHITESPACE$1.test(getString(value));
+}
+const EXPRESSION_WHITESPACE$1 = /^\s*$/;
+//#endregion
+//#region node_modules/@oscarpalmer/toretto/dist/internal/is.mjs
+/**
+* Is the value an event target?
+* @param value Value to check
+* @returns `true` if it's an event target, otherwise `false`
+*/
+function isEventTarget(value) {
+	return typeof value === "object" && value != null && typeof value.addEventListener === "function" && typeof value.removeEventListener === "function" && typeof value.dispatchEvent === "function";
+}
+/**
+* Is the value an HTML or SVG element?
+* @param value Value to check
+* @returns `true` if it's an HTML or SVG element, otherwise `false`
+*/
+function isHTMLOrSVGElement(value) {
+	return value instanceof HTMLElement || value instanceof SVGElement;
+}
+//#endregion
+//#region node_modules/@oscarpalmer/toretto/dist/is.mjs
+/**
+* Is the value a child node?
+* @param value Value to check
+* @returns `true` if it's a child node, otherwise `false`
+*/
+function isChildNode(value) {
+	return value instanceof Node && CHILD_NODE_TYPES.has(value.nodeType);
+}
+const CHILD_NODE_TYPES = new Set([
+	Node.ELEMENT_NODE,
+	Node.TEXT_NODE,
+	Node.PROCESSING_INSTRUCTION_NODE,
+	Node.COMMENT_NODE,
+	Node.DOCUMENT_TYPE_NODE
+]);
+//#endregion
+//#region node_modules/@oscarpalmer/toretto/dist/internal/element-value.mjs
+function setElementValue(element, first, second, third, callback) {
+	if (!isHTMLOrSVGElement(element)) return;
+	if (typeof first === "string") setElementValues(element, first, second, third, callback);
+	else if (isAttribute(first)) setElementValues(element, first.name, first.value, third, callback);
+}
+function setElementValues(element, first, second, third, callback) {
+	if (!isHTMLOrSVGElement(element)) return;
+	if (typeof first === "string") {
+		callback(element, first, second, third);
+		return;
+	}
+	const isArray = Array.isArray(first);
+	if (!isArray && !(typeof first === "object" && first !== null)) return;
+	const entries = isArray ? first : Object.entries(first).map(([name, value]) => ({
+		name,
+		value
+	}));
+	const { length } = entries;
+	for (let index = 0; index < length; index += 1) {
+		const entry = entries[index];
+		if (typeof entry === "object" && typeof entry?.name === "string") callback(element, entry.name, entry.value, third);
+	}
+}
+function updateElementValue(element, key, value, set, remove, isBoolean, json) {
+	if (isBoolean ? value == null : isNullableOrWhitespace(value)) remove.call(element, key);
+	else set.call(element, key, json ? JSON.stringify(value) : String(value));
+}
+//#endregion
+//#region node_modules/@oscarpalmer/toretto/dist/internal/attribute.mjs
+function badAttributeHandler(name, value) {
+	if (typeof name !== "string" || name.trim().length === 0 || typeof value !== "string") return true;
+	if (EXPRESSION_CLOBBERED_NAME.test(name) && (value in document || value in formElement) || EXPRESSION_EVENT_NAME$1.test(name)) return true;
+	if (EXPRESSION_SKIP_NAME.test(name) || EXPRESSION_URI_VALUE.test(value) || isValidSourceAttribute(name, value)) return false;
+	return EXPRESSION_DATA_OR_SCRIPT.test(value);
+}
+function booleanAttributeHandler(name, value) {
+	if (typeof name !== "string" || name.trim().length === 0 || typeof value !== "string") return true;
+	const normalizedName = name.toLowerCase();
+	if (!booleanAttributesSet.has(normalizedName)) return false;
+	const normalized = value.toLowerCase();
+	return !(normalized.length === 0 || normalized === normalizedName);
+}
+function decodeAttribute(value) {
+	textArea ??= document.createElement("textarea");
+	textArea.innerHTML = value;
+	return decodeURIComponent(textArea.value);
+}
+function handleAttribute(callback, decode, first, second) {
+	let name;
+	let value;
+	if (isAttribute(first)) {
+		name = first.name;
+		value = String(first.value);
+	} else if (typeof first === "string" && typeof second === "string") {
+		name = first;
+		value = second;
+	}
+	if (decode && value != null) value = decodeAttribute(value);
+	return callback(name, value?.replace(EXPRESSION_WHITESPACE, ""));
+}
+function isAttribute(value) {
+	return value instanceof Attr || isPlainObject(value) && typeof value.name === "string" && "value" in value;
+}
+function _isBadAttribute(first, second, decode) {
+	return handleAttribute(badAttributeHandler, decode, first, second);
+}
+function _isBooleanAttribute(first, decode) {
+	return handleAttribute((name) => booleanAttributesSet.has(name?.toLowerCase()), decode, first, "");
+}
+function _isEmptyNonBooleanAttribute(first, second, decode) {
+	return handleAttribute((name, value) => name != null && value != null && !booleanAttributesSet.has(name) && value.trim().length === 0, decode, first, second);
+}
+function _isInvalidBooleanAttribute(first, second, decode) {
+	return handleAttribute(booleanAttributeHandler, decode, first, second);
+}
+function isValidSourceAttribute(name, value) {
+	return EXPRESSION_SOURCE_NAME.test(name) && EXPRESSION_SOURCE_VALUE.test(value);
+}
+function updateAttribute(element, name, value, dispatch) {
+	const normalizedName = name.toLowerCase();
+	const isBoolean = booleanAttributesSet.has(normalizedName);
+	const next = isBoolean ? value === true || typeof value === "string" && (value === "" || value.toLowerCase() === normalizedName) : value == null ? "" : value;
+	if (name in element) updateProperty$1(element, normalizedName, next, dispatch);
+	updateElementValue(element, name, isBoolean ? next ? "" : null : value, element.setAttribute, element.removeAttribute, isBoolean, false);
+}
+function updateProperty$1(element, name, value, dispatch) {
+	if (Object.is(element[name], value)) return;
+	element[name] = value;
+	const event = dispatch !== false && elementEvents[element.tagName]?.[name];
+	if (typeof event === "string") element.dispatchEvent(new Event(event, { bubbles: true }));
+}
+const EXPRESSION_CLOBBERED_NAME = /^(id|name)$/i;
+const EXPRESSION_DATA_OR_SCRIPT = /^(?:data|\w+script):/i;
+const EXPRESSION_EVENT_NAME$1 = /^on/i;
+const EXPRESSION_SKIP_NAME = /^(aria-[-\w]+|data-[-\w.\u00B7-\uFFFF]+)$/i;
+const EXPRESSION_SOURCE_NAME = /^src$/i;
+const EXPRESSION_SOURCE_VALUE = /^data:/i;
+const EXPRESSION_URI_VALUE = /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.-]+(?:[^a-z+.\-:]|$))/i;
+const EXPRESSION_WHITESPACE = /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g;
+/**
+* List of boolean attributes
+*/
+const booleanAttributes = Object.freeze([
+	"async",
+	"autofocus",
+	"autoplay",
+	"checked",
+	"controls",
+	"default",
+	"defer",
+	"disabled",
+	"formnovalidate",
+	"hidden",
+	"inert",
+	"ismap",
+	"itemscope",
+	"loop",
+	"multiple",
+	"muted",
+	"nomodule",
+	"novalidate",
+	"open",
+	"playsinline",
+	"readonly",
+	"required",
+	"reversed",
+	"selected"
+]);
+const booleanAttributesSet = new Set(booleanAttributes);
+const elementEvents = {
+	DETAILS: { open: "toggle" },
+	INPUT: {
+		checked: "change",
+		value: "input"
+	},
+	SELECT: { value: "change" },
+	TEXTAREA: { value: "input" }
+};
+const formElement = document.createElement("form");
+let textArea;
+//#endregion
+//#region node_modules/@oscarpalmer/toretto/dist/attribute/set.mjs
+function setAttribute$1(element, first, second, third) {
+	setElementValue(element, first, second, third, updateAttribute);
+}
+//#endregion
+//#region node_modules/@oscarpalmer/toretto/dist/html/sanitize.mjs
+function handleElement(element, depth) {
+	if (depth === 0) {
+		const removable = element.querySelectorAll(REMOVE_SELECTOR);
+		for (const item of removable) item.remove();
+	}
+	sanitizeAttributes(element, [...element.attributes]);
+}
+/**
+* Is the element clobbered?
+*
+* Thanks, DOMPurify _(https://github.com/cure53/DOMPurify)_
+*/
+function isClobbered(value) {
+	return value instanceof HTMLFormElement && (typeof value.nodeName !== "string" || typeof value.textContent !== "string" || typeof value.removeChild !== "function" || !(value.attributes instanceof NamedNodeMap) || typeof value.removeAttribute !== "function" || typeof value.setAttribute !== "function" || typeof value.namespaceURI !== "string" || typeof value.insertBefore !== "function" || typeof value.hasChildNodes !== "function");
+}
+function removeNode(node) {
+	if (typeof node.remove === "function") node.remove();
+}
+function sanitizeAttributes(element, attributes) {
+	const { length } = attributes;
+	for (let index = 0; index < length; index += 1) {
+		const { name, value } = attributes[index];
+		if (_isBadAttribute(name, value, false) || _isEmptyNonBooleanAttribute(name, value, false)) element.removeAttribute(name);
+		else if (_isInvalidBooleanAttribute(name, value, false)) setAttribute$1(element, name, true);
+	}
+}
+function sanitizeNodes(nodes, depth) {
+	const actual = nodes.filter((node) => node instanceof Node);
+	let { length } = nodes;
+	for (let index = 0; index < length; index += 1) {
+		const node = actual[index];
+		let remove = isClobbered(node);
+		if (!remove) switch (node.nodeType) {
+			case Node.ELEMENT_NODE:
+				handleElement(node, depth);
+				break;
+			case Node.COMMENT_NODE:
+				remove = COMMENT_HARMFUL.test(node.data);
+				break;
+			case Node.DOCUMENT_TYPE_NODE:
+			case Node.PROCESSING_INSTRUCTION_NODE:
+				remove = true;
+				break;
+		}
+		if (remove) {
+			removeNode(node);
+			actual.splice(index, 1);
+			index -= 1;
+			length -= 1;
+			continue;
+		}
+		if (node.hasChildNodes()) sanitizeNodes([...node.childNodes], depth + 1);
+	}
+	return nodes;
+}
+const COMMENT_HARMFUL = /<[/\w]/g;
+const REMOVE_SELECTOR = "script, toretto-temporary";
+//#endregion
+//#region node_modules/@oscarpalmer/toretto/dist/html/index.mjs
+function createHtml(value) {
+	const parsed = getParser().parseFromString(getHtml(value), PARSE_TYPE_HTML);
+	parsed.body.normalize();
+	sanitizeNodes([parsed.body], 0);
+	return parsed.body.innerHTML;
+}
+function createTemplate(value, options) {
+	const template = document.createElement(TEMPLATE_TAG);
+	template.innerHTML = createHtml(value);
+	if (typeof value === "string" && options.cache) templates[value] = template;
+	return template;
+}
+function getHtml(value) {
+	return `${TEMPORARY_ELEMENT}${typeof value === "string" ? value : value.innerHTML}${TEMPORARY_ELEMENT}`;
+}
+function getNodes(value, options) {
+	if (typeof value !== "string" && !(value instanceof HTMLTemplateElement)) return [];
+	const template = getTemplate(value, options);
+	return template == null ? [] : [...template.content.cloneNode(true).childNodes];
+}
+function getOptions$1(input) {
+	const options = isPlainObject(input) ? input : {};
+	options.cache = typeof options.cache === "boolean" ? options.cache : true;
+	return options;
+}
+function getParser() {
+	parser ??= new DOMParser();
+	return parser;
+}
+function getTemplate(value, options) {
+	if (value instanceof HTMLTemplateElement) return createTemplate(value, options);
+	if (value.trim().length === 0) return;
+	let template = templates[value];
+	if (template != null) return template;
+	const element = EXPRESSION_ID.test(value) ? document.querySelector(`#${value}`) : null;
+	return createTemplate(element instanceof HTMLTemplateElement ? element : value, options);
+}
+const html$1 = ((value, options) => {
+	return getNodes(value, getOptions$1(options));
+});
+html$1.clear = () => {
+	templates = {};
+};
+html$1.remove = (template) => {
+	if (typeof template !== "string" || templates[template] == null) return;
+	const keys = Object.keys(templates);
+	const { length } = keys;
+	const updated = {};
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		if (key !== template) updated[key] = templates[key];
+	}
+	templates = updated;
+};
+const EXPRESSION_ID = /^[a-z][\w-]*$/i;
+const PARSE_TYPE_HTML = "text/html";
+const TEMPLATE_TAG = "template";
+const TEMPORARY_ELEMENT = "<toretto-temporary></toretto-temporary>";
+let parser;
+let templates = {};
+//#endregion
+//#region src/constants.ts
+const EVENT_DEFAULTS = {
+	A: "click",
+	BUTTON: "click",
+	DETAILS: "toggle",
+	FORM: "submit",
+	SELECT: "change",
+	TEXTAREA: "input"
+};
+const EXPRESSION_ABYDON_ATTRIBUTE_FULL = /(@?\w+)="<!--abydon.(\d+)-->"/g;
+const EXPRESSION_ABYDON_ATTRIBUTE_PREFIX = /^_/;
+const EXPRESSION_ABYDON_CONTENT = /^@?abydon\.(\d+)@?$/;
+const EXPRESSION_ATTRIBUTE_CLASS = /^class\./;
+const EXPRESSION_ATTRIBUTE_STYLE_FULL = /^style\.([\w-]+)(?:\.([\w-]+))?$/;
+const EXPRESSION_ATTRIBUTE_STYLE_PREFIX = /^style\./;
+const EXPRESSION_EVENT_CHANGE_TYPES = /^(checkbox|radio)$/;
+const EXPRESSION_EVENT_NAME = /^@([\w-]+)(?::([a-z:]+))?$/i;
+const EXPRESSION_EVENT_OPTIONS_ACTIVE = /^a(ctive)$/i;
+const EXPRESSION_EVENT_OPTIONS_CAPTURE = /^c(apture)$/i;
+const EXPRESSION_EVENT_OPTIONS_ONCE = /^o(nce)$/i;
+const EXPRESSION_EVENT_PREFIX = /^@/;
+const EXPRESSION_PERIOD = /\./;
+const NAME_FRAGMENT = "$fragment";
+const NAME_FRAGMENTS = "$fragments";
+//#endregion
+//#region src/helpers/index.ts
+function compareArrays(first, second) {
+	const firstIsLarger = first.length > second.length;
+	const from = firstIsLarger ? first : second;
+	const to = firstIsLarger ? second : first;
+	if (!from.filter((key) => to.includes(key)).every((key, index) => to[index] === key)) return COMPARISON_DISSIMILAR;
+	return firstIsLarger ? COMPARISON_REMOVED : COMPARISON_ADDED;
+}
+function isFragment(value) {
+	return isNamed(value, NAME_FRAGMENT);
+}
+function isFragments(value) {
+	return isNamed(value, NAME_FRAGMENTS);
+}
+function isNamed(value, name) {
+	return typeof value === "object" && value != null && name in value && value[name] === true;
+}
+const COMPARISON_ADDED = "added";
+const COMPARISON_DISSIMILAR = "dissimilar";
+const COMPARISON_REMOVED = "removed";
+//#endregion
+//#region src/fragments.ts
+var Fragments = class {
+	#state;
+	/**
+	* Fragment items
+	*/
+	get items() {
+		return this.#state.mapped;
+	}
+	constructor(items, identify, fragment) {
+		Object.defineProperty(this, NAME_FRAGMENTS, { value: true });
+		this.#state = {
+			fragment,
+			identify,
+			array: items,
+			instances: {},
+			mapped: array([]),
+			subscriber: void 0
+		};
+		states.set(this, this.#state);
+		initializeFragments(this.#state);
+	}
+};
+function handleFragments(item, remove) {
+	const state = isFragments(item) ? states.get(item) : item;
+	if (state != null) (remove ? removeFragments$1 : initializeFragments)(state);
+}
+function handleItems(state, items) {
+	const keys = /* @__PURE__ */ new Set();
+	const mapped = [];
+	const { length } = items;
+	for (let index = 0; index < length; index += 1) {
+		const item = items[index];
+		const identifier = state.identify(item);
+		if (identifier == null) throw new Error("Identifier cannot be null or undefined");
+		const key = getString(identifier);
+		if (keys.has(key)) throw new Error(`Duplicate identifier found: "${key}"`);
+		let instance = state.instances[key];
+		if (instance == null) {
+			instance = state.fragment(item);
+			if (!isFragment(instance)) throw new Error("Fragment function must return a Fragment instance");
+		}
+		instance.identify(key);
+		state.instances[key] = instance;
+		keys.add(key);
+		mapped.push(instance);
+	}
+	state.mapped.set(mapped);
+	updateFragments(state, keys);
+}
+function initializeFragments(state) {
+	state.subscriber ??= state.array.subscribe((items) => {
+		handleItems(state, items);
+	});
+}
+function removeFragments$1(state) {
+	state.subscriber?.();
+	updateFragments(state);
+	state.subscriber = void 0;
+}
+function updateFragments(state, active) {
+	const next = {};
+	const previous = { ...state.instances };
+	const keys = Object.keys(previous);
+	const { length } = keys;
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		if (active?.has(key)) next[key] = previous[key];
+		else previous[key].remove();
+	}
+	state.instances = next;
+	active?.clear();
+}
+const states = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region src/helpers/dom.ts
+function createNodes(value) {
+	if (isFragment(value)) return value.get();
+	if (isChildNode(value)) return [value];
+	return [new Text(getString(value))];
+}
+function removeNodes(nodes) {
+	const { length } = nodes;
+	for (let index = 0; index < length; index += 1) nodes[index].remove();
+}
+function replaceNodes(from, to) {
+	from[0]?.replaceWith(...to);
+	const { length } = from;
+	for (let index = 1; index < length; index += 1) from[index].remove();
+}
+//#endregion
+//#region node_modules/@oscarpalmer/toretto/dist/internal/get-value.mjs
+function getBoolean(value, defaultValue) {
+	return typeof value === "boolean" ? value : defaultValue ?? false;
+}
+//#endregion
+//#region node_modules/@oscarpalmer/toretto/dist/event/delegation.mjs
+function addDelegatedHandler(doc, type, name, passive) {
+	if (DELEGATED.has(name)) return;
+	DELEGATED.add(name);
+	doc.addEventListener(type, passive ? HANDLER_PASSIVE : HANDLER_ACTIVE, { passive });
+}
+function addDelegatedListener(target, type, name, listener, passive) {
+	target[name] ??= /* @__PURE__ */ new Set();
+	target[name].add(listener);
+	addDelegatedHandler(document, type, name, passive);
+	return () => {
+		removeDelegatedListener(target, name, listener);
+	};
+}
+function delegatedEventHandler(event) {
+	const key = `${EVENT_PREFIX}${event.type}${this ? EVENT_SUFFIX_PASSIVE : EVENT_SUFFIX_ACTIVE}`;
+	const items = event.composedPath();
+	const { length } = items;
+	let target = items[0];
+	Object.defineProperties(event, {
+		currentTarget: {
+			configurable: true,
+			get() {
+				return target;
+			}
+		},
+		target: {
+			configurable: true,
+			value: target
+		}
+	});
+	for (let index = 0; index < length; index += 1) {
+		const item = items[index];
+		const listeners = item[key];
+		if (item.disabled || listeners == null) continue;
+		target = item;
+		for (const listener of listeners) {
+			listener.call(item, event);
+			if (event.cancelBubble) return;
+		}
+	}
+}
+function getDelegatedName(target, type, options) {
+	if (isEventTarget(target) && EVENT_TYPES.has(type) && !options.capture && !options.once && options.signal == null) return `${EVENT_PREFIX}${type}${options.passive ? EVENT_SUFFIX_PASSIVE : EVENT_SUFFIX_ACTIVE}`;
+}
+function removeDelegatedListener(target, name, listener) {
+	const handlers = target[name];
+	if (handlers == null || !handlers.has(listener)) return false;
+	handlers.delete(listener);
+	if (handlers.size === 0) target[name] = void 0;
+	return true;
+}
+const DELEGATED = /* @__PURE__ */ new Set();
+const EVENT_PREFIX = "@";
+const EVENT_SUFFIX_ACTIVE = ":active";
+const EVENT_SUFFIX_PASSIVE = ":passive";
+const EVENT_TYPES = new Set([
+	"beforeinput",
+	"click",
+	"dblclick",
+	"contextmenu",
+	"focusin",
+	"focusout",
+	"input",
+	"keydown",
+	"keyup",
+	"mousedown",
+	"mousemove",
+	"mouseout",
+	"mouseover",
+	"mouseup",
+	"pointerdown",
+	"pointermove",
+	"pointerout",
+	"pointerover",
+	"pointerup",
+	"touchend",
+	"touchmove",
+	"touchstart"
+]);
+const HANDLER_ACTIVE = delegatedEventHandler.bind(false);
+const HANDLER_PASSIVE = delegatedEventHandler.bind(true);
+//#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/internal/function/misc.mjs
+/**
+* A function that does nothing, which can be useful, I guess…
+*/
+function noop() {}
+//#endregion
+//#region node_modules/@oscarpalmer/toretto/dist/event/index.mjs
+function createEventOptions(options) {
+	return {
+		capture: getBoolean(options?.capture),
+		once: getBoolean(options?.once),
+		passive: getBoolean(options?.passive, true),
+		signal: options?.signal instanceof AbortSignal ? options.signal : void 0
+	};
+}
+function on(target, type, listener, options) {
+	if (!isEventTarget(target) || typeof type !== "string" || typeof listener !== "function") return noop;
+	const extended = createEventOptions(options);
+	const delegated = getDelegatedName(target, type, extended);
+	if (delegated != null) return addDelegatedListener(target, type, delegated, listener, extended.passive);
+	target.addEventListener(type, listener, extended);
+	if (extended.once) return noop;
+	return () => {
+		target.removeEventListener(type, listener, extended);
+	};
+}
+//#endregion
+//#region src/node/event.ts
+function getOptions(options) {
+	const parts = options.split(":");
+	return {
+		capture: parts.some((part) => EXPRESSION_EVENT_OPTIONS_CAPTURE.test(part)),
+		once: parts.some((part) => EXPRESSION_EVENT_OPTIONS_ONCE.test(part)),
+		passive: !parts.some((part) => EXPRESSION_EVENT_OPTIONS_ACTIVE.test(part))
+	};
+}
+function getType(element, type) {
+	if (type !== "on") return type;
+	if (element instanceof HTMLInputElement) {
+		if (EXPRESSION_EVENT_CHANGE_TYPES.test(element.type)) return "change";
+		return element.type === "submit" ? "submit" : "input";
+	}
+	return EVENT_DEFAULTS[element.tagName] ?? type;
+}
+function mapEvent(element, name, value) {
+	const [, type, options] = EXPRESSION_EVENT_NAME.exec(name) ?? [];
+	if (type != null && typeof value === "function") on(element, getType(element, type), value, getOptions(options ?? ""));
+}
+//#endregion
+//#region node_modules/@oscarpalmer/toretto/dist/attribute/index.mjs
+function isBooleanAttribute(first) {
+	return _isBooleanAttribute(first, true);
+}
+//#endregion
+//#region src/node/attribute/value.ts
+function getCallback(element, name) {
+	if (isBooleanAttribute(name) && name in element) return name === "checked" ? updateChecked : updateProperty;
+	return name === "value" ? updateValue : setAttribute$1;
+}
+function setAttribute(data, element, name, value) {
+	switch (true) {
+		case EXPRESSION_ATTRIBUTE_CLASS.test(name):
+			setClasses(data, element, name, value);
+			return;
+		case EXPRESSION_ATTRIBUTE_STYLE_PREFIX.test(name):
+			setStyle(data, element, name, value);
+			return;
+		default:
+			setValue(data, element, name, value);
+			break;
+	}
+}
+function setClasses(data, element, name, value) {
+	function update(value) {
+		if (value === true) element.classList.add(...classes);
+		else element.classList.remove(...classes);
+	}
+	const classes = name.slice(6).split(".");
+	if (isReactive(value)) data.mora.subscribers.add(value.subscribe(update));
+	else update(value);
+}
+function setStyle(data, element, name, value) {
+	const [, property, unit] = EXPRESSION_ATTRIBUTE_STYLE_FULL.exec(name) ?? [];
+	if (property == null) return;
+	function update(value) {
+		if (value == null || value === false || value === true && unit == null) element.style.removeProperty(property);
+		else element.style.setProperty(property, value === true ? unit : String(value));
+	}
+	if (isReactive(value)) data.mora.subscribers.add(value.subscribe(update));
+	else update(value);
+}
+function setValue(data, element, name, value) {
+	const callback = getCallback(element, name);
+	if (isReactive(value)) data.mora.subscribers.add(value.subscribe((next) => {
+		callback(element, name, next);
+	}));
+	else callback(element, name, value);
+}
+function updateChecked(element, name, value) {
+	updateElement("change", "checked", element, name, value, value === true);
+}
+function updateElement(event, property, element, name, value, next) {
+	if (!(property in element) || element[property] === next) return;
+	setAttribute$1(element, name, value);
+	if (element[property] === next) return;
+	element[property] = next;
+	element.dispatchEvent(new Event(event, { bubbles: true }));
+}
+function updateProperty(element, name, value) {
+	setAttribute$1(element, name, value === true);
+}
+function updateValue(element, name, value) {
+	updateElement(element instanceof HTMLSelectElement ? "change" : "input", "value", element, name, value, String(value));
+}
+//#endregion
+//#region src/node/attribute/index.ts
+function getValue(data, original) {
+	const matches = EXPRESSION_ABYDON_CONTENT.exec(original ?? "");
+	return matches == null ? original : data.values[+matches[1]];
+}
+function mapAttributes(data, element) {
+	const attributes = [...element.attributes];
+	const { length } = attributes;
+	for (let index = 0; index < length; index += 1) {
+		const { name, value } = attributes[index];
+		const actualName = name.replace(EXPRESSION_ABYDON_ATTRIBUTE_PREFIX, "");
+		const actualValue = getValue(data, value);
+		if (actualName !== name) element.removeAttribute(name);
+		switch (true) {
+			case EXPRESSION_EVENT_PREFIX.test(actualName):
+				mapEvent(element, actualName, actualValue);
+				break;
+			case EXPRESSION_PERIOD.test(actualName):
+			case typeof actualValue === "function":
+			case isReactive(actualValue):
+				mapValue$1(data, element, actualName, actualValue);
+				break;
+			default: break;
+		}
+	}
+}
+function mapValue$1(data, element, name, value) {
+	if (typeof value === "function") setComputedAttribute(data, element, name, value);
+	else setAttribute(data, element, name, value);
+}
+function setComputedAttribute(data, element, name, callback) {
+	const value = computed(callback);
+	data.mora.values.add(value);
+	setAttribute(data, element, name, value);
+}
+//#endregion
+//#region src/node/value.ts
+function addToArray(identifiers, items, nodes, added) {
+	let position = nodes[0];
+	const before = added && !identifiers.previous.has(items.templates[0].identifier);
+	const next = items.next.flatMap((fragment) => fragment.get().flatMap((node) => ({
+		identifier: fragment.identifier,
+		value: node
+	})));
+	const { length } = next;
+	for (let index = 0; index < length; index += 1) {
+		const node = next[index];
+		if (!(added && identifiers.previous.has(node.identifier))) if (index === 0 && before) position.before(node.value);
+		else position.after(node.value);
+		position = node.value;
+	}
+}
+function handleArray(identifiers, items, nodes) {
+	const next = items.templates.map((template) => items.fragments?.find((fragment) => fragment.identifier === template.identifier) ?? template);
+	const comparison = compareArrays(items.fragments ?? [], items.templates);
+	if (comparison !== "removed") addToArray(identifiers, {
+		...items,
+		next
+	}, nodes, comparison === "added");
+	const toRemove = items.fragments?.filter((fragment) => !identifiers.next.has(fragment.identifier)) ?? [];
+	const { length } = toRemove;
+	for (let index = 0; index < length; index += 1) toRemove[index].remove();
+	return {
+		fragments: next,
+		nodes: next.flatMap((fragment) => fragment.get())
+	};
+}
+function removeFragments(fragments) {
+	if (fragments != null) {
+		const { length } = fragments;
+		for (let index = 0; index < length; index += 1) fragments[index].remove();
+	}
+}
+function replaceText(item, comment, isNullable) {
+	let to;
+	if (isNullable) to = [comment];
+	else to = item.text == null ? [] : [item.text];
+	replaceNodes(item.nodes ?? [], to);
+}
+function setArray(item, comment, value) {
+	if (value.length === 0) return { nodes: setText(item, comment, value) };
+	let templates = value.filter((item) => isFragment(item) && item.identifier != null);
+	const next = templates.map((fragment) => fragment.identifier);
+	const previous = item.fragments?.map((fragment) => fragment.identifier) ?? [];
+	if (new Set(next).size !== templates.length) templates = [];
+	const noTemplates = templates.length === 0;
+	if (noTemplates || item.nodes == null || previous.some((identifier) => identifier == null)) return {
+		fragments: noTemplates ? void 0 : templates,
+		nodes: setNodes(item, comment, noTemplates ? value.flatMap((item) => createNodes(item)) : templates.flatMap((template) => template.get()))
+	};
+	return handleArray({
+		next: new Set(next),
+		previous: new Set(previous)
+	}, {
+		templates,
+		fragments: item.fragments ?? []
+	}, item.nodes);
+}
+function setNodes(item, comment, next) {
+	if (item.nodes == null) {
+		if (comment.parentNode != null) replaceNodes([comment], next);
+		else if (item.text?.parentNode != null) replaceNodes([item.text], next);
+	} else replaceNodes(item.nodes, next);
+	removeFragments(item.fragments);
+	return next;
+}
+function setReactiveValue(data, comment, reactive) {
+	let item = data.items.find((item) => item.nodes?.includes(comment));
+	item ??= {};
+	item.text = new Text();
+	data.mora.subscribers.add(reactive.subscribe((value) => {
+		if (Array.isArray(value)) setReactiveValueForArray(item, comment, value);
+		else setReactiveValueForSingle(item, comment, value);
+		item.nodes = [...item.nodes ?? [comment]];
+	}));
+}
+function setReactiveValueForArray(item, comment, value) {
+	const result = setArray(item, comment, value);
+	item.fragments = typeof result === "boolean" ? void 0 : result?.fragments;
+	if (typeof result === "boolean") if (result) item.nodes = item.text == null ? [] : [item.text];
+	else item.nodes = void 0;
+	else item.nodes = result?.nodes;
+}
+function setReactiveValueForSingle(item, comment, value) {
+	const valueIsFragment = isFragment(value);
+	item.fragments = valueIsFragment ? [value] : void 0;
+	if (valueIsFragment || isChildNode(value)) item.nodes = setNodes(item, comment, createNodes(value));
+	else item.nodes = setText(item, comment, value);
+}
+function setText(item, comment, value) {
+	const isNullable = isNullableOrWhitespace(value);
+	if (item.text != null) item.text.textContent = isNullable ? "" : getString(value);
+	let result = false;
+	if (item.nodes != null) {
+		replaceText(item, comment, isNullable);
+		result = !isNullable;
+	} else if (isNullable && comment.parentNode == null) item.text?.replaceWith(comment);
+	else if (!isNullable && item?.text?.parentNode == null) {
+		if (item.text != null) comment.replaceWith(item.text);
+		result = true;
+	}
+	removeFragments(item.fragments);
+	if (result) return item.text == null ? [] : [item.text];
+}
+//#endregion
+//#region src/node/index.ts
+function mapNode(data, comment) {
+	const matches = EXPRESSION_ABYDON_CONTENT.exec(comment.textContent ?? "");
+	const value = matches == null ? null : data.values[+matches[1]];
+	if (value != null) mapValue(data, comment, value);
+}
+function mapNodes(data, nodes) {
+	const { length } = nodes;
+	for (let index = 0; index < length; index += 1) {
+		const node = nodes[index];
+		if (node instanceof Comment) {
+			mapNode(data, node);
+			continue;
+		}
+		if (isHTMLOrSVGElement(node)) mapAttributes(data, node);
+		if (node.hasChildNodes()) mapNodes(data, [...node.childNodes]);
+	}
+}
+function mapValue(data, comment, value) {
+	switch (true) {
+		case typeof value === "function":
+			setComputedValue(data, comment, value);
+			break;
+		case isFragments(value):
+			handleFragments(value, false);
+			setReactiveValue(data, comment, value.items);
+			break;
+		case isReactive(value):
+			setReactiveValue(data, comment, value);
+			break;
+		default:
+			replaceComment(data, comment, value);
+			break;
+	}
+}
+function replaceComment(data, comment, value) {
+	const item = data.items.find((item) => item.nodes?.includes(comment));
+	const nodes = createNodes(value);
+	if (item != null) {
+		item.fragments = isFragment(value) ? [value] : void 0;
+		item.nodes = nodes;
+	}
+	comment.replaceWith(...nodes);
+}
+function setComputedValue(data, comment, callback) {
+	const value = computed(callback);
+	data.mora.values.add(value);
+	setReactiveValue(data, comment, value);
+}
+//#endregion
+//#region src/parse.ts
+function handleExpression(data, prefix, expression) {
+	if (Array.isArray(expression)) {
+		const { length } = expression;
+		let expressions = "";
+		for (let index = 0; index < length; index += 1) expressions += handleExpression(data, "", expression[index]);
+		return `${prefix}${expressions}`;
+	}
+	if (typeof expression === "function" || typeof expression === "object" && expression != null) return transformExpression(prefix, data.values.push(expression) - 1);
+	return isNullableOrWhitespace(expression) ? prefix : `${prefix}${expression}`;
+}
+function parse(data) {
+	if (data.template != null) return data.template;
+	const { length } = data.strings;
+	data.template = "";
+	for (let index = 0; index < length; index += 1) data.template += handleExpression(data, data.strings[index], data.expressions[index]);
+	data.template = data.template.replaceAll(EXPRESSION_ABYDON_ATTRIBUTE_FULL, transformAttribute);
+	data.expressions = [];
+	data.strings = [];
+	return data.template;
+}
+function transformAttribute(_, name, index) {
+	return `_${name}="@abydon.${index}@"`;
+}
+function transformExpression(prefix, index) {
+	return `${prefix}<!--abydon.${index}-->`;
+}
+//#endregion
+//#region src/fragment.ts
+var Fragment = class {
+	#data;
+	#configuration = {
+		identifier: void 0,
+		cache: true
+	};
+	/**
+	* Fragment identifier
+	*/
+	get identifier() {
+		return this.#configuration.identifier;
+	}
+	constructor(strings, expressions) {
+		Object.defineProperty(this, NAME_FRAGMENT, { value: true });
+		this.#data = {
+			expressions,
+			strings,
+			items: [],
+			mora: {
+				subscribers: /* @__PURE__ */ new Set(),
+				values: /* @__PURE__ */ new Set()
+			},
+			values: []
+		};
+	}
+	/**
+	* Append the fragment to the given element
+	* @param element Element to append to
+	*/
+	appendTo(element) {
+		element.append(...this.get());
+	}
+	/**
+	* Configure the fragment
+	* @param configuration Configuration options
+	* @returns Fragment
+	*/
+	configure(configuration) {
+		const actual = isPlainObject(configuration) ? configuration : {};
+		if ("identifier" in actual) this.#configuration.identifier = actual.identifier;
+		if (typeof actual.cache === "boolean") this.#configuration.cache = actual.cache;
+		return this;
+	}
+	/**
+	* Get a list of the fragment's nodes
+	* @returns List of nodes
+	*/
+	get() {
+		const data = this.#data;
+		if (data.items.length === 0) {
+			const templated = html$1(parse(data), { cache: this.#configuration.cache });
+			data.items.splice(0, data.items.length, ...templated.map((node) => ({ nodes: [node] })));
+			mapNodes(data, data.items.flatMap((item) => item.fragments?.flatMap((fragment) => fragment.get()) ?? item.nodes ?? []));
+		}
+		return data.items.flatMap((item) => item.fragments?.flatMap((fragment) => fragment.get()) ?? item.nodes ?? []);
+	}
+	/**
+	* Set an identifier for the fragment
+	*
+	* _An identifier can be used to uniquely identify a fragment,
+	* which helps prevent re-rendering in certain scenarios._
+	* @param identifier Identifier
+	* @returns Fragment
+	*/
+	identify(identifier) {
+		this.#configuration.identifier = identifier;
+		return this;
+	}
+	/**
+	* Remove the fragment from the DOM
+	*/
+	remove() {
+		removeFragment(this.#data);
+	}
+};
+function removeFragment(data) {
+	removeMora(data);
+	let { length } = data.items;
+	for (let index = 0; index < length; index += 1) {
+		const { fragments, nodes } = data.items[index];
+		const fragmentsLength = fragments?.length ?? 0;
+		for (let fragmentIndex = 0; fragmentIndex < fragmentsLength; fragmentIndex += 1) fragments?.[fragmentIndex]?.remove();
+		removeNodes(nodes ?? []);
+	}
+	data.items.length = 0;
+	length = data.values.length;
+	for (let index = 0; index < length; index += 1) {
+		const value = data.values[index];
+		if (isFragments(value)) handleFragments(value, true);
+	}
+}
+function removeMora(data) {
+	const unsubscribers = [...data.mora.subscribers];
+	data.mora.subscribers.clear();
+	data.mora.values.clear();
+	for (const unsubscribe of unsubscribers) unsubscribe();
+}
+//#endregion
+//#region src/index.ts
+/**
+* Create Fragments from a reactive array
+* @param array Reactive array
+* @param identify Function to identify item
+* @param fragment Function to create fragment from item
+* @returns Fragments
+*/
+function fragments(array, identify, fragment) {
+	return new Fragments(array, identify, fragment);
+}
+/**
+* Create Fragment from a template
+* @returns Fragment
+*/
+function html(template, ...values) {
+	return new Fragment(template, values);
+}
+//#endregion
+export { array, computed, effect, fragments, html, isArray, isComputed, isEffect, isReactive, isSignal, signal, startBatch, stopBatch, store };