@ibiz-template/vue3-components 0.7.27 → 0.7.28-alpha.1

package/lib/node_modules/.pnpm/snabbdom@3.5.1/node_modules/snabbdom/build/htmldomapi.cjs

@@ -0,0 +1,117 @@
+'use strict';
+
+function createElement(tagName, options) {
+    return document.createElement(tagName, options);
+}
+function createElementNS(namespaceURI, qualifiedName, options) {
+    return document.createElementNS(namespaceURI, qualifiedName, options);
+}
+function createDocumentFragment() {
+    return parseFragment(document.createDocumentFragment());
+}
+function createTextNode(text) {
+    return document.createTextNode(text);
+}
+function createComment(text) {
+    return document.createComment(text);
+}
+function insertBefore(parentNode, newNode, referenceNode) {
+    if (isDocumentFragment(parentNode)) {
+        let node = parentNode;
+        while (node && isDocumentFragment(node)) {
+            const fragment = parseFragment(node);
+            node = fragment.parent;
+        }
+        parentNode = node !== null && node !== void 0 ? node : parentNode;
+    }
+    if (isDocumentFragment(newNode)) {
+        newNode = parseFragment(newNode, parentNode);
+    }
+    if (referenceNode && isDocumentFragment(referenceNode)) {
+        referenceNode = parseFragment(referenceNode).firstChildNode;
+    }
+    parentNode.insertBefore(newNode, referenceNode);
+}
+function removeChild(node, child) {
+    node.removeChild(child);
+}
+function appendChild(node, child) {
+    if (isDocumentFragment(child)) {
+        child = parseFragment(child, node);
+    }
+    node.appendChild(child);
+}
+function parentNode(node) {
+    if (isDocumentFragment(node)) {
+        while (node && isDocumentFragment(node)) {
+            const fragment = parseFragment(node);
+            node = fragment.parent;
+        }
+        return node !== null && node !== void 0 ? node : null;
+    }
+    return node.parentNode;
+}
+function nextSibling(node) {
+    var _a;
+    if (isDocumentFragment(node)) {
+        const fragment = parseFragment(node);
+        const parent = parentNode(fragment);
+        if (parent && fragment.lastChildNode) {
+            const children = Array.from(parent.childNodes);
+            const index = children.indexOf(fragment.lastChildNode);
+            return (_a = children[index + 1]) !== null && _a !== void 0 ? _a : null;
+        }
+        return null;
+    }
+    return node.nextSibling;
+}
+function tagName(elm) {
+    return elm.tagName;
+}
+function setTextContent(node, text) {
+    node.textContent = text;
+}
+function getTextContent(node) {
+    return node.textContent;
+}
+function isElement(node) {
+    return node.nodeType === 1;
+}
+function isText(node) {
+    return node.nodeType === 3;
+}
+function isComment(node) {
+    return node.nodeType === 8;
+}
+function isDocumentFragment(node) {
+    return node.nodeType === 11;
+}
+function parseFragment(fragmentNode, parentNode) {
+    var _a, _b, _c;
+    const fragment = fragmentNode;
+    (_a = fragment.parent) !== null && _a !== void 0 ? _a : (fragment.parent = parentNode !== null && parentNode !== void 0 ? parentNode : null);
+    (_b = fragment.firstChildNode) !== null && _b !== void 0 ? _b : (fragment.firstChildNode = fragmentNode.firstChild);
+    (_c = fragment.lastChildNode) !== null && _c !== void 0 ? _c : (fragment.lastChildNode = fragmentNode.lastChild);
+    return fragment;
+}
+const htmlDomApi = {
+    createElement,
+    createElementNS,
+    createTextNode,
+    createDocumentFragment,
+    createComment,
+    insertBefore,
+    removeChild,
+    appendChild,
+    parentNode,
+    nextSibling,
+    tagName,
+    setTextContent,
+    getTextContent,
+    isElement,
+    isText,
+    isComment,
+    isDocumentFragment,
+};
+
+exports.htmlDomApi = htmlDomApi;

