@hyperfixi/core 3.3.0 → 4.0.1

package/dist/behaviors/index.mjs

@@ -1,1145 +0,0 @@
-function ensureDomGlobals() {
-    if (typeof globalThis.Element === 'undefined') {
-        globalThis.Element = class {
-        };
-    }
-    return true;
-}
-ensureDomGlobals();
-
-// src/morphlex.ts
-var SUPPORTS_MOVE_BEFORE = "moveBefore" in Element.prototype;
-var ELEMENT_NODE_TYPE = 1;
-var TEXT_NODE_TYPE = 3;
-var IS_PARENT_NODE_TYPE = [
-  0,
-  1,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  1,
-  0,
-  1,
-  0
-];
-var Operation = {
-  EqualNode: 0,
-  SameElement: 1,
-  SameNode: 2
-};
-var candidateNodes = new Set;
-var candidateElements = new Set;
-var candidateElementsWithIds = new Set;
-var unmatchedNodes = new Set;
-var unmatchedElements = new Set;
-var whitespaceNodes = new Set;
-function morph(from, to, options = {}) {
-  if (typeof to === "string")
-    to = parseFragment(to).childNodes;
-  if (!options.preserveChanges && isParentNode(from))
-    flagDirtyInputs(from);
-  new Morph(options).morph(from, to);
-}
-function morphInner(from, to, options = {}) {
-  if (typeof to === "string") {
-    const fragment = parseFragment(to);
-    if (fragment.firstChild && fragment.childNodes.length === 1 && fragment.firstChild.nodeType === ELEMENT_NODE_TYPE) {
-      to = fragment.firstChild;
-    } else {
-      throw new Error("[Morphlex] The string was not a valid HTML element.");
-    }
-  }
-  if (from.nodeType === ELEMENT_NODE_TYPE && to.nodeType === ELEMENT_NODE_TYPE && from.localName === to.localName) {
-    if (isParentNode(from))
-      flagDirtyInputs(from);
-    new Morph(options).visitChildNodes(from, to);
-  } else {
-    throw new Error("[Morphlex] You can only do an inner morph with matching elements.");
-  }
-}
-function flagDirtyInputs(node) {
-  for (const input of node.querySelectorAll("input")) {
-    if (input.name && input.value !== input.defaultValue || input.checked !== input.defaultChecked) {
-      input.setAttribute("morphlex-dirty", "");
-    }
-  }
-  for (const element of node.querySelectorAll("option")) {
-    if (element.value && element.selected !== element.defaultSelected) {
-      element.setAttribute("morphlex-dirty", "");
-    }
-  }
-  for (const element of node.querySelectorAll("textarea")) {
-    if (element.value !== element.defaultValue) {
-      element.setAttribute("morphlex-dirty", "");
-    }
-  }
-}
-function parseFragment(string) {
-  const template = document.createElement("template");
-  template.innerHTML = string.trim();
-  return template.content;
-}
-function moveBefore(parent, node, insertionPoint) {
-  if (node === insertionPoint)
-    return;
-  if (node.parentNode === parent) {
-    if (node.nextSibling === insertionPoint)
-      return;
-    if (SUPPORTS_MOVE_BEFORE) {
-      parent.moveBefore(node, insertionPoint);
-      return;
-    }
-  }
-  parent.insertBefore(node, insertionPoint);
-}
-
-class Morph {
-  #idArrayMap = new WeakMap;
-  #idSetMap = new WeakMap;
-  #options;
-  constructor(options = {}) {
-    this.#options = options;
-  }
-  morph(from, to) {
-    if (isParentNode(from)) {
-      this.#mapIdSets(from);
-    }
-    if (to instanceof NodeList) {
-      this.#mapIdArraysForEach(to);
-      this.#morphOneToMany(from, to);
-    } else if (isParentNode(to)) {
-      this.#mapIdArrays(to);
-      this.#morphOneToOne(from, to);
-    }
-  }
-  #morphOneToMany(from, to) {
-    const length = to.length;
-    if (length === 0) {
-      this.#removeNode(from);
-    } else if (length === 1) {
-      this.#morphOneToOne(from, to[0]);
-    } else if (length > 1) {
-      const newNodes = [...to];
-      this.#morphOneToOne(from, newNodes.shift());
-      const insertionPoint = from.nextSibling;
-      const parent = from.parentNode || document;
-      for (let i = 0;i < newNodes.length; i++) {
-        const newNode = newNodes[i];
-        if (this.#options.beforeNodeAdded?.(parent, newNode, insertionPoint) ?? true) {
-          parent.insertBefore(newNode, insertionPoint);
-          this.#options.afterNodeAdded?.(newNode);
-        }
-      }
-    }
-  }
-  #morphOneToOne(from, to) {
-    if (from === to)
-      return;
-    if (from.isEqualNode(to))
-      return;
-    if (from.nodeType === ELEMENT_NODE_TYPE && to.nodeType === ELEMENT_NODE_TYPE) {
-      if (from.localName === to.localName) {
-        this.#morphMatchingElements(from, to);
-      } else {
-        this.#morphNonMatchingElements(from, to);
-      }
-    } else {
-      this.#morphOtherNode(from, to);
-    }
-  }
-  #morphMatchingElements(from, to) {
-    if (!(this.#options.beforeNodeVisited?.(from, to) ?? true))
-      return;
-    if (from.hasAttributes() || to.hasAttributes()) {
-      this.#visitAttributes(from, to);
-    }
-    if (from.localName === "textarea" && to.localName === "textarea") {
-      this.#visitTextArea(from, to);
-    } else if (from.hasChildNodes() || to.hasChildNodes()) {
-      this.visitChildNodes(from, to);
-    }
-    this.#options.afterNodeVisited?.(from, to);
-  }
-  #morphNonMatchingElements(from, to) {
-    if (!(this.#options.beforeNodeVisited?.(from, to) ?? true))
-      return;
-    this.#replaceNode(from, to);
-    this.#options.afterNodeVisited?.(from, to);
-  }
-  #morphOtherNode(from, to) {
-    if (!(this.#options.beforeNodeVisited?.(from, to) ?? true))
-      return;
-    if (from.nodeType === to.nodeType && from.nodeValue !== null && to.nodeValue !== null) {
-      from.nodeValue = to.nodeValue;
-    } else {
-      this.#replaceNode(from, to);
-    }
-    this.#options.afterNodeVisited?.(from, to);
-  }
-  #visitAttributes(from, to) {
-    if (from.hasAttribute("morphlex-dirty")) {
-      from.removeAttribute("morphlex-dirty");
-    }
-    for (const { name, value } of to.attributes) {
-      if (name === "value") {
-        if (isInputElement(from) && from.value !== value) {
-          if (!this.#options.preserveChanges || from.value === from.defaultValue) {
-            from.value = value;
-          }
-        }
-      }
-      if (name === "selected") {
-        if (isOptionElement(from) && !from.selected) {
-          if (!this.#options.preserveChanges || from.selected === from.defaultSelected) {
-            from.selected = true;
-          }
-        }
-      }
-      if (name === "checked") {
-        if (isInputElement(from) && !from.checked) {
-          if (!this.#options.preserveChanges || from.checked === from.defaultChecked) {
-            from.checked = true;
-          }
-        }
-      }
-      const oldValue = from.getAttribute(name);
-      if (oldValue !== value && (this.#options.beforeAttributeUpdated?.(from, name, value) ?? true)) {
-        from.setAttribute(name, value);
-        this.#options.afterAttributeUpdated?.(from, name, oldValue);
-      }
-    }
-    for (const { name, value } of from.attributes) {
-      if (!to.hasAttribute(name)) {
-        if (name === "selected") {
-          if (isOptionElement(from) && from.selected) {
-            if (!this.#options.preserveChanges || from.selected === from.defaultSelected) {
-              from.selected = false;
-            }
-          }
-        }
-        if (name === "checked") {
-          if (isInputElement(from) && from.checked) {
-            if (!this.#options.preserveChanges || from.checked === from.defaultChecked) {
-              from.checked = false;
-            }
-          }
-        }
-        if (this.#options.beforeAttributeUpdated?.(from, name, null) ?? true) {
-          from.removeAttribute(name);
-          this.#options.afterAttributeUpdated?.(from, name, value);
-        }
-      }
-    }
-  }
-  #visitTextArea(from, to) {
-    const newTextContent = to.textContent || "";
-    const isModified = from.value !== from.defaultValue;
-    if (from.textContent !== newTextContent) {
-      from.textContent = newTextContent;
-    }
-    if (this.#options.preserveChanges && isModified)
-      return;
-    from.value = from.defaultValue;
-  }
-  visitChildNodes(from, to) {
-    if (!(this.#options.beforeChildrenVisited?.(from) ?? true))
-      return;
-    const parent = from;
-    const fromChildNodes = [...from.childNodes];
-    const toChildNodes = [...to.childNodes];
-    candidateNodes.clear();
-    candidateElements.clear();
-    candidateElementsWithIds.clear();
-    unmatchedNodes.clear();
-    unmatchedElements.clear();
-    whitespaceNodes.clear();
-    const matches = [];
-    const op = [];
-    const nodeTypeMap = [];
-    const candidateNodeTypeMap = [];
-    const localNameMap = [];
-    const candidateLocalNameMap = [];
-    for (let i = 0;i < fromChildNodes.length; i++) {
-      const candidate = fromChildNodes[i];
-      const nodeType = candidate.nodeType;
-      candidateNodeTypeMap[i] = nodeType;
-      if (nodeType === ELEMENT_NODE_TYPE) {
-        candidateLocalNameMap[i] = candidate.localName;
-        if (candidate.id !== "") {
-          candidateElementsWithIds.add(i);
-        } else {
-          candidateElements.add(i);
-        }
-      } else if (nodeType === TEXT_NODE_TYPE && candidate.textContent?.trim() === "") {
-        whitespaceNodes.add(i);
-      } else {
-        candidateNodes.add(i);
-      }
-    }
-    for (let i = 0;i < toChildNodes.length; i++) {
-      const node = toChildNodes[i];
-      const nodeType = node.nodeType;
-      nodeTypeMap[i] = nodeType;
-      if (nodeType === ELEMENT_NODE_TYPE) {
-        localNameMap[i] = node.localName;
-        unmatchedElements.add(i);
-      } else if (nodeType === TEXT_NODE_TYPE && node.textContent?.trim() === "") {
-        continue;
-      } else {
-        unmatchedNodes.add(i);
-      }
-    }
-    for (const unmatchedIndex of unmatchedElements) {
-      const localName = localNameMap[unmatchedIndex];
-      const element = toChildNodes[unmatchedIndex];
-      for (const candidateIndex of candidateElements) {
-        if (localName !== candidateLocalNameMap[candidateIndex])
-          continue;
-        const candidate = fromChildNodes[candidateIndex];
-        if (candidate.isEqualNode(element)) {
-          matches[unmatchedIndex] = candidateIndex;
-          op[unmatchedIndex] = Operation.EqualNode;
-          candidateElements.delete(candidateIndex);
-          unmatchedElements.delete(unmatchedIndex);
-          break;
-        }
-      }
-    }
-    for (const unmatchedIndex of unmatchedElements) {
-      const element = toChildNodes[unmatchedIndex];
-      const id = element.id;
-      const idArray = this.#idArrayMap.get(element);
-      if (id === "" && !idArray)
-        continue;
-      candidateLoop:
-        for (const candidateIndex of candidateElementsWithIds) {
-          const candidate = fromChildNodes[candidateIndex];
-          if (localNameMap[unmatchedIndex] === candidateLocalNameMap[candidateIndex]) {
-            if (id !== "" && id === candidate.id) {
-              matches[unmatchedIndex] = candidateIndex;
-              op[unmatchedIndex] = Operation.SameElement;
-              candidateElementsWithIds.delete(candidateIndex);
-              unmatchedElements.delete(unmatchedIndex);
-              break candidateLoop;
-            }
-            if (idArray) {
-              const candidateIdSet = this.#idSetMap.get(candidate);
-              if (candidateIdSet) {
-                for (let i = 0;i < idArray.length; i++) {
-                  const arrayId = idArray[i];
-                  if (candidateIdSet.has(arrayId)) {
-                    matches[unmatchedIndex] = candidateIndex;
-                    op[unmatchedIndex] = Operation.SameElement;
-                    candidateElementsWithIds.delete(candidateIndex);
-                    unmatchedElements.delete(unmatchedIndex);
-                    break candidateLoop;
-                  }
-                }
-              }
-            }
-          }
-        }
-    }
-    for (const unmatchedIndex of unmatchedElements) {
-      const element = toChildNodes[unmatchedIndex];
-      const name = element.getAttribute("name");
-      const href = element.getAttribute("href");
-      const src = element.getAttribute("src");
-      for (const candidateIndex of candidateElements) {
-        const candidate = fromChildNodes[candidateIndex];
-        if (localNameMap[unmatchedIndex] === candidateLocalNameMap[candidateIndex] && (name && name === candidate.getAttribute("name") || href && href === candidate.getAttribute("href") || src && src === candidate.getAttribute("src"))) {
-          matches[unmatchedIndex] = candidateIndex;
-          op[unmatchedIndex] = Operation.SameElement;
-          candidateElements.delete(candidateIndex);
-          unmatchedElements.delete(unmatchedIndex);
-          break;
-        }
-      }
-    }
-    for (const unmatchedIndex of unmatchedElements) {
-      const element = toChildNodes[unmatchedIndex];
-      const localName = localNameMap[unmatchedIndex];
-      for (const candidateIndex of candidateElements) {
-        const candidate = fromChildNodes[candidateIndex];
-        const candidateLocalName = candidateLocalNameMap[candidateIndex];
-        if (localName === candidateLocalName) {
-          if (localName === "input" && candidate.type !== element.type) {
-            continue;
-          }
-          matches[unmatchedIndex] = candidateIndex;
-          op[unmatchedIndex] = Operation.SameElement;
-          candidateElements.delete(candidateIndex);
-          unmatchedElements.delete(unmatchedIndex);
-          break;
-        }
-      }
-    }
-    for (const unmatchedIndex of unmatchedNodes) {
-      const node = toChildNodes[unmatchedIndex];
-      for (const candidateIndex of candidateNodes) {
-        const candidate = fromChildNodes[candidateIndex];
-        if (candidate.isEqualNode(node)) {
-          matches[unmatchedIndex] = candidateIndex;
-          op[unmatchedIndex] = Operation.EqualNode;
-          candidateNodes.delete(candidateIndex);
-          unmatchedNodes.delete(unmatchedIndex);
-          break;
-        }
-      }
-    }
-    for (const unmatchedIndex of unmatchedNodes) {
-      const nodeType = nodeTypeMap[unmatchedIndex];
-      for (const candidateIndex of candidateNodes) {
-        if (nodeType === candidateNodeTypeMap[candidateIndex]) {
-          matches[unmatchedIndex] = candidateIndex;
-          op[unmatchedIndex] = Operation.SameNode;
-          candidateNodes.delete(candidateIndex);
-          unmatchedNodes.delete(unmatchedIndex);
-          break;
-        }
-      }
-    }
-    for (const i of candidateNodes)
-      this.#removeNode(fromChildNodes[i]);
-    for (const i of whitespaceNodes)
-      this.#removeNode(fromChildNodes[i]);
-    for (const i of candidateElements)
-      this.#removeNode(fromChildNodes[i]);
-    for (const i of candidateElementsWithIds)
-      this.#removeNode(fromChildNodes[i]);
-    const lisIndices = longestIncreasingSubsequence(matches);
-    const shouldNotMove = new Array(fromChildNodes.length);
-    for (let i = 0;i < lisIndices.length; i++) {
-      shouldNotMove[matches[lisIndices[i]]] = true;
-    }
-    let insertionPoint = parent.firstChild;
-    for (let i = 0;i < toChildNodes.length; i++) {
-      const node = toChildNodes[i];
-      const matchInd = matches[i];
-      if (matchInd !== undefined) {
-        const match = fromChildNodes[matchInd];
-        const operation = op[i];
-        if (!shouldNotMove[matchInd]) {
-          moveBefore(parent, match, insertionPoint);
-        }
-        if (operation === Operation.EqualNode) ; else if (operation === Operation.SameElement) {
-          this.#morphMatchingElements(match, node);
-        } else {
-          this.#morphOneToOne(match, node);
-        }
-        insertionPoint = match.nextSibling;
-      } else {
-        if (this.#options.beforeNodeAdded?.(parent, node, insertionPoint) ?? true) {
-          parent.insertBefore(node, insertionPoint);
-          this.#options.afterNodeAdded?.(node);
-          insertionPoint = node.nextSibling;
-        }
-      }
-    }
-    this.#options.afterChildrenVisited?.(from);
-  }
-  #replaceNode(node, newNode) {
-    const parent = node.parentNode || document;
-    const insertionPoint = node;
-    if ((this.#options.beforeNodeRemoved?.(node) ?? true) && (this.#options.beforeNodeAdded?.(parent, newNode, insertionPoint) ?? true)) {
-      parent.insertBefore(newNode, insertionPoint);
-      this.#options.afterNodeAdded?.(newNode);
-      node.remove();
-      this.#options.afterNodeRemoved?.(node);
-    }
-  }
-  #removeNode(node) {
-    if (this.#options.beforeNodeRemoved?.(node) ?? true) {
-      node.remove();
-      this.#options.afterNodeRemoved?.(node);
-    }
-  }
-  #mapIdArraysForEach(nodeList) {
-    for (const childNode of nodeList) {
-      if (isParentNode(childNode)) {
-        this.#mapIdArrays(childNode);
-      }
-    }
-  }
-  #mapIdArrays(node) {
-    const idArrayMap = this.#idArrayMap;
-    for (const element of node.querySelectorAll("[id]")) {
-      const id = element.id;
-      if (id === "")
-        continue;
-      let currentElement = element;
-      while (currentElement) {
-        const idArray = idArrayMap.get(currentElement);
-        if (idArray) {
-          idArray.push(id);
-        } else {
-          idArrayMap.set(currentElement, [id]);
-        }
-        if (currentElement === node)
-          break;
-        currentElement = currentElement.parentElement;
-      }
-    }
-  }
-  #mapIdSets(node) {
-    const idSetMap = this.#idSetMap;
-    for (const element of node.querySelectorAll("[id]")) {
-      const id = element.id;
-      if (id === "")
-        continue;
-      let currentElement = element;
-      while (currentElement) {
-        const idSet = idSetMap.get(currentElement);
-        if (idSet) {
-          idSet.add(id);
-        } else {
-          idSetMap.set(currentElement, new Set([id]));
-        }
-        if (currentElement === node)
-          break;
-        currentElement = currentElement.parentElement;
-      }
-    }
-  }
-}
-function isInputElement(element) {
-  return element.localName === "input";
-}
-function isOptionElement(element) {
-  return element.localName === "option";
-}
-function isParentNode(node) {
-  return !!IS_PARENT_NODE_TYPE[node.nodeType];
-}
-function longestIncreasingSubsequence(sequence) {
-  const n = sequence.length;
-  if (n === 0)
-    return [];
-  const smallestEnding = [];
-  const indices = [];
-  const prev = new Array(n);
-  for (let i = 0;i < n; i++) {
-    const val = sequence[i];
-    if (val === undefined)
-      continue;
-    let left = 0;
-    let right = smallestEnding.length;
-    while (left < right) {
-      const mid = Math.floor((left + right) / 2);
-      if (smallestEnding[mid] < val)
-        left = mid + 1;
-      else
-        right = mid;
-    }
-    prev[i] = left > 0 ? indices[left - 1] : -1;
-    if (left === smallestEnding.length) {
-      smallestEnding.push(val);
-      indices.push(i);
-    } else {
-      smallestEnding[left] = val;
-      indices[left] = i;
-    }
-  }
-  const result = [];
-  if (indices.length === 0)
-    return result;
-  let curr = indices[indices.length - 1];
-  while (curr !== undefined && curr !== -1) {
-    result.unshift(curr);
-    curr = prev[curr];
-  }
-  return result;
-}
-
-//# debugId=3F4BCB911DEC843864756E2164756E21
-
-function toMorphlexOptions(options) {
-    return { preserveChanges: (options?.preserveChanges ?? true) };
-}
-const morphAdapter = {
-    morph(target, content, options) {
-        morph(target, content, toMorphlexOptions(options));
-    },
-    morphInner(target, content, options) {
-        let contentEl;
-        if (typeof content === 'string') {
-            const wrapper = document.createElement(target.tagName);
-            wrapper.innerHTML = content;
-            contentEl = wrapper;
-        }
-        else {
-            contentEl = content;
-        }
-        morphInner(target, contentEl, toMorphlexOptions(options));
-    },
-};
-
-function getStartViewTransition() {
-    if (typeof document === 'undefined')
-        return undefined;
-    const fn = document
-        .startViewTransition;
-    return typeof fn === 'function' ? fn.bind(document) : undefined;
-}
-function isViewTransitionsSupported() {
-    return typeof getStartViewTransition() === 'function';
-}
-const queue = [];
-let processing = false;
-async function runOne(callback, options) {
-    const start = getStartViewTransition();
-    if (!start) {
-        await callback();
-        return;
-    }
-    const update = async () => {
-        await callback();
-    };
-    let transition;
-    if (options?.transitionName) {
-        try {
-            transition = start({
-                update,
-                types: [options.transitionName],
-            });
-        }
-        catch {
-            transition = start(update);
-        }
-    }
-    else {
-        transition = start(update);
-    }
-    await transition.finished;
-}
-async function drain() {
-    if (processing)
-        return;
-    processing = true;
-    try {
-        while (queue.length > 0) {
-            const item = queue.shift();
-            try {
-                await runOne(item.callback, item.options);
-                item.resolve();
-            }
-            catch (error) {
-                item.reject(error);
-            }
-        }
-    }
-    finally {
-        processing = false;
-    }
-}
-function withViewTransition(callback, options) {
-    return new Promise((resolve, reject) => {
-        queue.push({ callback, options, resolve, reject });
-        drain().catch(reject);
-    });
-}
-
-function isHTMLElement(value) {
-    return (value !== null &&
-        typeof value === 'object' &&
-        'nodeType' in value &&
-        value.nodeType === 1 &&
-        'tagName' in value &&
-        typeof value.tagName === 'string' &&
-        'classList' in value);
-}
-
-function loneRootWithTag(content, tagName) {
-    let root;
-    if (typeof content === 'string') {
-        const template = document.createElement('template');
-        template.innerHTML = content;
-        root = template.content.firstElementChild;
-        if (!root || root.nextElementSibling)
-            return null;
-    }
-    else {
-        root = content.cloneNode(true);
-    }
-    return root.tagName === tagName && isHTMLElement(root) ? root : null;
-}
-function executeSwap(target, content, strategy, morphOptions) {
-    const contentStr = content !== null && !isHTMLElement(content) ? content : '';
-    const contentEl = isHTMLElement(content) ? content : null;
-    switch (strategy) {
-        case 'morphMerge': {
-            const root = content !== null ? loneRootWithTag(content, target.tagName) : null;
-            executeSwap(target, root ?? content, root ? 'morphOuter' : 'morph', morphOptions);
-            break;
-        }
-        case 'morph':
-            if (content !== null) {
-                try {
-                    morphAdapter.morphInner(target, contentEl || contentStr, morphOptions);
-                }
-                catch (error) {
-                    console.warn('[HyperFixi] Morph failed, falling back to innerHTML:', error);
-                    if (contentEl) {
-                        target.innerHTML = '';
-                        target.appendChild(contentEl);
-                    }
-                    else {
-                        target.innerHTML = contentStr;
-                    }
-                }
-            }
-            break;
-        case 'morphOuter':
-            if (content !== null) {
-                try {
-                    morphAdapter.morph(target, contentEl || contentStr, morphOptions);
-                }
-                catch (error) {
-                    console.warn('[HyperFixi] Morph failed, falling back to outerHTML:', error);
-                    if (contentEl) {
-                        target.replaceWith(contentEl);
-                    }
-                    else {
-                        target.outerHTML = contentStr;
-                    }
-                }
-            }
-            break;
-        case 'innerHTML':
-            if (contentEl) {
-                target.innerHTML = '';
-                target.appendChild(contentEl);
-            }
-            else {
-                target.innerHTML = contentStr;
-            }
-            break;
-        case 'outerHTML':
-            if (contentEl) {
-                target.replaceWith(contentEl);
-            }
-            else {
-                target.outerHTML = contentStr;
-            }
-            break;
-        case 'beforeBegin':
-            if (contentEl) {
-                target.parentElement?.insertBefore(contentEl, target);
-            }
-            else {
-                target.insertAdjacentHTML('beforebegin', contentStr);
-            }
-            break;
-        case 'afterBegin':
-            if (contentEl) {
-                target.insertBefore(contentEl, target.firstChild);
-            }
-            else {
-                target.insertAdjacentHTML('afterbegin', contentStr);
-            }
-            break;
-        case 'beforeEnd':
-            if (contentEl) {
-                target.appendChild(contentEl);
-            }
-            else {
-                target.insertAdjacentHTML('beforeend', contentStr);
-            }
-            break;
-        case 'afterEnd':
-            if (contentEl) {
-                target.parentElement?.insertBefore(contentEl, target.nextSibling);
-            }
-            else {
-                target.insertAdjacentHTML('afterend', contentStr);
-            }
-            break;
-        case 'delete':
-            target.remove();
-            break;
-        case 'none':
-            break;
-        default:
-            throw new Error(`[HyperFixi] swap: unknown strategy "${strategy}"`);
-    }
-}
-async function executeSwapWithTransition(targets, content, strategy, options = {}) {
-    const { morphOptions, useViewTransition = false } = options;
-    const performSwap = () => {
-        for (const target of targets) {
-            executeSwap(target, content, strategy, morphOptions);
-        }
-    };
-    if (useViewTransition && isViewTransitionsSupported()) {
-        await withViewTransition(performSwap);
-    }
-    else {
-        performSwap();
-    }
-}
-
-function createCustomEvent(eventName, detail, options = {}) {
-    return new CustomEvent(eventName, {
-        detail: detail !== undefined ? detail : {},
-        bubbles: options.bubbles !== undefined ? options.bubbles : true,
-        cancelable: options.cancelable !== undefined ? options.cancelable : true,
-        composed: options.composed !== undefined ? options.composed : false,
-    });
-}
-function dispatchCustomEvent(target, eventName, detail = {}, options = {}) {
-    const event = createCustomEvent(eventName, detail, options);
-    target.dispatchEvent(event);
-    return event;
-}
-function dispatchLokaScriptEvent(target, eventName, detail = {}, options = {}) {
-    const lokascriptEvent = dispatchCustomEvent(target, `lokascript:${eventName}`, detail, options);
-    const hyperfixiEvent = dispatchCustomEvent(target, `hyperfixi:${eventName}`, detail, options);
-    return {
-        lokascript: lokascriptEvent,
-        hyperfixi: hyperfixiEvent,
-    };
-}
-
-function createHistorySwap(config) {
-    const { target, strategy = 'morph', useViewTransition = false, fetchOptions = {}, transformUrl, onBeforeFetch, onAfterSwap, onError, } = config;
-    const resolveTarget = () => {
-        if (typeof target === 'string') {
-            const element = document.querySelector(target);
-            return isHTMLElement(element) ? element : null;
-        }
-        return isHTMLElement(target) ? target : null;
-    };
-    const handlePopstate = async (_event) => {
-        const targetElement = resolveTarget();
-        if (!targetElement) {
-            console.warn(`HistorySwap: target "${target}" not found`);
-            return;
-        }
-        let url = window.location.href;
-        if (transformUrl) {
-            url = transformUrl(url);
-        }
-        try {
-            if (onBeforeFetch) {
-                await onBeforeFetch(url);
-            }
-            targetElement.classList.add('hx-swapping');
-            const response = await fetch(url, {
-                method: 'GET',
-                headers: {
-                    Accept: 'text/html',
-                    'HX-Request': 'true',
-                    'HX-History-Restore-Request': 'true',
-                },
-                ...fetchOptions,
-            });
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-            }
-            const html = await response.text();
-            await executeSwapWithTransition([targetElement], html, strategy, { useViewTransition });
-            targetElement.classList.remove('hx-swapping');
-            if (onAfterSwap) {
-                await onAfterSwap(url, html);
-            }
-            dispatchLokaScriptEvent(window, 'historyswap', { url, strategy, target });
-        }
-        catch (error) {
-            targetElement.classList.remove('hx-swapping');
-            if (onError) {
-                onError(error, url);
-            }
-            else {
-                console.error('HistorySwap fetch failed:', error);
-            }
-        }
-    };
-    window.addEventListener('popstate', handlePopstate);
-    return {
-        destroy: () => {
-            window.removeEventListener('popstate', handlePopstate);
-        },
-        config,
-    };
-}
-const HistorySwapBehavior = {
-    name: 'HistorySwap',
-    init(element, params = {}) {
-        const config = {
-            target: params.target || element,
-            strategy: params.strategy || 'morph',
-            useViewTransition: Boolean(params.useViewTransition),
-        };
-        return createHistorySwap(config);
-    },
-    destroy(instance) {
-        instance.destroy();
-    },
-};
-function registerHistorySwap(registry) {
-    if (registry instanceof Map) {
-        registry.set('HistorySwap', HistorySwapBehavior);
-    }
-    else if (registry && typeof registry.set === 'function') {
-        registry.set('HistorySwap', HistorySwapBehavior);
-    }
-    else if (registry && typeof registry === 'object') {
-        registry['HistorySwap'] = HistorySwapBehavior;
-    }
-}
-const historySwapHyperscript = `
-behavior HistorySwap(target, strategy)
-  init
-    if no target then set target to me end
-    if no strategy then set strategy to 'morph' end
-  end
-
-  on popstate from window
-    add .hx-swapping to target
-    fetch location.href as html
-    if strategy is 'morph' then
-      swap target with it
-    else if strategy is 'innerHTML' then
-      swap innerHTML of target with it
-    else
-      swap target with it
-    end
-    remove .hx-swapping from target
-  end
-end
-`;
-
-function isExternalUrl(url) {
-    try {
-        const parsed = new URL(url, window.location.origin);
-        return parsed.origin !== window.location.origin;
-    }
-    catch {
-        return false;
-    }
-}
-
-function shouldBoostLink(link) {
-    if (isExternalUrl(link.href)) {
-        return false;
-    }
-    if (link.target && link.target !== '_self') {
-        return false;
-    }
-    if (link.hasAttribute('download')) {
-        return false;
-    }
-    if (link.hasAttribute('data-no-boost') || link.hasAttribute('hx-boost-off')) {
-        return false;
-    }
-    if (link.protocol === 'javascript:' || link.protocol === 'mailto:') {
-        return false;
-    }
-    return true;
-}
-function shouldHandleClick(event) {
-    if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) {
-        return false;
-    }
-    if (event.button !== 0) {
-        return false;
-    }
-    return true;
-}
-function createBoosted(config) {
-    const { container, target, linkSelector = 'a[href]', formSelector = 'form', boostForms = false, strategy = 'morph', pushUrl = true, useViewTransition = false, fetchOptions = {}, onBeforeFetch, onAfterSwap, onError, } = config;
-    const resolveTarget = () => {
-        if (!target) {
-            return document.body;
-        }
-        if (typeof target === 'string') {
-            const element = document.querySelector(target);
-            return isHTMLElement(element) ? element : null;
-        }
-        return isHTMLElement(target) ? target : null;
-    };
-    const boost = async (url, method = 'GET', body = null) => {
-        const targetElement = resolveTarget();
-        if (!targetElement) {
-            console.warn(`Boosted: target "${target}" not found`);
-            return;
-        }
-        try {
-            if (onBeforeFetch) {
-                const result = await onBeforeFetch(url, method);
-                if (result === false) {
-                    return;
-                }
-            }
-            targetElement.classList.add('hx-swapping');
-            container.classList.add('hx-boosting');
-            const requestInit = {
-                method,
-                headers: {
-                    Accept: 'text/html',
-                    'HX-Request': 'true',
-                    'HX-Boosted': 'true',
-                },
-                ...fetchOptions,
-            };
-            if (body && method !== 'GET') {
-                requestInit.body = body;
-            }
-            const response = await fetch(url, requestInit);
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-            }
-            const html = await response.text();
-            await executeSwapWithTransition([targetElement], html, strategy, { useViewTransition });
-            targetElement.classList.remove('hx-swapping');
-            container.classList.remove('hx-boosting');
-            if (pushUrl && method === 'GET') {
-                window.history.pushState(null, '', url);
-            }
-            if (onAfterSwap) {
-                await onAfterSwap(url, html);
-            }
-            dispatchLokaScriptEvent(window, 'boosted', { url, method, strategy, target });
-        }
-        catch (error) {
-            targetElement.classList.remove('hx-swapping');
-            container.classList.remove('hx-boosting');
-            if (onError) {
-                onError(error, url);
-            }
-            else {
-                console.error('Boosted fetch failed:', error);
-                window.location.href = url;
-            }
-        }
-    };
-    const handleClick = async (event) => {
-        const link = event.target.closest(linkSelector);
-        if (!link) {
-            return;
-        }
-        if (!shouldHandleClick(event)) {
-            return;
-        }
-        if (!shouldBoostLink(link)) {
-            return;
-        }
-        event.preventDefault();
-        event.stopPropagation();
-        await boost(link.href);
-    };
-    const handleSubmit = async (event) => {
-        if (!boostForms) {
-            return;
-        }
-        const form = event.target.closest(formSelector);
-        if (!form) {
-            return;
-        }
-        if (form.hasAttribute('data-no-boost') || form.hasAttribute('hx-boost-off')) {
-            return;
-        }
-        if (form.target && form.target !== '_self') {
-            return;
-        }
-        event.preventDefault();
-        event.stopPropagation();
-        const method = (form.method || 'GET').toUpperCase();
-        const formData = new FormData(form);
-        let url;
-        let body = null;
-        if (method === 'GET') {
-            const params = new URLSearchParams();
-            formData.forEach((value, key) => {
-                params.append(key, String(value));
-            });
-            url = `${form.action || window.location.pathname}?${params.toString()}`;
-        }
-        else {
-            url = form.action || window.location.pathname;
-            body = formData;
-        }
-        await boost(url, method, body);
-    };
-    container.addEventListener('click', handleClick);
-    if (boostForms) {
-        container.addEventListener('submit', handleSubmit);
-    }
-    return {
-        destroy: () => {
-            container.removeEventListener('click', handleClick);
-            container.removeEventListener('submit', handleSubmit);
-        },
-        config,
-        boost,
-    };
-}
-const BoostedBehavior = {
-    name: 'Boosted',
-    init(element, params = {}) {
-        const config = {
-            container: element,
-            target: params.target,
-            linkSelector: params.linkSelector || 'a[href]',
-            formSelector: params.formSelector || 'form',
-            boostForms: Boolean(params.boostForms),
-            strategy: params.strategy || 'morph',
-            pushUrl: params.pushUrl !== false,
-            useViewTransition: Boolean(params.useViewTransition),
-        };
-        return createBoosted(config);
-    },
-    destroy(instance) {
-        instance.destroy();
-    },
-};
-function registerBoosted(registry) {
-    if (registry instanceof Map) {
-        registry.set('Boosted', BoostedBehavior);
-    }
-    else if (registry && typeof registry.set === 'function') {
-        registry.set('Boosted', BoostedBehavior);
-    }
-    else if (registry && typeof registry === 'object') {
-        registry['Boosted'] = BoostedBehavior;
-    }
-}
-const boostedHyperscript = `
-behavior Boosted(target, pushHistory)
-  init
-    if no target then set target to document.body end
-    if no pushHistory then set pushHistory to true end
-  end
-
-  on click from <a[href]/> in me
-    -- Skip if modifier keys pressed
-    if event.metaKey or event.ctrlKey or event.shiftKey or event.altKey then exit end
-
-    -- Skip external links
-    set href to the @href of the target
-    if href starts with 'http' and not (href starts with location.origin) then exit end
-
-    -- Skip links with target attribute
-    if the target has @target then exit end
-
-    halt the event
-    add .hx-swapping to target
-    fetch href as html
-    swap target with it
-    remove .hx-swapping from target
-    if pushHistory then push url href end
-  end
-end
-`;
-
-function registerAllBehaviors(registry) {
-    registerHistorySwap(registry);
-    registerBoosted(registry);
-}
-
-export { BoostedBehavior, HistorySwapBehavior, boostedHyperscript, createBoosted, createHistorySwap, historySwapHyperscript, registerAllBehaviors, registerBoosted, registerHistorySwap };
-//# sourceMappingURL=index.mjs.map