voby.js

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __reExport = (target, module, copyDefault, desc) => {
  if (module && typeof module === "object" || typeof module === "function") {
    for (let key of __getOwnPropNames(module))
      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
        __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
  }
  return target;
};
var __toESM = (module, isNodeMode) => {
  return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", !isNodeMode && module && module.__esModule ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
};

// node_modules/tiny-diff/dist/index.js
var require_dist = __commonJS({
  "node_modules/tiny-diff/dist/index.js"(exports, module) {
    "use strict";
    var diff2 = (parent, before, after, nextSibling) => {
      const bLength = after.length;
      let aEnd = before.length;
      let bEnd = bLength;
      let aStart = 0;
      let bStart = 0;
      let map = null;
      while (aStart < aEnd || bStart < bEnd) {
        if (aEnd === aStart) {
          const node = bEnd < bLength ? bStart ? after[bStart - 1].nextSibling : after[bEnd - bStart] : nextSibling;
          while (bStart < bEnd)
            parent.insertBefore(after[bStart++], node);
        } else if (bEnd === bStart) {
          while (aStart < aEnd) {
            if (!map || !map.has(before[aStart]))
              parent.removeChild(before[aStart]);
            aStart++;
          }
        } else if (before[aStart] === after[bStart]) {
          aStart++;
          bStart++;
        } else if (before[aEnd - 1] === after[bEnd - 1]) {
          aEnd--;
          bEnd--;
        } else if (before[aStart] === after[bEnd - 1] && after[bStart] === before[aEnd - 1]) {
          const node = before[--aEnd].nextSibling;
          parent.insertBefore(after[bStart++], before[aStart++].nextSibling);
          parent.insertBefore(after[--bEnd], node);
          before[aEnd] = after[bEnd];
        } else {
          if (!map) {
            map = /* @__PURE__ */ new Map();
            let i3 = bStart;
            while (i3 < bEnd)
              map.set(after[i3], i3++);
          }
          if (map.has(before[aStart])) {
            const index = map.get(before[aStart]);
            if (bStart < index && index < bEnd) {
              let i3 = aStart;
              let sequence = 1;
              while (++i3 < aEnd && i3 < bEnd && map.get(before[i3]) === index + sequence)
                sequence++;
              if (sequence > index - bStart) {
                const node = before[aStart];
                while (bStart < index)
                  parent.insertBefore(after[bStart++], node);
              } else {
                parent.replaceChild(after[bStart++], before[aStart++]);
              }
            } else
              aStart++;
          } else
            parent.removeChild(before[aStart++]);
        }
      }
    };
    module.exports = diff2;
    module.exports.default = diff2;
    Object.defineProperty(module.exports, "__esModule", { value: true });
  }
});

// node_modules/oby/dist/batch.js
var require_batch = __commonJS({
  "node_modules/oby/dist/batch.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var Batch = class {
      constructor() {
        this.level = 0;
        this.registerUpdate = (observable2, value) => {
          if (!this.queue)
            return;
          this.queue.set(observable2, value);
        };
        this.wrap = (fn) => {
          const queuePrev = this.queue;
          const queueNext = queuePrev || /* @__PURE__ */ new Map();
          this.level += 1;
          this.queue = queueNext;
          try {
            fn();
          } finally {
            this.level -= 1;
            this.queue = queuePrev;
            if (!this.level) {
              this.flush(queueNext);
            }
          }
        };
        this.flush = (queue) => {
          queue.forEach((value, observable2) => observable2.set(value));
        };
        this.has = () => {
          return !!this.queue;
        };
      }
    };
    exports.default = new Batch();
  }
});

// node_modules/oby/dist/constants.js
var require_constants = __commonJS({
  "node_modules/oby/dist/constants.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.SYMBOL = exports.NOOP = void 0;
    var NOOP = () => {
    };
    exports.NOOP = NOOP;
    var SYMBOL = Symbol("Observable");
    exports.SYMBOL = SYMBOL;
  }
});

// node_modules/oby/dist/callable.js
var require_callable = __commonJS({
  "node_modules/oby/dist/callable.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var constants_1 = require_constants();
    var callable = (() => {
      const self = function() {
        return this;
      };
      const traps = {
        get(target, property) {
          if (property === constants_1.SYMBOL)
            return true;
          const observable2 = target();
          return observable2[property].bind(observable2);
        },
        apply(target, thisArg, args) {
          if (!args.length)
            return target().get();
          return target().set(args[0]);
        }
      };
      return (observable2) => {
        return new Proxy(self.bind(observable2), traps);
      };
    })();
    exports.default = callable;
  }
});

// node_modules/oby/dist/utils.js
var require_utils = __commonJS({
  "node_modules/oby/dist/utils.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.isUndefined = exports.isSet = exports.isPrimitive = exports.isFunction = exports.isArray = exports.cloneDeep = void 0;
    var cloneDeep = (value) => {
      return JSON.parse(JSON.stringify(value));
    };
    exports.cloneDeep = cloneDeep;
    var { isArray } = Array;
    exports.isArray = isArray;
    var isFunction2 = (value) => {
      return typeof value === "function";
    };
    exports.isFunction = isFunction2;
    var isPrimitive = (value) => {
      if (value === null)
        return true;
      const type = typeof value;
      return type !== "object" && type !== "function";
    };
    exports.isPrimitive = isPrimitive;
    var isSet = (value) => {
      return value instanceof Set;
    };
    exports.isSet = isSet;
    var isUndefined = (value) => {
      return value === void 0;
    };
    exports.isUndefined = isUndefined;
  }
});

// node_modules/oby/dist/observer.js
var require_observer = __commonJS({
  "node_modules/oby/dist/observer.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var context_1 = require_context();
    var utils_1 = require_utils();
    var Observer = class {
      registerCleanup(cleanup) {
        if (!this.cleanups) {
          this.cleanups = cleanup;
        } else if ((0, utils_1.isArray)(this.cleanups)) {
          this.cleanups.push(cleanup);
        } else {
          this.cleanups = [this.cleanups, cleanup];
        }
      }
      registerError(error) {
        if (!this.errors) {
          this.errors = error;
        } else if ((0, utils_1.isArray)(this.errors)) {
          this.errors.push(error);
        } else {
          this.errors = [this.errors, error];
        }
      }
      registerObservable(observable2) {
        if (!this.observables) {
          this.observables = observable2;
        } else if ((0, utils_1.isArray)(this.observables)) {
          this.observables.push(observable2);
        } else {
          this.observables = [this.observables, observable2];
        }
      }
      registerObserver(observer) {
        if (!this.observers) {
          this.observers = observer;
        } else if ((0, utils_1.isArray)(this.observers)) {
          this.observers.push(observer);
        } else {
          this.observers = [this.observers, observer];
        }
      }
      registerParent(observer) {
        this.parent = observer;
      }
      registerSelf() {
        if (!this.observables) {
          return;
        } else if ((0, utils_1.isArray)(this.observables)) {
          context_1.default.registerObservables(this.observables);
        } else {
          context_1.default.registerObservable(this.observables);
        }
      }
      unregisterObserver(observer) {
        if (!this.observers) {
          return;
        } else if ((0, utils_1.isArray)(this.observers)) {
          const index = this.observers.indexOf(observer);
          if (index >= 0) {
            this.observers.splice(index, 1);
          }
        } else {
          if (this.observers === observer) {
            delete this.observers;
          }
        }
      }
      unregisterParent() {
        delete this.parent;
      }
      update() {
        delete this.dirty;
      }
      updateError(error, silent) {
        const { errors, parent } = this;
        if (errors) {
          if ((0, utils_1.isArray)(errors)) {
            errors.forEach((fn) => fn(error));
          } else {
            errors(error);
          }
          return true;
        } else {
          if (parent) {
            if (parent.updateError(error, true))
              return true;
          }
          if (!silent) {
            throw error;
          }
          return false;
        }
      }
      static unsubscribe(observer) {
        const { observers, observables, cleanups, errors } = observer;
        if (observers) {
          if ((0, utils_1.isArray)(observers)) {
            for (let i3 = 0, l2 = observers.length; i3 < l2; i3++) {
              Observer.unsubscribe(observers[i3]);
            }
            observers.length = 0;
          } else {
            Observer.unsubscribe(observers);
            delete observer.observers;
          }
        }
        if (observables) {
          if ((0, utils_1.isArray)(observables)) {
            for (let i3 = 0, l2 = observables.length; i3 < l2; i3++) {
              observables[i3].unregisterObserver(observer);
            }
            observables.length = 0;
          } else {
            observables.unregisterObserver(observer);
            delete observer.observables;
          }
        }
        if (cleanups) {
          if ((0, utils_1.isArray)(cleanups)) {
            for (let i3 = 0, l2 = cleanups.length; i3 < l2; i3++) {
              cleanups[i3]();
            }
            cleanups.length = 0;
          } else {
            cleanups();
            delete observer.cleanups;
          }
        }
        if (errors) {
          if ((0, utils_1.isArray)(errors)) {
            errors.length = 0;
          } else {
            delete observer.errors;
          }
        }
      }
    };
    exports.default = Observer;
  }
});