package/lib/node_modules/.pnpm/snabbdom@3.5.1/node_modules/snabbdom/build/index.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+var htmldomapi = require('./htmldomapi.cjs');
+var init = require('./init.cjs');
+var thunk = require('./thunk.cjs');
+var vnode = require('./vnode.cjs');
+var attachto = require('./helpers/attachto.cjs');
+var is = require('./is.cjs');
+var tovnode = require('./tovnode.cjs');
+var h = require('./h.cjs');
+require('./hooks.cjs');
+var attributes = require('./modules/attributes.cjs');
+var _class = require('./modules/class.cjs');
+var dataset = require('./modules/dataset.cjs');
+var eventlisteners = require('./modules/eventlisteners.cjs');
+var props = require('./modules/props.cjs');
+var style = require('./modules/style.cjs');
+var jsx = require('./jsx.cjs');
+
+// core
+
+exports.htmlDomApi = htmldomapi.htmlDomApi;
+exports.init = init.init;
+exports.thunk = thunk.thunk;
+exports.vnode = vnode.vnode;
+exports.attachTo = attachto.attachTo;
+exports.array = is.array;
+exports.primitive = is.primitive;
+exports.toVNode = tovnode.toVNode;
+exports.fragment = h.fragment;
+exports.h = h.h;
+exports.attributesModule = attributes.attributesModule;
+exports.classModule = _class.classModule;
+exports.datasetModule = dataset.datasetModule;
+exports.eventListenersModule = eventlisteners.eventListenersModule;
+exports.propsModule = props.propsModule;
+exports.styleModule = style.styleModule;
+exports.Fragment = jsx.Fragment;
+Object.defineProperty(exports, "jsx", {
+	enumerable: true,
+	get: function () { return jsx.jsx; }
+});

package/lib/node_modules/.pnpm/snabbdom@3.5.1/node_modules/snabbdom/build/init.cjs

