Something went wrong. Try again.
Monorepo for the nibling.run platform
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743// Derived from Node.js v24.16.0 (MIT; Copyright Node.js contributors, and Joyent, Inc. and// other Node contributors). See LICENSE-node.// path.win32, after Node v24's lib/path.js. Despite the name this is pure string logic —// no filesystem calls, no OS check beyond "are we literally running on Windows" — so it// runs the same on every host, including this one. Node's own win32 module keeps running// when Node itself runs on macOS/Linux (isWindows is a host check, not a module guard);// we are always in that "win32 module on a non-Windows host" situation, so `isWindows` is// hard-coded false below, matching what Node does on any POSIX host today.import { invalidArgType } from "./errors";import { matchesGlob as posixMatchesGlob } from "./path";
const CHAR_UPPERCASE_A = 65;const CHAR_LOWERCASE_A = 97;const CHAR_UPPERCASE_Z = 90;const CHAR_LOWERCASE_Z = 122;const CHAR_DOT = 46;const CHAR_FORWARD_SLASH = 47;const CHAR_BACKWARD_SLASH = 92;const CHAR_COLON = 58;const CHAR_QUESTION_MARK = 63;
function isPathSeparator(code: number): boolean { return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;}
function isPosixPathSeparator(code: number): boolean { return code === CHAR_FORWARD_SLASH;}
const WINDOWS_RESERVED_NAMES = [ "CON", "PRN", "AUX", "NUL", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9", "COM\xb9", "COM\xb2", "COM\xb3", "LPT\xb9", "LPT\xb2", "LPT\xb3",];
function isWindowsReservedName(path: string, colonIndex: number): boolean { const devicePart = path.slice(0, colonIndex).toUpperCase(); return WINDOWS_RESERVED_NAMES.includes(devicePart);}
function isWindowsDeviceRoot(code: number): boolean { return (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z) || (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z);}
/** Resolves "." and ".." path segments, generic over the separator: win32 keeps both * "/" and "\\" as separators while it normalizes, but only ever emits "\\". */function normalizeString(path: string, allowAboveRoot: boolean, separator: string, isSep: (code: number) => boolean): string { let res = ""; let lastSegmentLength = 0; let lastSlash = -1; let dots = 0; let code = 0; for (let i = 0; i <= path.length; ++i) { if (i < path.length) code = path.charCodeAt(i); else if (isSep(code)) break; else code = CHAR_FORWARD_SLASH;
if (isSep(code)) { if (lastSlash === i - 1 || dots === 1) { // NOOP } else if (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.length - lastSegmentLength - 1; 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 !== 0) { res = ""; lastSegmentLength = 0; lastSlash = i; dots = 0; continue; } } if (allowAboveRoot) { res += res.length > 0 ? `${separator}..` : ".."; 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;}
function formatExt(ext: string): string { return ext ? `${ext[0] === "." ? "" : "."}${ext}` : "";}
function validateString(value: unknown, name: string): asserts value is string { if (typeof value !== "string") throw invalidArgType(name, "of type string", value);}
function validateObject(value: unknown, name: string): void { if (value === null || typeof value !== "object" || Array.isArray(value)) { throw invalidArgType(name, "of type object", value); }}
interface ParsedPath { root: string; dir: string; base: string; ext: string; name: string }
const forwardSlashRegExp = /\//g;
/** On any host other than Windows, Node still runs this module exactly as written — * it is the host, not the module, that is never Windows here. */const isWindows = false;
export function makeWin32Path(cwd: () => string, env: () => Record<string, string | undefined>) { const win32 = { resolve(...args: string[]): string { let resolvedDevice = ""; let resolvedTail = ""; let resolvedAbsolute = false;
for (let i = args.length - 1; i >= -1; i--) { let path: string; if (i >= 0) { path = args[i]!; validateString(path, `paths[${i}]`); if (path.length === 0) continue; } else if (resolvedDevice.length === 0) { path = cwd(); if (args.length === 0 || ((args.length === 1 && (args[0] === "" || args[0] === ".")) && isPathSeparator(path.charCodeAt(0)))) { if (!isWindows) path = path.replace(forwardSlashRegExp, "\\"); return path; } } else { path = env()[`=${resolvedDevice}`] ?? cwd(); if (path === undefined || (path.slice(0, 2).toLowerCase() !== resolvedDevice.toLowerCase() && path.charCodeAt(2) === CHAR_BACKWARD_SLASH)) { path = `${resolvedDevice}\\`; } }
const len = path.length; let rootEnd = 0; let device = ""; let isAbsolute = false; const code = path.charCodeAt(0);
if (len === 1) { if (isPathSeparator(code)) { rootEnd = 1; isAbsolute = true; } } else if (isPathSeparator(code)) { isAbsolute = true; if (isPathSeparator(path.charCodeAt(1))) { let j = 2; let last = j; while (j < len && !isPathSeparator(path.charCodeAt(j))) j++; if (j < len && j !== last) { const firstPart = path.slice(last, j); last = j; while (j < len && isPathSeparator(path.charCodeAt(j))) j++; if (j < len && j !== last) { last = j; while (j < len && !isPathSeparator(path.charCodeAt(j))) j++; if (j === len || j !== last) { if (firstPart !== "." && firstPart !== "?") { device = `\\\\${firstPart}\\${path.slice(last, j)}`; rootEnd = j; } else { device = `\\\\${firstPart}`; rootEnd = 4; } } } } } else { rootEnd = 1; } } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) { device = path.slice(0, 2); rootEnd = 2; if (len > 2 && isPathSeparator(path.charCodeAt(2))) { isAbsolute = true; rootEnd = 3; } }
if (device.length > 0) { if (resolvedDevice.length > 0) { if (device.toLowerCase() !== resolvedDevice.toLowerCase()) continue; } else { resolvedDevice = device; } }
if (resolvedAbsolute) { if (resolvedDevice.length > 0) break; } else { resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`; resolvedAbsolute = isAbsolute; if (isAbsolute && resolvedDevice.length > 0) break; } }
resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, "\\", isPathSeparator);
return resolvedAbsolute ? `${resolvedDevice}\\${resolvedTail}` : `${resolvedDevice}${resolvedTail}` || "."; },
normalize(path: string): string { validateString(path, "path"); const len = path.length; if (len === 0) return "."; let rootEnd = 0; let device: string | undefined; let isAbsolute = false; const code = path.charCodeAt(0);
if (len === 1) return isPosixPathSeparator(code) ? "\\" : path; if (isPathSeparator(code)) { isAbsolute = true; if (isPathSeparator(path.charCodeAt(1))) { let j = 2; let last = j; while (j < len && !isPathSeparator(path.charCodeAt(j))) j++; if (j < len && j !== last) { const firstPart = path.slice(last, j); last = j; while (j < len && isPathSeparator(path.charCodeAt(j))) j++; if (j < len && j !== last) { last = j; while (j < len && !isPathSeparator(path.charCodeAt(j))) j++; if (j === len || j !== last) { if (firstPart === "." || firstPart === "?") { device = `\\\\${firstPart}`; rootEnd = 4; const colonIndex = path.indexOf(":"); const possibleDevice = path.slice(4, colonIndex + 1); if (isWindowsReservedName(possibleDevice, possibleDevice.length - 1)) { device = `\\\\?\\${possibleDevice}`; rootEnd = 4 + possibleDevice.length; } } else if (j === len) { return `\\\\${firstPart}\\${path.slice(last)}\\`; } else { device = `\\\\${firstPart}\\${path.slice(last, j)}`; rootEnd = j; } } } } } else { rootEnd = 1; } } else { const colonIndex = path.indexOf(":"); if (colonIndex > 0) { if (isWindowsDeviceRoot(code) && colonIndex === 1) { device = path.slice(0, 2); rootEnd = 2; if (len > 2 && isPathSeparator(path.charCodeAt(2))) { isAbsolute = true; rootEnd = 3; } } else if (isWindowsReservedName(path, colonIndex)) { device = path.slice(0, colonIndex + 1); rootEnd = colonIndex + 1; } } }
let tail = rootEnd < len ? normalizeString(path.slice(rootEnd), !isAbsolute, "\\", isPathSeparator) : ""; if (tail.length === 0 && !isAbsolute) tail = "."; if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) tail += "\\"; if (!isAbsolute && device === undefined && path.includes(":")) { // Not absolute and not resolved to a device: make sure `tail` cannot be read by // Windows as an absolute path (CVE-2024-36139). if (tail.length >= 2 && isWindowsDeviceRoot(tail.charCodeAt(0)) && tail.charCodeAt(1) === CHAR_COLON) { return `.\\${tail}`; } let index = path.indexOf(":"); do { if (index === len - 1 || isPathSeparator(path.charCodeAt(index + 1))) return `.\\${tail}`; } while ((index = path.indexOf(":", index + 1)) !== -1); } const colonIndex = path.indexOf(":"); if (isWindowsReservedName(path, colonIndex)) return `.\\${device ?? ""}${tail}`; if (device === undefined) return isAbsolute ? `\\${tail}` : tail; return isAbsolute ? `${device}\\${tail}` : `${device}${tail}`; },
isAbsolute(path: string): boolean { validateString(path, "path"); const len = path.length; if (len === 0) return false; const code = path.charCodeAt(0); return isPathSeparator(code) || (len > 2 && isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON && isPathSeparator(path.charCodeAt(2))); },
join(...args: string[]): string { if (args.length === 0) return ".";
const parts0: string[] = []; for (const arg of args) { validateString(arg, "path"); if (arg.length > 0) parts0.push(arg); } if (parts0.length === 0) return ".";
const firstPart = parts0[0]!; let joined = parts0.join("\\");
// Don't let the joined path start with two slashes — normalize() would read that // as a UNC root — unless the first arg very clearly meant to build one. let needsReplace = true; let slashCount = 0; if (isPathSeparator(firstPart.charCodeAt(0))) { ++slashCount; const firstLen = firstPart.length; if (firstLen > 1 && isPathSeparator(firstPart.charCodeAt(1))) { ++slashCount; if (firstLen > 2) { if (isPathSeparator(firstPart.charCodeAt(2))) ++slashCount; else needsReplace = false; } } } if (needsReplace) { while (slashCount < joined.length && isPathSeparator(joined.charCodeAt(slashCount))) slashCount++; if (slashCount >= 2) joined = `\\${joined.slice(slashCount)}`; }
// Skip normalization when a part names a reserved device, so e.g. "CON:" is kept // literal instead of being folded away as a drive-ish root. const parts: string[] = []; let part = ""; for (let i = 0; i < joined.length; i++) { if (joined[i] === "\\") { if (part) parts.push(part); part = ""; while (i + 1 < joined.length && joined[i + 1] === "\\") i++; } else { part += joined[i]; } } if (part) parts.push(part);
if (parts.some((p) => { const colonIndex = p.indexOf(":"); return colonIndex !== -1 && isWindowsReservedName(p, colonIndex); })) { let result = ""; for (let i = 0; i < joined.length; i++) result += joined[i] === "/" ? "\\" : joined[i]; return result; }
return win32.normalize(joined); },
relative(from: string, to: string): string { validateString(from, "from"); validateString(to, "to"); if (from === to) return "";
const fromOrig = win32.resolve(from); const toOrig = win32.resolve(to); if (fromOrig === toOrig) return "";
let fromLower = fromOrig.toLowerCase(); let toLower = toOrig.toLowerCase(); if (fromLower === toLower) return "";
if (fromOrig.length !== fromLower.length || toOrig.length !== toLower.length) { const fromSplit = fromOrig.split("\\"); const toSplit = toOrig.split("\\"); if (fromSplit[fromSplit.length - 1] === "") fromSplit.pop(); if (toSplit[toSplit.length - 1] === "") toSplit.pop();
const fromLen = fromSplit.length; const toLen = toSplit.length; const length = fromLen < toLen ? fromLen : toLen;
let i: number; for (i = 0; i < length; i++) { if (fromSplit[i]!.toLowerCase() !== toSplit[i]!.toLowerCase()) break; }
if (i === 0) return toOrig; if (i === length) { if (toLen > length) return toSplit.slice(i).join("\\"); if (fromLen > length) return "..\\".repeat(fromLen - 1 - i) + ".."; return ""; } return "..\\".repeat(fromLen - i) + toSplit.slice(i).join("\\"); }
let fromStart = 0; while (fromStart < fromLower.length && fromLower.charCodeAt(fromStart) === CHAR_BACKWARD_SLASH) fromStart++; let fromEnd = fromLower.length; while (fromEnd - 1 > fromStart && fromLower.charCodeAt(fromEnd - 1) === CHAR_BACKWARD_SLASH) fromEnd--; const fromLen = fromEnd - fromStart;
let toStart = 0; while (toStart < toLower.length && toLower.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) toStart++; let toEnd = toLower.length; while (toEnd - 1 > toStart && toLower.charCodeAt(toEnd - 1) === CHAR_BACKWARD_SLASH) toEnd--; const toLen = toEnd - toStart;
const length = fromLen < toLen ? fromLen : toLen; let lastCommonSep = -1; let i = 0; for (; i < length; i++) { const fromCode = fromLower.charCodeAt(fromStart + i); if (fromCode !== toLower.charCodeAt(toStart + i)) break; else if (fromCode === CHAR_BACKWARD_SLASH) lastCommonSep = i; }
if (i !== length) { if (lastCommonSep === -1) return toOrig; } else { if (toLen > length) { if (toLower.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) return toOrig.slice(toStart + i + 1); if (i === 2) return toOrig.slice(toStart + i); } if (fromLen > length) { if (fromLower.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) lastCommonSep = i; else if (i === 2) lastCommonSep = 3; } if (lastCommonSep === -1) lastCommonSep = 0; }
let out = ""; for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) { if (i === fromEnd || fromLower.charCodeAt(i) === CHAR_BACKWARD_SLASH) out += out.length === 0 ? ".." : "\\.."; }
toStart += lastCommonSep; if (out.length > 0) return `${out}${toOrig.slice(toStart, toEnd)}`; if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) ++toStart; return toOrig.slice(toStart, toEnd); },
toNamespacedPath(path: unknown): unknown { // Note: this will *probably* throw somewhere, same as Node — a non-string isn't // rejected here, only skipped, because toNamespacedPath has no validateString. if (typeof path !== "string" || path.length === 0) return path; const resolvedPath = win32.resolve(path); if (resolvedPath.length <= 2) return path; if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) { if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) { const code = resolvedPath.charCodeAt(2); if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) return `\\\\?\\UNC\\${resolvedPath.slice(2)}`; } } else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0)) && resolvedPath.charCodeAt(1) === CHAR_COLON && resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) { return `\\\\?\\${resolvedPath}`; } return resolvedPath; },
dirname(path: string): string { validateString(path, "path"); const len = path.length; if (len === 0) return "."; let rootEnd = -1; let offset = 0; const code = path.charCodeAt(0);
if (len === 1) return isPathSeparator(code) ? path : ".";
if (isPathSeparator(code)) { rootEnd = offset = 1; if (isPathSeparator(path.charCodeAt(1))) { let j = 2; let last = j; while (j < len && !isPathSeparator(path.charCodeAt(j))) j++; if (j < len && j !== last) { last = j; while (j < len && isPathSeparator(path.charCodeAt(j))) j++; if (j < len && j !== last) { last = j; while (j < len && !isPathSeparator(path.charCodeAt(j))) j++; if (j === len) return path; if (j !== last) rootEnd = offset = j + 1; } } } } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) { rootEnd = len > 2 && isPathSeparator(path.charCodeAt(2)) ? 3 : 2; offset = rootEnd; }
let end = -1; let matchedSlash = true; for (let i = len - 1; i >= offset; --i) { if (isPathSeparator(path.charCodeAt(i))) { if (!matchedSlash) { end = i; break; } } else { matchedSlash = false; } }
if (end === -1) { if (rootEnd === -1) return "."; end = rootEnd; } return path.slice(0, end); },
basename(path: string, suffix?: string): string { if (suffix !== undefined) validateString(suffix, "suffix"); validateString(path, "path"); let start = 0; let end = -1; let matchedSlash = true;
if (path.length >= 2 && isWindowsDeviceRoot(path.charCodeAt(0)) && path.charCodeAt(1) === CHAR_COLON) { start = 2; }
if (suffix !== undefined && suffix.length > 0 && suffix.length <= path.length) { if (suffix === path) return ""; let extIdx = suffix.length - 1; let firstNonSlashEnd = -1; for (let i = path.length - 1; i >= start; --i) { const code = path.charCodeAt(i); if (isPathSeparator(code)) { if (!matchedSlash) { start = i + 1; break; } } else { if (firstNonSlashEnd === -1) { matchedSlash = false; firstNonSlashEnd = i + 1; } if (extIdx >= 0) { if (code === suffix.charCodeAt(extIdx)) { if (--extIdx === -1) end = i; } else { extIdx = -1; end = firstNonSlashEnd; } } } } if (start === end) end = firstNonSlashEnd; else if (end === -1) end = path.length; return path.slice(start, end); } for (let i = path.length - 1; i >= start; --i) { if (isPathSeparator(path.charCodeAt(i))) { if (!matchedSlash) { start = i + 1; break; } } else if (end === -1) { matchedSlash = false; end = i + 1; } } if (end === -1) return ""; return path.slice(start, end); },
extname(path: string): string { validateString(path, "path"); let start = 0; let startDot = -1; let startPart = 0; let end = -1; let matchedSlash = true; let preDotState = 0;
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 (!matchedSlash) { startPart = i + 1; break; } continue; } if (end === -1) { matchedSlash = false; end = i + 1; } if (code === CHAR_DOT) { if (startDot === -1) startDot = i; else if (preDotState !== 1) preDotState = 1; } else if (startDot !== -1) { preDotState = -1; } }
if (startDot === -1 || end === -1 || preDotState === 0 || (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)) { return ""; } return path.slice(startDot, end); },
format(pathObject: Partial<ParsedPath>): string { validateObject(pathObject, "pathObject"); const dir = pathObject.dir || pathObject.root; const base = pathObject.base || `${pathObject.name || ""}${formatExt(pathObject.ext ?? "")}`; if (!dir) return base; return dir === pathObject.root ? `${dir}${base}` : `${dir}\\${base}`; },
parse(path: string): ParsedPath { validateString(path, "path"); const ret: ParsedPath = { root: "", dir: "", base: "", ext: "", name: "" }; if (path.length === 0) return ret;
const len = path.length; let rootEnd = 0; let code = path.charCodeAt(0);
if (len === 1) { if (isPathSeparator(code)) { ret.root = ret.dir = path; return ret; } ret.base = ret.name = path; return ret; } if (isPathSeparator(code)) { rootEnd = 1; if (isPathSeparator(path.charCodeAt(1))) { let j = 2; let last = j; while (j < len && !isPathSeparator(path.charCodeAt(j))) j++; if (j < len && j !== last) { last = j; while (j < len && isPathSeparator(path.charCodeAt(j))) j++; if (j < len && j !== last) { last = j; while (j < len && !isPathSeparator(path.charCodeAt(j))) j++; if (j === len) rootEnd = j; else if (j !== last) rootEnd = j + 1; } } } } else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) { if (len <= 2) { ret.root = ret.dir = path; return ret; } rootEnd = 2; if (isPathSeparator(path.charCodeAt(2))) { if (len === 3) { ret.root = ret.dir = path; return ret; } rootEnd = 3; } } 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; let preDotState = 0;
for (; i >= rootEnd; --i) { code = path.charCodeAt(i); if (isPathSeparator(code)) { if (!matchedSlash) { startPart = i + 1; break; } continue; } if (end === -1) { matchedSlash = false; end = i + 1; } if (code === CHAR_DOT) { if (startDot === -1) startDot = i; else if (preDotState !== 1) preDotState = 1; } else if (startDot !== -1) { preDotState = -1; } }
if (end !== -1) { if (startDot === -1 || preDotState === 0 || (preDotState === 1 && startDot === end - 1 && startDot === startPart + 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); } }
if (startPart > 0 && startPart !== rootEnd) ret.dir = path.slice(0, startPart - 1); else ret.dir = ret.root;
return ret; },
/** Not path-separator-sensitive the way the rest of win32 is: Node's real * win32.matchesGlob folds "\\" to "/" in both arguments first (confirmed by fuzzing * tens of thousands of cases against Node 24.16 — the only observed divergence * from "normalize then delegate to the posix matcher" was two cases that already * diverge for posix.matchesGlob itself, i.e. pre-existing quirks of that matcher, * not something win32 adds), then runs the exact same matcher as posix.matchesGlob. */ matchesGlob(path: unknown, pattern: unknown): boolean { validateString(path, "path"); validateString(pattern, "pattern"); return posixMatchesGlob(path.replace(/\\/g, "/"), pattern.replace(/\\/g, "/")); }, }; return win32;}