@oscarpalmer/abydon 0.12.0 → 0.14.0

package/dist/abydon.full.js

@@ -0,0 +1,1153 @@
+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_SIGNAL = "signal";
+const NAME_STORE = "store";
+const NAMES = new Set([
+	NAME_ARRAY,
+	NAME_COMPUTED,
+	NAME_SIGNAL,
+	NAME_STORE
+]);
+
+var Effect = class {
+	constructor(callback) {
+		Object.defineProperty(this, "$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;
+}
+
+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, NAMES);
+}
+function isSignal(value) {
+	return isMora(value, NAME_SIGNAL);
+}
+
+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();
+}
+
+var Subscription = class {
+	callback;
+	state;
+	constructor(state, callback) {
+		this.state = state;
+		this.callback = callback;
+		callback(state.value);
+	}
+	destroy() {
+		this.callback = noop;
+		this.state = void 0;
+	}
+};
+function noop() {}
+function subscribe(state, callback) {
+	if (typeof callback !== "function" || state.subscriptions.has(callback)) return noop;
+	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);
+}
+
+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, "$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);
+	}
+};
+
+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);
+}
+
+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;
+}
+
+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);
+}
+
+function getReactiveValueInProxy(reactive, mapped, key, isArray) {
+	let item = mapped.get(key);
+	if (item == null) {
+		item = computed(() => {
+			const value = reactive.get();
+			return isArray ? value.at(key) : value[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;
+}
+
+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();
+		if (first === "length") return this.length;
+		return getValue$1(this.state);
+	}
+	map(callback) {
+		return computed(() => this.get().map(callback));
+	}
+	notify() {
+		emitValue(this.state);
+	}
+	peek(value) {
+		if (value === "length") return this.#size.peek();
+		if (typeof value === "number") return this.state.value.at(value);
+		return [...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;
+	}
+	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;
+}
+
+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;
+}
+
+function getString$1(value) {
+	if (typeof value === "string") return value;
+	if (value == null) return "";
+	if (typeof value !== "object") return String(value);
+	const asString = String(value.valueOf?.() ?? value);
+	return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
+}
+
+function isNullableOrWhitespace(value) {
+	return value == null || EXPRESSION_WHITESPACE.test(getString$1(value));
+}
+var EXPRESSION_WHITESPACE = /^\s*$/;
+
+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);
+	}
+	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;
+	}
+	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);
+}
+
+function isChildNode(value) {
+	return value instanceof Node && CHILD_NODE_TYPES.has(value.nodeType);
+}
+function isHTMLOrSVGElement(value) {
+	return value instanceof HTMLElement || value instanceof SVGElement;
+}
+var CHILD_NODE_TYPES = new Set([
+	Node.ELEMENT_NODE,
+	Node.TEXT_NODE,
+	Node.PROCESSING_INSTRUCTION_NODE,
+	Node.COMMENT_NODE,
+	Node.DOCUMENT_TYPE_NODE
+]);
+
+function getString(value) {
+	if (typeof value === "string") return value;
+	if (value == null) return "";
+	if (typeof value !== "object") return String(value);
+	const asString = String(value.valueOf?.() ?? value);
+	return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
+}
+
+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;
+}
+
+function isAttribute(value) {
+	return value instanceof Attr || isPlainObject(value) && typeof value.name === "string" && typeof value.value === "string";
+}
+function isBadAttribute(first, second) {
+	return validateAttribute((attribute) => attribute == null || EXPRESSION_ON_PREFIX.test(attribute.name) || EXPRESSION_SOURCE_PREFIX.test(attribute.name) && EXPRESSION_VALUE_PREFIX.test(String(attribute.value)), first, second);
+}
+function isBooleanAttribute(value) {
+	return validateAttribute((attribute) => attribute != null && booleanAttributes.includes(attribute.name.toLowerCase()), value, "");
+}
+function isEmptyNonBooleanAttribute(first, second) {
+	return validateAttribute((attribute) => attribute != null && !booleanAttributes.includes(attribute.name) && String(attribute.value).trim().length === 0, first, second);
+}
+function isInvalidBooleanAttribute(first, second) {
+	return validateAttribute((attribute) => {
+		if (attribute == null) return true;
+		if (!booleanAttributes.includes(attribute.name)) return false;
+		const normalized = String(attribute.value).toLowerCase().trim();
+		return !(normalized.length === 0 || normalized === attribute.name);
+	}, first, second);
+}
+function isProperty(value) {
+	return isPlainObject(value) && typeof value.name === "string";
+}
+function setAttribute$1(element, first, second) {
+	updateValue(element, first, second, updateAttribute);
+}
+function setProperty(element, first, second) {
+	updateValue(element, first, second, updateProperty$1);
+}
+function updateAttribute(element, name, value) {
+	if (booleanAttributes.includes(name.toLowerCase())) updateProperty$1(element, name, value, false);
+	else if (value == null) element.removeAttribute(name);
+	else element.setAttribute(name, typeof value === "string" ? value : getString(value));
+}
+function updateProperty$1(element, name, value, validate) {
+	const actual = validate ?? true ? name.toLowerCase() : name;
+	if (actual === "hidden") element.hidden = value === "" || value === true;
+	else element[actual] = value === "" || typeof value === "string" && value.toLowerCase() === actual || value === true;
+}
+function updateValue(element, first, second, callback) {
+	if (!isHTMLOrSVGElement(element)) return;
+	if (isProperty(first)) callback(element, first.name, first.value);
+	else if (typeof first === "string") callback(element, first, second);
+}
+function validateAttribute(callback, first, second) {
+	let attribute;
+	if (isAttribute(first)) attribute = first;
+	else if (typeof first === "string" && typeof second === "string") attribute = {
+		name: first,
+		value: second
+	};
+	return callback(attribute);
+}
+var EXPRESSION_ON_PREFIX = /^on/i;
+var EXPRESSION_SOURCE_PREFIX = /^(href|src|xlink:href)$/i;
+var EXPRESSION_VALUE_PREFIX = /(data:text\/html|javascript:)/i;
+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"
+]);
+
+function getOptions$1(input) {
+	const options = isPlainObject(input) ? input : {};
+	options.sanitizeBooleanAttributes = typeof options.sanitizeBooleanAttributes === "boolean" ? options.sanitizeBooleanAttributes : true;
+	return options;
+}
+function sanitize(value, options) {
+	return sanitizeNodes$1(Array.isArray(value) ? value : [value], getOptions$1(options));
+}
+function sanitizeAttributes(element, attributes, options) {
+	const { length } = attributes;
+	for (let index = 0; index < length; index += 1) {
+		const attribute = attributes[index];
+		if (isBadAttribute(attribute) || isEmptyNonBooleanAttribute(attribute)) element.removeAttribute(attribute.name);
+		else if (options.sanitizeBooleanAttributes && isInvalidBooleanAttribute(attribute)) element.setAttribute(attribute.name, "");
+	}
+}
+function sanitizeNodes$1(nodes, options) {
+	const actual = nodes.filter((node) => node instanceof Node);
+	const { length } = nodes;
+	for (let index = 0; index < length; index += 1) {
+		const node = actual[index];
+		if (node instanceof Element) sanitizeAttributes(node, [...node.attributes], options);
+		if (node.hasChildNodes()) sanitizeNodes$1([...node.childNodes], options);
+	}
+	return nodes;
+}
+
+function createTemplate(html$1) {
+	const template = document.createElement("template");
+	template.innerHTML = html$1;
+	templates[html$1] = template;
+	return template;
+}
+function getTemplate(value) {
+	if (typeof value !== "string" || value.trim().length === 0) return;
+	let template = templates[value];
+	if (template != null) return template;
+	const element = EXPRESSION_ID.test(value) ? document.querySelector(`#${value}`) : null;
+	template = element instanceof HTMLTemplateElement ? element : createTemplate(value);
+	templates[value] = template;
+	return template;
+}
+var html$1 = ((value, sanitization) => {
+	if (typeof value !== "string" && !(value instanceof HTMLTemplateElement)) return [];
+	let options;
+	if (sanitization == null || sanitization === true) options = {};
+	else options = sanitization === false ? void 0 : sanitization;
+	const template = value instanceof HTMLTemplateElement ? value : getTemplate(value);
+	if (template == null) return [];
+	const cloned = template.content.cloneNode(true);
+	const scripts = cloned.querySelectorAll("script");
+	const { length } = scripts;
+	for (let index = 0; index < length; index += 1) scripts[index].remove();
+	cloned.normalize();
+	return options != null ? sanitize([...cloned.childNodes], options) : [...cloned.childNodes];
+});
+html$1.clear = () => {
+	templates = {};
+};
+html$1.remove = (template) => {
+	if (typeof template === "string") templates[template] = void 0;
+};
+var EXPRESSION_ID = /^[a-z][\w-]*$/i;
+var templates = {};
+
+const ABORT_CONTROLLERS = new WeakMap();
+const ATTRIBUTE_CLASS_PREFIX_LENGTH = 6;
+const EXPRESSION_ATTRIBUTE_CLASS = /^class\./;
+const EXPRESSION_ATTRIBUTE_STYLE_FULL = /^style\.([\w-]+)(?:\.([\w-]+))?$/;
+const EXPRESSION_ATTRIBUTE_STYLE_PREFIX = /^style\./;
+const EXPRESSION_COMMENT_FULL = /^<!--abydon\.(\d+)-->$/;
+const EXPRESSION_COMMENT_CONTENT = /^abydon\.(\d+)$/;
+const EXPRESSION_EVENT_NAME = /^@([\w-]+)(?::([a-z:]+))?$/i;
+const REASON_EVENT_REMOVED = 'Event removed as element was removed from document by Abydon';
+
+function getController(element) {
+    let controller = ABORT_CONTROLLERS.get(element);
+    if (controller == null) {
+        controller = new AbortController();
+        ABORT_CONTROLLERS.set(element, controller);
+    }
+    return controller;
+}
+function getOptions(options) {
+    const parts = options.split(':');
+    return {
+        capture: parts.includes('c') || parts.includes('capture'),
+        once: parts.includes('o') || parts.includes('once'),
+        passive: !(parts.includes('a') || parts.includes('active')),
+    };
+}
+function mapEvent(element, name, value) {
+    element.removeAttribute(name);
+    const [, type, options] = EXPRESSION_EVENT_NAME.exec(name) ?? [];
+    if (typeof value === 'function' && type != null) {
+        element.addEventListener(type, value, {
+            ...getOptions(options ?? ''),
+            signal: getController(element).signal,
+        });
+    }
+}
+function removeEvents(element) {
+    ABORT_CONTROLLERS.get(element)?.abort(REASON_EVENT_REMOVED);
+    ABORT_CONTROLLERS.delete(element);
+}
+
+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 'dissimilar';
+    }
+    return firstIsLarger ? 'removed' : 'added';
+}
+function isFragment(value) {
+    return (typeof value === 'object' &&
+        value != null &&
+        '$fragment' in value &&
+        value.$fragment === true);
+}
+
+function createNodes(value) {
+    if (isFragment(value)) {
+        return value.get();
+    }
+    if (isChildNode(value)) {
+        return [value];
+    }
+    return [new Text(getString$1(value))];
+}
+function removeNodes(nodes) {
+    sanitizeNodes(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();
+    }
+}
+function sanitizeNodes(nodes) {
+    const { length } = nodes;
+    for (let index = 0; index < length; index += 1) {
+        const node = nodes[index];
+        if (isHTMLOrSVGElement(node)) {
+            removeEvents(node);
+        }
+        if (node.hasChildNodes()) {
+            sanitizeNodes([...node.childNodes]);
+        }
+    }
+}
+
+function setAttribute(data, element, name, value) {
+    element.removeAttribute(name);
+    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(ATTRIBUTE_CLASS_PREFIX_LENGTH).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 : getString$1(value));
+        }
+    }
+    if (isReactive(value)) {
+        data.mora.subscribers.add(value.subscribe(update));
+    }
+    else {
+        update(value);
+    }
+}
+function setValue(data, element, name, value) {
+    let callback;
+    if (isBooleanAttribute(name) && name in element) {
+        callback = name === 'selected' ? updateSelected : updateProperty;
+    }
+    else {
+        callback = setAttribute$1;
+    }
+    if (isReactive(value)) {
+        data.mora.subscribers.add(value.subscribe(next => {
+            callback(element, name, next);
+        }));
+    }
+    else {
+        callback(element, name, value);
+    }
+}
+function updateProperty(element, name, value) {
+    element[name] = value === true;
+}
+function updateSelected(element, name, value) {
+    const select = element.closest('select');
+    const options = [...(select?.options ?? [])];
+    if (select != null && options.includes(element)) {
+        select.dispatchEvent(new Event('change', { bubbles: true }));
+    }
+    updateProperty(element, name, value);
+}
+
+function getValue(data, original) {
+    const matches = EXPRESSION_COMMENT_FULL.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 actual = getValue(data, value);
+        switch (true) {
+            case name.startsWith('@'):
+                mapEvent(element, name, actual);
+                break;
+            case name.includes('.') ||
+                typeof actual === 'function' ||
+                isReactive(actual):
+                mapValue$1(data, element, name, actual);
+                break;
+            case isBooleanAttribute(name):
+                setProperty(element, name, value);
+                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);
+}
+
+//
+function addToArray(identifiers, items, nodes, added) {
+    let position = nodes[0];
+    const before = added && !identifiers.previous.includes(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.includes(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.includes(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 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 ? undefined : templates,
+            nodes: setNodes(item, comment, noTemplates
+                ? value.flatMap(item => createNodes(item))
+                : templates.flatMap(template => template.get())),
+        };
+    }
+    return handleArray({
+        next,
+        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' ? undefined : result?.fragments;
+    if (typeof result === 'boolean') {
+        item.nodes = result ? item.text == null ? [] : [item.text] : undefined;
+    }
+    else {
+        item.nodes = result?.nodes;
+    }
+}
+function setReactiveValueForSingle(item, comment, value) {
+    const valueIsFragment = isFragment(value);
+    item.fragments = valueIsFragment ? [value] : undefined;
+    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$1(value);
+    }
+    let result = false;
+    if (item.nodes != null) {
+        replaceNodes(item.nodes, isNullable ? [comment] : item.text == null ? [] : [item.text]);
+        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);
+    return result ? item.text == null ? [] : [item.text] : undefined;
+}
+
+function mapNode(data, comment) {
+    const matches = EXPRESSION_COMMENT_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 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] : undefined;
+        item.nodes = nodes;
+    }
+    comment.replaceWith(...nodes);
+}
+function setComputedValue(data, comment, callback) {
+    const value = computed(callback);
+    data.mora.values.add(value);
+    setReactiveValue(data, comment, value);
+}
+
+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)) {
+        const index = data.values.push(expression) - 1;
+        return `${prefix}<!--abydon.${index}-->`;
+    }
+    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.expressions = [];
+    data.strings = [];
+    return data.template;
+}
+
+function calculate() {
+	return new Promise((resolve) => {
+		const values = [];
+		let last;
+		function step(now) {
+			if (last != null) values.push(now - last);
+			last = now;
+			if (values.length >= CALCULATION_TOTAL) resolve(values.sort().slice(2, -2).reduce((first, second) => first + second, 0) / (values.length - CALCULATION_TRIM));
+			else requestAnimationFrame(step);
+		}
+		requestAnimationFrame(step);
+	});
+}
+var CALCULATION_TOTAL = 10;
+var CALCULATION_TRIM = 4;
+calculate().then((value) => {
+});
+
+class Fragment {
+    #data;
+    #configuration = {
+        identifier: undefined,
+        ignoreCache: false,
+    };
+    get identifier() {
+        return this.#configuration.identifier;
+    }
+    constructor(strings, expressions) {
+        this.#data = {
+            expressions,
+            strings,
+            items: [],
+            mora: {
+                subscribers: new Set(),
+                values: new Set(),
+            },
+            values: [],
+        };
+        Object.defineProperty(this, '$fragment', {
+            value: true,
+        });
+    }
+    /**
+     * Appends the fragment to the given element
+     */
+    appendTo(element) {
+        element.append(...this.get());
+    }
+    configure(configuration) {
+        const actual = isPlainObject$1(configuration) ? configuration : {};
+        if (actual.identifier !== undefined) {
+            this.#configuration.identifier = actual.identifier;
+        }
+        if (typeof actual.ignoreCache === 'boolean') {
+            this.#configuration.ignoreCache = actual.ignoreCache;
+        }
+        return this;
+    }
+    /**
+     * Gets a list of the fragment's nodes
+     */
+    get() {
+        const data = this.#data;
+        if (data.items.length === 0) {
+            const parsed = parse(data);
+            const templated = html$1(parsed, {
+                sanitizeBooleanAttributes: false,
+            });
+            if (this.#configuration.ignoreCache) {
+                html$1.remove(parsed);
+            }
+            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 ?? []),
+        ];
+    }
+    identify(identifier) {
+        this.#configuration.identifier = identifier;
+        return this;
+    }
+    /**
+     * Removes the fragment from the DOM
+     */
+    remove() {
+        removeFragment(this.#data);
+    }
+}
+function removeFragment(data) {
+    removeMora(data);
+    const { length } = data.items;
+    for (let index = 0; index < length; index += 1) {
+        const { fragments, nodes } = data.items[index];
+        const length = fragments?.length ?? 0;
+        for (let index = 0; index < length; index += 1) {
+            fragments?.[index]?.remove();
+        }
+        removeNodes(nodes ?? []);
+    }
+    data.items.length = 0;
+}
+function removeMora(data) {
+    const unsubscribers = [...data.mora.subscribers];
+    data.mora.subscribers.clear();
+    data.mora.values.clear();
+    for (const unsubscribe of unsubscribers) {
+        unsubscribe();
+    }
+}
+
+function html(strings, ...values) {
+    return new Fragment(strings, values);
+}
+
+export { array, computed, effect, html, isArray, isComputed, isEffect, isReactive, isSignal, signal, startBatch, stopBatch, store };