keep-a-changelog 0.10.3 → 2.0.1

package/umd/deps/deno_land/std_0.120.0/path/_util.js

@@ -0,0 +1,134 @@
+// Copyright the Browserify authors. MIT License.
+// Ported from https://github.com/browserify/path-browserify/
+// This module is browser compatible.
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./_constants.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    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") {
+            throw new TypeError(`Path must be a string. Received ${JSON.stringify(path)}`);
+        }
+    }
+    exports.assertPath = assertPath;
+    function isPosixPathSeparator(code) {
+        return code === _constants_js_1.CHAR_FORWARD_SLASH;
+    }
+    exports.isPosixPathSeparator = isPosixPathSeparator;
+    function isPathSeparator(code) {
+        return isPosixPathSeparator(code) || code === _constants_js_1.CHAR_BACKWARD_SLASH;
+    }
+    exports.isPathSeparator = isPathSeparator;
+    function isWindowsDeviceRoot(code) {
+        return ((code >= _constants_js_1.CHAR_LOWERCASE_A && code <= _constants_js_1.CHAR_LOWERCASE_Z) ||
+            (code >= _constants_js_1.CHAR_UPPERCASE_A && code <= _constants_js_1.CHAR_UPPERCASE_Z));
+    }
+    exports.isWindowsDeviceRoot = isWindowsDeviceRoot;
+    // Resolves . and .. elements in a path with directory names
+    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 = _constants_js_1.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) !== _constants_js_1.CHAR_DOT ||
+                        res.charCodeAt(res.length - 2) !== _constants_js_1.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 === _constants_js_1.CHAR_DOT && dots !== -1) {
+                ++dots;
+            }
+            else {
+                dots = -1;
+            }
+        }
+        return res;
+    }
+    exports.normalizeString = normalizeString;
+    function _format(sep, pathObject) {
+        const dir = pathObject.dir || pathObject.root;
+        const base = pathObject.base ||
+            (pathObject.name || "") + (pathObject.ext || "");
+        if (!dir)
+            return base;
+        if (dir === pathObject.root)
+            return dir + base;
+        return dir + sep + base;
+    }
+    exports._format = _format;
+    const WHITESPACE_ENCODINGS = {
+        "\u0009": "%09",
+        "\u000A": "%0A",
+        "\u000B": "%0B",
+        "\u000C": "%0C",
+        "\u000D": "%0D",
+        "\u0020": "%20",
+    };
+    function encodeWhitespace(string) {
+        return string.replaceAll(/[\s]/g, (c) => {
+            return WHITESPACE_ENCODINGS[c] ?? c;
+        });
+    }
+    exports.encodeWhitespace = encodeWhitespace;
+});

package/umd/deps/deno_land/std_0.120.0/path/common.js

@@ -0,0 +1,50 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./separator.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    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) {
+        const [first = "", ...remaining] = paths;
+        if (first === "" || remaining.length === 0) {
+            return first.substring(0, first.lastIndexOf(sep) + 1);
+        }
+        const parts = first.split(sep);
+        let endOfPrefix = parts.length;
+        for (const path of remaining) {
+            const compare = path.split(sep);
+            for (let i = 0; i < endOfPrefix; i++) {
+                if (compare[i] !== parts[i]) {
+                    endOfPrefix = i;
+                }
+            }
+            if (endOfPrefix === 0) {
+                return "";
+            }
+        }
+        const prefix = parts.slice(0, endOfPrefix).join(sep);
+        return prefix.endsWith(sep) ? prefix : `${prefix}${sep}`;
+    }
+    exports.common = common;
+});

package/umd/deps/deno_land/std_0.120.0/path/glob.js

