ventojs 0.9.0 → 0.9.2

package/esm/src/tokenizer.js

@@ -2,84 +2,95 @@ export default function tokenize(source) {
     const tokens = [];
     let type = "string";
     let trimNext = false;
-    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()]);
-                trimNext = false;
-            }
-            else {
-                tokens.push([type, code]);
-            }
-            if (index === -1) {
-                break;
+    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]);
+                }
+                if (index === -1) {
+                    break;
+                }
+                position += index;
+                source = source.slice(index);
+                type = source.startsWith("{{#") ? "comment" : "tag";
+                continue;
             }
-            source = source.slice(index);
-            type = source.startsWith("{{#") ? "comment" : "tag";
-            continue;
-        }
-        if (type === "comment") {
-            source = source.slice(3);
-            const index = source.indexOf("#}}");
-            const comment = index === -1 ? source : source.slice(0, index);
-            tokens.push([type, comment]);
-            if (index === -1) {
-                break;
+            if (type === "comment") {
+                source = source.slice(3);
+                const index = source.indexOf("#}}");
+                const comment = index === -1 ? source : source.slice(0, index);
+                tokens.push([type, comment, position]);
+                if (index === -1) {
+                    break;
+                }
+                position += index + 3;
+                source = source.slice(index + 3);
+                type = "string";
+                continue;
             }
-            source = source.slice(index + 3);
-            type = "string";
-            continue;
-        }
-        if (type === "tag") {
-            const indexes = parseTag(source);
-            const lastIndex = indexes.length - 1;
-            let tag;
-            indexes.reduce((prev, curr, index) => {
-                let 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();
+            if (type === "tag") {
+                const indexes = parseTag(source);
+                const lastIndex = indexes.length - 1;
+                let tag;
+                indexes.reduce((prev, curr, index) => {
+                    let 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];
+                        tokens.push(tag);
+                        return curr;
                     }
                     // Right trim
-                    if (code.endsWith("-") && index === lastIndex) {
+                    if (index === lastIndex && code.endsWith("-")) {
                         code = code.slice(0, -1);
                         trimNext = true;
                     }
-                    tag = [type, code.trim()];
-                    tokens.push(tag);
+                    // Filters
+                    tokens.push(["filter", code.trim()]);
                     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 (!end) {
+                        throw new Error("Unclosed echo tag");
+                    }
+                    const rawCode = source.slice(0, end.index);
+                    tag[1] = `echo ${JSON.stringify(rawCode)}`;
+                    const length = Number(end.index) + end[0].length;
+                    source = source.slice(length);
+                    position += length;
                 }
-                // Right trim
-                if (index === lastIndex && code.endsWith("-")) {
-                    code = code.slice(0, -1);
-                    trimNext = true;
-                }
-                // Filters
-                tokens.push(["filter", code.trim()]);
-                return curr;
-            });
-            source = source.slice(indexes[indexes.length - 1]);
-            type = "string";
-            // Search the closing echo tag {{ /echo }}
-            if (tag?.[1] === "echo") {
-                const end = source.match(/{{\s*\/echo\s*}}/);
-                if (!end) {
-                    throw new Error("Unclosed echo tag");
-                }
-                const rawCode = source.slice(0, end.index);
-                tag[1] = `echo ${JSON.stringify(rawCode)}`;
-                source = source.slice(Number(end.index) + end[0].length);
+                continue;
             }
-            continue;
         }
     }
-    return tokens;
+    catch (error) {
+        return { tokens, position, error };
+    }
+    return { tokens, position, error: undefined };
 }
 /**
  * Parse a tag and return the indexes of the start and end brackets, and the filters between.

package/package.json

@@ -2,7 +2,7 @@
   "module": "./esm/mod.js",
   "main": "./script/mod.js",
   "name": "ventojs",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "🌬 A minimal but powerful template engine",
   "license": "MIT",
   "repository": "github:oscarotero/vento",

package/script/deps/deno.land/std@0.208.0/path/_common/assert_path.d.ts

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

package/script/deps/deno.land/std@0.208.0/path/_common/assert_path.js

@@ -0,0 +1,11 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright the Browserify authors. MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertPath = void 0;
+function assertPath(path) {
+    if (typeof path !== "string") {
+        throw new TypeError(`Path must be a string. Received ${JSON.stringify(path)}`);
+    }
+}
+exports.assertPath = assertPath;

package/script/deps/deno.land/std@0.208.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/script/deps/deno.land/std@0.208.0/path/_common/basename.js

@@ -0,0 +1,46 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertArgs = exports.lastPathSegment = exports.stripSuffix = void 0;
+const assert_path_js_1 = require("./assert_path.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);
+}
+exports.stripSuffix = stripSuffix;
+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);
+}
+exports.lastPathSegment = lastPathSegment;
+function assertArgs(path, suffix) {
+    (0, assert_path_js_1.assertPath)(path);
+    if (path.length === 0)
+        return path;
+    if (typeof suffix !== "string") {
+        throw new TypeError(`Suffix must be a string. Received ${JSON.stringify(suffix)}`);
+    }
+}
+exports.assertArgs = assertArgs;

package/script/deps/deno.land/std@0.208.0/path/_common/common.d.ts

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

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

@@ -2,21 +2,8 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.common = void 0;
-const separator_js_1 = require("./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/"
- * ```
- */
-function common(paths, sep = separator_js_1.SEP) {
+exports._common = void 0;
+function _common(paths, sep) {
     const [first = "", ...remaining] = paths;
     if (first === "" || remaining.length === 0) {
         return first.substring(0, first.lastIndexOf(sep) + 1);
@@ -37,4 +24,4 @@ function common(paths, sep = separator_js_1.SEP) {
     const prefix = parts.slice(0, endOfPrefix).join(sep);
     return prefix.endsWith(sep) ? prefix : `${prefix}${sep}`;
 }
-exports.common = common;
+exports._common = _common;

package/script/deps/deno.land/std@0.208.0/path/_common/dirname.d.ts

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

package/script/deps/deno.land/std@0.208.0/path/_common/dirname.js

@@ -0,0 +1,12 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertArg = void 0;
+const assert_path_js_1 = require("./assert_path.js");
+function assertArg(path) {
+    (0, assert_path_js_1.assertPath)(path);
+    if (path.length === 0)
+        return ".";
+}
+exports.assertArg = assertArg;

package/script/deps/deno.land/std@0.208.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.201.0/path/_format.js → script/deps/deno.land/std@0.208.0/path/_common/format.js}

@@ -1,5 +1,8 @@
+"use strict";
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertArg = exports._format = void 0;
 function _format(sep, pathObject) {
     const dir = pathObject.dir || pathObject.root;
     const base = pathObject.base ||
@@ -12,24 +15,10 @@ function _format(sep, pathObject) {
         return dir + base;
     return dir + sep + base;
 }
+exports._format = _format;
 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);
-}
+exports.assertArg = assertArg;

package/script/deps/deno.land/std@0.208.0/path/_common/from_file_url.d.ts

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

package/script/deps/deno.land/std@0.208.0/path/_common/from_file_url.js

@@ -0,0 +1,13 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertArg = void 0;
+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;
+}
+exports.assertArg = assertArg;

