track-cli 3.0.0-rc

package/esm/deps/deno.land/std@0.195.0/fs/mod.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Helpers for working with the filesystem.
+ *
+ * @module
+ */
+export * from "./empty_dir.js";
+export * from "./ensure_dir.js";
+export * from "./ensure_file.js";
+export * from "./ensure_link.js";
+export * from "./ensure_symlink.js";
+export * from "./exists.js";
+export * from "./expand_glob.js";
+export * from "./move.js";
+export * from "./copy.js";
+export * from "./walk.js";
+export * from "./eol.js";

package/esm/deps/deno.land/std@0.195.0/fs/mod.js

@@ -0,0 +1,17 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+/**
+ * Helpers for working with the filesystem.
+ *
+ * @module
+ */
+export * from "./empty_dir.js";
+export * from "./ensure_dir.js";
+export * from "./ensure_file.js";
+export * from "./ensure_link.js";
+export * from "./ensure_symlink.js";
+export * from "./exists.js";
+export * from "./expand_glob.js";
+export * from "./move.js";
+export * from "./copy.js";
+export * from "./walk.js";
+export * from "./eol.js";

package/esm/deps/deno.land/std@0.195.0/fs/move.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+export declare class SubdirectoryMoveError extends Error {
+    constructor(src: string | URL, dest: string | URL);
+}
+interface MoveOptions {
+    overwrite?: boolean;
+}
+/**
+ * Moves a file or directory.
+ *
+ * @example
+ * ```ts
+ * import { move } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * move("./foo", "./bar"); // returns a promise
+ * ```
+ */
+export declare function move(src: string | URL, dest: string | URL, { overwrite }?: MoveOptions): Promise<undefined>;
+/**
+ * Moves a file or directory synchronously.
+ * @example
+ * ```ts
+ * import { moveSync } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * moveSync("./foo", "./bar"); // void
+ * ```
+ */
+export declare function moveSync(src: string | URL, dest: string | URL, { overwrite }?: MoveOptions): void;
+export {};

package/esm/deps/deno.land/std@0.195.0/fs/move.js

@@ -0,0 +1,88 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import * as dntShim from "../../../../_dnt.shims.js";
+import { isSamePath, isSubdir } from "./_util.js";
+const EXISTS_ERROR = new dntShim.Deno.errors.AlreadyExists("dest already exists.");
+export class SubdirectoryMoveError extends Error {
+    constructor(src, dest) {
+        super(`Cannot move '${src}' to a subdirectory of itself, '${dest}'.`);
+    }
+}
+/**
+ * Moves a file or directory.
+ *
+ * @example
+ * ```ts
+ * import { move } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * move("./foo", "./bar"); // returns a promise
+ * ```
+ */
+export async function move(src, dest, { overwrite = false } = {}) {
+    const srcStat = await dntShim.Deno.stat(src);
+    if (srcStat.isDirectory &&
+        (isSubdir(src, dest) || isSamePath(src, dest))) {
+        throw new SubdirectoryMoveError(src, dest);
+    }
+    if (overwrite) {
+        if (isSamePath(src, dest))
+            return;
+        try {
+            await dntShim.Deno.remove(dest, { recursive: true });
+        }
+        catch (error) {
+            if (!(error instanceof dntShim.Deno.errors.NotFound)) {
+                throw error;
+            }
+        }
+    }
+    else {
+        try {
+            await dntShim.Deno.lstat(dest);
+            return Promise.reject(EXISTS_ERROR);
+        }
+        catch {
+            // Do nothing...
+        }
+    }
+    await dntShim.Deno.rename(src, dest);
+}
+/**
+ * Moves a file or directory synchronously.
+ * @example
+ * ```ts
+ * import { moveSync } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * moveSync("./foo", "./bar"); // void
+ * ```
+ */
+export function moveSync(src, dest, { overwrite = false } = {}) {
+    const srcStat = dntShim.Deno.statSync(src);
+    if (srcStat.isDirectory &&
+        (isSubdir(src, dest) || isSamePath(src, dest))) {
+        throw new SubdirectoryMoveError(src, dest);
+    }
+    if (overwrite) {
+        if (isSamePath(src, dest))
+            return;
+        try {
+            dntShim.Deno.removeSync(dest, { recursive: true });
+        }
+        catch (error) {
+            if (!(error instanceof dntShim.Deno.errors.NotFound)) {
+                throw error;
+            }
+        }
+    }
+    else {
+        try {
+            dntShim.Deno.lstatSync(dest);
+            throw EXISTS_ERROR;
+        }
+        catch (error) {
+            if (error === EXISTS_ERROR) {
+                throw error;
+            }
+        }
+    }
+    dntShim.Deno.renameSync(src, dest);
+}

