ventojs 2.0.0-canary.0 → 2.0.0-canary.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ventojs",
-  "version": "2.0.0-canary.0",
+  "version": "2.0.0-canary.1",
   "description": "🌬 A minimal but powerful template engine",
   "type": "module",
   "repository": {
@@ -23,12 +23,6 @@
         "default": "./mod.js"
       }
     },
-    "./browser.js": {
-      "import": {
-        "types": "./types/browser.d.ts",
-        "default": "./browser.js"
-      }
-    },
     "./core/environment.js": {
       "import": {
         "types": "./types/core/environment.d.ts",
@@ -66,18 +60,36 @@
         "default": "./loaders/file.js"
       }
     },
+    "./loaders/filesystem.js": {
+      "import": {
+        "types": "./types/loaders/filesystem.d.ts",
+        "default": "./loaders/filesystem.js"
+      }
+    },
     "./loaders/memory.js": {
       "import": {
         "types": "./types/loaders/memory.d.ts",
         "default": "./loaders/memory.js"
       }
     },
+    "./loaders/module.js": {
+      "import": {
+        "types": "./types/loaders/module.d.ts",
+        "default": "./loaders/module.js"
+      }
+    },
     "./loaders/url.js": {
       "import": {
         "types": "./types/loaders/url.d.ts",
         "default": "./loaders/url.js"
       }
     },
+    "./loaders/utils.js": {
+      "import": {
+        "types": "./types/loaders/utils.d.ts",
+        "default": "./loaders/utils.js"
+      }
+    },
     "./mod.js": {
       "import": {
         "types": "./types/mod.d.ts",
@@ -174,6 +186,12 @@
         "default": "./plugins/unescape.js"
       }
     },
-    "./prism-vento.js": "./prism-vento.js"
+    "./prism-vento.js": "./prism-vento.js",
+    "./web.js": {
+      "import": {
+        "types": "./types/web.d.ts",
+        "default": "./web.js"
+      }
+    }
   }
 }

package/plugins/auto_trim.js

