@veryfront/ext-content-mdx 0.1.1183 → 0.1.1185

package/esm/src/platform/compat/path/parse-format.js

@@ -1,26 +1,32 @@
-import { isDeno, nodePath } from "./runtime.js";
-import { basename, dirname, extname, join } from "./basic-operations.js";
-import { isAbsolute } from "./resolution.js";
+import { hasWindowsLikePath, portableFormat, portableParse, runtimeUsesWindowsPaths, toPortableSeparators, } from "./portable.js";
+import { getNativePathImplementation } from "./runtime.js";
 export function parse(path) {
-    if (!isDeno && nodePath) {
-        return nodePath.parse(path);
-    }
-    const dir = dirname(path);
-    const base = basename(path);
-    const ext = extname(path);
+    const windows = runtimeUsesWindowsPaths() || hasWindowsLikePath(path);
+    const pathApi = getNativePathImplementation(windows);
+    if (!pathApi)
+        return portableParse(path, windows);
+    const parsed = pathApi.parse(path);
     return {
-        root: isAbsolute(path) ? "/" : "",
-        dir,
-        base,
-        ext,
-        name: base.slice(0, base.length - ext.length),
+        root: toPortableSeparators(parsed.root ?? ""),
+        dir: toPortableSeparators(parsed.dir ?? ""),
+        base: parsed.base ?? "",
+        ext: parsed.ext ?? "",
+        name: parsed.name ?? "",
     };
 }
 export function format(pathObject) {
-    if (!isDeno && nodePath) {
-        return nodePath.format(pathObject);
-    }
-    const { dir = "", base = "", name = "", ext = "" } = pathObject;
-    const fileName = base || name + ext;
-    return dir ? join(dir, fileName) : fileName;
+    const windows = runtimeUsesWindowsPaths() ||
+        hasWindowsLikePath(pathObject.root ?? "") ||
+        hasWindowsLikePath(pathObject.dir ?? "");
+    const pathApi = getNativePathImplementation(windows);
+    if (!pathApi)
+        return portableFormat(pathObject, windows);
+    const formatted = pathApi.format({
+        root: pathObject.root ?? "",
+        dir: pathObject.dir ?? "",
+        base: pathObject.base ?? "",
+        ext: pathObject.ext ?? "",
+        name: pathObject.name ?? "",
+    });
+    return toPortableSeparators(formatted);
 }

package/esm/src/platform/compat/path/portable.d.ts

@@ -0,0 +1,16 @@
+import type { PathObject } from "./types.js";
+export declare function hasWindowsLikePath(path: string): boolean;
+export declare function toPortableSeparators(path: string): string;
+export declare function removeTrailingSeparatorsExceptRoot(path: string, windows: boolean): string;
+export declare function runtimeUsesWindowsPaths(): boolean;
+export declare function portableNormalize(path: string, windows: boolean): string;
+export declare function portableJoin(paths: readonly string[], windows: boolean): string;
+export declare function portableDirname(path: string, windows: boolean): string;
+export declare function portableBasename(path: string, ext: string | undefined, windows: boolean): string;
+export declare function portableExtname(path: string, windows: boolean): string;
+export declare function portableIsAbsolute(path: string, windows: boolean): boolean;
+export declare function portableResolve(paths: readonly string[], windows: boolean): string;
+export declare function portableRelative(from: string, to: string, windows: boolean): string;
+export declare function portableParse(path: string, windows: boolean): PathObject;
+export declare function portableFormat(pathObject: PathObject, windows: boolean): string;
+//# sourceMappingURL=portable.d.ts.map

