@zntc/core 0.1.0

package/dist/index.js

@@ -0,0 +1,3637 @@
+import { createRequire } from "node:module";
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// ../../node_modules/.bun/detect-libc@2.1.2/node_modules/detect-libc/lib/process.js
+var require_process = __commonJS((exports, module) => {
+  var isLinux = () => process.platform === "linux";
+  var report = null;
+  var getReport = () => {
+    if (!report) {
+      if (isLinux() && process.report) {
+        const orig = process.report.excludeNetwork;
+        process.report.excludeNetwork = true;
+        report = process.report.getReport();
+        process.report.excludeNetwork = orig;
+      } else {
+        report = {};
+      }
+    }
+    return report;
+  };
+  module.exports = { isLinux, getReport };
+});
+
+// ../../node_modules/.bun/detect-libc@2.1.2/node_modules/detect-libc/lib/filesystem.js
+var require_filesystem = __commonJS((exports, module) => {
+  var fs = __require("fs");
+  var LDD_PATH = "/usr/bin/ldd";
+  var SELF_PATH = "/proc/self/exe";
+  var MAX_LENGTH = 2048;
+  var readFileSync4 = (path) => {
+    const fd = fs.openSync(path, "r");
+    const buffer = Buffer.alloc(MAX_LENGTH);
+    const bytesRead = fs.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+    fs.close(fd, () => {});
+    return buffer.subarray(0, bytesRead);
+  };
+  var readFile = (path) => new Promise((resolve2, reject) => {
+    fs.open(path, "r", (err, fd) => {
+      if (err) {
+        reject(err);
+      } else {
+        const buffer = Buffer.alloc(MAX_LENGTH);
+        fs.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+          resolve2(buffer.subarray(0, bytesRead));
+          fs.close(fd, () => {});
+        });
+      }
+    });
+  });
+  module.exports = {
+    LDD_PATH,
+    SELF_PATH,
+    readFileSync: readFileSync4,
+    readFile
+  };
+});
+
+// ../../node_modules/.bun/detect-libc@2.1.2/node_modules/detect-libc/lib/elf.js
+var require_elf = __commonJS((exports, module) => {
+  var interpreterPath = (elf) => {
+    if (elf.length < 64) {
+      return null;
+    }
+    if (elf.readUInt32BE(0) !== 2135247942) {
+      return null;
+    }
+    if (elf.readUInt8(4) !== 2) {
+      return null;
+    }
+    if (elf.readUInt8(5) !== 1) {
+      return null;
+    }
+    const offset = elf.readUInt32LE(32);
+    const size = elf.readUInt16LE(54);
+    const count = elf.readUInt16LE(56);
+    for (let i = 0;i < count; i++) {
+      const headerOffset = offset + i * size;
+      const type = elf.readUInt32LE(headerOffset);
+      if (type === 3) {
+        const fileOffset = elf.readUInt32LE(headerOffset + 8);
+        const fileSize = elf.readUInt32LE(headerOffset + 32);
+        return elf.subarray(fileOffset, fileOffset + fileSize).toString().replace(/\0.*$/g, "");
+      }
+    }
+    return null;
+  };
+  module.exports = {
+    interpreterPath
+  };
+});
+
+// ../../node_modules/.bun/detect-libc@2.1.2/node_modules/detect-libc/lib/detect-libc.js
+var require_detect_libc = __commonJS((exports, module) => {
+  var childProcess = __require("child_process");
+  var { isLinux, getReport } = require_process();
+  var { LDD_PATH, SELF_PATH, readFile, readFileSync: readFileSync4 } = require_filesystem();
+  var { interpreterPath } = require_elf();
+  var cachedFamilyInterpreter;
+  var cachedFamilyFilesystem;
+  var cachedVersionFilesystem;
+  var command = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
+  var commandOut = "";
+  var safeCommand = () => {
+    if (!commandOut) {
+      return new Promise((resolve2) => {
+        childProcess.exec(command, (err, out) => {
+          commandOut = err ? " " : out;
+          resolve2(commandOut);
+        });
+      });
+    }
+    return commandOut;
+  };
+  var safeCommandSync = () => {
+    if (!commandOut) {
+      try {
+        commandOut = childProcess.execSync(command, { encoding: "utf8" });
+      } catch (_err) {
+        commandOut = " ";
+      }
+    }
+    return commandOut;
+  };
+  var GLIBC = "glibc";
+  var RE_GLIBC_VERSION = /LIBC[a-z0-9 \-).]*?(\d+\.\d+)/i;
+  var MUSL = "musl";
+  var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+  var familyFromReport = () => {
+    const report = getReport();
+    if (report.header && report.header.glibcVersionRuntime) {
+      return GLIBC;
+    }
+    if (Array.isArray(report.sharedObjects)) {
+      if (report.sharedObjects.some(isFileMusl)) {
+        return MUSL;
+      }
+    }
+    return null;
+  };
+  var familyFromCommand = (out) => {
+    const [getconf, ldd1] = out.split(/[\r\n]+/);
+    if (getconf && getconf.includes(GLIBC)) {
+      return GLIBC;
+    }
+    if (ldd1 && ldd1.includes(MUSL)) {
+      return MUSL;
+    }
+    return null;
+  };
+  var familyFromInterpreterPath = (path) => {
+    if (path) {
+      if (path.includes("/ld-musl-")) {
+        return MUSL;
+      } else if (path.includes("/ld-linux-")) {
+        return GLIBC;
+      }
+    }
+    return null;
+  };
+  var getFamilyFromLddContent = (content) => {
+    content = content.toString();
+    if (content.includes("musl")) {
+      return MUSL;
+    }
+    if (content.includes("GNU C Library")) {
+      return GLIBC;
+    }
+    return null;
+  };
+  var familyFromFilesystem = async () => {
+    if (cachedFamilyFilesystem !== undefined) {
+      return cachedFamilyFilesystem;
+    }
+    cachedFamilyFilesystem = null;
+    try {
+      const lddContent = await readFile(LDD_PATH);
+      cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+    } catch (e) {}
+    return cachedFamilyFilesystem;
+  };
+  var familyFromFilesystemSync = () => {
+    if (cachedFamilyFilesystem !== undefined) {
+      return cachedFamilyFilesystem;
+    }
+    cachedFamilyFilesystem = null;
+    try {
+      const lddContent = readFileSync4(LDD_PATH);
+      cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+    } catch (e) {}
+    return cachedFamilyFilesystem;
+  };
+  var familyFromInterpreter = async () => {
+    if (cachedFamilyInterpreter !== undefined) {
+      return cachedFamilyInterpreter;
+    }
+    cachedFamilyInterpreter = null;
+    try {
+      const selfContent = await readFile(SELF_PATH);
+      const path = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path);
+    } catch (e) {}
+    return cachedFamilyInterpreter;
+  };
+  var familyFromInterpreterSync = () => {
+    if (cachedFamilyInterpreter !== undefined) {
+      return cachedFamilyInterpreter;
+    }
+    cachedFamilyInterpreter = null;
+    try {
+      const selfContent = readFileSync4(SELF_PATH);
+      const path = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path);
+    } catch (e) {}
+    return cachedFamilyInterpreter;
+  };
+  var family = async () => {
+    let family2 = null;
+    if (isLinux()) {
+      family2 = await familyFromInterpreter();
+      if (!family2) {
+        family2 = await familyFromFilesystem();
+        if (!family2) {
+          family2 = familyFromReport();
+        }
+        if (!family2) {
+          const out = await safeCommand();
+          family2 = familyFromCommand(out);
+        }
+      }
+    }
+    return family2;
+  };
+  var familySync = () => {
+    let family2 = null;
+    if (isLinux()) {
+      family2 = familyFromInterpreterSync();
+      if (!family2) {
+        family2 = familyFromFilesystemSync();
+        if (!family2) {
+          family2 = familyFromReport();
+        }
+        if (!family2) {
+          const out = safeCommandSync();
+          family2 = familyFromCommand(out);
+        }
+      }
+    }
+    return family2;
+  };
+  var isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;
+  var isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;
+  var versionFromFilesystem = async () => {
+    if (cachedVersionFilesystem !== undefined) {
+      return cachedVersionFilesystem;
+    }
+    cachedVersionFilesystem = null;
+    try {
+      const lddContent = await readFile(LDD_PATH);
+      const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+      if (versionMatch) {
+        cachedVersionFilesystem = versionMatch[1];
+      }
+    } catch (e) {}
+    return cachedVersionFilesystem;
+  };
+  var versionFromFilesystemSync = () => {
+    if (cachedVersionFilesystem !== undefined) {
+      return cachedVersionFilesystem;
+    }
+    cachedVersionFilesystem = null;
+    try {
+      const lddContent = readFileSync4(LDD_PATH);
+      const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+      if (versionMatch) {
+        cachedVersionFilesystem = versionMatch[1];
+      }
+    } catch (e) {}
+    return cachedVersionFilesystem;
+  };
+  var versionFromReport = () => {
+    const report = getReport();
+    if (report.header && report.header.glibcVersionRuntime) {
+      return report.header.glibcVersionRuntime;
+    }
+    return null;
+  };
+  var versionSuffix = (s) => s.trim().split(/\s+/)[1];
+  var versionFromCommand = (out) => {
+    const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
+    if (getconf && getconf.includes(GLIBC)) {
+      return versionSuffix(getconf);
+    }
+    if (ldd1 && ldd2 && ldd1.includes(MUSL)) {
+      return versionSuffix(ldd2);
+    }
+    return null;
+  };
+  var version = async () => {
+    let version2 = null;
+    if (isLinux()) {
+      version2 = await versionFromFilesystem();
+      if (!version2) {
+        version2 = versionFromReport();
+      }
+      if (!version2) {
+        const out = await safeCommand();
+        version2 = versionFromCommand(out);
+      }
+    }
+    return version2;
+  };
+  var versionSync = () => {
+    let version2 = null;
+    if (isLinux()) {
+      version2 = versionFromFilesystemSync();
+      if (!version2) {
+        version2 = versionFromReport();
+      }
+      if (!version2) {
+        const out = safeCommandSync();
+        version2 = versionFromCommand(out);
+      }
+    }
+    return version2;
+  };
+  module.exports = {
+    GLIBC,
+    MUSL,
+    family,
+    familySync,
+    isNonGlibcLinux,
+    isNonGlibcLinuxSync,
+    version,
+    versionSync
+  };
+});
+
+// ../../node_modules/.bun/lightningcss@1.32.0/node_modules/lightningcss/node/browserslistToTargets.js
+var require_browserslistToTargets = __commonJS((exports, module) => {
+  var BROWSER_MAPPING = {
+    and_chr: "chrome",
+    and_ff: "firefox",
+    ie_mob: "ie",
+    op_mob: "opera",
+    and_qq: null,
+    and_uc: null,
+    baidu: null,
+    bb: null,
+    kaios: null,
+    op_mini: null
+  };
+  function browserslistToTargets(browserslist) {
+    let targets = {};
+    for (let browser of browserslist) {
+      let [name, v] = browser.split(" ");
+      if (BROWSER_MAPPING[name] === null) {
+        continue;
+      }
+      let version = parseVersion(v);
+      if (version == null) {
+        continue;
+      }
+      if (targets[name] == null || version < targets[name]) {
+        targets[name] = version;
+      }
+    }
+    return targets;
+  }
+  function parseVersion(version) {
+    let [major, minor = 0, patch = 0] = version.split("-")[0].split(".").map((v) => parseInt(v, 10));
+    if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
+      return null;
+    }
+    return major << 16 | minor << 8 | patch;
+  }
+  module.exports = browserslistToTargets;
+});
+
+// ../../node_modules/.bun/lightningcss@1.32.0/node_modules/lightningcss/node/composeVisitors.js
+var require_composeVisitors = __commonJS((exports, module) => {
+  function composeVisitors(visitors) {
+    if (visitors.length === 1) {
+      return visitors[0];
+    }
+    if (visitors.some((v) => typeof v === "function")) {
+      return (opts) => {
+        let v = visitors.map((v2) => typeof v2 === "function" ? v2(opts) : v2);
+        return composeVisitors(v);
+      };
+    }
+    let res = {};
+    composeSimpleVisitors(res, visitors, "StyleSheet");
+    composeSimpleVisitors(res, visitors, "StyleSheetExit");
+    composeObjectVisitors(res, visitors, "Rule", ruleVisitor, wrapCustomAndUnknownAtRule);
+    composeObjectVisitors(res, visitors, "RuleExit", ruleVisitor, wrapCustomAndUnknownAtRule);
+    composeObjectVisitors(res, visitors, "Declaration", declarationVisitor, wrapCustomProperty);
+    composeObjectVisitors(res, visitors, "DeclarationExit", declarationVisitor, wrapCustomProperty);
+    composeSimpleVisitors(res, visitors, "Url");
+    composeSimpleVisitors(res, visitors, "Color");
+    composeSimpleVisitors(res, visitors, "Image");
+    composeSimpleVisitors(res, visitors, "ImageExit");
+    composeSimpleVisitors(res, visitors, "Length");
+    composeSimpleVisitors(res, visitors, "Angle");
+    composeSimpleVisitors(res, visitors, "Ratio");
+    composeSimpleVisitors(res, visitors, "Resolution");
+    composeSimpleVisitors(res, visitors, "Time");
+    composeSimpleVisitors(res, visitors, "CustomIdent");
+    composeSimpleVisitors(res, visitors, "DashedIdent");
+    composeArrayFunctions(res, visitors, "MediaQuery");
+    composeArrayFunctions(res, visitors, "MediaQueryExit");
+    composeSimpleVisitors(res, visitors, "SupportsCondition");
+    composeSimpleVisitors(res, visitors, "SupportsConditionExit");
+    composeArrayFunctions(res, visitors, "Selector");
+    composeTokenVisitors(res, visitors, "Token", "token", false);
+    composeTokenVisitors(res, visitors, "Function", "function", false);
+    composeTokenVisitors(res, visitors, "FunctionExit", "function", true);
+    composeTokenVisitors(res, visitors, "Variable", "var", false);
+    composeTokenVisitors(res, visitors, "VariableExit", "var", true);
+    composeTokenVisitors(res, visitors, "EnvironmentVariable", "env", false);
+    composeTokenVisitors(res, visitors, "EnvironmentVariableExit", "env", true);
+    return res;
+  }
+  module.exports = composeVisitors;
+  function wrapCustomAndUnknownAtRule(k, f) {
+    if (k === "unknown") {
+      return (value) => f({ type: "unknown", value });
+    }
+    if (k === "custom") {
+      return (value) => f({ type: "custom", value });
+    }
+    return f;
+  }
+  function wrapCustomProperty(k, f) {
+    return k === "custom" ? (value) => f({ property: "custom", value }) : f;
+  }
+  function ruleVisitor(f, item) {
+    if (typeof f === "object") {
+      if (item.type === "unknown") {
+        let v = f.unknown;
+        if (typeof v === "object") {
+          v = v[item.value.name];
+        }
+        return v?.(item.value);
+      }
+      if (item.type === "custom") {
+        let v = f.custom;
+        if (typeof v === "object") {
+          v = v[item.value.name];
+        }
+        return v?.(item.value);
+      }
+      return f[item.type]?.(item);
+    }
+    return f?.(item);
+  }
+  function declarationVisitor(f, item) {
+    if (typeof f === "object") {
+      let name = item.property;
+      if (item.property === "unparsed") {
+        name = item.value.propertyId.property;
+      } else if (item.property === "custom") {
+        let v = f.custom;
+        if (typeof v === "object") {
+          v = v[item.value.name];
+        }
+        return v?.(item.value);
+      }
+      return f[name]?.(item);
+    }
+    return f?.(item);
+  }
+  function extractObjectsOrFunctions(visitors, key) {
+    let values = [];
+    let hasFunction = false;
+    let allKeys = new Set;
+    for (let visitor of visitors) {
+      let v = visitor[key];
+      if (v) {
+        if (typeof v === "function") {
+          hasFunction = true;
+        } else {
+          for (let key2 in v) {
+            allKeys.add(key2);
+          }
+        }
+        values.push(v);
+      }
+    }
+    return [values, hasFunction, allKeys];
+  }
+  function composeObjectVisitors(res, visitors, key, apply, wrapKey) {
+    let [values, hasFunction, allKeys] = extractObjectsOrFunctions(visitors, key);
+    if (values.length === 0) {
+      return;
+    }
+    if (values.length === 1) {
+      res[key] = values[0];
+      return;
+    }
+    let f = createArrayVisitor(visitors, (visitor, item) => apply(visitor[key], item));
+    if (hasFunction) {
+      res[key] = f;
+    } else {
+      let v = {};
+      for (let k of allKeys) {
+        v[k] = wrapKey(k, f);
+      }
+      res[key] = v;
+    }
+  }
+  function composeTokenVisitors(res, visitors, key, type, isExit) {
+    let [values, hasFunction, allKeys] = extractObjectsOrFunctions(visitors, key);
+    if (values.length === 0) {
+      return;
+    }
+    if (values.length === 1) {
+      res[key] = values[0];
+      return;
+    }
+    let f = createTokenVisitor(visitors, type, isExit);
+    if (hasFunction) {
+      res[key] = f;
+    } else {
+      let v = {};
+      for (let key2 of allKeys) {
+        v[key2] = f;
+      }
+      res[key] = v;
+    }
+  }
+  function createTokenVisitor(visitors, type, isExit) {
+    let v = createArrayVisitor(visitors, (visitor, item) => {
+      let f;
+      switch (item.type) {
+        case "token":
+          f = visitor.Token;
+          if (typeof f === "object") {
+            f = f[item.value.type];
+          }
+          break;
+        case "function":
+          f = isExit ? visitor.FunctionExit : visitor.Function;
+          if (typeof f === "object") {
+            f = f[item.value.name];
+          }
+          break;
+        case "var":
+          f = isExit ? visitor.VariableExit : visitor.Variable;
+          break;
+        case "env":
+          f = isExit ? visitor.EnvironmentVariableExit : visitor.EnvironmentVariable;
+          if (typeof f === "object") {
+            let name;
+            switch (item.value.name.type) {
+              case "ua":
+              case "unknown":
+                name = item.value.name.value;
+                break;
+              case "custom":
+                name = item.value.name.ident;
+                break;
+            }
+            f = f[name];
+          }
+          break;
+        case "color":
+          f = visitor.Color;
+          break;
+        case "url":
+          f = visitor.Url;
+          break;
+        case "length":
+          f = visitor.Length;
+          break;
+        case "angle":
+          f = visitor.Angle;
+          break;
+        case "time":
+          f = visitor.Time;
+          break;
+        case "resolution":
+          f = visitor.Resolution;
+          break;
+        case "dashed-ident":
+          f = visitor.DashedIdent;
+          break;
+      }
+      if (!f) {
+        return;
+      }
+      let res = f(item.value);
+      switch (item.type) {
+        case "color":
+        case "url":
+        case "length":
+        case "angle":
+        case "time":
+        case "resolution":
+        case "dashed-ident":
+          if (Array.isArray(res)) {
+            res = res.map((value) => ({ type: item.type, value }));
+          } else if (res) {
+            res = { type: item.type, value: res };
+          }
+          break;
+      }
+      return res;
+    });
+    return (value) => v({ type, value });
+  }
+  function extractFunctions(visitors, key) {
+    let functions = [];
+    for (let visitor of visitors) {
+      let f = visitor[key];
+      if (f) {
+        functions.push(f);
+      }
+    }
+    return functions;
+  }
+  function composeSimpleVisitors(res, visitors, key) {
+    let functions = extractFunctions(visitors, key);
+    if (functions.length === 0) {
+      return;
+    }
+    if (functions.length === 1) {
+      res[key] = functions[0];
+      return;
+    }
+    res[key] = (arg) => {
+      let mutated = false;
+      for (let f of functions) {
+        let res2 = f(arg);
+        if (res2) {
+          arg = res2;
+          mutated = true;
+        }
+      }
+      return mutated ? arg : undefined;
+    };
+  }
+  function composeArrayFunctions(res, visitors, key) {
+    let functions = extractFunctions(visitors, key);
+    if (functions.length === 0) {
+      return;
+    }
+    if (functions.length === 1) {
+      res[key] = functions[0];
+      return;
+    }
+    res[key] = createArrayVisitor(functions, (f, item) => f(item));
+  }
+  function createArrayVisitor(visitors, apply) {
+    let seen = new Bitset(visitors.length);
+    return (arg) => {
+      let arr = [arg];
+      let mutated = false;
+      seen.clear();
+      for (let i = 0;i < arr.length; i++) {
+        for (let v = 0;v < visitors.length && i < arr.length; ) {
+          if (seen.get(v)) {
+            v++;
+            continue;
+          }
+          let item = arr[i];
+          let visitor = visitors[v];
+          let res = apply(visitor, item);
+          if (Array.isArray(res)) {
+            if (res.length === 0) {
+              arr.splice(i, 1);
+            } else if (res.length === 1) {
+              arr[i] = res[0];
+            } else {
+              arr.splice(i, 1, ...res);
+            }
+            mutated = true;
+            seen.set(v);
+            v = 0;
+          } else if (res) {
+            arr[i] = res;
+            mutated = true;
+            seen.set(v);
+            v = 0;
+          } else {
+            v++;
+          }
+        }
+      }
+      if (!mutated) {
+        return;
+      }
+      return arr.length === 1 ? arr[0] : arr;
+    };
+  }
+
+  class Bitset {
+    constructor(maxBits = 32) {
+      this.bits = 0;
+      this.more = maxBits > 32 ? new Uint32Array(Math.ceil((maxBits - 32) / 32)) : null;
+    }
+    get(bit) {
+      if (bit >= 32 && this.more) {
+        let i = Math.floor((bit - 32) / 32);
+        let b = bit % 32;
+        return Boolean(this.more[i] & 1 << b);
+      } else {
+        return Boolean(this.bits & 1 << bit);
+      }
+    }
+    set(bit) {
+      if (bit >= 32 && this.more) {
+        let i = Math.floor((bit - 32) / 32);
+        let b = bit % 32;
+        this.more[i] |= 1 << b;
+      } else {
+        this.bits |= 1 << bit;
+      }
+    }
+    clear() {
+      this.bits = 0;
+      if (this.more) {
+        this.more.fill(0);
+      }
+    }
+  }
+});
+
+// ../../node_modules/.bun/lightningcss@1.32.0/node_modules/lightningcss/node/flags.js
+var require_flags = __commonJS((exports) => {
+  exports.Features = {
+    Nesting: 1,
+    NotSelectorList: 2,
+    DirSelector: 4,
+    LangSelectorList: 8,
+    IsSelector: 16,
+    TextDecorationThicknessPercent: 32,
+    MediaIntervalSyntax: 64,
+    MediaRangeSyntax: 128,
+    CustomMediaQueries: 256,
+    ClampFunction: 512,
+    ColorFunction: 1024,
+    OklabColors: 2048,
+    LabColors: 4096,
+    P3Colors: 8192,
+    HexAlphaColors: 16384,
+    SpaceSeparatedColorNotation: 32768,
+    FontFamilySystemUi: 65536,
+    DoublePositionGradients: 131072,
+    VendorPrefixes: 262144,
+    LogicalProperties: 524288,
+    LightDark: 1048576,
+    Selectors: 31,
+    MediaQueries: 448,
+    Colors: 1113088
+  };
+});
+
+// ../../node_modules/.bun/lightningcss@1.32.0/node_modules/lightningcss/node/index.js
+var require_node = __commonJS((exports, module) => {
+  var parts = [process.platform, process.arch];
+  if (process.platform === "linux") {
+    const { MUSL, familySync } = require_detect_libc();
+    const family = familySync();
+    if (family === MUSL) {
+      parts.push("musl");
+    } else if (process.arch === "arm") {
+      parts.push("gnueabihf");
+    } else {
+      parts.push("gnu");
+    }
+  } else if (process.platform === "win32") {
+    parts.push("msvc");
+  }
+  var native;
+  try {
+    native = __require(`lightningcss-${parts.join("-")}`);
+  } catch (err) {
+    native = __require(`../lightningcss.${parts.join("-")}.node`);
+  }
+  exports.transform = wrap(native.transform);
+  exports.transformStyleAttribute = wrap(native.transformStyleAttribute);
+  exports.bundle = wrap(native.bundle);
+  exports.bundleAsync = wrap(native.bundleAsync);
+  exports.browserslistToTargets = require_browserslistToTargets();
+  exports.composeVisitors = require_composeVisitors();
+  exports.Features = require_flags().Features;
+  function wrap(call) {
+    return (options) => {
+      if (typeof options.visitor === "function") {
+        let deps = [];
+        options.visitor = options.visitor({
+          addDependency(dep) {
+            deps.push(dep);
+          }
+        });
+        let result = call(options);
+        if (result instanceof Promise) {
+          result = result.then((res) => {
+            if (deps.length) {
+              res.dependencies ??= [];
+              res.dependencies.push(...deps);
+            }
+            return res;
+          });
+        } else if (deps.length) {
+          result.dependencies ??= [];
+          result.dependencies.push(...deps);
+        }
+        return result;
+      } else {
+        return call(options);
+      }
+    };
+  }
+});
+
+// index.ts
+import { createRequire as createRequire3 } from "module";
+import { existsSync as existsSync3, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3, dirname as dirname3, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/platforms.ts
+var PLATFORMS = [
+  {
+    name: "linux-x64-gnu",
+    npmOs: "linux",
+    npmCpu: "x64",
+    npmLibc: "glibc",
+    zigTarget: "x86_64-linux-gnu",
+    ghaRunner: "ubuntu-latest"
+  },
+  {
+    name: "linux-arm64-gnu",
+    npmOs: "linux",
+    npmCpu: "arm64",
+    npmLibc: "glibc",
+    zigTarget: "aarch64-linux-gnu",
+    ghaRunner: "ubuntu-24.04-arm"
+  },
+  {
+    name: "linux-x64-musl",
+    npmOs: "linux",
+    npmCpu: "x64",
+    npmLibc: "musl",
+    zigTarget: "x86_64-linux-musl",
+    ghaRunner: "ubuntu-latest"
+  },
+  {
+    name: "linux-arm64-musl",
+    npmOs: "linux",
+    npmCpu: "arm64",
+    npmLibc: "musl",
+    zigTarget: "aarch64-linux-musl",
+    ghaRunner: "ubuntu-24.04-arm"
+  },
+  {
+    name: "darwin-x64",
+    npmOs: "darwin",
+    npmCpu: "x64",
+    zigTarget: "x86_64-macos",
+    ghaRunner: "macos-15-intel"
+  },
+  {
+    name: "darwin-arm64",
+    npmOs: "darwin",
+    npmCpu: "arm64",
+    zigTarget: "aarch64-macos",
+    ghaRunner: "macos-latest"
+  },
+  {
+    name: "win32-x64-msvc",
+    npmOs: "win32",
+    npmCpu: "x64",
+    zigTarget: "x86_64-windows-msvc",
+    ghaRunner: "windows-latest"
+  },
+  {
+    name: "win32-arm64-msvc",
+    npmOs: "win32",
+    npmCpu: "arm64",
+    zigTarget: "aarch64-windows-msvc",
+    ghaRunner: "windows-11-arm"
+  },
+  {
+    name: "win32-ia32-msvc",
+    npmOs: "win32",
+    npmCpu: "ia32",
+    zigTarget: "x86-windows-msvc",
+    ghaRunner: "windows-latest"
+  }
+];
+function subPackageName(platform) {
+  return `@zntc/core-${platform.name}`;
+}
+function formatSupportedPlatforms() {
+  const groups = new Map;
+  for (const p of PLATFORMS) {
+    const key = `${p.npmOs}-${p.npmCpu}`;
+    if (!groups.has(key))
+      groups.set(key, []);
+    if (p.npmLibc)
+      groups.get(key).push(p.npmLibc);
+  }
+  return Array.from(groups, ([key, libcs]) => libcs.length > 0 ? `${key} (${libcs.join("/")})` : key).join(", ");
+}
+
+// ../shared/compat-engines.ts
+var FEATURES = [
+  "arrow",
+  "class",
+  "template_literal",
+  "destructuring",
+  "for_of",
+  "spread",
+  "object_extensions",
+  "default_params",
+  "block_scoping",
+  "generator",
+  "new_target",
+  "exponentiation",
+  "async_await",
+  "object_spread",
+  "optional_catch_binding",
+  "nullish_coalescing",
+  "optional_chaining",
+  "logical_assignment",
+  "class_static_block",
+  "class_private_method",
+  "class_private_field",
+  "top_level_await",
+  "hashbang",
+  "using",
+  "regex_sticky",
+  "regex_dotall",
+  "regex_named_groups",
+  "unicode_brace_escape"
+];
+var SUPPORT = {
+  arrow: {
+    chrome: [45, 0],
+    firefox: [22, 0],
+    safari: [10, 0],
+    edge: [12, 0],
+    node: [4, 0],
+    deno: [1, 0],
+    ios: [10, 0]
+  },
+  class: {
+    chrome: [49, 0],
+    firefox: [45, 0],
+    safari: [10, 1],
+    edge: [13, 0],
+    node: [6, 0],
+    deno: [1, 0],
+    ios: [10, 3]
+  },
+  template_literal: {
+    chrome: [41, 0],
+    firefox: [34, 0],
+    safari: [9, 0],
+    edge: [12, 0],
+    node: [4, 0],
+    deno: [1, 0],
+    ios: [9, 0]
+  },
+  destructuring: {
+    chrome: [49, 0],
+    firefox: [41, 0],
+    safari: [8, 0],
+    edge: [14, 0],
+    node: [6, 0],
+    deno: [1, 0],
+    ios: [8, 0]
+  },
+  for_of: {
+    chrome: [38, 0],
+    firefox: [13, 0],
+    safari: [7, 0],
+    edge: [12, 0],
+    node: [0, 12],
+    deno: [1, 0],
+    ios: [7, 0],
+    hermes: [0, 7]
+  },
+  spread: {
+    chrome: [46, 0],
+    firefox: [27, 0],
+    safari: [10, 0],
+    edge: [13, 0],
+    node: [5, 0],
+    deno: [1, 0],
+    ios: [10, 0],
+    hermes: [0, 7]
+  },
+  object_extensions: {
+    chrome: [43, 0],
+    firefox: [34, 0],
+    safari: [9, 0],
+    edge: [12, 0],
+    node: [4, 0],
+    deno: [1, 0],
+    ios: [9, 0],
+    hermes: [0, 7]
+  },
+  default_params: {
+    chrome: [49, 0],
+    firefox: [15, 0],
+    safari: [10, 0],
+    edge: [14, 0],
+    node: [6, 0],
+    deno: [1, 0],
+    ios: [10, 0]
+  },
+  block_scoping: {
+    chrome: [49, 0],
+    firefox: [51, 0],
+    safari: [11, 0],
+    edge: [14, 0],
+    node: [6, 0],
+    deno: [1, 0],
+    ios: [11, 0]
+  },
+  generator: {
+    chrome: [50, 0],
+    firefox: [53, 0],
+    safari: [10, 0],
+    edge: [13, 0],
+    node: [6, 0],
+    deno: [1, 0],
+    ios: [10, 0]
+  },
+  new_target: {
+    chrome: [46, 0],
+    firefox: [41, 0],
+    safari: [10, 0],
+    edge: [14, 0],
+    node: [5, 0],
+    deno: [1, 0],
+    ios: [10, 0]
+  },
+  exponentiation: {
+    chrome: [52, 0],
+    firefox: [52, 0],
+    safari: [10, 1],
+    edge: [14, 0],
+    node: [7, 0],
+    deno: [1, 0],
+    ios: [10, 3],
+    hermes: [0, 7]
+  },
+  async_await: {
+    chrome: [55, 0],
+    firefox: [52, 0],
+    safari: [11, 0],
+    edge: [15, 0],
+    node: [7, 6],
+    deno: [1, 0],
+    ios: [11, 0]
+  },
+  object_spread: {
+    chrome: [60, 0],
+    firefox: [55, 0],
+    safari: [11, 1],
+    edge: [79, 0],
+    node: [8, 3],
+    deno: [1, 0],
+    ios: [11, 3],
+    hermes: [0, 7]
+  },
+  optional_catch_binding: {
+    chrome: [66, 0],
+    firefox: [58, 0],
+    safari: [11, 1],
+    edge: [79, 0],
+    node: [10, 0],
+    deno: [1, 0],
+    ios: [11, 3],
+    hermes: [0, 12]
+  },
+  nullish_coalescing: {
+    chrome: [80, 0],
+    firefox: [72, 0],
+    safari: [13, 1],
+    edge: [80, 0],
+    node: [14, 0],
+    deno: [1, 0],
+    ios: [13, 4],
+    hermes: [0, 7]
+  },
+  optional_chaining: {
+    chrome: [91, 0],
+    firefox: [74, 0],
+    safari: [13, 1],
+    edge: [91, 0],
+    node: [16, 9],
+    deno: [1, 9],
+    ios: [13, 4],
+    hermes: [0, 12]
+  },
+  logical_assignment: {
+    chrome: [85, 0],
+    firefox: [79, 0],
+    safari: [14, 0],
+    edge: [85, 0],
+    node: [15, 0],
+    deno: [1, 2],
+    ios: [14, 0],
+    hermes: [0, 7]
+  },
+  class_static_block: {
+    chrome: [94, 0],
+    firefox: [93, 0],
+    safari: [16, 4],
+    edge: [94, 0],
+    node: [16, 11],
+    deno: [1, 14],
+    ios: [16, 4]
+  },
+  class_private_method: {
+    chrome: [84, 0],
+    firefox: [90, 0],
+    safari: [15, 0],
+    edge: [84, 0],
+    node: [14, 6],
+    deno: [1, 0],
+    ios: [15, 0]
+  },
+  class_private_field: {
+    chrome: [74, 0],
+    firefox: [90, 0],
+    safari: [14, 1],
+    edge: [79, 0],
+    node: [12, 0],
+    deno: [1, 0],
+    ios: [14, 5]
+  },
+  hashbang: {
+    chrome: [74, 0],
+    firefox: [67, 0],
+    safari: [13, 1],
+    edge: [79, 0],
+    node: [12, 0],
+    deno: [1, 0],
+    ios: [13, 4],
+    hermes: [0, 7]
+  },
+  using: {}
+};
+function verGte(a, b) {
+  if (a[0] !== b[0])
+    return a[0] > b[0];
+  return a[1] >= b[1];
+}
+function isSupported(feature, engine, ver) {
+  const min = SUPPORT[feature]?.[engine];
+  if (!min)
+    return false;
+  return verGte(ver, min);
+}
+function computeUnsupportedFromEngines(engines) {
+  let bits = 0;
+  for (let i = 0;i < FEATURES.length; i++) {
+    const feature = FEATURES[i];
+    let anyUnsupported = false;
+    for (const ev of engines) {
+      if (!isSupported(feature, ev.engine, [ev.major, ev.minor])) {
+        anyUnsupported = true;
+        break;
+      }
+    }
+    if (anyUnsupported)
+      bits |= 1 << i;
+  }
+  return bits;
+}
+// ../shared/index.ts
+var ES_TARGET_BITS = {
+  es5: 268435455,
+  es2015: 117438464,
+  es2016: 117436416,
+  es2017: 117432320,
+  es2018: 16760832,
+  es2019: 16744448,
+  es2020: 16646144,
+  es2021: 16515072,
+  es2022: 12582912,
+  es2023: 8388608,
+  es2024: 8388608,
+  es2025: 0,
+  esnext: 0
+};
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function validateTsConfigRaw(raw) {
+  if (raw === undefined)
+    return;
+  let config;
+  try {
+    config = JSON.parse(raw);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(`failed to parse --tsconfig-raw: ${reason}`);
+  }
+  if (!isPlainObject(config)) {
+    throw new Error("failed to parse --tsconfig-raw: expected a JSON object");
+  }
+}
+function buildOptionsJson(opts = {}, unsupportedOverride) {
+  const payload = {};
+  if (opts.target)
+    payload.target = opts.target;
+  if (unsupportedOverride !== undefined && unsupportedOverride !== 0)
+    payload.unsupported = unsupportedOverride;
+  if (opts.flow)
+    payload.flow = true;
+  if (opts.jsxInJs)
+    payload.jsxInJs = true;
+  if (opts.reactRefresh)
+    payload.reactRefresh = true;
+  if (opts.reactRefreshHookSignatures)
+    payload.reactRefreshHookSignatures = true;
+  if (opts.jsx !== undefined) {
+    payload.jsx = opts.jsx === "automatic-dev" ? "automatic_dev" : opts.jsx;
+  }
+  if (opts.jsxFactory)
+    payload.jsxFactory = opts.jsxFactory;
+  if (opts.jsxFragment)
+    payload.jsxFragment = opts.jsxFragment;
+  if (opts.jsxImportSource)
+    payload.jsxImportSource = opts.jsxImportSource;
+  if (opts.dropConsole)
+    payload.dropConsole = true;
+  if (opts.dropDebugger)
+    payload.dropDebugger = true;
+  if (opts.asciiOnly)
+    payload.asciiOnly = true;
+  if (opts.charsetUtf8)
+    payload.charsetUtf8 = true;
+  if (opts.experimentalDecorators)
+    payload.experimentalDecorators = true;
+  if (opts.emitDecoratorMetadata)
+    payload.emitDecoratorMetadata = true;
+  if (opts.useDefineForClassFields === false)
+    payload.useDefineForClassFields = false;
+  if (opts.verbatimModuleSyntax !== undefined)
+    payload.verbatimModuleSyntax = opts.verbatimModuleSyntax;
+  if (opts.tsconfigPath)
+    payload.tsconfigPath = opts.tsconfigPath;
+  if (opts.tsconfigRaw)
+    payload.tsconfigRaw = opts.tsconfigRaw;
+  if (opts.format)
+    payload.format = opts.format;
+  if (opts.quotes)
+    payload.quotes = opts.quotes;
+  if (opts.platform === "react-native")
+    payload.platform = "react_native";
+  else if (opts.platform)
+    payload.platform = opts.platform;
+  if (opts.minifyWhitespace || opts.minify)
+    payload.minifyWhitespace = true;
+  if (opts.minifyIdentifiers || opts.minify)
+    payload.minifyIdentifiers = true;
+  if (opts.minifySyntax || opts.minify)
+    payload.minifySyntax = true;
+  if (opts.sourcemap)
+    payload.sourcemap = true;
+  if (opts.sourcemapDebugIds)
+    payload.sourcemapDebugIds = true;
+  if (opts.sourcesContent === false)
+    payload.sourcesContent = false;
+  if (opts.sourceRoot)
+    payload.sourceRoot = opts.sourceRoot;
+  if (opts.define && opts.define.length > 0)
+    payload.define = opts.define;
+  if (opts.stopAfter)
+    payload.stopAfter = opts.stopAfter;
+  return JSON.stringify(payload);
+}
+function parseBrowserslistEntry(entry) {
+  const m = entry.trim().match(/^(\S+)\s+([\d.]+)(?:-[\d.]+)?$/);
+  if (!m)
+    return null;
+  const name = m[1].toLowerCase();
+  const versionStr = m[2];
+  const [majStr, minStr = "0"] = versionStr.split(".");
+  const major = parseInt(majStr, 10);
+  const minor = parseInt(minStr, 10);
+  if (Number.isNaN(major))
+    return null;
+  const map = {
+    chrome: "chrome",
+    and_chr: "chrome",
+    firefox: "firefox",
+    and_ff: "firefox",
+    safari: "safari",
+    ios_saf: "ios",
+    edge: "edge",
+    node: "node",
+    deno: "deno",
+    opera: "opera",
+    op_mob: "opera",
+    hermes: "hermes"
+  };
+  const engine = map[name];
+  if (!engine)
+    return null;
+  return { engine, major, minor };
+}
+function browserslistToUnsupported(entries) {
+  const engines = [];
+  for (const e of entries) {
+    const parsed = parseBrowserslistEntry(e);
+    if (parsed)
+      engines.push(parsed);
+  }
+  if (engines.length === 0)
+    return 0;
+  return computeUnsupportedFromEngines(engines);
+}
+
+// src/runtime-polyfills.ts
+import { readFileSync } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { dirname, resolve } from "node:path";
+var runtimeRequireOverride = null;
+function getRuntimeRequire() {
+  return runtimeRequireOverride ?? createRequire2(import.meta.url);
+}
+var ES_TARGETS = new Set([
+  "es5",
+  "es2015",
+  "es2016",
+  "es2017",
+  "es2018",
+  "es2019",
+  "es2020",
+  "es2021",
+  "es2022",
+  "es2023",
+  "es2024",
+  "es2025",
+  "esnext"
+]);
+var DEVICE_TARGET_RE = /\b(?:iphone|ipad|ipod|galaxy|pixel|nexus|oneplus|xiaomi|redmi|huawei|motorola|moto)\b/i;
+var RUNTIME_POLYFILL_FEATURE_MODULES = [
+  { feature: "aggregate_error", module: "es.aggregate-error" },
+  { feature: "aggregate_error", module: "es.aggregate-error.cause" },
+  { feature: "array_buffer", module: "es.array-buffer.constructor" },
+  { feature: "array_buffer_detached", module: "es.array-buffer.detached" },
+  { feature: "array_buffer_is_view", module: "es.array-buffer.is-view" },
+  { feature: "array_buffer_slice", module: "es.array-buffer.slice" },
+  { feature: "array_buffer_transfer", module: "es.array-buffer.transfer" },
+  {
+    feature: "array_buffer_transfer_to_fixed_length",
+    module: "es.array-buffer.transfer-to-fixed-length"
+  },
+  { feature: "array_at", module: "es.array.at" },
+  { feature: "array_concat", module: "es.array.concat" },
+  { feature: "array_copy_within", module: "es.array.copy-within" },
+  { feature: "array_every", module: "es.array.every" },
+  { feature: "array_fill", module: "es.array.fill" },
+  { feature: "array_filter", module: "es.array.filter" },
+  { feature: "array_find", module: "es.array.find" },
+  { feature: "array_find_index", module: "es.array.find-index" },
+  { feature: "array_find_last", module: "es.array.find-last" },
+  { feature: "array_find_last_index", module: "es.array.find-last-index" },
+  { feature: "array_flat", module: "es.array.flat" },
+  { feature: "array_flat_map", module: "es.array.flat-map" },
+  { feature: "array_for_each", module: "es.array.for-each" },
+  { feature: "array_from", module: "es.array.from" },
+  { feature: "array_from_async", module: "es.array.from-async" },
+  { feature: "array_includes", module: "es.array.includes" },
+  { feature: "array_index_of", module: "es.array.index-of" },
+  { feature: "array_is_array", module: "es.array.is-array" },
+  { feature: "array_join", module: "es.array.join" },
+  { feature: "array_last_index_of", module: "es.array.last-index-of" },
+  { feature: "array_map", module: "es.array.map" },
+  { feature: "array_of", module: "es.array.of" },
+  { feature: "array_push", module: "es.array.push" },
+  { feature: "array_reduce", module: "es.array.reduce" },
+  { feature: "array_reduce_right", module: "es.array.reduce-right" },
+  { feature: "array_reverse", module: "es.array.reverse" },
+  { feature: "array_slice", module: "es.array.slice" },
+  { feature: "array_some", module: "es.array.some" },
+  { feature: "array_sort", module: "es.array.sort" },
+  { feature: "array_splice", module: "es.array.splice" },
+  { feature: "array_to_reversed", module: "es.array.to-reversed" },
+  { feature: "array_to_sorted", module: "es.array.to-sorted" },
+  { feature: "array_to_spliced", module: "es.array.to-spliced" },
+  { feature: "array_unshift", module: "es.array.unshift" },
+  { feature: "array_with", module: "es.array.with" },
+  { feature: "async_disposable_stack", module: "es.async-disposable-stack.constructor" },
+  { feature: "data_view", module: "es.data-view" },
+  { feature: "data_view_get_float16", module: "es.data-view.get-float16" },
+  { feature: "data_view_set_float16", module: "es.data-view.set-float16" },
+  { feature: "date_now", module: "es.date.now" },
+  { feature: "date_to_iso_string", module: "es.date.to-iso-string" },
+  { feature: "disposable_stack", module: "es.disposable-stack.constructor" },
+  { feature: "error_is_error", module: "es.error.is-error" },
+  { feature: "escape", module: "es.escape" },
+  { feature: "function_bind", module: "es.function.bind" },
+  { feature: "global_this", module: "es.global-this" },
+  { feature: "iterator", module: "es.iterator.constructor" },
+  { feature: "iterator_drop", module: "es.iterator.drop" },
+  { feature: "iterator_every", module: "es.iterator.every" },
+  { feature: "iterator_filter", module: "es.iterator.filter" },
+  { feature: "iterator_find", module: "es.iterator.find" },
+  { feature: "iterator_flat_map", module: "es.iterator.flat-map" },
+  { feature: "iterator_for_each", module: "es.iterator.for-each" },
+  { feature: "iterator_from", module: "es.iterator.from" },
+  { feature: "iterator_map", module: "es.iterator.map" },
+  { feature: "iterator_reduce", module: "es.iterator.reduce" },
+  { feature: "iterator_some", module: "es.iterator.some" },
+  { feature: "iterator_take", module: "es.iterator.take" },
+  { feature: "iterator_to_array", module: "es.iterator.to-array" },
+  { feature: "json_is_raw_json", module: "es.json.is-raw-json" },
+  { feature: "json_parse", module: "es.json.parse" },
+  { feature: "json_raw_json", module: "es.json.raw-json" },
+  { feature: "json_stringify", module: "es.json.stringify" },
+  { feature: "map", module: "es.map" },
+  { feature: "map_get_or_insert", module: "es.map.get-or-insert" },
+  { feature: "map_get_or_insert_computed", module: "es.map.get-or-insert-computed" },
+  { feature: "map_group_by", module: "es.map.group-by" },
+  { feature: "math_acosh", module: "es.math.acosh" },
+  { feature: "math_asinh", module: "es.math.asinh" },
+  { feature: "math_atanh", module: "es.math.atanh" },
+  { feature: "math_cbrt", module: "es.math.cbrt" },
+  { feature: "math_clz32", module: "es.math.clz32" },
+  { feature: "math_cosh", module: "es.math.cosh" },
+  { feature: "math_expm1", module: "es.math.expm1" },
+  { feature: "math_f16round", module: "es.math.f16round" },
+  { feature: "math_fround", module: "es.math.fround" },
+  { feature: "math_hypot", module: "es.math.hypot" },
+  { feature: "math_imul", module: "es.math.imul" },
+  { feature: "math_log10", module: "es.math.log10" },
+  { feature: "math_log1p", module: "es.math.log1p" },
+  { feature: "math_log2", module: "es.math.log2" },
+  { feature: "math_sign", module: "es.math.sign" },
+  { feature: "math_sinh", module: "es.math.sinh" },
+  { feature: "math_sum_precise", module: "es.math.sum-precise" },
+  { feature: "math_tanh", module: "es.math.tanh" },
+  { feature: "math_trunc", module: "es.math.trunc" },
+  { feature: "number_constructor", module: "es.number.constructor" },
+  { feature: "number_epsilon", module: "es.number.epsilon" },
+  { feature: "number_is_finite", module: "es.number.is-finite" },
+  { feature: "number_is_integer", module: "es.number.is-integer" },
+  { feature: "number_is_nan", module: "es.number.is-nan" },
+  { feature: "number_is_safe_integer", module: "es.number.is-safe-integer" },
+  { feature: "number_max_safe_integer", module: "es.number.max-safe-integer" },
+  { feature: "number_min_safe_integer", module: "es.number.min-safe-integer" },
+  { feature: "number_parse_float", module: "es.number.parse-float" },
+  { feature: "number_parse_int", module: "es.number.parse-int" },
+  { feature: "number_to_exponential", module: "es.number.to-exponential" },
+  { feature: "number_to_fixed", module: "es.number.to-fixed" },
+  { feature: "number_to_precision", module: "es.number.to-precision" },
+  { feature: "object_assign", module: "es.object.assign" },
+  { feature: "object_create", module: "es.object.create" },
+  { feature: "object_define_getter", module: "es.object.define-getter" },
+  { feature: "object_define_properties", module: "es.object.define-properties" },
+  { feature: "object_define_property", module: "es.object.define-property" },
+  { feature: "object_define_setter", module: "es.object.define-setter" },
+  { feature: "object_entries", module: "es.object.entries" },
+  { feature: "object_freeze", module: "es.object.freeze" },
+  { feature: "object_from_entries", module: "es.object.from-entries" },
+  {
+    feature: "object_get_own_property_descriptor",
+    module: "es.object.get-own-property-descriptor"
+  },
+  {
+    feature: "object_get_own_property_descriptors",
+    module: "es.object.get-own-property-descriptors"
+  },
+  { feature: "object_get_own_property_names", module: "es.object.get-own-property-names" },
+  { feature: "object_get_prototype_of", module: "es.object.get-prototype-of" },
+  { feature: "object_group_by", module: "es.object.group-by" },
+  { feature: "object_has_own", module: "es.object.has-own" },
+  { feature: "object_is", module: "es.object.is" },
+  { feature: "object_is_extensible", module: "es.object.is-extensible" },
+  { feature: "object_is_frozen", module: "es.object.is-frozen" },
+  { feature: "object_is_sealed", module: "es.object.is-sealed" },
+  { feature: "object_keys", module: "es.object.keys" },
+  { feature: "object_lookup_getter", module: "es.object.lookup-getter" },
+  { feature: "object_lookup_setter", module: "es.object.lookup-setter" },
+  { feature: "object_prevent_extensions", module: "es.object.prevent-extensions" },
+  { feature: "object_proto", module: "es.object.proto" },
+  { feature: "object_seal", module: "es.object.seal" },
+  { feature: "object_set_prototype_of", module: "es.object.set-prototype-of" },
+  { feature: "object_values", module: "es.object.values" },
+  { feature: "parse_float", module: "es.parse-float" },
+  { feature: "parse_int", module: "es.parse-int" },
+  { feature: "set", module: "es.set" },
+  { feature: "set_difference", module: "es.set.difference.v2" },
+  { feature: "set_intersection", module: "es.set.intersection.v2" },
+  { feature: "set_is_disjoint_from", module: "es.set.is-disjoint-from.v2" },
+  { feature: "set_is_subset_of", module: "es.set.is-subset-of.v2" },
+  { feature: "set_is_superset_of", module: "es.set.is-superset-of.v2" },
+  { feature: "set_symmetric_difference", module: "es.set.symmetric-difference.v2" },
+  { feature: "set_union", module: "es.set.union.v2" },
+  { feature: "promise", module: "es.promise" },
+  { feature: "promise_all_settled", module: "es.promise.all-settled" },
+  { feature: "promise_any", module: "es.promise.any" },
+  { feature: "promise_finally", module: "es.promise.finally" },
+  { feature: "promise_try", module: "es.promise.try" },
+  { feature: "promise_with_resolvers", module: "es.promise.with-resolvers" },
+  { feature: "reflect_apply", module: "es.reflect.apply" },
+  { feature: "reflect_construct", module: "es.reflect.construct" },
+  { feature: "reflect_define_property", module: "es.reflect.define-property" },
+  { feature: "reflect_delete_property", module: "es.reflect.delete-property" },
+  { feature: "reflect_get", module: "es.reflect.get" },
+  {
+    feature: "reflect_get_own_property_descriptor",
+    module: "es.reflect.get-own-property-descriptor"
+  },
+  { feature: "reflect_get_prototype_of", module: "es.reflect.get-prototype-of" },
+  { feature: "reflect_has", module: "es.reflect.has" },
+  { feature: "reflect_is_extensible", module: "es.reflect.is-extensible" },
+  { feature: "reflect_own_keys", module: "es.reflect.own-keys" },
+  { feature: "reflect_prevent_extensions", module: "es.reflect.prevent-extensions" },
+  { feature: "reflect_set", module: "es.reflect.set" },
+  { feature: "reflect_set_prototype_of", module: "es.reflect.set-prototype-of" },
+  { feature: "regexp_escape", module: "es.regexp.escape" },
+  { feature: "regexp_flags", module: "es.regexp.flags" },
+  { feature: "regexp_sticky", module: "es.regexp.sticky" },
+  { feature: "regexp_dot_all", module: "es.regexp.dot-all" },
+  { feature: "structured_clone", module: "web.structured-clone" },
+  { feature: "string_anchor", module: "es.string.anchor" },
+  { feature: "string_big", module: "es.string.big" },
+  { feature: "string_blink", module: "es.string.blink" },
+  { feature: "string_bold", module: "es.string.bold" },
+  { feature: "string_code_point_at", module: "es.string.code-point-at" },
+  { feature: "string_ends_with", module: "es.string.ends-with" },
+  { feature: "string_fixed", module: "es.string.fixed" },
+  { feature: "string_fontcolor", module: "es.string.fontcolor" },
+  { feature: "string_fontsize", module: "es.string.fontsize" },
+  { feature: "string_from_code_point", module: "es.string.from-code-point" },
+  { feature: "string_includes", module: "es.string.includes" },
+  { feature: "string_is_well_formed", module: "es.string.is-well-formed" },
+  { feature: "string_italics", module: "es.string.italics" },
+  { feature: "string_link", module: "es.string.link" },
+  { feature: "string_match_all", module: "es.string.match-all" },
+  { feature: "string_pad_end", module: "es.string.pad-end" },
+  { feature: "string_pad_start", module: "es.string.pad-start" },
+  { feature: "string_raw", module: "es.string.raw" },
+  { feature: "string_repeat", module: "es.string.repeat" },
+  { feature: "string_replace_all", module: "es.string.replace-all" },
+  { feature: "string_small", module: "es.string.small" },
+  { feature: "string_starts_with", module: "es.string.starts-with" },
+  { feature: "string_strike", module: "es.string.strike" },
+  { feature: "string_sub", module: "es.string.sub" },
+  { feature: "string_substr", module: "es.string.substr" },
+  { feature: "string_sup", module: "es.string.sup" },
+  { feature: "string_to_well_formed", module: "es.string.to-well-formed" },
+  { feature: "string_trim", module: "es.string.trim" },
+  { feature: "string_trim_end", module: "es.string.trim-end" },
+  { feature: "string_trim_start", module: "es.string.trim-start" },
+  { feature: "suppressed_error", module: "es.suppressed-error.constructor" },
+  { feature: "symbol", module: "es.symbol" },
+  { feature: "symbol_async_dispose", module: "es.symbol.async-dispose" },
+  { feature: "symbol_async_iterator", module: "es.symbol.async-iterator" },
+  { feature: "symbol_description", module: "es.symbol.description" },
+  { feature: "symbol_dispose", module: "es.symbol.dispose" },
+  { feature: "symbol_has_instance", module: "es.symbol.has-instance" },
+  { feature: "symbol_is_concat_spreadable", module: "es.symbol.is-concat-spreadable" },
+  { feature: "symbol_iterator", module: "es.symbol.iterator" },
+  { feature: "symbol_match", module: "es.symbol.match" },
+  { feature: "symbol_match_all", module: "es.symbol.match-all" },
+  { feature: "symbol_replace", module: "es.symbol.replace" },
+  { feature: "symbol_search", module: "es.symbol.search" },
+  { feature: "symbol_species", module: "es.symbol.species" },
+  { feature: "symbol_split", module: "es.symbol.split" },
+  { feature: "symbol_to_primitive", module: "es.symbol.to-primitive" },
+  { feature: "symbol_to_string_tag", module: "es.symbol.to-string-tag" },
+  { feature: "symbol_unscopables", module: "es.symbol.unscopables" },
+  { feature: "typed_array_float32", module: "es.typed-array.float32-array" },
+  { feature: "typed_array_float64", module: "es.typed-array.float64-array" },
+  { feature: "typed_array_int8", module: "es.typed-array.int8-array" },
+  { feature: "typed_array_int16", module: "es.typed-array.int16-array" },
+  { feature: "typed_array_int32", module: "es.typed-array.int32-array" },
+  { feature: "typed_array_uint8", module: "es.typed-array.uint8-array" },
+  { feature: "typed_array_uint8_clamped", module: "es.typed-array.uint8-clamped-array" },
+  { feature: "typed_array_uint16", module: "es.typed-array.uint16-array" },
+  { feature: "typed_array_uint32", module: "es.typed-array.uint32-array" },
+  { feature: "typed_array_at", module: "es.typed-array.at" },
+  { feature: "typed_array_copy_within", module: "es.typed-array.copy-within" },
+  { feature: "typed_array_every", module: "es.typed-array.every" },
+  { feature: "typed_array_fill", module: "es.typed-array.fill" },
+  { feature: "typed_array_filter", module: "es.typed-array.filter" },
+  { feature: "typed_array_find", module: "es.typed-array.find" },
+  { feature: "typed_array_find_index", module: "es.typed-array.find-index" },
+  { feature: "typed_array_find_last", module: "es.typed-array.find-last" },
+  { feature: "typed_array_find_last_index", module: "es.typed-array.find-last-index" },
+  { feature: "typed_array_for_each", module: "es.typed-array.for-each" },
+  { feature: "typed_array_from", module: "es.typed-array.from" },
+  { feature: "typed_array_includes", module: "es.typed-array.includes" },
+  { feature: "typed_array_index_of", module: "es.typed-array.index-of" },
+  { feature: "typed_array_join", module: "es.typed-array.join" },
+  { feature: "typed_array_last_index_of", module: "es.typed-array.last-index-of" },
+  { feature: "typed_array_map", module: "es.typed-array.map" },
+  { feature: "typed_array_of", module: "es.typed-array.of" },
+  { feature: "typed_array_reduce", module: "es.typed-array.reduce" },
+  { feature: "typed_array_reduce_right", module: "es.typed-array.reduce-right" },
+  { feature: "typed_array_reverse", module: "es.typed-array.reverse" },
+  { feature: "typed_array_set", module: "es.typed-array.set" },
+  { feature: "typed_array_slice", module: "es.typed-array.slice" },
+  { feature: "typed_array_some", module: "es.typed-array.some" },
+  { feature: "typed_array_sort", module: "es.typed-array.sort" },
+  { feature: "typed_array_subarray", module: "es.typed-array.subarray" },
+  { feature: "typed_array_to_reversed", module: "es.typed-array.to-reversed" },
+  { feature: "typed_array_to_sorted", module: "es.typed-array.to-sorted" },
+  { feature: "typed_array_with", module: "es.typed-array.with" },
+  { feature: "uint8_array_from_base64", module: "es.uint8-array.from-base64" },
+  { feature: "uint8_array_from_hex", module: "es.uint8-array.from-hex" },
+  { feature: "uint8_array_set_from_base64", module: "es.uint8-array.set-from-base64" },
+  { feature: "uint8_array_set_from_hex", module: "es.uint8-array.set-from-hex" },
+  { feature: "uint8_array_to_base64", module: "es.uint8-array.to-base64" },
+  { feature: "uint8_array_to_hex", module: "es.uint8-array.to-hex" },
+  { feature: "unescape", module: "es.unescape" },
+  { feature: "weak_map", module: "es.weak-map" },
+  { feature: "weak_map_get_or_insert", module: "es.weak-map.get-or-insert" },
+  { feature: "weak_map_get_or_insert_computed", module: "es.weak-map.get-or-insert-computed" },
+  { feature: "weak_set", module: "es.weak-set" },
+  { feature: "web_atob", module: "web.atob" },
+  { feature: "web_btoa", module: "web.btoa" },
+  { feature: "web_dom_collections_for_each", module: "web.dom-collections.for-each" },
+  { feature: "web_dom_collections_iterator", module: "web.dom-collections.iterator" },
+  { feature: "web_dom_exception", module: "web.dom-exception.constructor" },
+  { feature: "web_immediate", module: "web.immediate" },
+  { feature: "web_queue_microtask", module: "web.queue-microtask" },
+  { feature: "web_self", module: "web.self" },
+  { feature: "web_timers", module: "web.timers" },
+  { feature: "web_url", module: "web.url" },
+  { feature: "web_url_can_parse", module: "web.url.can-parse" },
+  { feature: "web_url_parse", module: "web.url.parse" },
+  { feature: "web_url_to_json", module: "web.url.to-json" },
+  { feature: "web_url_search_params", module: "web.url-search-params" },
+  { feature: "web_url_search_params_delete", module: "web.url-search-params.delete" },
+  { feature: "web_url_search_params_has", module: "web.url-search-params.has" },
+  { feature: "web_url_search_params_size", module: "web.url-search-params.size" }
+];
+var RUNTIME_POLYFILL_CANDIDATE_MODULES = RUNTIME_POLYFILL_FEATURE_MODULES.map((item) => item.module);
+var coreJsCompatCache;
+var coreJsVersionCache;
+function isEsTarget(target) {
+  return target !== undefined && ES_TARGETS.has(target);
+}
+function loadCoreJsCompat() {
+  if (coreJsCompatCache !== undefined) {
+    if (coreJsCompatCache)
+      return coreJsCompatCache;
+    throwCoreJsCompatMissing();
+  }
+  try {
+    const req = getRuntimeRequire();
+    coreJsCompatCache = req("core-js-compat");
+    return coreJsCompatCache;
+  } catch {
+    coreJsCompatCache = null;
+    throwCoreJsCompatMissing();
+  }
+}
+function throwCoreJsCompatMissing() {
+  throw new Error("@zntc/core: runtimePolyfills requires the optional 'core-js-compat' package. Install it with `bun add core-js core-js-compat`.");
+}
+function readInstalledCoreJsVersion() {
+  if (coreJsVersionCache !== undefined)
+    return coreJsVersionCache ?? undefined;
+  try {
+    const req = getRuntimeRequire();
+    const pkgPath = req.resolve("core-js/package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    coreJsVersionCache = pkg.version ?? null;
+  } catch {
+    coreJsVersionCache = null;
+  }
+  return coreJsVersionCache ?? undefined;
+}
+function assertNotPhysicalDeviceTarget(raw) {
+  if (!DEVICE_TARGET_RE.test(raw))
+    return;
+  throw new Error(`@zntc/core: unsupported runtime target '${raw}'. Physical device names are not supported; use Browserslist targets such as 'ios_saf 12', 'chrome >= 85', or 'node 18'.`);
+}
+function assertNotCompactRuntimeTarget(raw) {
+  const compact = raw.match(/^(ios_saf|ios|safari|chrome|android|samsung|hermes|node)v?\d+(?:\.\d+)*$/i);
+  if (!compact)
+    return;
+  throw new Error(`@zntc/core: unsupported runtime target '${raw}'. Compact runtime target shorthands are not supported; use Browserslist targets such as 'ios_saf 12', 'chrome >= 85', or 'node 18'.`);
+}
+function assertBrowserslistRuntimeTarget(raw) {
+  if (!/^(?:hermes|react-native|reactnative)\b/i.test(raw))
+    return;
+  throw new Error(`@zntc/core: unsupported runtime target '${raw}'. runtimePolyfills.targets follows Rspack/SWC env.targets and accepts Browserslist queries; use platform: 'react-native' for the default Hermes runtime target.`);
+}
+function normalizeRuntimeTargetString(raw) {
+  const value = raw.trim();
+  assertNotPhysicalDeviceTarget(value);
+  assertNotCompactRuntimeTarget(value);
+  assertBrowserslistRuntimeTarget(value);
+  return value;
+}
+function normalizeRuntimeTargets(targets) {
+  if (Array.isArray(targets))
+    return targets.map(normalizeRuntimeTargetString);
+  return normalizeRuntimeTargetString(targets);
+}
+function normalizeBuildTargetForRuntime(target) {
+  if (!target || isEsTarget(target))
+    return;
+  const nodeTarget = target.match(/^node(\d+(?:\.\d+)*)$/i);
+  if (nodeTarget)
+    return { node: nodeTarget[1] };
+  const hermesTarget = target.match(/^hermes(\d+(?:\.\d+)*)$/i);
+  if (hermesTarget)
+    return { hermes: hermesTarget[1] };
+  return normalizeRuntimeTargets(target);
+}
+function defaultRuntimeTargets(options) {
+  if (options.platform === "node") {
+    const [major, minor = "0"] = process.versions.node.split(".");
+    return { node: `${major}.${minor}` };
+  }
+  if (options.platform === "react-native")
+    return { hermes: "0.7" };
+  return "defaults";
+}
+function chooseRuntimeTargets(options, runtime) {
+  const raw = runtime.targets ?? (options.browserslist ? options.browserslist : undefined);
+  if (raw !== undefined)
+    return normalizeRuntimeTargets(raw);
+  const target = normalizeBuildTargetForRuntime(options.target);
+  if (target !== undefined)
+    return target;
+  return defaultRuntimeTargets(options);
+}
+function normalizeCoreJsModuleName(raw) {
+  let value = raw.trim();
+  if (value.startsWith("core-js/modules/"))
+    value = value.slice("core-js/modules/".length);
+  if (value.endsWith(".js"))
+    value = value.slice(0, -3);
+  if (!/^(?:es|web)\.[a-z0-9.-]+$/i.test(value)) {
+    throw new Error(`@zntc/core: invalid core-js module '${raw}'. Expected e.g. 'es.string.replace-all'.`);
+  }
+  return value;
+}
+function normalizeRuntimePolyfillOptions(options) {
+  const raw = options.runtimePolyfills;
+  if (raw === undefined || raw === "off")
+    return null;
+  const runtime = typeof raw === "string" ? { mode: raw } : { ...raw };
+  const mode = runtime.mode ?? "auto";
+  if (mode !== "auto" && mode !== "usage" && mode !== "entry") {
+    throw new Error("@zntc/core: runtimePolyfills.mode must be 'auto', 'usage', or 'entry'.");
+  }
+  const provider = runtime.provider ?? "core-js";
+  if (provider !== "core-js") {
+    throw new Error("@zntc/core: runtimePolyfills.provider currently supports only 'core-js'.");
+  }
+  return {
+    mode,
+    provider,
+    targets: chooseRuntimeTargets(options, runtime),
+    include: (runtime.include ?? []).map(normalizeCoreJsModuleName),
+    exclude: (runtime.exclude ?? []).map(normalizeCoreJsModuleName),
+    proposals: runtime.proposals === true,
+    coreJsVersion: runtime.coreJs ?? options.coreJs ?? readInstalledCoreJsVersion()
+  };
+}
+function computeCoreJsCompatModules(targets, modules, options = {}) {
+  const compat = loadCoreJsCompat();
+  const result = compat({
+    targets,
+    modules,
+    version: options.version,
+    proposals: options.proposals
+  });
+  return result.list.map(normalizeCoreJsModuleName).sort();
+}
+function buildCoreJsResolver(entryPoints) {
+  const override = runtimeRequireOverride;
+  const requires = [];
+  if (override) {
+    requires.push(override);
+  } else {
+    const entry = entryPoints[0];
+    if (entry)
+      requires.push(createRequire2(resolve(dirname(resolve(entry)), "package.json")));
+    requires.push(createRequire2(import.meta.url));
+  }
+  return (moduleName) => {
+    const specifier = `core-js/modules/${moduleName}.js`;
+    let firstError;
+    for (const req of requires) {
+      try {
+        return req.resolve(specifier);
+      } catch (err) {
+        firstError ??= err instanceof Error ? err.message : String(err);
+      }
+    }
+    throw new Error(`@zntc/core: runtimePolyfills could not resolve '${specifier}'. Install core-js with \`bun add core-js\`.
+${firstError ?? ""}`);
+  };
+}
+function uniqueSorted(values) {
+  return [...new Set(values)].sort();
+}
+function resolveRuntimeModules(modules, resolveCoreJs) {
+  return uniqueSorted(modules).map((moduleName) => ({
+    module: moduleName,
+    path: resolveCoreJs(moduleName)
+  }));
+}
+function applyRuntimePolyfillsToNapiOptions(napiOptions, options) {
+  delete napiOptions.runtimePolyfills;
+  delete napiOptions.coreJs;
+  if (options.target && !isEsTarget(options.target))
+    delete napiOptions.target;
+  const runtime = normalizeRuntimePolyfillOptions(options);
+  if (!runtime)
+    return { cleanup: () => {}, modules: [] };
+  const exclude = new Set(runtime.exclude);
+  const includeModules = runtime.include.filter((moduleName) => !exclude.has(moduleName));
+  const resolveCoreJs = buildCoreJsResolver(options.entryPoints);
+  const includeResolved = resolveRuntimeModules(includeModules, resolveCoreJs);
+  if (runtime.mode === "entry") {
+    const entryModules = computeCoreJsCompatModules(runtime.targets, /^(?:es|web)\./, {
+      version: runtime.coreJsVersion,
+      proposals: runtime.proposals
+    }).filter((moduleName) => !exclude.has(moduleName));
+    const entryResolved = resolveRuntimeModules(entryModules, resolveCoreJs);
+    if (entryResolved.length === 0 && includeResolved.length === 0) {
+      return { cleanup: () => {}, modules: [] };
+    }
+    napiOptions.runtimePolyfillPlan = {
+      mode: "entry",
+      entry: entryResolved,
+      include: includeResolved,
+      exclude: runtime.exclude
+    };
+    return {
+      cleanup: () => {},
+      modules: uniqueSorted([...entryResolved, ...includeResolved].map((item) => item.module))
+    };
+  }
+  const targetCandidateSet = new Set(computeCoreJsCompatModules(runtime.targets, RUNTIME_POLYFILL_CANDIDATE_MODULES, {
+    version: runtime.coreJsVersion,
+    proposals: runtime.proposals
+  }).filter((moduleName) => !exclude.has(moduleName)));
+  const candidates = [];
+  for (const item of RUNTIME_POLYFILL_FEATURE_MODULES) {
+    if (!targetCandidateSet.has(item.module))
+      continue;
+    candidates.push({
+      feature: item.feature,
+      module: item.module,
+      path: resolveCoreJs(item.module)
+    });
+  }
+  if (candidates.length === 0 && includeResolved.length === 0) {
+    return { cleanup: () => {}, modules: [] };
+  }
+  napiOptions.runtimePolyfillPlan = {
+    mode: "usage",
+    candidates,
+    include: includeResolved,
+    exclude: runtime.exclude
+  };
+  return {
+    cleanup: () => {},
+    modules: uniqueSorted([...candidates, ...includeResolved].map((item) => item.module))
+  };
+}
+
+// src/config-loader.ts
+import { randomBytes } from "node:crypto";
+import { existsSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "node:fs";
+import { dirname as dirname2, extname, join, resolve as pathResolve } from "node:path";
+import { pathToFileURL } from "node:url";
+var CONFIG_EXT_PRIORITY = [".ts", ".mts", ".cts", ".mjs", ".js", ".cjs", ".json"];
+var TS_EXTS = new Set(CONFIG_EXT_PRIORITY.slice(0, 3));
+var JS_EXTS = new Set(CONFIG_EXT_PRIORITY.slice(3, 6));
+async function loadConfig(filePath, env) {
+  const absPath = pathResolve(filePath);
+  return loadConfigWithExtends(absPath, env, new Set);
+}
+async function loadConfigWithExtends(absPath, env, visited) {
+  if (visited.has(absPath)) {
+    throw new Error(`@zntc/core: circular extends detected at ${absPath} (chain: ${[...visited, absPath].join(" → ")})`);
+  }
+  visited.add(absPath);
+  const raw = await loadModuleDefault(absPath, "config");
+  const resolved = await resolveConfigValue(raw, env, absPath);
+  const extendsField = resolved.extends;
+  if (extendsField === undefined)
+    return resolved;
+  const extendsPaths = Array.isArray(extendsField) ? extendsField : [extendsField];
+  const baseDir = dirname2(absPath);
+  let merged = {};
+  for (const extPath of extendsPaths) {
+    const resolvedExt = pathResolve(baseDir, extPath);
+    const base = await loadConfigWithExtends(resolvedExt, env, new Set(visited));
+    merged = mergeUserConfigs(merged, base);
+  }
+  const { extends: _extends, ...currentWithoutExtends } = resolved;
+  return mergeUserConfigs(merged, currentWithoutExtends);
+}
+function defaultConfigEnv() {
+  return {
+    command: "bundle",
+    mode: "production",
+    env: process.env
+  };
+}
+async function resolveConfigValue(raw, env, absPath) {
+  if (typeof raw !== "function") {
+    return raw;
+  }
+  const result = await raw(env ?? defaultConfigEnv());
+  if (!isPlainObject(result)) {
+    const got = Array.isArray(result) ? "array" : typeof result;
+    throw new Error(`@zntc/core: functional config must return an object (got ${got}) from ${absPath}`);
+  }
+  return result;
+}
+async function loadModuleDefault(absPath, kind, options) {
+  const allowArray = options?.allowArray === true;
+  const ext = extname(absPath).toLowerCase();
+  if (ext === ".json") {
+    const raw = readFileOrThrowNotFound(absPath);
+    try {
+      return JSON.parse(raw);
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      throw new Error(`@zntc/core: failed to parse JSON ${kind} ${absPath}: ${reason}`);
+    }
+  }
+  if (TS_EXTS.has(ext)) {
+    return await loadTsModule(absPath, kind, allowArray);
+  }
+  if (JS_EXTS.has(ext)) {
+    try {
+      return await importAndResolveDefault(absPath, { allowArray });
+    } catch (err) {
+      if (err instanceof Error) {
+        err.message = err.message.replace("module not found", `${kind} file not found`).replace(/module must be an object or function/, `${kind} must export an object or function`);
+      }
+      throw err;
+    }
+  }
+  throw new Error(`@zntc/core: unsupported ${kind} extension "${ext}" for ${absPath}. Supported: .ts/.mts/.cts/.mjs/.js/.cjs/.json`);
+}
+async function loadTsModule(absPath, kind, allowArray) {
+  init();
+  const source = readFileOrThrowNotFound(absPath);
+  const parseFilename = absPath.endsWith(".cts") ? absPath.slice(0, -4) + ".ts" : absPath;
+  const result = transpile(source, {
+    filename: parseFilename,
+    format: "esm"
+  });
+  if (result.errors) {
+    throw new Error(`@zntc/core: ${kind} compile failed in ${absPath}
+${result.errors}`);
+  }
+  const tmpName = `.zntc-${kind}.bundled-${randomBytes(6).toString("hex")}.mjs`;
+  const tmpPath = join(dirname2(absPath), tmpName);
+  writeFileSync(tmpPath, result.code, "utf8");
+  try {
+    return await importAndResolveDefault(tmpPath, { allowArray });
+  } finally {
+    try {
+      unlinkSync(tmpPath);
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      console.warn(`@zntc/core: failed to remove tmp ${kind} ${tmpPath}: ${reason}`);
+    }
+  }
+}
+async function importAndResolveDefault(absPath, options) {
+  const allowArray = options?.allowArray === true;
+  const url = pathToFileURL(absPath).href;
+  let mod;
+  try {
+    mod = await import(url);
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ERR_MODULE_NOT_FOUND" || code === "ENOENT") {
+      throw new Error(`@zntc/core: module not found: ${absPath}`);
+    }
+    throw err;
+  }
+  const value = mod.default ?? mod;
+  const valueType = typeof value;
+  const isArray = Array.isArray(value);
+  const validObject = valueType === "object" && value !== null && (allowArray || !isArray);
+  if (valueType !== "function" && !validObject) {
+    const got = value === null ? "null" : isArray ? "array" : valueType;
+    throw new Error(`@zntc/core: module must be an object or function (got ${got}) from ${absPath}`);
+  }
+  return value;
+}
+function readFileOrThrowNotFound(absPath) {
+  try {
+    return readFileSync2(absPath, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw new Error(`@zntc/core: config file not found: ${absPath}`);
+    }
+    throw err;
+  }
+}
+function readFileIfExists(absPath) {
+  try {
+    return readFileSync2(absPath, "utf8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT" || code === "ENOTDIR")
+      return null;
+    throw err;
+  }
+}
+function findConfigPath(cwd) {
+  for (const ext of CONFIG_EXT_PRIORITY) {
+    const candidate = join(cwd, `zntc.config${ext}`);
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+function findModeConfigPath(cwd, mode) {
+  if (!mode)
+    return null;
+  for (const ext of CONFIG_EXT_PRIORITY) {
+    const candidate = join(cwd, `zntc.config.${mode}${ext}`);
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+function mergeUserConfigs(base, mode) {
+  const merged = { ...base };
+  for (const key of Object.keys(mode)) {
+    const modeVal = mode[key];
+    if (modeVal === undefined)
+      continue;
+    if (key === "plugins" && Array.isArray(modeVal) && Array.isArray(merged.plugins)) {
+      merged.plugins = [...merged.plugins, ...modeVal];
+      continue;
+    }
+    const baseVal = base[key];
+    if (typeof baseVal === "object" && baseVal !== null && !Array.isArray(baseVal) && typeof modeVal === "object" && modeVal !== null && !Array.isArray(modeVal)) {
+      merged[key] = {
+        ...baseVal,
+        ...modeVal
+      };
+      continue;
+    }
+    merged[key] = modeVal;
+  }
+  return merged;
+}
+// src/load-env.ts
+import { resolve as pathResolve2 } from "node:path";
+function parseDotenvLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#"))
+    return null;
+  const eqIdx = trimmed.indexOf("=");
+  if (eqIdx <= 0)
+    return null;
+  const key = trimmed.slice(0, eqIdx).trim();
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+    return null;
+  let value = trimmed.slice(eqIdx + 1).trim();
+  const quoted = value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'");
+  if (quoted) {
+    value = value.slice(1, -1);
+  } else {
+    value = value.replace(/\s+#.*$/, "");
+  }
+  return [key, value];
+}
+function parseDotenvFile(filePath) {
+  const content = readFileIfExists(filePath);
+  if (content === null)
+    return {};
+  const out = {};
+  for (const line of content.split(/\r?\n/)) {
+    const parsed = parseDotenvLine(line);
+    if (parsed)
+      out[parsed[0]] = parsed[1];
+  }
+  return out;
+}
+function loadEnv(mode, envDir, prefixes = ["VITE_", "ZNTC_"]) {
+  const prefixList = Array.isArray(prefixes) ? prefixes : [prefixes];
+  const dir = pathResolve2(envDir);
+  const files = [`.env`, `.env.local`, `.env.${mode}`, `.env.${mode}.local`];
+  const merged = {};
+  for (const file of files) {
+    Object.assign(merged, parseDotenvFile(`${dir}/${file}`));
+  }
+  const filtered = {};
+  for (const [key, value] of Object.entries(merged)) {
+    if (prefixList.some((p) => key.startsWith(p))) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+function envToDefine(env, mode, baseUrl = "/") {
+  const envObject = {
+    MODE: mode,
+    PROD: mode === "production",
+    DEV: mode !== "production",
+    SSR: false,
+    BASE_URL: baseUrl
+  };
+  for (const [key, value] of Object.entries(env))
+    envObject[key] = value;
+  const define = {
+    "import.meta.env": JSON.stringify(envObject)
+  };
+  for (const [key, value] of Object.entries(envObject)) {
+    define[`import.meta.env.${key}`] = JSON.stringify(value);
+  }
+  return define;
+}
+// src/typo-suggest.ts
+function levenshtein(a, b) {
+  if (a.length === 0)
+    return b.length;
+  if (b.length === 0)
+    return a.length;
+  const [s, l] = a.length <= b.length ? [a, b] : [b, a];
+  let prev = Array.from({ length: s.length + 1 });
+  let curr = Array.from({ length: s.length + 1 });
+  for (let i = 0;i <= s.length; i++)
+    prev[i] = i;
+  for (let i = 1;i <= l.length; i++) {
+    curr[0] = i;
+    for (let j = 1;j <= s.length; j++) {
+      const cost = l.charCodeAt(i - 1) === s.charCodeAt(j - 1) ? 0 : 1;
+      curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[s.length];
+}
+function suggestKey(unknown, known, threshold = 2) {
+  if (!unknown || known.length === 0)
+    return null;
+  const adjusted = Math.min(threshold, Math.max(1, Math.ceil(unknown.length / 3)));
+  let best = null;
+  let bestDist = adjusted + 1;
+  for (const candidate of known) {
+    const d = levenshtein(unknown, candidate);
+    if (d > adjusted)
+      continue;
+    if (d < bestDist || d === bestDist && best !== null && candidate < best) {
+      best = candidate;
+      bestDist = d;
+    }
+  }
+  return best;
+}
+function warnUnknownKeys(config, known, options = {}) {
+  const result = [];
+  const knownSet = new Set(known);
+  for (const key of Object.keys(config)) {
+    if (knownSet.has(key))
+      continue;
+    const suggestion = suggestKey(key, known);
+    result.push({ unknown: key, suggestion });
+    if (!options.silent) {
+      const where = options.sourceLabel ? ` (${options.sourceLabel})` : "";
+      const hint = suggestion ? ` — did you mean '${suggestion}'?` : "";
+      console.warn(`@zntc/core: unknown config key '${key}'${where}${hint}`);
+    }
+  }
+  return result;
+}
+var KNOWN_CONFIG_KEYS = [
+  "entryPoints",
+  "outdir",
+  "outfile",
+  "outbase",
+  "format",
+  "platform",
+  "target",
+  "browserslist",
+  "runtimePolyfills",
+  "coreJs",
+  "jsx",
+  "jsxDev",
+  "jsxFactory",
+  "jsxFragment",
+  "jsxImportSource",
+  "jsxInJs",
+  "jsxSideEffects",
+  "minify",
+  "minifyWhitespace",
+  "minifyIdentifiers",
+  "minifySyntax",
+  "sourcemap",
+  "sourcemapMode",
+  "sourcemapDebugIds",
+  "sourcesContent",
+  "sourceRoot",
+  "external",
+  "alias",
+  "define",
+  "server",
+  "loader",
+  "conditions",
+  "nodePaths",
+  "moduleSpecifierMap",
+  "resolveExtensions",
+  "mainFields",
+  "packagesExternal",
+  "preserveSymlinks",
+  "resolveSymlinkSiblings",
+  "disableHierarchicalLookup",
+  "splitting",
+  "outputExports",
+  "preserveModules",
+  "preserveModulesRoot",
+  "inlineDynamicImports",
+  "manualChunks",
+  "minChunkSize",
+  "metafile",
+  "treeShaking",
+  "shimMissingExports",
+  "keepNames",
+  "drop",
+  "dropConsole",
+  "dropDebugger",
+  "dropLabels",
+  "banner",
+  "footer",
+  "intro",
+  "outro",
+  "inject",
+  "pure",
+  "legalComments",
+  "entryNames",
+  "chunkNames",
+  "assetNames",
+  "experimentalDecorators",
+  "emitDecoratorMetadata",
+  "useDefineForClassFields",
+  "verbatimModuleSyntax",
+  "tsconfigPath",
+  "tsconfigRaw",
+  "globalName",
+  "globals",
+  "publicPath",
+  "charsetUtf8",
+  "asciiOnly",
+  "quotes",
+  "compiler",
+  "mf",
+  "flow",
+  "plugins",
+  "logLevel",
+  "logLimit",
+  "lineLimit",
+  "profile",
+  "profileFormat",
+  "profileLevel",
+  "tokenizeFormat",
+  "stopAfter",
+  "ignoreAnnotations",
+  "watchDelay",
+  "jobs",
+  "codegenTransform",
+  "extends",
+  "root",
+  "projectRoot",
+  "entry",
+  "dev",
+  "outDir",
+  "bundler",
+  "resolver",
+  "transformer",
+  "serializer",
+  "symbolicator",
+  "watchFolders"
+];
+// src/workspace.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync3 } from "node:fs";
+import { basename, join as join2, resolve as pathResolve3 } from "node:path";
+var CONFIG_EXT_PRIORITY_LOCAL = [".ts", ".mts", ".cts", ".mjs", ".js", ".cjs", ".json"];
+function defineWorkspace(input) {
+  return input;
+}
+var WORKSPACE_EXT_PRIORITY = CONFIG_EXT_PRIORITY_LOCAL;
+function findWorkspacePath(cwd) {
+  for (const ext of WORKSPACE_EXT_PRIORITY) {
+    const p = join2(cwd, `zntc.workspace${ext}`);
+    if (existsSync2(p))
+      return p;
+  }
+  return null;
+}
+async function loadWorkspace(filePath, env) {
+  const absPath = pathResolve3(filePath);
+  const raw = await loadModuleDefault(absPath, "workspace", { allowArray: true });
+  const entries = typeof raw === "function" ? await raw(env ?? defaultConfigEnv()) : raw;
+  if (!Array.isArray(entries)) {
+    const got = entries === null ? "null" : typeof entries;
+    throw new Error(`@zntc/core: workspace must export an array (got ${got}) from ${absPath}`);
+  }
+  for (let i = 0;i < entries.length; i += 1) {
+    const e = entries[i];
+    if (typeof e === "string") {
+      if (!e.length) {
+        throw new Error(`@zntc/core: workspace[${i}] is empty string in ${absPath}`);
+      }
+      continue;
+    }
+    if (!isPlainObject(e)) {
+      throw new Error(`@zntc/core: workspace[${i}] must be a string or object (got ${Array.isArray(e) ? "array" : e === null ? "null" : typeof e}) in ${absPath}`);
+    }
+    const name = e.name;
+    if (typeof name !== "string" || !name) {
+      throw new Error(`@zntc/core: workspace[${i}] inline entry requires non-empty 'name' in ${absPath}`);
+    }
+  }
+  return entries;
+}
+function identifyWorkspaceEntries(entries, rootDir) {
+  const seen = new Set;
+  const out = [];
+  const push = (w) => {
+    if (seen.has(w.cwd))
+      return;
+    seen.add(w.cwd);
+    out.push(w);
+  };
+  for (const entry of entries) {
+    if (typeof entry === "string") {
+      if (entry.includes("*")) {
+        for (const dir of expandGlob(entry, rootDir)) {
+          push({ name: detectPackageName(dir), cwd: dir, source: "glob", inlineConfig: null });
+        }
+      } else {
+        const abs = pathResolve3(rootDir, entry);
+        push({ name: detectPackageName(abs), cwd: abs, source: "path", inlineConfig: null });
+      }
+      continue;
+    }
+    const { name, ...rest } = entry;
+    push({
+      name,
+      cwd: rootDir,
+      source: "inline",
+      inlineConfig: rest
+    });
+  }
+  return out;
+}
+async function loadIdentifiedConfig(w, env) {
+  if (w.inlineConfig)
+    return w.inlineConfig;
+  const configPath = findConfigPath(w.cwd);
+  return configPath ? await loadConfig(configPath, env) : {};
+}
+function expandGlob(pattern, rootDir) {
+  if (pattern.includes("**")) {
+    throw new Error(`@zntc/core: workspace glob '**' is not supported (got '${pattern}'). Use single-level '*' patterns.`);
+  }
+  const lastSep = pattern.lastIndexOf("/");
+  if (lastSep === -1) {
+    return enumerateDirs(rootDir, pattern);
+  }
+  const dirPart = pattern.slice(0, lastSep);
+  const namePart = pattern.slice(lastSep + 1);
+  if (dirPart.includes("*")) {
+    throw new Error(`@zntc/core: workspace glob with '*' in directory part is not supported (got '${pattern}'). Use trailing-only '*'.`);
+  }
+  if (!namePart.includes("*")) {
+    return [pathResolve3(rootDir, pattern)];
+  }
+  const baseDir = pathResolve3(rootDir, dirPart);
+  return enumerateDirs(baseDir, namePart);
+}
+function enumerateDirs(baseDir, namePattern) {
+  if (!existsSync2(baseDir))
+    return [];
+  const matcher = makeStarMatcher(namePattern);
+  const out = [];
+  for (const d of readdirSync(baseDir, { withFileTypes: true })) {
+    if (!d.isDirectory())
+      continue;
+    if (d.name.startsWith("."))
+      continue;
+    if (d.name === "node_modules")
+      continue;
+    if (matcher(d.name))
+      out.push(join2(baseDir, d.name));
+  }
+  out.sort();
+  return out;
+}
+function makeStarMatcher(pattern) {
+  if (pattern === "*")
+    return () => true;
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  const re = new RegExp("^" + escaped + "$");
+  return (s) => re.test(s);
+}
+function detectPackageName(absDir) {
+  const pkgPath = join2(absDir, "package.json");
+  if (existsSync2(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+      if (typeof pkg.name === "string" && pkg.name)
+        return pkg.name;
+    } catch {}
+  }
+  return basename(absDir);
+}
+function filterWorkspaces(workspaces, filter) {
+  if (!filter)
+    return workspaces;
+  const filtered = workspaces.filter((w) => w.name === filter);
+  if (filtered.length === 0) {
+    const available = workspaces.map((w) => w.name).join(", ");
+    throw new Error(`@zntc/core: --workspace='${filter}' matched 0 entries (available: ${available || "<none>"})`);
+  }
+  return filtered;
+}
+// index.ts
+var UTF8_DECODER = new TextDecoder("utf-8");
+function attachTextGetter(file) {
+  let cachedContents;
+  let cachedText;
+  Object.defineProperty(file, "text", {
+    get() {
+      if (cachedContents !== file.contents) {
+        cachedContents = file.contents;
+        cachedText = UTF8_DECODER.decode(cachedContents);
+      }
+      return cachedText;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  return file;
+}
+function wrapOutputFiles(result) {
+  for (const file of result.outputFiles)
+    attachTextGetter(file);
+  return result;
+}
+var native = null;
+function detectLinuxLibc() {
+  if (process.platform !== "linux")
+    return;
+  try {
+    const report = process.report?.getReport();
+    if (report?.header?.glibcVersionRuntime)
+      return "glibc";
+  } catch {}
+  return "musl";
+}
+function getPlatformPackage() {
+  const { platform, arch } = process;
+  const libc = detectLinuxLibc();
+  const match = PLATFORMS.find((p) => p.npmOs === platform && p.npmCpu === arch && p.npmLibc === libc);
+  return match ? subPackageName(match) : null;
+}
+function findAddon() {
+  const __dirname2 = dirname3(fileURLToPath(import.meta.url));
+  const platformPkg = getPlatformPackage();
+  const zigOut = join3(__dirname2, "../../zig-out/lib/zntc.node");
+  if (existsSync3(zigOut))
+    return zigOut;
+  const zigOut2 = join3(__dirname2, "../../../zig-out/lib/zntc.node");
+  if (existsSync3(zigOut2))
+    return zigOut2;
+  if (platformPkg) {
+    try {
+      const nodeRequire = createRequire3(import.meta.url);
+      return nodeRequire.resolve(platformPkg);
+    } catch {}
+  }
+  const local = join3(__dirname2, "zntc.node");
+  if (existsSync3(local))
+    return local;
+  const parent = join3(__dirname2, "../zntc.node");
+  if (existsSync3(parent))
+    return parent;
+  const expected = platformPkg ? ` (expected sub-package: ${platformPkg})` : "";
+  throw new Error(`@zntc/core: native binary not found for ${process.platform}-${process.arch}${expected}. ` + `Supported: ${formatSupportedPlatforms()}. ` + "For development run `zig build napi`. " + "If your platform should be supported, please open an issue.");
+}
+function defineConfig(config) {
+  return config;
+}
+function init(addonPath) {
+  if (native)
+    return;
+  const path = addonPath ?? findAddon();
+  const nodeRequire = createRequire3(import.meta.url);
+  native = nodeRequire(path);
+}
+function ensureNative() {
+  init();
+  return native;
+}
+var _browserslist = null;
+var _browserslistResolved = false;
+function loadBrowserslist() {
+  if (_browserslistResolved)
+    return _browserslist;
+  _browserslistResolved = true;
+  try {
+    const req = createRequire3(import.meta.url);
+    const name = "browserslist";
+    _browserslist = req(name);
+  } catch {
+    _browserslist = null;
+  }
+  return _browserslist;
+}
+function resolveUnsupported(options) {
+  if (options.browserslist) {
+    const bl = loadBrowserslist();
+    if (!bl) {
+      throw new Error("@zntc/core: 'browserslist' option requires the 'browserslist' package. Install it: bun add browserslist");
+    }
+    return browserslistToUnsupported(bl(options.browserslist));
+  }
+  return options.target ? ES_TARGET_BITS[options.target] ?? 0 : 0;
+}
+
+class TsconfigCache {
+  _handle;
+  constructor() {
+    this._handle = ensureNative().createTsconfigCache();
+  }
+  clear() {
+    this._handle.clear();
+  }
+  get size() {
+    return this._handle.size();
+  }
+  [Symbol.dispose]() {
+    this._handle.clear();
+  }
+  static _unwrap(c) {
+    return c._handle;
+  }
+}
+function transpile(source, options = {}) {
+  if (!source)
+    throw new Error("@zntc/core: empty source");
+  validateTsConfigRaw(options.tsconfigRaw);
+  const optionsJson = buildOptionsJson(options, resolveUnsupported(options));
+  return ensureNative().transpile(source, options.filename ?? "input.js", optionsJson, options.cache ? TsconfigCache._unwrap(options.cache) : undefined);
+}
+function tokenize(source, options = {}) {
+  if (!source)
+    throw new Error("@zntc/core: empty source");
+  return ensureNative().tokenize(source, options.filename ?? "input.js");
+}
+function configureProfile(profile, level) {
+  ensureNative().configureProfile(profile, level);
+}
+function profileReport(format = "table") {
+  return ensureNative().profileReport(format);
+}
+function normalizePluginFailure(pluginName, hookName, thrown, fallbackFile) {
+  let message = "Plugin hook failed";
+  let file = fallbackFile ?? undefined;
+  let line;
+  let column;
+  if (typeof thrown === "string") {
+    message = thrown;
+  } else if (thrown && typeof thrown === "object") {
+    const err = thrown;
+    if (typeof err.message === "string")
+      message = err.message;
+    else if (typeof err.text === "string")
+      message = err.text;
+    else
+      message = String(thrown);
+    const loc = err.loc;
+    const fileCandidate = loc?.file ?? err.id ?? err.file ?? err.fileName;
+    if (typeof fileCandidate === "string" && fileCandidate.length > 0)
+      file = fileCandidate;
+    const lineCandidate = loc?.line ?? err.line ?? err.lineNumber;
+    const columnCandidate = loc?.column ?? err.column ?? err.columnNumber;
+    if (typeof lineCandidate === "number" && Number.isFinite(lineCandidate))
+      line = lineCandidate;
+    if (typeof columnCandidate === "number" && Number.isFinite(columnCandidate)) {
+      column = columnCandidate;
+    }
+  } else if (thrown != null) {
+    message = String(thrown);
+  }
+  return {
+    __zntcPluginFailure: true,
+    pluginName,
+    hookName,
+    message,
+    ...file ? { file } : {},
+    ...line !== undefined ? { line } : {},
+    ...column !== undefined ? { column } : {}
+  };
+}
+function pluginFailureText(failure) {
+  const location = failure.file && failure.line !== undefined ? ` (${failure.file}:${failure.line}:${failure.column ?? 0})` : failure.file ? ` (${failure.file})` : "";
+  return `Plugin "${failure.pluginName}" failed in ${failure.hookName}: ${failure.message}${location}`;
+}
+function pluginFailureToDiagnostic(failure) {
+  return {
+    code: "plugin_error",
+    text: pluginFailureText(failure),
+    ...failure.file ? { location: { file: failure.file, line: failure.line, column: failure.column } } : {}
+  };
+}
+function serializePluginSourceMap(map) {
+  if (map == null)
+    return null;
+  if (typeof map === "string") {
+    try {
+      JSON.parse(map);
+    } catch (err) {
+      throw new Error(`Invalid sourcemap: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return map;
+  }
+  if (typeof map !== "object") {
+    throw new Error(`Invalid sourcemap: expected object, string, null, or undefined`);
+  }
+  try {
+    return JSON.stringify(map);
+  } catch (err) {
+    throw new Error(`Invalid sourcemap: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function isPromiseLike(value) {
+  return value != null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function silenceUnsupportedSyncPromise(value) {
+  Promise.resolve(value).catch(() => {});
+}
+function syncPluginPromiseFailure(pluginName, hookName, file) {
+  return normalizePluginFailure(pluginName, hookName, new Error("buildSync() does not support async plugin hooks. Return a synchronous value or use build() instead."), file);
+}
+function isPluginFailureResult(value) {
+  return Boolean(value && typeof value === "object" && value.__zntcPluginFailure === true);
+}
+function safeSerializeSourceMap(map) {
+  try {
+    return { ok: true, map: serializePluginSourceMap(map) };
+  } catch (err) {
+    return { ok: false, err };
+  }
+}
+function mapMaybePromise(value, mapper) {
+  if (isPromiseLike(value))
+    return Promise.resolve(value).then(mapper);
+  return mapper(value);
+}
+function collectPluginRegistry(plugins) {
+  const registry = {
+    hooks: {
+      resolveId: [],
+      load: [],
+      transform: [],
+      renderChunk: [],
+      resolveContext: []
+    },
+    generateBundleCallbacks: [],
+    buildStartCallbacks: [],
+    buildEndCallbacks: [],
+    closeBundleCallbacks: [],
+    astFunctionHooks: [],
+    lifecycleFailures: []
+  };
+  for (const plugin of plugins) {
+    const build = {
+      onResolve(opts, cb) {
+        registry.hooks.resolveId.push({
+          pluginName: plugin.name,
+          filter: opts.filter,
+          callback: cb
+        });
+      },
+      onLoad(opts, cb) {
+        registry.hooks.load.push({ pluginName: plugin.name, filter: opts.filter, callback: cb });
+      },
+      onTransform(opts, cb) {
+        registry.hooks.transform.push({
+          pluginName: plugin.name,
+          filter: opts.filter,
+          callback: cb
+        });
+      },
+      onRenderChunk(opts, cb) {
+        registry.hooks.renderChunk.push({
+          pluginName: plugin.name,
+          filter: opts.filter,
+          callback: cb
+        });
+      },
+      onGenerateBundle(cb) {
+        registry.generateBundleCallbacks.push({ pluginName: plugin.name, callback: cb });
+      },
+      onBuildStart(cb) {
+        registry.buildStartCallbacks.push({ pluginName: plugin.name, callback: cb });
+      },
+      onBuildEnd(cb) {
+        registry.buildEndCallbacks.push({ pluginName: plugin.name, callback: cb });
+      },
+      onCloseBundle(cb) {
+        registry.closeBundleCallbacks.push({ pluginName: plugin.name, callback: cb });
+      },
+      onAstFunction(opts, cb) {
+        registry.astFunctionHooks.push({
+          pluginName: plugin.name,
+          filter: opts.filter,
+          callback: cb
+        });
+      },
+      onResolveContext(opts, cb) {
+        registry.hooks.resolveContext.push({
+          pluginName: plugin.name,
+          filter: opts.filter,
+          callback: cb
+        });
+      }
+    };
+    plugin.setup(build);
+  }
+  return registry;
+}
+var pluginArgBuilders = {
+  resolveId: (arg1, arg2) => [arg1, { path: arg1, importer: arg2 }],
+  load: (arg1, _) => [arg1, { path: arg1 }],
+  renderChunk: (arg1, arg2) => [arg2 ?? "", { code: arg1, chunk: arg2 }]
+};
+function lifecycleHookSpec(reg, hookName, arg1) {
+  switch (hookName) {
+    case "generateBundle": {
+      const outputs = arg1;
+      for (const file of outputs)
+        attachTextGetter(file);
+      return {
+        callbacks: reg.generateBundleCallbacks,
+        arg: outputs,
+        surfaceFailures: false
+      };
+    }
+    case "buildStart":
+      return { callbacks: reg.buildStartCallbacks, arg: undefined, surfaceFailures: false };
+    case "buildEnd": {
+      const msg = arg1;
+      return {
+        callbacks: reg.buildEndCallbacks,
+        arg: msg && msg.length > 0 ? new Error(msg) : undefined,
+        surfaceFailures: true
+      };
+    }
+    case "closeBundle":
+      return { callbacks: reg.closeBundleCallbacks, arg: undefined, surfaceFailures: true };
+    default:
+      return null;
+  }
+}
+function* dispatchHook(reg, hookName, arg1, arg2) {
+  if (hookName === "astFunction") {
+    if (reg.astFunctionHooks.length === 0)
+      return null;
+    let info;
+    try {
+      info = JSON.parse(arg1);
+    } catch {
+      return null;
+    }
+    for (const h of reg.astFunctionHooks) {
+      if (!h.filter.test(info.sourcePath))
+        continue;
+      const result = yield {
+        callback: () => h.callback(info),
+        pluginName: h.pluginName,
+        hookName: "astFunction",
+        fallbackFile: info.sourcePath
+      };
+      if (isPluginFailureResult(result))
+        return result;
+      if (result != null)
+        return result;
+    }
+    return null;
+  }
+  if (hookName === "resolveContext") {
+    if (reg.hooks.resolveContext.length === 0)
+      return null;
+    let args;
+    try {
+      args = JSON.parse(arg1);
+    } catch {
+      return null;
+    }
+    for (const h of reg.hooks.resolveContext) {
+      if (!h.filter.test(args.dir))
+        continue;
+      const result = yield {
+        callback: () => h.callback(args),
+        pluginName: h.pluginName,
+        hookName: "resolveContext",
+        fallbackFile: args.importer
+      };
+      if (isPluginFailureResult(result))
+        return result;
+      if (result != null)
+        return result;
+    }
+    return null;
+  }
+  {
+    const spec = lifecycleHookSpec(reg, hookName, arg1);
+    if (spec) {
+      let firstFailure = null;
+      for (const { pluginName, callback } of spec.callbacks) {
+        const result = yield {
+          callback: () => callback(spec.arg),
+          pluginName,
+          hookName
+        };
+        if (isPluginFailureResult(result) && firstFailure == null)
+          firstFailure = result;
+      }
+      if (spec.surfaceFailures) {
+        if (firstFailure)
+          reg.lifecycleFailures.push(firstFailure);
+        return null;
+      }
+      return firstFailure;
+    }
+  }
+  if (hookName === "transform" || hookName === "renderChunk") {
+    const hookList2 = reg.hooks[hookName];
+    if (!hookList2)
+      return null;
+    let currentCode = arg1;
+    let changed = false;
+    const sourceMaps = [];
+    for (const h of hookList2) {
+      if (!h.filter.test(arg2 ?? ""))
+        continue;
+      const cbArgs2 = hookName === "transform" ? { code: currentCode, path: arg2 } : { code: currentCode, chunk: arg2 };
+      const result = yield {
+        callback: () => h.callback(cbArgs2),
+        pluginName: h.pluginName,
+        hookName,
+        fallbackFile: arg2
+      };
+      if (isPluginFailureResult(result))
+        return result;
+      if (result != null) {
+        const obj = result;
+        const newCode = typeof result === "string" ? result : obj.code;
+        if (typeof newCode === "string") {
+          currentCode = newCode;
+          changed = true;
+        }
+        if (hookName === "transform" && typeof result === "object" && "map" in obj) {
+          const r = safeSerializeSourceMap(obj.map);
+          if (!r.ok)
+            return normalizePluginFailure(h.pluginName, hookName, r.err, arg2);
+          if (r.map != null)
+            sourceMaps.push(r.map);
+        }
+      }
+    }
+    return changed ? { code: currentCode, ...sourceMaps.length > 0 ? { maps: sourceMaps } : {} } : null;
+  }
+  const hookList = reg.hooks[hookName];
+  if (!hookList)
+    return null;
+  const buildArgs = pluginArgBuilders[hookName];
+  if (!buildArgs)
+    return null;
+  const [filterTarget, cbArgs] = buildArgs(arg1, arg2);
+  for (const h of hookList) {
+    if (!h.filter.test(filterTarget))
+      continue;
+    const fallbackFile = hookName === "resolveId" ? arg2 : filterTarget;
+    const result = yield {
+      callback: () => h.callback(cbArgs),
+      pluginName: h.pluginName,
+      hookName,
+      fallbackFile
+    };
+    if (isPluginFailureResult(result))
+      return result;
+    if (result != null) {
+      if (hookName === "load" && typeof result === "object" && "map" in result) {
+        const r = safeSerializeSourceMap(result.map);
+        if (!r.ok)
+          return normalizePluginFailure(h.pluginName, hookName, r.err, fallbackFile);
+        return { ...result, ...r.map != null ? { map: r.map } : { map: undefined } };
+      }
+      return result;
+    }
+  }
+  return null;
+}
+async function driveDispatchAsync(gen) {
+  let r = gen.next();
+  while (!r.done) {
+    const call = r.value;
+    let value;
+    try {
+      value = await call.callback();
+    } catch (err) {
+      value = normalizePluginFailure(call.pluginName, call.hookName, err, call.fallbackFile);
+    }
+    r = gen.next(value);
+  }
+  return r.value;
+}
+function driveDispatchSync(gen) {
+  let r = gen.next();
+  while (!r.done) {
+    const call = r.value;
+    let value;
+    try {
+      const raw = call.callback();
+      if (isPromiseLike(raw)) {
+        silenceUnsupportedSyncPromise(raw);
+        value = syncPluginPromiseFailure(call.pluginName, call.hookName, call.fallbackFile);
+      } else {
+        value = raw;
+      }
+    } catch (err) {
+      value = normalizePluginFailure(call.pluginName, call.hookName, err, call.fallbackFile);
+    }
+    r = gen.next(value);
+  }
+  return r.value;
+}
+function createPluginDispatcher(plugins) {
+  const reg = collectPluginRegistry(plugins);
+  const dispatcher = function dispatcher2(hookName, arg1, arg2) {
+    return driveDispatchAsync(dispatchHook(reg, hookName, arg1, arg2));
+  };
+  dispatcher.takeLifecycleFailures = () => reg.lifecycleFailures.splice(0);
+  return dispatcher;
+}
+function createSyncPluginDispatcher(plugins) {
+  const reg = collectPluginRegistry(plugins);
+  const dispatcher = function dispatcher2(hookName, arg1, arg2) {
+    return driveDispatchSync(dispatchHook(reg, hookName, arg1, arg2));
+  };
+  dispatcher.takeLifecycleFailures = () => reg.lifecycleFailures.splice(0);
+  return dispatcher;
+}
+function arrayAliasToPlugin(aliasArray) {
+  return {
+    name: "zntc:array-alias",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, (args) => {
+        for (const { find, replacement } of aliasArray) {
+          if (find instanceof RegExp) {
+            if (args.path.search(find) !== -1) {
+              return { path: args.path.replace(find, replacement) };
+            }
+          } else if (args.path === find || args.path.startsWith(find + "/")) {
+            return { path: args.path.replace(find, replacement) };
+          }
+        }
+        return null;
+      });
+    }
+  };
+}
+function resolveDispatcher(options, mode = "async") {
+  const arrayAlias = Array.isArray(options.alias) ? options.alias : null;
+  const userPlugins = options.plugins ?? [];
+  const allPlugins = arrayAlias ? [arrayAliasToPlugin(arrayAlias), ...userPlugins] : userPlugins;
+  if (allPlugins.length === 0)
+    return null;
+  return mode === "sync" ? createSyncPluginDispatcher(allPlugins) : createPluginDispatcher(allPlugins);
+}
+function isBrowserLikeBuildPlatform(platform) {
+  return platform === undefined || platform === "browser" || platform === "react-native";
+}
+function withDefaultBuildDefines(options) {
+  const define = { ...options.define };
+  const browserLike = isBrowserLikeBuildPlatform(options.platform) || options.minifySyntax === true;
+  if (browserLike && define["process.env.NODE_ENV"] === undefined) {
+    define["process.env.NODE_ENV"] = options.devMode ? '"development"' : '"production"';
+  }
+  if (options.platform === "react-native" && define.__DEV__ === undefined) {
+    define.__DEV__ = options.devMode ? "true" : "false";
+  }
+  return Object.keys(define).length > 0 ? define : undefined;
+}
+function withDefaultAppBuildDefines(options) {
+  const define = { ...options.define };
+  if (define["process.env.NODE_ENV"] === undefined) {
+    define["process.env.NODE_ENV"] = (options.mode ?? "production") === "production" ? '"production"' : '"development"';
+  }
+  return define;
+}
+function prepareNapiOptions(options) {
+  const napiOptions = { ...options };
+  const define = withDefaultBuildDefines(options);
+  if (define)
+    napiOptions.define = define;
+  delete napiOptions.write;
+  delete napiOptions.outdir;
+  delete napiOptions.plugins;
+  delete napiOptions.allowOverwrite;
+  if (Array.isArray(napiOptions.alias))
+    delete napiOptions.alias;
+  delete napiOptions.manualChunks;
+  if (options.manualChunks) {
+    napiOptions._manualChunks = options.manualChunks;
+  }
+  delete napiOptions.mf;
+  if (options.mf) {
+    napiOptions.mfRaw = JSON.stringify(options.mf);
+  }
+  if (options.blockList) {
+    napiOptions.blockList = options.blockList.map((p) => {
+      if (p instanceof RegExp)
+        return p.source;
+      if (typeof p === "string")
+        return p;
+      throw new TypeError(`blockList entries must be RegExp or string, got ${typeof p}`);
+    });
+  }
+  if (options.browserslist) {
+    napiOptions.unsupported = resolveUnsupported({ browserslist: options.browserslist });
+    delete napiOptions.browserslist;
+  }
+  if (options.target && !isEsTarget(options.target)) {
+    delete napiOptions.target;
+  }
+  delete napiOptions.compiler;
+  const sc = options.compiler?.styledComponents;
+  if (sc !== undefined && sc !== false) {
+    napiOptions.styledComponents = true;
+    if (typeof sc === "object") {
+      if (sc.ssr === false)
+        napiOptions.styledComponentsSsr = false;
+      if (sc.minify === true)
+        napiOptions.styledComponentsMinify = true;
+      if (sc.fileName === false)
+        napiOptions.styledComponentsFileName = false;
+      if (sc.pure === true)
+        napiOptions.styledComponentsPure = true;
+      if (typeof sc.namespace === "string" && sc.namespace.length > 0) {
+        napiOptions.styledComponentsNamespace = sc.namespace;
+      }
+      if (Array.isArray(sc.meaninglessFileNames)) {
+        napiOptions.styledComponentsMeaninglessFileNames = sc.meaninglessFileNames;
+      }
+      if (Array.isArray(sc.topLevelImportPaths)) {
+        napiOptions.styledComponentsTopLevelImportPaths = sc.topLevelImportPaths;
+      }
+      if (sc.cssProp === true)
+        napiOptions.styledComponentsCssProp = true;
+    }
+  }
+  const em = options.compiler?.emotion;
+  if (em !== undefined && em !== false) {
+    napiOptions.emotion = true;
+    if (typeof em === "object") {
+      if (em.autoLabel === false) {
+        napiOptions.emotionAutoLabel = "never";
+      } else if (em.autoLabel === true) {
+        napiOptions.emotionAutoLabel = "always";
+      } else if (typeof em.autoLabel === "string") {
+        napiOptions.emotionAutoLabel = em.autoLabel;
+      }
+      if (em.sourceMap === true)
+        napiOptions.emotionSourceMap = true;
+      if (typeof em.labelFormat === "string" && em.labelFormat.length > 0) {
+        napiOptions.emotionLabelFormat = em.labelFormat;
+      }
+      const extras = collectEmotionImportMapExtras(em.importMap);
+      if (extras.css.length > 0)
+        napiOptions.emotionExtraCssSources = extras.css;
+      if (extras.styled.length > 0)
+        napiOptions.emotionExtraStyledSources = extras.styled;
+    }
+  }
+  const runtimePolyfills = applyRuntimePolyfillsToNapiOptions(napiOptions, {
+    entryPoints: options.entryPoints,
+    platform: options.platform,
+    target: options.target,
+    browserslist: options.browserslist,
+    runtimePolyfills: options.runtimePolyfills,
+    coreJs: options.coreJs,
+    runBeforeMain: options.runBeforeMain,
+    resolveExtensions: options.resolveExtensions
+  });
+  return { napiOptions, cleanup: runtimePolyfills.cleanup };
+}
+var EMOTION_CSS_CANONICAL_SOURCES = new Set([
+  "@emotion/react",
+  "@emotion/css",
+  "@emotion/core",
+  "@emotion/native",
+  "@emotion/primitives",
+  "@emotion/primitives-core"
+]);
+function collectEmotionImportMapExtras(importMap) {
+  const css = new Set;
+  const styled = new Set;
+  if (!importMap)
+    return { css: [], styled: [] };
+  for (const [source, locals] of Object.entries(importMap)) {
+    for (const spec of Object.values(locals)) {
+      const [pkg, exportName] = spec.canonicalImport;
+      if (pkg === "@emotion/styled" && exportName === "default") {
+        styled.add(source);
+      } else if (EMOTION_CSS_CANONICAL_SOURCES.has(pkg)) {
+        css.add(source);
+      }
+    }
+  }
+  return { css: [...css], styled: [...styled] };
+}
+function postProcessCssOutputs(result, options) {
+  if (!options.minify)
+    return;
+  let lcss;
+  try {
+    lcss = require_node();
+  } catch {
+    return;
+  }
+  for (const file of result.outputFiles) {
+    if (!file.path.endsWith(".css"))
+      continue;
+    try {
+      const transformed = lcss.transform({
+        code: file.contents,
+        minify: true,
+        filename: file.path
+      });
+      file.contents = transformed.code;
+    } catch {}
+  }
+}
+function writeOutputFiles(result, options) {
+  const shouldWrite = options.write ?? (options.outdir != null || options.outfile != null);
+  if (!shouldWrite)
+    return;
+  if (!options.allowOverwrite && options.outfile) {
+    const outResolved = resolve2(options.outfile);
+    for (const entry of options.entryPoints) {
+      if (resolve2(entry) === outResolved) {
+        throw new Error(`@zntc/core: output file '${options.outfile}' would overwrite input file (set allowOverwrite: true to permit)`);
+      }
+    }
+  }
+  const createdDirs = new Set;
+  const outfileResolved = options.outfile ? resolve2(options.outfile) : null;
+  for (const file of result.outputFiles) {
+    let outPath;
+    if (outfileResolved && file.path === "bundle.js") {
+      outPath = outfileResolved;
+    } else if (outfileResolved && file.path.endsWith(".map")) {
+      outPath = outfileResolved + ".map";
+    } else if (options.outdir) {
+      outPath = join3(resolve2(options.outdir), file.path);
+    } else {
+      outPath = resolve2(file.path);
+    }
+    const dir = dirname3(outPath);
+    if (!createdDirs.has(dir)) {
+      mkdirSync(dir, { recursive: true });
+      createdDirs.add(dir);
+    }
+    writeFileSync2(outPath, file.contents);
+  }
+}
+async function build(options) {
+  const n = ensureNative();
+  if (!options.entryPoints?.length)
+    throw new Error("@zntc/core: entryPoints is required");
+  validateTsConfigRaw(options.tsconfigRaw);
+  if (options.output && options.output.length >= 2) {
+    return buildMultiFormat(options);
+  }
+  const { napiOptions, cleanup } = prepareNapiOptions(options);
+  const dispatcher = resolveDispatcher(options);
+  if (dispatcher)
+    napiOptions._pluginDispatcher = dispatcher;
+  try {
+    const result = wrapOutputFiles(await n.build(napiOptions));
+    if (dispatcher) {
+      for (const failure of dispatcher.takeLifecycleFailures()) {
+        result.errors.push(pluginFailureToDiagnostic(failure));
+      }
+    }
+    postProcessCssOutputs(result, options);
+    writeOutputFiles(result, options);
+    if (dispatcher) {
+      await dispatcher("closeBundle", undefined, null);
+      for (const failure of dispatcher.takeLifecycleFailures()) {
+        result.errors.push(pluginFailureToDiagnostic(failure));
+      }
+    }
+    return result;
+  } finally {
+    cleanup();
+  }
+}
+function buildSync(options) {
+  const n = ensureNative();
+  if (!options.entryPoints?.length)
+    throw new Error("@zntc/core: entryPoints is required");
+  validateTsConfigRaw(options.tsconfigRaw);
+  const { napiOptions, cleanup } = prepareNapiOptions(options);
+  const dispatcher = resolveDispatcher(options, "sync");
+  if (dispatcher)
+    napiOptions._pluginDispatcherSync = dispatcher;
+  try {
+    const result = wrapOutputFiles(n.buildSync(napiOptions));
+    if (dispatcher) {
+      for (const failure of dispatcher.takeLifecycleFailures()) {
+        result.errors.push(pluginFailureToDiagnostic(failure));
+      }
+    }
+    postProcessCssOutputs(result, options);
+    writeOutputFiles(result, options);
+    if (dispatcher) {
+      dispatcher("closeBundle", undefined, null);
+      for (const failure of dispatcher.takeLifecycleFailures()) {
+        result.errors.push(pluginFailureToDiagnostic(failure));
+      }
+    }
+    return result;
+  } finally {
+    cleanup();
+  }
+}
+
+class BuildInstance {
+  #base;
+  #closed = false;
+  constructor(base) {
+    this.#base = base;
+  }
+  get closed() {
+    return this.#closed;
+  }
+  async write(output = {}) {
+    this.#assertOpen();
+    return build(mergeOutput(this.#base, output));
+  }
+  async generate(output = {}) {
+    this.#assertOpen();
+    return build({ ...mergeOutput(this.#base, output), write: false });
+  }
+  async close() {
+    this.#closed = true;
+  }
+  #assertOpen() {
+    if (this.#closed)
+      throw new Error("@zntc/core: BuildInstance is closed");
+  }
+}
+function mergeOutput(base, out) {
+  const merged = { ...base };
+  if (out.format !== undefined)
+    merged.format = out.format;
+  if (out.dir !== undefined)
+    merged.outdir = out.dir;
+  if (out.file !== undefined)
+    merged.outfile = out.file;
+  if (out.globals !== undefined)
+    merged.globals = out.globals;
+  return merged;
+}
+async function zntc(options) {
+  if (!options.entryPoints?.length)
+    throw new Error("@zntc/core: entryPoints is required");
+  validateTsConfigRaw(options.tsconfigRaw);
+  return new BuildInstance(options);
+}
+async function buildMultiFormat(options) {
+  const outputs = options.output;
+  const { output: _omit, ...baseOpts } = options;
+  const aggregated = {
+    outputFiles: [],
+    errors: [],
+    warnings: [],
+    outputsByFormat: []
+  };
+  for (const cfg of outputs) {
+    const r = await build(mergeOutput(baseOpts, cfg));
+    aggregated.errors.push(...r.errors);
+    aggregated.warnings.push(...r.warnings);
+    aggregated.outputsByFormat.push({
+      format: cfg.format ?? "esm",
+      outputFiles: r.outputFiles
+    });
+  }
+  if (aggregated.outputsByFormat.length > 0) {
+    aggregated.outputFiles = aggregated.outputsByFormat[0].outputFiles;
+  }
+  return aggregated;
+}
+function buildAppSync(options = {}) {
+  const n = ensureNative();
+  const { publicDir, compiler, ...rest } = options;
+  return wrapOutputFiles(n.buildAppSync({
+    ...rest,
+    define: withDefaultAppBuildDefines(options),
+    ...publicDir === false ? { disablePublicDir: true } : publicDir !== undefined ? { publicDir } : {},
+    ...buildCompilerNapiFields(compiler)
+  }));
+}
+function buildCompilerNapiFields(compiler) {
+  const out = {};
+  const sc = compiler?.styledComponents;
+  if (sc !== undefined && sc !== false)
+    out.styledComponents = true;
+  if (typeof sc === "object") {
+    if (sc.ssr === false)
+      out.styledComponentsSsr = false;
+    if (sc.minify === true)
+      out.styledComponentsMinify = true;
+    if (sc.fileName === false)
+      out.styledComponentsFileName = false;
+    if (sc.pure === true)
+      out.styledComponentsPure = true;
+    if (typeof sc.namespace === "string" && sc.namespace.length > 0) {
+      out.styledComponentsNamespace = sc.namespace;
+    }
+    if (Array.isArray(sc.meaninglessFileNames)) {
+      out.styledComponentsMeaninglessFileNames = sc.meaninglessFileNames;
+    }
+    if (Array.isArray(sc.topLevelImportPaths)) {
+      out.styledComponentsTopLevelImportPaths = sc.topLevelImportPaths;
+    }
+    if (sc.cssProp === true)
+      out.styledComponentsCssProp = true;
+  }
+  const em = compiler?.emotion;
+  if (em !== undefined && em !== false)
+    out.emotion = true;
+  if (typeof em === "object") {
+    if (em.autoLabel === false)
+      out.emotionAutoLabel = "never";
+    else if (em.autoLabel === true)
+      out.emotionAutoLabel = "always";
+    else if (typeof em.autoLabel === "string")
+      out.emotionAutoLabel = em.autoLabel;
+    if (em.sourceMap === true)
+      out.emotionSourceMap = true;
+    if (typeof em.labelFormat === "string" && em.labelFormat.length > 0) {
+      out.emotionLabelFormat = em.labelFormat;
+    }
+    const extras = collectEmotionImportMapExtras(em.importMap);
+    if (extras.css.length > 0)
+      out.emotionExtraCssSources = extras.css;
+    if (extras.styled.length > 0)
+      out.emotionExtraStyledSources = extras.styled;
+  }
+  return out;
+}
+function prepareAppDevSync(options = {}) {
+  const n = ensureNative();
+  const { publicDir, ...rest } = options;
+  return n.prepareAppDevSync({
+    ...rest,
+    ...publicDir === false ? { disablePublicDir: true } : publicDir !== undefined ? { publicDir } : {}
+  });
+}
+function close() {
+  native = null;
+}
+function benchmark(options) {
+  if (!options.source && !options.file) {
+    throw new Error("@zntc/core.benchmark: 'source' or 'file' is required");
+  }
+  if (!Array.isArray(options.phases) || options.phases.length === 0) {
+    throw new Error("@zntc/core.benchmark: 'phases' must be a non-empty string array");
+  }
+  return ensureNative().benchmark({
+    source: options.source,
+    file: options.file,
+    filename: options.filename ?? "input.js",
+    phases: options.phases,
+    iterations: options.iterations ?? 100,
+    warmup: options.warmup ?? 10
+  });
+}
+function extractHandler(hook) {
+  if (hook == null)
+    return;
+  if (typeof hook === "function")
+    return hook;
+  if (typeof hook === "object" && typeof hook.handler === "function") {
+    return hook.handler;
+  }
+  return;
+}
+function normalizeVitePluginSourceMap(map, onDrop) {
+  if (map == null)
+    return;
+  if (typeof map === "object") {
+    const obj = map;
+    const ver = typeof obj.version === "string" ? Number(obj.version) : obj.version;
+    if (ver !== 3) {
+      onDrop(`version=${String(obj.version)} (expected 3)`);
+      return;
+    }
+    if (!Array.isArray(obj.sources)) {
+      onDrop(`missing sources array`);
+      return;
+    }
+    if (typeof obj.mappings !== "string") {
+      onDrop(`missing mappings string`);
+      return;
+    }
+  }
+  try {
+    return serializePluginSourceMap(map) ?? undefined;
+  } catch (err) {
+    onDrop(err instanceof Error ? err.message : String(err));
+    return;
+  }
+}
+function createRollupPluginContext(pluginName) {
+  return {
+    error(error) {
+      throw error;
+    },
+    warn(message) {
+      console.warn(`@zntc/core [${pluginName}]: ${typeof message === "string" ? message : String(message)}`);
+    },
+    addWatchFile(_id) {},
+    resolve(_source, _importer, _options) {
+      throw new Error(`@zntc/core [${pluginName}]: this.resolve() is not supported by vitePlugin() adapter yet ` + `(graph mutation surface missing). Use alias config or another plugin's resolveId hook.`);
+    },
+    emitFile(_file) {
+      throw new Error(`@zntc/core [${pluginName}]: this.emitFile() is not supported by vitePlugin() adapter yet.`);
+    }
+  };
+}
+function createDropWarner(context) {
+  const seen = new Set;
+  return (reason) => {
+    if (seen.has(reason))
+      return;
+    seen.add(reason);
+    context.warn(`sourcemap dropped: ${reason}`);
+  };
+}
+function vitePlugin(rollupPlugin) {
+  return {
+    name: rollupPlugin.name,
+    setup(build2) {
+      const context = createRollupPluginContext(rollupPlugin.name);
+      const onDropSourceMap = createDropWarner(context);
+      const resolveId = extractHandler(rollupPlugin.resolveId);
+      if (resolveId) {
+        build2.onResolve({ filter: /.*/ }, (args) => {
+          const result = resolveId.call(context, args.path, args.importer);
+          return mapMaybePromise(result, (result2) => {
+            if (result2 == null)
+              return null;
+            if (typeof result2 === "string")
+              return { path: result2 };
+            if (typeof result2 === "object" && "id" in result2) {
+              return { path: result2.id, external: result2.external };
+            }
+            return null;
+          });
+        });
+      }
+      const load = extractHandler(rollupPlugin.load);
+      if (load) {
+        build2.onLoad({ filter: /.*/ }, (args) => {
+          const result = load.call(context, args.path);
+          return mapMaybePromise(result, (result2) => {
+            if (result2 == null)
+              return null;
+            if (typeof result2 === "string")
+              return { contents: result2 };
+            if (typeof result2 === "object" && "code" in result2) {
+              return {
+                contents: result2.code,
+                map: normalizeVitePluginSourceMap(result2.map, onDropSourceMap)
+              };
+            }
+            return null;
+          });
+        });
+      }
+      const transform = extractHandler(rollupPlugin.transform);
+      if (transform) {
+        build2.onTransform({ filter: /.*/ }, (args) => {
+          const result = transform.call(context, args.code, args.path);
+          return mapMaybePromise(result, (result2) => {
+            if (result2 == null)
+              return null;
+            if (typeof result2 === "string")
+              return { code: result2 };
+            if (typeof result2 === "object" && "code" in result2) {
+              return {
+                code: result2.code,
+                map: normalizeVitePluginSourceMap(result2.map, onDropSourceMap)
+              };
+            }
+            return null;
+          });
+        });
+      }
+      const renderChunk = extractHandler(rollupPlugin.renderChunk);
+      if (renderChunk) {
+        build2.onRenderChunk({ filter: /.*/ }, (args) => {
+          const result = renderChunk.call(context, args.code, args.chunk);
+          return mapMaybePromise(result, (result2) => {
+            if (result2 == null)
+              return null;
+            if (typeof result2 === "string")
+              return { code: result2 };
+            if (typeof result2 === "object" && "code" in result2) {
+              return { code: result2.code };
+            }
+            return null;
+          });
+        });
+      }
+      const generateBundle = extractHandler(rollupPlugin.generateBundle);
+      if (generateBundle) {
+        build2.onGenerateBundle((outputs) => generateBundle.call(context, outputs));
+      }
+      const buildStart = extractHandler(rollupPlugin.buildStart);
+      if (buildStart) {
+        build2.onBuildStart(() => buildStart.call(context));
+      }
+      const buildEnd = extractHandler(rollupPlugin.buildEnd);
+      if (buildEnd) {
+        build2.onBuildEnd((err) => buildEnd.call(context, err));
+      }
+      const closeBundle = extractHandler(rollupPlugin.closeBundle);
+      if (closeBundle) {
+        build2.onCloseBundle(() => closeBundle.call(context));
+      }
+    }
+  };
+}
+function watch(options) {
+  const n = ensureNative();
+  const { napiOptions: nativeOpts, cleanup } = prepareNapiOptions(options);
+  const dispatcher = resolveDispatcher(options);
+  if (dispatcher) {
+    nativeOpts._pluginDispatcher = dispatcher;
+    const dispatchCloseBundle = () => {
+      dispatcher("closeBundle", undefined, null).catch(() => {});
+    };
+    const wrapWatchCallback = (callback) => (event) => {
+      Promise.resolve().then(() => callback?.(event)).finally(dispatchCloseBundle).catch(() => {});
+    };
+    nativeOpts.onReady = wrapWatchCallback(options.onReady);
+    nativeOpts.onRebuild = wrapWatchCallback(options.onRebuild);
+  }
+  let handle;
+  try {
+    handle = n.watch(nativeOpts);
+  } catch (err) {
+    cleanup();
+    throw err;
+  }
+  return {
+    stop() {
+      try {
+        handle.stop();
+      } finally {
+        cleanup();
+      }
+    },
+    getBundleSourceMap() {
+      return handle.getBundleSourceMap();
+    },
+    getHmrSourceMap(moduleId) {
+      return handle.getHmrSourceMap(moduleId);
+    }
+  };
+}
+export {
+  zntc,
+  watch,
+  warnUnknownKeys,
+  vitePlugin,
+  validateTsConfigRaw,
+  transpile,
+  tokenize,
+  suggestKey,
+  profileReport,
+  prepareAppDevSync,
+  mergeUserConfigs,
+  loadWorkspace,
+  loadModuleDefault,
+  loadIdentifiedConfig,
+  loadEnv,
+  loadConfig,
+  isPlainObject,
+  init,
+  importAndResolveDefault,
+  identifyWorkspaceEntries,
+  findWorkspacePath,
+  findModeConfigPath,
+  findConfigPath,
+  filterWorkspaces,
+  envToDefine,
+  defineWorkspace,
+  defineConfig,
+  defaultConfigEnv,
+  configureProfile,
+  close,
+  buildSync,
+  buildAppSync,
+  build,
+  benchmark,
+  WORKSPACE_EXT_PRIORITY,
+  TsconfigCache,
+  KNOWN_CONFIG_KEYS,
+  BuildInstance
+};