ventojs 0.6.0 → 0.7.2

package/README.md

@@ -91,13 +91,26 @@ First, let's take a look at this syntax example:
 
 ## Getting started
 
-This is a library for Deno. I'm planning to release an NPM version in the
-future.
+This is a library for Deno. ~~I'm planning to release an NPM version in the
+future.~~
+[There's already an NPM version](https://www.npmjs.com/package/ventojs) that you
+can install with `npm install ventojs`.
 
-First, you need to import the library and create an instance:
+Import the library and create an instance:
 
 ```ts
-import vento from "https://deno.land/x/vento@v0.2.0/mod.ts";
+import vento from "https://deno.land/x/vento/mod.ts";
+
+const vto = vento({
+  // Resolve the non-relative includes paths
+  includes: "./path/to/includes",
+});
+```
+
+Or in Node:
+
+```ts
+import vento from "ventojs";
 
 const vto = vento({
   // Resolve the non-relative includes paths
@@ -113,19 +126,22 @@ can use `load` to load and compile a template file and return it.
 const template = vto.load("my-template.vto");
 
 // Now you can use it passing the data
-template({ title: "Hello world" });
+const result = template({ title: "Hello world" });
+console.log(result.content);
 ```
 
 Alternatively, you can load and run the template file in a single call:
 
 ```ts
-vto.run("my-template.vto", { title: "Hello world" });
+const result = vto.run("my-template.vto", { title: "Hello world" });
+console.log(result.content);
 ```
 
 If the template code is not a file, you can run it directly:
 
 ```ts
-vto.runString("<h1>{{ title }}</h1>", { title: "Hello world" });
+const result = vto.runString("<h1>{{ title }}</h1>", { title: "Hello world" });
+console.log(result.content);
 ```
 
 ## Visual Studio Code Support

package/esm/_dnt.shims.js

@@ -4,7 +4,6 @@ const dntGlobals = {
     Deno,
 };
 export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
-// deno-lint-ignore ban-types
 function createMergeProxy(baseObj, extObj) {
     return new Proxy(baseObj, {
         get(_target, prop, _receiver) {

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

@@ -0,0 +1,2 @@
+/** Make an assertion, error will be thrown if `expr` does not have truthy value. */
+export declare function assert(expr: unknown, msg?: string): asserts expr;

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

@@ -0,0 +1,8 @@
+// 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. */
+export function assert(expr, msg = "") {
+    if (!expr) {
+        throw new AssertionError(msg);
+    }
+}

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

@@ -0,0 +1,4 @@
+export declare class AssertionError extends Error {
+    name: string;
+    constructor(message: string);
+}

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

@@ -0,0 +1,7 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+export class AssertionError extends Error {
+    name = "AssertionError";
+    constructor(message) {
+        super(message);
+    }
+}

package/esm/deps/deno.land/std@0.201.0/path/_basename.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Return the last portion of a `path`.
+ * Trailing directory separators are ignored, and optional suffix is removed.
+ *
+ * @param path - path to extract the name from.
+ * @param [suffix] - suffix to remove from extracted name.
+ */
+export declare function posixBasename(path: string, suffix?: string): string;
+/**
+ * Return the last portion of a `path`.
+ * Trailing directory separators are ignored, and optional suffix is removed.
+ *
+ * @param path - path to extract the name from.
+ * @param [suffix] - suffix to remove from extracted name.
+ */
+export declare function windowsBasename(path: string, suffix?: string): string;

package/esm/deps/deno.land/std@0.201.0/path/_basename.js

@@ -0,0 +1,78 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { CHAR_COLON } from "./_constants.js";
+import { assertPath, isPathSeparator, isPosixPathSeparator, isWindowsDeviceRoot, stripTrailingSeparators, } from "./_util.js";
+function stripSuffix(name, suffix) {
+    if (suffix.length >= name.length) {
+        return name;
+    }
+    const lenDiff = name.length - suffix.length;
+    for (let i = suffix.length - 1; i >= 0; --i) {
+        if (name.charCodeAt(lenDiff + i) !== suffix.charCodeAt(i)) {
+            return name;
+        }
+    }
+    return name.slice(0, -suffix.length);
+}
+function lastPathSegment(path, isSep, start = 0) {
+    let matchedNonSeparator = false;
+    let end = path.length;
+    for (let i = path.length - 1; i >= start; --i) {
+        if (isSep(path.charCodeAt(i))) {
+            if (matchedNonSeparator) {
+                start = i + 1;
+                break;
+            }
+        }
+        else if (!matchedNonSeparator) {
+            matchedNonSeparator = true;
+            end = i + 1;
+        }
+    }
+    return path.slice(start, end);
+}
+function assertArgs(path, suffix) {
+    assertPath(path);
+    if (path.length === 0)
+        return path;
+    if (typeof suffix !== "string") {
+        throw new TypeError(`Suffix must be a string. Received ${JSON.stringify(suffix)}`);
+    }
+}
+/**
+ * Return the last portion of a `path`.
+ * Trailing directory separators are ignored, and optional suffix is removed.
+ *
+ * @param path - path to extract the name from.
+ * @param [suffix] - suffix to remove from extracted name.
+ */
+export function posixBasename(path, suffix = "") {
+    assertArgs(path, suffix);
+    const lastSegment = lastPathSegment(path, isPosixPathSeparator);
+    const strippedSegment = stripTrailingSeparators(lastSegment, isPosixPathSeparator);
+    return suffix ? stripSuffix(strippedSegment, suffix) : strippedSegment;
+}
+/**
+ * Return the last portion of a `path`.
+ * Trailing directory separators are ignored, and optional suffix is removed.
+ *
+ * @param path - path to extract the name from.
+ * @param [suffix] - suffix to remove from extracted name.
+ */
+export function windowsBasename(path, suffix = "") {
+    assertArgs(path, suffix);
+    // Check for a drive letter prefix so as not to mistake the following
+    // path separator as an extra separator at the end of the path that can be
+    // disregarded
+    let start = 0;
+    if (path.length >= 2) {
+        const drive = path.charCodeAt(0);
+        if (isWindowsDeviceRoot(drive)) {
+            if (path.charCodeAt(1) === CHAR_COLON)
+                start = 2;
+        }
+    }
+    const lastSegment = lastPathSegment(path, isPathSeparator, start);
+    const strippedSegment = stripTrailingSeparators(lastSegment, isPathSeparator);
+    return suffix ? stripSuffix(strippedSegment, suffix) : strippedSegment;
+}

package/esm/deps/deno.land/std@0.201.0/path/_dirname.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Return the directory path of a `path`.
+ * @param path - path to extract the directory from.
+ */
+export declare function posixDirname(path: string): string;
+/**
+ * Return the directory path of a `path`.
+ * @param path - path to extract the directory from.
+ */
+export declare function windowsDirname(path: string): string;

package/esm/deps/deno.land/std@0.201.0/path/_dirname.js

@@ -0,0 +1,132 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { CHAR_COLON } from "./_constants.js";
+import { assertPath, isPathSeparator, isPosixPathSeparator, isWindowsDeviceRoot, stripTrailingSeparators, } from "./_util.js";
+function assertArg(path) {
+    assertPath(path);
+    if (path.length === 0)
+        return ".";
+}
+/**
+ * Return the directory path of a `path`.
+ * @param path - path to extract the directory from.
+ */
+export function posixDirname(path) {
+    assertArg(path);
+    let end = -1;
+    let matchedNonSeparator = false;
+    for (let i = path.length - 1; i >= 1; --i) {
+        if (isPosixPathSeparator(path.charCodeAt(i))) {
+            if (matchedNonSeparator) {
+                end = i;
+                break;
+            }
+        }
+        else {
+            matchedNonSeparator = true;
+        }
+    }
+    // No matches. Fallback based on provided path:
+    //
+    // - leading slashes paths
+    //     "/foo" => "/"
+    //     "///foo" => "/"
+    // - no slash path
+    //     "foo" => "."
+    if (end === -1) {
+        return isPosixPathSeparator(path.charCodeAt(0)) ? "/" : ".";
+    }
+    return stripTrailingSeparators(path.slice(0, end), isPosixPathSeparator);
+}
+/**
+ * Return the directory path of a `path`.
+ * @param path - path to extract the directory from.
+ */
+export function windowsDirname(path) {
+    assertArg(path);
+    const len = path.length;
+    let rootEnd = -1;
+    let end = -1;
+    let matchedSlash = true;
+    let offset = 0;
+    const code = path.charCodeAt(0);
+    // Try to match a root
+    if (len > 1) {
+        if (isPathSeparator(code)) {
+            // Possible UNC root
+            rootEnd = offset = 1;
+            if (isPathSeparator(path.charCodeAt(1))) {
+                // Matched double path separator at beginning
+                let j = 2;
+                let last = j;
+                // Match 1 or more non-path separators
+                for (; j < len; ++j) {
+                    if (isPathSeparator(path.charCodeAt(j)))
+                        break;
+                }
+                if (j < len && j !== last) {
+                    // Matched!
+                    last = j;
+                    // Match 1 or more path separators
+                    for (; j < len; ++j) {
+                        if (!isPathSeparator(path.charCodeAt(j)))
+                            break;
+                    }
+                    if (j < len && j !== last) {
+                        // Matched!
+                        last = j;
+                        // Match 1 or more non-path separators
+                        for (; j < len; ++j) {
+                            if (isPathSeparator(path.charCodeAt(j)))
+                                break;
+                        }
+                        if (j === len) {
+                            // We matched a UNC root only
+                            return path;
+                        }
+                        if (j !== last) {
+                            // We matched a UNC root with leftovers
+                            // Offset by 1 to include the separator after the UNC root to
+                            // treat it as a "normal root" on top of a (UNC) root
+                            rootEnd = offset = j + 1;
+                        }
+                    }
+                }
+            }
+        }
+        else if (isWindowsDeviceRoot(code)) {
+            // Possible device root
+            if (path.charCodeAt(1) === CHAR_COLON) {
+                rootEnd = offset = 2;
+                if (len > 2) {
+                    if (isPathSeparator(path.charCodeAt(2)))
+                        rootEnd = offset = 3;
+                }
+            }
+        }
+    }
+    else if (isPathSeparator(code)) {
+        // `path` contains just a path separator, exit early to avoid
+        // unnecessary work
+        return path;
+    }
+    for (let i = len - 1; i >= offset; --i) {
+        if (isPathSeparator(path.charCodeAt(i))) {
+            if (!matchedSlash) {
+                end = i;
+                break;
+            }
+        }
+        else {
+            // We saw the first non-path separator
+            matchedSlash = false;
+        }
+    }
+    if (end === -1) {
+        if (rootEnd === -1)
+            return ".";
+        else
+            end = rootEnd;
+    }
+    return stripTrailingSeparators(path.slice(0, end), isPosixPathSeparator);
+}

package/esm/deps/deno.land/std@0.201.0/path/_extname.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Return the extension of the `path` with leading period.
+ * @param path with extension
+ * @returns extension (ex. for `file.ts` returns `.ts`)
+ */
+export declare function posixExtname(path: string): string;
+/**
+ * Return the extension of the `path` with leading period.
+ * @param path with extension
+ * @returns extension (ex. for `file.ts` returns `.ts`)
+ */
+export declare function windowsExtname(path: string): string;

package/esm/deps/deno.land/std@0.201.0/path/_extname.js

@@ -0,0 +1,121 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { CHAR_COLON, CHAR_DOT } from "./_constants.js";
+import { assertPath, isPathSeparator, isPosixPathSeparator, isWindowsDeviceRoot, } from "./_util.js";
+/**
+ * Return the extension of the `path` with leading period.
+ * @param path with extension
+ * @returns extension (ex. for `file.ts` returns `.ts`)
+ */
+export function posixExtname(path) {
+    assertPath(path);
+    let startDot = -1;
+    let startPart = 0;
+    let end = -1;
+    let matchedSlash = true;
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    let preDotState = 0;
+    for (let i = path.length - 1; i >= 0; --i) {
+        const code = path.charCodeAt(i);
+        if (isPosixPathSeparator(code)) {
+            // If we reached a path separator that was not part of a set of path
+            // separators at the end of the string, stop now
+            if (!matchedSlash) {
+                startPart = i + 1;
+                break;
+            }
+            continue;
+        }
+        if (end === -1) {
+            // We saw the first non-path separator, mark this as the end of our
+            // extension
+            matchedSlash = false;
+            end = i + 1;
+        }
+        if (code === CHAR_DOT) {
+            // If this is our first dot, mark it as the start of our extension
+            if (startDot === -1)
+                startDot = i;
+            else if (preDotState !== 1)
+                preDotState = 1;
+        }
+        else if (startDot !== -1) {
+            // We saw a non-dot and non-path separator before our dot, so we should
+            // have a good chance at having a non-empty extension
+            preDotState = -1;
+        }
+    }
+    if (startDot === -1 ||
+        end === -1 ||
+        // We saw a non-dot character immediately before the dot
+        preDotState === 0 ||
+        // The (right-most) trimmed path component is exactly '..'
+        (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)) {
+        return "";
+    }
+    return path.slice(startDot, end);
+}
+/**
+ * Return the extension of the `path` with leading period.
+ * @param path with extension
+ * @returns extension (ex. for `file.ts` returns `.ts`)
+ */
+export function windowsExtname(path) {
+    assertPath(path);
+    let start = 0;
+    let startDot = -1;
+    let startPart = 0;
+    let end = -1;
+    let matchedSlash = true;
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    let preDotState = 0;
+    // Check for a drive letter prefix so as not to mistake the following
+    // path separator as an extra separator at the end of the path that can be
+    // disregarded
+    if (path.length >= 2 &&
+        path.charCodeAt(1) === CHAR_COLON &&
+        isWindowsDeviceRoot(path.charCodeAt(0))) {
+        start = startPart = 2;
+    }
+    for (let i = path.length - 1; i >= start; --i) {
+        const code = path.charCodeAt(i);
+        if (isPathSeparator(code)) {
+            // If we reached a path separator that was not part of a set of path
+            // separators at the end of the string, stop now
+            if (!matchedSlash) {
+                startPart = i + 1;
+                break;
+            }
+            continue;
+        }
+        if (end === -1) {
+            // We saw the first non-path separator, mark this as the end of our
+            // extension
+            matchedSlash = false;
+            end = i + 1;
+        }
+        if (code === CHAR_DOT) {
+            // If this is our first dot, mark it as the start of our extension
+            if (startDot === -1)
+                startDot = i;
+            else if (preDotState !== 1)
+                preDotState = 1;
+        }
+        else if (startDot !== -1) {
+            // We saw a non-dot and non-path separator before our dot, so we should
+            // have a good chance at having a non-empty extension
+            preDotState = -1;
+        }
+    }
+    if (startDot === -1 ||
+        end === -1 ||
+        // We saw a non-dot character immediately before the dot
+        preDotState === 0 ||
+        // The (right-most) trimmed path component is exactly '..'
+        (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)) {
+        return "";
+    }
+    return path.slice(startDot, end);
+}

package/esm/deps/deno.land/std@0.201.0/path/_format.d.ts

@@ -0,0 +1,11 @@
+import type { FormatInputPathObject } from "./_interface.js";
+/**
+ * Generate a path from `FormatInputPathObject` object.
+ * @param pathObject with path
+ */
+export declare function posixFormat(pathObject: FormatInputPathObject): string;
+/**
+ * Generate a path from `FormatInputPathObject` object.
+ * @param pathObject with path
+ */
+export declare function windowsFormat(pathObject: FormatInputPathObject): string;

package/esm/deps/deno.land/std@0.201.0/path/_format.js

@@ -0,0 +1,35 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+function _format(sep, pathObject) {
+    const dir = pathObject.dir || pathObject.root;
+    const base = pathObject.base ||
+        (pathObject.name || "") + (pathObject.ext || "");
+    if (!dir)
+        return base;
+    if (base === sep)
+        return dir;
+    if (dir === pathObject.root)
+        return dir + base;
+    return dir + sep + base;
+}
+function assertArg(pathObject) {
+    if (pathObject === null || typeof pathObject !== "object") {
+        throw new TypeError(`The "pathObject" argument must be of type Object. Received type ${typeof pathObject}`);
+    }
+}
+/**
+ * Generate a path from `FormatInputPathObject` object.
+ * @param pathObject with path
+ */
+export function posixFormat(pathObject) {
+    assertArg(pathObject);
+    return _format("/", pathObject);
+}
+/**
+ * Generate a path from `FormatInputPathObject` object.
+ * @param pathObject with path
+ */
+export function windowsFormat(pathObject) {
+    assertArg(pathObject);
+    return _format("\\", pathObject);
+}

package/esm/deps/deno.land/std@0.201.0/path/_from_file_url.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+/**
+ * Converts a file URL to a path string.
+ *
+ * ```ts
+ * import { fromFileUrl } from "https://deno.land/std@$STD_VERSION/path/posix.ts";
+ *
+ * fromFileUrl("file:///home/foo"); // "/home/foo"
+ * ```
+ * @param url of a file URL
+ */
+export declare function posixFromFileUrl(url: URL | string): string;
+/**
+ * Converts a file URL to a path string.
+ *
+ * ```ts
+ * import { fromFileUrl } from "https://deno.land/std@$STD_VERSION/path/win32.ts";
+ *
+ * fromFileUrl("file:///home/foo"); // "\\home\\foo"
+ * fromFileUrl("file:///C:/Users/foo"); // "C:\\Users\\foo"
+ * fromFileUrl("file://localhost/home/foo"); // "\\\\localhost\\home\\foo"
+ * ```
+ * @param url of a file URL
+ */
+export declare function windowsFromFileUrl(url: URL | string): string;

package/esm/deps/deno.land/std@0.201.0/path/_from_file_url.js

@@ -0,0 +1,46 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+function assertArg(url) {
+    url = url instanceof URL ? url : new URL(url);
+    if (url.protocol !== "file:") {
+        throw new TypeError("Must be a file URL.");
+    }
+    return url;
+}
+/**
+ * Converts a file URL to a path string.
+ *
+ * ```ts
+ * import { fromFileUrl } from "https://deno.land/std@$STD_VERSION/path/posix.ts";
+ *
+ * fromFileUrl("file:///home/foo"); // "/home/foo"
+ * ```
+ * @param url of a file URL
+ */
+export function posixFromFileUrl(url) {
+    url = assertArg(url);
+    return decodeURIComponent(url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25"));
+}
+/**
+ * Converts a file URL to a path string.
+ *
+ * ```ts
+ * import { fromFileUrl } from "https://deno.land/std@$STD_VERSION/path/win32.ts";
+ *
+ * fromFileUrl("file:///home/foo"); // "\\home\\foo"
+ * fromFileUrl("file:///C:/Users/foo"); // "C:\\Users\\foo"
+ * fromFileUrl("file://localhost/home/foo"); // "\\\\localhost\\home\\foo"
+ * ```
+ * @param url of a file URL
+ */
+export function windowsFromFileUrl(url) {
+    url = assertArg(url);
+    let path = decodeURIComponent(url.pathname.replace(/\//g, "\\").replace(/%(?![0-9A-Fa-f]{2})/g, "%25")).replace(/^\\*([A-Za-z]:)(\\|$)/, "$1\\");
+    if (url.hostname !== "") {
+        // Note: The `URL` implementation guarantees that the drive letter and
+        // hostname are mutually exclusive. Otherwise it would not have been valid
+        // to append the hostname and path like this.
+        path = `\\\\${url.hostname}${path}`;
+    }
+    return path;
+}

package/esm/deps/deno.land/std@0.201.0/path/_is_absolute.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Verifies whether provided path is absolute
+ * @param path to be verified as absolute
+ */
+export declare function windowsIsAbsolute(path: string): boolean;
+/**
+ * Verifies whether provided path is absolute
+ * @param path to be verified as absolute
+ */
+export declare function posixIsAbsolute(path: string): boolean;

package/esm/deps/deno.land/std@0.201.0/path/_is_absolute.js

@@ -0,0 +1,34 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { CHAR_COLON } from "./_constants.js";
+import { assertPath, isPathSeparator, isPosixPathSeparator, isWindowsDeviceRoot, } from "./_util.js";
+/**
+ * Verifies whether provided path is absolute
+ * @param path to be verified as absolute
+ */
+export function windowsIsAbsolute(path) {
+    assertPath(path);
+    const len = path.length;
+    if (len === 0)
+        return false;
+    const code = path.charCodeAt(0);
+    if (isPathSeparator(code)) {
+        return true;
+    }
+    else if (isWindowsDeviceRoot(code)) {
+        // Possible device root
+        if (len > 2 && path.charCodeAt(1) === CHAR_COLON) {
+            if (isPathSeparator(path.charCodeAt(2)))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Verifies whether provided path is absolute
+ * @param path to be verified as absolute
+ */
+export function posixIsAbsolute(path) {
+    assertPath(path);
+    return path.length > 0 && isPosixPathSeparator(path.charCodeAt(0));
+}

package/esm/deps/deno.land/std@0.201.0/path/_join.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Join all given a sequence of `paths`,then normalizes the resulting path.
+ * @param paths to be joined and normalized
+ */
+export declare function posixJoin(...paths: string[]): string;
+/**
+ * Join all given a sequence of `paths`,then normalizes the resulting path.
+ * @param paths to be joined and normalized
+ */
+export declare function windowsJoin(...paths: string[]): string;