ventojs 0.9.2 → 0.11.0

package/esm/deps/deno.land/std@0.210.0/assert/assert.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Make an assertion, error will be thrown if `expr` does not have truthy value.
+ *
+ * @example
+ * ```ts
+ * import { assert } from "https://deno.land/std@$STD_VERSION/assert/assert.ts";
+ *
+ * assert("hello".includes("ello")); // Doesn't throw
+ * assert("hello".includes("world")); // Throws
+ * ```
+ */
+export declare function assert(expr: unknown, msg?: string): asserts expr;

package/esm/deps/deno.land/std@0.210.0/assert/assert.js

@@ -0,0 +1,18 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Make an assertion, error will be thrown if `expr` does not have truthy value.
+ *
+ * @example
+ * ```ts
+ * import { assert } from "https://deno.land/std@$STD_VERSION/assert/assert.ts";
+ *
+ * assert("hello".includes("ello")); // Doesn't throw
+ * assert("hello".includes("world")); // Throws
+ * ```
+ */
+export function assert(expr, msg = "") {
+    if (!expr) {
+        throw new AssertionError(msg);
+    }
+}

package/esm/deps/deno.land/std@0.210.0/assert/assertion_error.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example
+ * ```ts
+ * import { AssertionError } from "https://deno.land/std@$STD_VERSION/assert/assertion_error.ts";
+ *
+ * throw new AssertionError("Assertion failed");
+ * ```
+ */
+export declare class AssertionError extends Error {
+    /** Constructs a new instance. */
+    constructor(message: string);
+}

package/esm/deps/deno.land/std@0.210.0/assert/assertion_error.js

@@ -0,0 +1,18 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example
+ * ```ts
+ * import { AssertionError } from "https://deno.land/std@$STD_VERSION/assert/assertion_error.ts";
+ *
+ * throw new AssertionError("Assertion failed");
+ * ```
+ */
+export class AssertionError extends Error {
+    /** Constructs a new instance. */
+    constructor(message) {
+        super(message);
+        this.name = "AssertionError";
+    }
+}

package/{script/deps/deno.land/std@0.208.0 → esm/deps/deno.land/std@0.210.0}/path/_common/glob_to_reg_exp.d.ts

