@veryfront/ext-content-mdx 0.1.1189 → 0.1.1191

package/esm/src/platform/adapters/runtime/shared/node-filesystem-adapter.js

@@ -1,3 +1,4 @@
+import * as dntShim from "../../../../../_dnt.shims.js";
 import { createFileWatcher, createWatcherIterator, setupNodeFsWatcher } from "./shared-watcher.js";
 import { makeNodeTempDir } from "./temp-dir.js";
 import { isProxyWithoutHooks } from "../../../compat/error-introspection.js";
@@ -5,8 +6,11 @@ import { isCanonicalNotFoundError } from "../../../compat/not-found-error.js";
 import { readBoundedFilePrefix, readFileWithinLimit, withFileHandle, } from "../../bounded-file-read.js";
 import { markNativeFileSystemAdapter } from "../../native-file-system-provenance.js";
 import { constants as nodeFsConstants } from "node:fs";
-import { isAbsolute, relative, resolve, sep } from "../../../compat/path/index.js";
-import { FileSnapshotChangedError } from "../../file-snapshot-error.js";
+import { resolve } from "../../../compat/path/index.js";
+import { runtimeUsesWindowsPaths } from "../../../compat/path/portable.js";
+import { FileSnapshotChangedError, FileSnapshotPathError } from "../../file-snapshot-error.js";
+import { hasUsableNativeFileIdentity, } from "./native-snapshot-identity.js";
+import { isPathContainedBy } from "../../path-containment.js";
 const silentLogger = {
     error: () => { },
     debug: () => { },
@@ -56,10 +60,25 @@ const nodeFileSystemOperations = {
 function hasOwn(value, property) {
     return Object.prototype.hasOwnProperty.call(value, property);
 }
-function isContainedPath(path, root) {
-    const relation = relative(root, path);
-    return relation === "" ||
-        (relation !== ".." && !relation.startsWith(`..${sep}`) && !isAbsolute(relation));
+function detectNodeCompatibleRuntime() {
+    const runtime = dntShim.dntGlobalThis;
+    const versions = runtime.process?.versions;
+    if (typeof versions?.deno === "string" || runtime.Deno !== undefined)
+        return "deno";
+    if (typeof versions?.bun === "string" || runtime.Bun !== undefined)
+        return "bun";
+    if (runtime.process?.release?.name === "node" &&
+        typeof versions?.node === "string") {
+        return "node";
+    }
+    return "unknown";
+}
+export function hasUsableWindowsSnapshotIdentity(runtime) {
+    // Node exposes bigint file identity and generation fields on Windows. Each
+    // snapshot still validates that the native identity is present and usable.
+    // Bun and Deno do not currently document an equivalent contract, so their
+    // Windows adapters must fail closed.
+    return runtime === "node";
 }
 function requirePositiveSafeInteger(value) {
     if (!Number.isSafeInteger(value) || value <= 0) {
@@ -75,6 +94,11 @@ function sameGeneration(left, right) {
         left.mtimeNs === right.mtimeNs &&
         left.ctimeNs === right.ctimeNs;
 }
+function requireUsableIdentity(stat, message) {
+    if (!hasUsableNativeFileIdentity(stat)) {
+        throw changed(message);
+    }
+}
 function changed(message, cause) {
     const error = new FileSnapshotChangedError(message);
     if (cause !== undefined) {
@@ -108,24 +132,36 @@ function throwSnapshotChangeForPathRace(message, cause) {
     }
     throwSnapshotChangeForMissingPath(message, cause);
 }
-async function readNodeFileSnapshotWithinLimit(operations, noFollow, path, containmentRoot, byteLimit) {
+export async function readNodeFileSnapshotWithinLimit(operations, platform, noFollow, path, containmentRoot, byteLimit) {
     requirePositiveSafeInteger(byteLimit);
+    let openFlags;
+    if (platform === "windows") {
+        openFlags = "r";
+    }
+    else {
+        if (typeof noFollow !== "number" || noFollow === 0) {
+            throw new TypeError("This runtime cannot guarantee no-follow snapshot opens");
+        }
+        openFlags = nodeFsConstants.O_RDONLY | noFollow;
+    }
     const lexicalRoot = resolve(containmentRoot);
     const candidate = resolve(path);
-    if (!isContainedPath(candidate, lexicalRoot)) {
-        throw new TypeError("Snapshot path must be contained by the requested root");
-    }
     const canonicalRoot = await operations.realpath(lexicalRoot);
+    if (!isPathContainedBy(candidate, lexicalRoot) &&
+        !isPathContainedBy(candidate, canonicalRoot)) {
+        throw new FileSnapshotPathError("Snapshot path must be contained by the requested root");
+    }
     const pathnameBefore = await operations.lstat(candidate);
     if (pathnameBefore.isSymbolicLink()) {
-        throw new TypeError("Snapshot path must not be a symbolic link");
+        throw new FileSnapshotPathError("Snapshot path must not be a symbolic link");
     }
     if (!pathnameBefore.isFile()) {
-        throw new TypeError("Snapshot path must identify a regular file");
+        throw new FileSnapshotPathError("Snapshot path must identify a regular file");
     }
+    requireUsableIdentity(pathnameBefore, "Stable native file identity is unavailable for the snapshot path");
     return await withFileHandle(async () => {
         try {
-            return await operations.open(candidate, nodeFsConstants.O_RDONLY | noFollow);
+            return await operations.open(candidate, openFlags);
         }
         catch (cause) {
             throwSnapshotChangeForPathRace("File identity became uncertain while opening the snapshot", cause);
@@ -138,6 +174,7 @@ async function readNodeFileSnapshotWithinLimit(operations, noFollow, path, conta
         catch (cause) {
             throwSnapshotChangeForMissingPath("Opened file identity could not be verified", cause);
         }
+        requireUsableIdentity(handleBefore, "Stable native file identity is unavailable for the opened snapshot");
         if (!handleBefore.isFile() || !sameGeneration(pathnameBefore, handleBefore)) {
             throw changed("File identity changed while opening the snapshot");
         }
@@ -157,8 +194,9 @@ async function readNodeFileSnapshotWithinLimit(operations, noFollow, path, conta
             !sameGeneration(handleBefore, pathnameOpened)) {
             throw changed("File identity changed while opening the snapshot");
         }
-        if (!isContainedPath(canonicalTarget, canonicalRoot)) {
-            throw new TypeError("Snapshot target must be contained by the canonical root");
+        requireUsableIdentity(pathnameOpened, "Stable native file identity is unavailable while verifying the snapshot");
+        if (!isPathContainedBy(canonicalTarget, canonicalRoot)) {
+            throw new FileSnapshotPathError("Snapshot target must be contained by the canonical root");
         }
         if (handleBefore.size < 0n) {
             throw changed("File size became uncertain while opening the snapshot");
@@ -200,12 +238,14 @@ async function readNodeFileSnapshotWithinLimit(operations, noFollow, path, conta
         catch (cause) {
             throwSnapshotChangeForPathRace("File identity became uncertain after reading the snapshot", cause);
         }
+        requireUsableIdentity(handleAfter, "Stable native file identity is unavailable after reading the snapshot");
+        requireUsableIdentity(pathnameAfter, "Stable native file identity is unavailable after reading the snapshot path");
         if (!pathnameAfter.isFile() ||
             pathnameAfter.isSymbolicLink() ||
             !sameGeneration(handleBefore, handleAfter) ||
             !sameGeneration(handleBefore, pathnameAfter) ||
             canonicalTargetAfter !== canonicalTarget ||
-            !isContainedPath(canonicalTargetAfter, canonicalRoot)) {
+            !isPathContainedBy(canonicalTargetAfter, canonicalRoot)) {
             throw changed("File snapshot changed during the read");
         }
         return bytes;
@@ -227,9 +267,13 @@ export class NodeCompatibleFileSystemAdapter {
             ...options.operations,
         };
         const noFollow = hasOwn(options, "noFollow") ? options.noFollow : nodeFsConstants.O_NOFOLLOW;
-        if (typeof noFollow === "number" && noFollow !== 0) {
+        const platform = options.platform ?? (runtimeUsesWindowsPaths() ? "windows" : "posix");
+        const canOpenExactSnapshot = platform === "windows"
+            ? hasUsableWindowsSnapshotIdentity(detectNodeCompatibleRuntime())
+            : typeof noFollow === "number" && noFollow !== 0;
+        if (canOpenExactSnapshot) {
             Object.defineProperty(this, "readFileSnapshotWithinLimit", {
-                value: (path, containmentRoot, byteLimit) => readNodeFileSnapshotWithinLimit(operations, noFollow, path, containmentRoot, byteLimit),
+                value: (path, containmentRoot, byteLimit) => readNodeFileSnapshotWithinLimit(operations, platform, noFollow, path, containmentRoot, byteLimit),
                 enumerable: true,
             });
         }

package/esm/src/platform/compat/error-introspection.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Whether this runtime can distinguish Proxy values without evaluating a trap.
+ * Callers that need a fail-closed guarantee must not treat a `false` result
+ * from {@link isProxyWithoutHooks} as proof when this capability is absent.
+ */
+export declare const canIdentifyProxyWithoutHooks: boolean;
 /** True when own stack descriptors can be inspected without formatting them. */
 export declare const canInspectErrorStackDescriptorWithoutHooks: boolean;
 /**
@@ -22,7 +28,12 @@ export declare function isNativeErrorWithoutHooks(value: unknown): value is Erro
  * prototype name or constructor name; unreadable/exotic shapes fail closed.
  */
 export declare function readNativeErrorNameWithoutHooks(error: Error): string;
-/** Identify a Proxy without evaluating any trap on the proxied value. */
+/**
+ * Identify a Proxy without evaluating any trap on the proxied value.
+ *
+ * Returns `false` without inspecting `value` when
+ * {@link canIdentifyProxyWithoutHooks} is false.
+ */
 export declare function isProxyWithoutHooks(value: unknown): boolean;
 /** Identify a genuine Uint8Array without evaluating project-owned hooks. */
 export declare function isUint8ArrayWithoutHooks(value: unknown): value is Uint8Array;

package/esm/src/platform/compat/error-introspection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-introspection.d.ts","sourceRoot":"","sources":["../../../../src/src/platform/compat/error-introspection.ts"],"names":[],"mappings":"AA2HA,gFAAgF;AAChF,eAAO,MAAM,0CAA0C,SAA0C,CAAC;AAgClG;;;;;;;;;;GAUG;AACH,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,SAAS,CAuBjF;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAExE;AA6BD;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAkBpE;AAED,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE3D;AAED,4EAA4E;AAC5E,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAE5E;AAED,gFAAgF;AAChF,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,CAE3B;AAED;;;;GAIG;AACH,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAgBnD"}
+{"version":3,"file":"error-introspection.d.ts","sourceRoot":"","sources":["../../../../src/src/platform/compat/error-introspection.ts"],"names":[],"mappings":"AA0DA;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,SAAkC,CAAC;AA8F5E,gFAAgF;AAChF,eAAO,MAAM,0CAA0C,SAA0C,CAAC;AAgClG;;;;;;;;;;GAUG;AACH,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,SAAS,CAuBjF;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAExE;AA6BD;;;;GAIG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAkBpE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE3D;AAED,4EAA4E;AAC5E,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAE5E;AAED,gFAAgF;AAChF,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,CAE3B;AAED;;;;GAIG;AACH,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAgBnD"}

package/esm/src/platform/compat/error-introspection.js

@@ -16,15 +16,45 @@ const apply = Reflect.apply;
 const NativeError = Error;
 const NativeAsyncFunctionPrototype = getPrototypeOf(async function () { });
 const toStringTagSymbol = Symbol.toStringTag;
+function hasOwn(object, key) {
+    return apply(objectHasOwnProperty, object, [key]);
+}
+/**
+ * Capture the portable Error brand primitive during trusted framework
+ * bootstrap, before tenant code can replace mutable globals. Edge runtimes do
+ * not expose an immutable host-module equivalent, so this capture boundary is
+ * the authority for later no-hook Error checks.
+ */
+function captureErrorIsError() {
+    const descriptor = getOwnPropertyDescriptor(NativeError, "isError");
+    return descriptor && hasOwn(descriptor, "value") &&
+        typeof descriptor.value === "function"
+        ? descriptor.value
+        : undefined;
+}
+const capturedErrorIsError = captureErrorIsError();
 const unavailableBrandCheck = (_value) => false;
+function portableErrorBrandCheck(value) {
+    if (!capturedErrorIsError)
+        return false;
+    try {
+        return apply(capturedErrorIsError, NativeError, [value]) === true;
+    }
+    catch (_) {
+        return false;
+    }
+}
 const nativeAsyncFunctionBrandCheck = nativeBrandChecks?.isAsyncFunction ?? unavailableBrandCheck;
-const nativeErrorBrandCheck = nativeBrandChecks?.isNativeError ?? unavailableBrandCheck;
+const nativeErrorBrandCheck = nativeBrandChecks?.isNativeError ?? portableErrorBrandCheck;
 const nativePromiseBrandCheck = nativeBrandChecks?.isPromise ?? unavailableBrandCheck;
 const nativeProxyBrandCheck = nativeBrandChecks?.isProxy ?? unavailableBrandCheck;
 const nativeUint8ArrayBrandCheck = nativeBrandChecks?.isUint8Array ?? unavailableBrandCheck;
-function hasOwn(object, key) {
-    return apply(objectHasOwnProperty, object, [key]);
-}
+/**
+ * Whether this runtime can distinguish Proxy values without evaluating a trap.
+ * Callers that need a fail-closed guarantee must not treat a `false` result
+ * from {@link isProxyWithoutHooks} as proof when this capability is absent.
+ */
+export const canIdentifyProxyWithoutHooks = nativeBrandChecks !== undefined;
 function createDataDescriptor(value) {
     const descriptor = createObject(null);
     descriptor.configurable = true;
@@ -219,7 +249,12 @@ export function readNativeErrorNameWithoutHooks(error) {
         return "Error";
     }
 }
-/** Identify a Proxy without evaluating any trap on the proxied value. */
+/**
+ * Identify a Proxy without evaluating any trap on the proxied value.
+ *
+ * Returns `false` without inspecting `value` when
+ * {@link canIdentifyProxyWithoutHooks} is false.
+ */
 export function isProxyWithoutHooks(value) {
     return nativeProxyBrandCheck(value);
 }

package/esm/src/platform/compat/path/basic-operations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"basic-operations.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/path/basic-operations.ts"],"names":[],"mappings":"AAgBA,yEAAyE;AACzE,wBAAgB,IAAI,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAQ/C;AAED,wCAAwC;AACxC,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI5C;AAED,oCAAoC;AACpC,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAK3D;AAED,4CAA4C;AAC5C,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI5C"}
+{"version":3,"file":"basic-operations.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/path/basic-operations.ts"],"names":[],"mappings":"AAqBA,yEAAyE;AACzE,wBAAgB,IAAI,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAU/C;AAED,wCAAwC;AACxC,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI5C;AAED,oCAAoC;AACpC,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAK3D;AAED,4CAA4C;AAC5C,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI5C"}

package/esm/src/platform/compat/path/basic-operations.js

@@ -1,11 +1,15 @@
 import { hasWindowsLikePath, portableBasename, portableDirname, portableExtname, portableJoin, removeTrailingSeparatorsExceptRoot, runtimeUsesWindowsPaths, toPortableSeparators, } from "./portable.js";
 import { getNativePathImplementation } from "./runtime.js";
+const ArrayPrototypeEvery = Array.prototype.every;
+const ArrayPrototypeSome = Array.prototype.some;
+const ReflectApply = Reflect.apply;
 function usesWindowsFlavor(paths) {
-    return runtimeUsesWindowsPaths() || paths.some(hasWindowsLikePath);
+    return runtimeUsesWindowsPaths() ||
+        ReflectApply(ArrayPrototypeSome, paths, [hasWindowsLikePath]);
 }
 /** Join and normalize path segments using their detected path flavor. */
 export function join(...paths) {
-    if (paths.every((path) => path.length === 0))
+    if (ReflectApply(ArrayPrototypeEvery, paths, [(path) => path.length === 0]))
         return "/";
     const windows = usesWindowsFlavor(paths);
     const pathApi = getNativePathImplementation(windows);

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

@@ -1 +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"}
+{"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;AAoD7C,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEzD;AA2FD,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,CAkCR;AAED,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,OAAO,GACf,MAAM,CAiCR;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

@@ -1,15 +1,44 @@
 import * as dntShim from "../../../../_dnt.shims.js";
+import { primordialArrayAt as arrayAt, primordialArrayFilter as arrayFilter, primordialArrayJoin as arrayJoin, primordialArrayPop as arrayPop, primordialArrayPush as arrayPush, } from "../primordials/array.js";
+const apply = Reflect.apply;
+const arraySlice = Array.prototype.slice;
+const regExpExec = RegExp.prototype.exec;
+const stringEndsWith = String.prototype.endsWith;
+const stringIncludes = String.prototype.includes;
+const stringLastIndexOf = String.prototype.lastIndexOf;
+const stringReplaceAll = String.prototype.replaceAll;
+const stringSlice = String.prototype.slice;
+const stringSplit = String.prototype.split;
+const stringStartsWith = String.prototype.startsWith;
+const stringToLowerCase = String.prototype.toLowerCase;
+function includes(value, search) {
+    return apply(stringIncludes, value, [search]);
+}
+function startsWith(value, search) {
+    return apply(stringStartsWith, value, [search]);
+}
+function endsWith(value, search) {
+    return apply(stringEndsWith, value, [search]);
+}
+function slice(value, start, end) {
+    return apply(stringSlice, value, end === undefined ? [start] : [start, end]);
+}
+function lastIndexOf(value, search) {
+    return apply(stringLastIndexOf, value, [search]);
+}
+function matches(pattern, value) {
+    return apply(regExpExec, pattern, [value]);
+}
 export function hasWindowsLikePath(path) {
-    return path.includes("\\") ||
-        /^[A-Za-z]:/.test(path);
+    return includes(path, "\\") || matches(/^[A-Za-z]:/, path) !== null;
 }
 export function toPortableSeparators(path) {
-    return path.replaceAll("\\", "/");
+    return apply(stringReplaceAll, path, ["\\", "/"]);
 }
 function analyzeRoot(path, windows) {
     const portable = toPortableSeparators(path);
     if (windows) {
-        const unc = portable.match(/^\/\/([^/]+)\/+([^/]+)(\/+(.*))?$/);
+        const unc = matches(/^\/\/([^/]+)\/+([^/]+)(\/+(.*))?$/, portable);
         if (unc?.[1] && unc[2]) {
             const device = `//${unc[1]}/${unc[2]}`;
             return {
@@ -19,7 +48,7 @@ function analyzeRoot(path, windows) {
                 root: unc[3] === undefined ? device : `${device}/`,
             };
         }
-        const drive = portable.match(/^([A-Za-z]:)(\/+)?(.*)$/);
+        const drive = matches(/^([A-Za-z]:)(\/+)?(.*)$/, portable);
         if (drive?.[1] !== undefined) {
             const absolute = drive[2] !== undefined;
             return {
@@ -30,11 +59,14 @@ function analyzeRoot(path, windows) {
             };
         }
     }
-    if (portable.startsWith("/")) {
+    if (startsWith(portable, "/")) {
+        let restStart = 0;
+        while (portable[restStart] === "/")
+            restStart++;
         return {
             absolute: true,
             device: "",
-            rest: portable.replace(/^\/+/, ""),
+            rest: slice(portable, restStart),
             root: "/",
         };
     }
@@ -51,25 +83,30 @@ function appendRoot(root, tail) {
     if (!root.absolute)
         return `${root.root}${tail || "."}`;
     if (!tail) {
-        return root.device.startsWith("//") ? `${root.device}/` : root.root;
+        return startsWith(root.device, "//") ? `${root.device}/` : root.root;
     }
-    return root.root.endsWith("/") ? `${root.root}${tail}` : `${root.root}/${tail}`;
+    return endsWith(root.root, "/") ? `${root.root}${tail}` : `${root.root}/${tail}`;
 }
 function normalizeTail(rest, absolute) {
     const normalized = [];
-    for (const segment of rest.split("/")) {
+    const segments = apply(stringSplit, rest, ["/"]);
+    // Path normalization is reached by shared-runtime coordination after tenant
+    // code has loaded. Avoid the live Array iterator so post-import prototype
+    // mutation cannot turn canonical lockfile lookup into a process-wide outage.
+    for (let index = 0; index < segments.length; index++) {
+        const segment = segments[index];
         if (segment === "" || segment === ".")
             continue;
         if (segment !== "..") {
-            normalized.push(segment);
+            arrayPush(normalized, segment);
             continue;
         }
-        const previous = normalized.at(-1);
+        const previous = arrayAt(normalized, -1);
         if (previous !== undefined && previous !== "..") {
-            normalized.pop();
+            arrayPop(normalized);
         }
         else if (!absolute) {
-            normalized.push("..");
+            arrayPush(normalized, "..");
         }
     }
     return normalized;
@@ -80,15 +117,15 @@ function canonicalPath(path, windows) {
 export function removeTrailingSeparatorsExceptRoot(path, windows) {
     const root = analyzeRoot(path, windows);
     let canonical = canonicalPath(path, windows);
-    while (canonical.endsWith("/") &&
+    while (endsWith(canonical, "/") &&
         canonical.length > root.root.length) {
-        canonical = canonical.slice(0, -1);
+        canonical = slice(canonical, 0, -1);
     }
     return canonical;
 }
 function rootKey(root, windows) {
     const value = root.device || root.root;
-    return windows ? value.toLowerCase() : value;
+    return windows ? apply(stringToLowerCase, value, []) : value;
 }
 export function runtimeUsesWindowsPaths() {
     const runtime = dntShim.dntGlobalThis;
@@ -121,44 +158,44 @@ export function portableNormalize(path, windows) {
     if (path === "")
         return ".";
     const root = analyzeRoot(path, windows);
-    const tail = normalizeTail(root.rest, root.absolute).join("/");
+    const tail = arrayJoin(normalizeTail(root.rest, root.absolute), "/");
     let result = appendRoot(root, tail);
-    const hadTrailingSeparator = /[\\/]$/.test(path);
+    const hadTrailingSeparator = matches(/[\\/]$/, path) !== null;
     if (hadTrailingSeparator && result === ".")
         return "./";
     if (hadTrailingSeparator &&
         result !== root.root &&
-        !result.endsWith("/")) {
+        !endsWith(result, "/")) {
         result += "/";
     }
     return result;
 }
 export function portableJoin(paths, windows) {
-    const nonempty = paths.filter((path) => path.length > 0);
+    const nonempty = arrayFilter(paths, (path) => path.length > 0);
     if (nonempty.length === 0)
         return "/";
-    return portableNormalize(nonempty.join("/"), windows);
+    return portableNormalize(arrayJoin(nonempty, "/"), windows);
 }
 export function portableDirname(path, windows) {
     if (path.length === 0)
         return ".";
     const root = analyzeRoot(path, windows);
     let canonical = canonicalPath(path, windows);
-    while (canonical.endsWith("/") &&
+    while (endsWith(canonical, "/") &&
         canonical.length > root.root.length) {
-        canonical = canonical.slice(0, -1);
+        canonical = slice(canonical, 0, -1);
     }
     if (canonical === root.root || canonical === root.device) {
         return root.root || root.device || ".";
     }
-    const lastSeparator = canonical.lastIndexOf("/");
+    const lastSeparator = lastIndexOf(canonical, "/");
     if (lastSeparator === -1)
         return root.device || ".";
     if (lastSeparator < root.root.length)
         return root.root || "/";
     if (lastSeparator === 0)
         return "/";
-    return canonical.slice(0, lastSeparator);
+    return slice(canonical, 0, lastSeparator);
 }
 export function portableBasename(path, ext, windows) {
     if (path.length === 0)
@@ -168,44 +205,45 @@ export function portableBasename(path, ext, windows) {
     const originalPath = canonical;
     if (ext !== undefined && ext !== "" && ext === originalPath)
         return "";
-    while (canonical.endsWith("/") &&
+    while (endsWith(canonical, "/") &&
         canonical.length > root.root.length) {
-        canonical = canonical.slice(0, -1);
+        canonical = slice(canonical, 0, -1);
     }
     if (windows &&
-        root.device.startsWith("//") &&
+        startsWith(root.device, "//") &&
         root.rest === "") {
-        return root.device.slice(root.device.lastIndexOf("/") + 1);
+        return slice(root.device, lastIndexOf(root.device, "/") + 1);
     }
     if (canonical === root.root || canonical === root.device)
         return "";
-    const lastSeparator = canonical.lastIndexOf("/");
-    let base = canonical.slice(lastSeparator + 1);
+    const lastSeparator = lastIndexOf(canonical, "/");
+    let base = slice(canonical, lastSeparator + 1);
     if (!root.absolute &&
         root.device &&
         lastSeparator === -1 &&
-        base.startsWith(root.device)) {
-        base = base.slice(root.device.length);
+        startsWith(base, root.device)) {
+        base = slice(base, root.device.length);
     }
-    if (ext !== undefined && ext !== "" && base.endsWith(ext)) {
+    if (ext !== undefined && ext !== "" && endsWith(base, ext)) {
         if (ext.length < base.length)
-            return base.slice(0, -ext.length);
+            return slice(base, 0, -ext.length);
     }
     return base;
 }
 export function portableExtname(path, windows) {
     const base = portableBasename(path, undefined, windows);
-    const lastDot = base.lastIndexOf(".");
+    const lastDot = lastIndexOf(base, ".");
     if (lastDot <= 0 || base === "." || base === "..")
         return "";
-    return base.slice(lastDot);
+    return slice(base, lastDot);
 }
 export function portableIsAbsolute(path, windows) {
     return analyzeRoot(path, windows).absolute;
 }
 export function portableResolve(paths, windows) {
     let resolved = runtimeCwd();
-    for (const rawPath of paths) {
+    for (let index = 0; index < paths.length; index++) {
+        const rawPath = paths[index];
         if (rawPath.length === 0)
             continue;
         const path = toPortableSeparators(rawPath);
@@ -228,10 +266,10 @@ export function portableResolve(paths, windows) {
     }
     const normalized = portableNormalize(resolved, windows);
     const root = analyzeRoot(normalized, windows);
-    if (normalized.endsWith("/") &&
+    if (endsWith(normalized, "/") &&
         normalized !== root.root &&
         normalized !== `${root.device}/`) {
-        return normalized.slice(0, -1);
+        return slice(normalized, 0, -1);
     }
     return normalized;
 }
@@ -249,34 +287,40 @@ export function portableRelative(from, to, windows) {
     while (common < fromParts.length && common < toParts.length) {
         const fromPart = fromParts[common];
         const toPart = toParts[common];
-        const equal = windows ? fromPart.toLowerCase() === toPart.toLowerCase() : fromPart === toPart;
+        const equal = windows
+            ? apply(stringToLowerCase, fromPart, []) === apply(stringToLowerCase, toPart, [])
+            : fromPart === toPart;
         if (!equal)
             break;
         common++;
     }
-    const result = [
-        ...Array.from({ length: fromParts.length - common }, () => ".."),
-        ...toParts.slice(common),
-    ];
-    return result.join("/") || ".";
+    const result = [];
+    for (let index = common; index < fromParts.length; index++) {
+        arrayPush(result, "..");
+    }
+    const remainingToParts = apply(arraySlice, toParts, [common]);
+    for (let index = 0; index < remainingToParts.length; index++) {
+        arrayPush(result, remainingToParts[index]);
+    }
+    return arrayJoin(result, "/") || ".";
 }
 export function portableParse(path, windows) {
     const root = analyzeRoot(path, windows);
     let canonical = canonicalPath(path, windows);
-    while (canonical.endsWith("/") &&
+    while (endsWith(canonical, "/") &&
         canonical.length > root.root.length) {
-        canonical = canonical.slice(0, -1);
+        canonical = slice(canonical, 0, -1);
     }
-    const base = windows && root.device.startsWith("//") && root.rest === ""
+    const base = windows && startsWith(root.device, "//") && root.rest === ""
         ? ""
         : portableBasename(canonical, undefined, windows);
     const ext = portableExtname(base, windows);
-    const name = base.slice(0, base.length - ext.length);
+    const name = slice(base, 0, base.length - ext.length);
     let dir = "";
     if (base === "") {
         dir = root.root;
     }
-    else if (canonical.includes("/") ||
+    else if (includes(canonical, "/") ||
         (windows && root.device !== "")) {
         dir = portableDirname(canonical, windows);
     }
@@ -292,7 +336,7 @@ 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 ext = rawExt && !startsWith(rawExt, ".") ? `.${rawExt}` : rawExt;
     const base = pathObject.base ||
         `${pathObject.name ?? ""}${ext}`;
     const directory = dir || root;
@@ -300,7 +344,7 @@ export function portableFormat(pathObject, windows) {
         return base;
     if (!base)
         return directory;
-    if (directory.endsWith("/") || (windows && /^[A-Za-z]:$/.test(directory))) {
+    if (endsWith(directory, "/") || (windows && matches(/^[A-Za-z]:$/, directory) !== null)) {
         return `${directory}${base}`;
     }
     return `${directory}/${base}`;

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":"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"}
+{"version":3,"file":"resolution.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/path/resolution.ts"],"names":[],"mappings":"AAsBA,6DAA6D;AAC7D,wBAAgB,OAAO,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAMlD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAMhD;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAOzD;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAW9C"}