foldkit 0.128.1 → 0.130.0

package/dist/snabbdom/init.js

@@ -0,0 +1,486 @@
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
+import { htmlDomApi } from './htmldomapi.js';
+import * as is from './is.js';
+import { vnode, vnodeDataMaskKey } from './vnode.js';
+const emptyNode = vnode('', {}, [], undefined, undefined);
+function sameVnode(vnode1, vnode2) {
+    if (vnode1 === vnode2) {
+        return true;
+    }
+    if (vnode1.sel !== vnode2.sel) {
+        return false;
+    }
+    if (vnode1.key !== vnode2.key) {
+        return false;
+    }
+    if (vnode1.identity !== vnode2.identity) {
+        return false;
+    }
+    if (vnode1.data?.is !== vnode2.data?.is) {
+        return false;
+    }
+    return vnode1.sel !== undefined || typeof vnode1.text === typeof vnode2.text;
+}
+/**
+ * @todo Remove this function when the document fragment is considered stable.
+ */
+function documentFragmentIsNotSupported() {
+    throw new Error('The document fragment is not supported on this platform.');
+}
+function isElement(api, vnode) {
+    return api.isElement(vnode);
+}
+function isDocumentFragment(api, vnode) {
+    return api.isDocumentFragment?.(vnode) ?? false;
+}
+function createKeyToPreviousIndex(children, beginIndex, endIndex) {
+    const map = new Map();
+    for (let childIndex = beginIndex; childIndex <= endIndex; ++childIndex) {
+        const key = children[childIndex]?.key;
+        if (key !== undefined) {
+            map.set(key, childIndex);
+        }
+    }
+    return map;
+}
+const hooks = [
+    'create',
+    'update',
+    'remove',
+    'destroy',
+    'pre',
+    'post',
+];
+let duplicateKeyWarningOverride = undefined;
+/** Overrides the `import.meta.hot` gate on the dev-only duplicate sibling key
+ *  warning so unit tests can force it on or off. Pass `undefined` to restore
+ *  the gate. Internal, test-only. */
+export const __overrideDuplicateKeyWarning = (isActive) => {
+    duplicateKeyWarningOverride = isActive;
+};
+// NOTE: `import.meta` is read through a structural cast rather than the
+// vite/client `ImportMeta` augmentation so repo-internal programs that
+// typecheck this source without vite types (internal/lustre-benchmark) still
+// compile. The emitted JS is a plain `import.meta.hot` access either way.
+const isDuplicateKeyWarningActive = () => duplicateKeyWarningOverride ?? !!import.meta.hot;
+export function init(modules, domApi, options) {
+    const moduleHooks = {
+        create: [],
+        update: [],
+        remove: [],
+        destroy: [],
+        pre: [],
+        post: [],
+    };
+    const moduleDataMasks = {
+        create: [],
+        update: [],
+        destroy: [],
+    };
+    const api = domApi !== undefined ? domApi : htmlDomApi;
+    let isDuplicateKeyWarningIssued = false;
+    for (const hook of hooks) {
+        for (const module of modules) {
+            const currentHook = module[hook];
+            if (currentHook !== undefined) {
+                ;
+                moduleHooks[hook].push(currentHook);
+                if (hook === 'create' || hook === 'update' || hook === 'destroy') {
+                    moduleDataMasks[hook].push(module.dataMask);
+                }
+            }
+        }
+    }
+    function emptyNodeAt(element) {
+        const id = element.id ? '#' + element.id : '';
+        // element.className doesn't return a string when element is an SVG element inside a shadowRoot.
+        // https://stackoverflow.com/questions/29454340/detecting-classname-of-svganimatedstring
+        const classes = element.getAttribute('class');
+        const classSelector = classes ? '.' + classes.split(' ').join('.') : '';
+        return vnode(api.tagName(element).toLowerCase() + id + classSelector, {}, [], undefined, element);
+    }
+    function emptyDocumentFragmentAt(fragment) {
+        return vnode(undefined, {}, [], undefined, fragment);
+    }
+    function createRemoveCallback(childElement, listeners) {
+        return function removeCallback() {
+            if (--listeners === 0) {
+                const parent = api.parentNode(childElement);
+                if (parent !== null) {
+                    api.removeChild(parent, childElement);
+                }
+            }
+        };
+    }
+    function createElm(vnode, insertedVnodeQueue) {
+        const data = vnode.data;
+        const hook = data?.hook;
+        hook?.init?.(vnode);
+        const children = vnode.children;
+        const selector = vnode.sel;
+        if (selector === '!') {
+            vnode.text ??= '';
+            vnode.elm = api.createComment(vnode.text);
+        }
+        else if (selector === '') {
+            // textNode has no selector
+            vnode.elm = api.createTextNode(vnode.text);
+        }
+        else if (selector !== undefined) {
+            // Parse selector
+            const hashIndex = selector.indexOf('#');
+            const dotIndex = selector.indexOf('.', hashIndex);
+            const hash = hashIndex > 0 ? hashIndex : selector.length;
+            const dot = dotIndex > 0 ? dotIndex : selector.length;
+            const tagName = hashIndex !== -1 || dotIndex !== -1
+                ? selector.slice(0, Math.min(hash, dot))
+                : selector;
+            const namespace = data?.ns;
+            const element = namespace === undefined
+                ? api.createElement(tagName, data)
+                : api.createElementNS(namespace, tagName, data);
+            vnode.elm = element;
+            if (hash < dot) {
+                element.setAttribute('id', selector.slice(hash + 1, dot));
+            }
+            if (dotIndex > 0) {
+                element.setAttribute('class', selector.slice(dot + 1).replace(/\./g, ' '));
+            }
+            const dataMask = data?.[vnodeDataMaskKey];
+            for (let moduleIndex = 0; moduleIndex < moduleHooks.create.length; ++moduleIndex) {
+                const moduleDataMask = moduleDataMasks.create[moduleIndex];
+                if (moduleDataMask === undefined ||
+                    dataMask === undefined ||
+                    (dataMask & moduleDataMask) !== 0) {
+                    moduleHooks.create[moduleIndex](emptyNode, vnode);
+                }
+            }
+            if (is.primitive(vnode.text) &&
+                (!is.array(children) || children.length === 0)) {
+                // allow h1 and similar nodes to be created w/ text and empty child list
+                api.appendChild(element, api.createTextNode(vnode.text));
+            }
+            if (is.array(children)) {
+                for (let childIndex = 0; childIndex < children.length; ++childIndex) {
+                    const child = children[childIndex];
+                    if (child != null) {
+                        api.appendChild(element, createElm(child, insertedVnodeQueue));
+                    }
+                }
+            }
+            if (hook !== undefined) {
+                hook.create?.(emptyNode, vnode);
+                if (hook.insert !== undefined) {
+                    insertedVnodeQueue.push(vnode);
+                }
+            }
+        }
+        else if (options?.experimental?.fragments && vnode.children) {
+            vnode.elm = (api.createDocumentFragment ?? documentFragmentIsNotSupported)();
+            const dataMask = data?.[vnodeDataMaskKey];
+            for (let moduleIndex = 0; moduleIndex < moduleHooks.create.length; ++moduleIndex) {
+                const moduleDataMask = moduleDataMasks.create[moduleIndex];
+                if (moduleDataMask === undefined ||
+                    dataMask === undefined ||
+                    (dataMask & moduleDataMask) !== 0) {
+                    moduleHooks.create[moduleIndex](emptyNode, vnode);
+                }
+            }
+            for (let childIndex = 0; childIndex < vnode.children.length; ++childIndex) {
+                const child = vnode.children[childIndex];
+                if (child != null) {
+                    api.appendChild(vnode.elm, createElm(child, insertedVnodeQueue));
+                }
+            }
+        }
+        else {
+            vnode.elm = api.createTextNode(vnode.text);
+        }
+        return vnode.elm;
+    }
+    function addVnodes(parentElement, before, vnodes, startIndex, endIndex, insertedVnodeQueue) {
+        for (; startIndex <= endIndex; ++startIndex) {
+            const child = vnodes[startIndex];
+            if (child != null) {
+                api.insertBefore(parentElement, createElm(child, insertedVnodeQueue), before);
+            }
+        }
+    }
+    function invokeDestroyHook(vnode) {
+        const data = vnode.data;
+        if (data !== undefined) {
+            data?.hook?.destroy?.(vnode);
+            const dataMask = data[vnodeDataMaskKey];
+            for (let moduleIndex = 0; moduleIndex < moduleHooks.destroy.length; ++moduleIndex) {
+                const moduleDataMask = moduleDataMasks.destroy[moduleIndex];
+                if (moduleDataMask === undefined ||
+                    dataMask === undefined ||
+                    (dataMask & moduleDataMask) !== 0) {
+                    moduleHooks.destroy[moduleIndex](vnode);
+                }
+            }
+            if (vnode.children !== undefined) {
+                for (let childIndex = 0; childIndex < vnode.children.length; ++childIndex) {
+                    const child = vnode.children[childIndex];
+                    if (child != null && typeof child !== 'string') {
+                        invokeDestroyHook(child);
+                    }
+                }
+            }
+        }
+    }
+    function removeVnodes(parentElement, vnodes, startIndex, endIndex) {
+        for (; startIndex <= endIndex; ++startIndex) {
+            let listeners;
+            const child = vnodes[startIndex];
+            if (child != null) {
+                if (child.sel !== undefined) {
+                    invokeDestroyHook(child);
+                    listeners = moduleHooks.remove.length + 1;
+                    const removeCallback = createRemoveCallback(child.elm, listeners);
+                    for (let moduleIndex = 0; moduleIndex < moduleHooks.remove.length; ++moduleIndex) {
+                        moduleHooks.remove[moduleIndex](child, removeCallback);
+                    }
+                    const removeHook = child.data?.hook?.remove;
+                    if (removeHook !== undefined) {
+                        removeHook(child, removeCallback);
+                    }
+                    else {
+                        removeCallback();
+                    }
+                }
+                else if (child.children) {
+                    // Fragment node
+                    invokeDestroyHook(child);
+                    removeVnodes(parentElement, child.children, 0, child.children.length - 1);
+                }
+                else {
+                    // Text node
+                    api.removeChild(parentElement, child.elm);
+                }
+            }
+        }
+    }
+    function warnOnDuplicateKeys(children, beginIndex, endIndex, parentElement) {
+        if (!isDuplicateKeyWarningActive() || isDuplicateKeyWarningIssued) {
+            return;
+        }
+        const seenKeys = new Set();
+        for (let childIndex = beginIndex; childIndex <= endIndex; ++childIndex) {
+            const key = children[childIndex]?.key;
+            if (key === undefined) {
+                continue;
+            }
+            if (seenKeys.has(key)) {
+                isDuplicateKeyWarningIssued = true;
+                const parentSelector = api.isElement(parentElement)
+                    ? api.tagName(parentElement).toLowerCase()
+                    : String(parentElement.nodeName).toLowerCase();
+                console.warn(`[foldkit] Duplicate key "${String(key)}" among children of ` +
+                    `<${parentSelector}>. Keys must be unique among siblings; duplicates ` +
+                    'make sibling matching ambiguous and can patch the wrong element.');
+                return;
+            }
+            seenKeys.add(key);
+        }
+    }
+    function updateChildren(parentElement, previousChildren, nextChildren, insertedVnodeQueue) {
+        if (previousChildren.length === 0 && nextChildren.length === 0) {
+            return;
+        }
+        warnOnDuplicateKeys(nextChildren, 0, nextChildren.length - 1, parentElement);
+        let previousStartIndex = 0;
+        let nextStartIndex = 0;
+        let previousEndIndex = previousChildren.length - 1;
+        let nextEndIndex = nextChildren.length - 1;
+        while (previousStartIndex <= previousEndIndex &&
+            nextStartIndex <= nextEndIndex &&
+            previousChildren[previousStartIndex] === nextChildren[nextStartIndex]) {
+            previousStartIndex += 1;
+            nextStartIndex += 1;
+        }
+        while (previousStartIndex <= previousEndIndex &&
+            nextStartIndex <= nextEndIndex &&
+            previousChildren[previousEndIndex] === nextChildren[nextEndIndex]) {
+            previousEndIndex -= 1;
+            nextEndIndex -= 1;
+        }
+        let previousStartVnode = previousChildren[previousStartIndex];
+        let previousEndVnode = previousChildren[previousEndIndex];
+        let nextStartVnode = nextChildren[nextStartIndex];
+        let nextEndVnode = nextChildren[nextEndIndex];
+        let previousKeyToIndex;
+        let indexInPreviousChildren;
+        let vnodeToMove;
+        let before;
+        while (previousStartIndex <= previousEndIndex &&
+            nextStartIndex <= nextEndIndex) {
+            if (previousStartVnode == null) {
+                previousStartVnode = previousChildren[++previousStartIndex];
+            }
+            else if (previousEndVnode == null) {
+                previousEndVnode = previousChildren[--previousEndIndex];
+            }
+            else if (nextStartVnode == null) {
+                nextStartVnode = nextChildren[++nextStartIndex];
+            }
+            else if (nextEndVnode == null) {
+                nextEndVnode = nextChildren[--nextEndIndex];
+            }
+            else if (sameVnode(previousStartVnode, nextStartVnode)) {
+                patchVnode(previousStartVnode, nextStartVnode, insertedVnodeQueue);
+                previousStartVnode = previousChildren[++previousStartIndex];
+                nextStartVnode = nextChildren[++nextStartIndex];
+            }
+            else if (sameVnode(previousEndVnode, nextEndVnode)) {
+                patchVnode(previousEndVnode, nextEndVnode, insertedVnodeQueue);
+                previousEndVnode = previousChildren[--previousEndIndex];
+                nextEndVnode = nextChildren[--nextEndIndex];
+            }
+            else if (sameVnode(previousStartVnode, nextEndVnode)) {
+                // Vnode moved right
+                patchVnode(previousStartVnode, nextEndVnode, insertedVnodeQueue);
+                api.insertBefore(parentElement, previousStartVnode.elm, api.nextSibling(previousEndVnode.elm));
+                previousStartVnode = previousChildren[++previousStartIndex];
+                nextEndVnode = nextChildren[--nextEndIndex];
+            }
+            else if (sameVnode(previousEndVnode, nextStartVnode)) {
+                // Vnode moved left
+                patchVnode(previousEndVnode, nextStartVnode, insertedVnodeQueue);
+                api.insertBefore(parentElement, previousEndVnode.elm, previousStartVnode.elm);
+                previousEndVnode = previousChildren[--previousEndIndex];
+                nextStartVnode = nextChildren[++nextStartIndex];
+            }
+            else {
+                if (previousKeyToIndex === undefined) {
+                    previousKeyToIndex = createKeyToPreviousIndex(previousChildren, previousStartIndex, previousEndIndex);
+                    warnOnDuplicateKeys(previousChildren, previousStartIndex, previousEndIndex, parentElement);
+                }
+                const nextStartKey = nextStartVnode.key;
+                indexInPreviousChildren =
+                    nextStartKey === undefined
+                        ? undefined
+                        : previousKeyToIndex.get(nextStartKey);
+                if (indexInPreviousChildren === undefined) {
+                    // `nextStartVnode` is new, create and insert it in beginning
+                    api.insertBefore(parentElement, createElm(nextStartVnode, insertedVnodeQueue), previousStartVnode.elm);
+                    nextStartVnode = nextChildren[++nextStartIndex];
+                }
+                else if (nextEndVnode.key === undefined ||
+                    previousKeyToIndex.get(nextEndVnode.key) === undefined) {
+                    // `nextEndVnode` is new, create and insert it in the end
+                    api.insertBefore(parentElement, createElm(nextEndVnode, insertedVnodeQueue), api.nextSibling(previousEndVnode.elm));
+                    nextEndVnode = nextChildren[--nextEndIndex];
+                }
+                else {
+                    // Neither of the new endpoints are new vnodes, so we make progress by
+                    // moving `nextStartVnode` into position
+                    vnodeToMove = previousChildren[indexInPreviousChildren];
+                    if (!sameVnode(vnodeToMove, nextStartVnode)) {
+                        api.insertBefore(parentElement, createElm(nextStartVnode, insertedVnodeQueue), previousStartVnode.elm);
+                    }
+                    else {
+                        patchVnode(vnodeToMove, nextStartVnode, insertedVnodeQueue);
+                        previousChildren[indexInPreviousChildren] = undefined;
+                        api.insertBefore(parentElement, vnodeToMove.elm, previousStartVnode.elm);
+                    }
+                    nextStartVnode = nextChildren[++nextStartIndex];
+                }
+            }
+        }
+        if (nextStartIndex <= nextEndIndex) {
+            before =
+                nextChildren[nextEndIndex + 1] == null
+                    ? null
+                    : nextChildren[nextEndIndex + 1].elm;
+            addVnodes(parentElement, before, nextChildren, nextStartIndex, nextEndIndex, insertedVnodeQueue);
+        }
+        if (previousStartIndex <= previousEndIndex) {
+            removeVnodes(parentElement, previousChildren, previousStartIndex, previousEndIndex);
+        }
+    }
+    function patchVnode(oldVnode, vnode, insertedVnodeQueue) {
+        if (oldVnode === vnode) {
+            return;
+        }
+        const hook = vnode.data?.hook;
+        hook?.prepatch?.(oldVnode, vnode);
+        const element = (vnode.elm = oldVnode.elm);
+        if (vnode.data !== undefined ||
+            (vnode.text !== undefined && vnode.text !== oldVnode.text)) {
+            vnode.data ??= {};
+            oldVnode.data ??= {};
+            const oldDataMask = oldVnode.data[vnodeDataMaskKey];
+            const dataMask = vnode.data[vnodeDataMaskKey];
+            for (let moduleIndex = 0; moduleIndex < moduleHooks.update.length; ++moduleIndex) {
+                const moduleDataMask = moduleDataMasks.update[moduleIndex];
+                if (moduleDataMask === undefined ||
+                    oldDataMask === undefined ||
+                    dataMask === undefined ||
+                    ((oldDataMask | dataMask) & moduleDataMask) !== 0) {
+                    moduleHooks.update[moduleIndex](oldVnode, vnode);
+                }
+            }
+            vnode.data?.hook?.update?.(oldVnode, vnode);
+        }
+        const previousChildren = oldVnode.children;
+        const nextChildren = vnode.children;
+        if (vnode.text === undefined) {
+            if (previousChildren !== undefined && nextChildren !== undefined) {
+                if (previousChildren !== nextChildren) {
+                    updateChildren(element, previousChildren, nextChildren, insertedVnodeQueue);
+                }
+            }
+            else if (nextChildren !== undefined) {
+                if (oldVnode.text !== undefined)
+                    api.setTextContent(element, '');
+                addVnodes(element, null, nextChildren, 0, nextChildren.length - 1, insertedVnodeQueue);
+            }
+            else if (previousChildren !== undefined) {
+                removeVnodes(element, previousChildren, 0, previousChildren.length - 1);
+            }
+            else if (oldVnode.text !== undefined) {
+                api.setTextContent(element, '');
+            }
+        }
+        else if (oldVnode.text !== vnode.text) {
+            if (previousChildren !== undefined) {
+                removeVnodes(element, previousChildren, 0, previousChildren.length - 1);
+            }
+            api.setTextContent(element, vnode.text);
+        }
+        hook?.postpatch?.(oldVnode, vnode);
+    }
+    return function patch(oldVnode, vnode) {
+        const insertedVnodeQueue = [];
+        isDuplicateKeyWarningIssued = false;
+        for (let moduleIndex = 0; moduleIndex < moduleHooks.pre.length; ++moduleIndex) {
+            moduleHooks.pre[moduleIndex]();
+        }
+        if (isElement(api, oldVnode)) {
+            oldVnode = emptyNodeAt(oldVnode);
+        }
+        else if (isDocumentFragment(api, oldVnode)) {
+            oldVnode = emptyDocumentFragmentAt(oldVnode);
+        }
+        if (sameVnode(oldVnode, vnode)) {
+            patchVnode(oldVnode, vnode, insertedVnodeQueue);
+        }
+        else {
+            const element = oldVnode.elm;
+            const parent = api.parentNode(element);
+            createElm(vnode, insertedVnodeQueue);
+            if (parent !== null) {
+                api.insertBefore(parent, vnode.elm, api.nextSibling(element));
+                removeVnodes(parent, [oldVnode], 0, 0);
+            }
+        }
+        for (let insertedVnodeIndex = 0; insertedVnodeIndex < insertedVnodeQueue.length; ++insertedVnodeIndex) {
+            insertedVnodeQueue[insertedVnodeIndex].data.hook.insert(insertedVnodeQueue[insertedVnodeIndex]);
+        }
+        for (let moduleIndex = 0; moduleIndex < moduleHooks.post.length; ++moduleIndex) {
+            moduleHooks.post[moduleIndex]();
+        }
+        return vnode;
+    };
+}

