@veryfront/ext-content-mdx 0.1.1119 → 0.1.1122

package/esm/src/platform/compat/fs.js

@@ -0,0 +1,336 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import { createError, toError } from "../../errors/veryfront-error.js";
+import { isBun, isDeno, isNode } from "./runtime.js";
+/**
+ * Typed accessor for the Deno global.
+ *
+ * This is pure typing only — it reads no environment variables and performs no
+ * side effects, so this module stays importable without `--allow-env`. It
+ * exists to retire the `@ts-ignore` comments that were previously required to
+ * access `Deno.*` APIs from runtime-agnostic compat code.
+ */
+function denoGlobal() {
+    return dntShim.dntGlobalThis.Deno;
+}
+class NodeFileSystem {
+    fs;
+    os;
+    path;
+    initialized = false;
+    async ensureInitialized() {
+        if (this.initialized)
+            return;
+        if (!isNode && !isBun) {
+            throw toError(createError({
+                type: "not_supported",
+                message: "Node.js fs modules not available",
+                feature: "Node.js",
+            }));
+        }
+        const [fsModule, osModule, pathModule] = await Promise.all([
+            import("node:fs/promises"),
+            import("node:os"),
+            import("node:path"),
+        ]);
+        this.fs = fsModule;
+        this.os = osModule;
+        this.path = pathModule;
+        this.initialized = true;
+    }
+    getFs() {
+        if (!this.fs)
+            throw new Error("NodeFileSystem not initialized");
+        return this.fs;
+    }
+    getOs() {
+        if (!this.os)
+            throw new Error("NodeFileSystem not initialized");
+        return this.os;
+    }
+    getPath() {
+        if (!this.path)
+            throw new Error("NodeFileSystem not initialized");
+        return this.path;
+    }
+    async readTextFile(path) {
+        await this.ensureInitialized();
+        return this.getFs().readFile(path, { encoding: "utf8" });
+    }
+    async readFile(path) {
+        await this.ensureInitialized();
+        return this.getFs().readFile(path);
+    }
+    async writeTextFile(path, data) {
+        await this.ensureInitialized();
+        await this.getFs().writeFile(path, data, { encoding: "utf8" });
+    }
+    async writeFile(path, data) {
+        await this.ensureInitialized();
+        await this.getFs().writeFile(path, data);
+    }
+    async exists(path) {
+        await this.ensureInitialized();
+        try {
+            await this.getFs().access(path);
+            return true;
+        }
+        catch (error) {
+            if (error?.code === "ENOENT")
+                return false;
+            throw error;
+        }
+    }
+    async stat(path) {
+        await this.ensureInitialized();
+        const stat = await this.getFs().stat(path);
+        return {
+            isFile: stat.isFile(),
+            isDirectory: stat.isDirectory(),
+            isSymlink: stat.isSymbolicLink(),
+            size: stat.size,
+            mtime: stat.mtime,
+        };
+    }
+    async lstat(path) {
+        await this.ensureInitialized();
+        const stat = await this.getFs().lstat(path);
+        return {
+            isFile: stat.isFile(),
+            isDirectory: stat.isDirectory(),
+            isSymlink: stat.isSymbolicLink(),
+            size: stat.size,
+            mtime: stat.mtime,
+        };
+    }
+    async mkdir(path, options) {
+        await this.ensureInitialized();
+        await this.getFs().mkdir(path, { recursive: options?.recursive ?? false });
+    }
+    async *readDir(path) {
+        await this.ensureInitialized();
+        const entries = await this.getFs().readdir(path, { withFileTypes: true });
+        for (const entry of entries) {
+            yield {
+                name: entry.name,
+                isFile: entry.isFile(),
+                isDirectory: entry.isDirectory(),
+                isSymlink: entry.isSymbolicLink(),
+            };
+        }
+    }
+    async remove(path, options) {
+        await this.ensureInitialized();
+        const recursive = options?.recursive ?? false;
+        await this.getFs().rm(path, { recursive, force: recursive });
+    }
+    async makeTempDir(options) {
+        await this.ensureInitialized();
+        const tempDir = this.getPath().join(this.getOs().tmpdir(), `${options?.prefix ?? "tmp-"}${dntShim.crypto.randomUUID().slice(0, 8)}`);
+        await this.getFs().mkdir(tempDir, { recursive: true });
+        return tempDir;
+    }
+    async chmod(path, mode) {
+        await this.ensureInitialized();
+        try {
+            await this.getFs().chmod(path, mode);
+        }
+        catch {
+            // Ignore errors on Windows where chmod is not fully supported.
+            // Intentionally not logged: this low-level compat module must stay
+            // importable without `--allow-env` (the logger reads env at import).
+        }
+    }
+}
+class DenoFileSystem {
+    readTextFile(path) {
+        return denoGlobal().readTextFile(path);
+    }
+    readFile(path) {
+        return denoGlobal().readFile(path);
+    }
+    async writeTextFile(path, data) {
+        await denoGlobal().writeTextFile(path, data);
+    }
+    async writeFile(path, data) {
+        await denoGlobal().writeFile(path, data);
+    }
+    async exists(path) {
+        try {
+            await denoGlobal().stat(path);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof denoGlobal().errors.NotFound)
+                return false;
+            throw error;
+        }
+    }
+    async stat(path) {
+        const stat = await denoGlobal().stat(path);
+        return {
+            isFile: stat.isFile,
+            isDirectory: stat.isDirectory,
+            isSymlink: stat.isSymlink,
+            size: stat.size,
+            mtime: stat.mtime,
+        };
+    }
+    async lstat(path) {
+        const stat = await denoGlobal().lstat(path);
+        return {
+            isFile: stat.isFile,
+            isDirectory: stat.isDirectory,
+            isSymlink: stat.isSymlink,
+            size: stat.size,
+            mtime: stat.mtime,
+        };
+    }
+    async mkdir(path, options) {
+        await denoGlobal().mkdir(path, { recursive: options?.recursive ?? false });
+    }
+    async *readDir(path) {
+        for await (const entry of denoGlobal().readDir(path)) {
+            yield {
+                name: entry.name,
+                isFile: entry.isFile,
+                isDirectory: entry.isDirectory,
+                isSymlink: entry.isSymlink,
+            };
+        }
+    }
+    async remove(path, options) {
+        await denoGlobal().remove(path, { recursive: options?.recursive ?? false });
+    }
+    makeTempDir(options) {
+        return denoGlobal().makeTempDir({ prefix: options?.prefix });
+    }
+    async chmod(path, mode) {
+        try {
+            await denoGlobal().chmod(path, mode);
+        }
+        catch (_) {
+            /* expected: chmod is not fully supported on Windows */
+        }
+    }
+}
+/** Create file system. */
+export function createFileSystem() {
+    return isDeno ? new DenoFileSystem() : new NodeFileSystem();
+}
+let _fs = null;
+function getFs() {
+    _fs ??= createFileSystem();
+    return _fs;
+}
+/** Read a file as text. */
+export function readTextFile(path) {
+    return getFs().readTextFile(path);
+}
+/** Read a file as bytes. */
+export function readFile(path) {
+    return getFs().readFile(path);
+}
+/** Write text to a file. */
+export function writeTextFile(path, data) {
+    return getFs().writeTextFile(path, data);
+}
+/** Write bytes to a file. */
+export function writeFile(path, data) {
+    return getFs().writeFile(path, data);
+}
+/** Check whether a path exists. */
+export function exists(path) {
+    return getFs().exists(path);
+}
+/** Read file metadata. */
+export function stat(path) {
+    return getFs().stat(path);
+}
+/** Read file metadata without following a terminal symbolic link. */
+export async function lstat(path) {
+    if (isDeno) {
+        const info = await denoGlobal().lstat(path);
+        return {
+            isFile: info.isFile,
+            isDirectory: info.isDirectory,
+            isSymlink: info.isSymlink,
+            size: info.size,
+            mtime: info.mtime,
+        };
+    }
+    const fs = await import("node:fs/promises");
+    const info = await fs.lstat(path);
+    return {
+        isFile: info.isFile(),
+        isDirectory: info.isDirectory(),
+        isSymlink: info.isSymbolicLink(),
+        size: info.size,
+        mtime: info.mtime,
+    };
+}
+/** Create a directory. */
+export function mkdir(path, options) {
+    return getFs().mkdir(path, options);
+}
+/** Remove a file or directory. */
+export function remove(path, options) {
+    return getFs().remove(path, options);
+}
+/** Read directory entries. */
+export function readDir(path) {
+    return getFs().readDir(path);
+}
+/** Create temp dir. */
+export function makeTempDir(options) {
+    return getFs().makeTempDir(options);
+}
+/** Change file permissions. */
+export function chmod(path, mode) {
+    return getFs().chmod(path, mode);
+}
+export async function symlink(target, path) {
+    if (isDeno) {
+        await denoGlobal().symlink(target, path);
+        return;
+    }
+    const fs = await import("node:fs/promises");
+    await fs.symlink(target, path);
+}
+/**
+ * Resolve a path to its canonical absolute form, following symlinks.
+ * Throws if the path does not exist. Useful for containment checks where a
+ * symlink could otherwise escape an intended directory.
+ */
+export async function realPath(path) {
+    if (isDeno) {
+        return await denoGlobal().realPath(path);
+    }
+    const fs = await import("node:fs/promises");
+    return await fs.realpath(path);
+}
+/** Error shape for is not found. */
+export function isNotFoundError(error, seen = new Set()) {
+    if (seen.has(error))
+        return false;
+    seen.add(error);
+    const NotFound = dntShim.dntGlobalThis.Deno?.errors?.NotFound;
+    if (isDeno && NotFound && error instanceof NotFound)
+        return true;
+    if (error?.code === "ENOENT")
+        return true;
+    if (error instanceof Error && error.name === "VeryfrontError" &&
+        error.slug === "file-not-found") {
+        return true;
+    }
+    if (error instanceof Error && "cause" in error) {
+        return isNotFoundError(error.cause, seen);
+    }
+    return false;
+}
+/** Error shape for is already exists. */
+export function isAlreadyExistsError(error) {
+    const AlreadyExists = dntShim.dntGlobalThis.Deno?.errors?.AlreadyExists;
+    if (isDeno && AlreadyExists && error instanceof AlreadyExists)
+        return true;
+    return error?.code === "EEXIST";
+}