@@ -26,7 +26,8 @@ export function autoTrim(tokens, options) {
         const token = tokens[i];
         const next = tokens[i + 1];
         const [type, code] = token;
-        if (type === "tag" && options.tags.find((tag) => code.startsWith(tag))) {
+        if (type === "tag" &&
+            options.tags.find((tag) => code === tag || code.startsWith(tag + " "))) {
             // Remove leading horizontal space
             previous[1] = previous[1].replace(/(^|\n)[ \t]*$/, "$1");
             // Remove trailing horizontal space + newline

package/plugins/echo.js

@@ -3,7 +3,7 @@ export default function () {
         env.tags.push(echoTag);
     };
 }
-function echoTag(env, code, output, tokens) {
+function echoTag(env, [, code], output, tokens) {
     if (!/^echo\b/.test(code)) {
         return;
     }
@@ -16,14 +16,10 @@ function echoTag(env, code, output, tokens) {
     // Captured echo, e.g. {{ echo |> toUpperCase }} foo {{ /echo }}
     const compiled = [`let __tmp = "";`];
     const filters = env.compileFilters(tokens, "__tmp");
-    compiled.push(...env.compileTokens(tokens, "__tmp", ["/echo"]));
+    compiled.push(...env.compileTokens(tokens, "__tmp", "/echo"));
     if (filters != "__tmp") {
         compiled.push(`__tmp = ${filters}`);
     }
-    const closeToken = tokens.shift();
-    if (!closeToken || closeToken[0] != "tag" || closeToken[1] != "/echo") {
-        throw new Error("Unclosed echo tag");
-    }
     return `{
     ${compiled.join("\n")}
     ${output} += __tmp;

package/plugins/escape.js

@@ -1,17 +1,40 @@
-const UNSAFE = /['"&<>]/g;
-const escapeMap = {
-    "'": "&apos;",
-    '"': "&quot;",
-    "&": "&amp;",
-    "<": "&lt;",
-    ">": "&gt;",
-};
+import { SafeString } from "../core/environment.js";
+const UNSAFE = /[<>"&']/;
 export default function () {
     return (env) => {
         env.filters.escape = (value) => {
             if (!value)
                 return "";
-            return value.toString().replace(UNSAFE, (match) => escapeMap[match]);
+            if (value instanceof SafeString)
+                return value.toString();
+            const str = value.toString();
+            const match = UNSAFE.exec(str);
+            if (match === null) {
+                return str;
+            }
+            let html = "";
+            for (let i = match.index; i < str.length; i++) {
+                switch (str.charCodeAt(i)) {
+                    case 34: // "
+                        html += "&quot;";
+                        break;
+                    case 39: // '
+                        html += "&apos;";
+                        break;
+                    case 38: // &
+                        html += "&amp;";
+                        break;
+                    case 60: // <
+                        html += "&lt;";
+                        break;
+                    case 62: // >
+                        html += "&gt;";
+                        break;
+                    default:
+                        html += str[i];
+                }
+            }
+            return html;
         };
     };
 }

package/plugins/export.js

@@ -1,3 +1,4 @@
+import { TokenError } from "../core/errors.js";
 export default function () {
     return (env) => {
         env.tags.push(exportTag);
@@ -8,7 +9,8 @@ const BLOCK_EXPORT = /^([a-zA-Z_]\w*)\s*$/;
 const INLINE_NAMED_EXPORT = /^([a-zA-Z_]\w*)\s*=([^]*)$/;
 const NAMED_EXPORTS = /^{[^]*?}$/;
 const AS = /\s+\bas\b\s+/;
-function exportTag(env, code, _output, tokens) {
+function exportTag(env, token, _output, tokens) {
+    const [, code] = token;
     const exportStart = code.match(EXPORT_START);
     if (!exportStart) {
         return;
@@ -22,11 +24,7 @@ function exportTag(env, code, _output, tokens) {
         const [, name] = blockExport;
         const compiledFilters = env.compileFilters(tokens, name);
         compiled.push(`var ${name} = "";`);
-        compiled.push(...env.compileTokens(tokens, name, ["/export"]));
-        if (tokens[0]?.[0] !== "tag" || tokens[0]?.[1] !== "/export") {
-            throw new Error(`Missing closing tag for export tag: ${code}`);
-        }
-        tokens.shift();
+        compiled.push(...env.compileTokens(tokens, name, "/export"));
         compiled.push(`${name} = ${compiledFilters}`);
         compiled.push(`${dataVarname}["${name}"] = ${name};`);
         compiled.push(`__exports["${name}"] = ${name};`);
@@ -60,7 +58,7 @@ function exportTag(env, code, _output, tokens) {
                 compiled.push(`__exports["${rename}"] = ${value};`);
             }
             else {
-                throw new Error(`Invalid export: ${code}`);
+                throw new TokenError("Invalid export", token);
             }
         }
         return compiled.join("\n");

package/plugins/for.js

@@ -1,3 +1,4 @@
+import { TokenError } from "../core/errors.js";
 import iterateTopLevel from "../core/js.js";
 export default function () {
     return (env) => {
@@ -5,7 +6,8 @@ export default function () {
         env.utils.toIterator = toIterator;
     };
 }
-function forTag(env, code, output, tokens) {
+function forTag(env, token, output, tokens) {
+    const [, code] = token;
     if (code === "break" || code === "continue") {
         return `${code};`;
     }
@@ -15,7 +17,7 @@ function forTag(env, code, output, tokens) {
     const compiled = [];
     const match = code.match(/^for\s+(await\s+)?([\s\S]*)$/);
     if (!match) {
-        throw new Error(`Invalid for loop: ${code}`);
+        throw new TokenError("Invalid for loop", token);
     }
     let [, aw, tagCode] = match;
     let var1;
@@ -27,7 +29,7 @@ function forTag(env, code, output, tokens) {
     else {
         const parts = tagCode.match(/(^[^\s,]+)([\s|\S]+)$/);
         if (!parts) {
-            throw new Error(`Invalid for loop variable: ${tagCode}`);
+            throw new TokenError(`Invalid for loop variable: ${tagCode}`, token);
         }
         var1 = parts[1].trim();
         tagCode = parts[2].trim();
@@ -41,7 +43,7 @@ function forTag(env, code, output, tokens) {
         else {
             const parts = tagCode.match(/^([\w]+)\s+of\s+([\s|\S]+)$/);
             if (!parts) {
-                throw new Error(`Invalid for loop variable: ${tagCode}`);
+                throw new TokenError(`Invalid for loop variable: ${tagCode}`, token);
             }
             var2 = parts[1].trim();
             collection = parts[2].trim();
@@ -56,8 +58,7 @@ function forTag(env, code, output, tokens) {
     else {
         compiled.push(`for ${aw || ""}(let ${var1} of __env.utils.toIterator(${env.compileFilters(tokens, collection)})) {`);
     }
-    compiled.push(...env.compileTokens(tokens, output, ["/for"]));
-    tokens.shift();
+    compiled.push(...env.compileTokens(tokens, output, "/for"));
     compiled.push("}");
     return compiled.join("\n");
 }

package/plugins/function.js

@@ -1,15 +1,17 @@
+import { TokenError } from "../core/errors.js";
 export default function () {
     return (env) => {
         env.tags.push(functionTag);
     };
 }
-function functionTag(env, code, _output, tokens) {
+function functionTag(env, token, _output, tokens) {
+    const [, code] = token;
     if (!code.match(/^(export\s+)?(async\s+)?function\s/)) {
         return;
     }
     const match = code.match(/^(export\s+)?(async\s+)?function\s+(\w+)\s*(\([^)]+\))?$/);
     if (!match) {
-        throw new Error(`Invalid function: ${code}`);
+        throw new TokenError("Invalid function tag", token);
     }
     const [_, exp, as, name, args] = match;
     const compiled = [];
@@ -17,19 +19,13 @@ function functionTag(env, code, _output, tokens) {
     compiled.push(`let __output = "";`);
     const result = env.compileFilters(tokens, "__output");
     if (exp) {
-        compiled.push(...env.compileTokens(tokens, "__output", ["/export"]));
-        if (tokens.length && (tokens[0][0] !== "tag" || tokens[0][1] !== "/export")) {
-            throw new Error(`Missing closing tag for export function tag: ${code}`);
-        }
+        compiled.push(...env.compileTokens(tokens, "__output", "/export"));
     }
     else {
-        compiled.push(...env.compileTokens(tokens, "__output", ["/function"]));
-        if (tokens.length && (tokens[0][0] !== "tag" || tokens[0][1] !== "/function")) {
-            throw new Error(`Missing closing tag for function tag: ${code}`);
-        }
+        compiled.push(...env.compileTokens(tokens, "__output", "/function"));
     }
     tokens.shift();
-    compiled.push(`return ${result};`);
+    compiled.push(`return __env.utils.safeString(${result});`);
     compiled.push(`}`);
     if (exp) {
         compiled.push(`__exports["${name}"] = ${name}`);

package/plugins/if.js

@@ -1,10 +1,11 @@
+import { TokenError } from "../core/errors.js";
 export default function () {
     return (env) => {
         env.tags.push(ifTag);
         env.tags.push(elseTag);
     };
 }
-function ifTag(env, code, output, tokens) {
+function ifTag(env, [, code], output, tokens) {
     if (!code.startsWith("if ")) {
         return;
     }
@@ -12,18 +13,18 @@ function ifTag(env, code, output, tokens) {
     const compiled = [];
     const val = env.compileFilters(tokens, condition);
     compiled.push(`if (${val}) {`);
-    compiled.push(...env.compileTokens(tokens, output, ["/if"]));
-    tokens.shift();
+    compiled.push(...env.compileTokens(tokens, output, "/if"));
     compiled.push("}");
     return compiled.join("\n");
 }
-function elseTag(_env, code) {
+function elseTag(_env, token) {
+    const [, code] = token;
     if (!code.startsWith("else ") && code !== "else") {
         return;
     }
     const match = code.match(/^else(\s+if\s+(.*))?$/);
     if (!match) {
-        throw new Error(`Invalid else: ${code}`);
+        throw new TokenError("Invalid else tag", token);
     }
     const [_, ifTag, condition] = match;
     if (ifTag) {

package/plugins/import.js

@@ -1,3 +1,4 @@
+import { TokenError } from "../core/errors.js";
 export default function () {
     return (env) => {
         env.tags.push(importTag);
@@ -7,13 +8,14 @@ const IMPORT_STATEMENT = /^import\b\s*([^]*?)\s*\bfrom\b([^]*)$/;
 const DEFAULT_IMPORT = /^\b[a-zA-Z_]\w*\b$/i;
 const NAMED_IMPORTS = /^{[^]*?}$/;
 const AS = /\s+\bas\b\s+/;
-function importTag(env, code) {
+function importTag(env, token) {
+    const [, code] = token;
     if (!code.startsWith("import ")) {
         return;
     }
     const match = code.match(IMPORT_STATEMENT);
     if (!match) {
-        throw new Error(`Invalid import: ${code}`);
+        throw new TokenError("Invalid import tag", token);
     }
     const compiled = [];
     const variables = [];
@@ -41,18 +43,18 @@ function importTag(env, code) {
                     return `${name}: ${rename}`;
                 }
                 else {
-                    throw new Error(`Invalid import: ${code}`);
+                    throw new TokenError("Invalid named import", token);
                 }
             });
             compiled.push(`({${chunks.join(",")}} = __tmp);`);
         }
         else {
-            throw new Error(`Invalid import: ${code}`);
+            throw new TokenError("Invalid import tag", token);
         }
     }
     const { dataVarname } = env.options;
     return `let ${variables.join(",")}; {
-    let __tmp = await __env.run(${specifier}, {...${dataVarname}}, __file);
+    let __tmp = await __env.run(${specifier}, {...${dataVarname}}, __template.path);
     ${compiled.join("\n")}
   }`;
 }

package/plugins/include.js

@@ -1,10 +1,12 @@
+import { TokenError } from "../core/errors.js";
 import iterateTopLevel from "../core/js.js";
 export default function () {
     return (env) => {
         env.tags.push(includeTag);
     };
 }
-function includeTag(env, code, output, tokens) {
+function includeTag(env, token, output, tokens) {
+    const [, code] = token;
     if (!code.startsWith("include ")) {
         return;
     }
@@ -19,7 +21,7 @@ function includeTag(env, code, output, tokens) {
                 bracketIndex = index;
         }
         if (bracketIndex == -1) {
-            throw Error(`Invalid include tag: ${tagCode}`);
+            throw new TokenError("Invalid include tag", token);
         }
         file = tagCode.slice(0, bracketIndex).trim();
         data = tagCode.slice(bracketIndex).trim();
@@ -28,7 +30,7 @@ function includeTag(env, code, output, tokens) {
     return `{
     const __tmp = await __env.run(${file},
       {...${dataVarname}${data ? `, ...${data}` : ""}},
-      __file
+      __template.path
     );
     ${output} += ${env.compileFilters(tokens, "__tmp.content")};
   }`;

package/plugins/js.js

@@ -3,7 +3,7 @@ export default function () {
         env.tags.push(jsTag);
     };
 }
-function jsTag(_env, code) {
+function jsTag(_env, [, code]) {
     if (!code.startsWith(">")) {
         return;
     }

package/plugins/layout.js

@@ -1,15 +1,17 @@
+import { TokenError } from "../core/errors.js";
 export default function () {
     return (env) => {
         env.tags.push(layoutTag);
     };
 }
-function layoutTag(env, code, output, tokens) {
+function layoutTag(env, token, output, tokens) {
+    const [, code] = token;
     if (!code.startsWith("layout ")) {
         return;
     }
     const match = code?.match(/^layout\s+([^{]+|`[^`]+`)+(?:\{([\s|\S]*)\})?$/);
     if (!match) {
-        throw new Error(`Invalid wrap: ${code}`);
+        throw new TokenError("Invalid layout tag", token);
     }
     const [_, file, data] = match;
     const varname = output.startsWith("__layout")
@@ -19,16 +21,12 @@ function layoutTag(env, code, output, tokens) {
     const compiledFilters = env.compileFilters(tokens, varname);
     compiled.push("{");
     compiled.push(`let ${varname} = "";`);
-    compiled.push(...env.compileTokens(tokens, varname, ["/layout"]));
-    if (tokens.length && (tokens[0][0] !== "tag" || tokens[0][1] !== "/layout")) {
-        throw new Error(`Missing closing tag for layout tag: ${code}`);
-    }
-    tokens.shift();
+    compiled.push(...env.compileTokens(tokens, varname, "/layout"));
     compiled.push(`${varname} = ${compiledFilters};`);
     const { dataVarname } = env.options;
     compiled.push(`const __tmp = await __env.run(${file},
       {...${dataVarname}${data ? `, ${data}` : ""}, content: ${env.compileFilters(tokens, varname)}},
-      __file
+      __template.path
     );
     ${output} += __tmp.content;`);
     compiled.push("}");

package/plugins/set.js

@@ -1,9 +1,11 @@
+import { TokenError } from "../core/errors.js";
 export default function () {
     return (env) => {
         env.tags.push(setTag);
     };
 }
-function setTag(env, code, _output, tokens) {
+function setTag(env, token, _output, tokens) {
+    const [, code] = token;
     if (!code.startsWith("set ")) {
         return;
     }
@@ -13,7 +15,7 @@ function setTag(env, code, _output, tokens) {
     if (expression.includes("=")) {
         const match = code.match(/^set\s+([\w]+)\s*=\s*([\s\S]+)$/);
         if (!match) {
-            throw new Error(`Invalid set tag: ${code}`);
+            throw new TokenError("Invalid set tag", token);
         }
         const [, variable, value] = match;
         const val = env.compileFilters(tokens, value);
@@ -25,11 +27,7 @@ function setTag(env, code, _output, tokens) {
     const subvarName = `${dataVarname}["${varName}"]`;
     const compiledFilters = env.compileFilters(tokens, subvarName);
     compiled.push(`${subvarName} = "";`);
-    compiled.push(...env.compileTokens(tokens, subvarName, ["/set"]));
-    if (tokens.length && (tokens[0][0] !== "tag" || tokens[0][1] !== "/set")) {
-        throw new Error(`Missing closing tag for set tag: ${code}`);
-    }
-    tokens.shift();
+    compiled.push(...env.compileTokens(tokens, subvarName, "/set"));
     compiled.push(`var ${varName} = ${subvarName} = ${compiledFilters};`);
     return compiled.join("\n");
 }

package/types/core/environment.d.ts

@@ -3,20 +3,18 @@ export interface TemplateResult {
     content: string;
     [key: string]: unknown;
 }
-export interface Template {
-    (data?: Record<string, unknown>): Promise<TemplateResult>;
+export interface TemplateContext {
     source: string;
     code: string;
-    file?: string;
+    path?: string;
+    defaults?: Record<string, unknown>;
+    tokens?: Token[];
 }
-export interface TemplateSync {
-    (data?: Record<string, unknown>): TemplateResult;
-    source: string;
-    code: string;
-    file?: string;
+export interface Template extends TemplateContext {
+    (data?: Record<string, unknown>): Promise<TemplateResult>;
 }
 export type TokenPreprocessor = (env: Environment, tokens: Token[], path?: string) => Token[] | void;
-export type Tag = (env: Environment, code: string, output: string, tokens: Token[]) => string | undefined;
+export type Tag = (env: Environment, token: Token, output: string, tokens: Token[]) => string | undefined;
 export type FilterThis = {
     data: Record<string, unknown>;
     env: Environment;
@@ -27,8 +25,9 @@ export interface TemplateSource {
     source: string;
     data?: Record<string, unknown>;
 }
+export type PrecompiledTemplate = (env: Environment) => Template;
 export interface Loader {
-    load(file: string): Promise<TemplateSource>;
+    load(file: string): Promise<TemplateSource | PrecompiledTemplate>;
     resolve(from: string, file: string): string;
 }
 export interface Options {
@@ -48,11 +47,11 @@ export declare class Environment {
     use(plugin: Plugin): void;
     run(file: string, data?: Record<string, unknown>, from?: string): Promise<TemplateResult>;
     runString(source: string, data?: Record<string, unknown>, file?: string): Promise<TemplateResult>;
-    runStringSync(source: string, data?: Record<string, unknown>): TemplateResult;
-    compile(source: string, path?: string, defaults?: Record<string, unknown>, sync?: false): Template;
-    compile(source: string, path?: string, defaults?: Record<string, unknown>, sync?: true): TemplateSync;
+    compile(source: string, path?: string, defaults?: Record<string, unknown>): Template;
     tokenize(source: string, path?: string): Token[];
     load(file: string, from?: string): Promise<Template>;
-    compileTokens(tokens: Token[], outputVar?: string, stopAt?: string[]): string[];
+    compileTokens(tokens: Token[], outputVar?: string, closeToken?: string): string[];
     compileFilters(tokens: Token[], output: string, autoescape?: boolean): string;
 }
+export declare class SafeString extends String {
+}

package/types/core/errors.d.ts

@@ -1,16 +1,38 @@
-declare class VentoBaseError extends Error {
-    name: string;
-}
-export declare class TemplateError extends VentoBaseError {
-    path: string;
+import type { Token } from "./tokenizer.d.ts";
+import type { TemplateContext } from "./environment.d.ts";
+export interface ErrorContext {
+    type: string;
+    message: string;
     source: string;
     position: number;
-    constructor(path?: string, source?: string, position?: number, cause?: Error);
+    file?: string;
+}
+export declare abstract class VentoError extends Error {
+    abstract getContext(): ErrorContext | undefined | Promise<ErrorContext | undefined>;
+}
+export declare class TokenError extends VentoError {
+    token: Token | number;
+    source?: string;
+    file?: string;
+    constructor(message: string, token: Token | number, source?: string, file?: string);
+    getContext(): {
+        type: string;
+        message: string;
+        source: string;
+        position: number;
+        file: string;
+    };
+}
+export declare class RuntimeError extends VentoError {
+    context: TemplateContext;
+    constructor(error: Error, context: TemplateContext);
+    getContext(): ErrorContext | Promise<ErrorContext>;
+}
+export declare function createError(error: Error, context: TemplateContext): Error;
+export declare function printError(error: unknown): Promise<void>;
+export interface ErrorFormat {
+    number: (n: string) => string;
+    dim: (line: string) => string;
+    error: (msg: string) => string;
 }
-/** Returns the number and code of the errored line */
-export declare function errorLine(source: string, position: number): {
-    line: number;
-    column: number;
-    code: string;
-};
-export {};
+export declare function stringifyContext(context: ErrorContext, format?: ErrorFormat): string;

package/types/core/tokenizer.d.ts

@@ -1,5 +1,5 @@
 export type TokenType = "string" | "tag" | "filter" | "comment";
-export type Token = [TokenType, string, number?];
+export type Token = [TokenType, string, number];
 export default function tokenize(source: string): Token[];
 /**
  * Parse a tag and return the indexes of the start and end brackets, and the filters between.

package/types/loaders/file.d.ts

@@ -1,7 +1,7 @@
 import type { Loader, TemplateSource } from "../core/environment.d.ts";
 /**
  * Vento file loader for loading templates from the file system.
- * Used by JS runtimes like Node, Deno, and Bun.
+ * Used by Node-like runtimes (Node, Deno, Bun, ...)
  */
 export declare class FileLoader implements Loader {
     #private;

package/types/loaders/filesystem.d.ts

@@ -0,0 +1,12 @@
+import type { Loader, TemplateSource } from "../core/environment.d.ts";
+/**
+ * Vento FileSystem API loader for loading templates.
+ * Used by browser environments.
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/File_System_API
+ */
+export declare class FileSystemLoader implements Loader {
+    #private;
+    constructor(handle: FileSystemDirectoryHandle);
+    load(file: string): Promise<TemplateSource>;
+    resolve(from: string, file: string): string;
+}

package/types/loaders/memory.d.ts

@@ -4,7 +4,7 @@ import type { Loader, TemplateSource } from "../core/environment.d.ts";
  * Used for testing or in-memory operations.
  */
 export declare class MemoryLoader implements Loader {
-    files: Record<string, string>;
+    files: Map<string, string>;
     constructor(files: Record<string, string>);
     load(file: string): Promise<TemplateSource>;
     resolve(from: string, file: string): string;

package/types/loaders/module.d.ts

@@ -0,0 +1,19 @@
+import type { Loader, PrecompiledTemplate, Template } from "../core/environment.d.ts";
+/**
+ * Vento loader for loading templates from a ES modules.
+ * Used to load precompiled templates.
+ */
+export declare class ModuleLoader implements Loader {
+    #private;
+    constructor(root: URL);
+    load(file: string): Promise<PrecompiledTemplate>;
+    resolve(from: string, file: string): string;
+}
+export interface ExportOptions {
+    source?: boolean;
+}
+/**
+ * Exports a template as a string that can be used in an ES module.
+ * This is useful for precompiled templates.
+ */
+export declare function exportTemplate(template: Template, options?: ExportOptions): string;

package/types/loaders/utils.d.ts

@@ -0,0 +1 @@
+export declare function join(...paths: string[]): string;