@veryfront/ext-content-mdx 0.1.985

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

@@ -0,0 +1,56 @@
+import { isDeno, nodePath } from "./runtime.js";
+function hasWindowsLikePath(path) {
+    return path.includes("\\") || /^[A-Za-z]:/.test(path) || path.startsWith("\\\\");
+}
+/** Normalize backslashes to forward slashes (for Deno on Windows). */
+function normSep(p) {
+    return p.includes("\\") ? p.replace(/\\/g, "/") : p;
+}
+/** Join path segments. */
+export function join(...paths) {
+    const joined = paths
+        .map(normSep)
+        .filter((p) => p.length > 0)
+        .join("/")
+        .replace(/\/+/g, "/")
+        .replace(/\/$/, "");
+    return joined || "/";
+}
+/** Return the parent directory path. */
+export function dirname(path) {
+    if (!isDeno && nodePath && !hasWindowsLikePath(path))
+        return nodePath.dirname(path);
+    const p = normSep(path);
+    const lastSlash = p.lastIndexOf("/");
+    if (lastSlash === -1)
+        return ".";
+    if (lastSlash === 0)
+        return "/";
+    return p.slice(0, lastSlash);
+}
+/** Return the last path segment. */
+export function basename(path, ext) {
+    if (!isDeno && nodePath && !hasWindowsLikePath(path)) {
+        // Only pass ext if defined - Bun is strict about this parameter
+        return ext === undefined ? nodePath.basename(path) : nodePath.basename(path, ext);
+    }
+    let normalizedPath = normSep(path);
+    while (normalizedPath.length > 1 && normalizedPath.endsWith("/")) {
+        normalizedPath = normalizedPath.slice(0, -1);
+    }
+    const lastSlash = normalizedPath.lastIndexOf("/");
+    let base = lastSlash === -1 ? normalizedPath : normalizedPath.slice(lastSlash + 1);
+    if (ext && base.endsWith(ext))
+        base = base.slice(0, -ext.length);
+    return base;
+}
+/** Return the file extension for a path. */
+export function extname(path) {
+    if (!isDeno && nodePath && !hasWindowsLikePath(path))
+        return nodePath.extname(path);
+    const base = basename(path);
+    const lastDot = base.lastIndexOf(".");
+    if (lastDot <= 0)
+        return "";
+    return base.slice(lastDot);
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Compat - Path
+ *
+ * @module platform/compat/path
+ */
+export type { NodePathModule, PathObject } from "./types.js";
+export { delimiter, hasNodePath, isDeno, nodePath, sep, sep as SEPARATOR } from "./runtime.js";
+export { basename, dirname, extname, join } from "./basic-operations.js";
+export { isAbsolute, normalize, relative, resolve } from "./resolution.js";
+export { format, parse } from "./parse-format.js";
+export { fromFileUrl, toFileUrl } from "./url-conversion.js";
+export { validatePathSecurity } from "./security.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/path/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7D,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,IAAI,SAAS,EAAE,MAAM,cAAc,CAAC;AAE/F,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC3E,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC"}

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

@@ -0,0 +1,11 @@
+/**
+ * Compat - Path
+ *
+ * @module platform/compat/path
+ */
+export { delimiter, hasNodePath, isDeno, nodePath, sep, sep as SEPARATOR } from "./runtime.js";
+export { basename, dirname, extname, join } from "./basic-operations.js";
+export { isAbsolute, normalize, relative, resolve } from "./resolution.js";
+export { format, parse } from "./parse-format.js";
+export { fromFileUrl, toFileUrl } from "./url-conversion.js";
+export { validatePathSecurity } from "./security.js";

package/esm/src/platform/compat/path/parse-format.d.ts

@@ -0,0 +1,4 @@
+import type { PathObject } from "./types.js";
+export declare function parse(path: string): PathObject;
+export declare function format(pathObject: PathObject): string;
+//# sourceMappingURL=parse-format.d.ts.map

