@marko/runtime-tags 0.1.1

package/dist/dom.js

@@ -0,0 +1,904 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+
+// src/dom.ts
+var dom_exports = {};
+__export(dom_exports, {
+  attr: () => attr,
+  attrs: () => attrs,
+  bindFunction: () => bindFunction,
+  bindRenderer: () => bindRenderer,
+  childClosures: () => childClosures,
+  classAttr: () => classAttr,
+  closure: () => closure,
+  conditional: () => conditional,
+  conditionalOnlyChild: () => conditionalOnlyChild,
+  createRenderer: () => createRenderer,
+  createScope: () => createScope,
+  createScopeWithRenderer: () => createScopeWithRenderer,
+  createTemplate: () => createTemplate,
+  data: () => data,
+  dynamicClosure: () => dynamicClosure,
+  dynamicSubscribers: () => dynamicSubscribers,
+  dynamicTagAttrs: () => dynamicTagAttrs,
+  getAbortSignal: () => getAbortSignal,
+  getRegisteredWithScope: () => getRegisteredWithScope,
+  html: () => html,
+  inChild: () => inChild,
+  inConditionalScope: () => inConditionalScope,
+  inLoopScope: () => inLoopScope,
+  init: () => init,
+  initValue: () => initValue,
+  intersection: () => intersection,
+  intersections: () => intersections,
+  lifecycle: () => lifecycle,
+  loopIn: () => loopIn,
+  loopOf: () => loopOf,
+  loopTo: () => loopTo,
+  nextTagId: () => nextTagId,
+  on: () => on,
+  patchConditionals: () => patchConditionals,
+  prepare: () => prepare,
+  props: () => props,
+  queueEffect: () => queueEffect,
+  queueSource: () => queueSource,
+  register: () => register,
+  registerSubscriber: () => registerSubscriber,
+  resetAbortSignal: () => resetAbortSignal,
+  run: () => run,
+  runEffects: () => runEffects,
+  scopeLookup: () => scopeLookup,
+  setTagVar: () => setTagVar,
+  styleAttr: () => styleAttr,
+  tagVarSignal: () => tagVarSignal,
+  value: () => value,
+  values: () => values,
+  write: () => write
+});
+module.exports = __toCommonJS(dom_exports);
+
+// src/dom/scope.ts
+function createScope($global) {
+  let scope = {};
+  return scope.o = !0, scope.$global = $global, scope;
+}
+var emptyScope = createScope({});
+function getEmptyScope(marker) {
+  return emptyScope.a = emptyScope.c = marker, emptyScope;
+}
+function write(scope, localIndex, value2) {
+  return scope[localIndex] !== value2 ? (scope[localIndex] = value2, 1) : 0;
+}
+function binder(bind) {
+  return (scope, value2) => {
+    scope.h ??= /* @__PURE__ */ new Map();
+    let bound = scope.h.get(value2);
+    return bound || (bound = bind(scope, value2), scope.h.set(value2, bound)), bound;
+  };
+}
+var bindRenderer = binder(
+  (ownerScope, renderer) => renderer && {
+    ...renderer,
+    i: ownerScope
+  }
+), bindFunction = binder(
+  (boundScope, fn) => fn.length ? function(...args) {
+    return fn.call(this, boundScope, ...args);
+  } : function() {
+    return fn.call(this, boundScope);
+  }
+);
+function destroyScope(scope) {
+  _destroyScope(scope), scope._?.f?.delete(scope);
+  let closureSignals = scope.p?.b;
+  if (closureSignals)
+    for (let signal of closureSignals)
+      signal.g?.(scope);
+  return scope;
+}
+function _destroyScope(scope) {
+  let cleanup = scope.f;
+  if (cleanup)
+    for (let instance of cleanup)
+      _destroyScope(instance);
+  let controllers = scope.j;
+  if (controllers)
+    for (let ctrl of controllers.values())
+      ctrl.abort();
+}
+function onDestroy(scope) {
+  let parentScope = scope._;
+  for (; parentScope && !parentScope.f?.has(scope); )
+    (parentScope.f ||= /* @__PURE__ */ new Set()).add(scope), scope = parentScope, parentScope = scope._;
+}
+function removeAndDestroyScope(scope) {
+  destroyScope(scope);
+  let current = scope.a, stop = scope.c.nextSibling;
+  for (; current !== stop; ) {
+    let next = current.nextSibling;
+    current.remove(), current = next;
+  }
+}
+function insertBefore(scope, parent, nextSibling) {
+  let current = scope.a, stop = scope.c.nextSibling;
+  for (; current !== stop; ) {
+    let next = current.nextSibling;
+    parent.insertBefore(current, nextSibling), current = next;
+  }
+}
+
+// src/dom/reconcile-longest-increasing-subsequence.ts
+var WRONG_POS = 2147483647;
+function reconcile(parent, oldScopes, newScopes, afterReference) {
+  let oldStart = 0, newStart = 0, oldEnd = oldScopes.length - 1, newEnd = newScopes.length - 1, oldStartScope = oldScopes[oldStart], newStartScope = newScopes[newStart], oldEndScope = oldScopes[oldEnd], newEndScope = newScopes[newEnd], i, j, k, nextSibling, oldScope, newScope;
+  outer: {
+    for (; oldStartScope === newStartScope; ) {
+      if (++oldStart, ++newStart, oldStart > oldEnd || newStart > newEnd)
+        break outer;
+      oldStartScope = oldScopes[oldStart], newStartScope = newScopes[newStart];
+    }
+    for (; oldEndScope === newEndScope; ) {
+      if (--oldEnd, --newEnd, oldStart > oldEnd || newStart > newEnd)
+        break outer;
+      oldEndScope = oldScopes[oldEnd], newEndScope = newScopes[newEnd];
+    }
+  }
+  if (oldStart > oldEnd) {
+    if (newStart <= newEnd) {
+      k = newEnd + 1, nextSibling = k < newScopes.length ? newScopes[k].a : afterReference;
+      do
+        insertBefore(newScopes[newStart++], parent, nextSibling);
+      while (newStart <= newEnd);
+    }
+  } else if (newStart > newEnd)
+    do
+      removeAndDestroyScope(oldScopes[oldStart++]);
+    while (oldStart <= oldEnd);
+  else {
+    let oldLength = oldEnd - oldStart + 1, newLength = newEnd - newStart + 1, aNullable = oldScopes, sources = new Array(newLength);
+    for (i = 0; i < newLength; ++i)
+      sources[i] = -1;
+    let pos = 0, synced = 0, keyIndex = /* @__PURE__ */ new Map();
+    for (j = newStart; j <= newEnd; ++j)
+      keyIndex.set(newScopes[j], j);
+    for (i = oldStart; i <= oldEnd && synced < newLength; ++i)
+      oldScope = oldScopes[i], j = keyIndex.get(oldScope), j !== void 0 && (pos = pos > j ? WRONG_POS : j, ++synced, newScope = newScopes[j], sources[j - newStart] = i, aNullable[i] = null);
+    if (oldLength === oldScopes.length && synced === 0) {
+      for (; newStart < newLength; ++newStart)
+        insertBefore(newScopes[newStart], parent, afterReference);
+      for (; oldStart < oldLength; ++oldStart)
+        removeAndDestroyScope(oldScopes[oldStart]);
+    } else {
+      for (i = oldLength - synced; i > 0; )
+        oldScope = aNullable[oldStart++], oldScope !== null && (removeAndDestroyScope(oldScope), i--);
+      if (pos === WRONG_POS) {
+        let seq = longestIncreasingSubsequence(sources);
+        for (j = seq.length - 1, k = newScopes.length, i = newLength - 1; i >= 0; --i)
+          sources[i] === -1 ? (pos = i + newStart, newScope = newScopes[pos++], nextSibling = pos < k ? newScopes[pos].a : afterReference, insertBefore(newScope, parent, nextSibling)) : j < 0 || i !== seq[j] ? (pos = i + newStart, newScope = newScopes[pos++], nextSibling = pos < k ? newScopes[pos].a : afterReference, insertBefore(newScope, parent, nextSibling)) : --j;
+      } else if (synced !== newLength)
+        for (k = newScopes.length, i = newLength - 1; i >= 0; --i)
+          sources[i] === -1 && (pos = i + newStart, newScope = newScopes[pos++], nextSibling = pos < k ? newScopes[pos].a : afterReference, insertBefore(newScope, parent, nextSibling));
+    }
+  }
+}
+function longestIncreasingSubsequence(a) {
+  let p = a.slice(), result = [];
+  result.push(0);
+  let u, v;
+  for (let i = 0, il = a.length; i < il; ++i) {
+    if (a[i] === -1)
+      continue;
+    let j = result[result.length - 1];
+    if (a[j] < a[i]) {
+      p[i] = j, result.push(i);
+      continue;
+    }
+    for (u = 0, v = result.length - 1; u < v; ) {
+      let c = (u + v) / 2 | 0;
+      a[result[c]] < a[i] ? u = c + 1 : v = c;
+    }
+    a[i] < a[result[u]] && (u > 0 && (p[i] = result[u - 1]), result[u] = i);
+  }
+  for (u = result.length, v = result[u - 1]; u-- > 0; )
+    result[u] = v, v = p[v];
+  return result;
+}
+
+// src/common/helpers.ts
+function classValue(value2) {
+  return toDelimitedString(value2, " ", stringifyClassObject);
+}
+function stringifyClassObject(name, value2) {
+  return isVoid(value2) ? "" : name;
+}
+function styleValue(value2) {
+  return toDelimitedString(value2, ";", stringifyStyleObject);
+}
+var NON_DIMENSIONAL = /^(--|ta|or|li|z)|n-c|i(do|nk|m|t)|w$|we/;
+function stringifyStyleObject(name, value2) {
+  return isVoid(value2) ? "" : (typeof value2 == "number" && value2 && !NON_DIMENSIONAL.test(name) && (value2 += "px"), `${name}:${value2}`);
+}
+function toDelimitedString(val, delimiter, stringify) {
+  switch (typeof val) {
+    case "string":
+      return val;
+    case "object":
+      if (val !== null) {
+        let result = "", curDelimiter = "";
+        if (Array.isArray(val))
+          for (let v of val) {
+            let part = toDelimitedString(v, delimiter, stringify);
+            part !== "" && (result += curDelimiter + part, curDelimiter = delimiter);
+          }
+        else
+          for (let name in val) {
+            let v = val[name], part = stringify(name, v);
+            part !== "" && (result += curDelimiter + part, curDelimiter = delimiter);
+          }
+        return result;
+      }
+  }
+  return "";
+}
+function isVoid(value2) {
+  return value2 == null || value2 === !1;
+}
+
+// src/dom/abort-signal.ts
+function resetAbortSignal(scope, id) {
+  let controllers = scope.j;
+  if (controllers) {
+    let ctrl = controllers.get(id);
+    ctrl && (ctrl.abort(), controllers.delete(id));
+  }
+}
+function getAbortSignal(scope, id) {
+  let controllers = scope.j ??= /* @__PURE__ */ new Map(), controller = controllers.get(id);
+  return controller || (onDestroy(scope), controllers.set(id, controller = new AbortController())), controller.signal;
+}
+
+// src/dom/dom.ts
+function attr(element, name, value2) {
+  let normalizedValue = normalizeAttrValue(value2);
+  normalizedValue === void 0 ? element.removeAttribute(name) : element.setAttribute(name, normalizedValue);
+}
+function classAttr(element, value2) {
+  attr(element, "class", classValue(value2) || !1);
+}
+function styleAttr(element, value2) {
+  attr(element, "style", styleValue(value2) || !1);
+}
+function data(node, value2) {
+  let normalizedValue = normalizeString(value2);
+  node.data !== normalizedValue && (node.data = normalizedValue);
+}
+function attrs(scope, elementAccessor, nextAttrs) {
+  let prevAttrs = scope[elementAccessor + "~" /* PreviousAttributes */], element = scope[elementAccessor];
+  if (prevAttrs)
+    for (let name in prevAttrs)
+      nextAttrs && name in nextAttrs || element.removeAttribute(name);
+  for (let name in nextAttrs)
+    prevAttrs && nextAttrs[name] === prevAttrs[name] || (name === "class" ? classAttr(element, nextAttrs[name]) : name === "style" ? styleAttr(element, nextAttrs[name]) : name !== "renderBody" && attr(element, name, nextAttrs[name]));
+  scope[elementAccessor + "~" /* PreviousAttributes */] = nextAttrs;
+}
+var doc = document, parser = /* @__PURE__ */ doc.createElement("template");
+function html(scope, value2, index) {
+  let firstChild = scope[index], lastChild = scope[index + "-"] || firstChild, parentNode = firstChild.parentNode, afterReference = lastChild.nextSibling;
+  parser.innerHTML = value2 || value2 === 0 ? `${value2}` : "<!>";
+  let newContent = parser.content;
+  write(scope, index, newContent.firstChild), write(scope, index + "-", newContent.lastChild), parentNode.insertBefore(newContent, firstChild);
+  let current = firstChild;
+  for (; current !== afterReference; ) {
+    let next = current.nextSibling;
+    current.remove(), current = next;
+  }
+}
+function props(scope, nodeIndex, index) {
+  let nextProps = scope[index], prevProps = scope[index + "-"], node = scope[nodeIndex];
+  if (prevProps)
+    for (let name in prevProps)
+      name in nextProps || (node[name] = void 0);
+  for (let name in nextProps)
+    node[name] = nextProps[name];
+  scope[index + "-"] = nextProps;
+}
+function normalizeAttrValue(value2) {
+  if (value2 || value2 === 0)
+    return value2 === !0 ? "" : value2 + "";
+}
+function normalizeString(value2) {
+  return value2 || value2 === 0 ? value2 + "" : "\u200D";
+}
+function lifecycle(scope, index, thisObj) {
+  let instance = scope[index];
+  instance ? (Object.assign(instance, thisObj), instance.onUpdate?.()) : (scope[index] = thisObj, thisObj.onMount?.(), getAbortSignal(
+    scope,
+    "-" /* LifecycleAbortController */ + index
+  ).onabort = () => thisObj.onDestroy?.());
+}
+
+// src/dom/walker.ts
+var walker = /* @__PURE__ */ document.createTreeWalker(document);
+function trimWalkString(walkString) {
+  let end = walkString.length;
+  for (; walkString.charCodeAt(--end) > 47 /* BeginChild */; )
+    ;
+  return walkString.slice(0, end + 1);
+}
+function walk(startNode, walkCodes, scope) {
+  walker.currentNode = startNode, walkInternal(walkCodes, scope, 0), walker.currentNode = document.documentElement;
+}
+function walkInternal(walkCodes, scope, currentWalkIndex) {
+  let value2, storedMultiplier = 0, currentMultiplier = 0, currentScopeIndex = 0;
+  for (; value2 = walkCodes.charCodeAt(currentWalkIndex++); )
+    if (currentMultiplier = storedMultiplier, storedMultiplier = 0, value2 >= 117 /* Multiplier */)
+      storedMultiplier = currentMultiplier * 10 /* Multiplier */ + value2 - 117 /* Multiplier */;
+    else if (value2 >= 107 /* Out */) {
+      for (value2 = 10 /* Out */ * currentMultiplier + value2 - 107 /* Out */; value2--; )
+        walker.parentNode();
+      walker.nextSibling();
+    } else if (value2 >= 97 /* Over */)
+      for (value2 = 10 /* Over */ * currentMultiplier + value2 - 97 /* Over */; value2--; )
+        !walker.nextSibling() && walker.nextNode();
+    else if (value2 >= 67 /* Next */)
+      for (value2 = 20 /* Next */ * currentMultiplier + value2 - 67 /* Next */; value2--; )
+        walker.nextNode();
+    else if (value2 === 47 /* BeginChild */)
+      currentWalkIndex = walkInternal(
+        walkCodes,
+        scope[currentScopeIndex++] = createScope(scope.$global),
+        currentWalkIndex
+      );
+    else {
+      if (value2 === 38 /* EndChild */)
+        return currentWalkIndex;
+      if (value2 === 32 /* Get */)
+        scope[currentScopeIndex++] = walker.currentNode;
+      else {
+        let newNode = scope[currentScopeIndex++] = document.createTextNode(""), current = walker.currentNode, parentNode = current.parentNode;
+        value2 === 33 /* Before */ ? parentNode.insertBefore(newNode, current) : (value2 === 35 /* After */ ? parentNode.insertBefore(newNode, current.nextSibling) : parentNode.replaceChild(newNode, current), walker.currentNode = newNode);
+      }
+    }
+  return currentWalkIndex;
+}
+
+// src/dom/renderer.ts
+function createScopeWithRenderer(renderer, $global, ownerScope) {
+  let newScope = createScope($global);
+  if (newScope._ = renderer.i || ownerScope, newScope.p = renderer, initRenderer(renderer, newScope), renderer.b)
+    for (let signal of renderer.b)
+      signal.e?.(newScope);
+  return newScope;
+}
+function initRenderer(renderer, scope) {
+  let dom = typeof renderer == "string" ? document.createElement(renderer) : renderer.q();
+  return walk(
+    dom.nodeType === 11 /* DocumentFragment */ ? dom.firstChild : dom,
+    renderer.k ?? " ",
+    scope
+  ), scope.a = dom.nodeType === 11 /* DocumentFragment */ ? dom.firstChild : dom, scope.c = dom.nodeType === 11 /* DocumentFragment */ ? dom.lastChild : dom, renderer.l && renderer.l(scope), dom;
+}
+function dynamicTagAttrs(nodeAccessor, renderBody, inputIsArgs) {
+  return (scope, getAttrs, clean) => {
+    let renderer = scope[nodeAccessor + "(" /* ConditionalRenderer */];
+    if (!renderer || renderer === renderBody || clean && !renderer.d)
+      return;
+    let childScope = scope[nodeAccessor + "!" /* ConditionalScope */];
+    if (typeof renderer == "string")
+      attrs(childScope, 0, getAttrs()), setConditionalRendererOnlyChild(
+        childScope,
+        0,
+        renderBody && bindRenderer(scope, renderBody)
+      );
+    else if (renderer.d)
+      if (clean)
+        renderer.d(childScope, null, clean);
+      else {
+        let attributes = getAttrs();
+        renderer.d(
+          childScope,
+          inputIsArgs ? attributes : [
+            renderBody ? {
+              ...attributes,
+              renderBody: bindRenderer(scope, renderBody)
+            } : attributes
+          ],
+          clean
+        );
+      }
+  };
+}
+function createRenderer(template, walks, setup, closureSignals, hasUserEffects = 0, args) {
+  return {
+    m: template,
+    k: walks && /* @__PURE__ */ trimWalkString(walks),
+    l: setup,
+    q: _clone,
+    b: new Set(closureSignals),
+    r: hasUserEffects,
+    n: void 0,
+    d: args,
+    i: void 0
+  };
+}
+function _clone() {
+  let sourceNode = this.n;
+  if (!sourceNode) {
+    let walks = this.k, ensureFragment = walks && walks.length < 4 && walks.charCodeAt(walks.length - 1) !== 32 /* Get */;
+    this.n = sourceNode = parse(
+      this.m,
+      ensureFragment
+    );
+  }
+  return sourceNode.cloneNode(!0);
+}
+var doc2 = document, parser2 = /* @__PURE__ */ doc2.createElement("template");
+function parse(template, ensureFragment) {
+  let node;
+  parser2.innerHTML = template;
+  let content = parser2.content;
+  return ensureFragment || (node = content.firstChild) !== content.lastChild || node && node.nodeType === 8 /* Comment */ ? (node = doc2.createDocumentFragment(), node.appendChild(content)) : node || (node = doc2.createTextNode("")), node;
+}
+
+// src/dom/signals.ts
+function initValue(valueAccessor, fn) {
+  let markAccessor = valueAccessor + "#" /* Mark */;
+  return (scope, nextValue, clean) => {
+    clean !== 1 && scope[markAccessor] === void 0 && fn(scope, nextValue, clean);
+  };
+}
+function value(valueAccessor, render, intersection2, valueWithIntersection) {
+  let markAccessor = valueAccessor + "#" /* Mark */;
+  return (scope, nextValue, clean) => {
+    let creation, currentMark;
+    clean === 1 ? currentMark = scope[markAccessor] = (scope[markAccessor] ?? 0) + 1 : (creation = scope[markAccessor] === void 0, currentMark = scope[markAccessor] ||= 1), currentMark === 1 && (clean !== 1 && (creation || !(clean ||= scope[valueAccessor] === nextValue)) ? (scope[valueAccessor] = nextValue, render?.(scope, nextValue)) : valueWithIntersection?.(scope, 0, clean), intersection2?.(scope, clean)), clean !== 1 && scope[markAccessor]--;
+  };
+}
+var accessorId = 0;
+function intersection(count, fn, intersection2, valueWithIntersection) {
+  let cleanAccessor = "?" /* Dynamic */ + accessorId++, markAccessor = cleanAccessor + "#" /* Mark */;
+  return (scope, clean) => {
+    let currentMark;
+    clean === 1 ? currentMark = scope[markAccessor] = (scope[markAccessor] ?? 0) + 1 : scope[markAccessor] === void 0 ? (scope[markAccessor] = count - 1, clean = void 0) : (currentMark = scope[markAccessor]--, clean = scope[cleanAccessor] &&= clean), currentMark === 1 && (clean ? valueWithIntersection?.(scope, 0, clean) : (scope[cleanAccessor] = !0, fn(scope, clean)), intersection2?.(scope, clean));
+  };
+}
+var defaultGetOwnerScope = (scope) => scope._;
+function closure(ownerValueAccessor, fn, _getOwnerScope, intersection2, valueWithIntersection) {
+  let cleanAccessor = "?" /* Dynamic */ + accessorId++, markAccessor = cleanAccessor + 1, getOwnerScope = _getOwnerScope || defaultGetOwnerScope, getOwnerValueAccessor = typeof ownerValueAccessor == "function" ? ownerValueAccessor : () => ownerValueAccessor;
+  return (scope, clean) => {
+    let ownerScope, ownerValueAccessor2, currentMark;
+    if (clean === 1)
+      currentMark = scope[markAccessor] = (scope[markAccessor] ?? 0) + 1;
+    else if (scope[markAccessor] === void 0) {
+      ownerScope = getOwnerScope(scope), ownerValueAccessor2 = getOwnerValueAccessor(scope);
+      let ownerMark = ownerScope[ownerValueAccessor2 + "#" /* Mark */], ownerHasRun = ownerMark === void 0 ? !ownerScope.o : ownerMark === 0;
+      scope[markAccessor] = (currentMark = ownerHasRun ? 1 : 2) - 1, clean = void 0;
+    } else
+      currentMark = scope[markAccessor]--, clean = scope[cleanAccessor] &&= clean;
+    currentMark === 1 && (clean ? valueWithIntersection?.(scope, 0, clean) : (scope[cleanAccessor] = !1, ownerScope ??= getOwnerScope(scope), ownerValueAccessor2 ??= getOwnerValueAccessor(scope), fn?.(scope, ownerScope[ownerValueAccessor2])), intersection2?.(scope, clean));
+  };
+}
+function dynamicClosure(ownerValueAccessor, fn, _getOwnerScope, intersection2, valueWithIntersection) {
+  let getOwnerScope = _getOwnerScope || defaultGetOwnerScope, getOwnerValueAccessor = typeof ownerValueAccessor == "function" ? ownerValueAccessor : () => ownerValueAccessor, signalFn = closure(
+    getOwnerValueAccessor,
+    fn,
+    getOwnerScope,
+    intersection2,
+    valueWithIntersection
+  );
+  return Object.assign(signalFn, {
+    e(scope) {
+      let ownerScope = getOwnerScope(scope), providerSubscriptionsAccessor = getOwnerValueAccessor(scope) + "*" /* Subscribers */;
+      ownerScope[providerSubscriptionsAccessor] ??= /* @__PURE__ */ new Set(), ownerScope[providerSubscriptionsAccessor].add(
+        bindFunction(scope, signalFn)
+      );
+    },
+    g(scope) {
+      let ownerScope = getOwnerScope(scope), providerSubscriptionsAccessor = getOwnerValueAccessor(scope) + "*" /* Subscribers */;
+      ownerScope[providerSubscriptionsAccessor]?.delete(
+        bindFunction(scope, signalFn)
+      );
+    }
+  });
+}
+function childClosures(closureSignals, childAccessor) {
+  return Object.assign((scope, clean) => {
+    let childScope = scope[childAccessor];
+    for (let closureSignal of closureSignals)
+      closureSignal(childScope, clean);
+  }, {
+    e(scope) {
+      let childScope = scope[childAccessor];
+      for (let closureSignal of closureSignals)
+        closureSignal.e?.(childScope);
+    },
+    g(scope) {
+      let childScope = scope[childAccessor];
+      for (let closureSignal of closureSignals)
+        closureSignal.g?.(childScope);
+    }
+  });
+}
+function dynamicSubscribers(valueAccessor) {
+  let subscribersAccessor = valueAccessor + "*" /* Subscribers */;
+  return (scope, clean) => {
+    let subscribers = scope[subscribersAccessor];
+    if (subscribers)
+      for (let subscriber of subscribers)
+        subscriber(clean);
+  };
+}
+function setTagVar(scope, childAccessor, tagVarSignal2) {
+  scope[childAccessor]["/" /* TagVariable */] = bindFunction(
+    scope,
+    tagVarSignal2
+  );
+}
+var tagVarSignal = (scope, value2, clean) => scope["/" /* TagVariable */]?.(value2, clean), renderBodyClosures = (renderBody, childScope, clean) => {
+  let signals = renderBody?.b;
+  if (signals)
+    for (let signal of signals)
+      signal(childScope, clean);
+};
+var tagId = 0;
+function nextTagId() {
+  return "c" + tagId++;
+}
+function inChild(childAccessor, signal) {
+  return (scope, _, clean) => {
+    signal(scope[childAccessor], _, clean);
+  };
+}
+function intersections(signals) {
+  return (scope, clean) => {
+    for (let signal of signals)
+      signal(scope, clean);
+  };
+}
+function values(signals) {
+  return (scope, _, clean) => {
+    for (let signal of signals)
+      signal(scope, _, clean);
+  };
+}
+
+// src/dom/control-flow.ts
+function patchConditionals(fn) {
+  conditional = fn(conditional), conditionalOnlyChild = fn(conditionalOnlyChild);
+}
+var conditional = function(nodeAccessor, dynamicTagAttrs2, intersection2, valueWithIntersection) {
+  let rendererAccessor = nodeAccessor + "(" /* ConditionalRenderer */, childScopeAccessor = nodeAccessor + "!" /* ConditionalScope */;
+  return (scope, newRenderer, clean) => {
+    newRenderer = newRenderer ? newRenderer._ || newRenderer : void 0;
+    let currentRenderer = scope[rendererAccessor];
+    !clean && !(clean = currentRenderer === newRenderer) ? (currentRenderer = scope[rendererAccessor] = newRenderer, setConditionalRenderer(scope, nodeAccessor, newRenderer), dynamicTagAttrs2?.(scope)) : valueWithIntersection?.(scope, 0, clean), intersection2?.(scope, clean), renderBodyClosures(currentRenderer, scope[childScopeAccessor], clean);
+  };
+};
+function inConditionalScope(signal, nodeAccessor) {
+  let scopeAccessor = nodeAccessor + "!" /* ConditionalScope */, rendererAccessor = nodeAccessor + "(" /* ConditionalRenderer */;
+  return (scope, clean) => {
+    let conditionalScope = scope[scopeAccessor];
+    if (conditionalScope) {
+      let conditionalRenderer = scope[rendererAccessor];
+      (!conditionalRenderer?.b || conditionalRenderer.b.has(signal)) && signal(conditionalScope, clean);
+    }
+  };
+}
+function setConditionalRenderer(scope, nodeAccessor, newRenderer) {
+  let newScope, prevScope = scope[nodeAccessor + "!" /* ConditionalScope */];
+  newRenderer ? (newScope = scope[nodeAccessor + "!" /* ConditionalScope */] = createScopeWithRenderer(newRenderer, scope.$global, scope), prevScope = prevScope || getEmptyScope(scope[nodeAccessor])) : (newScope = getEmptyScope(scope[nodeAccessor]), scope[nodeAccessor + "!" /* ConditionalScope */] = void 0), insertBefore(
+    newScope,
+    prevScope.a.parentNode,
+    prevScope.a
+  ), removeAndDestroyScope(prevScope);
+}
+var conditionalOnlyChild = function(nodeAccessor, action) {
+  let rendererAccessor = nodeAccessor + "(" /* ConditionalRenderer */, childScopeAccessor = nodeAccessor + "!" /* ConditionalScope */;
+  return (scope, newRenderer, clean) => {
+    let currentRenderer = scope[rendererAccessor];
+    !clean && currentRenderer !== newRenderer && (currentRenderer = scope[rendererAccessor] = newRenderer, setConditionalRendererOnlyChild(scope, nodeAccessor, newRenderer)), renderBodyClosures(currentRenderer, scope[childScopeAccessor], clean), action?.(scope, currentRenderer, clean);
+  };
+};
+function setConditionalRendererOnlyChild(scope, nodeAccessor, newRenderer) {
+  let prevScope = scope[nodeAccessor + "!" /* ConditionalScope */], referenceNode = scope[nodeAccessor];
+  if (referenceNode.textContent = "", newRenderer) {
+    let newScope = scope[nodeAccessor + "!" /* ConditionalScope */] = createScopeWithRenderer(newRenderer, scope.$global, scope);
+    insertBefore(newScope, referenceNode, null);
+  }
+  prevScope && destroyScope(prevScope);
+}
+var emptyMarkerMap = (/* @__PURE__ */ new Map()).set(Symbol("empty"), getEmptyScope(void 0)), emptyMarkerArray = [
+  /* @__PURE__ */ getEmptyScope(void 0)
+], emptyMap = /* @__PURE__ */ new Map(), emptyArray = [];
+function loopOf(nodeAccessor, renderer) {
+  return loop(nodeAccessor, renderer, (value2, cb) => {
+    let [all, getKey = keyBySecondArg] = value2, i = 0;
+    for (let item of all)
+      cb(getKey(item, i), [item, i, all]), i++;
+  });
+}
+function loopIn(nodeAccessor, renderer) {
+  return loop(nodeAccessor, renderer, (value2, cb) => {
+    let [all, getKey = keyByFirstArg] = value2;
+    for (let key in all) {
+      let v = all[key];
+      cb(getKey(key, v), [key, v, all]);
+    }
+  });
+}
+function loopTo(nodeAccessor, renderer) {
+  return loop(nodeAccessor, renderer, (value2, cb) => {
+    let [to, from = 0, step = 1, getKey = keyByFirstArg] = value2, steps = (to - from) / step;
+    for (let i = 0; i <= steps; i++) {
+      let v = from + i * step;
+      cb(getKey(v), [v]);
+    }
+  });
+}
+function loop(nodeAccessor, renderer, forEach) {
+  let loopScopeAccessor = nodeAccessor + "!" /* LoopScopeArray */, closureSignals = renderer.b, params = renderer.d;
+  return (scope, value2, clean) => {
+    if (clean) {
+      for (let childScope of scope[loopScopeAccessor]) {
+        params?.(childScope, null, clean);
+        for (let signal of closureSignals)
+          signal(childScope, clean);
+      }
+      return;
+    }
+    let referenceNode = scope[nodeAccessor], referenceIsMarker = referenceNode.nodeType === 8 || referenceNode.nodeType === 3, oldMap = scope[nodeAccessor + "(" /* LoopScopeMap */] || (referenceIsMarker ? emptyMarkerMap : emptyMap), oldArray = scope[nodeAccessor + "!" /* LoopScopeArray */] || Array.from(oldMap.values()), newMap, newArray, afterReference, parentNode, needsReconciliation = !0;
+    if (forEach(value2, (key, args) => {
+      let childScope = oldMap.get(key), isNew = !childScope;
+      if (childScope || (childScope = createScopeWithRenderer(renderer, scope.$global, scope)), params && params(childScope, args), closureSignals)
+        for (let signal of closureSignals)
+          signal(childScope, isNew);
+      newMap ? (newMap.set(key, childScope), newArray.push(childScope)) : (newMap = /* @__PURE__ */ new Map([[key, childScope]]), newArray = [childScope]);
+    }), !newMap)
+      if (referenceIsMarker)
+        newMap = emptyMarkerMap, newArray = emptyMarkerArray, getEmptyScope(referenceNode);
+      else {
+        if (renderer.r)
+          for (let i = 0; i < oldArray.length; i++)
+            destroyScope(oldArray[i]);
+        referenceNode.textContent = "", newMap = emptyMap, newArray = emptyArray, needsReconciliation = !1;
+      }
+    if (needsReconciliation) {
+      if (referenceIsMarker) {
+        oldMap === emptyMarkerMap && getEmptyScope(referenceNode);
+        let oldLastChild = oldArray[oldArray.length - 1];
+        afterReference = oldLastChild.c.nextSibling, parentNode = oldLastChild.a.parentNode;
+      } else
+        afterReference = null, parentNode = referenceNode;
+      reconcile(parentNode, oldArray, newArray, afterReference);
+    }
+    scope[nodeAccessor + "(" /* LoopScopeMap */] = newMap, scope[nodeAccessor + "!" /* LoopScopeArray */] = newArray;
+  };
+}
+function inLoopScope(signal, loopNodeAccessor) {
+  let loopScopeAccessor = loopNodeAccessor + "!" /* LoopScopeArray */;
+  return (scope, clean) => {
+    let loopScopes = scope[loopScopeAccessor] ?? scope[loopNodeAccessor + "(" /* LoopScopeMap */]?.values() ?? [];
+    for (let scope2 of loopScopes)
+      signal(scope2, clean);
+  };
+}
+function keyBySecondArg(_item, index) {
+  return index;
+}
+function keyByFirstArg(name) {
+  return name;
+}
+
+// src/dom/event.ts
+var elementHandlersByEvent = /* @__PURE__ */ new Map(), delegatedEventsByRoot = /* @__PURE__ */ new WeakMap(), eventOpts = { capture: !0 };
+function on(element, type, handler) {
+  let handlersByElement = elementHandlersByEvent.get(type);
+  handlersByElement || elementHandlersByEvent.set(type, handlersByElement = /* @__PURE__ */ new WeakMap()), handlersByElement.has(element) || ensureDelegated(element, type), handlersByElement.set(element, handler || void 0);
+}
+function ensureDelegated(node, type) {
+  let root = node.getRootNode(), delegatedEvents = delegatedEventsByRoot.get(root);
+  delegatedEvents || delegatedEventsByRoot.set(root, delegatedEvents = /* @__PURE__ */ new Set()), delegatedEvents.has(type) || (delegatedEvents.add(type), root.addEventListener(type, handleDelegated, eventOpts));
+}
+function handleDelegated(ev) {
+  let target = ev.target;
+  if (target) {
+    let handlersByElement = elementHandlersByEvent.get(ev.type);
+    if (handlersByElement.get(target)?.(ev, target), ev.bubbles)
+      for (; (target = target.parentElement) && !ev.cancelBubble; )
+        handlersByElement.get(target)?.(ev, target);
+  }
+}
+
+// src/dom/resume.ts
+var registeredObjects = /* @__PURE__ */ new Map(), doc3 = document;
+function register(id, obj) {
+  return registeredObjects.set(id, obj), obj;
+}
+function getRegisteredWithScope(registryId, scope) {
+  let obj = registeredObjects.get(registryId);
+  return scope ? obj.m ? bindRenderer(scope, obj) : bindFunction(scope, obj) : obj;
+}
+var scopeLookup = {};
+function init(runtimeId = "M" /* DefaultRuntimeId */) {
+  let runtimeLength = runtimeId.length, resumeVar = runtimeId + "$h" /* VarResume */, initialHydration = window[resumeVar], walker2 = doc3.createTreeWalker(
+    doc3,
+    128
+    /** NodeFilter.SHOW_COMMENT */
+  ), currentScopeId, currentNode, getScope = (id) => scopeLookup[id] ?? (scopeLookup[id] = {}), stack = [], fakeArray = { push: resume };
+  if (initialHydration)
+    for (let i = 0; i < initialHydration.length; i += 2)
+      resume(initialHydration[i], initialHydration[i + 1]);
+  else
+    window[resumeVar] = fakeArray;
+  function resume(scopesFn, calls) {
+    if (doc3.readyState !== "loading" && (walker2.currentNode = doc3), scopesFn) {
+      let scopes = scopesFn(getRegisteredWithScope, scopeLookup);
+      scopeLookup.$global ||= scopes.$global || {};
+      for (let scopeIdAsString in scopes) {
+        if (scopeIdAsString === "$global")
+          continue;
+        let scopeId = parseInt(scopeIdAsString), scope = scopes[scopeId], storedScope = scopeLookup[scopeId];
+        scope.$global = scopes.$global, storedScope !== scope && (scopeLookup[scopeId] = Object.assign(scope, storedScope));
+      }
+    }
+    for (; currentNode = walker2.nextNode(); ) {
+      let nodeValue = currentNode.nodeValue;
+      if (nodeValue.startsWith(runtimeId)) {
+        let token = nodeValue[runtimeLength], scopeId = parseInt(nodeValue.slice(runtimeLength + 1)), scope = getScope(scopeId), data2 = nodeValue.slice(nodeValue.indexOf(" ") + 1);
+        if (token === "*" /* Node */)
+          scope[data2] = currentNode.previousSibling;
+        else if (token === "[" /* SectionStart */)
+          stack.push(currentScopeId), currentScopeId = scopeId, scope.a = currentNode;
+        else if (token === "]" /* SectionEnd */) {
+          if (scope[data2] = currentNode, scopeId < currentScopeId) {
+            let currScope = scopeLookup[currentScopeId], currParent = currentNode.parentNode, startNode = currScope.a;
+            currParent !== startNode.parentNode && currParent.prepend(startNode), currScope.c = currentNode.previousSibling, currentScopeId = stack.pop();
+          }
+        } else if (token === "|" /* SectionSingleNodesEnd */) {
+          scope[parseInt(data2)] = currentNode;
+          let childScopeIds = JSON.parse(
+            "[" + data2.slice(data2.indexOf(" ") + 1) + "]"
+          );
+          for (let i = childScopeIds.length - 1; i >= 0; i--) {
+            let childScope = getScope(childScopeIds[i]);
+            for (; (currentNode = currentNode.previousSibling).nodeType === 8; )
+              ;
+            childScope.a = childScope.c = currentNode;
+          }
+        }
+      }
+    }
+    for (let i = 0; i < calls.length; i += 2)
+      registeredObjects.get(calls[i + 1])(
+        scopeLookup[calls[i]]
+      );
+  }
+}
+function registerSubscriber(id, signal) {
+  return register(id, signal.e), signal;
+}
+
+// src/dom/schedule.ts
+var port2 = /* @__PURE__ */ (() => {
+  let { port1, port2: port22 } = new MessageChannel();
+  return port1.onmessage = () => {
+    isScheduled = !1, run();
+  }, port22;
+})(), isScheduled;
+function schedule() {
+  isScheduled || (isScheduled = !0, queueMicrotask(flushAndWaitFrame));
+}
+function flushAndWaitFrame() {
+  run(), requestAnimationFrame(triggerMacroTask);
+}
+function triggerMacroTask() {
+  port2.postMessage(0);
+}
+
+// src/dom/queue.ts
+var currentBatch = [], currentEffects = [];
+function queueSource(scope, signal, value2) {
+  return schedule(), signal(scope, 0, 1), currentBatch.push(scope, signal, value2), value2;
+}
+function queueEffect(scope, fn) {
+  currentEffects.push(scope, fn);
+}
+function run() {
+  try {
+    runBatch();
+  } finally {
+    currentBatch = [];
+  }
+  try {
+    runEffects();
+  } finally {
+    currentEffects = [];
+  }
+}
+function runSync(fn) {
+  let prevBatch = currentBatch, prevEffects = currentEffects;
+  currentBatch = [], currentEffects = [];
+  try {
+    fn(), runBatch(), currentBatch = prevBatch, runEffects();
+  } finally {
+    currentBatch = prevBatch, currentEffects = prevEffects;
+  }
+}
+function prepare(fn) {
+  let prevBatch = currentBatch, prevEffects = currentEffects, preparedEffects = currentEffects = [];
+  currentBatch = [];
+  try {
+    fn(), runBatch();
+  } finally {
+    currentBatch = prevBatch, currentEffects = prevEffects;
+  }
+  return preparedEffects;
+}
+function runEffects(effects = currentEffects) {
+  for (let i = 0; i < effects.length; i += 2 /* Total */) {
+    let scope = effects[i], fn = effects[i + 1];
+    fn(scope);
+  }
+}
+function runBatch() {
+  for (let i = 0; i < currentBatch.length; i += 3 /* Total */) {
+    let scope = currentBatch[i + 0 /* Scope */], signal = currentBatch[i + 1 /* Signal */], value2 = currentBatch[i + 2 /* Value */];
+    signal(scope, value2);
+  }
+}
+
+// src/dom/template.ts
+var createTemplate = (renderer, templateId) => register(templateId, new ClientTemplate(renderer)), ClientTemplate = class {
+  _;
+  constructor(renderer) {
+    this._ = renderer;
+  }
+  mount(templateInput = {}, reference, position) {
+    let scope, dom, { $global = {}, ...input } = templateInput, args = this._.d, effects = prepare(() => {
+      scope = createScope($global), dom = initRenderer(this._, scope), args && args(scope, [input]);
+    });
+    switch (position) {
+      case "afterbegin":
+        reference.insertBefore(dom, reference.firstChild);
+        break;
+      case "afterend":
+        reference.parentElement.insertBefore(dom, reference.nextSibling);
+        break;
+      case "beforebegin":
+        reference.parentElement.insertBefore(dom, reference);
+        break;
+      default:
+        reference.appendChild(dom);
+        break;
+    }
+    return runEffects(effects), {
+      update: (newInput) => {
+        args && runSync(() => {
+          args(scope, null, 1), args(scope, [newInput]);
+        });
+      },
+      destroy: () => {
+        removeAndDestroyScope(scope);
+      }
+    };
+  }
+  render() {
+    throw new Error(
+      "render() is not implemented for the DOM compilation of a Marko template"
+    );
+  }
+};
+//# sourceMappingURL=dom.js.map