@@ -1,3 +1,4 @@
+/** Options for {@linkcode globToRegExp}. */
 export interface GlobOptions {
     /** Extended glob syntax.
      * See https://www.linuxjournal.com/content/bash-extended-globbing.

package/esm/deps/deno.land/std@0.210.0/path/common.d.ts

@@ -0,0 +1,13 @@
+/** Determines the common path from a set of paths, using an optional separator,
+ * which defaults to the OS default separator.
+ *
+ * ```ts
+ *       import { common } from "https://deno.land/std@$STD_VERSION/path/mod.ts";
+ *       const p = common([
+ *         "./deno/std/path/mod.ts",
+ *         "./deno/std/fs/mod.ts",
+ *       ]);
+ *       console.log(p); // "./deno/std/"
+ * ```
+ */
+export declare function common(paths: string[], sep?: "/" | "\\"): string;

package/esm/deps/deno.land/{std@0.208.0 → std@0.210.0}/path/extname.js

@@ -2,7 +2,7 @@
 // This module is browser compatible.
 import { isWindows } from "./_os.js";
 import { extname as posixExtname } from "./posix/extname.js";
-import { extname as windowsExtname } from "./posix/extname.js";
+import { extname as windowsExtname } from "./windows/extname.js";
 /**
  * Return the extension of the `path` with leading period.
  * @param path with extension

package/{script/deps/deno.land/std@0.208.0 → esm/deps/deno.land/std@0.210.0}/path/mod.d.ts

@@ -4,8 +4,8 @@ import * as _posix from "./posix/mod.js";
 export declare const win32: typeof _windows;
 /** @deprecated (will be removed after 1.0.0) Import from {@link https://deno.land/std/posix/mod.ts} instead. */
 export declare const posix: typeof _posix;
-export declare const sep: string;
-export declare const delimiter: string;
+export declare const sep: "/" | "\\";
+export declare const delimiter: ":" | ";";
 export * from "./basename.js";
 export * from "./dirname.js";
 export * from "./extname.js";

package/esm/deps/deno.land/{std@0.208.0 → std@0.210.0}/path/mod.js

@@ -40,7 +40,9 @@ export const win32 = _windows;
 /** @deprecated (will be removed after 1.0.0) Import from {@link https://deno.land/std/posix/mod.ts} instead. */
 export const posix = _posix;
 export const sep = isWindows ? _windows.sep : _posix.sep;
-export const delimiter = isWindows ? _windows.delimiter : _posix.delimiter;
+export const delimiter = isWindows
+    ? _windows.delimiter
+    : _posix.delimiter;
 export * from "./basename.js";
 export * from "./dirname.js";
 export * from "./extname.js";

package/{script/deps/deno.land/std@0.208.0 → esm/deps/deno.land/std@0.210.0}/path/posix/to_file_url.d.ts

@@ -9,4 +9,4 @@
  * ```
  * @param path to convert to file URL
  */
-export declare function toFileUrl(path: string): import("url").URL;
+export declare function toFileUrl(path: string): URL;

package/esm/deps/deno.land/{std@0.208.0 → std@0.210.0}/path/separator.d.ts

@@ -1,2 +1,2 @@
-export declare const SEP: string;
+export declare const SEP: "/" | "\\";
 export declare const SEP_PATTERN: RegExp;

package/esm/deps.d.ts

@@ -1,2 +1,2 @@
-export * as path from "./deps/deno.land/std@0.208.0/path/mod.js";
-export * as html from "./deps/deno.land/std@0.208.0/html/mod.js";
+export * as path from "./deps/deno.land/std@0.210.0/path/mod.js";
+export * as html from "./deps/deno.land/std@0.210.0/html/mod.js";

package/esm/deps.js

@@ -1,2 +1,2 @@
-export * as path from "./deps/deno.land/std@0.208.0/path/mod.js";
-export * as html from "./deps/deno.land/std@0.208.0/html/mod.js";
+export * as path from "./deps/deno.land/std@0.210.0/path/mod.js";
+export * as html from "./deps/deno.land/std@0.210.0/html/mod.js";

package/esm/mod.js

@@ -13,6 +13,7 @@ import exportTag from "./plugins/export.js";
 import echoTag from "./plugins/echo.js";
 import escape from "./plugins/escape.js";
 import unescape from "./plugins/unescape.js";
+import trim from "./plugins/trim.js";
 export default function (options = {}) {
     const loader = typeof options.includes === "object"
         ? options.includes
@@ -36,5 +37,6 @@ export default function (options = {}) {
     env.use(echoTag());
     env.use(escape());
     env.use(unescape());
+    env.use(trim());
     return env;
 }

package/esm/plugins/auto_trim.d.ts

@@ -0,0 +1,8 @@
+import type { Token } from "../src/tokenizer.js";
+import type { Environment } from "../src/environment.js";
+export declare const defaultTags: string[];
+export type AutoTrimOptions = {
+    tags: string[];
+};
+export default function (options?: AutoTrimOptions): (env: Environment) => void;
+export declare function autoTrim(tokens: Token[], options: AutoTrimOptions): void;

package/esm/plugins/auto_trim.js

@@ -0,0 +1,36 @@
+export const defaultTags = [
+    ">",
+    "#",
+    "set",
+    "/set",
+    "if",
+    "/if",
+    "else",
+    "for",
+    "/for",
+    "function",
+    "async",
+    "/function",
+    "export",
+    "/export",
+    "import",
+];
+export default function (options = { tags: defaultTags }) {
+    return (env) => {
+        env.tokenPreprocessors.push((_, tokens) => autoTrim(tokens, options));
+    };
+}
+export function autoTrim(tokens, options) {
+    for (let i = 0; i < tokens.length; i++) {
+        const previous = tokens[i - 1];
+        const token = tokens[i];
+        const next = tokens[i + 1];
+        const [type, code] = token;
+        if (type === "tag" && options.tags.find((tag) => code.startsWith(tag))) {
+            // Remove leading horizontal space
+            previous[1] = previous[1].replace(/[ \t]*$/, "");
+            // Remove trailing horizontal space + newline
+            next[1] = next[1].replace(/^[ \t]*(?:\r\n|\n)/, "");
+        }
+    }
+}

package/esm/plugins/escape.js

@@ -1,6 +1,7 @@
 import { html } from "../deps.js";
 export default function () {
     return (env) => {
-        env.filters.escape = html.escape;
+        // deno-lint-ignore no-explicit-any
+        env.filters.escape = (value) => value ? html.escape(value.toString()) : "";
     };
 }

package/esm/plugins/for.js

@@ -25,7 +25,9 @@ function forTag(env, code, output, tokens) {
     compiled.push("}");
     return compiled.join("\n");
 }
-function toIterator(item, withKeys = false) {
+function toIterator(
+// deno-lint-ignore no-explicit-any
+item, withKeys = false) {
     if (item === undefined || item === null) {
         return [];
     }
@@ -36,6 +38,18 @@ function toIterator(item, withKeys = false) {
         return toIterator(item(), withKeys);
     }
     if (typeof item === "object" && item !== null) {
+        if (typeof item[Symbol.iterator] === "function") {
+            if (withKeys) {
+                return iterableToEntries(item);
+            }
+            return item;
+        }
+        if (typeof item[Symbol.asyncIterator] === "function") {
+            if (withKeys) {
+                return asyncIterableToEntries(item);
+            }
+            return item;
+        }
         return withKeys ? Object.entries(item) : Object.values(item);
     }
     if (typeof item === "string") {
@@ -46,3 +60,15 @@ function toIterator(item, withKeys = false) {
     }
     return toIterator([item], withKeys);
 }
+function* iterableToEntries(iterator) {
+    let i = 0;
+    for (const value of iterator) {
+        yield [i++, value];
+    }
+}
+async function* asyncIterableToEntries(iterator) {
+    let i = 0;
+    for await (const value of iterator) {
+        yield [i++, value];
+    }
+}

package/esm/plugins/js.js

@@ -4,7 +4,7 @@ export default function () {
     };
 }
 function jsTag(_env, code) {
-    if (!code.startsWith("> ")) {
+    if (!code.startsWith(">")) {
         return;
     }
     return code.replace(/^>\s+/, "");

package/esm/plugins/trim.d.ts

@@ -0,0 +1,4 @@
+import type { Token } from "../src/tokenizer.js";
+import type { Environment } from "../src/environment.js";
+export default function (): (env: Environment) => void;
+export declare function trim(_: Environment, tokens: Token[]): void;

package/esm/plugins/trim.js

@@ -0,0 +1,28 @@
+export default function () {
+    return (env) => {
+        env.tokenPreprocessors.push(trim);
+    };
+}
+export function trim(_, tokens) {
+    for (let i = 0; i < tokens.length; i++) {
+        const previous = tokens[i - 1];
+        const token = tokens[i];
+        const next = tokens[i + 1];
+        let [type, code] = token;
+        if (type === "tag" && code.startsWith("-")) {
+            previous[1] = previous[1].trimEnd();
+            code = code.slice(1);
+        }
+        if (type === "tag" && code.endsWith("-")) {
+            next[1] = next[1].trimStart();
+            code = code.slice(0, -1);
+        }
+        // Trim tag and filter code
+        switch (type) {
+            case "tag":
+            case "filter":
+                token[1] = code.trim();
+                break;
+        }
+    }
+}

package/esm/plugins/unescape.js

@@ -1,6 +1,7 @@
 import { html } from "../deps.js";
 export default function () {
     return (env) => {
-        env.filters.unescape = html.unescape;
+        // deno-lint-ignore no-explicit-any
+        env.filters.unescape = (value) => value ? html.unescape(value.toString()) : "";
     };
 }

package/esm/src/environment.d.ts

@@ -16,8 +16,13 @@ export interface TemplateSync {
     code: string;
     file?: string;
 }
+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 Filter = (...args: any[]) => any;
+export type FilterThis = {
+    data: Record<string, unknown>;
+    env: Environment;
+};
+export type Filter = (this: FilterThis, ...args: any[]) => any;
 export type Plugin = (env: Environment) => void;
 export interface Options {
     loader: Loader;
@@ -29,6 +34,7 @@ export declare class Environment {
     cache: Map<string, Template>;
     options: Options;
     tags: Tag[];
+    tokenPreprocessors: TokenPreprocessor[];
     filters: Record<string, Filter>;
     utils: Record<string, unknown>;
     constructor(options: Options);
@@ -38,6 +44,7 @@ export declare class Environment {
     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;
+    tokenize(source: string, path?: string): Token[];
     load(file: string, from?: string): Promise<Template>;
     compileTokens(tokens: Token[], outputVar?: string, stopAt?: string[]): string[];
     compileFilters(tokens: Token[], output: string, autoescape?: boolean): string;

package/esm/src/environment.js

@@ -4,6 +4,7 @@ export class Environment {
     cache = new Map();
     options;
     tags = [];
+    tokenPreprocessors = [];
     filters = {};
     utils = {};
     constructor(options) {
@@ -34,10 +35,7 @@ export class Environment {
         return template(data);
     }
     compile(source, path, defaults, sync = false) {
-        const { tokens, position, error } = tokenize(source);
-        if (error) {
-            throw this.createError(path || "unknown", source, position, error);
-        }
+        const tokens = this.tokenize(source, path);
         const code = this.compileTokens(tokens).join("\n");
         const { dataVarname, useWith } = this.options;
         const constructor = new Function("__file", "__env", "__defaults", `return${sync ? "" : " async"} function (${dataVarname}) {
@@ -59,10 +57,29 @@ export class Environment {
         template.source = source;
         return template;
     }
+    tokenize(source, path) {
+        const result = tokenize(source);
+        let { tokens } = result;
+        const { position, error } = result;
+        if (error) {
+            throw this.createError(path || "unknown", source, position, error);
+        }
+        for (const tokenPreprocessor of this.tokenPreprocessors) {
+            const result = tokenPreprocessor(this, tokens, path);
+            if (result !== undefined) {
+                tokens = result;
+            }
+        }
+        return tokens;
+    }
     async load(file, from) {
         const path = from ? this.options.loader.resolve(from, file) : file;
         if (!this.cache.has(path)) {
-            const { source, data } = await this.options.loader.load(path);
+            // Remove query and hash params from path before loading
+            const cleanPath = path
+                .split("?")[0]
+                .split("#")[0];
+            const { source, data } = await this.options.loader.load(cleanPath);
             const template = this.compile(source, path, data);
             this.cache.set(path, template);
         }
@@ -124,7 +141,8 @@ export class Environment {
             }
             else {
                 // It's a filter (e.g. filters.upper())
-                output = `${isAsync ? "await " : ""}__env.filters.${name}(${output}${args ? `, ${args}` : ""})`;
+                const { dataVarname } = this.options;
+                output = `${(isAsync || checkAsync(this.filters[name])) ? "await " : ""}__env.filters.${name}.call({data:${dataVarname},env:__env}, ${output}${args ? `, ${args}` : ""})`;
             }
         }
         // Escape by default
@@ -171,3 +189,6 @@ export function errorLine(source, pos) {
     }
     return [line, column, source.split("\n")[line - 1]];
 }
+function checkAsync(fn) {
+    return fn.constructor?.name === "AsyncFunction";
+}

package/esm/src/tokenizer.js

@@ -1,20 +1,13 @@
 export default function tokenize(source) {
     const tokens = [];
     let type = "string";
-    let trimNext = false;
     let position = 0;
     try {
         while (source.length > 0) {
             if (type === "string") {
                 const index = source.indexOf("{{");
                 const code = index === -1 ? source : source.slice(0, index);
-                if (trimNext) {
-                    tokens.push([type, code.trimStart(), position]);
-                    trimNext = false;
-                }
-                else {
-                    tokens.push([type, code, position]);
-                }
+                tokens.push([type, code, position]);
                 if (index === -1) {
                     break;
                 }
@@ -41,39 +34,23 @@ export default function tokenize(source) {
                 const lastIndex = indexes.length - 1;
                 let tag;
                 indexes.reduce((prev, curr, index) => {
-                    let code = source.slice(prev, curr - 2);
+                    const code = source.slice(prev, curr - 2);
                     // Tag
                     if (index === 1) {
-                        // Left trim
-                        if (code.startsWith("-")) {
-                            code = code.slice(1);
-                            const lastToken = tokens[tokens.length - 1];
-                            lastToken[1] = lastToken[1].trimEnd();
-                        }
-                        // Right trim
-                        if (code.endsWith("-") && index === lastIndex) {
-                            code = code.slice(0, -1);
-                            trimNext = true;
-                        }
-                        tag = [type, code.trim(), position];
+                        tag = [type, code, position];
                         tokens.push(tag);
                         return curr;
                     }
-                    // Right trim
-                    if (index === lastIndex && code.endsWith("-")) {
-                        code = code.slice(0, -1);
-                        trimNext = true;
-                    }
                     // Filters
-                    tokens.push(["filter", code.trim()]);
+                    tokens.push(["filter", code]);
                     return curr;
                 });
                 position += indexes[lastIndex];
                 source = source.slice(indexes[lastIndex]);
                 type = "string";
                 // Search the closing echo tag {{ /echo }}
-                if (tag?.[1] === "echo") {
-                    const end = source.match(/{{\s*\/echo\s*}}/);
+                if (tag?.[1].match(/^\-?\s*echo\s*\-?$/)) {
+                    const end = source.match(/{{\-?\s*\/echo\s*\-?}}/);
                     if (!end) {
                         throw new Error("Unclosed echo tag");
                     }
@@ -111,7 +88,8 @@ export function parseTag(source) {
                     statuses.unshift("bracket");
                 }
                 else if (status !== "comment" && status !== "single-quote" &&
-                    status !== "double-quote" && status !== "literal") {
+                    status !== "double-quote" && status !== "literal" &&
+                    status !== "regex" && status !== "line-comment") {
                     statuses.unshift("bracket");
                 }
                 break;
@@ -136,7 +114,9 @@ export function parseTag(source) {
                 }
                 else if (status !== "comment" &&
                     status !== "single-quote" &&
-                    status !== "literal") {
+                    status !== "literal" &&
+                    status !== "regex" &&
+                    status !== "line-comment") {
                     statuses.unshift("double-quote");
                 }
                 break;
@@ -149,7 +129,9 @@ export function parseTag(source) {
                 }
                 else if (status !== "comment" &&
                     status !== "double-quote" &&
-                    status !== "literal") {
+                    status !== "literal" &&
+                    status !== "regex" &&
+                    status !== "line-comment") {
                     statuses.unshift("single-quote");
                 }
                 break;
@@ -162,23 +144,56 @@ export function parseTag(source) {
                 }
                 else if (status !== "comment" &&
                     status !== "double-quote" &&
-                    status !== "single-quote") {
+                    status !== "single-quote" &&
+                    status !== "regex" &&
+                    status !== "line-comment") {
                     statuses.unshift("literal");
                 }
                 break;
             }
-            // Detect comments
+            // Detect comments and regex
             case "/": {
                 const status = statuses[0];
-                if (status !== "single-quote" && status !== "double-quote" &&
-                    status !== "literal") {
-                    if (source.charAt(index) === "*") {
-                        statuses.unshift("comment");
+                if (status === "single-quote" || status === "double-quote" ||
+                    status === "literal" || status === "line-comment") {
+                    break;
+                }
+                // We are in a comment: close or ignore
+                if (status === "comment") {
+                    if (source.charAt(index - 2) === "*") {
+                        statuses.shift();
                     }
-                    else if (status === "comment" &&
-                        source.charAt(index - 2) === "*") {
+                    break;
+                }
+                // We are in a regex: close or ignore
+                if (status === "regex") {
+                    if (source.charAt(index - 2) !== "\\") {
                         statuses.shift();
                     }
+                    break;
+                }
+                // Start a new comment
+                if (source.charAt(index) === "*") {
+                    statuses.unshift("comment");
+                    break;
+                }
+                // Start a new line comment
+                if (source.charAt(index - 2) === "/") {
+                    statuses.unshift("line-comment");
+                    break;
+                }
+                // Start a new regex
+                const prev = prevChar(source, index - 1);
+                if (prev === "(" || prev === "=" || prev === ":" || prev === ",") {
+                    statuses.unshift("regex");
+                }
+                break;
+            }
+            // Detect end of line comments
+            case "\n": {
+                const status = statuses[0];
+                if (status === "line-comment") {
+                    statuses.shift();
                 }
                 break;
             }
@@ -194,3 +209,13 @@ export function parseTag(source) {
     }
     throw new Error("Unclosed tag");
 }
+// Get the previous character in a string ignoring spaces, line breaks and tabs
+function prevChar(source, index) {
+    while (index > 0) {
+        const char = source.charAt(--index);
+        if (char !== " " && char !== "\n" && char !== "\r" && char !== "\t") {
+            return char;
+        }
+    }
+    return "";
+}

package/package.json

@@ -2,7 +2,7 @@
   "module": "./esm/mod.js",
   "main": "./script/mod.js",
   "name": "ventojs",
-  "version": "0.9.2",
+  "version": "0.11.0",
   "description": "🌬 A minimal but powerful template engine",
   "license": "MIT",
   "repository": "github:oscarotero/vento",
@@ -12,6 +12,10 @@
     ".": {
       "import": "./esm/mod.js",
       "require": "./script/mod.js"
+    },
+    "./plugins/auto_trim.js": {
+      "import": "./esm/plugins/auto_trim.js",
+      "require": "./script/plugins/auto_trim.js"
     }
   },
   "scripts": {

package/script/deps/deno.land/std@0.210.0/assert/assert.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Make an assertion, error will be thrown if `expr` does not have truthy value.
+ *
+ * @example
+ * ```ts
+ * import { assert } from "https://deno.land/std@$STD_VERSION/assert/assert.ts";
+ *
+ * assert("hello".includes("ello")); // Doesn't throw
+ * assert("hello".includes("world")); // Throws
+ * ```
+ */
+export declare function assert(expr: unknown, msg?: string): asserts expr;

package/script/deps/deno.land/{std@0.208.0 → std@0.210.0}/assert/assert.js

@@ -3,7 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.assert = void 0;
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 const assertion_error_js_1 = require("./assertion_error.js");
-/** Make an assertion, error will be thrown if `expr` does not have truthy value. */
+/**
+ * Make an assertion, error will be thrown if `expr` does not have truthy value.
+ *
+ * @example
+ * ```ts
+ * import { assert } from "https://deno.land/std@$STD_VERSION/assert/assert.ts";
+ *
+ * assert("hello".includes("ello")); // Doesn't throw
+ * assert("hello".includes("world")); // Throws
+ * ```
+ */
 function assert(expr, msg = "") {
     if (!expr) {
         throw new assertion_error_js_1.AssertionError(msg);