ventojs 0.8.1 → 0.9.1

package/README.md

@@ -1,7 +1,7 @@
-# VENTO
+# Vento
 
 This is a minimal template engine inspired by other great engines like Nunjucks,
-Liquid, Mustache or EJS.
+Liquid, Mustache, and EJS.
 
 ## Why another template engine?
 
@@ -32,6 +32,7 @@ neither is). The issues I found in existing template engines:
 ### Liquid
 
 - I like:
+
   - The support for async evaluation is less hacky than Nunjucks.
   - The variables are not escaped by default, there's an `escape` filter for
     that.
@@ -91,66 +92,9 @@ 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.~~
-[There's already an NPM version](https://www.npmjs.com/package/ventojs) that you
-can install with `npm install ventojs`.
-
-Import the library and create an instance:
-
-```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
-  includes: "./path/to/includes",
-});
-```
-
-There are different ways to load, compile and run a template. For example, you
-can use `load` to load and compile a template file and return it.
-
-```ts
-// Load and return a template
-const template = await vto.load("my-template.vto");
-
-// Now you can use it passing the data
-const result = await template({ title: "Hello world" });
-console.log(result.content);
-```
-
-Alternatively, you can load and run the template file in a single call:
-
-```ts
-const result = await 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
-const result = await vto.runString("<h1>{{ title }}</h1>", {
-  title: "Hello world",
-});
-console.log(result.content);
-```
-
-## Visual Studio Code Support
-
-[The Vento extension for VS Code](https://marketplace.visualstudio.com/items?itemName=oscarotero.vento-syntax)
-enables syntax highlight and provides some useful snippets.
+See [Getting started](https://vento.js.org/getting-started/) on the docs.
 
-## API
+## Editor support
 
-[Read the docs](https://oscarotero.github.io/vento/)
+See [Editor integrations](https://vento.js.org/editor-integrations/) on the
+docs.

package/esm/deps/deno.land/std@0.205.0/html/entities.d.ts

@@ -0,0 +1,38 @@
+export type EntityList = Record<string, string>;
+/**
+ * Escapes text for safe interpolation into HTML text content and quoted attributes
+ *
+ * @example
+ * ```ts
+ * import { escape } from "https://deno.land/std@$STD_VERSION/html/entities.ts";
+ * import { assertEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_equals.ts";
+ *
+ * assertEquals(escape("<>'&AA"), "&lt;&gt;&#39;&amp;AA");
+ *
+ * // characters that don't need to be escaped will be left alone,
+ * // even if named HTML entities exist for them
+ * assertEquals(escape("þð"), "þð");
+ * ```
+ */
+export declare function escape(str: string): string;
+export type UnescapeOptions = {
+    entityList: EntityList;
+};
+/**
+ * Unescapes HTML entities in text
+ *
+ * @example
+ * ```ts
+ * import { unescape } from "https://deno.land/std@$STD_VERSION/html/entities.ts";
+ * import { assertEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_equals.ts";
+ *
+ * // default options (only handles &<>'" and numeric entities)
+ * assertEquals(unescape("&lt;&gt;&apos;&amp;&#65;&#x41;"), "<>'&AA");
+ * assertEquals(unescape("&thorn;&eth;"), "&thorn;&eth;");
+ *
+ * // using the full named entity list from the HTML spec (~47K unminified)
+ * import entityList from "https://deno.land/std@$STD_VERSION/html/named_entity_list.json" assert { type: "json" };
+ * assertEquals(unescape("&thorn;&eth;", { entityList }), "þð");
+ * ```
+ */
+export declare function unescape(str: string, options?: Partial<UnescapeOptions>): string;

package/esm/deps/deno.land/std@0.205.0/html/entities.js

@@ -0,0 +1,76 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const rawToEntityEntries = [
+    ["&", "&"],
+    ["<", "&lt;"],
+    [">", "&gt;"],
+    ['"', "&quot;"],
+    ["'", "&#39;"],
+];
+const defaultEntityList = Object.fromEntries([
+    ...rawToEntityEntries.map(([raw, entity]) => [entity, raw]),
+    ["&apos;", "'"],
+    ["&nbsp;", "\xa0"],
+]);
+const rawToEntity = new Map(rawToEntityEntries);
+const rawRe = new RegExp(`[${[...rawToEntity.keys()].join("")}]`, "g");
+/**
+ * Escapes text for safe interpolation into HTML text content and quoted attributes
+ *
+ * @example
+ * ```ts
+ * import { escape } from "https://deno.land/std@$STD_VERSION/html/entities.ts";
+ * import { assertEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_equals.ts";
+ *
+ * assertEquals(escape("<>'&AA"), "&lt;&gt;&#39;&amp;AA");
+ *
+ * // characters that don't need to be escaped will be left alone,
+ * // even if named HTML entities exist for them
+ * assertEquals(escape("þð"), "þð");
+ * ```
+ */
+export function escape(str) {
+    return str.replaceAll(rawRe, (m) => rawToEntity.get(m));
+}
+const defaultUnescapeOptions = {
+    entityList: defaultEntityList,
+};
+const MAX_CODE_POINT = 0x10ffff;
+const RX_DEC_ENTITY = /&#([0-9]+);/g;
+const RX_HEX_ENTITY = /&#x(\p{AHex}+);/gu;
+const entityListRegexCache = new WeakMap();
+/**
+ * Unescapes HTML entities in text
+ *
+ * @example
+ * ```ts
+ * import { unescape } from "https://deno.land/std@$STD_VERSION/html/entities.ts";
+ * import { assertEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_equals.ts";
+ *
+ * // default options (only handles &<>'" and numeric entities)
+ * assertEquals(unescape("&lt;&gt;&apos;&amp;&#65;&#x41;"), "<>'&AA");
+ * assertEquals(unescape("&thorn;&eth;"), "&thorn;&eth;");
+ *
+ * // using the full named entity list from the HTML spec (~47K unminified)
+ * import entityList from "https://deno.land/std@$STD_VERSION/html/named_entity_list.json" assert { type: "json" };
+ * assertEquals(unescape("&thorn;&eth;", { entityList }), "þð");
+ * ```
+ */
+export function unescape(str, options = {}) {
+    const { entityList } = { ...defaultUnescapeOptions, ...options };
+    let entityRe = entityListRegexCache.get(entityList);
+    if (!entityRe) {
+        entityRe = new RegExp(`(${Object.keys(entityList)
+            .sort((a, b) => b.length - a.length)
+            .join("|")})`, "g");
+        entityListRegexCache.set(entityList, entityRe);
+    }
+    return str
+        .replaceAll(entityRe, (m) => entityList[m])
+        .replaceAll(RX_DEC_ENTITY, (_, dec) => codePointStrToChar(dec, 10))
+        .replaceAll(RX_HEX_ENTITY, (_, hex) => codePointStrToChar(hex, 16));
+}
+function codePointStrToChar(codePointStr, radix) {
+    const codePoint = parseInt(codePointStr, radix);
+    return codePoint > MAX_CODE_POINT ? "�" : String.fromCodePoint(codePoint);
+}

package/esm/deps/deno.land/std@0.205.0/html/mod.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Functions for HTML tasks such as escaping or unescaping HTML entities
+ *
+ * @module
+ */
+export * from "./entities.js";

package/esm/deps/deno.land/std@0.205.0/html/mod.js

@@ -0,0 +1,8 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * Functions for HTML tasks such as escaping or unescaping HTML entities
+ *
+ * @module
+ */
+export * from "./entities.js";

package/esm/deps/deno.land/std@0.205.0/path/_common/assert_path.d.ts

@@ -0,0 +1 @@
+export declare function assertPath(path: string): void;

package/esm/deps/deno.land/std@0.205.0/path/_common/assert_path.js

@@ -0,0 +1,7 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright the Browserify authors. MIT License.
+export function assertPath(path) {
+    if (typeof path !== "string") {
+        throw new TypeError(`Path must be a string. Received ${JSON.stringify(path)}`);
+    }
+}

package/esm/deps/deno.land/std@0.205.0/path/_common/basename.d.ts

@@ -0,0 +1,3 @@
+export declare function stripSuffix(name: string, suffix: string): string;
+export declare function lastPathSegment(path: string, isSep: (char: number) => boolean, start?: number): string;
+export declare function assertArgs(path: string, suffix: string): string | undefined;

package/esm/deps/deno.land/std@0.205.0/path/_common/basename.js

@@ -0,0 +1,40 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { assertPath } from "./assert_path.js";
+export 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);
+}
+export 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);
+}
+export 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)}`);
+    }
+}

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

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

package/esm/deps/deno.land/{std@0.201.0/path → std@0.205.0/path/_common}/common.js

@@ -1,19 +1,6 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
-import { SEP } from "./separator.js";
-/** 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 function common(paths, sep = SEP) {
+export function _common(paths, sep) {
     const [first = "", ...remaining] = paths;
     if (first === "" || remaining.length === 0) {
         return first.substring(0, first.lastIndexOf(sep) + 1);

package/esm/deps/deno.land/std@0.205.0/path/_common/dirname.d.ts

@@ -0,0 +1 @@
+export declare function assertArg(path: string): "." | undefined;

package/esm/deps/deno.land/std@0.205.0/path/_common/dirname.js

@@ -0,0 +1,8 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { assertPath } from "./assert_path.js";
+export function assertArg(path) {
+    assertPath(path);
+    if (path.length === 0)
+        return ".";
+}

package/esm/deps/deno.land/std@0.205.0/path/_common/format.d.ts

@@ -0,0 +1,3 @@
+import type { FormatInputPathObject } from "../_interface.js";
+export declare function _format(sep: string, pathObject: FormatInputPathObject): string;
+export declare function assertArg(pathObject: FormatInputPathObject): void;

package/esm/deps/deno.land/std@0.205.0/path/_common/format.js

@@ -0,0 +1,19 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+export 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;
+}
+export function assertArg(pathObject) {
+    if (pathObject === null || typeof pathObject !== "object") {
+        throw new TypeError(`The "pathObject" argument must be of type Object. Received type ${typeof pathObject}`);
+    }
+}

package/esm/deps/deno.land/std@0.205.0/path/_common/from_file_url.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare function assertArg(url: URL | string): URL;

package/esm/deps/deno.land/std@0.205.0/path/_common/from_file_url.js

@@ -0,0 +1,9 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+export 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;
+}

package/esm/deps/deno.land/std@0.205.0/path/_common/glob_to_reg_exp.d.ts

@@ -0,0 +1,27 @@
+export interface GlobOptions {
+    /** Extended glob syntax.
+     * See https://www.linuxjournal.com/content/bash-extended-globbing.
+     *
+     * @default {true}
+     */
+    extended?: boolean;
+    /** Globstar syntax.
+     * See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.
+     * If false, `**` is treated like `*`.
+     *
+     * @default {true}
+     */
+    globstar?: boolean;
+    /** Whether globstar should be case-insensitive. */
+    caseInsensitive?: boolean;
+}
+export type GlobToRegExpOptions = GlobOptions;
+export interface GlobConstants {
+    sep: string;
+    sepMaybe: string;
+    seps: string[];
+    globstar: string;
+    wildcard: string;
+    escapePrefix: string;
+}
+export declare function _globToRegExp(c: GlobConstants, glob: string, { extended, globstar: globstarOption, caseInsensitive, }?: GlobToRegExpOptions): RegExp;

package/esm/deps/deno.land/{std@0.201.0/path/glob.js → std@0.205.0/path/_common/glob_to_reg_exp.js}

@@ -1,11 +1,5 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
-import { isWindows, osType } from "./_os.js";
-import { SEP, SEP_PATTERN } from "./separator.js";
-import * as _win32 from "./win32.js";
-import * as _posix from "./posix.js";
-const path = isWindows ? _win32 : _posix;
-const { join, normalize } = path;
 const regExpEscapeChars = [
     "!",
     "$",
@@ -23,76 +17,15 @@ const regExpEscapeChars = [
     "|",
 ];
 const rangeEscapeChars = ["-", "\\", "]"];
-/** Convert a glob string to a regular expression.
- *
- * Tries to match bash glob expansion as closely as possible.
- *
- * Basic glob syntax:
- * - `*` - Matches everything without leaving the path segment.
- * - `?` - Matches any single character.
- * - `{foo,bar}` - Matches `foo` or `bar`.
- * - `[abcd]` - Matches `a`, `b`, `c` or `d`.
- * - `[a-d]` - Matches `a`, `b`, `c` or `d`.
- * - `[!abcd]` - Matches any single character besides `a`, `b`, `c` or `d`.
- * - `[[:<class>:]]` - Matches any character belonging to `<class>`.
- *     - `[[:alnum:]]` - Matches any digit or letter.
- *     - `[[:digit:]abc]` - Matches any digit, `a`, `b` or `c`.
- *     - See https://facelessuser.github.io/wcmatch/glob/#posix-character-classes
- *       for a complete list of supported character classes.
- * - `\` - Escapes the next character for an `os` other than `"windows"`.
- * - \` - Escapes the next character for `os` set to `"windows"`.
- * - `/` - Path separator.
- * - `\` - Additional path separator only for `os` set to `"windows"`.
- *
- * Extended syntax:
- * - Requires `{ extended: true }`.
- * - `?(foo|bar)` - Matches 0 or 1 instance of `{foo,bar}`.
- * - `@(foo|bar)` - Matches 1 instance of `{foo,bar}`. They behave the same.
- * - `*(foo|bar)` - Matches _n_ instances of `{foo,bar}`.
- * - `+(foo|bar)` - Matches _n > 0_ instances of `{foo,bar}`.
- * - `!(foo|bar)` - Matches anything other than `{foo,bar}`.
- * - See https://www.linuxjournal.com/content/bash-extended-globbing.
- *
- * Globstar syntax:
- * - Requires `{ globstar: true }`.
- * - `**` - Matches any number of any path segments.
- *     - Must comprise its entire path segment in the provided glob.
- * - See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.
- *
- * Note the following properties:
- * - The generated `RegExp` is anchored at both start and end.
- * - Repeating and trailing separators are tolerated. Trailing separators in the
- *   provided glob have no meaning and are discarded.
- * - Absolute globs will only match absolute paths, etc.
- * - Empty globs will match nothing.
- * - Any special glob syntax must be contained to one path segment. For example,
- *   `?(foo|bar/baz)` is invalid. The separator will take precedence and the
- *   first segment ends with an unclosed group.
- * - If a path segment ends with unclosed groups or a dangling escape prefix, a
- *   parse error has occurred. Every character for that segment is taken
- *   literally in this event.
- *
- * Limitations:
- * - A negative group like `!(foo|bar)` will wrongly be converted to a negative
- *   look-ahead followed by a wildcard. This means that `!(foo).js` will wrongly
- *   fail to match `foobar.js`, even though `foobar` is not `foo`. Effectively,
- *   `!(foo|bar)` is treated like `!(@(foo|bar)*)`. This will work correctly if
- *   the group occurs not nested at the end of the segment. */
-export function globToRegExp(glob, { extended = true, globstar: globstarOption = true, os = osType, caseInsensitive = false, } = {}) {
+export function _globToRegExp(c, glob, { extended = true, globstar: globstarOption = true, 
+// os = osType,
+caseInsensitive = false, } = {}) {
     if (glob === "") {
         return /(?!)/;
     }
-    const sep = os === "windows" ? "(?:\\\\|/)+" : "/+";
-    const sepMaybe = os === "windows" ? "(?:\\\\|/)*" : "/*";
-    const seps = os === "windows" ? ["\\", "/"] : ["/"];
-    const globstar = os === "windows"
-        ? "(?:[^\\\\/]*(?:\\\\|/|$)+)*"
-        : "(?:[^/]*(?:/|$)+)*";
-    const wildcard = os === "windows" ? "[^\\\\/]*" : "[^/]*";
-    const escapePrefix = os === "windows" ? "`" : "\\";
     // Remove trailing separators.
     let newLength = glob.length;