// node_modules/oby/dist/context.js
var require_context = __commonJS({
  "node_modules/oby/dist/context.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var constants_1 = require_constants();
    var observer_1 = require_observer();
    var Context = class {
      constructor() {
        this.sampling = false;
        this.registerCleanup = (cleanup) => {
          if (!this.observer)
            return;
          this.observer.registerCleanup(cleanup);
        };
        this.registerError = (error) => {
          if (!this.observer)
            return;
          this.observer.registerError(error);
        };
        this.registerObservable = (observable2) => {
          if (!this.observer)
            return;
          if (this.sampling)
            return;
          if (observable2.hasObserver(this.observer))
            return;
          this.observer.registerObservable(observable2);
          observable2.registerObserver(this.observer);
        };
        this.registerObservables = (observables) => {
          if (!this.observer)
            return;
          if (this.sampling)
            return;
          observables.forEach(this.registerObservable);
        };
        this.registerObserver = (observer) => {
          if (!this.observer)
            return;
          this.observer.registerObserver(observer);
          observer.registerParent(this.observer);
        };
        this.unregisterObserver = (observer) => {
          if (!this.observer)
            return;
          this.observer.unregisterObserver(observer);
          observer.unregisterParent();
        };
        this.wrap = (fn) => {
          const observer = new observer_1.default();
          try {
            return this.wrapWith(fn, observer, true);
          } catch (error) {
            observer.updateError(error);
          }
        };
        this.wrapVoid = (fn) => {
          this.wrap(fn);
        };
        this.wrapWith = (fn, observer, disposable, sampling) => {
          const observerPrev = this.observer;
          const samplingPrev = this.sampling;
          this.observer = observer;
          this.sampling = !!sampling;
          try {
            const dispose = observer && disposable ? () => this.dispose(observer) : constants_1.NOOP;
            return fn(dispose);
          } finally {
            this.observer = observerPrev;
            this.sampling = samplingPrev;
          }
        };
        this.wrapWithout = (fn) => {
          return this.wrapWith(fn);
        };
        this.wrapWithSampling = (fn) => {
          return this.wrapWith(fn, this.observer, false, true);
        };
        this.dispose = (observer) => {
          observer_1.default.unsubscribe(observer);
          this.observer = void 0;
        };
      }
    };
    exports.default = new Context();
  }
});

// node_modules/oby/dist/observable.js
var require_observable = __commonJS({
  "node_modules/oby/dist/observable.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var batch_1 = require_batch();
    var computed_1 = require_computed();
    var context_1 = require_context();
    var utils_1 = require_utils();
    var Observable = class {
      constructor(value, options, parent) {
        this.value = value;
        if (options) {
          if (options.comparator) {
            this.comparator = options.comparator;
          }
        }
        if (parent) {
          this.parent = parent;
        }
      }
      hasObserver(observer) {
        if (!this.observers) {
          return false;
        } else if ((0, utils_1.isSet)(this.observers)) {
          return this.observers.has(observer);
        } else {
          return this.observers === observer;
        }
      }
      registerObserver(observer) {
        if (!this.observers) {
          this.observers = observer;
        } else if ((0, utils_1.isSet)(this.observers)) {
          this.observers.add(observer);
        } else if (this.observers === observer) {
          return;
        } else {
          this.observers = /* @__PURE__ */ new Set([this.observers, observer]);
        }
      }
      unregisterObserver(observer) {
        if (!this.observers) {
          return;
        } else if ((0, utils_1.isSet)(this.observers)) {
          this.observers.delete(observer);
        } else if (this.observers === observer) {
          this.observers = void 0;
        }
      }
      registerSelf() {
        if (this.parent) {
          if (!this.parent.dirty) {
            this.parent.registerSelf();
          } else {
            this.parent.update();
          }
        } else {
          context_1.default.registerObservable(this);
        }
      }
      get() {
        this.registerSelf();
        return this.value;
      }
      sample() {
        return this.value;
      }
      set(value) {
        if (Observable.compare(value, this.value, this.comparator)) {
          return this.value;
        }
        if (batch_1.default.has()) {
          batch_1.default.registerUpdate(this, value);
          return value;
        } else {
          this.value = value;
          this.emit();
          return value;
        }
      }
      produce(fn) {
        const isValuePrimitive = (0, utils_1.isPrimitive)(this.value);
        const valueClone = isValuePrimitive ? this.value : (0, utils_1.cloneDeep)(this.value);
        const valueResult = fn(valueClone);
        const valueNext = isValuePrimitive || !(0, utils_1.isUndefined)(valueResult) ? valueResult : valueClone;
        return this.set(valueNext);
      }
      update(fn) {
        const valueNext = fn(this.value);
        return this.set(valueNext);
      }
      emit() {
        const { observers } = this;
        if (!observers)
          return;
        if ((0, utils_1.isSet)(observers) && !observers.size)
          return;
        context_1.default.wrapWithout(() => {
          if ((0, utils_1.isSet)(observers)) {
            const queue = Array.from(observers.values());
            for (let i3 = 0, l2 = queue.length; i3 < l2; i3++) {
              const observer = queue[i3];
              observer.dirty = true;
            }
            for (let i3 = 0, l2 = queue.length; i3 < l2; i3++) {
              const observer = queue[i3];
              if (!observer.dirty)
                continue;
              if (!observers.has(observer))
                continue;
              observer.update();
            }
          } else {
            observers.update();
          }
        });
      }
      on(fn, options, dependencies) {
        if ((0, utils_1.isArray)(options))
          return this.on(fn, void 0, options);
        const observable2 = computed_1.default.wrap(() => {
          this.get();
          if (dependencies)
            dependencies.forEach((observable3) => observable3());
          return context_1.default.wrapWithSampling(() => fn(this.value));
        }, void 0, options);
        return observable2;
      }
      static compare(value, valuePrev, comparator = Object.is) {
        return comparator(value, valuePrev);
      }
    };
    exports.default = Observable;
  }
});

// node_modules/oby/dist/computed.js
var require_computed = __commonJS({
  "node_modules/oby/dist/computed.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var callable_1 = require_callable();
    var context_1 = require_context();
    var observable_1 = require_observable();
    var observer_1 = require_observer();
    var Computed = class extends observer_1.default {
      constructor(fn, valueInitial, options) {
        super();
        this.fn = fn;
        this.observable = new observable_1.default(valueInitial, options, this);
        this.update();
      }
      update() {
        context_1.default.registerObserver(this);
        observer_1.default.unsubscribe(this);
        delete this.dirty;
        const valuePrev = this.observable.sample();
        try {
          const valueNext = context_1.default.wrapWith(() => this.fn(valuePrev), this, true);
          this.observable.set(valueNext);
        } catch (error) {
          this.updateError(error);
        }
      }
      static wrap(fn, value, options) {
        return (0, callable_1.default)(new Computed(fn, value, options).observable);
      }
    };
    exports.default = Computed;
  }
});

