@esportsplus/template 0.12.12 → 0.14.0

package/build/attributes.d.ts

@@ -1,7 +1,9 @@
 import { Attributes, Element } from './types.js';
+declare const apply: (element: Element) => void;
+declare const spread: (element: Element, attributes: Attributes | Attributes[]) => void;
 declare const _default: {
     apply: (element: Element) => void;
-    set: (element: Element, value: unknown, name: string) => void;
     spread: (element: Element, attributes: Attributes | Attributes[]) => void;
 };
 export default _default;
+export { apply, spread };

package/build/attributes.js

@@ -1,11 +1,10 @@
 import { effect, root } from '@esportsplus/reactivity';
-import { ATTRIBUTES } from './constants.js';
 import { className, isArray, isObject, raf, removeAttribute, setAttribute } from './utilities.js';
 import event from './event.js';
 let attributes = {}, delimiters = {
     class: ' ',
     style: ';'
-};
+}, key = Symbol();
 function attribute(element, name, value) {
     if (value === false || value == null) {
         value = '';
@@ -45,12 +44,22 @@ function reactive(element, id, name, value, wait = false) {
     }
 }
 function set(element, value, name) {
-    if (typeof value === 'function') {
+    if (name === 'style' && isObject(value)) {
+        for (let key in value) {
+            set(element, value[key], name);
+        }
+    }
+    else if (isArray(value)) {
+        for (let i = 0, n = value.length; i < n; i++) {
+            set(element, value[i], name);
+        }
+    }
+    else if (typeof value === 'function') {
         if (name.startsWith('on')) {
             event(element, name, value);
         }
         else {
-            reactive(element, ('e' + store(element)[ATTRIBUTES]++), name, value, true);
+            reactive(element, ('e' + store(element)[key]++), name, value, true);
         }
     }
     else {
@@ -58,7 +67,7 @@ function set(element, value, name) {
     }
 }
 function store(element) {
-    return (element[ATTRIBUTES] || (element[ATTRIBUTES] = { [ATTRIBUTES]: 0 }));
+    return (element[key] || (element[key] = { [key]: 0 }));
 }
 function update(element, id, name, value, wait = false) {
     if (value === false || value == null) {
@@ -119,44 +128,32 @@ function update(element, id, name, value, wait = false) {
         attribute(element, name, value);
     }
 }
-export default {
-    apply: (element) => {
-        for (let key in attributes) {
-            attribute(element, key, attributes[key]);
-        }
-        attributes = {};
-    },
-    set: (element, value, name) => {
-        if (name === 'style' && isObject(value)) {
-            for (let key in value) {
-                set(element, value[key], name);
-            }
-        }
-        else if (isArray(value)) {
-            for (let i = 0, n = value.length; i < n; i++) {
-                set(element, value[i], name);
-            }
-        }
-        else {
-            set(element, value, name);
+const apply = (element) => {
+    for (let key in attributes) {
+        attribute(element, key, attributes[key]);
+    }
+    attributes = {};
+};
+const spread = function (element, attributes) {
+    if (isObject(attributes)) {
+        for (let name in attributes) {
+            set(element, attributes[name], name);
         }
-    },
-    spread: function (element, attributes) {
-        if (isObject(attributes)) {
-            for (let name in attributes) {
-                this.set(element, attributes[name], name);
+    }
+    else if (isArray(attributes)) {
+        for (let i = 0, n = attributes.length; i < n; i++) {
+            let attrs = attributes[i];
+            if (!isObject(attrs)) {
+                continue;
             }
-        }
-        else if (isArray(attributes)) {
-            for (let i = 0, n = attributes.length; i < n; i++) {
-                let attrs = attributes[i];
-                if (!isObject(attrs)) {
-                    continue;
-                }
-                for (let name in attrs) {
-                    this.set(element, attrs[name], name);
-                }
+            for (let name in attrs) {
+                set(element, attrs[name], name);
             }
         }
     }
+    else {
+        throw new Error('@esportsplus/template: attributes must be of type `Attributes` or `Attributes[]`; Received ' + JSON.stringify(attributes));
+    }
 };
+export default { apply, spread };
+export { apply, spread };

package/build/constants.d.ts

@@ -1,18 +1,16 @@
-declare const ATTRIBUTES: unique symbol;
 declare const NODE_CLOSING = 1;
 declare const NODE_ELEMENT = 3;
 declare const NODE_SLOT = 4;
 declare const NODE_VOID = 5;
 declare const NODE_WHITELIST: Record<string, number>;
 declare const REGEX_EMPTY_TEXT_NODES: RegExp;
-declare const REGEX_EVENTS: RegExp;
-declare const REGEX_EXTRA_WHITESPACE: RegExp;
-declare const REGEX_SLOT_ATTRIBUTES: RegExp;
 declare const REGEX_SLOT_NODES: RegExp;
 declare const RENDERABLE: unique symbol;
 declare const RENDERABLE_REACTIVE: unique symbol;
 declare const RENDERABLE_TEMPLATE: unique symbol;
 declare const SLOT: unique symbol;
+declare const SLOT_CLEANUP: unique symbol;
 declare const SLOT_HTML = "<!--$-->";
 declare const SLOT_MARKER = "{{$}}";
-export { ATTRIBUTES, NODE_CLOSING, NODE_ELEMENT, NODE_SLOT, NODE_VOID, NODE_WHITELIST, REGEX_EMPTY_TEXT_NODES, REGEX_EVENTS, REGEX_EXTRA_WHITESPACE, REGEX_SLOT_ATTRIBUTES, REGEX_SLOT_NODES, RENDERABLE, RENDERABLE_REACTIVE, RENDERABLE_TEMPLATE, SLOT, SLOT_HTML, SLOT_MARKER };
+declare const SLOT_MARKER_LENGTH: number;
+export { NODE_CLOSING, NODE_ELEMENT, NODE_SLOT, NODE_VOID, NODE_WHITELIST, REGEX_EMPTY_TEXT_NODES, REGEX_SLOT_NODES, RENDERABLE, RENDERABLE_REACTIVE, RENDERABLE_TEMPLATE, SLOT, SLOT_CLEANUP, SLOT_HTML, SLOT_MARKER, SLOT_MARKER_LENGTH };

package/build/constants.js

@@ -1,4 +1,3 @@
-const ATTRIBUTES = Symbol();
 const NODE_CLOSING = 1;
 const NODE_COMMENT = 2;
 const NODE_ELEMENT = 3;
@@ -25,14 +24,13 @@ const NODE_WHITELIST = {
     'wbr': NODE_VOID
 };
 const REGEX_EMPTY_TEXT_NODES = /(>|})\s+(<|{)/g;
-const REGEX_EVENTS = /(?:\s*on[\w-:]+\s*=\s*["'][^"']*["'])/g;
-const REGEX_EXTRA_WHITESPACE = /\s\s+/g;
-const REGEX_SLOT_ATTRIBUTES = /<[\w-]+([^><]*{{\$}}[^><]*)>/g;
 const REGEX_SLOT_NODES = /<([\w-]+|[\/!])(?:([^><]*{{\$}}[^><]*)|(?:[^><]*))?>|{{\$}}/g;
 const RENDERABLE = Symbol();
 const RENDERABLE_REACTIVE = Symbol();
 const RENDERABLE_TEMPLATE = Symbol();
 const SLOT = Symbol();
+const SLOT_CLEANUP = Symbol();
 const SLOT_HTML = '<!--$-->';
 const SLOT_MARKER = '{{$}}';
-export { ATTRIBUTES, NODE_CLOSING, NODE_ELEMENT, NODE_SLOT, NODE_VOID, NODE_WHITELIST, REGEX_EMPTY_TEXT_NODES, REGEX_EVENTS, REGEX_EXTRA_WHITESPACE, REGEX_SLOT_ATTRIBUTES, REGEX_SLOT_NODES, RENDERABLE, RENDERABLE_REACTIVE, RENDERABLE_TEMPLATE, SLOT, SLOT_HTML, SLOT_MARKER };
+const SLOT_MARKER_LENGTH = SLOT_MARKER.length;
+export { NODE_CLOSING, NODE_ELEMENT, NODE_SLOT, NODE_VOID, NODE_WHITELIST, REGEX_EMPTY_TEXT_NODES, REGEX_SLOT_NODES, RENDERABLE, RENDERABLE_REACTIVE, RENDERABLE_TEMPLATE, SLOT, SLOT_CLEANUP, SLOT_HTML, SLOT_MARKER, SLOT_MARKER_LENGTH };

package/build/event.d.ts

@@ -1,3 +1,3 @@
 import { Element } from './types.js';
-declare const _default: (element: Element, event: string, listener: Function) => void;
+declare const _default: (element: Element, event: `on${string}`, listener: Function) => any;
 export default _default;

package/build/event.js

@@ -1,33 +1,15 @@
 import { root } from '@esportsplus/reactivity';
+import { SLOT_CLEANUP } from './constants.js';
 import { addEventListener, defineProperty, parentElement } from './utilities.js';
-let capture = new Set(['blur', 'focus', 'scroll']), keys = {}, passive = new Set([
-    'mousedown', 'mouseenter', 'mouseleave', 'mousemove', 'mouseout', 'mouseover', 'mouseup', 'mousewheel',
-    'scroll',
-    'touchcancel', 'touchend', 'touchleave', 'touchmove', 'touchstart',
-    'wheel'
+let capture = new Set(['onblur', 'onfocus', 'onscroll']), controllers = new Map(), keys = {}, passive = new Set([
+    'onmousedown', 'onmouseenter', 'onmouseleave', 'onmousemove', 'onmouseout', 'onmouseover', 'onmouseup', 'onmousewheel',
+    'onscroll',
+    'ontouchcancel', 'ontouchend', 'ontouchleave', 'ontouchmove', 'ontouchstart',
+    'onwheel'
 ]);
-function register(event) {
-    let key = keys[event] = Symbol(), type = event.slice(2);
-    addEventListener.call(window.document, type, (e) => {
-        let node = e.target;
-        defineProperty(e, 'currentTarget', {
-            configurable: true,
-            get() {
-                return node || window.document;
-            }
-        });
-        while (node) {
-            if (key in node) {
-                return node[key].call(node, e);
-            }
-            node = parentElement.call(node);
-        }
-    }, {
-        capture: capture.has(type),
-        passive: passive.has(type)
-    });
-    return key;
-}
+['onmousemove', 'onmousewheel', 'onscroll', 'ontouchend', 'ontouchmove', 'ontouchstart', 'onwheel'].map(event => {
+    controllers.set(event, null);
+});
 export default (element, event, listener) => {
     if (event === 'onmount') {
         let interval = setInterval(() => {
@@ -45,5 +27,48 @@ export default (element, event, listener) => {
     else if (event === 'onrender') {
         return root(() => listener(element));
     }
-    element[keys[event] || register(event)] = listener;
+    let controller = controllers.get(event), signal;
+    if (controller === null) {
+        let { abort, signal } = new AbortController();
+        controllers.set(event, controller = {
+            abort,
+            signal,
+            listeners: 0,
+        });
+    }
+    if (controller) {
+        controller.listeners++;
+        (element[SLOT_CLEANUP] ??= []).push(() => {
+            if (--controller.listeners) {
+                return;
+            }
+            controller.abort();
+            controllers.set(event, null);
+        });
+        signal = controller.signal;
+    }
+    let key = keys[event];
+    if (!key) {
+        key = keys[event] = Symbol();
+        addEventListener.call(window.document, event.slice(2), (e) => {
+            let node = e.target;
+            defineProperty(e, 'currentTarget', {
+                configurable: true,
+                get() {
+                    return node || window.document;
+                }
+            });
+            while (node) {
+                if (key in node) {
+                    return node[key].call(node, e);
+                }
+                node = parentElement.call(node);
+            }
+        }, {
+            capture: capture.has(event),
+            passive: passive.has(event),
+            signal
+        });
+    }
+    element[key] = listener;
 };

package/build/html/cache.js

@@ -1,67 +1,19 @@
-import { NODE_CLOSING, NODE_ELEMENT, NODE_SLOT, NODE_VOID, NODE_WHITELIST, REGEX_EMPTY_TEXT_NODES, REGEX_EVENTS, REGEX_EXTRA_WHITESPACE, REGEX_SLOT_ATTRIBUTES, REGEX_SLOT_NODES, SLOT_HTML, SLOT_MARKER } from '../constants.js';
+import { NODE_CLOSING, NODE_ELEMENT, NODE_SLOT, NODE_VOID, NODE_WHITELIST, REGEX_EMPTY_TEXT_NODES, REGEX_SLOT_NODES, SLOT_HTML, SLOT_MARKER, SLOT_MARKER_LENGTH } from '../constants.js';
 import { firstChild, firstElementChild, fragment, nextElementSibling, nextSibling } from '../utilities.js';
-import a from '../attributes.js';
+import { spread } from '../attributes.js';
 import s from '../slot.js';
 let cache = new WeakMap();
 function build(literals, values) {
     if (values.length === 0) {
         return set(literals, literals[0]);
     }
-    let attributes = {}, buffer = '', html = minify(literals.join(SLOT_MARKER)), index = 0, level = 0, levels = [{
+    let buffer = '', html = literals.join(SLOT_MARKER)
+        .replace(REGEX_EMPTY_TEXT_NODES, '$1$2')
+        .trim(), index = 0, level = 0, levels = [{
             children: 0,
             elements: 0,
             path: []
-        }], slot = 0, slots = [], total = values.length;
-    {
-        let attribute = '', buffer = '', char = '', quote = '';
-        for (let match of html.matchAll(REGEX_SLOT_ATTRIBUTES)) {
-            let found = match[1], metadata = attributes[found];
-            if (metadata) {
-                continue;
-            }
-            metadata = attributes[found] = [];
-            for (let i = 0, n = found.length; i < n; i++) {
-                char = found[i];
-                if (char === ' ') {
-                    buffer = '';
-                }
-                else if (char === '=') {
-                    attribute = buffer;
-                    buffer = '';
-                }
-                else if (char === '"' || char === "'") {
-                    if (!attribute) {
-                    }
-                    else if (!quote) {
-                        quote = char;
-                    }
-                    else if (quote === char) {
-                        attribute = '';
-                        buffer = '';
-                        quote = '';
-                    }
-                }
-                else if (char === '{' && char !== buffer) {
-                    buffer = char;
-                }
-                else {
-                    buffer += char;
-                    if (buffer === SLOT_MARKER) {
-                        buffer = '';
-                        if (attribute) {
-                            metadata.push(attribute);
-                            if (!quote) {
-                                attribute = '';
-                            }
-                        }
-                        else {
-                            metadata.push(null);
-                        }
-                    }
-                }
-            }
-        }
-    }
+        }], parsed = html.split(SLOT_MARKER), slot = 0, slots = [], total = values.length;
     for (let match of html.matchAll(REGEX_SLOT_NODES)) {
         let parent = levels[level], type = match[1] === undefined ? NODE_SLOT : (NODE_WHITELIST[match[1].toLowerCase()] || NODE_ELEMENT);
         if ((match.index || 1) - 1 > index) {
@@ -70,19 +22,15 @@ function build(literals, values) {
         if (type === NODE_ELEMENT || type === NODE_VOID) {
             let attr = match[2];
             if (attr) {
-                let metadata = attributes[attr], path = methods(parent.children, parent.path, firstChild, nextSibling);
-                if (!metadata) {
-                    throw new Error(`Template: attribute metadata could not be found for '${attr}'`);
-                }
-                for (let i = 0, n = metadata.length; i < n; i++) {
-                    let name = metadata[i];
+                let i = attr.indexOf(SLOT_MARKER), path = methods(parent.children, parent.path, firstChild, nextSibling);
+                while (i !== -1) {
                     slots.push({
-                        fn: name === null ? a.spread : a.set,
-                        name,
+                        fn: spread,
                         path,
                         slot
                     });
-                    buffer += literals[slot++];
+                    buffer += parsed[slot++];
+                    i = attr.indexOf(SLOT_MARKER, i + SLOT_MARKER_LENGTH);
                 }
             }
             if (type === NODE_ELEMENT) {
@@ -97,16 +45,15 @@ function build(literals, values) {
             parent.elements++;
         }
         else if (type === NODE_SLOT) {
-            buffer += literals[slot] + SLOT_HTML;
+            buffer += parsed[slot] + SLOT_HTML;
             slots.push({
                 fn: s,
-                name: null,
                 path: methods(parent.children, parent.path, firstChild, nextSibling),
                 slot: slot++
             });
         }
         if (slot === total) {
-            buffer += literals[slot];
+            buffer += parsed[slot];
             break;
         }
         if (type === NODE_CLOSING) {
@@ -117,7 +64,7 @@ function build(literals, values) {
         }
         index = (match.index || 0) + match[0].length;
     }
-    return set(literals, minify(buffer.replace(REGEX_EVENTS, '')), slots);
+    return set(literals, buffer, slots);
 }
 function methods(children, copy, first, next) {
     let methods = copy.slice();
@@ -127,9 +74,6 @@ function methods(children, copy, first, next) {
     }
     return methods;
 }
-function minify(html) {
-    return html.replace(REGEX_EMPTY_TEXT_NODES, '$1$2').replace(REGEX_EXTRA_WHITESPACE, ' ').trim();
-}
 function set(literals, html, slots = null) {
     let template = {
         fragment: fragment(html),

package/build/html/hydrate.js

@@ -1,6 +1,6 @@
 import { root } from '@esportsplus/reactivity';
 import { cloneNode, firstChild, nextSibling } from '../utilities.js';
-import a from '../attributes.js';
+import { apply } from '../attributes.js';
 import cache from './cache.js';
 function reactive(renderable, slot) {
     let array = renderable.values, factory = renderable.template, refresh = () => {
@@ -23,10 +23,10 @@ function render(renderable, template) {
     if (slots !== null) {
         let node, previous, values = renderable.values;
         for (let i = slots.length - 1; i >= 0; i--) {
-            let { fn, name, path, slot } = slots[i];
+            let { fn, path, slot } = slots[i];
             if (path === previous) { }
             else {
-                a.apply(node);
+                apply(node);
                 node = fragment;
                 previous = path;
                 for (let o = 0, j = path.length; o < j; o++) {
@@ -35,7 +35,9 @@ function render(renderable, template) {
             }
             fn(node, values[slot], name);
         }
-        a.apply(node);
+        if (node) {
+            apply(node);
+        }
     }
     for (let element = firstChild.call(fragment); element; element = nextSibling.call(element)) {
         elements.push(element);

package/build/slot.d.ts

@@ -10,10 +10,10 @@ declare class Slot {
     set length(n: number);
     anchor(index?: number): Element;
     clear(): void;
-    pop(): Elements | undefined;
+    pop(): Elements[] | undefined;
     push(...groups: Elements[]): number;
     render(input: unknown): this;
-    shift(): Elements | undefined;
+    shift(): Elements[] | undefined;
     splice(start: number, stop?: number, ...groups: Elements[]): Elements[];
     unshift(...groups: Elements[]): number;
 }

package/build/slot.js

@@ -1,9 +1,9 @@
 import { effect, root, DIRTY } from '@esportsplus/reactivity';
-import { RENDERABLE, RENDERABLE_REACTIVE, SLOT } from './constants.js';
+import { RENDERABLE, RENDERABLE_REACTIVE, SLOT, SLOT_CLEANUP } from './constants.js';
 import { hydrate } from './html/index.js';
 import { firstChild, isArray, isObject, nextSibling, nodeValue, raf, text } from './utilities.js';
-let cleanup = [], key = Symbol(), scheduled = false;
-function afterGroups(anchor, groups) {
+let cleanup = [], scheduled = false;
+function after(anchor, groups) {
     for (let i = 0, n = groups.length; i < n; i++) {
         let group = groups[i];
         if (group.length) {
@@ -13,29 +13,13 @@ function afterGroups(anchor, groups) {
     }
     return groups;
 }
-function removeGroup(group) {
-    if (group === undefined) {
-        return group;
-    }
-    for (let i = 0, n = group.length; i < n; i++) {
-        let item = group[i];
-        if (key in item) {
-            cleanup.push(item[key]);
-        }
-        item.remove();
-    }
-    if (!scheduled && cleanup.length) {
-        schedule();
-    }
-    return group;
-}
-function removeGroups(groups) {
+function remove(...groups) {
     for (let i = 0, n = groups.length; i < n; i++) {
         let group = groups[i];
         for (let j = 0, o = group.length; j < o; j++) {
             let item = group[j];
-            if (key in item) {
-                cleanup.push(item[key]);
+            if (item[SLOT_CLEANUP]) {
+                cleanup.push(...item[SLOT_CLEANUP]);
             }
             item.remove();
         }
@@ -55,12 +39,12 @@ function render(anchor, input, slot) {
             for (let i = 0, n = input.length; i < n; i++) {
                 groups.push(render(null, input[i]));
             }
-            return anchor ? afterGroups(anchor, groups) : groups;
+            return anchor ? after(anchor, groups) : groups;
         }
         let nodes = [];
         if (RENDERABLE in input) {
             if (input[RENDERABLE] === RENDERABLE_REACTIVE) {
-                return afterGroups(anchor, hydrate.reactive(input, slot));
+                return after(anchor, hydrate.reactive(input, slot));
             }
             else {
                 nodes = hydrate.static(input);
@@ -98,13 +82,16 @@ function schedule() {
     scheduled = true;
     raf.add(() => {
         try {
-            let slot;
-            while (slot = cleanup.pop()) {
-                slot.clear();
+            let fn;
+            while (fn = cleanup.pop()) {
+                fn();
             }
         }
         catch (e) { }
         scheduled = false;
+        if (cleanup.length) {
+            schedule();
+        }
     });
 }
 class Slot {
@@ -113,7 +100,9 @@ class Slot {
     nodes;
     text = null;
     constructor(marker) {
-        marker[key] = this;
+        (marker[SLOT_CLEANUP] ??= []).push(() => {
+            this.clear();
+        });
         this.marker = marker;
         this.nodes = [];
     }
@@ -131,14 +120,18 @@ class Slot {
         return node || this.marker;
     }
     clear() {
-        removeGroups(this.nodes);
+        remove(...this.nodes);
         this.text = null;
     }
     pop() {
-        return removeGroup(this.nodes.pop());
+        let group = this.nodes.pop();
+        if (!group) {
+            return undefined;
+        }
+        return remove(group);
     }
     push(...groups) {
-        afterGroups(this.anchor(), groups);
+        after(this.anchor(), groups);
         for (let i = 0, n = groups.length; i < n; i++) {
             this.nodes.push(groups[i]);
         }
@@ -182,13 +175,17 @@ class Slot {
         return this;
     }
     shift() {
-        return removeGroup(this.nodes.shift());
+        let group = this.nodes.shift();
+        if (!group) {
+            return undefined;
+        }
+        return remove(group);
     }
     splice(start, stop = this.nodes.length, ...groups) {
-        return removeGroups(this.nodes.splice(start, stop, ...afterGroups(this.anchor(start), groups)));
+        return remove(...this.nodes.splice(start, stop, ...after(this.anchor(start), groups)));
     }
     unshift(...groups) {
-        return this.nodes.unshift(...afterGroups(this.marker, groups));
+        return this.nodes.unshift(...after(this.marker, groups));
     }
 }
 export default (marker, value) => {

package/build/types.d.ts

@@ -1,5 +1,5 @@
 import { ReactiveArray } from '@esportsplus/reactivity';
-import { RENDERABLE, RENDERABLE_REACTIVE, RENDERABLE_TEMPLATE } from './constants.js';
+import { RENDERABLE, RENDERABLE_REACTIVE, RENDERABLE_TEMPLATE, SLOT_CLEANUP } from './constants.js';
 import { firstChild } from './utilities.js';
 import attributes from './attributes.js';
 import event from './event.js';
@@ -12,10 +12,14 @@ type Attributes = {
 } & {
     [key: `aria-${string}`]: string | number | boolean | undefined;
     [key: `data-${string}`]: string | undefined;
+    onmount?: (element: Element) => void;
+    onrender?: (element: Element) => void;
 } & Record<PropertyKey, unknown>;
 type Effect<T> = () => EffectResponse<T>;
 type EffectResponse<T> = T extends [] ? EffectResponse<T[number]>[] : Primitive | Renderable<T>;
-type Element = HTMLElement & Attributes & Record<PropertyKey, unknown>;
+type Element = HTMLElement & Attributes & {
+    [SLOT_CLEANUP]?: VoidFunction[];
+} & Record<PropertyKey, unknown>;
 type Elements = Element[];
 type Primitive = bigint | boolean | null | number | string | undefined;
 type Renderable<T = unknown> = RenderableReactive<T> | RenderableTemplate<T>;
@@ -37,8 +41,7 @@ type Template = {
     html: string;
     literals: TemplateStringsArray;
     slots: {
-        fn: typeof attributes.set | typeof attributes.spread | typeof event | typeof slot;
-        name: PropertyKey | null;
+        fn: typeof attributes.spread | typeof event | typeof slot;
         path: typeof firstChild[];
         slot: number;
     }[] | null;

package/build/types.js

@@ -1 +1 @@
-import { RENDERABLE } from './constants.js';
+import { RENDERABLE, SLOT_CLEANUP } from './constants.js';

package/package.json

@@ -3,7 +3,7 @@
   "dependencies": {
     "@esportsplus/reactivity": "^0.4.6",
     "@esportsplus/tasks": "^0.1.9",
-    "@esportsplus/utilities": "^0.18.2"
+    "@esportsplus/utilities": "^0.19.0"
   },
   "devDependencies": {
     "@esportsplus/typescript": "^0.9.1"
@@ -13,7 +13,7 @@
   "private": false,
   "type": "module",
   "types": "./build/index.d.ts",
-  "version": "0.12.12",
+  "version": "0.14.0",
   "scripts": {
     "build": "tsc && tsc-alias",
     "-": "-"