package/esm/deps/deno.land/std@0.195.0/fs/walk.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+import { WalkEntry } from "./_util.js";
+export declare class WalkError extends Error {
+    cause: unknown;
+    name: string;
+    path: string;
+    constructor(cause: unknown, path: string);
+}
+export interface WalkOptions {
+    /** @default {Infinity} */
+    maxDepth?: number;
+    /** @default {true} */
+    includeFiles?: boolean;
+    /** @default {true} */
+    includeDirs?: boolean;
+    /** @default {false} */
+    followSymlinks?: boolean;
+    exts?: string[];
+    match?: RegExp[];
+    skip?: RegExp[];
+}
+export type { WalkEntry };
+/**
+ * Walks the file tree rooted at root, yielding each file or directory in the
+ * tree filtered according to the given options.
+ *
+ * @example
+ * ```ts
+ * import { walk } from "https://deno.land/std@$STD_VERSION/fs/walk.ts";
+ * import { assert } from "https://deno.land/std@$STD_VERSION/assert/assert.ts";
+ *
+ * for await (const entry of walk(".")) {
+ *   console.log(entry.path);
+ *   assert(entry.isFile);
+ * }
+ * ```
+ */
+export declare function walk(root: string | URL, { maxDepth, includeFiles, includeDirs, followSymlinks, exts, match, skip, }?: WalkOptions): AsyncIterableIterator<WalkEntry>;
+/** Same as walk() but uses synchronous ops */
+export declare function walkSync(root: string | URL, { maxDepth, includeFiles, includeDirs, followSymlinks, exts, match, skip, }?: WalkOptions): IterableIterator<WalkEntry>;

package/esm/deps/deno.land/std@0.195.0/fs/walk.js

