@rusticarcade/palette 0.3.1 → 0.7.0

package/dist/dev/index.js

@@ -11,12 +11,11 @@ INVALID_ENV
 Failed to find a custom elements registry in this environment. Is a window
 global available with a customElements property?
 `,
-    [100 /* DUPE_TAGNAME */]: `
-DUPE_TAGNAME
-Failed to register a custom element with the tagname %s because another
-custom element is already defined with that name.
+    [2 /* INVALID_CALLSITE */]: `
+INVALID_CALLSITE
+A function was invoked with an invalid set of parameters.   
 `,
-    [101 /* INVALID_TAGNAME */]: `
+    [100 /* INVALID_TAGNAME */]: `
 INVALID_TAGNAME
 Failed to determine a valid HTML Tag to use when registering a component as a
 custom element. Specify a static readonly tagName property on your component
@@ -41,44 +40,39 @@ type. Values must be a string, HTMLElement.
 
 Instead, got %s: %s.
 `,
-    [200 /* TEMPLATE_INVALID */]: `
+    [200 /* TEMPLATE_INVALID_VALUE */]: `
 TEMPLATE_INVALID
 The value %s cannot be interpolated via the Template html string helper.
 Values may only be HTMLTemplateElements (template content is adopted) or
 strings (shorthand for a ::swap directive on an element)
 `,
-    [201 /* TEMPLATE_INVALID_NOTATION */]: `
+    [201 /* TEMPLATE_INVALID_NOTATION_SYNTAX */]: `
 TEMPLATE_INVALID_NOTATION
 A template value notation failed to parse. Notations must begin with one of
 @, $, *, or #, followed by a dot-separated path of accessor names. Optionally,
-notations may have modifiers around them, such as the NOT() modifier.
+notations may have modifiers such as the ! modifier.
 
 The notation that failed to parse was "%s"
 `,
-    [202 /* TEMPLATE_INVALID_COMPONENT */]: `
+    [203 /* TEMPLATE_INVALID_COMPONENT */]: `
 TEMPLATE_INVALID_COMPONENT
 Failed to interpolate a Component in an html template string due to the
 Component having an invalid tagName property.
 
 Component "%s" has an invalid tagName property "%s"
     `,
-    [205 /* TEMPLATE_MISSING_LIST_PARENT */]: `
-TEMPLATE_MISSING_LIST_PARENT
-A template failed to prepare an ::each directive because no valid parent node
-was found for the list to render into.
-`,
-    [203 /* TEMPLATE_INVALID_LIST */]: `
+    [204 /* TEMPLATE_INVALID_LIST_DATA */]: `
 TEMPLATE_INVALID_LIST
 A template failed to render because an ::each directive fetched a value which
 was not an array of actionable data.
 `,
-    [204 /* TEMPLATE_INVALID_NODE_REF */]: `
+    [3 /* MISSING_NODE_REF */]: `
 TEMPLATE_INVALID_NODE_REF
 A template failed to prepare a node from a compiled source. Typically, this
 means something is broken within the compiled template rather than an error with
 the template content itself.
 `,
-    [206 /* TEMPLATE_MISSING_LIST_KEY */]: `
+    [205 /* TEMPLATE_MISSING_LIST_KEY */]: `
 TEMPLATE_MISSING_LIST_KEY
 A template failed to compile because an ::each directive was found on an element
 without a corresponding ::key directive. ::each directives must have a ::key
@@ -87,11 +81,27 @@ value for each item in the list.
 
 Example: <li ::each="$items" ::key="#id"> ... </li>
 `,
-    [207 /* TEMPLATE_DUPLICATE_LIST_KEY */]: `
+    [206 /* TEMPLATE_DUPLICATE_LIST_KEY */]: `
 TEMPLATE_DUPLICATE_LIST_KEY
 A list failed to render because item key %s appeared multiple times when
 resolving list item keys. Each ::key directive must reference a notation whose
 value is unique for each list item.
+`,
+    [207 /* TEMPLATE_INVALID_CONDITIONAL */]: `
+TEMPLATE_INVALID_CONDITIONAL
+A template failed to compile due to an invalid use of conditional directives.
+
+Conditional elements must be siblings. The first conditional branch must use an
+::if directive, followed by zero or more ::else-if directives, and finally zero
+or one ::else directive.
+
+::if and ::else-if directives must specify a notation to evaluate. ::else does
+not take any values and is just a binary attribute.
+`,
+    [202 /* TEMPLATE_MISSING_NOTATION */]: `
+TEMPLATE_MISSING_NOTATION
+A template failed to compile because a %s directive did not have an associated
+notation despite requiring one.
 `,
     [303 /* INVALID_STATE_KEY */]: `
 INVALID_STATE_KEY
@@ -126,6 +136,19 @@ during a render lifecycle method such as beforeUpdate() or afterUpdate(). If
 state changes unconditionally during a render, the render will infinitely loop.
 Updating render source data during a render cycle is supported, but infinite
 update loops may occur if unchecked.
+`,
+    [208 /* TEMPLATE_INVALID_KEY_DIRECTIVE */]: `
+TEMPLATE_INVALID_KEY_DIRECTIVE
+A template failed to compile because a ::key directive was found on an element
+with no associated ::each directive. ::key directives can only be used in
+association with list rendering via ::each.
+`,
+    [209 /* TEMPLATE_PARENT_REQUIRED */]: `
+TEMPLATE_PARENT_REQUIRED
+A template failed to compile due to an element which requires a parent having
+no available parent in the template.
+
+::each and ::if/::else-if/::else elements must have a parent node.
 `
   };
   return DEV_ERROR_INFO[code];
@@ -147,279 +170,7 @@ class PaletteError extends Error {
   }
 }
 
-// src/helper/css.ts
-function css(strings, ...values) {
-  let result = strings[0] ?? "";
-  for (let i = 0;i < values.length; i++) {
-    const nextVal = values[i] ?? "";
-    const nextStr = strings[i + 1] ?? "";
-    result += `${nextVal}${nextStr}`;
-  }
-  const sheet = new CSSStyleSheet;
-  sheet.replaceSync(result);
-  return sheet;
-}
-function classify(...args) {
-  let resultString = "";
-  for (let index = 0;index < args.length; index++) {
-    const argument = args[index];
-    if (!argument) {
-      continue;
-    }
-    if (typeof argument === "string" || typeof argument === "number") {
-      if (resultString) {
-        resultString += " ";
-      }
-      resultString += argument;
-      continue;
-    }
-    if (Array.isArray(argument)) {
-      const nestedResult = classify(...argument);
-      if (nestedResult) {
-        if (resultString) {
-          resultString += " ";
-        }
-        resultString += nestedResult;
-      }
-      continue;
-    }
-    if (typeof argument === "object") {
-      for (const className in argument) {
-        if (argument[className]) {
-          if (resultString) {
-            resultString += " ";
-          }
-          resultString += className;
-        }
-      }
-    }
-  }
-  return resultString;
-}
-// src/util/attributes.ts
-function serializeAttribute(value) {
-  if (typeof value === "string" || typeof value === "number") {
-    return `${value}`;
-  }
-  if (value === true) {
-    return "";
-  }
-  if (value === null || value === false || value === undefined) {
-    return null;
-  }
-  return value.toString();
-}
-function createAttributeMap(source) {
-  const map = new Map;
-  if (source instanceof HTMLElement) {
-    for (const name of source.getAttributeNames()) {
-      map.set(name, serializeAttribute(source.getAttribute(name)));
-    }
-    return map;
-  }
-  if (source instanceof Map) {
-    for (const [key, val] of source) {
-      map.set(key, serializeAttribute(val));
-    }
-    return map;
-  }
-  if (typeof source === "object" && source !== null) {
-    for (const [key, val] of Object.entries(source)) {
-      map.set(key, serializeAttribute(val));
-    }
-    return map;
-  }
-  throw new PaletteError(0 /* INVARIANT */);
-}
-function applyAttributeMap(target, attrs) {
-  const currentNames = new Set(target.getAttributeNames());
-  const incomingNames = new Set(attrs.keys());
-  const attributesToRemove = currentNames.difference(incomingNames);
-  for (const attr of attributesToRemove) {
-    target.removeAttribute(attr);
-  }
-  for (const [name, val] of attrs) {
-    if (val === null) {
-      target.removeAttribute(name);
-    } else {
-      target.setAttribute(name, val);
-    }
-  }
-}
-// src/util/change-tag.ts
-function changeTag($target, newTag) {
-  const $newEl = document.createElement(newTag);
-  while ($target.firstChild !== null) {
-    $newEl.appendChild($target.firstChild);
-  }
-  for (const attrName of $target.getAttributeNames()) {
-    const val = $target.getAttribute(attrName);
-    if (val !== null) {
-      $newEl.setAttribute(attrName, val);
-    }
-  }
-  $target.replaceWith($newEl);
-  return $newEl;
-}
-// src/util/element-match.ts
-function isTagName(str) {
-  for (let i = 0;i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    if (!(char === 45 /* Hyphen */ || char >= 65 /* A */ && char <= 90 /* Z */ || char >= 97 /* a */ && char <= 122 /* z */)) {
-      return false;
-    }
-  }
-  return true;
-}
-function elementMatches(element, query) {
-  if (query[0] === "#" && query.indexOf(" ") === -1 && query.indexOf(".") === -1 && query.indexOf("[") === -1 && query.indexOf(":") === -1 && query.indexOf(">") === -1) {
-    return element.id === query.slice(1);
-  }
-  if (query[0] === "." && query.indexOf(" ") === -1 && query.indexOf("#") === -1 && query.indexOf("[") === -1 && query.indexOf(":") === -1 && query.indexOf(">") === -1) {
-    return element.classList.contains(query.slice(1));
-  }
-  if (isTagName(query)) {
-    return element.tagName.toLowerCase() === query.toLowerCase();
-  }
-  if (query[0] === "[" && query[query.length - 1] === "]" && query.indexOf(" ") === -1 && query.indexOf(":") === -1) {
-    const attr = query.slice(1, -1);
-    const eqIndex = attr.indexOf("=");
-    if (eqIndex === -1) {
-      return element.hasAttribute(attr);
-    }
-    const attrName = attr.slice(0, eqIndex);
-    const attrValue = attr.slice(eqIndex + 1).replace(/^["']|["']$/g, "");
-    return element.getAttribute(attrName) === attrValue;
-  }
-  return element.matches(query);
-}
-// src/util/lru-cache.ts
-class LRUCache {
-  _maxSize;
-  _data;
-  _metrics = { hits: 0, misses: 0 };
-  constructor(maxSize = 500) {
-    if (maxSize <= 0) {
-      throw new Error("LRU Cache capacity must be >= 1");
-    }
-    if (true) {
-      this._metrics = { hits: 0, misses: 0 };
-    }
-    this._maxSize = maxSize;
-    this._data = new Map;
-  }
-  _trim = () => {
-    while (this._data.size > this._maxSize) {
-      const firstKey = this._data.keys().next().value;
-      if (firstKey === undefined) {
-        throw new Error("Absurd");
-      }
-      this._data.delete(firstKey);
-    }
-  };
-  get metrics() {
-    if (true) {
-      const { hits = 0, misses = 0 } = this._metrics ?? {};
-      const lookups = hits + misses;
-      const hitRate = lookups === 0 ? 0 : hits / lookups;
-      return {
-        lookups,
-        hits,
-        misses,
-        capacity: this._maxSize,
-        entries: this._data.size,
-        hitRate
-      };
-    }
-    return {
-      lookups: 0,
-      hits: 0,
-      misses: 0,
-      capacity: 0,
-      entries: 0,
-      hitRate: 0
-    };
-  }
-  setCapacity = (maxSize) => {
-    if (maxSize <= 0 && true) {
-      console.warn("[Palette LRU Cache] Cache size is <= 0. Cache is disabled.");
-    }
-    this._maxSize = maxSize;
-    this._trim();
-  };
-  get(key) {
-    const value = this._data.get(key);
-    if (value === undefined) {
-      if (true) {
-        this._metrics.misses += 1;
-      }
-      return;
-    }
-    this._data.delete(key);
-    this._data.set(key, value);
-    if (true) {
-      this._metrics.hits += 1;
-    }
-    return value;
-  }
-  set(key, value) {
-    if (this._data.has(key)) {
-      this._data.delete(key);
-    }
-    this._data.set(key, value);
-    if (this._data.size > this._maxSize) {
-      this._trim();
-    }
-  }
-  clear() {
-    this._data.clear();
-  }
-  get size() {
-    return this._data.size;
-  }
-}
-var lru_cache_default = LRUCache;
-
-// src/util/fragments.ts
-var fragmentCache = new lru_cache_default;
-function htmlToFragment(html) {
-  const lookup = fragmentCache.get(html);
-  if (lookup !== undefined) {
-    return lookup.cloneNode(true);
-  }
-  const temp = document.createElement("template");
-  temp.innerHTML = html;
-  fragmentCache.set(html, temp.content);
-  return temp.content.cloneNode(true);
-}
-// src/helper/html.ts
-function parseTemplateStringValue(val) {
-  if (val instanceof HTMLTemplateElement) {
-    return val.innerHTML;
-  }
-  if (typeof val === "function" && (val.prototype instanceof Component || val === Component)) {
-    const tagName = val.tagName;
-    if (!isTagName(tagName)) {
-      throw new PaletteError(202 /* TEMPLATE_INVALID_COMPONENT */, val.name, val.tagName);
-    }
-    return tagName;
-  }
-  if (typeof val === "string") {
-    return `<span ::swap="${val}"></span>`;
-  }
-  throw new PaletteError(200 /* TEMPLATE_INVALID */, String(val));
-}
-function html(strings, ...values) {
-  const fullString = strings.reduce((acc, str, i) => {
-    const parsedValue = values[i] ? `${parseTemplateStringValue(values[i])}` : "";
-    return acc + str + parsedValue;
-  }, "");
-  const templateElement = document.createElement("template");
-  templateElement.innerHTML = fullString;
-  return templateElement;
-}
 // src/state/state.ts
-var PROXY_DEPTH_WARNING_LIMIT = 4;
 var ArrayMutatorFunctions = new Set([
   "push",
   "pop",
@@ -439,18 +190,18 @@ var DataStructureMutatorFunctions = new Set([
 ]);
 
 class State {
+  static isState(value) {
+    return value !== null && typeof value === "object" && value instanceof State;
+  }
   _data;
   _listeners = new Set;
   _proxy;
   _proxyCache = new WeakMap;
   _reverseProxyCache = new WeakMap;
-  _isLocked = false;
-  _hasWarned = false;
-  constructor(initialData, onChange) {
+  constructor(initialData, listener) {
     this._data = initialData;
-    this.get = this.get.bind(this);
-    if (onChange) {
-      this._listeners.add(onChange);
+    if (listener) {
+      this._listeners.add(listener);
     }
   }
   _createProxy(target, path = []) {
@@ -461,16 +212,6 @@ class State {
     if (cached) {
       return cached;
     }
-    if (true) {
-      if (!this._hasWarned && path.length > PROXY_DEPTH_WARNING_LIMIT) {
-        this._hasWarned = true;
-        console.warn(`
-[State] Deeply nested live state access may have performance impacts. For deeply
-nested or complex state updates, use .mutate(), .patch(), or .transaction() for
-optimal performance (Warning while evaluating live access to ${path.join(".")})
-`);
-      }
-    }
     const proxy = new Proxy(target, {
       get: (obj, key) => {
         if (typeof key === "symbol") {
@@ -488,9 +229,6 @@ optimal performance (Warning while evaluating live access to ${path.join(".")})
             }
             const res = current[key](...args);
             if (isMutation) {
-              if (this._isLocked) {
-                throw new PaletteError(305 /* STATE_LOCKED */);
-              }
               this._processIncomingState(snapshot);
             }
             return res;
@@ -502,9 +240,6 @@ optimal performance (Warning while evaluating live access to ${path.join(".")})
         return value;
       },
       set: (_obj, key, value) => {
-        if (this._isLocked) {
-          throw new PaletteError(305 /* STATE_LOCKED */);
-        }
         if (typeof key === "symbol") {
           return false;
         }
@@ -567,18 +302,18 @@ optimal performance (Warning while evaluating live access to ${path.join(".")})
     let current = this._data;
     for (let i = 0;i < path.length - 1; i++) {
       const key = path[i] ?? "";
-      if (!(key in current)) {
+      if (current === undefined) {
         throw new PaletteError(303 /* INVALID_STATE_KEY */, path.join("."));
       }
       current = current[key];
     }
     const finalKey = path[path.length - 1] ?? "";
-    if (!(finalKey in current)) {
+    if (current === undefined) {
       throw new PaletteError(303 /* INVALID_STATE_KEY */, path.join("."));
     }
     if (current[finalKey] !== value && !Object.is(current[finalKey], value)) {
       current[finalKey] = value;
-      this._emit(this.current);
+      this._emit(this.raw);
     }
   }
   _processIncomingState = (incomingState) => {
@@ -596,13 +331,14 @@ optimal performance (Warning while evaluating live access to ${path.join(".")})
     if (hasChanges) {
       this._emit(this._data);
     }
+    return this;
   };
   _emit = (data) => {
     for (const listener of this._listeners) {
       listener(data);
     }
   };
-  get current() {
+  get raw() {
     return this._data;
   }
   get live() {
@@ -611,9 +347,6 @@ optimal performance (Warning while evaluating live access to ${path.join(".")})
     }
     return this._proxy;
   }
-  get isLocked() {
-    return this._isLocked;
-  }
   addListener = (listener) => {
     this._listeners.add(listener);
   };
@@ -627,114 +360,233 @@ optimal performance (Warning while evaluating live access to ${path.join(".")})
     return structuredClone(this._data);
   };
   set = (key, value) => {
-    if (this._isLocked) {
-      throw new PaletteError(305 /* STATE_LOCKED */);
-    }
     const partial = {};
     partial[key] = value;
-    this._processIncomingState(partial);
+    return this._processIncomingState(partial);
   };
   patch = (patch) => {
-    if (this._isLocked) {
-      throw new PaletteError(305 /* STATE_LOCKED */);
-    }
-    this._processIncomingState(patch);
-    return this;
+    return this._processIncomingState(patch);
   };
   replace = (state) => {
-    if (this._isLocked) {
-      throw new PaletteError(305 /* STATE_LOCKED */);
-    }
     this._data = state;
     this._emit(this._data);
     return this;
   };
-  lock = () => {
-    if (this._isLocked) {
-      throw new PaletteError(305 /* STATE_LOCKED */);
-    }
-    this._isLocked = true;
-    return this;
-  };
-  unlock = () => {
-    this._isLocked = false;
-    return this;
-  };
   mutate = (mutator) => {
-    if (this._isLocked) {
-      throw new PaletteError(305 /* STATE_LOCKED */);
-    }
-    this._processIncomingState(mutator(this.snapshot()));
-    return this;
+    return this._processIncomingState(mutator(this.snapshot()));
   };
-  mutateAsync = async (mutator, lock = false) => {
-    if (this._isLocked) {
-      throw new PaletteError(305 /* STATE_LOCKED */);
+}
+// src/util/lru-cache.ts
+class LRUCache {
+  _maxSize;
+  _data;
+  _metrics = { hits: 0, misses: 0 };
+  constructor(maxSize = 500) {
+    if (maxSize <= 0) {
+      throw new Error("LRU Cache capacity must be >= 1");
     }
-    if (lock) {
-      this._isLocked = true;
+    if (true) {
+      this._metrics = { hits: 0, misses: 0 };
     }
-    const mutationResult = await mutator(this.snapshot());
-    this._processIncomingState(mutationResult);
-    if (lock) {
-      this._isLocked = false;
+    this._maxSize = maxSize;
+    this._data = new Map;
+  }
+  _trim = () => {
+    while (this._data.size > this._maxSize) {
+      const firstKey = this._data.keys().next().value;
+      if (firstKey === undefined) {
+        throw new Error("Absurd");
+      }
+      this._data.delete(firstKey);
     }
-    return this;
   };
-  transaction = (fn) => {
-    if (this._isLocked) {
-      throw new PaletteError(305 /* STATE_LOCKED */);
+  getMetrics() {
+    if (true) {
+      const { hits = 0, misses = 0 } = this._metrics ?? {};
+      const lookups = hits + misses;
+      const hitRate = lookups === 0 ? 0 : hits / lookups;
+      return {
+        lookups,
+        hits,
+        misses,
+        capacity: this._maxSize,
+        entries: this._data.size,
+        hitRate
+      };
     }
-    this._isLocked = true;
-    let success = true;
-    try {
-      const transactionState = new State(this.snapshot());
-      fn(transactionState);
-      this._processIncomingState(transactionState.current);
-    } catch (error) {
-      if (true) {
-        console.warn("[State] Transaction failed due to caught error", error);
-      }
-      success = false;
-    } finally {
-      this._isLocked = false;
+  }
+  setCapacity = (maxSize) => {
+    if (maxSize <= 0 && true) {
+      console.warn("[Palette LRU Cache] Cache size is <= 0. Cache is disabled.");
     }
-    return success;
+    this._maxSize = maxSize;
+    this._trim();
   };
-  transactionAsync = async (fn) => {
-    if (this._isLocked) {
-      throw new PaletteError(305 /* STATE_LOCKED */);
-    }
-    this._isLocked = true;
-    let success = true;
-    try {
-      const transactionState = new State(this.snapshot());
-      await fn(transactionState);
-      this._processIncomingState(transactionState.current);
-    } catch (error) {
+  get(key) {
+    const value = this._data.get(key);
+    if (value === undefined) {
       if (true) {
-        console.warn("[State] Transaction failed due to caught error", error);
+        this._metrics.misses += 1;
       }
-      success = false;
-    } finally {
-      this._isLocked = false;
+      return;
     }
-    return success;
-  };
+    this._data.delete(key);
+    this._data.set(key, value);
+    if (true) {
+      this._metrics.hits += 1;
+    }
+    return value;
+  }
+  set(key, value) {
+    if (this._data.has(key)) {
+      this._data.delete(key);
+    }
+    this._data.set(key, value);
+    if (this._data.size > this._maxSize) {
+      this._trim();
+    }
+  }
+  clear() {
+    this._data.clear();
+  }
+  get size() {
+    return this._data.size;
+  }
 }
-// src/template/syntax.ts
-function isBoundAttribute(attrName) {
-  if (attrName[0] !== ":" || attrName.length < 2) {
-    return false;
+var lru_cache_default = LRUCache;
+
+// src/util/fragments.ts
+var fragmentCache = new lru_cache_default;
+function htmlToFragment(html) {
+  const lookup = fragmentCache.get(html);
+  if (lookup !== undefined) {
+    return lookup.cloneNode(true);
+  }
+  const temp = document.createElement("template");
+  temp.innerHTML = html;
+  fragmentCache.set(html, temp.content);
+  return temp.content.cloneNode(true);
+}
+function saveFragment(html, fragment) {
+  fragmentCache.set(html, fragment);
+}
+
+// src/util/attributes.ts
+function serializeAttribute(value) {
+  if (typeof value === "string" || typeof value === "number") {
+    return `${value}`;
+  }
+  if (value === true) {
+    return "";
+  }
+  if (value === null || value === false || value === undefined) {
+    return null;
+  }
+  return value.toString();
+}
+function applyAttribute(element, name, value) {
+  if (value === null) {
+    element.removeAttribute(name);
+  } else {
+    element.setAttribute(name, value);
+  }
+}
+function getElementAttributes(source) {
+  const attrs = {};
+  for (const name of source.getAttributeNames()) {
+    attrs[name] = serializeAttribute(source.getAttribute(name));
+  }
+  return attrs;
+}
+function applyElementAttributes(target, attrs) {
+  const currentNames = new Set(target.getAttributeNames());
+  const incomingNames = new Set(Object.keys(attrs));
+  const attributesToRemove = currentNames.difference(incomingNames);
+  for (const attr of attributesToRemove) {
+    target.removeAttribute(attr);
+  }
+  for (const [name, val] of Object.entries(attrs)) {
+    applyAttribute(target, name, serializeAttribute(val));
+  }
+}
+function formatAttributeRecord(record) {
+  const out = {};
+  for (const [key, val] of Object.entries(record)) {
+    out[key] = serializeAttribute(val);
   }
-  for (let i = 1;i < attrName.length; i++) {
-    const char = attrName.charCodeAt(i);
-    if (!(char === 45 /* Hyphen */ || char >= 65 /* A */ && char <= 90 /* Z */ || char >= 97 /* a */ && char <= 122 /* z */)) {
+  return out;
+}
+// src/util/element-match.ts
+function isTagName(str) {
+  for (let i = 0;i < str.length; i++) {
+    const char = str.charAt(i);
+    if (!(char === "-" || char >= "A" && char <= "Z" || char >= "a" && char <= "z")) {
       return false;
     }
   }
   return true;
 }
+function elementMatches(element, query) {
+  if (query[0] === "#" && query.indexOf(" ") === -1 && query.indexOf(".") === -1 && query.indexOf("[") === -1 && query.indexOf(":") === -1 && query.indexOf(">") === -1) {
+    return element.id === query.slice(1);
+  }
+  if (query[0] === "." && query.indexOf(" ") === -1 && query.indexOf("#") === -1 && query.indexOf("[") === -1 && query.indexOf(":") === -1 && query.indexOf(">") === -1) {
+    return element.classList.contains(query.slice(1));
+  }
+  if (isTagName(query)) {
+    return element.tagName.toLowerCase() === query.toLowerCase();
+  }
+  if (query[0] === "[" && query[query.length - 1] === "]" && query.indexOf(" ") === -1 && query.indexOf(":") === -1) {
+    const attr = query.slice(1, -1);
+    const eqIndex = attr.indexOf("=");
+    if (eqIndex === -1) {
+      return element.hasAttribute(attr);
+    }
+    const attrName = attr.slice(0, eqIndex);
+    const attrValue = attr.slice(eqIndex + 1).replace(/^["']|["']$/g, "");
+    return element.getAttribute(attrName) === attrValue;
+  }
+  return element.matches(query);
+}
+// src/util/dom.ts
+function walkParents(target, fn) {
+  let current = target.parentNode;
+  while (current !== null) {
+    const result = fn(current);
+    if (result) {
+      return true;
+    }
+    if (isShadowRoot(current)) {
+      current = current.host;
+    } else {
+      current = current.parentNode;
+    }
+  }
+  return false;
+}
+function isElement(value) {
+  return value !== null && typeof value === "object" && value instanceof Element;
+}
+function isHTMLElement(value) {
+  return value !== null && typeof value === "object" && value instanceof HTMLElement;
+}
+function isHTMLTemplateElement(value) {
+  return value !== null && typeof value === "object" && value instanceof HTMLTemplateElement;
+}
+function isShadowRoot(value) {
+  return value !== null && typeof value === "object" && value instanceof ShadowRoot;
+}
+function isNode(value) {
+  return value !== null && typeof value === "object" && value instanceof Node;
+}
+function isComment(value) {
+  return value !== null && typeof value === "object" && value instanceof Comment;
+}
+
+// src/template/constant.ts
+var REF_ATTR = "data-node-ref";
+
+// src/template/syntax.ts
 var PREFIX_MAPPING = {
   ["@" /* Attributes */]: "attr",
   ["$" /* State */]: "state",
@@ -742,7 +594,12 @@ var PREFIX_MAPPING = {
   ["#" /* Item */]: "item"
 };
 var prefixMapping = new Map(Object.entries(PREFIX_MAPPING));
+var parsedNotationCache = new LRUCache;
 function parseNotation(notation) {
+  const cached = parsedNotationCache.get(notation);
+  if (cached) {
+    return cached;
+  }
   let notModifier = false;
   let pathPart = "";
   const computedPath = [];
@@ -753,7 +610,7 @@ function parseNotation(notation) {
     } else if (isFirst) {
       const prefix = prefixMapping.get(char);
       if (!prefix) {
-        throw new PaletteError(201 /* TEMPLATE_INVALID_NOTATION */, notation);
+        throw new PaletteError(201 /* TEMPLATE_INVALID_NOTATION_SYNTAX */, notation);
       }
       computedPath.push(prefix);
       isFirst = false;
@@ -762,63 +619,38 @@ function parseNotation(notation) {
         computedPath.push(pathPart);
         pathPart = "";
       } else {
-        throw new PaletteError(201 /* TEMPLATE_INVALID_NOTATION */, notation);
+        throw new PaletteError(201 /* TEMPLATE_INVALID_NOTATION_SYNTAX */, notation);
       }
     } else {
       pathPart += char;
     }
   }
   if (!pathPart.length) {
-    throw new PaletteError(201 /* TEMPLATE_INVALID_NOTATION */, notation);
+    throw new PaletteError(201 /* TEMPLATE_INVALID_NOTATION_SYNTAX */, notation);
   }
   computedPath.push(pathPart);
   if (computedPath.length < 2) {
-    throw new PaletteError(201 /* TEMPLATE_INVALID_NOTATION */, notation);
+    throw new PaletteError(201 /* TEMPLATE_INVALID_NOTATION_SYNTAX */, notation);
   }
-  return {
+  const parsedNotation = {
     base: notation,
     path: computedPath,
     modifiers: notModifier ? { not: true } : undefined
   };
+  parsedNotationCache.set(notation, parsedNotation);
+  return parsedNotation;
 }
+var valueAccessorCache = new LRUCache;
 function buildValueAccessor(notation) {
-  const { path, modifiers } = notation;
+  const { path, modifiers, base } = notation;
+  const cached = valueAccessorCache.get(base);
+  if (cached) {
+    return cached;
+  }
   if (path.length < 2) {
     throw new PaletteError(0 /* INVARIANT */);
   }
-  if (path.length === 2) {
-    const [firstKey, secondKey] = path;
-    if (firstKey === undefined || secondKey === undefined) {
-      throw new PaletteError(0 /* INVARIANT */);
-    }
-    return (source) => {
-      const value = source?.[firstKey]?.[secondKey] ?? null;
-      if (modifiers?.not) {
-        if (firstKey === "attr") {
-          return value !== "" && !value;
-        }
-        return !value;
-      }
-      return value;
-    };
-  }
-  if (path.length === 3) {
-    const [firstKey, secondKey, thirdKey] = path;
-    if (firstKey === undefined || secondKey === undefined || thirdKey === undefined) {
-      throw new PaletteError(0 /* INVARIANT */);
-    }
-    return (source) => {
-      const value = source?.[firstKey]?.[secondKey]?.[thirdKey] ?? null;
-      if (modifiers?.not) {
-        if (firstKey === "attr") {
-          return value !== "" && !value;
-        }
-        return !value;
-      }
-      return value;
-    };
-  }
-  return (source) => {
+  const accessor = (source) => {
     let current = source;
     for (const part of path) {
       if (!current || typeof current !== "object") {
@@ -834,45 +666,67 @@ function buildValueAccessor(notation) {
     }
     return current;
   };
+  valueAccessorCache.set(base, accessor);
+  return accessor;
 }
 
-// src/template/build.ts
-var REF_ATTR = "data-node-ref";
+// src/template/util.ts
+function htmlStringToTemplate(html) {
+  const fragment = htmlToFragment(html);
+  const templateElement = document.createElement("template");
+  templateElement.content.appendChild(fragment);
+  return new Template(templateElement);
+}
 function collectOperableNodes(fragment) {
   const walker = document.createTreeWalker(fragment, NodeFilter.SHOW_ELEMENT);
   const knownIgnores = new Set;
   const nodes = [];
   let currentNode = walker.nextNode();
   while (currentNode) {
-    if (!(currentNode instanceof HTMLElement)) {
+    if (!isHTMLElement(currentNode)) {
       currentNode = walker.nextNode();
       continue;
     }
     let parent = currentNode.parentNode;
-    let isInList = false;
-    while (parent && !isInList) {
-      if (knownIgnores.has(parent) || parent instanceof HTMLElement && parent.hasAttribute("::each" /* Each */)) {
-        isInList = true;
+    let isInoperable = false;
+    while (parent && !isInoperable) {
+      if (knownIgnores.has(parent) || isHTMLElement(parent) && (parent.hasAttribute("::each" /* Each */) || parent.hasAttribute("::if" /* If */) || parent.hasAttribute("::else" /* Else */) || parent.hasAttribute("::else-if" /* ElseIf */))) {
+        isInoperable = true;
         knownIgnores.add(currentNode);
         break;
       }
       parent = parent.parentNode;
     }
-    if (!isInList) {
+    if (!isInoperable) {
       nodes.push(currentNode);
     }
     currentNode = walker.nextNode();
   }
   return nodes;
 }
+
+// src/template/compile.ts
+var requiresNotation = new Set([
+  "::each" /* Each */,
+  "::if" /* If */,
+  "::else-if" /* ElseIf */,
+  "::key" /* Key */,
+  "::swap" /* Swap */,
+  "::tag" /* Tag */
+]);
+var compiledTemplateCache = new LRUCache;
 function compileTemplate(source) {
+  const cachedTemplate = compiledTemplateCache.get(source);
+  if (cachedTemplate) {
+    return cachedTemplate;
+  }
   const parsedNotations = new Map;
-  const schemes = [];
-  let elementId = 0;
+  const compiledSchemes = [];
+  let nextNodeRef = 0;
   const ensureNodeRef = (el) => {
     let ref = el.getAttribute(REF_ATTR);
     if (!ref) {
-      ref = `el-${elementId++}`;
+      ref = `el-${nextNodeRef++}`;
       el.setAttribute(REF_ATTR, ref);
     }
     return ref;
@@ -880,26 +734,39 @@ function compileTemplate(source) {
   const clonedTemplateElement = source.content.cloneNode(true);
   const nodes = collectOperableNodes(clonedTemplateElement);
   for (const node of nodes) {
-    const attributes2 = new Map;
-    for (const name of node.getAttributeNames()) {
-      attributes2.set(name, node.getAttribute(name));
-    }
-    for (const [attributeName, attributeValue] of attributes2) {
+    const allAttributesForNode = node.getAttributeNames();
+    for (const attributeName of allAttributesForNode) {
+      const attributeValue = node.getAttribute(attributeName);
       if (attributeValue === null || attributeName[0] !== ":") {
         continue;
       }
+      if (attributeName === "::key" /* Key */) {
+        if (!allAttributesForNode.includes("::each" /* Each */)) {
+          throw new PaletteError(208 /* TEMPLATE_INVALID_KEY_DIRECTIVE */);
+        }
+        continue;
+      }
+      if (requiresNotation.has(attributeName) && attributeValue === "") {
+        throw new PaletteError(202 /* TEMPLATE_MISSING_NOTATION */, attributeName);
+      }
       let notation = parsedNotations.get(attributeValue);
       if (notation === undefined) {
         notation = parseNotation(attributeValue);
         parsedNotations.set(attributeValue, notation);
       }
       node.removeAttribute(attributeName);
-      if (attributeName === "::key" /* Key */) {
-        continue;
-      }
-      if (attributeName === "::tag" /* Tag */) {
-        schemes.push({
-          type: "tag",
+      if (attributeName[1] !== ":") {
+        const bindName = attributeName.slice(1);
+        const scheme = {
+          type: "attr" /* Attribute */,
+          notation: parseNotation(attributeValue),
+          attribute: bindName,
+          nodeRef: ensureNodeRef(node)
+        };
+        compiledSchemes.push(scheme);
+      } else if (attributeName === "::tag" /* Tag */) {
+        compiledSchemes.push({
+          type: "tag" /* Tag */,
           notation,
           nodeRef: ensureNodeRef(node)
         });
@@ -907,7 +774,7 @@ function compileTemplate(source) {
         const nodeRef = ensureNodeRef(node);
         const keyNotation = node.getAttribute("::key" /* Key */);
         if (keyNotation === null) {
-          throw new PaletteError(206 /* TEMPLATE_MISSING_LIST_KEY */);
+          throw new PaletteError(205 /* TEMPLATE_MISSING_LIST_KEY */);
         }
         node.removeAttribute("::key" /* Key */);
         const listContentHtml = node.innerHTML;
@@ -915,31 +782,72 @@ function compileTemplate(source) {
           node.removeChild(node.firstChild);
         }
         const scheme = {
-          type: "each",
+          type: "list" /* List */,
           notation,
           keyNotation: parseNotation(keyNotation),
           nodeRef,
           listContentHtml
         };
-        schemes.push(scheme);
+        compiledSchemes.push(scheme);
       } else if (attributeName === "::swap" /* Swap */) {
         const scheme = {
-          type: "swap",
+          type: "swap" /* Swap */,
           notation,
           nodeRef: ensureNodeRef(node)
         };
-        schemes.push(scheme);
-      } else if (isBoundAttribute(attributeName)) {
-        const bindName = attributeName.slice(1);
+        compiledSchemes.push(scheme);
+      } else if (attributeName === "::if" /* If */) {
         const scheme = {
-          type: "attr",
+          type: "cond" /* Conditional */,
+          branches: []
+        };
+        node.removeAttribute("::if" /* If */);
+        const ifBranch = {
+          type: "::if" /* If */,
           notation,
-          attribute: bindName,
-          nodeRef: ensureNodeRef(node)
+          branchRootRef: ensureNodeRef(node),
+          branchTemplateHTML: node.innerHTML
         };
-        schemes.push(scheme);
+        scheme.branches.push(ifBranch);
+        let condNode = node.nextElementSibling;
+        while (condNode?.hasAttribute("::else-if" /* ElseIf */)) {
+          if (!isHTMLElement(condNode)) {
+            break;
+          }
+          const baseElseIfNotation = condNode.getAttribute("::else-if" /* ElseIf */);
+          if (!baseElseIfNotation) {
+            throw new PaletteError(202 /* TEMPLATE_MISSING_NOTATION */, "::else-if" /* ElseIf */);
+          }
+          let parsedElseIfNotation = parsedNotations.get(baseElseIfNotation);
+          if (parsedElseIfNotation === undefined) {
+            parsedElseIfNotation = parseNotation(baseElseIfNotation);
+            parsedNotations.set(baseElseIfNotation, parsedElseIfNotation);
+          }
+          condNode.removeAttribute("::else-if" /* ElseIf */);
+          const elseIfBranch = {
+            type: "::else-if" /* ElseIf */,
+            notation: parsedElseIfNotation,
+            branchRootRef: ensureNodeRef(condNode),
+            branchTemplateHTML: condNode.innerHTML
+          };
+          scheme.branches.push(elseIfBranch);
+          condNode = condNode.nextElementSibling;
+        }
+        if (condNode && isHTMLElement(condNode) && condNode?.hasAttribute("::else" /* Else */)) {
+          condNode.removeAttribute("::else" /* Else */);
+          const elseBranch = {
+            type: "::else" /* Else */,
+            branchRootRef: ensureNodeRef(condNode),
+            branchTemplateHTML: condNode.innerHTML
+          };
+          scheme.branches.push(elseBranch);
+        }
+        compiledSchemes.push(scheme);
       } else {
         if (true) {
+          if (attributeName === "::else" /* Else */ || attributeName === "::else-if" /* ElseIf */) {
+            throw new PaletteError(207 /* TEMPLATE_INVALID_CONDITIONAL */);
+          }
           console.warn(`Template: ${attributeName} is not a valid directive`);
         }
       }
@@ -951,117 +859,110 @@ function compileTemplate(source) {
   }
   const temp = document.createElement("div");
   temp.appendChild(clonedTemplateElement.cloneNode(true));
-  const html2 = temp.innerHTML;
+  const html = temp.innerHTML;
   const compiled = {
-    html: html2,
-    schemes,
+    html,
+    schemes: compiledSchemes,
     notations
   };
+  compiledTemplateCache.set(source, compiled);
+  saveFragment(html, clonedTemplateElement);
   return compiled;
 }
-function prepareCompiledTemplate(compiled, prototypeFragment) {
-  const plansByNotation = new Map;
-  const notationAccessors = new Map;
-  const nodeRefs = new Map;
-  for (const [notation, parsed] of Object.entries(compiled.notations)) {
-    notationAccessors.set(notation, buildValueAccessor(parsed));
-  }
-  const fragment = prototypeFragment ?? htmlToFragment(compiled.html);
-  const walker = document.createTreeWalker(fragment, NodeFilter.SHOW_ELEMENT, {
-    acceptNode(node) {
-      return node.hasAttribute(REF_ATTR) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+
+// src/helper/css.ts
+function parseCSSTemplateStringValue(val) {
+  if (typeof val === "function") {
+    const tagName = val.tagName;
+    if (!isTagName(tagName)) {
+      throw new PaletteError(203 /* TEMPLATE_INVALID_COMPONENT */, val.name, val.tagName);
     }
-  });
-  let markNode = walker.nextNode();
-  while (markNode) {
-    if (!(markNode instanceof HTMLElement)) {
+    return tagName;
+  }
+  if (typeof val === "string") {
+    return val;
+  }
+  throw new PaletteError(200 /* TEMPLATE_INVALID_VALUE */, String(val));
+}
+function css(strings, ...values) {
+  let result = strings[0] ?? "";
+  for (let i = 0;i < values.length; i++) {
+    const nextVal = values[i] ?? "";
+    const nextStr = strings[i + 1] ?? "";
+    result += parseCSSTemplateStringValue(nextVal);
+    result += nextStr;
+  }
+  const sheet = new CSSStyleSheet;
+  sheet.replaceSync(result);
+  return sheet;
+}
+function classify(...args) {
+  let resultString = "";
+  for (let index = 0;index < args.length; index++) {
+    const argument = args[index];
+    if (!argument) {
       continue;
     }
-    const ref = markNode.getAttribute(REF_ATTR);
-    if (ref === null) {
-      throw new PaletteError(0 /* INVARIANT */);
-    }
-    nodeRefs.set(ref, markNode);
-    markNode.removeAttribute(REF_ATTR);
-    markNode = walker.nextNode();
-  }
-  const associatePlan = (plan, notation) => {
-    let notationPlans = plansByNotation.get(notation);
-    if (!notationPlans) {
-      notationPlans = new Set;
-      plansByNotation.set(notation, notationPlans);
+    if (typeof argument === "string" || typeof argument === "number") {
+      if (resultString) {
+        resultString += " ";
+      }
+      resultString += argument;
+      continue;
     }
-    notationPlans.add(plan);
-  };
-  const getByNodeRef = (nodeRef) => {
-    const cached = nodeRefs.get(nodeRef);
-    if (cached) {
-      return cached;
+    if (Array.isArray(argument)) {
+      const nestedResult = classify(...argument);
+      if (nestedResult) {
+        if (resultString) {
+          resultString += " ";
+        }
+        resultString += nestedResult;
+      }
+      continue;
     }
-    throw new PaletteError(204 /* TEMPLATE_INVALID_NODE_REF */);
-  };
-  for (const scheme of compiled.schemes) {
-    if (scheme.type === "each") {
-      const itemPrototype = getByNodeRef(scheme.nodeRef);
-      const listContainer = itemPrototype.parentElement;
-      if (!listContainer) {
-        throw new PaletteError(205 /* TEMPLATE_MISSING_LIST_PARENT */);
+    if (typeof argument === "object") {
+      for (const className in argument) {
+        if (argument[className]) {
+          if (resultString) {
+            resultString += " ";
+          }
+          resultString += className;
+        }
       }
-      const startMarker = document.createComment("list-start");
-      const endMarker = document.createComment("list-end");
-      listContainer.insertBefore(startMarker, itemPrototype);
-      listContainer.insertBefore(endMarker, itemPrototype.nextSibling);
-      const rowRootElement = itemPrototype.cloneNode(false);
-      const templateContentFragment = htmlToFragment(scheme.listContentHtml);
-      const rowTemplateElement = document.createElement("template");
-      rowTemplateElement.content.appendChild(templateContentFragment);
-      itemPrototype.remove();
-      const plan = {
-        type: "each",
-        notation: scheme.notation,
-        keyNotation: scheme.keyNotation,
-        listContainerElement: listContainer,
-        rowTemplateElement,
-        rowRootElement,
-        startMarker,
-        endMarker,
-        rowTemplatesByRoot: new WeakMap,
-        rowRootsByKey: new Map
-      };
-      associatePlan(plan, scheme.notation.base);
-    } else if (scheme.type === "swap") {
-      const plan = {
-        type: "swap",
-        notation: scheme.notation,
-        node: getByNodeRef(scheme.nodeRef)
-      };
-      associatePlan(plan, scheme.notation.base);
-    } else if (scheme.type === "tag") {
-      const plan = {
-        type: "tag",
-        notation: scheme.notation,
-        node: getByNodeRef(scheme.nodeRef)
-      };
-      associatePlan(plan, plan.notation.base);
-    } else if (scheme.type === "attr") {
-      const plan = {
-        type: "attr",
-        attribute: scheme.attribute,
-        notation: scheme.notation,
-        node: getByNodeRef(scheme.nodeRef)
-      };
-      associatePlan(plan, plan.notation.base);
     }
   }
-  return {
-    plansByNotation,
-    notationAccessors,
-    fragment
-  };
+  return resultString;
 }
-
-// src/template/jobs.ts
+// src/helper/html.ts
+function parseTemplateStringValue(val) {
+  if (isHTMLTemplateElement(val)) {
+    return val.innerHTML;
+  }
+  if (Component.isComponentClass(val)) {
+    const tagName = val.tagName;
+    if (!isTagName(tagName)) {
+      throw new PaletteError(203 /* TEMPLATE_INVALID_COMPONENT */, val.name, val.tagName);
+    }
+    return tagName;
+  }
+  if (typeof val === "string") {
+    return `<span ::swap="${val}"></span>`;
+  }
+  throw new PaletteError(200 /* TEMPLATE_INVALID_VALUE */, String(val));
+}
+function html(strings, ...values) {
+  const fullString = strings.reduce((acc, str, i) => {
+    const parsedValue = values[i] ? `${parseTemplateStringValue(values[i])}` : "";
+    return acc + str + parsedValue;
+  }, "");
+  const templateElement = document.createElement("template");
+  templateElement.innerHTML = fullString;
+  return templateElement;
+}
+// src/template/jobs/common.ts
 var SKIPPED_JOB = Symbol("noop");
+
+// src/template/jobs/attribute.ts
 function prepareAttributeJob(plan, values) {
   const rawValue = values.get(plan.notation.base);
   let value = typeof rawValue === "function" ? rawValue(plan.node) : rawValue;
@@ -1077,13 +978,165 @@ function prepareAttributeJob(plan, values) {
 }
 function runAttributeJobs(jobs) {
   for (const [node, name, value] of jobs) {
-    if (value === null) {
-      node.removeAttribute(name);
+    applyAttribute(node, name, value);
+  }
+}
+
+// src/template/jobs/conditional.ts
+function prepareConditionalRenderJob(plan, values) {
+  let displayedBranch = null;
+  for (const branch of plan.branches) {
+    if (branch.type === "::else" /* Else */) {
+      displayedBranch = branch;
+      break;
     } else {
-      node.setAttribute(name, value);
+      const rawValue = values.get(branch.notation.base);
+      const value = typeof rawValue === "function" ? rawValue(plan.start) : rawValue;
+      if (value) {
+        displayedBranch = branch;
+        break;
+      }
+    }
+  }
+  return [plan, displayedBranch, values];
+}
+function runConditionalRenderJobs(jobs) {
+  for (const [plan, branch, values] of jobs) {
+    const parent = plan.start.parentNode;
+    if (!parent) {
+      throw new PaletteError(209 /* TEMPLATE_PARENT_REQUIRED */);
+    }
+    if (branch === null || !Object.is(plan.currentRoot, branch.branchRoot)) {
+      const nodesToRemove = new Set;
+      let node = plan.start;
+      while (node && node !== plan.end) {
+        if (isHTMLElement(node)) {
+          nodesToRemove.add(node);
+        }
+        node = node.nextSibling;
+      }
+      for (const toRemove of nodesToRemove) {
+        parent.removeChild(toRemove);
+      }
+      if (branch) {
+        parent.insertBefore(branch.branchRoot, plan.end);
+      }
     }
+    if (branch === null) {
+      continue;
+    }
+    branch.branchTemplate.renderWithValues(branch.branchRoot, values);
   }
 }
+
+// src/template/jobs/list.ts
+function fetchListData(plan, values) {
+  const notationValue = values.get(plan.notation.base);
+  const evaluatedValue = typeof notationValue === "function" ? notationValue(plan.startMarker.parentNode) : notationValue;
+  if (evaluatedValue === null || evaluatedValue === undefined) {
+    return [];
+  }
+  if (Array.isArray(evaluatedValue)) {
+    return evaluatedValue;
+  }
+  throw new PaletteError(204 /* TEMPLATE_INVALID_LIST_DATA */);
+}
+function collectHTMLElements(start, end) {
+  let node = start;
+  const nodeSet = new Set;
+  while (node && node !== end) {
+    if (isHTMLElement(node)) {
+      nodeSet.add(node);
+    }
+    node = node.nextSibling;
+  }
+  return nodeSet;
+}
+function prepareListRenderJob(plan, values) {
+  const listData = fetchListData(plan, values);
+  if (listData.length === 0) {
+    return [plan, []];
+  }
+  const {
+    rowTemplatesByRoot,
+    rowTemplateElement,
+    rowRootPrototype: rowRootElement
+  } = plan;
+  const keyAccessor = buildValueAccessor(plan.keyNotation);
+  const listRenderContexts = new Map;
+  for (const item of listData) {
+    const context = {
+      item
+    };
+    const key = keyAccessor(context);
+    if (listRenderContexts.has(key)) {
+      throw new PaletteError(206 /* TEMPLATE_DUPLICATE_LIST_KEY */, String(key));
+    }
+    let rowRoot = plan.rowRootsByKey.get(key);
+    if (rowRoot === undefined) {
+      rowRoot = rowRootElement.cloneNode(false);
+      plan.rowRootsByKey.set(key, rowRoot);
+    }
+    let rowTemplate = rowTemplatesByRoot.get(rowRoot);
+    if (rowTemplate === undefined) {
+      rowTemplate = new Template(rowTemplateElement);
+      rowTemplatesByRoot.set(rowRoot, rowTemplate);
+    }
+    const jobItem = {
+      context,
+      root: rowRoot,
+      template: rowTemplate,
+      attrs: formatAttributeRecord(item)
+    };
+    listRenderContexts.set(key, jobItem);
+  }
+  for (const [key, root] of plan.rowRootsByKey) {
+    if (!listRenderContexts.has(key)) {
+      plan.rowRootsByKey.delete(key);
+      plan.rowTemplatesByRoot.delete(root);
+    }
+  }
+  return [plan, Array.from(listRenderContexts.values())];
+}
+function runListRenderJobs(jobs) {
+  for (const [plan, renderItems] of jobs) {
+    const { endMarker, listContainer: listContainerElement } = plan;
+    if (renderItems.length === 0) {
+      for (const root of plan.rowRootsByKey.values()) {
+        root.remove();
+      }
+      plan.rowRootsByKey.clear();
+      continue;
+    }
+    const existingDOMNodes = Array.from(collectHTMLElements(plan.startMarker, plan.endMarker));
+    const rootsToKeep = new Set;
+    let existingDOMNodeIdx = 0;
+    for (const renderItem of renderItems) {
+      const { root, attrs: attrMap, context, template } = renderItem;
+      const existingDOMNode = existingDOMNodes[existingDOMNodeIdx];
+      applyElementAttributes(root, attrMap);
+      template.render(root, context);
+      rootsToKeep.add(root);
+      if (Object.is(existingDOMNode, root)) {
+        existingDOMNodeIdx += 1;
+        continue;
+      }
+      if (!existingDOMNode) {
+        listContainerElement.insertBefore(root, endMarker);
+        continue;
+      }
+      listContainerElement.insertBefore(root, existingDOMNode);
+    }
+    for (const root of existingDOMNodes) {
+      if (!rootsToKeep.has(root)) {
+        root.remove();
+        plan.rowTemplatesByRoot.delete(root);
+      }
+    }
+  }
+}
+
+// src/template/jobs/swap.ts
 function prepareContentSwapJob(plan, values) {
   const rawValue = values.get(plan.notation.base);
   const value = typeof rawValue === "function" ? rawValue(plan.node) : rawValue;
@@ -1094,11 +1147,11 @@ function prepareContentSwapJob(plan, values) {
     }
     return [plan, document.createTextNode(asStr)];
   } else if (value === null || value === undefined) {
-    if (plan.node instanceof Comment) {
+    if (isComment(plan.node)) {
       return SKIPPED_JOB;
     }
     return [plan, document.createComment("empty")];
-  } else if (value instanceof HTMLElement) {
+  } else if (isHTMLElement(value)) {
     if (Object.is(plan.node, value)) {
       return SKIPPED_JOB;
     }
@@ -1117,6 +1170,22 @@ function runContentSwapJobs(jobs) {
     plan.node = replace;
   }
 }
+
+// src/template/jobs/tag.ts
+function changeTag($target, newTag) {
+  const $newEl = document.createElement(newTag);
+  while ($target.firstChild !== null) {
+    $newEl.appendChild($target.firstChild);
+  }
+  for (const attrName of $target.getAttributeNames()) {
+    const val = $target.getAttribute(attrName);
+    if (val !== null) {
+      $newEl.setAttribute(attrName, val);
+    }
+  }
+  $target.replaceWith($newEl);
+  return $newEl;
+}
 function prepareTagChangeJob(plan, values) {
   const rawValue = values.get(plan.notation.base) ?? "";
   const value = typeof rawValue === "function" ? rawValue(plan.node) : rawValue;
@@ -1132,128 +1201,231 @@ function runTagChangeJobs(jobs) {
     plan.node = changeTag(plan.node, nextTag);
   }
 }
-function fetchListData(plan, values) {
-  const notationValue = values.get(plan.notation.base);
-  const evaluatedValue = typeof notationValue === "function" ? notationValue(plan.startMarker.parentNode) : notationValue;
-  if (evaluatedValue === null || evaluatedValue === undefined) {
-    return [];
-  }
-  if (Array.isArray(evaluatedValue)) {
-    return evaluatedValue;
-  }
-  throw new PaletteError(203 /* TEMPLATE_INVALID_LIST */);
-}
-function collectHTMLElements(start, end) {
-  let node = start;
-  const nodeSet = new Set;
-  while (node && node !== end) {
-    if (node instanceof HTMLElement) {
-      nodeSet.add(node);
+
+// src/template/jobs/index.ts
+function createJobsFromPlans(plans, newValues) {
+  const jobs = {
+    conditionals: [],
+    attributes: [],
+    swaps: [],
+    tags: [],
+    lists: []
+  };
+  for (const plan of plans) {
+    switch (plan.type) {
+      case "cond" /* Conditional */: {
+        const job = prepareConditionalRenderJob(plan, newValues);
+        if (job !== SKIPPED_JOB) {
+          jobs.conditionals.push(job);
+        }
+        break;
+      }
+      case "attr" /* Attribute */: {
+        const job = prepareAttributeJob(plan, newValues);
+        if (job !== SKIPPED_JOB) {
+          jobs.attributes.push(job);
+        }
+        break;
+      }
+      case "list" /* List */: {
+        const job = prepareListRenderJob(plan, newValues);
+        if (job !== SKIPPED_JOB) {
+          jobs.lists.push(job);
+        }
+        break;
+      }
+      case "swap" /* Swap */: {
+        const job = prepareContentSwapJob(plan, newValues);
+        if (job !== SKIPPED_JOB) {
+          jobs.swaps.push(job);
+        }
+        break;
+      }
+      case "tag" /* Tag */: {
+        const job = prepareTagChangeJob(plan, newValues);
+        if (job !== SKIPPED_JOB) {
+          jobs.tags.push(job);
+        }
+        break;
+      }
+      default:
+        throw new PaletteError(0 /* INVARIANT */);
     }
-    node = node.nextSibling;
   }
-  return nodeSet;
+  return jobs;
 }
-function prepareListRenderJob(plan, values) {
-  const listData = fetchListData(plan, values);
-  if (listData.length === 0) {
-    return [plan, []];
+function executeRenderJobs(jobs) {
+  runConditionalRenderJobs(jobs.conditionals);
+  runAttributeJobs(jobs.attributes);
+  runListRenderJobs(jobs.lists);
+  runContentSwapJobs(jobs.swaps);
+  runTagChangeJobs(jobs.tags);
+}
+
+// src/template/prepare.ts
+var requireParentNode = (node) => {
+  if (!node.parentNode) {
+    throw new PaletteError(209 /* TEMPLATE_PARENT_REQUIRED */);
   }
-  const { rowTemplatesByRoot, rowTemplateElement, rowRootElement } = plan;
-  const keyAccessor = buildValueAccessor(plan.keyNotation);
-  const listRenderContexts = new Map;
-  for (const item of listData) {
-    const context = {
-      item
-    };
-    const key = keyAccessor(context);
-    if (listRenderContexts.has(key)) {
-      throw new PaletteError(207 /* TEMPLATE_DUPLICATE_LIST_KEY */, String(key));
+  return node.parentNode;
+};
+var createCommentBefore = (node, text = "") => {
+  const parent = requireParentNode(node);
+  const comment = document.createComment(text);
+  parent.insertBefore(comment, node);
+  return comment;
+};
+var createCommentAfter = (node, text = "") => {
+  const parent = requireParentNode(node);
+  const comment = document.createComment(text);
+  parent.insertBefore(comment, node.nextSibling);
+  return comment;
+};
+function prepareCompiledTemplate(compiled, prototypeFragment) {
+  const plansByNotation = new Map;
+  const notationAccessors = new Map;
+  const subtemplates = new Set;
+  const nodeRefs = new Map;
+  for (const [notation, parsed] of Object.entries(compiled.notations)) {
+    notationAccessors.set(notation, buildValueAccessor(parsed));
+  }
+  const fragment = prototypeFragment ?? htmlToFragment(compiled.html);
+  const walker = document.createTreeWalker(fragment, NodeFilter.SHOW_ELEMENT, {
+    acceptNode(node) {
+      return node.hasAttribute(REF_ATTR) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
     }
-    let rowRoot = plan.rowRootsByKey.get(key);
-    if (rowRoot === undefined) {
-      rowRoot = rowRootElement.cloneNode(false);
-      plan.rowRootsByKey.set(key, rowRoot);
+  });
+  let markNode = walker.nextNode();
+  while (markNode) {
+    if (!isHTMLElement(markNode)) {
+      continue;
     }
-    let rowTemplate = rowTemplatesByRoot.get(rowRoot);
-    if (rowTemplate === undefined) {
-      rowTemplate = new Template(rowTemplateElement);
-      rowTemplatesByRoot.set(rowRoot, rowTemplate);
+    const ref = markNode.getAttribute(REF_ATTR);
+    if (ref === null) {
+      throw new PaletteError(0 /* INVARIANT */);
     }
-    const jobItem = {
-      context,
-      root: rowRoot,
-      template: rowTemplate,
-      attrMap: createAttributeMap(item)
-    };
-    listRenderContexts.set(key, jobItem);
+    nodeRefs.set(ref, markNode);
+    markNode.removeAttribute(REF_ATTR);
+    markNode = walker.nextNode();
   }
-  for (const [key, root] of plan.rowRootsByKey) {
-    if (!listRenderContexts.has(key)) {
-      plan.rowRootsByKey.delete(key);
-      plan.rowTemplatesByRoot.delete(root);
+  const associatePlan = (plan, notation) => {
+    let notationPlans = plansByNotation.get(notation);
+    if (!notationPlans) {
+      notationPlans = new Set;
+      plansByNotation.set(notation, notationPlans);
     }
-  }
-  return [plan, Array.from(listRenderContexts.values())];
-}
-function runListRenderJobs(jobs) {
-  for (const [plan, renderItems] of jobs) {
-    const { endMarker, listContainerElement } = plan;
-    if (renderItems.length === 0) {
-      for (const root of plan.rowRootsByKey.values()) {
-        root.remove();
-      }
-      plan.rowRootsByKey.clear();
-      continue;
+    notationPlans.add(plan);
+  };
+  const getByNodeRef = (nodeRef) => {
+    const cached = nodeRefs.get(nodeRef);
+    if (cached) {
+      return cached;
     }
-    const existingDOMNodes = Array.from(collectHTMLElements(plan.startMarker, plan.endMarker));
-    const rootsToKeep = new Set;
-    let existingDOMNodeIdx = 0;
-    for (const renderItem of renderItems) {
-      const { root, attrMap, context, template } = renderItem;
-      const existingDOMNode = existingDOMNodes[existingDOMNodeIdx];
-      applyAttributeMap(root, attrMap);
-      template.render(root, context);
-      rootsToKeep.add(root);
-      if (Object.is(existingDOMNode, root)) {
-        existingDOMNodeIdx += 1;
-        continue;
-      }
-      if (!existingDOMNode) {
-        listContainerElement.insertBefore(root, endMarker);
-        continue;
+    throw new PaletteError(3 /* MISSING_NODE_REF */);
+  };
+  for (const scheme of compiled.schemes) {
+    if (scheme.type === "list" /* List */) {
+      const itemPrototype = getByNodeRef(scheme.nodeRef);
+      const listParentNode = requireParentNode(itemPrototype);
+      const rowRootPrototype = itemPrototype.cloneNode(false);
+      const startMarker = createCommentBefore(itemPrototype);
+      const endMarker = createCommentAfter(itemPrototype);
+      itemPrototype.remove();
+      const templateContentFragment = htmlToFragment(scheme.listContentHtml);
+      const rowTemplateElement = document.createElement("template");
+      rowTemplateElement.content.appendChild(templateContentFragment);
+      const plan = {
+        type: "list" /* List */,
+        notation: scheme.notation,
+        keyNotation: scheme.keyNotation,
+        listContainer: listParentNode,
+        rowTemplateElement,
+        rowRootPrototype,
+        startMarker,
+        endMarker,
+        rowTemplatesByRoot: new WeakMap,
+        rowRootsByKey: new Map
+      };
+      associatePlan(plan, scheme.notation.base);
+    } else if (scheme.type === "cond" /* Conditional */) {
+      const firstBranch = scheme.branches[0];
+      if (!firstBranch) {
+        throw new PaletteError(0 /* INVARIANT */);
       }
-      listContainerElement.insertBefore(root, existingDOMNode);
-    }
-    for (const root of existingDOMNodes) {
-      if (!rootsToKeep.has(root)) {
-        root.remove();
-        plan.rowTemplatesByRoot.delete(root);
+      const firstBranchRoot = getByNodeRef(firstBranch.branchRootRef);
+      const startComment = createCommentBefore(firstBranchRoot);
+      const lastBranch = scheme.branches[scheme.branches.length - 1];
+      const lastBranchRoot = getByNodeRef(lastBranch.branchRootRef);
+      const endComment = createCommentAfter(lastBranchRoot);
+      const plan = {
+        type: "cond" /* Conditional */,
+        start: startComment,
+        end: endComment,
+        branches: []
+      };
+      for (const branch of scheme.branches) {
+        if (branch.type === "::if" /* If */ || branch.type === "::else-if" /* ElseIf */) {
+          const branchRoot = getByNodeRef(branch.branchRootRef);
+          const branchTemplate = htmlStringToTemplate(branch.branchTemplateHTML);
+          subtemplates.add(branchTemplate);
+          plan.branches.push({
+            type: branch.type,
+            notation: branch.notation,
+            branchRoot: getByNodeRef(branch.branchRootRef),
+            branchTemplate: htmlStringToTemplate(branch.branchTemplateHTML)
+          });
+          associatePlan(plan, branch.notation.base);
+          branchRoot.remove();
+        } else {
+          plan.branches.push({
+            type: branch.type,
+            branchRoot: getByNodeRef(branch.branchRootRef),
+            branchTemplate: htmlStringToTemplate(branch.branchTemplateHTML)
+          });
+        }
       }
+    } else if (scheme.type === "swap" /* Swap */ || scheme.type === "tag" /* Tag */) {
+      const plan = {
+        type: scheme.type,
+        notation: scheme.notation,
+        node: getByNodeRef(scheme.nodeRef)
+      };
+      associatePlan(plan, scheme.notation.base);
+    } else if (scheme.type === "attr" /* Attribute */) {
+      const plan = {
+        type: "attr" /* Attribute */,
+        attribute: scheme.attribute,
+        notation: scheme.notation,
+        node: getByNodeRef(scheme.nodeRef)
+      };
+      associatePlan(plan, plan.notation.base);
     }
   }
-}
-
-// src/template/template.ts
-var compileCache = new LRUCache;
-if (typeof window !== "undefined") {
-  window.__PALETTE_DEVTOOLS__ = {
-    dumpCacheMetrics: () => {
-      console.log("Compiled Templates Cache", compileCache.metrics);
-      console.log("HTML Fragments Cache", fragmentCache.metrics);
-    }
+  return {
+    plansByNotation,
+    notationAccessors,
+    fragment,
+    subtemplates
   };
 }
 
+// src/template/template.ts
 class Template {
+  static isTemplate(value) {
+    return value !== null && typeof value === "object" && value instanceof Template;
+  }
   static cache = {
     clear: () => {
       fragmentCache.clear();
-      compileCache.clear();
+      compiledTemplateCache.clear();
+      valueAccessorCache.clear();
+      parsedNotationCache.clear();
     },
     setCapacity: (maxSize) => {
       fragmentCache.setCapacity(maxSize);
-      compileCache.setCapacity(maxSize);
+      compiledTemplateCache.setCapacity(maxSize);
+      valueAccessorCache.setCapacity(maxSize);
+      parsedNotationCache.setCapacity(maxSize);
     }
   };
   _compiled;
@@ -1263,21 +1435,29 @@ class Template {
   _fragment;
   _plansByNotation = new Map;
   _notationAccessors = new Map;
+  _subtemplates = new Set;
   constructor(template) {
-    if (template instanceof HTMLTemplateElement) {
-      this._templateElement = template;
-      const cached = compileCache.get(template);
-      const compiled = cached ?? compileTemplate(template);
-      this._compiled = compiled;
-      compileCache.set(template, compiled);
-    } else {
-      this._compiled = template;
-    }
+    this._templateElement = template;
+    this._compiled = compileTemplate(template);
     const fragment = htmlToFragment(this._compiled.html);
     const hydrated = prepareCompiledTemplate(this._compiled, fragment);
     this._plansByNotation = hydrated.plansByNotation;
     this._notationAccessors = hydrated.notationAccessors;
     this._fragment = hydrated.fragment;
+    this._subtemplates = hydrated.subtemplates;
+    const allRelevantAccessors = new Map(this._notationAccessors);
+    for (const child of this._subtemplates) {
+      for (const [key, val] of child.notationMap) {
+        allRelevantAccessors.set(key, val);
+      }
+    }
+    this._notationAccessors = allRelevantAccessors;
+  }
+  get compiled() {
+    return this._compiled;
+  }
+  get notationMap() {
+    return this._notationAccessors;
   }
   clone = () => {
     return new Template(this.element());
@@ -1292,70 +1472,32 @@ class Template {
   };
   _collectUpdatedValues = (context) => {
     const updatedValues = new Map;
+    let hasChanges = false;
     for (const [rawNotation, accessor] of this._notationAccessors) {
       const previousValue = this._latestRenderedValues.get(rawNotation);
       const newValue = accessor(context);
+      updatedValues.set(rawNotation, newValue);
       if (previousValue !== newValue && !Object.is(previousValue, newValue)) {
-        updatedValues.set(rawNotation, newValue);
+        hasChanges = true;
       }
     }
-    return updatedValues;
+    return [hasChanges, updatedValues];
   };
   _update(newValues) {
-    const scheduledPlans = new Set;
-    const attributeJobs = [];
-    const contentSwapJobs = [];
-    const tagChangeJobs = [];
-    const listRenderJobs = [];
+    const allAffectedPlans = new Set;
     for (const [notation] of newValues) {
       const affectedPlans = this._plansByNotation.get(notation);
-      if (affectedPlans) {
-        for (const plan of affectedPlans) {
-          if (scheduledPlans.has(plan)) {
-            continue;
-          }
-          scheduledPlans.add(plan);
-          switch (plan.type) {
-            case "attr": {
-              const job = prepareAttributeJob(plan, newValues);
-              if (job !== SKIPPED_JOB) {
-                attributeJobs.push(job);
-              }
-              break;
-            }
-            case "each": {
-              const job = prepareListRenderJob(plan, newValues);
-              if (job !== SKIPPED_JOB) {
-                listRenderJobs.push(job);
-              }
-              break;
-            }
-            case "swap": {
-              const job = prepareContentSwapJob(plan, newValues);
-              if (job !== SKIPPED_JOB) {
-                contentSwapJobs.push(job);
-              }
-              break;
-            }
-            case "tag": {
-              const job = prepareTagChangeJob(plan, newValues);
-              if (job !== SKIPPED_JOB) {
-                tagChangeJobs.push(job);
-              }
-              break;
-            }
-            default:
-              throw new PaletteError(0 /* INVARIANT */);
-          }
-        }
+      if (!affectedPlans) {
+        continue;
+      }
+      for (const plan of affectedPlans) {
+        allAffectedPlans.add(plan);
       }
     }
-    runAttributeJobs(attributeJobs);
-    runListRenderJobs(listRenderJobs);
-    runContentSwapJobs(contentSwapJobs);
-    runTagChangeJobs(tagChangeJobs);
+    const jobs = createJobsFromPlans(allAffectedPlans, newValues);
+    executeRenderJobs(jobs);
   }
-  render = (root, context) => {
+  renderWithValues = (root, values) => {
     if (root !== this._mountedRoot) {
       this._mountedRoot = root;
       while (root.firstChild) {
@@ -1363,37 +1505,78 @@ class Template {
       }
       root.append(this._fragment);
     }
-    const resolvedValues = this._collectUpdatedValues(context);
-    if (resolvedValues.size !== 0) {
-      this._update(resolvedValues);
-      for (const [key, val] of resolvedValues) {
-        this._latestRenderedValues.set(key, val);
-      }
+    this._update(values);
+  };
+  render = (root, context) => {
+    const [hasChanges, resolvedValues] = this._collectUpdatedValues(context);
+    if (root === this._mountedRoot && !hasChanges) {
+      return;
     }
+    this.renderWithValues(root, resolvedValues);
+    this._latestRenderedValues = resolvedValues;
   };
 }
-// src/component/delegator.ts
-class EventDelegator {
-  static nextListenerId = 0;
-  static processTargetDescriptor(targetDescriptor) {
-    if (targetDescriptor instanceof HTMLElement) {
-      if (targetDescriptor.id.length) {
-        return `#${targetDescriptor.id}`;
+// src/task-scheduler.ts
+class TaskScheduler {
+  _queues = {
+    tasks: [],
+    frames: []
+  };
+  _promises = {};
+  _resolvers = {};
+  _onError;
+  constructor(onError) {
+    this._onError = onError;
+  }
+  _flushQueue = (queueType) => {
+    const queue = this._queues[queueType];
+    try {
+      while (queue.length) {
+        const task = queue.shift();
+        task?.();
+      }
+    } catch (error) {
+      if (this._onError) {
+        this._onError(error);
       } else {
-        const generatedId = `listen-${EventDelegator.nextListenerId++}`;
-        targetDescriptor.setAttribute("data-listener-id", generatedId);
-        return `[data-listener-id="${generatedId}"]`;
+        throw error;
       }
-    } else if (typeof targetDescriptor === "function") {
-      if (true) {
-        if (targetDescriptor.tagName.length === 0) {
-          console.warn(`[Component] Automatic listener setup failure: Component ${targetDescriptor.name} has no defined tagname`);
-        }
+    } finally {
+      this._resolvers[queueType]?.();
+      this._resolvers[queueType] = undefined;
+      this._promises[queueType] = undefined;
+    }
+  };
+  _schedule = (type, task, prioritize = false) => {
+    const queue = this._queues[type];
+    if (prioritize) {
+      queue.unshift(task);
+    } else {
+      queue.push(task);
+    }
+    if (!this._promises[type]) {
+      this._promises[type] = new Promise((resolve) => {
+        this._resolvers[type] = resolve;
+      });
+      if (type === "frames") {
+        requestAnimationFrame(this._flushQueue.bind(this, "frames"));
+      } else {
+        queueMicrotask(this._flushQueue.bind(this, "tasks"));
       }
-      return targetDescriptor.tagName;
     }
-    return targetDescriptor;
-  }
+    return this._promises[type];
+  };
+  scheduleMicrotask = (task, prioritize = false) => {
+    return this._schedule("tasks", task, prioritize);
+  };
+  scheduleFrameTask = (task, prioritize = false) => {
+    return this._schedule("frames", task, prioritize);
+  };
+}
+var asyncTasks = new TaskScheduler;
+
+// src/component/delegator.ts
+class EventDelegator {
   _root;
   _rootListeners = new Map;
   _events = new Map;
@@ -1424,7 +1607,7 @@ class EventDelegator {
     const listener = (event) => {
       const handlersForEvent = this._handlersForEvent(eventName);
       const { target } = event;
-      if (target === null || !(target instanceof Node)) {
+      if (target === null || !isNode(target)) {
         return;
       }
       let node = target;
@@ -1438,7 +1621,7 @@ class EventDelegator {
         if (node === this._root) {
           break;
         }
-        if (!(node instanceof Element)) {
+        if (!isElement(node)) {
           node = node.parentNode;
           continue;
         }
@@ -1456,7 +1639,7 @@ class EventDelegator {
           return;
         }
         node = node.parentNode;
-        if (node === this._root || node instanceof ShadowRoot) {
+        if (node === this._root || isShadowRoot(node)) {
           break;
         }
       }
@@ -1485,214 +1668,171 @@ class EventDelegator {
 }
 
 // src/component/component.ts
-var MAX_SEQUENTIAL_RENDERS = 100;
+var MAX_SEQUENTIAL_RENDERS = 1e4;
 var BLANK_TEMPLATE = document.createElement("template");
+var HOST_TARGET = ":host";
+var RootMode;
+((RootMode2) => {
+  RootMode2["Closed"] = "closed";
+  RootMode2["Open"] = "open";
+})(RootMode ||= {});
 
 class Component extends HTMLElement {
-  static register(component, tagName) {
-    if (typeof window === "undefined" || typeof window.customElements === "undefined") {
-      throw new PaletteError(1 /* INVALID_ENV */);
-    }
-    const componentTagname = "tagName" in component && typeof component.tagName === "string" ? component.tagName : null;
-    const computedTagname = tagName ?? componentTagname;
-    if (computedTagname === null || computedTagname.length === 0 || !computedTagname.includes("-")) {
-      throw new PaletteError(101 /* INVALID_TAGNAME */);
-    }
-    if (window.customElements.get(computedTagname)) {
-      throw new PaletteError(100 /* DUPE_TAGNAME */, tagName ?? "");
+  static isComponent(value) {
+    return typeof value === "object" && value !== null && value instanceof Component;
+  }
+  static isComponentClass(value) {
+    return value !== null && typeof value === "function" && (value.prototype instanceof Component || value === Component);
+  }
+  static readComponentTagName(componentClass) {
+    const { tagName } = componentClass;
+    if (true) {
+      if (tagName === "") {
+        console.warn(`[Component] Empty tag name when reading from component ${componentClass.name}`);
+      }
     }
-    window.customElements.define(computedTagname, component);
+    return tagName;
   }
   static tagName = "";
   static template = BLANK_TEMPLATE;
-  static styles = [];
+  static style = [];
   static observedAttributes = [];
-  static shadowRootMode = "closed";
-  initialState;
-  computedProperties;
-  liveAttributes;
-  _isComponentMounted = false;
-  _template;
-  _root;
-  _state;
-  _delegator;
-  _ownListeners = new Set;
-  _liveAttributeConfigs = new Map;
-  _cleanupFn;
-  _renderInternals = {
-    willRender: false,
+  static rootMode = "closed" /* Closed */;
+  root;
+  template;
+  _cmp = {
+    isFinalized: false,
+    isInitialRenderComplete: false,
+    isRenderScheduled: false,
     isRendering: false,
-    sequentialRenders: 0,
-    postRenderCallbacks: new Set,
-    lastRenderedAttributeMap: new Map,
-    trackedAttributeChanges: new Map
+    sequentialRenderCount: 0,
+    lastRenderedAttributes: {},
+    pendingAttributeChanges: {}
   };
   constructor() {
     super();
-    const { template: template2, styles, shadowRootMode } = this.constructor;
-    const newStyles = Array.isArray(styles) ? styles : typeof styles === "object" ? [styles] : [css`${styles}`];
-    this._root = this.attachShadow({ mode: shadowRootMode });
-    this._root.adoptedStyleSheets.push(...newStyles);
-    this._template = template2 instanceof Template ? template2 : new Template(template2);
+    const {
+      template: template2,
+      style,
+      rootMode: mode
+    } = this.constructor;
+    this.root = this.attachShadow({ mode });
+    let adoptStyles = [];
+    if (Array.isArray(style)) {
+      adoptStyles = style;
+    } else if (style instanceof CSSStyleSheet) {
+      adoptStyles = [style];
+    } else {
+      const adoptSheet = new CSSStyleSheet;
+      adoptSheet.replaceSync(style);
+      adoptStyles = [adoptSheet];
+    }
+    this.root.adoptedStyleSheets.push(...adoptStyles);
+    this.template = Template.isTemplate(template2) ? template2 : new Template(template2);
   }
   _getRenderContext(attr) {
+    const state = this._cmp.state?.raw ?? {};
+    const computed = this.computedProperties?.call(this, attr, state);
     return {
-      attr: Object.fromEntries(attr),
-      data: typeof this.computedProperties === "function" ? this.computedProperties() : this.computedProperties,
-      state: this._state ? this._state.current : undefined
+      attr,
+      data: computed,
+      state
     };
   }
   _escalateError(error) {
-    let node = this.parentNode;
-    while (node) {
-      if (node instanceof Component && "onError" in node && typeof node.onError === "function") {
+    const isErrorHandled = walkParents(this, (node) => {
+      if (node instanceof Component && node.onError) {
         node.onError(error);
-        return;
-      } else if (node instanceof ShadowRoot) {
-        node = node.host;
-      } else {
-        node = node.parentNode;
+        return true;
       }
+    });
+    if (!isErrorHandled) {
+      throw error;
     }
-    throw error;
   }
   _reportError(error) {
-    if (!this.onError) {
-      this._escalateError(error);
-    } else {
-      this.onError(error);
-    }
+    this.onError ? this.onError(error) : this._escalateError(error);
   }
-  _executeAttributeChangeHandlers = () => {
-    const prevAttrs = this._renderInternals.lastRenderedAttributeMap;
-    const trackedChanges = new Map(this._renderInternals.trackedAttributeChanges);
-    this._renderInternals.trackedAttributeChanges.clear();
-    for (const [name, val] of trackedChanges) {
-      const config = this._liveAttributeConfigs.get(name);
-      if (!config) {
-        continue;
-      }
-      if ("onChange" in config) {
-        const previousValue = prevAttrs.get(name) ?? null;
-        if (config && previousValue !== val) {
-          config.onChange?.call(this, val, previousValue);
-        }
-      }
-    }
-  };
-  _reflectLiveAttributes = () => {
-    const toSet = [];
-    for (const [name, config] of this._liveAttributeConfigs) {
-      if ("reflect" in config) {
-        const val = serializeAttribute(config.reflect?.call(this));
-        const current = this.getAttribute(name);
-        if (val !== current) {
-          toSet.push([name, val]);
-        }
-      }
-    }
-    for (const [name, val] of toSet) {
-      this.reflectAttribute(name, val);
-    }
-  };
-  _performUpdate = () => {
+  _render = () => {
     try {
-      this._renderInternals.isRendering = true;
-      this._renderInternals.willRender = false;
-      this._executeAttributeChangeHandlers();
-      const prevAttrs = this._renderInternals.lastRenderedAttributeMap;
-      this.beforeUpdate?.();
-      const newAttributes = createAttributeMap(this);
-      this._template.render(this.root, this._getRenderContext(newAttributes));
-      this._renderInternals.lastRenderedAttributeMap = newAttributes;
+      this._cmp.isRendering = true;
+      this._cmp.isRenderScheduled = false;
+      const prevAttrs = this._cmp.lastRenderedAttributes;
+      this.beforeUpdate?.(this._cmp.pendingAttributeChanges);
+      const newAttributes = getElementAttributes(this);
+      this.template.render(this.root, this._getRenderContext(newAttributes));
+      this._cmp.lastRenderedAttributes = newAttributes;
       this.afterUpdate?.(prevAttrs);
-      this._reflectLiveAttributes();
-      if (this._renderInternals.postRenderCallbacks.size) {
-        const callbacks = Array.from(this._renderInternals.postRenderCallbacks);
-        this._renderInternals.postRenderCallbacks.clear();
-        for (const fn of callbacks) {
-          fn();
-        }
-      }
-      if (this._renderInternals.willRender) {
-        this._renderInternals.sequentialRenders += 1;
-        if (this._renderInternals.sequentialRenders >= MAX_SEQUENTIAL_RENDERS) {
-          throw new PaletteError(306 /* MAX_SEQUENTIAL_RENDERS */, `${this._renderInternals.sequentialRenders}`);
+      if (this._cmp.isRenderScheduled) {
+        this._cmp.sequentialRenderCount += 1;
+        if (this._cmp.sequentialRenderCount >= MAX_SEQUENTIAL_RENDERS) {
+          throw new PaletteError(306 /* MAX_SEQUENTIAL_RENDERS */, `${this._cmp.sequentialRenderCount}`);
         }
-        this._performUpdate();
+        this._render();
       } else {
-        this._renderInternals.sequentialRenders = 0;
+        this._cmp.sequentialRenderCount = 0;
       }
     } catch (error) {
-      this._renderInternals.willRender = false;
+      this._cmp.isRenderScheduled = false;
       this._reportError(error);
     } finally {
-      this._renderInternals.isRendering = false;
-    }
-  };
-  _scheduleUpdate = () => {
-    if (this._renderInternals.willRender) {
-      return;
+      this._cmp.isRendering = false;
     }
-    this._renderInternals.willRender = true;
-    if (this._renderInternals.isRendering) {
-      return;
-    }
-    requestAnimationFrame(this._performUpdate);
   };
   _adoptState(state) {
-    if (Object.is(this._state, state)) {
+    if (Object.is(this._cmp.state, state)) {
       return;
     }
-    if (this._state) {
-      this._state.removeListener(this._scheduleUpdate);
-      this._scheduleUpdate();
+    if (this._cmp.state) {
+      this._cmp.state.removeListener(this.render);
+      this.render();
     }
-    const incomingStateObj = state instanceof State ? state : new State(state);
-    this._state = incomingStateObj;
-    this._state.removeListener(this._scheduleUpdate);
-    this._state.addListener(this._scheduleUpdate);
+    const incomingStateObj = State.isState(state) ? state : new State(state);
+    this._cmp.state = incomingStateObj;
+    this._cmp.state.removeListener(this.render);
+    this._cmp.state.addListener(this.render);
   }
   connectedCallback() {
-    if (this._isComponentMounted) {
+    if (this._cmp.isInitialRenderComplete) {
       return;
     }
-    queueMicrotask(() => {
+    asyncTasks.scheduleMicrotask(() => {
       try {
-        this._renderInternals.isRendering = true;
-        this._renderInternals.willRender = false;
-        const attributes2 = createAttributeMap(this);
-        this._liveAttributeConfigs = new Map(Object.entries(this.liveAttributes ?? {}));
+        this._cmp.isRendering = true;
+        this._cmp.isRenderScheduled = false;
+        const attributes2 = getElementAttributes(this);
         if (this.initialState) {
-          const init = typeof this.initialState === "object" ? this.initialState : this.initialState();
-          this._adoptState(init);
+          this._adoptState(this.initialState());
         }
-        this._template.render(this.root, this._getRenderContext(attributes2));
-        this._reflectLiveAttributes();
-        this._renderInternals.lastRenderedAttributeMap = attributes2;
-        this._isComponentMounted = true;
-        this._cleanupFn = this.script?.() ?? undefined;
+        this.template.render(this.root, this._getRenderContext(attributes2));
+        this._cmp.lastRenderedAttributes = attributes2;
+        this._cmp.isInitialRenderComplete = true;
+        this._cmp.cleanupFn = this.script?.() ?? undefined;
       } catch (error) {
         this._reportError(error);
       } finally {
-        this._renderInternals.isRendering = false;
+        this._cmp.isRendering = false;
       }
     });
   }
   disconnectedCallback() {
-    queueMicrotask(() => {
-      if (this.isConnected || !this._isComponentMounted) {
+    if (this._cmp.isFinalized) {
+      return;
+    }
+    asyncTasks.scheduleMicrotask(() => {
+      if (this.isConnected || !this._cmp.isInitialRenderComplete) {
         return;
       }
+      this._cmp.isFinalized = true;
       try {
-        this._delegator?.cleanup();
-        if (this._ownListeners.size > 0) {
-          for (const listener of this._ownListeners) {
+        const { delegator, cleanupFn, hostListeners } = this._cmp;
+        delegator?.cleanup();
+        if (hostListeners && hostListeners.size > 0) {
+          for (const listener of hostListeners) {
             this.removeEventListener(listener.event, listener.handler);
           }
         }
-        this._cleanupFn?.();
-        this._isComponentMounted = false;
+        cleanupFn?.();
       } catch (error) {
         this._reportError(error);
       } finally {
@@ -1705,200 +1845,185 @@ class Component extends HTMLElement {
     });
   }
   attributeChangedCallback(name, _, newValue) {
-    if (this._renderInternals.isRendering) {
+    if (this._cmp.isRendering) {
       return;
     }
-    if (newValue === this._renderInternals.lastRenderedAttributeMap?.get(name)) {
-      return;
-    }
-    this._renderInternals.trackedAttributeChanges.set(name, newValue);
-    if (!this._renderInternals.willRender) {
-      this._scheduleUpdate();
+    this._cmp.pendingAttributeChanges[name] = newValue;
+    if (!this._cmp.isRenderScheduled) {
+      this.render();
     }
   }
-  get root() {
-    return this._root;
+  get isMounted() {
+    return this.isConnected && this._cmp.isInitialRenderComplete;
   }
-  get state() {
-    if (!this._state) {
+  getState() {
+    if (!this._cmp.state) {
       throw new PaletteError(301 /* MISSING_STATE */);
     }
-    return this._state.live;
+    return this._cmp.state;
+  }
+  get state() {
+    return this.getState().live;
   }
   set state(newState) {
     this._adoptState(newState);
   }
-  getState() {
-    if (!this._state) {
-      throw new PaletteError(301 /* MISSING_STATE */);
-    }
-    return this._state;
-  }
-  requestRender(callback) {
-    if (callback) {
-      this._renderInternals.postRenderCallbacks.add(callback);
-    }
-    this._scheduleUpdate();
-  }
-  listen(targetDescriptor, eventName, eventHandler) {
-    const query = EventDelegator.processTargetDescriptor(targetDescriptor);
-    if (query === ":host" || query === ":HOST") {
-      this.addEventListener(eventName, eventHandler);
-      this._ownListeners.add({
-        handler: eventHandler,
-        event: eventName
-      });
+  render = () => {
+    if (this._cmp.isRenderScheduled) {
       return;
     }
-    if (!this._delegator) {
-      this._delegator = new EventDelegator(this.root);
+    this._cmp.isRenderScheduled = true;
+    if (this._cmp.isRendering) {
+      return;
     }
-    this._delegator.addListener(eventName, eventHandler, query);
-  }
-  stopListening(targetDescriptor, eventName, eventHandler) {
-    const query = EventDelegator.processTargetDescriptor(targetDescriptor);
-    if (query === ":host" || query === ":HOST") {
-      this.removeEventListener(eventName, eventHandler);
-      for (const listener of this._ownListeners) {
-        if (listener.event === eventName && listener.handler === eventHandler) {
-          this._ownListeners.delete(listener);
-        }
+    asyncTasks.scheduleFrameTask(this._render);
+  };
+  listen(targetDescriptor, eventName, eventHandler) {
+    if (targetDescriptor === HOST_TARGET || targetDescriptor === this) {
+      if (!this._cmp.hostListeners) {
+        this._cmp.hostListeners = new Set;
       }
-      return;
+      const hostListeners = this._cmp.hostListeners;
+      const entry = {
+        event: eventName,
+        handler: eventHandler
+      };
+      hostListeners.add(entry);
+      this.addEventListener(eventName, eventHandler);
+      return () => {
+        this.removeEventListener(eventName, eventHandler);
+        hostListeners.delete(entry);
+      };
     }
-    if (!this._delegator) {
-      return;
+    if (typeof targetDescriptor === "object") {
+      throw new PaletteError(2 /* INVALID_CALLSITE */);
     }
-    this._delegator.removeListener(eventName, eventHandler, query);
-  }
-  dispatchEvent(event, detail, options) {
-    if (event instanceof Event) {
-      return super.dispatchEvent(event);
+    if (!this._cmp.delegator) {
+      this._cmp.delegator = new EventDelegator(this.root);
     }
-    const opts = {
-      bubbles: true,
-      cancelable: true,
-      composed: true,
-      ...options ?? {}
+    const delegator = this._cmp.delegator;
+    const query = typeof targetDescriptor === "string" ? targetDescriptor : Component.readComponentTagName(targetDescriptor);
+    delegator.addListener(eventName, eventHandler, query);
+    return () => {
+      delegator.removeListener(eventName, eventHandler, query);
     };
-    return super.dispatchEvent(new CustomEvent(event, {
-      detail,
-      ...opts
-    }));
-  }
-  querySelector(query) {
-    return this._root.querySelector(query);
-  }
-  querySelectorAll(query) {
-    return this._root.querySelectorAll(query);
   }
-  getElementById(id) {
-    if (this._root instanceof ShadowRoot) {
-      return this._root.getElementById(id);
+  dispatchEvent(a, b) {
+    if (typeof a === "object" && typeof b === "undefined") {
+      return super.dispatchEvent(a);
+    } else if (typeof a === "string") {
+      return super.dispatchEvent(new CustomEvent(a, {
+        bubbles: true,
+        cancelable: true,
+        composed: true,
+        ...b
+      }));
     } else {
-      return HTMLElement.prototype.querySelector.call(this, `#${id}`);
+      throw new PaletteError(2 /* INVALID_CALLSITE */);
     }
   }
-  requireElementById(id) {
-    const lookup = this.getElementById(id);
+  ref(id) {
+    const lookup = this.root.getElementById(id);
     if (!lookup) {
       throw new PaletteError(300 /* MISSING_ELEMENT */);
     }
     return lookup;
   }
-  setAttribute(name, value) {
-    const serialized = serializeAttribute(value);
-    if (serialized === null) {
-      HTMLElement.prototype.removeAttribute.call(this, name);
-    } else {
-      HTMLElement.prototype.setAttribute.call(this, name, serialized);
-    }
-  }
-  getAttribute(name, defaultValue) {
-    const value = HTMLElement.prototype.getAttribute.call(this, name);
-    if (defaultValue === undefined) {
-      return value;
-    }
-    if (typeof defaultValue === "number") {
-      if (value === null) {
-        return defaultValue;
-      }
-      const parsed = Number(value);
-      if (Number.isNaN(parsed)) {
-        return defaultValue;
-      }
-      return parsed;
-    }
-    throw new PaletteError(0 /* INVARIANT */);
-  }
-  reflectAttribute(name, value) {
-    const current = this.getAttribute(name);
-    const reflected = serializeAttribute(value);
-    if (current !== reflected) {
-      this.setAttribute(name, reflected);
-    }
-  }
-  toString(full = false) {
-    const name = this.constructor.name;
+  toString() {
+    const { tagName, name } = this.constructor;
+    const computedName = tagName === "" ? name : tagName;
     const attrString = this.getAttributeNames().map((attrName) => {
       const val = this.getAttribute(attrName);
       return val ? `${attrName}="${val}"` : "";
     }).join(" ");
     const attrs = attrString.length > 0 ? ` ${attrString}` : "";
-    if (full) {
-      return `Component<${name}${attrs}>
-${this.root.innerHTML}
-</${name}>`;
-    }
-    return `Component<${name}${attrs}>`;
+    return `<${computedName}${attrs}></${computedName}>`;
   }
 }
 // src/component/factory.ts
 var BLANK_TEMPLATE2 = document.createElement("template");
-function define(tagname, definition) {
+function defineFromClass(cls, tagName) {
+  if (tagName && cls.tagName === "") {
+    cls.tagName = tagName;
+  }
+  if (true) {
+    if (tagName && tagName !== cls.tagName) {
+      console.warn(`[COMPONENT] Component ${cls.name} was defined with tagname ${tagName} ` + `which does not match its static tagName property`);
+    }
+  }
+  window.customElements.define(cls.tagName, cls);
+}
+function define(a, b) {
+  if (typeof a === "function") {
+    defineFromClass(a);
+    return a;
+  }
+  if (typeof a === "string" && typeof b === "function") {
+    defineFromClass(b, a);
+    return b;
+  }
+  if (b === undefined) {
+    throw new PaletteError(2 /* INVALID_CALLSITE */);
+  }
+  const tagName = a;
+  const definition = b;
+  if (typeof definition === "function") {
+    if (definition.tagName === "") {
+      definition.tagName = tagName;
+    }
+    if (true) {
+      if (tagName !== definition.tagName) {
+        console.warn(`[COMPONENT] Component ${definition.name} was defined with tagname ${tagName} ` + `which does not match its static tagName property`);
+      }
+    }
+    window.customElements.define(tagName, definition);
+    return definition;
+  }
   const {
     template: template2 = BLANK_TEMPLATE2,
-    styles = [],
-    shadowRootMode = "closed",
-    initialState,
-    computedProperties = {},
-    liveAttributes = {},
+    style = [],
+    rootMode = "closed" /* Closed */,
+    initialState: stateInitializer,
+    computedProperties,
+    observedAttributes = [],
     script,
     beforeUpdate,
     afterUpdate,
     finalize,
     onError
   } = definition;
-  const fullObservedAttributes = Array.from(new Set([...Object.keys(liveAttributes)]));
+  let getInitialState;
+  if (stateInitializer) {
+    getInitialState = typeof stateInitializer === "function" ? stateInitializer : () => stateInitializer;
+  }
   const cls = class extends Component {
-    static tagName = tagname;
+    static tagName = tagName;
     static template = template2;
-    static styles = styles;
-    static observedAttributes = [...fullObservedAttributes];
-    static shadowRootMode = shadowRootMode;
-    constructor() {
-      super();
-      this.initialState = typeof initialState === "function" ? initialState.bind(this) : initialState;
-      this.computedProperties = typeof computedProperties === "function" ? computedProperties.bind(this) : computedProperties;
-      this.liveAttributes = liveAttributes;
-      for (const def of Object.values(this.liveAttributes)) {
-        if (def.onChange) {
-          def.onChange = def.onChange.bind(this);
-        }
-        if (def.reflect) {
-          def.reflect = def.reflect.bind(this);
-        }
-      }
-      this.script = script?.bind(this) ?? undefined;
-      this.beforeUpdate = beforeUpdate?.bind(this) ?? undefined;
-      this.afterUpdate = afterUpdate?.bind(this) ?? undefined;
-      this.finalize = finalize?.bind(this) ?? undefined;
-      this.onError = onError?.bind(this) ?? undefined;
-    }
+    static style = style;
+    static observedAttributes = [...observedAttributes];
+    static shadowRootMode = rootMode;
   };
-  Component.register(cls, tagname);
+  cls.prototype.initialState = getInitialState;
+  cls.prototype.computedProperties = computedProperties;
+  cls.prototype.script = script;
+  cls.prototype.beforeUpdate = beforeUpdate;
+  cls.prototype.afterUpdate = afterUpdate;
+  cls.prototype.finalize = finalize;
+  cls.prototype.onError = onError;
+  customElements.define(tagName, cls);
   return cls;
 }
+// src/devtools.ts
+if (typeof window !== "undefined") {
+  window.__PALETTE_DEVTOOLS__ = {
+    dumpCacheMetrics: () => {
+      console.log("Compiled Templates", compiledTemplateCache.getMetrics());
+      console.log("HTML Fragments", fragmentCache.getMetrics());
+      console.log("Notation Accessor", valueAccessorCache.getMetrics());
+      console.log("Parsed Notations", parsedNotationCache.getMetrics());
+    }
+  };
+}
 export {
   html,
   define,
@@ -1906,9 +2031,10 @@ export {
   classify,
   Template,
   State,
+  RootMode,
   PaletteError,
   Component
 };
 
-//# debugId=0F958CC20A4D682464756E2164756E21
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/errors.ts", "src/helper/css.ts", "src/util/attributes.ts", "src/util/change-tag.ts", "src/util/element-match.ts", "src/util/lru-cache.ts", "src/util/fragments.ts", "src/helper/html.ts", "src/state/state.ts", "src/template/syntax.ts", "src/template/build.ts", "src/template/jobs.ts", "src/template/template.ts", "src/component/delegator.ts", "src/component/component.ts", "src/component/factory.ts"],
  "sourcesContent": [
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n/**\n * Possible error types for {@link PaletteError}\n *\n * Codes are categorized into groups by the 100's:\n *\n * - 0 - 99: Invariants\n * - 100 - 199: Custom Elements / Environment Errors\n * - 200 - 299: Templating Errors\n * - 300 - 399: Runtime Errors\n */\nexport const enum ErrorCode {\n  // 0 - 99: Invariants\n  INVARIANT = 0,\n  INVALID_ENV = 1,\n\n  // 100 - 199: Custom Elements Errors\n  DUPE_TAGNAME = 100,\n  INVALID_TAGNAME = 101,\n\n  // 200 - 299: Template Errors\n  TEMPLATE_INVALID = 200,\n  TEMPLATE_INVALID_NOTATION = 201,\n  TEMPLATE_INVALID_COMPONENT = 202,\n  TEMPLATE_INVALID_LIST = 203,\n  TEMPLATE_INVALID_NODE_REF = 204,\n  TEMPLATE_MISSING_LIST_PARENT = 205,\n  TEMPLATE_MISSING_LIST_KEY = 206,\n  TEMPLATE_DUPLICATE_LIST_KEY = 207,\n\n  // 300 - 399: Runtime Errors\n  MISSING_ELEMENT = 300,\n  MISSING_STATE = 301,\n  INVALID_CONTENT = 302,\n  INVALID_STATE_KEY = 303,\n  INVALID_STATE_UPDATE = 304,\n  STATE_LOCKED = 305,\n  MAX_SEQUENTIAL_RENDERS = 306,\n}\n\nfunction getDevError(code: ErrorCode) {\n  const DEV_ERROR_INFO: Record<ErrorCode, string> = {\n    [ErrorCode.INVARIANT]: `\nINVARIANT\nA condition has occurred which should never happen, such as a code path that\nshouldn't be reachable when using correct types, or a disallowed state.\n`,\n\n    [ErrorCode.INVALID_ENV]: `\nINVALID_ENV\nFailed to find a custom elements registry in this environment. Is a window\nglobal available with a customElements property?\n`,\n\n    [ErrorCode.DUPE_TAGNAME]: `\nDUPE_TAGNAME\nFailed to register a custom element with the tagname %s because another\ncustom element is already defined with that name.\n`,\n\n    [ErrorCode.INVALID_TAGNAME]: `\nINVALID_TAGNAME\nFailed to determine a valid HTML Tag to use when registering a component as a\ncustom element. Specify a static readonly tagName property on your component\nclass or provide a tagName argument to Component.register.\n\nAlternatively, you can directly register your element as you would any other\nHTML custom element: customElements.define(\"my-tag\", MyComponentClass);\n`,\n\n    [ErrorCode.MISSING_ELEMENT]: `\nMISSING_ELEMENT\nAn element was expected to exist but was not found when the DOM was queried.\n`,\n\n    [ErrorCode.MISSING_STATE]: `\nMISSING_STATE\nA Component's reactive state was accessed, but no initialState is defined for\nthe Component's class. Initial state must be defined as an object or function.\n`,\n\n    [ErrorCode.INVALID_CONTENT]: `\nINVALID_CONTENT\nTried to set a value as content in a template, but the value was not a supported\ntype. Values must be a string, HTMLElement.\n\nInstead, got %s: %s.\n`,\n\n    [ErrorCode.TEMPLATE_INVALID]: `\nTEMPLATE_INVALID\nThe value %s cannot be interpolated via the Template html string helper.\nValues may only be HTMLTemplateElements (template content is adopted) or\nstrings (shorthand for a ::swap directive on an element)\n`,\n\n    [ErrorCode.TEMPLATE_INVALID_NOTATION]: `\nTEMPLATE_INVALID_NOTATION\nA template value notation failed to parse. Notations must begin with one of\n@, $, *, or #, followed by a dot-separated path of accessor names. Optionally,\nnotations may have modifiers around them, such as the NOT() modifier.\n\nThe notation that failed to parse was \"%s\"\n`,\n    [ErrorCode.TEMPLATE_INVALID_COMPONENT]: `\nTEMPLATE_INVALID_COMPONENT\nFailed to interpolate a Component in an html template string due to the\nComponent having an invalid tagName property.\n\nComponent \"%s\" has an invalid tagName property \"%s\"\n    `,\n\n    [ErrorCode.TEMPLATE_MISSING_LIST_PARENT]: `\nTEMPLATE_MISSING_LIST_PARENT\nA template failed to prepare an ::each directive because no valid parent node\nwas found for the list to render into.\n`,\n\n    [ErrorCode.TEMPLATE_INVALID_LIST]: `\nTEMPLATE_INVALID_LIST\nA template failed to render because an ::each directive fetched a value which\nwas not an array of actionable data.\n`,\n\n    [ErrorCode.TEMPLATE_INVALID_NODE_REF]: `\nTEMPLATE_INVALID_NODE_REF\nA template failed to prepare a node from a compiled source. Typically, this\nmeans something is broken within the compiled template rather than an error with\nthe template content itself.\n`,\n\n    [ErrorCode.TEMPLATE_MISSING_LIST_KEY]: `\nTEMPLATE_MISSING_LIST_KEY\nA template failed to compile because an ::each directive was found on an element\nwithout a corresponding ::key directive. ::each directives must have a ::key\ndirective specified on the same element, whose notation evaluates to a unique\nvalue for each item in the list.\n\nExample: <li ::each=\"$items\" ::key=\"#id\"> ... </li>\n`,\n\n    [ErrorCode.TEMPLATE_DUPLICATE_LIST_KEY]: `\nTEMPLATE_DUPLICATE_LIST_KEY\nA list failed to render because item key %s appeared multiple times when\nresolving list item keys. Each ::key directive must reference a notation whose\nvalue is unique for each list item.\n`,\n\n    [ErrorCode.INVALID_STATE_KEY]: `\nINVALID_STATE_KEY\nTried to access a state property which does not exist\n\nKey path: %s\n`,\n\n    [ErrorCode.INVALID_STATE_UPDATE]: `\nINVALID_STATE_UPDATE\nA Component's setState() was called with a value which could not be patched in\nto the existing component state.\n\nsetState() takes a partial object describing state keys to update.\n\nInstead, received: %s\n`,\n\n    [ErrorCode.STATE_LOCKED]: `\nSTATE_LOCKED\nA State received a request to update or lock while already locked.\nStates may be locked using the .lock() method and unlocked using the .unlock()\nmethod. States lock during async mutations done through the .mutateAsync()\nmethod if \"true\" is passed as the second parameter.\n\nYou can check the lock status of a State instance with .isLocked\n`,\n\n    [ErrorCode.MAX_SEQUENTIAL_RENDERS]: `\nMAX_SEQUENTIAL_RENDERS\nA component has errored after re-rendering more than %s times in the same frame.\n\nThis typically happens because state or live attributes are being modified\nduring a render lifecycle method such as beforeUpdate() or afterUpdate(). If\nstate changes unconditionally during a render, the render will infinitely loop.\nUpdating render source data during a render cycle is supported, but infinite\nupdate loops may occur if unchecked.\n`,\n  };\n\n  return DEV_ERROR_INFO[code];\n}\n\n/**\n * An error originating from within a Palette subsystem.\n *\n * In the `development` environment, the error will surface with extended info\n * about the error and any details which may be relevant to help with debugging.\n *\n * In the `production` environment, a minimal error only surfacing the numeric\n * error code is thrown instead.\n *\n * Codes are categorized into groups by the 100's:\n *\n * - 0 - 99: Invariants\n * - 100 - 199: Custom Elements / Environment Errors\n * - 200 - 299: Templating Errors\n * - 300 - 399: Runtime Errors\n */\nexport class PaletteError extends Error {\n  name = \"PaletteError\";\n  code: number;\n\n  constructor(code: number, ...values: string[]) {\n    let message = `Code: ${code}`;\n    if (__DEV__) {\n      message += getDevError(code);\n\n      for (const val of values) {\n        message = message.replace(`%s`, String(val));\n      }\n    }\n\n    super(message);\n    this.code = code;\n  }\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n/**\n * @returns An array of {@link CSSStyleSheet}s containing the provided CSS\n */\nexport function css(\n  strings: TemplateStringsArray,\n  ...values: unknown[]\n): CSSStyleSheet {\n  let result = strings[0] ?? \"\";\n\n  for (let i = 0; i < values.length; i++) {\n    const nextVal = values[i] ?? \"\";\n    const nextStr = strings[i + 1] ?? \"\";\n    result += `${nextVal}${nextStr}`;\n  }\n\n  const sheet = new CSSStyleSheet();\n  sheet.replaceSync(result);\n  return sheet;\n}\n\ntype ClassValue =\n  | string\n  | number\n  | boolean\n  | undefined\n  | null\n  | ClassArray\n  | ClassObject;\ntype ClassArray = ClassValue[];\ntype ClassObject = Record<string, any>;\n\n/**\n * Given flexible input, generate a string suitable for setting as an html class\n *\n * @example\n *\n * ```typescript\n * classify(\"my-class\", \"another-class\") // \"my-class another-class\"\n * classify([\"my-class\", \"another-class\"]) // \"my-class another-class\"\n * classify({ enabled: true, disabled: false }) // \"enabled\"\n * ```\n */\nexport function classify(...args: ClassValue[]): string {\n  let resultString = \"\";\n\n  for (let index = 0; index < args.length; index++) {\n    const argument = args[index];\n\n    if (!argument) {\n      continue;\n    }\n\n    // Strings/nums -> Direct append\n    if (typeof argument === \"string\" || typeof argument === \"number\") {\n      if (resultString) {\n        resultString += \" \";\n      }\n      resultString += argument;\n      continue;\n    }\n\n    // Handle arrays recursively\n    if (Array.isArray(argument)) {\n      const nestedResult = classify(...argument);\n      if (nestedResult) {\n        if (resultString) {\n          resultString += \" \";\n        }\n        resultString += nestedResult;\n      }\n      continue;\n    }\n\n    // Handle objects with conditional class names\n    if (typeof argument === \"object\") {\n      for (const className in argument) {\n        // Only include class name if its value is truthy\n        if (argument[className]) {\n          if (resultString) {\n            resultString += \" \";\n          }\n          resultString += className;\n        }\n      }\n    }\n  }\n\n  return resultString;\n}\n",
    "/*\n * Copyright © Rustic Arcade, LLC 2026\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n\nimport { ErrorCode, PaletteError } from \"#error\";\n\n/** An attribute value as read from a DOM element */\ntype AttributeValue = string | null;\n\n/** A Map of string attribute names to {@link AttributeValue} */\ntype AttributeMap = Map<string, AttributeValue>;\n\nexport function serializeAttribute(value: unknown): AttributeValue {\n  if (typeof value === \"string\" || typeof value === \"number\") {\n    return `${value}`;\n  }\n\n  if (value === true) {\n    return \"\";\n  }\n\n  if (value === null || value === false || value === undefined) {\n    return null;\n  }\n\n  return value.toString();\n}\n\nexport function createAttributeMap(\n  source: object | Map<string, unknown> | HTMLElement,\n): AttributeMap {\n  const map = new Map<string, string | null>();\n\n  if (source instanceof HTMLElement) {\n    for (const name of source.getAttributeNames()) {\n      map.set(name, serializeAttribute(source.getAttribute(name)));\n    }\n    return map;\n  }\n\n  if (source instanceof Map) {\n    for (const [key, val] of source) {\n      map.set(key, serializeAttribute(val));\n    }\n    return map;\n  }\n\n  if (typeof source === \"object\" && source !== null) {\n    for (const [key, val] of Object.entries(source)) {\n      map.set(key, serializeAttribute(val));\n    }\n    return map;\n  }\n\n  throw new PaletteError(ErrorCode.INVARIANT);\n}\n\nexport function applyAttributeMap(\n  target: HTMLElement,\n  attrs: AttributeMap,\n): void {\n  const currentNames = new Set(target.getAttributeNames());\n  const incomingNames = new Set(attrs.keys());\n  const attributesToRemove = currentNames.difference(incomingNames);\n\n  for (const attr of attributesToRemove) {\n    target.removeAttribute(attr);\n  }\n\n  for (const [name, val] of attrs) {\n    if (val === null) {\n      target.removeAttribute(name);\n    } else {\n      target.setAttribute(name, val);\n    }\n  }\n}\n",
    "/*\n * Copyright © Rustic Arcade, LLC 2026\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n\n/**\n * Given an element, replace it with a different tag, adopting all attributes\n * and child elements.\n * @param $target The element to swap out\n * @param newTag The new HTML tagName to use\n * @returns The newly swapped-in element\n */\nexport function changeTag($target: HTMLElement, newTag: string): HTMLElement {\n  const $newEl = document.createElement(newTag);\n\n  while ($target.firstChild !== null) {\n    $newEl.appendChild($target.firstChild);\n  }\n\n  for (const attrName of $target.getAttributeNames()) {\n    const val = $target.getAttribute(attrName);\n\n    if (val !== null) {\n      $newEl.setAttribute(attrName, val);\n    }\n  }\n\n  $target.replaceWith($newEl);\n  return $newEl;\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\nimport { CharCodes } from \"./character-codes\";\n\nexport function isTagName(str: string): boolean {\n  for (let i = 0; i < str.length; i++) {\n    // Ensure the character code is a letter or hyphen\n    const char = str.charCodeAt(i);\n\n    if (\n      !(\n        char === CharCodes.Hyphen ||\n        (char >= CharCodes.A && char <= CharCodes.Z) ||\n        (char >= CharCodes.a && char <= CharCodes.z)\n      )\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * A performance optimized version of `.matches()` which includes faster\n * matching strategies for common queries.\n *\n * @remarks\n * Optimized query types:\n *\n * - Single ID selector `\"#identifier\"`\n * - Single class selector `\".classname\"`\n * - Tagname selector `\"button\"`\n * - Simple attribute selector `\"[attr='value']\"`\n *\n * All other types of queries use the base .matches() for comparison\n */\nexport function elementMatches(element: Element, query: string) {\n  // If the query is a simple ID, check it directly\n  if (\n    query[0] === \"#\" &&\n    query.indexOf(\" \") === -1 &&\n    query.indexOf(\".\") === -1 &&\n    query.indexOf(\"[\") === -1 &&\n    query.indexOf(\":\") === -1 &&\n    query.indexOf(\">\") === -1\n  ) {\n    return element.id === query.slice(1);\n  }\n\n  // If the query is a simple classname, check it directly\n  if (\n    query[0] === \".\" &&\n    query.indexOf(\" \") === -1 &&\n    query.indexOf(\"#\") === -1 &&\n    query.indexOf(\"[\") === -1 &&\n    query.indexOf(\":\") === -1 &&\n    query.indexOf(\">\") === -1\n  ) {\n    return element.classList.contains(query.slice(1));\n  }\n\n  // If the query is for just a tagname, check it directly\n  if (isTagName(query)) {\n    return element.tagName.toLowerCase() === query.toLowerCase();\n  }\n\n  // If the query is for a single selector value, check it directly\n  if (\n    query[0] === \"[\" &&\n    query[query.length - 1] === \"]\" &&\n    query.indexOf(\" \") === -1 &&\n    query.indexOf(\":\") === -1\n  ) {\n    const attr = query.slice(1, -1);\n    const eqIndex = attr.indexOf(\"=\");\n    if (eqIndex === -1) {\n      return element.hasAttribute(attr);\n    }\n    const attrName = attr.slice(0, eqIndex);\n    const attrValue = attr.slice(eqIndex + 1).replace(/^[\"']|[\"']$/g, \"\");\n    return element.getAttribute(attrName) === attrValue;\n  }\n\n  // Otherwise, use native `.matches` for complex stuff\n  return element.matches(query);\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\ntype Metrics = {\n  hits: number;\n  misses: number;\n};\n\nexport type LRUCacheMetrics = {\n  lookups: number;\n  hits: number;\n  misses: number;\n  capacity: number;\n  entries: number;\n  hitRate: number;\n};\n\n/**\n * A simple in-memory LRU Cache using JavaScript maps.\n *\n * @example\n *\n * Cached network request\n *\n * ```typescript\n * // A cache of API URLs to their returned payloads\n * const cache = new LRUCache<string, APIPayload>();\n *\n * async function makeRequest(url: string) {\n *   let cached = cache.get(url);\n *   if (cached) {\n *     return cached;\n *   }\n *\n *   // ... Make the request and cache.set() the response\n * }\n * ```\n */\nexport class LRUCache<K, V> {\n  private _maxSize: number;\n  private _data: Map<K, V>;\n  private _metrics: Metrics = { hits: 0, misses: 0 };\n\n  constructor(maxSize: number = 500) {\n    if (maxSize <= 0) {\n      throw new Error(\"LRU Cache capacity must be >= 1\");\n    }\n\n    if (__DEV__) {\n      this._metrics = { hits: 0, misses: 0 };\n    }\n\n    this._maxSize = maxSize;\n    this._data = new Map<K, V>();\n  }\n\n  private _trim = () => {\n    while (this._data.size > this._maxSize) {\n      const firstKey = this._data.keys().next().value;\n      if (firstKey === undefined) {\n        throw new Error(\"Absurd\");\n      }\n      this._data.delete(firstKey);\n    }\n  };\n\n  /**\n   * Get cache performance metrics from this LRU Cache instance.\n   *\n   * In development mode, this returns insights into hits/misses of the cache,\n   * as well as the current configuration and entry count.\n   *\n   * In production mode, this returns a placeholder object, as metric collection\n   * is not active in production.\n   */\n  get metrics(): LRUCacheMetrics {\n    if (__DEV__) {\n      const { hits = 0, misses = 0 } = this._metrics ?? {};\n      const lookups = hits + misses;\n      const hitRate = lookups === 0 ? 0 : hits / lookups;\n\n      return {\n        lookups,\n        hits: hits,\n        misses: misses,\n        capacity: this._maxSize,\n        entries: this._data.size,\n        hitRate,\n      };\n    }\n\n    return {\n      lookups: 0,\n      hits: 0,\n      misses: 0,\n      capacity: 0,\n      entries: 0,\n      hitRate: 0,\n    };\n  }\n\n  /**\n   * Update the maximum cache size for this instance. Immediately triggers a\n   * purge of cached contents if the new capacity is less than the current\n   * number of cached entries.\n   */\n  setCapacity = (maxSize: number): void => {\n    if (maxSize <= 0 && __DEV__) {\n      console.warn(\n        \"[Palette LRU Cache] Cache size is <= 0. Cache is disabled.\",\n      );\n    }\n\n    this._maxSize = maxSize;\n    this._trim();\n  };\n\n  /**\n   * Fetch a value from the cache, returning `undefined` if no value was found\n   */\n  get(key: K): V | undefined {\n    const value = this._data.get(key);\n\n    if (value === undefined) {\n      if (__DEV__) {\n        this._metrics.misses += 1;\n      }\n      return undefined;\n    }\n\n    // Delete and re-set the value to move the key to the end of the key list\n    this._data.delete(key);\n    this._data.set(key, value);\n\n    if (__DEV__) {\n      this._metrics.hits += 1;\n    }\n\n    return value;\n  }\n\n  /**\n   * Set a value in the cache. This also moves the value to the back of the list\n   * of values to consider evicting when the cache is full.\n   */\n  set(key: K, value: V): void {\n    // Remove if exists to update position\n    if (this._data.has(key)) {\n      this._data.delete(key);\n    }\n\n    this._data.set(key, value);\n\n    if (this._data.size > this._maxSize) {\n      this._trim();\n    }\n  }\n\n  /**\n   * Clear all contents of this cache instance\n   */\n  clear(): void {\n    this._data.clear();\n  }\n\n  /**\n   * Get the number of entries in this cache instance\n   */\n  get size(): number {\n    return this._data.size;\n  }\n}\n\nexport default LRUCache;\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\nimport LRUCache from \"./lru-cache\";\n\nexport const fragmentCache = new LRUCache<string, DocumentFragment>();\n\nexport function htmlToFragment(html: string): DocumentFragment {\n  const lookup = fragmentCache.get(html);\n\n  if (lookup !== undefined) {\n    return lookup.cloneNode(true) as DocumentFragment;\n  }\n\n  const temp = document.createElement(\"template\");\n  temp.innerHTML = html;\n  fragmentCache.set(html, temp.content);\n  return temp.content.cloneNode(true) as DocumentFragment;\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\nimport { Component } from \"#component\";\nimport { ErrorCode, PaletteError } from \"#error\";\nimport { isTagName } from \"#util\";\n\nexport function parseTemplateStringValue(\n  val: string | typeof Component | HTMLTemplateElement,\n): string {\n  if (val instanceof HTMLTemplateElement) {\n    return val.innerHTML;\n  }\n\n  if (\n    typeof val === \"function\" &&\n    (val.prototype instanceof Component || val === Component)\n  ) {\n    const tagName = val.tagName;\n    if (!isTagName(tagName)) {\n      throw new PaletteError(\n        ErrorCode.TEMPLATE_INVALID_COMPONENT,\n        val.name,\n        val.tagName,\n      );\n    }\n    return tagName;\n  }\n\n  if (typeof val === \"string\") {\n    return `<span ::swap=\"${val}\"></span>`;\n  }\n\n  throw new PaletteError(ErrorCode.TEMPLATE_INVALID, String(val));\n}\n\n/**\n * Create an {@link HTMLTemplateElement} from the provided HTML string.\n *\n * These HTML Templates can be used as standard HTML Templates, or as the\n * foundation for a {@link Component} or standalone {@link Template}\n *\n * Interpolates values in the template string to provide helpers for composing\n * templates:\n *\n * - HTMLTemplateElement references are serialized to HTML and inlined\n * - Strings are modified to become <span> tags with the ::swap directive set\n *   to the string value. This is helpful shorthand for content placeholders.\n *\n * @example\n *\n * This template string\n *\n * ```typescript\n * const $template = html`\n * <div :class=\"*classnames\">\n *   ${\"@content\"}\n * </div>\n * `\n * ```\n *\n * Produces this template element (portrayed as HTML)\n *\n * ```html\n * <template>\n *   <div :class=\"*classnames\">\n *     <span ::swap=\"@content\"></span>\n *   </div>\n * </template>\n * ```\n */\nexport function html(\n  strings: TemplateStringsArray,\n  ...values: (\n    | `@${string}`\n    | `$${string}`\n    | `#${string}`\n    | `*${string}`\n    | HTMLTemplateElement\n    | typeof Component<any>\n  )[]\n): HTMLTemplateElement {\n  const fullString = strings.reduce((acc, str, i) => {\n    const parsedValue = values[i]\n      ? `${parseTemplateStringValue(values[i])}`\n      : \"\";\n    return acc + str + parsedValue;\n  }, \"\");\n\n  const templateElement = document.createElement(\"template\");\n  templateElement.innerHTML = fullString;\n  return templateElement;\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n\nimport { ErrorCode, PaletteError } from \"#error\";\n\nexport type StateListener<Shape> = (state: Shape) => void;\n\nconst PROXY_DEPTH_WARNING_LIMIT = 4;\n\nconst ArrayMutatorFunctions = new Set([\n  \"push\",\n  \"pop\",\n  \"shift\",\n  \"unshift\",\n  \"splice\",\n  \"sort\",\n  \"reverse\",\n  \"fill\",\n  \"copyWithin\",\n]);\n\nconst DataStructureMutatorFunctions = new Set([\n  \"add\",\n  \"delete\",\n  \"clear\",\n  \"set\",\n]);\n\n/**\n * Powerful and flexible state management with deep reactivity, transaction, and\n * locking support.\n *\n * The State class wraps stateful data and provides an API for mutating the data\n * while listeners subscribe to meaningful updates.\n *\n * Modify state with setters, mutators, transactions, or proxied updates with\n * deep reactivity and array mutation support built in.\n *\n * @example\n *\n * ```typescript\n * const state = new State({count: 1});\n * state.addListener(data => console.log(data))\n *\n * state.set(\"count\", 2); // Prints \"2\"\n * state.set(\"count\", 2); // Nothing happens, no change\n * state.live.count = 3; // Prints \"3\"\n * ```\n */\nexport class State<Shape extends object> {\n  private _data: Shape;\n  private _listeners: Set<StateListener<Shape>> = new Set();\n  private _proxy?: Shape;\n  private _proxyCache = new WeakMap<object, any>();\n  private _reverseProxyCache = new WeakMap<object, object>();\n  private _isLocked = false;\n\n  // Only allow warning in dev mode, and only print the warning once per inst\n  private _hasWarned = !__DEV__;\n\n  constructor(initialData: Shape, onChange?: StateListener<Shape>) {\n    this._data = initialData;\n    this.get = this.get.bind(this);\n\n    if (onChange) {\n      this._listeners.add(onChange);\n    }\n  }\n\n  /**\n   * Lazily create and cache proxies into the state for reactive updates on\n   * nested values.\n   */\n  private _createProxy<T>(target: T, path: string[] = []): T {\n    // Return primitives immediately\n    if (typeof target !== \"object\" || target === null) {\n      return target;\n    }\n\n    // Check for a cached proxy for this object\n    const cached = this._proxyCache.get(target as object);\n    if (cached) {\n      return cached;\n    }\n\n    if (__DEV__) {\n      if (!this._hasWarned && path.length > PROXY_DEPTH_WARNING_LIMIT) {\n        this._hasWarned = true;\n        console.warn(`\n[State] Deeply nested live state access may have performance impacts. For deeply\nnested or complex state updates, use .mutate(), .patch(), or .transaction() for\noptimal performance (Warning while evaluating live access to ${path.join(\".\")})\n`);\n      }\n    }\n\n    // Otherwise create a new proxy and cache it\n    const proxy = new Proxy(target as object, {\n      get: (obj, key: string | symbol) => {\n        // Symbols -> Direct return\n        if (typeof key === \"symbol\") {\n          return (obj as any)[key];\n        }\n\n        const value = (obj as any)[key];\n\n        // For Arrays, Maps, and Sets, handle mutator functions correctly\n        if (\n          (obj instanceof Set || obj instanceof Map || Array.isArray(obj)) &&\n          typeof value === \"function\"\n        ) {\n          const mutationFns = Array.isArray(obj)\n            ? ArrayMutatorFunctions\n            : DataStructureMutatorFunctions;\n          const isMutation = mutationFns.has(key);\n\n          return (...args: any[]) => {\n            const snapshot = this.snapshot();\n\n            let current: any = snapshot;\n\n            for (const p of path) {\n              current = current[p];\n            }\n\n            const res = (current as any)[key](...args);\n\n            if (isMutation) {\n              if (this._isLocked) {\n                throw new PaletteError(ErrorCode.STATE_LOCKED);\n              }\n              this._processIncomingState(snapshot);\n            }\n\n            return res;\n          };\n        }\n\n        // Objects -> recursively create a proxy\n        if (typeof value === \"object\" && value !== null) {\n          return this._createProxy(value, [...path, key]);\n        }\n\n        // Primitives -> Return value\n        return value;\n      },\n\n      set: (_obj, key: string | symbol, value: any) => {\n        // Reject if currently locked\n        if (this._isLocked) {\n          throw new PaletteError(ErrorCode.STATE_LOCKED);\n        }\n\n        // Disallow setting symbol properties on target data values\n        if (typeof key === \"symbol\") {\n          return false;\n        }\n\n        // Compute and update the path with the value\n        const newPath = [...path, key];\n        this._setNested(newPath, this._unwrapProxy(value));\n\n        return true;\n      },\n\n      has: (obj, key: string | symbol) => {\n        return key in obj;\n      },\n\n      ownKeys: (obj) => {\n        return Reflect.ownKeys(obj);\n      },\n\n      getOwnPropertyDescriptor: (obj, key: string | symbol) => {\n        const desc = Object.getOwnPropertyDescriptor(obj, key);\n\n        if (desc) {\n          desc.configurable = true;\n        }\n\n        return desc;\n      },\n\n      deleteProperty: (obj, key) => {\n        if (typeof key === \"symbol\" || !(key in obj)) {\n          return false;\n        }\n\n        // Compute and update the path with the value\n        const newPath = [...path, key];\n\n        this._setNested(newPath, undefined);\n\n        return true;\n      },\n    }) as T;\n\n    this._proxyCache.set(target as object, proxy);\n    this._reverseProxyCache.set(proxy as object, target as object);\n    return proxy;\n  }\n\n  private _unwrapProxy<T>(value: T): T {\n    // Don't do anything for primitives\n    if (typeof value !== \"object\" || value === null) {\n      return value;\n    }\n\n    // Check if this is one of our proxies\n    const rawTarget = this._reverseProxyCache.get(value as object);\n    if (rawTarget) {\n      return rawTarget as T;\n    }\n\n    // Handle arrays\n    if (Array.isArray(value)) {\n      return value.map((item) => this._unwrapProxy(item)) as T;\n    }\n\n    // Handle plain objects\n    if (Object.getPrototypeOf(value) === Object.prototype) {\n      const unwrapped: any = {};\n      for (const key in value) {\n        if (Object.hasOwn(value, key)) {\n          unwrapped[key] = this._unwrapProxy((value as any)[key]);\n        }\n      }\n      return unwrapped;\n    }\n\n    // Other objects (Date, Map, Set, etc.) pass through\n    return value;\n  }\n\n  /**\n   * Handle setting nested values and emitting updated data if the value changed\n   */\n  private _setNested(path: string[], value: any): void {\n    // Nothing to do with empty paths\n    if (!path.length) {\n      return;\n    }\n\n    // Start at the root and seek to the value being set\n    let current: any = this._data;\n\n    for (let i = 0; i < path.length - 1; i++) {\n      const key = path[i] ?? \"\";\n      if (!(key in current)) {\n        throw new PaletteError(ErrorCode.INVALID_STATE_KEY, path.join(\".\"));\n      }\n      current = current[key];\n    }\n\n    const finalKey = path[path.length - 1] ?? \"\";\n    if (!(finalKey in current)) {\n      throw new PaletteError(ErrorCode.INVALID_STATE_KEY, path.join(\".\"));\n    }\n\n    // Set and emit only if the value is different. Otherwise no-op.\n    if (current[finalKey] !== value && !Object.is(current[finalKey], value)) {\n      current[finalKey] = value;\n      this._emit(this.current);\n    }\n  }\n\n  /**\n   * Process an incoming partial state and emit updates to listeners if there\n   * are any changes detected.\n   *\n   * @remarks\n   * Object.is() to check for differences. Does not attempt deep diffing.\n   */\n  private _processIncomingState = (incomingState: Partial<Shape>): void => {\n    if (\n      typeof incomingState !== \"object\" ||\n      incomingState === null ||\n      Array.isArray(incomingState)\n    ) {\n      throw new PaletteError(\n        ErrorCode.INVALID_STATE_UPDATE,\n        JSON.stringify(incomingState),\n      );\n    }\n    let hasChanges = false;\n\n    // Check if any key/value pair on the incoming state differs from the\n    // existing data\n    for (const [key, newValue] of Object.entries(incomingState)) {\n      const currentValue = this._data[key as keyof Shape];\n      if (!Object.is(currentValue, newValue)) {\n        hasChanges = true;\n        (this._data as any)[key] = newValue;\n      }\n    }\n\n    if (hasChanges) {\n      this._emit(this._data);\n    }\n  };\n\n  /**\n   * Emit the current state to all listeners\n   */\n  private _emit = (data: Shape): void => {\n    for (const listener of this._listeners) {\n      listener(data);\n    }\n  };\n\n  /**\n   * The current state\n   *\n   * @remarks\n   * This is a direct reference to the internal state. It is marked as Readonly\n   * to help prevent accidental changes. Never edit this value directly.\n   */\n  get current(): Readonly<Shape> {\n    return this._data;\n  }\n\n  /**\n   * Proxied access to state properties with automatic reconciliation.\n   *\n   * Allows direct property access for both reading and writing state values.\n   *\n   * @example\n   *\n   * Deep reactivity with the `.live` accessor\n   *\n   * ```typescript\n   * const state = new State({\n   *   nested: {\n   *     values: [1, 2, 3],\n   *   }\n   * });\n   *\n   * // Deep value assignment triggers state updates\n   * state.live.nested.values[1] = 5;\n   *\n   * // Array mutators are automatically reactive as well\n   * state.live.nested.values.push(4);\n   * state.live.nested.values.reverse();\n   * ```\n   */\n  get live(): Shape {\n    if (!this._proxy) {\n      this._proxy = this._createProxy(this._data);\n    }\n    return this._proxy;\n  }\n\n  /**\n   * Indicates if this state is currently locked (true) or not (false)\n   */\n  get isLocked(): boolean {\n    return this._isLocked;\n  }\n\n  /**\n   * Add a handler function for when this state changes.\n   *\n   * Listeners are invoked in the order they are registered and are passed a\n   * reference to the internally managed state object as a readonly object.\n   *\n   * **Do not modify state values directly**. Instead, use {@link set} or\n   * {@link patch} to make immutable updates.\n   */\n  addListener = (listener: StateListener<Shape>): void => {\n    this._listeners.add(listener);\n  };\n\n  /**\n   * Remove a previously registered state handler\n   */\n  removeListener = (listener: StateListener<Shape>): void => {\n    this._listeners.delete(listener);\n  };\n\n  /**\n   * Get a single value from the state object\n   *\n   * The value is returned as Readonly to prevent accidental state mutations.\n   * To mutate stateful properties, use {@link set} or {@link patch} instead.\n   *\n   * @example\n   *\n   * ```typescript\n   * const state = new State({ count: 1 });\n   * console.log(state.get(\"count\")); // 1\n   * ```\n   *\n   */\n  get = <K extends keyof Shape>(key: K): Readonly<Shape[K]> => {\n    return this._data[key] as Readonly<Shape[K]>;\n  };\n\n  /**\n   * Returns a deep clone of the current state data using `structuredClone()` to\n   * make the copy.\n   *\n   * The object returned from this function can be edited without modifying the\n   * actual internal state.\n   *\n   * @example\n   *\n   * ```typescript\n   * const snap = state.snapshot();\n   * snap.count += 1;\n   * state.patch(snap);\n   * ```\n   */\n  snapshot = (): Shape => {\n    return structuredClone(this._data);\n  };\n\n  /**\n   * Set a single stateful property while leaving other properties unchanged.\n   *\n   * Triggers an update to all listeners if the value is different from before\n   * when compared using shallow equality.\n   *\n   * @example\n   *\n   * ```typescript\n   * const state = new State({ count: 1, color: \"red\" });\n   * state.set(\"count\", 2); // State is now { count: 2, color: \"red\" }\n   * ```\n   */\n  set = <K extends keyof Shape>(key: K, value: Shape[K]): void => {\n    // Reject if currently locked\n    if (this._isLocked) {\n      throw new PaletteError(ErrorCode.STATE_LOCKED);\n    }\n\n    const partial: Partial<Shape> = {};\n    partial[key] = value;\n\n    this._processIncomingState(partial);\n  };\n\n  /**\n   * Set multiple stateful properties at once, leaving omitted properties\n   * unchanged.\n   *\n   * @example\n   *\n   * Patch a partial state, updating all listed properties at once\n   *\n   * ```typescript\n   * const state = new State({\n   *   weather: \"sunny\",\n   *   temperature: 30,\n   *   humidity: 70,\n   * });\n   *\n   * // Leaves `temperature` unchanged\n   * state.patch({\n   *   weather: \"cloudy\",\n   *   humidity: 50,\n   * });\n   * ```\n   */\n  patch = (patch: Partial<Shape>): State<Shape> => {\n    // Reject if currently locked\n    if (this._isLocked) {\n      throw new PaletteError(ErrorCode.STATE_LOCKED);\n    }\n\n    this._processIncomingState(patch);\n    return this;\n  };\n\n  /**\n   * Fully replace the current state data and force listeners to receive the\n   * updated data immediately.\n   */\n  replace = (state: Shape): State<Shape> => {\n    // Reject if currently locked\n    if (this._isLocked) {\n      throw new PaletteError(ErrorCode.STATE_LOCKED);\n    }\n\n    this._data = state;\n    this._emit(this._data);\n    return this;\n  };\n\n  /**\n   * Lock this State instance, preventing further external changes\n   */\n  lock = (): State<Shape> => {\n    if (this._isLocked) {\n      throw new PaletteError(ErrorCode.STATE_LOCKED);\n    }\n\n    this._isLocked = true;\n    return this;\n  };\n\n  /**\n   * Unlock this State instance, allowing further external changes\n   */\n  unlock = (): State<Shape> => {\n    this._isLocked = false;\n    return this;\n  };\n\n  /**\n   * Apply complex updates to the state using a mutator function.\n   *\n   * The mutator function takes one parameter which is a structuredClone copy of\n   * the current state object. Whatever is returned by the mutator is then\n   * patched in to the state.\n   */\n  mutate = (mutator: (current: Shape) => Shape): State<Shape> => {\n    if (this._isLocked) {\n      throw new PaletteError(ErrorCode.STATE_LOCKED);\n    }\n\n    this._processIncomingState(mutator(this.snapshot()));\n    return this;\n  };\n\n  /**\n   * Perform an async mutation of the state, optionally locking the state during\n   * the process.\n   * @param mutator A function to mutate and return the new state\n   * @param lock If `true`, lock the state until the mutator completes\n   */\n  mutateAsync = async (\n    mutator: (current: Shape) => Promise<Shape>,\n    lock = false,\n  ): Promise<State<Shape>> => {\n    if (this._isLocked) {\n      throw new PaletteError(ErrorCode.STATE_LOCKED);\n    }\n\n    if (lock) {\n      this._isLocked = true;\n    }\n\n    const mutationResult = await mutator(this.snapshot());\n    this._processIncomingState(mutationResult);\n\n    if (lock) {\n      this._isLocked = false;\n    }\n\n    return this;\n  };\n\n  /**\n   * Perform a transaction-style set of actions defined within a function.\n   *\n   * The provided function can do anything, beyond just setting state. Any\n   * uncaught errors thrown from within the function will cause the transaction\n   * to fail and the state to automatically roll back to the last valid state.\n   *\n   * During a transaction, this state instance will be locked, preventing other\n   * changes.\n   *\n   * Transactions will always result in a state update when successful.\n   *\n   * @example\n   *\n   * Transactions with locking and rollback support\n   *\n   * ```typescript\n   * const state = new State({count: 1});\n   *\n   * state.transaction(async (s) => {\n   *   // `s` is a full State object you can safely manipulate\n   *   s.set(\"count\", 10);\n   * });\n   * state.get(\"count\"); // => 10;\n   *\n   * // Errors inside the transaction roll back the state\n   * state.transaction(async (s) => {\n   *   s.set(\"count\", 100);\n   *   throw new Error();\n   * });\n   * state.get(\"count\"); // => 10;\n   */\n  transaction = (fn: (state: State<Shape>) => void): boolean => {\n    if (this._isLocked) {\n      throw new PaletteError(ErrorCode.STATE_LOCKED);\n    }\n\n    // Lock outside of the try/catch to throw immediately, separating the\n    // transaction function error from the actual call site errors\n    this._isLocked = true;\n\n    let success = true;\n\n    try {\n      // Create a temporary state object to use within the transaction\n      const transactionState = new State<Shape>(this.snapshot());\n\n      // Run the transaction itself\n      fn(transactionState);\n\n      // Adopt the resulting state of the temporary object\n      this._processIncomingState(transactionState.current);\n    } catch (error) {\n      if (__DEV__) {\n        console.warn(\"[State] Transaction failed due to caught error\", error);\n      }\n      success = false;\n    } finally {\n      this._isLocked = false;\n    }\n\n    return success;\n  };\n\n  /**\n   * Perform a transaction-style set of actions defined within an async function\n   *\n   * The provided function can do anything, beyond just setting state. Any\n   * uncaught errors thrown from within the function will cause the transaction\n   * to fail and the state to automatically roll back to the last valid state.\n   *\n   * During a transaction, this state instance will be locked, preventing other\n   * changes.\n   *\n   * Transactions will always result in a state update when successful.\n   *\n   * @example\n   *\n   * Transactions with locking and rollback support\n   *\n   * ```typescript\n   * const state = new State({count: 1});\n   *\n   * // Awaiting the result of a transaction\n   * await state.transactionAsync(async (s) => {\n   *   // `s` is a full State object you can safely manipulate\n   *   s.set(\"count\", 10);\n   * });\n   * state.get(\"count\"); // => 10;\n   *\n   * // Errors inside the transaction roll back the state\n   * await state.transactionAsync(async (s) => {\n   *   s.set(\"count\", 100);\n   *   throw new Error();\n   * });\n   * state.get(\"count\"); // => 10;\n   *\n   * // If you forget to await the transaction, its still locked\n   * state.transactionAsync(async (s) => {\n   *   await waitSeconds(1);\n   * });\n   * state.set(\"count\", 1); // Error: State is locked!\n   * ```\n   */\n  transactionAsync = async (\n    fn: (state: State<Shape>) => Promise<void>,\n  ): Promise<boolean> => {\n    if (this._isLocked) {\n      throw new PaletteError(ErrorCode.STATE_LOCKED);\n    }\n\n    // Lock outside of the try/catch to throw immediately, separating the\n    // transaction function error from the actual call site errors\n    this._isLocked = true;\n\n    let success = true;\n\n    try {\n      // Create a temporary state object to use within the transaction\n      const transactionState = new State<Shape>(this.snapshot());\n\n      // Run the transaction itself\n      await fn(transactionState);\n\n      // Adopt the resulting state of the temporary object\n      this._processIncomingState(transactionState.current);\n    } catch (error) {\n      if (__DEV__) {\n        console.warn(\"[State] Transaction failed due to caught error\", error);\n      }\n      success = false;\n    } finally {\n      this._isLocked = false;\n    }\n\n    return success;\n  };\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n\nimport { ErrorCode, PaletteError } from \"#error\";\nimport { CharCodes } from \"#util\";\nimport type { ParsedNotation } from \"./types\";\n\n/**\n * Check if an attribute name matches the \"bound attribute\" syntax\n *\n * @example\n * ```typescript\n * isBoundAttribute(\":class\") // true\n * isBoundAttribute(\"::class\") // false\n * isBoundAttribute(\"class\") // false\n * ```\n *\n * @remarks\n * This function uses loops and character code checks instead of a regex to\n * optimize for hot paths during initial parsing and rendering.\n */\nexport function isBoundAttribute(attrName: string): boolean {\n  if (attrName[0] !== \":\" || attrName.length < 2) {\n    return false;\n  }\n\n  for (let i = 1; i < attrName.length; i++) {\n    // Ensure the character code is a letter or hyphen\n    const char = attrName.charCodeAt(i);\n\n    if (\n      !(\n        char === CharCodes.Hyphen ||\n        (char >= CharCodes.A && char <= CharCodes.Z) ||\n        (char >= CharCodes.a && char <= CharCodes.z)\n      )\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nconst enum NotationPrefix {\n  Attributes = \"@\",\n  State = \"$\",\n  Data = \"*\",\n  Item = \"#\",\n}\n\nconst PREFIX_MAPPING: Record<NotationPrefix, string> = {\n  [NotationPrefix.Attributes]: \"attr\",\n  [NotationPrefix.State]: \"state\",\n  [NotationPrefix.Data]: \"data\",\n  [NotationPrefix.Item]: \"item\",\n};\n\nconst prefixMapping = new Map(Object.entries(PREFIX_MAPPING));\n\n/**\n * Parse a notation into an object with runtime information\n *\n * @remarks\n * Four notations are supported:\n *\n * - `@attrname` -> Root element attributes\n * - `$statevalue` -> Stateful content\n * - `*property.or.whatever` -> Computed data properties\n * - `#color` -> List item properties\n */\nexport function parseNotation(notation: string): ParsedNotation {\n  // Check for prefix modifiers\n  let notModifier = false;\n\n  let pathPart = \"\";\n  const computedPath: string[] = [];\n\n  let isFirst = true;\n  for (const char of notation) {\n    // ! at position 0 -> Enable NOT modifier, dont count towards idx\n    if (isFirst && char === \"!\") {\n      notModifier = true;\n    }\n\n    // Otherwise, position 0 must be a prefix\n    else if (isFirst) {\n      const prefix = prefixMapping.get(char);\n\n      if (!prefix) {\n        throw new PaletteError(ErrorCode.TEMPLATE_INVALID_NOTATION, notation);\n      }\n\n      computedPath.push(prefix);\n      isFirst = false;\n    }\n\n    // Collect characters and push when hitting a dot or end\n    else if (char === \".\") {\n      if (pathPart.length) {\n        computedPath.push(pathPart);\n        pathPart = \"\";\n      } else {\n        throw new PaletteError(ErrorCode.TEMPLATE_INVALID_NOTATION, notation);\n      }\n    } else {\n      pathPart += char;\n    }\n  }\n\n  // Add the final part which must exist (otherwise, it ended in a dot)\n  if (!pathPart.length) {\n    throw new PaletteError(ErrorCode.TEMPLATE_INVALID_NOTATION, notation);\n  }\n\n  computedPath.push(pathPart);\n\n  if (computedPath.length < 2) {\n    throw new PaletteError(ErrorCode.TEMPLATE_INVALID_NOTATION, notation);\n  }\n\n  return {\n    base: notation,\n    path: computedPath,\n    modifiers: notModifier ? { not: true } : undefined,\n  };\n}\n\nexport type NotationAccessor = (source: unknown) => unknown;\n\nexport function buildValueAccessor(notation: ParsedNotation): NotationAccessor {\n  const { path, modifiers } = notation;\n\n  if (path.length < 2) {\n    // Notations must always have at least 2 parts: the namespace, and at least\n    // one property name on the namespace (example: [\"state\", \"visible\"])\n    throw new PaletteError(ErrorCode.INVARIANT);\n  }\n\n  // For 2 and 3 length paths, pre-bake accessors to optimize for common cases\n  if (path.length === 2) {\n    const [firstKey, secondKey] = path;\n\n    if (firstKey === undefined || secondKey === undefined) {\n      throw new PaletteError(ErrorCode.INVARIANT);\n    }\n\n    return (source: unknown) => {\n      const value = (source as any)?.[firstKey]?.[secondKey] ?? null;\n      if (modifiers?.not) {\n        // Attribute values must treat the empty string as truthy per DOM rules\n        if (firstKey === \"attr\") {\n          return value !== \"\" && !value;\n        }\n\n        return !value;\n      }\n      return value;\n    };\n  }\n\n  if (path.length === 3) {\n    const [firstKey, secondKey, thirdKey] = path;\n\n    if (\n      firstKey === undefined ||\n      secondKey === undefined ||\n      thirdKey === undefined\n    ) {\n      throw new PaletteError(ErrorCode.INVARIANT);\n    }\n\n    return (source: unknown) => {\n      const value =\n        (source as any)?.[firstKey]?.[secondKey]?.[thirdKey] ?? null;\n      if (modifiers?.not) {\n        if (firstKey === \"attr\") {\n          return value !== \"\" && !value;\n        }\n\n        return !value;\n      }\n      return value;\n    };\n  }\n\n  // For longer paths, opt for a pre-built loop\n  return (source: unknown) => {\n    let current = source;\n\n    for (const part of path) {\n      if (!current || typeof current !== \"object\") {\n        return null;\n      }\n\n      current = current[part as keyof typeof current];\n    }\n\n    if (modifiers?.not) {\n      if (path[0] === \"attr\") {\n        return current !== \"\" && !current;\n      }\n      return !current;\n    }\n\n    return current;\n  };\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\nimport { ErrorCode, PaletteError } from \"#error\";\nimport { htmlToFragment } from \"#util\";\nimport {\n  buildValueAccessor,\n  isBoundAttribute,\n  type NotationAccessor,\n  parseNotation,\n} from \"./syntax\";\nimport {\n  type AnyRenderPlan,\n  type AnyScheme,\n  type AttributeUpdatePlan,\n  type AttributeUpdateScheme,\n  type CompiledTemplate,\n  type ContentSwapPlan,\n  type ContentSwapScheme,\n  Directive,\n  type ListRenderPlan,\n  type ListRenderScheme,\n  type ParsedNotation,\n  type PreparedTemplate,\n  type TagChangePlan,\n} from \"./types\";\n\nconst REF_ATTR = \"data-node-ref\";\n\nfunction collectOperableNodes(fragment: DocumentFragment): HTMLElement[] {\n  const walker = document.createTreeWalker(fragment, NodeFilter.SHOW_ELEMENT);\n  const knownIgnores = new Set<Node>();\n  const nodes: HTMLElement[] = [];\n\n  let currentNode: Node | null = walker.nextNode();\n\n  while (currentNode) {\n    if (!(currentNode instanceof HTMLElement)) {\n      currentNode = walker.nextNode();\n      continue;\n    }\n\n    let parent = currentNode.parentNode;\n    let isInList = false;\n\n    while (parent && !isInList) {\n      if (\n        knownIgnores.has(parent) ||\n        (parent instanceof HTMLElement && parent.hasAttribute(Directive.Each))\n      ) {\n        isInList = true;\n        knownIgnores.add(currentNode);\n        break;\n      }\n\n      parent = parent.parentNode;\n    }\n\n    if (!isInList) {\n      nodes.push(currentNode);\n    }\n\n    currentNode = walker.nextNode();\n  }\n\n  return nodes;\n}\n\n/**\n * Compile an {@link HTMLTemplateElement} into a {@link CompiledTemplate} for\n * caching, cloning, or storage.\n *\n * Compiled template objects contain a JSON-serializable data representation of\n * a template and can be prepared using {@link prepareCompiledTemplate} to\n * create new Template instances.\n *\n * @example\n *\n * ```typescript\n * const compiled = compileTemplate($templateElement);\n * const stringified = JSON.stringify(compiled); // a JSON template bundle\n * ```\n */\nexport function compileTemplate(source: HTMLTemplateElement): CompiledTemplate {\n  const parsedNotations = new Map<string, ParsedNotation>();\n  const schemes: AnyScheme[] = [];\n  let elementId = 0;\n\n  const ensureNodeRef = (el: HTMLElement): string => {\n    let ref = el.getAttribute(REF_ATTR);\n    if (!ref) {\n      ref = `el-${elementId++}`;\n      el.setAttribute(REF_ATTR, ref);\n    }\n    return ref;\n  };\n\n  const clonedTemplateElement = source.content.cloneNode(\n    true,\n  ) as DocumentFragment;\n\n  const nodes: HTMLElement[] = collectOperableNodes(clonedTemplateElement);\n\n  for (const node of nodes) {\n    // Collect all attributes on this node\n    const attributes = new Map();\n    for (const name of node.getAttributeNames()) {\n      attributes.set(name, node.getAttribute(name));\n    }\n\n    // Check for directive attributes\n    for (const [attributeName, attributeValue] of attributes) {\n      // Bail quickly if this isn't a directive\n      if (attributeValue === null || attributeName[0] !== \":\") {\n        continue;\n      }\n\n      // If the notation has been parsed before, reuse that\n      let notation = parsedNotations.get(attributeValue);\n\n      if (notation === undefined) {\n        notation = parseNotation(attributeValue);\n        parsedNotations.set(attributeValue, notation);\n      }\n\n      node.removeAttribute(attributeName);\n\n      // ::key is handled in the ::each route\n      if (attributeName === Directive.Key) {\n        continue;\n      }\n\n      // TAG CHANGE SCHEMES\n      if (attributeName === Directive.Tag) {\n        schemes.push({\n          type: \"tag\",\n          notation,\n          nodeRef: ensureNodeRef(node),\n        });\n      }\n\n      // LIST RENDER SCHEMES\n      else if (attributeName === Directive.Each) {\n        const nodeRef = ensureNodeRef(node);\n\n        // A ::key directive is required with any ::each\n        const keyNotation = node.getAttribute(Directive.Key);\n        if (keyNotation === null) {\n          throw new PaletteError(ErrorCode.TEMPLATE_MISSING_LIST_KEY);\n        }\n\n        node.removeAttribute(Directive.Key);\n\n        const listContentHtml = node.innerHTML;\n\n        while (node.firstChild) {\n          node.removeChild(node.firstChild);\n        }\n\n        const scheme: ListRenderScheme = {\n          type: \"each\",\n          notation,\n          keyNotation: parseNotation(keyNotation),\n          nodeRef,\n          listContentHtml,\n        };\n\n        schemes.push(scheme);\n      }\n\n      // CONTENT SWAP SCHEMES\n      else if (attributeName === Directive.Swap) {\n        const scheme: ContentSwapScheme = {\n          type: \"swap\",\n          notation,\n          nodeRef: ensureNodeRef(node),\n        };\n\n        schemes.push(scheme);\n      }\n\n      // ATTRIBUTE UPDATE SCHEMES\n      else if (isBoundAttribute(attributeName)) {\n        const bindName = attributeName.slice(1);\n\n        const scheme: AttributeUpdateScheme = {\n          type: \"attr\",\n          notation,\n          attribute: bindName,\n          nodeRef: ensureNodeRef(node),\n        };\n\n        schemes.push(scheme);\n      } else {\n        if (__DEV__) {\n          console.warn(`Template: ${attributeName} is not a valid directive`);\n        }\n      }\n    }\n  }\n\n  const notations: Record<string, ParsedNotation> = {};\n\n  for (const [key, val] of parsedNotations) {\n    notations[key] = val;\n  }\n\n  const temp = document.createElement(\"div\");\n  temp.appendChild(clonedTemplateElement.cloneNode(true));\n  const html = temp.innerHTML;\n\n  const compiled: CompiledTemplate = {\n    html,\n    schemes,\n    notations,\n  };\n\n  return compiled;\n}\n\n/**\n * Given a {@link CompiledTemplate} structure, return an object containing the\n * data needed to create new Template instances.\n *\n * @example\n *\n * ```typescript\n * const compiledTemplate = getCompiledTemplateJSON();\n * const parsed = JSON.parse(compiledTemplate);\n * const prepared = prepareCompiledTemplate(parsed);\n *\n * // Elsewhere...\n *\n * const template = new Template(prepared);\n * ```\n */\nexport function prepareCompiledTemplate(\n  compiled: CompiledTemplate,\n  prototypeFragment?: DocumentFragment,\n): PreparedTemplate {\n  const plansByNotation: Map<string, Set<AnyRenderPlan>> = new Map();\n  const notationAccessors: Map<string, NotationAccessor> = new Map();\n  const nodeRefs: Map<string, HTMLElement> = new Map();\n\n  for (const [notation, parsed] of Object.entries(compiled.notations)) {\n    notationAccessors.set(notation, buildValueAccessor(parsed));\n  }\n\n  const fragment = prototypeFragment ?? htmlToFragment(compiled.html);\n\n  const walker = document.createTreeWalker(fragment, NodeFilter.SHOW_ELEMENT, {\n    acceptNode(node: HTMLElement) {\n      return node.hasAttribute(REF_ATTR)\n        ? NodeFilter.FILTER_ACCEPT\n        : NodeFilter.FILTER_SKIP;\n    },\n  });\n\n  let markNode: Node | null = walker.nextNode();\n\n  while (markNode) {\n    if (!(markNode instanceof HTMLElement)) {\n      continue;\n    }\n\n    const ref = markNode.getAttribute(REF_ATTR);\n\n    if (ref === null) {\n      // Should never happen in practice, as the tree walker only surfaces\n      // elements with an extant node ref attribute\n      throw new PaletteError(ErrorCode.INVARIANT);\n    }\n\n    nodeRefs.set(ref, markNode);\n    markNode.removeAttribute(REF_ATTR);\n    markNode = walker.nextNode();\n  }\n\n  const associatePlan = (plan: AnyRenderPlan, notation: string) => {\n    let notationPlans = plansByNotation.get(notation);\n    if (!notationPlans) {\n      notationPlans = new Set();\n      plansByNotation.set(notation, notationPlans);\n    }\n    notationPlans.add(plan);\n  };\n\n  const getByNodeRef = (nodeRef: string): HTMLElement => {\n    const cached = nodeRefs.get(nodeRef);\n\n    if (cached) {\n      return cached;\n    }\n\n    throw new PaletteError(ErrorCode.TEMPLATE_INVALID_NODE_REF);\n  };\n\n  for (const scheme of compiled.schemes) {\n    // Hydrate List schemes into List plans\n    if (scheme.type === \"each\") {\n      const itemPrototype = getByNodeRef(scheme.nodeRef);\n      const listContainer = itemPrototype.parentElement;\n\n      if (!listContainer) {\n        throw new PaletteError(ErrorCode.TEMPLATE_MISSING_LIST_PARENT);\n      }\n\n      // Create list start/end markers\n      const startMarker = document.createComment(\"list-start\");\n      const endMarker = document.createComment(\"list-end\");\n\n      listContainer.insertBefore(startMarker, itemPrototype);\n      listContainer.insertBefore(endMarker, itemPrototype.nextSibling);\n\n      // Shallow copy of the row root\n      const rowRootElement = itemPrototype.cloneNode(false) as HTMLElement;\n\n      // Copy the contents of the row into a template\n      const templateContentFragment = htmlToFragment(scheme.listContentHtml);\n      const rowTemplateElement = document.createElement(\"template\");\n      rowTemplateElement.content.appendChild(templateContentFragment);\n\n      // Remove the original root prototype since we will be rendering new items\n      itemPrototype.remove();\n\n      const plan: ListRenderPlan = {\n        type: \"each\",\n        notation: scheme.notation,\n        keyNotation: scheme.keyNotation,\n        listContainerElement: listContainer,\n        rowTemplateElement,\n        rowRootElement,\n        startMarker,\n        endMarker,\n        rowTemplatesByRoot: new WeakMap(),\n        rowRootsByKey: new Map(),\n      };\n\n      associatePlan(plan, scheme.notation.base);\n    }\n    // Hydrate Swap schemes into Swap plans\n    else if (scheme.type === \"swap\") {\n      const plan: ContentSwapPlan = {\n        type: \"swap\",\n        notation: scheme.notation,\n        node: getByNodeRef(scheme.nodeRef),\n      };\n\n      associatePlan(plan, scheme.notation.base);\n    }\n\n    // Hydrate Tag change plans\n    else if (scheme.type === \"tag\") {\n      const plan: TagChangePlan = {\n        type: \"tag\",\n        notation: scheme.notation,\n        node: getByNodeRef(scheme.nodeRef),\n      };\n\n      associatePlan(plan, plan.notation.base);\n    }\n\n    // Hydrate Attribute update plans\n    else if (scheme.type === \"attr\") {\n      const plan: AttributeUpdatePlan = {\n        type: \"attr\",\n        attribute: scheme.attribute,\n        notation: scheme.notation,\n        node: getByNodeRef(scheme.nodeRef),\n      };\n\n      associatePlan(plan, plan.notation.base);\n    }\n  }\n\n  return {\n    plansByNotation,\n    notationAccessors,\n    fragment,\n  };\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n\nimport { ErrorCode, PaletteError } from \"#error\";\nimport { classify } from \"#helper\";\nimport {\n  applyAttributeMap,\n  changeTag,\n  createAttributeMap,\n  serializeAttribute,\n} from \"#util\";\nimport { buildValueAccessor } from \"./syntax\";\nimport { Template, type TemplateContext } from \"./template\";\nimport type {\n  AttributeUpdateJob,\n  AttributeUpdatePlan,\n  ContentSwapJob,\n  ContentSwapPlan,\n  ListRenderJob,\n  ListRenderJobItem,\n  ListRenderPlan,\n  TagChangeJob,\n  TagChangePlan,\n} from \"./types\";\n\nexport const SKIPPED_JOB = Symbol(\"noop\");\nexport type SkippedJob = typeof SKIPPED_JOB;\n\n///////////////////////////\n// ATTRIBUTE UPDATE JOBS //\n///////////////////////////\n\nexport function prepareAttributeJob(\n  plan: AttributeUpdatePlan,\n  values: Map<string, unknown>,\n): AttributeUpdateJob | SkippedJob {\n  const rawValue = values.get(plan.notation.base);\n  let value = typeof rawValue === \"function\" ? rawValue(plan.node) : rawValue;\n\n  // Parse the value with `classify` if setting the class attribute\n  if (plan.attribute === \"class\" && typeof value !== \"string\") {\n    value = classify(value);\n  }\n\n  const serializedValue = serializeAttribute(value);\n  const current = plan.node.getAttribute(plan.attribute);\n\n  if (serializedValue !== current) {\n    return [plan.node, plan.attribute, serializedValue];\n  }\n\n  return SKIPPED_JOB;\n}\n\nexport function runAttributeJobs(jobs: AttributeUpdateJob[]): void {\n  for (const [node, name, value] of jobs) {\n    if (value === null) {\n      node.removeAttribute(name);\n    } else {\n      node.setAttribute(name, value);\n    }\n  }\n}\n\n///////////////////////\n// CONTENT SWAP JOBS //\n///////////////////////\n\nexport function prepareContentSwapJob(\n  plan: ContentSwapPlan,\n  values: Map<string, unknown>,\n): ContentSwapJob | SkippedJob {\n  const rawValue = values.get(plan.notation.base);\n  const value = typeof rawValue === \"function\" ? rawValue(plan.node) : rawValue;\n\n  // String, Number, Boolean -> Text Node\n  if (\n    typeof value === \"string\" ||\n    typeof value === \"number\" ||\n    typeof value === \"boolean\"\n  ) {\n    const asStr = `${value}`;\n    if (plan.node.textContent === asStr) {\n      return SKIPPED_JOB;\n    }\n\n    return [plan, document.createTextNode(asStr)];\n  }\n\n  // Nullish values -> Comment\n  else if (value === null || value === undefined) {\n    if (plan.node instanceof Comment) {\n      return SKIPPED_JOB;\n    }\n\n    return [plan, document.createComment(\"empty\")];\n  }\n\n  // HTMLElement -> Swap nodes\n  else if (value instanceof HTMLElement) {\n    if (Object.is(plan.node, value)) {\n      return SKIPPED_JOB;\n    }\n\n    return [plan, value.cloneNode(true)];\n  }\n\n  // Anything else -> Unsupported\n  else {\n    throw new PaletteError(\n      ErrorCode.INVALID_CONTENT,\n      typeof value,\n      JSON.stringify(value),\n    );\n  }\n}\n\nexport function runContentSwapJobs(jobs: ContentSwapJob[]): void {\n  for (const [plan, replace] of jobs) {\n    const parent = plan.node.parentNode;\n\n    if (!parent) {\n      // Should never happen in practice\n      throw new PaletteError(ErrorCode.INVARIANT);\n    }\n\n    parent.replaceChild(replace, plan.node);\n    plan.node = replace;\n  }\n}\n\n/////////////////////\n// TAG CHANGE JOBS //\n/////////////////////\n\nexport function prepareTagChangeJob(\n  plan: TagChangePlan,\n  values: Map<string, unknown>,\n): TagChangeJob | SkippedJob {\n  const rawValue = values.get(plan.notation.base) ?? \"\";\n  const value = typeof rawValue === \"function\" ? rawValue(plan.node) : rawValue;\n  const nextTag = `${value}`.toLowerCase();\n  const currentTag = plan.node.tagName.toLowerCase();\n\n  if (!nextTag || nextTag === currentTag) {\n    return SKIPPED_JOB;\n  }\n\n  return [plan, nextTag];\n}\n\nexport function runTagChangeJobs(jobs: TagChangeJob[]): void {\n  for (const [plan, nextTag] of jobs) {\n    plan.node = changeTag(plan.node, nextTag);\n  }\n}\n\n//////////////////////\n// LIST RENDER JOBS //\n//////////////////////\n\nfunction fetchListData(\n  plan: ListRenderPlan,\n  values: Map<string, unknown>,\n): Record<string, unknown>[] {\n  const notationValue = values.get(plan.notation.base);\n  const evaluatedValue =\n    typeof notationValue === \"function\"\n      ? notationValue(plan.startMarker.parentNode)\n      : notationValue;\n\n  if (evaluatedValue === null || evaluatedValue === undefined) {\n    return [];\n  }\n\n  if (Array.isArray(evaluatedValue)) {\n    return evaluatedValue;\n  }\n\n  throw new PaletteError(ErrorCode.TEMPLATE_INVALID_LIST);\n}\n\nfunction collectHTMLElements(start: Node, end: Node): Set<HTMLElement> {\n  let node: Node | null = start;\n  const nodeSet = new Set<HTMLElement>();\n\n  while (node && node !== end) {\n    if (node instanceof HTMLElement) {\n      nodeSet.add(node);\n    }\n\n    node = node.nextSibling;\n  }\n\n  return nodeSet;\n}\n\nexport function prepareListRenderJob(\n  plan: ListRenderPlan,\n  values: Map<string, unknown>,\n): ListRenderJob | SkippedJob {\n  // Fetch the data for rendering the updated list items\n  const listData = fetchListData(plan, values);\n\n  // Empty -> Remove the list contents entirely and exit\n  if (listData.length === 0) {\n    return [plan, []];\n  }\n\n  // Collect existing elements from the DOM for assessment\n  const { rowTemplatesByRoot, rowTemplateElement, rowRootElement } = plan;\n  const keyAccessor = buildValueAccessor(plan.keyNotation);\n  const listRenderContexts: Map<unknown, ListRenderJobItem> = new Map();\n\n  for (const item of listData) {\n    const context: TemplateContext = {\n      item,\n    };\n\n    const key = keyAccessor(context);\n\n    if (listRenderContexts.has(key)) {\n      throw new PaletteError(\n        ErrorCode.TEMPLATE_DUPLICATE_LIST_KEY,\n        String(key),\n      );\n    }\n\n    // Get or create the HTML Element we expect to see here\n    let rowRoot = plan.rowRootsByKey.get(key);\n\n    if (rowRoot === undefined) {\n      rowRoot = rowRootElement.cloneNode(false) as HTMLElement;\n      plan.rowRootsByKey.set(key, rowRoot);\n    }\n\n    // Get or create the template associated with the row root\n    let rowTemplate = rowTemplatesByRoot.get(rowRoot);\n\n    if (rowTemplate === undefined) {\n      rowTemplate = new Template(rowTemplateElement);\n      rowTemplatesByRoot.set(rowRoot, rowTemplate);\n    }\n\n    const jobItem: ListRenderJobItem = {\n      context,\n      root: rowRoot,\n      template: rowTemplate,\n      attrMap: createAttributeMap(item),\n    };\n\n    listRenderContexts.set(key, jobItem);\n  }\n\n  // Clean up cached data\n  for (const [key, root] of plan.rowRootsByKey) {\n    if (!listRenderContexts.has(key)) {\n      plan.rowRootsByKey.delete(key);\n      plan.rowTemplatesByRoot.delete(root);\n    }\n  }\n\n  return [plan, Array.from(listRenderContexts.values())];\n}\n\nexport function runListRenderJobs(jobs: ListRenderJob[]): void {\n  for (const [plan, renderItems] of jobs) {\n    const { endMarker, listContainerElement } = plan;\n\n    // Fast path for empty lists -> Remove everything and continue\n    if (renderItems.length === 0) {\n      for (const root of plan.rowRootsByKey.values()) {\n        root.remove();\n      }\n      plan.rowRootsByKey.clear();\n      continue;\n    }\n\n    // Otherwise, scan the current nodes and modify as needed\n    const existingDOMNodes = Array.from(\n      collectHTMLElements(plan.startMarker, plan.endMarker),\n    );\n\n    const rootsToKeep = new Set<HTMLElement>();\n\n    let existingDOMNodeIdx = 0;\n\n    for (const renderItem of renderItems) {\n      const { root, attrMap, context, template } = renderItem;\n      const existingDOMNode = existingDOMNodes[existingDOMNodeIdx];\n\n      // Spread item as attributes on the root and update the template\n      applyAttributeMap(root, attrMap);\n      template.render(root, context);\n\n      rootsToKeep.add(root);\n\n      // Node is the existing DOM Node, continue\n      if (Object.is(existingDOMNode, root)) {\n        existingDOMNodeIdx += 1;\n        continue;\n      }\n\n      // No existing node -> append item\n      if (!existingDOMNode) {\n        listContainerElement.insertBefore(root, endMarker);\n        continue;\n      }\n\n      // DOM node exists but isn't the one we're looking for. Insert before.\n      listContainerElement.insertBefore(root, existingDOMNode);\n    }\n\n    // Remove any remaining old elements\n    for (const root of existingDOMNodes) {\n      if (!rootsToKeep.has(root)) {\n        root.remove();\n        plan.rowTemplatesByRoot.delete(root);\n      }\n    }\n  }\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\nimport { ErrorCode, PaletteError } from \"../errors\";\nimport { fragmentCache, htmlToFragment } from \"../util/fragments\";\nimport { LRUCache } from \"../util/lru-cache\";\nimport { compileTemplate, prepareCompiledTemplate } from \"./build\";\nimport {\n  prepareAttributeJob,\n  prepareContentSwapJob,\n  prepareListRenderJob,\n  prepareTagChangeJob,\n  runAttributeJobs,\n  runContentSwapJobs,\n  runListRenderJobs,\n  runTagChangeJobs,\n  SKIPPED_JOB,\n} from \"./jobs\";\nimport type { NotationAccessor } from \"./syntax\";\nimport type {\n  AnyRenderPlan,\n  AttributeUpdateJob,\n  CompiledTemplate,\n  ContentSwapJob,\n  ListRenderJob,\n  TagChangeJob,\n} from \"./types\";\n\nexport type TemplateRoot = HTMLElement | ShadowRoot;\nexport type TemplateContext = {\n  attr?: Record<string, string | null>;\n  state?: Record<string, unknown>;\n  data?: Record<string, unknown>;\n  item?: Record<string, unknown>;\n  index?: number;\n};\n\nconst compileCache = new LRUCache<HTMLTemplateElement, CompiledTemplate>();\n\nif (__DEV__ && typeof window !== \"undefined\") {\n  (window as any).__PALETTE_DEVTOOLS__ = {\n    dumpCacheMetrics: () => {\n      console.log(\"Compiled Templates Cache\", compileCache.metrics);\n      console.log(\"HTML Fragments Cache\", fragmentCache.metrics);\n    },\n  };\n}\n\n/**\n * A renderable template from an HTMLTemplateElement\n *\n * Leverages a simple syntax to provide accessors to template data from one of\n * four categories, based on use case:\n *\n * ```\n * `@` -> The `attr` namespace (the host element's attributes)\n * `$` -> The `state` namespace (the host element's reactive state)\n * `*` -> The `data` namespace (the host element's computed data)\n * `#` -> The `item` namespace (list item access with ::each)\n * ```\n *\n * Bind attributes to a value using the `:attribute` syntax:\n *\n * ```html\n * <div :id=\"$id\" :class=\"@classname\"></div>\n * ```\n */\nexport class Template {\n  /**\n   * Properties related to the global Template build cache.\n   *\n   * This is not something typically needed for general app development, but\n   * allows for advanced configuration to tune the caching system if need be.\n   *\n   * Cache sizes default to 500 HTML Template Fragments and compiled Palette\n   * templates (includes nested templates like lists) to cover most application\n   * needs without using much memory.\n   */\n  static cache = {\n    /**\n     * Wipe all cached templates and HTML fragments\n     */\n    clear: (): void => {\n      fragmentCache.clear();\n      compileCache.clear();\n    },\n\n    /**\n     * the default cache capacity of 500 items per cache\n     *\n     * General caching guidance:\n     * - 95% of the time, 500 works fine\n     * - For very large applications, up to 1000 is reasonable\n     * - For smaller apps, dropping down to 100 - 250 may save memory\n     *\n     * Ultimately the impact will be minimal unless your app has very specific\n     * rendering needs.\n     */\n    setCapacity: (maxSize: number): void => {\n      fragmentCache.setCapacity(maxSize);\n      compileCache.setCapacity(maxSize);\n    },\n  };\n\n  private _compiled: CompiledTemplate;\n\n  /**\n   * The original {@link HTMLTemplateElement} used to create this Template.\n   *\n   * @remarks\n   * Make sure to never operate directly on this element. Always clone.\n   */\n  private _templateElement?: HTMLTemplateElement;\n\n  /** The current known root element that this Template is rendered into */\n  private _mountedRoot?: TemplateRoot;\n\n  /** The most recent set value for each notation that has rendered */\n  private _latestRenderedValues: Map<string, unknown> = new Map();\n\n  /** The active HTMLElement which the template is updating on renders */\n  private _fragment: DocumentFragment;\n\n  /** Value Notations -> Set<Render Plans> */\n  private _plansByNotation: Map<string, Set<AnyRenderPlan>> = new Map();\n\n  /** Value Notations -> Accessor functions */\n  private _notationAccessors: Map<string, NotationAccessor> = new Map();\n\n  constructor(template: HTMLTemplateElement) {\n    if (template instanceof HTMLTemplateElement) {\n      this._templateElement = template;\n      const cached = compileCache.get(template);\n      const compiled = cached ?? compileTemplate(template);\n      this._compiled = compiled;\n\n      // Always set the compiled template to move it to the front of the cache\n      compileCache.set(template, compiled);\n    } else {\n      this._compiled = template;\n    }\n\n    // Prepare a fragment from the compiled HTML (cached)\n    const fragment = htmlToFragment(this._compiled.html);\n    const hydrated = prepareCompiledTemplate(this._compiled, fragment);\n\n    this._plansByNotation = hydrated.plansByNotation;\n    this._notationAccessors = hydrated.notationAccessors;\n    this._fragment = hydrated.fragment;\n  }\n\n  /**\n   * Create a full copy of this template for use in rendering to another root\n   */\n  clone = (): Template => {\n    return new Template(this.element());\n  };\n\n  /**\n   * @returns An {@link HTMLTemplateElement} representing this template\n   */\n  element = (): HTMLTemplateElement => {\n    if (this._templateElement) {\n      return this._templateElement;\n    }\n\n    const template = document.createElement(\"template\");\n    template.innerHTML = this._compiled.html;\n    return template;\n  };\n\n  private _collectUpdatedValues = (\n    context: TemplateContext,\n  ): Map<string, unknown> => {\n    const updatedValues = new Map<string, unknown>();\n\n    for (const [rawNotation, accessor] of this._notationAccessors) {\n      const previousValue = this._latestRenderedValues.get(rawNotation);\n      const newValue = accessor(context);\n\n      if (previousValue !== newValue && !Object.is(previousValue, newValue)) {\n        updatedValues.set(rawNotation, newValue);\n      }\n    }\n\n    return updatedValues;\n  };\n\n  private _update(newValues: Map<string, unknown>) {\n    const scheduledPlans: Set<AnyRenderPlan> = new Set();\n\n    const attributeJobs: AttributeUpdateJob[] = [];\n    const contentSwapJobs: ContentSwapJob[] = [];\n    const tagChangeJobs: TagChangeJob[] = [];\n    const listRenderJobs: ListRenderJob[] = [];\n\n    for (const [notation] of newValues) {\n      const affectedPlans = this._plansByNotation.get(notation);\n\n      if (affectedPlans) {\n        for (const plan of affectedPlans) {\n          if (scheduledPlans.has(plan)) {\n            continue;\n          }\n\n          scheduledPlans.add(plan);\n\n          switch (plan.type) {\n            case \"attr\": {\n              const job = prepareAttributeJob(plan, newValues);\n              if (job !== SKIPPED_JOB) {\n                attributeJobs.push(job);\n              }\n              break;\n            }\n            case \"each\": {\n              const job = prepareListRenderJob(plan, newValues);\n              if (job !== SKIPPED_JOB) {\n                listRenderJobs.push(job);\n              }\n              break;\n            }\n            case \"swap\": {\n              const job = prepareContentSwapJob(plan, newValues);\n              if (job !== SKIPPED_JOB) {\n                contentSwapJobs.push(job);\n              }\n              break;\n            }\n            case \"tag\": {\n              const job = prepareTagChangeJob(plan, newValues);\n              if (job !== SKIPPED_JOB) {\n                tagChangeJobs.push(job);\n              }\n              break;\n            }\n            default:\n              // Should be impossible given an exhaustive switch case\n              throw new PaletteError(ErrorCode.INVARIANT);\n          }\n        }\n      }\n    }\n\n    runAttributeJobs(attributeJobs);\n    runListRenderJobs(listRenderJobs);\n    runContentSwapJobs(contentSwapJobs);\n    runTagChangeJobs(tagChangeJobs);\n  }\n\n  /**\n   * Render this template into a target host element.\n   */\n  render = (root: TemplateRoot, context: TemplateContext): void => {\n    if (root !== this._mountedRoot) {\n      this._mountedRoot = root;\n      while (root.firstChild) {\n        root.removeChild(root.firstChild);\n      }\n\n      root.append(this._fragment);\n    }\n\n    const resolvedValues = this._collectUpdatedValues(context);\n\n    if (resolvedValues.size !== 0) {\n      this._update(resolvedValues);\n\n      // Save the values that were used for this render if the render succeeded\n      for (const [key, val] of resolvedValues) {\n        this._latestRenderedValues.set(key, val);\n      }\n    }\n  };\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\nimport { elementMatches } from \"#util\";\nimport type { Component } from \"./component\";\n\nexport type EventName = keyof GlobalEventHandlersEventMap;\nexport type EventHandler<K extends EventName = EventName> = (\n  event: GlobalEventHandlersEventMap[K],\n) => void;\n\ntype EventHandlerMap = Map<string, EventHandler>;\n\n/**\n * Managed event delegation to coalesce event listeners for an entire tree into\n * single root-level listeners.\n *\n * @example\n * Listen for events from any child element of the delegated root\n *\n * ```typescript\n * const delegator = new EventDelegator($root);\n * delegator.addDelegatedListener(\"click\", handleClick);\n * ```\n *\n * @example\n * Listen for events from child elements matching `.action`\n *\n * ```typescript\n * const delegator = new EventDelegator($root);\n * delegator.addDelegatedListener(\"click\", handleClick, \".action\");\n * ```\n */\nexport class EventDelegator {\n  static nextListenerId = 0;\n\n  static processTargetDescriptor(\n    targetDescriptor: string | typeof Component<any> | HTMLElement,\n  ): string {\n    // Create a query filter from the target descriptor\n    if (targetDescriptor instanceof HTMLElement) {\n      // If the element has an ID, use that\n      if (targetDescriptor.id.length) {\n        return `#${targetDescriptor.id}`;\n      } else {\n        const generatedId = `listen-${EventDelegator.nextListenerId++}`;\n        targetDescriptor.setAttribute(\"data-listener-id\", generatedId);\n        return `[data-listener-id=\"${generatedId}\"]`;\n      }\n    } else if (typeof targetDescriptor === \"function\") {\n      if (__DEV__) {\n        if (targetDescriptor.tagName.length === 0) {\n          console.warn(\n            `[Component] Automatic listener setup failure: Component ${targetDescriptor.name} has no defined tagname`,\n          );\n        }\n      }\n\n      // If the target descriptor is a Component class, pull the tagname\n      return targetDescriptor.tagName;\n    }\n\n    return targetDescriptor;\n  }\n\n  private _root: HTMLElement | ShadowRoot | Document;\n  private _rootListeners: EventHandlerMap = new Map();\n  private _events: Map<string, Map<string, Set<EventHandler>>> = new Map();\n\n  constructor(root: HTMLElement | ShadowRoot | Document = document) {\n    this._root = root;\n  }\n\n  private _handlersForEvent(event: string): Map<string, Set<EventHandler>> {\n    let handlerMap = this._events.get(event);\n\n    if (handlerMap === undefined) {\n      handlerMap = new Map();\n      this._events.set(event, handlerMap);\n    }\n\n    return handlerMap;\n  }\n\n  private _handlersForEventAndQuery<E extends EventName>(\n    event: E,\n    query: string,\n  ): Set<EventHandler<E>> {\n    const handlerMap = this._handlersForEvent(event);\n    let handlerSet = handlerMap.get(query);\n\n    if (handlerSet === undefined) {\n      handlerSet = new Set();\n      handlerMap.set(query, handlerSet);\n    }\n\n    return handlerSet;\n  }\n\n  private _createRootListener(eventName: string): void {\n    if (this._rootListeners.has(eventName)) {\n      return;\n    }\n\n    const listener = (event: Event) => {\n      const handlersForEvent = this._handlersForEvent(eventName);\n      const { target } = event;\n\n      if (target === null || !(target instanceof Node)) {\n        return;\n      }\n\n      let node: Node | null = target;\n\n      let stopImmediateCalled = false;\n      const originalFn = event.stopImmediatePropagation;\n      event.stopImmediatePropagation = () => {\n        originalFn.call(event);\n        stopImmediateCalled = true;\n      };\n\n      while (node) {\n        if (node === this._root) {\n          break;\n        }\n\n        // Skip invalid elements\n        if (!(node instanceof Element)) {\n          node = node.parentNode;\n          continue;\n        }\n\n        // Invoke handlers\n        for (const [query, handlers] of handlersForEvent) {\n          if (query === \"*\" || elementMatches(node, query)) {\n            for (const handler of handlers) {\n              handler.call(node, event);\n\n              // Respect .stopImmediatePropagation() and .preventDefault()\n              if (stopImmediateCalled || event.defaultPrevented) {\n                return;\n              }\n            }\n          }\n        }\n\n        // Respect .stopPropagation()\n        if (event.cancelBubble) {\n          return;\n        }\n\n        node = node.parentNode;\n\n        if (node === this._root || node instanceof ShadowRoot) {\n          break;\n        }\n      }\n    };\n\n    this._rootListeners.set(eventName, listener);\n    this._root.addEventListener(eventName, listener);\n  }\n\n  addListener<E extends EventName>(\n    eventName: E,\n    handler: EventHandler<E>,\n    queryFilter: string = \"*\",\n  ): void {\n    this._handlersForEventAndQuery(eventName, queryFilter).add(handler);\n    this._createRootListener(eventName);\n  }\n\n  removeListener(\n    eventName: EventName,\n    handler: EventHandler,\n    queryFilter: string,\n  ): void {\n    const handlerSet = this._handlersForEventAndQuery(eventName, queryFilter);\n    handlerSet.delete(handler);\n\n    // If that was the last handler for that event/query combo, delete the set\n    if (handlerSet.size === 0) {\n      const eventHandlerSets = this._handlersForEvent(eventName);\n      eventHandlerSets.delete(queryFilter);\n    }\n  }\n\n  cleanup = (): void => {\n    for (const [event, handler] of this._rootListeners) {\n      this._root.removeEventListener(event, handler);\n    }\n\n    this._rootListeners.clear();\n  };\n}\n",
    "/*\n * Copyright © Rustic Arcade, LLC 2026\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n\nimport { ErrorCode, PaletteError } from \"#error\";\nimport { css } from \"#helper\";\nimport { State } from \"#state\";\nimport { Template, type TemplateContext } from \"#template\";\nimport { createAttributeMap, serializeAttribute } from \"#util\";\nimport { EventDelegator, type EventHandler, type EventName } from \"./delegator\";\nimport type {\n  AttributeMap,\n  ComponentStyles,\n  ComputedProperties,\n  LiveAttributes,\n  StateInitializer,\n} from \"./types\";\n\nconst MAX_SEQUENTIAL_RENDERS = 100;\nconst BLANK_TEMPLATE = document.createElement(\"template\");\n\ntype InternalRenderStatus = {\n  willRender: boolean;\n  isRendering: boolean;\n  sequentialRenders: number;\n  postRenderCallbacks: Set<VoidFunction>;\n  lastRenderedAttributeMap: AttributeMap;\n  trackedAttributeChanges: AttributeMap;\n};\n\n/**\n * The **Component** class extends the base HTMLElement class to provide an\n * ergonomic way to design and develop Web Components with reactive state,\n * managed attributes, and dynamic templating.\n */\nexport abstract class Component<\n  StateShape extends object = {},\n> extends HTMLElement {\n  // ╭────────────────────────────────────────────────────────╮\n  // │                 Static Helper Methods                  │\n  // ╰────────────────────────────────────────────────────────╯\n\n  /**\n   * Register a Component with the browser. Optionally provide an overriding\n   * tag name.\n   */\n  static register(\n    component: CustomElementConstructor | typeof Component,\n    tagName?: string,\n  ): void {\n    if (\n      typeof window === \"undefined\" ||\n      typeof window.customElements === \"undefined\"\n    ) {\n      throw new PaletteError(ErrorCode.INVALID_ENV);\n    }\n\n    const componentTagname =\n      \"tagName\" in component && typeof component.tagName === \"string\"\n        ? component.tagName\n        : null;\n    const computedTagname = tagName ?? componentTagname;\n\n    if (\n      computedTagname === null ||\n      computedTagname.length === 0 ||\n      !computedTagname.includes(\"-\")\n    ) {\n      throw new PaletteError(ErrorCode.INVALID_TAGNAME);\n    }\n\n    if (window.customElements.get(computedTagname)) {\n      throw new PaletteError(ErrorCode.DUPE_TAGNAME, tagName ?? \"\");\n    }\n\n    // Ensure any live attributes are included in the observedAttributes\n\n    window.customElements.define(\n      computedTagname,\n      component as CustomElementConstructor,\n    );\n  }\n\n  // ╭────────────────────────────────────────────────────────╮\n  // │       Static Component Configuration Properties        │\n  // ╰────────────────────────────────────────────────────────╯\n\n  /**\n   * The HTML tag name to use for this Component\n   */\n  static tagName: string = \"\";\n\n  /**\n   * An HTML Template element for this element to use.\n   */\n  static template: HTMLTemplateElement | Template = BLANK_TEMPLATE;\n\n  /**\n   * A {@link CSSStyleSheet} array or string to adopt as the component's scoped styles\n   */\n  static styles: ComponentStyles = [];\n\n  /**\n   * An array of html attribute names to observe to trigger updates.\n   *\n   * @remarks\n   * If you use the {@link define} factory helper, this value will be\n   * automatically merged with a list of any defined {@link liveAttributes}.\n   */\n  static observedAttributes: string[] = [];\n\n  /**\n   * The mode for this Component's ShadowRoot.\n   *\n   * - `\"open\"` allows JS access to the children of this component\n   * - `\"closed\"` (default) disallows internal JS access\n   */\n  static shadowRootMode: \"closed\" | \"open\" = \"closed\";\n\n  // ╭────────────────────────────────────────────────────────╮\n  // │                  Lifecycle Properties                  │\n  // ╰────────────────────────────────────────────────────────╯\n\n  /**\n   * Primary scripting for this component.\n   *\n   * Use `script()` to define primary behaviors, listeners, and initializations.\n   *\n   * If need be, return a function to automatically call when the component is\n   * unmounting for cleanup scripts. Alternatively, use {@link finalize} for\n   * cleanup tasks, which will always run last, even after the returned function\n   * from script().\n   */\n  protected script?(): VoidFunction | void;\n\n  /**\n   * Called immediately before each template update\n   */\n  protected beforeUpdate?(): void;\n\n  /**\n   * Called immediately after each template update\n   */\n  protected afterUpdate?(previousAttributes: AttributeMap): void;\n\n  /**\n   * Called as the final lifecycle method at the end of the unmounting process.\n   *\n   * Content has been removed from the DOM and the component is no longer\n   * considered mounted when this function runs.\n   *\n   * Use this for final cleanup tasks and freeing resources.\n   */\n  protected finalize?(): void;\n\n  /**\n   * If defined, receives errors caught during the lifecycle methods of this\n   * component and it's children. If not defined, this component will instead\n   * throw errors as they are found.\n   *\n   * If the error cannot be handled, `onError()` should re-throw it for a higher\n   * up component to evaluate.\n   *\n   * To display an error message while removing an erroring component from the\n   * DOM, use `this.replaceWith()` and a newly constructed placeholder element.\n   *\n   * @example\n   *\n   * Recovering from errors or displaying a fallback\n   *\n   * ```typescript\n   * onError(error) {\n   *   // Handle known errors\n   *   if (error.message = \"Invalid Input\") {\n   *     this.state.input = \"\";\n   *     return;\n   *   }\n   *\n   *   // Display a fallback banner\n   *   const banner = document.createElement(\"div\");\n   *   banner.textContent = \"An unexpected error done did\";\n   *   this.replaceWith(banner);\n   * }\n   * ```\n   */\n  protected onError?(error: unknown): void;\n\n  /**\n   * The initial value for this Component's reactive internal state, if any.\n   *\n   * If `initialState` is defined as a function, the function is evaluated at\n   * mounting time and the return value is used as the initial state.\n   */\n  protected initialState?: StateInitializer<StateShape>;\n\n  /**\n   * An object or function returning an object which populates the `data` values\n   * in the templating engine. Such values are accessed using the `*` notation.\n   *\n   * When a hosted value is accessed, it's value is coerced based on the way it\n   * is being used. For attributes, values are serialized to a string or null,\n   * which will set the attribute (string) or remove it (null).\n   *\n   * For content swaps, strings, numbers and booleans are rendered as strings\n   * and set as textContent. null and undefined values render nothing (with a\n   * comment placeholder), an HTMLElement will be swapped in as a cloned node.\n   *\n   * Functions are evaluated at render/update time, and their return value is\n   * used instead. Functions are passed the current target node accessing the\n   * property as its first and only argument.\n   *\n   * Other types are unsupported.\n   *\n   * @example\n   *\n   * ```typescript\n   * host = {\n   *   avatarUrl: \"http://...\",\n   *   renderTime: () => new Date().toISOString(),\n   * }\n   * ```\n   *\n   * ```html\n   * <img :src=\"*avatarUrl\" />\n   * <span>Rendered at ${\"*renderTime\"}</span>\n   * ```\n   */\n  protected computedProperties?: ComputedProperties<StateShape>;\n\n  /**\n   * Declaration of attribute behaviors during updates.\n   *\n   * Each key is the name of an attribute. Values are an object with two\n   * optional function definitions:\n   *\n   * `onChange(newValue, oldValue): void`, a handler function for when the value\n   * of this attribute has changed. Runs once per update cycle, *before* the\n   * update occurs.\n   *\n   * `reflect(): unknown`, a function which returns a value to serialize and set\n   * as this attribute *after* an update completes.\n   *\n   * @example\n   *\n   * ```typescript\n   * liveAttributes = {\n   *   done: {\n   *     onChange(newValue) {\n   *       this.state.set(\"done\", !!newValue);\n   *     },\n   *     reflect() { return this.state.current.done }\n   *   }\n   * };\n   * ```\n   *\n   * @remarks\n   *\n   * If using the {@link define} helper, the keys of this property are\n   * automatically merged with any defined {@link observedAttributes}.\n   *\n   * If you are directly extending the class, `observedAttributes` must be\n   * explicitly defined with any attributes that should be monitored, regardless\n   * of if they're defined here.\n   */\n  protected liveAttributes?: LiveAttributes<StateShape>;\n\n  // ╭────────────────────────────────────────────────────────╮\n  // │               Internal State Management                │\n  // ╰────────────────────────────────────────────────────────╯\n\n  private _isComponentMounted: boolean = false;\n  private _template: Template;\n  private _root: ShadowRoot;\n  private _state?: State<StateShape>;\n  private _delegator?: EventDelegator;\n  private _ownListeners: Set<{\n    handler: EventHandler;\n    event: EventName;\n  }> = new Set();\n  private _liveAttributeConfigs: Map<\n    string,\n    LiveAttributes<StateShape>[string]\n  > = new Map();\n  private _cleanupFn?: VoidFunction;\n\n  private _renderInternals: InternalRenderStatus = {\n    willRender: false,\n\n    /** When set to `true`, the render/update process is actively running */\n    isRendering: false,\n    sequentialRenders: 0,\n    postRenderCallbacks: new Set(),\n    lastRenderedAttributeMap: new Map(),\n    trackedAttributeChanges: new Map(),\n  };\n\n  // ╭────────────────────────────────────────────────────────╮\n  // │             Internals and Private Methods              │\n  // ╰────────────────────────────────────────────────────────╯\n\n  constructor() {\n    super();\n\n    const { template, styles, shadowRootMode } = this\n      .constructor as typeof Component;\n\n    // Normalize styles to an array of CSSStyleSheet objects\n    const newStyles = Array.isArray(styles)\n      ? styles\n      : typeof styles === \"object\"\n        ? [styles]\n        : [css`${styles}`];\n\n    this._root = this.attachShadow({ mode: shadowRootMode });\n    this._root.adoptedStyleSheets.push(...newStyles);\n    this._template =\n      template instanceof Template ? template : new Template(template);\n  }\n\n  /** Produce the data object to pass to the template's render function */\n  private _getRenderContext(attr: AttributeMap): TemplateContext {\n    return {\n      attr: Object.fromEntries(attr),\n      data:\n        typeof this.computedProperties === \"function\"\n          ? this.computedProperties()\n          : this.computedProperties,\n      state: this._state ? this._state.current : undefined,\n    };\n  }\n\n  private _escalateError(error: unknown): void {\n    let node: Node | null = this.parentNode;\n\n    while (node) {\n      if (\n        node instanceof Component &&\n        \"onError\" in node &&\n        typeof node.onError === \"function\"\n      ) {\n        node.onError(error);\n        return;\n      } else if (node instanceof ShadowRoot) {\n        node = node.host;\n      } else {\n        node = node.parentNode;\n      }\n    }\n\n    // If nothing was found to escalate to, throw the error\n    throw error;\n  }\n\n  private _reportError(error: unknown): void {\n    if (!this.onError) {\n      this._escalateError(error);\n    } else {\n      this.onError(error);\n    }\n  }\n\n  private _executeAttributeChangeHandlers = () => {\n    const prevAttrs = this._renderInternals.lastRenderedAttributeMap;\n\n    // Copy the changes to a new map and clear the tracking map\n    const trackedChanges = new Map(\n      this._renderInternals.trackedAttributeChanges,\n    );\n    this._renderInternals.trackedAttributeChanges.clear();\n\n    for (const [name, val] of trackedChanges) {\n      const config = this._liveAttributeConfigs.get(name);\n      if (!config) {\n        continue;\n      }\n\n      if (\"onChange\" in config) {\n        const previousValue = prevAttrs.get(name) ?? null;\n\n        if (config && previousValue !== val) {\n          config.onChange?.call(this, val, previousValue);\n        }\n      }\n    }\n  };\n\n  private _reflectLiveAttributes = () => {\n    const toSet: [name: string, val: string | null][] = [];\n\n    for (const [name, config] of this._liveAttributeConfigs) {\n      if (\"reflect\" in config) {\n        const val = serializeAttribute(config.reflect?.call(this));\n        const current = this.getAttribute(name);\n\n        if (val !== current) {\n          toSet.push([name, val]);\n        }\n      }\n    }\n\n    for (const [name, val] of toSet) {\n      this.reflectAttribute(name, val);\n    }\n  };\n\n  /** The actual update behavior */\n  private _performUpdate = (): void => {\n    try {\n      // Immediately flip flags to denote a render is in progress and allow\n      // queueing another render request.\n      this._renderInternals.isRendering = true;\n      this._renderInternals.willRender = false;\n\n      // Attributes: Run any `read` hooks for changed attributes\n      this._executeAttributeChangeHandlers();\n\n      // Cache the attributes from the previous render\n      const prevAttrs = this._renderInternals.lastRenderedAttributeMap;\n\n      this.beforeUpdate?.();\n\n      // Update the current snapshot of attributes\n      const newAttributes = createAttributeMap(this);\n      this._template.render(this.root, this._getRenderContext(newAttributes));\n      this._renderInternals.lastRenderedAttributeMap = newAttributes;\n      this.afterUpdate?.(prevAttrs);\n\n      // Attributes: Run any `write` hooks for updated values\n      this._reflectLiveAttributes();\n\n      // Run any requested render callbacks\n      // These are considered lifecycle methods as well, and will report errors\n      // as any other lifecycle method would\n      if (this._renderInternals.postRenderCallbacks.size) {\n        const callbacks = Array.from(this._renderInternals.postRenderCallbacks);\n        this._renderInternals.postRenderCallbacks.clear();\n\n        for (const fn of callbacks) {\n          fn();\n        }\n      }\n\n      // If the `willRender` flag was flipped, immediately perform a render\n      if (this._renderInternals.willRender) {\n        this._renderInternals.sequentialRenders += 1;\n\n        if (this._renderInternals.sequentialRenders >= MAX_SEQUENTIAL_RENDERS) {\n          throw new PaletteError(\n            ErrorCode.MAX_SEQUENTIAL_RENDERS,\n            `${this._renderInternals.sequentialRenders}`,\n          );\n        }\n\n        this._performUpdate();\n      } else {\n        this._renderInternals.sequentialRenders = 0;\n      }\n    } catch (error) {\n      this._renderInternals.willRender = false;\n      this._reportError(error);\n    } finally {\n      this._renderInternals.isRendering = false;\n    }\n  };\n\n  /** Safely request for an update to run on the next frame */\n  private _scheduleUpdate = () => {\n    // Prevent scheduling multiple renders\n    if (this._renderInternals.willRender) {\n      return;\n    }\n\n    this._renderInternals.willRender = true;\n\n    // If currently rendering, don't request a render, it will auto-continue\n    // until there are no changes to render\n    if (this._renderInternals.isRendering) {\n      return;\n    }\n\n    // If a render is requested and we're not rendering, request a render frame\n    requestAnimationFrame(this._performUpdate);\n  };\n\n  private _adoptState(state: StateShape | State<StateShape>) {\n    // If this is exactly our own state object, do nothing\n    if (Object.is(this._state, state)) {\n      return;\n    }\n\n    // If state exists, remove the listener and schedule a render\n    if (this._state) {\n      this._state.removeListener(this._scheduleUpdate);\n      this._scheduleUpdate();\n    }\n\n    // Adopt the incoming state obj or wrap and adopt it\n    const incomingStateObj = state instanceof State ? state : new State(state);\n    this._state = incomingStateObj;\n\n    // Ensure there is not accidentally two of the same render listeners\n    this._state.removeListener(this._scheduleUpdate);\n    this._state.addListener(this._scheduleUpdate);\n  }\n\n  // ╭────────────────────────────────────────────────────────╮\n  // │           Custom Element Callback Overrides            │\n  // ╰────────────────────────────────────────────────────────╯\n\n  /**\n   * @deprecated Use {@link script} instead\n   */\n  protected connectedCallback(): void {\n    if (this._isComponentMounted) {\n      return;\n    }\n\n    queueMicrotask(() => {\n      try {\n        this._renderInternals.isRendering = true;\n        this._renderInternals.willRender = false;\n\n        const attributes = createAttributeMap(this);\n        this._liveAttributeConfigs = new Map(\n          Object.entries(this.liveAttributes ?? {}),\n        );\n\n        // If this is a stateful component, set up that state\n        if (this.initialState) {\n          const init =\n            typeof this.initialState === \"object\"\n              ? this.initialState\n              : this.initialState();\n\n          this._adoptState(init);\n        }\n\n        this._template.render(this.root, this._getRenderContext(attributes));\n        this._reflectLiveAttributes();\n        this._renderInternals.lastRenderedAttributeMap = attributes;\n        this._isComponentMounted = true;\n        this._cleanupFn = this.script?.() ?? undefined;\n      } catch (error) {\n        this._reportError(error);\n      } finally {\n        this._renderInternals.isRendering = false;\n      }\n    });\n  }\n\n  /**\n   * @deprecated use {@link finalize}\n   */\n  protected disconnectedCallback(): void {\n    queueMicrotask(() => {\n      // If this task runs but the component is still connected, then do nothing\n      // because the component was just moved in the DOM.\n      if (this.isConnected || !this._isComponentMounted) {\n        return;\n      }\n\n      // Only run the disconnect if the element is actually unmounted and not\n      // just moved. Using this in place of connectedMoveCallback() for compat\n      try {\n        this._delegator?.cleanup();\n\n        // Clear any listeners set up on self\n        if (this._ownListeners.size > 0) {\n          for (const listener of this._ownListeners) {\n            this.removeEventListener(listener.event, listener.handler);\n          }\n        }\n\n        this._cleanupFn?.();\n        this._isComponentMounted = false;\n      } catch (error) {\n        this._reportError(error);\n      } finally {\n        // Run the finalize call after everything, even if the cleanup fn failed\n        try {\n          this.finalize?.();\n        } catch (error) {\n          this._reportError(error);\n        }\n      }\n    });\n  }\n\n  /**\n   * @deprecated Use {@link liveAttributes} instead\n   */\n  protected attributeChangedCallback(\n    name: string,\n    _: string | null,\n    newValue: string | null,\n  ): void {\n    // Ignore attribute changes that occur during an update, as they are\n    // coming from inside the house\n    if (this._renderInternals.isRendering) {\n      return;\n    }\n\n    // Skip non-changes using the stored attributes as reference to compare\n    // to the render state rather than the dom\n    if (\n      newValue === this._renderInternals.lastRenderedAttributeMap?.get(name)\n    ) {\n      return;\n    }\n\n    // Cache the updated attribute value\n    this._renderInternals.trackedAttributeChanges.set(name, newValue);\n\n    // Schedule a render\n    if (!this._renderInternals.willRender) {\n      this._scheduleUpdate();\n    }\n  }\n\n  // ╭────────────────────────────────────────────────────────╮\n  // │                    Public Interface                    │\n  // ╰────────────────────────────────────────────────────────╯\n\n  /**\n   * The ShadowRoot node of this element\n   */\n  get root(): ShadowRoot {\n    return this._root;\n  }\n\n  /**\n   * Directly access and manipulate this Component's reactive state with deep\n   * reactivity enabled.\n   *\n   * @example\n   *\n   * ```typescript\n   * initialState = { values: { count: 1, time: 0 } };\n   *\n   * increment() {\n   *   this.state.values.count = 2;\n   * }\n   * ```\n   *\n   * @remarks\n   * This is a shorthand getter for `this.getState().live`\n   */\n  get state(): StateShape {\n    if (!this._state) {\n      throw new PaletteError(ErrorCode.MISSING_STATE);\n    }\n\n    return this._state.live;\n  }\n\n  /**\n   * Replace the current state with a new value or adopt a whole different State\n   * instance\n   *\n   * @example\n   *\n   * State replacement\n   *\n   * ```typescript\n   * // Always triggers a render\n   * this.state = { some: \"newState\" }\n   *\n   * // Adopt a new state instance altogether\n   * const otherState = new State({some: \"newState\"});\n   * this.state = otherState;\n   *\n   * // Causes a render\n   * otherState.set(\"some\", \"value\");\n   * ```\n   */\n  set state(newState: StateShape | State<StateShape>) {\n    this._adoptState(newState);\n  }\n\n  /**\n   * Access the full {@link State} instance for this Component.\n   *\n   * Using this method on a component which is not using reactive state\n   * will result in an error being thrown.\n   *\n   * @example\n   *\n   * Retrieve stateful value\n   *\n   * ```typescript\n   * class Example extends Component {\n   *   initialState = { count: 1 };\n   *\n   *   script() {\n   *     const state = this.getState();\n   *     console.log(`The count is ${state.get(\"count\")}`);\n   *   }\n   *\n   * }\n   * ```\n   *\n   * @example\n   *\n   * Set a stateful value\n   *\n   * ```typescript\n   * class Example extends Component {\n   *   initialState = { count: 1 };\n   *\n   *   increment() {\n   *     const state = this.getState();\n   *     const current = state.get(\"count\");\n   *     state.set(\"count\", current + 1);\n   *   }\n   * }\n   * ```\n   */\n  getState(): State<StateShape> {\n    if (!this._state) {\n      throw new PaletteError(ErrorCode.MISSING_STATE);\n    }\n\n    return this._state;\n  }\n\n  /**\n   * Manually schedule a render to occur\n   *\n   * @remarks\n   * Calling {@link requestRender} multiple times in the same event loop won't\n   * schedule multiple renders. Renders are scheduled to occur on the next\n   * animation frame.\n   */\n  requestRender(callback?: VoidFunction): void {\n    if (callback) {\n      this._renderInternals.postRenderCallbacks.add(callback);\n    }\n\n    this._scheduleUpdate();\n  }\n\n  /**\n   * Create a managed event listener on this Component with an optional query\n   * filter string to specify which elements to listen to events from.\n   *\n   * Event handlers set up with `listen()` are automatically cleaned up when\n   * the component is unmounted.\n   *\n   * Handlers are delegated to a single listener per event on the root of the\n   * Component, which is the closed ShadowRoot by default.\n   *\n   * @example\n   *\n   * Set up an event listener for a click event from a button with ID \"submit\"\n   *\n   * ```typescript\n   * this.listen(\"#submit\", \"click\", this.handleClick);\n   * ```\n   *\n   * @example\n   *\n   * Set up an event listener on the host element itself (`this`).\n   *\n   * ```typescript\n   * // Use \":host\" or \":HOST\" as the query selector to targe the host element\n   * this.listen(\":host\", \"animationend\", this.handler);\n   * ```\n   */\n  listen<E extends EventName>(\n    targetDescriptor: string | typeof Component<any> | HTMLElement,\n    eventName: E,\n    eventHandler: EventHandler<E>,\n  ): void {\n    const query = EventDelegator.processTargetDescriptor(targetDescriptor);\n\n    // If the query filter is `\":host\"`, set up an ownListener\n    if (query === \":host\" || query === \":HOST\") {\n      this.addEventListener(eventName, eventHandler);\n      this._ownListeners.add({\n        handler: eventHandler as EventHandler,\n        event: eventName,\n      });\n      return;\n    }\n\n    // Otherwise, set up a root listener\n    if (!this._delegator) {\n      this._delegator = new EventDelegator(this.root);\n    }\n\n    this._delegator.addListener(eventName, eventHandler, query);\n  }\n\n  stopListening<E extends EventName>(\n    targetDescriptor: string | typeof Component<any> | HTMLElement,\n    eventName: E,\n    eventHandler: EventHandler<E>,\n  ): void {\n    const query = EventDelegator.processTargetDescriptor(targetDescriptor);\n\n    // If the query filter is `\":host\"`, remove from the ownListener list\n    if (query === \":host\" || query === \":HOST\") {\n      this.removeEventListener(eventName, eventHandler as EventHandler);\n      for (const listener of this._ownListeners) {\n        if (listener.event === eventName && listener.handler === eventHandler) {\n          this._ownListeners.delete(listener);\n        }\n      }\n      return;\n    }\n\n    // If the delegator is not set up, there's nothing to do\n    if (!this._delegator) {\n      return;\n    }\n\n    this._delegator.removeListener(\n      eventName,\n      eventHandler as EventHandler,\n      query,\n    );\n  }\n\n  dispatchEvent(event: Event): boolean;\n\n  /**\n   * Dispatch a {@link CustomEvent} with the specified name and detail\n   *\n   * @example Defining custom events\n   *\n   * ```typescript\n   * // Define types. This can happen in the same file or elsewhere for common\n   * // and shared events.\n   * export type MyEvent = CustomEvent<T> // Set `T` to the event detail type\n   *\n   * declare global {\n   *  interface GlobalEventHandlersEventMap {\n   *    \"my-event-name\": MyEvent\n   *  }\n   * }\n   *\n   * // Dispatch a custom event\n   * this.dispatchEvent(\"my-event-name\", T);\n   *\n   * // Listen to a custom event\n   * $el.addEventListener(\"my-event-name\", ...);\n   * ```\n   */\n  dispatchEvent<T>(\n    event: string,\n    detail?: T,\n    options?: {\n      bubbles: boolean;\n      cancelable: boolean;\n      composed: boolean;\n    },\n  ): boolean;\n  dispatchEvent<T>(\n    event: string | Event,\n    detail?: T,\n    options?: {\n      bubbles: boolean;\n      cancelable: boolean;\n      composed: boolean;\n    },\n  ): boolean {\n    if (event instanceof Event) {\n      return super.dispatchEvent(event);\n    }\n\n    const opts = {\n      bubbles: true,\n      cancelable: true,\n      composed: true,\n      ...(options ?? {}),\n    };\n\n    return super.dispatchEvent(\n      new CustomEvent<T>(event, {\n        detail,\n        ...opts,\n      }),\n    );\n  }\n\n  querySelector<E extends HTMLElement>(query: string): E | null {\n    return this._root.querySelector(query);\n  }\n\n  querySelectorAll<E extends HTMLElement>(query: string): NodeListOf<E> {\n    return this._root.querySelectorAll(query) as NodeListOf<E>;\n  }\n\n  getElementById<E extends HTMLElement>(id: string): E | null {\n    if (this._root instanceof ShadowRoot) {\n      return this._root.getElementById(id) as E | null;\n    } else {\n      return HTMLElement.prototype.querySelector.call(\n        this,\n        `#${id}`,\n      ) as E | null;\n    }\n  }\n\n  requireElementById<E extends HTMLElement>(id: string): E {\n    const lookup = this.getElementById<E>(id);\n    if (!lookup) {\n      throw new PaletteError(ErrorCode.MISSING_ELEMENT);\n    }\n    return lookup;\n  }\n\n  setAttribute(name: string, value: string): void;\n\n  /**\n   * Set a value as an attribute, serializing to a string or `null`.\n   *\n   * null values cause the attribute to be removed from this element\n   */\n  setAttribute(name: string, value: unknown): void;\n  setAttribute(name: string, value: unknown): void {\n    const serialized = serializeAttribute(value);\n    if (serialized === null) {\n      HTMLElement.prototype.removeAttribute.call(this, name);\n    } else {\n      HTMLElement.prototype.setAttribute.call(this, name, serialized);\n    }\n  }\n\n  getAttribute(name: string): string | null;\n\n  /**\n   * Get an attribute as a number, falling back to a specified default.\n   *\n   *\n   * `null` attributes are returned as `null`, while string attributes are\n   * parsed using the `Number()` constructor.\n   *\n   * Values which evaluate to NaN are returned as `null`.\n   */\n  getAttribute(name: string, defaultValue: number): number;\n\n  /**\n   * Get an attribute as a string, falling back to a specified default\n   */\n  getAttribute(name: string, defaultValue: string): string;\n  getAttribute(\n    name: string,\n    defaultValue?: string | number,\n  ): string | number | null {\n    const value = HTMLElement.prototype.getAttribute.call(this, name);\n\n    if (defaultValue === undefined) {\n      return value;\n    }\n\n    if (typeof defaultValue === \"number\") {\n      if (value === null) {\n        return defaultValue;\n      }\n\n      const parsed = Number(value);\n\n      if (Number.isNaN(parsed)) {\n        return defaultValue;\n      }\n\n      return parsed;\n    }\n\n    // Invalid function invocation\n    throw new PaletteError(ErrorCode.INVARIANT);\n  }\n\n  /**\n   * Set the value of an attribute on this element if the provided value\n   * differs from the attribute when serialized\n   */\n  reflectAttribute(name: string, value: unknown): void {\n    const current = this.getAttribute(name);\n    const reflected = serializeAttribute(value);\n\n    if (current !== reflected) {\n      this.setAttribute(name, reflected);\n    }\n  }\n\n  /**\n   * Serialize this element to a string\n   */\n  toString(full: boolean = false): string {\n    const name = (this.constructor as typeof Component).name;\n    const attrString = this.getAttributeNames()\n      .map((attrName) => {\n        const val = this.getAttribute(attrName);\n        return val ? `${attrName}=\"${val}\"` : \"\";\n      })\n      .join(\" \");\n    const attrs = attrString.length > 0 ? ` ${attrString}` : \"\";\n\n    if (full) {\n      return `Component<${name}${attrs}>\\n${this.root.innerHTML}\\n</${name}>`;\n    }\n\n    return `Component<${name}${attrs}>`;\n  }\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n\nimport { Component } from \"./component\";\nimport type {\n  AttributeMap,\n  ComponentStyles,\n  ComputedProperties,\n  LiveAttributes,\n  StateInitializer,\n} from \"./types\";\n\nconst BLANK_TEMPLATE = document.createElement(\"template\");\n\nexport interface ComponentShorthand<StateShape extends object = {}> {\n  /**\n   * An HTML Template element for this element to use.\n   */\n  template?: HTMLTemplateElement;\n\n  /**\n   * A {@link CSSStyleSheet} array to adopt to the element's shadow DOM\n   */\n  styles?: ComponentStyles;\n\n  /**\n   * The mode for this Component's ShadowRoot.\n   *\n   * - `\"open\"` allows JS access to the children of this component\n   * - `\"closed\"` (default) disallows internal JS access\n   */\n  shadowRootMode?: \"closed\" | \"open\";\n\n  /**\n   * The initial state for this Component's reactive internal state, if any.\n   */\n  initialState?: StateInitializer<StateShape>;\n\n  /**\n   * An object or function returning an object which populates the `data` values\n   * in the templating engine. Such values are accessed using the `*` notation.\n   */\n  computedProperties?: ComputedProperties<StateShape>;\n\n  /**\n   * Declaration of attribute behaviors during updates.\n   */\n  liveAttributes?: LiveAttributes<StateShape>;\n\n  /**\n   * Initialization scripting for this Component\n   */\n  script?: (this: Component<StateShape>) => VoidFunction | void;\n\n  /**\n   * Called immediately before each template update\n   */\n  beforeUpdate?: (this: Component<StateShape>) => void;\n\n  /**\n   * Called immediately after each template update\n   */\n  afterUpdate?: (\n    this: Component<StateShape>,\n    previousAttributes: AttributeMap,\n  ) => void;\n\n  /**\n   * Called as the final lifecycle method at the end of the unmounting process.\n   *\n   * Content has been removed from the DOM and the component is no longer\n   * considered mounted when this function runs.\n   *\n   * Use this for final cleanup tasks and freeing resources.\n   */\n  finalize?: (this: Component<StateShape>) => void;\n\n  /**\n   * If defined, receives errors caught during the lifecycle methods of this\n   * component and it's children. If not defined, this component will instead\n   * throw errors as they are found.\n   *\n   * If the error cannot be handled, `onError()` should re-throw it for a higher\n   * up component to evaluate.\n   *\n   * To display an error message while removing an erroring component from the\n   * DOM, use `this.replaceWith()` and a newly constructed placeholder element.\n   *\n   * @example\n   *\n   * Recovering from errors or displaying a fallback\n   *\n   * ```typescript\n   * onError(error) {\n   *   // Handle known errors\n   *   if (error.message = \"Invalid Input\") {\n   *     this.state.input = \"\";\n   *     return;\n   *   }\n   *\n   *   // Display a fallback banner\n   *   const banner = document.createElement(\"div\");\n   *   banner.textContent = \"An unexpected error done did\";\n   *   this.replaceWith(banner);\n   * }\n   * ```\n   */\n  onError?: (this: Component<StateShape>, error: unknown) => void;\n}\n\nexport function define<StateShape extends object = {}>(\n  tagname: string,\n  definition: ComponentShorthand<StateShape>,\n): typeof Component<StateShape> {\n  const {\n    // Config\n    template = BLANK_TEMPLATE,\n    styles = [],\n    shadowRootMode = \"closed\",\n    initialState,\n    computedProperties = {},\n    liveAttributes = {},\n\n    // Lifecycle\n    script,\n    beforeUpdate,\n    afterUpdate,\n    finalize,\n    onError,\n  } = definition;\n\n  const fullObservedAttributes = Array.from(\n    new Set([...Object.keys(liveAttributes)]),\n  );\n\n  const cls = class extends Component<StateShape> {\n    static tagName = tagname;\n    static template = template;\n    static styles = styles;\n    static observedAttributes = [...fullObservedAttributes];\n    static shadowRootMode = shadowRootMode;\n\n    constructor() {\n      super();\n\n      this.initialState =\n        typeof initialState === \"function\"\n          ? initialState.bind(this)\n          : initialState;\n      this.computedProperties =\n        typeof computedProperties === \"function\"\n          ? computedProperties.bind(this)\n          : computedProperties;\n      this.liveAttributes = liveAttributes;\n\n      for (const def of Object.values(this.liveAttributes)) {\n        if (def.onChange) {\n          def.onChange = def.onChange.bind(this);\n        }\n\n        if (def.reflect) {\n          def.reflect = def.reflect.bind(this);\n        }\n      }\n\n      this.script = script?.bind(this) ?? undefined;\n      this.beforeUpdate = beforeUpdate?.bind(this) ?? undefined;\n      this.afterUpdate = afterUpdate?.bind(this) ?? undefined;\n      this.finalize = finalize?.bind(this) ?? undefined;\n      this.onError = onError?.bind(this) ?? undefined;\n    }\n  };\n\n  Component.register(cls, tagname);\n\n  return cls;\n}\n"
  ],
  "mappings": "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",
  "debugId": "0F958CC20A4D682464756E2164756E21",
  "names": []
}
+//# debugId=D9A90808356EA17464756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/errors.ts", "src/state/state.ts", "src/util/lru-cache.ts", "src/util/fragments.ts", "src/util/attributes.ts", "src/util/element-match.ts", "src/util/dom.ts", "src/template/constant.ts", "src/template/syntax.ts", "src/template/util.ts", "src/template/compile.ts", "src/helper/css.ts", "src/helper/html.ts", "src/template/jobs/common.ts", "src/template/jobs/attribute.ts", "src/template/jobs/conditional.ts", "src/template/jobs/list.ts", "src/template/jobs/swap.ts", "src/template/jobs/tag.ts", "src/template/jobs/index.ts", "src/template/prepare.ts", "src/template/template.ts", "src/task-scheduler.ts", "src/component/delegator.ts", "src/component/component.ts", "src/component/factory.ts", "src/devtools.ts"],
  "sourcesContent": [
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n/**\n * Possible error types for {@link PaletteError}\n *\n * Codes are categorized into groups by the 100's:\n *\n * - 0 - 99: Invariants\n * - 100 - 199: Custom Elements / Environment Errors\n * - 200 - 299: Templating Errors\n * - 300 - 399: Runtime Errors\n */\nexport const enum ErrorCode {\n  // 0 - 99: Invariants\n  INVARIANT = 0,\n  INVALID_ENV = 1,\n  INVALID_CALLSITE = 2,\n  MISSING_NODE_REF = 3,\n\n  // 100 - 199: Custom Elements Errors\n  INVALID_TAGNAME = 100,\n\n  // 200 - 299: Template Errors\n  TEMPLATE_INVALID_VALUE = 200,\n  TEMPLATE_INVALID_NOTATION_SYNTAX = 201,\n  TEMPLATE_MISSING_NOTATION = 202,\n  TEMPLATE_INVALID_COMPONENT = 203,\n  TEMPLATE_INVALID_LIST_DATA = 204,\n  TEMPLATE_MISSING_LIST_KEY = 205,\n  TEMPLATE_DUPLICATE_LIST_KEY = 206,\n  TEMPLATE_INVALID_CONDITIONAL = 207,\n  TEMPLATE_INVALID_KEY_DIRECTIVE = 208,\n  TEMPLATE_PARENT_REQUIRED = 209,\n\n  // 300 - 399: Runtime Errors\n  MISSING_ELEMENT = 300,\n  MISSING_STATE = 301,\n  INVALID_CONTENT = 302,\n  INVALID_STATE_KEY = 303,\n  INVALID_STATE_UPDATE = 304,\n  STATE_LOCKED = 305,\n  MAX_SEQUENTIAL_RENDERS = 306,\n}\n\nfunction getDevError(code: ErrorCode) {\n  const DEV_ERROR_INFO: Record<ErrorCode, string> = {\n    [ErrorCode.INVARIANT]: `\nINVARIANT\nA condition has occurred which should never happen, such as a code path that\nshouldn't be reachable when using correct types, or a disallowed state.\n`,\n\n    [ErrorCode.INVALID_ENV]: `\nINVALID_ENV\nFailed to find a custom elements registry in this environment. Is a window\nglobal available with a customElements property?\n`,\n    [ErrorCode.INVALID_CALLSITE]: `\nINVALID_CALLSITE\nA function was invoked with an invalid set of parameters.   \n`,\n\n    [ErrorCode.INVALID_TAGNAME]: `\nINVALID_TAGNAME\nFailed to determine a valid HTML Tag to use when registering a component as a\ncustom element. Specify a static readonly tagName property on your component\nclass or provide a tagName argument to Component.register.\n\nAlternatively, you can directly register your element as you would any other\nHTML custom element: customElements.define(\"my-tag\", MyComponentClass);\n`,\n\n    [ErrorCode.MISSING_ELEMENT]: `\nMISSING_ELEMENT\nAn element was expected to exist but was not found when the DOM was queried.\n`,\n\n    [ErrorCode.MISSING_STATE]: `\nMISSING_STATE\nA Component's reactive state was accessed, but no initialState is defined for\nthe Component's class. Initial state must be defined as an object or function.\n`,\n\n    [ErrorCode.INVALID_CONTENT]: `\nINVALID_CONTENT\nTried to set a value as content in a template, but the value was not a supported\ntype. Values must be a string, HTMLElement.\n\nInstead, got %s: %s.\n`,\n\n    [ErrorCode.TEMPLATE_INVALID_VALUE]: `\nTEMPLATE_INVALID\nThe value %s cannot be interpolated via the Template html string helper.\nValues may only be HTMLTemplateElements (template content is adopted) or\nstrings (shorthand for a ::swap directive on an element)\n`,\n\n    [ErrorCode.TEMPLATE_INVALID_NOTATION_SYNTAX]: `\nTEMPLATE_INVALID_NOTATION\nA template value notation failed to parse. Notations must begin with one of\n@, $, *, or #, followed by a dot-separated path of accessor names. Optionally,\nnotations may have modifiers such as the ! modifier.\n\nThe notation that failed to parse was \"%s\"\n`,\n    [ErrorCode.TEMPLATE_INVALID_COMPONENT]: `\nTEMPLATE_INVALID_COMPONENT\nFailed to interpolate a Component in an html template string due to the\nComponent having an invalid tagName property.\n\nComponent \"%s\" has an invalid tagName property \"%s\"\n    `,\n\n    [ErrorCode.TEMPLATE_INVALID_LIST_DATA]: `\nTEMPLATE_INVALID_LIST\nA template failed to render because an ::each directive fetched a value which\nwas not an array of actionable data.\n`,\n\n    [ErrorCode.MISSING_NODE_REF]: `\nTEMPLATE_INVALID_NODE_REF\nA template failed to prepare a node from a compiled source. Typically, this\nmeans something is broken within the compiled template rather than an error with\nthe template content itself.\n`,\n\n    [ErrorCode.TEMPLATE_MISSING_LIST_KEY]: `\nTEMPLATE_MISSING_LIST_KEY\nA template failed to compile because an ::each directive was found on an element\nwithout a corresponding ::key directive. ::each directives must have a ::key\ndirective specified on the same element, whose notation evaluates to a unique\nvalue for each item in the list.\n\nExample: <li ::each=\"$items\" ::key=\"#id\"> ... </li>\n`,\n\n    [ErrorCode.TEMPLATE_DUPLICATE_LIST_KEY]: `\nTEMPLATE_DUPLICATE_LIST_KEY\nA list failed to render because item key %s appeared multiple times when\nresolving list item keys. Each ::key directive must reference a notation whose\nvalue is unique for each list item.\n`,\n\n    [ErrorCode.TEMPLATE_INVALID_CONDITIONAL]: `\nTEMPLATE_INVALID_CONDITIONAL\nA template failed to compile due to an invalid use of conditional directives.\n\nConditional elements must be siblings. The first conditional branch must use an\n::if directive, followed by zero or more ::else-if directives, and finally zero\nor one ::else directive.\n\n::if and ::else-if directives must specify a notation to evaluate. ::else does\nnot take any values and is just a binary attribute.\n`,\n\n    [ErrorCode.TEMPLATE_MISSING_NOTATION]: `\nTEMPLATE_MISSING_NOTATION\nA template failed to compile because a %s directive did not have an associated\nnotation despite requiring one.\n`,\n\n    [ErrorCode.INVALID_STATE_KEY]: `\nINVALID_STATE_KEY\nTried to access a state property which does not exist\n\nKey path: %s\n`,\n\n    [ErrorCode.INVALID_STATE_UPDATE]: `\nINVALID_STATE_UPDATE\nA Component's setState() was called with a value which could not be patched in\nto the existing component state.\n\nsetState() takes a partial object describing state keys to update.\n\nInstead, received: %s\n`,\n\n    [ErrorCode.STATE_LOCKED]: `\nSTATE_LOCKED\nA State received a request to update or lock while already locked.\nStates may be locked using the .lock() method and unlocked using the .unlock()\nmethod. States lock during async mutations done through the .mutateAsync()\nmethod if \"true\" is passed as the second parameter.\n\nYou can check the lock status of a State instance with .isLocked\n`,\n\n    [ErrorCode.MAX_SEQUENTIAL_RENDERS]: `\nMAX_SEQUENTIAL_RENDERS\nA component has errored after re-rendering more than %s times in the same frame.\n\nThis typically happens because state or live attributes are being modified\nduring a render lifecycle method such as beforeUpdate() or afterUpdate(). If\nstate changes unconditionally during a render, the render will infinitely loop.\nUpdating render source data during a render cycle is supported, but infinite\nupdate loops may occur if unchecked.\n`,\n\n    [ErrorCode.TEMPLATE_INVALID_KEY_DIRECTIVE]: `\nTEMPLATE_INVALID_KEY_DIRECTIVE\nA template failed to compile because a ::key directive was found on an element\nwith no associated ::each directive. ::key directives can only be used in\nassociation with list rendering via ::each.\n`,\n    [ErrorCode.TEMPLATE_PARENT_REQUIRED]: `\nTEMPLATE_PARENT_REQUIRED\nA template failed to compile due to an element which requires a parent having\nno available parent in the template.\n\n::each and ::if/::else-if/::else elements must have a parent node.\n`,\n  };\n\n  return DEV_ERROR_INFO[code];\n}\n\n/**\n * An error originating from within a Palette subsystem.\n *\n * In the `development` environment, the error will surface with extended info\n * about the error and any details which may be relevant to help with debugging.\n *\n * In the `production` environment, a minimal error only surfacing the numeric\n * error code is thrown instead.\n *\n * Codes are categorized into groups by the 100's:\n *\n * - 0 - 99: Invariants\n * - 100 - 199: Custom Elements / Environment Errors\n * - 200 - 299: Templating Errors\n * - 300 - 399: Runtime Errors\n */\nexport class PaletteError extends Error {\n  name = \"PaletteError\";\n  code: number;\n\n  constructor(code: number, ...values: string[]) {\n    let message = `Code: ${code}`;\n    if (__DEV__) {\n      message += getDevError(code);\n\n      for (const val of values) {\n        message = message.replace(`%s`, String(val));\n      }\n    }\n\n    super(message);\n    this.code = code;\n  }\n}\n",
    "/*\n * Copyright © Rustic Arcade, LLC 2026\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n\nimport { ErrorCode, PaletteError } from \"#error\";\n\nexport type StateListener<Shape> = (state: Shape) => void;\n\nconst ArrayMutatorFunctions = new Set([\n  \"push\",\n  \"pop\",\n  \"shift\",\n  \"unshift\",\n  \"splice\",\n  \"sort\",\n  \"reverse\",\n  \"fill\",\n  \"copyWithin\",\n]);\n\nconst DataStructureMutatorFunctions = new Set([\n  \"add\",\n  \"delete\",\n  \"clear\",\n  \"set\",\n]);\n\n/**\n * Powerful and flexible state management with deep reactivity, transaction, and\n * locking support.\n *\n * The State class wraps stateful data and provides an API for mutating the data\n * while listeners subscribe to meaningful updates.\n */\nexport class State<Shape extends object> {\n  static isState<T extends object>(value: unknown): value is State<T> {\n    return (\n      value !== null && typeof value === \"object\" && value instanceof State\n    );\n  }\n\n  private _data: Shape;\n  private _listeners: Set<StateListener<Shape>> = new Set();\n  private _proxy?: Shape;\n  private _proxyCache = new WeakMap<object, any>();\n  private _reverseProxyCache = new WeakMap<object, object>();\n\n  constructor(initialData: Shape, listener?: StateListener<Shape>) {\n    this._data = initialData;\n    if (listener) {\n      this._listeners.add(listener);\n    }\n  }\n\n  /**\n   * Lazily create and cache proxies into the state for reactive updates on\n   * nested values.\n   */\n  private _createProxy<T>(target: T, path: string[] = []): T {\n    // Return primitives immediately\n    if (typeof target !== \"object\" || target === null) {\n      return target;\n    }\n\n    // Check for a cached proxy for this object\n    const cached = this._proxyCache.get(target as object);\n    if (cached) {\n      return cached;\n    }\n\n    // Otherwise create a new proxy and cache it\n    const proxy = new Proxy(target as object, {\n      get: (obj, key: string | symbol) => {\n        // Symbols -> Direct return\n        if (typeof key === \"symbol\") {\n          return (obj as any)[key];\n        }\n\n        const value = (obj as any)[key];\n\n        // For Arrays, Maps, and Sets, handle mutator functions correctly\n        if (\n          (obj instanceof Set || obj instanceof Map || Array.isArray(obj)) &&\n          typeof value === \"function\"\n        ) {\n          const mutationFns = Array.isArray(obj)\n            ? ArrayMutatorFunctions\n            : DataStructureMutatorFunctions;\n          const isMutation = mutationFns.has(key);\n\n          return (...args: any[]) => {\n            const snapshot = this.snapshot();\n\n            let current: any = snapshot;\n\n            for (const p of path) {\n              current = current[p];\n            }\n\n            const res = (current as any)[key](...args);\n\n            if (isMutation) {\n              this._processIncomingState(snapshot);\n            }\n\n            return res;\n          };\n        }\n\n        // Objects -> recursively create a proxy\n        if (typeof value === \"object\" && value !== null) {\n          return this._createProxy(value, [...path, key]);\n        }\n\n        // Primitives -> Return value\n        return value;\n      },\n\n      set: (_obj, key: string | symbol, value: any) => {\n        // Disallow setting symbol properties on target data values\n        if (typeof key === \"symbol\") {\n          return false;\n        }\n\n        // Compute and update the path with the value\n        const newPath = [...path, key];\n        this._setNested(newPath, this._unwrapProxy(value));\n\n        return true;\n      },\n\n      has: (obj, key: string | symbol) => {\n        return key in obj;\n      },\n\n      ownKeys: (obj) => {\n        return Reflect.ownKeys(obj);\n      },\n\n      getOwnPropertyDescriptor: (obj, key: string | symbol) => {\n        const desc = Object.getOwnPropertyDescriptor(obj, key);\n\n        if (desc) {\n          desc.configurable = true;\n        }\n\n        return desc;\n      },\n\n      deleteProperty: (obj, key) => {\n        if (typeof key === \"symbol\" || !(key in obj)) {\n          return false;\n        }\n\n        // Compute and update the path with the value\n        const newPath = [...path, key];\n\n        this._setNested(newPath, undefined);\n\n        return true;\n      },\n    }) as T;\n\n    this._proxyCache.set(target as object, proxy);\n    this._reverseProxyCache.set(proxy as object, target as object);\n    return proxy;\n  }\n\n  private _unwrapProxy<T>(value: T): T {\n    // Don't do anything for primitives\n    if (typeof value !== \"object\" || value === null) {\n      return value;\n    }\n\n    // Check if this is one of our proxies\n    const rawTarget = this._reverseProxyCache.get(value as object);\n    if (rawTarget) {\n      return rawTarget as T;\n    }\n\n    // Handle arrays\n    if (Array.isArray(value)) {\n      return value.map((item) => this._unwrapProxy(item)) as T;\n    }\n\n    // Handle plain objects\n    if (Object.getPrototypeOf(value) === Object.prototype) {\n      const unwrapped: any = {};\n      for (const key in value) {\n        if (Object.hasOwn(value, key)) {\n          unwrapped[key] = this._unwrapProxy((value as any)[key]);\n        }\n      }\n      return unwrapped;\n    }\n\n    // Other objects (Date, Map, Set, etc.) pass through\n    return value;\n  }\n\n  /**\n   * Handle setting nested values and emitting updated data if the value changed\n   */\n  private _setNested(path: string[], value: any): void {\n    // Nothing to do with empty paths\n    if (!path.length) {\n      return;\n    }\n\n    // Start at the root and seek to the value being set\n    let current: any = this._data;\n\n    for (let i = 0; i < path.length - 1; i++) {\n      const key = path[i] ?? \"\";\n\n      if (current === undefined) {\n        throw new PaletteError(ErrorCode.INVALID_STATE_KEY, path.join(\".\"));\n      }\n\n      current = current[key];\n    }\n\n    const finalKey = path[path.length - 1] ?? \"\";\n\n    if (current === undefined) {\n      throw new PaletteError(ErrorCode.INVALID_STATE_KEY, path.join(\".\"));\n    }\n\n    // Set and emit only if the value is different. Otherwise no-op.\n    if (current[finalKey] !== value && !Object.is(current[finalKey], value)) {\n      current[finalKey] = value;\n      this._emit(this.raw);\n    }\n  }\n\n  /**\n   * Process an incoming partial state and emit updates to listeners if there\n   * are any changes detected.\n   *\n   * @remarks\n   * Object.is() to check for differences. Does not attempt deep diffing.\n   */\n  private _processIncomingState = (\n    incomingState: Partial<Shape>,\n  ): State<Shape> => {\n    if (\n      typeof incomingState !== \"object\" ||\n      incomingState === null ||\n      Array.isArray(incomingState)\n    ) {\n      throw new PaletteError(\n        ErrorCode.INVALID_STATE_UPDATE,\n        JSON.stringify(incomingState),\n      );\n    }\n    let hasChanges = false;\n\n    // Check if any key/value pair on the incoming state differs from the\n    // existing data\n    for (const [key, newValue] of Object.entries(incomingState)) {\n      const currentValue = this._data[key as keyof Shape];\n      if (!Object.is(currentValue, newValue)) {\n        hasChanges = true;\n        (this._data as any)[key] = newValue;\n      }\n    }\n\n    if (hasChanges) {\n      this._emit(this._data);\n    }\n\n    return this;\n  };\n\n  /**\n   * Emit the current state to all listeners\n   */\n  private _emit = (data: Shape): void => {\n    for (const listener of this._listeners) {\n      listener(data);\n    }\n  };\n\n  /**\n   * The current state\n   *\n   * @remarks\n   * This is a direct reference to the internal state. It is marked as Readonly\n   * to help prevent accidental changes. Never edit this value directly.\n   */\n  get raw(): Readonly<Shape> {\n    return this._data;\n  }\n\n  /**\n   * Live reactive accessor for state data. Deeply nested changes trigger\n   * automatic updates, including array, Map, and Set mutations.\n   *\n   * @remarks\n   * For deeply nested values, the `.live` accessor may add performance overhead\n   * compared to directly accessing the value via `.current`\n   */\n  get live(): Shape {\n    if (!this._proxy) {\n      this._proxy = this._createProxy(this._data);\n    }\n    return this._proxy;\n  }\n\n  /**\n   * Add a handler function for when this state changes.\n   *\n   * Listeners are invoked in the order they are registered and are passed a\n   * reference to the internally managed state object as a readonly object.\n   *\n   * **Do not modify state values directly**. Instead, use {@link set} or\n   * {@link patch} to make immutable updates.\n   */\n  addListener = (listener: StateListener<Shape>): void => {\n    this._listeners.add(listener);\n  };\n\n  /**\n   * Remove a previously registered state handler\n   */\n  removeListener = (listener: StateListener<Shape>): void => {\n    this._listeners.delete(listener);\n  };\n\n  /**\n   * Get a single value from the state object\n   *\n   * The value is returned as Readonly to prevent accidental state mutations.\n   * To mutate stateful properties, use {@link set} or {@link patch} instead.\n   */\n  get = <K extends keyof Shape>(key: K): Readonly<Shape[K]> => {\n    return this._data[key] as Readonly<Shape[K]>;\n  };\n\n  /**\n   * Returns a deep clone of the current state data using `structuredClone()` to\n   * make the copy.\n   *\n   * The object returned from this function can be edited without modifying the\n   * actual internal state.\n   * ```\n   */\n  snapshot = (): Shape => {\n    return structuredClone(this._data);\n  };\n\n  /**\n   * Set a single stateful property while leaving other properties unchanged.\n   *\n   * Triggers an update to all listeners if the value is different from before\n   * when compared using shallow equality.\n   *\n   * @example\n   *\n   * ```typescript\n   * const state = new State({ count: 1, color: \"red\" });\n   * state.set(\"count\", 2); // State is now { count: 2, color: \"red\" }\n   * ```\n   */\n  set = <K extends keyof Shape>(key: K, value: Shape[K]): State<Shape> => {\n    const partial: Partial<Shape> = {};\n    partial[key] = value;\n    return this._processIncomingState(partial);\n  };\n\n  /**\n   * Set multiple stateful properties at once, leaving omitted properties\n   * unchanged.\n   */\n  patch = (patch: Partial<Shape>): State<Shape> => {\n    return this._processIncomingState(patch);\n  };\n\n  /**\n   * Fully replace the current state data and force an update\n   */\n  replace = (state: Shape): State<Shape> => {\n    this._data = state;\n    this._emit(this._data);\n    return this;\n  };\n\n  /**\n   * Apply complex updates to the state using a mutator function.\n   *\n   * The mutator function takes one parameter which is a structuredClone copy of\n   * the current state object. Whatever is returned by the mutator is then\n   * patched in to the state.\n   */\n  mutate = (mutator: (current: Shape) => Shape): State<Shape> => {\n    return this._processIncomingState(mutator(this.snapshot()));\n  };\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\ntype Metrics = {\n  hits: number;\n  misses: number;\n};\n\nexport type LRUCacheMetrics = {\n  lookups: number;\n  hits: number;\n  misses: number;\n  capacity: number;\n  entries: number;\n  hitRate: number;\n};\n\n/**\n * A simple in-memory LRU Cache using JavaScript maps.\n *\n * @example\n *\n * Cached network request\n *\n * ```typescript\n * // A cache of API URLs to their returned payloads\n * const cache = new LRUCache<string, APIPayload>();\n *\n * async function makeRequest(url: string) {\n *   let cached = cache.get(url);\n *   if (cached) {\n *     return cached;\n *   }\n *\n *   // ... Make the request and cache.set() the response\n * }\n * ```\n */\nexport class LRUCache<K, V> {\n  private _maxSize: number;\n  private _data: Map<K, V>;\n  private _metrics: Metrics = { hits: 0, misses: 0 };\n\n  constructor(maxSize: number = 500) {\n    if (maxSize <= 0) {\n      throw new Error(\"LRU Cache capacity must be >= 1\");\n    }\n\n    if (__DEV__) {\n      this._metrics = { hits: 0, misses: 0 };\n    }\n\n    this._maxSize = maxSize;\n    this._data = new Map<K, V>();\n  }\n\n  private _trim = () => {\n    while (this._data.size > this._maxSize) {\n      const firstKey = this._data.keys().next().value;\n      if (firstKey === undefined) {\n        throw new Error(\"Absurd\");\n      }\n      this._data.delete(firstKey);\n    }\n  };\n\n  /**\n   * Get cache performance metrics from this LRU Cache instance.\n   *\n   * In development mode, this returns insights into hits/misses of the cache,\n   * as well as the current configuration and entry count.\n   *\n   * In production mode, this returns a placeholder object, as metric collection\n   * is not active in production.\n   */\n  getMetrics(): LRUCacheMetrics | void {\n    if (__DEV__) {\n      const { hits = 0, misses = 0 } = this._metrics ?? {};\n      const lookups = hits + misses;\n      const hitRate = lookups === 0 ? 0 : hits / lookups;\n\n      return {\n        lookups,\n        hits: hits,\n        misses: misses,\n        capacity: this._maxSize,\n        entries: this._data.size,\n        hitRate,\n      };\n    }\n  }\n\n  /**\n   * Update the maximum cache size for this instance. Immediately triggers a\n   * purge of cached contents if the new capacity is less than the current\n   * number of cached entries.\n   */\n  setCapacity = (maxSize: number): void => {\n    if (maxSize <= 0 && __DEV__) {\n      console.warn(\n        \"[Palette LRU Cache] Cache size is <= 0. Cache is disabled.\",\n      );\n    }\n\n    this._maxSize = maxSize;\n    this._trim();\n  };\n\n  /**\n   * Fetch a value from the cache, returning `undefined` if no value was found\n   */\n  get(key: K): V | undefined {\n    const value = this._data.get(key);\n\n    if (value === undefined) {\n      if (__DEV__) {\n        this._metrics.misses += 1;\n      }\n      return undefined;\n    }\n\n    // Delete and re-set the value to move the key to the end of the key list\n    this._data.delete(key);\n    this._data.set(key, value);\n\n    if (__DEV__) {\n      this._metrics.hits += 1;\n    }\n\n    return value;\n  }\n\n  /**\n   * Set a value in the cache. This also moves the value to the back of the list\n   * of values to consider evicting when the cache is full.\n   */\n  set(key: K, value: V): void {\n    // Remove if exists to update position\n    if (this._data.has(key)) {\n      this._data.delete(key);\n    }\n\n    this._data.set(key, value);\n\n    if (this._data.size > this._maxSize) {\n      this._trim();\n    }\n  }\n\n  /**\n   * Clear all contents of this cache instance\n   */\n  clear(): void {\n    this._data.clear();\n  }\n\n  /**\n   * Get the number of entries in this cache instance\n   */\n  get size(): number {\n    return this._data.size;\n  }\n}\n\nexport default LRUCache;\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\nimport LRUCache from \"./lru-cache\";\n\nexport const fragmentCache = new LRUCache<string, DocumentFragment>();\n\nexport function htmlToFragment(html: string): DocumentFragment {\n  const lookup = fragmentCache.get(html);\n\n  if (lookup !== undefined) {\n    return lookup.cloneNode(true) as DocumentFragment;\n  }\n\n  const temp = document.createElement(\"template\");\n  temp.innerHTML = html;\n  fragmentCache.set(html, temp.content);\n  return temp.content.cloneNode(true) as DocumentFragment;\n}\n\nexport function saveFragment(html: string, fragment: DocumentFragment): void {\n  fragmentCache.set(html, fragment);\n}\n",
    "/*\n * Copyright © Rustic Arcade, LLC 2026\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\nexport function serializeAttribute(value: unknown): string | null {\n  if (typeof value === \"string\" || typeof value === \"number\") {\n    return `${value}`;\n  }\n\n  if (value === true) {\n    return \"\";\n  }\n\n  if (value === null || value === false || value === undefined) {\n    return null;\n  }\n\n  return value.toString();\n}\n\nexport function applyAttribute(\n  element: HTMLElement,\n  name: string,\n  value: string | null,\n): void {\n  if (value === null) {\n    element.removeAttribute(name);\n  } else {\n    element.setAttribute(name, value);\n  }\n}\n\nexport function getElementAttributes(\n  source: HTMLElement,\n): Record<string, string | null> {\n  const attrs: Record<string, string | null> = {};\n\n  for (const name of source.getAttributeNames()) {\n    attrs[name] = serializeAttribute(source.getAttribute(name));\n  }\n\n  return attrs;\n}\n\nexport function applyElementAttributes(\n  target: HTMLElement,\n  attrs: Record<string, unknown>,\n): void {\n  const currentNames = new Set(target.getAttributeNames());\n  const incomingNames = new Set(Object.keys(attrs));\n  const attributesToRemove = currentNames.difference(incomingNames);\n\n  for (const attr of attributesToRemove) {\n    target.removeAttribute(attr);\n  }\n\n  for (const [name, val] of Object.entries(attrs)) {\n    applyAttribute(target, name, serializeAttribute(val));\n  }\n}\n\nexport function formatAttributeRecord(\n  record: Record<string, unknown>,\n): Record<string, string | null> {\n  const out: Record<string, string | null> = {};\n\n  for (const [key, val] of Object.entries(record)) {\n    out[key] = serializeAttribute(val);\n  }\n\n  return out;\n}\n",
    "/*\n * Copyright © Rustic Arcade, LLC 2026\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n\n/**\n * Check if a given string is a valid html tagname, optimized for hot paths.\n *\n * @remarks\n * This function avoids using the regex engine for performance\n */\nexport function isTagName(str: string): boolean {\n  for (let i = 0; i < str.length; i++) {\n    const char = str.charAt(i);\n\n    if (\n      !(\n        char === \"-\" ||\n        (char >= \"A\" && char <= \"Z\") ||\n        (char >= \"a\" && char <= \"z\")\n      )\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * A performance optimized version of `.matches()` which includes faster\n * matching strategies for common queries.\n *\n * @remarks\n * Optimized query types:\n *\n * - Single ID selector `\"#identifier\"`\n * - Single class selector `\".classname\"`\n * - Tagname selector `\"button\"`\n * - Simple attribute selector `\"[attr='value']\"`\n *\n * All other types of queries use the base .matches() for comparison\n */\nexport function elementMatches(element: Element, query: string) {\n  // If the query is a simple ID, check it directly\n  if (\n    query[0] === \"#\" &&\n    query.indexOf(\" \") === -1 &&\n    query.indexOf(\".\") === -1 &&\n    query.indexOf(\"[\") === -1 &&\n    query.indexOf(\":\") === -1 &&\n    query.indexOf(\">\") === -1\n  ) {\n    return element.id === query.slice(1);\n  }\n\n  // If the query is a simple classname, check it directly\n  if (\n    query[0] === \".\" &&\n    query.indexOf(\" \") === -1 &&\n    query.indexOf(\"#\") === -1 &&\n    query.indexOf(\"[\") === -1 &&\n    query.indexOf(\":\") === -1 &&\n    query.indexOf(\">\") === -1\n  ) {\n    return element.classList.contains(query.slice(1));\n  }\n\n  // If the query is for just a tagname, check it directly\n  if (isTagName(query)) {\n    return element.tagName.toLowerCase() === query.toLowerCase();\n  }\n\n  // If the query is for a single selector value, check it directly\n  if (\n    query[0] === \"[\" &&\n    query[query.length - 1] === \"]\" &&\n    query.indexOf(\" \") === -1 &&\n    query.indexOf(\":\") === -1\n  ) {\n    const attr = query.slice(1, -1);\n    const eqIndex = attr.indexOf(\"=\");\n    if (eqIndex === -1) {\n      return element.hasAttribute(attr);\n    }\n    const attrName = attr.slice(0, eqIndex);\n    const attrValue = attr.slice(eqIndex + 1).replace(/^[\"']|[\"']$/g, \"\");\n    return element.getAttribute(attrName) === attrValue;\n  }\n\n  // Otherwise, use native `.matches` for complex stuff\n  return element.matches(query);\n}\n",
    "type WalkerFn = (node: Node) => boolean | void;\n\n/**\n * Walk up the parent nodes from a target child element and invoke a function\n * on each node. If the function returns `true` for a node, execution will\n * stop and this function will also return `true`. If the function does not\n * return true, it will continue walking up the parent nodes.\n */\nexport function walkParents(target: Node, fn: WalkerFn): boolean {\n  let current: Node | null = target.parentNode;\n\n  while (current !== null) {\n    const result = fn(current);\n\n    if (result) {\n      return true;\n    }\n\n    if (isShadowRoot(current)) {\n      current = current.host;\n    } else {\n      current = current.parentNode;\n    }\n  }\n\n  return false;\n}\n\nexport function isElement(value: unknown): value is Element {\n  return (\n    value !== null && typeof value === \"object\" && value instanceof Element\n  );\n}\n\nexport function isHTMLElement(value: unknown): value is HTMLElement {\n  return (\n    value !== null && typeof value === \"object\" && value instanceof HTMLElement\n  );\n}\n\nexport function isHTMLTemplateElement(\n  value: unknown,\n): value is HTMLTemplateElement {\n  return (\n    value !== null &&\n    typeof value === \"object\" &&\n    value instanceof HTMLTemplateElement\n  );\n}\nexport function isShadowRoot(value: unknown): value is ShadowRoot {\n  return (\n    value !== null && typeof value === \"object\" && value instanceof ShadowRoot\n  );\n}\n\nexport function isNode(value: unknown): value is Node {\n  return value !== null && typeof value === \"object\" && value instanceof Node;\n}\n\nexport function isComment(value: unknown): value is Comment {\n  return (\n    value !== null && typeof value === \"object\" && value instanceof Comment\n  );\n}\n",
    "export const REF_ATTR = \"data-node-ref\";\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n\nimport { ErrorCode, PaletteError } from \"#error\";\nimport { LRUCache } from \"#util\";\n\nconst enum NotationPrefix {\n  Attributes = \"@\",\n  State = \"$\",\n  Data = \"*\",\n  Item = \"#\",\n}\n\nconst PREFIX_MAPPING: Record<NotationPrefix, string> = {\n  [NotationPrefix.Attributes]: \"attr\",\n  [NotationPrefix.State]: \"state\",\n  [NotationPrefix.Data]: \"data\",\n  [NotationPrefix.Item]: \"item\",\n};\n\nconst prefixMapping = new Map(Object.entries(PREFIX_MAPPING));\n\nexport type ParsedNotation = {\n  /** The raw string representation of the parsed notation */\n  base: string;\n\n  /** An array of property names forming a path to the notation value */\n  path: string[];\n\n  modifiers?: {\n    not?: boolean;\n  };\n};\n\nexport const parsedNotationCache = new LRUCache<string, ParsedNotation>();\n\n/**\n * Parse a notation into an object with runtime information\n *\n * @remarks\n * Four notations are supported:\n *\n * - `@attrname` -> Root element attributes\n * - `$statevalue` -> Stateful content\n * - `*property.or.whatever` -> Computed data properties\n * - `#color` -> List item properties\n */\nexport function parseNotation(notation: string): ParsedNotation {\n  const cached = parsedNotationCache.get(notation);\n  if (cached) {\n    return cached;\n  }\n\n  // Check for prefix modifiers\n  let notModifier = false;\n\n  let pathPart = \"\";\n  const computedPath: string[] = [];\n\n  let isFirst = true;\n  for (const char of notation) {\n    // ! at position 0 -> Enable NOT modifier, dont count towards idx\n    if (isFirst && char === \"!\") {\n      notModifier = true;\n    }\n\n    // Otherwise, position 0 must be a prefix\n    else if (isFirst) {\n      const prefix = prefixMapping.get(char);\n\n      if (!prefix) {\n        throw new PaletteError(\n          ErrorCode.TEMPLATE_INVALID_NOTATION_SYNTAX,\n          notation,\n        );\n      }\n\n      computedPath.push(prefix);\n      isFirst = false;\n    }\n\n    // Collect characters and push when hitting a dot or end\n    else if (char === \".\") {\n      if (pathPart.length) {\n        computedPath.push(pathPart);\n        pathPart = \"\";\n      } else {\n        throw new PaletteError(\n          ErrorCode.TEMPLATE_INVALID_NOTATION_SYNTAX,\n          notation,\n        );\n      }\n    } else {\n      pathPart += char;\n    }\n  }\n\n  // Add the final part which must exist (otherwise, it ended in a dot)\n  if (!pathPart.length) {\n    throw new PaletteError(\n      ErrorCode.TEMPLATE_INVALID_NOTATION_SYNTAX,\n      notation,\n    );\n  }\n\n  computedPath.push(pathPart);\n\n  if (computedPath.length < 2) {\n    throw new PaletteError(\n      ErrorCode.TEMPLATE_INVALID_NOTATION_SYNTAX,\n      notation,\n    );\n  }\n\n  const parsedNotation: ParsedNotation = {\n    base: notation,\n    path: computedPath,\n    modifiers: notModifier ? { not: true } : undefined,\n  };\n\n  parsedNotationCache.set(notation, parsedNotation);\n\n  return parsedNotation;\n}\n\nexport type NotationAccessor = (source: unknown) => unknown;\n\nexport const valueAccessorCache = new LRUCache<string, NotationAccessor>();\n\nexport function buildValueAccessor(notation: ParsedNotation): NotationAccessor {\n  const { path, modifiers, base } = notation;\n\n  const cached = valueAccessorCache.get(base);\n  if (cached) {\n    return cached;\n  }\n\n  if (path.length < 2) {\n    // Notations must always have at least 2 parts: the namespace, and at least\n    // one property name on the namespace (example: [\"state\", \"visible\"])\n    throw new PaletteError(ErrorCode.INVARIANT);\n  }\n\n  const accessor = (source: unknown) => {\n    let current = source;\n\n    for (const part of path) {\n      if (!current || typeof current !== \"object\") {\n        return null;\n      }\n\n      current = current[part as keyof typeof current];\n    }\n\n    if (modifiers?.not) {\n      if (path[0] === \"attr\") {\n        return current !== \"\" && !current;\n      }\n      return !current;\n    }\n\n    return current;\n  };\n\n  valueAccessorCache.set(base, accessor);\n\n  return accessor;\n}\n",
    "import { htmlToFragment } from \"#util\";\nimport { isHTMLElement } from \"../util/dom\";\nimport { Directive } from \"./directive\";\nimport { Template } from \"./template\";\n\nexport function htmlStringToTemplate(html: string): Template {\n  const fragment = htmlToFragment(html);\n  const templateElement = document.createElement(\"template\");\n  templateElement.content.appendChild(fragment);\n  return new Template(templateElement);\n}\n\nexport function collectOperableNodes(\n  fragment: DocumentFragment,\n): HTMLElement[] {\n  const walker = document.createTreeWalker(fragment, NodeFilter.SHOW_ELEMENT);\n  const knownIgnores = new Set<Node>();\n  const nodes: HTMLElement[] = [];\n\n  let currentNode: Node | null = walker.nextNode();\n\n  while (currentNode) {\n    if (!isHTMLElement(currentNode)) {\n      currentNode = walker.nextNode();\n      continue;\n    }\n\n    let parent = currentNode.parentNode;\n    let isInoperable = false;\n\n    while (parent && !isInoperable) {\n      if (\n        knownIgnores.has(parent) ||\n        (isHTMLElement(parent) &&\n          (parent.hasAttribute(Directive.Each) ||\n            parent.hasAttribute(Directive.If) ||\n            parent.hasAttribute(Directive.Else) ||\n            parent.hasAttribute(Directive.ElseIf)))\n      ) {\n        isInoperable = true;\n        knownIgnores.add(currentNode);\n        break;\n      }\n\n      parent = parent.parentNode;\n    }\n\n    if (!isInoperable) {\n      nodes.push(currentNode);\n    }\n\n    currentNode = walker.nextNode();\n  }\n\n  return nodes;\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n\nimport { ErrorCode, PaletteError } from \"#error\";\nimport { LRUCache, saveFragment } from \"#util\";\nimport { isHTMLElement } from \"../util/dom\";\nimport { REF_ATTR } from \"./constant\";\nimport { Directive } from \"./directive\";\nimport { type ParsedNotation, parseNotation } from \"./syntax\";\nimport {\n  type AnyScheme,\n  type AttributeUpdateScheme,\n  type ConditionalRenderScheme,\n  type ConditionalRenderSchemeBranch,\n  type ContentSwapScheme,\n  type ListRenderScheme,\n  UpdateType,\n} from \"./types\";\nimport { collectOperableNodes } from \"./util\";\n\nconst requiresNotation = new Set<string>([\n  Directive.Each,\n  Directive.If,\n  Directive.ElseIf,\n  Directive.Key,\n  Directive.Swap,\n  Directive.Tag,\n]);\n\n/**\n * A JSON-serializable representation of a {@link Template} instance, including\n * everything needed to recreate the template.\n */\nexport interface CompiledTemplate {\n  html: string;\n  schemes: AnyScheme[];\n  notations: Record<string, ParsedNotation>;\n}\n\nexport const compiledTemplateCache = new LRUCache<\n  HTMLTemplateElement,\n  CompiledTemplate\n>();\n\n/**\n * Compile an {@link HTMLTemplateElement} into a {@link CompiledTemplate} for\n * caching, cloning, or storage.\n *\n * Compiled template objects contain a JSON-serializable data representation of\n * a template and can be prepared using {@link prepareCompiledTemplate} to\n * create new Template instances.\n *\n * @example\n *\n * ```typescript\n * const compiled = compileTemplate($templateElement);\n * const stringified = JSON.stringify(compiled); // a JSON template bundle\n * ```\n */\nexport function compileTemplate(source: HTMLTemplateElement): CompiledTemplate {\n  // Check if the template is already cached\n  const cachedTemplate = compiledTemplateCache.get(source);\n  if (cachedTemplate) {\n    return cachedTemplate;\n  }\n\n  const parsedNotations = new Map<string, ParsedNotation>();\n  const compiledSchemes: AnyScheme[] = [];\n\n  let nextNodeRef = 0;\n  const ensureNodeRef = (el: HTMLElement): string => {\n    let ref = el.getAttribute(REF_ATTR);\n    if (!ref) {\n      ref = `el-${nextNodeRef++}`;\n      el.setAttribute(REF_ATTR, ref);\n    }\n    return ref;\n  };\n\n  const clonedTemplateElement = source.content.cloneNode(\n    true,\n  ) as DocumentFragment;\n\n  const nodes: HTMLElement[] = collectOperableNodes(clonedTemplateElement);\n\n  for (const node of nodes) {\n    const allAttributesForNode = node.getAttributeNames();\n\n    for (const attributeName of allAttributesForNode) {\n      const attributeValue = node.getAttribute(attributeName);\n\n      // Bail quickly if this isn't a directive\n      if (attributeValue === null || attributeName[0] !== \":\") {\n        continue;\n      }\n\n      // Expect any ::key to have an ::each\n      if (attributeName === Directive.Key) {\n        if (!allAttributesForNode.includes(Directive.Each)) {\n          throw new PaletteError(ErrorCode.TEMPLATE_INVALID_KEY_DIRECTIVE);\n        }\n        continue;\n      }\n\n      // Ensure required notations exist\n      if (requiresNotation.has(attributeName) && attributeValue === \"\") {\n        throw new PaletteError(\n          ErrorCode.TEMPLATE_MISSING_NOTATION,\n          attributeName,\n        );\n      }\n\n      let notation = parsedNotations.get(attributeValue);\n\n      if (notation === undefined) {\n        notation = parseNotation(attributeValue);\n        parsedNotations.set(attributeValue, notation);\n      }\n\n      node.removeAttribute(attributeName);\n\n      // If the second character is not a colon, it is a binding\n      if (attributeName[1] !== \":\") {\n        const bindName = attributeName.slice(1);\n\n        const scheme: AttributeUpdateScheme = {\n          type: UpdateType.Attribute,\n          notation: parseNotation(attributeValue),\n          attribute: bindName,\n          nodeRef: ensureNodeRef(node),\n        };\n\n        compiledSchemes.push(scheme);\n      }\n\n      // TAG CHANGE SCHEMES\n      else if (attributeName === Directive.Tag) {\n        compiledSchemes.push({\n          type: UpdateType.Tag,\n          notation,\n          nodeRef: ensureNodeRef(node),\n        });\n      }\n\n      // LIST RENDER SCHEMES\n      else if (attributeName === Directive.Each) {\n        const nodeRef = ensureNodeRef(node);\n\n        // A ::key directive is required with any ::each\n        const keyNotation = node.getAttribute(Directive.Key);\n        if (keyNotation === null) {\n          throw new PaletteError(ErrorCode.TEMPLATE_MISSING_LIST_KEY);\n        }\n\n        node.removeAttribute(Directive.Key);\n\n        const listContentHtml = node.innerHTML;\n\n        while (node.firstChild) {\n          node.removeChild(node.firstChild);\n        }\n\n        const scheme: ListRenderScheme = {\n          type: UpdateType.List,\n          notation,\n          keyNotation: parseNotation(keyNotation),\n          nodeRef,\n          listContentHtml,\n        };\n\n        compiledSchemes.push(scheme);\n      }\n\n      // CONTENT SWAP SCHEMES\n      else if (attributeName === Directive.Swap) {\n        const scheme: ContentSwapScheme = {\n          type: UpdateType.Swap,\n          notation,\n          nodeRef: ensureNodeRef(node),\n        };\n\n        compiledSchemes.push(scheme);\n      }\n\n      // CONDITIONAL RENDER SCHEMES\n      else if (attributeName === Directive.If) {\n        const scheme: ConditionalRenderScheme = {\n          type: UpdateType.Conditional,\n          branches: [],\n        };\n\n        // First branch - this IF\n        node.removeAttribute(Directive.If);\n        const ifBranch: ConditionalRenderSchemeBranch = {\n          type: Directive.If,\n          notation,\n          branchRootRef: ensureNodeRef(node),\n          branchTemplateHTML: node.innerHTML,\n        };\n\n        scheme.branches.push(ifBranch);\n\n        let condNode = node.nextElementSibling;\n\n        // Check future nodes for else-if\n        while (condNode?.hasAttribute(Directive.ElseIf)) {\n          if (!isHTMLElement(condNode)) {\n            break;\n          }\n\n          const baseElseIfNotation = condNode.getAttribute(Directive.ElseIf);\n\n          if (!baseElseIfNotation) {\n            throw new PaletteError(\n              ErrorCode.TEMPLATE_MISSING_NOTATION,\n              Directive.ElseIf,\n            );\n          }\n\n          // If the notation has been parsed before, reuse that\n          let parsedElseIfNotation = parsedNotations.get(baseElseIfNotation);\n\n          if (parsedElseIfNotation === undefined) {\n            parsedElseIfNotation = parseNotation(baseElseIfNotation);\n            parsedNotations.set(baseElseIfNotation, parsedElseIfNotation);\n          }\n\n          condNode.removeAttribute(Directive.ElseIf);\n\n          const elseIfBranch: ConditionalRenderSchemeBranch = {\n            type: Directive.ElseIf,\n            notation: parsedElseIfNotation,\n            branchRootRef: ensureNodeRef(condNode),\n            branchTemplateHTML: condNode.innerHTML,\n          };\n\n          scheme.branches.push(elseIfBranch);\n          condNode = condNode.nextElementSibling;\n        }\n\n        // Else\n        if (\n          condNode &&\n          isHTMLElement(condNode) &&\n          condNode?.hasAttribute(Directive.Else)\n        ) {\n          condNode.removeAttribute(Directive.Else);\n\n          const elseBranch: ConditionalRenderSchemeBranch = {\n            type: Directive.Else,\n            branchRootRef: ensureNodeRef(condNode),\n            branchTemplateHTML: condNode.innerHTML,\n          };\n\n          scheme.branches.push(elseBranch);\n        }\n\n        compiledSchemes.push(scheme);\n      } else {\n        if (__DEV__) {\n          if (\n            attributeName === Directive.Else ||\n            attributeName === Directive.ElseIf\n          ) {\n            throw new PaletteError(ErrorCode.TEMPLATE_INVALID_CONDITIONAL);\n          }\n\n          console.warn(`Template: ${attributeName} is not a valid directive`);\n        }\n      }\n    }\n  }\n\n  const notations: Record<string, ParsedNotation> = {};\n\n  for (const [key, val] of parsedNotations) {\n    notations[key] = val;\n  }\n\n  const temp = document.createElement(\"div\");\n  temp.appendChild(clonedTemplateElement.cloneNode(true));\n  const html = temp.innerHTML;\n\n  const compiled: CompiledTemplate = {\n    html,\n    schemes: compiledSchemes,\n    notations,\n  };\n\n  // Cache the compiled template and html/fragment combo to prevent needing\n  // to re-create the fragment from HTML again when compiling at runtime\n  compiledTemplateCache.set(source, compiled);\n  saveFragment(html, clonedTemplateElement);\n\n  return compiled;\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n\nimport type { Component } from \"#component\";\nimport { ErrorCode, PaletteError } from \"#error\";\nimport { isTagName } from \"#util\";\n\nexport function parseCSSTemplateStringValue(\n  val: string | typeof Component,\n): string {\n  // Convert component refs to their tagnames\n  if (typeof val === \"function\") {\n    const tagName = val.tagName;\n    if (!isTagName(tagName)) {\n      throw new PaletteError(\n        ErrorCode.TEMPLATE_INVALID_COMPONENT,\n        val.name,\n        val.tagName,\n      );\n    }\n    return tagName;\n  }\n\n  if (typeof val === \"string\") {\n    return val;\n  }\n\n  throw new PaletteError(ErrorCode.TEMPLATE_INVALID_VALUE, String(val));\n}\n\n/**\n * @returns An array of {@link CSSStyleSheet}s containing the provided CSS\n */\nexport function css(\n  strings: TemplateStringsArray,\n  ...values: (string | typeof Component<any>)[]\n): CSSStyleSheet {\n  let result = strings[0] ?? \"\";\n\n  for (let i = 0; i < values.length; i++) {\n    const nextVal = values[i] ?? \"\";\n    const nextStr = strings[i + 1] ?? \"\";\n    result += parseCSSTemplateStringValue(nextVal);\n    result += nextStr;\n  }\n\n  const sheet = new CSSStyleSheet();\n  sheet.replaceSync(result);\n  return sheet;\n}\n\nexport type ClassifyInput =\n  | string\n  | number\n  | boolean\n  | undefined\n  | null\n  | Record<string, any>\n  | ClassifyInput[];\n\n/**\n * Given flexible input, generate a string suitable for setting as an html class\n *\n * @example\n *\n * ```typescript\n * classify(\"my-class\", \"another-class\") // \"my-class another-class\"\n * classify([\"my-class\", \"another-class\"]) // \"my-class another-class\"\n * classify({ enabled: true, disabled: false }) // \"enabled\"\n * ```\n */\nexport function classify(...args: ClassifyInput[]): string {\n  let resultString = \"\";\n\n  for (let index = 0; index < args.length; index++) {\n    const argument = args[index];\n\n    if (!argument) {\n      continue;\n    }\n\n    // Strings/nums -> Direct append\n    if (typeof argument === \"string\" || typeof argument === \"number\") {\n      if (resultString) {\n        resultString += \" \";\n      }\n      resultString += argument;\n      continue;\n    }\n\n    // Handle arrays recursively\n    if (Array.isArray(argument)) {\n      const nestedResult = classify(...argument);\n      if (nestedResult) {\n        if (resultString) {\n          resultString += \" \";\n        }\n        resultString += nestedResult;\n      }\n      continue;\n    }\n\n    // Handle objects with conditional class names\n    if (typeof argument === \"object\") {\n      for (const className in argument) {\n        // Only include class name if its value is truthy\n        if (argument[className]) {\n          if (resultString) {\n            resultString += \" \";\n          }\n          resultString += className;\n        }\n      }\n    }\n  }\n\n  return resultString;\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\nimport { Component } from \"#component\";\nimport { ErrorCode, PaletteError } from \"#error\";\nimport { isTagName } from \"#util\";\nimport { isHTMLTemplateElement } from \"../util/dom\";\n\nexport function parseTemplateStringValue(\n  val: string | typeof Component | HTMLTemplateElement,\n): string {\n  if (isHTMLTemplateElement(val)) {\n    return val.innerHTML;\n  }\n\n  if (Component.isComponentClass(val)) {\n    const tagName = val.tagName;\n    if (!isTagName(tagName)) {\n      throw new PaletteError(\n        ErrorCode.TEMPLATE_INVALID_COMPONENT,\n        val.name,\n        val.tagName,\n      );\n    }\n    return tagName;\n  }\n\n  if (typeof val === \"string\") {\n    return `<span ::swap=\"${val}\"></span>`;\n  }\n\n  throw new PaletteError(ErrorCode.TEMPLATE_INVALID_VALUE, String(val));\n}\n\n/**\n * Create an {@link HTMLTemplateElement} from the provided HTML string.\n *\n * These HTML Templates can be used as standard HTML Templates, or as the\n * foundation for a {@link Component} or standalone {@link Template}\n *\n * Interpolates values in the template string to provide helpers for composing\n * templates:\n *\n * - HTMLTemplateElement references are serialized to HTML and inlined\n * - Strings are modified to become <span> tags with the ::swap directive set\n *   to the string value. This is helpful shorthand for content placeholders.\n *\n * @example\n *\n * This template string\n *\n * ```typescript\n * const $template = html`\n * <div :class=\"*classnames\">\n *   ${\"@content\"}\n * </div>\n * `\n * ```\n *\n * Produces this template element (portrayed as HTML)\n *\n * ```html\n * <template>\n *   <div :class=\"*classnames\">\n *     <span ::swap=\"@content\"></span>\n *   </div>\n * </template>\n * ```\n */\nexport function html(\n  strings: TemplateStringsArray,\n  ...values: (\n    | `@${string}`\n    | `$${string}`\n    | `#${string}`\n    | `*${string}`\n    | HTMLTemplateElement\n    | typeof Component<any>\n  )[]\n): HTMLTemplateElement {\n  const fullString = strings.reduce((acc, str, i) => {\n    const parsedValue = values[i]\n      ? `${parseTemplateStringValue(values[i])}`\n      : \"\";\n    return acc + str + parsedValue;\n  }, \"\");\n\n  const templateElement = document.createElement(\"template\");\n  templateElement.innerHTML = fullString;\n  return templateElement;\n}\n",
    "export const SKIPPED_JOB = Symbol(\"noop\");\nexport type SkippedJob = typeof SKIPPED_JOB;\n",
    "import { classify } from \"#helper\";\nimport { applyAttribute, serializeAttribute } from \"#util\";\nimport type { AttributeUpdatePlan } from \"../types\";\nimport { SKIPPED_JOB, type SkippedJob } from \"./common\";\n\nexport type AttributeUpdateJob = [\n  node: HTMLElement,\n  name: string,\n  value: string | null,\n];\n\nexport function prepareAttributeJob(\n  plan: AttributeUpdatePlan,\n  values: Map<string, unknown>,\n): AttributeUpdateJob | SkippedJob {\n  const rawValue = values.get(plan.notation.base);\n  let value = typeof rawValue === \"function\" ? rawValue(plan.node) : rawValue;\n\n  // Parse the value with `classify` if setting the class attribute\n  if (plan.attribute === \"class\" && typeof value !== \"string\") {\n    value = classify(value);\n  }\n\n  const serializedValue = serializeAttribute(value);\n  const current = plan.node.getAttribute(plan.attribute);\n\n  if (serializedValue !== current) {\n    return [plan.node, plan.attribute, serializedValue];\n  }\n\n  return SKIPPED_JOB;\n}\n\nexport function runAttributeJobs(jobs: AttributeUpdateJob[]): void {\n  for (const [node, name, value] of jobs) {\n    applyAttribute(node, name, value);\n  }\n}\n",
    "import { ErrorCode, PaletteError } from \"#error\";\nimport { isHTMLElement } from \"../../util/dom\";\nimport { Directive } from \"../directive\";\nimport type {\n  ConditionalRenderPlan,\n  ConditionalRenderPlanBranch,\n} from \"../types\";\nimport type { SkippedJob } from \"./common\";\n\nexport type ConditionalRenderJob = [\n  plan: ConditionalRenderPlan,\n  branch: ConditionalRenderPlanBranch | null,\n  values: Map<string, unknown>,\n];\n\nexport function prepareConditionalRenderJob(\n  plan: ConditionalRenderPlan,\n  values: Map<string, unknown>,\n): ConditionalRenderJob | SkippedJob {\n  // Determine which branch to dipslay\n  let displayedBranch: ConditionalRenderPlanBranch | null = null;\n\n  for (const branch of plan.branches) {\n    if (branch.type === Directive.Else) {\n      displayedBranch = branch;\n      break;\n    } else {\n      const rawValue = values.get(branch.notation.base);\n      const value =\n        typeof rawValue === \"function\" ? rawValue(plan.start) : rawValue;\n\n      if (value) {\n        displayedBranch = branch;\n        break;\n      }\n    }\n  }\n\n  return [plan, displayedBranch, values];\n}\n\nexport function runConditionalRenderJobs(jobs: ConditionalRenderJob[]): void {\n  for (const [plan, branch, values] of jobs) {\n    const parent = plan.start.parentNode;\n\n    if (!parent) {\n      throw new PaletteError(ErrorCode.TEMPLATE_PARENT_REQUIRED);\n    }\n\n    // If the current root and branch root differ, remove content\n    if (branch === null || !Object.is(plan.currentRoot, branch.branchRoot)) {\n      // Remove existing content if the branch has changed\n      const nodesToRemove = new Set<Node>();\n\n      let node: Node | null = plan.start;\n      while (node && node !== plan.end) {\n        if (isHTMLElement(node)) {\n          nodesToRemove.add(node);\n        }\n        node = node.nextSibling;\n      }\n\n      for (const toRemove of nodesToRemove) {\n        parent.removeChild(toRemove);\n      }\n\n      // Then add the branch root if need be\n      if (branch) {\n        parent.insertBefore(branch.branchRoot, plan.end);\n      }\n    }\n\n    // Null branch -> Render nothing\n    if (branch === null) {\n      continue;\n    }\n\n    // Otherwise render branch template\n    branch.branchTemplate.renderWithValues(branch.branchRoot, values);\n  }\n}\n",
    "import { ErrorCode, PaletteError } from \"#error\";\nimport { applyElementAttributes, formatAttributeRecord } from \"#util\";\nimport { isHTMLElement } from \"../../util/dom\";\nimport { buildValueAccessor } from \"../syntax\";\nimport { Template, type TemplateContext } from \"../template\";\nimport type { ListRenderPlan } from \"../types\";\nimport type { SkippedJob } from \"./common\";\n\nexport type ListRenderJobItem = {\n  context: TemplateContext;\n  attrs: Record<string, string | null>;\n  root: HTMLElement;\n  template: Template;\n};\n\nexport type ListRenderJob = [plan: ListRenderPlan, list: ListRenderJobItem[]];\n\nfunction fetchListData(\n  plan: ListRenderPlan,\n  values: Map<string, unknown>,\n): Record<string, unknown>[] {\n  const notationValue = values.get(plan.notation.base);\n  const evaluatedValue =\n    typeof notationValue === \"function\"\n      ? notationValue(plan.startMarker.parentNode)\n      : notationValue;\n\n  if (evaluatedValue === null || evaluatedValue === undefined) {\n    return [];\n  }\n\n  if (Array.isArray(evaluatedValue)) {\n    return evaluatedValue;\n  }\n\n  throw new PaletteError(ErrorCode.TEMPLATE_INVALID_LIST_DATA);\n}\n\nfunction collectHTMLElements(start: Node, end: Node): Set<HTMLElement> {\n  let node: Node | null = start;\n  const nodeSet = new Set<HTMLElement>();\n\n  while (node && node !== end) {\n    if (isHTMLElement(node)) {\n      nodeSet.add(node);\n    }\n\n    node = node.nextSibling;\n  }\n\n  return nodeSet;\n}\n\nexport function prepareListRenderJob(\n  plan: ListRenderPlan,\n  values: Map<string, unknown>,\n): ListRenderJob | SkippedJob {\n  // Fetch the data for rendering the updated list items\n  const listData = fetchListData(plan, values);\n\n  // Empty -> Remove the list contents entirely and exit\n  if (listData.length === 0) {\n    return [plan, []];\n  }\n\n  // Collect existing elements from the DOM for assessment\n  const {\n    rowTemplatesByRoot,\n    rowTemplateElement,\n    rowRootPrototype: rowRootElement,\n  } = plan;\n  const keyAccessor = buildValueAccessor(plan.keyNotation);\n  const listRenderContexts: Map<unknown, ListRenderJobItem> = new Map();\n\n  for (const item of listData) {\n    const context: TemplateContext = {\n      item,\n    };\n\n    const key = keyAccessor(context);\n\n    if (listRenderContexts.has(key)) {\n      throw new PaletteError(\n        ErrorCode.TEMPLATE_DUPLICATE_LIST_KEY,\n        String(key),\n      );\n    }\n\n    // Get or create the HTML Element we expect to see here\n    let rowRoot = plan.rowRootsByKey.get(key);\n\n    if (rowRoot === undefined) {\n      rowRoot = rowRootElement.cloneNode(false) as HTMLElement;\n      plan.rowRootsByKey.set(key, rowRoot);\n    }\n\n    // Get or create the template associated with the row root\n    let rowTemplate = rowTemplatesByRoot.get(rowRoot);\n\n    if (rowTemplate === undefined) {\n      rowTemplate = new Template(rowTemplateElement);\n      rowTemplatesByRoot.set(rowRoot, rowTemplate);\n    }\n\n    const jobItem: ListRenderJobItem = {\n      context,\n      root: rowRoot,\n      template: rowTemplate,\n      attrs: formatAttributeRecord(item),\n    };\n\n    listRenderContexts.set(key, jobItem);\n  }\n\n  // Clean up cached data\n  for (const [key, root] of plan.rowRootsByKey) {\n    if (!listRenderContexts.has(key)) {\n      plan.rowRootsByKey.delete(key);\n      plan.rowTemplatesByRoot.delete(root);\n    }\n  }\n\n  return [plan, Array.from(listRenderContexts.values())];\n}\n\nexport function runListRenderJobs(jobs: ListRenderJob[]): void {\n  for (const [plan, renderItems] of jobs) {\n    const { endMarker, listContainer: listContainerElement } = plan;\n\n    // Fast path for empty lists -> Remove everything and continue\n    if (renderItems.length === 0) {\n      for (const root of plan.rowRootsByKey.values()) {\n        root.remove();\n      }\n      plan.rowRootsByKey.clear();\n      continue;\n    }\n\n    // Otherwise, scan the current nodes and modify as needed\n    const existingDOMNodes = Array.from(\n      collectHTMLElements(plan.startMarker, plan.endMarker),\n    );\n\n    const rootsToKeep = new Set<HTMLElement>();\n\n    let existingDOMNodeIdx = 0;\n\n    for (const renderItem of renderItems) {\n      const { root, attrs: attrMap, context, template } = renderItem;\n      const existingDOMNode = existingDOMNodes[existingDOMNodeIdx];\n\n      // Spread item as attributes on the root and update the template\n      applyElementAttributes(root, attrMap);\n      template.render(root, context);\n\n      rootsToKeep.add(root);\n\n      // Node is the existing DOM Node, continue\n      if (Object.is(existingDOMNode, root)) {\n        existingDOMNodeIdx += 1;\n        continue;\n      }\n\n      // No existing node -> append item\n      if (!existingDOMNode) {\n        listContainerElement.insertBefore(root, endMarker);\n        continue;\n      }\n\n      // DOM node exists but isn't the one we're looking for. Insert before.\n      listContainerElement.insertBefore(root, existingDOMNode);\n    }\n\n    // Remove any remaining old elements\n    for (const root of existingDOMNodes) {\n      if (!rootsToKeep.has(root)) {\n        root.remove();\n        plan.rowTemplatesByRoot.delete(root);\n      }\n    }\n  }\n}\n",
    "import { ErrorCode, PaletteError } from \"#error\";\nimport { isComment, isHTMLElement } from \"../../util/dom\";\nimport type { ContentSwapPlan } from \"../types\";\nimport { SKIPPED_JOB, type SkippedJob } from \"./common\";\n\nexport type ContentSwapJob = [plan: ContentSwapPlan, swap: Node];\n\nexport function prepareContentSwapJob(\n  plan: ContentSwapPlan,\n  values: Map<string, unknown>,\n): ContentSwapJob | SkippedJob {\n  const rawValue = values.get(plan.notation.base);\n  const value = typeof rawValue === \"function\" ? rawValue(plan.node) : rawValue;\n\n  // String, Number, Boolean -> Text Node\n  if (\n    typeof value === \"string\" ||\n    typeof value === \"number\" ||\n    typeof value === \"boolean\"\n  ) {\n    const asStr = `${value}`;\n    if (plan.node.textContent === asStr) {\n      return SKIPPED_JOB;\n    }\n\n    return [plan, document.createTextNode(asStr)];\n  }\n\n  // Nullish values -> Comment\n  else if (value === null || value === undefined) {\n    if (isComment(plan.node)) {\n      return SKIPPED_JOB;\n    }\n\n    return [plan, document.createComment(\"empty\")];\n  }\n\n  // HTMLElement -> Swap nodes\n  else if (isHTMLElement(value)) {\n    if (Object.is(plan.node, value)) {\n      return SKIPPED_JOB;\n    }\n\n    return [plan, value.cloneNode(true)];\n  }\n\n  // Anything else -> Unsupported\n  else {\n    throw new PaletteError(\n      ErrorCode.INVALID_CONTENT,\n      typeof value,\n      JSON.stringify(value),\n    );\n  }\n}\n\nexport function runContentSwapJobs(jobs: ContentSwapJob[]): void {\n  for (const [plan, replace] of jobs) {\n    const parent = plan.node.parentNode;\n\n    if (!parent) {\n      // Should never happen in practice\n      throw new PaletteError(ErrorCode.INVARIANT);\n    }\n\n    parent.replaceChild(replace, plan.node);\n    plan.node = replace;\n  }\n}\n",
    "import type { TagChangePlan } from \"../types\";\nimport { SKIPPED_JOB, type SkippedJob } from \"./common\";\n\nexport type TagChangeJob = [plan: TagChangePlan, newTag: string];\n\n/**\n * Given an element, replace it with a different tag, adopting all attributes\n * and child elements.\n * @param $target The element to swap out\n * @param newTag The new HTML tagName to use\n * @returns The newly swapped-in element\n */\nexport function changeTag($target: HTMLElement, newTag: string): HTMLElement {\n  const $newEl = document.createElement(newTag);\n\n  while ($target.firstChild !== null) {\n    $newEl.appendChild($target.firstChild);\n  }\n\n  for (const attrName of $target.getAttributeNames()) {\n    const val = $target.getAttribute(attrName);\n\n    if (val !== null) {\n      $newEl.setAttribute(attrName, val);\n    }\n  }\n\n  $target.replaceWith($newEl);\n  return $newEl;\n}\n\nexport function prepareTagChangeJob(\n  plan: TagChangePlan,\n  values: Map<string, unknown>,\n): TagChangeJob | SkippedJob {\n  const rawValue = values.get(plan.notation.base) ?? \"\";\n  const value = typeof rawValue === \"function\" ? rawValue(plan.node) : rawValue;\n  const nextTag = `${value}`.toLowerCase();\n  const currentTag = plan.node.tagName.toLowerCase();\n\n  if (!nextTag || nextTag === currentTag) {\n    return SKIPPED_JOB;\n  }\n\n  return [plan, nextTag];\n}\n\nexport function runTagChangeJobs(jobs: TagChangeJob[]): void {\n  for (const [plan, nextTag] of jobs) {\n    plan.node = changeTag(plan.node, nextTag);\n  }\n}\n",
    "import { ErrorCode, PaletteError } from \"#error\";\nimport { type AnyRenderPlan, UpdateType } from \"../types\";\nimport {\n  type AttributeUpdateJob,\n  prepareAttributeJob,\n  runAttributeJobs,\n} from \"./attribute\";\nimport { SKIPPED_JOB } from \"./common\";\nimport {\n  type ConditionalRenderJob,\n  prepareConditionalRenderJob,\n  runConditionalRenderJobs,\n} from \"./conditional\";\nimport {\n  type ListRenderJob,\n  prepareListRenderJob,\n  runListRenderJobs,\n} from \"./list\";\nimport {\n  type ContentSwapJob,\n  prepareContentSwapJob,\n  runContentSwapJobs,\n} from \"./swap\";\nimport {\n  prepareTagChangeJob,\n  runTagChangeJobs,\n  type TagChangeJob,\n} from \"./tag\";\n\nexport * from \"./attribute\";\nexport * from \"./common\";\nexport * from \"./conditional\";\nexport * from \"./list\";\nexport * from \"./swap\";\nexport * from \"./tag\";\n\ninterface RenderJobs {\n  conditionals: ConditionalRenderJob[];\n  attributes: AttributeUpdateJob[];\n  swaps: ContentSwapJob[];\n  tags: TagChangeJob[];\n  lists: ListRenderJob[];\n}\n\nexport function createJobsFromPlans(\n  plans: Set<AnyRenderPlan>,\n  newValues: Map<string, unknown>,\n): RenderJobs {\n  const jobs: RenderJobs = {\n    conditionals: [],\n    attributes: [],\n    swaps: [],\n    tags: [],\n    lists: [],\n  };\n\n  for (const plan of plans) {\n    switch (plan.type) {\n      case UpdateType.Conditional: {\n        const job = prepareConditionalRenderJob(plan, newValues);\n        if (job !== SKIPPED_JOB) {\n          jobs.conditionals.push(job);\n        }\n        break;\n      }\n      case UpdateType.Attribute: {\n        const job = prepareAttributeJob(plan, newValues);\n        if (job !== SKIPPED_JOB) {\n          jobs.attributes.push(job);\n        }\n        break;\n      }\n      case UpdateType.List: {\n        const job = prepareListRenderJob(plan, newValues);\n        if (job !== SKIPPED_JOB) {\n          jobs.lists.push(job);\n        }\n        break;\n      }\n      case UpdateType.Swap: {\n        const job = prepareContentSwapJob(plan, newValues);\n        if (job !== SKIPPED_JOB) {\n          jobs.swaps.push(job);\n        }\n        break;\n      }\n      case UpdateType.Tag: {\n        const job = prepareTagChangeJob(plan, newValues);\n        if (job !== SKIPPED_JOB) {\n          jobs.tags.push(job);\n        }\n        break;\n      }\n      default:\n        // Should be impossible given an exhaustive switch case\n        throw new PaletteError(ErrorCode.INVARIANT);\n    }\n  }\n\n  return jobs;\n}\n\nexport function executeRenderJobs(jobs: RenderJobs): void {\n  runConditionalRenderJobs(jobs.conditionals);\n  runAttributeJobs(jobs.attributes);\n  runListRenderJobs(jobs.lists);\n  runContentSwapJobs(jobs.swaps);\n  runTagChangeJobs(jobs.tags);\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\nimport { ErrorCode, PaletteError } from \"#error\";\nimport { htmlToFragment } from \"#util\";\nimport { isHTMLElement } from \"../util/dom\";\nimport type { CompiledTemplate } from \"./compile\";\nimport { REF_ATTR } from \"./constant\";\nimport { Directive } from \"./directive\";\nimport { buildValueAccessor, type NotationAccessor } from \"./syntax\";\nimport type { Template } from \"./template\";\nimport {\n  type AnyRenderPlan,\n  type AttributeUpdatePlan,\n  type ConditionalRenderPlan,\n  type ContentSwapPlan,\n  type ListRenderPlan,\n  type TagChangePlan,\n  UpdateType,\n} from \"./types\";\nimport { htmlStringToTemplate } from \"./util\";\n\n/**\n * A pre-processed {@link CompiledTemplate} result containing the bulk of the\n * data necessary to create a template instance.\n */\nexport interface PreparedTemplate {\n  fragment: DocumentFragment;\n  plansByNotation: Map<string, Set<AnyRenderPlan>>;\n  notationAccessors: Map<string, NotationAccessor>;\n  subtemplates: Set<Template>;\n}\n\nconst requireParentNode = (node: Node): Node => {\n  if (!node.parentNode) {\n    throw new PaletteError(ErrorCode.TEMPLATE_PARENT_REQUIRED);\n  }\n\n  return node.parentNode;\n};\n\nconst createCommentBefore = (node: Node, text = \"\"): Comment => {\n  const parent = requireParentNode(node);\n  const comment = document.createComment(text);\n  parent.insertBefore(comment, node);\n  return comment;\n};\n\nconst createCommentAfter = (node: Node, text = \"\"): Comment => {\n  const parent = requireParentNode(node);\n  const comment = document.createComment(text);\n  parent.insertBefore(comment, node.nextSibling);\n  return comment;\n};\n\n/**\n * Given a {@link CompiledTemplate} structure, return an object containing the\n * data needed to create new Template instances.\n *\n * @example\n *\n * ```typescript\n * const compiledTemplate = getCompiledTemplateJSON();\n * const parsed = JSON.parse(compiledTemplate);\n * const prepared = prepareCompiledTemplate(parsed);\n *\n * // Elsewhere...\n *\n * const template = new Template(prepared);\n * ```\n */\nexport function prepareCompiledTemplate(\n  compiled: CompiledTemplate,\n  prototypeFragment?: DocumentFragment,\n): PreparedTemplate {\n  const plansByNotation: Map<string, Set<AnyRenderPlan>> = new Map();\n  const notationAccessors: Map<string, NotationAccessor> = new Map();\n  const subtemplates: Set<Template> = new Set();\n  const nodeRefs: Map<string, HTMLElement> = new Map();\n\n  for (const [notation, parsed] of Object.entries(compiled.notations)) {\n    notationAccessors.set(notation, buildValueAccessor(parsed));\n  }\n\n  const fragment = prototypeFragment ?? htmlToFragment(compiled.html);\n\n  const walker = document.createTreeWalker(fragment, NodeFilter.SHOW_ELEMENT, {\n    acceptNode(node: HTMLElement) {\n      return node.hasAttribute(REF_ATTR)\n        ? NodeFilter.FILTER_ACCEPT\n        : NodeFilter.FILTER_SKIP;\n    },\n  });\n\n  let markNode: Node | null = walker.nextNode();\n\n  while (markNode) {\n    if (!isHTMLElement(markNode)) {\n      continue;\n    }\n\n    const ref = markNode.getAttribute(REF_ATTR);\n\n    if (ref === null) {\n      // Should never happen in practice, as the tree walker only surfaces\n      // elements with an extant node ref attribute\n      throw new PaletteError(ErrorCode.INVARIANT);\n    }\n\n    nodeRefs.set(ref, markNode);\n    markNode.removeAttribute(REF_ATTR);\n    markNode = walker.nextNode();\n  }\n\n  const associatePlan = (plan: AnyRenderPlan, notation: string) => {\n    let notationPlans = plansByNotation.get(notation);\n    if (!notationPlans) {\n      notationPlans = new Set();\n      plansByNotation.set(notation, notationPlans);\n    }\n    notationPlans.add(plan);\n  };\n\n  const getByNodeRef = (nodeRef: string): HTMLElement => {\n    const cached = nodeRefs.get(nodeRef);\n\n    if (cached) {\n      return cached;\n    }\n\n    throw new PaletteError(ErrorCode.MISSING_NODE_REF);\n  };\n\n  for (const scheme of compiled.schemes) {\n    // Hydrate List schemes into List plans\n    if (scheme.type === UpdateType.List) {\n      // Use the prototype row root to create the plan\n      const itemPrototype = getByNodeRef(scheme.nodeRef);\n      const listParentNode = requireParentNode(itemPrototype);\n      const rowRootPrototype = itemPrototype.cloneNode(false) as HTMLElement;\n      const startMarker = createCommentBefore(itemPrototype);\n      const endMarker = createCommentAfter(itemPrototype);\n\n      // Remove the original root prototype since we will be rendering new items\n      itemPrototype.remove();\n\n      // Copy the contents of the row into a template\n      const templateContentFragment = htmlToFragment(scheme.listContentHtml);\n      const rowTemplateElement = document.createElement(\"template\");\n      rowTemplateElement.content.appendChild(templateContentFragment);\n\n      const plan: ListRenderPlan = {\n        type: UpdateType.List,\n        notation: scheme.notation,\n        keyNotation: scheme.keyNotation,\n        listContainer: listParentNode,\n        rowTemplateElement,\n        rowRootPrototype,\n        startMarker,\n        endMarker,\n        rowTemplatesByRoot: new WeakMap(),\n        rowRootsByKey: new Map(),\n      };\n\n      associatePlan(plan, scheme.notation.base);\n    }\n\n    // Hydrate conditional render schemes into plans\n    else if (scheme.type === UpdateType.Conditional) {\n      // Grab the first branch and insert the start comment before it\n      const firstBranch = scheme.branches[0];\n      if (!firstBranch) {\n        throw new PaletteError(ErrorCode.INVARIANT);\n      }\n\n      const firstBranchRoot = getByNodeRef(firstBranch.branchRootRef);\n      const startComment = createCommentBefore(firstBranchRoot);\n\n      // Grab the last branch and insert the end comment after it\n      // biome-ignore lint/style/noNonNullAssertion: Logically guaranteed\n      const lastBranch = scheme.branches[scheme.branches.length - 1]!;\n      const lastBranchRoot = getByNodeRef(lastBranch.branchRootRef);\n      const endComment = createCommentAfter(lastBranchRoot);\n\n      const plan: ConditionalRenderPlan = {\n        type: UpdateType.Conditional,\n        start: startComment,\n        end: endComment,\n        branches: [],\n      };\n\n      // Hydrate the branches\n      for (const branch of scheme.branches) {\n        // If and Else-If have notations\n        if (branch.type === Directive.If || branch.type === Directive.ElseIf) {\n          const branchRoot = getByNodeRef(branch.branchRootRef);\n          const branchTemplate = htmlStringToTemplate(\n            branch.branchTemplateHTML,\n          );\n\n          // Add the child template\n          subtemplates.add(branchTemplate);\n\n          plan.branches.push({\n            type: branch.type,\n            notation: branch.notation,\n            branchRoot: getByNodeRef(branch.branchRootRef),\n            branchTemplate: htmlStringToTemplate(branch.branchTemplateHTML),\n          });\n          associatePlan(plan, branch.notation.base);\n          branchRoot.remove();\n        }\n\n        // Else is binary, no notation associated\n        else {\n          plan.branches.push({\n            type: branch.type,\n            branchRoot: getByNodeRef(branch.branchRootRef),\n            branchTemplate: htmlStringToTemplate(branch.branchTemplateHTML),\n          });\n        }\n      }\n    }\n\n    // Swap/Tag are the same signature\n    else if (\n      scheme.type === UpdateType.Swap ||\n      scheme.type === UpdateType.Tag\n    ) {\n      const plan: ContentSwapPlan | TagChangePlan = {\n        type: scheme.type,\n        notation: scheme.notation,\n        node: getByNodeRef(scheme.nodeRef),\n      };\n\n      associatePlan(plan, scheme.notation.base);\n    }\n\n    // Hydrate Attribute update plans\n    else if (scheme.type === UpdateType.Attribute) {\n      const plan: AttributeUpdatePlan = {\n        type: UpdateType.Attribute,\n        attribute: scheme.attribute,\n        notation: scheme.notation,\n        node: getByNodeRef(scheme.nodeRef),\n      };\n\n      associatePlan(plan, plan.notation.base);\n    }\n  }\n\n  return {\n    plansByNotation,\n    notationAccessors,\n    fragment,\n    subtemplates,\n  };\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\nimport { fragmentCache, htmlToFragment } from \"../util/fragments\";\nimport {\n  type CompiledTemplate,\n  compiledTemplateCache,\n  compileTemplate,\n} from \"./compile\";\nimport { createJobsFromPlans, executeRenderJobs } from \"./jobs\";\nimport { prepareCompiledTemplate } from \"./prepare\";\nimport {\n  type NotationAccessor,\n  parsedNotationCache,\n  valueAccessorCache,\n} from \"./syntax\";\nimport type { AnyRenderPlan } from \"./types\";\n\nexport type TemplateRoot = HTMLElement | ShadowRoot;\nexport type TemplateContext = {\n  attr?: Record<string, string | null>;\n  state?: Record<string, unknown>;\n  data?: Record<string, unknown>;\n  item?: Record<string, unknown>;\n  index?: number;\n};\n\n/**\n * A renderable template from an HTMLTemplateElement\n *\n * Leverages a simple syntax to provide accessors to template data from one of\n * four categories, based on use case:\n *\n * | Prefix | Namespace                                        |\n * | ------ | ------------------------------------------------ |\n * | `@`    | The `attr` namespace (host element attributes)   |\n * | `$`    | The `state` namespace (component reactive state) |\n * | `*`    | The `data` namespace (component computed props)  |\n * | `#`    | The `item` namespace (list item context)         |\n *\n * Bind attributes to a value using the `:attribute` syntax:\n *\n * ```html\n * <div :id=\"$id\" :class=\"@classname\"></div>\n * ```\n *\n * Or use directives with notations for advanced templating:\n *\n * ```html\n * <div ::if=\"*showList\">\n *   <ul>\n *     <li ::each=\"$items\" ::key=\"#id\">\n *       <span ::swap=\"#content\"></span>\n *     </li>\n *   </ul>\n * </div>\n * ```\n */\nexport class Template {\n  static isTemplate(value: unknown): value is Template {\n    return (\n      value !== null && typeof value === \"object\" && value instanceof Template\n    );\n  }\n\n  /**\n   * Properties related to the global Template build cache.\n   *\n   * This is not something typically needed for general app development, but\n   * allows for advanced configuration to tune the caching system if need be.\n   *\n   * Cache sizes default to 500 HTML Template Fragments and compiled Palette\n   * templates (includes nested templates like lists) to cover most application\n   * needs without using much memory.\n   */\n  static cache = {\n    /**\n     * Wipe all cached templates and HTML fragments\n     */\n    clear: (): void => {\n      fragmentCache.clear();\n      compiledTemplateCache.clear();\n      valueAccessorCache.clear();\n      parsedNotationCache.clear();\n    },\n\n    /**\n     * the default cache capacity of 500 items per cache\n     *\n     * General caching guidance:\n     * - 95% of the time, 500 works fine\n     * - For very large applications, up to 1000 is reasonable\n     * - For smaller apps, dropping down to 100 - 250 may save memory\n     *\n     * Ultimately the impact will be minimal unless your app has very specific\n     * rendering needs.\n     */\n    setCapacity: (maxSize: number): void => {\n      fragmentCache.setCapacity(maxSize);\n      compiledTemplateCache.setCapacity(maxSize);\n      valueAccessorCache.setCapacity(maxSize);\n      parsedNotationCache.setCapacity(maxSize);\n    },\n  };\n\n  private _compiled: CompiledTemplate;\n\n  /**\n   * The original {@link HTMLTemplateElement} used to create this Template.\n   *\n   * @remarks\n   * Make sure to never operate directly on this element. Always clone.\n   */\n  private _templateElement?: HTMLTemplateElement;\n\n  /** The current known root element that this Template is rendered into */\n  private _mountedRoot?: TemplateRoot;\n\n  /** The most recent set value for each notation that has rendered */\n  private _latestRenderedValues: Map<string, unknown> = new Map();\n\n  /** The active HTMLElement which the template is updating on renders */\n  private _fragment: DocumentFragment;\n\n  /** Value Notations -> Set<Render Plans> */\n  private _plansByNotation: Map<string, Set<AnyRenderPlan>> = new Map();\n\n  /** Value Notations -> Accessor functions */\n  private _notationAccessors: Map<string, NotationAccessor> = new Map();\n\n  private _subtemplates: Set<Template> = new Set();\n\n  constructor(template: HTMLTemplateElement) {\n    this._templateElement = template;\n    this._compiled = compileTemplate(template);\n\n    // Prepare a fragment from the compiled HTML (cached)\n    const fragment = htmlToFragment(this._compiled.html);\n    const hydrated = prepareCompiledTemplate(this._compiled, fragment);\n\n    this._plansByNotation = hydrated.plansByNotation;\n    this._notationAccessors = hydrated.notationAccessors;\n    this._fragment = hydrated.fragment;\n    this._subtemplates = hydrated.subtemplates;\n\n    const allRelevantAccessors = new Map<string, NotationAccessor>(\n      this._notationAccessors,\n    );\n\n    for (const child of this._subtemplates) {\n      for (const [key, val] of child.notationMap) {\n        allRelevantAccessors.set(key, val);\n      }\n    }\n\n    this._notationAccessors = allRelevantAccessors;\n  }\n\n  get compiled(): CompiledTemplate {\n    return this._compiled;\n  }\n\n  get notationMap(): Map<string, NotationAccessor> {\n    return this._notationAccessors;\n  }\n\n  /**\n   * Create a full copy of this template for use in rendering to another root\n   */\n  clone = (): Template => {\n    return new Template(this.element());\n  };\n\n  /**\n   * @returns An {@link HTMLTemplateElement} representing this template\n   */\n  element = (): HTMLTemplateElement => {\n    if (this._templateElement) {\n      return this._templateElement;\n    }\n\n    const template = document.createElement(\"template\");\n    template.innerHTML = this._compiled.html;\n    return template;\n  };\n\n  private _collectUpdatedValues = (\n    context: TemplateContext,\n  ): [hasChanges: boolean, values: Map<string, unknown>] => {\n    const updatedValues = new Map<string, unknown>();\n    let hasChanges = false;\n\n    for (const [rawNotation, accessor] of this._notationAccessors) {\n      const previousValue = this._latestRenderedValues.get(rawNotation);\n      const newValue = accessor(context);\n      updatedValues.set(rawNotation, newValue);\n\n      if (previousValue !== newValue && !Object.is(previousValue, newValue)) {\n        hasChanges = true;\n      }\n    }\n\n    return [hasChanges, updatedValues];\n  };\n\n  private _update(newValues: Map<string, unknown>) {\n    // Collect affected plans\n    const allAffectedPlans: Set<AnyRenderPlan> = new Set();\n\n    for (const [notation] of newValues) {\n      const affectedPlans = this._plansByNotation.get(notation);\n\n      if (!affectedPlans) {\n        continue;\n      }\n\n      for (const plan of affectedPlans) {\n        allAffectedPlans.add(plan);\n      }\n    }\n\n    const jobs = createJobsFromPlans(allAffectedPlans, newValues);\n    executeRenderJobs(jobs);\n  }\n\n  renderWithValues = (\n    root: TemplateRoot,\n    values: Map<string, unknown>,\n  ): void => {\n    if (root !== this._mountedRoot) {\n      this._mountedRoot = root;\n      while (root.firstChild) {\n        root.removeChild(root.firstChild);\n      }\n\n      root.append(this._fragment);\n    }\n\n    this._update(values);\n  };\n\n  /**\n   * Render this template into a target host element.\n   */\n  render = (root: TemplateRoot, context: TemplateContext): void => {\n    const [hasChanges, resolvedValues] = this._collectUpdatedValues(context);\n\n    // If no values have changed, exit early\n    if (root === this._mountedRoot && !hasChanges) {\n      return;\n    }\n\n    this.renderWithValues(root, resolvedValues);\n    this._latestRenderedValues = resolvedValues;\n  };\n}\n",
    "type TaskQueue = \"tasks\" | \"frames\";\ntype TaskQueues = Record<TaskQueue, VoidFunction[]>;\ntype TaskPromises = Partial<Record<TaskQueue, Promise<void>>>;\ntype TaskResolvers = Partial<Record<TaskQueue, VoidFunction>>;\n\nexport class TaskScheduler {\n  private _queues: TaskQueues = {\n    tasks: [],\n    frames: [],\n  };\n  private _promises: TaskPromises = {};\n  private _resolvers: TaskResolvers = {};\n  private _onError?: (error: unknown) => void;\n\n  constructor(onError?: (error: unknown) => void) {\n    this._onError = onError;\n  }\n\n  private _flushQueue = (queueType: TaskQueue) => {\n    const queue = this._queues[queueType];\n    try {\n      while (queue.length) {\n        const task = queue.shift();\n        task?.();\n      }\n    } catch (error) {\n      if (this._onError) {\n        this._onError(error);\n      } else {\n        throw error;\n      }\n    } finally {\n      // Resolve the task promise\n      this._resolvers[queueType]?.();\n      this._resolvers[queueType] = undefined;\n      this._promises[queueType] = undefined;\n    }\n  };\n\n  private _schedule = (\n    type: TaskQueue,\n    task: VoidFunction,\n    prioritize = false,\n  ): Promise<void> => {\n    const queue = this._queues[type];\n    if (prioritize) {\n      queue.unshift(task);\n    } else {\n      queue.push(task);\n    }\n\n    if (!this._promises[type]) {\n      this._promises[type] = new Promise((resolve) => {\n        this._resolvers[type] = resolve;\n      });\n\n      if (type === \"frames\") {\n        requestAnimationFrame(this._flushQueue.bind(this, \"frames\"));\n      } else {\n        queueMicrotask(this._flushQueue.bind(this, \"tasks\"));\n      }\n    }\n\n    return this._promises[type];\n  };\n\n  scheduleMicrotask = (\n    task: VoidFunction,\n    prioritize = false,\n  ): Promise<void> => {\n    return this._schedule(\"tasks\", task, prioritize);\n  };\n\n  scheduleFrameTask = (\n    task: VoidFunction,\n    prioritize = false,\n  ): Promise<void> => {\n    return this._schedule(\"frames\", task, prioritize);\n  };\n}\n\nexport const asyncTasks = new TaskScheduler();\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\nimport { elementMatches } from \"#util\";\nimport { isElement, isNode, isShadowRoot } from \"../util/dom\";\n\nexport type EventName = keyof GlobalEventHandlersEventMap;\nexport type EventHandler<K extends EventName = EventName> = (\n  event: GlobalEventHandlersEventMap[K],\n) => void;\n\ntype EventHandlerMap = Map<string, EventHandler>;\n\n/**\n * Managed event delegation to coalesce event listeners for an entire tree into\n * single root-level listeners.\n *\n * @example\n * Listen for events from any child element of the delegated root\n *\n * ```typescript\n * const delegator = new EventDelegator($root);\n * delegator.addDelegatedListener(\"click\", handleClick);\n * ```\n *\n * @example\n * Listen for events from child elements matching `.action`\n *\n * ```typescript\n * const delegator = new EventDelegator($root);\n * delegator.addDelegatedListener(\"click\", handleClick, \".action\");\n * ```\n */\nexport class EventDelegator {\n  private _root: HTMLElement | ShadowRoot | Document;\n  private _rootListeners: EventHandlerMap = new Map();\n  private _events: Map<string, Map<string, Set<EventHandler>>> = new Map();\n\n  constructor(root: HTMLElement | ShadowRoot | Document = document) {\n    this._root = root;\n  }\n\n  private _handlersForEvent(event: string): Map<string, Set<EventHandler>> {\n    let handlerMap = this._events.get(event);\n\n    if (handlerMap === undefined) {\n      handlerMap = new Map();\n      this._events.set(event, handlerMap);\n    }\n\n    return handlerMap;\n  }\n\n  private _handlersForEventAndQuery<E extends EventName>(\n    event: E,\n    query: string,\n  ): Set<EventHandler<E>> {\n    const handlerMap = this._handlersForEvent(event);\n    let handlerSet = handlerMap.get(query);\n\n    if (handlerSet === undefined) {\n      handlerSet = new Set();\n      handlerMap.set(query, handlerSet);\n    }\n\n    return handlerSet;\n  }\n\n  private _createRootListener(eventName: string): void {\n    if (this._rootListeners.has(eventName)) {\n      return;\n    }\n\n    const listener = (event: Event) => {\n      const handlersForEvent = this._handlersForEvent(eventName);\n      const { target } = event;\n\n      if (target === null || !isNode(target)) {\n        return;\n      }\n\n      let node: Node | null = target;\n\n      let stopImmediateCalled = false;\n      const originalFn = event.stopImmediatePropagation;\n      event.stopImmediatePropagation = () => {\n        originalFn.call(event);\n        stopImmediateCalled = true;\n      };\n\n      while (node) {\n        if (node === this._root) {\n          break;\n        }\n\n        // Skip invalid elements\n        if (!isElement(node)) {\n          node = node.parentNode;\n          continue;\n        }\n\n        // Invoke handlers\n        for (const [query, handlers] of handlersForEvent) {\n          if (query === \"*\" || elementMatches(node, query)) {\n            for (const handler of handlers) {\n              handler.call(node, event);\n\n              // Respect .stopImmediatePropagation() and .preventDefault()\n              if (stopImmediateCalled || event.defaultPrevented) {\n                return;\n              }\n            }\n          }\n        }\n\n        // Respect .stopPropagation()\n        if (event.cancelBubble) {\n          return;\n        }\n\n        node = node.parentNode;\n\n        if (node === this._root || isShadowRoot(node)) {\n          break;\n        }\n      }\n    };\n\n    this._rootListeners.set(eventName, listener);\n    this._root.addEventListener(eventName, listener);\n  }\n\n  addListener<E extends EventName>(\n    eventName: E,\n    handler: EventHandler<E>,\n    queryFilter: string = \"*\",\n  ): void {\n    this._handlersForEventAndQuery(eventName, queryFilter).add(handler);\n    this._createRootListener(eventName);\n  }\n\n  removeListener(\n    eventName: EventName,\n    handler: EventHandler,\n    queryFilter: string,\n  ): void {\n    const handlerSet = this._handlersForEventAndQuery(eventName, queryFilter);\n    handlerSet.delete(handler);\n\n    // If that was the last handler for that event/query combo, delete the set\n    if (handlerSet.size === 0) {\n      const eventHandlerSets = this._handlersForEvent(eventName);\n      eventHandlerSets.delete(queryFilter);\n    }\n  }\n\n  cleanup = (): void => {\n    for (const [event, handler] of this._rootListeners) {\n      this._root.removeEventListener(event, handler);\n    }\n\n    this._rootListeners.clear();\n  };\n}\n",
    "/*\n * Copyright © Rustic Arcade, LLC 2026\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\nimport { ErrorCode, PaletteError } from \"#error\";\nimport { State } from \"#state\";\nimport { Template, type TemplateContext } from \"#template\";\nimport { getElementAttributes } from \"#util\";\nimport { asyncTasks } from \"../task-scheduler\";\nimport { walkParents } from \"../util/dom\";\nimport { EventDelegator, type EventHandler, type EventName } from \"./delegator\";\n\nconst MAX_SEQUENTIAL_RENDERS = 10000;\nconst BLANK_TEMPLATE = document.createElement(\"template\");\nconst HOST_TARGET = \":host\";\n\nexport enum RootMode {\n  Closed = \"closed\",\n  Open = \"open\",\n}\n\ntype Internals<StateShape extends object = {}> = {\n  isFinalized: boolean;\n  isInitialRenderComplete: boolean;\n  isRenderScheduled: boolean;\n  isRendering: boolean;\n  sequentialRenderCount: number;\n  lastRenderedAttributes: Record<string, string | null>;\n  pendingAttributeChanges: Record<string, string | null>;\n\n  state?: State<StateShape>;\n  delegator?: EventDelegator;\n  hostListeners?: Set<ComponentHostListener>;\n  cleanupFn?: VoidFunction;\n};\n\ntype ComponentHostListener = {\n  handler: EventHandler;\n  event: EventName;\n};\n\n/**\n * The **Component** class extends the base HTMLElement class to provide an\n * ergonomic way to design and develop Web Components with reactive state,\n * managed attributes, and dynamic templating.\n */\nexport abstract class Component<\n  StateShape extends object = {},\n> extends HTMLElement {\n  /**\n   * Check if a value is a Component instance\n   */\n  static isComponent(value: unknown): value is Component {\n    return (\n      typeof value === \"object\" && value !== null && value instanceof Component\n    );\n  }\n\n  /**\n   * Check if a value is a Component class\n   */\n  static isComponentClass(value: unknown): value is typeof Component {\n    return (\n      value !== null &&\n      typeof value === \"function\" &&\n      (value.prototype instanceof Component || value === Component)\n    );\n  }\n\n  static readComponentTagName(componentClass: typeof Component): string {\n    const { tagName } = componentClass;\n\n    if (__DEV__) {\n      if (tagName === \"\") {\n        console.warn(\n          `[Component] Empty tag name when reading from component ${componentClass.name}`,\n        );\n      }\n    }\n\n    return tagName;\n  }\n\n  /** The HTML tag name to use for this Component */\n  static tagName: string = \"\";\n\n  /** An HTML Template element for this element to use. */\n  static template: HTMLTemplateElement | Template = BLANK_TEMPLATE;\n\n  /** Styles to encapsulate to this component's root. */\n  static style: CSSStyleSheet | CSSStyleSheet[] | string = [];\n\n  /** Attributes to watch for changes for updates. */\n  static observedAttributes: string[] = [];\n\n  /**\n   * The mode for this Component's ShadowRoot.\n   *\n   * MDN: https://developer.mozilla.org/en-US/docs/Web/API/ShadowRoot/mode\n   */\n  static rootMode: RootMode = RootMode.Closed;\n\n  /**\n   * Initialization lifecycle method. Main scripting and event listeners.\n   * @returns a function to handle cleanup tasks when the component unmounts\n   */\n  public script?(): VoidFunction | void;\n\n  /** Called immediately before each template update */\n  public beforeUpdate?(changedAttributes: Record<string, string | null>): void;\n\n  /** Called immediately after each template update */\n  public afterUpdate?(previousAttributes: Record<string, string | null>): void;\n\n  /** Final lifecycle method called at the end of the unmounting process. */\n  public finalize?(): void;\n\n  /**\n   * Handle errors thrown during lifecycle methods of this component or any\n   * unhandled errors from child components.\n   */\n  public onError?(error: unknown): void;\n\n  /** The initial state for this Component */\n  public initialState?(): State<StateShape> | StateShape;\n\n  /**\n   * An object or function returning an object which populates the `data` values\n   * in the templating engine. Such values are accessed using the `*` notation.\n   */\n  public computedProperties?(\n    this: Component<StateShape>,\n    attributes: Record<string, string | null>,\n    state: StateShape,\n  ): Record<string, unknown>;\n\n  public readonly root: ShadowRoot;\n  public readonly template: Template;\n\n  private _cmp: Internals<StateShape> = {\n    isFinalized: false,\n    isInitialRenderComplete: false,\n    isRenderScheduled: false,\n    isRendering: false,\n    sequentialRenderCount: 0,\n    lastRenderedAttributes: {},\n    pendingAttributeChanges: {},\n  };\n\n  // ╭────────────────────────────────────────────────────────╮\n  // │             Internals and Private Methods              │\n  // ╰────────────────────────────────────────────────────────╯\n\n  constructor() {\n    super();\n\n    const {\n      template,\n      style,\n      rootMode: mode,\n    } = this.constructor as typeof Component;\n\n    // Create the element's shadow dom\n    this.root = this.attachShadow({ mode });\n\n    // Coerce and adopt styles\n    let adoptStyles: CSSStyleSheet[] = [];\n\n    if (Array.isArray(style)) {\n      adoptStyles = style;\n    } else if (style instanceof CSSStyleSheet) {\n      adoptStyles = [style];\n    } else {\n      const adoptSheet = new CSSStyleSheet();\n      adoptSheet.replaceSync(style);\n      adoptStyles = [adoptSheet];\n    }\n\n    this.root.adoptedStyleSheets.push(...adoptStyles);\n\n    // Adopt template\n    this.template = Template.isTemplate(template)\n      ? template\n      : new Template(template);\n  }\n\n  /** Produce the data object to pass to the template's render function */\n  private _getRenderContext(\n    attr: Record<string, string | null>,\n  ): TemplateContext {\n    const state = (this._cmp.state?.raw ?? {}) as StateShape;\n    const computed = this.computedProperties?.call(this, attr, state);\n\n    return {\n      attr: attr,\n      data: computed,\n      state: state as Record<string, unknown>,\n    };\n  }\n\n  private _escalateError(error: unknown): void {\n    const isErrorHandled = walkParents(this, (node: Node) => {\n      if (node instanceof Component && node.onError) {\n        node.onError(error);\n        return true;\n      }\n    });\n\n    if (!isErrorHandled) {\n      throw error;\n    }\n  }\n\n  private _reportError(error: unknown): void {\n    this.onError ? this.onError(error) : this._escalateError(error);\n  }\n\n  /** The actual update behavior */\n  private _render = (): void => {\n    try {\n      // Immediately flip flags to denote a render is in progress and allow\n      // queueing another render request.\n      this._cmp.isRendering = true;\n      this._cmp.isRenderScheduled = false;\n\n      // Cache the attributes from the previous render\n      const prevAttrs = this._cmp.lastRenderedAttributes;\n\n      this.beforeUpdate?.(this._cmp.pendingAttributeChanges);\n\n      // Update the current snapshot of attributes\n      const newAttributes = getElementAttributes(this);\n      this.template.render(this.root, this._getRenderContext(newAttributes));\n      this._cmp.lastRenderedAttributes = newAttributes;\n\n      this.afterUpdate?.(prevAttrs);\n\n      // If the `willRender` flag was flipped, immediately perform a render\n      if (this._cmp.isRenderScheduled) {\n        this._cmp.sequentialRenderCount += 1;\n\n        if (this._cmp.sequentialRenderCount >= MAX_SEQUENTIAL_RENDERS) {\n          throw new PaletteError(\n            ErrorCode.MAX_SEQUENTIAL_RENDERS,\n            `${this._cmp.sequentialRenderCount}`,\n          );\n        }\n\n        this._render();\n      } else {\n        this._cmp.sequentialRenderCount = 0;\n      }\n    } catch (error) {\n      this._cmp.isRenderScheduled = false;\n      this._reportError(error);\n    } finally {\n      this._cmp.isRendering = false;\n    }\n  };\n\n  private _adoptState(state: StateShape | State<StateShape>) {\n    // If this is exactly our own state object, do nothing\n    if (Object.is(this._cmp.state, state)) {\n      return;\n    }\n\n    // If state exists, remove the listener and schedule a render\n    if (this._cmp.state) {\n      this._cmp.state.removeListener(this.render);\n      this.render();\n    }\n\n    // Adopt the incoming state obj or wrap and adopt it\n    const incomingStateObj = State.isState<StateShape>(state)\n      ? state\n      : new State(state);\n    this._cmp.state = incomingStateObj;\n\n    // Ensure there is not accidentally two of the same render listeners\n    this._cmp.state.removeListener(this.render);\n    this._cmp.state.addListener(this.render);\n  }\n\n  // ╭────────────────────────────────────────────────────────╮\n  // │           Custom Element Callback Overrides            │\n  // ╰────────────────────────────────────────────────────────╯\n\n  /**\n   * @deprecated Use {@link script} instead\n   */\n  protected connectedCallback(): void {\n    if (this._cmp.isInitialRenderComplete) {\n      return;\n    }\n\n    asyncTasks.scheduleMicrotask(() => {\n      try {\n        this._cmp.isRendering = true;\n        this._cmp.isRenderScheduled = false;\n\n        const attributes = getElementAttributes(this);\n\n        // If this is a stateful component, set up that state\n        if (this.initialState) {\n          this._adoptState(this.initialState());\n        }\n\n        this.template.render(this.root, this._getRenderContext(attributes));\n\n        this._cmp.lastRenderedAttributes = attributes;\n        this._cmp.isInitialRenderComplete = true;\n        this._cmp.cleanupFn = this.script?.() ?? undefined;\n      } catch (error) {\n        this._reportError(error);\n      } finally {\n        this._cmp.isRendering = false;\n      }\n    });\n  }\n\n  /**\n   * @deprecated use {@link finalize}\n   */\n  protected disconnectedCallback(): void {\n    if (this._cmp.isFinalized) {\n      return;\n    }\n\n    asyncTasks.scheduleMicrotask(() => {\n      // If this task runs but the component is still connected, then do nothing\n      // because the component was just moved in the DOM.\n      if (this.isConnected || !this._cmp.isInitialRenderComplete) {\n        return;\n      }\n\n      this._cmp.isFinalized = true;\n\n      // Only run the disconnect if the element is actually unmounted and not\n      // just moved. Using this in place of connectedMoveCallback() for compat\n      try {\n        const { delegator, cleanupFn, hostListeners } = this._cmp;\n        delegator?.cleanup();\n\n        // Clear any listeners set up on self\n        if (hostListeners && hostListeners.size > 0) {\n          for (const listener of hostListeners) {\n            this.removeEventListener(listener.event, listener.handler);\n          }\n        }\n\n        cleanupFn?.();\n      } catch (error) {\n        this._reportError(error);\n      } finally {\n        // Run the finalize call after everything, even if the cleanup fn failed\n        try {\n          this.finalize?.();\n        } catch (error) {\n          this._reportError(error);\n        }\n      }\n    });\n  }\n\n  /**\n   * @deprecated Use {@link beforeUpdate} and {@link afterUpdate} instead\n   */\n  protected attributeChangedCallback(\n    name: string,\n    _: string | null,\n    newValue: string | null,\n  ): void {\n    // Ignore attribute changes that occur during an update, as they are\n    // coming from inside the house\n    if (this._cmp.isRendering) {\n      return;\n    }\n\n    // Cache the updated attribute value\n    this._cmp.pendingAttributeChanges[name] = newValue;\n\n    // Schedule a render\n    if (!this._cmp.isRenderScheduled) {\n      this.render();\n    }\n  }\n\n  // ╭────────────────────────────────────────────────────────╮\n  // │                    Public Interface                    │\n  // ╰────────────────────────────────────────────────────────╯\n\n  get isMounted(): boolean {\n    return this.isConnected && this._cmp.isInitialRenderComplete;\n  }\n\n  /**\n   * Access the full {@link State} instance for this Component.\n   *\n   * @remarks\n   * Calling this method on a component which is not using reactive state\n   * will result in an error being thrown.\n   */\n  getState(): State<StateShape> {\n    if (!this._cmp.state) {\n      throw new PaletteError(ErrorCode.MISSING_STATE);\n    }\n\n    return this._cmp.state;\n  }\n\n  /**\n   * Accessor for live reactive state.\n   *\n   * For the full state manipulation API, use {@link getState}\n   */\n  get state(): StateShape {\n    return this.getState().live;\n  }\n\n  /**\n   * Replace the current state with a new value or adopt a whole different State\n   * instance\n   */\n  set state(newState: StateShape | State<StateShape>) {\n    this._adoptState(newState);\n  }\n\n  /**\n   * Manually schedule a render to occur, optionally providing a callback to\n   * invoke after the render completes.\n   *\n   * @remarks\n   * Calling {@link render} multiple times in the same event loop won't\n   * schedule multiple renders. Renders are scheduled to occur on the next\n   * animation frame.\n   */\n  render = (): void => {\n    // Prevent scheduling multiple renders\n    if (this._cmp.isRenderScheduled) {\n      return;\n    }\n\n    this._cmp.isRenderScheduled = true;\n\n    // If currently rendering, don't request a render, it will auto-continue\n    // until there are no changes to render\n    if (this._cmp.isRendering) {\n      return;\n    }\n\n    // If a render is requested and we're not rendering, request a render frame\n    asyncTasks.scheduleFrameTask(this._render);\n  };\n\n  /**\n   * Listen for events on a child element based on the provided query\n   *\n   * @returns A function which removes the listener when called\n   *\n   * @remarks\n   * Event listeners created with this method are automatically cleaned up when\n   * the component unmounts. You can manually remove the listener during the\n   * component's lifecycle by calling the returned function if need be.\n   */\n  listen<E extends EventName>(\n    target: string,\n    eventName: E,\n    eventHandler: EventHandler<E>,\n  ): VoidFunction;\n\n  /**\n   * Listen for events on a child element based on the provided component's tag\n   *\n   * @returns A function which removes the listener when called\n   *\n   * @remarks\n   * Event listeners created with this method are automatically cleaned up when\n   * the component unmounts. You can manually remove the listener during the\n   * component's lifecycle by calling the returned function if need be.\n   */\n  listen<E extends EventName>(\n    target: typeof Component<any>,\n    eventName: E,\n    eventHandler: EventHandler<E>,\n  ): VoidFunction;\n\n  /**\n   * Listen for events on the host element\n   *\n   * @returns A function which removes the listener when called\n   *\n   * @remarks\n   * Event listeners created with this method are automatically cleaned up when\n   * the component unmounts. You can manually remove the listener during the\n   * component's lifecycle by calling the returned function if need be.\n   */\n  listen<E extends EventName>(\n    target: typeof this,\n    eventName: E,\n    eventHandler: EventHandler<E>,\n  ): VoidFunction;\n\n  /**\n   * Listen for events on the host element\n   *\n   * @returns A function which removes the listener when called\n   *\n   * @remarks\n   * Event listeners created with this method are automatically cleaned up when\n   * the component unmounts. You can manually remove the listener during the\n   * component's lifecycle by calling the returned function if need be.\n   */\n  listen<E extends EventName>(\n    target: \":host\",\n    eventName: E,\n    eventHandler: EventHandler<E>,\n  ): VoidFunction;\n\n  listen<E extends EventName>(\n    targetDescriptor: string | typeof Component<any> | typeof this,\n    eventName: E,\n    eventHandler: EventHandler<E>,\n  ): VoidFunction {\n    // Host element events\n    if (targetDescriptor === HOST_TARGET || targetDescriptor === this) {\n      if (!this._cmp.hostListeners) {\n        this._cmp.hostListeners = new Set();\n      }\n\n      const hostListeners = this._cmp.hostListeners;\n\n      const entry: ComponentHostListener = {\n        event: eventName,\n        handler: eventHandler as EventHandler,\n      };\n\n      hostListeners.add(entry);\n      this.addEventListener(eventName, eventHandler);\n\n      return () => {\n        this.removeEventListener(eventName, eventHandler);\n        hostListeners.delete(entry);\n      };\n    }\n\n    // Other objects as a descriptor indicate an error\n    if (typeof targetDescriptor === \"object\") {\n      throw new PaletteError(ErrorCode.INVALID_CALLSITE);\n    }\n\n    // Child element events\n    if (!this._cmp.delegator) {\n      this._cmp.delegator = new EventDelegator(this.root);\n    }\n\n    const delegator = this._cmp.delegator;\n\n    const query =\n      typeof targetDescriptor === \"string\"\n        ? targetDescriptor\n        : Component.readComponentTagName(targetDescriptor);\n\n    delegator.addListener(eventName, eventHandler, query);\n\n    return () => {\n      delegator.removeListener(eventName, eventHandler as EventHandler, query);\n    };\n  }\n\n  /**\n   * Publish a {@link CustomEvent} with the provided name and options.\n   *\n   * Default options are:\n   *\n   * ```typescript\n   * {\n   *   bubbles: true,\n   *   cancelable: true,\n   *   composed: true,\n   *   detail: undefined,\n   * }\n   * ```\n   *\n   * @param name The name of the custom event to publish\n   * @param options Options to configure the custom event\n   */\n  dispatchEvent<T>(name: string, options: CustomEventInit<T>): boolean;\n  dispatchEvent(event: Event): boolean;\n  dispatchEvent<T>(a: Event | string, b?: CustomEventInit<T>): boolean {\n    if (typeof a === \"object\" && typeof b === \"undefined\") {\n      return super.dispatchEvent(a);\n    } else if (typeof a === \"string\") {\n      return super.dispatchEvent(\n        new CustomEvent(a, {\n          bubbles: true,\n          cancelable: true,\n          composed: true,\n          ...b,\n        }),\n      );\n    } else {\n      throw new PaletteError(ErrorCode.INVALID_CALLSITE);\n    }\n  }\n\n  /**\n   * Returns a reference to the HTML Element with the provided ID within the\n   * shadow root of this component.\n   *\n   * Throws an error if no element with the provided ID is found\n   */\n  ref<E extends HTMLElement>(id: string): E {\n    const lookup = this.root.getElementById(id);\n    if (!lookup) {\n      throw new PaletteError(ErrorCode.MISSING_ELEMENT);\n    }\n    return lookup as E;\n  }\n\n  /**\n   * Serialize this element to a string\n   */\n  toString(): string {\n    const { tagName, name } = this.constructor as typeof Component;\n    const computedName = tagName === \"\" ? name : tagName;\n    const attrString = this.getAttributeNames()\n      .map((attrName) => {\n        const val = this.getAttribute(attrName);\n        return val ? `${attrName}=\"${val}\"` : \"\";\n      })\n      .join(\" \");\n    const attrs = attrString.length > 0 ? ` ${attrString}` : \"\";\n    return `<${computedName}${attrs}></${computedName}>`;\n  }\n}\n",
    "/*\n * This Source Code Form is subject to the terms of the Mozilla Public\n * License, v. 2.0. If a copy of the MPL was not distributed with this\n * file, You can obtain one at https://mozilla.org/MPL/2.0/.\n */\n\nimport { ErrorCode, PaletteError } from \"#error\";\nimport type { State } from \"#state\";\nimport { Component, RootMode } from \"./component\";\n\nconst BLANK_TEMPLATE = document.createElement(\"template\");\n\nexport interface ComponentShorthand<StateShape extends object = {}> {\n  /** An HTML Template element for this element to use. */\n  template?: HTMLTemplateElement;\n\n  /** Styles to encapsulate to this component's root. */\n  style?: CSSStyleSheet | CSSStyleSheet[] | string;\n\n  /**\n   * The mode for this Component's ShadowRoot.\n   *\n   * MDN: https://developer.mozilla.org/en-US/docs/Web/API/ShadowRoot/mode\n   */\n  rootMode?: RootMode;\n\n  /** Attributes to watch for changes for updates. */\n  observedAttributes?: string[];\n\n  /** The initial state for this Component */\n  initialState?:\n    | State<StateShape>\n    | StateShape\n    | (() => State<StateShape>)\n    | (() => StateShape);\n\n  /**\n   * An object or function returning an object which populates the `data` values\n   * in the templating engine. Such values are accessed using the `*` notation.\n   */\n  computedProperties?(\n    this: Component<StateShape>,\n    attributes?: Record<string, string | null>,\n    state?: StateShape,\n  ): Record<string, unknown>;\n\n  /** Initialization scripting for this Component */\n  script?: (this: Component<StateShape>) => VoidFunction | void;\n\n  /** Called immediately before each template update */\n  beforeUpdate?: (\n    this: Component<StateShape>,\n    changedAttributes?: Record<string, string | null>,\n  ) => void;\n\n  /** Called immediately after each template update */\n  afterUpdate?: (\n    this: Component<StateShape>,\n    previousAttributes?: Record<string, string | null>,\n  ) => void;\n\n  /**\n   * Called as the final lifecycle method at the end of the unmounting process.\n   */\n  finalize?: (this: Component<StateShape>) => void;\n\n  /**\n   * If defined, receives errors caught during the lifecycle methods of this\n   * component and it's children. If not defined, this component will instead\n   * throw errors as they are found.\n   */\n  onError?: (this: Component<StateShape>, error: unknown) => void;\n}\n\nfunction defineFromClass<StateShape extends object = {}>(\n  cls: typeof Component<StateShape>,\n  tagName?: string,\n) {\n  // Set the tagName static if its not already set\n  if (tagName && cls.tagName === \"\") {\n    cls.tagName = tagName;\n  }\n\n  if (__DEV__) {\n    if (tagName && tagName !== cls.tagName) {\n      console.warn(\n        `[COMPONENT] Component ${cls.name} was defined with tagname ${tagName} ` +\n          `which does not match its static tagName property`,\n      );\n    }\n  }\n\n  window.customElements.define(\n    cls.tagName,\n    cls as unknown as CustomElementConstructor,\n  );\n}\n\n/**\n * Define a Palette Component using the shorthand syntax\n *\n * @example\n *\n * ```typescript\n * define(\"my-component\", {\n *   template: html`...`,\n *   style: css`...`,\n *   initialState: { ... },\n *   computedProperties() { ... },\n *   script() { ... },\n *   // and any other lifecycle methods\n * });\n * ```\n */\nexport function define<StateShape extends object = {}>(\n  tagName: string,\n  definition: ComponentShorthand<StateShape>,\n): typeof Component<StateShape>;\n\n/**\n * Register a Palette Component as a custom element\n */\nexport function define<Cls extends typeof Component<any>>(definition: Cls): Cls;\n\n/**\n * Register a Palette Component as a custom element\n */\nexport function define<Cls extends typeof Component<any>>(\n  tagName: string,\n  definition: Cls,\n): Cls;\n\nexport function define<StateShape extends object = {}>(\n  a: string | typeof Component<StateShape>,\n  b?: ComponentShorthand<StateShape> | typeof Component<StateShape>,\n): typeof Component<StateShape> {\n  // Handle component class paths\n  if (typeof a === \"function\") {\n    defineFromClass(a);\n    return a;\n  }\n\n  if (typeof a === \"string\" && typeof b === \"function\") {\n    defineFromClass(b, a);\n    return b;\n  }\n\n  if (b === undefined) {\n    throw new PaletteError(ErrorCode.INVALID_CALLSITE);\n  }\n\n  // Handle shorthand\n  const tagName = a;\n  const definition = b;\n\n  // Component constructors are functions -> Define them with their tagname if present\n  if (typeof definition === \"function\") {\n    // Set the tagName static if its not already set\n    if (definition.tagName === \"\") {\n      definition.tagName = tagName;\n    }\n\n    if (__DEV__) {\n      if (tagName !== definition.tagName) {\n        console.warn(\n          `[COMPONENT] Component ${definition.name} was defined with tagname ${tagName} ` +\n            `which does not match its static tagName property`,\n        );\n      }\n    }\n\n    window.customElements.define(\n      tagName,\n      definition as unknown as CustomElementConstructor,\n    );\n    return definition;\n  }\n\n  const {\n    // Config\n    template = BLANK_TEMPLATE,\n    style = [],\n    rootMode = RootMode.Closed,\n    initialState: stateInitializer,\n    computedProperties,\n    observedAttributes = [],\n\n    // Lifecycle\n    script,\n    beforeUpdate,\n    afterUpdate,\n    finalize,\n    onError,\n  } = definition;\n\n  let getInitialState: (() => State<StateShape> | StateShape) | undefined;\n\n  if (stateInitializer) {\n    getInitialState =\n      typeof stateInitializer === \"function\"\n        ? stateInitializer\n        : () => stateInitializer;\n  }\n\n  const cls = class extends Component<StateShape> {\n    static tagName = tagName;\n    static template = template;\n    static style = style;\n    static observedAttributes = [...observedAttributes];\n    static shadowRootMode = rootMode;\n  };\n\n  cls.prototype.initialState = getInitialState;\n  cls.prototype.computedProperties = computedProperties;\n\n  cls.prototype.script = script;\n  cls.prototype.beforeUpdate = beforeUpdate;\n  cls.prototype.afterUpdate = afterUpdate;\n  cls.prototype.finalize = finalize;\n  cls.prototype.onError = onError;\n\n  customElements.define(tagName, cls);\n  return cls;\n}\n",
    "import { fragmentCache } from \"#util\";\nimport { compiledTemplateCache } from \"./template/compile\";\nimport { parsedNotationCache, valueAccessorCache } from \"./template/syntax\";\n\nif (__DEV__ && typeof window !== \"undefined\") {\n  (window as any).__PALETTE_DEVTOOLS__ = {\n    dumpCacheMetrics: () => {\n      console.log(\"Compiled Templates\", compiledTemplateCache.getMetrics());\n      console.log(\"HTML Fragments\", fragmentCache.getMetrics());\n      console.log(\"Notation Accessor\", valueAccessorCache.getMetrics());\n      console.log(\"Parsed Notations\", parsedNotationCache.getMetrics());\n    },\n  };\n}\n"
  ],
  "mappings": "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",
  "debugId": "D9A90808356EA17464756E2164756E21",
  "names": []
}