emsdk-env 0.1.0 → 0.3.0

package/dist/build-CYHeaOdc.js

@@ -0,0 +1,890 @@
+/*!
+ * name: emsdk-env
+ * version: 0.3.0
+ * description: Emscripten environment builder
+ * author: Kouji Matsui (@kekyo@mi.kekyo.net)
+ * license: MIT
+ * repository.url: https://github.com/kekyo/emsdk-env
+ * git.commit.hash: 4a03739b8c88111950fa216a7c10c7bfd65ea239
+ */
+
+import { mkdir, access, constants, mkdtemp, rename, rm } from "fs/promises";
+import { homedir, tmpdir } from "os";
+import { glob } from "glob";
+import { join, resolve, isAbsolute, relative } from "path";
+import { spawn } from "child_process";
+const __NOOP_HANDLER = () => {
+};
+const __NOOP_RELEASABLE = {
+  release: __NOOP_HANDLER,
+  [Symbol.dispose]: __NOOP_HANDLER
+};
+const toAbortError = (reason) => {
+  if (reason instanceof Error) {
+    return reason;
+  }
+  if (typeof reason === "string") {
+    return new Error(reason);
+  }
+  return new Error("Operation aborted");
+};
+const onAbort = (signal, callback) => {
+  if (!signal) {
+    return __NOOP_RELEASABLE;
+  }
+  if (signal.aborted) {
+    try {
+      callback(toAbortError(signal.reason));
+    } catch (error) {
+      console.warn("AbortHook callback error: ", error);
+    }
+    return __NOOP_RELEASABLE;
+  }
+  let abortHandler;
+  abortHandler = () => {
+    if (abortHandler) {
+      const reason = signal.reason;
+      signal.removeEventListener("abort", abortHandler);
+      abortHandler = void 0;
+      try {
+        callback(toAbortError(reason));
+      } catch (error) {
+        console.warn("AbortHook callback error: ", error);
+      }
+    }
+  };
+  const release = () => {
+    if (abortHandler) {
+      signal.removeEventListener("abort", abortHandler);
+      abortHandler = void 0;
+    }
+  };
+  signal.addEventListener("abort", abortHandler, { once: true });
+  const handle = {
+    release,
+    [Symbol.dispose]: release
+  };
+  return handle;
+};
+const defer = (fn) => {
+  if (typeof setImmediate === "function") {
+    setImmediate(fn);
+  } else {
+    setTimeout(fn, 0);
+  }
+};
+const ABORTED_ERROR$2 = () => new Error("Lock acquisition was aborted");
+const createLockHandle = (releaseCallback) => {
+  let isActive = true;
+  const release = () => {
+    if (!isActive) {
+      return;
+    }
+    isActive = false;
+    releaseCallback();
+  };
+  return {
+    get isActive() {
+      return isActive;
+    },
+    release,
+    [Symbol.dispose]: release
+  };
+};
+const createMutex = (maxConsecutiveCalls = 20) => {
+  let isLocked = false;
+  const queue = [];
+  let count = 0;
+  const processQueue = () => {
+    var _a;
+    if (isLocked || queue.length === 0) {
+      return;
+    }
+    const item = queue.shift();
+    if ((_a = item.signal) == null ? void 0 : _a.aborted) {
+      item.reject(ABORTED_ERROR$2());
+      scheduleNextProcess();
+      return;
+    }
+    isLocked = true;
+    const lockHandle = createLockHandle(releaseLock);
+    item.resolve(lockHandle);
+  };
+  const scheduleNextProcess = () => {
+    count++;
+    if (count >= maxConsecutiveCalls) {
+      count = 0;
+      defer(processQueue);
+    } else {
+      processQueue();
+    }
+  };
+  const releaseLock = () => {
+    if (!isLocked) {
+      return;
+    }
+    isLocked = false;
+    scheduleNextProcess();
+  };
+  const removeFromQueue = (item) => {
+    const index = queue.indexOf(item);
+    if (index !== -1) {
+      queue.splice(index, 1);
+    }
+  };
+  const lock = async (signal) => {
+    if (signal) {
+      if (signal.aborted) {
+        throw ABORTED_ERROR$2();
+      }
+      return new Promise((resolve2, reject) => {
+        const queueItem = {
+          resolve: void 0,
+          reject: void 0,
+          signal
+        };
+        const abortHandle = onAbort(signal, () => {
+          removeFromQueue(queueItem);
+          reject(ABORTED_ERROR$2());
+        });
+        queueItem.resolve = (handle) => {
+          abortHandle.release();
+          resolve2(handle);
+        };
+        queueItem.reject = (error) => {
+          abortHandle.release();
+          reject(error);
+        };
+        queue.push(queueItem);
+        processQueue();
+      });
+    } else {
+      return new Promise((resolve2, reject) => {
+        queue.push({
+          resolve: resolve2,
+          reject
+        });
+        processQueue();
+      });
+    }
+  };
+  const result = {
+    lock,
+    waiter: {
+      wait: lock
+    },
+    get isLocked() {
+      return isLocked;
+    },
+    get pendingCount() {
+      return queue.length;
+    }
+  };
+  return result;
+};
+const createAbortError = () => {
+  const error = new Error("The operation was aborted.");
+  error.name = "AbortError";
+  return error;
+};
+const runCommand = async (command, args, cwd, signal) => {
+  signal == null ? void 0 : signal.throwIfAborted();
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: "inherit"
+    });
+    let settled = false;
+    const onAbort2 = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      child.kill();
+      rejectPromise(createAbortError());
+    };
+    signal == null ? void 0 : signal.addEventListener("abort", onAbort2, { once: true });
+    const cleanup = () => {
+      signal == null ? void 0 : signal.removeEventListener("abort", onAbort2);
+    };
+    child.once("error", (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      rejectPromise(error);
+    });
+    child.once("close", (code) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      if (code === 0) {
+        resolvePromise();
+        return;
+      }
+      rejectPromise(
+        new Error(
+          `Command failed: ${command} ${args.join(" ")} (exit code ${code})`
+        )
+      );
+    });
+  });
+};
+const runCommandWithEnv = async (command, args, cwd, env, signal) => {
+  signal == null ? void 0 : signal.throwIfAborted();
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn(command, args, {
+      cwd,
+      env,
+      stdio: "inherit"
+    });
+    let settled = false;
+    const onAbort2 = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      child.kill();
+      rejectPromise(createAbortError());
+    };
+    signal == null ? void 0 : signal.addEventListener("abort", onAbort2, { once: true });
+    const cleanup = () => {
+      signal == null ? void 0 : signal.removeEventListener("abort", onAbort2);
+    };
+    child.once("error", (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      rejectPromise(error);
+    });
+    child.once("close", (code) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      if (code === 0) {
+        resolvePromise();
+        return;
+      }
+      rejectPromise(
+        new Error(
+          `Command failed: ${command} ${args.join(" ")} (exit code ${code})`
+        )
+      );
+    });
+  });
+};
+const runCommandCapture = async (command, args, cwd, signal) => {
+  signal == null ? void 0 : signal.throwIfAborted();
+  return new Promise((resolvePromise, rejectPromise) => {
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    const child = spawn(command, args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let settled = false;
+    const onAbort2 = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      child.kill();
+      rejectPromise(createAbortError());
+    };
+    signal == null ? void 0 : signal.addEventListener("abort", onAbort2, { once: true });
+    const cleanup = () => {
+      signal == null ? void 0 : signal.removeEventListener("abort", onAbort2);
+    };
+    child.stdout.on("data", (chunk) => {
+      stdoutChunks.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrChunks.push(chunk);
+    });
+    child.once("error", (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      rejectPromise(error);
+    });
+    child.once("close", (code) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      if (code === 0) {
+        resolvePromise(Buffer.concat(stdoutChunks));
+        return;
+      }
+      const stderrText = Buffer.concat(stderrChunks).toString("utf8");
+      rejectPromise(
+        new Error(
+          `Command failed: ${command} ${args.join(" ")} (exit code ${code})${stderrText ? `
+${stderrText}` : ""}`
+        )
+      );
+    });
+  });
+};
+const pathExists = async (targetPath) => {
+  try {
+    await access(targetPath, constants.F_OK);
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+const ensureDirectory = async (targetPath) => {
+  await mkdir(targetPath, { recursive: true });
+};
+const DEFAULT_REPO_URL = "https://github.com/emscripten-core/emsdk.git";
+const DEFAULT_GIT_REF = "main";
+const DEFAULT_CACHE_DIR = join(homedir(), ".cache", "emsdk-env");
+const DEFAULT_TARGET_VERSION = "latest";
+const versionMutexes = /* @__PURE__ */ new Map();
+const getVersionMutex = (key) => {
+  let mutex = versionMutexes.get(key);
+  if (!mutex) {
+    mutex = createMutex();
+    versionMutexes.set(key, mutex);
+  }
+  return mutex;
+};
+const ensureNonEmpty = (value, label) => {
+  if (value.trim().length === 0) {
+    throw new TypeError(`${label} must be a non-empty string.`);
+  }
+};
+const sanitizeSegment = (value) => {
+  const trimmed = value.trim();
+  ensureNonEmpty(trimmed, "targetVersion");
+  const sanitized = trimmed.replace(/[^A-Za-z0-9._-]/g, "_");
+  if (sanitized === "." || sanitized === ".." || sanitized.length === 0) {
+    throw new TypeError("targetVersion results in an unsafe path segment.");
+  }
+  return sanitized;
+};
+const resolveEmsdkCommand = () => process.platform === "win32" ? "emsdk.bat" : "./emsdk";
+const runEmsdk = async (repoDir, args, signal) => {
+  if (process.platform === "win32") {
+    await runCommand("cmd", ["/c", "emsdk.bat", ...args], repoDir, signal);
+    return;
+  }
+  await runCommand(resolveEmsdkCommand(), args, repoDir, signal);
+};
+const runGitClone = async (gitPath, repoUrl, targetDir, cwd, signal) => {
+  await runCommand(
+    gitPath,
+    ["clone", repoUrl, targetDir, "--depth", "1", "--branch", DEFAULT_GIT_REF],
+    cwd,
+    signal
+  );
+};
+const isAlreadyExistsError = (error) => error instanceof Error && "code" in error && error.code !== void 0 && ["EEXIST", "ENOTEMPTY", "EISDIR"].includes(
+  String(error.code)
+);
+const prepareEmsdk = async (options) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  if (!options) {
+    throw new TypeError("options must be provided.");
+  }
+  if (options.targetVersion !== void 0 && typeof options.targetVersion !== "string") {
+    throw new TypeError("targetVersion must be a string.");
+  }
+  const targetVersion = (_a = options.targetVersion) != null ? _a : DEFAULT_TARGET_VERSION;
+  ensureNonEmpty(targetVersion, "targetVersion");
+  (_b = options.signal) == null ? void 0 : _b.throwIfAborted();
+  const cacheDir = resolve((_c = options.cacheDir) != null ? _c : DEFAULT_CACHE_DIR);
+  const repoUrl = (_d = options.repoUrl) != null ? _d : DEFAULT_REPO_URL;
+  const gitPath = (_e = options.gitPath) != null ? _e : "git";
+  const versionDir = sanitizeSegment(targetVersion);
+  const finalDir = resolve(cacheDir, versionDir);
+  const mutex = getVersionMutex(finalDir);
+  const lock = await mutex.lock(options.signal);
+  try {
+    (_f = options.signal) == null ? void 0 : _f.throwIfAborted();
+    if (await pathExists(finalDir)) {
+      return finalDir;
+    }
+    await ensureDirectory(cacheDir);
+    const tempRoot = await mkdtemp(join(cacheDir, ".tmp-"));
+    const tempRepoDir = join(tempRoot, "emsdk");
+    try {
+      await runGitClone(
+        gitPath,
+        repoUrl,
+        tempRepoDir,
+        cacheDir,
+        options.signal
+      );
+      (_g = options.signal) == null ? void 0 : _g.throwIfAborted();
+      await runEmsdk(tempRepoDir, ["install", targetVersion], options.signal);
+      try {
+        await rename(tempRepoDir, finalDir);
+      } catch (error) {
+        if (isAlreadyExistsError(error)) {
+          return finalDir;
+        }
+        throw error;
+      }
+    } finally {
+      await rm(tempRoot, { recursive: true, force: true });
+    }
+    (_h = options.signal) == null ? void 0 : _h.throwIfAborted();
+    await runEmsdk(finalDir, ["activate", targetVersion], options.signal);
+    return finalDir;
+  } finally {
+    lock.release();
+  }
+};
+const shellQuote = (value) => `'${String(value).replace(/'/g, `'"'"'`)}'`;
+const parseEnvBuffer = (buffer) => {
+  const entries = buffer.toString("utf8").split("\0");
+  const env = {};
+  for (const entry of entries) {
+    if (!entry) {
+      continue;
+    }
+    const delimiterIndex = entry.indexOf("=");
+    if (delimiterIndex <= 0) {
+      continue;
+    }
+    const key = entry.slice(0, delimiterIndex);
+    const value = entry.slice(delimiterIndex + 1);
+    env[key] = value;
+  }
+  return env;
+};
+const loadEmsdkEnv = async (emsdkRoot, logger, signal) => {
+  if (process.platform === "win32") {
+    throw new Error(
+      "Emscripten environment extraction on Windows is not implemented yet."
+    );
+  }
+  const envScript = resolve(emsdkRoot, "emsdk_env.sh");
+  if (!await pathExists(envScript)) {
+    throw new Error(`emsdk_env.sh not found: ${envScript}`);
+  }
+  const command = `. ${shellQuote(envScript)} >/dev/null 2>&1; env -0`;
+  logger.debug(`Loading emsdk environment: ${envScript}`);
+  const output = await runCommandCapture(
+    "bash",
+    ["-lc", command],
+    emsdkRoot,
+    signal
+  );
+  return parseEnvBuffer(output);
+};
+const resolveEmccCommand = async (env, emsdkRoot) => {
+  if (env.EMCC) {
+    return env.EMCC;
+  }
+  if (env.EMSCRIPTEN) {
+    const candidate = join(env.EMSCRIPTEN, "emcc");
+    if (await pathExists(candidate)) {
+      return candidate;
+    }
+  }
+  const fallback = join(emsdkRoot, "upstream", "emscripten", "emcc");
+  if (await pathExists(fallback)) {
+    return fallback;
+  }
+  return "emcc";
+};
+const createConsoleLogger = (prefix) => {
+  return {
+    debug: (msg) => console.debug(`[${prefix}]: ${msg}`),
+    info: (msg) => console.info(`[${prefix}]: ${msg}`),
+    warn: (msg) => console.warn(`[${prefix}]: ${msg}`),
+    error: (msg) => console.error(`[${prefix}]: ${msg}`)
+  };
+};
+const DEFAULT_WASM_SRC_DIR = "wasm";
+const DEFAULT_WASM_OUT_DIR = join("src", "wasm");
+const DEFAULT_WASM_BUILD_DIR = join(tmpdir(), "emsdk-env");
+const DEFAULT_EMSDK_TARGET_VERSION = "latest";
+let buildSequence = 0;
+const padNumber = (value, length = 2) => String(value).padStart(length, "0");
+const formatTimestamp = (date) => {
+  const year = date.getFullYear();
+  const month = padNumber(date.getMonth() + 1);
+  const day = padNumber(date.getDate());
+  const hour = padNumber(date.getHours());
+  const minute = padNumber(date.getMinutes());
+  const second = padNumber(date.getSeconds());
+  return `${year}${month}${day}_${hour}${minute}${second}`;
+};
+const createBuildId = () => {
+  buildSequence += 1;
+  const timestamp = formatTimestamp(/* @__PURE__ */ new Date());
+  const seq = String(buildSequence).padStart(4, "0");
+  return `${timestamp}_${seq}_${process.pid}`;
+};
+const ensureArray = (value) => value != null ? value : [];
+const normalizePrepareOptions = (options) => {
+  const { targetVersion, ...rest } = options != null ? options : {};
+  return {
+    targetVersion: targetVersion != null ? targetVersion : DEFAULT_EMSDK_TARGET_VERSION,
+    ...rest
+  };
+};
+const mergeDefines = (common, target) => ({
+  ...common != null ? common : {},
+  ...target != null ? target : {}
+});
+const resolvePath = (rootDir, value) => isAbsolute(value) ? value : resolve(rootDir, value);
+const expandPlaceholders = (value, env, label) => value.replace(/\{([A-Z0-9_]+)\}/g, (_match, key) => {
+  const replacement = env[key];
+  if (replacement === void 0) {
+    throw new Error(`Unknown placeholder {${key}} in ${label}.`);
+  }
+  return replacement;
+});
+const expandArray = (values, env, label) => values.map((value) => expandPlaceholders(value, env, label));
+const resolveDefines = (defines, env) => {
+  const resolved = {};
+  for (const [key, value] of Object.entries(defines)) {
+    if (typeof value === "string") {
+      resolved[key] = expandPlaceholders(value, env, `defines.${key}`);
+    } else {
+      resolved[key] = value;
+    }
+  }
+  return resolved;
+};
+const resolveIncludeDirs = (includeDirs, env, rootDir) => {
+  const expanded = expandArray(includeDirs, env, "includeDirs");
+  return expanded.map((value) => resolvePath(rootDir, value));
+};
+const resolveOutFile = (outFile, env, outDir) => {
+  const expanded = expandPlaceholders(outFile, env, "outFile");
+  return resolvePath(outDir, expanded);
+};
+const resolveSourcesFromPatterns = async (patterns, env, srcDir, label) => {
+  const expanded = expandArray(patterns, env, label);
+  const resolvedPatterns = expanded.map((value) => resolvePath(srcDir, value));
+  const results = await Promise.all(
+    resolvedPatterns.map((pattern) => glob(pattern, { nodir: true }))
+  );
+  const sources = results.flat();
+  sources.sort();
+  return sources;
+};
+const buildDefineFlags = (defines) => Object.entries(defines).map(([key, value]) => `-D${key}=${String(value)}`);
+const buildExportFlags = (exports$1) => {
+  if (exports$1.length === 0) {
+    return [];
+  }
+  return ["-s", `EXPORTED_FUNCTIONS=${JSON.stringify(exports$1)}`];
+};
+const createEnvForBuild = (baseEnv, overrides) => ({
+  ...process.env,
+  ...baseEnv,
+  ...overrides
+});
+const resolveTargetOutFile = (targetName, targetOutFile, env, outDir) => {
+  if (targetOutFile) {
+    return resolveOutFile(targetOutFile, env, outDir);
+  }
+  return resolve(outDir, `${targetName}.wasm`);
+};
+const resolveTargetSources = async (targetSources, env, srcDir) => {
+  const patterns = targetSources && targetSources.length > 0 ? targetSources : [join(srcDir, "**", "*.c"), join(srcDir, "**", "*.cpp")];
+  return resolveSourcesFromPatterns(patterns, env, srcDir, "sources");
+};
+const toSafeObjectName = (rootDir, sourcePath, groupIndex) => {
+  const baseName = relative(rootDir, sourcePath).replace(/[\\/]/g, "_").replace(/[^A-Za-z0-9._-]/g, "_");
+  if (groupIndex === void 0) {
+    return baseName;
+  }
+  return `${baseName}__g${groupIndex}`;
+};
+const dedupeSources = (sources) => {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const source of sources) {
+    if (seen.has(source)) {
+      continue;
+    }
+    seen.add(source);
+    deduped.push(source);
+  }
+  return deduped;
+};
+const buildCompileArgs = (options, includeDirs, defines, env, rootDir) => {
+  const resolvedOptions = expandArray(options, env, "options");
+  const includeArgs = resolveIncludeDirs(includeDirs, env, rootDir).map(
+    (dir) => `-I${dir}`
+  );
+  const defineArgs = buildDefineFlags(resolveDefines(defines, env));
+  return { resolvedOptions, includeArgs, defineArgs };
+};
+const buildWasm = async (options) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  if (!options) {
+    throw new TypeError("options must be provided.");
+  }
+  if (!options.rule || !options.rule.targets) {
+    throw new TypeError("rule targets must be provided.");
+  }
+  const targets = Object.entries(options.rule.targets);
+  if (targets.length === 0) {
+    throw new TypeError("rule targets must not be empty.");
+  }
+  const logger = (_a = options.logger) != null ? _a : createConsoleLogger("emsdk-env");
+  const rootDir = resolve((_b = options.root) != null ? _b : process.cwd());
+  const emsdkOptions = normalizePrepareOptions(options.emsdk);
+  const emsdkRoot = await prepareEmsdk(emsdkOptions);
+  const emsdkEnv = await loadEmsdkEnv(emsdkRoot, logger, emsdkOptions.signal);
+  const baseEnv = {
+    ...emsdkEnv,
+    ROOT: rootDir
+  };
+  const rawSrcDir = expandPlaceholders(
+    (_c = options.srcDir) != null ? _c : DEFAULT_WASM_SRC_DIR,
+    baseEnv,
+    "srcDir"
+  );
+  const rawOutDir = expandPlaceholders(
+    (_d = options.outDir) != null ? _d : DEFAULT_WASM_OUT_DIR,
+    baseEnv,
+    "outDir"
+  );
+  const rawBuildDir = expandPlaceholders(
+    (_e = options.buildDir) != null ? _e : DEFAULT_WASM_BUILD_DIR,
+    baseEnv,
+    "buildDir"
+  );
+  const srcDir = resolvePath(rootDir, rawSrcDir);
+  const outDir = resolvePath(rootDir, rawOutDir);
+  const buildDir = resolvePath(rootDir, rawBuildDir);
+  const buildId = createBuildId();
+  const buildRunDir = resolve(buildDir, buildId);
+  const cleanupBuildDir = (_f = options.cleanupBuildDir) != null ? _f : true;
+  const parallel = (_g = options.parallel) != null ? _g : true;
+  const envWithDirs = {
+    ...emsdkEnv,
+    ROOT: rootDir,
+    SRC_DIR: srcDir,
+    OUT_DIR: outDir,
+    BUILD_DIR: buildDir
+  };
+  const emccCommand = await resolveEmccCommand(envWithDirs, emsdkRoot);
+  const common = (_h = options.rule.common) != null ? _h : {};
+  await ensureDirectory(outDir);
+  await ensureDirectory(buildDir);
+  await rm(buildRunDir, { recursive: true, force: true });
+  await ensureDirectory(buildRunDir);
+  const outFiles = {};
+  try {
+    for (const [targetName, target] of targets) {
+      const mergedLinkOptions = [
+        ...ensureArray(common.linkOptions),
+        ...ensureArray(target.linkOptions)
+      ];
+      const mergedExports = [
+        ...ensureArray(common.exports),
+        ...ensureArray(target.exports)
+      ];
+      const baseCompileOptions = [
+        ...ensureArray(common.options),
+        ...ensureArray(target.options)
+      ];
+      const baseIncludeDirs = [
+        ...ensureArray(common.includeDirs),
+        ...ensureArray(target.includeDirs)
+      ];
+      const baseDefines = mergeDefines(common.defines, target.defines);
+      const sourceGroups = (_i = target.sourceGroups) != null ? _i : [];
+      const targetEnv = {
+        ...envWithDirs,
+        TARGET_NAME: targetName
+      };
+      const buildEnv = createEnvForBuild(targetEnv, {});
+      const resolvedOutFile = resolveTargetOutFile(
+        targetName,
+        target.outFile,
+        targetEnv,
+        outDir
+      );
+      const sources = await resolveTargetSources(
+        target.sources,
+        targetEnv,
+        srcDir
+      );
+      const groupSources = sourceGroups.map(() => []);
+      const groupSourceSet = /* @__PURE__ */ new Set();
+      for (let index = 0; index < sourceGroups.length; index += 1) {
+        const group = sourceGroups[index];
+        if (!group) {
+          continue;
+        }
+        const resolved = await resolveSourcesFromPatterns(
+          group.sources,
+          targetEnv,
+          srcDir,
+          `sourceGroups[${index}].sources`
+        );
+        const deduped = dedupeSources(resolved);
+        groupSources[index] = deduped;
+        for (const source of deduped) {
+          groupSourceSet.add(source);
+        }
+      }
+      const baseSources = sources.filter(
+        (source) => !groupSourceSet.has(source)
+      );
+      const groupedSources = groupSources.flat();
+      if (baseSources.length + groupedSources.length === 0) {
+        throw new Error(`No sources matched for target: ${targetName}`);
+      }
+      const targetBuildDir = resolve(buildRunDir, targetName);
+      await rm(targetBuildDir, { recursive: true, force: true });
+      await ensureDirectory(targetBuildDir);
+      const resolvedLinkOptions = expandArray(
+        mergedLinkOptions,
+        targetEnv,
+        "linkOptions"
+      );
+      const resolvedExports = expandArray(mergedExports, targetEnv, "exports");
+      const exportArgs = buildExportFlags(resolvedExports);
+      const baseCompileArgs = buildCompileArgs(
+        baseCompileOptions,
+        baseIncludeDirs,
+        baseDefines,
+        targetEnv,
+        rootDir
+      );
+      const groupCompileArgs = sourceGroups.map((group) => {
+        var _a2;
+        const groupOptions = [
+          ...baseCompileOptions,
+          ...ensureArray(group == null ? void 0 : group.options)
+        ];
+        const groupIncludeDirs = [
+          ...baseIncludeDirs,
+          ...ensureArray(group == null ? void 0 : group.includeDirs)
+        ];
+        const groupDefines = mergeDefines(baseDefines, (_a2 = group == null ? void 0 : group.defines) != null ? _a2 : {});
+        return buildCompileArgs(
+          groupOptions,
+          groupIncludeDirs,
+          groupDefines,
+          targetEnv,
+          rootDir
+        );
+      });
+      logger.info(`Compiling target: ${targetName}`);
+      const compileSource = async (source, args, groupIndex) => {
+        const objectName = toSafeObjectName(rootDir, source, groupIndex);
+        const outputObject = resolve(targetBuildDir, `${objectName}.o`);
+        const compileArgs = [
+          "-c",
+          source,
+          "-o",
+          outputObject,
+          ...args.resolvedOptions,
+          ...args.includeArgs,
+          ...args.defineArgs
+        ];
+        logger.debug(`emcc ${compileArgs.join(" ")}`);
+        await runCommandWithEnv(
+          emccCommand,
+          compileArgs,
+          rootDir,
+          buildEnv,
+          emsdkOptions.signal
+        );
+        return outputObject;
+      };
+      const buildObjectsSequential = async () => {
+        const objectFiles2 = [];
+        for (const source of baseSources) {
+          objectFiles2.push(
+            await compileSource(source, baseCompileArgs, void 0)
+          );
+        }
+        for (let index = 0; index < groupSources.length; index += 1) {
+          const sourcesInGroup = groupSources[index];
+          if (!sourcesInGroup) {
+            continue;
+          }
+          const groupArgs = groupCompileArgs[index];
+          if (!groupArgs) {
+            continue;
+          }
+          for (const source of sourcesInGroup) {
+            objectFiles2.push(await compileSource(source, groupArgs, index));
+          }
+        }
+        return objectFiles2;
+      };
+      const compileJobs = [];
+      for (const source of baseSources) {
+        compileJobs.push({
+          source,
+          args: baseCompileArgs,
+          groupIndex: void 0
+        });
+      }
+      for (let index = 0; index < groupSources.length; index += 1) {
+        const sourcesInGroup = groupSources[index];
+        if (!sourcesInGroup) {
+          continue;
+        }
+        const groupArgs = groupCompileArgs[index];
+        if (!groupArgs) {
+          continue;
+        }
+        for (const source of sourcesInGroup) {
+          compileJobs.push({ source, args: groupArgs, groupIndex: index });
+        }
+      }
+      const objectFiles = parallel ? await Promise.all(
+        compileJobs.map(
+          (job) => compileSource(job.source, job.args, job.groupIndex)
+        )
+      ) : await buildObjectsSequential();
+      logger.info(`Linking target: ${targetName}`);
+      const linkArgs = [
+        ...objectFiles,
+        "-o",
+        resolvedOutFile,
+        ...resolvedLinkOptions,
+        ...exportArgs
+      ];
+      logger.debug(`emcc ${linkArgs.join(" ")}`);
+      await runCommandWithEnv(
+        emccCommand,
+        linkArgs,
+        rootDir,
+        buildEnv,
+        emsdkOptions.signal
+      );
+      outFiles[targetName] = resolvedOutFile;
+    }
+  } finally {
+    if (cleanupBuildDir) {
+      await rm(buildRunDir, { recursive: true, force: true });
+    }
+  }
+  return {
+    emsdkRoot,
+    outFiles
+  };
+};
+export {
+  buildWasm as b,
+  prepareEmsdk as p
+};
+//# sourceMappingURL=build-CYHeaOdc.js.map