package/esm/src/platform/compat/path/parse-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-format.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/path/parse-format.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAgB9C;AAED,wBAAgB,MAAM,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CASrD"}

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

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

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

@@ -0,0 +1,6 @@
+/** Resolve path segments to an absolute path. */
+export declare function resolve(...paths: string[]): string;
+export declare function isAbsolute(path: string): boolean;
+export declare function relative(from: string, to: string): string;
+export declare function normalize(path: string): string;
+//# sourceMappingURL=resolution.d.ts.map

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

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

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

@@ -0,0 +1,121 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+import { isDeno, nodePath } from "./runtime.js";
+function hasWindowsLikePath(path) {
+    return path.includes("\\") || /^[A-Za-z]:/.test(path) || path.startsWith("\\\\");
+}
+/** Normalize backslashes to forward slashes (for Deno on Windows). */
+function normSep(p) {
+    return p.includes("\\") ? p.replace(/\\/g, "/") : p;
+}
+/** Match Windows drive letter prefix like "C:/" */
+const DRIVE_LETTER = /^[A-Za-z]:\//;
+/** Resolve path segments to an absolute path. */
+export function resolve(...paths) {
+    if (!isDeno && nodePath && !paths.some(hasWindowsLikePath))
+        return nodePath.resolve(...paths);
+    let resolvedPath = normSep(dntShim.dntGlobalThis.Deno?.cwd?.() ?? "/");
+    for (const rawPath of paths) {
+        if (!rawPath)
+            continue;
+        const path = normSep(rawPath);
+        if (path.startsWith("/") || DRIVE_LETTER.test(path)) {
+            resolvedPath = path;
+        }
+        else {
+            resolvedPath = `${resolvedPath}/${path}`;
+        }
+    }
+    // Preserve drive letter prefix (e.g. "D:/") if present
+    let prefix = "/";
+    const driveMatch = resolvedPath.match(DRIVE_LETTER);
+    if (driveMatch) {
+        prefix = driveMatch[0]; // e.g. "D:/"
+        resolvedPath = resolvedPath.slice(prefix.length);
+    }
+    else if (resolvedPath.startsWith("/")) {
+        resolvedPath = resolvedPath.slice(1);
+    }
+    const parts = resolvedPath.split("/").filter(Boolean);
+    const resolved = [];
+    for (const part of parts) {
+        if (part === "..") {
+            resolved.pop();
+            continue;
+        }
+        if (part !== ".")
+            resolved.push(part);
+    }
+    return `${prefix}${resolved.join("/")}`;
+}
+export function isAbsolute(path) {
+    if (!isDeno && nodePath && !hasWindowsLikePath(path) && nodePath.isAbsolute(path))
+        return true;
+    // Cross-platform fallback: Unix, Windows drive letters, and UNC paths
+    if (path.startsWith("/"))
+        return true;
+    if (/^[A-Za-z]:[/\\]/.test(path))
+        return true;
+    return /^\\\\[^\\]+\\[^\\]+/.test(path);
+}
+export function relative(from, to) {
+    if (!isDeno && nodePath && !hasWindowsLikePath(from) && !hasWindowsLikePath(to)) {
+        const relativePath = nodePath.relative(from, to);
+        return relativePath || ".";
+    }
+    const resolvedFrom = resolve(from);
+    const resolvedTo = resolve(to);
+    // Strip drive prefix for comparison (both will share the same drive after resolve)
+    const fromDrive = resolvedFrom.match(DRIVE_LETTER);
+    const fromBase = fromDrive ? resolvedFrom.slice(fromDrive[0].length) : resolvedFrom.slice(1);
+    const toDrive = resolvedTo.match(DRIVE_LETTER);
+    const toBase = toDrive ? resolvedTo.slice(toDrive[0].length) : resolvedTo.slice(1);
+    const fromParts = fromBase.split("/").filter(Boolean);
+    const toParts = toBase.split("/").filter(Boolean);
+    let common = 0;
+    const minLen = Math.min(fromParts.length, toParts.length);
+    for (let i = 0; i < minLen; i++) {
+        if (fromParts[i] !== toParts[i])
+            break;
+        common++;
+    }
+    const ups = fromParts.length - common;
+    const result = [...new Array(ups).fill(".."), ...toParts.slice(common)];
+    return result.join("/") || ".";
+}
+export function normalize(path) {
+    if (!isDeno && nodePath && !hasWindowsLikePath(path))
+        return nodePath.normalize(path);
+    if (path === "")
+        return ".";
+    const p = normSep(path);
+    const abs = isAbsolute(p);
+    // Preserve drive letter prefix
+    let prefix = "";
+    const driveMatch = p.match(DRIVE_LETTER);
+    if (driveMatch) {
+        prefix = driveMatch[0];
+    }
+    else if (abs) {
+        prefix = "/";
+    }
+    const pathWithoutPrefix = driveMatch ? p.slice(prefix.length) : abs ? p.slice(1) : p;
+    const parts = pathWithoutPrefix.split("/").filter((s) => s && s !== ".");
+    const normalized = [];
+    for (const part of parts) {
+        if (part !== "..") {
+            normalized.push(part);
+            continue;
+        }
+        const last = normalized[normalized.length - 1];
+        if (normalized.length > 0 && last !== "..") {
+            normalized.pop();
+            continue;
+        }
+        if (!abs)
+            normalized.push("..");
+    }
+    const result = normalized.join("/");
+    if (abs)
+        return result ? `${prefix}${result}` : prefix || "/";
+    return result || ".";
+}

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