@@ -0,0 +1,158 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Documentation and interface for walk were adapted from Go
+// https://golang.org/pkg/path/filepath/#Walk
+// Copyright 2009 The Go Authors. All rights reserved. BSD license.
+import * as dntShim from "../../../../_dnt.shims.js";
+import { assert } from "../assert/assert.js";
+import { join, normalize } from "../path/mod.js";
+import { createWalkEntry, createWalkEntrySync, toPathString, } from "./_util.js";
+export class WalkError extends Error {
+    constructor(cause, path) {
+        super(`${cause instanceof Error ? cause.message : cause} for path "${path}"`);
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "WalkError"
+        });
+        Object.defineProperty(this, "path", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.path = path;
+        this.cause = cause;
+    }
+}
+function include(path, exts, match, skip) {
+    if (exts && !exts.some((ext) => path.endsWith(ext))) {
+        return false;
+    }
+    if (match && !match.some((pattern) => !!path.match(pattern))) {
+        return false;
+    }
+    if (skip && skip.some((pattern) => !!path.match(pattern))) {
+        return false;
+    }
+    return true;
+}
+function wrapErrorWithPath(err, root) {
+    if (err instanceof WalkError)
+        return err;
+    return new WalkError(err, root);
+}
+/**
+ * Walks the file tree rooted at root, yielding each file or directory in the
+ * tree filtered according to the given options.
+ *
+ * @example
+ * ```ts
+ * import { walk } from "https://deno.land/std@$STD_VERSION/fs/walk.ts";
+ * import { assert } from "https://deno.land/std@$STD_VERSION/assert/assert.ts";
+ *
+ * for await (const entry of walk(".")) {
+ *   console.log(entry.path);
+ *   assert(entry.isFile);
+ * }
+ * ```
+ */
+export async function* walk(root, { maxDepth = Infinity, includeFiles = true, includeDirs = true, followSymlinks = false, exts = undefined, match = undefined, skip = undefined, } = {}) {
+    if (maxDepth < 0) {
+        return;
+    }
+    root = toPathString(root);
+    if (includeDirs && include(root, exts, match, skip)) {
+        yield await createWalkEntry(root);
+    }
+    if (maxDepth < 1 || !include(root, undefined, undefined, skip)) {
+        return;
+    }
+    try {
+        for await (const entry of dntShim.Deno.readDir(root)) {
+            assert(entry.name != null);
+            let path = join(root, entry.name);
+            let { isSymlink, isDirectory } = entry;
+            if (isSymlink) {
+                if (!followSymlinks)
+                    continue;
+                path = await dntShim.Deno.realPath(path);
+                // Caveat emptor: don't assume |path| is not a symlink. realpath()
+                // resolves symlinks but another process can replace the file system
+                // entity with a different type of entity before we call lstat().
+                ({ isSymlink, isDirectory } = await dntShim.Deno.lstat(path));
+            }
+            if (isSymlink || isDirectory) {
+                yield* walk(path, {
+                    maxDepth: maxDepth - 1,
+                    includeFiles,
+                    includeDirs,
+                    followSymlinks,
+                    exts,
+                    match,
+                    skip,
+                });
+            }
+            else if (includeFiles && include(path, exts, match, skip)) {
+                yield { path, ...entry };
+            }
+        }
+    }
+    catch (err) {
+        throw wrapErrorWithPath(err, normalize(root));
+    }
+}
+/** Same as walk() but uses synchronous ops */
+export function* walkSync(root, { maxDepth = Infinity, includeFiles = true, includeDirs = true, followSymlinks = false, exts = undefined, match = undefined, skip = undefined, } = {}) {
+    root = toPathString(root);
+    if (maxDepth < 0) {
+        return;
+    }
+    if (includeDirs && include(root, exts, match, skip)) {
+        yield createWalkEntrySync(root);
+    }
+    if (maxDepth < 1 || !include(root, undefined, undefined, skip)) {
+        return;
+    }
+    let entries;
+    try {
+        entries = dntShim.Deno.readDirSync(root);
+    }
+    catch (err) {
+        throw wrapErrorWithPath(err, normalize(root));
+    }
+    for (const entry of entries) {
+        assert(entry.name != null);
+        let path = join(root, entry.name);
+        let { isSymlink, isDirectory } = entry;
+        if (isSymlink) {
+            if (!followSymlinks)
+                continue;
+            path = dntShim.Deno.realPathSync(path);
+            // Caveat emptor: don't assume |path| is not a symlink. realpath()
+            // resolves symlinks but another process can replace the file system
+            // entity with a different type of entity before we call lstat().
+            ({ isSymlink, isDirectory } = dntShim.Deno.lstatSync(path));
+        }
+        if (isSymlink || isDirectory) {
+            yield* walkSync(path, {
+                maxDepth: maxDepth - 1,
+                includeFiles,
+                includeDirs,
+                followSymlinks,
+                exts,
+                match,
+                skip,
+            });
+        }
+        else if (includeFiles && include(path, exts, match, skip)) {
+            yield { path, ...entry };
+        }
+    }
+}

package/esm/deps/deno.land/std@0.195.0/path/_constants.d.ts

