keep-a-changelog 2.2.1 → 2.4.1

package/script/deps/deno.land/{std@0.173.0 → std@0.189.0}/path/_util.js

@@ -4,7 +4,7 @@
 // Ported from https://github.com/browserify/path-browserify/
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeWhitespace = exports._format = exports.normalizeString = exports.isWindowsDeviceRoot = exports.isPathSeparator = exports.isPosixPathSeparator = exports.assertPath = void 0;
+exports.stripSuffix = exports.stripTrailingSeparators = exports.lastPathSegment = exports.encodeWhitespace = exports._format = exports.normalizeString = exports.isWindowsDeviceRoot = exports.isPathSeparator = exports.isPosixPathSeparator = exports.assertPath = void 0;
 const _constants_js_1 = require("./_constants.js");
 function assertPath(path) {
     if (typeof path !== "string") {
@@ -104,6 +104,8 @@ function _format(sep, pathObject) {
         (pathObject.name || "") + (pathObject.ext || "");
     if (!dir)
         return base;
+    if (base === sep)
+        return dir;
     if (dir === pathObject.root)
         return dir + base;
     return dir + sep + base;
@@ -123,3 +125,50 @@ function encodeWhitespace(string) {
     });
 }
 exports.encodeWhitespace = encodeWhitespace;
+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 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);
+}
+exports.stripTrailingSeparators = stripTrailingSeparators;
+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;

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

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

package/script/deps/deno.land/std@0.189.0/path/glob.d.ts

@@ -0,0 +1,83 @@
+import type { OSType } from "../_util/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. */
+    os?: OSType;
+}
+export type GlobToRegExpOptions = GlobOptions;
+/** 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 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;

package/script/deps/deno.land/std@0.189.0/path/mod.d.ts

@@ -0,0 +1,11 @@
+import * as _win32 from "./win32.js";
+import * as _posix from "./posix.js";
+export declare const win32: typeof _win32;
+export declare const posix: typeof _posix;
+export declare const basename: typeof _posix.basename | typeof _win32.basename, delimiter: string, dirname: typeof _posix.dirname | typeof _win32.dirname, extname: typeof _posix.extname | typeof _win32.extname, format: typeof _posix.format | typeof _win32.format, fromFileUrl: typeof _posix.fromFileUrl | typeof _win32.fromFileUrl, isAbsolute: typeof _win32.isAbsolute | typeof _posix.isAbsolute, join: typeof _posix.join | typeof _win32.join, normalize: typeof _win32.normalize | typeof _posix.normalize, parse: typeof _posix.parse | typeof _win32.parse, relative: typeof _posix.relative | typeof _win32.relative, resolve: typeof _win32.resolve | typeof _posix.resolve, toFileUrl: typeof _posix.toFileUrl | typeof _win32.toFileUrl, toNamespacedPath: typeof _posix.toNamespacedPath | typeof _win32.toNamespacedPath;
+/** @deprecated (will be removed after 0.188.0) Use SEP intead. */
+export declare const sep: string;
+export * from "./common.js";
+export { SEP, SEP_PATTERN } from "./separator.js";
+export * from "./_interface.js";
+export * from "./glob.js";

package/script/deps/deno.land/{std@0.173.0 → std@0.189.0}/path/mod.js

@@ -2,6 +2,7 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // Copyright the Browserify authors. MIT License.
 // Ported mostly from https://github.com/browserify/path-browserify/