package/esm/src/platform/compat/path/portable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portable.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/path/portable.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAS7C,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGxD;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEzD;AAmFD,wBAAgB,kCAAkC,CAChD,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,OAAO,GACf,MAAM,CAUR;AAOD,wBAAgB,uBAAuB,IAAI,OAAO,CASjD;AAyBD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAkBxE;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAI/E;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAqBtE;AAED,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,OAAO,EAAE,OAAO,GACf,MAAM,CAuCR;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAKtE;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAE1E;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,OAAO,EAAE,OAAO,GACf,MAAM,CAiCR;AAED,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,OAAO,GACf,MAAM,CA2BR;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,UAAU,CAiCxE;AAED,wBAAgB,cAAc,CAC5B,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,OAAO,GACf,MAAM,CAeR"}

package/esm/src/platform/compat/path/portable.js

@@ -0,0 +1,307 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+export function hasWindowsLikePath(path) {
+    return path.includes("\\") ||
+        /^[A-Za-z]:/.test(path);
+}
+export function toPortableSeparators(path) {
+    return path.replaceAll("\\", "/");
+}
+function analyzeRoot(path, windows) {
+    const portable = toPortableSeparators(path);
+    if (windows) {
+        const unc = portable.match(/^\/\/([^/]+)\/+([^/]+)(\/+(.*))?$/);
+        if (unc?.[1] && unc[2]) {
+            const device = `//${unc[1]}/${unc[2]}`;
+            return {
+                absolute: true,
+                device,
+                rest: unc[4] ?? "",
+                root: unc[3] === undefined ? device : `${device}/`,
+            };
+        }
+        const drive = portable.match(/^([A-Za-z]:)(\/+)?(.*)$/);
+        if (drive?.[1] !== undefined) {
+            const absolute = drive[2] !== undefined;
+            return {
+                absolute,
+                device: drive[1],
+                rest: drive[3] ?? "",
+                root: absolute ? `${drive[1]}/` : drive[1],
+            };
+        }
+    }
+    if (portable.startsWith("/")) {
+        return {
+            absolute: true,
+            device: "",
+            rest: portable.replace(/^\/+/, ""),
+            root: "/",
+        };
+    }
+    return {
+        absolute: false,
+        device: "",
+        rest: portable,
+        root: "",
+    };
+}
+function appendRoot(root, tail) {
+    if (root.root === "")
+        return tail || ".";
+    if (!root.absolute)
+        return `${root.root}${tail || "."}`;
+    if (!tail) {
+        return root.device.startsWith("//") ? `${root.device}/` : root.root;
+    }
+    return root.root.endsWith("/") ? `${root.root}${tail}` : `${root.root}/${tail}`;
+}
+function normalizeTail(rest, absolute) {
+    const normalized = [];
+    for (const segment of rest.split("/")) {
+        if (segment === "" || segment === ".")
+            continue;
+        if (segment !== "..") {
+            normalized.push(segment);
+            continue;
+        }
+        const previous = normalized.at(-1);
+        if (previous !== undefined && previous !== "..") {
+            normalized.pop();
+        }
+        else if (!absolute) {
+            normalized.push("..");
+        }
+    }
+    return normalized;
+}
+function canonicalPath(path, windows) {
+    return windows ? toPortableSeparators(path) : path;
+}
+export function removeTrailingSeparatorsExceptRoot(path, windows) {
+    const root = analyzeRoot(path, windows);
+    let canonical = canonicalPath(path, windows);
+    while (canonical.endsWith("/") &&
+        canonical.length > root.root.length) {
+        canonical = canonical.slice(0, -1);
+    }
+    return canonical;
+}
+function rootKey(root, windows) {
+    const value = root.device || root.root;
+    return windows ? value.toLowerCase() : value;
+}
+export function runtimeUsesWindowsPaths() {
+    const runtime = dntShim.dntGlobalThis;
+    if (typeof runtime.Deno?.build?.os === "string") {
+        return runtime.Deno.build.os === "windows";
+    }
+    return runtime.process?.platform === "win32";
+}
+function runtimeCwd() {
+    const deno = dntShim.dntGlobalThis.Deno;
+    try {
+        if (typeof deno?.cwd === "function")
+            return deno.cwd();
+    }
+    catch {
+        // Continue to the next runtime source.
+    }
+    const process = dntShim.dntGlobalThis.process;
+    try {
+        if (typeof process?.cwd === "function")
+            return process.cwd();
+    }
+    catch {
+        // Browsers do not expose a process working directory.
+    }
+    // Browser builds use a virtual root because no host working directory exists.
+    return "/";
+}
+export function portableNormalize(path, windows) {
+    if (path === "")
+        return ".";
+    const root = analyzeRoot(path, windows);
+    const tail = normalizeTail(root.rest, root.absolute).join("/");
+    let result = appendRoot(root, tail);
+    const hadTrailingSeparator = /[\\/]$/.test(path);
+    if (hadTrailingSeparator && result === ".")
+        return "./";
+    if (hadTrailingSeparator &&
+        result !== root.root &&
+        !result.endsWith("/")) {
+        result += "/";
+    }
+    return result;
+}
+export function portableJoin(paths, windows) {
+    const nonempty = paths.filter((path) => path.length > 0);
+    if (nonempty.length === 0)
+        return "/";
+    return portableNormalize(nonempty.join("/"), windows);
+}
+export function portableDirname(path, windows) {
+    if (path.length === 0)
+        return ".";
+    const root = analyzeRoot(path, windows);
+    let canonical = canonicalPath(path, windows);
+    while (canonical.endsWith("/") &&
+        canonical.length > root.root.length) {
+        canonical = canonical.slice(0, -1);
+    }
+    if (canonical === root.root || canonical === root.device) {
+        return root.root || root.device || ".";
+    }
+    const lastSeparator = canonical.lastIndexOf("/");
+    if (lastSeparator === -1)
+        return root.device || ".";
+    if (lastSeparator < root.root.length)
+        return root.root || "/";
+    if (lastSeparator === 0)
+        return "/";
+    return canonical.slice(0, lastSeparator);
+}
+export function portableBasename(path, ext, windows) {
+    if (path.length === 0)
+        return "";
+    const root = analyzeRoot(path, windows);
+    let canonical = canonicalPath(path, windows);
+    const originalPath = canonical;
+    if (ext !== undefined && ext !== "" && ext === originalPath)
+        return "";
+    while (canonical.endsWith("/") &&
+        canonical.length > root.root.length) {
+        canonical = canonical.slice(0, -1);
+    }
+    if (windows &&
+        root.device.startsWith("//") &&
+        root.rest === "") {
+        return root.device.slice(root.device.lastIndexOf("/") + 1);
+    }
+    if (canonical === root.root || canonical === root.device)
+        return "";
+    const lastSeparator = canonical.lastIndexOf("/");
+    let base = canonical.slice(lastSeparator + 1);
+    if (!root.absolute &&
+        root.device &&
+        lastSeparator === -1 &&
+        base.startsWith(root.device)) {
+        base = base.slice(root.device.length);
+    }
+    if (ext !== undefined && ext !== "" && base.endsWith(ext)) {
+        if (ext.length < base.length)
+            return base.slice(0, -ext.length);
+    }
+    return base;
+}
+export function portableExtname(path, windows) {
+    const base = portableBasename(path, undefined, windows);
+    const lastDot = base.lastIndexOf(".");
+    if (lastDot <= 0 || base === "." || base === "..")
+        return "";
+    return base.slice(lastDot);
+}
+export function portableIsAbsolute(path, windows) {
+    return analyzeRoot(path, windows).absolute;
+}
+export function portableResolve(paths, windows) {
+    let resolved = runtimeCwd();
+    for (const rawPath of paths) {
+        if (rawPath.length === 0)
+            continue;
+        const path = toPortableSeparators(rawPath);
+        const incoming = analyzeRoot(path, windows);
+        const current = analyzeRoot(resolved, windows);
+        if (incoming.absolute && incoming.device) {
+            resolved = path;
+        }
+        else if (incoming.absolute) {
+            resolved = windows && current.device ? `${current.device}/${incoming.rest}` : path;
+        }
+        else if (incoming.device) {
+            resolved = rootKey(incoming, true) === rootKey(current, true)
+                ? `${current.root}${current.rest}/${incoming.rest}`
+                : `${incoming.device}/${incoming.rest}`;
+        }
+        else {
+            resolved = `${resolved}/${path}`;
+        }
+    }
+    const normalized = portableNormalize(resolved, windows);
+    const root = analyzeRoot(normalized, windows);
+    if (normalized.endsWith("/") &&
+        normalized !== root.root &&
+        normalized !== `${root.device}/`) {
+        return normalized.slice(0, -1);
+    }
+    return normalized;
+}
+export function portableRelative(from, to, windows) {
+    const resolvedFrom = portableResolve([from], windows);
+    const resolvedTo = portableResolve([to], windows);
+    const fromRoot = analyzeRoot(resolvedFrom, windows);
+    const toRoot = analyzeRoot(resolvedTo, windows);
+    if (rootKey(fromRoot, windows) !== rootKey(toRoot, windows)) {
+        return resolvedTo;
+    }
+    const fromParts = normalizeTail(fromRoot.rest, true);
+    const toParts = normalizeTail(toRoot.rest, true);
+    let common = 0;
+    while (common < fromParts.length && common < toParts.length) {
+        const fromPart = fromParts[common];
+        const toPart = toParts[common];
+        const equal = windows ? fromPart.toLowerCase() === toPart.toLowerCase() : fromPart === toPart;
+        if (!equal)
+            break;
+        common++;
+    }
+    const result = [
+        ...Array.from({ length: fromParts.length - common }, () => ".."),
+        ...toParts.slice(common),
+    ];
+    return result.join("/") || ".";
+}
+export function portableParse(path, windows) {
+    const root = analyzeRoot(path, windows);
+    let canonical = canonicalPath(path, windows);
+    while (canonical.endsWith("/") &&
+        canonical.length > root.root.length) {
+        canonical = canonical.slice(0, -1);
+    }
+    const base = windows && root.device.startsWith("//") && root.rest === ""
+        ? ""
+        : portableBasename(canonical, undefined, windows);
+    const ext = portableExtname(base, windows);
+    const name = base.slice(0, base.length - ext.length);
+    let dir = "";
+    if (base === "") {
+        dir = root.root;
+    }
+    else if (canonical.includes("/") ||
+        (windows && root.device !== "")) {
+        dir = portableDirname(canonical, windows);
+    }
+    return {
+        root: root.root,
+        dir,
+        base,
+        ext,
+        name,
+    };
+}
+export function portableFormat(pathObject, windows) {
+    const root = toPortableSeparators(pathObject.root ?? "");
+    const dir = toPortableSeparators(pathObject.dir ?? "");
+    const rawExt = pathObject.ext ?? "";
+    const ext = rawExt && !rawExt.startsWith(".") ? `.${rawExt}` : rawExt;
+    const base = pathObject.base ||
+        `${pathObject.name ?? ""}${ext}`;
+    const directory = dir || root;
+    if (!directory)
+        return base;
+    if (!base)
+        return directory;
+    if (directory.endsWith("/") || (windows && /^[A-Za-z]:$/.test(directory))) {
+        return `${directory}${base}`;
+    }
+    return `${directory}/${base}`;
+}

