@esportsplus/template 0.34.0 → 0.35.0

package/build/compiler/codegen.d.ts

@@ -4,9 +4,8 @@ type CodegenResult = {
     changed: boolean;
     code: string;
 };
-declare const addImport: (code: string) => string;
 declare const generateCode: (templates: TemplateInfo[], originalCode: string, sourceFile: ts.SourceFile, checker?: ts.TypeChecker) => CodegenResult;
 declare const generateReactiveInlining: (calls: ReactiveCallInfo[], code: string, sourceFile: ts.SourceFile) => string;
 declare const needsArraySlotImport: (sourceFile: ts.SourceFile) => boolean;
-export { addImport, generateCode, generateReactiveInlining, needsArraySlotImport };
+export { generateCode, generateReactiveInlining, needsArraySlotImport };
 export type { CodegenResult };

package/build/compiler/codegen.js

@@ -1,10 +1,9 @@
 import { ts } from '@esportsplus/typescript';
-import { ast, code as c, uid } from '@esportsplus/typescript/compiler';
+import { ast, code as c, imports, uid } from '@esportsplus/typescript/compiler';
+import { COMPILER_ENTRYPOINT, COMPILER_TYPES, PACKAGE } from '../constants.js';
 import { analyzeExpression, generateAttributeBinding, generateSpreadBindings } from './type-analyzer.js';
-import { COMPILER_ENTRYPOINT, COMPILER_NAMESPACE, COMPILER_TYPES, PACKAGE, PACKAGE_COMPILER } from '../constants.js';
 import parser from './parser.js';
 const ARROW_EMPTY_PARAMS = /\(\s*\)\s*=>\s*$/;
