emsdk-env 0.9.0 → 0.11.0

package/dist/build-CgmcFNSR.cjs

@@ -1,1681 +0,0 @@
-/*!
- * name: emsdk-env
- * version: 0.9.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: 73d7e217903f020ef22daa9289362dcd19bddac1
- */
-
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-const promises = require("fs/promises");
-const os = require("os");
-const glob = require("glob");
-const path = require("path");
-const child_process = require("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((resolve, 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();
-          resolve(handle);
-        };
-        queueItem.reject = (error) => {
-          abortHandle.release();
-          reject(error);
-        };
-        queue.push(queueItem);
-        processQueue();
-      });
-    } else {
-      return new Promise((resolve, reject) => {
-        queue.push({
-          resolve,
-          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 = child_process.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 = child_process.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 = child_process.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 promises.access(targetPath, promises.constants.F_OK);
-    return true;
-  } catch (e) {
-    return false;
-  }
-};
-const ensureDirectory = async (targetPath) => {
-  await promises.mkdir(targetPath, { recursive: true });
-};
-const DEFAULT_REPO_URL = "https://github.com/emscripten-core/emsdk.git";
-const DEFAULT_GIT_REF = "main";
-const DEFAULT_CACHE_DIR = path.join(os.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 = path.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 = path.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 promises.mkdtemp(path.join(cacheDir, ".tmp-"));
-    const tempRepoDir = path.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 promises.rename(tempRepoDir, finalDir);
-      } catch (error) {
-        if (isAlreadyExistsError(error)) {
-          return finalDir;
-        }
-        throw error;
-      }
-    } finally {
-      await promises.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 = path.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 = path.join(env.EMSCRIPTEN, "emcc");
-    if (await pathExists(candidate)) {
-      return candidate;
-    }
-  }
-  const fallback = path.join(emsdkRoot, "upstream", "emscripten", "emcc");
-  if (await pathExists(fallback)) {
-    return fallback;
-  }
-  return "emcc";
-};
-const resolveEmarCommand = async (env, emsdkRoot) => {
-  if (env.EMAR) {
-    return env.EMAR;
-  }
-  if (env.EMSCRIPTEN) {
-    const candidate = path.join(env.EMSCRIPTEN, "emar");
-    if (await pathExists(candidate)) {
-      return candidate;
-    }
-  }
-  const fallback = path.join(emsdkRoot, "upstream", "emscripten", "emar");
-  if (await pathExists(fallback)) {
-    return fallback;
-  }
-  return "emar";
-};
-const resolveWasmOptCommand = async (env, emsdkRoot) => {
-  var _a;
-  if (env.WASM_OPT) {
-    return env.WASM_OPT;
-  }
-  const binaryenRoot = (_a = env.BINARYEN_ROOT) != null ? _a : env.BINARYEN;
-  if (binaryenRoot) {
-    const candidate = path.join(binaryenRoot, "bin", "wasm-opt");
-    if (await pathExists(candidate)) {
-      return candidate;
-    }
-  }
-  const fallback = path.join(emsdkRoot, "upstream", "bin", "wasm-opt");
-  if (await pathExists(fallback)) {
-    return fallback;
-  }
-  return "wasm-opt";
-};
-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_INCLUDE_DIR = "include";
-const DEFAULT_WASM_OUT_DIR = path.join("src", "wasm");
-const DEFAULT_WASM_LIB_DIR = "lib";
-const DEFAULT_IMPORT_INCLUDE_DIR = "include";
-const DEFAULT_IMPORT_LIB_DIR = "lib";
-const DEFAULT_WASM_BUILD_DIR = path.join(os.tmpdir(), "emsdk-env");
-const DEFAULT_EMSDK_TARGET_VERSION = "latest";
-const DEFAULT_WASM_OPT_ARGS = ["-Oz"];
-const DEFAULT_GENERATED_LOADER_OUT_FILE = path.join(
-  "src",
-  "generated",
-  "wasm-loader.ts"
-);
-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 resolveTargetType = (value) => value != null ? value : "wasm";
-const normalizePrepareOptions = (options) => {
-  const { targetVersion, ...rest } = options != null ? options : {};
-  return {
-    targetVersion: targetVersion != null ? targetVersion : DEFAULT_EMSDK_TARGET_VERSION,
-    ...rest
-  };
-};
-const parseStringKeyValueInput = (values) => {
-  const parsed = {};
-  for (const entry of values) {
-    const index = entry.indexOf("=");
-    if (index === -1) {
-      parsed[entry] = void 0;
-      continue;
-    }
-    const key = entry.slice(0, index);
-    const value = entry.slice(index + 1);
-    parsed[key] = value;
-  }
-  return parsed;
-};
-const isDefineMap = (input) => input instanceof Map;
-const normalizeDefineInput = (input) => {
-  if (!input) {
-    return {};
-  }
-  if (Array.isArray(input)) {
-    return parseStringKeyValueInput(input);
-  }
-  if (isDefineMap(input)) {
-    return Object.fromEntries(input);
-  }
-  return { ...input };
-};
-const isLinkDirectiveMap = (input) => input instanceof Map;
-const normalizeLinkDirectiveInput = (input) => {
-  if (!input) {
-    return {};
-  }
-  if (Array.isArray(input)) {
-    return parseStringKeyValueInput(input);
-  }
-  if (isLinkDirectiveMap(input)) {
-    return Object.fromEntries(input);
-  }
-  return { ...input };
-};
-const mergeDefines = (common, target) => ({
-  ...normalizeDefineInput(common),
-  ...normalizeDefineInput(target)
-});
-const mergeLinkDirectives = (common, target) => ({
-  ...normalizeLinkDirectiveInput(common),
-  ...normalizeLinkDirectiveInput(target)
-});
-const resolveWasmOptEnabled = (common, target) => {
-  var _a, _b;
-  return (_b = (_a = target == null ? void 0 : target.enable) != null ? _a : common == null ? void 0 : common.enable) != null ? _b : false;
-};
-const resolveWasmOptArgs = (common, target, env) => {
-  var _a, _b;
-  const commonArgs = (_a = common == null ? void 0 : common.options) != null ? _a : DEFAULT_WASM_OPT_ARGS;
-  const targetArgs = (_b = target == null ? void 0 : target.options) != null ? _b : [];
-  const mergedArgs = [...commonArgs, ...targetArgs];
-  return expandArray(mergedArgs, env, "wasmOpt.options");
-};
-const stripOuterQuotes = (value) => {
-  const trimmed = value.trim();
-  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
-    return trimmed.slice(1, -1);
-  }
-  return trimmed;
-};
-const extractWasmBinaryFile = (value) => {
-  if (value.startsWith("WASM_BINARY_FILE=")) {
-    return value.slice("WASM_BINARY_FILE=".length);
-  }
-  const match = value.match(/^(?:-s|--settings)(?:=)?WASM_BINARY_FILE=(.+)$/);
-  if (match) {
-    return match[1];
-  }
-  return void 0;
-};
-const resolveWasmBinaryFileFromLinkOptions = (linkOptions) => {
-  for (let index = 0; index < linkOptions.length; index += 1) {
-    const option = linkOptions[index];
-    if (!option) {
-      continue;
-    }
-    if (option === "-s" || option === "--settings") {
-      const next = linkOptions[index + 1];
-      if (!next) {
-        continue;
-      }
-      const extracted2 = extractWasmBinaryFile(next);
-      if (extracted2) {
-        return stripOuterQuotes(extracted2);
-      }
-    }
-    const extracted = extractWasmBinaryFile(option);
-    if (extracted) {
-      return stripOuterQuotes(extracted);
-    }
-  }
-  return void 0;
-};
-const resolveWasmOptInputFile = (resolvedOutFile, resolvedLinkOptions) => {
-  const wasmBinaryFile = resolveWasmBinaryFileFromLinkOptions(resolvedLinkOptions);
-  if (wasmBinaryFile) {
-    return path.isAbsolute(wasmBinaryFile) ? wasmBinaryFile : path.resolve(path.dirname(resolvedOutFile), wasmBinaryFile);
-  }
-  const parsed = path.parse(resolvedOutFile);
-  if (parsed.ext.toLowerCase() === ".wasm") {
-    return resolvedOutFile;
-  }
-  const baseName = parsed.name.toLowerCase().endsWith(".wasm") ? parsed.name : `${parsed.name}.wasm`;
-  return path.join(parsed.dir, baseName);
-};
-const resolvePath = (rootDir, value) => path.isAbsolute(value) ? value : path.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 resolveLinkDirectiveValue = (value, env, label) => {
-  if (typeof value === "string") {
-    return expandPlaceholders(value, env, label);
-  }
-  if (Array.isArray(value)) {
-    return value.map(
-      (entry, index) => expandPlaceholders(entry, env, `${label}[${index}]`)
-    );
-  }
-  return value;
-};
-const resolveLinkDirectives = (directives, env) => {
-  const resolved = {};
-  for (const [key, value] of Object.entries(directives)) {
-    resolved[key] = resolveLinkDirectiveValue(
-      value,
-      env,
-      `linkDirectives.${key}`
-    );
-  }
-  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.glob(pattern, { nodir: true }))
-  );
-  const sources = results.flat();
-  sources.sort();
-  return sources;
-};
-const buildDefineFlags = (defines) => Object.entries(defines).flatMap(
-  ([key, value]) => value === null || value === void 0 ? [`-D${key}`] : [`-D${key}=${String(value)}`]
-);
-const serializeLinkDirectiveValue = (value) => Array.isArray(value) ? JSON.stringify(value) : String(value);
-const buildLinkDirectiveFlags = (directives) => {
-  if (Object.keys(directives).length === 0) {
-    return [];
-  }
-  return Object.entries(directives).flatMap(
-    ([key, value]) => value === null || value === void 0 ? ["-s", key] : ["-s", `${key}=${serializeLinkDirectiveValue(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, baseDir, extension) => {
-  if (targetOutFile) {
-    return resolveOutFile(targetOutFile, env, baseDir);
-  }
-  return path.resolve(baseDir, `${targetName}.${extension}`);
-};
-const resolveTargetSources = async (targetSources, env, srcDir) => {
-  const patterns = targetSources && targetSources.length > 0 ? targetSources : [path.join(srcDir, "**", "*.c"), path.join(srcDir, "**", "*.cpp")];
-  return resolveSourcesFromPatterns(patterns, env, srcDir, "sources");
-};
-const toSafeObjectName = (rootDir, sourcePath, groupIndex) => {
-  const baseName = path.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 dedupeValues = (values) => {
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = [];
-  for (const value of values) {
-    if (seen.has(value)) {
-      continue;
-    }
-    seen.add(value);
-    deduped.push(value);
-  }
-  return deduped;
-};
-const isSubPath = (parentDir, targetPath) => {
-  const rel = path.relative(parentDir, targetPath);
-  if (rel === "") {
-    return true;
-  }
-  return !rel.startsWith("..") && !path.isAbsolute(rel);
-};
-const readTextIfExists = async (filePath) => {
-  try {
-    return await promises.readFile(filePath, "utf8");
-  } catch (error) {
-    const nodeError = error;
-    if (nodeError.code === "ENOENT") {
-      return void 0;
-    }
-    throw error;
-  }
-};
-const writeTextIfChanged = async (filePath, content) => {
-  const existing = await readTextIfExists(filePath);
-  if (existing === content) {
-    return false;
-  }
-  await ensureDirectory(path.dirname(filePath));
-  await promises.writeFile(filePath, content, "utf8");
-  return true;
-};
-const toPascalCaseIdentifier = (value) => {
-  const tokens = value.split(/[^A-Za-z0-9]+/).map((token) => token.trim()).filter((token) => token.length > 0);
-  if (tokens.length === 0) {
-    throw new Error(`Cannot derive loader function name from target: ${value}`);
-  }
-  const pascal = tokens.map((token) => token.charAt(0).toUpperCase() + token.slice(1)).join("");
-  return /^[0-9]/.test(pascal) ? `Target${pascal}` : pascal;
-};
-const toRelativeImportSpecifier = (fromFile, toFile) => {
-  const rel = path.relative(path.dirname(fromFile), toFile).replace(/\\/g, "/");
-  return rel.startsWith(".") ? rel : `./${rel}`;
-};
-const buildGeneratedLoaderContent = (generatedLoaderFile, targets) => {
-  const targetBlocks = targets.map((target) => {
-    const specifier = JSON.stringify(
-      toRelativeImportSpecifier(generatedLoaderFile, target.outFile)
-    );
-    return `export const ${target.functionName} = async <T extends object>(
-  options?: TargetWasmLoadOptions
-): Promise<WasmInstance<T>> => {
-  const source = options?.url ?? new URL(${specifier}, import.meta.url);
-  return await loadWasm<T>(source, {
-    imports: options?.imports,
-  });
-};`;
-  }).join("\n\n");
-  return `// Generated by emsdk-env. DO NOT EDIT.
-
-export type WasmSource =
-  | string
-  | URL
-  | ArrayBuffer
-  | ArrayBufferView
-  | Response;
-
-export interface WasmLoadOptions {
-  readonly imports?: WebAssembly.Imports;
-}
-
-export interface TargetWasmLoadOptions extends WasmLoadOptions {
-  readonly url?: string | URL;
-}
-
-export interface WasmInstance<T extends object> {
-  readonly exports: T;
-  readonly memory: WebAssembly.Memory;
-  readonly table: WebAssembly.Table | undefined;
-  readonly rawExports: WebAssembly.Exports;
-  readonly module: WebAssembly.Module;
-  readonly instance: WebAssembly.Instance;
-  readonly initialize: (() => unknown) | undefined;
-  readonly start: (() => unknown) | undefined;
-}
-
-const resolveWasmBytes = async (source: WasmSource): Promise<ArrayBuffer> => {
-  if (typeof Response !== 'undefined' && source instanceof Response) {
-    return await source.arrayBuffer();
-  }
-  if (source instanceof URL || typeof source === 'string') {
-    const response = await fetch(source);
-    if (!response.ok) {
-      throw new Error(\`Failed to fetch wasm: \${response.url}\`);
-    }
-    return await response.arrayBuffer();
-  }
-  if (ArrayBuffer.isView(source)) {
-    const view = new Uint8Array(
-      source.buffer,
-      source.byteOffset,
-      source.byteLength
-    );
-    return view.slice().buffer;
-  }
-  return source;
-};
-
-const getImportValue = (
-  imports: WebAssembly.Imports | undefined,
-  moduleName: string,
-  name: string
-) => {
-  const moduleImports = imports?.[moduleName];
-  if (!moduleImports || typeof moduleImports !== 'object') {
-    return undefined;
-  }
-  return (moduleImports as Record<string, unknown>)[name];
-};
-
-const resolveMemory = (
-  module: WebAssembly.Module,
-  instance: WebAssembly.Instance,
-  imports: WebAssembly.Imports | undefined
-) => {
-  let memory: WebAssembly.Memory | undefined;
-  for (const entry of WebAssembly.Module.exports(module)) {
-    if (entry.kind !== 'memory') {
-      continue;
-    }
-    if (memory) {
-      throw new Error('Multiple wasm memories are not supported.');
-    }
-    const value = instance.exports[entry.name];
-    if (!(value instanceof WebAssembly.Memory)) {
-      throw new Error(\`Export is not a WebAssembly.Memory: \${entry.name}\`);
-    }
-    memory = value;
-  }
-  if (memory) {
-    return memory;
-  }
-  for (const entry of WebAssembly.Module.imports(module)) {
-    if (entry.kind !== 'memory') {
-      continue;
-    }
-    if (memory) {
-      throw new Error('Multiple wasm memories are not supported.');
-    }
-    const value = getImportValue(imports, entry.module, entry.name);
-    if (!(value instanceof WebAssembly.Memory)) {
-      throw new Error(
-        \`Imported value is not a WebAssembly.Memory: \${entry.module}.\${entry.name}\`
-      );
-    }
-    memory = value;
-  }
-  if (!memory) {
-    throw new Error('WASM memory export/import was not resolved.');
-  }
-  return memory;
-};
-
-const resolveTable = (
-  module: WebAssembly.Module,
-  instance: WebAssembly.Instance,
-  imports: WebAssembly.Imports | undefined
-) => {
-  let table: WebAssembly.Table | undefined;
-  for (const entry of WebAssembly.Module.exports(module)) {
-    if (entry.kind !== 'table') {
-      continue;
-    }
-    if (table) {
-      throw new Error('Multiple wasm tables are not supported.');
-    }
-    const value = instance.exports[entry.name];
-    if (!(value instanceof WebAssembly.Table)) {
-      throw new Error(\`Export is not a WebAssembly.Table: \${entry.name}\`);
-    }
-    table = value;
-  }
-  if (table) {
-    return table;
-  }
-  for (const entry of WebAssembly.Module.imports(module)) {
-    if (entry.kind !== 'table') {
-      continue;
-    }
-    if (table) {
-      throw new Error('Multiple wasm tables are not supported.');
-    }
-    const value = getImportValue(imports, entry.module, entry.name);
-    if (!(value instanceof WebAssembly.Table)) {
-      throw new Error(
-        \`Imported value is not a WebAssembly.Table: \${entry.module}.\${entry.name}\`
-      );
-    }
-    table = value;
-  }
-  return table;
-};
-
-export const loadWasm = async <T extends object>(
-  source: WasmSource,
-  options?: WasmLoadOptions
-): Promise<WasmInstance<T>> => {
-  const bytes = await resolveWasmBytes(source);
-  const module = await WebAssembly.compile(bytes);
-  const instance = await WebAssembly.instantiate(module, options?.imports ?? {});
-
-  const functionExports: Record<string, (...args: unknown[]) => unknown> = {};
-  for (const entry of WebAssembly.Module.exports(module)) {
-    if (entry.kind !== 'function') {
-      continue;
-    }
-    const value = instance.exports[entry.name];
-    if (typeof value !== 'function') {
-      throw new Error(\`Export is not a function: \${entry.name}\`);
-    }
-    functionExports[entry.name] = value as (...args: unknown[]) => unknown;
-  }
-
-  const initialize =
-    typeof instance.exports._initialize === 'function'
-      ? (instance.exports._initialize as () => unknown)
-      : undefined;
-  const start =
-    typeof instance.exports._start === 'function'
-      ? (instance.exports._start as () => unknown)
-      : undefined;
-
-  return {
-    exports: functionExports as T,
-    memory: resolveMemory(module, instance, options?.imports),
-    table: resolveTable(module, instance, options?.imports),
-    rawExports: instance.exports,
-    module,
-    instance,
-    initialize,
-    start,
-  };
-};
-
-${targetBlocks}
-`;
-};
-const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-const resolvePackageJsonPath = async (startPath, packageName) => {
-  let current = path.dirname(startPath);
-  for (; ; ) {
-    const candidate = path.join(current, "package.json");
-    if (await pathExists(candidate)) {
-      return candidate;
-    }
-    const parent = path.dirname(current);
-    if (parent === current) {
-      throw new Error(`package.json not found for import: ${packageName}`);
-    }
-    current = parent;
-  }
-};
-const loadPackageJson = async (packageJsonPath, packageName) => {
-  try {
-    const raw = await promises.readFile(packageJsonPath, "utf8");
-    const parsed = JSON.parse(raw);
-    if (!isRecord(parsed)) {
-      throw new Error("package.json must be an object.");
-    }
-    return parsed;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      `Failed to read package.json for import ${packageName}: ${message}`
-    );
-  }
-};
-const resolveImportPaths = async (resolver, packageName) => {
-  let resolvedEntry;
-  try {
-    resolvedEntry = resolver.resolve(packageName);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to resolve import ${packageName}: ${message}`);
-  }
-  const packageJsonPath = await resolvePackageJsonPath(
-    resolvedEntry,
-    packageName
-  );
-  const packageRoot = path.dirname(packageJsonPath);
-  const packageJson = await loadPackageJson(packageJsonPath, packageName);
-  const emsdkConfigRaw = packageJson["emsdk-env"];
-  if (emsdkConfigRaw !== void 0 && !isRecord(emsdkConfigRaw)) {
-    throw new Error(
-      `Invalid emsdk-env config for import ${packageName}: expected an object.`
-    );
-  }
-  const includeRaw = isRecord(emsdkConfigRaw) ? emsdkConfigRaw.include : void 0;
-  if (includeRaw !== void 0 && typeof includeRaw !== "string") {
-    throw new Error(
-      `Invalid emsdk-env include for import ${packageName}: expected a string.`
-    );
-  }
-  const libRaw = isRecord(emsdkConfigRaw) ? emsdkConfigRaw.lib : void 0;
-  if (libRaw !== void 0 && typeof libRaw !== "string") {
-    throw new Error(
-      `Invalid emsdk-env lib for import ${packageName}: expected a string.`
-    );
-  }
-  const includeRel = includeRaw != null ? includeRaw : DEFAULT_IMPORT_INCLUDE_DIR;
-  const libRel = libRaw != null ? libRaw : DEFAULT_IMPORT_LIB_DIR;
-  const includeDir = path.resolve(packageRoot, includeRel);
-  const libDir = path.resolve(packageRoot, libRel);
-  const includeExists = await pathExists(includeDir);
-  const libExists = await pathExists(libDir);
-  if (!includeExists && !libExists) {
-    throw new Error(
-      `Import ${packageName} does not provide include or lib directories.`
-    );
-  }
-  return {
-    includeDir: includeExists ? includeDir : void 0,
-    libDir: libExists ? libDir : void 0
-  };
-};
-const resolveImportDirectories = async (rootDir, imports) => {
-  if (imports.length === 0) {
-    return { includeDirs: [], libDirs: [] };
-  }
-  const moduleApi = await import("node:module");
-  const resolver = moduleApi.createRequire(path.resolve(rootDir, "package.json"));
-  const includeDirs = [];
-  const libDirs = [];
-  for (const packageName of imports) {
-    const resolved = await resolveImportPaths(resolver, packageName);
-    if (resolved.includeDir) {
-      includeDirs.push(resolved.includeDir);
-    }
-    if (resolved.libDir) {
-      libDirs.push(resolved.libDir);
-    }
-  }
-  return {
-    includeDirs: dedupeValues(includeDirs),
-    libDirs: dedupeValues(libDirs)
-  };
-};
-const resolveGeneratedLoaderOutFile = (rootDir, env, generatedLoader) => {
-  var _a;
-  if (!(generatedLoader == null ? void 0 : generatedLoader.enable)) {
-    return void 0;
-  }
-  const rawOutFile = expandPlaceholders(
-    (_a = generatedLoader.outFile) != null ? _a : DEFAULT_GENERATED_LOADER_OUT_FILE,
-    env,
-    "generatedLoader.outFile"
-  );
-  return resolvePath(rootDir, rawOutFile);
-};
-const resolveGeneratedLoaderWatchDirs = (rootDir, srcDir, commonIncludeDirs, env, targetEntries, importIncludeDirs) => {
-  const dirs = [srcDir, ...resolveIncludeDirs(commonIncludeDirs, env, rootDir)];
-  for (const [targetName, target] of targetEntries) {
-    if (!target.includeDirs || target.includeDirs.length === 0) {
-      continue;
-    }
-    const targetEnv = {
-      ...env,
-      TARGET_NAME: targetName
-    };
-    dirs.push(...resolveIncludeDirs(target.includeDirs, targetEnv, rootDir));
-  }
-  dirs.push(...importIncludeDirs);
-  return dedupeValues(dirs);
-};
-const validateGeneratedLoaderOutFile = (generatedLoaderFile, watchDirs) => {
-  for (const dir of watchDirs) {
-    if (isSubPath(dir, generatedLoaderFile)) {
-      throw new Error(
-        `generatedLoader.outFile must not be placed under watched directory: ${generatedLoaderFile}`
-      );
-    }
-  }
-};
-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, _j;
-  if (!options) {
-    throw new TypeError("options must be provided.");
-  }
-  if (!options.rule || !options.rule.targets) {
-    throw new TypeError("rule targets must be provided.");
-  }
-  const targetEntries = Object.entries(options.rule.targets);
-  if (targetEntries.length === 0) {
-    throw new TypeError("rule targets must not be empty.");
-  }
-  const logger = (_a = options.logger) != null ? _a : createConsoleLogger("emsdk-env");
-  const rootDir = path.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 rawIncludeDir = expandPlaceholders(
-    (_d = options.includeDir) != null ? _d : DEFAULT_WASM_INCLUDE_DIR,
-    baseEnv,
-    "includeDir"
-  );
-  const rawOutDir = expandPlaceholders(
-    (_e = options.outDir) != null ? _e : DEFAULT_WASM_OUT_DIR,
-    baseEnv,
-    "outDir"
-  );
-  const rawLibDir = expandPlaceholders(
-    (_f = options.libDir) != null ? _f : DEFAULT_WASM_LIB_DIR,
-    baseEnv,
-    "libDir"
-  );
-  const rawBuildDir = expandPlaceholders(
-    (_g = options.buildDir) != null ? _g : DEFAULT_WASM_BUILD_DIR,
-    baseEnv,
-    "buildDir"
-  );
-  const srcDir = resolvePath(rootDir, rawSrcDir);
-  const includeDir = resolvePath(rootDir, rawIncludeDir);
-  const outDir = resolvePath(rootDir, rawOutDir);
-  const libDir = resolvePath(rootDir, rawLibDir);
-  const buildDir = resolvePath(rootDir, rawBuildDir);
-  const buildId = createBuildId();
-  const buildRunDir = path.resolve(buildDir, buildId);
-  const cleanupBuildDir = (_h = options.cleanupBuildDir) != null ? _h : true;
-  const parallel = (_i = options.parallel) != null ? _i : true;
-  const envWithDirs = {
-    ...emsdkEnv,
-    ROOT: rootDir,
-    SRC_DIR: srcDir,
-    INCLUDE_DIR: includeDir,
-    OUT_DIR: outDir,
-    LIB_DIR: libDir,
-    BUILD_DIR: buildDir
-  };
-  const emccCommand = await resolveEmccCommand(envWithDirs, emsdkRoot);
-  const common = (_j = options.rule.common) != null ? _j : {};
-  const commonIncludeDirs = common.includeDirs === void 0 ? [includeDir] : common.includeDirs;
-  const importDirectories = await resolveImportDirectories(
-    rootDir,
-    ensureArray(options.imports)
-  );
-  const importIncludeDirs = importDirectories.includeDirs;
-  const importLibDirs = importDirectories.libDirs;
-  const linkLibDirs = dedupeValues([libDir, ...importLibDirs]);
-  const generatedLoaderFile = resolveGeneratedLoaderOutFile(
-    rootDir,
-    envWithDirs,
-    options.generatedLoader
-  );
-  if (generatedLoaderFile) {
-    const watchDirs = resolveGeneratedLoaderWatchDirs(
-      rootDir,
-      srcDir,
-      commonIncludeDirs,
-      envWithDirs,
-      targetEntries,
-      importIncludeDirs
-    );
-    validateGeneratedLoaderOutFile(generatedLoaderFile, watchDirs);
-  }
-  logger.debug(`Detected rootDir: '${rootDir}'`);
-  logger.debug(`Detected srcDir: '${srcDir}'`);
-  logger.debug(`Detected outDir: '${outDir}'`);
-  logger.debug(`Detected libDir: '${libDir}'`);
-  logger.debug(`Detected buildDir: '${buildDir}'`);
-  logger.debug(`Detected buildId: '${buildId}'`);
-  logger.debug(`Detected buildRunDir: '${buildRunDir}'`);
-  logger.debug(`Detected cleanupBuildDir: ${cleanupBuildDir}`);
-  logger.debug(`Detected parallel: ${parallel}`);
-  logger.debug(`Detected emccCommand: '${emccCommand}'`);
-  logger.debug(
-    `Detected importIncludeDirs: [${importIncludeDirs.map((p) => `'${p}'`).join(",")}]`
-  );
-  logger.debug(
-    `Detected importLibDirs: [${importLibDirs.map((p) => `'${p}'`).join(",")}]`
-  );
-  if (generatedLoaderFile) {
-    logger.debug(`Detected generatedLoaderFile: '${generatedLoaderFile}'`);
-  }
-  await ensureDirectory(outDir);
-  await ensureDirectory(libDir);
-  await ensureDirectory(buildDir);
-  await promises.rm(buildRunDir, { recursive: true, force: true });
-  await ensureDirectory(buildRunDir);
-  const hasArchiveTargets = targetEntries.some(
-    ([, target]) => resolveTargetType(target.type) === "archive"
-  );
-  const emarCommand = hasArchiveTargets ? await resolveEmarCommand(envWithDirs, emsdkRoot) : void 0;
-  if (emarCommand) {
-    logger.debug(`Detected emarCommand: '${emarCommand}'`);
-  }
-  let wasmOptCommand;
-  const getWasmOptCommand = async () => {
-    if (wasmOptCommand) {
-      return wasmOptCommand;
-    }
-    wasmOptCommand = await resolveWasmOptCommand(envWithDirs, emsdkRoot);
-    logger.debug(`Detected wasmOptCommand: '${wasmOptCommand}'`);
-    return wasmOptCommand;
-  };
-  const outFiles = {};
-  let resultGeneratedLoaderFile;
-  const buildTargets = async (expectedType) => {
-    var _a2;
-    for (const [targetName, target] of targetEntries) {
-      const targetType = resolveTargetType(target.type);
-      if (targetType !== expectedType) {
-        continue;
-      }
-      if (targetType === "archive") {
-        if (target.linkOptions !== void 0) {
-          throw new Error(
-            `linkOptions is not supported for archive target: ${targetName}`
-          );
-        }
-        if (target.linkDirectives !== void 0) {
-          throw new Error(
-            `linkDirectives is not supported for archive target: ${targetName}`
-          );
-        }
-        if (target.exports !== void 0) {
-          throw new Error(
-            `exports is not supported for archive target: ${targetName}`
-          );
-        }
-        if (target.wasmOpt !== void 0) {
-          throw new Error(
-            `wasmOpt is not supported for archive target: ${targetName}`
-          );
-        }
-      }
-      const mergedLinkOptions = targetType === "archive" ? [] : [
-        ...ensureArray(common.linkOptions),
-        ...ensureArray(target.linkOptions)
-      ];
-      const mergedLinkDirectives = targetType === "archive" ? {} : mergeLinkDirectives(common.linkDirectives, target.linkDirectives);
-      const mergedExports = targetType === "archive" ? [] : [...ensureArray(common.exports), ...ensureArray(target.exports)];
-      const wasmOptEnabled = targetType === "archive" ? false : resolveWasmOptEnabled(common.wasmOpt, target.wasmOpt);
-      const baseCompileOptions = [
-        ...ensureArray(common.options),
-        ...ensureArray(target.options)
-      ];
-      const baseIncludeDirs = [
-        ...ensureArray(commonIncludeDirs),
-        ...ensureArray(target.includeDirs),
-        ...importIncludeDirs
-      ];
-      const baseDefines = mergeDefines(common.defines, target.defines);
-      const sourceGroups = (_a2 = target.sourceGroups) != null ? _a2 : [];
-      const targetEnv = {
-        ...envWithDirs,
-        TARGET_NAME: targetName
-      };
-      const buildEnv = createEnvForBuild(targetEnv, {});
-      const resolvedOutFile = resolveTargetOutFile(
-        targetName,
-        target.outFile,
-        targetEnv,
-        targetType === "archive" ? libDir : outDir,
-        targetType === "archive" ? "a" : "wasm"
-      );
-      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 = path.resolve(buildRunDir, targetName);
-      await promises.rm(targetBuildDir, { recursive: true, force: true });
-      await ensureDirectory(targetBuildDir);
-      const resolvedLinkDirectives = targetType === "archive" ? {} : resolveLinkDirectives(mergedLinkDirectives, targetEnv);
-      const linkDirectiveArgs = buildLinkDirectiveFlags(resolvedLinkDirectives);
-      const resolvedLinkOptions = targetType === "archive" ? [] : [
-        ...linkDirectiveArgs,
-        ...expandArray(mergedLinkOptions, targetEnv, "linkOptions")
-      ];
-      const resolvedExports = targetType === "archive" ? [] : expandArray(mergedExports, targetEnv, "exports");
-      const exportArgs = buildExportFlags(resolvedExports);
-      const resolvedWasmOptArgs = wasmOptEnabled ? resolveWasmOptArgs(common.wasmOpt, target.wasmOpt, targetEnv) : [];
-      const baseCompileArgs = buildCompileArgs(
-        baseCompileOptions,
-        baseIncludeDirs,
-        baseDefines,
-        targetEnv,
-        rootDir
-      );
-      const groupCompileArgs = sourceGroups.map((group) => {
-        const groupOptions = [
-          ...baseCompileOptions,
-          ...ensureArray(group == null ? void 0 : group.options)
-        ];
-        const groupIncludeDirs = [
-          ...baseIncludeDirs,
-          ...ensureArray(group == null ? void 0 : group.includeDirs)
-        ];
-        const groupDefines = mergeDefines(baseDefines, group == null ? void 0 : group.defines);
-        return buildCompileArgs(
-          groupOptions,
-          groupIncludeDirs,
-          groupDefines,
-          targetEnv,
-          rootDir
-        );
-      });
-      const compileSource = async (source, args, groupIndex) => {
-        const objectName = toSafeObjectName(rootDir, source, groupIndex);
-        const outputObject = path.resolve(targetBuildDir, `${objectName}.o`);
-        const compileArgs = [
-          "-c",
-          source,
-          "-o",
-          outputObject,
-          ...args.resolvedOptions,
-          ...args.includeArgs,
-          ...args.defineArgs
-        ];
-        const sourcePath = path.relative(rootDir, source);
-        logger.info(`Compiling source: ${sourcePath} --> $tmp/${objectName}.o`);
-        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 });
-        }
-      }
-      logger.info(
-        parallel ? `Building target: '${targetName}' [${compileJobs.length} files, in parallel]` : `Building target: '${targetName}' [${compileJobs.length} files]`
-      );
-      const objectFiles = parallel ? await Promise.all(
-        compileJobs.map(
-          (job) => compileSource(job.source, job.args, job.groupIndex)
-        )
-      ) : await buildObjectsSequential();
-      if (targetType === "archive") {
-        if (!emarCommand) {
-          throw new Error("emar command is required for archive targets.");
-        }
-        logger.info(`Archiving target: ${targetName}.a`);
-        const archiveArgs = ["rcs", resolvedOutFile, ...objectFiles];
-        logger.debug(`emar ${archiveArgs.join(" ")}`);
-        await runCommandWithEnv(
-          emarCommand,
-          archiveArgs,
-          rootDir,
-          buildEnv,
-          emsdkOptions.signal
-        );
-      } else {
-        logger.info(`Linking target: ${targetName}.wasm`);
-        const linkArgs = [
-          ...objectFiles,
-          "-o",
-          resolvedOutFile,
-          ...linkLibDirs.map((dir) => `-L${dir}`),
-          ...resolvedLinkOptions,
-          ...exportArgs
-        ];
-        logger.debug(`emcc ${linkArgs.join(" ")}`);
-        await runCommandWithEnv(
-          emccCommand,
-          linkArgs,
-          rootDir,
-          buildEnv,
-          emsdkOptions.signal
-        );
-        if (wasmOptEnabled) {
-          const wasmOptInput = resolveWasmOptInputFile(
-            resolvedOutFile,
-            resolvedLinkOptions
-          );
-          if (!await pathExists(wasmOptInput)) {
-            throw new Error(
-              `wasm-opt enabled but wasm binary not found: ${wasmOptInput}`
-            );
-          }
-          const tempOutFile = `${wasmOptInput}.opt`;
-          const wasmOptArgs = [
-            wasmOptInput,
-            "-o",
-            tempOutFile,
-            ...resolvedWasmOptArgs
-          ];
-          const wasmOptCommand2 = await getWasmOptCommand();
-          logger.info(`Optimizing target: ${targetName}.wasm`);
-          logger.debug(`wasm-opt ${wasmOptArgs.join(" ")}`);
-          await runCommandWithEnv(
-            wasmOptCommand2,
-            wasmOptArgs,
-            rootDir,
-            buildEnv,
-            emsdkOptions.signal
-          );
-          await promises.rm(wasmOptInput, { force: true });
-          await promises.rename(tempOutFile, wasmOptInput);
-        }
-      }
-      outFiles[targetName] = resolvedOutFile;
-    }
-  };
-  try {
-    await buildTargets("archive");
-    await buildTargets("wasm");
-    if (generatedLoaderFile) {
-      const generatedTargets = [];
-      const functionNames = /* @__PURE__ */ new Set();
-      for (const [targetName, target] of targetEntries) {
-        if (resolveTargetType(target.type) !== "wasm") {
-          continue;
-        }
-        const outFile = outFiles[targetName];
-        if (!outFile) {
-          continue;
-        }
-        const functionName = `load${toPascalCaseIdentifier(targetName)}Wasm`;
-        if (functionNames.has(functionName)) {
-          throw new Error(
-            `Generated loader function name collision: ${functionName}`
-          );
-        }
-        functionNames.add(functionName);
-        generatedTargets.push({
-          targetName,
-          functionName,
-          outFile
-        });
-      }
-      const content = buildGeneratedLoaderContent(
-        generatedLoaderFile,
-        generatedTargets
-      );
-      const didWrite = await writeTextIfChanged(generatedLoaderFile, content);
-      logger.info(
-        didWrite ? `Generated loader: ${path.relative(rootDir, generatedLoaderFile)}` : `Generated loader unchanged: ${path.relative(rootDir, generatedLoaderFile)}`
-      );
-      resultGeneratedLoaderFile = generatedLoaderFile;
-    }
-  } finally {
-    if (cleanupBuildDir) {
-      await promises.rm(buildRunDir, { recursive: true, force: true });
-    }
-  }
-  return {
-    emsdkRoot,
-    outFiles,
-    ...resultGeneratedLoaderFile ? { generatedLoaderFile: resultGeneratedLoaderFile } : {}
-  };
-};
-exports.buildWasm = buildWasm;
-exports.createConsoleLogger = createConsoleLogger;
-exports.prepareEmsdk = prepareEmsdk;
-//# sourceMappingURL=build-CgmcFNSR.cjs.map