@@ -0,0 +1,378 @@
+'use strict';
+
+var vnode = require('./vnode.cjs');
+var is = require('./is.cjs');
+var htmldomapi = require('./htmldomapi.cjs');
+
+function isUndef(s) {
+    return s === undefined;
+}
+function isDef(s) {
+    return s !== undefined;
+}
+const emptyNode = vnode.vnode("", {}, [], undefined, undefined);
+function sameVnode(vnode1, vnode2) {
+    var _a, _b;
+    const isSameKey = vnode1.key === vnode2.key;
+    const isSameIs = ((_a = vnode1.data) === null || _a === void 0 ? void 0 : _a.is) === ((_b = vnode2.data) === null || _b === void 0 ? void 0 : _b.is);
+    const isSameSel = vnode1.sel === vnode2.sel;
+    const isSameTextOrFragment = !vnode1.sel && vnode1.sel === vnode2.sel
+        ? typeof vnode1.text === typeof vnode2.text
+        : true;
+    return isSameSel && isSameKey && isSameIs && isSameTextOrFragment;
+}
+/**
+ * @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);
+}
+function createKeyToOldIdx(children, beginIdx, endIdx) {
+    var _a;
+    const map = {};
+    for (let i = beginIdx; i <= endIdx; ++i) {
+        const key = (_a = children[i]) === null || _a === void 0 ? void 0 : _a.key;
+        if (key !== undefined) {
+            map[key] = i;
+        }
+    }
+    return map;
+}
+const hooks = [
+    "create",
+    "update",
+    "remove",
+    "destroy",
+    "pre",
+    "post",
+];
+function init(modules, domApi, options) {
+    const cbs = {
+        create: [],
+        update: [],
+        remove: [],
+        destroy: [],
+        pre: [],
+        post: [],
+    };
+    const api = domApi !== undefined ? domApi : htmldomapi.htmlDomApi;
+    for (const hook of hooks) {
+        for (const module of modules) {
+            const currentHook = module[hook];
+            if (currentHook !== undefined) {
+                cbs[hook].push(currentHook);
+            }
+        }
+    }
+    function emptyNodeAt(elm) {
+        const id = elm.id ? "#" + elm.id : "";
+        // elm.className doesn't return a string when elm is an SVG element inside a shadowRoot.
+        // https://stackoverflow.com/questions/29454340/detecting-classname-of-svganimatedstring
+        const classes = elm.getAttribute("class");
+        const c = classes ? "." + classes.split(" ").join(".") : "";
+        return vnode.vnode(api.tagName(elm).toLowerCase() + id + c, {}, [], undefined, elm);
+    }
+    function emptyDocumentFragmentAt(frag) {
+        return vnode.vnode(undefined, {}, [], undefined, frag);
+    }
+    function createRmCb(childElm, listeners) {
+        return function rmCb() {
+            if (--listeners === 0) {
+                const parent = api.parentNode(childElm);
+                api.removeChild(parent, childElm);
+            }
+        };
+    }
+    function createElm(vnode, insertedVnodeQueue) {
+        var _a, _b, _c, _d;
+        let i;
+        let data = vnode.data;
+        if (data !== undefined) {
+            const init = (_a = data.hook) === null || _a === void 0 ? void 0 : _a.init;
+            if (isDef(init)) {
+                init(vnode);
+                data = vnode.data;
+            }
+        }
+        const children = vnode.children;
+        const sel = vnode.sel;
+        if (sel === "!") {
+            if (isUndef(vnode.text)) {
+                vnode.text = "";
+            }
+            vnode.elm = api.createComment(vnode.text);
+        }
+        else if (sel !== undefined) {
+            // Parse selector
+            const hashIdx = sel.indexOf("#");
+            const dotIdx = sel.indexOf(".", hashIdx);
+            const hash = hashIdx > 0 ? hashIdx : sel.length;
+            const dot = dotIdx > 0 ? dotIdx : sel.length;
+            const tag = hashIdx !== -1 || dotIdx !== -1
+                ? sel.slice(0, Math.min(hash, dot))
+                : sel;
+            const elm = (vnode.elm =
+                isDef(data) && isDef((i = data.ns))
+                    ? api.createElementNS(i, tag, data)
+                    : api.createElement(tag, data));
+            if (hash < dot)
+                elm.setAttribute("id", sel.slice(hash + 1, dot));
+            if (dotIdx > 0)
+                elm.setAttribute("class", sel.slice(dot + 1).replace(/\./g, " "));
+            for (i = 0; i < cbs.create.length; ++i)
+                cbs.create[i](emptyNode, vnode);
+            if (is.array(children)) {
+                for (i = 0; i < children.length; ++i) {
+                    const ch = children[i];
+                    if (ch != null) {
+                        api.appendChild(elm, createElm(ch, insertedVnodeQueue));
+                    }
+                }
+            }
+            else if (is.primitive(vnode.text)) {
+                api.appendChild(elm, api.createTextNode(vnode.text));
+            }
+            const hook = vnode.data.hook;
+            if (isDef(hook)) {
+                (_b = hook.create) === null || _b === void 0 ? void 0 : _b.call(hook, emptyNode, vnode);
+                if (hook.insert) {
+                    insertedVnodeQueue.push(vnode);
+                }
+            }
+        }
+        else if (((_c = options === null || options === void 0 ? void 0 : options.experimental) === null || _c === void 0 ? void 0 : _c.fragments) && vnode.children) {
+            vnode.elm = ((_d = api.createDocumentFragment) !== null && _d !== void 0 ? _d : documentFragmentIsNotSupported)();
+            for (i = 0; i < cbs.create.length; ++i)
+                cbs.create[i](emptyNode, vnode);
+            for (i = 0; i < vnode.children.length; ++i) {
+                const ch = vnode.children[i];
+                if (ch != null) {
+                    api.appendChild(vnode.elm, createElm(ch, insertedVnodeQueue));
+                }
+            }
+        }
+        else {
+            vnode.elm = api.createTextNode(vnode.text);
+        }
+        return vnode.elm;
+    }
+    function addVnodes(parentElm, before, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            const ch = vnodes[startIdx];
+            if (ch != null) {
+                api.insertBefore(parentElm, createElm(ch, insertedVnodeQueue), before);
+            }
+        }
+    }
+    function invokeDestroyHook(vnode) {
+        var _a, _b;
+        const data = vnode.data;
+        if (data !== undefined) {
+            (_b = (_a = data === null || data === void 0 ? void 0 : data.hook) === null || _a === void 0 ? void 0 : _a.destroy) === null || _b === void 0 ? void 0 : _b.call(_a, vnode);
+            for (let i = 0; i < cbs.destroy.length; ++i)
+                cbs.destroy[i](vnode);
+            if (vnode.children !== undefined) {
+                for (let j = 0; j < vnode.children.length; ++j) {
+                    const child = vnode.children[j];
+                    if (child != null && typeof child !== "string") {
+                        invokeDestroyHook(child);
+                    }
+                }
+            }
+        }
+    }
+    function removeVnodes(parentElm, vnodes, startIdx, endIdx) {
+        var _a, _b;
+        for (; startIdx <= endIdx; ++startIdx) {
+            let listeners;
+            let rm;
+            const ch = vnodes[startIdx];
+            if (ch != null) {
+                if (isDef(ch.sel)) {
+                    invokeDestroyHook(ch);
+                    listeners = cbs.remove.length + 1;
+                    rm = createRmCb(ch.elm, listeners);
+                    for (let i = 0; i < cbs.remove.length; ++i)
+                        cbs.remove[i](ch, rm);
+                    const removeHook = (_b = (_a = ch === null || ch === void 0 ? void 0 : ch.data) === null || _a === void 0 ? void 0 : _a.hook) === null || _b === void 0 ? void 0 : _b.remove;
+                    if (isDef(removeHook)) {
+                        removeHook(ch, rm);
+                    }
+                    else {
+                        rm();
+                    }
+                }
+                else if (ch.children) {
+                    // Fragment node
+                    invokeDestroyHook(ch);
+                    removeVnodes(parentElm, ch.children, 0, ch.children.length - 1);
+                }
+                else {
+                    // Text node
+                    api.removeChild(parentElm, ch.elm);
+                }
+            }
+        }
+    }
+    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue) {
+        let oldStartIdx = 0;
+        let newStartIdx = 0;
+        let oldEndIdx = oldCh.length - 1;
+        let oldStartVnode = oldCh[0];
+        let oldEndVnode = oldCh[oldEndIdx];
+        let newEndIdx = newCh.length - 1;
+        let newStartVnode = newCh[0];
+        let newEndVnode = newCh[newEndIdx];
+        let oldKeyToIdx;
+        let idxInOld;
+        let elmToMove;
+        let before;
+        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+            if (oldStartVnode == null) {
+                oldStartVnode = oldCh[++oldStartIdx]; // Vnode might have been moved left
+            }
+            else if (oldEndVnode == null) {
+                oldEndVnode = oldCh[--oldEndIdx];
+            }
+            else if (newStartVnode == null) {
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else if (newEndVnode == null) {
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newStartVnode)) {
+                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);
+                oldStartVnode = oldCh[++oldStartIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else if (sameVnode(oldEndVnode, newEndVnode)) {
+                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newEndVnode)) {
+                // Vnode moved right
+                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);
+                api.insertBefore(parentElm, oldStartVnode.elm, api.nextSibling(oldEndVnode.elm));
+                oldStartVnode = oldCh[++oldStartIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldEndVnode, newStartVnode)) {
+                // Vnode moved left
+                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);
+                api.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else {
+                if (oldKeyToIdx === undefined) {
+                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
+                }
+                idxInOld = oldKeyToIdx[newStartVnode.key];
+                if (isUndef(idxInOld)) {
+                    // New element
+                    api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);
+                }
+                else {
+                    elmToMove = oldCh[idxInOld];
+                    if (elmToMove.sel !== newStartVnode.sel) {
+                        api.insertBefore(parentElm, createElm(newStartVnode, insertedVnodeQueue), oldStartVnode.elm);
+                    }
+                    else {
+                        patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);
+                        oldCh[idxInOld] = undefined;
+                        api.insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm);
+                    }
+                }
+                newStartVnode = newCh[++newStartIdx];
+            }
+        }
+        if (newStartIdx <= newEndIdx) {
+            before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].elm;
+            addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
+        }
+        if (oldStartIdx <= oldEndIdx) {
+            removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);
+        }
+    }
+    function patchVnode(oldVnode, vnode, insertedVnodeQueue) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const hook = (_a = vnode.data) === null || _a === void 0 ? void 0 : _a.hook;
+        (_b = hook === null || hook === void 0 ? void 0 : hook.prepatch) === null || _b === void 0 ? void 0 : _b.call(hook, oldVnode, vnode);
+        const elm = (vnode.elm = oldVnode.elm);
+        if (oldVnode === vnode)
+            return;
+        if (vnode.data !== undefined ||
+            (isDef(vnode.text) && vnode.text !== oldVnode.text)) {
+            (_c = vnode.data) !== null && _c !== void 0 ? _c : (vnode.data = {});
+            (_d = oldVnode.data) !== null && _d !== void 0 ? _d : (oldVnode.data = {});
+            for (let i = 0; i < cbs.update.length; ++i)
+                cbs.update[i](oldVnode, vnode);
+            (_g = (_f = (_e = vnode.data) === null || _e === void 0 ? void 0 : _e.hook) === null || _f === void 0 ? void 0 : _f.update) === null || _g === void 0 ? void 0 : _g.call(_f, oldVnode, vnode);
+        }
+        const oldCh = oldVnode.children;
+        const ch = vnode.children;
+        if (isUndef(vnode.text)) {
+            if (isDef(oldCh) && isDef(ch)) {
+                if (oldCh !== ch)
+                    updateChildren(elm, oldCh, ch, insertedVnodeQueue);
+            }
+            else if (isDef(ch)) {
+                if (isDef(oldVnode.text))
+                    api.setTextContent(elm, "");
+                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+            }
+            else if (isDef(oldCh)) {
+                removeVnodes(elm, oldCh, 0, oldCh.length - 1);
+            }
+            else if (isDef(oldVnode.text)) {
+                api.setTextContent(elm, "");
+            }
+        }
+        else if (oldVnode.text !== vnode.text) {
+            if (isDef(oldCh)) {
+                removeVnodes(elm, oldCh, 0, oldCh.length - 1);
+            }
+            api.setTextContent(elm, vnode.text);
+        }
+        (_h = hook === null || hook === void 0 ? void 0 : hook.postpatch) === null || _h === void 0 ? void 0 : _h.call(hook, oldVnode, vnode);
+    }
+    return function patch(oldVnode, vnode) {
+        let i, elm, parent;
+        const insertedVnodeQueue = [];
+        for (i = 0; i < cbs.pre.length; ++i)
+            cbs.pre[i]();
+        if (isElement(api, oldVnode)) {
+            oldVnode = emptyNodeAt(oldVnode);
+        }
+        else if (isDocumentFragment(api, oldVnode)) {
+            oldVnode = emptyDocumentFragmentAt(oldVnode);
+        }
+        if (sameVnode(oldVnode, vnode)) {
+            patchVnode(oldVnode, vnode, insertedVnodeQueue);
+        }
+        else {
+            elm = oldVnode.elm;
+            parent = api.parentNode(elm);
+            createElm(vnode, insertedVnodeQueue);
+            if (parent !== null) {
+                api.insertBefore(parent, vnode.elm, api.nextSibling(elm));
+                removeVnodes(parent, [oldVnode], 0, 0);
+            }
+        }
+        for (i = 0; i < insertedVnodeQueue.length; ++i) {
+            insertedVnodeQueue[i].data.hook.insert(insertedVnodeQueue[i]);
+        }
+        for (i = 0; i < cbs.post.length; ++i)
+            cbs.post[i]();
+        return vnode;
+    };
+}
+
+exports.init = init;

package/lib/node_modules/.pnpm/snabbdom@3.5.1/node_modules/snabbdom/build/is.cjs

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

package/lib/node_modules/.pnpm/snabbdom@3.5.1/node_modules/snabbdom/build/jsx.cjs

@@ -0,0 +1,67 @@
+'use strict';
+
+var vnode = require('./vnode.cjs');
+var h = require('./h.cjs');
+
+/* eslint-disable @typescript-eslint/no-namespace, import/export */
+function Fragment(data, ...children) {
+    const flatChildren = flattenAndFilter(children, []);
+    if (flatChildren.length === 1 &&
+        !flatChildren[0].sel &&
+        flatChildren[0].text) {
+        // only child is a simple text node, pass as text for a simpler vtree
+        return vnode.vnode(undefined, undefined, undefined, flatChildren[0].text, undefined);
+    }
+    else {
+        return vnode.vnode(undefined, data !== null && data !== void 0 ? data : {}, flatChildren, undefined, undefined);
+    }
+}
+function flattenAndFilter(children, flattened) {
+    for (const child of children) {
+        // filter out falsey children, except 0 since zero can be a valid value e.g inside a chart
+        if (child !== undefined &&
+            child !== null &&
+            child !== false &&
+            child !== "") {
+            if (Array.isArray(child)) {
+                flattenAndFilter(child, flattened);
+            }
+            else if (typeof child === "string" ||
+                typeof child === "number" ||
+                typeof child === "boolean") {
+                flattened.push(vnode.vnode(undefined, undefined, undefined, String(child), undefined));
+            }
+            else {
+                flattened.push(child);
+            }
+        }
+    }
+    return flattened;
+}
+/**
+ * jsx/tsx compatible factory function
+ * see: https://www.typescriptlang.org/docs/handbook/jsx.html#factory-functions
+ */
+function jsx(tag, data, ...children) {
+    const flatChildren = flattenAndFilter(children, []);
+    if (typeof tag === "function") {
+        // tag is a function component
+        return tag(data, flatChildren);
+    }
+    else {
+        if (flatChildren.length === 1 &&
+            !flatChildren[0].sel &&
+            flatChildren[0].text) {
+            // only child is a simple text node, pass as text for a simpler vtree
+            return h.h(tag, data, flatChildren[0].text);
+        }
+        else {
+            return h.h(tag, data, flatChildren);
+        }
+    }
+}
+(function (jsx) {
+})(jsx || (jsx = {}));
+
+exports.Fragment = Fragment;
+exports.jsx = jsx;