// node_modules/oby/dist/disposed.js
var require_disposed = __commonJS({
  "node_modules/oby/dist/disposed.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var _1 = require_dist2();
    var context_1 = require_context();
    var disposed = () => {
      const value = (0, _1.default)(false);
      context_1.default.registerCleanup(() => {
        value(true);
      });
      return value;
    };
    exports.default = disposed;
  }
});

// node_modules/oby/dist/effect.js
var require_effect = __commonJS({
  "node_modules/oby/dist/effect.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var context_1 = require_context();
    var observer_1 = require_observer();
    var utils_1 = require_utils();
    var Effect = class extends observer_1.default {
      constructor(fn) {
        super();
        this.fn = fn;
        this.update();
      }
      isDisposable() {
        const { observers, observables, cleanups } = this;
        if (observers) {
          if ((0, utils_1.isArray)(observers)) {
            if (observers.length) {
              return false;
            }
          } else {
            return false;
          }
        }
        if (observables) {
          if ((0, utils_1.isArray)(observables)) {
            if (observables.length) {
              return false;
            }
          } else {
            return false;
          }
        }
        if (cleanups) {
          if ((0, utils_1.isArray)(cleanups)) {
            if (cleanups.length) {
              return false;
            }
          } else {
            return false;
          }
        }
        return true;
      }
      update() {
        context_1.default.registerObserver(this);
        observer_1.default.unsubscribe(this);
        delete this.dirty;
        try {
          const cleanup = context_1.default.wrapWith(() => this.fn(), this, false);
          if (cleanup) {
            this.registerCleanup(cleanup);
          } else {
            if (this.isDisposable()) {
              context_1.default.unregisterObserver(this);
              observer_1.default.unsubscribe(this);
            }
          }
        } catch (error) {
          this.updateError(error);
        }
      }
      static wrap(fn) {
        new Effect(fn);
      }
    };
    exports.default = Effect;
  }
});

// node_modules/oby/dist/from.js
var require_from = __commonJS({
  "node_modules/oby/dist/from.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var _1 = require_dist2();
    var effect_1 = require_effect();
    var from = (fn, options) => {
      const value = (0, _1.default)(void 0, options);
      effect_1.default.wrap(() => fn(value));
      return value;
    };
    exports.default = from;
  }
});

// node_modules/oby/dist/is.js
var require_is = __commonJS({
  "node_modules/oby/dist/is.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var constants_1 = require_constants();
    var utils_1 = require_utils();
    var is = (value) => {
      return (0, utils_1.isFunction)(value) && !!value[constants_1.SYMBOL];
    };
    exports.default = is;
  }
});

// node_modules/oby/dist/get.js
var require_get = __commonJS({
  "node_modules/oby/dist/get.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var is_1 = require_is();
    var get = (value) => {
      if ((0, is_1.default)(value))
        return get(value());
      return value;
    };
    exports.default = get;
  }
});

// node_modules/oby/dist/index.js
var require_dist2 = __commonJS({
  "node_modules/oby/dist/index.js"(exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var batch_1 = require_batch();
    var callable_1 = require_callable();
    var computed_1 = require_computed();
    var context_1 = require_context();
    var disposed_1 = require_disposed();
    var effect_1 = require_effect();
    var from_1 = require_from();
    var get_1 = require_get();
    var is_1 = require_is();
    var observable_1 = require_observable();
    function observable2(value, options) {
      return (0, callable_1.default)(new observable_1.default(value, options));
    }
    observable2.batch = batch_1.default.wrap;
    observable2.cleanup = context_1.default.registerCleanup;
    observable2.computed = computed_1.default.wrap;
    observable2.disposed = disposed_1.default;
    observable2.effect = effect_1.default.wrap;
    observable2.error = context_1.default.registerError;
    observable2.from = from_1.default;
    observable2.get = get_1.default;
    observable2.is = is_1.default;
    observable2.root = context_1.default.wrapVoid;
    observable2.sample = context_1.default.wrapWithSampling;
    exports.default = observable2;
  }
});

// src/components/component.ts
var Component = class {
  constructor(props) {
    this.props = props;
  }
  render() {
    throw new Error("Missing render function");
  }
};
var component_default = Component;

// src/utils/lang.ts
var { assign } = Object;
var castError = (exception) => {
  if (isError(exception))
    return exception;
  if (isString(exception))
    return new Error(exception);
  return new Error("Unknown error");
};
var flatten = (() => {
  const { isArray } = Array;
  return (arr) => {
    for (let i3 = 0, l2 = arr.length; i3 < l2; i3++) {
      if (!isArray(arr[i3]))
        continue;
      return arr.flat(Infinity);
    }
    return arr;
  };
})();
var indexOf = (() => {
  const _indexOf = Array.prototype.indexOf;
  return (arr, value) => {
    return _indexOf.call(arr, value);
  };
})();
var isError = (value) => {
  return value instanceof Error;
};
var isFunction = (value) => {
  return typeof value === "function";
};
var isNil = (value) => {
  return value === null || value === void 0;
};
var isNode = (value) => {
  return value instanceof Node;
};
var isString = (value) => {
  return typeof value === "string";
};

// src/utils/setters.ts
var import_tiny_diff = __toESM(require_dist());

// src/template.ts
var SYMBOL_ACCESSOR = Symbol();
var template = (fn) => {
  const safePropertyRe = /^[a-z0-9-_]+$/i;
  const checkValidProperty = (property) => {
    if (isString(property) && safePropertyRe.test(property))
      return true;
    throw new Error(`Invalid property, only alphanumeric properties are allowed inside templates, received: "${property}"`);
  };
  const makeAccessor = (actionsWithNodes) => {
    return new Proxy({}, {
      get(target, key) {
        checkValidProperty(key);
        const accessor = (node, prop, targetNode) => {
          checkValidProperty(prop);
          actionsWithNodes.push([node, prop, key, targetNode]);
        };
        accessor[SYMBOL_ACCESSOR] = true;
        return accessor;
      }
    });
  };
  const makeActionsWithNodesAndTemplate = () => {
    const actionsWithNodes = [];
    const accessor = makeAccessor(actionsWithNodes);
    const component = fn(accessor);
    if (isFunction(component)) {
      const template2 = component();
      if (template2 instanceof HTMLElement) {
        return { actionsWithNodes, template: template2 };
      }
    }
    throw new Error("Invalid template, it must return a function that returns an HTMLElement");
  };
  const makeActionsWithPaths = (actionsWithNodes) => {
    const actionsWithPaths = [];
    for (let i3 = 0, l2 = actionsWithNodes.length; i3 < l2; i3++) {
      const [node, prop, key, targetNode] = actionsWithNodes[i3];
      const nodePath = makeNodePath(node);
      const targetNodePath = targetNode ? makeNodePath(targetNode) : void 0;
      actionsWithPaths.push([nodePath, prop, key, targetNodePath]);
    }
    return actionsWithPaths;
  };
  const makeNodePath = (() => {
    let prevNode = null;
    let prevPath;
    return (node) => {
      if (node === prevNode)
        return prevPath;
      const path = [];
      let child = node;
      let parent = child.parentNode;
      while (parent) {
        const index = !child.previousSibling ? 0 : !child.nextSibling ? -0 : indexOf(parent.childNodes, child);
        path.push(index);
        child = parent;
        parent = parent.parentNode;
      }
      prevNode = node;
      prevPath = path;
      return path;
    };
  })();
  const makeReviverActions = (actionsWithPaths) => {
    const actions = [];
    for (let i3 = 0, l2 = actionsWithPaths.length; i3 < l2; i3++) {
      const [nodePath, prop, key, targetNodePath] = actionsWithPaths[i3];
      if (targetNodePath) {
        if (targetNodePath.length) {
          actions.push(`this.setChildReplacement ( props["${key}"], root${targetNodePath.slice().reverse().map((index) => Object.is(0, index) ? ".firstChild" : Object.is(-0, index) ? ".lastChild" : `.firstChild${".nextSibling".repeat(index)}`).join("")} );`);
        } else {
          actions.push(`this.setChildReplacement ( props["${key}"], root );`);
        }
      } else {
        if (nodePath.length) {
          actions.push(`this.setProp ( root${nodePath.slice().reverse().map((index) => Object.is(0, index) ? ".firstChild" : Object.is(-0, index) ? ".lastChild" : `.firstChild${".nextSibling".repeat(index)}`).join("")}, "${prop}", props["${key}"] );`);
        } else {
          actions.push(`this.setProp ( root, "${prop}", props["${key}"] );`);
        }
      }
    }
    return actions;
  };
  const makeReviver = (actionsWithPaths) => {
    const actions = makeReviverActions(actionsWithPaths);
    const fn2 = new Function("root", "props", `${actions.join("")}return root;`);
    const apis = { setChildReplacement, setProp };
    return fn2.bind(apis);
  };
  const makeComponent = () => {
    const { actionsWithNodes, template: template2 } = makeActionsWithNodesAndTemplate();
    const actionsWithPaths = makeActionsWithPaths(actionsWithNodes);
    const reviver = makeReviver(actionsWithPaths);
    return (props) => {
      return () => {
        const root = template2.cloneNode(true);
        return reviver(root, props);
      };
    };
  };
  return makeComponent();
};
template.isAccessor = (value) => {
  return isFunction(value) && value.hasOwnProperty(SYMBOL_ACCESSOR);
};
var template_default = template;