package/dist/snabbdom/is.d.ts

@@ -0,0 +1,3 @@
+export declare const array: (arg: any) => arg is any[];
+export declare function primitive(s: any): s is string | number;
+//# sourceMappingURL=is.d.ts.map

package/dist/snabbdom/is.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is.d.ts","sourceRoot":"","sources":["../../src/snabbdom/is.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,4BAAgB,CAAA;AAClC,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,MAAM,GAAG,MAAM,CAOtD"}

package/dist/snabbdom/is.js

@@ -0,0 +1,7 @@
+export const array = Array.isArray;
+export function primitive(s) {
+    return (typeof s === 'string' ||
+        typeof s === 'number' ||
+        s instanceof String ||
+        s instanceof Number);
+}

package/dist/snabbdom/module.d.ts

@@ -0,0 +1,11 @@
+import type { CreateHook, DestroyHook, PostHook, PreHook, RemoveHook, UpdateHook } from './hooks.js';
+export type Module = Partial<{
+    dataMask: number;
+    pre: PreHook;
+    create: CreateHook;
+    update: UpdateHook;
+    destroy: DestroyHook;
+    remove: RemoveHook;
+    post: PostHook;
+}>;
+//# sourceMappingURL=module.d.ts.map

package/dist/snabbdom/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../src/snabbdom/module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,WAAW,EACX,QAAQ,EACR,OAAO,EACP,UAAU,EACV,UAAU,EACX,MAAM,YAAY,CAAA;AAEnB,MAAM,MAAM,MAAM,GAAG,OAAO,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,OAAO,CAAA;IACZ,MAAM,EAAE,UAAU,CAAA;IAClB,MAAM,EAAE,UAAU,CAAA;IAClB,OAAO,EAAE,WAAW,CAAA;IACpB,MAAM,EAAE,UAAU,CAAA;IAClB,IAAI,EAAE,QAAQ,CAAA;CACf,CAAC,CAAA"}