package/esm/src/platform/compat/process/command.d.ts

@@ -0,0 +1,33 @@
+export interface CommandResult {
+    success: boolean;
+    code: number;
+    stdout?: string;
+    stderr?: string;
+}
+export interface CommandOptions {
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    /** Start from an empty environment before applying `env`. */
+    clearEnv?: boolean;
+    /** Capture stdout/stderr to return in result */
+    capture?: boolean;
+    /** Inherit stdio from parent process (shows output in terminal) */
+    inherit?: boolean;
+    /** Use shell to run the command (needed for .cmd files on Windows) */
+    shell?: boolean;
+    /** Kill the command if it exceeds this duration (milliseconds) */
+    timeoutMs?: number;
+}
+/**
+ * Run a command and return the result.
+ * Works across Deno, Node.js, and Bun.
+ *
+ * @param cmd - Command to run
+ * @param options - Command options
+ * @param options.capture - Capture stdout/stderr to return in result
+ * @param options.inherit - Inherit stdio from parent (shows output in terminal)
+ * @param options.shell - Use shell to run command (needed for .cmd on Windows)
+ */
+export declare function runCommand(cmd: string, options?: CommandOptions): Promise<CommandResult>;
+//# sourceMappingURL=command.d.ts.map

package/esm/src/platform/compat/process/command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/process/command.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gDAAgD;IAChD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,mEAAmE;IACnE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,sEAAsE;IACtE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,kEAAkE;IAClE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA6ED;;;;;;;;;GASG;AACH,wBAAsB,UAAU,CAC9B,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,aAAa,CAAC,CAoMxB"}