// src/observable.ts
var import_oby = __toESM(require_dist2());
var $ = import_oby.default;
var $$ = import_oby.default.get;

// src/hooks/use_effect.ts
var useEffect = $.effect;
var use_effect_default = useEffect;

// src/is_observable.ts
var isObservable = $.is;
var is_observable_default = isObservable;

// src/sample.ts
var sample = $.sample;
var sample_default = sample;

// src/utils/resolvers.ts
var resolveAbstract = (value, setter, isResolvable) => {
  if (isResolvable(value)) {
    let valuePrev;
    use_effect_default(() => {
      const valueNext = value();
      if (isResolvable(valueNext)) {
        resolveAbstract(valueNext, setter, isResolvable);
      } else {
        setter(valueNext, valuePrev);
        valuePrev = valueNext;
      }
    });
  } else {
    setter(value);
  }
};
var resolveChild = (value, setter) => {
  if (is_observable_default(value)) {
    use_effect_default(() => {
      const valueNext = value();
      if (isFunction(valueNext)) {
        resolveChild(valueNext, setter);
      } else {
        setter(valueNext);
      }
    });
  } else if (isFunction(value)) {
    resolveChild(sample_default(value), setter);
  } else {
    setter(value);
  }
};
var resolveChildDeep = (child) => {
  while (isFunction(child)) {
    child = child();
  }
  if (Array.isArray(child)) {
    const childResolved = new Array(child.length);
    for (let i3 = 0, l2 = child.length; i3 < l2; i3++) {
      childResolved[i3] = resolveChildDeep(child[i3]);
    }
    return childResolved;
  }
  return child;
};
var resolveFunction = (value, setter) => {
  return resolveAbstract(value, setter, isFunction);
};
var resolveObservable = (value, setter) => {
  return resolveAbstract(value, setter, is_observable_default);
};