-    for (; newLength > 1 && seps.includes(glob[newLength - 1]); newLength--)
+    for (; newLength > 1 && c.seps.includes(glob[newLength - 1]); newLength--)
         ;
     glob = glob.slice(0, newLength);
     let regExpString = "";
@@ -105,14 +38,14 @@ export function globToRegExp(glob, { extended = true, globstar: globstarOption =
         let endsWithSep = false;
         let i = j;
         // Terminates with `i` at the non-inclusive end of the current segment.
-        for (; i < glob.length && !seps.includes(glob[i]); i++) {
+        for (; i < glob.length && !c.seps.includes(glob[i]); i++) {
             if (inEscape) {
                 inEscape = false;
                 const escapeChars = inRange ? rangeEscapeChars : regExpEscapeChars;
                 segment += escapeChars.includes(glob[i]) ? `\\${glob[i]}` : glob[i];
                 continue;
             }
-            if (glob[i] === escapePrefix) {
+            if (glob[i] === c.escapePrefix) {
                 inEscape = true;
                 continue;
             }
@@ -191,7 +124,7 @@ export function globToRegExp(glob, { extended = true, globstar: globstarOption =
                 segment += ")";
                 const type = groupStack.pop();
                 if (type === "!") {
-                    segment += wildcard;
+                    segment += c.wildcard;
                 }
                 else if (type !== "@") {
                     segment += type;
@@ -261,13 +194,13 @@ export function globToRegExp(glob, { extended = true, globstar: globstarOption =
                     }
                     const nextChar = glob[i + 1];
                     if (globstarOption && numStars === 2 &&
-                        [...seps, undefined].includes(prevChar) &&
-                        [...seps, undefined].includes(nextChar)) {
-                        segment += globstar;
+                        [...c.seps, undefined].includes(prevChar) &&
+                        [...c.seps, undefined].includes(nextChar)) {
+                        segment += c.globstar;
                         endsWithSep = true;
                     }
                     else {
-                        segment += wildcard;
+                        segment += c.wildcard;
                     }
                 }
                 continue;
@@ -285,11 +218,11 @@ export function globToRegExp(glob, { extended = true, globstar: globstarOption =
         }
         regExpString += segment;
         if (!endsWithSep) {
-            regExpString += i < glob.length ? sep : sepMaybe;
+            regExpString += i < glob.length ? c.sep : c.sepMaybe;
             endsWithSep = true;
         }
         // Terminates with `i` at the start of the next segment.
-        while (seps.includes(glob[i]))
+        while (c.seps.includes(glob[i]))
             i++;
         // Check that the next value of `j` is indeed higher than the current value.
         if (!(i > j)) {
@@ -300,62 +233,3 @@ export function globToRegExp(glob, { extended = true, globstar: globstarOption =
     regExpString = `^${regExpString}$`;
     return new RegExp(regExpString, caseInsensitive ? "i" : "");
 }
-/** Test whether the given string is a glob */
-export function isGlob(str) {
-    const chars = { "{": "}", "(": ")", "[": "]" };
-    const regex = /\\(.)|(^!|\*|\?|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/;
-    if (str === "") {
-        return false;
-    }
-    let match;
-    while ((match = regex.exec(str))) {
-        if (match[2])
-            return true;
-        let idx = match.index + match[0].length;
-        // if an open bracket/brace/paren is escaped,
-        // set the index to the next closing character
-        const open = match[1];
-        const close = open ? chars[open] : null;
-        if (open && close) {
-            const n = str.indexOf(close, idx);
-            if (n !== -1) {
-                idx = n + 1;
-            }
-        }
-        str = str.slice(idx);
-    }
-    return false;
-}
-/** Like normalize(), but doesn't collapse "**\/.." when `globstar` is true. */
-export function normalizeGlob(glob, { globstar = false } = {}) {
-    if (glob.match(/\0/g)) {
-        throw new Error(`Glob contains invalid characters: "${glob}"`);
-    }
-    if (!globstar) {
-        return normalize(glob);
-    }
-    const s = SEP_PATTERN.source;
-    const badParentPattern = new RegExp(`(?<=(${s}|^)\\*\\*${s})\\.\\.(?=${s}|$)`, "g");
-    return normalize(glob.replace(badParentPattern, "\0")).replace(/\0/g, "..");
-}
-/** Like join(), but doesn't collapse "**\/.." when `globstar` is true. */
-export function joinGlobs(globs, { extended = true, globstar = false } = {}) {
-    if (!globstar || globs.length === 0) {
-        return join(...globs);
-    }
-    if (globs.length === 0)
-        return ".";
-    let joined;
-    for (const glob of globs) {
-        const path = glob;
-        if (path.length > 0) {
-            if (!joined)
-                joined = path;
-            else
-                joined += `${SEP}${path}`;
-        }
-    }
-    if (!joined)
-        return ".";
-    return normalizeGlob(joined, { extended, globstar });
-}

package/esm/deps/deno.land/std@0.205.0/path/_common/is_glob.d.ts

@@ -0,0 +1,2 @@
+/** Test whether the given string is a glob */
+export declare function isGlob(str: string): boolean;

package/esm/deps/deno.land/std@0.205.0/path/_common/is_glob.js

@@ -0,0 +1,28 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/** Test whether the given string is a glob */
+export function isGlob(str) {
+    const chars = { "{": "}", "(": ")", "[": "]" };
+    const regex = /\\(.)|(^!|\*|\?|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/;
+    if (str === "") {
+        return false;
+    }
+    let match;
+    while ((match = regex.exec(str))) {
+        if (match[2])
+            return true;
+        let idx = match.index + match[0].length;
+        // if an open bracket/brace/paren is escaped,
+        // set the index to the next closing character
+        const open = match[1];
+        const close = open ? chars[open] : null;
+        if (open && close) {
+            const n = str.indexOf(close, idx);
+            if (n !== -1) {
+                idx = n + 1;
+            }
+        }
+        str = str.slice(idx);
+    }
+    return false;
+}

package/esm/deps/deno.land/std@0.205.0/path/_common/normalize.d.ts

@@ -0,0 +1 @@
+export declare function assertArg(path: string): "." | undefined;

package/esm/deps/deno.land/std@0.205.0/path/_common/normalize.js

@@ -0,0 +1,8 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { assertPath } from "./assert_path.js";
+export function assertArg(path) {
+    assertPath(path);
+    if (path.length === 0)
+        return ".";
+}

package/esm/deps/deno.land/std@0.205.0/path/_common/normalize_string.d.ts

@@ -0,0 +1 @@
+export declare function normalizeString(path: string, allowAboveRoot: boolean, separator: string, isPathSeparator: (code: number) => boolean): string;