@boba-cli/machine 0.1.0-alpha.1

package/dist/node/index.cjs

@@ -0,0 +1,827 @@
+'use strict';
+
+var module$1 = require('module');
+var process = require('process');
+var promises = require('fs/promises');
+var os = require('os');
+var nodePath = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var process__default = /*#__PURE__*/_interopDefault(process);
+var nodePath__namespace = /*#__PURE__*/_interopNamespace(nodePath);
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// ../../node_modules/.pnpm/tsup@8.5.1_@microsoft+api-extractor@7.55.2_@types+node@24.10.2__jiti@2.6.1_postcss@8.5._cc73ec3ff2d01f4687d3b65cbe1abb84/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/style/index.ts
+var ESC = "\x1B[";
+var CODES = {
+  // Modifiers (open, close)
+  bold: ["1", "22"],
+  dim: ["2", "22"],
+  italic: ["3", "23"],
+  underline: ["4", "24"],
+  inverse: ["7", "27"],
+  hidden: ["8", "28"],
+  strikethrough: ["9", "29"],
+  // Basic foreground colors (30-37)
+  black: ["30", "39"],
+  red: ["31", "39"],
+  green: ["32", "39"],
+  yellow: ["33", "39"],
+  blue: ["34", "39"],
+  magenta: ["35", "39"],
+  cyan: ["36", "39"],
+  white: ["37", "39"],
+  // Bright foreground colors (90-97)
+  blackBright: ["90", "39"],
+  redBright: ["91", "39"],
+  greenBright: ["92", "39"],
+  yellowBright: ["93", "39"],
+  blueBright: ["94", "39"],
+  magentaBright: ["95", "39"],
+  cyanBright: ["96", "39"],
+  whiteBright: ["97", "39"],
+  // Basic background colors (40-47)
+  bgBlack: ["40", "49"],
+  bgRed: ["41", "49"],
+  bgGreen: ["42", "49"],
+  bgYellow: ["43", "49"],
+  bgBlue: ["44", "49"],
+  bgMagenta: ["45", "49"],
+  bgCyan: ["46", "49"],
+  bgWhite: ["47", "49"],
+  // Bright background colors (100-107)
+  bgBlackBright: ["100", "49"],
+  bgRedBright: ["101", "49"],
+  bgGreenBright: ["102", "49"],
+  bgYellowBright: ["103", "49"],
+  bgBlueBright: ["104", "49"],
+  bgMagentaBright: ["105", "49"],
+  bgCyanBright: ["106", "49"],
+  bgWhiteBright: ["107", "49"]
+};
+function applyStyle(text, open, close) {
+  const openSeq = `${ESC}${open}m`;
+  const closeSeq = `${ESC}${close}m`;
+  const replaced = text.replace(
+    new RegExp(closeSeq.replace(/[[\](){}|^$+*?.\\]/g, "\\$&"), "g"),
+    closeSeq + openSeq
+  );
+  return openSeq + replaced + closeSeq;
+}
+function hexToRgb(hex) {
+  const clean = hex.replace(/^#/, "");
+  const num = parseInt(clean, 16);
+  if (clean.length === 3) {
+    const r2 = (num >> 8 & 15) * 17;
+    const g2 = (num >> 4 & 15) * 17;
+    const b2 = (num & 15) * 17;
+    return [r2, g2, b2];
+  }
+  const r = num >> 16 & 255;
+  const g = num >> 8 & 255;
+  const b = num & 255;
+  return [r, g, b];
+}
+function createStyle(colorSupport) {
+  const enabled = colorSupport.level > 0;
+  function build(stack) {
+    const fn = (text) => {
+      if (!enabled || stack.length === 0) {
+        return text;
+      }
+      let result = text;
+      for (let i = stack.length - 1; i >= 0; i--) {
+        const [open, close] = stack[i];
+        result = applyStyle(result, open, close);
+      }
+      return result;
+    };
+    const codeNames = Object.keys(CODES);
+    for (const name of codeNames) {
+      const [open, close] = CODES[name];
+      Object.defineProperty(fn, name, {
+        get() {
+          return build([...stack, [open, close]]);
+        }
+      });
+    }
+    Object.defineProperty(fn, "gray", {
+      get() {
+        const [open, close] = CODES.blackBright;
+        return build([...stack, [open, close]]);
+      }
+    });
+    Object.defineProperty(fn, "grey", {
+      get() {
+        const [open, close] = CODES.blackBright;
+        return build([...stack, [open, close]]);
+      }
+    });
+    Object.defineProperty(fn, "hex", {
+      value: (color) => {
+        if (!enabled || !colorSupport.has16m) {
+          return build(stack);
+        }
+        const [r, g, b] = hexToRgb(color);
+        return build([...stack, [`38;2;${r};${g};${b}`, "39"]]);
+      },
+      writable: true
+    });
+    Object.defineProperty(fn, "rgb", {
+      value: (r, g, b) => {
+        if (!enabled || !colorSupport.has16m) {
+          return build(stack);
+        }
+        return build([...stack, [`38;2;${r};${g};${b}`, "39"]]);
+      },
+      writable: true
+    });
+    Object.defineProperty(fn, "bgHex", {
+      value: (color) => {
+        if (!enabled || !colorSupport.has16m) {
+          return build(stack);
+        }
+        const [r, g, b] = hexToRgb(color);
+        return build([...stack, [`48;2;${r};${g};${b}`, "49"]]);
+      },
+      writable: true
+    });
+    Object.defineProperty(fn, "bgRgb", {
+      value: (r, g, b) => {
+        if (!enabled || !colorSupport.has16m) {
+          return build(stack);
+        }
+        return build([...stack, [`48;2;${r};${g};${b}`, "49"]]);
+      },
+      writable: true
+    });
+    Object.defineProperty(fn, "ansi256", {
+      value: (code) => {
+        if (!enabled || !colorSupport.has256) {
+          return build(stack);
+        }
+        return build([...stack, [`38;5;${code}`, "39"]]);
+      },
+      writable: true
+    });
+    Object.defineProperty(fn, "bgAnsi256", {
+      value: (code) => {
+        if (!enabled || !colorSupport.has256) {
+          return build(stack);
+        }
+        return build([...stack, [`48;5;${code}`, "49"]]);
+      },
+      writable: true
+    });
+    return fn;
+  }
+  return build([]);
+}
+
+// src/node/archive.ts
+var NodeArchiveAdapter = class {
+  hasArchiver;
+  hasUnzipper;
+  /**
+   * Create a new Node.js archive adapter.
+   * Checks for availability of archiver and unzipper packages.
+   */
+  constructor() {
+    this.hasArchiver = this.checkPackageAvailability("archiver");
+    this.hasUnzipper = this.checkPackageAvailability("unzipper");
+  }
+  /**
+   * Check if a package is available.
+   * @param packageName - Package to check
+   * @returns True if package can be imported
+   */
+  checkPackageAvailability(packageName) {
+    try {
+      __require.resolve(packageName);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if archive operations are available.
+   * @returns True if both archiver and unzipper are available
+   */
+  isAvailable() {
+    return this.hasArchiver && this.hasUnzipper;
+  }
+  /**
+   * Create a zip archive from a directory.
+   * @param sourceDir - Source directory to archive
+   * @param destPath - Destination path for the zip file
+   * @throws Error if archiver is not available or archiving fails
+   */
+  async zip(sourceDir, destPath) {
+    if (!this.hasArchiver) {
+      throw new Error(
+        "Archive operations not available: archiver package not found. Install with: pnpm add archiver"
+      );
+    }
+    const archiver = await import('archiver');
+    const { createWriteStream } = await import('fs');
+    const { stat: stat2 } = await import('fs/promises');
+    const path = await import('path');
+    return new Promise((resolve2, reject) => {
+      const outputStream = createWriteStream(destPath);
+      const archive = archiver.default("zip", { zlib: { level: 9 } });
+      outputStream.on("close", () => {
+        resolve2();
+      });
+      archive.on("error", (err) => {
+        reject(err);
+      });
+      archive.pipe(outputStream);
+      stat2(sourceDir).then((stats) => {
+        if (stats.isDirectory()) {
+          archive.directory(sourceDir, false);
+        } else {
+          archive.file(sourceDir, { name: path.basename(sourceDir) });
+        }
+        void archive.finalize();
+      }).catch((err) => {
+        reject(err);
+      });
+    });
+  }
+  /**
+   * Extract a zip archive to a directory.
+   * @param archivePath - Path to the zip file
+   * @param destDir - Destination directory for extraction
+   * @throws Error if unzipper is not available or extraction fails
+   */
+  async unzip(archivePath, destDir) {
+    if (!this.hasUnzipper) {
+      throw new Error(
+        "Archive operations not available: unzipper package not found. Install with: pnpm add unzipper"
+      );
+    }
+    const unzipper = await import('unzipper');
+    const { createReadStream } = await import('fs');
+    return new Promise((resolve2, reject) => {
+      createReadStream(archivePath).pipe(unzipper.Extract({ path: destDir })).on("close", () => {
+        resolve2();
+      }).on("error", (err) => {
+        reject(err);
+      });
+    });
+  }
+};
+var require2 = module$1.createRequire(importMetaUrl);
+var NodeClipboardAdapter = class {
+  clipboard = null;
+  available = null;
+  /**
+   * Create a new Node.js clipboard adapter.
+   * Optionally pass a pre-loaded clipboardy module for dependency injection.
+   * @param clipboardModule - Optional pre-loaded clipboard module
+   */
+  constructor(clipboardModule) {
+    if (clipboardModule) {
+      this.clipboard = clipboardModule;
+      this.available = true;
+    }
+  }
+  async loadClipboard() {
+    if (this.available === false) {
+      return null;
+    }
+    if (this.clipboard !== null) {
+      return this.clipboard;
+    }
+    try {
+      const module = await import('clipboardy');
+      this.clipboard = module.default;
+      this.available = true;
+      return this.clipboard;
+    } catch {
+      this.available = false;
+      return null;
+    }
+  }
+  async read() {
+    const clipboard = await this.loadClipboard();
+    if (!clipboard) {
+      throw new Error(
+        "Clipboard not available. Install clipboardy: npm install clipboardy"
+      );
+    }
+    try {
+      return await clipboard.read();
+    } catch {
+      this.available = false;
+      this.clipboard = null;
+      throw new Error(
+        "Clipboard not available. Install clipboardy: npm install clipboardy"
+      );
+    }
+  }
+  async write(text) {
+    const clipboard = await this.loadClipboard();
+    if (!clipboard) {
+      throw new Error(
+        "Clipboard not available. Install clipboardy: npm install clipboardy"
+      );
+    }
+    try {
+      await clipboard.write(text);
+    } catch {
+      this.available = false;
+      this.clipboard = null;
+      throw new Error(
+        "Clipboard not available. Install clipboardy: npm install clipboardy"
+      );
+    }
+  }
+  isAvailable() {
+    if (this.available !== null) {
+      return this.available;
+    }
+    try {
+      require2.resolve("clipboardy");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+var require3 = module$1.createRequire(importMetaUrl);
+var NodeEnvironmentAdapter = class {
+  supportsColorModule = null;
+  colorSupportCached = null;
+  backgroundCached = null;
+  /**
+   * Create a new Node.js environment adapter.
+   * Optionally pass a pre-loaded supports-color module for dependency injection.
+   * @param supportsColor - Optional pre-loaded supports-color module
+   */
+  constructor(supportsColor) {
+    if (supportsColor) {
+      this.supportsColorModule = supportsColor;
+    }
+  }
+  get(name) {
+    return process__default.default.env[name];
+  }
+  getColorSupport() {
+    if (this.colorSupportCached) {
+      return this.colorSupportCached;
+    }
+    const support = this.detectColorSupport();
+    this.colorSupportCached = support;
+    return support;
+  }
+  detectColorSupport() {
+    const module = this.loadSupportsColor();
+    if (module) {
+      const stdout = module.stdout;
+      if (stdout && typeof stdout.level === "number") {
+        const level = stdout.level;
+        return {
+          level,
+          hasBasic: level >= 1,
+          has256: level >= 2,
+          has16m: level >= 3
+        };
+      }
+    }
+    return this.detectColorSupportFromEnv();
+  }
+  loadSupportsColor() {
+    if (this.supportsColorModule !== null) {
+      return this.supportsColorModule;
+    }
+    try {
+      const module = require3("supports-color");
+      this.supportsColorModule = module;
+      return module;
+    } catch {
+      return null;
+    }
+  }
+  detectColorSupportFromEnv() {
+    const colorTerm = process__default.default.env.COLORTERM?.toLowerCase();
+    if (colorTerm === "truecolor" || colorTerm === "24bit") {
+      return { level: 3, hasBasic: true, has256: true, has16m: true };
+    }
+    const term = process__default.default.env.TERM?.toLowerCase() ?? "";
+    if (term.includes("256color") || term.includes("256-color")) {
+      return { level: 2, hasBasic: true, has256: true, has16m: false };
+    }
+    if (term.includes("color") || term.includes("ansi") || term.includes("xterm") || term.includes("vt100") || term.includes("screen") || term.includes("linux")) {
+      return { level: 1, hasBasic: true, has256: false, has16m: false };
+    }
+    if (process__default.default.env.CI) {
+      return { level: 1, hasBasic: true, has256: false, has16m: false };
+    }
+    if (process__default.default.stdout?.isTTY) {
+      return { level: 1, hasBasic: true, has256: false, has16m: false };
+    }
+    return { level: 0, hasBasic: false, has256: false, has16m: false };
+  }
+  getTerminalBackground() {
+    if (this.backgroundCached) {
+      return this.backgroundCached;
+    }
+    const background = this.detectTerminalBackground();
+    this.backgroundCached = background;
+    return background;
+  }
+  detectTerminalBackground() {
+    const colorFgBg = process__default.default.env.COLORFGBG;
+    if (colorFgBg) {
+      const parts = colorFgBg.split(";");
+      const bg = parseInt(parts[parts.length - 1] ?? "", 10);
+      if (!isNaN(bg)) {
+        return bg < 7 || bg >= 8 && bg < 16 && bg !== 15 ? "dark" : "light";
+      }
+    }
+    const termBackground = process__default.default.env.TERM_BACKGROUND?.toLowerCase();
+    if (termBackground === "dark" || termBackground === "light") {
+      return termBackground;
+    }
+    const termProgram = process__default.default.env.TERM_PROGRAM ?? "";
+    if (/iTerm/i.test(termProgram)) {
+      return "dark";
+    }
+    if (process__default.default.env.TERM_PROGRAM === "vscode") {
+      return "dark";
+    }
+    return "unknown";
+  }
+};
+var NodeDirectoryEntry = class {
+  name;
+  _isDirectory;
+  _isFile;
+  _isSymbolicLink;
+  constructor(name, isDirectory, isFile, isSymbolicLink) {
+    this.name = name;
+    this._isDirectory = isDirectory;
+    this._isFile = isFile;
+    this._isSymbolicLink = isSymbolicLink;
+  }
+  isDirectory() {
+    return this._isDirectory;
+  }
+  isFile() {
+    return this._isFile;
+  }
+  isSymbolicLink() {
+    return this._isSymbolicLink;
+  }
+};
+var NodeFileSystemAdapter = class {
+  async readdir(path, options) {
+    if (options?.withFileTypes) {
+      const entries = await promises.readdir(path, { withFileTypes: true });
+      return entries.map(
+        (entry) => new NodeDirectoryEntry(
+          entry.name,
+          entry.isDirectory(),
+          entry.isFile(),
+          entry.isSymbolicLink()
+        )
+      );
+    }
+    return promises.readdir(path);
+  }
+  async stat(path) {
+    const stats = await promises.stat(path);
+    return {
+      size: stats.size,
+      mode: stats.mode,
+      mtime: stats.mtime,
+      isDirectory: stats.isDirectory(),
+      isFile: stats.isFile(),
+      isSymbolicLink: stats.isSymbolicLink()
+    };
+  }
+  async readFile(path, encoding) {
+    return promises.readFile(path, { encoding: encoding ?? "utf-8" });
+  }
+  async writeFile(path, content) {
+    await promises.writeFile(path, content, "utf-8");
+  }
+  async exists(path) {
+    try {
+      await promises.stat(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async mkdir(path, options) {
+    await promises.mkdir(path, { recursive: options?.recursive });
+  }
+  async unlink(path) {
+    await promises.unlink(path);
+  }
+  async rmdir(path, options) {
+    if (options?.recursive || options?.force) {
+      await promises.rm(path, { recursive: options.recursive ?? false, force: options.force ?? false });
+    } else {
+      await promises.rmdir(path);
+    }
+  }
+  async rename(src, dst) {
+    await promises.rename(src, dst);
+  }
+  async copyFile(src, dst) {
+    await promises.copyFile(src, dst);
+  }
+  cwd() {
+    return process__default.default.cwd();
+  }
+  homedir() {
+    return os.homedir();
+  }
+};
+var NodePathAdapter = class {
+  sep = nodePath__namespace.sep;
+  join(...segments) {
+    return nodePath__namespace.join(...segments);
+  }
+  dirname(path) {
+    return nodePath__namespace.dirname(path);
+  }
+  basename(path, ext) {
+    return nodePath__namespace.basename(path, ext);
+  }
+  extname(path) {
+    return nodePath__namespace.extname(path);
+  }
+  resolve(...segments) {
+    return nodePath__namespace.resolve(...segments);
+  }
+  isAbsolute(path) {
+    return nodePath__namespace.isAbsolute(path);
+  }
+  normalize(path) {
+    return nodePath__namespace.normalize(path);
+  }
+};
+var NodeSignalAdapter = class {
+  interruptHandlers = /* @__PURE__ */ new Set();
+  terminateHandlers = /* @__PURE__ */ new Set();
+  disposed = false;
+  handleInterrupt = () => {
+    for (const handler of this.interruptHandlers) {
+      handler();
+    }
+  };
+  handleTerminate = () => {
+    for (const handler of this.terminateHandlers) {
+      handler();
+    }
+  };
+  onInterrupt(handler) {
+    if (this.interruptHandlers.size === 0) {
+      process__default.default.on("SIGINT", this.handleInterrupt);
+    }
+    this.interruptHandlers.add(handler);
+    return {
+      dispose: () => {
+        this.interruptHandlers.delete(handler);
+        if (this.interruptHandlers.size === 0) {
+          process__default.default.off("SIGINT", this.handleInterrupt);
+        }
+      }
+    };
+  }
+  onTerminate(handler) {
+    if (this.terminateHandlers.size === 0) {
+      process__default.default.on("SIGTERM", this.handleTerminate);
+    }
+    this.terminateHandlers.add(handler);
+    return {
+      dispose: () => {
+        this.terminateHandlers.delete(handler);
+        if (this.terminateHandlers.size === 0) {
+          process__default.default.off("SIGTERM", this.handleTerminate);
+        }
+      }
+    };
+  }
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    process__default.default.off("SIGINT", this.handleInterrupt);
+    process__default.default.off("SIGTERM", this.handleTerminate);
+    this.interruptHandlers.clear();
+    this.terminateHandlers.clear();
+  }
+};
+
+// src/bytes.ts
+var encoder = new TextEncoder();
+new TextDecoder("utf-8");
+function encodeString(text) {
+  return encoder.encode(text);
+}
+
+// src/node/terminal.ts
+var NodeTerminalAdapter = class {
+  constructor(input = process__default.default.stdin, output = process__default.default.stdout) {
+    this.input = input;
+    this.output = output;
+  }
+  rawModeEnabled = false;
+  inputHandlers = /* @__PURE__ */ new Set();
+  resizeHandlers = /* @__PURE__ */ new Set();
+  disposed = false;
+  handleData = (data) => {
+    const bytes = typeof data === "string" ? encodeString(data) : new Uint8Array(data);
+    for (const handler of this.inputHandlers) {
+      handler(bytes);
+    }
+  };
+  handleResize = () => {
+    const size = this.getSize();
+    for (const handler of this.resizeHandlers) {
+      handler(size);
+    }
+  };
+  onInput(handler) {
+    if (this.inputHandlers.size === 0) {
+      this.input.on("data", this.handleData);
+      this.input.resume();
+    }
+    this.inputHandlers.add(handler);
+    return {
+      dispose: () => {
+        this.inputHandlers.delete(handler);
+        if (this.inputHandlers.size === 0) {
+          this.input.off("data", this.handleData);
+        }
+      }
+    };
+  }
+  onResize(handler) {
+    if (this.resizeHandlers.size === 0 && this.isWritableStream(this.output)) {
+      this.output.on("resize", this.handleResize);
+    }
+    this.resizeHandlers.add(handler);
+    return {
+      dispose: () => {
+        this.resizeHandlers.delete(handler);
+        if (this.resizeHandlers.size === 0 && this.isWritableStream(this.output)) {
+          this.output.off("resize", this.handleResize);
+        }
+      }
+    };
+  }
+  write(data) {
+    if (data.length === 0) {
+      return;
+    }
+    this.output.write(data);
+  }
+  getSize() {
+    const stream = this.output;
+    return {
+      columns: stream.columns ?? 80,
+      rows: stream.rows ?? 24
+    };
+  }
+  enableRawMode() {
+    const stream = this.input;
+    if (this.isTTY() && typeof stream.setRawMode === "function") {
+      stream.setRawMode(true);
+      stream.resume();
+      this.rawModeEnabled = true;
+    }
+  }
+  disableRawMode() {
+    const stream = this.input;
+    if (this.rawModeEnabled && typeof stream.setRawMode === "function") {
+      stream.setRawMode(false);
+      stream.pause();
+      this.rawModeEnabled = false;
+    }
+  }
+  isTTY() {
+    const stream = this.input;
+    return typeof stream.isTTY === "boolean" && stream.isTTY;
+  }
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    this.disableRawMode();
+    this.input.off("data", this.handleData);
+    if (this.isWritableStream(this.output)) {
+      this.output.off("resize", this.handleResize);
+    }
+    this.inputHandlers.clear();
+    this.resizeHandlers.clear();
+  }
+  isWritableStream(stream) {
+    return "on" in stream && typeof stream.on === "function";
+  }
+};
+
+// src/node/index.ts
+var NodePlatformAdapter = class {
+  terminal;
+  signals;
+  clipboard;
+  environment;
+  filesystem;
+  path;
+  archive;
+  style;
+  disposed = false;
+  disposables = [];
+  /**
+   * Create a new Node.js platform adapter.
+   * @param options - Configuration options
+   */
+  constructor(options = {}) {
+    const terminalAdapter = new NodeTerminalAdapter(
+      options.input,
+      options.output
+    );
+    const signalAdapter = new NodeSignalAdapter();
+    const clipboardAdapter = new NodeClipboardAdapter();
+    const environmentAdapter = new NodeEnvironmentAdapter();
+    const filesystemAdapter = new NodeFileSystemAdapter();
+    const pathAdapter = new NodePathAdapter();
+    const archiveAdapter = new NodeArchiveAdapter();
+    const colorSupport = environmentAdapter.getColorSupport();
+    const styleAdapter = {
+      style: createStyle(colorSupport),
+      enabled: colorSupport.level > 0,
+      level: colorSupport.level
+    };
+    this.terminal = terminalAdapter;
+    this.signals = signalAdapter;
+    this.clipboard = clipboardAdapter;
+    this.environment = environmentAdapter;
+    this.filesystem = filesystemAdapter;
+    this.path = pathAdapter;
+    this.archive = archiveAdapter;
+    this.style = styleAdapter;
+    this.disposables.push(terminalAdapter, signalAdapter);
+  }
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    for (const disposable of this.disposables) {
+      disposable.dispose();
+    }
+  }
+};
+function createNodePlatform(options = {}) {
+  return new NodePlatformAdapter(options);
+}
+
+exports.NodeArchiveAdapter = NodeArchiveAdapter;
+exports.NodeClipboardAdapter = NodeClipboardAdapter;
+exports.NodeEnvironmentAdapter = NodeEnvironmentAdapter;
+exports.NodeFileSystemAdapter = NodeFileSystemAdapter;
+exports.NodePathAdapter = NodePathAdapter;
+exports.NodePlatformAdapter = NodePlatformAdapter;
+exports.NodeSignalAdapter = NodeSignalAdapter;
+exports.NodeTerminalAdapter = NodeTerminalAdapter;
+exports.createNodePlatform = createNodePlatform;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map