// src/utils/setters.ts
var setAttributeStatic = (attributes, key, value) => {
  const attribute = attributes.getNamedItem(key);
  if (isNil(value) || value === false) {
    if (attribute) {
      attributes.removeNamedItem(key);
    }
  } else {
    value = value === true ? "" : String(value);
    if (attribute) {
      if (attribute.value !== value) {
        attribute.value = value;
      }
    } else {
      const attribute2 = document.createAttribute(key);
      attribute2.value = value;
      attributes.setNamedItem(attribute2);
    }
  }
};
var setAttribute = (element, key, value) => {
  const { attributes } = element;
  resolveFunction(value, (value2) => {
    setAttributeStatic(attributes, key, value2);
  });
};
var setChildReplacement = (child, childPrev) => {
  const type = typeof child;
  if (type === "string" || type === "number" || type === "bigint") {
    const value = String(child);
    if (childPrev.nodeType === 3) {
      if (childPrev.nodeValue !== value) {
        childPrev.nodeValue = value;
      }
      return [childPrev];
    } else {
      const parent = childPrev.parentElement;
      if (!parent)
        throw new Error("Invalid child replacement");
      const textNode = new Text(value);
      parent.replaceChild(textNode, childPrev);
      return [textNode];
    }
  } else {
    const parent = childPrev.parentElement;
    if (!parent)
      throw new Error("Invalid child replacement");
    return setChild(parent, child, [childPrev]);
  }
};
var setChildStatic = (parent, child, childrenPrev) => {
  const childrenPrevLength = childrenPrev.length;
  if (childrenPrevLength === 0) {
    const type = typeof child;
    if (type === "string" || type === "number" || type === "bigint") {
      const textNode = new Text(String(child));
      parent.appendChild(textNode);
      return [textNode];
    } else if (type === "object" && child !== null && typeof child.nodeType === "number") {
      const node = child;
      parent.insertBefore(node, null);
      return [node];
    }
  }
  if (childrenPrevLength === 1) {
    const type = typeof child;
    if (type === "string" || type === "number" || type === "bigint") {
      return setChildReplacement(child, childrenPrev[0]);
    }
  }
  const childrenNext = [];
  const childrenNextSibling = childrenPrev[childrenPrevLength - 1]?.nextSibling || null;
  const children = Array.isArray(child) ? flatten(child) : [child];
  for (let i3 = 0, l2 = children.length; i3 < l2; i3++) {
    const child2 = children[i3];
    const type = typeof child2;
    if (type === "string" || type === "number" || type === "bigint") {
      childrenNext.push(new Text(String(child2)));
    } else if (type === "object" && child2 !== null && typeof child2.nodeType === "number") {
      childrenNext.push(child2);
    } else if (type === "function") {
      let prev = [];
      resolveChild(child2, (child3) => {
        const prevLength = prev.length;
        const prevStart = prev[0];
        prev = setChildStatic(parent, child3, prev);
        const prevStartIndex = prevStart ? childrenNext.indexOf(prevStart) : childrenNext.length;
        childrenNext.splice(prevStartIndex, prevLength, ...prev);
      });
    }
  }
  if (!childrenNext.length && childrenPrevLength === 1 && childrenPrev[0].nodeType === 8) {
    return childrenPrev;
  }
  if (!childrenNext.length && parent.childNodes.length === childrenPrevLength) {
    parent.textContent = "";
    childrenPrev = [];
  }
  if (!childrenNext.length) {
    childrenNext[0] = new Comment();
  }
  (0, import_tiny_diff.default)(parent, childrenPrev, childrenNext, childrenNextSibling);
  return childrenNext;
};
var setChild = (parent, child, childPrev = []) => {
  resolveChild(child, (child2) => {
    childPrev = setChildStatic(parent, child2, childPrev);
  });
  return childPrev;
};
var setClassStatic = (classList, key, value) => {
  classList.toggle(key, !!value);
};
var setClass = (classList, key, value) => {
  resolveFunction(value, (value2) => {
    setClassStatic(classList, key, value2);
  });
};
var setClassesStatic = (element, classList, object, objectPrev) => {
  if (isString(object)) {
    if (element.className !== object) {
      element.className = object;
    }
  } else {
    if (objectPrev) {
      if (isString(objectPrev)) {
        if (objectPrev) {
          element.className = "";
        }
      } else {
        for (const key in objectPrev) {
          if (object && key in object)
            continue;
          setClass(classList, key, false);
        }
      }
    }
    for (const key in object) {
      setClass(classList, key, object[key]);
    }
  }
};
var setClasses = (element, object) => {
  const { classList } = element;
  resolveFunction(object, (object2, objectPrev) => {
    setClassesStatic(element, classList, object2, objectPrev);
  });
};
var setEventStatic = (() => {
  const delegatedEvents = {
    onbeforeinput: "_onbeforeinput",
    onclick: "_onclick",
    ondblclick: "_ondblclick",
    onfocusin: "_onfocusin",
    onfocusout: "_onfocusout",
    oninput: "_oninput",
    onkeydown: "_onkeydown",
    onkeyup: "_onkeyup",
    onmousedown: "_onmousedown",
    onmouseup: "_onmouseup"
  };
  const delegatedEventsListening = {};
  const delegate = (event) => {
    const key = delegatedEvents[event];
    document[event] = (event2) => {
      const targets = event2.composedPath();
      const target = targets[0] || document;
      Object.defineProperty(event2, "currentTarget", {
        configurable: true,
        get() {
          return target;
        }
      });
      for (let i3 = 0, l2 = targets.length; i3 < l2; i3++) {
        const handler = targets[i3][key];
        if (!handler)
          continue;
        handler(event2);
        if (event2.cancelBubble)
          break;
      }
    };
  };
  return (element, event, value) => {
    if (event.endsWith("capture")) {
      const type = event.slice(2, -7);
      const key = `_${event}`;
      const valuePrev = element[key];
      if (valuePrev)
        element.removeEventListener(type, valuePrev, { capture: true });
      if (value)
        element.addEventListener(type, value, { capture: true });
      element[key] = value;
    } else if (event in delegatedEvents) {
      if (!(event in delegatedEventsListening)) {
        delegatedEventsListening[event] = true;
        delegate(event);
      }
      element[delegatedEvents[event]] = value;
    } else {
      element[event] = value;
    }
  };
})();
var setEvent = (element, event, value) => {
  resolveObservable(value, (value2) => {
    setEventStatic(element, event, value2);
  });
};
var setHTMLStatic = (element, value) => {
  element.innerHTML = String(value ?? "");
};
var setHTML = (element, value) => {
  resolveFunction(value, (value2) => {
    resolveFunction(value2.__html, (html) => {
      setHTMLStatic(element, html);
    });
  });
};
var setPropertyStatic = (element, key, value) => {
  if (key === "className") {
    const className = String(value ?? "");
    if (element.className !== className) {
      element.className = className;
    }
  } else {
    if (element[key] !== value) {
      element[key] = value;
    }
  }
};
var setProperty = (element, key, value) => {
  resolveFunction(value, (value2) => {
    setPropertyStatic(element, key, value2);
  });
};
var setRef = (element, value) => {
  if (!isFunction(value))
    throw new Error("Invalid ref");
  queueMicrotask(() => {
    value(element);
  });
};
var setStyleStatic = (() => {
  const propertyNonDimensionalRe = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;
  return (style, key, value) => {
    if (key.charCodeAt(0) === 45) {
      style.setProperty(key, String(value));
    } else if (isNil(value)) {
      style[key] = null;
    } else {
      value = isString(value) || propertyNonDimensionalRe.test(key) ? value : `${value}px`;
      if (style[key] !== value) {
        style[key] = value;
      }
    }
  };
})();
var setStyle = (style, key, value) => {
  resolveFunction(value, (value2) => {
    setStyleStatic(style, key, value2);
  });
};
var setStylesStatic = (style, object, objectPrev) => {
  if (isString(object)) {
    if (style.cssText !== object) {
      style.cssText = object;
    }
  } else {
    if (objectPrev) {
      if (isString(objectPrev)) {
        if (objectPrev) {
          style.cssText = "";
        }
      } else {
        for (const key in objectPrev) {
          if (object && key in object)
            continue;
          setStyleStatic(style, key, null);
        }
      }
    }
    for (const key in object) {
      setStyle(style, key, object[key]);
    }
  }
};
var setStyles = (element, object) => {
  const { style } = element;
  resolveFunction(object, (object2, objectPrev) => {
    setStylesStatic(style, object2, objectPrev);
  });
};
var setTemplateAccessor = (element, key, value) => {
  if (key === "children") {
    const placeholder = new Text();
    element.insertBefore(placeholder, null);
    value(element, "child", placeholder);
  } else {
    value(element, key);
  }
};
var setProp = (element, key, value) => {
  if (template_default.isAccessor(value)) {
    setTemplateAccessor(element, key, value);
  } else if (key === "children") {
    setChild(element, value);
  } else if (key === "ref") {
    setRef(element, value);
  } else if (key === "style") {
    setStyles(element, value);
  } else if (key === "class") {
    setClasses(element, value);
  } else if (key === "innerHTML" || key === "outerHTML" || key === "textContent") {
  } else if (key === "dangerouslySetInnerHTML") {
    setHTML(element, value);
  } else if (key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110) {
    setEvent(element, key.toLowerCase(), value);
  } else if (key in element) {
    setProperty(element, key, value);
  } else {
    setAttribute(element, key, value);
  }
};
var setProps = (element, object) => {
  for (const key in object) {
    setProp(element, key, object[key]);
  }
};

// src/create_element.ts
function createElement(component, props, ..._children) {
  const { children: __children, key, ref, ...rest } = props || {};
  const children = _children.length === 1 ? _children[0] : _children.length === 0 ? __children : _children;
  if (!isNil(rest.className) && isString(rest.class)) {
    throw new Error("Invalid class prop, it can only be null, undefined or an object when className is provided too");
  }
  if (isFunction(component)) {
    if (component_default.isPrototypeOf(component)) {
      const props2 = rest;
      if (!isNil(children))
        props2.children = children;
      return () => {
        const instance = new component(props2);
        const child = instance.render();
        if (!isNil(ref))
          setRef(instance, ref);
        return child;
      };
    } else {
      const props2 = rest;
      if (!isNil(children))
        props2.children = children;
      if (!isNil(ref))
        props2.ref = ref;
      return () => {
        return component(props2);
      };
    }
  } else if (isString(component)) {
    const props2 = rest;
    if (!isNil(children))
      props2.children = children;
    if (!isNil(ref))
      props2.ref = ref;
    return () => {
      const child = document.createElement(component);
      setProps(child, props2);
      return child;
    };
  } else if (isNode(component)) {
    return () => {
      return component;
    };
  } else {
    throw new Error("Invalid component");
  }
}
var create_element_default = createElement;

// src/hooks/use_computed.ts
var useComputed = $.computed;
var use_computed_default = useComputed;

// src/hooks/use_error.ts
var useError = $.error;
var use_error_default = useError;

// src/components/error_boundary.ts
var ErrorBoundary = ({ fallback, children }) => {
  const error = $(null);
  return use_computed_default(() => {
    if (error()) {
      const reset = () => error(null);
      const props = { error: error(), reset };
      return create_element_default(fallback, props);
    } else {
      use_error_default((err) => {
        error(castError(err));
      });
      return resolveChildDeep(children);
    }
  });
};
var error_boundary_default = ErrorBoundary;

// src/hooks/use_resolved.ts
function useResolved(value, callback) {
  if (callback) {
    if (isFunction(value)) {
      let valueFn = value;
      let valuePrev;
      let result;
      use_effect_default(() => {
        const valueNext = valueFn();
        if (isFunction(valueNext)) {
          result = useResolved(valueNext, callback);
        } else {
          result = callback(valueNext, valuePrev);
          valuePrev = valueNext;
        }
      });
      return result;
    } else {
      return callback(value);
    }
  } else {
    while (isFunction(value)) {
      value = value();
    }
    return value;
  }
}
var use_resolved_default = useResolved;