+// 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);
@@ -29,7 +30,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SEP_PATTERN = exports.SEP = exports.toNamespacedPath = exports.toFileUrl = exports.sep = exports.resolve = exports.relative = exports.parse = exports.normalize = exports.join = exports.isAbsolute = exports.fromFileUrl = exports.format = exports.extname = exports.dirname = exports.delimiter = exports.basename = exports.posix = exports.win32 = void 0;
+exports.SEP_PATTERN = exports.SEP = exports.sep = exports.toNamespacedPath = exports.toFileUrl = exports.resolve = exports.relative = exports.parse = exports.normalize = exports.join = exports.isAbsolute = exports.fromFileUrl = exports.format = exports.extname = exports.dirname = exports.delimiter = exports.basename = exports.posix = exports.win32 = void 0;
 /**
  * Utilities for working with OS-specific file paths.
  *
@@ -54,7 +55,9 @@ const _posix = __importStar(require("./posix.js"));
 const path = os_js_1.isWindows ? _win32 : _posix;
 exports.win32 = _win32;
 exports.posix = _posix;
-exports.basename = path.basename, exports.delimiter = path.delimiter, exports.dirname = path.dirname, exports.extname = path.extname, exports.format = path.format, exports.fromFileUrl = path.fromFileUrl, exports.isAbsolute = path.isAbsolute, exports.join = path.join, exports.normalize = path.normalize, exports.parse = path.parse, exports.relative = path.relative, exports.resolve = path.resolve, exports.sep = path.sep, exports.toFileUrl = path.toFileUrl, exports.toNamespacedPath = path.toNamespacedPath;
+exports.basename = path.basename, exports.delimiter = path.delimiter, exports.dirname = path.dirname, exports.extname = path.extname, exports.format = path.format, exports.fromFileUrl = path.fromFileUrl, exports.isAbsolute = path.isAbsolute, exports.join = path.join, exports.normalize = path.normalize, exports.parse = path.parse, exports.relative = path.relative, exports.resolve = path.resolve, exports.toFileUrl = path.toFileUrl, exports.toNamespacedPath = path.toNamespacedPath;
+/** @deprecated (will be removed after 0.188.0) Use SEP intead. */
+exports.sep = path.sep;
 __exportStar(require("./common.js"), exports);
 var separator_js_1 = require("./separator.js");
 Object.defineProperty(exports, "SEP", { enumerable: true, get: function () { return separator_js_1.SEP; } });

package/script/deps/deno.land/std@0.189.0/path/posix.d.ts