package/esm/src/platform/compat/process/command.js

@@ -0,0 +1,206 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+import { dynamicImport } from "../dynamic-import.js";
+import { getDenoRuntime, isBun as IS_BUN, isDeno as IS_DENO } from "../runtime.js";
+import { isWindowsPlatform, runtimeProcess } from "./runtime-process.js";
+const COMMAND_TIMEOUT_EXIT_CODE = 124;
+const FORCE_KILL_GRACE_MS = 250;
+function createTimeoutResult(timeoutMs, stdout, stderr) {
+    return {
+        success: false,
+        code: COMMAND_TIMEOUT_EXIT_CODE,
+        stdout,
+        stderr: `${stderr ?? ""}\nCommand timed out after ${timeoutMs}ms`.trim(),
+    };
+}
+function createProcessTimeout(timeoutMs, terminate, forceTerminate) {
+    let timedOut = false;
+    let timeoutId;
+    let forceKillId;
+    if (timeoutMs && timeoutMs > 0) {
+        timeoutId = dntShim.setTimeout(() => {
+            timedOut = true;
+            try {
+                terminate();
+            }
+            catch (_) {
+                /* expected: best-effort terminate may fail if process already exited */
+            }
+            forceKillId = dntShim.setTimeout(() => {
+                try {
+                    forceTerminate();
+                }
+                catch (_) {
+                    /* expected: best-effort force terminate may fail if process already exited */
+                }
+            }, FORCE_KILL_GRACE_MS);
+        }, timeoutMs);
+    }
+    return {
+        hasTimedOut: () => timedOut,
+        clear: () => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (forceKillId)
+                clearTimeout(forceKillId);
+        },
+    };
+}
+async function readStreamToString(stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (value)
+            chunks.push(value);
+    }
+    const total = chunks.reduce((acc, c) => acc + c.length, 0);
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        merged.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return new TextDecoder().decode(merged);
+}
+/**
+ * Run a command and return the result.
+ * Works across Deno, Node.js, and Bun.
+ *
+ * @param cmd - Command to run
+ * @param options - Command options
+ * @param options.capture - Capture stdout/stderr to return in result
+ * @param options.inherit - Inherit stdio from parent (shows output in terminal)
+ * @param options.shell - Use shell to run command (needed for .cmd on Windows)
+ */
+export async function runCommand(cmd, options = {}) {
+    const { args = [], cwd: cmdCwd, env: cmdEnv, clearEnv = false, capture = false, inherit = false, shell = false, timeoutMs, } = options;
+    const effectiveTimeoutMs = timeoutMs && timeoutMs > 0 ? Math.floor(timeoutMs) : undefined;
+    // Determine stdio mode: inherit > capture > null
+    const stdioMode = inherit ? "inherit" : capture ? "piped" : "null";
+    const deno = IS_DENO ? getDenoRuntime() : undefined;
+    if (deno) {
+        const command = new deno.Command(cmd, {
+            args,
+            cwd: cmdCwd,
+            env: cmdEnv,
+            clearEnv,
+            stdin: inherit ? "inherit" : "null",
+            stdout: stdioMode,
+            stderr: stdioMode,
+        });
+        const child = command.spawn();
+        const timeout = createProcessTimeout(effectiveTimeoutMs, () => child.kill("SIGTERM"), () => child.kill("SIGKILL"));
+        try {
+            const [status, stdout, stderr] = await Promise.all([
+                child.status,
+                capture && child.stdout ? readStreamToString(child.stdout) : Promise.resolve(undefined),
+                capture && child.stderr ? readStreamToString(child.stderr) : Promise.resolve(undefined),
+            ]);
+            if (timeout.hasTimedOut()) {
+                return createTimeoutResult(effectiveTimeoutMs ?? 0, stdout, stderr);
+            }
+            return {
+                success: status.success,
+                code: status.code,
+                stdout,
+                stderr,
+            };
+        }
+        finally {
+            timeout.clear();
+        }
+    }
+    if (IS_BUN) {
+        const bunGlobal = dntShim.dntGlobalThis;
+        const bunStdio = inherit ? "inherit" : capture ? "pipe" : "ignore";
+        const isWindows = isWindowsPlatform();
+        const bunCmd = shell
+            ? args.length === 0
+                ? isWindows ? ["cmd", "/c", cmd] : ["sh", "-c", cmd]
+                : isWindows
+                    ? ["cmd", "/c", cmd, ...args]
+                    : ["sh", "-c", 'exec "$@"', "sh", cmd, ...args]
+            : [cmd, ...args];
+        const proc = bunGlobal.Bun.spawn({
+            cmd: bunCmd,
+            cwd: cmdCwd,
+            env: clearEnv ? cmdEnv ?? {} : cmdEnv,
+            stdout: bunStdio,
+            stderr: bunStdio,
+        });
+        const timeout = createProcessTimeout(effectiveTimeoutMs, () => proc.kill?.("SIGTERM"), () => proc.kill?.("SIGKILL"));
+        try {
+            const [code, stdout, stderr] = await Promise.all([
+                proc.exited,
+                capture && proc.stdout ? readStreamToString(proc.stdout) : Promise.resolve(undefined),
+                capture && proc.stderr ? readStreamToString(proc.stderr) : Promise.resolve(undefined),
+            ]);
+            if (timeout.hasTimedOut()) {
+                return createTimeoutResult(effectiveTimeoutMs ?? 0, stdout, stderr);
+            }
+            return { success: code === 0, code, stdout, stderr };
+        }
+        finally {
+            timeout.clear();
+        }
+    }
+    if (!runtimeProcess)
+        return { success: false, code: 1 };
+    const process = runtimeProcess;
+    const { spawn } = await dynamicImport("node:child_process");
+    const nodeStdio = inherit
+        ? ["inherit", "inherit", "inherit"]
+        : capture
+            ? ["ignore", "pipe", "pipe"]
+            : ["ignore", "ignore", "ignore"];
+    return await new Promise((resolve) => {
+        const child = spawn(cmd, args, {
+            cwd: cmdCwd,
+            env: clearEnv ? cmdEnv ?? {} : cmdEnv ? { ...process.env, ...cmdEnv } : undefined,
+            stdio: nodeStdio,
+            shell,
+        });
+        let stdout = "";
+        let stderr = "";
+        const decoder = new TextDecoder();
+        const timeout = createProcessTimeout(effectiveTimeoutMs, () => child.kill("SIGTERM"), () => child.kill("SIGKILL"));
+        if (capture) {
+            child.stdout?.on("data", (data) => {
+                stdout += decoder.decode(data);
+            });
+            child.stderr?.on("data", (data) => {
+                stderr += decoder.decode(data);
+            });
+        }
+        child.on("close", (code) => {
+            timeout.clear();
+            if (timeout.hasTimedOut()) {
+                resolve(createTimeoutResult(effectiveTimeoutMs ?? 0, capture ? stdout : undefined, capture ? stderr : undefined));
+                return;
+            }
+            resolve({
+                success: code === 0,
+                code: code ?? 1,
+                stdout: capture ? stdout : undefined,
+                stderr: capture ? stderr : undefined,
+            });
+        });
+        child.on("error", (spawnError) => {
+            timeout.clear();
+            // Include the spawn error message so callers can distinguish ENOENT
+            // ("command not found"), EACCES ("permission denied"), etc.
+            resolve({
+                success: false,
+                code: 1,
+                stdout: capture ? stdout : undefined,
+                stderr: capture
+                    ? (stderr
+                        ? `${stderr}\nSpawn error: ${spawnError.message}`
+                        : `Spawn error: ${spawnError.message}`)
+                    : undefined,
+            });
+        });
+    });
+}

