ventojs 0.9.0 → 0.9.2

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

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

package/esm/deps/deno.land/std@0.208.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.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/esm/deps/deno.land/std@0.208.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.208.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.208.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.208.0/path/_common/dirname.d.ts

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

package/esm/deps/deno.land/std@0.208.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.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.208.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.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/esm/deps/deno.land/std@0.208.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.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/esm/deps/deno.land/{std@0.201.0/path/glob.js → std@0.208.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.208.0/path/_common/normalize.d.ts

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

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

package/esm/deps/deno.land/{std@0.201.0/path/_util.js → std@0.208.0/path/_common/normalize_string.js}

@@ -2,22 +2,7 @@
 // Copyright the Browserify authors. MIT License.
 // Ported from https://github.com/browserify/path-browserify/
 // This module is browser compatible.
-import { CHAR_BACKWARD_SLASH, CHAR_DOT, CHAR_FORWARD_SLASH, CHAR_LOWERCASE_A, CHAR_LOWERCASE_Z, CHAR_UPPERCASE_A, CHAR_UPPERCASE_Z, } from "./_constants.js";
-export function assertPath(path) {
-    if (typeof path !== "string") {
-        throw new TypeError(`Path must be a string. Received ${JSON.stringify(path)}`);
-    }
-}
-export function isPosixPathSeparator(code) {
-    return code === CHAR_FORWARD_SLASH;
-}
-export function isPathSeparator(code) {
-    return isPosixPathSeparator(code) || code === CHAR_BACKWARD_SLASH;
-}
-export function isWindowsDeviceRoot(code) {
-    return ((code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z) ||
-        (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z));
-}
+import { CHAR_DOT, CHAR_FORWARD_SLASH } from "./constants.js";
 // Resolves . and .. elements in a path with directory names
 export function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
     let res = "";
@@ -90,18 +75,3 @@ export function normalizeString(path, allowAboveRoot, separator, isPathSeparator
     }
     return res;
 }
-export function stripTrailingSeparators(segment, isSep) {
-    if (segment.length <= 1) {
-        return segment;
-    }
-    let end = segment.length;
-    for (let i = segment.length - 1; i > 0; i--) {
-        if (isSep(segment.charCodeAt(i))) {
-            end = i;
-        }
-        else {
-            break;
-        }
-    }
-    return segment.slice(0, end);
-}

package/esm/deps/deno.land/std@0.208.0/path/_common/relative.d.ts

@@ -0,0 +1 @@
+export declare function assertArgs(from: string, to: string): "" | undefined;

package/esm/deps/deno.land/std@0.208.0/path/_common/relative.js

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

package/esm/deps/deno.land/std@0.208.0/path/_common/strip_trailing_separators.d.ts

@@ -0,0 +1 @@
+export declare function stripTrailingSeparators(segment: string, isSep: (char: number) => boolean): string;

package/esm/deps/deno.land/std@0.208.0/path/_common/strip_trailing_separators.js

@@ -0,0 +1,19 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright the Browserify authors. MIT License.
+// Ported from https://github.com/browserify/path-browserify/
+// This module is browser compatible.
+export function stripTrailingSeparators(segment, isSep) {
+    if (segment.length <= 1) {
+        return segment;
+    }
+    let end = segment.length;
+    for (let i = segment.length - 1; i > 0; i--) {
+        if (isSep(segment.charCodeAt(i))) {
+            end = i;
+        }
+        else {
+            break;
+        }
+    }
+    return segment.slice(0, end);
+}

package/esm/deps/deno.land/std@0.208.0/path/_common/to_file_url.d.ts

@@ -0,0 +1 @@
+export declare function encodeWhitespace(string: string): string;

package/esm/deps/deno.land/std@0.208.0/path/_common/to_file_url.js

@@ -0,0 +1,15 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const WHITESPACE_ENCODINGS = {
+    "\u0009": "%09",
+    "\u000A": "%0A",
+    "\u000B": "%0B",
+    "\u000C": "%0C",
+    "\u000D": "%0D",
+    "\u0020": "%20",
+};
+export function encodeWhitespace(string) {
+    return string.replaceAll(/[\s]/g, (c) => {
+        return WHITESPACE_ENCODINGS[c] ?? c;
+    });
+}

package/esm/deps/deno.land/std@0.208.0/path/_os.d.ts

@@ -0,0 +1,3 @@
+export type OSType = "darwin" | "linux" | "windows" | "freebsd" | "netbsd" | "aix" | "solaris" | "illumos";
+export declare const osType: OSType;
+export declare const isWindows: boolean;

