@veryfront/ext-content-mdx 0.1.1190 → 0.1.1192

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"}

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

@@ -1,26 +1,35 @@
 import { hasWindowsLikePath, portableIsAbsolute, portableNormalize, portableRelative, portableResolve, removeTrailingSeparatorsExceptRoot, runtimeUsesWindowsPaths, toPortableSeparators, } from "./portable.js";
 import { getNativePathImplementation } from "./runtime.js";
+const apply = Reflect.apply;
 function usesWindowsFlavor(paths) {
-    return runtimeUsesWindowsPaths() || paths.some(hasWindowsLikePath);
+    if (runtimeUsesWindowsPaths())
+        return true;
+    for (let index = 0; index < paths.length; index++) {
+        if (hasWindowsLikePath(paths[index]))
+            return true;
+    }
+    return false;
 }
 /** Resolve path segments to an absolute, normalized path. */
 export function resolve(...paths) {
     const windows = usesWindowsFlavor(paths);
     const pathApi = getNativePathImplementation(windows);
     return pathApi
-        ? toPortableSeparators(pathApi.resolve(...paths))
+        ? toPortableSeparators(apply(pathApi.resolve, pathApi, paths))
         : portableResolve(paths, windows);
 }
 export function isAbsolute(path) {
     const windows = usesWindowsFlavor([path]);
     const pathApi = getNativePathImplementation(windows);
-    return pathApi?.isAbsolute(path) ?? portableIsAbsolute(path, windows);
+    return pathApi
+        ? apply(pathApi.isAbsolute, pathApi, [path])
+        : portableIsAbsolute(path, windows);
 }
 export function relative(from, to) {
     const windows = usesWindowsFlavor([from, to]);
     const pathApi = getNativePathImplementation(windows);
     const result = pathApi
-        ? toPortableSeparators(pathApi.relative(from, to))
+        ? toPortableSeparators(apply(pathApi.relative, pathApi, [from, to]))
         : portableRelative(from, to, windows);
     return result || ".";
 }