package/esm/src/platform/compat/process.d.ts

@@ -0,0 +1,5 @@
+export { deleteEnv, env, type EnvBooleanOptions, getEnv, getEnvBoolean, getEnvNumber, getEnvOverlayStorage, getEnvString, getHostEnv, setEnv, } from "./process/env.js";
+export { chdir, cwd, execPath, exit, getArgs, getOsType, getRuntimeVersion, getStdout, getTerminalSize, isInteractive, isStdoutTTY, memoryUsage, onGlobalError, onSignal, pid, promptSync, readStdinByteSync, unrefTimer, uptime, writeStdout, writeStdoutAsync, } from "./process/lifecycle.js";
+export { testHasRuntimeProcess } from "./process/runtime-process.js";
+export { type CommandOptions, type CommandResult, runCommand } from "./process/command.js";
+//# sourceMappingURL=process.d.ts.map

package/esm/src/platform/compat/process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process.d.ts","sourceRoot":"","sources":["../../../../src/src/platform/compat/process.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,GAAG,EACH,KAAK,iBAAiB,EACtB,MAAM,EACN,aAAa,EACb,YAAY,EACZ,oBAAoB,EACpB,YAAY,EACZ,UAAU,EACV,MAAM,GACP,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,KAAK,EACL,GAAG,EACH,QAAQ,EACR,IAAI,EACJ,OAAO,EACP,SAAS,EACT,iBAAiB,EACjB,SAAS,EACT,eAAe,EACf,aAAa,EACb,WAAW,EACX,WAAW,EACX,aAAa,EACb,QAAQ,EACR,GAAG,EACH,UAAU,EACV,iBAAiB,EACjB,UAAU,EACV,MAAM,EACN,WAAW,EACX,gBAAgB,GACjB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC"}