@@ -0,0 +1,8 @@
+import type { NodePathModule } from "./types.js";
+export declare const isDeno: boolean;
+declare let nodePath: NodePathModule | null;
+export { nodePath };
+export declare const sep: string;
+export declare const delimiter: string;
+export declare const hasNodePath: boolean;
+//# sourceMappingURL=runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/path/runtime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAKjD,eAAO,MAAM,MAAM,SAAsC,CAAC;AAE1D,QAAA,IAAI,QAAQ,EAAE,cAAc,GAAG,IAAW,CAAC;AAa3C,OAAO,EAAE,QAAQ,EAAE,CAAC;AAEpB,eAAO,MAAM,GAAG,QAAuB,CAAC;AACxC,eAAO,MAAM,SAAS,QAA6B,CAAC;AACpD,eAAO,MAAM,WAAW,SAAoB,CAAC"}

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

@@ -0,0 +1,20 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+const globalProcess = dntShim.dntGlobalThis.process;
+const hasNodeApis = !!globalProcess?.versions?.node || "Bun" in dntShim.dntGlobalThis;
+export const isDeno = typeof dntShim.Deno !== "undefined";
+let nodePath = null;
+if (hasNodeApis) {
+    try {
+        const nodeRequire = typeof require !== "undefined" ? require : null;
+        if (nodeRequire) {
+            nodePath = nodeRequire("node:path");
+        }
+    }
+    catch (_) {
+        /* expected: node:path require may fail in non-Node runtimes */
+    }
+}
+export { nodePath };
+export const sep = nodePath?.sep ?? "/";
+export const delimiter = nodePath?.delimiter ?? ":";
+export const hasNodePath = nodePath !== null;

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

@@ -0,0 +1,2 @@
+export declare function validatePathSecurity(path: string): boolean;
+//# sourceMappingURL=security.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"security.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/path/security.ts"],"names":[],"mappings":"AAMA,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAsB1D"}

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

@@ -0,0 +1,24 @@
+import { FORBIDDEN_PATH_PATTERNS, MAX_PATH_LENGTH, MAX_PATH_TRAVERSAL_DEPTH, } from "../../../utils/constants/security.js";
+export function validatePathSecurity(path) {
+    if (path == null)
+        return false;
+    if (path.length > MAX_PATH_LENGTH)
+        return false;
+    for (const pattern of FORBIDDEN_PATH_PATTERNS) {
+        if (pattern.test(path))
+            return false;
+    }
+    const parts = path.split(/[\/\\]/);
+    let depth = 0;
+    for (const part of parts) {
+        if (part === "..") {
+            depth++;
+        }
+        else if (part !== "." && part !== "") {
+            depth = 0;
+        }
+        if (depth > MAX_PATH_TRAVERSAL_DEPTH)
+            return false;
+    }
+    return true;
+}

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