package/dist/snabbdom/module.js

@@ -0,0 +1 @@
+export {};

package/dist/snabbdom/props.d.ts

@@ -0,0 +1,2 @@
+export type Props = Record<string, any>;
+//# sourceMappingURL=props.d.ts.map

package/dist/snabbdom/props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"props.d.ts","sourceRoot":"","sources":["../../src/snabbdom/props.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA"}

package/dist/snabbdom/props.js

@@ -0,0 +1 @@
+export {};

package/dist/snabbdom/style.d.ts

@@ -0,0 +1,9 @@
+import type { Module } from './module.js';
+export type ElementStyle = Partial<CSSStyleDeclaration>;
+export type VNodeStyle = ElementStyle & Record<string, string> & {
+    delayed?: ElementStyle & Record<string, string>;
+    remove?: ElementStyle & Record<string, string>;
+    destroy?: ElementStyle & Record<string, string>;
+};
+export declare const styleModule: Module;
+//# sourceMappingURL=style.d.ts.map

package/dist/snabbdom/style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"style.d.ts","sourceRoot":"","sources":["../../src/snabbdom/style.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAGzC,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAA;AAEvD,MAAM,MAAM,UAAU,GAAG,YAAY,GACnC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;IACvB,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/C,MAAM,CAAC,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9C,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAChD,CAAA;AAgHH,eAAO,MAAM,WAAW,EAAE,MAOzB,CAAA"}