package/esm/src/platform/compat/process.js

@@ -0,0 +1,4 @@
+export { deleteEnv, env, getEnv, getEnvBoolean, getEnvNumber, getEnvOverlayStorage, getEnvString, getHostEnv, setEnv, } from "./process/env.js";
+export { chdir, cwd, execPath, exit, getArgs, getOsType, getRuntimeVersion, getStdout, getTerminalSize, isInteractive, isStdoutTTY, memoryUsage, onGlobalError, onSignal, pid, promptSync, readStdinByteSync, unrefTimer, uptime, writeStdout, writeStdoutAsync, } from "./process/lifecycle.js";
+export { testHasRuntimeProcess } from "./process/runtime-process.js";
+export { runCommand } from "./process/command.js";

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

@@ -0,0 +1,70 @@
+/**
+ * Canonical URL builders for import rewriting.
+ *
+ * Single source of truth for all URL generation.
+ * Ensures consistent URLs across SSR and browser for hydration parity.
+ */
+/**
+ * Default React version - used when not specified.
+ *
+ * MUST match the React version the build bundles (see `react/deno.json`),
+ * because veryfront's framework React re-export is generated against that
+ * version and references its named exports. A drift guard in
+ * `src/utils/constants/cdn.test.ts` enforces this.
+ */
+export declare const DEFAULT_REACT_VERSION = "19.2.4";
+/** Tailwind CSS version */
+export declare const TAILWIND_VERSION = "4.1.8";
+/** csstype version - must match deno.json for type consistency */
+export declare const CSSTYPE_VERSION = "3.2.3";
+type EsmShOptions = {
+    external?: string[];
+    target?: string;
+    deps?: Record<string, string>;
+};
+/**
+ * Build esm.sh URL with proper configuration.
+ *
+ * @param pkg - Package name (e.g., "react", "lodash")
+ * @param version - Package version (optional)
+ * @param subpath - Subpath (e.g., "/jsx-runtime")
+ * @param options - URL options
+ */
+export declare function buildEsmShUrl(pkg: string, version?: string, subpath?: string, options?: EsmShOptions): string;
+/**
+ * Build React esm.sh URL.
+ * Uses deps=csstype for type consistency.
+ */
+export declare function buildReactUrl(pkg: "react" | "react-dom", version: string, subpath?: string, external?: boolean): string;
+/**
+ * Get complete React import map for a specific version.
+ */
+export declare function getReactImportMap(version: string): Record<string, string>;
+/**
+ * Build module server URL for a path.
+ */
+export declare function buildModuleServerUrl(baseUrl: string, path: string): string;
+/**
+ * Build cross-project import URL.
+ */
+export declare function buildCrossProjectUrl(projectSlug: string, version: string | null, path: string): string;
+/**
+ * Build veryfront framework module URL.
+ */
+export declare function buildVeryfrontModuleUrl(path: string): string;
+/**
+ * Normalize file extension for JavaScript output.
+ */
+export declare function normalizeExtension(path: string, options?: {
+    removeExtension?: boolean;
+}): string;
+/**
+ * Check if a URL is an esm.sh URL.
+ */
+export declare function isEsmShUrl(url: string): boolean;
+/**
+ * Add deps query param to esm.sh URL if not already present.
+ */
+export declare function addEsmShDeps(url: string, reactVersion: string): string;
+export {};
+//# sourceMappingURL=url-builder.d.ts.map

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

@@ -0,0 +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;;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"}