@@ -0,0 +1,22 @@
+export interface PathObject {
+    root?: string;
+    dir?: string;
+    base?: string;
+    ext?: string;
+    name?: string;
+}
+export interface NodePathModule {
+    sep: string;
+    delimiter: string;
+    join(...paths: string[]): string;
+    resolve(...paths: string[]): string;
+    dirname(path: string): string;
+    basename(path: string, ext?: string): string;
+    extname(path: string): string;
+    isAbsolute(path: string): boolean;
+    relative(from: string, to: string): string;
+    normalize(path: string): string;
+    parse(path: string): PathObject;
+    format(pathObject: PathObject): string;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/path/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IACjC,OAAO,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IACpC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7C,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3C,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAChC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;IAChC,MAAM,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAAC;CACxC"}

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

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

package/esm/src/platform/compat/path/url-conversion.d.ts

@@ -0,0 +1,3 @@
+export declare function fromFileUrl(url: string | URL): string;
+export declare function toFileUrl(path: string): URL;
+//# sourceMappingURL=url-conversion.d.ts.map

package/esm/src/platform/compat/path/url-conversion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url-conversion.d.ts","sourceRoot":"","sources":["../../../../../src/src/platform/compat/path/url-conversion.ts"],"names":[],"mappings":"AA6BA,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,MAAM,CAuBrD;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAG3C"}

package/esm/src/platform/compat/path/url-conversion.js

@@ -0,0 +1,45 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+import { hasNodePath, isDeno } from "./runtime.js";
+import { isAbsolute, resolve } from "./resolution.js";
+let _fileURLToPath = null;
+function getFileURLToPath() {
+    if (_fileURLToPath)
+        return _fileURLToPath;
+    if (!hasNodePath)
+        return null;
+    try {
+        const nodeUrl = dntShim.dntGlobalThis.require?.("node:url");
+        const fileURLToPath = nodeUrl?.fileURLToPath;
+        if (!fileURLToPath)
+            return null;
+        _fileURLToPath = fileURLToPath;
+        return _fileURLToPath;
+    }
+    catch (_) {
+        /* expected: node:url require may fail in non-Node runtimes */
+        return null;
+    }
+}
+export function fromFileUrl(url) {
+    const fileURLToPath = getFileURLToPath();
+    if (fileURLToPath)
+        return fileURLToPath(url);
+    const urlString = typeof url === "string" ? url : url.toString();
+    if (isDeno) {
+        const g = dntShim.dntGlobalThis;
+        const hasCwd = Boolean(g.Deno?.cwd);
+        const isWindows = g.Deno?.build?.os === "windows";
+        if (hasCwd && isWindows) {
+            return decodeURIComponent(urlString.slice(8).replace(/\//g, "\\"));
+        }
+        return decodeURIComponent(urlString.slice(7));
+    }
+    if (!urlString.startsWith("file://")) {
+        throw new TypeError("Must be a file URL");
+    }
+    return decodeURIComponent(urlString.slice(7));
+}
+export function toFileUrl(path) {
+    const absolute = hasNodePath ? path : isAbsolute(path) ? path : resolve(path);
+    return new URL(`file://${absolute}`);
+}

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

@@ -0,0 +1,31 @@
+export interface CommandResult {
+    success: boolean;
+    code: number;
+    stdout?: string;
+    stderr?: string;
+}
+export interface CommandOptions {
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    /** 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,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,CAuLxB"}

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

@@ -0,0 +1,194 @@
+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, 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,
+            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: 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: 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", () => {
+            timeout.clear();
+            resolve({ success: false, code: 1 });
+        });
+    });
+}