// src/hooks/use_cleanup.ts
var useCleanup = $.cleanup;
var use_cleanup_default = useCleanup;

// src/hooks/use_root.ts
var useRoot = $.root;
var use_root_default = useRoot;

// src/components/for.caches.ts
var Cache = class {
  constructor(component) {
    this.component = component;
    use_cleanup_default(() => this.dispose());
  }
  before() {
  }
  after() {
  }
  dispose() {
  }
  render(value) {
    return this.component(value);
  }
};
var CacheStatic = class extends Cache {
  constructor() {
    super(...arguments);
    this.cache = /* @__PURE__ */ new Map();
  }
  dispose() {
    for (const [, dispose] of this.cache.values()) {
      dispose();
    }
    this.cache.clear();
  }
  render(value) {
    const cached = this.cache.get(value);
    if (cached) {
      return cached[0];
    } else {
      let result;
      use_root_default((dispose) => {
        result = resolveChildDeep(this.component(value));
        this.cache.set(value, [result, dispose]);
      });
      return result;
    }
  }
};
var CacheDynamic = class extends CacheStatic {
  constructor() {
    super(...arguments);
    this.next = /* @__PURE__ */ new Map();
  }
  before() {
    this.next = /* @__PURE__ */ new Map();
  }
  after() {
    this.dispose();
    this.cache = this.next;
  }
  render(value) {
    const cached = this.cache.get(value);
    if (cached) {
      this.cache.delete(value);
      this.next.set(value, cached);
      return cached[0];
    } else {
      let result;
      use_root_default((dispose) => {
        result = resolveChildDeep(this.component(value));
        this.next.set(value, [result, dispose]);
      });
      return result;
    }
  }
};

// src/components/for.ts
var For = ({ Cache: Cache2, values, children }) => {
  Cache2 = Cache2 || For.CacheDynamic;
  const cache = new Cache2(children);
  return use_computed_default(() => {
    cache.before();
    const result = use_resolved_default(values).map((value) => cache.render(value));
    cache.after();
    return result;
  });
};
For.Cache = Cache;
For.CacheStatic = CacheStatic;
For.CacheDynamic = CacheDynamic;
var for_default = For;

// src/components/fragment.ts
var Fragment = ({ children }) => {
  return children;
};
var fragment_default = Fragment;

// src/components/if.ts
var If = ({ when, children }) => {
  if (isFunction(when)) {
    return use_computed_default(() => {
      if (use_resolved_default(when))
        return children;
    });
  } else {
    if (when)
      return children;
  }
};
var if_default = If;

// src/render.ts
var render = (child, parent) => {
  if (!parent)
    throw new Error("Invalid parent node");
  let disposeRoot;
  parent.textContent = "";
  use_root_default((dispose) => {
    disposeRoot = dispose;
    setChild(parent, child);
  });
  return () => {
    disposeRoot();
    parent.textContent = "";
  };
};
var render_default = render;

// src/components/portal.ts
var Portal = ({ mount, children }) => {
  const parent = mount || document.body;
  const portal = document.createElement("div");
  parent.insertBefore(portal, null);
  const dispose = render_default(children, portal);
  use_cleanup_default(() => {
    parent.removeChild(portal);
    dispose();
  });
  return assign(() => null, { metadata: { portal } });
};
var portal_default = Portal;

// src/components/switch.ts
var Switch = ({ when, children }) => {
  const items = children.map((child2) => child2());
  const child = (when2) => items.find((item) => item.metadata.default || item.metadata.when === when2);
  if (isFunction(when)) {
    return use_computed_default(() => {
      return child(use_resolved_default(when));
    });
  } else {
    return child(when);
  }
};
Switch.Case = ({ when, children }) => {
  return assign(() => children, { metadata: { when } });
};
Switch.Default = ({ children }) => {
  return assign(() => children, { metadata: { default: true } });
};
var switch_default = Switch;

// src/components/ternary.ts
var Ternary = ({ when, children }) => {
  if (isFunction(when)) {
    return use_computed_default(() => {
      if (use_resolved_default(when))
        return children[0];
      return children[1];
    });
  } else {
    if (when)
      return children[0];
    return children[1];
  }
};
var ternary_default = Ternary;

// src/hooks/use_abort_controller.ts
var useAbortController = (signals) => {
  const aborted = $(false);
  const aborter = new AbortController();
  const abort = () => {
    aborter.abort();
    aborted(true);
  };
  if (signals) {
    use_effect_default(() => {
      if (aborted())
        return;
      for (let i3 = 0, l2 = signals.length; i3 < l2; i3++) {
        if (signals[i3].aborted)
          return abort();
      }
      for (let i3 = 0, l2 = signals.length; i3 < l2; i3++) {
        signals[i3].addEventListener("abort", abort);
      }
      return () => {
        for (let i3 = 0, l2 = signals.length; i3 < l2; i3++) {
          signals[i3].removeEventListener("abort", abort);
        }
      };
    });
  }
  use_cleanup_default(abort);
  return aborter;
};
var use_abort_controller_default = useAbortController;

// src/hooks/use_scheduler.ts
var useScheduler = ({ cancel, schedule }) => {
  const id = sample_default(schedule);
  const dispose = () => sample_default(() => cancel(id));
  use_cleanup_default(dispose);
  return dispose;
};
var use_scheduler_default = useScheduler;

// src/hooks/use_animation_frame.ts
var useAnimationFrame = (callback) => {
  return use_scheduler_default({
    cancel: cancelAnimationFrame,
    schedule: () => requestAnimationFrame($$(callback))
  });
};
var use_animation_frame_default = useAnimationFrame;

// src/hooks/use_scheduler_loop.ts
var useSchedulerLoop = ({ cancel, schedule }) => {
  let id;
  const loop = () => id = sample_default(() => schedule(loop));
  const dispose = () => sample_default(() => cancel(id));
  loop();
  use_cleanup_default(dispose);
  return dispose;
};
var use_scheduler_loop_default = useSchedulerLoop;

// src/hooks/use_animation_loop.ts
var useAnimationLoop = (callback) => {
  return use_scheduler_loop_default({
    cancel: cancelAnimationFrame,
    schedule: (loop) => {
      const cb = $$(callback);
      return requestAnimationFrame((time) => {
        loop();
        cb(time);
      });
    }
  });
};
var use_animation_loop_default = useAnimationLoop;

// src/hooks/use_disposed.ts
var useDisposed = $.disposed;
var use_disposed_default = useDisposed;

// src/hooks/use_fetch.ts
var useFetch = (input, init) => {
  const state = $({ loading: true });
  use_effect_default(() => {
    const disposed = use_disposed_default();
    state({ loading: true });
    const onResolve = (response) => {
      if (disposed())
        return;
      state({ loading: false, response });
    };
    const onReject = (exception) => {
      if (disposed())
        return;
      const error = castError(exception);
      state({ loading: false, error });
    };
    const request = $$(input);
    const options = $$(init) || {};
    const signal = use_abort_controller_default(options.signal ? [options.signal] : void 0).signal;
    options.signal = signal;
    fetch(request, options).then(onResolve, onReject);
  });
  return state;
};
var use_fetch_default = useFetch;

// src/hooks/use_from.ts
var useFrom = $.from;
var use_from_default = useFrom;

// src/hooks/use_idle_callback.ts
var useIdleCallback = (callback, options) => {
  return use_scheduler_default({
    cancel: cancelIdleCallback,
    schedule: () => requestIdleCallback($$(callback), $$(options))
  });
};
var use_idle_callback_default = useIdleCallback;