-const REGEX_PACKAGE_IMPORT = new RegExp(`import\\s*\\{[^}]*\\}\\s*from\\s*['"]${PACKAGE.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"];?\\n?`, 'g');
 let printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
 function collectNestedTemplateReplacements(ctx, node, exprStart, replacements) {
     if (isNestedHtmlTemplate(node)) {
@@ -36,7 +35,8 @@ function generateNestedTemplateCode(ctx, node) {
 }
 function generateNodeBinding(ctx, anchor, exprText, exprNode) {
     if (!exprNode) {
-        return `${COMPILER_NAMESPACE}.slot(${anchor}, ${exprText});`;
+        ctx.neededImports.add('slot');
+        return `slot(${anchor}, ${exprText});`;
     }
     if (isNestedHtmlTemplate(exprNode)) {
         return `${anchor}.parentNode.insertBefore(${generateNestedTemplateCode(ctx, exprNode)}, ${anchor});`;
@@ -44,15 +44,18 @@ function generateNodeBinding(ctx, anchor, exprText, exprNode) {
     let slotType = analyzeExpression(exprNode, ctx.checker);
     switch (slotType) {
         case COMPILER_TYPES.Effect:
-            return `new ${COMPILER_NAMESPACE}.EffectSlot(${anchor}, ${exprText});`;
+            ctx.neededImports.add('EffectSlot');
+            return `new EffectSlot(${anchor}, ${exprText});`;
         case COMPILER_TYPES.ArraySlot:
-            return `new ${COMPILER_NAMESPACE}.ArraySlot(${anchor}, ${exprText});`;
+            ctx.neededImports.add('ArraySlot');
+            return `new ArraySlot(${anchor}, ${exprText});`;
         case COMPILER_TYPES.Static:
             return `${anchor}.textContent = ${exprText};`;
         case COMPILER_TYPES.DocumentFragment:
             return `${anchor}.parentNode.insertBefore(${exprText}, ${anchor});`;
         default:
-            return `${COMPILER_NAMESPACE}.slot(${anchor}, ${exprText});`;
+            ctx.neededImports.add('slot');
+            return `slot(${anchor}, ${exprText});`;
     }
 }
 function generateTemplateCode(ctx, { html, slots }, exprTexts, exprNodes, isArrowBody) {
@@ -81,7 +84,8 @@ function generateTemplateCode(ctx, { html, slots }, exprTexts, exprNodes, isArro
             }
         }
         let name = uid('element'), suffix = path.slice(startIdx).join('.');
-        declarations.push(`${name} = ${ancestorVar}.${suffix} as ${COMPILER_NAMESPACE}.Element`);
+        ctx.neededImports.add('Element');
+        declarations.push(`${name} = ${ancestorVar}.${suffix} as Element`);
         nodes.set(key, name);
     }
     code.push(isArrowBody ? '{' : `(() => {`, `let ${declarations.join(',\n')};`);
@@ -94,14 +98,14 @@ function generateTemplateCode(ctx, { html, slots }, exprTexts, exprNodes, isArro
             for (let j = 0, m = names.length; j < m; j++) {
                 let name = names[j];
                 if (name === COMPILER_TYPES.Attributes) {
-                    let bindings = generateSpreadBindings(exprNodes[index], exprTexts[index] || 'undefined', elementVar, ctx.checker, COMPILER_NAMESPACE);
+                    let bindings = generateSpreadBindings(exprNodes[index], exprTexts[index] || 'undefined', elementVar, ctx.checker, ctx.neededImports);
                     for (let k = 0, o = bindings.length; k < o; k++) {
                         code.push(bindings[k]);
                     }
                     index++;
                 }
                 else {
-                    code.push(generateAttributeBinding(elementVar, name, exprTexts[index++] || 'undefined', slot.attributes.statics[name] || '', COMPILER_NAMESPACE));
+                    code.push(generateAttributeBinding(elementVar, name, exprTexts[index++] || 'undefined', slot.attributes.statics[name] || '', ctx.neededImports));
                 }
             }
         }
@@ -155,12 +159,6 @@ function rewriteExpression(ctx, expr) {
     collectNestedTemplateReplacements(ctx, expr, expr.getStart(), replacements);
     return c.replaceReverse(expr.getText(ctx.sourceFile), replacements);
 }
-const addImport = (code) => {
-    return `import * as ${COMPILER_NAMESPACE} from '${PACKAGE_COMPILER}';\n` + code;
-};
-const removePackageImport = (code) => {
-    return code.replace(REGEX_PACKAGE_IMPORT, '');
-};
 const generateCode = (templates, originalCode, sourceFile, checker) => {
     if (templates.length === 0) {
         return { changed: false, code: originalCode };
@@ -180,6 +178,7 @@ const generateCode = (templates, originalCode, sourceFile, checker) => {
         checker,
         hoistedFactories: new Map(),
         htmlToTemplateId: new Map(),
+        neededImports: new Set(['template']),
         printer,
         sourceFile
     }, replacements = [];
@@ -210,9 +209,12 @@ const generateCode = (templates, originalCode, sourceFile, checker) => {
     if (changed && ctx.hoistedFactories.size > 0) {
         let factories = [];
         for (let [id, html] of ctx.hoistedFactories) {
-            factories.push(`const ${id} = ${COMPILER_NAMESPACE}.template(\`${html}\`);`);
+            factories.push(`const ${id} = template(\`${html}\`);`);
         }
-        code = addImport(factories.join('\n') + removePackageImport(code));
+        code = imports.modify(factories.join('\n') + code, sourceFile, PACKAGE, {
+            add: ctx.neededImports,
+            remove: [COMPILER_ENTRYPOINT]
+        });
     }
     return { changed, code };
 };
@@ -225,7 +227,7 @@ const generateReactiveInlining = (calls, code, sourceFile) => {
         let call = calls[i];
         replacements.push({
             end: call.end,
-            newText: `new ${COMPILER_NAMESPACE}.ArraySlot(
+            newText: `new ArraySlot(
                 ${printer.printNode(ts.EmitHint.Expression, call.arrayArg, sourceFile)},
                 ${printer.printNode(ts.EmitHint.Expression, call.callbackArg, sourceFile)}
             )`,
@@ -236,7 +238,7 @@ const generateReactiveInlining = (calls, code, sourceFile) => {
 };
 const needsArraySlotImport = (sourceFile) => {
     return ast.hasMatch(sourceFile, n => ts.isNewExpression(n) &&
-        ts.isPropertyAccessExpression(n.expression) &&
-        n.expression.name.text === 'ArraySlot') && !hasArraySlotImport(sourceFile);
+        ts.isIdentifier(n.expression) &&
+        n.expression.text === 'ArraySlot') && !hasArraySlotImport(sourceFile);
 };
-export { addImport, generateCode, generateReactiveInlining, needsArraySlotImport };
+export { generateCode, generateReactiveInlining, needsArraySlotImport };

package/build/compiler/index.d.ts

@@ -6,9 +6,3 @@ type TransformResult = {
 };
 declare const transform: (sourceFile: ts.SourceFile, program: ts.Program) => TransformResult;
 export { transform };
-export * from '../attributes.js';
-export * from '../event/index.js';
-export { ArraySlot } from '../slot/array.js';
-export { EffectSlot } from '../slot/effect.js';
-export type * from '../types.js';
-export * from '../utilities.js';

package/build/compiler/index.js

@@ -1,8 +1,8 @@
-import { code as c } from '@esportsplus/typescript/compiler';
-import { addImport, generateCode, generateReactiveInlining, needsArraySlotImport } from './codegen.js';
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY } from '../constants.js';
-import { findHtmlTemplates, findReactiveCalls } from './ts-parser.js';
 import { ts } from '@esportsplus/typescript';
+import { code as c, imports } from '@esportsplus/typescript/compiler';
+import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, PACKAGE } from '../constants.js';
+import { generateCode, generateReactiveInlining, needsArraySlotImport } from './codegen.js';
+import { findHtmlTemplates, findReactiveCalls } from './ts-parser.js';
 const PATTERNS = [`${COMPILER_ENTRYPOINT}\``, `${COMPILER_ENTRYPOINT}.${COMPILER_ENTRYPOINT_REACTIVITY}`];
 const REGEX_BACKSLASH = /\\/g;
 const REGEX_FORWARD_SLASH = /\//g;
@@ -18,15 +18,14 @@ const transform = (sourceFile, program) => {
         checker = program.getTypeChecker();
         sourceFile = programSourceFile;
     }
-    let changed = false, codegenChanged = false, needsImport = false, reactiveCalls = findReactiveCalls(sourceFile), result = code;
+    let changed = false, codegenChanged = false, needsImport = false, reactiveCalls = findReactiveCalls(sourceFile, checker), result = code;
     if (reactiveCalls.length > 0) {
         changed = true;
-        checker = undefined;
         result = generateReactiveInlining(reactiveCalls, result, sourceFile);
         sourceFile = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
         needsImport = needsArraySlotImport(sourceFile);
     }
-    let templates = findHtmlTemplates(sourceFile);
+    let templates = findHtmlTemplates(sourceFile, checker);
     if (templates.length > 0) {
         let codegenResult = generateCode(templates, result, sourceFile, checker);
         if (codegenResult.changed) {
@@ -36,7 +35,7 @@ const transform = (sourceFile, program) => {
         }
     }
     if (needsImport && !codegenChanged) {
-        result = addImport(result);
+        result = imports.modify(result, sourceFile, PACKAGE, { add: ['ArraySlot'] });
     }
     if (changed) {
         sourceFile = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
@@ -44,8 +43,3 @@ const transform = (sourceFile, program) => {
     return { changed, code: result, sourceFile };
 };
 export { transform };
-export * from '../attributes.js';
-export * from '../event/index.js';
-export { ArraySlot } from '../slot/array.js';
-export { EffectSlot } from '../slot/effect.js';
-export * from '../utilities.js';

package/build/compiler/ts-parser.d.ts

@@ -14,7 +14,7 @@ type TemplateInfo = {
     node: ts.TaggedTemplateExpression;
     start: number;
 };
-declare const findHtmlTemplates: (sourceFile: ts.SourceFile) => TemplateInfo[];
-declare const findReactiveCalls: (sourceFile: ts.SourceFile) => ReactiveCallInfo[];
+declare const findHtmlTemplates: (sourceFile: ts.SourceFile, checker?: ts.TypeChecker) => TemplateInfo[];
+declare const findReactiveCalls: (sourceFile: ts.SourceFile, checker?: ts.TypeChecker) => ReactiveCallInfo[];
 export { findHtmlTemplates, findReactiveCalls };
 export type { ReactiveCallInfo, TemplateInfo };

package/build/compiler/ts-parser.js

@@ -1,12 +1,38 @@
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY } from '../constants.js';
 import { ts } from '@esportsplus/typescript';
-function visitReactiveCalls(node, calls) {
+import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, PACKAGE } from '../constants.js';
+function isHtmlFromPackage(node, checker) {
+    if (node.text !== COMPILER_ENTRYPOINT) {
+        return false;
+    }
+    if (!checker) {
+        return true;
+    }
+    let symbol = checker.getSymbolAtLocation(node);
+    if (!symbol) {
+        return true;
+    }
+    if (symbol.flags & ts.SymbolFlags.Alias) {
+        symbol = checker.getAliasedSymbol(symbol);
+    }
+    let declarations = symbol.getDeclarations();
+    if (!declarations || declarations.length === 0) {
+        return true;
+    }
+    for (let i = 0, n = declarations.length; i < n; i++) {
+        let fileName = declarations[i].getSourceFile().fileName;
+        if (fileName.includes(PACKAGE) || fileName.includes('@esportsplus/template')) {
+            return true;
+        }
+    }
+    return false;
+}
+function visitReactiveCalls(node, calls, checker) {
     if (ts.isCallExpression(node) &&
         ts.isPropertyAccessExpression(node.expression) &&
         ts.isIdentifier(node.expression.expression) &&
-        node.expression.expression.text === COMPILER_ENTRYPOINT &&
         node.expression.name.text === COMPILER_ENTRYPOINT_REACTIVITY &&
-        node.arguments.length === 2) {
+        node.arguments.length === 2 &&
+        isHtmlFromPackage(node.expression.expression, checker)) {
         calls.push({
             arrayArg: node.arguments[0],
             callbackArg: node.arguments[1],
@@ -15,13 +41,13 @@ function visitReactiveCalls(node, calls) {
             start: node.getStart()
         });
     }
-    ts.forEachChild(node, child => visitReactiveCalls(child, calls));
+    ts.forEachChild(node, child => visitReactiveCalls(child, calls, checker));
 }
-function visitTemplates(node, depth, templates) {
+function visitTemplates(node, depth, templates, checker) {
     let nextDepth = (ts.isArrowFunction(node) || ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isMethodDeclaration(node))
         ? depth + 1
         : depth;
-    if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && node.tag.text === COMPILER_ENTRYPOINT) {
+    if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && isHtmlFromPackage(node.tag, checker)) {
         let expressions = [], literals = [], template = node.template;
         if (ts.isNoSubstitutionTemplateLiteral(template)) {
             literals.push(template.text);
@@ -43,17 +69,17 @@ function visitTemplates(node, depth, templates) {
             start: node.getStart()
         });
     }
-    ts.forEachChild(node, child => visitTemplates(child, nextDepth, templates));
+    ts.forEachChild(node, child => visitTemplates(child, nextDepth, templates, checker));
 }
-const findHtmlTemplates = (sourceFile) => {
+const findHtmlTemplates = (sourceFile, checker) => {
     let templates = [];
-    visitTemplates(sourceFile, 0, templates);
+    visitTemplates(sourceFile, 0, templates, checker);
     templates.sort((a, b) => a.depth !== b.depth ? b.depth - a.depth : a.start - b.start);
     return templates;
 };
-const findReactiveCalls = (sourceFile) => {
+const findReactiveCalls = (sourceFile, checker) => {
     let calls = [];
-    visitReactiveCalls(sourceFile, calls);
+    visitReactiveCalls(sourceFile, calls, checker);
     return calls;
 };
 export { findHtmlTemplates, findReactiveCalls };

package/build/compiler/type-analyzer.d.ts

@@ -1,6 +1,6 @@
 import { COMPILER_TYPES } from '../constants.js';
 import { ts } from '@esportsplus/typescript';
 declare const analyzeExpression: (expr: ts.Expression, checker?: ts.TypeChecker) => COMPILER_TYPES;
-declare const generateAttributeBinding: (elementVar: string, name: string, expr: string, staticValue: string, ns: string) => string;
-declare const generateSpreadBindings: (expr: ts.Expression, exprCode: string, elementVar: string, checker: ts.TypeChecker | undefined, ns: string) => string[];
+declare const generateAttributeBinding: (elementVar: string, name: string, expr: string, staticValue: string, neededImports: Set<string>) => string;
+declare const generateSpreadBindings: (expr: ts.Expression, exprCode: string, elementVar: string, checker: ts.TypeChecker | undefined, neededImports: Set<string>) => string[];
 export { analyzeExpression, generateAttributeBinding, generateSpreadBindings };

package/build/compiler/type-analyzer.js

@@ -119,35 +119,43 @@ function isTypeFunction(type, checker) {
 const analyzeExpression = (expr, checker) => {
     return inferCOMPILER_TYPES(expr, checker);
 };
-const generateAttributeBinding = (elementVar, name, expr, staticValue, ns) => {
+const generateAttributeBinding = (elementVar, name, expr, staticValue, neededImports) => {
     if (name.startsWith('on') && name.length > 2) {
         let event = name.slice(2).toLowerCase(), key = name.toLowerCase();
         if (LIFECYCLE_EVENTS.has(key)) {
-            return `${ns}.${key}(${elementVar}, ${expr});`;
+            neededImports.add(key);
+            return `${key}(${elementVar}, ${expr});`;
         }
         if (DIRECT_ATTACH_EVENTS.has(key)) {
-            return `${ns}.on(${elementVar}, '${event}', ${expr});`;
+            neededImports.add('on');
+            return `on(${elementVar}, '${event}', ${expr});`;
         }
-        return `${ns}.delegate(${elementVar}, '${event}', ${expr});`;
+        neededImports.add('delegate');
+        return `delegate(${elementVar}, '${event}', ${expr});`;
     }
     if (name === 'class') {
-        return `${ns}.setClass(${elementVar}, '${staticValue}', ${expr});`;
+        neededImports.add('setClass');
+        return `setClass(${elementVar}, '${staticValue}', ${expr});`;
     }
     if (name === COMPILER_TYPES.Attributes) {
-        return `${ns}.setProperties(${elementVar}, ${expr});`;
+        neededImports.add('setProperties');
+        return `setProperties(${elementVar}, ${expr});`;
     }
     if (name === 'style') {
-        return `${ns}.setStyle(${elementVar}, '${staticValue}', ${expr});`;
+        neededImports.add('setStyle');
+        return `setStyle(${elementVar}, '${staticValue}', ${expr});`;
     }
-    return `${ns}.setProperty(${elementVar}, '${name}', ${expr});`;
+    neededImports.add('setProperty');
+    return `setProperty(${elementVar}, '${name}', ${expr});`;
 };
-const generateSpreadBindings = (expr, exprCode, elementVar, checker, ns) => {
+const generateSpreadBindings = (expr, exprCode, elementVar, checker, neededImports) => {
     while (ts.isParenthesizedExpression(expr)) {
         expr = expr.expression;
     }
     let analysis = analyzeSpread(expr, checker);
     if (!analysis.canUnpack) {
-        return [`${ns}.setProperties(${elementVar}, ${exprCode});`];
+        neededImports.add('setProperties');
+        return [`setProperties(${elementVar}, ${exprCode});`];
     }
     let lines = [];
     if (ts.isObjectLiteralExpression(expr)) {
@@ -170,14 +178,14 @@ const generateSpreadBindings = (expr, exprCode, elementVar, checker, ns) => {
                 }
             }
             if (value !== null) {
-                lines.push(generateAttributeBinding(elementVar, key, value, '', ns));
+                lines.push(generateAttributeBinding(elementVar, key, value, '', neededImports));
             }
         }
     }
     else {
         for (let i = 0, n = analysis.keys.length; i < n; i++) {
             let key = analysis.keys[i];
-            lines.push(generateAttributeBinding(elementVar, key, `${exprCode}.${key}`, '', ns));
+            lines.push(generateAttributeBinding(elementVar, key, `${exprCode}.${key}`, '', neededImports));
         }
     }
     return lines;

package/build/constants.d.ts

@@ -2,7 +2,6 @@ declare const ARRAY_SLOT: unique symbol;
 declare const CLEANUP: unique symbol;
 declare const COMPILER_ENTRYPOINT = "html";
 declare const COMPILER_ENTRYPOINT_REACTIVITY = "reactive";
-declare const COMPILER_NAMESPACE: string;
 declare const enum COMPILER_TYPES {
     ArraySlot = "array-slot",
     Attributes = "attributes",
@@ -17,10 +16,9 @@ declare const enum COMPILER_TYPES {
 declare const DIRECT_ATTACH_EVENTS: Set<string>;
 declare const LIFECYCLE_EVENTS: Set<string>;
 declare const PACKAGE = "@esportsplus/template";
-declare const PACKAGE_COMPILER = "@esportsplus/template/compiler";
 declare const SLOT_HTML = "<!--$-->";
 declare const STATE_HYDRATING = 0;
 declare const STATE_NONE = 1;
 declare const STATE_WAITING = 2;
 declare const STORE: unique symbol;
-export { ARRAY_SLOT, CLEANUP, COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_NAMESPACE, COMPILER_TYPES, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS, PACKAGE, PACKAGE_COMPILER, SLOT_HTML, STATE_HYDRATING, STATE_NONE, STATE_WAITING, STORE, };
+export { ARRAY_SLOT, CLEANUP, COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_TYPES, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS, PACKAGE, SLOT_HTML, STATE_HYDRATING, STATE_NONE, STATE_WAITING, STORE, };

package/build/constants.js

@@ -1,9 +1,7 @@
-import { uid } from '@esportsplus/typescript/compiler';
 const ARRAY_SLOT = Symbol('template.array.slot');
 const CLEANUP = Symbol('template.cleanup');
 const COMPILER_ENTRYPOINT = 'html';
 const COMPILER_ENTRYPOINT_REACTIVITY = 'reactive';
-const COMPILER_NAMESPACE = uid('template');
 var COMPILER_TYPES;
 (function (COMPILER_TYPES) {
     COMPILER_TYPES["ArraySlot"] = "array-slot";
@@ -30,10 +28,9 @@ const LIFECYCLE_EVENTS = new Set([
     'onconnect', 'ondisconnect', 'onrender', 'onresize', 'ontick'
 ]);
 const PACKAGE = '@esportsplus/template';
-const PACKAGE_COMPILER = '@esportsplus/template/compiler';
 const SLOT_HTML = '<!--$-->';
 const STATE_HYDRATING = 0;
 const STATE_NONE = 1;
 const STATE_WAITING = 2;
 const STORE = Symbol('template.store');
-export { ARRAY_SLOT, CLEANUP, COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_NAMESPACE, COMPILER_TYPES, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS, PACKAGE, PACKAGE_COMPILER, SLOT_HTML, STATE_HYDRATING, STATE_NONE, STATE_WAITING, STORE, };
+export { ARRAY_SLOT, CLEANUP, COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_TYPES, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS, PACKAGE, SLOT_HTML, STATE_HYDRATING, STATE_NONE, STATE_WAITING, STORE, };

package/build/index.d.ts

@@ -1,5 +1,10 @@
-import './runtime.js';
 export { default as html } from './html.js';
 export { default as render } from './render.js';
 export { default as svg } from './svg.js';
+export * from './attributes.js';
+export * from './event/index.js';
+export { ArraySlot } from './slot/array.js';
+export { EffectSlot } from './slot/effect.js';
+export { default as slot } from './slot/index.js';
 export type { Attributes, Element, Renderable } from './types.js';
+export * from './utilities.js';

package/build/index.js

@@ -1,4 +1,14 @@
-import './runtime.js';
+import { CLEANUP, STORE } from './constants.js';
+if (typeof Node !== 'undefined') {
+    Node.prototype[CLEANUP] = null;
+    Node.prototype[STORE] = null;
+}
 export { default as html } from './html.js';
 export { default as render } from './render.js';
 export { default as svg } from './svg.js';
+export * from './attributes.js';
+export * from './event/index.js';
+export { ArraySlot } from './slot/array.js';
+export { EffectSlot } from './slot/effect.js';
+export { default as slot } from './slot/index.js';
+export * from './utilities.js';

package/build/utilities.js

@@ -1,10 +1,10 @@
 import { SLOT_HTML } from './constants.js';
-let clonableTemplate = document.createElement('template'), clonableText = document.createTextNode('');
+let tmpl = document.createElement('template'), txt = document.createTextNode('');
 const clone = typeof navigator !== 'undefined' && navigator.userAgent.includes('Firefox')
     ? document.importNode.bind(document)
     : (node, deep = true) => node.cloneNode(deep);
 const fragment = (html) => {
-    let element = clonableTemplate.cloneNode();
+    let element = tmpl.cloneNode();
     element.innerHTML = html;
     return element.content;
 };
@@ -14,7 +14,7 @@ const template = (html) => {
     let cached;
     return () => {
         if (!cached) {
-            let element = clonableTemplate.cloneNode();
+            let element = tmpl.cloneNode();
             element.innerHTML = html;
             cached = element.content;
         }
@@ -22,7 +22,7 @@ const template = (html) => {
     };
 };
 const text = (value) => {
-    let element = clonableText.cloneNode();
+    let element = txt.cloneNode();
     if (value !== '') {
         element.nodeValue = value;
     }

package/package.json

@@ -2,34 +2,28 @@
   "author": "ICJR",
   "dependencies": {
     "@esportsplus/queue": "^0.2.0",
-    "@esportsplus/reactivity": "^0.26.0",
+    "@esportsplus/reactivity": "^0.27.0",
     "@esportsplus/utilities": "^0.27.2",
     "serve": "^14.2.5"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.21.0",
+    "@esportsplus/typescript": "^0.22.0",
     "@types/node": "^25.0.3",
     "vite": "^7.3.0",
     "vite-tsconfig-paths": "^6.0.3"
   },
   "exports": {
     ".": {
-      "import": "./build/index.js",
-      "types": "./build/index.d.ts"
-    },
-    "./compiler": {
-      "import": "./build/compiler/index.js",
-      "types": "./build/compiler/index.d.ts"
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
     },
     "./compiler/tsc": {
       "types": "./build/compiler/plugins/tsc.d.ts",
-      "import": "./build/compiler/plugins/tsc.js",
-      "require": "./build/compiler/plugins/tsc.js"
+      "default": "./build/compiler/plugins/tsc.js"
     },
     "./compiler/vite": {
       "types": "./build/compiler/plugins/vite.d.ts",
-      "import": "./build/compiler/plugins/vite.js",
-      "require": "./build/compiler/plugins/vite.js"
+      "default": "./build/compiler/plugins/vite.js"
     }
   },
   "main": "./build/index.js",
@@ -41,7 +35,7 @@
   },
   "type": "module",
   "types": "./build/index.d.ts",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "scripts": {
     "build": "tsc",
     "build:test": "vite build --config test/vite.config.ts",

package/src/compiler/codegen.ts

@@ -1,11 +1,8 @@
 import { ts } from '@esportsplus/typescript';
-import { ast, code as c, uid, type Replacement } from '@esportsplus/typescript/compiler';
+import { ast, code as c, imports, uid, type Replacement } from '@esportsplus/typescript/compiler';
+import { COMPILER_ENTRYPOINT, COMPILER_TYPES, PACKAGE } from '~/constants';
 import type { ReactiveCallInfo, TemplateInfo } from './ts-parser';
 import { analyzeExpression, generateAttributeBinding, generateSpreadBindings } from './type-analyzer';
-import {
-    COMPILER_ENTRYPOINT, COMPILER_NAMESPACE, COMPILER_TYPES,
-    PACKAGE, PACKAGE_COMPILER
-} from '~/constants';
 import parser from './parser';
 
 
@@ -22,6 +19,7 @@ type CodegenContext = {
     checker?: ts.TypeChecker;
     hoistedFactories: Map<string, string>;
     htmlToTemplateId: Map<string, string>;
+    neededImports: Set<string>;
     printer: ts.Printer;
     sourceFile: ts.SourceFile;
 };
@@ -44,11 +42,6 @@ type ParseResult = {
 
 const ARROW_EMPTY_PARAMS = /\(\s*\)\s*=>\s*$/;
 
-const REGEX_PACKAGE_IMPORT = new RegExp(
-    `import\\s*\\{[^}]*\\}\\s*from\\s*['"]${PACKAGE.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"];?\\n?`,
-    'g'
-);
-
 
 let printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
 
@@ -103,7 +96,8 @@ function generateNestedTemplateCode(ctx: CodegenContext, node: ts.TaggedTemplate
 
 function generateNodeBinding(ctx: CodegenContext, anchor: string, exprText: string, exprNode: ts.Expression | undefined): string {
     if (!exprNode) {
-        return `${COMPILER_NAMESPACE}.slot(${anchor}, ${exprText});`;
+        ctx.neededImports.add('slot');
+        return `slot(${anchor}, ${exprText});`;
     }
 
     if (isNestedHtmlTemplate(exprNode)) {
@@ -114,10 +108,12 @@ function generateNodeBinding(ctx: CodegenContext, anchor: string, exprText: stri
 
     switch (slotType) {
         case COMPILER_TYPES.Effect:
-            return `new ${COMPILER_NAMESPACE}.EffectSlot(${anchor}, ${exprText});`;
+            ctx.neededImports.add('EffectSlot');
+            return `new EffectSlot(${anchor}, ${exprText});`;
 
         case COMPILER_TYPES.ArraySlot:
-            return `new ${COMPILER_NAMESPACE}.ArraySlot(${anchor}, ${exprText});`;
+            ctx.neededImports.add('ArraySlot');
+            return `new ArraySlot(${anchor}, ${exprText});`;
 
         case COMPILER_TYPES.Static:
             return `${anchor}.textContent = ${exprText};`;
@@ -126,7 +122,8 @@ function generateNodeBinding(ctx: CodegenContext, anchor: string, exprText: stri
             return `${anchor}.parentNode.insertBefore(${exprText}, ${anchor});`;
 
         default:
-            return `${COMPILER_NAMESPACE}.slot(${anchor}, ${exprText});`;
+            ctx.neededImports.add('slot');
+            return `slot(${anchor}, ${exprText});`;
     }
 }
 
@@ -179,7 +176,8 @@ function generateTemplateCode(
         let name = uid('element'),
             suffix = path.slice(startIdx).join('.');
 
-        declarations.push(`${name} = ${ancestorVar}.${suffix} as ${COMPILER_NAMESPACE}.Element`);
+        ctx.neededImports.add('Element');
+        declarations.push(`${name} = ${ancestorVar}.${suffix} as Element`);
         nodes.set(key, name);
     }
 
@@ -206,7 +204,7 @@ function generateTemplateCode(
                             exprTexts[index] || 'undefined',
                             elementVar,
                             ctx.checker,
-                            COMPILER_NAMESPACE
+                            ctx.neededImports
                         );
 
                     for (let k = 0, o = bindings.length; k < o; k++) {
@@ -222,7 +220,7 @@ function generateTemplateCode(
                             name,
                             exprTexts[index++] || 'undefined',
                             slot.attributes.statics[name] || '',
-                            COMPILER_NAMESPACE
+                            ctx.neededImports
                         )
                     );
                 }
@@ -299,14 +297,6 @@ function rewriteExpression(ctx: CodegenContext, expr: ts.Expression): string {
 }
 
 
-const addImport = (code: string): string => {
-    return `import * as ${COMPILER_NAMESPACE} from '${PACKAGE_COMPILER}';\n` + code;
-};
-
-const removePackageImport = (code: string): string => {
-    return code.replace(REGEX_PACKAGE_IMPORT, '');
-};
-
 const generateCode = (templates: TemplateInfo[], originalCode: string, sourceFile: ts.SourceFile, checker?: ts.TypeChecker): CodegenResult => {
     if (templates.length === 0) {
         return { changed: false, code: originalCode };
@@ -333,6 +323,7 @@ const generateCode = (templates: TemplateInfo[], originalCode: string, sourceFil
             checker,
             hoistedFactories: new Map(),
             htmlToTemplateId: new Map(),
+            neededImports: new Set(['template']),
             printer,
             sourceFile
         },
@@ -384,10 +375,13 @@ const generateCode = (templates: TemplateInfo[], originalCode: string, sourceFil
         let factories: string[] = [];
 
         for (let [id, html] of ctx.hoistedFactories) {
-            factories.push(`const ${id} = ${COMPILER_NAMESPACE}.template(\`${html}\`);`);
+            factories.push(`const ${id} = template(\`${html}\`);`);
         }
 
-        code = addImport(factories.join('\n') + removePackageImport(code));
+        code = imports.modify(factories.join('\n') + code, sourceFile, PACKAGE, {
+            add: ctx.neededImports,
+            remove: [COMPILER_ENTRYPOINT]
+        });
     }
 
     return { changed, code };
@@ -405,7 +399,7 @@ const generateReactiveInlining = (calls: ReactiveCallInfo[], code: string, sourc
 
         replacements.push({
             end: call.end,
-            newText: `new ${COMPILER_NAMESPACE}.ArraySlot(
+            newText: `new ArraySlot(
                 ${printer.printNode(ts.EmitHint.Expression, call.arrayArg, sourceFile)},
                 ${printer.printNode(ts.EmitHint.Expression, call.callbackArg, sourceFile)}
             )`,
@@ -419,11 +413,11 @@ const generateReactiveInlining = (calls: ReactiveCallInfo[], code: string, sourc
 const needsArraySlotImport = (sourceFile: ts.SourceFile): boolean => {
     return ast.hasMatch(sourceFile, n =>
         ts.isNewExpression(n) &&
-        ts.isPropertyAccessExpression(n.expression) &&
-        n.expression.name.text === 'ArraySlot'
+        ts.isIdentifier(n.expression) &&
+        n.expression.text === 'ArraySlot'
     ) && !hasArraySlotImport(sourceFile);
 };
 
 
-export { addImport, generateCode, generateReactiveInlining, needsArraySlotImport };
+export { generateCode, generateReactiveInlining, needsArraySlotImport };
 export type { CodegenResult };

package/src/compiler/index.ts

@@ -1,8 +1,8 @@
-import { code as c } from '@esportsplus/typescript/compiler';
-import { addImport, generateCode, generateReactiveInlining, needsArraySlotImport } from './codegen';
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY } from '../constants';
-import { findHtmlTemplates, findReactiveCalls } from './ts-parser';
 import { ts } from '@esportsplus/typescript';
+import { code as c, imports } from '@esportsplus/typescript/compiler';
+import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, PACKAGE } from '~/constants';
+import { generateCode, generateReactiveInlining, needsArraySlotImport } from './codegen';
+import { findHtmlTemplates, findReactiveCalls } from './ts-parser';
 
 
 type TransformResult = {
@@ -40,18 +40,17 @@ const transform = (sourceFile: ts.SourceFile, program: ts.Program): TransformRes
     let changed = false,
         codegenChanged = false,
         needsImport = false,
-        reactiveCalls = findReactiveCalls(sourceFile),
+        reactiveCalls = findReactiveCalls(sourceFile, checker),
         result = code;
 
     if (reactiveCalls.length > 0) {
         changed = true;
-        checker = undefined;
         result = generateReactiveInlining(reactiveCalls, result, sourceFile);
         sourceFile = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
         needsImport = needsArraySlotImport(sourceFile);
     }
 
-    let templates = findHtmlTemplates(sourceFile);
+    let templates = findHtmlTemplates(sourceFile, checker);
 
     if (templates.length > 0) {
         let codegenResult = generateCode(templates, result, sourceFile, checker);
@@ -64,7 +63,7 @@ const transform = (sourceFile: ts.SourceFile, program: ts.Program): TransformRes
     }
 
     if (needsImport && !codegenChanged) {
-        result = addImport(result);
+        result = imports.modify(result, sourceFile, PACKAGE, { add: ['ArraySlot'] });
     }
 
     if (changed) {
@@ -76,9 +75,3 @@ const transform = (sourceFile: ts.SourceFile, program: ts.Program): TransformRes
 
 
 export { transform };
-export * from '~/attributes';
-export * from '~/event';
-export { ArraySlot } from '~/slot/array';
-export { EffectSlot } from '~/slot/effect';
-export type * from '~/types';
-export * from '~/utilities';

package/src/compiler/parser.ts

@@ -1,4 +1,4 @@
-import { COMPILER_TYPES, PACKAGE, SLOT_HTML } from '../constants';
+import { COMPILER_TYPES, PACKAGE, SLOT_HTML } from '~/constants';
 
 
 type NodePath = ('firstChild' | 'firstElementChild' | 'nextElementSibling' | 'nextSibling')[];

package/src/compiler/ts-parser.ts

@@ -1,5 +1,5 @@
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY } from '../constants';
 import { ts } from '@esportsplus/typescript';
+import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, PACKAGE } from '~/constants';
 
 
 type ReactiveCallInfo = {
@@ -20,14 +20,55 @@ type TemplateInfo = {
 };
 
 
-function visitReactiveCalls(node: ts.Node, calls: ReactiveCallInfo[]): void {
+function isHtmlFromPackage(node: ts.Identifier, checker: ts.TypeChecker | undefined): boolean {
+    // Fast path: check identifier name first
+    if (node.text !== COMPILER_ENTRYPOINT) {
+        return false;
+    }
+
+    // Without checker, fall back to string-based check
+    if (!checker) {
+        return true;
+    }
+
+    let symbol = checker.getSymbolAtLocation(node);
+
+    if (!symbol) {
+        return true;
+    }
+
+    // Follow aliases (re-exports) to find original symbol
+    if (symbol.flags & ts.SymbolFlags.Alias) {
+        symbol = checker.getAliasedSymbol(symbol);
+    }
+
+    let declarations = symbol.getDeclarations();
+
+    if (!declarations || declarations.length === 0) {
+        return true;
+    }
+
+    // Check if any declaration is from our package
+    for (let i = 0, n = declarations.length; i < n; i++) {
+        let fileName = declarations[i].getSourceFile().fileName;
+
+        // Check for package in node_modules path or direct package reference
+        if (fileName.includes(PACKAGE) || fileName.includes('@esportsplus/template')) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+function visitReactiveCalls(node: ts.Node, calls: ReactiveCallInfo[], checker: ts.TypeChecker | undefined): void {
     if (
         ts.isCallExpression(node) &&
         ts.isPropertyAccessExpression(node.expression) &&
         ts.isIdentifier(node.expression.expression) &&
-        node.expression.expression.text === COMPILER_ENTRYPOINT &&
         node.expression.name.text === COMPILER_ENTRYPOINT_REACTIVITY &&
-        node.arguments.length === 2
+        node.arguments.length === 2 &&
+        isHtmlFromPackage(node.expression.expression, checker)
     ) {
         calls.push({
             arrayArg: node.arguments[0],
@@ -38,15 +79,15 @@ function visitReactiveCalls(node: ts.Node, calls: ReactiveCallInfo[]): void {
         });
     }
 
-    ts.forEachChild(node, child => visitReactiveCalls(child, calls));
+    ts.forEachChild(node, child => visitReactiveCalls(child, calls, checker));
 }
 
-function visitTemplates(node: ts.Node, depth: number, templates: TemplateInfo[]): void {
+function visitTemplates(node: ts.Node, depth: number, templates: TemplateInfo[], checker: ts.TypeChecker | undefined): void {
     let nextDepth = (ts.isArrowFunction(node) || ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isMethodDeclaration(node))
             ? depth + 1
             : depth;
 
-    if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && node.tag.text === COMPILER_ENTRYPOINT) {
+    if (ts.isTaggedTemplateExpression(node) && ts.isIdentifier(node.tag) && isHtmlFromPackage(node.tag, checker)) {
         let expressions: ts.Expression[] = [],
             literals: string[] = [],
             template = node.template;
@@ -75,14 +116,14 @@ function visitTemplates(node: ts.Node, depth: number, templates: TemplateInfo[])
         });
     }
 
-    ts.forEachChild(node, child => visitTemplates(child, nextDepth, templates));
+    ts.forEachChild(node, child => visitTemplates(child, nextDepth, templates, checker));
 }
 
 
-const findHtmlTemplates = (sourceFile: ts.SourceFile): TemplateInfo[] => {
+const findHtmlTemplates = (sourceFile: ts.SourceFile, checker?: ts.TypeChecker): TemplateInfo[] => {
     let templates: TemplateInfo[] = [];
 
-    visitTemplates(sourceFile, 0, templates);
+    visitTemplates(sourceFile, 0, templates, checker);
 
     // Sort by depth descending (deepest first), then by position for stable ordering
     templates.sort((a, b) => a.depth !== b.depth ? b.depth - a.depth : a.start - b.start);
@@ -90,10 +131,10 @@ const findHtmlTemplates = (sourceFile: ts.SourceFile): TemplateInfo[] => {
     return templates;
 };
 
-const findReactiveCalls = (sourceFile: ts.SourceFile): ReactiveCallInfo[] => {
+const findReactiveCalls = (sourceFile: ts.SourceFile, checker?: ts.TypeChecker): ReactiveCallInfo[] => {
     let calls: ReactiveCallInfo[] = [];
 
-    visitReactiveCalls(sourceFile, calls);
+    visitReactiveCalls(sourceFile, calls, checker);
 
     return calls;
 };

package/src/compiler/type-analyzer.ts

@@ -4,7 +4,7 @@ import {
     COMPILER_TYPES,
     DIRECT_ATTACH_EVENTS,
     LIFECYCLE_EVENTS
-} from '../constants';
+} from '~/constants';
 import { ts } from '@esportsplus/typescript';
 
 
@@ -172,35 +172,42 @@ const analyzeExpression = (expr: ts.Expression, checker?: ts.TypeChecker): COMPI
     return inferCOMPILER_TYPES(expr, checker);
 };
 
-const generateAttributeBinding = (elementVar: string, name: string, expr: string, staticValue: string, ns: string): string => {
+const generateAttributeBinding = (elementVar: string, name: string, expr: string, staticValue: string, neededImports: Set<string>): string => {
     if (name.startsWith('on') && name.length > 2) {
         let event = name.slice(2).toLowerCase(),
             key = name.toLowerCase();
 
         if (LIFECYCLE_EVENTS.has(key)) {
-            return `${ns}.${key}(${elementVar}, ${expr});`;
+            neededImports.add(key);
+            return `${key}(${elementVar}, ${expr});`;
         }
 
         if (DIRECT_ATTACH_EVENTS.has(key)) {
-            return `${ns}.on(${elementVar}, '${event}', ${expr});`;
+            neededImports.add('on');
+            return `on(${elementVar}, '${event}', ${expr});`;
         }
 
-        return `${ns}.delegate(${elementVar}, '${event}', ${expr});`;
+        neededImports.add('delegate');
+        return `delegate(${elementVar}, '${event}', ${expr});`;
     }
 
     if (name === 'class') {
-        return `${ns}.setClass(${elementVar}, '${staticValue}', ${expr});`;
+        neededImports.add('setClass');
+        return `setClass(${elementVar}, '${staticValue}', ${expr});`;
     }
 
     if (name === COMPILER_TYPES.Attributes) {
-        return `${ns}.setProperties(${elementVar}, ${expr});`;
+        neededImports.add('setProperties');
+        return `setProperties(${elementVar}, ${expr});`;
     }
 
     if (name === 'style') {
-        return `${ns}.setStyle(${elementVar}, '${staticValue}', ${expr});`;
+        neededImports.add('setStyle');
+        return `setStyle(${elementVar}, '${staticValue}', ${expr});`;
     }
 
-    return `${ns}.setProperty(${elementVar}, '${name}', ${expr});`;
+    neededImports.add('setProperty');
+    return `setProperty(${elementVar}, '${name}', ${expr});`;
 };
 
 const generateSpreadBindings = (
@@ -208,7 +215,7 @@ const generateSpreadBindings = (
     exprCode: string,
     elementVar: string,
     checker: ts.TypeChecker | undefined,
-    ns: string
+    neededImports: Set<string>
 ): string[] => {
     while (ts.isParenthesizedExpression(expr)) {
         expr = expr.expression;
@@ -217,7 +224,8 @@ const generateSpreadBindings = (
     let analysis = analyzeSpread(expr, checker);
 
     if (!analysis.canUnpack) {
-        return [`${ns}.setProperties(${elementVar}, ${exprCode});`];
+        neededImports.add('setProperties');
+        return [`setProperties(${elementVar}, ${exprCode});`];
     }
 
     let lines: string[] = [];
@@ -247,7 +255,7 @@ const generateSpreadBindings = (
             }
 
             if (value !== null) {
-                lines.push(generateAttributeBinding(elementVar, key, value, '', ns));
+                lines.push(generateAttributeBinding(elementVar, key, value, '', neededImports));
             }
         }
     }
@@ -255,7 +263,7 @@ const generateSpreadBindings = (
         for (let i = 0, n = analysis.keys.length; i < n; i++) {
             let key = analysis.keys[i];
 
-            lines.push(generateAttributeBinding(elementVar, key, `${exprCode}.${key}`, '', ns));
+            lines.push(generateAttributeBinding(elementVar, key, `${exprCode}.${key}`, '', neededImports));
         }
     }
 

package/src/constants.ts

@@ -1,17 +1,11 @@
-import { uid } from '@esportsplus/typescript/compiler';
-
-
 const ARRAY_SLOT = Symbol('template.array.slot');
 
 const CLEANUP = Symbol('template.cleanup');
 
-
 const COMPILER_ENTRYPOINT = 'html';
 
 const COMPILER_ENTRYPOINT_REACTIVITY = 'reactive';
 
-const COMPILER_NAMESPACE = uid('template');
-
 const enum COMPILER_TYPES {
     ArraySlot = 'array-slot',
     Attributes = 'attributes',
@@ -40,9 +34,6 @@ const LIFECYCLE_EVENTS = new Set<string>([
 
 const PACKAGE = '@esportsplus/template';
 
-const PACKAGE_COMPILER = '@esportsplus/template/compiler';
-
-
 const SLOT_HTML = '<!--$-->';
 
 const STATE_HYDRATING = 0;
@@ -57,9 +48,9 @@ const STORE = Symbol('template.store');
 export {
     ARRAY_SLOT,
     CLEANUP,
-    COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_NAMESPACE, COMPILER_TYPES,
+    COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_TYPES,
     DIRECT_ATTACH_EVENTS,
     LIFECYCLE_EVENTS,
-    PACKAGE, PACKAGE_COMPILER,
+    PACKAGE,
     SLOT_HTML, STATE_HYDRATING, STATE_NONE, STATE_WAITING, STORE,
-};
+};

package/src/index.ts

@@ -1,5 +1,20 @@
-import './runtime';
+import { CLEANUP, STORE } from './constants';
+
+
+// Pre-allocate on Node prototype to optimize property access
+if (typeof Node !== 'undefined') {
+    (Node.prototype as any)[CLEANUP] = null;
+    (Node.prototype as any)[STORE] = null;
+}
+
+
 export { default as html } from './html';
 export { default as render } from './render';
 export { default as svg } from './svg';
+export * from './attributes';
+export * from './event';
+export { ArraySlot } from './slot/array';
+export { EffectSlot } from './slot/effect';
+export { default as slot } from './slot';
 export type { Attributes, Element, Renderable } from './types';
+export * from './utilities';

package/src/utilities.ts

@@ -1,8 +1,8 @@
 import { SLOT_HTML } from './constants';
 
 
-let clonableTemplate = document.createElement('template'),
-    clonableText = document.createTextNode('');
+let tmpl = document.createElement('template'),
+    txt = document.createTextNode('');
 
 
 // Firefox's importNode outperforms cloneNode in certain scenarios
@@ -12,7 +12,7 @@ const clone = typeof navigator !== 'undefined' && navigator.userAgent.includes('
 
 // Create a fragment from HTML string
 const fragment = (html: string): DocumentFragment => {
-    let element = clonableTemplate.cloneNode() as HTMLTemplateElement;
+    let element = tmpl.cloneNode() as HTMLTemplateElement;
 
     element.innerHTML = html;
 
@@ -29,7 +29,8 @@ const template = (html: string) => {
 
     return () => {
         if (!cached) {
-            let element = clonableTemplate.cloneNode() as HTMLTemplateElement;
+            let element = tmpl.cloneNode() as HTMLTemplateElement;
+
             element.innerHTML = html;
             cached = element.content;
         }
@@ -39,7 +40,7 @@ const template = (html: string) => {
 };
 
 const text = (value: string) => {
-    let element = clonableText.cloneNode();
+    let element = txt.cloneNode();
 
     if (value !== '') {
         element.nodeValue = value;

package/test/vite.config.ts

@@ -1,7 +1,7 @@
 import { defineConfig } from 'vite';
 import { resolve } from 'path';
 import tsconfigPaths from 'vite-tsconfig-paths';
-import templatePlugin from '../src/compiler/vite';
+import templatePlugin from '../src/compiler/plugins/vite';
 
 
 export default defineConfig({

package/build/runtime.d.ts

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

package/build/runtime.js

@@ -1,5 +0,0 @@
-import { CLEANUP, STORE } from './constants.js';
-if (typeof Node !== 'undefined') {
-    Node.prototype[CLEANUP] = null;
-    Node.prototype[STORE] = null;
-}

package/src/runtime.ts

@@ -1,8 +0,0 @@
-import { CLEANUP, STORE } from './constants';
-
-
-// Pre-allocate on Node prototype to optimize property access
-if (typeof Node !== 'undefined') {
-    (Node.prototype as any)[CLEANUP] = null;
-    (Node.prototype as any)[STORE] = null;
-}