@italone/solace 0.0.1

package/dist/index.js

@@ -0,0 +1,1394 @@
+import { h as hasDevtoolsListeners, e as emitDevtoolsEvent } from './index-CkECgTuy.js';
+import { S as ShapeFlags, h, F as Fragment } from './h-B1loyNPC.js';
+
+const targetMap = new WeakMap();
+let activeEffect;
+class ReactiveEffect {
+    constructor(fn, scheduler) {
+        this.fn = fn;
+        this.scheduler = scheduler;
+        this.active = true;
+        this.deps = [];
+    }
+    run() {
+        if (!this.active) {
+            return this.fn();
+        }
+        return runEffect(this);
+    }
+    stop() {
+        if (!this.active) {
+            return;
+        }
+        cleanupEffect(this);
+        this.active = false;
+    }
+}
+function runEffect(reactiveEffect) {
+    const parentEffect = activeEffect;
+    cleanupEffect(reactiveEffect);
+    activeEffect = reactiveEffect;
+    try {
+        return reactiveEffect.fn();
+    }
+    finally {
+        activeEffect = parentEffect;
+    }
+}
+function cleanupEffect(reactiveEffect) {
+    reactiveEffect.deps.forEach((dep) => {
+        dep.delete(reactiveEffect);
+    });
+    reactiveEffect.deps.length = 0;
+}
+function effect(fn) {
+    const reactiveEffect = new ReactiveEffect(fn);
+    reactiveEffect.run();
+    return reactiveEffect.run.bind(reactiveEffect);
+}
+function track(target, key) {
+    if (activeEffect === undefined) {
+        return;
+    }
+    let depsMap = targetMap.get(target);
+    if (depsMap === undefined) {
+        depsMap = new Map();
+        targetMap.set(target, depsMap);
+    }
+    let dep = depsMap.get(key);
+    if (dep === undefined) {
+        dep = new Set();
+        depsMap.set(key, dep);
+    }
+    if (dep.has(activeEffect)) {
+        return;
+    }
+    dep.add(activeEffect);
+    activeEffect.deps.push(dep);
+}
+function trigger(target, key) {
+    const dep = targetMap.get(target)?.get(key);
+    if (dep === undefined) {
+        return;
+    }
+    const effects = new Set(dep);
+    let scheduledEffects = 0;
+    let runEffects = 0;
+    effects.forEach((reactiveEffect) => {
+        if (!reactiveEffect.active) {
+            return;
+        }
+        if (reactiveEffect.scheduler !== undefined) {
+            scheduledEffects += 1;
+            reactiveEffect.scheduler();
+            return;
+        }
+        runEffects += 1;
+        reactiveEffect.run();
+    });
+    emitReactivityTriggerDevtoolsEvent(target, key, scheduledEffects, runEffects);
+}
+function emitReactivityTriggerDevtoolsEvent(target, key, scheduledEffects, runEffects) {
+    if (!hasDevtoolsListeners()) {
+        return;
+    }
+    emitDevtoolsEvent({
+        type: "reactivity:trigger",
+        targetType: getDevtoolsTargetType(target),
+        keyType: typeof key,
+        effectCount: scheduledEffects + runEffects,
+        scheduledEffects,
+        runEffects,
+    });
+}
+function getDevtoolsTargetType(target) {
+    if (Array.isArray(target)) {
+        return "array";
+    }
+    return typeof target;
+}
+
+function computed(getter) {
+    let dirty = true;
+    let value;
+    const computedRef = {
+        get value() {
+            if (dirty) {
+                value = reactiveEffect.run();
+                dirty = false;
+            }
+            track(computedRef, "value");
+            return value;
+        },
+    };
+    const reactiveEffect = new ReactiveEffect(getter, () => {
+        if (!dirty) {
+            dirty = true;
+            trigger(computedRef, "value");
+        }
+    });
+    return computedRef;
+}
+
+const queue = [];
+const queuedJobs = new Set();
+const resolvedPromise = Promise.resolve();
+let currentFlushPromise = null;
+let dedupedJobs = 0;
+function queueJob(job) {
+    if (queuedJobs.has(job)) {
+        if (hasDevtoolsListeners()) {
+            dedupedJobs += 1;
+        }
+        return;
+    }
+    queuedJobs.add(job);
+    queue.push(job);
+    queueFlush();
+}
+function nextTick(callback) {
+    const promise = currentFlushPromise ?? resolvedPromise;
+    return callback === undefined ? promise : promise.then(callback);
+}
+function queueFlush() {
+    currentFlushPromise ?? (currentFlushPromise = resolvedPromise.then(flushJobs));
+}
+function flushJobs() {
+    const shouldEmitDevtoolsEvent = hasDevtoolsListeners();
+    const startedAt = shouldEmitDevtoolsEvent ? now() : 0;
+    let flushedJobs = 0;
+    try {
+        for (let index = 0; index < queue.length; index += 1) {
+            const job = queue[index];
+            job();
+            flushedJobs += 1;
+        }
+    }
+    finally {
+        if (shouldEmitDevtoolsEvent) {
+            emitDevtoolsEvent({
+                type: "scheduler:flush",
+                queuedJobs: flushedJobs,
+                dedupedJobs,
+                durationMs: Math.max(0, now() - startedAt),
+            });
+        }
+        queue.length = 0;
+        queuedJobs.clear();
+        dedupedJobs = 0;
+        currentFlushPromise = null;
+    }
+}
+function now() {
+    return globalThis.performance?.now() ?? Date.now();
+}
+
+let currentInstance = null;
+function setCurrentInstance(instance) {
+    currentInstance = instance;
+}
+function getCurrentInstance() {
+    return currentInstance;
+}
+function onMounted(hook) {
+    injectHook("mounted", hook);
+}
+function onUpdated(hook) {
+    injectHook("updated", hook);
+}
+function onUnmounted(hook) {
+    injectHook("unmounted", hook);
+}
+function callHooks(hooks) {
+    for (const hook of hooks) {
+        hook();
+    }
+}
+function injectHook(type, hook) {
+    if (currentInstance === null) {
+        return;
+    }
+    currentInstance[type].push(hook);
+}
+
+function initProps(instance, rawProps) {
+    instance.props = normalizeProps(rawProps);
+}
+function updateProps(instance, rawProps) {
+    const nextProps = normalizeProps(rawProps);
+    for (const key of Object.keys(instance.props)) {
+        if (!(key in nextProps)) {
+            delete instance.props[key];
+        }
+    }
+    for (const [key, value] of Object.entries(nextProps)) {
+        instance.props[key] = value;
+    }
+}
+function normalizeProps(rawProps) {
+    if (rawProps === null) {
+        return {};
+    }
+    const props = {};
+    for (const [key, value] of Object.entries(rawProps)) {
+        if (key !== "key") {
+            props[key] = value;
+        }
+    }
+    return props;
+}
+
+let nextComponentDevtoolsId = 1;
+function createComponentInstance(vnode, parent = null, appProvides = parent?.appProvides ?? null) {
+    const instance = {
+        vnode,
+        type: vnode.type,
+        parent,
+        appProvides,
+        props: {},
+        provides: new Map(),
+        slots: {},
+        setupState: {},
+        subTree: null,
+        devtoolsId: nextComponentDevtoolsId,
+        isMounted: false,
+        isUnmounted: false,
+        isUpdateQueued: false,
+        render: () => {
+            throw new Error("Component render function called before setup");
+        },
+        effect: null,
+        update: null,
+        emit: () => undefined,
+        mounted: [],
+        updated: [],
+        unmounted: [],
+    };
+    nextComponentDevtoolsId += 1;
+    instance.emit = emit.bind(null, instance);
+    return instance;
+}
+function getComponentDevtoolsName(instance) {
+    return instance.type.name || "AnonymousComponent";
+}
+function setupComponent(instance) {
+    initProps(instance, instance.vnode.props);
+    initSlots(instance, instance.vnode.children);
+    let resolvedRender = null;
+    let hasResolvedSetup = false;
+    const setupContext = {
+        emit: instance.emit,
+        slots: instance.slots,
+    };
+    instance.render = () => {
+        if (resolvedRender !== null) {
+            return resolvedRender();
+        }
+        const setupResult = runComponentSetup(instance, setupContext, hasResolvedSetup);
+        hasResolvedSetup = true;
+        if (typeof setupResult === "function") {
+            resolvedRender = setupResult;
+            return resolvedRender();
+        }
+        return setupResult;
+    };
+}
+function updateComponentProps(instance, nextVNode) {
+    instance.vnode = nextVNode;
+    updateProps(instance, nextVNode.props);
+    initSlots(instance, nextVNode.children);
+}
+function runComponentSetup(instance, setupContext, hasResolvedSetup) {
+    if (hasResolvedSetup) {
+        return instance.type(instance.props, setupContext);
+    }
+    setCurrentInstance(instance);
+    try {
+        return instance.type(instance.props, setupContext);
+    }
+    finally {
+        setCurrentInstance(null);
+    }
+}
+function initSlots(instance, children) {
+    for (const key of Object.keys(instance.slots)) {
+        delete instance.slots[key];
+    }
+    if (children === null) {
+        return;
+    }
+    if (isVNodeSlots(children)) {
+        for (const [name, slot] of Object.entries(children)) {
+            if (typeof slot === "function") {
+                instance.slots[name] = slot;
+            }
+        }
+        return;
+    }
+    instance.slots.default = () => children;
+}
+function emit(instance, event, ...args) {
+    const handler = resolveEmitHandler(instance.vnode.props, event);
+    emitComponentEmitDevtoolsEvent(instance, event, handler);
+    if (typeof handler === "function") {
+        handler(...args);
+        return;
+    }
+    if (Array.isArray(handler)) {
+        for (const item of handler) {
+            if (typeof item === "function") {
+                item(...args);
+            }
+        }
+    }
+}
+function emitComponentEmitDevtoolsEvent(instance, event, handler) {
+    if (!hasDevtoolsListeners()) {
+        return;
+    }
+    emitDevtoolsEvent({
+        type: "component:emit",
+        id: instance.devtoolsId,
+        name: getComponentDevtoolsName(instance),
+        event,
+        handlerCount: countEmitHandlers(handler),
+    });
+}
+function countEmitHandlers(handler) {
+    if (typeof handler === "function") {
+        return 1;
+    }
+    if (Array.isArray(handler)) {
+        return handler.filter((item) => typeof item === "function").length;
+    }
+    return 0;
+}
+function resolveEmitHandler(props, event) {
+    if (props === null) {
+        return undefined;
+    }
+    return props[toHandlerKey(camelize(event))] ?? props[toHandlerKey(event)];
+}
+function toHandlerKey(event) {
+    return `on${event.charAt(0).toUpperCase()}${event.slice(1)}`;
+}
+function camelize(value) {
+    return value.replace(/-(\w)/g, (_, character) => character.toUpperCase());
+}
+function isVNodeSlots(children) {
+    return (children !== null &&
+        typeof children === "object" &&
+        !Array.isArray(children) &&
+        !("type" in children));
+}
+
+function isEventProp(key) {
+    return /^on[A-Z]/.test(key);
+}
+function patchEvent(el, key, previousValue, nextValue) {
+    const invokers = getInvokers(el);
+    const existingInvoker = invokers[key];
+    const nextEventValue = normalizeEventValue(nextValue);
+    if (existingInvoker !== undefined && nextEventValue !== null) {
+        existingInvoker.value = nextEventValue;
+        return;
+    }
+    const eventName = key.slice(2).toLowerCase();
+    if (nextEventValue !== null) {
+        const invoker = createInvoker(nextEventValue);
+        invokers[key] = invoker;
+        el.addEventListener(eventName, invoker);
+        return;
+    }
+    if (existingInvoker !== undefined) {
+        el.removeEventListener(eventName, existingInvoker);
+        invokers[key] = undefined;
+    }
+}
+function removeEvents(el) {
+    const invokers = el._vei;
+    if (invokers === undefined) {
+        return;
+    }
+    for (const [key, invoker] of Object.entries(invokers)) {
+        if (invoker !== undefined) {
+            el.removeEventListener(key.slice(2).toLowerCase(), invoker);
+            invokers[key] = undefined;
+        }
+    }
+}
+function getInvokers(el) {
+    const element = el;
+    element._vei ?? (element._vei = {});
+    return element._vei;
+}
+function createInvoker(initialValue) {
+    const invoker = ((event) => {
+        invoker.value(event);
+    });
+    invoker.value = initialValue;
+    return invoker;
+}
+function normalizeEventValue(value) {
+    return typeof value === "function" ? value : null;
+}
+
+function createElement(type) {
+    return document.createElement(type);
+}
+function insert(child, parent, anchor = null) {
+    parent.insertBefore(child, anchor);
+}
+function setText(node, text) {
+    node.textContent = text;
+}
+function remove(child) {
+    if (child instanceof Element) {
+        removeEvents(child);
+    }
+    child.parentNode?.removeChild(child);
+}
+function patchProp(el, key, previousValue, nextValue) {
+    if (isEventProp(key)) {
+        patchEvent(el, key, previousValue, nextValue);
+        return;
+    }
+    if (nextValue === null || nextValue === undefined || nextValue === false) {
+        el.removeAttribute(key);
+        return;
+    }
+    el.setAttribute(key, String(nextValue));
+}
+
+function patch(n1, n2, container, anchor = null, parentComponent = null, appProvides = parentComponent?.appProvides ?? null) {
+    if (n1 !== null && !isSameVNodeType(n1, n2)) {
+        const nextAnchor = n1.el?.nextSibling ?? anchor;
+        unmount(n1);
+        patch(null, n2, container, nextAnchor, parentComponent, appProvides);
+        return;
+    }
+    if (n2.shapeFlag & ShapeFlags.ELEMENT) {
+        if (n1 === null) {
+            mountElement(n2, container, anchor, parentComponent, appProvides);
+            return;
+        }
+        patchElement(n1, n2, parentComponent, appProvides);
+        return;
+    }
+    if (n2.shapeFlag & ShapeFlags.FRAGMENT) {
+        if (n1 === null) {
+            mountFragment(n2, container, anchor, parentComponent, appProvides);
+            return;
+        }
+        patchChildren(n1, n2, container, parentComponent, appProvides);
+        n2.el = getFragmentRoot(n2);
+        return;
+    }
+    if (n2.shapeFlag & ShapeFlags.COMPONENT) {
+        if (n1 === null) {
+            mountComponent(n2, container, anchor, parentComponent, appProvides);
+            return;
+        }
+        updateComponent(n1, n2);
+    }
+}
+function mountFragment(vnode, container, anchor, parentComponent, appProvides) {
+    if (vnode.shapeFlag & ShapeFlags.ARRAY_CHILDREN) {
+        const children = vnode.children;
+        if (canBatchMountFragment(children)) {
+            const fragment = document.createDocumentFragment();
+            for (const child of children) {
+                patch(null, child, fragment, null, parentComponent, appProvides);
+            }
+            insert(fragment, container, anchor);
+            vnode.el = getFragmentRoot(vnode);
+            return;
+        }
+        for (const child of children) {
+            patch(null, child, container, anchor, parentComponent, appProvides);
+        }
+    }
+    vnode.el = getFragmentRoot(vnode);
+}
+function canBatchMountFragment(children) {
+    return children.length > 0;
+}
+function mountElement(vnode, container, anchor, parentComponent, appProvides) {
+    const el = createElement(vnode.type);
+    vnode.el = el;
+    if (vnode.props) {
+        mountInitialProps(el, vnode.props);
+    }
+    if (vnode.shapeFlag & ShapeFlags.TEXT_CHILDREN) {
+        setText(el, vnode.children);
+    }
+    else if (vnode.shapeFlag & ShapeFlags.ARRAY_CHILDREN) {
+        mountChildren(vnode.children, el, parentComponent, appProvides);
+    }
+    insert(el, container, anchor);
+    emitRendererElementDevtoolsEvent("mount", vnode.type);
+}
+function mountComponent(vnode, container, anchor, parentComponent, appProvides) {
+    const instance = createComponentInstance(vnode, parentComponent, appProvides);
+    vnode.component = instance;
+    setupComponent(instance);
+    const componentUpdate = () => {
+        try {
+            if (instance.isUnmounted) {
+                return;
+            }
+            if (!instance.isMounted) {
+                const subTree = instance.render();
+                instance.subTree = subTree;
+                patch(null, subTree, container, anchor, instance, instance.appProvides);
+                vnode.el = subTree.el;
+                instance.isMounted = true;
+                callHooks(instance.mounted);
+                emitComponentDevtoolsEvent("component:mount", instance);
+                return;
+            }
+            const nextTree = instance.render();
+            const previousTree = instance.subTree;
+            patch(previousTree, nextTree, container, anchor, instance, instance.appProvides);
+            instance.subTree = nextTree;
+            instance.vnode.el = nextTree.el;
+            callHooks(instance.updated);
+            emitComponentDevtoolsEvent("component:update", instance);
+        }
+        finally {
+            instance.isUpdateQueued = false;
+        }
+    };
+    const reactiveEffect = new ReactiveEffect(componentUpdate, () => {
+        if (instance.update === null || instance.isUpdateQueued) {
+            return;
+        }
+        instance.isUpdateQueued = true;
+        queueJob(instance.update);
+    });
+    instance.effect = reactiveEffect;
+    instance.update = reactiveEffect.run.bind(reactiveEffect);
+    instance.update();
+}
+function mountChildren(children, container, parentComponent, appProvides) {
+    if (canBatchMountChildren(children, 0, children.length - 1)) {
+        const fragment = document.createDocumentFragment();
+        for (const child of children) {
+            patch(null, child, fragment, null, parentComponent, appProvides);
+        }
+        insert(fragment, container, null);
+        return;
+    }
+    for (const child of children) {
+        patch(null, child, container, null, parentComponent, appProvides);
+    }
+}
+function updateComponent(n1, n2) {
+    const instance = n1.component;
+    n2.component = instance;
+    if (!shouldUpdateComponent(n1, n2)) {
+        instance.vnode = n2;
+        n2.el = n1.el;
+        return;
+    }
+    updateComponentProps(instance, n2);
+    instance.update?.();
+    n2.el = instance.subTree?.el ?? null;
+}
+function shouldUpdateComponent(n1, n2) {
+    if (n1.children !== n2.children) {
+        return true;
+    }
+    return havePropsChanged(n1.props, n2.props);
+}
+function havePropsChanged(oldProps, newProps) {
+    if (oldProps === newProps) {
+        return false;
+    }
+    if (oldProps === null) {
+        return hasPatchableProps(newProps);
+    }
+    if (newProps === null) {
+        return hasPatchableProps(oldProps);
+    }
+    for (const key in oldProps) {
+        if (!hasOwnProp(oldProps, key) || key === "key") {
+            continue;
+        }
+        if (!hasOwnProp(newProps, key) || oldProps[key] !== newProps[key]) {
+            return true;
+        }
+    }
+    for (const key in newProps) {
+        if (!hasOwnProp(newProps, key) || key === "key") {
+            continue;
+        }
+        if (!hasOwnProp(oldProps, key)) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasPatchableProps(props) {
+    if (props === null) {
+        return false;
+    }
+    for (const key in props) {
+        if (hasOwnProp(props, key) && key !== "key") {
+            return true;
+        }
+    }
+    return false;
+}
+function hasOwnProp(props, key) {
+    return Object.prototype.hasOwnProperty.call(props, key);
+}
+function mountInitialProps(el, props) {
+    for (const key in props) {
+        if (!hasOwnProp(props, key) || key === "key") {
+            continue;
+        }
+        const value = props[key];
+        if (value === null || value === undefined || value === false) {
+            continue;
+        }
+        if (key === "class") {
+            mountInitialClass(el, value);
+            continue;
+        }
+        if (mightBeEventProp(key)) {
+            patchProp(el, key, null, value);
+            continue;
+        }
+        el.setAttribute(key, String(value));
+    }
+}
+function mountInitialClass(el, value) {
+    if (el instanceof HTMLElement) {
+        el.className = String(value);
+        return;
+    }
+    el.setAttribute("class", String(value));
+}
+function mightBeEventProp(key) {
+    return key.length > 2 && key[0] === "o" && key[1] === "n" && isEventProp(key);
+}
+function patchElement(n1, n2, parentComponent, appProvides) {
+    const el = n1.el;
+    n2.el = el;
+    const propsChanged = havePropsChanged(n1.props, n2.props);
+    const childrenChanged = haveElementChildrenChanged(n1, n2);
+    if (!propsChanged && !childrenChanged) {
+        return;
+    }
+    if (propsChanged) {
+        patchProps(el, n1.props, n2.props);
+    }
+    if (childrenChanged) {
+        patchChildren(n1, n2, el, parentComponent, appProvides);
+    }
+    emitRendererElementDevtoolsEvent("update", n2.type);
+}
+function haveElementChildrenChanged(n1, n2) {
+    const oldShapeFlag = n1.shapeFlag;
+    const newShapeFlag = n2.shapeFlag;
+    const oldHasTextChildren = Boolean(oldShapeFlag & ShapeFlags.TEXT_CHILDREN);
+    const newHasTextChildren = Boolean(newShapeFlag & ShapeFlags.TEXT_CHILDREN);
+    const oldHasArrayChildren = Boolean(oldShapeFlag & ShapeFlags.ARRAY_CHILDREN);
+    const newHasArrayChildren = Boolean(newShapeFlag & ShapeFlags.ARRAY_CHILDREN);
+    if (oldHasTextChildren || newHasTextChildren) {
+        return !oldHasTextChildren || !newHasTextChildren || n1.children !== n2.children;
+    }
+    if (oldHasArrayChildren || newHasArrayChildren) {
+        return !oldHasArrayChildren || !newHasArrayChildren || n1.children !== n2.children;
+    }
+    return false;
+}
+function patchProps(el, oldProps, newProps) {
+    const previousProps = oldProps ?? {};
+    const nextProps = newProps ?? {};
+    for (const [key, nextValue] of Object.entries(nextProps)) {
+        if (key === "key") {
+            continue;
+        }
+        const previousValue = previousProps[key];
+        if (previousValue !== nextValue) {
+            patchProp(el, key, previousValue, nextValue);
+        }
+    }
+    for (const key of Object.keys(previousProps)) {
+        if (key !== "key" && !(key in nextProps)) {
+            patchProp(el, key, previousProps[key], null);
+        }
+    }
+}
+function patchChildren(n1, n2, container, parentComponent, appProvides) {
+    const oldChildren = n1.children;
+    const newChildren = n2.children;
+    const oldShapeFlag = n1.shapeFlag;
+    const newShapeFlag = n2.shapeFlag;
+    if (newShapeFlag & ShapeFlags.TEXT_CHILDREN) {
+        if (oldShapeFlag & ShapeFlags.ARRAY_CHILDREN) {
+            unmountChildren(oldChildren);
+        }
+        if (oldChildren !== newChildren) {
+            setText(container, newChildren);
+        }
+        return;
+    }
+    if (newShapeFlag & ShapeFlags.ARRAY_CHILDREN) {
+        const nextChildren = newChildren;
+        if (oldShapeFlag & ShapeFlags.TEXT_CHILDREN) {
+            setText(container, "");
+            mountChildren(nextChildren, container, parentComponent, appProvides);
+            return;
+        }
+        if (oldShapeFlag & ShapeFlags.ARRAY_CHILDREN) {
+            patchArrayChildren(oldChildren, nextChildren, container, parentComponent, appProvides);
+            return;
+        }
+        mountChildren(nextChildren, container, parentComponent, appProvides);
+        return;
+    }
+    if (oldShapeFlag & ShapeFlags.ARRAY_CHILDREN) {
+        unmountChildren(oldChildren);
+    }
+    else if (oldShapeFlag & ShapeFlags.TEXT_CHILDREN) {
+        setText(container, "");
+    }
+}
+function patchArrayChildren(oldChildren, newChildren, container, parentComponent, appProvides) {
+    if (hasUniqueKeys(oldChildren) && hasUniqueKeys(newChildren)) {
+        patchKeyedChildren(oldChildren, newChildren, container, parentComponent, appProvides);
+        return;
+    }
+    patchUnkeyedChildren(oldChildren, newChildren, container, parentComponent, appProvides);
+}
+function patchUnkeyedChildren(oldChildren, newChildren, container, parentComponent, appProvides) {
+    const commonLength = Math.min(oldChildren.length, newChildren.length);
+    for (let index = 0; index < commonLength; index += 1) {
+        patch(oldChildren[index], newChildren[index], container, null, parentComponent, appProvides);
+    }
+    if (newChildren.length > oldChildren.length) {
+        mountNewChildren(newChildren, commonLength, newChildren.length - 1, container, null, parentComponent, appProvides);
+        return;
+    }
+    unmountChildrenRange(oldChildren, commonLength, oldChildren.length - 1);
+}
+function patchKeyedChildren(oldChildren, newChildren, container, parentComponent, appProvides) {
+    let oldStart = 0;
+    let newStart = 0;
+    let oldEnd = oldChildren.length - 1;
+    let newEnd = newChildren.length - 1;
+    while (oldStart <= oldEnd &&
+        newStart <= newEnd &&
+        isSameVNodeType(oldChildren[oldStart], newChildren[newStart])) {
+        patch(oldChildren[oldStart], newChildren[newStart], container, null, parentComponent, appProvides);
+        oldStart += 1;
+        newStart += 1;
+    }
+    while (oldStart <= oldEnd &&
+        newStart <= newEnd &&
+        isSameVNodeType(oldChildren[oldEnd], newChildren[newEnd])) {
+        patch(oldChildren[oldEnd], newChildren[newEnd], container, null, parentComponent, appProvides);
+        oldEnd -= 1;
+        newEnd -= 1;
+    }
+    if (oldStart > oldEnd) {
+        const anchor = getAnchor(newChildren, newEnd + 1);
+        mountNewChildren(newChildren, newStart, newEnd, container, anchor, parentComponent, appProvides);
+        return;
+    }
+    if (newStart > newEnd) {
+        unmountChildrenRange(oldChildren, oldStart, oldEnd);
+        return;
+    }
+    const oldKeyedChildren = new Map();
+    const newIndexToOldIndexMap = new Array(newEnd - newStart + 1).fill(0);
+    const usedOldChildren = new Set();
+    for (let index = oldStart; index <= oldEnd; index += 1) {
+        const oldChild = oldChildren[index];
+        if (oldChild.key !== null) {
+            oldKeyedChildren.set(oldChild.key, {
+                vnode: oldChild,
+                index,
+            });
+        }
+    }
+    for (let index = newStart; index <= newEnd; index += 1) {
+        const newChild = newChildren[index];
+        const oldRecord = oldKeyedChildren.get(newChild.key) ?? null;
+        if (oldRecord !== null) {
+            usedOldChildren.add(oldRecord.vnode);
+            newIndexToOldIndexMap[index - newStart] = oldRecord.index + 1;
+            patch(oldRecord.vnode, newChild, container, null, parentComponent, appProvides);
+        }
+    }
+    unmountUnusedKeyedChildren(oldChildren, oldStart, oldEnd, usedOldChildren);
+    const stablePositions = getIncreasingSubsequence(newIndexToOldIndexMap);
+    let stableIndex = stablePositions.length - 1;
+    for (let index = newEnd; index >= newStart; index -= 1) {
+        if (newIndexToOldIndexMap[index - newStart] === 0) {
+            const runStart = getNewRunStart(newIndexToOldIndexMap, newStart, index);
+            if (runStart < index && canBatchMountChildren(newChildren, runStart, index)) {
+                mountNewChildren(newChildren, runStart, index, container, getAnchor(newChildren, index + 1), parentComponent, appProvides);
+                index = runStart;
+                continue;
+            }
+            patch(null, newChildren[index], container, getAnchor(newChildren, index + 1), parentComponent, appProvides);
+            continue;
+        }
+        const childEl = newChildren[index].el;
+        if (childEl === null) {
+            continue;
+        }
+        if (stableIndex >= 0 && index - newStart === stablePositions[stableIndex]) {
+            stableIndex -= 1;
+            continue;
+        }
+        insert(childEl, container, getAnchor(newChildren, index + 1));
+    }
+}
+function getNewRunStart(newIndexToOldIndexMap, newStart, index) {
+    let start = index;
+    while (start > newStart && newIndexToOldIndexMap[start - 1 - newStart] === 0) {
+        start -= 1;
+    }
+    return start;
+}
+function unmountUnusedKeyedChildren(children, start, end, usedChildren) {
+    let index = start;
+    while (index <= end) {
+        if (usedChildren.has(children[index])) {
+            index += 1;
+            continue;
+        }
+        const runStart = index;
+        while (index <= end && !usedChildren.has(children[index])) {
+            index += 1;
+        }
+        unmountChildrenRange(children, runStart, index - 1);
+    }
+}
+function mountNewChildren(children, start, end, container, anchor, parentComponent, appProvides) {
+    if (canBatchMountChildren(children, start, end)) {
+        const fragment = document.createDocumentFragment();
+        for (let index = start; index <= end; index += 1) {
+            patch(null, children[index], fragment, null, parentComponent, appProvides);
+        }
+        insert(fragment, container, anchor);
+        return;
+    }
+    for (let index = start; index <= end; index += 1) {
+        patch(null, children[index], container, anchor, parentComponent, appProvides);
+    }
+}
+function canBatchMountChildren(children, start, end) {
+    return start <= end;
+}
+function unmountChildrenRange(children, start, end) {
+    if (canBatchRemoveChildren(children, start, end)) {
+        const fragment = document.createDocumentFragment();
+        for (let index = start; index <= end; index += 1) {
+            fragment.appendChild(children[index].el);
+        }
+        return;
+    }
+    for (let index = start; index <= end; index += 1) {
+        unmount(children[index]);
+    }
+}
+function canBatchRemoveChildren(children, start, end) {
+    if (start > end || hasDevtoolsListeners()) {
+        return false;
+    }
+    let parent = null;
+    for (let index = start; index <= end; index += 1) {
+        const child = children[index];
+        if (!(child.shapeFlag & ShapeFlags.ELEMENT) ||
+            child.shapeFlag & ShapeFlags.ARRAY_CHILDREN ||
+            child.el === null ||
+            hasEventProps(child.props)) {
+            return false;
+        }
+        parent ?? (parent = child.el.parentNode);
+        if (parent === null || child.el.parentNode !== parent) {
+            return false;
+        }
+    }
+    return true;
+}
+function hasEventProps(props) {
+    if (props === null) {
+        return false;
+    }
+    return Object.keys(props).some(isEventProp);
+}
+function getAnchor(children, index) {
+    return children[index]?.el ?? null;
+}
+function getIncreasingSubsequence(source) {
+    const predecessors = source.slice();
+    const result = [];
+    for (let index = 0; index < source.length; index += 1) {
+        const value = source[index];
+        if (value === 0) {
+            continue;
+        }
+        const lastResultIndex = result[result.length - 1];
+        if (result.length === 0 || source[lastResultIndex] < value) {
+            if (result.length > 0) {
+                predecessors[index] = lastResultIndex;
+            }
+            result.push(index);
+            continue;
+        }
+        let start = 0;
+        let end = result.length - 1;
+        while (start < end) {
+            const middle = Math.floor((start + end) / 2);
+            if (source[result[middle]] < value) {
+                start = middle + 1;
+            }
+            else {
+                end = middle;
+            }
+        }
+        if (value < source[result[start]]) {
+            if (start > 0) {
+                predecessors[index] = result[start - 1];
+            }
+            result[start] = index;
+        }
+    }
+    if (result.length === 0) {
+        return [];
+    }
+    let current = result[result.length - 1];
+    for (let index = result.length - 1; index >= 0; index -= 1) {
+        result[index] = current;
+        current = predecessors[current];
+    }
+    return result;
+}
+function hasUniqueKeys(children) {
+    const keys = new Set();
+    for (const child of children) {
+        if (child.key === null || keys.has(child.key)) {
+            return false;
+        }
+        keys.add(child.key);
+    }
+    return children.length > 0;
+}
+function isSameVNodeType(n1, n2) {
+    return n1.type === n2.type && n1.key === n2.key;
+}
+function unmountChildren(children) {
+    for (const child of children) {
+        unmount(child);
+    }
+}
+function unmount(vnode) {
+    if (vnode.shapeFlag & ShapeFlags.COMPONENT) {
+        const instance = vnode.component;
+        if (instance === null) {
+            return;
+        }
+        instance.isUnmounted = true;
+        instance.isMounted = false;
+        instance.effect?.stop();
+        instance.effect = null;
+        instance.update = null;
+        if (instance.subTree !== null) {
+            unmount(instance.subTree);
+        }
+        callHooks(instance.unmounted);
+        emitComponentDevtoolsEvent("component:unmount", instance);
+        return;
+    }
+    if (vnode.shapeFlag & ShapeFlags.FRAGMENT) {
+        if (vnode.shapeFlag & ShapeFlags.ARRAY_CHILDREN) {
+            unmountChildren(vnode.children);
+        }
+        return;
+    }
+    if (vnode.shapeFlag & ShapeFlags.ARRAY_CHILDREN) {
+        unmountChildren(vnode.children);
+    }
+    if (vnode.el !== null) {
+        remove(vnode.el);
+        emitRendererElementDevtoolsEvent("unmount", vnode.type);
+    }
+}
+function getFragmentRoot(vnode) {
+    if (!(vnode.shapeFlag & ShapeFlags.ARRAY_CHILDREN)) {
+        return null;
+    }
+    return vnode.children[0]?.el ?? null;
+}
+function emitComponentDevtoolsEvent(type, instance) {
+    if (!hasDevtoolsListeners()) {
+        return;
+    }
+    emitDevtoolsEvent({
+        type,
+        id: instance.devtoolsId,
+        name: getComponentDevtoolsName(instance),
+    });
+}
+function emitRendererElementDevtoolsEvent(operation, tag) {
+    if (!hasDevtoolsListeners()) {
+        return;
+    }
+    emitDevtoolsEvent({
+        type: "renderer:element",
+        operation,
+        tag,
+    });
+}
+
+function render(source, container, appProvides = null) {
+    const renderContainer = container;
+    if (typeof source === "function") {
+        renderReactiveSource(source, renderContainer, appProvides);
+        return;
+    }
+    stopReactiveRender(renderContainer);
+    renderVNode(source, renderContainer, appProvides);
+}
+function renderReactiveSource(source, container, appProvides) {
+    stopReactiveRender(container);
+    const update = () => {
+        renderVNode(source(), container, appProvides);
+    };
+    const reactiveEffect = new ReactiveEffect(update, () => {
+        queueJob(job);
+    });
+    const runner = reactiveEffect.run.bind(reactiveEffect);
+    const job = () => {
+        if (container._solaceRenderEffect === reactiveEffect) {
+            runner();
+        }
+    };
+    container._solaceRenderEffect = reactiveEffect;
+    runner();
+}
+function stopReactiveRender(container) {
+    container._solaceRenderEffect?.stop();
+    container._solaceRenderEffect = undefined;
+}
+function renderVNode(vnode, container, appProvides) {
+    patch(container._solaceVNode ?? null, vnode, container, null, null, appProvides);
+    container._solaceVNode = vnode;
+}
+
+function createApp(rootComponent) {
+    const installedPlugins = new Set();
+    const appProvides = new Map();
+    const app = {
+        mount(container) {
+            const vnode = typeof rootComponent === "function" ? h(rootComponent) : rootComponent;
+            render(vnode, container, appProvides);
+        },
+        provide(key, value) {
+            appProvides.set(key, value);
+            return app;
+        },
+        use(plugin, ...options) {
+            if (installedPlugins.has(plugin)) {
+                return app;
+            }
+            installedPlugins.add(plugin);
+            if (typeof plugin === "function") {
+                plugin(app, ...options);
+            }
+            else {
+                plugin.install(app, ...options);
+            }
+            return app;
+        },
+    };
+    return app;
+}
+
+function hasChanged(value, oldValue) {
+    return !Object.is(value, oldValue);
+}
+function isObject(value) {
+    return value !== null && typeof value === "object";
+}
+
+function reactive(target) {
+    if (!isObject(target)) {
+        return target;
+    }
+    return new Proxy(target, {
+        get(target, key, receiver) {
+            const result = Reflect.get(target, key, receiver);
+            track(target, key);
+            return result;
+        },
+        set(target, key, value, receiver) {
+            const oldValue = Reflect.get(target, key, receiver);
+            const result = Reflect.set(target, key, value, receiver);
+            if (hasChanged(value, oldValue)) {
+                trigger(target, key);
+            }
+            return result;
+        },
+    });
+}
+
+function ref(value) {
+    const refObject = {
+        get value() {
+            track(refObject, "value");
+            return value;
+        },
+        set value(newValue) {
+            if (!hasChanged(newValue, value)) {
+                return;
+            }
+            value = newValue;
+            trigger(refObject, "value");
+        },
+    };
+    return refObject;
+}
+
+function watch(source, callback) {
+    let oldValue;
+    const job = () => {
+        const newValue = reactiveEffect.run();
+        callback(newValue, oldValue);
+        oldValue = newValue;
+    };
+    const reactiveEffect = new ReactiveEffect(source, job);
+    oldValue = reactiveEffect.run();
+    return () => {
+        reactiveEffect.stop();
+    };
+}
+function watchEffect(effect) {
+    const reactiveEffect = new ReactiveEffect(effect);
+    reactiveEffect.run();
+    return () => {
+        reactiveEffect.stop();
+    };
+}
+
+function defineAsyncComponent(source) {
+    const options = normalizeAsyncComponentOptions(source);
+    let resolvedComponent = null;
+    let pendingRequest = null;
+    let loadError = null;
+    let isLoadingVisible = getDelay(options) <= 0;
+    let failedAttempts = 0;
+    let activeAttemptId = 0;
+    let delayTimer = null;
+    let timeoutTimer = null;
+    let retryTimer = null;
+    return (props, { slots }) => {
+        const instance = getCurrentInstance();
+        const update = instance?.update ?? null;
+        return () => {
+            const children = normalizeSlotChildren(slots.default?.());
+            if (resolvedComponent !== null) {
+                return renderComponent(resolvedComponent, props, children);
+            }
+            if (loadError !== null) {
+                return options.errorComponent
+                    ? renderComponent(options.errorComponent, props, children)
+                    : h(Fragment, null, []);
+            }
+            if (pendingRequest === null && retryTimer === null && loadError === null) {
+                startLoad(update);
+            }
+            return options.loadingComponent && isLoadingVisible
+                ? renderComponent(options.loadingComponent, props, children)
+                : h(Fragment, null, []);
+        };
+    };
+    function startLoad(update) {
+        const attemptId = activeAttemptId + 1;
+        activeAttemptId = attemptId;
+        clearAttemptTimers();
+        startDelayTimer(options, () => {
+            if (attemptId !== activeAttemptId) {
+                return;
+            }
+            isLoadingVisible = true;
+            update?.();
+        });
+        startTimeoutTimer(options, () => {
+            handleLoadFailure(new Error("Async component timed out"), attemptId, update);
+        });
+        pendingRequest = options
+            .loader()
+            .then((component) => {
+            if (attemptId !== activeAttemptId || loadError !== null) {
+                return;
+            }
+            clearAsyncTimers();
+            pendingRequest = null;
+            resolvedComponent = component;
+            update?.();
+        })
+            .catch((error) => {
+            handleLoadFailure(error, attemptId, update);
+        });
+    }
+    function handleLoadFailure(error, attemptId, update) {
+        if (attemptId !== activeAttemptId || resolvedComponent !== null || loadError !== null) {
+            return;
+        }
+        clearAttemptTimers();
+        pendingRequest = null;
+        failedAttempts += 1;
+        if (failedAttempts <= getRetry(options)) {
+            const retryDelay = getRetryDelay(options);
+            if (retryDelay <= 0) {
+                startLoad(update);
+                return;
+            }
+            retryTimer = setTimeout(() => {
+                retryTimer = null;
+                startLoad(update);
+            }, retryDelay);
+            return;
+        }
+        loadError = error;
+        update?.();
+    }
+    function startDelayTimer(currentOptions, onDelay) {
+        const delay = getDelay(currentOptions);
+        if (delay <= 0) {
+            isLoadingVisible = true;
+            return;
+        }
+        isLoadingVisible = false;
+        delayTimer = setTimeout(onDelay, delay);
+    }
+    function startTimeoutTimer(currentOptions, onTimeout) {
+        if (currentOptions.timeout === undefined) {
+            return;
+        }
+        timeoutTimer = setTimeout(onTimeout, currentOptions.timeout);
+    }
+    function clearAsyncTimers() {
+        clearAttemptTimers();
+        if (retryTimer !== null) {
+            clearTimeout(retryTimer);
+            retryTimer = null;
+        }
+    }
+    function clearAttemptTimers() {
+        if (delayTimer !== null) {
+            clearTimeout(delayTimer);
+            delayTimer = null;
+        }
+        if (timeoutTimer !== null) {
+            clearTimeout(timeoutTimer);
+            timeoutTimer = null;
+        }
+    }
+}
+function normalizeAsyncComponentOptions(source) {
+    return typeof source === "function" ? { loader: source } : source;
+}
+function renderComponent(component, props, children) {
+    return h(component, props, children);
+}
+function normalizeSlotChildren(children) {
+    return children ?? null;
+}
+function getDelay(options) {
+    return options.delay ?? 0;
+}
+function getRetry(options) {
+    return options.retry ?? 0;
+}
+function getRetryDelay(options) {
+    return options.retryDelay ?? 0;
+}
+
+function defineComponent(component) {
+    return component;
+}
+
+function provide(key, value) {
+    const instance = getCurrentInstance();
+    if (instance === null) {
+        return;
+    }
+    instance.provides.set(key, value);
+}
+function inject(key, defaultValue) {
+    const instance = getCurrentInstance();
+    if (instance === null) {
+        return defaultValue;
+    }
+    let parent = instance.parent;
+    while (parent !== null) {
+        if (parent.provides.has(key)) {
+            return parent.provides.get(key);
+        }
+        parent = parent.parent;
+    }
+    if (instance.appProvides?.has(key)) {
+        return instance.appProvides.get(key);
+    }
+    return defaultValue;
+}
+
+function createStore(options) {
+    const state = reactive(options.state());
+    const getterRefs = {};
+    const getters = {};
+    const context = {
+        state,
+        getters,
+    };
+    const actions = {};
+    for (const [key, getter] of Object.entries(options.getters ?? {})) {
+        getterRefs[key] = computed(() => getter({ state }));
+        Object.defineProperty(getters, key, {
+            enumerable: true,
+            get: () => getterRefs[key]?.value,
+        });
+    }
+    for (const [key, action] of Object.entries(options.actions ?? {})) {
+        const runAction = action;
+        actions[key] = ((...args) => {
+            if (!hasDevtoolsListeners()) {
+                return runAction(context, ...args);
+            }
+            const startedAt = performance.now();
+            try {
+                const result = runAction(context, ...args);
+                emitStoreActionDevtoolsEvent(String(key), "success", startedAt);
+                return result;
+            }
+            catch (error) {
+                emitStoreActionDevtoolsEvent(String(key), "error", startedAt);
+                throw error;
+            }
+        });
+    }
+    return {
+        state,
+        getters,
+        actions,
+    };
+}
+function emitStoreActionDevtoolsEvent(name, status, startedAt) {
+    emitDevtoolsEvent({
+        type: "store:action",
+        name,
+        status,
+        durationMs: performance.now() - startedAt,
+    });
+}
+
+export { Fragment, computed, createApp, createStore, defineAsyncComponent, defineComponent, effect, h, inject, nextTick, onMounted, onUnmounted, onUpdated, provide, reactive, ref, render, watch, watchEffect };