// src/hooks/use_idle_loop.ts
var useIdleLoop = (callback, options) => {
  return use_scheduler_loop_default({
    cancel: cancelIdleCallback,
    schedule: (loop) => {
      const cb = $$(callback);
      const opts = $$(options);
      return requestIdleCallback((deadline) => {
        loop();
        cb(deadline);
      }, opts);
    }
  });
};
var use_idle_loop_default = useIdleLoop;

// src/hooks/use_interval.ts
var useInterval = (callback, ms) => {
  return use_scheduler_default({
    cancel: clearInterval,
    schedule: () => setInterval($$(callback), $$(ms))
  });
};
var use_interval_default = useInterval;

// src/hooks/use_promise.ts
var usePromise = (promise) => {
  const state = $({ loading: true });
  use_effect_default(() => {
    const disposed = use_disposed_default();
    state({ loading: true });
    const onResolve = (value) => {
      if (disposed())
        return;
      state({ loading: false, value });
    };
    const onReject = (exception) => {
      if (disposed())
        return;
      const error = castError(exception);
      state({ loading: false, error });
    };
    $$(promise).then(onResolve, onReject);
  });
  return state;
};
var use_promise_default = usePromise;

// src/hooks/use_timeout.ts
var useTimeout = (callback, ms) => {
  return use_scheduler_default({
    cancel: clearTimeout,
    schedule: () => setTimeout($$(callback), $$(ms))
  });
};
var use_timeout_default = useTimeout;

// src/batch.ts
var batch = $.batch;
var batch_default = batch;

// src/render_to_string.ts
var renderToString = (child, timeout = 1) => {
  return new Promise((resolve) => {
    use_root_default((dispose) => {
      const { portal } = portal_default({ children: child }).metadata;
      setTimeout(() => {
        resolve(portal.innerHTML);
        dispose();
      }, timeout);
    });
  });
};
var render_to_string_default = renderToString;