@@ -0,0 +1,39 @@
+export declare const CHAR_UPPERCASE_A = 65;
+export declare const CHAR_LOWERCASE_A = 97;
+export declare const CHAR_UPPERCASE_Z = 90;
+export declare const CHAR_LOWERCASE_Z = 122;
+export declare const CHAR_DOT = 46;
+export declare const CHAR_FORWARD_SLASH = 47;
+export declare const CHAR_BACKWARD_SLASH = 92;
+export declare const CHAR_VERTICAL_LINE = 124;
+export declare const CHAR_COLON = 58;
+export declare const CHAR_QUESTION_MARK = 63;
+export declare const CHAR_UNDERSCORE = 95;
+export declare const CHAR_LINE_FEED = 10;
+export declare const CHAR_CARRIAGE_RETURN = 13;
+export declare const CHAR_TAB = 9;
+export declare const CHAR_FORM_FEED = 12;
+export declare const CHAR_EXCLAMATION_MARK = 33;
+export declare const CHAR_HASH = 35;
+export declare const CHAR_SPACE = 32;
+export declare const CHAR_NO_BREAK_SPACE = 160;
+export declare const CHAR_ZERO_WIDTH_NOBREAK_SPACE = 65279;
+export declare const CHAR_LEFT_SQUARE_BRACKET = 91;
+export declare const CHAR_RIGHT_SQUARE_BRACKET = 93;
+export declare const CHAR_LEFT_ANGLE_BRACKET = 60;
+export declare const CHAR_RIGHT_ANGLE_BRACKET = 62;
+export declare const CHAR_LEFT_CURLY_BRACKET = 123;
+export declare const CHAR_RIGHT_CURLY_BRACKET = 125;
+export declare const CHAR_HYPHEN_MINUS = 45;
+export declare const CHAR_PLUS = 43;
+export declare const CHAR_DOUBLE_QUOTE = 34;
+export declare const CHAR_SINGLE_QUOTE = 39;
+export declare const CHAR_PERCENT = 37;
+export declare const CHAR_SEMICOLON = 59;
+export declare const CHAR_CIRCUMFLEX_ACCENT = 94;
+export declare const CHAR_GRAVE_ACCENT = 96;
+export declare const CHAR_AT = 64;
+export declare const CHAR_AMPERSAND = 38;
+export declare const CHAR_EQUAL = 61;
+export declare const CHAR_0 = 48;
+export declare const CHAR_9 = 57;

package/esm/deps/deno.land/std@0.195.0/path/_constants.js

@@ -0,0 +1,46 @@
+// 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.
+// Alphabet chars.
+export const CHAR_UPPERCASE_A = 65; /* A */
+export const CHAR_LOWERCASE_A = 97; /* a */
+export const CHAR_UPPERCASE_Z = 90; /* Z */
+export const CHAR_LOWERCASE_Z = 122; /* z */
+// Non-alphabetic chars.
+export const CHAR_DOT = 46; /* . */
+export const CHAR_FORWARD_SLASH = 47; /* / */
+export const CHAR_BACKWARD_SLASH = 92; /* \ */
+export const CHAR_VERTICAL_LINE = 124; /* | */
+export const CHAR_COLON = 58; /* : */
+export const CHAR_QUESTION_MARK = 63; /* ? */
+export const CHAR_UNDERSCORE = 95; /* _ */
+export const CHAR_LINE_FEED = 10; /* \n */
+export const CHAR_CARRIAGE_RETURN = 13; /* \r */
+export const CHAR_TAB = 9; /* \t */
+export const CHAR_FORM_FEED = 12; /* \f */
+export const CHAR_EXCLAMATION_MARK = 33; /* ! */
+export const CHAR_HASH = 35; /* # */
+export const CHAR_SPACE = 32; /*   */
+export const CHAR_NO_BREAK_SPACE = 160; /* \u00A0 */
+export const CHAR_ZERO_WIDTH_NOBREAK_SPACE = 65279; /* \uFEFF */
+export const CHAR_LEFT_SQUARE_BRACKET = 91; /* [ */
+export const CHAR_RIGHT_SQUARE_BRACKET = 93; /* ] */
+export const CHAR_LEFT_ANGLE_BRACKET = 60; /* < */
+export const CHAR_RIGHT_ANGLE_BRACKET = 62; /* > */
+export const CHAR_LEFT_CURLY_BRACKET = 123; /* { */
+export const CHAR_RIGHT_CURLY_BRACKET = 125; /* } */
+export const CHAR_HYPHEN_MINUS = 45; /* - */
+export const CHAR_PLUS = 43; /* + */
+export const CHAR_DOUBLE_QUOTE = 34; /* " */
+export const CHAR_SINGLE_QUOTE = 39; /* ' */
+export const CHAR_PERCENT = 37; /* % */
+export const CHAR_SEMICOLON = 59; /* ; */
+export const CHAR_CIRCUMFLEX_ACCENT = 94; /* ^ */
+export const CHAR_GRAVE_ACCENT = 96; /* ` */
+export const CHAR_AT = 64; /* @ */
+export const CHAR_AMPERSAND = 38; /* & */
+export const CHAR_EQUAL = 61; /* = */
+// Digits
+export const CHAR_0 = 48; /* 0 */
+export const CHAR_9 = 57; /* 9 */