@@ -0,0 +1,397 @@
+// Copyright 2018-2021 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;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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;
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../_util/os.js", "./separator.js", "./win32.js", "./posix.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.joinGlobs = exports.normalizeGlob = exports.isGlob = exports.globToRegExp = void 0;
+    const os_js_1 = require("../_util/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;
+    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, } = {}) {
+        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--)
+            ;
+        glob = glob.slice(0, newLength);
+        let regExpString = "";
+        // Terminates correctly. Trust that `j` is incremented every iteration.
+        for (let j = 0; j < glob.length;) {
+            let segment = "";
+            const groupStack = [];
+            let inRange = false;
+            let inEscape = false;
+            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++) {
+                if (inEscape) {
+                    inEscape = false;
+                    const escapeChars = inRange ? rangeEscapeChars : regExpEscapeChars;
+                    segment += escapeChars.includes(glob[i]) ? `\\${glob[i]}` : glob[i];
+                    continue;
+                }
+                if (glob[i] == escapePrefix) {
+                    inEscape = true;
+                    continue;
+                }
+                if (glob[i] == "[") {
+                    if (!inRange) {
+                        inRange = true;
+                        segment += "[";
+                        if (glob[i + 1] == "!") {
+                            i++;
+                            segment += "^";
+                        }
+                        else if (glob[i + 1] == "^") {
+                            i++;
+                            segment += "\\^";
+                        }
+                        continue;
+                    }
+                    else if (glob[i + 1] == ":") {
+                        let k = i + 1;
+                        let value = "";
+                        while (glob[k + 1] != null && glob[k + 1] != ":") {
+                            value += glob[k + 1];
+                            k++;
+                        }
+                        if (glob[k + 1] == ":" && glob[k + 2] == "]") {
+                            i = k + 2;
+                            if (value == "alnum")
+                                segment += "\\dA-Za-z";
+                            else if (value == "alpha")
+                                segment += "A-Za-z";
+                            else if (value == "ascii")
+                                segment += "\x00-\x7F";
+                            else if (value == "blank")
+                                segment += "\t ";
+                            else if (value == "cntrl")
+                                segment += "\x00-\x1F\x7F";
+                            else if (value == "digit")
+                                segment += "\\d";
+                            else if (value == "graph")
+                                segment += "\x21-\x7E";
+                            else if (value == "lower")
+                                segment += "a-z";
+                            else if (value == "print")
+                                segment += "\x20-\x7E";
+                            else if (value == "punct") {
+                                segment += "!\"#$%&'()*+,\\-./:;<=>?@[\\\\\\]^_‘{|}~";
+                            }
+                            else if (value == "space")
+                                segment += "\\s\v";
+                            else if (value == "upper")
+                                segment += "A-Z";
+                            else if (value == "word")
+                                segment += "\\w";
+                            else if (value == "xdigit")
+                                segment += "\\dA-Fa-f";
+                            continue;
+                        }
+                    }
+                }
+                if (glob[i] == "]" && inRange) {
+                    inRange = false;
+                    segment += "]";
+                    continue;
+                }
+                if (inRange) {
+                    if (glob[i] == "\\") {
+                        segment += `\\\\`;
+                    }
+                    else {
+                        segment += glob[i];
+                    }
+                    continue;
+                }
+                if (glob[i] == ")" && groupStack.length > 0 &&
+                    groupStack[groupStack.length - 1] != "BRACE") {
+                    segment += ")";
+                    const type = groupStack.pop();
+                    if (type == "!") {
+                        segment += wildcard;
+                    }
+                    else if (type != "@") {
+                        segment += type;
+                    }
+                    continue;
+                }
+                if (glob[i] == "|" && groupStack.length > 0 &&
+                    groupStack[groupStack.length - 1] != "BRACE") {
+                    segment += "|";
+                    continue;
+                }
+                if (glob[i] == "+" && extended && glob[i + 1] == "(") {
+                    i++;
+                    groupStack.push("+");
+                    segment += "(?:";
+                    continue;
+                }
+                if (glob[i] == "@" && extended && glob[i + 1] == "(") {
+                    i++;
+                    groupStack.push("@");
+                    segment += "(?:";
+                    continue;
+                }
+                if (glob[i] == "?") {
+                    if (extended && glob[i + 1] == "(") {
+                        i++;
+                        groupStack.push("?");
+                        segment += "(?:";
+                    }
+                    else {
+                        segment += ".";
+                    }
+                    continue;
+                }
+                if (glob[i] == "!" && extended && glob[i + 1] == "(") {
+                    i++;
+                    groupStack.push("!");
+                    segment += "(?!";
+                    continue;
+                }
+                if (glob[i] == "{") {
+                    groupStack.push("BRACE");
+                    segment += "(?:";
+                    continue;
+                }
+                if (glob[i] == "}" && groupStack[groupStack.length - 1] == "BRACE") {
+                    groupStack.pop();
+                    segment += ")";
+                    continue;
+                }
+                if (glob[i] == "," && groupStack[groupStack.length - 1] == "BRACE") {
+                    segment += "|";
+                    continue;
+                }
+                if (glob[i] == "*") {
+                    if (extended && glob[i + 1] == "(") {
+                        i++;
+                        groupStack.push("*");
+                        segment += "(?:";
+                    }
+                    else {
+                        const prevChar = glob[i - 1];
+                        let numStars = 1;
+                        while (glob[i + 1] == "*") {
+                            i++;
+                            numStars++;
+                        }
+                        const nextChar = glob[i + 1];
+                        if (globstarOption && numStars == 2 &&
+                            [...seps, undefined].includes(prevChar) &&
+                            [...seps, undefined].includes(nextChar)) {
+                            segment += globstar;
+                            endsWithSep = true;
+                        }
+                        else {
+                            segment += wildcard;
+                        }
+                    }
+                    continue;
+                }
+                segment += regExpEscapeChars.includes(glob[i]) ? `\\${glob[i]}` : glob[i];
+            }
+            // Check for unclosed groups or a dangling backslash.
+            if (groupStack.length > 0 || inRange || inEscape) {
+                // Parse failure. Take all characters from this segment literally.
+                segment = "";
+                for (const c of glob.slice(j, i)) {
+                    segment += regExpEscapeChars.includes(c) ? `\\${c}` : c;
+                    endsWithSep = false;
+                }
+            }
+            regExpString += segment;
+            if (!endsWithSep) {
+                regExpString += i < glob.length ? sep : sepMaybe;
+                endsWithSep = true;
+            }
+            // Terminates with `i` at the start of the next segment.
+            while (seps.includes(glob[i]))
+                i++;
+            // Check that the next value of `j` is indeed higher than the current value.
+            if (!(i > j)) {
+                throw new Error("Assertion failure: i > j (potential infinite loop)");
+            }
+            j = i;
+        }
+        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;
+});

package/umd/deps/deno_land/std_0.120.0/path/mod.js

@@ -0,0 +1,51 @@
+// 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;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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;
+};
+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);
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../_util/os.js", "./win32.js", "./posix.js", "./common.js", "./separator.js", "./_interface.js", "./glob.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    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;
+    const os_js_1 = require("../_util/os.js");
+    const _win32 = __importStar(require("./win32.js"));
+    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;
+    __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; } });
+    Object.defineProperty(exports, "SEP_PATTERN", { enumerable: true, get: function () { return separator_js_1.SEP_PATTERN; } });
+    __exportStar(require("./_interface.js"), exports);
+    __exportStar(require("./glob.js"), exports);
+});