@oscarpalmer/abydon 0.12.0 → 0.13.0

package/dist/abydon.full.js

@@ -0,0 +1,1247 @@
+function isArray(value) {
+  return isMora(value, arrayName);
+}
+function isComputed(value) {
+  return isMora(value, computedName);
+}
+function isEffect(value) {
+  return isMora(value, effectName);
+}
+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, reactiveNames);
+}
+function isSignal(value) {
+  return isMora(value, signalName);
+}
+const arrayName = "array";
+const computedName = "computed";
+const effectName = "effect";
+const signalName = "signal";
+const storeName = "store";
+const reactiveNames = /* @__PURE__ */ new Set([arrayName, computedName, signalName, storeName]);
+
+class Effect {
+  constructor(callback) {
+    Object.defineProperty(this, "$mora", {
+      value: effectName
+    });
+    this.state = {
+      callback
+    };
+    runEffect(this);
+  }
+}
+function runEffect(effect2) {
+  const previousEffect = activeEffect;
+  activeEffect = effect2;
+  try {
+    effect2.state.callback();
+  } finally {
+    activeEffect = previousEffect;
+  }
+}
+function effect(callback) {
+  return new Effect(callback);
+}
+let activeEffect;
+
+function flushHandlers() {
+  while (batchDepth === 0 && batchedHandlers.size > 0) {
+    const handlers = [...batchedHandlers];
+    batchedHandlers.clear();
+    for (const handler of handlers) {
+      if (isEffect(handler)) {
+        runEffect(handler);
+      } else {
+        handler.callback(handler.state.value);
+      }
+    }
+  }
+}
+function startBatch() {
+  batchDepth += 1;
+}
+function stopBatch() {
+  if (batchDepth > 0) {
+    batchDepth -= 1;
+  }
+  flushHandlers();
+}
+const batchedHandlers = /* @__PURE__ */ new Set();
+let batchDepth = 0;
+
+class Subscription {
+  constructor(state, callback) {
+    this.state = state;
+    this.callback = callback;
+    callback(state.value);
+  }
+}
+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) {
+  const subscription = state.subscriptions.get(callback);
+  state.subscriptions.delete(callback);
+  if (subscription != null) {
+    subscription.callback = noop;
+    subscription.state = void 0;
+  }
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, key + "" , value);
+class Reactive {
+  constructor(name, value, options) {
+    __publicField$1(this, "state", {
+      computeds: /* @__PURE__ */ new Set(),
+      effects: /* @__PURE__ */ new Set(),
+      equal: Object.is,
+      subscriptions: /* @__PURE__ */ new Map(),
+      value: void 0
+    });
+    this.state.value = value;
+    if (typeof options === "object" && typeof options.equal === "function") {
+      this.state.equal = options.equal;
+    }
+    Object.defineProperty(this, "$mora", {
+      value: name
+    });
+  }
+  /**
+   * Get the value _(without reactivity)_
+   */
+  peek() {
+    return this.state.value;
+  }
+  /**
+   * Subscribe to changes
+   */
+  subscribe(callback) {
+    return subscribe(this.state, callback);
+  }
+  /**
+   * JSON representation of the value
+   */
+  toJSON() {
+    return this.get();
+  }
+  /**
+   * String representation of the value
+   */
+  toString() {
+    return String(this.get());
+  }
+  /**
+   * Unsubscribe from changes
+   */
+  unsubscribe(callback) {
+    unsubscribe(this.state, callback);
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+let activeComputed;
+class Computed extends Reactive {
+  constructor(callback, options) {
+    super(computedName, void 0, options);
+    __publicField(this, "effect", {
+      dirty: true,
+      instance: void 0
+    });
+    this.effect.instance = effect(() => {
+      if (this.effect.dirty) {
+        const previousComputed = activeComputed;
+        activeComputed = this;
+        const value = callback();
+        activeComputed = previousComputed;
+        if (!this.state.equal(this.state.value, value)) {
+          this.state.value = value;
+          for (const computed2 of this.state.computeds) {
+            computed2.effect.dirty = true;
+          }
+          for (const effect2 of this.state.effects) {
+            batchedHandlers.add(effect2);
+          }
+          for (const [, subscription] of this.state.subscriptions) {
+            subscription.callback(value);
+          }
+        }
+        this.effect.dirty = false;
+      }
+    });
+  }
+  /**
+   * @inheritdoc
+   */
+  get() {
+    if (activeComputed != null && this !== activeComputed) {
+      this.state.computeds.add(activeComputed);
+    }
+    if (activeEffect != null && activeEffect !== this.effect.instance) {
+      this.state.effects.add(activeEffect);
+    }
+    if (this.effect.dirty && batchDepth === 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) {
+    batchedHandlers.add(effect);
+  }
+  for (const [, subscription] of state.subscriptions) {
+    batchedHandlers.add(subscription);
+  }
+  if (batchDepth === 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 (activeComputed != null) {
+    state.computeds.add(activeComputed);
+  }
+  if (activeEffect != null) {
+    state.effects.add(activeEffect);
+  }
+  return state.value;
+}
+
+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)) {
+      const keyedValue = value[key];
+      proxy[key] = keyedValue;
+    }
+  }
+  stopBatch();
+}
+function setValueInProxy(target, property, value, state, isArray, length) {
+  if (isArray) {
+    const isIndex = !Number.isNaN(Number(property));
+    const isLength = property === "length";
+    if (!isIndex && !isLength) {
+      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 == null ? void 0 : length.set(target.length);
+    }
+  }
+  return true;
+}
+
+class Signal extends Reactive {
+  constructor(value, options) {
+    super(signalName, value, options);
+  }
+  /**
+   * @inheritdoc
+   */
+  get() {
+    return getValue$1(this.state);
+  }
+  /**
+   * Set the value
+   */
+  set(value) {
+    if (!this.state.equal(this.state.value, value)) {
+      this.state.value = value;
+      emitValue(this.state);
+    }
+  }
+  /**
+   * Update the value _(based on the current value)_
+   */
+  update(callback) {
+    this.set(callback(this.state.value));
+  }
+}
+function signal(value, options) {
+  return new Signal(value, options);
+}
+
+var __typeError$1 = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck$1 = (obj, member, msg) => member.has(obj) || __typeError$1("Cannot " + msg);
+var __privateGet$1 = (obj, member, getter) => (__accessCheck$1(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$1 = (obj, member, value) => member.has(obj) ? __typeError$1("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var _indiced, _size;
+class ReactiveArray extends Reactive {
+  constructor(value, options) {
+    super(
+      arrayName,
+      new Proxy(value, {
+        get: (target, property) => updateMethods.has(property) ? updateArray(property, target, this.state, __privateGet$1(this, _size)) : Reflect.get(target, property),
+        set: (target, property, value2) => setValueInProxy(
+          target,
+          property,
+          value2,
+          this.state,
+          true,
+          __privateGet$1(this, _size)
+        )
+      }),
+      options
+    );
+    __privateAdd$1(this, _indiced, /* @__PURE__ */ new Map());
+    __privateAdd$1(this, _size, signal(0));
+    __privateGet$1(this, _size).set(value.length);
+  }
+  /**
+   * The length of the array
+   */
+  get length() {
+    return __privateGet$1(this, _size).get();
+  }
+  /**
+   * Set the length of the array
+   */
+  set length(value) {
+    if (typeof value === "number" && value >= 0 && value !== this.state.value.length) {
+      this.get().length = value;
+    }
+  }
+  /**
+   * Clear the array
+   */
+  clear() {
+    this.length = 0;
+  }
+  get(first) {
+    if (typeof first === "number") {
+      return getReactiveValueInProxy(this, __privateGet$1(this, _indiced), first, true).get();
+    }
+    if (first === "length") {
+      return this.length;
+    }
+    return getValue$1(this.state);
+  }
+  /**
+   * Create a computed, filtered array
+   */
+  filter(callback) {
+    return computed(() => this.get().filter(callback));
+  }
+  /**
+   * Create a computed, mapped array
+   */
+  map(callback) {
+    return computed(() => this.get().map(callback));
+  }
+  peek(value) {
+    if (value === true) {
+      return __privateGet$1(this, _size).peek();
+    }
+    if (typeof value === "number") {
+      return this.state.value.at(value);
+    }
+    return [...this.state.value];
+  }
+  /**
+   * Remove and return the last item of the array
+   */
+  pop() {
+    return this.state.value.pop();
+  }
+  /**
+   * Add items to the end of the array
+   */
+  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") {
+      this.state.value[first] = second;
+    }
+  }
+  /**
+   * Remove and return the first item of the array
+   */
+  shift() {
+    return this.state.value.shift();
+  }
+  /**
+   * Remove and return items from the array _(and optionally add new items)_
+   */
+  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,
+        __privateGet$1(this, _indiced),
+        first,
+        true
+      ).subscribe(second);
+    }
+    return typeof first === "function" ? subscribe(this.state, first) : noop;
+  }
+  /**
+   * Add items to the beginning of the array
+   */
+  unshift(...items) {
+    return this.state.value.unshift(...items);
+  }
+  /**
+   * Update the value _(based on the current value)_
+   */
+  update(callback) {
+    const updated = callback(this.state.value);
+    if (updated == null || Array.isArray(updated)) {
+      this.set(updated);
+    }
+  }
+}
+_indiced = new WeakMap();
+_size = new WeakMap();
+function array(value, options) {
+  return new ReactiveArray(Array.isArray(value) ? value : [], options);
+}
+function updateArray(type, array2, state, length) {
+  const affectsLength = lengthAffectingMethods.has(type);
+  const previousArray = affectsLength ? [] : [...array2];
+  const previousLength = array2.length;
+  return (...args) => {
+    const result = array2[type](
+      ...args
+    );
+    if (affectsLength ? array2.length !== previousLength : !equalArrays(state, previousArray, array2)) {
+      emitValue(state);
+      length.set(array2.length);
+    }
+    return result;
+  };
+}
+const lengthAffectingMethods = /* @__PURE__ */ new Set([
+  "pop",
+  "push",
+  "shift",
+  "unshift"
+]);
+const updateMethods = /* @__PURE__ */ new Set([
+  ...lengthAffectingMethods,
+  "copyWithin",
+  "fill",
+  "reverse",
+  "sort",
+  "splice"
+]);
+
+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;
+}
+
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var _keyed;
+class Store extends Reactive {
+  constructor(value, options) {
+    super(
+      storeName,
+      new Proxy(value, {
+        set: (target, property, value2) => setValueInProxy(target, property, value2, this.state, false)
+      }),
+      options
+    );
+    __privateAdd(this, _keyed, /* @__PURE__ */ new Map());
+  }
+  get(key) {
+    return isKey(key) ? getReactiveValueInProxy(this, __privateGet(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, __privateGet(this, _keyed), first, false).subscribe(
+        second
+      );
+    }
+    return typeof first === "function" ? subscribe(this.state, first) : noop;
+  }
+  /**
+   * Update the value _(based on the current value)_
+   */
+  update(callback) {
+    const updated = callback({ ...this.state.value });
+    if (updated == null || isPlainObject$1(updated)) {
+      setProxyValue(this.state.value, updated ?? {});
+    }
+  }
+}
+_keyed = new WeakMap();
+function store(value, options) {
+  return new Store(isPlainObject$1(value) ? value : {}, options);
+}
+
+function isChildNode(value) {
+	return value instanceof Node && childNodeTypes.has(value.nodeType);
+}
+function isHTMLOrSVGElement(value) {
+	return value instanceof HTMLElement || value instanceof SVGElement;
+}
+var childNodeTypes = new Set([
+	1,
+	3,
+	7,
+	8,
+	10
+]);
+
+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 isNullableOrWhitespace(value) {
+	return value == null || whiteSpaceExpression.test(getString(value));
+}
+var whiteSpaceExpression = /^\s*$/;
+
+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 || onPrefix.test(attribute.name) || sourcePrefix.test(attribute.name) && valuePrefix.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 updateAttribute(element, name, value) {
+	if (booleanAttributes.includes(name.toLowerCase())) updateProperty$1(element, name, value);
+	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 = 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);
+}
+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"
+]);
+var onPrefix = /^on/i;
+var sourcePrefix = /^(href|src|xlink:href)$/i;
+var valuePrefix = /(data:text\/html|javascript:)/i;
+
+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(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(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([...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;
+	if (value in templates) return templates[value];
+	let template;
+	if (idPattern.test(value)) template = document.querySelector(`#${value}`);
+	templates[value] = template instanceof HTMLTemplateElement ? template : createTemplate(value);
+	return templates[value];
+}
+function html$1(value, sanitization) {
+	if (typeof value !== "string" && !(value instanceof HTMLTemplateElement)) return [];
+	const options = sanitization == null || sanitization === true ? {} : isPlainObject(sanitization) ? { ...sanitization } : null;
+	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];
+}
+var idPattern = /^[a-z][\w-]*$/i;
+var templates = {};
+
+const controllers = new WeakMap();
+const eventNamePattern = /^@([\w-]+)(?::([a-z:]+))?$/i;
+const reason = 'Event removed as element was removed from document by Abydon';
+function getController(element) {
+    let controller = controllers.get(element);
+    if (controller == null) {
+        controller = new AbortController();
+        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] = eventNamePattern.exec(name) ?? [];
+    if (typeof value === 'function' && type != null) {
+        element.addEventListener(type, value, {
+            ...getOptions(options ?? ''),
+            signal: getController(element).signal,
+        });
+    }
+}
+function removeEvents(element) {
+    controllers.get(element)?.abort(reason);
+    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(value))];
+}
+function removeNodes(nodes) {
+    sanitiseNodes(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 sanitiseNodes(nodes) {
+    const { length } = nodes;
+    for (let index = 0; index < length; index += 1) {
+        const node = nodes[index];
+        if (isHTMLOrSVGElement(node)) {
+            removeEvents(node);
+        }
+        if (node.hasChildNodes()) {
+            sanitiseNodes([...node.childNodes]);
+        }
+    }
+}
+
+const classExpression = /^class\./;
+const styleFullExpression = /^style\.([\w-]+)(?:\.([\w-]+))?$/;
+const stylePrefixExpression = /^style\./;
+function setAttribute(data, element, name, value) {
+    element.removeAttribute(name);
+    switch (true) {
+        case classExpression.test(name):
+            setClasses(data, element, name, value);
+            return;
+        case stylePrefixExpression.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) {
+    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(value));
+        }
+    }
+    const [, property, unit] = styleFullExpression.exec(name) ?? [];
+    if (property != null) {
+        if (isReactive(value)) {
+            data.mora.subscribers.add(value.subscribe(update));
+        }
+        else {
+            update(value);
+        }
+    }
+}
+function setValue(data, element, name, value) {
+    const callback = isBooleanAttribute(name) && name in element
+        ? name === 'selected'
+            ? updateSelected
+            : updateProperty
+        : setAttribute$1;
+    if (isReactive(value)) {
+        data.mora.subscribers.add(value.subscribe(next => {
+            callback(element, name, next);
+        }));
+    }
+    else {
+        callback(element, name, value);
+    }
+}
+function triggerSelectChange(select) {
+    if (select != null) {
+        select.dispatchEvent(new Event('change', { bubbles: true }));
+    }
+}
+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)) {
+        triggerSelectChange(select);
+    }
+    updateProperty(element, name, value);
+}
+
+const commentExpression$1 = /^<!--abydon\.(\d+)-->$/;
+function getValue(data, original) {
+    const matches = commentExpression$1.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);
+        if (name.startsWith('@')) {
+            mapEvent(element, name, actual);
+        }
+        else if (name.includes('.') ||
+            typeof value === 'function' ||
+            isReactive(actual)) {
+            mapValue$1(data, element, name, actual);
+        }
+    }
+}
+function mapValue$1(data, element, name, value) {
+    switch (true) {
+        case typeof value === 'function':
+            setComputedAttribute(data, element, name, value);
+            break;
+        default:
+            setAttribute(data, element, name, value);
+            break;
+    }
+}
+function setComputedAttribute(data, element, name, callback) {
+    const value = computed(callback);
+    data.mora.values.add(value);
+    setAttribute(data, element, name, value);
+}
+
+function removeFragments(fragments) {
+    if (fragments != null) {
+        const { length } = fragments;
+        for (let index = 0; index < length; index += 1) {
+            fragments[index].remove();
+        }
+    }
+}
+function setArray(fragments, nodes, comment, text, value) {
+    if (value.length === 0) {
+        return {
+            nodes: setText(fragments, nodes, comment, text, value),
+        };
+    }
+    let templates = value.filter(item => isFragment(item) && item.identifier != null);
+    const identifiers = templates.map(fragment => fragment.identifier);
+    const oldIdentifiers = fragments?.map(fragment => fragment.identifier) ?? [];
+    if (new Set(identifiers).size !== templates.length) {
+        templates = [];
+    }
+    const noTemplates = templates.length === 0;
+    if (noTemplates ||
+        nodes == null ||
+        oldIdentifiers.some(identifier => identifier == null)) {
+        return {
+            fragments: noTemplates ? undefined : templates,
+            nodes: setNodes(fragments, nodes, comment, text, noTemplates
+                ? value.flatMap(item => createNodes(item))
+                : templates.flatMap(template => template.get())),
+        };
+    }
+    const next = templates.map(template => fragments?.find(fragment => fragment.identifier === template.identifier) ?? template);
+    const comparison = compareArrays(fragments ?? [], templates);
+    if (comparison !== 'removed') {
+        let position = nodes[0];
+        const before = comparison === 'added' &&
+            !oldIdentifiers.includes(templates[0].identifier);
+        const items = next.flatMap(fragment => fragment.get().flatMap(node => ({
+            identifier: fragment.identifier,
+            value: node,
+        })));
+        const { length } = items;
+        for (let index = 0; index < length; index += 1) {
+            const item = items[index];
+            if (comparison === 'dissimilar' ||
+                !oldIdentifiers.includes(item.identifier)) {
+                if (index === 0 && before) {
+                    position.before(item.value);
+                }
+                else {
+                    position.after(item.value);
+                }
+            }
+            position = item.value;
+        }
+    }
+    const toRemove = fragments?.filter(fragment => !identifiers.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 setNodes(fragments, nodes, comment, text, next) {
+    if (nodes == null) {
+        if (comment.parentNode != null) {
+            replaceNodes([comment], next);
+        }
+        else if (text.parentNode != null) {
+            replaceNodes([text], next);
+        }
+    }
+    else {
+        replaceNodes(nodes, next);
+    }
+    removeFragments(fragments);
+    return next;
+}
+function setReactiveValue(data, comment, reactive) {
+    const item = data.items.find(item => item.nodes.includes(comment));
+    const text = new Text();
+    let fragments;
+    let nodes;
+    data.mora.subscribers.add(reactive.subscribe(value => {
+        if (Array.isArray(value)) {
+            const result = setArray(fragments, nodes, comment, text, value);
+            fragments = typeof result === 'boolean' ? undefined : result?.fragments;
+            nodes =
+                typeof result === 'boolean'
+                    ? result
+                        ? [text]
+                        : undefined
+                    : result?.nodes;
+        }
+        else {
+            const valueIsFragment = isFragment(value);
+            fragments = valueIsFragment ? [value] : undefined;
+            if (valueIsFragment || isChildNode(value)) {
+                nodes = setNodes(fragments, nodes, comment, text, createNodes(value));
+            }
+            else {
+                nodes = setText(fragments, nodes, comment, text, value);
+            }
+        }
+        if (item != null) {
+            item.fragments = fragments;
+            item.nodes = [...(nodes ?? [comment])];
+        }
+    }));
+}
+function setText(fragments, nodes, comment, text, value) {
+    const isNullable = isNullableOrWhitespace(value);
+    text.textContent = isNullable ? '' : getString(value);
+    let result = false;
+    if (nodes != null) {
+        replaceNodes(nodes, [isNullable ? comment : text]);
+        result = !isNullable;
+    }
+    else if (isNullable && comment.parentNode == null) {
+        text.replaceWith(comment);
+    }
+    else if (!isNullable && text.parentNode == null) {
+        comment.replaceWith(text);
+        result = true;
+    }
+    removeFragments(fragments);
+    return result ? [text] : undefined;
+}
+
+const commentExpression = /^abydon\.(\d+)$/;
+function mapNode(data, comment) {
+    const matches = commentExpression.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) {
+    const { length } = data.strings;
+    let template = '';
+    for (let index = 0; index < length; index += 1) {
+        template += handleExpression(data, data.strings[index], data.expressions[index]);
+    }
+    return template;
+}
+
+class Fragment {
+    $fragment = true;
+    data;
+    get identifier() {
+        return this.data.identifier;
+    }
+    constructor(strings, expressions) {
+        this.data = {
+            expressions,
+            strings,
+            items: [],
+            mora: {
+                subscribers: new Set(),
+                values: new Set(),
+            },
+            values: [],
+        };
+    }
+    /**
+     * Appends the fragment to the given element
+     */
+    appendTo(element) {
+        element.append(...this.get());
+    }
+    /**
+     * Gets a list of the fragment's nodes
+     */
+    get() {
+        if (this.data.items.length === 0) {
+            const parsed = parse(this.data);
+            const templated = html$1(parsed, {
+                sanitizeBooleanAttributes: false,
+            });
+            this.data.items.splice(0, this.data.items.length, ...templated.map(node => ({
+                nodes: [node],
+            })));
+            mapNodes(this.data, this.data.items.flatMap(item => item.fragments?.flatMap(fragment => fragment.get()) ?? item.nodes));
+        }
+        return [
+            ...this.data.items.flatMap(item => item.fragments?.flatMap(fragment => fragment.get()) ?? item.nodes),
+        ];
+    }
+    identify(identifier) {
+        this.data.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 ?? [];
+        for (let index = 0; index < length; index += 1) {
+            fragments?.[index]?.remove();
+        }
+        removeNodes(nodes);
+    }
+    data.items.splice(0, length);
+}
+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 };