package/esm/deps/deno.land/std@0.195.0/path/_interface.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A parsed path object generated by path.parse() or consumed by path.format().
+ */
+export interface ParsedPath {
+    /**
+     * The root of the path such as '/' or 'c:\'
+     */
+    root: string;
+    /**
+     * The full directory path such as '/home/user/dir' or 'c:\path\dir'
+     */
+    dir: string;
+    /**
+     * The file name including extension (if any) such as 'index.html'
+     */
+    base: string;
+    /**
+     * The file extension (if any) such as '.html'
+     */
+    ext: string;
+    /**
+     * The file name without extension (if any) such as 'index'
+     */
+    name: string;
+}
+export type FormatInputPathObject = Partial<ParsedPath>;

package/esm/deps/deno.land/std@0.195.0/path/_interface.js

@@ -0,0 +1,3 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+export {};

package/esm/deps/deno.land/std@0.195.0/path/_util.d.ts

@@ -0,0 +1,11 @@
+import type { FormatInputPathObject } from "./_interface.js";
+export declare function assertPath(path: string): void;
+export declare function isPosixPathSeparator(code: number): boolean;
+export declare function isPathSeparator(code: number): boolean;
+export declare function isWindowsDeviceRoot(code: number): boolean;
+export declare function normalizeString(path: string, allowAboveRoot: boolean, separator: string, isPathSeparator: (code: number) => boolean): string;
+export declare function _format(sep: string, pathObject: FormatInputPathObject): string;
+export declare function encodeWhitespace(string: string): string;
+export declare function lastPathSegment(path: string, isSep: (char: number) => boolean, start?: number): string;
+export declare function stripTrailingSeparators(segment: string, isSep: (char: number) => boolean): string;
+export declare function stripSuffix(name: string, suffix: string): string;

package/esm/deps/deno.land/std@0.195.0/path/_util.js

@@ -0,0 +1,161 @@
+// 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.
+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));
+}
+// Resolves . and .. elements in a path with directory names
+export function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
+    let res = "";
+    let lastSegmentLength = 0;
+    let lastSlash = -1;
+    let dots = 0;
+    let code;
+    for (let i = 0, len = path.length; i <= len; ++i) {
+        if (i < len)
+            code = path.charCodeAt(i);
+        else if (isPathSeparator(code))
+            break;
+        else
+            code = CHAR_FORWARD_SLASH;
+        if (isPathSeparator(code)) {
+            if (lastSlash === i - 1 || dots === 1) {
+                // NOOP
+            }
+            else if (lastSlash !== i - 1 && dots === 2) {
+                if (res.length < 2 ||
+                    lastSegmentLength !== 2 ||
+                    res.charCodeAt(res.length - 1) !== CHAR_DOT ||
+                    res.charCodeAt(res.length - 2) !== CHAR_DOT) {
+                    if (res.length > 2) {
+                        const lastSlashIndex = res.lastIndexOf(separator);
+                        if (lastSlashIndex === -1) {
+                            res = "";
+                            lastSegmentLength = 0;
+                        }
+                        else {
+                            res = res.slice(0, lastSlashIndex);
+                            lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);
+                        }
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                    else if (res.length === 2 || res.length === 1) {
+                        res = "";
+                        lastSegmentLength = 0;
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                }
+                if (allowAboveRoot) {
+                    if (res.length > 0)
+                        res += `${separator}..`;
+                    else
+                        res = "..";
+                    lastSegmentLength = 2;
+                }
+            }
+            else {
+                if (res.length > 0)
+                    res += separator + path.slice(lastSlash + 1, i);
+                else
+                    res = path.slice(lastSlash + 1, i);
+                lastSegmentLength = i - lastSlash - 1;
+            }
+            lastSlash = i;
+            dots = 0;
+        }
+        else if (code === CHAR_DOT && dots !== -1) {
+            ++dots;
+        }
+        else {
+            dots = -1;
+        }
+    }
+    return res;
+}
+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;
+}
+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;
+    });
+}
+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 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);
+}
+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);
+}

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