@@ -28,7 +37,7 @@ export function normalize(path) {
     const windows = usesWindowsFlavor([path]);
     const pathApi = getNativePathImplementation(windows);
     const normalized = pathApi
-        ? toPortableSeparators(pathApi.normalize(path))
+        ? toPortableSeparators(apply(pathApi.normalize, pathApi, [path]))
         : portableNormalize(path, windows);
     // The established Veryfront facade contract returns canonical paths without
     // a trailing separator, except for filesystem roots. Enforce that

package/esm/src/platform/compat/primordials/array.d.ts

@@ -0,0 +1,8 @@
+export declare function primordialArrayAt<T>(values: readonly T[], index: number): T | undefined;
+export declare function primordialArrayFilter<T>(values: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => unknown): T[];
+export declare function primordialArrayJoin(values: readonly unknown[], separator: string): string;
+export declare function primordialArrayMap<T, U>(values: readonly T[], callback: (value: T, index: number, array: readonly T[]) => U): U[];
+export declare function primordialArrayPop<T>(values: T[]): T | undefined;
+export declare function primordialArrayPush<T>(values: T[], value: T): void;
+export declare function primordialArraySort<T>(values: T[], compare: (left: T, right: T) => number): T[];
+//# sourceMappingURL=array.d.ts.map

package/esm/src/platform/compat/primordials/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/primordials/array.ts"],"names":[],"mappings":"AAaA,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,MAAM,EAAE,SAAS,CAAC,EAAE,EACpB,KAAK,EAAE,MAAM,GACZ,CAAC,GAAG,SAAS,CAEf;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,MAAM,EAAE,SAAS,CAAC,EAAE,EACpB,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,OAAO,GACnE,CAAC,EAAE,CAEL;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,OAAO,EAAE,EAC1B,SAAS,EAAE,MAAM,GAChB,MAAM,CAER;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,CAAC,EACrC,MAAM,EAAE,SAAS,CAAC,EAAE,EACpB,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,CAAC,GAC5D,CAAC,EAAE,CAEL;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,CAAC,GAAG,SAAS,CAEhE;AAED,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAElE;AAED,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,MAAM,EAAE,CAAC,EAAE,EACX,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,GACrC,CAAC,EAAE,CAEL"}

package/esm/src/platform/compat/primordials/array.js

@@ -0,0 +1,33 @@
+// Capture shared array intrinsics once, before project code can replace mutable
+// prototype methods in a long-lived runtime. Keep this module dependency-free so
+// low-level compatibility code and higher framework layers can use the same
+// trusted operations without introducing an import cycle.
+const ArrayPrototypeAt = Array.prototype.at;
+const ArrayPrototypeFilter = Array.prototype.filter;
+const ArrayPrototypeJoin = Array.prototype.join;
+const ArrayPrototypeMap = Array.prototype.map;
+const ArrayPrototypePop = Array.prototype.pop;
+const ArrayPrototypePush = Array.prototype.push;
+const ArrayPrototypeSort = Array.prototype.sort;
+const ReflectApply = Reflect.apply;
+export function primordialArrayAt(values, index) {
+    return ReflectApply(ArrayPrototypeAt, values, [index]);
+}
+export function primordialArrayFilter(values, predicate) {
+    return ReflectApply(ArrayPrototypeFilter, values, [predicate]);
+}
+export function primordialArrayJoin(values, separator) {
+    return ReflectApply(ArrayPrototypeJoin, values, [separator]);
+}
+export function primordialArrayMap(values, callback) {
+    return ReflectApply(ArrayPrototypeMap, values, [callback]);
+}
+export function primordialArrayPop(values) {
+    return ReflectApply(ArrayPrototypePop, values, []);
+}
+export function primordialArrayPush(values, value) {
+    ReflectApply(ArrayPrototypePush, values, [value]);
+}
+export function primordialArraySort(values, compare) {
+    return ReflectApply(ArrayPrototypeSort, values, [compare]);
+}

package/esm/src/transforms/import-rewriter/url-builder.d.ts

@@ -66,6 +66,12 @@ export declare function appendSameOriginDependencyPinningPathKey(url: string, de
  * Foreign origins and flag-off requests are preserved byte-for-byte.
  */
 export declare function appendSameOriginSSRDependencyPinningKey(url: string, dependencyPinningCacheKey?: string, moduleServerOrigin?: string): string;
+/**
+ * Bind a same-origin absolute module URL to an SSR dependency snapshot using
+ * the module-server path transport. Use this only when the consumer resolves
+ * `/_vf_modules/` paths through the module server instead of generic fetch.
+ */
+export declare function appendSameOriginSSRDependencyPinningPathKey(url: string, dependencyPinningCacheKey?: string, moduleServerOrigin?: string): string;
 export interface ExtractedDependencyPinningPath {
     pathname: string;
     cacheKey?: string;

package/esm/src/transforms/import-rewriter/url-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"url-builder.d.ts","sourceRoot":"","sources":["../../../../src/src/transforms/import-rewriter/url-builder.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,WAAW,CAAC;AAE9C,2BAA2B;AAC3B,eAAO,MAAM,gBAAgB,UAAU,CAAC;AAExC,kEAAkE;AAClE,eAAO,MAAM,eAAe,UAAU,CAAC;AAEvC,KAAK,YAAY,GAAG;IAClB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,YAAY,GACrB,MAAM,CAqBR;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,OAAO,GAAG,WAAW,EAC1B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,EAChB,QAAQ,UAAQ,GACf,MAAM,CAKR;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAWzE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAI1E;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,MAAM,EACX,yBAAyB,CAAC,EAAE,MAAM,GACjC,MAAM,CAcR;AAeD;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,MAAM,EACX,yBAAyB,CAAC,EAAE,MAAM,GACjC,MAAM,CA4CR;AAED;;;GAGG;AACH,wBAAgB,wCAAwC,CACtD,GAAG,EAAE,MAAM,EACX,yBAAyB,CAAC,EAAE,MAAM,EAClC,kBAAkB,CAAC,EAAE,MAAM,GAC1B,MAAM,CA8BR;AAED;;;GAGG;AACH,wBAAgB,uCAAuC,CACrD,GAAG,EAAE,MAAM,EACX,yBAAyB,CAAC,EAAE,MAAM,EAClC,kBAAkB,CAAC,EAAE,MAAM,GAC1B,MAAM,CAwBR;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,MAAM,GACf,8BAA8B,CA4ChC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GAAG,IAAI,EACtB,IAAI,EAAE,MAAM,GACX,MAAM,CAIR;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG5D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAGhG;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE/C;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAgDtE"}
+{"version":3,"file":"url-builder.d.ts","sourceRoot":"","sources":["../../../../src/src/transforms/import-rewriter/url-builder.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,WAAW,CAAC;AAE9C,2BAA2B;AAC3B,eAAO,MAAM,gBAAgB,UAAU,CAAC;AAExC,kEAAkE;AAClE,eAAO,MAAM,eAAe,UAAU,CAAC;AAEvC,KAAK,YAAY,GAAG;IAClB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B,CAAC;AA0BF;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,YAAY,GACrB,MAAM,CAQR;AAgBD;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,OAAO,GAAG,WAAW,EAC1B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,EAChB,QAAQ,UAAQ,GACf,MAAM,CAKR;AAYD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAazE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAI1E;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,MAAM,EACX,yBAAyB,CAAC,EAAE,MAAM,GACjC,MAAM,CAcR;AA4CD;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,MAAM,EACX,yBAAyB,CAAC,EAAE,MAAM,GACjC,MAAM,CAqCR;AAED;;;GAGG;AACH,wBAAgB,wCAAwC,CACtD,GAAG,EAAE,MAAM,EACX,yBAAyB,CAAC,EAAE,MAAM,EAClC,kBAAkB,CAAC,EAAE,MAAM,GAC1B,MAAM,CA8BR;AAED;;;GAGG;AACH,wBAAgB,uCAAuC,CACrD,GAAG,EAAE,MAAM,EACX,yBAAyB,CAAC,EAAE,MAAM,EAClC,kBAAkB,CAAC,EAAE,MAAM,GAC1B,MAAM,CA0BR;AAED;;;;GAIG;AACH,wBAAgB,2CAA2C,CACzD,GAAG,EAAE,MAAM,EACX,yBAAyB,CAAC,EAAE,MAAM,EAClC,kBAAkB,CAAC,EAAE,MAAM,GAC1B,MAAM,CA8BR;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,MAAM,GACf,8BAA8B,CAmChC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GAAG,IAAI,EACtB,IAAI,EAAE,MAAM,GACX,MAAM,CAIR;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG5D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAGhG;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE/C;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAgDtE"}

package/esm/src/transforms/import-rewriter/url-builder.js

@@ -4,6 +4,7 @@
  * Single source of truth for all URL generation.
  * Ensures consistent URLs across SSR and browser for hydration parity.
  */
+import { primordialArrayJoin as arrayJoin, primordialArrayPush as arrayPush, } from "../../platform/compat/primordials/array.js";
 /**
  * Default React version - used when not specified.
  *
@@ -17,6 +18,24 @@ export const DEFAULT_REACT_VERSION = "19.2.4";
 export const TAILWIND_VERSION = "4.1.8";
 /** csstype version - must match deno.json for type consistency */
 export const CSSTYPE_VERSION = "3.2.3";
+const ObjectEntries = Object.entries;
+function buildEsmShParams(options) {
+    const params = [];
+    if (options?.external?.length) {
+        arrayPush(params, `external=${arrayJoin(options.external, ",")}`);
+    }
+    arrayPush(params, `target=${options?.target ?? "es2022"}`);
+    if (options?.deps) {
+        const deps = [];
+        const entries = ObjectEntries(options.deps);
+        for (let index = 0; index < entries.length; index++) {
+            const [key, value] = entries[index];
+            arrayPush(deps, `${key}@${value}`);
+        }
+        arrayPush(params, `deps=${arrayJoin(deps, ",")}`);
+    }
+    return params;
+}
 /**
  * Build esm.sh URL with proper configuration.
  *
@@ -26,22 +45,21 @@ export const CSSTYPE_VERSION = "3.2.3";
  * @param options - URL options
  */
 export function buildEsmShUrl(pkg, version, subpath, options) {
-    const params = [];
-    if (options?.external?.length) {
-        params.push(`external=${options.external.join(",")}`);
-    }
-    params.push(`target=${options?.target ?? "es2022"}`);
-    if (options?.deps) {
-        const depsStr = Object.entries(options.deps)
-            .map(([k, v]) => `${k}@${v}`)
-            .join(",");
-        params.push(`deps=${depsStr}`);
-    }
+    const params = buildEsmShParams(options);
     const versionStr = version ? `@${version}` : "";
     const pathStr = subpath ?? "";
-    const queryStr = params.length ? `?${params.join("&")}` : "";
+    const queryStr = params.length ? `?${arrayJoin(params, "&")}` : "";
     return `https://esm.sh/${pkg}${versionStr}${pathStr}${queryStr}`;
 }
+/**
+ * Build an esm.sh package-prefix URL. esm.sh's `&option/` form keeps the
+ * trailing slash required by the import-map prefix-matching algorithm.
+ */
+function buildEsmShPrefixUrl(pkg, version, options) {
+    const params = buildEsmShParams(options);
+    const optionStr = params.length ? `&${arrayJoin(params, "&")}` : "";
+    return `https://esm.sh/${pkg}@${version}${optionStr}/`;
+}
 /**
  * Build React esm.sh URL.
  * Uses deps=csstype for type consistency.
@@ -52,6 +70,12 @@ export function buildReactUrl(pkg, version, subpath, external = false) {
         deps: { csstype: CSSTYPE_VERSION },
     });
 }
+function buildReactPrefixUrl(pkg, version) {
+    return buildEsmShPrefixUrl(pkg, version, {
+        external: ["react"],
+        deps: { csstype: CSSTYPE_VERSION },
+    });
+}
 /**
  * Get complete React import map for a specific version.
  */
@@ -63,8 +87,10 @@ export function getReactImportMap(version) {
         "react-dom/server": buildReactUrl("react-dom", version, "/server", true),
         "react/jsx-runtime": buildReactUrl("react", version, "/jsx-runtime", true),
         "react/jsx-dev-runtime": buildReactUrl("react", version, "/jsx-dev-runtime", true),
-        // Prefix match for any react/* subpath imports
-        "react/": buildReactUrl("react", version, "/", true),
+        // Prefix matches cover future package exports without allowing a project
+        // import map to redirect React or ReactDOM subpaths.
+        "react/": buildReactPrefixUrl("react", version),
+        "react-dom/": buildReactPrefixUrl("react-dom", version),
     };
 }
 /**
@@ -94,6 +120,17 @@ export function appendDependencyPinningKey(url, dependencyPinningCacheKey) {
 const DEPENDENCY_PINNING_PATH_MARKER = "_pins/";
 const MODULE_SERVER_PATH_PREFIXES = ["/_vf_modules/"];
 const DEPENDENCY_PINNING_PATH_KEY_PATTERN = /^on:[A-Za-z0-9._-]+$/;
+function splitUrlComponents(url) {
+    const hashIndex = url.indexOf("#");
+    const hash = hashIndex === -1 ? "" : url.slice(hashIndex);
+    const urlWithoutHash = hashIndex === -1 ? url : url.slice(0, hashIndex);
+    const queryIndex = urlWithoutHash.indexOf("?");
+    return {
+        path: queryIndex === -1 ? urlWithoutHash : urlWithoutHash.slice(0, queryIndex),
+        params: new URLSearchParams(queryIndex === -1 ? "" : urlWithoutHash.slice(queryIndex + 1)),
+        hash,
+    };
+}
 function decodeDependencyPinningPathKey(encodedKey) {
     try {
         const cacheKey = decodeURIComponent(encodedKey);
@@ -103,6 +140,15 @@ function decodeDependencyPinningPathKey(encodedKey) {
         return undefined;
     }
 }
+function hasMalformedPercentEncoding(value) {
+    try {
+        decodeURIComponent(value);
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
 /**
  * Bind an import-map prefix target to a dependency snapshot without adding a
  * query string. Import-map prefix targets must end in `/`; placing the token in
@@ -112,12 +158,7 @@ function decodeDependencyPinningPathKey(encodedKey) {
 export function appendDependencyPinningPathKey(url, dependencyPinningCacheKey) {
     if (!dependencyPinningCacheKey?.startsWith("on:"))
         return url;
-    const hashIndex = url.indexOf("#");
-    const hash = hashIndex === -1 ? "" : url.slice(hashIndex);
-    const urlWithoutHash = hashIndex === -1 ? url : url.slice(0, hashIndex);
-    const queryIndex = urlWithoutHash.indexOf("?");
-    const path = queryIndex === -1 ? urlWithoutHash : urlWithoutHash.slice(0, queryIndex);
-    const params = new URLSearchParams(queryIndex === -1 ? "" : urlWithoutHash.slice(queryIndex + 1));
+    const { path, params, hash } = splitUrlComponents(url);
     for (const prefix of MODULE_SERVER_PATH_PREFIXES) {
         const prefixIndex = path.indexOf(prefix);
         if (prefixIndex === -1)
@@ -187,8 +228,37 @@ export function appendSameOriginSSRDependencyPinningKey(url, dependencyPinningCa
             !target.pathname.startsWith("/_vf_modules/")) {
             return url;
         }
-        target.searchParams.set("ssr", "true");
-        return appendDependencyPinningKey(target.href, dependencyPinningCacheKey);
+        const params = target.searchParams;
+        params.set("pins", dependencyPinningCacheKey);
+        params.set("ssr", "true");
+        return target.toString();
+    }
+    catch {
+        return url;
+    }
+}
+/**
+ * Bind a same-origin absolute module URL to an SSR dependency snapshot using
+ * the module-server path transport. Use this only when the consumer resolves
+ * `/_vf_modules/` paths through the module server instead of generic fetch.
+ */
+export function appendSameOriginSSRDependencyPinningPathKey(url, dependencyPinningCacheKey, moduleServerOrigin) {
+    if (!dependencyPinningCacheKey?.startsWith("on:") ||
+        !moduleServerOrigin ||
+        (!/^https?:\/\//i.test(url) && !url.startsWith("//"))) {
+        return url;
+    }
+    try {
+        const requestOrigin = new URL(moduleServerOrigin);
+        const target = new URL(url, requestOrigin);
+        if (target.origin !== requestOrigin.origin ||
+            !target.pathname.startsWith("/_vf_modules/")) {
+            return url;
+        }
+        const moduleUrl = appendDependencyPinningPathKey(`${target.pathname}${target.search}${target.hash}`, dependencyPinningCacheKey);
+        const { path, params, hash } = splitUrlComponents(moduleUrl);
+        params.set("ssr", "true");
+        return `${path}?${params.toString()}${hash}`;
     }
     catch {
         return url;
@@ -209,6 +279,9 @@ export function extractDependencyPinningPathKey(pathname) {
         const encodedKey = separatorIndex === -1
             ? encodedKeyAndPath
             : encodedKeyAndPath.slice(0, separatorIndex);
+        if (hasMalformedPercentEncoding(encodedKey)) {
+            return { pathname, found: true, malformed: true };
+        }
         const cacheKey = decodeDependencyPinningPathKey(encodedKey);
         if (!cacheKey) {
             return { pathname, found: false, malformed: false };
@@ -218,13 +291,7 @@ export function extractDependencyPinningPathKey(pathname) {
         }
         const modulePath = encodedKeyAndPath.slice(separatorIndex + 1);
         if (modulePath.startsWith(DEPENDENCY_PINNING_PATH_MARKER)) {
-            const nestedKeyEnd = modulePath.indexOf("/", DEPENDENCY_PINNING_PATH_MARKER.length);
-            const nestedEncodedKey = nestedKeyEnd === -1
-                ? modulePath.slice(DEPENDENCY_PINNING_PATH_MARKER.length)
-                : modulePath.slice(DEPENDENCY_PINNING_PATH_MARKER.length, nestedKeyEnd);
-            if (decodeDependencyPinningPathKey(nestedEncodedKey)) {
-                return { pathname, found: true, malformed: true };
-            }
+            return { pathname, found: true, malformed: true };
         }
         return {
             pathname: `${prefix}${modulePath}`,