@esportsplus/template 0.31.7 → 0.32.1

package/src/transformer/codegen.ts

@@ -1,8 +1,14 @@
-import { applyReplacementsReverse, uid } from '@esportsplus/typescript/transformer';
+import { code as c, uid } from '@esportsplus/typescript/transformer';
 import type { Replacement } from '@esportsplus/typescript/transformer';
 import type { ReactiveCallInfo, TemplateInfo } from './ts-parser';
 import { analyzeExpression, generateAttributeBinding, generateSpreadBindings } from './type-analyzer';
 import { ts } from '@esportsplus/typescript';
+import {
+    COMPILER_ENTRYPOINT,
+    COMPILER_NAMESPACE,
+    COMPILER_TYPES,
+    PACKAGE
+} from '../constants';
 import parser from './parser';
 
 
@@ -12,7 +18,15 @@ type AttributeSlot = {
         statics: Record<string, string>;
     };
     path: string[];
-    type: 'attributes';
+    type: COMPILER_TYPES.AttributeSlot;
+};
+
+type CodegenContext = {
+    checker?: ts.TypeChecker;
+    hoistedFactories: Map<string, string>;
+    htmlToTemplateId: Map<string, string>;
+    printer: ts.Printer;
+    sourceFile: ts.SourceFile;
 };
 
 type CodegenResult = {
@@ -22,7 +36,7 @@ type CodegenResult = {
 
 type NodeSlot = {
     path: string[];
-    type: 'slot';
+    type: COMPILER_TYPES.NodeSlot;
 };
 
 type ParseResult = {
@@ -33,38 +47,28 @@ type ParseResult = {
 
 const ARROW_EMPTY_PARAMS = /\(\s*\)\s*=>\s*$/;
 
-const TEMPLATE_IMPORT = /import\s+\{[^}]*\}\s+from\s+['"]@esportsplus\/template['"];?\s*\n?/g;
-
-
-let currentChecker: ts.TypeChecker | undefined,
-    hoistedFactories = new Map<string, string>(),
-    htmlToTemplateId = new Map<string, string>(),
-    ns = '';
+let printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
 
 
 function collectNestedTemplateReplacements(
+    ctx: CodegenContext,
     node: ts.Node,
     exprStart: number,
-    sourceFile: ts.SourceFile,
     replacements: Replacement[]
 ): void {
     if (isNestedHtmlTemplate(node as ts.Expression)) {
         replacements.push({
             end: node.end - exprStart,
-            newText: generateNestedTemplateCode(node as ts.TaggedTemplateExpression, sourceFile),
+            newText: generateNestedTemplateCode(ctx, node as ts.TaggedTemplateExpression),
             start: node.getStart() - exprStart
         });
     }
     else {
-        ts.forEachChild(node, child => collectNestedTemplateReplacements(child, exprStart, sourceFile, replacements));
+        ts.forEachChild(node, child => collectNestedTemplateReplacements(ctx, child, exprStart, replacements));
     }
 }
 
-function generateImports(): string {
-    return `import * as ${ns} from '@esportsplus/template';`;
-}
-
-function generateNestedTemplateCode(node: ts.TaggedTemplateExpression, sourceFile: ts.SourceFile): string {
+function generateNestedTemplateCode(ctx: CodegenContext, node: ts.TaggedTemplateExpression): string {
     let expressions: ts.Expression[] = [],
         exprTexts: string[] = [],
         literals: string[] = [],
@@ -81,57 +85,57 @@ function generateNestedTemplateCode(node: ts.TaggedTemplateExpression, sourceFil
 
             expressions.push(expr);
             literals.push(template.templateSpans[i].literal.text);
-            exprTexts.push(rewriteExpression(expr, sourceFile));
+            exprTexts.push(rewriteExpression(ctx, expr));
         }
     }
 
     return generateTemplateCode(
+        ctx,
         parser.parse(literals) as ParseResult,
         exprTexts,
         expressions,
-        sourceFile,
         false
     );
 }
 
-function generateNodeBinding(anchor: string, exprText: string, exprNode: ts.Expression | undefined, sourceFile: ts.SourceFile): string {
+function generateNodeBinding(ctx: CodegenContext, anchor: string, exprText: string, exprNode: ts.Expression | undefined): string {
     if (!exprNode) {
-        return `${ns}.slot(${anchor}, ${exprText});`;
+        return `${COMPILER_NAMESPACE}.slot(${anchor}, ${exprText});`;
     }
 
     if (isNestedHtmlTemplate(exprNode)) {
-        return `${anchor}.parentNode.insertBefore(${generateNestedTemplateCode(exprNode, sourceFile)}, ${anchor});`;
+        return `${anchor}.parentNode.insertBefore(${generateNestedTemplateCode(ctx, exprNode)}, ${anchor});`;
     }
 
-    let slotType = analyzeExpression(exprNode, currentChecker);
+    let slotType = analyzeExpression(exprNode, ctx.checker);
 
     switch (slotType) {
-        case 'effect':
-            return `new ${ns}.EffectSlot(${anchor}, ${exprText});`;
+        case COMPILER_TYPES.Effect:
+            return `new ${COMPILER_NAMESPACE}.EffectSlot(${anchor}, ${exprText});`;
 
-        case 'array-slot':
-            return `new ${ns}.ArraySlot(${anchor}, ${exprText});`;
+        case COMPILER_TYPES.ArraySlot:
+            return `new ${COMPILER_NAMESPACE}.ArraySlot(${anchor}, ${exprText});`;
 
-        case 'static':
+        case COMPILER_TYPES.Static:
             return `${anchor}.textContent = ${exprText};`;
 
-        case 'document-fragment':
+        case COMPILER_TYPES.DocumentFragment:
             return `${anchor}.parentNode.insertBefore(${exprText}, ${anchor});`;
 
         default:
-            return `${ns}.slot(${anchor}, ${exprText});`;
+            return `${COMPILER_NAMESPACE}.slot(${anchor}, ${exprText});`;
     }
 }
 
 function generateTemplateCode(
+    ctx: CodegenContext,
     { html, slots }: ParseResult,
     exprTexts: string[],
     exprNodes: ts.Expression[],
-    sourceFile: ts.SourceFile,
     isArrowBody: boolean
 ): string {
     if (!slots || slots.length === 0) {
-        return `${getOrCreateTemplateId(html)}()`;
+        return `${getOrCreateTemplateId(ctx, html)}()`;
     }
 
     let code: string[] = [],
@@ -140,7 +144,7 @@ function generateTemplateCode(
         nodes = new Map<string, string>(),
         root = uid('root');
 
-    declarations.push(`${root} = ${getOrCreateTemplateId(html)}()`);
+    declarations.push(`${root} = ${getOrCreateTemplateId(ctx, html)}()`);
     nodes.set('', root);
 
     for (let i = 0, n = slots.length; i < n; i++) {
@@ -187,7 +191,7 @@ function generateTemplateCode(
                 : (nodes.get(slots[i].path.join('.')) || root),
             slot = slots[i];
 
-        if (slot.type === 'attributes') {
+        if (slot.type === COMPILER_TYPES.AttributeSlot) {
             for (let j = 0, m = slot.attributes.names.length; j < m; j++) {
                 let name = slot.attributes.names[j];
 
@@ -196,8 +200,9 @@ function generateTemplateCode(
                             exprNodes[index],
                             exprTexts[index] || 'undefined',
                             elementVar,
-                            sourceFile,
-                            currentChecker
+                            ctx.sourceFile,
+                            ctx.checker,
+                            COMPILER_NAMESPACE
                         );
 
                     for (let k = 0, o = bindings.length; k < o; k++) {
@@ -211,7 +216,8 @@ function generateTemplateCode(
                             elementVar,
                             name,
                             exprTexts[index++] || 'undefined',
-                            slot.attributes.statics[name] || ''
+                            slot.attributes.statics[name] || '',
+                            COMPILER_NAMESPACE
                         );
 
                     code.push(binding);
@@ -219,7 +225,7 @@ function generateTemplateCode(
             }
         }
         else {
-            code.push(generateNodeBinding(elementVar, exprTexts[index] || 'undefined', exprNodes[index], sourceFile));
+            code.push(generateNodeBinding(ctx, elementVar, exprTexts[index] || 'undefined', exprNodes[index]));
             index++;
         }
     }
@@ -230,13 +236,13 @@ function generateTemplateCode(
     return code.join('\n');
 }
 
-function getOrCreateTemplateId(html: string): string {
-    let id = htmlToTemplateId.get(html);
+function getOrCreateTemplateId(ctx: CodegenContext, html: string): string {
+    let id = ctx.htmlToTemplateId.get(html);
 
     if (!id) {
         id = uid('tmpl');
-        hoistedFactories.set(id, html);
-        htmlToTemplateId.set(html, id);
+        ctx.hoistedFactories.set(id, html);
+        ctx.htmlToTemplateId.set(html, id);
     }
 
     return id;
@@ -266,109 +272,109 @@ function hasArraySlotImport(sourceFile: ts.SourceFile): boolean {
     return false;
 }
 
-function hasArraySlotUsage(node: ts.Node): boolean {
-    if (
-        ts.isNewExpression(node) &&
-        ts.isIdentifier(node.expression) &&
-        node.expression.text === 'ArraySlot'
-    ) {
+function hasMatch(node: ts.Node, predicate: (n: ts.Node) => boolean): boolean {
+    if (predicate(node)) {
         return true;
     }
 
     let found = false;
 
     ts.forEachChild(node, child => {
-        if (!found && hasArraySlotUsage(child)) {
-            found = true;
+        if (!found) {
+            found = hasMatch(child, predicate);
         }
     });
 
     return found;
 }
 
-function hasNestedTemplates(node: ts.Node): boolean {
-    if (isNestedHtmlTemplate(node as ts.Expression)) {
-        return true;
-    }
-
-    let found = false;
-
-    ts.forEachChild(node, child => {
-        if (!found && hasNestedTemplates(child)) {
-            found = true;
-        }
-    });
+function hasArraySlotUsage(node: ts.Node): boolean {
+    return hasMatch(node, n =>
+        ts.isNewExpression(n) &&
+        ts.isPropertyAccessExpression(n.expression) &&
+        n.expression.name.text === 'ArraySlot'
+    );
+}
 
-    return found;
+function hasNestedTemplates(node: ts.Node): boolean {
+    return hasMatch(node, n => isNestedHtmlTemplate(n as ts.Expression));
 }
 
 function isNestedHtmlTemplate(expr: ts.Expression): expr is ts.TaggedTemplateExpression {
-    return ts.isTaggedTemplateExpression(expr) && ts.isIdentifier(expr.tag) && expr.tag.text === 'html';
+    return ts.isTaggedTemplateExpression(expr) && ts.isIdentifier(expr.tag) && expr.tag.text === COMPILER_ENTRYPOINT;
 }
 
-function isNestedTemplate(template: TemplateInfo, allTemplates: TemplateInfo[]): boolean {
-    for (let i = 0, n = allTemplates.length; i < n; i++) {
-        let other = allTemplates[i];
+function isNestedTemplate(template: TemplateInfo, exprRanges: { end: number; start: number }[]): boolean {
+    for (let i = 0, n = exprRanges.length; i < n; i++) {
+        let range = exprRanges[i];
 
-        if (other === template) {
-            continue;
-        }
-
-        for (let j = 0, m = other.expressions.length; j < m; j++) {
-            let expr = other.expressions[j];
-
-            if (template.start >= expr.getStart() && template.end <= expr.end) {
-                return true;
-            }
+        if (template.start >= range.start && template.end <= range.end) {
+            return true;
         }
     }
 
     return false;
 }
 
-function rewriteExpression(expr: ts.Expression, sourceFile: ts.SourceFile): string {
+function rewriteExpression(ctx: CodegenContext, expr: ts.Expression): string {
     if (isNestedHtmlTemplate(expr)) {
-        return generateNestedTemplateCode(expr, sourceFile);
+        return generateNestedTemplateCode(ctx, expr);
     }
 
     if (!hasNestedTemplates(expr)) {
-        return ts.createPrinter({ newLine: ts.NewLineKind.LineFeed }).printNode(ts.EmitHint.Expression, expr, sourceFile);
+        return ctx.printer.printNode(ts.EmitHint.Expression, expr, ctx.sourceFile);
     }
 
     let exprStart = expr.getStart(),
         replacements: Replacement[] = [];
 
-    collectNestedTemplateReplacements(expr, exprStart, sourceFile, replacements);
+    collectNestedTemplateReplacements(ctx, expr, exprStart, replacements);
 
-    return applyReplacementsReverse(expr.getText(sourceFile), replacements);
+    return c.replaceReverse(expr.getText(ctx.sourceFile), replacements);
 }
 
 
-
 const addArraySlotImport = (code: string): string => {
-    // Strip original @esportsplus/template imports (they lose symbol bindings in TS 5.9.3)
-    return `import * as ${ns} from '@esportsplus/template';\n\n` + code.replace(TEMPLATE_IMPORT, '');
+    return `import * as ${COMPILER_NAMESPACE} from '${PACKAGE}';\n` + code;
 };
 
-const generateCode = (templates: TemplateInfo[], originalCode: string, sourceFile: ts.SourceFile): CodegenResult => {
+const generateCode = (templates: TemplateInfo[], originalCode: string, sourceFile: ts.SourceFile, checker?: ts.TypeChecker): CodegenResult => {
     if (templates.length === 0) {
         return { changed: false, code: originalCode };
     }
 
-    let rootTemplates = templates.filter(t => !isNestedTemplate(t, templates));
+    // Precompute expression ranges for nested template detection
+    let exprRanges: { end: number; start: number }[] = [];
+
+    for (let i = 0, n = templates.length; i < n; i++) {
+        let exprs = templates[i].expressions;
+
+        for (let j = 0, m = exprs.length; j < m; j++) {
+            exprRanges.push({ end: exprs[j].end, start: exprs[j].getStart() });
+        }
+    }
+
+    let rootTemplates = templates.filter(t => !isNestedTemplate(t, exprRanges));
 
     if (rootTemplates.length === 0) {
         return { changed: false, code: originalCode };
     }
 
-    let replacements: Replacement[] = [];
+    let ctx: CodegenContext = {
+            checker,
+            hoistedFactories: new Map(),
+            htmlToTemplateId: new Map(),
+            printer,
+            sourceFile
+        },
+        replacements: Replacement[] = [];
 
     for (let i = 0, n = rootTemplates.length; i < n; i++) {
         let exprTexts: string[] = [],
             template = rootTemplates[i];
 
         for (let j = 0, m = template.expressions.length; j < m; j++) {
-            exprTexts.push(rewriteExpression(template.expressions[j], sourceFile));
+            exprTexts.push(rewriteExpression(ctx, template.expressions[j]));
         }
 
         let codeBefore = originalCode.slice(0, template.start),
@@ -382,7 +388,7 @@ const generateCode = (templates: TemplateInfo[], originalCode: string, sourceFil
             if (arrowMatch) {
                 replacements.push({
                     end: template.end,
-                    newText: getOrCreateTemplateId(parsed.html),
+                    newText: getOrCreateTemplateId(ctx, parsed.html),
                     start: template.start - arrowMatch[0].length
                 });
                 continue;
@@ -392,10 +398,10 @@ const generateCode = (templates: TemplateInfo[], originalCode: string, sourceFil
         replacements.push({
             end: template.end,
             newText: generateTemplateCode(
+                ctx,
                 parsed,
                 exprTexts,
                 template.expressions,
-                sourceFile,
                 isArrowBody
             ),
             start: template.start
@@ -403,18 +409,16 @@ const generateCode = (templates: TemplateInfo[], originalCode: string, sourceFil
     }
 
     let changed = replacements.length > 0,
-        code = applyReplacementsReverse(originalCode, replacements);
+        code = c.replaceReverse(originalCode, replacements);
 
-    if (changed && hoistedFactories.size > 0) {
+    if (changed && ctx.hoistedFactories.size > 0) {
         let factories: string[] = [];
 
-        for (let [id, html] of hoistedFactories) {
-            factories.push(`const ${id} = ${ns}.template(\`${html}\`);`);
+        for (let [id, html] of ctx.hoistedFactories) {
+            factories.push(`const ${id} = ${COMPILER_NAMESPACE}.template(\`${html}\`);`);
         }
 
-        // Strip original @esportsplus/template imports (they lose symbol bindings in TS 5.9.3)
-        code = code.replace(TEMPLATE_IMPORT, '');
-        code = generateImports() + '\n\n' + factories.join('\n') + '\n\n' + code;
+        code = `import * as ${COMPILER_NAMESPACE} from '${PACKAGE}';\n\n` + factories.join('\n') + '\n\n' + code;
     }
 
     return { changed, code };
@@ -425,43 +429,28 @@ const generateReactiveInlining = (calls: ReactiveCallInfo[], code: string, sourc
         return code;
     }
 
-    let printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed }),
-        result = code;
+    let replacements: Replacement[] = [];
 
-    for (let i = calls.length - 1; i >= 0; i--) {
+    for (let i = 0, n = calls.length; i < n; i++) {
         let call = calls[i];
 
-        result = result.slice(0, call.start);
-        result += `new ${ns}.ArraySlot(
+        replacements.push({
+            end: call.end,
+            newText: `new ${COMPILER_NAMESPACE}.ArraySlot(
                 ${printer.printNode(ts.EmitHint.Expression, call.arrayArg, sourceFile)},
                 ${printer.printNode(ts.EmitHint.Expression, call.callbackArg, sourceFile)}
-            )`;
-        result += result.slice(call.end);
+            )`,
+            start: call.start
+        });
     }
 
-    return result;
-};
-
-const getNames = () => ({
-    attr: `${ns}.attributes`,
-    event: `${ns}.event`,
-    slot: `${ns}.slot`
-});
-
-const initNamespace = (): void => {
-    hoistedFactories.clear();
-    htmlToTemplateId.clear();
-    ns = uid('t');
+    return c.replaceReverse(code, replacements);
 };
 
 const needsArraySlotImport = (sourceFile: ts.SourceFile): boolean => {
     return hasArraySlotUsage(sourceFile) && !hasArraySlotImport(sourceFile);
 };
 
-const setTypeChecker = (checker: ts.TypeChecker | undefined): void => {
-    currentChecker = checker;
-};
-
 
-export { addArraySlotImport, generateCode, generateReactiveInlining, getNames, initNamespace, needsArraySlotImport, setTypeChecker };
+export { addArraySlotImport, generateCode, generateReactiveInlining, needsArraySlotImport };
 export type { CodegenResult };

package/src/transformer/index.ts

@@ -1,5 +1,6 @@
-import { mightNeedTransform } from '@esportsplus/typescript/transformer';
-import { addArraySlotImport, generateCode, generateReactiveInlining, initNamespace, setTypeChecker } from './codegen';
+import { code as c } from '@esportsplus/typescript/transformer';
+import { addArraySlotImport, generateCode, generateReactiveInlining, needsArraySlotImport } from './codegen';
+import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY } from '../constants';
 import { findHtmlTemplates, findReactiveCalls } from './ts-parser';
 import { ts } from '@esportsplus/typescript';
 
@@ -11,28 +12,21 @@ type TransformResult = {
 };
 
 
-const PATTERNS = ['html`', 'html.reactive'];
+const PATTERNS = [`${COMPILER_ENTRYPOINT}\``, `${COMPILER_ENTRYPOINT}.${COMPILER_ENTRYPOINT_REACTIVITY}`];
 
 
 function createTransformer(program: ts.Program): ts.TransformerFactory<ts.SourceFile> {
-    let printer = ts.createPrinter(),
-        typeChecker = program.getTypeChecker();
+    let typeChecker = program.getTypeChecker();
 
     return (_context: ts.TransformationContext) => {
         return (sourceFile: ts.SourceFile): ts.SourceFile => {
-            // Use printer to get current text representation (handles chained transformers)
-            let code = printer.printFile(sourceFile);
+            let code = sourceFile.getFullText();
 
-            if (!mightNeedTransform(code, { patterns: PATTERNS })) {
+            if (!c.contains(code, { patterns: PATTERNS })) {
                 return sourceFile;
             }
 
-            // Re-parse the printed code to get accurate positions
-            let reparsed = ts.createSourceFile(sourceFile.fileName, code, sourceFile.languageVersion, true);
-
-            setTypeChecker(typeChecker);
-
-            let result = transformCode(code, reparsed);
+            let result = transformCode(code, sourceFile, typeChecker);
 
             if (!result.changed) {
                 return sourceFile;
@@ -43,64 +37,65 @@ function createTransformer(program: ts.Program): ts.TransformerFactory<ts.Source
     };
 }
 
-function transformCode(code: string, sourceFile: ts.SourceFile): TransformResult {
-    let changed = false,
-        result = code;
 
-    initNamespace();
+const transform = (sourceFile: ts.SourceFile, program: ts.Program): TransformResult => {
+    let code = sourceFile.getFullText();
+
+    if (!c.contains(code, { patterns: PATTERNS })) {
+        return { changed: false, code, sourceFile };
+    }
 
-    let reactiveCalls = findReactiveCalls(sourceFile);
+    let checker: ts.TypeChecker | undefined,
+        fileName = sourceFile.fileName,
+        programSourceFile = program.getSourceFile(fileName)
+            || program.getSourceFile(fileName.replace(/\\/g, '/'))
+            || program.getSourceFile(fileName.replace(/\//g, '\\'));
+
+    if (programSourceFile) {
+        checker = program.getTypeChecker();
+        sourceFile = programSourceFile;
+    }
+
+    return transformCode(code, sourceFile, checker);
+};
+
+const transformCode = (code: string, sourceFile: ts.SourceFile, checker?: ts.TypeChecker): TransformResult => {
+    let changed = false,
+        codegenChanged = false,
+        needsImport = false,
+        result = code,
+        reactiveCalls = findReactiveCalls(sourceFile);
 
     if (reactiveCalls.length > 0) {
         result = generateReactiveInlining(reactiveCalls, result, sourceFile);
-        // Always add namespace import when reactive calls are inlined (strips original named imports)
-        result = addArraySlotImport(result);
         changed = true;
         sourceFile = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
-
-        setTypeChecker(undefined);
+        needsImport = needsArraySlotImport(sourceFile);
+        checker = undefined;
     }
 
     let templates = findHtmlTemplates(sourceFile);
 
     if (templates.length > 0) {
-        let codegenResult = generateCode(templates, result, sourceFile);
+        let codegenResult = generateCode(templates, result, sourceFile, checker);
 
         if (codegenResult.changed) {
             changed = true;
+            codegenChanged = true;
             result = codegenResult.code;
-            sourceFile = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
         }
     }
 
-    return { changed, code: result, sourceFile };
-}
-
-
-const transform = (sourceFile: ts.SourceFile, program: ts.Program): TransformResult => {
-    // Use printer to get current text representation (handles chained transformers)
-    let printer = ts.createPrinter(),
-        code = printer.printFile(sourceFile);
-
-    if (!mightNeedTransform(code, { patterns: PATTERNS })) {
-        return { changed: false, code, sourceFile };
+    if (needsImport && !codegenChanged) {
+        result = addArraySlotImport(result);
     }
 
-    // Re-parse the printed code to get accurate positions
-    let reparsed = ts.createSourceFile(sourceFile.fileName, code, sourceFile.languageVersion, true);
-
-    let programSourceFile = program.getSourceFile(sourceFile.fileName);
-
-    if (programSourceFile) {
-        setTypeChecker(program.getTypeChecker());
-    }
-    else {
-        setTypeChecker(undefined);
+    if (changed) {
+        sourceFile = ts.createSourceFile(sourceFile.fileName, result, sourceFile.languageVersion, true);
     }
 
-    return transformCode(code, reparsed);
+    return { changed, code: result, sourceFile };
 };
 
 
-export type { TransformResult };
-export { createTransformer, mightNeedTransform, PATTERNS, transform };
+export { createTransformer, transform, transformCode, PATTERNS };

package/src/transformer/parser.ts

@@ -1,5 +1,8 @@
-// Inlined to avoid importing constants.ts which depends on utilities.ts (uses document)
-const SLOT_HTML = '<!--$-->';
+import {
+    COMPILER_TYPES,
+    PACKAGE,
+    SLOT_HTML
+} from '../constants';
 
 
 type NodePath = ('firstChild' | 'firstElementChild' | 'nextElementSibling' | 'nextSibling')[];
@@ -92,8 +95,8 @@ const parse = (literals: string[]) => {
         parsed = html.split(SLOT_MARKER),
         slot = 0,
         slots: (
-            { path: NodePath; type: 'slot' } |
-            { attributes: typeof attributes[string]; path: NodePath; type: 'attributes' }
+            { path: NodePath; type: COMPILER_TYPES.NodeSlot } |
+            { attributes: typeof attributes[string]; path: NodePath; type: COMPILER_TYPES.AttributeSlot }
         )[] = [];
 
     {
@@ -186,10 +189,10 @@ const parse = (literals: string[]) => {
                     let attrs = attributes[attr];
 
                     if (!attrs) {
-                        throw new Error(`@esportsplus/template: attribute metadata could not be found for '${attr}'`);
+                        throw new Error(`${PACKAGE}: attribute metadata could not be found for '${attr}'`);
                     }
 
-                    slots.push({ attributes: attrs, path, type: 'attributes' });
+                    slots.push({ attributes: attrs, path, type: COMPILER_TYPES.AttributeSlot });
 
                     for (let i = 0, n = attrs.names.length; i < n; i++) {
                         buffer += parsed[slot++];
@@ -204,7 +207,7 @@ const parse = (literals: string[]) => {
             }
             else if (type === NODE_SLOT) {
                 buffer += parsed[slot++] + SLOT_HTML;
-                slots.push({ path: methods(parent.children, parent.path, 'firstChild', 'nextSibling'), type: 'slot' });
+                slots.push({ path: methods(parent.children, parent.path, 'firstChild', 'nextSibling'), type: COMPILER_TYPES.NodeSlot });
             }
 
             if (n === slot) {