fix(core): make Template a string primitive

Signed-off-by: 90dy <90dy@proton.me>

Author: 90dy

src/core/mod.ts

@@ -300,7 +300,19 @@ export const LANGUAGES: Record<string, LanguageDefinition> = {
   },
 };
 
-class TemplateDocument<T> extends String {
+type Template<T> = string & {
+  readonly type: string;
+  readonly raw: string;
+  readonly data?: unknown;
+  indent: (value: false | number) => Template<T>;
+  noindent: () => Template<T>;
+  throw: () => never;
+  parse: <TParsed = T>(
+    parser?: (text: string) => TParsed,
+  ) => Template<TParsed>;
+}
+
+class TemplateClass<T = unknown> extends String {
   public readonly type: string;
   public readonly raw: string;
   public data?: T;
@@ -350,36 +362,36 @@ class TemplateDocument<T> extends String {
     return this.valueOf();
    }
 
-  indent(value: false | number): TemplateDocument<T> {
-    return new TemplateDocument<T>(
+  indent(value: false | number): TemplateClass<T> {
+    return new TemplateClass<T>(
       this.type,
       { raw: [this.raw] },
       [],
       undefined,
       {
         indent: value,
       },
-    );
+    )
   }
-  noindent(): TemplateDocument<T> {
+  noindent(): TemplateClass<T> {
     return this.indent(false);
   }
-  throw(): TemplateDocument<T> {
+  throw(): TemplateClass<T> | never {
     if (this.error) {
       throw this.error;
     }
-    return this;
+    return this
   }
   parse<TParsed = T>(
     parser?: (text: string) => TParsed,
-  ): TemplateDocument<TParsed> {
+  ): TemplateClass<TParsed> {
     this.parser = parser ?? this.parser;
     try {
       this.data = this.parser?.(this.raw) as T;
     } catch (error) {
       this.error = error as Error;
     }
-    return this as unknown as TemplateDocument<TParsed>; 
+    return this as unknown as TemplateClass<TParsed>;
   }
 }
 
@@ -399,13 +411,13 @@ export function ext<Type extends string>(
   return (
     template: { raw: readonly string[] | ArrayLike<string> },
     ...substitutions: any[]
-  ) => new TemplateDocument(type, template, substitutions, parser, options);
+  ) => new TemplateClass(type, template, substitutions, parser, options) as Template<Type>;
 }
 
 type Ext<Type extends string> = <T>(
   template: { raw: readonly string[] | ArrayLike<string> },
   ...substitutions: any[]
-) => TemplateDocument<T>;
+) => Template<T>;
 
 // Export all template functions individually
 // Web languages