rwsdk 0.0.83 → 0.0.84

package/dist/runtime/lib/router.d.ts

@@ -6,6 +6,7 @@ export type DocumentProps = RequestInfo & {
 export type RwContext = {
     nonce: string;
     Document: React.FC<DocumentProps>;
+    rscPayload: boolean;
 };
 export type RouteMiddleware = (requestInfo: RequestInfo) => Response | Promise<Response> | void | Promise<void> | Promise<Response | void>;
 type RouteFunction = (requestInfo: RequestInfo) => Response | Promise<Response>;
@@ -17,6 +18,7 @@ export type RouteDefinition = {
     path: string;
     handler: RouteHandler;
 };
+export declare function matchPath(routePath: string, requestPath: string): RequestInfo["params"] | null;
 export declare function defineRoutes(routes: Route[]): {
     routes: Route[];
     handle: ({ request, renderPage, getRequestInfo, onError, runWithRequestInfoOverrides, }: {
@@ -30,5 +32,12 @@ export declare function defineRoutes(routes: Route[]): {
 export declare function route(path: string, handler: RouteHandler): RouteDefinition;
 export declare function index(handler: RouteHandler): RouteDefinition;
 export declare function prefix(prefix: string, routes: ReturnType<typeof route>[]): RouteDefinition[];
-export declare function render(Document: React.FC<DocumentProps>, routes: Route[]): Route[];
+export declare function render(Document: React.FC<DocumentProps>, routes: Route[], 
+/**
+ * @param options - Configuration options for rendering.
+ * @param options.rscPayload - Toggle the RSC payload that's appended to the Document. Disabling this will mean that interactivity no longer works.
+ */
+options?: {
+    rscPayload: boolean;
+}): Route[];
 export {};

package/dist/runtime/lib/router.js

@@ -1,5 +1,18 @@
 import { isValidElementType } from "react-is";
-function matchPath(routePath, requestPath) {
+export function matchPath(routePath, requestPath) {
+    // Check for invalid pattern: multiple colons in a segment (e.g., /:param1:param2/)
+    if (routePath.includes(":")) {
+        const segments = routePath.split("/");
+        for (const segment of segments) {
+            if ((segment.match(/:/g) || []).length > 1) {
+                throw new Error(`Invalid route pattern: segment "${segment}" in "${routePath}" contains multiple colons.`);
+            }
+        }
+    }
+    // Check for invalid pattern: double wildcard (e.g., /**/)
+    if (routePath.indexOf("**") !== -1) {
+        throw new Error(`Invalid route pattern: "${routePath}" contains "**". Use "*" for a single wildcard segment.`);
+    }
     const pattern = routePath
         .replace(/:[a-zA-Z0-9]+/g, "([^/]+)") // Convert :param to capture group
         .replace(/\*/g, "(.*)"); // Convert * to wildcard capture group
@@ -8,18 +21,33 @@ function matchPath(routePath, requestPath) {
     if (!matches) {
         return null;
     }
-    // Extract named parameters and wildcards
+    // Revised parameter extraction:
     const params = {};
-    const paramNames = [...routePath.matchAll(/:[a-zA-Z0-9]+/g)].map((m) => m[0].slice(1));
-    const wildcardCount = (routePath.match(/\*/g) || []).length;
-    // Add named parameters
-    paramNames.forEach((name, i) => {
-        params[name] = matches[i + 1];
-    });
-    // Add wildcard parameters with numeric indices
-    for (let i = 0; i < wildcardCount; i++) {
-        const wildcardIndex = paramNames.length + i + 1;
-        params[`$${i}`] = matches[wildcardIndex];
+    let currentMatchIndex = 1; // Regex matches are 1-indexed
+    // This regex finds either a named parameter token (e.g., ":id") or a wildcard star token ("*").
+    const tokenRegex = /:([a-zA-Z0-9_]+)|\*/g;
+    let matchToken;
+    let wildcardCounter = 0;
+    // Ensure regex starts from the beginning of the routePath for each call if it's stateful (it is with /g)
+    tokenRegex.lastIndex = 0;
+    while ((matchToken = tokenRegex.exec(routePath)) !== null) {
+        // Ensure we have a corresponding match from the regex execution
+        if (matches[currentMatchIndex] === undefined) {
+            // This case should ideally not be hit if routePath and pattern generation are correct
+            // and all parts of the regex matched.
+            // Consider logging a warning or throwing an error if critical.
+            break;
+        }
+        if (matchToken[1]) {
+            // This token is a named parameter (e.g., matchToken[1] is "id" for ":id")
+            params[matchToken[1]] = matches[currentMatchIndex];
+        }
+        else {
+            // This token is a wildcard "*"
+            params[`$${wildcardCounter}`] = matches[currentMatchIndex];
+            wildcardCounter++;
+        }
+        currentMatchIndex++;
     }
     return params;
 }
@@ -104,9 +132,15 @@ export function prefix(prefix, routes) {
         };
     });
 }
-export function render(Document, routes) {
+export function render(Document, routes, 
+/**
+ * @param options - Configuration options for rendering.
+ * @param options.rscPayload - Toggle the RSC payload that's appended to the Document. Disabling this will mean that interactivity no longer works.
+ */
+options = { rscPayload: true }) {
     const documentMiddleware = ({ rw }) => {
         rw.Document = Document;
+        rw.rscPayload = options.rscPayload;
     };
     return [documentMiddleware, ...routes];
 }

package/dist/runtime/lib/router.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/lib/router.test.js

@@ -0,0 +1,58 @@
+import { describe, it, expect } from "vitest";
+import { matchPath } from "./router";
+describe("matchPath", () => {
+    // Test case 1: Static paths
+    it("should match static paths", () => {
+        expect(matchPath("/about/", "/about/")).toEqual({});
+        expect(matchPath("/contact/", "/contact/")).toEqual({});
+    });
+    it("should not match different static paths", () => {
+        expect(matchPath("/about/", "/service/")).toBeNull();
+    });
+    // Test case 2: Paths with parameters
+    it("should match paths with parameters and extract them", () => {
+        expect(matchPath("/users/:id/", "/users/123/")).toEqual({ id: "123" });
+        expect(matchPath("/posts/:category/:slug/", "/posts/tech/my-first-post/")).toEqual({ category: "tech", slug: "my-first-post" });
+    });
+    it("should not match if parameter is missing", () => {
+        expect(matchPath("/users/:id/", "/users/")).toBeNull();
+    });
+    // Test case 3: Paths with wildcards
+    it("should match paths with wildcards and extract them", () => {
+        expect(matchPath("/files/*/", "/files/document.pdf/")).toEqual({
+            $0: "document.pdf",
+        });
+        expect(matchPath("/data/*\/content/", "/data/archive/content/")).toEqual({
+            $0: "archive",
+        });
+        expect(matchPath("/assets/*/*/", "/assets/images/pic.png/")).toEqual({
+            $0: "images",
+            $1: "pic.png",
+        });
+    });
+    it("should match empty wildcard", () => {
+        expect(matchPath("/files/*/", "/files//")).toEqual({ $0: "" });
+    });
+    // Test case 4: Paths with both parameters and wildcards
+    it("should match paths with both parameters and wildcards", () => {
+        expect(matchPath("/products/:productId/*/", "/products/abc/details/more/")).toEqual({ productId: "abc", $0: "details/more" });
+    });
+    // Test case 5: Paths that don't match
+    it("should return null for non-matching paths", () => {
+        expect(matchPath("/specific/path/", "/a/different/path/")).toBeNull();
+    });
+    // Test case 6: Edge cases
+    it("should handle trailing slashes correctly", () => {
+        // Current implementation in defineRoutes adds a trailing slash if missing,
+        // and route() function also enforces it. matchPath itself doesn't normalize.
+        expect(matchPath("/path/", "/path")).toBeNull(); // Path to match must end with /
+        expect(matchPath("/path/", "/path/")).toEqual({});
+    });
+    it("should handle paths with multiple parameters and wildcards interspersed", () => {
+        expect(matchPath("/type/:typeId/item/*/:itemId/*/", "/type/a/item/image/b/thumb/")).toEqual({ typeId: "a", $0: "image", itemId: "b", $1: "thumb" });
+    });
+    it("should not allow named parameters or wildcards in the same path", () => {
+        expect(() => matchPath("/type/:typeId:is:broken", "/type/a-thumb-drive")).toThrow();
+        expect(() => matchPath("/type/**", "/type/a-thumb-drive")).toThrow();
+    });
+});

package/dist/runtime/render/__rwsdk_ssr_bridge.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import ReactServerDom from "react-dom/server.edge";
+import { DocumentProps } from "../lib/router";
+import { RequestInfo } from "../requestInfo/types";
+export declare const renderRscThenableToHtmlStream: ({ thenable, Document, requestInfo, nonce, }: {
+    thenable: any;
+    Document: React.FC<DocumentProps>;
+    requestInfo: RequestInfo;
+    nonce?: string;
+}) => Promise<ReactServerDom.ReactDOMServerReadableStream>;

package/dist/runtime/render/__rwsdk_ssr_bridge.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import ReactServerDom from "react-dom/server.edge";
+const { use } = React;
+const { renderToReadableStream } = ReactServerDom;
+export const renderRscThenableToHtmlStream = ({ thenable, Document, requestInfo, nonce, }) => {
+    const Component = () => (_jsx(Document, { ...requestInfo, children: use(thenable).node }));
+    return renderToReadableStream(_jsx(Component, {}), { nonce });
+};

package/dist/runtime/render/__rwsdkssr_render.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import ReactServerDom from "react-dom/server.edge";
+import { type DocumentProps } from "../lib/router";
+import { type RequestInfo } from "../requestInfo/types";
+export declare const renderRscThenableToHtmlStream: ({ thenable, Document, requestInfo, }: {
+    thenable: any;
+    Document: React.FC<DocumentProps>;
+    requestInfo: RequestInfo;
+}) => Promise<ReactServerDom.ReactDOMServerReadableStream>;

package/dist/runtime/render/__rwsdkssr_render.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import ReactServerDom from "react-dom/server.edge";
+const { use } = React;
+const { renderToReadableStream } = ReactServerDom;
+export const renderRscThenableToHtmlStream = async ({ thenable, Document, requestInfo, }) => {
+    const Component = () => {
+        return (_jsx(Document, { ...requestInfo, children: use(thenable).node }));
+    };
+    return await renderToReadableStream(_jsx(Component, {}), {
+        nonce: requestInfo.rw.nonce,
+    });
+};

package/dist/runtime/render/injectRSCPayload.js

@@ -3,7 +3,7 @@
 const encoder = new TextEncoder();
 const trailer = "</body></html>";
 export function injectRSCPayload(rscStream, { nonce }) {
-    const decoder = new TextDecoder("utf-8");
+    let decoder = new TextDecoder();
     let resolveFlightDataPromise;
     let flightDataPromise = new Promise((resolve) => (resolveFlightDataPromise = resolve));
     let startedRSC = false;
@@ -13,9 +13,12 @@ export function injectRSCPayload(rscStream, { nonce }) {
     let buffered = [];
     let timeout = null;
     function flushBufferedChunks(controller) {
-        for (const chunk of buffered) {
-            const html = decoder.decode(chunk, { stream: true });
-            controller.enqueue(encoder.encode(html));
+        for (let chunk of buffered) {
+            let buf = decoder.decode(chunk);
+            if (buf.endsWith(trailer)) {
+                buf = buf.slice(0, -trailer.length);
+            }
+            controller.enqueue(encoder.encode(buf));
         }
         buffered.length = 0;
         timeout = null;
@@ -42,8 +45,7 @@ export function injectRSCPayload(rscStream, { nonce }) {
                 clearTimeout(timeout);
                 flushBufferedChunks(controller);
             }
-            controller.enqueue(encoder.encode(decoder.decode()));
-            controller.enqueue(encoder.encode(trailer));
+            controller.enqueue(encoder.encode("</body></html>"));
         },
     });
 }

package/dist/runtime/render/ssrBridge.d.ts

@@ -0,0 +1,2 @@
+import { renderToReadableStream } from "react-dom/server.edge";
+export declare const ssrRenderToReadableStream: typeof renderToReadableStream;

package/dist/runtime/render/ssrBridge.js

@@ -0,0 +1,2 @@
+import { renderToReadableStream } from "react-dom/server.edge";
+export const ssrRenderToReadableStream = renderToReadableStream;

package/dist/runtime/render/ssrRenderToReadableStream.d.ts

@@ -0,0 +1,2 @@
+import { renderToReadableStream } from "react-dom/server.edge";
+export declare const ssrRenderToReadableStream: typeof renderToReadableStream;

package/dist/runtime/render/ssrRenderToReadableStream.js

@@ -0,0 +1,2 @@
+import { renderToReadableStream } from "react-dom/server.edge";
+export const ssrRenderToReadableStream = renderToReadableStream;

package/dist/runtime/requestInfo/__rwsdknossr_worker.d.ts

@@ -0,0 +1,5 @@
+import { RequestInfo, DefaultAppContext } from "./types";
+export declare const requestInfo: RequestInfo<DefaultAppContext>;
+export declare function getRequestInfo(): RequestInfo;
+export declare function runWithRequestInfo<Result>(context: Record<string, any>, fn: () => Result): Result;
+export declare function runWithRequestInfoOverrides<Result>(overrides: Record<string, any>, fn: () => Result): Result;

package/dist/runtime/requestInfo/__rwsdknossr_worker.js

@@ -0,0 +1,33 @@
+import { AsyncLocalStorage } from "async_hooks";
+const requestInfoStore = new AsyncLocalStorage();
+const requestInfoBase = {};
+const REQUEST_INFO_KEYS = ["request", "params", "ctx", "headers", "rw", "cf"];
+REQUEST_INFO_KEYS.forEach((key) => {
+    Object.defineProperty(requestInfoBase, key, {
+        enumerable: true,
+        configurable: false,
+        get: function () {
+            const store = requestInfoStore.getStore();
+            return store ? store[key] : undefined;
+        },
+    });
+});
+export const requestInfo = Object.freeze(requestInfoBase);
+export function getRequestInfo() {
+    const store = requestInfoStore.getStore();
+    if (!store) {
+        throw new Error("Request context not found");
+    }
+    return store;
+}
+export function runWithRequestInfo(context, fn) {
+    return requestInfoStore.run(context, fn);
+}
+export function runWithRequestInfoOverrides(overrides, fn) {
+    const requestInfo = requestInfoStore.getStore();
+    const newRequestInfo = {
+        ...requestInfo,
+        ...overrides,
+    };
+    return requestInfoStore.run(newRequestInfo, fn);
+}

package/dist/runtime/worker.js

@@ -37,6 +37,7 @@ export const defineApp = (routes) => {
                 const rw = {
                     Document: DefaultDocument,
                     nonce: generateNonce(),
+                    rscPayload: true,
                 };
                 const outerRequestInfo = {
                     request,
@@ -104,9 +105,12 @@ export const defineApp = (routes) => {
                         Parent: ({ children }) => (_jsx(rw.Document, { ...requestInfo, children: children })),
                         nonce: rw.nonce,
                     });
-                    const html = htmlStream.pipeThrough(injectRSCPayload(rscPayloadStream2, {
-                        nonce: rw.nonce,
-                    }));
+                    let html = htmlStream;
+                    if (rw.rscPayload) {
+                        html = htmlStream.pipeThrough(injectRSCPayload(rscPayloadStream2, {
+                            nonce: rw.nonce,
+                        }));
+                    }
                     return new Response(html, {
                         headers: {
                             "content-type": "text/html; charset=utf-8",

package/dist/vite/aliasedModuleResolver.d.mts

@@ -0,0 +1,9 @@
+export declare function createAliasedModuleResolver({ getAliases, roots, conditionNames, name, }: {
+    getAliases?: () => Array<{
+        find: string | RegExp;
+        replacement: string;
+    }>;
+    roots: string[];
+    conditionNames?: string[];
+    name?: string;
+}): (request: string, importer: string) => string | false;

package/dist/vite/aliasedModuleResolver.mjs

@@ -0,0 +1,62 @@
+import path from "path";
+import enhancedResolve from "enhanced-resolve";
+import debug from "debug";
+function applyAlias(request, aliasEntries, name) {
+    if (!aliasEntries)
+        return request;
+    const logPrefix = `[${name}]`;
+    // Support both array and object forms
+    const entries = Array.isArray(aliasEntries)
+        ? aliasEntries
+        : Object.entries(aliasEntries).map(([find, replacement]) => ({
+            find,
+            replacement,
+        }));
+    for (const entry of entries) {
+        const { find, replacement } = entry;
+        if (typeof find === "string") {
+            if (request === find || request.startsWith(find + "/")) {
+                debug("rwsdk:vite:aliased-module-resolver")("%s [applyAlias] Matched string alias: '%s' -> '%s' for request '%s'", logPrefix, find, replacement, request);
+                return replacement + request.slice(find.length);
+            }
+        }
+        else if (find instanceof RegExp) {
+            if (find.test(request)) {
+                debug("rwsdk:vite:aliased-module-resolver")("%s [applyAlias] Matched RegExp alias: %O -> '%s' for request '%s'", logPrefix, find, replacement, request);
+                return request.replace(find, replacement);
+            }
+        }
+    }
+    return request;
+}
+export function createAliasedModuleResolver({ getAliases, roots, conditionNames = ["workerd", "edge", "import", "default"], name = "aliasedModuleResolver", }) {
+    const log = debug("rwsdk:vite:aliased-module-resolver");
+    const logPrefix = `[${name}]`;
+    // Create a resolver instance with the provided conditionNames
+    const baseModuleResolver = enhancedResolve.create.sync({
+        conditionNames,
+    });
+    return function resolveModule(request, importer) {
+        log("%s Called with request: '%s', importer: '%s'", logPrefix, request, importer);
+        const aliasEntries = getAliases ? getAliases() : [];
+        log("%s Alias entries: %O", logPrefix, aliasEntries);
+        const normalized = applyAlias(request, aliasEntries, name);
+        log("%s After aliasing: '%s'", logPrefix, normalized);
+        const result = baseModuleResolver(normalized, path.dirname(importer));
+        if (result) {
+            log("%s Resolved %s relative to: '%s'", logPrefix, result, importer);
+            return result;
+        }
+        for (const root of roots) {
+            try {
+                const result = baseModuleResolver(root, normalized);
+                log("%s Resolved %s to: '%s' with root '%s'", logPrefix, normalized, result, root);
+                return result;
+            }
+            catch (err) {
+                log("%s Resolution failed for '%s' from root '%s': %O", logPrefix, normalized, root, err);
+            }
+        }
+        return false;
+    };
+}

package/dist/vite/aliasedSSRResolver.d.mts

@@ -0,0 +1,5 @@
+export declare function createAliasedSSRResolver({ getResolveConfig, roots, name, }: {
+    getResolveConfig: () => any;
+    roots: string[];
+    name?: string;
+}): (request: string, importer: string) => string | false;

package/dist/vite/aliasedSSRResolver.mjs

@@ -0,0 +1,74 @@
+import path from "path";
+import enhancedResolve from "enhanced-resolve";
+import debug from "debug";
+const baseSSRResolver = enhancedResolve.create.sync({
+    conditionNames: ["workerd", "edge", "import", "default"],
+});
+function applyAlias(request, aliasEntries, name) {
+    if (!aliasEntries)
+        return request;
+    const logPrefix = `[${name}]`;
+    // Support both array and object forms
+    const entries = Array.isArray(aliasEntries)
+        ? aliasEntries
+        : Object.entries(aliasEntries).map(([find, replacement]) => ({
+            find,
+            replacement,
+        }));
+    for (const entry of entries) {
+        const { find, replacement } = entry;
+        if (typeof find === "string") {
+            if (request === find || request.startsWith(find + "/")) {
+                debug("rwsdk:vite:aliased-ssr-resolver")("%s [applyAlias] Matched string alias: '%s' -> '%s' for request '%s'", logPrefix, find, replacement, request);
+                return replacement + request.slice(find.length);
+            }
+        }
+        else if (find instanceof RegExp) {
+            if (find.test(request)) {
+                debug("rwsdk:vite:aliased-ssr-resolver")("%s [applyAlias] Matched RegExp alias: %O -> '%s' for request '%s'", logPrefix, find, replacement, request);
+                return request.replace(find, replacement);
+            }
+        }
+    }
+    return request;
+}
+export function createAliasedSSRResolver({ getResolveConfig, roots, name = "aliasedSSRResolver", }) {
+    const log = debug("rwsdk:vite:aliased-ssr-resolver");
+    const logPrefix = `[${name}]`;
+    return function resolveModule(request, importer) {
+        log("%s Called with request: '%s', importer: '%s'", logPrefix, request, importer);
+        let normalized = request;
+        const resolveConfig = getResolveConfig?.() || {};
+        const aliasEntries = resolveConfig.alias;
+        log("%s Alias entries: %O", logPrefix, aliasEntries);
+        normalized = applyAlias(normalized, aliasEntries, name);
+        log("%s After aliasing: '%s'", logPrefix, normalized);
+        let rootsToTry = roots && roots.length > 0 ? roots : [];
+        // If leading slash, treat as first root-rooted (for compatibility)
+        if (normalized.startsWith("/")) {
+            if (rootsToTry.length > 0) {
+                const rooted = path.join(rootsToTry[0], normalized);
+                log("%s Leading slash detected, resolving as root[0]-rooted: '%s'", logPrefix, rooted);
+                normalized = rooted;
+                rootsToTry = [rootsToTry[0]];
+            }
+        }
+        const isAbsolute = path.isAbsolute(normalized);
+        if (isAbsolute) {
+            log("%s Resolving absolute path: '%s'", logPrefix, normalized);
+            return normalized;
+        }
+        for (const root of rootsToTry) {
+            try {
+                log("%s Trying root: '%s'", logPrefix, root);
+                const result = baseSSRResolver(root, normalized);
+                log("%s Resolved to: '%s' with root '%s'", logPrefix, result, root);
+                return result;
+            }
+            catch (err) {
+                log("%s Resolution failed for '%s' from root '%s': %O", logPrefix, normalized, root, err);
+            }
+        }
+        return false;
+    };
+}

package/dist/vite/ensureConfigArrays.d.mts

@@ -0,0 +1 @@
+export declare const ensureConfigArrays: (config: any) => void;

package/dist/vite/ensureConfigArrays.mjs

@@ -0,0 +1,12 @@
+export const ensureConfigArrays = (config) => {
+    config.optimizeDeps ??= {};
+    config.optimizeDeps.include ??= [];
+    config.optimizeDeps.esbuildOptions ??= {};
+    config.optimizeDeps.esbuildOptions.plugins ??= [];
+    config.resolve ??= {};
+    config.resolve.alias ??= [];
+    if (!Array.isArray(config.resolve.alias)) {
+        const aliasObj = config.resolve.alias;
+        config.resolve.alias = Object.entries(aliasObj).map(([find, replacement]) => ({ find, replacement }));
+    }
+};

package/dist/vite/findImportSpecifiers.d.mts

@@ -0,0 +1,14 @@
+export declare const IMPORT_PATTERNS: string[];
+/**
+ * Finds import specifiers and their positions in the code using the provided patterns.
+ * @param code The code to search for import specifiers.
+ * @param lang The language parser to use (TypeScript or Tsx).
+ * @param ignoredImportPatterns Array of regex patterns to ignore.
+ * @param log Optional logger function for debug output.
+ * @returns Array of objects with start, end, and raw import string.
+ */
+export declare function findImportSpecifiers(id: string, code: string, ignoredImportPatterns: RegExp[], log?: (...args: any[]) => void): Array<{
+    s: number;
+    e: number;
+    raw: string;
+}>;

package/dist/vite/findImportSpecifiers.mjs

@@ -0,0 +1,76 @@
+import { parse as sgParse, Lang as SgLang, Lang } from "@ast-grep/napi";
+import path from "path";
+// These patterns are used to match import statements in code for SSR transformations.
+export const IMPORT_PATTERNS = [
+    'import { $$$ } from "$MODULE"',
+    "import { $$$ } from '$MODULE'",
+    'import $DEFAULT from "$MODULE"',
+    "import $DEFAULT from '$MODULE'",
+    'import * as $NS from "$MODULE"',
+    "import * as $NS from '$MODULE'",
+    'import "$MODULE"',
+    "import '$MODULE'",
+    // Static Re-exports
+    'export { $$$ } from "$MODULE"',
+    "export { $$$ } from '$MODULE'",
+    'export * from "$MODULE"',
+    "export * from '$MODULE'",
+    // Dynamic Imports
+    'import("$MODULE")',
+    "import('$MODULE')",
+    "import(`$MODULE`)",
+    // CommonJS require
+    'require("$MODULE")',
+    "require('$MODULE')",
+    "require(`$MODULE`)",
+];
+/**
+ * Finds import specifiers and their positions in the code using the provided patterns.
+ * @param code The code to search for import specifiers.
+ * @param lang The language parser to use (TypeScript or Tsx).
+ * @param ignoredImportPatterns Array of regex patterns to ignore.
+ * @param log Optional logger function for debug output.
+ * @returns Array of objects with start, end, and raw import string.
+ */
+export function findImportSpecifiers(id, code, ignoredImportPatterns, log) {
+    const ext = path.extname(id).toLowerCase();
+    const lang = ext === ".tsx" || ext === ".jsx" ? Lang.Tsx : SgLang.TypeScript;
+    const logger = log ?? (() => { });
+    const results = [];
+    try {
+        // sgParse and lang must be provided by the consumer
+        const root = sgParse(lang, code);
+        for (const pattern of IMPORT_PATTERNS) {
+            try {
+                const matches = root.root().findAll(pattern);
+                for (const match of matches) {
+                    const moduleCapture = match.getMatch("MODULE");
+                    if (moduleCapture) {
+                        const importPath = moduleCapture.text();
+                        if (importPath.startsWith("virtual:")) {
+                            logger(":findImportSpecifiersWithPositions: Ignoring import because it starts with 'virtual:': importPath=%s", importPath);
+                        }
+                        else if (importPath.includes("__rwsdknossr")) {
+                            logger(":findImportSpecifiersWithPositions: Ignoring import because it includes '__rwsdknossr': importPath=%s", importPath);
+                        }
+                        else if (ignoredImportPatterns.some((pattern) => pattern.test(importPath))) {
+                            logger(":findImportSpecifiersWithPositions: Ignoring import because it matches IGNORED_IMPORT_PATTERNS: importPath=%s", importPath);
+                        }
+                        else {
+                            const { start, end } = moduleCapture.range();
+                            results.push({ s: start.index, e: end.index, raw: importPath });
+                            logger(":findImportSpecifiersWithPositions: Including import specifier: importPath=%s, range=[%d, %d]", importPath, start.index, end.index);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                logger(":findImportSpecifiersWithPositions: Error processing pattern: %O", err);
+            }
+        }
+    }
+    catch (err) {
+        logger(":findImportSpecifiersWithPositions: Error parsing content: %O", err);
+    }
+    return results;
+}

package/dist/vite/isBareImport.d.mts

@@ -0,0 +1 @@
+export declare function isBareImport(importPath: string): boolean;

package/dist/vite/isBareImport.mjs

@@ -0,0 +1,5 @@
+export function isBareImport(importPath) {
+    return (!importPath.startsWith(".") &&
+        !importPath.startsWith("/") &&
+        !importPath.startsWith("virtual:"));
+}

package/dist/vite/moduleResolver.d.mts

@@ -0,0 +1,10 @@
+export type ModuleResolver = ReturnType<typeof createModuleResolver>;
+export declare function createModuleResolver({ getAliases, roots, conditionNames, name, }: {
+    getAliases?: () => Array<{
+        find: string | RegExp;
+        replacement: string;
+    }>;
+    roots: string[];
+    conditionNames?: string[];
+    name: string;
+}): (request: string, importer?: string) => string | false;