// node_modules/goober/dist/goober.modern.js
var e = { data: "" };
var t = (t2) => typeof window == "object" ? ((t2 ? t2.querySelector("#_goober") : window._goober) || Object.assign((t2 || document.head).appendChild(document.createElement("style")), { innerHTML: " ", id: "_goober" })).firstChild : t2 || e;
var l = /(?:([\u0080-\uFFFF\w-%@]+) *:? *([^{;]+?);|([^;}{]*?) *{)|(}\s*)/g;
var a = /\/\*[^]*?\*\/|\s\s+|\n/g;
var n = (e2, t2) => {
  let r2 = "", l2 = "", a2 = "";
  for (let o3 in e2) {
    let s2 = e2[o3];
    o3[0] == "@" ? o3[1] == "i" ? r2 = o3 + " " + s2 + ";" : l2 += o3[1] == "f" ? n(s2, o3) : o3 + "{" + n(s2, o3[1] == "k" ? "" : t2) + "}" : typeof s2 == "object" ? l2 += n(s2, t2 ? t2.replace(/([^,])+/g, (e3) => o3.replace(/(^:.*)|([^,])+/g, (t3) => /&/.test(t3) ? t3.replace(/&/g, e3) : e3 ? e3 + " " + t3 : t3)) : o3) : s2 != null && (o3 = /^--/.test(o3) ? o3 : o3.replace(/[A-Z]/g, "-$&").toLowerCase(), a2 += n.p ? n.p(o3, s2) : o3 + ":" + s2 + ";");
  }
  return r2 + (t2 && a2 ? t2 + "{" + a2 + "}" : a2) + l2;
};
var o = {};
var s = (e2) => {
  if (typeof e2 == "object") {
    let t2 = "";
    for (let r2 in e2)
      t2 += r2 + s(e2[r2]);
    return t2;
  }
  return e2;
};
var c = (e2, t2, r2, c2, i3) => {
  let u2 = s(e2), p2 = o[u2] || (o[u2] = ((e3) => {
    let t3 = 0, r3 = 11;
    for (; t3 < e3.length; )
      r3 = 101 * r3 + e3.charCodeAt(t3++) >>> 0;
    return "go" + r3;
  })(u2));
  if (!o[p2]) {
    let t3 = u2 !== e2 ? e2 : ((e3) => {
      let t4, r3 = [{}];
      for (; t4 = l.exec(e3.replace(a, "")); )
        t4[4] ? r3.shift() : t4[3] ? r3.unshift(r3[0][t4[3]] = r3[0][t4[3]] || {}) : r3[0][t4[1]] = t4[2];
      return r3[0];
    })(e2);
    o[p2] = n(i3 ? { ["@keyframes " + p2]: t3 } : t3, r2 ? "" : "." + p2);
  }
  return ((e3, t3, r3) => {
    t3.data.indexOf(e3) == -1 && (t3.data = r3 ? e3 + t3.data : t3.data + e3);
  })(o[p2], t2, c2), p2;
};
var i = (e2, t2, r2) => e2.reduce((e3, l2, a2) => {
  let o3 = t2[a2];
  if (o3 && o3.call) {
    let e4 = o3(r2), t3 = e4 && e4.props && e4.props.className || /^go/.test(e4) && e4;
    o3 = t3 ? "." + t3 : e4 && typeof e4 == "object" ? e4.props ? "" : n(e4, "") : e4 === false ? "" : e4;
  }
  return e3 + l2 + (o3 == null ? "" : o3);
}, "");
function u(e2) {
  let r2 = this || {}, l2 = e2.call ? e2(r2.p) : e2;
  return c(l2.unshift ? l2.raw ? i(l2, [].slice.call(arguments, 1), r2.p) : l2.reduce((e3, t2) => Object.assign(e3, t2 && t2.call ? t2(r2.p) : t2), {}) : l2, t(r2.target), r2.g, r2.o, r2.k);
}
var p;
var d;
var f;
var g = u.bind({ g: 1 });
var b = u.bind({ k: 1 });
function h(e2, t2, r2, l2) {
  n.p = t2, p = e2, d = r2, f = l2;
}
function m(e2, t2) {
  let r2 = this || {};
  return function() {
    let l2 = arguments;
    function a2(n3, o3) {
      let s2 = Object.assign({}, n3), c2 = s2.className || a2.className;
      r2.p = Object.assign({ theme: d && d() }, s2), r2.o = / *go\d+/.test(c2), s2.className = u.apply(r2, l2) + (c2 ? " " + c2 : ""), t2 && (s2.ref = o3);
      let i3 = e2;
      return e2[0] && (i3 = s2.as || e2, delete s2.as), f && i3[0] && f(s2), p(i3, s2);
    }
    return t2 ? t2(a2) : a2;
  };
}

// node_modules/goober/prefixer/dist/goober-autoprefixer.modern.js
var i2 = /* @__PURE__ */ new Map([["align-self", "-ms-grid-row-align"], ["color-adjust", "-webkit-print-color-adjust"], ["column-gap", "grid-column-gap"], ["gap", "grid-gap"], ["grid-template-columns", "-ms-grid-columns"], ["grid-template-rows", "-ms-grid-rows"], ["justify-self", "-ms-grid-column-align"], ["margin-inline-end", "-webkit-margin-end"], ["margin-inline-start", "-webkit-margin-start"], ["overflow-wrap", "word-wrap"], ["padding-inline-end", "-webkit-padding-end"], ["padding-inline-start", "-webkit-padding-start"], ["row-gap", "grid-row-gap"], ["scroll-margin-bottom", "scroll-snap-margin-bottom"], ["scroll-margin-left", "scroll-snap-margin-left"], ["scroll-margin-right", "scroll-snap-margin-right"], ["scroll-margin-top", "scroll-snap-margin-top"], ["scroll-margin", "scroll-snap-margin"], ["text-combine-upright", "-ms-text-combine-horizontal"]]);
function n2(n3, r2) {
  let t2 = "";
  const a2 = i2.get(n3);
  a2 && (t2 += `${a2}:${r2};`);
  const o3 = function(i3) {
    var n4 = /^(?:(text-(?:decoration$|e|or|si)|back(?:ground-cl|d|f)|box-d|(?:mask(?:$|-[ispro]|-cl)))|(tab-|column(?!-s)|text-align-l)|(ap)|(u|hy))/i.exec(i3);
    return n4 ? n4[1] ? 1 : n4[2] ? 2 : n4[3] ? 3 : 5 : 0;
  }(n3);
  1 & o3 && (t2 += `-webkit-${n3}:${r2};`), 2 & o3 && (t2 += `-moz-${n3}:${r2};`), 4 & o3 && (t2 += `-ms-${n3}:${r2};`);
  const l2 = function(i3, n4) {
    var r3 = /^(?:(pos)|(background-i)|((?:max-|min-)?(?:block-s|inl|he|widt))|(dis))/i.exec(i3);
    return r3 ? r3[1] ? /^sti/i.test(n4) ? 1 : 0 : r3[2] ? /^image-/i.test(n4) ? 1 : 0 : r3[3] ? n4[3] === "-" ? 2 : 0 : /^(inline-)?grid$/i.test(n4) ? 4 : 0 : 0;
  }(n3, r2);
  return 1 & l2 ? t2 += `${n3}:-webkit-${r2};` : 2 & l2 ? t2 += `${n3}:-moz-${r2};` : 4 & l2 && (t2 += `${n3}:-ms-${r2};`), t2 += `${n3}:${r2};`, t2;
}

// src/styled/class.ts
var cls = (() => {
  let id = 0;
  return (name) => {
    const suffixId = id++;
    const suffixName = name.replace(/\s/g, "_");
    const suffixRandom = Math.round(16777215 * Math.random()).toString(16);
    const raw = `cls-${suffixId}-${suffixName}-${suffixRandom}`;
    const cooked = `.${raw}`;
    const fn = () => cooked;
    fn.raw = raw;
    fn.cooked = cooked;
    fn.toString = fn;
    return fn;
  };
})();
var class_default = cls;

// src/styled/css.ts
var css_default = u;

// node_modules/goober/global/dist/goober-global.modern.js
var o2 = u.bind({ g: 1 });
function r() {
  const n3 = m.call({ g: 1 }, "div").apply(null, arguments);
  return function(l2) {
    return n3(l2), null;
  };
}

// src/styled/global.ts
var global_default = r;

// src/styled/keyframes.ts
var keyframes_default = b;

// src/styled/index.ts
h(create_element_default, n2);
var styled = (component) => {
  return m(component);
};
styled.class = class_default;
styled.css = css_default;
styled.global = global_default;
styled.keyframes = keyframes_default;
styled.a = styled("a");
styled.abbr = styled("abbr");
styled.address = styled("address");
styled.area = styled("area");
styled.article = styled("article");
styled.aside = styled("aside");
styled.audio = styled("audio");
styled.b = styled("b");
styled.base = styled("base");
styled.bdi = styled("bdi");
styled.bdo = styled("bdo");
styled.big = styled("big");
styled.blockquote = styled("blockquote");
styled.body = styled("body");
styled.br = styled("br");
styled.button = styled("button");
styled.canvas = styled("canvas");
styled.caption = styled("caption");
styled.cite = styled("cite");
styled.code = styled("code");
styled.col = styled("col");
styled.colgroup = styled("colgroup");
styled.data = styled("data");
styled.datalist = styled("datalist");
styled.dd = styled("dd");
styled.del = styled("del");
styled.details = styled("details");
styled.dfn = styled("dfn");
styled.dialog = styled("dialog");
styled.div = styled("div");
styled.dl = styled("dl");
styled.dt = styled("dt");
styled.em = styled("em");
styled.embed = styled("embed");
styled.fieldset = styled("fieldset");
styled.figcaption = styled("figcaption");
styled.figure = styled("figure");
styled.footer = styled("footer");
styled.form = styled("form");
styled.h1 = styled("h1");
styled.h2 = styled("h2");
styled.h3 = styled("h3");
styled.h4 = styled("h4");
styled.h5 = styled("h5");
styled.h6 = styled("h6");
styled.head = styled("head");
styled.header = styled("header");
styled.hgroup = styled("hgroup");
styled.hr = styled("hr");
styled.html = styled("html");
styled.i = styled("i");
styled.iframe = styled("iframe");
styled.img = styled("img");
styled.input = styled("input");
styled.ins = styled("ins");
styled.kbd = styled("kbd");
styled.keygen = styled("keygen");
styled.label = styled("label");
styled.legend = styled("legend");
styled.li = styled("li");
styled.link = styled("link");
styled.main = styled("main");
styled.map = styled("map");
styled.mark = styled("mark");
styled.menu = styled("menu");
styled.menuitem = styled("menuitem");
styled.meta = styled("meta");
styled.meter = styled("meter");
styled.nav = styled("nav");
styled.noscript = styled("noscript");
styled.object = styled("object");
styled.ol = styled("ol");
styled.optgroup = styled("optgroup");
styled.option = styled("option");
styled.output = styled("output");
styled.p = styled("p");
styled.param = styled("param");
styled.picture = styled("picture");
styled.pre = styled("pre");
styled.progress = styled("progress");
styled.q = styled("q");
styled.rp = styled("rp");
styled.rt = styled("rt");
styled.ruby = styled("ruby");
styled.s = styled("s");
styled.samp = styled("samp");
styled.script = styled("script");
styled.section = styled("section");
styled.select = styled("select");
styled.slot = styled("slot");
styled.small = styled("small");
styled.source = styled("source");
styled.span = styled("span");
styled.strong = styled("strong");
styled.style = styled("style");
styled.sub = styled("sub");
styled.summary = styled("summary");
styled.sup = styled("sup");
styled.table = styled("table");
styled.tbody = styled("tbody");
styled.td = styled("td");
styled.textarea = styled("textarea");
styled.tfoot = styled("tfoot");
styled.th = styled("th");
styled.thead = styled("thead");
styled.time = styled("time");
styled.title = styled("title");
styled.tr = styled("tr");
styled.track = styled("track");
styled.u = styled("u");
styled.ul = styled("ul");
styled.var = styled("var");
styled.video = styled("video");
styled.wbr = styled("wbr");
var styled_default = styled;

// src/svg.ts
var svg = (statics, ...dynamics) => {
  return use_computed_default(() => {
    let html = statics[0];
    for (let i3 = 1, l2 = statics.length; i3 < l2; i3++) {
      html += String(use_resolved_default(dynamics[i3 - 1]));
      html += statics[i3];
    }
    const container = document.createElement("div");
    container.innerHTML = html.trim();
    return container.firstChild;
  });
};
var svg_default = svg;
export {
  $,
  $$,
  component_default as Component,
  error_boundary_default as ErrorBoundary,
  for_default as For,
  fragment_default as Fragment,
  if_default as If,
  portal_default as Portal,
  switch_default as Switch,
  ternary_default as Ternary,
  batch_default as batch,
  create_element_default as createElement,
  is_observable_default as isObservable,
  render_default as render,
  render_to_string_default as renderToString,
  sample_default as sample,
  styled_default as styled,
  svg_default as svg,
  template_default as template,
  use_abort_controller_default as useAbortController,
  use_animation_frame_default as useAnimationFrame,
  use_animation_loop_default as useAnimationLoop,
  use_cleanup_default as useCleanup,
  use_computed_default as useComputed,
  use_disposed_default as useDisposed,
  use_effect_default as useEffect,
  use_error_default as useError,
  use_fetch_default as useFetch,
  use_from_default as useFrom,
  use_idle_callback_default as useIdleCallback,
  use_idle_loop_default as useIdleLoop,
  use_interval_default as useInterval,
  use_promise_default as usePromise,
  use_resolved_default as useResolved,
  use_root_default as useRoot,
  use_timeout_default as useTimeout
};