@@ -0,0 +1,86 @@
+/// <reference types="node" />
+import type { FormatInputPathObject, ParsedPath } from "./_interface.js";
+export declare const sep = "/";
+export declare const delimiter = ":";
+/**
+ * Resolves `pathSegments` into an absolute path.
+ * @param pathSegments an array of path segments
+ */
+export declare function resolve(...pathSegments: string[]): string;
+/**
+ * Normalize the `path`, resolving `'..'` and `'.'` segments.
+ * Note that resolving these segments does not necessarily mean that all will be eliminated.
+ * A `'..'` at the top-level will be preserved, and an empty path is canonically `'.'`.
+ * @param path to be normalized
+ */
+export declare function normalize(path: string): string;
+/**
+ * Verifies whether provided path is absolute
+ * @param path to be verified as absolute
+ */
+export declare function isAbsolute(path: string): boolean;
+/**
+ * Join all given a sequence of `paths`,then normalizes the resulting path.
+ * @param paths to be joined and normalized
+ */
+export declare function join(...paths: string[]): string;
+/**
+ * Return the relative path from `from` to `to` based on current working directory.
+ * @param from path in current working directory
+ * @param to path in current working directory
+ */
+export declare function relative(from: string, to: string): string;
+/**
+ * Resolves path to a namespace path
+ * @param path to resolve to namespace
+ */
+export declare function toNamespacedPath(path: string): string;
+/**
+ * Return the directory path of a `path`.
+ * @param path - path to extract the directory from.
+ */
+export declare function dirname(path: 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 basename(path: string, suffix?: 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 extname(path: string): string;
+/**
+ * Generate a path from `FormatInputPathObject` object.
+ * @param pathObject with path
+ */
+export declare function format(pathObject: FormatInputPathObject): string;
+/**
+ * Return a `ParsedPath` object of the `path`.
+ * @param path to process
+ */
+export declare function parse(path: string): ParsedPath;
+/**
+ * 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 fromFileUrl(url: string | URL): string;
+/**
+ * Converts a path string to a file URL.
+ *
+ * ```ts
+ *      import { toFileUrl } from "https://deno.land/std@$STD_VERSION/path/posix.ts";
+ *      toFileUrl("/home/foo"); // new URL("file:///home/foo")
+ * ```
+ * @param path to convert to file URL
+ */
+export declare function toFileUrl(path: string): URL;

package/script/deps/deno.land/{std@0.173.0 → std@0.189.0}/path/posix.js

@@ -59,7 +59,7 @@ function resolve(...pathSegments) {
             continue;
         }
         resolvedPath = `${path}/${resolvedPath}`;
-        resolvedAbsolute = path.charCodeAt(0) === _constants_js_1.CHAR_FORWARD_SLASH;
+        resolvedAbsolute = (0, _util_js_1.isPosixPathSeparator)(path.charCodeAt(0));
     }
     // At this point the path should be resolved to a full absolute path, but
     // handle relative paths to be safe (might happen when process.cwd() fails)
@@ -87,8 +87,8 @@ function normalize(path) {
     (0, _util_js_1.assertPath)(path);
     if (path.length === 0)
         return ".";
-    const isAbsolute = path.charCodeAt(0) === _constants_js_1.CHAR_FORWARD_SLASH;
-    const trailingSeparator = path.charCodeAt(path.length - 1) === _constants_js_1.CHAR_FORWARD_SLASH;
+    const isAbsolute = (0, _util_js_1.isPosixPathSeparator)(path.charCodeAt(0));
+    const trailingSeparator = (0, _util_js_1.isPosixPathSeparator)(path.charCodeAt(path.length - 1));
     // Normalize the path
     path = (0, _util_js_1.normalizeString)(path, !isAbsolute, "/", _util_js_1.isPosixPathSeparator);
     if (path.length === 0 && !isAbsolute)
@@ -106,7 +106,7 @@ exports.normalize = normalize;
  */
 function isAbsolute(path) {
     (0, _util_js_1.assertPath)(path);
-    return path.length > 0 && path.charCodeAt(0) === _constants_js_1.CHAR_FORWARD_SLASH;
+    return path.length > 0 && (0, _util_js_1.isPosixPathSeparator)(path.charCodeAt(0));
 }
 exports.isAbsolute = isAbsolute;
 /**
@@ -150,7 +150,7 @@ function relative(from, to) {
     let fromStart = 1;
     const fromEnd = from.length;
     for (; fromStart < fromEnd; ++fromStart) {
-        if (from.charCodeAt(fromStart) !== _constants_js_1.CHAR_FORWARD_SLASH)
+        if (!(0, _util_js_1.isPosixPathSeparator)(from.charCodeAt(fromStart)))
             break;
     }
     const fromLen = fromEnd - fromStart;
@@ -158,7 +158,7 @@ function relative(from, to) {
     let toStart = 1;
     const toEnd = to.length;
     for (; toStart < toEnd; ++toStart) {
-        if (to.charCodeAt(toStart) !== _constants_js_1.CHAR_FORWARD_SLASH)
+        if (!(0, _util_js_1.isPosixPathSeparator)(to.charCodeAt(toStart)))
             break;
     }
     const toLen = toEnd - toStart;
@@ -169,7 +169,7 @@ function relative(from, to) {
     for (; i <= length; ++i) {
         if (i === length) {
             if (toLen > length) {
-                if (to.charCodeAt(toStart + i) === _constants_js_1.CHAR_FORWARD_SLASH) {
+                if ((0, _util_js_1.isPosixPathSeparator)(to.charCodeAt(toStart + i))) {
                     // We get here if `from` is the exact base path for `to`.
                     // For example: from='/foo/bar'; to='/foo/bar/baz'
                     return to.slice(toStart + i + 1);
@@ -181,7 +181,7 @@ function relative(from, to) {
                 }
             }
             else if (fromLen > length) {
-                if (from.charCodeAt(fromStart + i) === _constants_js_1.CHAR_FORWARD_SLASH) {
+                if ((0, _util_js_1.isPosixPathSeparator)(from.charCodeAt(fromStart + i))) {
                     // We get here if `to` is the exact base path for `from`.
                     // For example: from='/foo/bar/baz'; to='/foo/bar'
                     lastCommonSep = i;
@@ -198,14 +198,14 @@ function relative(from, to) {
         const toCode = to.charCodeAt(toStart + i);
         if (fromCode !== toCode)
             break;
-        else if (fromCode === _constants_js_1.CHAR_FORWARD_SLASH)
+        else if ((0, _util_js_1.isPosixPathSeparator)(fromCode))
             lastCommonSep = i;
     }
     let out = "";
     // Generate the relative path based on the path difference between `to`
     // and `from`
     for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
-        if (i === fromEnd || from.charCodeAt(i) === _constants_js_1.CHAR_FORWARD_SLASH) {
+        if (i === fromEnd || (0, _util_js_1.isPosixPathSeparator)(from.charCodeAt(i))) {
             if (out.length === 0)
                 out += "..";
             else
@@ -218,7 +218,7 @@ function relative(from, to) {
         return out + to.slice(toStart + lastCommonSep);
     else {
         toStart += lastCommonSep;
-        if (to.charCodeAt(toStart) === _constants_js_1.CHAR_FORWARD_SLASH)
+        if ((0, _util_js_1.isPosixPathSeparator)(to.charCodeAt(toStart)))
             ++toStart;
         return to.slice(toStart);
     }
@@ -235,115 +235,54 @@ function toNamespacedPath(path) {
 exports.toNamespacedPath = toNamespacedPath;
 /**
  * Return the directory path of a `path`.
- * @param path to determine the directory path for
+ * @param path - path to extract the directory from.
  */
 function dirname(path) {
-    (0, _util_js_1.assertPath)(path);
     if (path.length === 0)
         return ".";
-    const hasRoot = path.charCodeAt(0) === _constants_js_1.CHAR_FORWARD_SLASH;
     let end = -1;
-    let matchedSlash = true;
+    let matchedNonSeparator = false;
     for (let i = path.length - 1; i >= 1; --i) {
-        if (path.charCodeAt(i) === _constants_js_1.CHAR_FORWARD_SLASH) {
-            if (!matchedSlash) {
+        if ((0, _util_js_1.isPosixPathSeparator)(path.charCodeAt(i))) {
+            if (matchedNonSeparator) {
                 end = i;
                 break;
             }
         }
         else {
-            // We saw the first non-path separator
-            matchedSlash = false;
+            matchedNonSeparator = true;
         }
     }
-    if (end === -1)
-        return hasRoot ? "/" : ".";
-    if (hasRoot && end === 1)
-        return "//";
-    return path.slice(0, end);
+    // No matches. Fallback based on provided path:
+    //
+    // - leading slashes paths
+    //     "/foo" => "/"
+    //     "///foo" => "/"
+    // - no slash path
+    //     "foo" => "."
+    if (end === -1) {
+        return (0, _util_js_1.isPosixPathSeparator)(path.charCodeAt(0)) ? "/" : ".";
+    }
+    return (0, _util_js_1.stripTrailingSeparators)(path.slice(0, end), _util_js_1.isPosixPathSeparator);
 }
 exports.dirname = dirname;
 /**
- * Return the last portion of a `path`. Trailing directory separators are ignored.
- * @param path to process
- * @param ext of path directory
+ * 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.
  */
-function basename(path, ext = "") {
-    if (ext !== undefined && typeof ext !== "string") {
-        throw new TypeError('"ext" argument must be a string');
-    }
+function basename(path, suffix = "") {
     (0, _util_js_1.assertPath)(path);
-    let start = 0;
-    let end = -1;
-    let matchedSlash = true;
-    let i;
-    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
-        if (ext.length === path.length && ext === path)
-            return "";
-        let extIdx = ext.length - 1;
-        let firstNonSlashEnd = -1;
-        for (i = path.length - 1; i >= 0; --i) {
-            const code = path.charCodeAt(i);
-            if ((0, _util_js_1.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) {
-                    start = i + 1;
-                    break;
-                }
-            }
-            else {
-                if (firstNonSlashEnd === -1) {
-                    // We saw the first non-path separator, mark this as the end of our
-                    // path component in case we don't match a whole suffix
-                    matchedSlash = false;
-                    firstNonSlashEnd = i + 1;
-                    end = firstNonSlashEnd;
-                }
-                if (extIdx >= 0) {
-                    // Try to match the explicit suffix
-                    if (code === ext.charCodeAt(extIdx)) {
-                        if (--extIdx === -1) {
-                            // We matched whole suffix, so mark this as the end of our path
-                            // component
-                            end = i;
-                        }
-                    }
-                    else {
-                        // Suffix character does not match, so bail out early
-                        // from checking rest of characters
-                        extIdx = -1;
-                    }
-                }
-            }
-        }
-        if (end === -1)
-            return "";
-        if (start === end)
-            end = firstNonSlashEnd;
-        return path.slice(start, end);
-    }
-    else {
-        for (i = path.length - 1; i >= 0; --i) {
-            if ((0, _util_js_1.isPosixPathSeparator)(path.charCodeAt(i))) {
-                // 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) {
-                    start = i + 1;
-                    break;
-                }
-            }
-            else if (end === -1) {
-                // We saw the first non-path separator, mark this as the end of our
-                // path component
-                matchedSlash = false;
-                end = i + 1;
-            }
-        }
-        if (end === -1)
-            return "";
-        return path.slice(start, end);
+    if (path.length === 0)
+        return path;
+    if (typeof suffix !== "string") {
+        throw new TypeError(`Suffix must be a string. Received ${JSON.stringify(suffix)}`);
     }
+    const lastSegment = (0, _util_js_1.lastPathSegment)(path, _util_js_1.isPosixPathSeparator);
+    const strippedSegment = (0, _util_js_1.stripTrailingSeparators)(lastSegment, _util_js_1.isPosixPathSeparator);
+    return suffix ? (0, _util_js_1.stripSuffix)(strippedSegment, suffix) : strippedSegment;
 }
 exports.basename = basename;
 /**
@@ -362,7 +301,7 @@ function extname(path) {
     let preDotState = 0;
     for (let i = path.length - 1; i >= 0; --i) {
         const code = path.charCodeAt(i);
-        if (code === _constants_js_1.CHAR_FORWARD_SLASH) {
+        if ((0, _util_js_1.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) {
@@ -421,7 +360,7 @@ function parse(path) {
     const ret = { root: "", dir: "", base: "", ext: "", name: "" };
     if (path.length === 0)
         return ret;
-    const isAbsolute = path.charCodeAt(0) === _constants_js_1.CHAR_FORWARD_SLASH;
+    const isAbsolute = (0, _util_js_1.isPosixPathSeparator)(path.charCodeAt(0));
     let start;
     if (isAbsolute) {
         ret.root = "/";
@@ -441,7 +380,7 @@ function parse(path) {
     // Get non-dir info
     for (; i >= start; --i) {
         const code = path.charCodeAt(i);
-        if (code === _constants_js_1.CHAR_FORWARD_SLASH) {
+        if ((0, _util_js_1.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) {
@@ -483,6 +422,8 @@ function parse(path) {
                 ret.base = ret.name = path.slice(startPart, end);
             }
         }
+        // Fallback to '/' in case there is no basename
+        ret.base = ret.base || "/";
     }
     else {
         if (startPart === 0 && isAbsolute) {
@@ -495,8 +436,9 @@ function parse(path) {
         }
         ret.ext = path.slice(startDot, end);
     }
-    if (startPart > 0)
-        ret.dir = path.slice(0, startPart - 1);
+    if (startPart > 0) {
+        ret.dir = (0, _util_js_1.stripTrailingSeparators)(path.slice(0, startPart - 1), _util_js_1.isPosixPathSeparator);
+    }
     else if (isAbsolute)
         ret.dir = "/";
     return ret;

package/script/deps/deno.land/std@0.189.0/path/separator.d.ts

@@ -0,0 +1,2 @@
+export declare const SEP: string;
+export declare const SEP_PATTERN: RegExp;

package/script/deps/deno.land/std@0.189.0/path/win32.d.ts

@@ -0,0 +1,91 @@
+/// <reference types="node" />
+import type { FormatInputPathObject, ParsedPath } from "./_interface.js";
+export declare const sep = "\\";
+export declare const delimiter = ";";
+/**
+ * Resolves path segments into a `path`
+ * @param pathSegments to process to path
+ */
+export declare function resolve(...pathSegments: string[]): string;
+/**
+ * Normalizes a `path`
+ * @param path to normalize
+ */
+export declare function normalize(path: string): string;
+/**
+ * Verifies whether path is absolute
+ * @param path to verify
+ */
+export declare function isAbsolute(path: string): boolean;
+/**
+ * Join all given a sequence of `paths`,then normalizes the resulting path.
+ * @param paths to be joined and normalized
+ */
+export declare function join(...paths: string[]): string;
+/**
+ * It will solve the relative path from `from` to `to`, for instance:
+ *  from = 'C:\\orandea\\test\\aaa'
+ *  to = 'C:\\orandea\\impl\\bbb'
+ * The output of the function should be: '..\\..\\impl\\bbb'
+ * @param from relative path
+ * @param to relative path
+ */
+export declare function relative(from: string, to: string): string;
+/**
+ * Resolves path to a namespace path
+ * @param path to resolve to namespace
+ */
+export declare function toNamespacedPath(path: string): string;
+/**
+ * Return the directory path of a `path`.
+ * @param path - path to extract the directory from.
+ */
+export declare function dirname(path: string): string;
+/**
+ * Return the last portion of a `path`.
+ * Trailing directory separators are ignored, and optional suffix is removed.
+ *
+ * @param path - path to extract name from.
+ * @param [suffix] - suffix to remove from extracted name.
+ */
+export declare function basename(path: string, suffix?: 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 extname(path: string): string;
+/**
+ * Generate a path from `FormatInputPathObject` object.
+ * @param pathObject with path
+ */
+export declare function format(pathObject: FormatInputPathObject): string;
+/**
+ * Return a `ParsedPath` object of the `path`.
+ * @param path to process
+ */
+export declare function parse(path: string): ParsedPath;
+/**
+ * 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 fromFileUrl(url: string | URL): string;
+/**
+ * Converts a path string to a file URL.
+ *
+ * ```ts
+ *      import { toFileUrl } from "https://deno.land/std@$STD_VERSION/path/win32.ts";
+ *      toFileUrl("\\home\\foo"); // new URL("file:///home/foo")
+ *      toFileUrl("C:\\Users\\foo"); // new URL("file:///C:/Users/foo")
+ *      toFileUrl("\\\\127.0.0.1\\home\\foo"); // new URL("file://127.0.0.1/home/foo")
+ * ```
+ * @param path to convert to file URL
+ */
+export declare function toFileUrl(path: string): URL;