diff --git a/src/vendor/deno.land/std@0.204.0/assert/assert.ts b/src/vendor/deno.land/std@0.204.0/assert/assert.ts new file mode 100644 index 00000000000..3f868f4e0d2 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/assert/assert.ts @@ -0,0 +1,9 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +import { AssertionError } from "./assertion_error.ts"; + +/** Make an assertion, error will be thrown if `expr` does not have truthy value. */ +export function assert(expr: unknown, msg = ""): asserts expr { + if (!expr) { + throw new AssertionError(msg); + } +} diff --git a/src/vendor/deno.land/std@0.204.0/assert/assertion_error.ts b/src/vendor/deno.land/std@0.204.0/assert/assertion_error.ts new file mode 100644 index 00000000000..feecc9e87a6 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/assert/assertion_error.ts @@ -0,0 +1,7 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +export class AssertionError extends Error { + override name = "AssertionError"; + constructor(message: string) { + super(message); + } +} diff --git a/src/vendor/deno.land/std@0.204.0/path/_common/assert_path.ts b/src/vendor/deno.land/std@0.204.0/path/_common/assert_path.ts new file mode 100644 index 00000000000..d100f295f7b --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/_common/assert_path.ts @@ -0,0 +1,10 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// Copyright the Browserify authors. MIT License. + +export function assertPath(path: string) { + if (typeof path !== "string") { + throw new TypeError( + `Path must be a string. Received ${JSON.stringify(path)}`, + ); + } +} diff --git a/src/vendor/deno.land/std@0.204.0/path/_common/basename.ts b/src/vendor/deno.land/std@0.204.0/path/_common/basename.ts new file mode 100644 index 00000000000..119f1f8819d --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/_common/basename.ts @@ -0,0 +1,53 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { assertPath } from "./assert_path.ts"; + +export function stripSuffix(name: string, suffix: string): string { + 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: string, + isSep: (char: number) => boolean, + start = 0, +): string { + 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: string, suffix: string) { + assertPath(path); + if (path.length === 0) return path; + if (typeof suffix !== "string") { + throw new TypeError( + `Suffix must be a string. Received ${JSON.stringify(suffix)}`, + ); + } +} diff --git a/src/vendor/deno.land/std@0.204.0/path/_common/common.ts b/src/vendor/deno.land/std@0.204.0/path/_common/common.ts new file mode 100644 index 00000000000..18b7a0e37a9 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/_common/common.ts @@ -0,0 +1,26 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +export function _common(paths: string[], sep: string): string { + 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}`; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/_common/constants.ts b/src/vendor/deno.land/std@0.204.0/path/_common/constants.ts new file mode 100644 index 00000000000..8da22a8da70 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/_common/constants.ts @@ -0,0 +1,49 @@ +// 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 */ diff --git a/src/vendor/deno.land/std@0.204.0/path/_common/dirname.ts b/src/vendor/deno.land/std@0.204.0/path/_common/dirname.ts new file mode 100644 index 00000000000..c6caef43c39 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/_common/dirname.ts @@ -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.ts"; + +export function assertArg(path: string) { + assertPath(path); + if (path.length === 0) return "."; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/_common/format.ts b/src/vendor/deno.land/std@0.204.0/path/_common/format.ts new file mode 100644 index 00000000000..65862c92cf4 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/_common/format.ts @@ -0,0 +1,25 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import type { FormatInputPathObject } from "../_interface.ts"; + +export function _format( + sep: string, + pathObject: FormatInputPathObject, +): string { + const dir: string | undefined = pathObject.dir || pathObject.root; + const base: string = 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: FormatInputPathObject) { + if (pathObject === null || typeof pathObject !== "object") { + throw new TypeError( + `The "pathObject" argument must be of type Object. Received type ${typeof pathObject}`, + ); + } +} diff --git a/src/vendor/deno.land/std@0.204.0/path/_common/from_file_url.ts b/src/vendor/deno.land/std@0.204.0/path/_common/from_file_url.ts new file mode 100644 index 00000000000..5bd8b335c88 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/_common/from_file_url.ts @@ -0,0 +1,10 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +export function assertArg(url: URL | string) { + url = url instanceof URL ? url : new URL(url); + if (url.protocol !== "file:") { + throw new TypeError("Must be a file URL."); + } + return url; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/_common/glob_to_reg_exp.ts b/src/vendor/deno.land/std@0.204.0/path/_common/glob_to_reg_exp.ts new file mode 100644 index 00000000000..cef68fd9851 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/_common/glob_to_reg_exp.ts @@ -0,0 +1,280 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +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; + +const regExpEscapeChars = [ + "!", + "$", + "(", + ")", + "*", + "+", + ".", + "=", + "?", + "[", + "\\", + "^", + "{", + "|", +]; +const rangeEscapeChars = ["-", "\\", "]"]; + +export interface GlobConstants { + sep: string; + sepMaybe: string; + seps: string[]; + globstar: string; + wildcard: string; + escapePrefix: string; +} + +export function _globToRegExp( + c: GlobConstants, + glob: string, + { + extended = true, + globstar: globstarOption = true, + // os = osType, + caseInsensitive = false, + }: GlobToRegExpOptions = {}, +): RegExp { + if (glob === "") { + return /(?!)/; + } + + // Remove trailing separators. + let newLength = glob.length; + for (; newLength > 1 && c.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: string[] = []; + 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 && !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] === c.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] !== undefined && 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 += c.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 && + [...c.seps, undefined].includes(prevChar) && + [...c.seps, undefined].includes(nextChar) + ) { + segment += c.globstar; + endsWithSep = true; + } else { + segment += c.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 ? c.sep : c.sepMaybe; + endsWithSep = true; + } + + // Terminates with `i` at the start of the next segment. + while (c.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" : ""); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/_common/is_glob.ts b/src/vendor/deno.land/std@0.204.0/path/_common/is_glob.ts new file mode 100644 index 00000000000..87e03893ddc --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/_common/is_glob.ts @@ -0,0 +1,35 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +/** Test whether the given string is a glob */ +export function isGlob(str: string): boolean { + const chars: Record = { "{": "}", "(": ")", "[": "]" }; + const regex = + /\\(.)|(^!|\*|\?|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/; + + if (str === "") { + return false; + } + + let match: RegExpExecArray | null; + + 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; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/_common/normalize.ts b/src/vendor/deno.land/std@0.204.0/path/_common/normalize.ts new file mode 100644 index 00000000000..c6caef43c39 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/_common/normalize.ts @@ -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.ts"; + +export function assertArg(path: string) { + assertPath(path); + if (path.length === 0) return "."; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/_common/normalize_string.ts b/src/vendor/deno.land/std@0.204.0/path/_common/normalize_string.ts new file mode 100644 index 00000000000..5defbe4e176 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/_common/normalize_string.ts @@ -0,0 +1,74 @@ +// 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_DOT, CHAR_FORWARD_SLASH } from "./constants.ts"; + +// Resolves . and .. elements in a path with directory names +export function normalizeString( + path: string, + allowAboveRoot: boolean, + separator: string, + isPathSeparator: (code: number) => boolean, +): string { + let res = ""; + let lastSegmentLength = 0; + let lastSlash = -1; + let dots = 0; + let code: number | undefined; + 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; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/_common/relative.ts b/src/vendor/deno.land/std@0.204.0/path/_common/relative.ts new file mode 100644 index 00000000000..2472e373a35 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/_common/relative.ts @@ -0,0 +1,10 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { assertPath } from "./assert_path.ts"; + +export function assertArgs(from: string, to: string) { + assertPath(from); + assertPath(to); + if (from === to) return ""; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/_common/strip_trailing_separators.ts b/src/vendor/deno.land/std@0.204.0/path/_common/strip_trailing_separators.ts new file mode 100644 index 00000000000..6205e45c21c --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/_common/strip_trailing_separators.ts @@ -0,0 +1,25 @@ +// 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: string, + isSep: (char: number) => boolean, +): string { + 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); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/_common/to_file_url.ts b/src/vendor/deno.land/std@0.204.0/path/_common/to_file_url.ts new file mode 100644 index 00000000000..ec7af4a903d --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/_common/to_file_url.ts @@ -0,0 +1,17 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +const WHITESPACE_ENCODINGS: Record = { + "\u0009": "%09", + "\u000A": "%0A", + "\u000B": "%0B", + "\u000C": "%0C", + "\u000D": "%0D", + "\u0020": "%20", +}; + +export function encodeWhitespace(string: string): string { + return string.replaceAll(/[\s]/g, (c) => { + return WHITESPACE_ENCODINGS[c] ?? c; + }); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/_interface.ts b/src/vendor/deno.land/std@0.204.0/path/_interface.ts new file mode 100644 index 00000000000..153f3defd21 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/_interface.ts @@ -0,0 +1,30 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +/** + * 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; diff --git a/src/vendor/deno.land/std@0.204.0/path/_os.ts b/src/vendor/deno.land/std@0.204.0/path/_os.ts new file mode 100644 index 00000000000..016322d2096 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/_os.ts @@ -0,0 +1,31 @@ +// 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 +export type OSType = + | "darwin" + | "linux" + | "windows" + | "freebsd" + | "netbsd" + | "aix" + | "solaris" + | "illumos"; + +export const osType: OSType = (() => { + // deno-lint-ignore no-explicit-any + const { Deno } = globalThis as any; + if (typeof Deno?.build?.os === "string") { + return Deno.build.os; + } + + // deno-lint-ignore no-explicit-any + const { navigator } = globalThis as any; + if (navigator?.appVersion?.includes?.("Win")) { + return "windows"; + } + + return "linux"; +})(); + +export const isWindows = osType === "windows"; diff --git a/src/vendor/deno.land/std@0.204.0/path/basename.ts b/src/vendor/deno.land/std@0.204.0/path/basename.ts new file mode 100644 index 00000000000..8a6044607d5 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/basename.ts @@ -0,0 +1,19 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { isWindows } from "./_os.ts"; +import { basename as posixBasename } from "./posix/basename.ts"; +import { basename as windowsBasename } from "./windows/basename.ts"; + +/** + * 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 function basename(path: string, suffix = ""): string { + return isWindows + ? windowsBasename(path, suffix) + : posixBasename(path, suffix); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/common.ts b/src/vendor/deno.land/std@0.204.0/path/common.ts new file mode 100644 index 00000000000..5ac90e93c39 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/common.ts @@ -0,0 +1,21 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { _common } from "./_common/common.ts"; +import { SEP } from "./separator.ts"; + +/** 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: string[], sep = SEP): string { + return _common(paths, sep); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/dirname.ts b/src/vendor/deno.land/std@0.204.0/path/dirname.ts new file mode 100644 index 00000000000..dad3456794c --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/dirname.ts @@ -0,0 +1,14 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { isWindows } from "./_os.ts"; +import { dirname as posixDirname } from "./posix/dirname.ts"; +import { dirname as windowsDirname } from "./windows/dirname.ts"; + +/** + * Return the directory path of a `path`. + * @param path - path to extract the directory from. + */ +export function dirname(path: string): string { + return isWindows ? windowsDirname(path) : posixDirname(path); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/extname.ts b/src/vendor/deno.land/std@0.204.0/path/extname.ts new file mode 100644 index 00000000000..697795dd00e --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/extname.ts @@ -0,0 +1,14 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { isWindows } from "./_os.ts"; +import { extname as posixExtname } from "./posix/extname.ts"; +import { extname as windowsExtname } from "./posix/extname.ts"; +/** + * Return the extension of the `path` with leading period. + * @param path with extension + * @returns extension (ex. for `file.ts` returns `.ts`) + */ +export function extname(path: string): string { + return isWindows ? windowsExtname(path) : posixExtname(path); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/format.ts b/src/vendor/deno.land/std@0.204.0/path/format.ts new file mode 100644 index 00000000000..f9a823da227 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/format.ts @@ -0,0 +1,15 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { isWindows } from "./_os.ts"; +import { format as posixFormat } from "./posix/format.ts"; +import { format as windowsFormat } from "./windows/format.ts"; +import { FormatInputPathObject } from "./_interface.ts"; + +/** + * Generate a path from `FormatInputPathObject` object. + * @param pathObject with path + */ +export function format(pathObject: FormatInputPathObject): string { + return isWindows ? windowsFormat(pathObject) : posixFormat(pathObject); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/from_file_url.ts b/src/vendor/deno.land/std@0.204.0/path/from_file_url.ts new file mode 100644 index 00000000000..421607fbcd7 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/from_file_url.ts @@ -0,0 +1,26 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { isWindows } from "./_os.ts"; +import { fromFileUrl as posixFromFileUrl } from "./posix/from_file_url.ts"; +import { fromFileUrl as windowsFromFileUrl } from "./windows/from_file_url.ts"; + +/** + * Converts a file URL to a path string. + * + * ```ts + * import { fromFileUrl } from "https://deno.land/std@$STD_VERSION/path/from_file_url.ts"; + * + * // posix + * fromFileUrl("file:///home/foo"); // "/home/foo" + * + * // win32 + * 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 function fromFileUrl(url: string | URL): string { + return isWindows ? windowsFromFileUrl(url) : posixFromFileUrl(url); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/glob.ts b/src/vendor/deno.land/std@0.204.0/path/glob.ts new file mode 100644 index 00000000000..28f9d3a9ad3 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/glob.ts @@ -0,0 +1,107 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { isWindows, OSType } from "./_os.ts"; +import type { GlobOptions } from "./_common/glob_to_reg_exp.ts"; +import { + globToRegExp as posixGlobToRegExp, + joinGlobs as posixJoinGlobs, + normalizeGlob as posixNormalizeGlob, +} from "./posix/glob.ts"; +import { + globToRegExp as windowsGlobToRegExp, + joinGlobs as windowsJoinGlobs, + normalizeGlob as windowsNormalizeGlob, +} from "./windows/glob.ts"; + +export { isGlob } from "./_common/is_glob.ts"; + +export type { GlobOptions }; + +export type GlobToRegExpOptions = GlobOptions & { + os?: OSType; +}; + +/** 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`. + * - `[[::]]` - Matches any character belonging to ``. + * - `[[: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: string, + options: GlobToRegExpOptions = {}, +): RegExp { + return options.os === "windows" || (!options.os && isWindows) + ? windowsGlobToRegExp(glob, options) + : posixGlobToRegExp(glob, options); +} + +/** Like normalize(), but doesn't collapse "**\/.." when `globstar` is true. */ +export function normalizeGlob( + glob: string, + options: GlobOptions = {}, +): string { + return isWindows + ? windowsNormalizeGlob(glob, options) + : posixNormalizeGlob(glob, options); +} + +/** Like join(), but doesn't collapse "**\/.." when `globstar` is true. */ +export function joinGlobs( + globs: string[], + options: GlobOptions = {}, +): string { + return isWindows + ? windowsJoinGlobs(globs, options) + : posixJoinGlobs(globs, options); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/is_absolute.ts b/src/vendor/deno.land/std@0.204.0/path/is_absolute.ts new file mode 100644 index 00000000000..9e5ddeff8a6 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/is_absolute.ts @@ -0,0 +1,14 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { isWindows } from "./_os.ts"; +import { isAbsolute as posixIsAbsolute } from "./posix/is_absolute.ts"; +import { isAbsolute as windowsIsAbsolute } from "./windows/is_absolute.ts"; + +/** + * Verifies whether provided path is absolute + * @param path to be verified as absolute + */ +export function isAbsolute(path: string): boolean { + return isWindows ? windowsIsAbsolute(path) : posixIsAbsolute(path); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/join.ts b/src/vendor/deno.land/std@0.204.0/path/join.ts new file mode 100644 index 00000000000..83f572cd26e --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/join.ts @@ -0,0 +1,14 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { isWindows } from "./_os.ts"; +import { join as posixJoin } from "./posix/join.ts"; +import { join as windowsJoin } from "./windows/join.ts"; + +/** + * Join all given a sequence of `paths`,then normalizes the resulting path. + * @param paths to be joined and normalized + */ +export function join(...paths: string[]) { + return isWindows ? windowsJoin(...paths) : posixJoin(...paths); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/mod.ts b/src/vendor/deno.land/std@0.204.0/path/mod.ts new file mode 100644 index 00000000000..1c6d4eb6591 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/mod.ts @@ -0,0 +1,66 @@ +// 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. + +/** + * Utilities for working with OS-specific file paths. + * + * Functions from this module will automatically switch to support the path style + * of the current OS, either `windows` for Microsoft Windows, or `posix` for + * every other operating system, eg. Linux, MacOS, BSD etc. + * + * To use functions for a specific path style regardless of the current OS + * import the modules from the platform sub directory instead. + * + * Example, for `posix`: + * + * ```ts + * import { fromFileUrl } from "https://deno.land/std@$STD_VERSION/path/posix/from_file_url.ts"; + * const p = fromFileUrl("file:///home/foo"); + * console.log(p); // "/home/foo" + * ``` + * + * or, for `windows`: + * + * ```ts + * import { fromFileUrl } from "https://deno.land/std@$STD_VERSION/path/windows/from_file_url.ts"; + * const p = fromFileUrl("file:///home/foo"); + * console.log(p); // "\\home\\foo" + * ``` + * + * This module is browser compatible. + * + * @module + */ + +import { isWindows } from "./_os.ts"; +import * as _windows from "./windows/mod.ts"; +import * as _posix from "./posix/mod.ts"; + +/** @deprecated (will be removed after 1.0.0) Import from `path/windows/mod.ts` instead. */ +export const win32 = _windows; + +/** @deprecated (will be removed after 1.0.0) Import from `path/posix/mod.ts` instead. */ +export const posix = _posix; + +export const sep = isWindows ? _windows.sep : _posix.sep; +export const delimiter = isWindows ? _windows.delimiter : _posix.delimiter; + +export * from "./basename.ts"; +export * from "./dirname.ts"; +export * from "./extname.ts"; +export * from "./format.ts"; +export * from "./from_file_url.ts"; +export * from "./is_absolute.ts"; +export * from "./join.ts"; +export * from "./normalize.ts"; +export * from "./parse.ts"; +export * from "./relative.ts"; +export * from "./resolve.ts"; +export * from "./to_file_url.ts"; +export * from "./to_namespaced_path.ts"; +export * from "./common.ts"; +export * from "./separator.ts"; +export * from "./_interface.ts"; +export * from "./glob.ts"; diff --git a/src/vendor/deno.land/std@0.204.0/path/normalize.ts b/src/vendor/deno.land/std@0.204.0/path/normalize.ts new file mode 100644 index 00000000000..4486d7cc10c --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/normalize.ts @@ -0,0 +1,15 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { isWindows } from "./_os.ts"; +import { normalize as posixNormalize } from "./posix/normalize.ts"; +import { normalize as windowsNormalize } from "./windows/normalize.ts"; +/** + * 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 function normalize(path: string): string { + return isWindows ? windowsNormalize(path) : posixNormalize(path); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/parse.ts b/src/vendor/deno.land/std@0.204.0/path/parse.ts new file mode 100644 index 00000000000..e900d96872d --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/parse.ts @@ -0,0 +1,15 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { isWindows } from "./_os.ts"; +import type { ParsedPath } from "./_interface.ts"; +import { parse as posixParse } from "./posix/parse.ts"; +import { parse as windowsParse } from "./windows/parse.ts"; + +/** + * Return a `ParsedPath` object of the `path`. + * @param path to process + */ +export function parse(path: string): ParsedPath { + return isWindows ? windowsParse(path) : posixParse(path); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/posix/_util.ts b/src/vendor/deno.land/std@0.204.0/path/posix/_util.ts new file mode 100644 index 00000000000..f8cb5081597 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/posix/_util.ts @@ -0,0 +1,10 @@ +// 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_FORWARD_SLASH } from "../_common/constants.ts"; + +export function isPosixPathSeparator(code: number): boolean { + return code === CHAR_FORWARD_SLASH; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/posix/basename.ts b/src/vendor/deno.land/std@0.204.0/path/posix/basename.ts new file mode 100644 index 00000000000..6a84ea162dd --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/posix/basename.ts @@ -0,0 +1,28 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { + assertArgs, + lastPathSegment, + stripSuffix, +} from "../_common/basename.ts"; +import { stripTrailingSeparators } from "../_common/strip_trailing_separators.ts"; +import { isPosixPathSeparator } from "./_util.ts"; + +/** + * 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 function basename(path: string, suffix = ""): string { + assertArgs(path, suffix); + + const lastSegment = lastPathSegment(path, isPosixPathSeparator); + const strippedSegment = stripTrailingSeparators( + lastSegment, + isPosixPathSeparator, + ); + return suffix ? stripSuffix(strippedSegment, suffix) : strippedSegment; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/posix/common.ts b/src/vendor/deno.land/std@0.204.0/path/posix/common.ts new file mode 100644 index 00000000000..ae1bc581e56 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/posix/common.ts @@ -0,0 +1,21 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { _common } from "../_common/common.ts"; +import { SEP } from "./separator.ts"; + +/** 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: string[], sep = SEP): string { + return _common(paths, sep); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/posix/dirname.ts b/src/vendor/deno.land/std@0.204.0/path/posix/dirname.ts new file mode 100644 index 00000000000..4bcc61bd6f0 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/posix/dirname.ts @@ -0,0 +1,44 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { assertArg } from "../_common/dirname.ts"; +import { stripTrailingSeparators } from "../_common/strip_trailing_separators.ts"; +import { isPosixPathSeparator } from "./_util.ts"; + +/** + * Return the directory path of a `path`. + * @param path - path to extract the directory from. + */ +export function dirname(path: string): string { + assertArg(path); + + let end = -1; + let matchedNonSeparator = false; + + for (let i = path.length - 1; i >= 1; --i) { + if (isPosixPathSeparator(path.charCodeAt(i))) { + if (matchedNonSeparator) { + end = i; + break; + } + } else { + matchedNonSeparator = true; + } + } + + // No matches. Fallback based on provided path: + // + // - leading slashes paths + // "/foo" => "/" + // "///foo" => "/" + // - no slash path + // "foo" => "." + if (end === -1) { + return isPosixPathSeparator(path.charCodeAt(0)) ? "/" : "."; + } + + return stripTrailingSeparators( + path.slice(0, end), + isPosixPathSeparator, + ); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/posix/extname.ts b/src/vendor/deno.land/std@0.204.0/path/posix/extname.ts new file mode 100644 index 00000000000..0bac5360466 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/posix/extname.ts @@ -0,0 +1,62 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { CHAR_DOT } from "../_common/constants.ts"; +import { assertPath } from "../_common/assert_path.ts"; +import { isPosixPathSeparator } from "./_util.ts"; + +/** + * Return the extension of the `path` with leading period. + * @param path with extension + * @returns extension (ex. for `file.ts` returns `.ts`) + */ +export function extname(path: string): string { + assertPath(path); + + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + for (let i = path.length - 1; i >= 0; --i) { + const code = path.charCodeAt(i); + if (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) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + + if ( + startDot === -1 || + end === -1 || + // We saw a non-dot character immediately before the dot + preDotState === 0 || + // The (right-most) trimmed path component is exactly '..' + (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) + ) { + return ""; + } + return path.slice(startDot, end); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/posix/format.ts b/src/vendor/deno.land/std@0.204.0/path/posix/format.ts new file mode 100644 index 00000000000..954d99cf5c1 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/posix/format.ts @@ -0,0 +1,14 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { _format, assertArg } from "../_common/format.ts"; +import type { FormatInputPathObject } from "../_interface.ts"; + +/** + * Generate a path from `FormatInputPathObject` object. + * @param pathObject with path + */ +export function format(pathObject: FormatInputPathObject): string { + assertArg(pathObject); + return _format("/", pathObject); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/posix/from_file_url.ts b/src/vendor/deno.land/std@0.204.0/path/posix/from_file_url.ts new file mode 100644 index 00000000000..71edfe6052d --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/posix/from_file_url.ts @@ -0,0 +1,21 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { assertArg } from "../_common/from_file_url.ts"; + +/** + * 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 function fromFileUrl(url: URL | string): string { + url = assertArg(url); + return decodeURIComponent( + url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25"), + ); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/posix/glob.ts b/src/vendor/deno.land/std@0.204.0/path/posix/glob.ts new file mode 100644 index 00000000000..2c0e51c855a --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/posix/glob.ts @@ -0,0 +1,125 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { + _globToRegExp, + GlobConstants, + GlobOptions, + GlobToRegExpOptions, +} from "../_common/glob_to_reg_exp.ts"; +import { normalize } from "./normalize.ts"; +import { join } from "./join.ts"; +import { SEP, SEP_PATTERN } from "./separator.ts"; + +export { isGlob } from "../_common/is_glob.ts"; + +const constants: GlobConstants = { + sep: "/+", + sepMaybe: "/*", + seps: ["/"], + globstar: "(?:[^/]*(?:/|$)+)*", + wildcard: "[^/]*", + escapePrefix: "\\", +}; + +/** 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`. + * - `[[::]]` - Matches any character belonging to ``. + * - `[[: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: string, + options: GlobToRegExpOptions = {}, +): RegExp { + return _globToRegExp(constants, glob, options); +} + +/** Like normalize(), but doesn't collapse "**\/.." when `globstar` is true. */ +export function normalizeGlob( + glob: string, + { globstar = false }: GlobOptions = {}, +): string { + 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: string[], + { extended = true, globstar = false }: GlobOptions = {}, +): string { + if (!globstar || globs.length === 0) { + return join(...globs); + } + if (globs.length === 0) return "."; + let joined: string | undefined; + 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 }); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/posix/is_absolute.ts b/src/vendor/deno.land/std@0.204.0/path/posix/is_absolute.ts new file mode 100644 index 00000000000..5c6fd14ed89 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/posix/is_absolute.ts @@ -0,0 +1,14 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { assertPath } from "../_common/assert_path.ts"; +import { isPosixPathSeparator } from "./_util.ts"; + +/** + * Verifies whether provided path is absolute + * @param path to be verified as absolute + */ +export function isAbsolute(path: string): boolean { + assertPath(path); + return path.length > 0 && isPosixPathSeparator(path.charCodeAt(0)); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/posix/join.ts b/src/vendor/deno.land/std@0.204.0/path/posix/join.ts new file mode 100644 index 00000000000..69132ee00b9 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/posix/join.ts @@ -0,0 +1,25 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { assertPath } from "../_common/assert_path.ts"; +import { normalize } from "./normalize.ts"; + +/** + * Join all given a sequence of `paths`,then normalizes the resulting path. + * @param paths to be joined and normalized + */ +export function join(...paths: string[]): string { + if (paths.length === 0) return "."; + + let joined: string | undefined; + for (let i = 0, len = paths.length; i < len; ++i) { + const path = paths[i]; + assertPath(path); + if (path.length > 0) { + if (!joined) joined = path; + else joined += `/${path}`; + } + } + if (!joined) return "."; + return normalize(joined); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/posix/mod.ts b/src/vendor/deno.land/std@0.204.0/path/posix/mod.ts new file mode 100644 index 00000000000..a22e5d63b3f --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/posix/mod.ts @@ -0,0 +1,44 @@ +// 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. + +/** + * Utilities for working with OS-specific file paths. + * + * Codes in the examples uses POSIX path but it automatically use Windows path + * on Windows. Use methods under `posix` or `win32` object instead to handle non + * platform specific path like: + * ```ts + * import { posix, win32 } from "https://deno.land/std@$STD_VERSION/path/mod.ts"; + * const p1 = posix.fromFileUrl("file:///home/foo"); + * const p2 = win32.fromFileUrl("file:///home/foo"); + * console.log(p1); // "/home/foo" + * console.log(p2); // "\\home\\foo" + * ``` + * + * This module is browser compatible. + * + * @module + */ + +export const sep = "/"; +export const delimiter = ":"; + +export * from "./basename.ts"; +export * from "./dirname.ts"; +export * from "./extname.ts"; +export * from "./format.ts"; +export * from "./from_file_url.ts"; +export * from "./is_absolute.ts"; +export * from "./join.ts"; +export * from "./normalize.ts"; +export * from "./parse.ts"; +export * from "./relative.ts"; +export * from "./resolve.ts"; +export * from "./to_file_url.ts"; +export * from "./to_namespaced_path.ts"; +export * from "./common.ts"; +export * from "./separator.ts"; +export * from "../_interface.ts"; +export * from "../glob.ts"; diff --git a/src/vendor/deno.land/std@0.204.0/path/posix/normalize.ts b/src/vendor/deno.land/std@0.204.0/path/posix/normalize.ts new file mode 100644 index 00000000000..4c25f70219e --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/posix/normalize.ts @@ -0,0 +1,30 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { assertArg } from "../_common/normalize.ts"; +import { normalizeString } from "../_common/normalize_string.ts"; +import { isPosixPathSeparator } from "./_util.ts"; + +/** + * 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 function normalize(path: string): string { + assertArg(path); + + const isAbsolute = isPosixPathSeparator(path.charCodeAt(0)); + const trailingSeparator = isPosixPathSeparator( + path.charCodeAt(path.length - 1), + ); + + // Normalize the path + path = normalizeString(path, !isAbsolute, "/", isPosixPathSeparator); + + if (path.length === 0 && !isAbsolute) path = "."; + if (path.length > 0 && trailingSeparator) path += "/"; + + if (isAbsolute) return `/${path}`; + return path; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/posix/parse.ts b/src/vendor/deno.land/std@0.204.0/path/posix/parse.ts new file mode 100644 index 00000000000..89aae0c92ce --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/posix/parse.ts @@ -0,0 +1,102 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { CHAR_DOT } from "../_common/constants.ts"; +import { ParsedPath } from "../_interface.ts"; +import { stripTrailingSeparators } from "../_common/strip_trailing_separators.ts"; +import { assertPath } from "../_common/assert_path.ts"; +import { isPosixPathSeparator } from "./_util.ts"; + +/** + * Return a `ParsedPath` object of the `path`. + * @param path to process + */ +export function parse(path: string): ParsedPath { + assertPath(path); + + const ret: ParsedPath = { root: "", dir: "", base: "", ext: "", name: "" }; + if (path.length === 0) return ret; + const isAbsolute = isPosixPathSeparator(path.charCodeAt(0)); + let start: number; + if (isAbsolute) { + ret.root = "/"; + start = 1; + } else { + start = 0; + } + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + let i = path.length - 1; + + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + + // Get non-dir info + for (; i >= start; --i) { + const code = path.charCodeAt(i); + if (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) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + + if ( + startDot === -1 || + end === -1 || + // We saw a non-dot character immediately before the dot + preDotState === 0 || + // The (right-most) trimmed path component is exactly '..' + (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) + ) { + if (end !== -1) { + if (startPart === 0 && isAbsolute) { + ret.base = ret.name = path.slice(1, end); + } else { + 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) { + ret.name = path.slice(1, startDot); + ret.base = path.slice(1, end); + } else { + ret.name = path.slice(startPart, startDot); + ret.base = path.slice(startPart, end); + } + ret.ext = path.slice(startDot, end); + } + + if (startPart > 0) { + ret.dir = stripTrailingSeparators( + path.slice(0, startPart - 1), + isPosixPathSeparator, + ); + } else if (isAbsolute) ret.dir = "/"; + + return ret; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/posix/relative.ts b/src/vendor/deno.land/std@0.204.0/path/posix/relative.ts new file mode 100644 index 00000000000..abdb6f4fc7e --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/posix/relative.ts @@ -0,0 +1,91 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { isPosixPathSeparator } from "./_util.ts"; +import { resolve } from "./resolve.ts"; +import { assertArgs } from "../_common/relative.ts"; + +/** + * 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 function relative(from: string, to: string): string { + assertArgs(from, to); + + from = resolve(from); + to = resolve(to); + + if (from === to) return ""; + + // Trim any leading backslashes + let fromStart = 1; + const fromEnd = from.length; + for (; fromStart < fromEnd; ++fromStart) { + if (!isPosixPathSeparator(from.charCodeAt(fromStart))) break; + } + const fromLen = fromEnd - fromStart; + + // Trim any leading backslashes + let toStart = 1; + const toEnd = to.length; + for (; toStart < toEnd; ++toStart) { + if (!isPosixPathSeparator(to.charCodeAt(toStart))) break; + } + const toLen = toEnd - toStart; + + // Compare paths to find the longest common path from root + const length = fromLen < toLen ? fromLen : toLen; + let lastCommonSep = -1; + let i = 0; + for (; i <= length; ++i) { + if (i === length) { + if (toLen > length) { + if (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); + } else if (i === 0) { + // We get here if `from` is the root + // For example: from='/'; to='/foo' + return to.slice(toStart + i); + } + } else if (fromLen > length) { + if (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; + } else if (i === 0) { + // We get here if `to` is the root. + // For example: from='/foo'; to='/' + lastCommonSep = 0; + } + } + break; + } + const fromCode = from.charCodeAt(fromStart + i); + const toCode = to.charCodeAt(toStart + i); + if (fromCode !== toCode) break; + else if (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 || isPosixPathSeparator(from.charCodeAt(i))) { + if (out.length === 0) out += ".."; + else out += "/.."; + } + } + + // Lastly, append the rest of the destination (`to`) path that comes after + // the common path parts + if (out.length > 0) return out + to.slice(toStart + lastCommonSep); + else { + toStart += lastCommonSep; + if (isPosixPathSeparator(to.charCodeAt(toStart))) ++toStart; + return to.slice(toStart); + } +} diff --git a/src/vendor/deno.land/std@0.204.0/path/posix/resolve.ts b/src/vendor/deno.land/std@0.204.0/path/posix/resolve.ts new file mode 100644 index 00000000000..61ca4465156 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/posix/resolve.ts @@ -0,0 +1,56 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { normalizeString } from "../_common/normalize_string.ts"; +import { assertPath } from "../_common/assert_path.ts"; +import { isPosixPathSeparator } from "./_util.ts"; + +/** + * Resolves path segments into a `path` + * @param pathSegments to process to path + */ +export function resolve(...pathSegments: string[]): string { + let resolvedPath = ""; + let resolvedAbsolute = false; + + for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + let path: string; + + if (i >= 0) path = pathSegments[i]; + else { + // deno-lint-ignore no-explicit-any + const { Deno } = globalThis as any; + if (typeof Deno?.cwd !== "function") { + throw new TypeError("Resolved a relative path without a CWD."); + } + path = Deno.cwd(); + } + + assertPath(path); + + // Skip empty entries + if (path.length === 0) { + continue; + } + + resolvedPath = `${path}/${resolvedPath}`; + resolvedAbsolute = 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 Deno.cwd() fails) + + // Normalize the path + resolvedPath = normalizeString( + resolvedPath, + !resolvedAbsolute, + "/", + isPosixPathSeparator, + ); + + if (resolvedAbsolute) { + if (resolvedPath.length > 0) return `/${resolvedPath}`; + else return "/"; + } else if (resolvedPath.length > 0) return resolvedPath; + else return "."; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/posix/separator.ts b/src/vendor/deno.land/std@0.204.0/path/posix/separator.ts new file mode 100644 index 00000000000..b28cbfb4568 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/posix/separator.ts @@ -0,0 +1,5 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +export const SEP = "/"; +export const SEP_PATTERN = /\/+/; diff --git a/src/vendor/deno.land/std@0.204.0/path/posix/to_file_url.ts b/src/vendor/deno.land/std@0.204.0/path/posix/to_file_url.ts new file mode 100644 index 00000000000..7c333922ec2 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/posix/to_file_url.ts @@ -0,0 +1,27 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { encodeWhitespace } from "../_common/to_file_url.ts"; +import { isAbsolute } from "./is_absolute.ts"; + +/** + * 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 function toFileUrl(path: string) { + if (!isAbsolute(path)) { + throw new TypeError("Must be an absolute path."); + } + + const url = new URL("file:///"); + url.pathname = encodeWhitespace( + path.replace(/%/g, "%25").replace(/\\/g, "%5C"), + ); + return url; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/posix/to_namespaced_path.ts b/src/vendor/deno.land/std@0.204.0/path/posix/to_namespaced_path.ts new file mode 100644 index 00000000000..3d3f5b378a4 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/posix/to_namespaced_path.ts @@ -0,0 +1,11 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +/** + * Resolves path to a namespace path + * @param path to resolve to namespace + */ +export function toNamespacedPath(path: string): string { + // Non-op on posix systems + return path; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/relative.ts b/src/vendor/deno.land/std@0.204.0/path/relative.ts new file mode 100644 index 00000000000..d7946283bd5 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/relative.ts @@ -0,0 +1,21 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { isWindows } from "./_os.ts"; +import { relative as posixRelative } from "./posix/relative.ts"; +import { relative as windowsRelative } from "./windows/relative.ts"; + +/** + * Return the relative path from `from` to `to` based on current working directory. + * + * An example in windws, for instance: + * from = 'C:\\orandea\\test\\aaa' + * to = 'C:\\orandea\\impl\\bbb' + * The output of the function should be: '..\\..\\impl\\bbb' + * + * @param from path in current working directory + * @param to path in current working directory + */ +export function relative(from: string, to: string): string { + return isWindows ? windowsRelative(from, to) : posixRelative(from, to); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/resolve.ts b/src/vendor/deno.land/std@0.204.0/path/resolve.ts new file mode 100644 index 00000000000..5fede537c27 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/resolve.ts @@ -0,0 +1,16 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { isWindows } from "./_os.ts"; +import { resolve as posixResolve } from "./posix/resolve.ts"; +import { resolve as windowsResolve } from "./windows/resolve.ts"; + +/** + * Resolves path segments into a `path` + * @param pathSegments to process to path + */ +export function resolve(...pathSegments: string[]): string { + return isWindows + ? windowsResolve(...pathSegments) + : posixResolve(...pathSegments); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/separator.ts b/src/vendor/deno.land/std@0.204.0/path/separator.ts new file mode 100644 index 00000000000..b7b9faebf84 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/separator.ts @@ -0,0 +1,7 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { isWindows } from "./_os.ts"; + +export const SEP = isWindows ? "\\" : "/"; +export const SEP_PATTERN = isWindows ? /[\\/]+/ : /\/+/; diff --git a/src/vendor/deno.land/std@0.204.0/path/to_file_url.ts b/src/vendor/deno.land/std@0.204.0/path/to_file_url.ts new file mode 100644 index 00000000000..f40c23714c0 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/to_file_url.ts @@ -0,0 +1,26 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { isWindows } from "./_os.ts"; +import { toFileUrl as posixToFileUrl } from "./posix/to_file_url.ts"; +import { toFileUrl as windowsToFileUrl } from "./windows/to_file_url.ts"; + +/** + * Converts a path string to a file URL. + * + * ```ts + * import { toFileUrl } from "https://deno.land/std@$STD_VERSION/path/to_file_url.ts"; + * + * // posix + * toFileUrl("/home/foo"); // new URL("file:///home/foo") + * + * // win32 + * 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 function toFileUrl(path: string): URL { + return isWindows ? windowsToFileUrl(path) : posixToFileUrl(path); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/to_namespaced_path.ts b/src/vendor/deno.land/std@0.204.0/path/to_namespaced_path.ts new file mode 100644 index 00000000000..d5f9d8c700a --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/to_namespaced_path.ts @@ -0,0 +1,16 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { isWindows } from "./_os.ts"; +import { toNamespacedPath as posixToNamespacedPath } from "./posix/to_namespaced_path.ts"; +import { toNamespacedPath as windowsToNamespacedPath } from "./windows/to_namespaced_path.ts"; + +/** + * Resolves path to a namespace path + * @param path to resolve to namespace + */ +export function toNamespacedPath(path: string): string { + return isWindows + ? windowsToNamespacedPath(path) + : posixToNamespacedPath(path); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/windows/_util.ts b/src/vendor/deno.land/std@0.204.0/path/windows/_util.ts new file mode 100644 index 00000000000..06137020874 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/windows/_util.ts @@ -0,0 +1,28 @@ +// 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_FORWARD_SLASH, + CHAR_LOWERCASE_A, + CHAR_LOWERCASE_Z, + CHAR_UPPERCASE_A, + CHAR_UPPERCASE_Z, +} from "../_common/constants.ts"; + +export function isPosixPathSeparator(code: number): boolean { + return code === CHAR_FORWARD_SLASH; +} + +export function isPathSeparator(code: number): boolean { + return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH; +} + +export function isWindowsDeviceRoot(code: number): boolean { + return ( + (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z) || + (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z) + ); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/windows/basename.ts b/src/vendor/deno.land/std@0.204.0/path/windows/basename.ts new file mode 100644 index 00000000000..cc509323de9 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/windows/basename.ts @@ -0,0 +1,37 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { + assertArgs, + lastPathSegment, + stripSuffix, +} from "../_common/basename.ts"; +import { CHAR_COLON } from "../_common/constants.ts"; +import { stripTrailingSeparators } from "../_common/strip_trailing_separators.ts"; +import { isPathSeparator, isWindowsDeviceRoot } from "./_util.ts"; + +/** + * 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 function basename(path: string, suffix = ""): string { + assertArgs(path, suffix); + + // Check for a drive letter prefix so as not to mistake the following + // path separator as an extra separator at the end of the path that can be + // disregarded + let start = 0; + if (path.length >= 2) { + const drive = path.charCodeAt(0); + if (isWindowsDeviceRoot(drive)) { + if (path.charCodeAt(1) === CHAR_COLON) start = 2; + } + } + + const lastSegment = lastPathSegment(path, isPathSeparator, start); + const strippedSegment = stripTrailingSeparators(lastSegment, isPathSeparator); + return suffix ? stripSuffix(strippedSegment, suffix) : strippedSegment; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/windows/common.ts b/src/vendor/deno.land/std@0.204.0/path/windows/common.ts new file mode 100644 index 00000000000..ae1bc581e56 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/windows/common.ts @@ -0,0 +1,21 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { _common } from "../_common/common.ts"; +import { SEP } from "./separator.ts"; + +/** 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: string[], sep = SEP): string { + return _common(paths, sep); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/windows/dirname.ts b/src/vendor/deno.land/std@0.204.0/path/windows/dirname.ts new file mode 100644 index 00000000000..856d40871ce --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/windows/dirname.ts @@ -0,0 +1,103 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { assertArg } from "../_common/dirname.ts"; +import { CHAR_COLON } from "../_common/constants.ts"; +import { stripTrailingSeparators } from "../_common/strip_trailing_separators.ts"; +import { + isPathSeparator, + isPosixPathSeparator, + isWindowsDeviceRoot, +} from "./_util.ts"; + +/** + * Return the directory path of a `path`. + * @param path - path to extract the directory from. + */ +export function dirname(path: string): string { + assertArg(path); + + const len = path.length; + let rootEnd = -1; + let end = -1; + let matchedSlash = true; + let offset = 0; + const code = path.charCodeAt(0); + + // Try to match a root + if (len > 1) { + if (isPathSeparator(code)) { + // Possible UNC root + + rootEnd = offset = 1; + + if (isPathSeparator(path.charCodeAt(1))) { + // Matched double path separator at beginning + let j = 2; + let last = j; + // Match 1 or more non-path separators + for (; j < len; ++j) { + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + // Matched! + last = j; + // Match 1 or more path separators + for (; j < len; ++j) { + if (!isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + // Matched! + last = j; + // Match 1 or more non-path separators + for (; j < len; ++j) { + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j === len) { + // We matched a UNC root only + return path; + } + if (j !== last) { + // We matched a UNC root with leftovers + + // Offset by 1 to include the separator after the UNC root to + // treat it as a "normal root" on top of a (UNC) root + rootEnd = offset = j + 1; + } + } + } + } + } else if (isWindowsDeviceRoot(code)) { + // Possible device root + + if (path.charCodeAt(1) === CHAR_COLON) { + rootEnd = offset = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) rootEnd = offset = 3; + } + } + } + } else if (isPathSeparator(code)) { + // `path` contains just a path separator, exit early to avoid + // unnecessary work + return path; + } + + for (let i = len - 1; i >= offset; --i) { + if (isPathSeparator(path.charCodeAt(i))) { + if (!matchedSlash) { + end = i; + break; + } + } else { + // We saw the first non-path separator + matchedSlash = false; + } + } + + if (end === -1) { + if (rootEnd === -1) return "."; + else end = rootEnd; + } + return stripTrailingSeparators(path.slice(0, end), isPosixPathSeparator); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/windows/extname.ts b/src/vendor/deno.land/std@0.204.0/path/windows/extname.ts new file mode 100644 index 00000000000..8b325c59e2f --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/windows/extname.ts @@ -0,0 +1,76 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { CHAR_COLON, CHAR_DOT } from "../_common/constants.ts"; +import { assertPath } from "../_common/assert_path.ts"; +import { isPathSeparator, isWindowsDeviceRoot } from "./_util.ts"; + +/** + * Return the extension of the `path` with leading period. + * @param path with extension + * @returns extension (ex. for `file.ts` returns `.ts`) + */ +export function extname(path: string): string { + assertPath(path); + + let start = 0; + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + + // Check for a drive letter prefix so as not to mistake the following + // path separator as an extra separator at the end of the path that can be + // disregarded + + if ( + path.length >= 2 && + path.charCodeAt(1) === CHAR_COLON && + isWindowsDeviceRoot(path.charCodeAt(0)) + ) { + start = startPart = 2; + } + + for (let i = path.length - 1; i >= start; --i) { + const code = path.charCodeAt(i); + if (isPathSeparator(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) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + + if ( + startDot === -1 || + end === -1 || + // We saw a non-dot character immediately before the dot + preDotState === 0 || + // The (right-most) trimmed path component is exactly '..' + (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) + ) { + return ""; + } + return path.slice(startDot, end); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/windows/format.ts b/src/vendor/deno.land/std@0.204.0/path/windows/format.ts new file mode 100644 index 00000000000..3b0e555ee0e --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/windows/format.ts @@ -0,0 +1,14 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { _format, assertArg } from "../_common/format.ts"; +import type { FormatInputPathObject } from "../_interface.ts"; + +/** + * Generate a path from `FormatInputPathObject` object. + * @param pathObject with path + */ +export function format(pathObject: FormatInputPathObject): string { + assertArg(pathObject); + return _format("\\", pathObject); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/windows/from_file_url.ts b/src/vendor/deno.land/std@0.204.0/path/windows/from_file_url.ts new file mode 100644 index 00000000000..fd907efe52e --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/windows/from_file_url.ts @@ -0,0 +1,30 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { assertArg } from "../_common/from_file_url.ts"; + +/** + * 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 function fromFileUrl(url: URL | string): string { + url = assertArg(url); + let path = decodeURIComponent( + url.pathname.replace(/\//g, "\\").replace(/%(?![0-9A-Fa-f]{2})/g, "%25"), + ).replace(/^\\*([A-Za-z]:)(\\|$)/, "$1\\"); + if (url.hostname !== "") { + // Note: The `URL` implementation guarantees that the drive letter and + // hostname are mutually exclusive. Otherwise it would not have been valid + // to append the hostname and path like this. + path = `\\\\${url.hostname}${path}`; + } + return path; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/windows/glob.ts b/src/vendor/deno.land/std@0.204.0/path/windows/glob.ts new file mode 100644 index 00000000000..1a8286c6b46 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/windows/glob.ts @@ -0,0 +1,124 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { + _globToRegExp, + GlobConstants, + GlobOptions, + GlobToRegExpOptions, +} from "../_common/glob_to_reg_exp.ts"; +import { normalize } from "./normalize.ts"; +import { join } from "./join.ts"; +import { SEP, SEP_PATTERN } from "./separator.ts"; +export { isGlob } from "../_common/is_glob.ts"; + +const constants: GlobConstants = { + sep: "(?:\\\\|/)+", + sepMaybe: "(?:\\\\|/)*", + seps: ["\\", "/"], + globstar: "(?:[^\\\\/]*(?:\\\\|/|$)+)*", + wildcard: "[^\\\\/]*", + escapePrefix: "`", +}; + +/** 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`. + * - `[[::]]` - Matches any character belonging to ``. + * - `[[: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: string, + options: GlobToRegExpOptions = {}, +): RegExp { + return _globToRegExp(constants, glob, options); +} + +/** Like normalize(), but doesn't collapse "**\/.." when `globstar` is true. */ +export function normalizeGlob( + glob: string, + { globstar = false }: GlobOptions = {}, +): string { + 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: string[], + { extended = true, globstar = false }: GlobOptions = {}, +): string { + if (!globstar || globs.length === 0) { + return join(...globs); + } + if (globs.length === 0) return "."; + let joined: string | undefined; + 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 }); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/windows/is_absolute.ts b/src/vendor/deno.land/std@0.204.0/path/windows/is_absolute.ts new file mode 100644 index 00000000000..17af3b024b0 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/windows/is_absolute.ts @@ -0,0 +1,29 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { CHAR_COLON } from "../_common/constants.ts"; +import { assertPath } from "../_common/assert_path.ts"; +import { isPathSeparator, isWindowsDeviceRoot } from "./_util.ts"; + +/** + * Verifies whether provided path is absolute + * @param path to be verified as absolute + */ +export function isAbsolute(path: string): boolean { + assertPath(path); + + const len = path.length; + if (len === 0) return false; + + const code = path.charCodeAt(0); + if (isPathSeparator(code)) { + return true; + } else if (isWindowsDeviceRoot(code)) { + // Possible device root + + if (len > 2 && path.charCodeAt(1) === CHAR_COLON) { + if (isPathSeparator(path.charCodeAt(2))) return true; + } + } + return false; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/windows/join.ts b/src/vendor/deno.land/std@0.204.0/path/windows/join.ts new file mode 100644 index 00000000000..513c5f510a7 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/windows/join.ts @@ -0,0 +1,72 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { assert } from "../../assert/assert.ts"; +import { assertPath } from "../_common/assert_path.ts"; +import { isPathSeparator } from "./_util.ts"; +import { normalize } from "./normalize.ts"; + +/** + * Join all given a sequence of `paths`,then normalizes the resulting path. + * @param paths to be joined and normalized + */ +export function join(...paths: string[]): string { + if (paths.length === 0) return "."; + + let joined: string | undefined; + let firstPart: string | null = null; + for (let i = 0; i < paths.length; ++i) { + const path = paths[i]; + assertPath(path); + if (path.length > 0) { + if (joined === undefined) joined = firstPart = path; + else joined += `\\${path}`; + } + } + + if (joined === undefined) return "."; + + // Make sure that the joined path doesn't start with two slashes, because + // normalize() will mistake it for an UNC path then. + // + // This step is skipped when it is very clear that the user actually + // intended to point at an UNC path. This is assumed when the first + // non-empty string arguments starts with exactly two slashes followed by + // at least one more non-slash character. + // + // Note that for normalize() to treat a path as an UNC path it needs to + // have at least 2 components, so we don't filter for that here. + // This means that the user can use join to construct UNC paths from + // a server name and a share name; for example: + // path.join('//server', 'share') -> '\\\\server\\share\\') + let needsReplace = true; + let slashCount = 0; + assert(firstPart !== null); + if (isPathSeparator(firstPart.charCodeAt(0))) { + ++slashCount; + const firstLen = firstPart.length; + if (firstLen > 1) { + if (isPathSeparator(firstPart.charCodeAt(1))) { + ++slashCount; + if (firstLen > 2) { + if (isPathSeparator(firstPart.charCodeAt(2))) ++slashCount; + else { + // We matched a UNC path in the first part + needsReplace = false; + } + } + } + } + } + if (needsReplace) { + // Find any more consecutive slashes we need to replace + for (; slashCount < joined.length; ++slashCount) { + if (!isPathSeparator(joined.charCodeAt(slashCount))) break; + } + + // Replace the slashes if needed + if (slashCount >= 2) joined = `\\${joined.slice(slashCount)}`; + } + + return normalize(joined); +} diff --git a/src/vendor/deno.land/std@0.204.0/path/windows/mod.ts b/src/vendor/deno.land/std@0.204.0/path/windows/mod.ts new file mode 100644 index 00000000000..bb864cb2a58 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/windows/mod.ts @@ -0,0 +1,44 @@ +// 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. + +/** + * Utilities for working with OS-specific file paths. + * + * Codes in the examples uses POSIX path but it automatically use Windows path + * on Windows. Use methods under `posix` or `win32` object instead to handle non + * platform specific path like: + * ```ts + * import { posix, win32 } from "https://deno.land/std@$STD_VERSION/path/mod.ts"; + * const p1 = posix.fromFileUrl("file:///home/foo"); + * const p2 = win32.fromFileUrl("file:///home/foo"); + * console.log(p1); // "/home/foo" + * console.log(p2); // "\\home\\foo" + * ``` + * + * This module is browser compatible. + * + * @module + */ + +export const sep = "\\"; +export const delimiter = ";"; + +export * from "./basename.ts"; +export * from "./dirname.ts"; +export * from "./extname.ts"; +export * from "./format.ts"; +export * from "./from_file_url.ts"; +export * from "./is_absolute.ts"; +export * from "./join.ts"; +export * from "./normalize.ts"; +export * from "./parse.ts"; +export * from "./relative.ts"; +export * from "./resolve.ts"; +export * from "./to_file_url.ts"; +export * from "./to_namespaced_path.ts"; +export * from "./common.ts"; +export * from "./separator.ts"; +export * from "../_interface.ts"; +export * from "../glob.ts"; diff --git a/src/vendor/deno.land/std@0.204.0/path/windows/normalize.ts b/src/vendor/deno.land/std@0.204.0/path/windows/normalize.ts new file mode 100644 index 00000000000..fd2400425a5 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/windows/normalize.ts @@ -0,0 +1,127 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { assertArg } from "../_common/normalize.ts"; +import { CHAR_COLON } from "../_common/constants.ts"; +import { normalizeString } from "../_common/normalize_string.ts"; +import { isPathSeparator, isWindowsDeviceRoot } from "./_util.ts"; + +/** + * 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 function normalize(path: string): string { + assertArg(path); + + const len = path.length; + let rootEnd = 0; + let device: string | undefined; + let isAbsolute = false; + const code = path.charCodeAt(0); + + // Try to match a root + if (len > 1) { + if (isPathSeparator(code)) { + // Possible UNC root + + // If we started with a separator, we know we at least have an absolute + // path of some kind (UNC or otherwise) + isAbsolute = true; + + if (isPathSeparator(path.charCodeAt(1))) { + // Matched double path separator at beginning + let j = 2; + let last = j; + // Match 1 or more non-path separators + for (; j < len; ++j) { + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + const firstPart = path.slice(last, j); + // Matched! + last = j; + // Match 1 or more path separators + for (; j < len; ++j) { + if (!isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + // Matched! + last = j; + // Match 1 or more non-path separators + for (; j < len; ++j) { + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j === len) { + // We matched a UNC root only + // Return the normalized version of the UNC root since there + // is nothing left to process + + return `\\\\${firstPart}\\${path.slice(last)}\\`; + } else if (j !== last) { + // We matched a UNC root with leftovers + + device = `\\\\${firstPart}\\${path.slice(last, j)}`; + rootEnd = j; + } + } + } + } else { + rootEnd = 1; + } + } else if (isWindowsDeviceRoot(code)) { + // Possible device root + + if (path.charCodeAt(1) === CHAR_COLON) { + device = path.slice(0, 2); + rootEnd = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) { + // Treat separator following drive name as an absolute path + // indicator + isAbsolute = true; + rootEnd = 3; + } + } + } + } + } else if (isPathSeparator(code)) { + // `path` contains just a path separator, exit early to avoid unnecessary + // work + return "\\"; + } + + let tail: string; + if (rootEnd < len) { + tail = normalizeString( + path.slice(rootEnd), + !isAbsolute, + "\\", + isPathSeparator, + ); + } else { + tail = ""; + } + if (tail.length === 0 && !isAbsolute) tail = "."; + if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) { + tail += "\\"; + } + if (device === undefined) { + if (isAbsolute) { + if (tail.length > 0) return `\\${tail}`; + else return "\\"; + } else if (tail.length > 0) { + return tail; + } else { + return ""; + } + } else if (isAbsolute) { + if (tail.length > 0) return `${device}\\${tail}`; + else return `${device}\\`; + } else if (tail.length > 0) { + return device + tail; + } else { + return device; + } +} diff --git a/src/vendor/deno.land/std@0.204.0/path/windows/parse.ts b/src/vendor/deno.land/std@0.204.0/path/windows/parse.ts new file mode 100644 index 00000000000..ef26b47a196 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/windows/parse.ts @@ -0,0 +1,165 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { CHAR_COLON, CHAR_DOT } from "../_common/constants.ts"; +import { ParsedPath } from "../_interface.ts"; +import { assertPath } from "../_common/assert_path.ts"; +import { isPathSeparator, isWindowsDeviceRoot } from "./_util.ts"; + +/** + * Return a `ParsedPath` object of the `path`. + * @param path to process + */ +export function parse(path: string): ParsedPath { + assertPath(path); + + const ret: ParsedPath = { root: "", dir: "", base: "", ext: "", name: "" }; + + const len = path.length; + if (len === 0) return ret; + + let rootEnd = 0; + let code = path.charCodeAt(0); + + // Try to match a root + if (len > 1) { + if (isPathSeparator(code)) { + // Possible UNC root + + rootEnd = 1; + if (isPathSeparator(path.charCodeAt(1))) { + // Matched double path separator at beginning + let j = 2; + let last = j; + // Match 1 or more non-path separators + for (; j < len; ++j) { + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + // Matched! + last = j; + // Match 1 or more path separators + for (; j < len; ++j) { + if (!isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + // Matched! + last = j; + // Match 1 or more non-path separators + for (; j < len; ++j) { + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j === len) { + // We matched a UNC root only + + rootEnd = j; + } else if (j !== last) { + // We matched a UNC root with leftovers + + rootEnd = j + 1; + } + } + } + } + } else if (isWindowsDeviceRoot(code)) { + // Possible device root + + if (path.charCodeAt(1) === CHAR_COLON) { + rootEnd = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) { + if (len === 3) { + // `path` contains just a drive root, exit early to avoid + // unnecessary work + ret.root = ret.dir = path; + ret.base = "\\"; + return ret; + } + rootEnd = 3; + } + } else { + // `path` contains just a relative drive root, exit early to avoid + // unnecessary work + ret.root = ret.dir = path; + return ret; + } + } + } + } else if (isPathSeparator(code)) { + // `path` contains just a path separator, exit early to avoid + // unnecessary work + ret.root = ret.dir = path; + ret.base = "\\"; + return ret; + } + + if (rootEnd > 0) ret.root = path.slice(0, rootEnd); + + let startDot = -1; + let startPart = rootEnd; + let end = -1; + let matchedSlash = true; + let i = path.length - 1; + + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + + // Get non-dir info + for (; i >= rootEnd; --i) { + code = path.charCodeAt(i); + if (isPathSeparator(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) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + + if ( + startDot === -1 || + end === -1 || + // We saw a non-dot character immediately before the dot + preDotState === 0 || + // The (right-most) trimmed path component is exactly '..' + (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) + ) { + if (end !== -1) { + ret.base = ret.name = path.slice(startPart, end); + } + } else { + ret.name = path.slice(startPart, startDot); + ret.base = path.slice(startPart, end); + ret.ext = path.slice(startDot, end); + } + + // Fallback to '\' in case there is no basename + ret.base = ret.base || "\\"; + + // If the directory is the root, use the entire root as the `dir` including + // the trailing slash if any (`C:\abc` -> `C:\`). Otherwise, strip out the + // trailing slash (`C:\abc\def` -> `C:\abc`). + if (startPart > 0 && startPart !== rootEnd) { + ret.dir = path.slice(0, startPart - 1); + } else ret.dir = ret.root; + + return ret; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/windows/relative.ts b/src/vendor/deno.land/std@0.204.0/path/windows/relative.ts new file mode 100644 index 00000000000..c8c4bb9084f --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/windows/relative.ts @@ -0,0 +1,118 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { CHAR_BACKWARD_SLASH } from "../_common/constants.ts"; +import { resolve } from "./resolve.ts"; +import { assertArgs } from "../_common/relative.ts"; + +/** + * Return the relative path from `from` to `to` based on current working directory. + * + * An example in windws, for instance: + * from = 'C:\\orandea\\test\\aaa' + * to = 'C:\\orandea\\impl\\bbb' + * The output of the function should be: '..\\..\\impl\\bbb' + * + * @param from path in current working directory + * @param to path in current working directory + */ +export function relative(from: string, to: string): string { + assertArgs(from, to); + + const fromOrig = resolve(from); + const toOrig = resolve(to); + + if (fromOrig === toOrig) return ""; + + from = fromOrig.toLowerCase(); + to = toOrig.toLowerCase(); + + if (from === to) return ""; + + // Trim any leading backslashes + let fromStart = 0; + let fromEnd = from.length; + for (; fromStart < fromEnd; ++fromStart) { + if (from.charCodeAt(fromStart) !== CHAR_BACKWARD_SLASH) break; + } + // Trim trailing backslashes (applicable to UNC paths only) + for (; fromEnd - 1 > fromStart; --fromEnd) { + if (from.charCodeAt(fromEnd - 1) !== CHAR_BACKWARD_SLASH) break; + } + const fromLen = fromEnd - fromStart; + + // Trim any leading backslashes + let toStart = 0; + let toEnd = to.length; + for (; toStart < toEnd; ++toStart) { + if (to.charCodeAt(toStart) !== CHAR_BACKWARD_SLASH) break; + } + // Trim trailing backslashes (applicable to UNC paths only) + for (; toEnd - 1 > toStart; --toEnd) { + if (to.charCodeAt(toEnd - 1) !== CHAR_BACKWARD_SLASH) break; + } + const toLen = toEnd - toStart; + + // Compare paths to find the longest common path from root + const length = fromLen < toLen ? fromLen : toLen; + let lastCommonSep = -1; + let i = 0; + for (; i <= length; ++i) { + if (i === length) { + if (toLen > length) { + if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) { + // We get here if `from` is the exact base path for `to`. + // For example: from='C:\\foo\\bar'; to='C:\\foo\\bar\\baz' + return toOrig.slice(toStart + i + 1); + } else if (i === 2) { + // We get here if `from` is the device root. + // For example: from='C:\\'; to='C:\\foo' + return toOrig.slice(toStart + i); + } + } + if (fromLen > length) { + if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) { + // We get here if `to` is the exact base path for `from`. + // For example: from='C:\\foo\\bar'; to='C:\\foo' + lastCommonSep = i; + } else if (i === 2) { + // We get here if `to` is the device root. + // For example: from='C:\\foo\\bar'; to='C:\\' + lastCommonSep = 3; + } + } + break; + } + const fromCode = from.charCodeAt(fromStart + i); + const toCode = to.charCodeAt(toStart + i); + if (fromCode !== toCode) break; + else if (fromCode === CHAR_BACKWARD_SLASH) lastCommonSep = i; + } + + // We found a mismatch before the first common path separator was seen, so + // return the original `to`. + if (i !== length && lastCommonSep === -1) { + return toOrig; + } + + let out = ""; + if (lastCommonSep === -1) lastCommonSep = 0; + // 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) === CHAR_BACKWARD_SLASH) { + if (out.length === 0) out += ".."; + else out += "\\.."; + } + } + + // Lastly, append the rest of the destination (`to`) path that comes after + // the common path parts + if (out.length > 0) { + return out + toOrig.slice(toStart + lastCommonSep, toEnd); + } else { + toStart += lastCommonSep; + if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) ++toStart; + return toOrig.slice(toStart, toEnd); + } +} diff --git a/src/vendor/deno.land/std@0.204.0/path/windows/resolve.ts b/src/vendor/deno.land/std@0.204.0/path/windows/resolve.ts new file mode 100644 index 00000000000..969b998e3d2 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/windows/resolve.ts @@ -0,0 +1,161 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { CHAR_COLON } from "../_common/constants.ts"; +import { normalizeString } from "../_common/normalize_string.ts"; +import { assertPath } from "../_common/assert_path.ts"; +import { isPathSeparator, isWindowsDeviceRoot } from "./_util.ts"; + +/** + * Resolves path segments into a `path` + * @param pathSegments to process to path + */ +export function resolve(...pathSegments: string[]): string { + let resolvedDevice = ""; + let resolvedTail = ""; + let resolvedAbsolute = false; + + for (let i = pathSegments.length - 1; i >= -1; i--) { + let path: string; + // deno-lint-ignore no-explicit-any + const { Deno } = globalThis as any; + if (i >= 0) { + path = pathSegments[i]; + } else if (!resolvedDevice) { + if (typeof Deno?.cwd !== "function") { + throw new TypeError("Resolved a drive-letter-less path without a CWD."); + } + path = Deno.cwd(); + } else { + if ( + typeof Deno?.env?.get !== "function" || typeof Deno?.cwd !== "function" + ) { + throw new TypeError("Resolved a relative path without a CWD."); + } + path = Deno.cwd(); + + // Verify that a cwd was found and that it actually points + // to our drive. If not, default to the drive's root. + if ( + path === undefined || + path.slice(0, 3).toLowerCase() !== `${resolvedDevice.toLowerCase()}\\` + ) { + path = `${resolvedDevice}\\`; + } + } + + assertPath(path); + + const len = path.length; + + // Skip empty entries + if (len === 0) continue; + + let rootEnd = 0; + let device = ""; + let isAbsolute = false; + const code = path.charCodeAt(0); + + // Try to match a root + if (len > 1) { + if (isPathSeparator(code)) { + // Possible UNC root + + // If we started with a separator, we know we at least have an + // absolute path of some kind (UNC or otherwise) + isAbsolute = true; + + if (isPathSeparator(path.charCodeAt(1))) { + // Matched double path separator at beginning + let j = 2; + let last = j; + // Match 1 or more non-path separators + for (; j < len; ++j) { + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + const firstPart = path.slice(last, j); + // Matched! + last = j; + // Match 1 or more path separators + for (; j < len; ++j) { + if (!isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + // Matched! + last = j; + // Match 1 or more non-path separators + for (; j < len; ++j) { + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j === len) { + // We matched a UNC root only + device = `\\\\${firstPart}\\${path.slice(last)}`; + rootEnd = j; + } else if (j !== last) { + // We matched a UNC root with leftovers + + device = `\\\\${firstPart}\\${path.slice(last, j)}`; + rootEnd = j; + } + } + } + } else { + rootEnd = 1; + } + } else if (isWindowsDeviceRoot(code)) { + // Possible device root + + if (path.charCodeAt(1) === CHAR_COLON) { + device = path.slice(0, 2); + rootEnd = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) { + // Treat separator following drive name as an absolute path + // indicator + isAbsolute = true; + rootEnd = 3; + } + } + } + } + } else if (isPathSeparator(code)) { + // `path` contains just a path separator + rootEnd = 1; + isAbsolute = true; + } + + if ( + device.length > 0 && + resolvedDevice.length > 0 && + device.toLowerCase() !== resolvedDevice.toLowerCase() + ) { + // This path points to another device so it is not applicable + continue; + } + + if (resolvedDevice.length === 0 && device.length > 0) { + resolvedDevice = device; + } + if (!resolvedAbsolute) { + resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`; + resolvedAbsolute = isAbsolute; + } + + if (resolvedAbsolute && resolvedDevice.length > 0) break; + } + + // At this point the path should be resolved to a full absolute path, + // but handle relative paths to be safe (might happen when Deno.cwd() + // fails) + + // Normalize the tail path + resolvedTail = normalizeString( + resolvedTail, + !resolvedAbsolute, + "\\", + isPathSeparator, + ); + + return resolvedDevice + (resolvedAbsolute ? "\\" : "") + resolvedTail || "."; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/windows/separator.ts b/src/vendor/deno.land/std@0.204.0/path/windows/separator.ts new file mode 100644 index 00000000000..4c405f71e96 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/windows/separator.ts @@ -0,0 +1,5 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +export const SEP = "\\"; +export const SEP_PATTERN = /[\\/]+/; diff --git a/src/vendor/deno.land/std@0.204.0/path/windows/to_file_url.ts b/src/vendor/deno.land/std@0.204.0/path/windows/to_file_url.ts new file mode 100644 index 00000000000..fe6430d9345 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/windows/to_file_url.ts @@ -0,0 +1,36 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { encodeWhitespace } from "../_common/to_file_url.ts"; +import { isAbsolute } from "./is_absolute.ts"; + +/** + * 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 function toFileUrl(path: string): URL { + if (!isAbsolute(path)) { + throw new TypeError("Must be an absolute path."); + } + + const [, hostname, pathname] = path.match( + /^(?:[/\\]{2}([^/\\]+)(?=[/\\](?:[^/\\]|$)))?(.*)/, + )!; + const url = new URL("file:///"); + url.pathname = encodeWhitespace(pathname.replace(/%/g, "%25")); + if (hostname !== undefined && hostname !== "localhost") { + url.hostname = hostname; + if (!url.hostname) { + throw new TypeError("Invalid hostname."); + } + } + return url; +} diff --git a/src/vendor/deno.land/std@0.204.0/path/windows/to_namespaced_path.ts b/src/vendor/deno.land/std@0.204.0/path/windows/to_namespaced_path.ts new file mode 100644 index 00000000000..acc404e4a32 --- /dev/null +++ b/src/vendor/deno.land/std@0.204.0/path/windows/to_namespaced_path.ts @@ -0,0 +1,49 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. + +import { + CHAR_BACKWARD_SLASH, + CHAR_COLON, + CHAR_DOT, + CHAR_QUESTION_MARK, +} from "../_common/constants.ts"; +import { isWindowsDeviceRoot } from "./_util.ts"; +import { resolve } from "./resolve.ts"; + +/** + * Resolves path to a namespace path + * @param path to resolve to namespace + */ +export function toNamespacedPath(path: string): string { + // Note: this will *probably* throw somewhere. + if (typeof path !== "string") return path; + if (path.length === 0) return ""; + + const resolvedPath = resolve(path); + + if (resolvedPath.length >= 3) { + if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) { + // Possible UNC root + + if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) { + const code = resolvedPath.charCodeAt(2); + if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) { + // Matched non-long UNC root, convert the path to a long UNC path + return `\\\\?\\UNC\\${resolvedPath.slice(2)}`; + } + } + } else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) { + // Possible device root + + if ( + resolvedPath.charCodeAt(1) === CHAR_COLON && + resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH + ) { + // Matched device root, convert the path to a long UNC path + return `\\\\?\\${resolvedPath}`; + } + } + } + + return path; +}