package/script/deps/deno.land/std@0.208.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/script/deps/deno.land/{std@0.201.0/path/glob.js → std@0.208.0/path/_common/glob_to_reg_exp.js}

@@ -1,37 +1,8 @@
 "use strict";
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.joinGlobs = exports.normalizeGlob = exports.isGlob = exports.globToRegExp = void 0;
-const _os_js_1 = require("./_os.js");
-const separator_js_1 = require("./separator.js");
-const _win32 = __importStar(require("./win32.js"));
-const _posix = __importStar(require("./posix.js"));
-const path = _os_js_1.isWindows ? _win32 : _posix;
-const { join, normalize } = path;
+exports._globToRegExp = void 0;
 const regExpEscapeChars = [
     "!",
     "$",
@@ -49,76 +20,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. */
-function globToRegExp(glob, { extended = true, globstar: globstarOption = true, os = _os_js_1.osType, caseInsensitive = false, } = {}) {
+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 = "";
@@ -131,14 +41,14 @@ function globToRegExp(glob, { extended = true, globstar: globstarOption = true,
         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;
             }
@@ -217,7 +127,7 @@ function globToRegExp(glob, { extended = true, globstar: globstarOption = true,
                 segment += ")";
                 const type = groupStack.pop();
                 if (type === "!") {
-                    segment += wildcard;
+                    segment += c.wildcard;
                 }
                 else if (type !== "@") {
                     segment += type;
@@ -287,13 +197,13 @@ function globToRegExp(glob, { extended = true, globstar: globstarOption = true,
                     }
                     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;
@@ -311,11 +221,11 @@ function globToRegExp(glob, { extended = true, globstar: globstarOption = true,
         }
         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)) {
@@ -326,66 +236,4 @@ function globToRegExp(glob, { extended = true, globstar: globstarOption = true,
     regExpString = `^${regExpString}$`;
     return new RegExp(regExpString, caseInsensitive ? "i" : "");
 }
-exports.globToRegExp = globToRegExp;
-/** Test whether the given string is a glob */
-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;
-}
-exports.isGlob = isGlob;
-/** Like normalize(), but doesn't collapse "**\/.." when `globstar` is true. */
-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 = separator_js_1.SEP_PATTERN.source;
-    const badParentPattern = new RegExp(`(?<=(${s}|^)\\*\\*${s})\\.\\.(?=${s}|$)`, "g");
-    return normalize(glob.replace(badParentPattern, "\0")).replace(/\0/g, "..");
-}
-exports.normalizeGlob = normalizeGlob;
-/** Like join(), but doesn't collapse "**\/.." when `globstar` is true. */
-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 += `${separator_js_1.SEP}${path}`;
-        }
-    }
-    if (!joined)
-        return ".";
-    return normalizeGlob(joined, { extended, globstar });
-}
-exports.joinGlobs = joinGlobs;
+exports._globToRegExp = _globToRegExp;

package/script/deps/deno.land/std@0.208.0/path/_common/normalize.d.ts

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

package/script/deps/deno.land/std@0.208.0/path/_common/normalize.js

@@ -0,0 +1,12 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertArg = void 0;
+const assert_path_js_1 = require("./assert_path.js");
+function assertArg(path) {
+    (0, assert_path_js_1.assertPath)(path);
+    if (path.length === 0)
+        return ".";
+}
+exports.assertArg = assertArg;

package/script/deps/deno.land/std@0.208.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;