package/esm/src/platform/compat/path/posix.d.ts

@@ -0,0 +1,14 @@
+export interface PosixPath {
+    join(...paths: string[]): string;
+    resolve(...paths: string[]): string;
+    normalize(path: string): string;
+    relative(from: string, to: string): string;
+    dirname(path: string): string;
+    basename(path: string, suffix?: string): string;
+    extname(path: string): string;
+    isAbsolute(path: string): boolean;
+    readonly sep: "/";
+    readonly delimiter: ":";
+}
+export declare const posix: Readonly<PosixPath>;
+//# sourceMappingURL=posix.d.ts.map

package/esm/src/platform/compat/path/posix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"posix.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/path/posix.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,SAAS;IACxB,IAAI,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IACjC,OAAO,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IACpC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3C,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAChD,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAClC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAClB,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC;CACzB;AAkND,eAAO,MAAM,KAAK,EAAE,QAAQ,CAAC,SAAS,CAWpC,CAAC"}

package/esm/src/platform/compat/path/posix.js

@@ -0,0 +1,206 @@
+/** Dependency-free POSIX path operations for every supported runtime. */
+import * as dntShim from "../../../../_dnt.shims.js";
+function assertPath(value) {
+    if (typeof value !== "string") {
+        throw new TypeError(`Path must be a string. Received ${typeof value}`);
+    }
+}
+function normalizeSegments(path, allowAboveRoot) {
+    const segments = [];
+    for (const segment of path.split("/")) {
+        if (segment.length === 0 || segment === ".")
+            continue;
+        if (segment !== "..") {
+            segments.push(segment);
+            continue;
+        }
+        const previous = segments.at(-1);
+        if (previous !== undefined && previous !== "..") {
+            segments.pop();
+        }
+        else if (allowAboveRoot) {
+            segments.push("..");
+        }
+    }
+    return segments.join("/");
+}
+function runtimeWorkingDirectory() {
+    const runtime = dntShim.dntGlobalThis;
+    if (typeof runtime.Deno?.cwd === "function") {
+        const directory = runtime.Deno.cwd();
+        assertPath(directory);
+        return directory;
+    }
+    if (typeof runtime.process?.cwd === "function") {
+        const directory = runtime.process.cwd();
+        assertPath(directory);
+        return directory;
+    }
+    // Browser and worker runtimes resolve relative virtual paths from their root.
+    return "/";
+}
+function normalize(path) {
+    assertPath(path);
+    if (path.length === 0)
+        return ".";
+    const absolute = path.startsWith("/");
+    const trailingSeparator = path.endsWith("/");
+    let normalized = normalizeSegments(path, !absolute);
+    if (normalized.length > 0 && trailingSeparator)
+        normalized += "/";
+    if (absolute)
+        return normalized.length > 0 ? `/${normalized}` : "/";
+    if (normalized.length > 0)
+        return normalized;
+    return trailingSeparator ? "./" : ".";
+}
+function join(...paths) {
+    let joined = "";
+    for (const path of paths) {
+        assertPath(path);
+        if (path.length === 0)
+            continue;
+        joined = joined.length === 0 ? path : `${joined}/${path}`;
+    }
+    return joined.length === 0 ? "." : normalize(joined);
+}
+function resolve(...paths) {
+    let resolved = "";
+    let absolute = false;
+    for (let index = paths.length - 1; index >= -1 && !absolute; index--) {
+        const path = index >= 0 ? paths[index] : runtimeWorkingDirectory();
+        assertPath(path);
+        if (path.length === 0)
+            continue;
+        resolved = `${path}/${resolved}`;
+        absolute = path.startsWith("/");
+    }
+    const normalized = normalizeSegments(resolved, !absolute);
+    if (absolute)
+        return normalized.length > 0 ? `/${normalized}` : "/";
+    return normalized.length > 0 ? normalized : ".";
+}
+function relative(from, to) {
+    assertPath(from);
+    assertPath(to);
+    const resolvedFrom = resolve(from);
+    const resolvedTo = resolve(to);
+    if (resolvedFrom === resolvedTo)
+        return "";
+    const fromSegments = resolvedFrom.split("/").filter(Boolean);
+    const toSegments = resolvedTo.split("/").filter(Boolean);
+    let common = 0;
+    while (common < fromSegments.length &&
+        common < toSegments.length &&
+        fromSegments[common] === toSegments[common]) {
+        common++;
+    }
+    return [
+        ...Array.from({ length: fromSegments.length - common }, () => ".."),
+        ...toSegments.slice(common),
+    ].join("/");
+}
+function dirname(path) {
+    assertPath(path);
+    if (path.length === 0)
+        return ".";
+    const hasRoot = path.startsWith("/");
+    let end = -1;
+    let matchedSeparator = true;
+    for (let index = path.length - 1; index >= 1; index--) {
+        if (path[index] === "/") {
+            if (!matchedSeparator) {
+                end = index;
+                break;
+            }
+        }
+        else {
+            matchedSeparator = false;
+        }
+    }
+    if (end === -1)
+        return hasRoot ? "/" : ".";
+    if (hasRoot && end === 1)
+        return "//";
+    return path.slice(0, end);
+}
+function basename(path, suffix) {
+    assertPath(path);
+    if (suffix !== undefined)
+        assertPath(suffix);
+    let start = 0;
+    let end = -1;
+    let matchedSeparator = true;
+    if (suffix !== undefined && suffix.length > 0 && suffix.length <= path.length) {
+        if (suffix === path)
+            return "";
+        let suffixIndex = suffix.length - 1;
+        let firstNonSeparatorEnd = -1;
+        for (let index = path.length - 1; index >= 0; index--) {
+            const character = path[index];
+            if (character === "/") {
+                if (!matchedSeparator) {
+                    start = index + 1;
+                    break;
+                }
+                continue;
+            }
+            if (firstNonSeparatorEnd === -1) {
+                matchedSeparator = false;
+                firstNonSeparatorEnd = index + 1;
+            }
+            if (suffixIndex < 0)
+                continue;
+            if (character === suffix[suffixIndex]) {
+                suffixIndex--;
+                if (suffixIndex === -1)
+                    end = index;
+            }
+            else {
+                suffixIndex = -1;
+                end = firstNonSeparatorEnd;
+            }
+        }
+        if (start === end)
+            end = firstNonSeparatorEnd;
+        else if (end === -1)
+            end = path.length;
+        return path.slice(start, end);
+    }
+    for (let index = path.length - 1; index >= 0; index--) {
+        if (path[index] === "/") {
+            if (!matchedSeparator) {
+                start = index + 1;
+                break;
+            }
+        }
+        else if (end === -1) {
+            matchedSeparator = false;
+            end = index + 1;
+        }
+    }
+    return end === -1 ? "" : path.slice(start, end);
+}
+function extname(path) {
+    const base = basename(path);
+    if (base === "." || base === "..")
+        return "";
+    const lastDot = base.lastIndexOf(".");
+    return lastDot <= 0 ? "" : base.slice(lastDot);
+}
+function isAbsolute(path) {
+    assertPath(path);
+    return path.startsWith("/");
+}
+export const posix = Object.freeze({
+    join,
+    resolve,
+    normalize,
+    relative,
+    dirname,
+    basename,
+    extname,
+    isAbsolute,
+    sep: "/",
+    delimiter: ":",
+});

package/esm/src/platform/compat/path/resolution.d.ts

@@ -1,4 +1,4 @@
-/** Resolve path segments to an absolute path. */
+/** Resolve path segments to an absolute, normalized path. */
 export declare function resolve(...paths: string[]): string;
 export declare function isAbsolute(path: string): boolean;
 export declare function relative(from: string, to: string): string;

package/esm/src/platform/compat/path/resolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolution.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/path/resolution.ts"],"names":[],"mappings":"AAeA,iDAAiD;AACjD,wBAAgB,OAAO,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAqClD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAMhD;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CA8BzD;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAyC9C"}
+{"version":3,"file":"resolution.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/path/resolution.ts"],"names":[],"mappings":"AAgBA,6DAA6D;AAC7D,wBAAgB,OAAO,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAMlD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAIhD;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAOzD;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAW9C"}