package/dist/snabbdom/style.js

@@ -0,0 +1,123 @@
+import { VNodeDataMask } from './vnode.js';
+// Binding `requestAnimationFrame` like this fixes a bug in IE/Edge. See #360 and #409.
+const raf = typeof window !== 'undefined' &&
+    typeof window.requestAnimationFrame === 'function'
+    ? window.requestAnimationFrame.bind(window)
+    : setTimeout;
+const nextFrame = function (fn) {
+    raf(function () {
+        raf(fn);
+    });
+};
+let reflowForced = false;
+function setNextFrame(obj, prop, val) {
+    nextFrame(function () {
+        obj[prop] = val;
+    });
+}
+function updateStyle(oldVnode, vnode) {
+    let cur;
+    let name;
+    const elm = vnode.elm;
+    let oldStyle = oldVnode.data.style;
+    let style = vnode.data.style;
+    if (!oldStyle && !style)
+        return;
+    if (oldStyle === style)
+        return;
+    oldStyle = oldStyle || {};
+    style = style || {};
+    const oldHasDel = 'delayed' in oldStyle;
+    for (name in oldStyle) {
+        if (!(name in style)) {
+            if (name[0] === '-' && name[1] === '-') {
+                ;
+                elm.style.removeProperty(name);
+            }
+            else {
+                ;
+                elm.style[name] = '';
+            }
+        }
+    }
+    for (name in style) {
+        cur = style[name];
+        if (name === 'delayed' && style.delayed) {
+            for (const name2 in style.delayed) {
+                cur = style.delayed[name2];
+                if (!oldHasDel || cur !== oldStyle.delayed[name2]) {
+                    setNextFrame(elm.style, name2, cur);
+                }
+            }
+        }
+        else if (name !== 'remove' && cur !== oldStyle[name]) {
+            if (name[0] === '-' && name[1] === '-') {
+                ;
+                elm.style.setProperty(name, cur);
+            }
+            else {
+                ;
+                elm.style[name] = cur;
+            }
+        }
+    }
+}
+function applyDestroyStyle(vnode) {
+    let style;
+    let name;
+    const elm = vnode.elm;
+    const s = vnode.data.style;
+    if (!s || !(style = s['destroy']))
+        return;
+    for (name in style) {
+        ;
+        elm.style[name] = style[name];
+    }
+}
+function applyRemoveStyle(vnode, rm) {
+    const s = vnode.data.style;
+    if (!s || !s.remove) {
+        rm();
+        return;
+    }
+    if (!reflowForced) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        ;
+        vnode.elm.offsetLeft;
+        reflowForced = true;
+    }
+    let name;
+    const elm = vnode.elm;
+    let i = 0;
+    const style = s.remove;
+    let amount = 0;
+    const applied = [];
+    for (name in style) {
+        applied.push(name);
+        elm.style[name] = style[name];
+    }
+    const compStyle = getComputedStyle(elm);
+    const props = compStyle['transition-property'].split(', ');
+    for (; i < props.length; ++i) {
+        if (applied.indexOf(props[i]) !== -1)
+            amount++;
+    }
+    ;
+    elm.addEventListener('transitionend', function (ev) {
+        if (ev.target === elm)
+            --amount;
+        if (amount === 0)
+            rm();
+    });
+}
+function forceReflow() {
+    reflowForced = false;
+}
+export const styleModule = {
+    dataMask: VNodeDataMask.Style,
+    pre: forceReflow,
+    create: updateStyle,
+    update: updateStyle,
+    destroy: applyDestroyStyle,
+    remove: applyRemoveStyle,
+};

package/dist/snabbdom/tovnode.d.ts

@@ -0,0 +1,4 @@
+import { type DOMAPI } from './htmldomapi.js';
+import { type VNode } from './vnode.js';
+export declare function toVNode(node: Node, domApi?: DOMAPI): VNode;
+//# sourceMappingURL=tovnode.d.ts.map

package/dist/snabbdom/tovnode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tovnode.d.ts","sourceRoot":"","sources":["../../src/snabbdom/tovnode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAc,MAAM,iBAAiB,CAAA;AACzD,OAAO,EAAE,KAAK,KAAK,EAAS,MAAM,YAAY,CAAA;AAc9C,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,CAiD1D"}