package/esm/deps/deno.land/{std@0.201.0 → std@0.208.0}/path/_os.js

@@ -1,5 +1,6 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
+// Keep this up-to-date with Deno.build.os
 import * as dntShim from "../../../../_dnt.shims.js";
 export const osType = (() => {
     // deno-lint-ignore no-explicit-any
@@ -15,4 +16,3 @@ export const osType = (() => {
     return "linux";
 })();
 export const isWindows = osType === "windows";
-export const isLinux = osType === "linux";

package/esm/deps/deno.land/{std@0.201.0 → std@0.208.0}/path/basename.js

@@ -1,7 +1,8 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 import { isWindows } from "./_os.js";
-import { posixBasename, windowsBasename } from "./_basename.js";
+import { basename as posixBasename } from "./posix/basename.js";
+import { basename as windowsBasename } from "./windows/basename.js";
 /**
  * Return the last portion of a `path`.
  * Trailing directory separators are ignored, and optional suffix is removed.

package/esm/deps/deno.land/std@0.208.0/path/common.js

@@ -0,0 +1,19 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { _common } from "./_common/common.js";
+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) {
+    return _common(paths, sep);
+}

package/esm/deps/deno.land/{std@0.201.0 → std@0.208.0}/path/dirname.js

@@ -1,7 +1,8 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 import { isWindows } from "./_os.js";
-import { posixDirname, windowsDirname } from "./_dirname.js";
+import { dirname as posixDirname } from "./posix/dirname.js";
+import { dirname as windowsDirname } from "./windows/dirname.js";
 /**
  * Return the directory path of a `path`.
  * @param path - path to extract the directory from.

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

@@ -1,7 +1,8 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 import { isWindows } from "./_os.js";
-import { posixExtname, windowsExtname } from "./_extname.js";
+import { extname as posixExtname } from "./posix/extname.js";
+import { extname as windowsExtname } from "./posix/extname.js";
 /**
  * Return the extension of the `path` with leading period.
  * @param path with extension

package/esm/deps/deno.land/{std@0.201.0 → std@0.208.0}/path/format.js

@@ -1,7 +1,8 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 import { isWindows } from "./_os.js";
-import { posixFormat, windowsFormat } from "./_format.js";
+import { format as posixFormat } from "./posix/format.js";
+import { format as windowsFormat } from "./windows/format.js";
 /**
  * Generate a path from `FormatInputPathObject` object.
  * @param pathObject with path

package/esm/deps/deno.land/{std@0.201.0 → std@0.208.0}/path/from_file_url.js

@@ -1,7 +1,8 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 import { isWindows } from "./_os.js";
-import { posixFromFileUrl, windowsFromFileUrl } from "./_from_file_url.js";
+import { fromFileUrl as posixFromFileUrl } from "./posix/from_file_url.js";
+import { fromFileUrl as windowsFromFileUrl } from "./windows/from_file_url.js";
 /**
  * Converts a file URL to a path string.
  *

package/esm/deps/deno.land/{std@0.201.0/path/glob.d.ts → std@0.208.0/path/glob_to_regexp.d.ts}

@@ -1,24 +1,8 @@
-import { type OSType } from "./_os.js";
-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;
-    /** Operating system. Defaults to the native OS. */
+import type { GlobOptions } from "./_common/glob_to_reg_exp.js";
+import { OSType } from "./_os.js";
+export type GlobToRegExpOptions = GlobOptions & {
     os?: OSType;
-}
-export type GlobToRegExpOptions = GlobOptions;
+};
 /** Convert a glob string to a regular expression.
  *
  * Tries to match bash glob expansion as closely as possible.
@@ -74,10 +58,4 @@ export type GlobToRegExpOptions = GlobOptions;
  *   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 declare function globToRegExp(glob: string, { extended, globstar: globstarOption, os, caseInsensitive, }?: GlobToRegExpOptions): RegExp;
-/** Test whether the given string is a glob */
-export declare function isGlob(str: string): boolean;
-/** Like normalize(), but doesn't collapse "**\/.." when `globstar` is true. */
-export declare function normalizeGlob(glob: string, { globstar }?: GlobOptions): string;
-/** Like join(), but doesn't collapse "**\/.." when `globstar` is true. */
-export declare function joinGlobs(globs: string[], { extended, globstar }?: GlobOptions): string;
+export declare function globToRegExp(glob: string, options?: GlobToRegExpOptions): RegExp;