essor 0.0.1 → 0.0.3-beta.4

package/dist/index.dev.cjs.js

@@ -0,0 +1,896 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Fragment: () => Fragment,
+  computed: () => computed,
+  createSignal: () => createSignal,
+  createStore: () => createStore,
+  effect: () => effect,
+  h: () => h,
+  isJsxElement: () => isJsxElement,
+  nextTick: () => nextTick,
+  onDestroy: () => onDestroy,
+  onMount: () => onMount,
+  signal: () => signal,
+  signalObject: () => signalObject,
+  template: () => template,
+  useInject: () => useInject,
+  useProvide: () => useProvide
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/signal/signal.ts
+var activeEffect = null;
+var activeComputed = null;
+var computedSet = /* @__PURE__ */ new Set();
+var targetMap = /* @__PURE__ */ new WeakMap();
+var EffectDeps = /* @__PURE__ */ new Set();
+function track(target, key) {
+  let depsMap = targetMap.get(target);
+  if (!depsMap) {
+    depsMap = /* @__PURE__ */ new Map();
+    targetMap.set(target, depsMap);
+  }
+  let dep = depsMap.get(key);
+  if (!dep) {
+    dep = /* @__PURE__ */ new Set();
+    depsMap.set(key, dep);
+  }
+  if (activeEffect)
+    dep.add(activeEffect);
+  if (activeComputed) {
+    computedSet.add(activeComputed);
+  }
+}
+function trigger(target, key) {
+  if (computedSet.size > 0) {
+    computedSet.forEach((computedSignal) => computedSignal.run());
+  }
+  const depsMap = targetMap.get(target);
+  if (!depsMap) {
+    return;
+  }
+  const dep = depsMap.get(key);
+  if (dep) {
+    dep.forEach((effect2) => EffectDeps.has(effect2) && effect2());
+  }
+}
+var Signal = class {
+  constructor(value) {
+    this._value = value;
+  }
+  valueOf() {
+    track(this, "value");
+    return this._value;
+  }
+  toString() {
+    track(this, "value");
+    return String(this._value);
+  }
+  toJSON() {
+    return this._value;
+  }
+  get value() {
+    track(this, "value");
+    return this._value;
+  }
+  set value(newValue) {
+    if (this._value !== newValue) {
+      this._value = newValue;
+      trigger(this, "value");
+    }
+  }
+  peek() {
+    return this._value;
+  }
+  update() {
+    trigger(this, "value");
+  }
+};
+function signal(value) {
+  if (isSignal(value)) {
+    return value;
+  }
+  return new Signal(value);
+}
+function isSignal(value) {
+  return value instanceof Signal;
+}
+var Computed = class {
+  constructor(fn) {
+    this.fn = fn;
+    const prev = activeComputed;
+    activeComputed = this;
+    track(this, "_value");
+    this._value = this.fn();
+    activeComputed = prev;
+  }
+  peek() {
+    return this._value;
+  }
+  run() {
+    const newValue = this.fn();
+    if (newValue !== this._value) {
+      this._value = newValue;
+    }
+  }
+  get value() {
+    track(this, "_value");
+    return this._value;
+  }
+};
+function computed(fn) {
+  return new Computed(fn);
+}
+function effect(fn) {
+  function effectFn() {
+    const prev = activeEffect;
+    activeEffect = effectFn;
+    fn();
+    activeEffect = prev;
+  }
+  EffectDeps.add(effectFn);
+  effectFn();
+  return () => {
+    EffectDeps.delete(effectFn);
+    activeEffect = null;
+  };
+}
+function createSignal(value) {
+  const signal2 = new Signal(value);
+  return [
+    signal2.value,
+    (newValue) => {
+      signal2.value = newValue;
+    }
+  ];
+}
+function signalObject(initialValues) {
+  const signals = Object.entries(initialValues).reduce((acc, [key, value]) => {
+    acc[key] = isSignal(value) ? value : signal(value);
+    return acc;
+  }, {});
+  return signals;
+}
+function signalToObject(signal2) {
+  if (!signal2)
+    return {};
+  if (isSignal(signal2)) {
+    return signal2.peek();
+  }
+  return Object.entries(signal2).reduce((acc, [key, value]) => {
+    acc[key] = isSignal(value) ? value.peek() : value;
+    return acc;
+  }, {});
+}
+
+// src/signal/store.ts
+var _id = 0;
+var StoreMap = /* @__PURE__ */ new Map();
+function createOptionsStore(options) {
+  const { state, getters, actions } = options;
+  const initState = __spreadValues({}, state != null ? state : {});
+  const signalState = signalObject(state != null ? state : {});
+  const subscriptions = [];
+  const actionCallbacks = [];
+  const default_actions = {
+    patch$(payload) {
+      Object.assign(signalState, signalObject(payload));
+      subscriptions.forEach((callback) => callback(signalToObject(signalState)));
+      actionCallbacks.forEach((callback) => callback(signalToObject(signalState)));
+    },
+    subscribe$(callback) {
+      subscriptions.push(callback);
+    },
+    unsubscribe$(callback) {
+      const index = subscriptions.indexOf(callback);
+      if (index !== -1) {
+        subscriptions.splice(index, 1);
+      }
+    },
+    onAction$(callback) {
+      actionCallbacks.push(callback);
+    },
+    reset$() {
+      default_actions.patch$(initState);
+    }
+  };
+  const states = {
+    _id: `store_${_id}`
+  };
+  for (const key in getters) {
+    const getter = getters[key];
+    if (getter) {
+      states[key] = computed(() => {
+        return getter.call(signalState);
+      });
+    }
+  }
+  for (const key in actions) {
+    const action = actions[key];
+    if (action) {
+      states[key] = action.bind(signalState);
+    }
+  }
+  StoreMap.set(_id, signal);
+  ++_id;
+  return new Proxy(
+    {},
+    {
+      get(_, key) {
+        if (key in states) {
+          return states[key];
+        }
+        if (key in default_actions) {
+          return default_actions[key];
+        }
+        return signalState[key].value;
+      }
+    }
+  );
+}
+function createStore(options) {
+  return function() {
+    if (StoreMap.has(_id)) {
+      return StoreMap.get(_id);
+    }
+    return createOptionsStore(options);
+  };
+}
+
+// src/utils/comm.ts
+function coerceArray(data) {
+  return Array.isArray(data) ? data.flat() : [data];
+}
+var noop = Function.prototype;
+
+// src/utils/is.ts
+var isArray = Array.isArray;
+function isNil(x) {
+  return x === null || x === void 0;
+}
+var isFunction = (val) => typeof val === "function";
+function isFalsy(x) {
+  return x === false || x === null || x === void 0 || x === "";
+}
+
+// src/utils/name.ts
+var kebabCase = (string) => {
+  return string.replaceAll(/[A-Z]+/g, (match, offset) => {
+    return `${offset > 0 ? "-" : ""}${match.toLocaleLowerCase()}`;
+  });
+};
+
+// src/template/utils.ts
+function coerceNode(data) {
+  if (isJsxElement(data) || data instanceof Node) {
+    return data;
+  }
+  const text = isFalsy(data) ? "" : String(data);
+  return document.createTextNode(text);
+}
+function insertChild(parent, child, before = null) {
+  const beforeNode = isJsxElement(before) ? before.firstChild : before;
+  if (isJsxElement(child)) {
+    child.mount(parent, beforeNode);
+  } else if (beforeNode) {
+    beforeNode.before(child);
+  } else {
+    parent.append(child);
+  }
+}
+function removeChild(child) {
+  if (isJsxElement(child)) {
+    child.unmount();
+  } else {
+    const parent = child.parentNode;
+    if (parent) {
+      child.remove();
+    }
+  }
+}
+function replaceChild(parent, node, child) {
+  insertChild(parent, node, child);
+  removeChild(child);
+}
+function setAttribute(element, attr, value) {
+  if (attr === "class") {
+    if (typeof value === "string") {
+      element.className = value;
+    } else if (Array.isArray(value)) {
+      element.className = value.join(" ");
+    } else if (value && typeof value === "object") {
+      element.className = Object.entries(value).reduce((acc, [key, value2]) => acc + (value2 ? ` ${key}` : ""), "").trim();
+    }
+    return;
+  }
+  if (attr === "style") {
+    if (typeof value === "string") {
+      element.style.cssText = value;
+    } else if (value && typeof value === "object") {
+      const obj = value;
+      Object.keys(obj).forEach((key) => {
+        element.style.setProperty(kebabCase(key), String(obj[key]));
+      });
+    }
+    return;
+  }
+  if (isFalsy(value)) {
+    element.removeAttribute(attr);
+  } else if (value === true) {
+    element.setAttribute(attr, "");
+  } else {
+    element.setAttribute(attr, String(value));
+  }
+}
+function binNode(node, setter) {
+  if (node instanceof HTMLInputElement) {
+    if (node.type === "checkbox") {
+      return addEventListener(node, "change", () => {
+        setter(Boolean(node.checked));
+      });
+    }
+    if (node.type === "date") {
+      return addEventListener(node, "change", () => {
+        setter(node.value ? node.value : "");
+      });
+    }
+    if (node.type === "file") {
+      return addEventListener(node, "change", () => {
+        if (node.files) {
+          setter(node.files);
+        }
+      });
+    }
+    if (node.type === "number") {
+      return addEventListener(node, "input", () => {
+        const value = Number.parseFloat(node.value);
+        setter(Number.isNaN(value) ? "" : String(value));
+      });
+    }
+    if (node.type === "radio") {
+      return addEventListener(node, "change", () => {
+        setter(node.checked ? node.value : "");
+      });
+    }
+    if (node.type === "text") {
+      return addEventListener(node, "input", () => {
+        setter(node.value);
+      });
+    }
+  }
+  if (node instanceof HTMLSelectElement) {
+    return addEventListener(node, "change", () => {
+      setter(node.value);
+    });
+  }
+  if (node instanceof HTMLTextAreaElement) {
+    return addEventListener(node, "input", () => {
+      setter(node.value);
+    });
+  }
+}
+var p = Promise.resolve();
+function nextTick(fn) {
+  return fn ? p.then(fn) : p;
+}
+function addEventListener(node, eventName, handler) {
+  node.addEventListener(eventName, handler);
+  return () => node.removeEventListener(eventName, handler);
+}
+
+// src/template/component-node.ts
+var _ComponentNode = class _ComponentNode {
+  constructor(template2, props, key) {
+    this.template = template2;
+    this.props = props;
+    this.key = key;
+    this.proxyProps = {};
+    this.context = {};
+    this.emitter = /* @__PURE__ */ new Set();
+    this.mounted = false;
+    this.rootNode = null;
+    this.hooks = {
+      mounted: /* @__PURE__ */ new Set(),
+      destroy: /* @__PURE__ */ new Set()
+    };
+    this.trackMap = /* @__PURE__ */ new Map();
+    this.proxyProps = signalObject(props);
+  }
+  addEventListener() {
+  }
+  removeEventListener() {
+  }
+  get firstChild() {
+    var _a, _b;
+    return (_b = (_a = this.rootNode) == null ? void 0 : _a.firstChild) != null ? _b : null;
+  }
+  get isConnected() {
+    var _a, _b;
+    return (_b = (_a = this.rootNode) == null ? void 0 : _a.isConnected) != null ? _b : false;
+  }
+  addHook(hook, cb) {
+    var _a;
+    (_a = this.hooks[hook]) == null ? void 0 : _a.add(cb);
+  }
+  getContext(context) {
+    return _ComponentNode.context[context];
+  }
+  setContext(context, value) {
+    _ComponentNode.context[context] = value;
+  }
+  inheritNode(node) {
+    this.context = node.context;
+    this.hooks = node.hooks;
+    Object.assign(this.proxyProps, node.proxyProps);
+    this.rootNode = node.rootNode;
+    this.trackMap = node.trackMap;
+    const props = this.props;
+    this.props = node.props;
+    this.patchProps(props);
+  }
+  unmount() {
+    var _a;
+    this.hooks.destroy.forEach((handler) => handler());
+    Object.values(this.hooks).forEach((set) => set.clear());
+    (_a = this.rootNode) == null ? void 0 : _a.unmount();
+    this.rootNode = null;
+    this.proxyProps = {};
+    this.mounted = false;
+    this.emitter.forEach((emitter) => emitter());
+    _ComponentNode.context = {};
+  }
+  mount(parent, before) {
+    var _a, _b, _c, _d;
+    if (!isFunction(this.template)) {
+      throw new Error("Template must be a function");
+    }
+    if (this.isConnected) {
+      return (_b = (_a = this.rootNode) == null ? void 0 : _a.mount(parent, before)) != null ? _b : [];
+    }
+    _ComponentNode.ref = this;
+    this.rootNode = this.template(this.proxyProps);
+    _ComponentNode.ref = null;
+    this.mounted = true;
+    const mountedNode = (_d = (_c = this.rootNode) == null ? void 0 : _c.mount(parent, before)) != null ? _d : [];
+    this.hooks.mounted.forEach((handler) => handler());
+    this.patchProps(this.props);
+    return mountedNode;
+  }
+  getNodeTrack(trackKey, suppressCleanupCall) {
+    let track2 = this.trackMap.get(trackKey);
+    if (!track2) {
+      track2 = { cleanup: () => {
+      } };
+      this.trackMap.set(trackKey, track2);
+    }
+    if (!suppressCleanupCall) {
+      track2.cleanup();
+    }
+    return track2;
+  }
+  patchProps(props) {
+    var _a, _b, _c, _d, _e;
+    for (const [key, prop] of Object.entries(props)) {
+      if (key.indexOf("on") === 0 && ((_a = this.rootNode) == null ? void 0 : _a.nodes)) {
+        const event = key.slice(2).toLowerCase();
+        const listener = prop;
+        const cleanup = addEventListener(this.rootNode.nodes[0], event, listener);
+        this.emitter.add(cleanup);
+      } else if (key.indexOf("bind:") === 0) {
+        this.proxyProps[key] = signal(prop);
+      } else if (key === "ref") {
+        isFunction(prop) ? prop((_b = this.rootNode) == null ? void 0 : _b.nodes[0]) : props[key] = (_c = this.rootNode) == null ? void 0 : _c.nodes[0];
+      } else {
+        const newValue = (_e = (_d = this.proxyProps)[key]) != null ? _e : _d[key] = signal(prop);
+        const track2 = this.getNodeTrack(key);
+        track2.cleanup = effect(() => {
+          newValue.value = prop;
+        });
+      }
+    }
+    this.props = props;
+  }
+};
+_ComponentNode.ref = null;
+_ComponentNode.context = {};
+var ComponentNode = _ComponentNode;
+
+// src/template/patch.ts
+function patchChildren(parent, childrenMap, nextChildren, before) {
+  const result = /* @__PURE__ */ new Map();
+  const children = childrenMap.values();
+  const parentChildNodesLength = parent.childNodes.length;
+  if (childrenMap.size > 0 && nextChildren.length === 0) {
+    if (parentChildNodesLength === childrenMap.size + (before ? 1 : 0)) {
+      const parentElement = parent;
+      parentElement.innerHTML = "";
+      if (before) {
+        insertChild(parent, before);
+      }
+    } else {
+      const range = document.createRange();
+      const child = children.next().value;
+      const start = isJsxElement(child) ? child.firstChild : child;
+      range.setStartBefore(start);
+      if (before) {
+        range.setEndBefore(before);
+      } else {
+        range.setEndAfter(parent);
+      }
+      range.deleteContents();
+    }
+    childrenMap.forEach((node) => {
+      if (isJsxElement(node)) {
+        node.unmount();
+      }
+    });
+    return result;
+  }
+  const replaces = [];
+  const nextChildrenMap = mapKeys(nextChildren);
+  for (let [i, child] of nextChildren.entries()) {
+    let currChild = children.next().value;
+    let currKey = getKey(currChild, i);
+    while (currChild && !nextChildrenMap.has(currKey)) {
+      removeChild(currChild);
+      childrenMap.delete(currKey);
+      currChild = children.next().value;
+      currKey = getKey(currChild, i);
+    }
+    const key = getKey(child, i);
+    const origChild = childrenMap.get(key);
+    if (origChild) {
+      child = patch(parent, origChild, child);
+    }
+    if (currChild) {
+      if (currChild) {
+        const placeholder = document.createComment("");
+        insertChild(parent, placeholder, currChild);
+        replaces.push([placeholder, child]);
+      } else {
+        insertChild(parent, child, before);
+      }
+    } else {
+      insertChild(parent, child, before);
+    }
+    result.set(key, child);
+  }
+  replaces.forEach(([placeholder, child]) => replaceChild(parent, child, placeholder));
+  childrenMap.forEach((child, key) => {
+    if (child.isConnected && !result.has(key)) {
+      removeChild(child);
+    }
+  });
+  return result;
+}
+function patch(parent, node, next) {
+  if (node === next) {
+    return node;
+  }
+  if (isJsxElement(node) && isJsxElement(next) && node.template === next.template) {
+    next.inheritNode(node);
+    return next;
+  }
+  if (node instanceof Text && next instanceof Text) {
+    if (node.textContent !== next.textContent) {
+      node.textContent = next.textContent;
+    }
+    return node;
+  }
+  replaceChild(parent, next, node);
+  return next;
+}
+function mapKeys(children) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [i, child] of children.entries()) {
+    const key = getKey(child, i);
+    result.set(key, child);
+  }
+  return result;
+}
+function getKey(node, index) {
+  const id = node instanceof Element ? node.id : void 0;
+  const result = id === "" ? void 0 : id;
+  return result != null ? result : `_$${index}$`;
+}
+
+// src/template/template-node.ts
+var TemplateNode = class _TemplateNode {
+  constructor(template2, props, key) {
+    this.template = template2;
+    this.props = props;
+    this.key = key;
+    this.treeMap = /* @__PURE__ */ new Map();
+    this.mounted = false;
+    this.nodes = [];
+    this.provides = {};
+    this.trackMap = /* @__PURE__ */ new Map();
+    this.parent = null;
+  }
+  get firstChild() {
+    var _a;
+    return (_a = this.nodes[0]) != null ? _a : null;
+  }
+  get isConnected() {
+    return this.mounted;
+  }
+  addEventListener() {
+  }
+  removeEventListener() {
+  }
+  unmount() {
+    this.trackMap.forEach((track2) => {
+      var _a, _b;
+      (_a = track2.cleanup) == null ? void 0 : _a.call(track2);
+      (_b = track2.lastNodes) == null ? void 0 : _b.forEach((node) => {
+        if (track2.isRoot) {
+          removeChild(node);
+        } else if (node instanceof _TemplateNode) {
+          node.unmount();
+        }
+      });
+    });
+    this.trackMap.clear();
+    this.treeMap.clear();
+    this.nodes.forEach((node) => removeChild(node));
+    this.nodes = [];
+    this.mounted = false;
+  }
+  mount(parent, before) {
+    var _a;
+    this.parent = parent;
+    if (this.isConnected) {
+      this.nodes.forEach((node) => insertChild(parent, node, before));
+      return this.nodes;
+    }
+    const cloneNode = this.template.content.cloneNode(true);
+    const firstChild = cloneNode.firstChild;
+    if ((_a = firstChild == null ? void 0 : firstChild.hasAttribute) == null ? void 0 : _a.call(firstChild, "_svg_")) {
+      firstChild.remove();
+      firstChild == null ? void 0 : firstChild.childNodes.forEach((node) => {
+        cloneNode.append(node);
+      });
+    }
+    this.nodes = Array.from(cloneNode.childNodes);
+    this.mapNodeTree(parent, cloneNode);
+    insertChild(parent, cloneNode, before);
+    this.patchNodes(this.props);
+    this.mounted = true;
+    return this.nodes;
+  }
+  mapNodeTree(parent, tree) {
+    let index = 1;
+    this.treeMap.set(0, parent);
+    const walk = (node) => {
+      if (node.nodeType !== Node.DOCUMENT_FRAGMENT_NODE) {
+        this.treeMap.set(index++, node);
+      }
+      let child = node.firstChild;
+      while (child) {
+        walk(child);
+        child = child.nextSibling;
+      }
+    };
+    walk(tree);
+  }
+  patchNodes(props) {
+    for (const key in props) {
+      const index = Number(key);
+      const node = this.treeMap.get(index);
+      if (node) {
+        const value = this.props[key];
+        this.patchNode(key, node, value, index === 0);
+      }
+    }
+    this.props = props;
+  }
+  getNodeTrack(trackKey, trackLastNodes, isRoot) {
+    var _a;
+    let track2 = this.trackMap.get(trackKey);
+    if (!track2) {
+      track2 = { cleanup: () => {
+      } };
+      if (trackLastNodes) {
+        track2.lastNodes = /* @__PURE__ */ new Map();
+      }
+      if (isRoot) {
+        track2.isRoot = true;
+      }
+      this.trackMap.set(trackKey, track2);
+    }
+    (_a = track2.cleanup) == null ? void 0 : _a.call(track2);
+    return track2;
+  }
+  inheritNode(node) {
+    this.mounted = node.mounted;
+    this.nodes = node.nodes;
+    this.trackMap = node.trackMap;
+    this.treeMap = node.treeMap;
+    const props = this.props;
+    this.props = node.props;
+    this.patchNodes(props);
+  }
+  patchNode(key, node, props, isRoot) {
+    for (const attr in props) {
+      if (attr === "children" && props.children) {
+        if (!isArray(props.children)) {
+          const trackKey = `${key}:${attr}:${0}`;
+          const track2 = this.getNodeTrack(trackKey, true, isRoot);
+          patchChild(track2, node, props.children, null);
+        } else {
+          props.children.forEach(([child, path], index) => {
+            var _a;
+            const before = isNil(path) ? null : (_a = this.treeMap.get(path)) != null ? _a : null;
+            const trackKey = `${key}:${attr}:${index}`;
+            const track2 = this.getNodeTrack(trackKey, true, isRoot);
+            patchChild(track2, node, child, before);
+          });
+        }
+      } else if (attr === "ref") {
+        if (isFunction(props[attr])) {
+          props[attr](node);
+        } else {
+          props[attr] = node;
+        }
+      } else if (attr.indexOf("on") === 0) {
+        const eventName = attr.slice(2).toLocaleLowerCase();
+        const track2 = this.getNodeTrack(`${key}:${attr}`);
+        const listener = props[attr];
+        track2.cleanup = addEventListener(node, eventName, listener);
+      } else if (attr.indexOf("bind:") === 0) {
+        const bindKey = attr.slice(5).toLocaleLowerCase();
+        const val = props[attr];
+        const track2 = this.getNodeTrack(`${key}:${attr}`);
+        const triggerValue = isSignal(val) ? val : signal(val);
+        const cleanup = effect(() => {
+          triggerValue.value = val;
+          node[bindKey] = triggerValue.value;
+        });
+        const cleanupBind = binNode(node, (value) => {
+          props[`update:${bindKey}`](value);
+        });
+        track2.cleanup = () => {
+          cleanup == null ? void 0 : cleanup();
+          cleanupBind == null ? void 0 : cleanupBind();
+        };
+      } else if (attr.indexOf("update:") !== 0) {
+        const track2 = this.getNodeTrack(`${key}:${attr}`);
+        const val = props[attr];
+        const triggerValue = isSignal(val) ? val : signal(val);
+        const cleanup = effect(() => {
+          triggerValue.value = val;
+          patchAttribute(track2, node, attr, triggerValue.value);
+        });
+        track2.cleanup = () => {
+          cleanup == null ? void 0 : cleanup();
+        };
+      }
+    }
+  }
+};
+function patchAttribute(track2, node, attr, data) {
+  const element = node;
+  if (!element.setAttribute) {
+    return;
+  }
+  if (isFunction(data)) {
+    track2.cleanup = effect(() => {
+      setAttribute(element, attr, data());
+    });
+  } else {
+    setAttribute(element, attr, data);
+  }
+}
+function patchChild(track2, parent, child, before) {
+  if (isFunction(child)) {
+    track2.cleanup = effect(() => {
+      const nextNodes = coerceArray(child()).map(coerceNode);
+      track2.lastNodes = patchChildren(parent, track2.lastNodes, nextNodes, before);
+    });
+  } else {
+    coerceArray(child).forEach((node, i) => {
+      const newNode = coerceNode(node);
+      track2.lastNodes.set(String(i), newNode);
+      insertChild(parent, newNode, before);
+    });
+  }
+}
+
+// src/template/template.ts
+function h(template2, props, key) {
+  return isFunction(template2) ? new ComponentNode(template2, props, key) : new TemplateNode(template2, props, key);
+}
+function isJsxElement(node) {
+  return node instanceof ComponentNode || node instanceof TemplateNode;
+}
+function template(html) {
+  const template2 = document.createElement("template");
+  template2.innerHTML = html;
+  return template2;
+}
+function Fragment(props) {
+  return props.children;
+}
+
+// src/template/hooks.ts
+function onMount(cb) {
+  var _a;
+  throwIfOutsideComponent("onMounted");
+  (_a = ComponentNode.ref) == null ? void 0 : _a.addHook("mounted", cb);
+}
+function onDestroy(cb) {
+  var _a;
+  throwIfOutsideComponent("onDestroy");
+  (_a = ComponentNode.ref) == null ? void 0 : _a.addHook("destroy", cb);
+}
+function throwIfOutsideComponent(hook) {
+  if (!ComponentNode.ref) {
+    throw new Error(
+      `"${hook}" can only be called within the component function body
+      and cannot be used in asynchronous or deferred calls.`
+    );
+  }
+}
+function useProvide(key, value) {
+  var _a;
+  throwIfOutsideComponent("useProvide");
+  (_a = ComponentNode.ref) == null ? void 0 : _a.setContext(key, value);
+}
+function useInject(key, defaultValue) {
+  var _a;
+  throwIfOutsideComponent("useInject");
+  return ((_a = ComponentNode.ref) == null ? void 0 : _a.getContext(key)) || defaultValue;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Fragment,
+  computed,
+  createSignal,
+  createStore,
+  effect,
+  h,
+  isJsxElement,
+  nextTick,
+  onDestroy,
+  onMount,
+  signal,
+  signalObject,
+  template,
+  useInject,
+  useProvide
+});
+//# sourceMappingURL=index.dev.cjs.js.map