package/lib/node_modules/.pnpm/snabbdom@3.5.1/node_modules/snabbdom/build/modules/attributes.cjs

@@ -0,0 +1,61 @@
+'use strict';
+
+const xlinkNS = "http://www.w3.org/1999/xlink";
+const xmlNS = "http://www.w3.org/XML/1998/namespace";
+const colonChar = 58;
+const xChar = 120;
+function updateAttrs(oldVnode, vnode) {
+    let key;
+    const elm = vnode.elm;
+    let oldAttrs = oldVnode.data.attrs;
+    let attrs = vnode.data.attrs;
+    if (!oldAttrs && !attrs)
+        return;
+    if (oldAttrs === attrs)
+        return;
+    oldAttrs = oldAttrs || {};
+    attrs = attrs || {};
+    // update modified attributes, add new attributes
+    for (key in attrs) {
+        const cur = attrs[key];
+        const old = oldAttrs[key];
+        if (old !== cur) {
+            if (cur === true) {
+                elm.setAttribute(key, "");
+            }
+            else if (cur === false) {
+                elm.removeAttribute(key);
+            }
+            else {
+                if (key.charCodeAt(0) !== xChar) {
+                    elm.setAttribute(key, cur);
+                }
+                else if (key.charCodeAt(3) === colonChar) {
+                    // Assume xml namespace
+                    elm.setAttributeNS(xmlNS, key, cur);
+                }
+                else if (key.charCodeAt(5) === colonChar) {
+                    // Assume xlink namespace
+                    elm.setAttributeNS(xlinkNS, key, cur);
+                }
+                else {
+                    elm.setAttribute(key, cur);
+                }
+            }
+        }
+    }
+    // remove removed attributes
+    // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)
+    // the other option is to remove all attributes with value == undefined
+    for (key in oldAttrs) {
+        if (!(key in attrs)) {
+            elm.removeAttribute(key);
+        }
+    }
+}
+const attributesModule = {
+    create: updateAttrs,
+    update: updateAttrs,
+};
+
+exports.attributesModule = attributesModule;