shell-dsl 0.0.1 → 0.0.2

package/dist/cjs/src/errors.cjs

@@ -0,0 +1,73 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/errors.ts
+var exports_errors = {};
+__export(exports_errors, {
+  ShellError: () => ShellError,
+  ParseError: () => ParseError,
+  LexError: () => LexError
+});
+module.exports = __toCommonJS(exports_errors);
+
+class ShellError extends Error {
+  stdout;
+  stderr;
+  exitCode;
+  constructor(message, stdout, stderr, exitCode) {
+    super(message);
+    this.name = "ShellError";
+    this.stdout = stdout;
+    this.stderr = stderr;
+    this.exitCode = exitCode;
+  }
+}
+
+class LexError extends Error {
+  position;
+  line;
+  column;
+  constructor(message, position, line, column) {
+    super(`Lex error at line ${line}, column ${column}: ${message}`);
+    this.name = "LexError";
+    this.position = position;
+    this.line = line;
+    this.column = column;
+  }
+}
+
+class ParseError extends Error {
+  position;
+  constructor(message, position) {
+    super(message);
+    this.name = "ParseError";
+    this.position = position;
+  }
+}
+
+//# debugId=E975DE8E8BF5A03864756E2164756E21

package/dist/cjs/src/errors.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/errors.ts"],
+  "sourcesContent": [
+    "export class ShellError extends Error {\n  stdout: Buffer;\n  stderr: Buffer;\n  exitCode: number;\n\n  constructor(message: string, stdout: Buffer, stderr: Buffer, exitCode: number) {\n    super(message);\n    this.name = \"ShellError\";\n    this.stdout = stdout;\n    this.stderr = stderr;\n    this.exitCode = exitCode;\n  }\n}\n\nexport class LexError extends Error {\n  position: number;\n  line: number;\n  column: number;\n\n  constructor(message: string, position: number, line: number, column: number) {\n    super(`Lex error at line ${line}, column ${column}: ${message}`);\n    this.name = \"LexError\";\n    this.position = position;\n    this.line = line;\n    this.column = column;\n  }\n}\n\nexport class ParseError extends Error {\n  position?: number;\n\n  constructor(message: string, position?: number) {\n    super(message);\n    this.name = \"ParseError\";\n    this.position = position;\n  }\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAO,MAAM,mBAAmB,MAAM;AAAA,EACpC;AAAA,EACA;AAAA,EACA;AAAA,EAEA,WAAW,CAAC,SAAiB,QAAgB,QAAgB,UAAkB;AAAA,IAC7E,MAAM,OAAO;AAAA,IACb,KAAK,OAAO;AAAA,IACZ,KAAK,SAAS;AAAA,IACd,KAAK,SAAS;AAAA,IACd,KAAK,WAAW;AAAA;AAEpB;AAAA;AAEO,MAAM,iBAAiB,MAAM;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AAAA,EAEA,WAAW,CAAC,SAAiB,UAAkB,MAAc,QAAgB;AAAA,IAC3E,MAAM,qBAAqB,gBAAgB,WAAW,SAAS;AAAA,IAC/D,KAAK,OAAO;AAAA,IACZ,KAAK,WAAW;AAAA,IAChB,KAAK,OAAO;AAAA,IACZ,KAAK,SAAS;AAAA;AAElB;AAAA;AAEO,MAAM,mBAAmB,MAAM;AAAA,EACpC;AAAA,EAEA,WAAW,CAAC,SAAiB,UAAmB;AAAA,IAC9C,MAAM,OAAO;AAAA,IACb,KAAK,OAAO;AAAA,IACZ,KAAK,WAAW;AAAA;AAEpB;",
+  "debugId": "E975DE8E8BF5A03864756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/fs/index.cjs

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/fs/index.ts
+var exports_fs = {};
+__export(exports_fs, {
+  createVirtualFS: () => import_memfs_adapter.createVirtualFS
+});
+module.exports = __toCommonJS(exports_fs);
+var import_memfs_adapter = require("./memfs-adapter.cjs");
+
+//# debugId=EFC1FC4A0309E57D64756E2164756E21

package/dist/cjs/src/fs/index.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/fs/index.ts"],
+  "sourcesContent": [
+    "export { createVirtualFS } from \"./memfs-adapter.cjs\";\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAgC,IAAhC;",
+  "debugId": "EFC1FC4A0309E57D64756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/fs/memfs-adapter.cjs

@@ -0,0 +1,221 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/fs/memfs-adapter.ts
+var exports_memfs_adapter = {};
+__export(exports_memfs_adapter, {
+  createVirtualFS: () => createVirtualFS
+});
+module.exports = __toCommonJS(exports_memfs_adapter);
+var pathModule = __toESM(require("path"));
+function createVirtualFS(memfs) {
+  const { promises: fs } = memfs;
+  return {
+    async readFile(path) {
+      const content = await fs.readFile(path);
+      return Buffer.from(content);
+    },
+    async readdir(path) {
+      const entries = await fs.readdir(path);
+      return entries.map(String);
+    },
+    async stat(path) {
+      const stats = await fs.stat(path);
+      return {
+        isFile: () => stats.isFile(),
+        isDirectory: () => stats.isDirectory(),
+        size: Number(stats.size),
+        mtime: new Date(stats.mtime)
+      };
+    },
+    async exists(path) {
+      try {
+        await fs.stat(path);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async writeFile(path, data) {
+      await fs.writeFile(path, data);
+    },
+    async appendFile(path, data) {
+      await fs.appendFile(path, data);
+    },
+    async mkdir(path, opts) {
+      await fs.mkdir(path, opts);
+    },
+    async rm(path, opts) {
+      try {
+        const stats = await fs.stat(path);
+        if (stats.isDirectory()) {
+          await fs.rmdir(path, { recursive: opts?.recursive });
+        } else {
+          await fs.unlink(path);
+        }
+      } catch (err) {
+        if (!opts?.force)
+          throw err;
+      }
+    },
+    resolve(...paths) {
+      return pathModule.resolve(...paths);
+    },
+    dirname(path) {
+      return pathModule.dirname(path);
+    },
+    basename(path) {
+      return pathModule.basename(path);
+    },
+    async glob(pattern, opts) {
+      const cwd = opts?.cwd ?? "/";
+      return expandGlob(memfs, pattern, cwd);
+    }
+  };
+}
+async function expandGlob(memfs, pattern, cwd) {
+  const { promises: fs } = memfs;
+  const patterns = expandBraces(pattern);
+  const allMatches = [];
+  for (const pat of patterns) {
+    const matches = await matchPattern(fs, pat, cwd);
+    allMatches.push(...matches);
+  }
+  return [...new Set(allMatches)].sort();
+}
+function expandBraces(pattern) {
+  const braceMatch = pattern.match(/\{([^{}]+)\}/);
+  if (!braceMatch)
+    return [pattern];
+  const before = pattern.slice(0, braceMatch.index);
+  const after = pattern.slice(braceMatch.index + braceMatch[0].length);
+  const options = braceMatch[1].split(",");
+  const results = [];
+  for (const opt of options) {
+    const expanded = expandBraces(before + opt + after);
+    results.push(...expanded);
+  }
+  return results;
+}
+async function matchPattern(fs, pattern, cwd) {
+  const parts = pattern.split("/").filter((p) => p !== "");
+  const isAbsolute = pattern.startsWith("/");
+  const startDir = isAbsolute ? "/" : cwd;
+  return matchParts(fs, parts, startDir, isAbsolute);
+}
+async function matchParts(fs, parts, currentPath, isAbsolute) {
+  if (parts.length === 0) {
+    return [currentPath];
+  }
+  const [part, ...rest] = parts;
+  if (part === "**") {
+    const results = [];
+    const withoutStar = await matchParts(fs, rest, currentPath, isAbsolute);
+    results.push(...withoutStar);
+    try {
+      const entries = await fs.readdir(currentPath);
+      for (const entry of entries) {
+        const entryPath = pathModule.join(currentPath, String(entry));
+        try {
+          const stat = await fs.stat(entryPath);
+          if (stat.isDirectory()) {
+            const subMatches = await matchParts(fs, parts, entryPath, isAbsolute);
+            results.push(...subMatches);
+          }
+        } catch {}
+      }
+    } catch {}
+    return results;
+  }
+  const regex = globToRegex(part);
+  try {
+    const entries = await fs.readdir(currentPath);
+    const results = [];
+    for (const entry of entries) {
+      const entryName = String(entry);
+      if (regex.test(entryName)) {
+        const entryPath = pathModule.join(currentPath, entryName);
+        if (rest.length === 0) {
+          results.push(entryPath);
+        } else {
+          try {
+            const stat = await fs.stat(entryPath);
+            if (stat.isDirectory()) {
+              const subMatches = await matchParts(fs, rest, entryPath, isAbsolute);
+              results.push(...subMatches);
+            }
+          } catch {}
+        }
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+function globToRegex(pattern) {
+  let regex = "^";
+  for (let i = 0;i < pattern.length; i++) {
+    const char = pattern[i];
+    if (char === "*") {
+      regex += "[^/]*";
+    } else if (char === "?") {
+      regex += "[^/]";
+    } else if (char === "[") {
+      let j = i + 1;
+      let classContent = "";
+      while (j < pattern.length && pattern[j] !== "]") {
+        classContent += pattern[j];
+        j++;
+      }
+      regex += `[${classContent}]`;
+      i = j;
+    } else if (".+^${}()|\\".includes(char)) {
+      regex += "\\" + char;
+    } else {
+      regex += char;
+    }
+  }
+  regex += "$";
+  return new RegExp(regex);
+}
+
+//# debugId=141567D3FA5282DB64756E2164756E21

package/dist/cjs/src/fs/memfs-adapter.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/fs/memfs-adapter.ts"],
+  "sourcesContent": [
+    "import type { IFs } from \"memfs\";\nimport type { VirtualFS, FileStat } from \"../types.cjs\";\nimport * as pathModule from \"path\";\n\nexport function createVirtualFS(memfs: IFs): VirtualFS {\n  const { promises: fs } = memfs;\n\n  return {\n    async readFile(path: string): Promise<Buffer> {\n      const content = await fs.readFile(path);\n      return Buffer.from(content);\n    },\n\n    async readdir(path: string): Promise<string[]> {\n      const entries = await fs.readdir(path);\n      return entries.map(String);\n    },\n\n    async stat(path: string): Promise<FileStat> {\n      const stats = await fs.stat(path);\n      return {\n        isFile: () => stats.isFile(),\n        isDirectory: () => stats.isDirectory(),\n        size: Number(stats.size),\n        mtime: new Date(stats.mtime),\n      };\n    },\n\n    async exists(path: string): Promise<boolean> {\n      try {\n        await fs.stat(path);\n        return true;\n      } catch {\n        return false;\n      }\n    },\n\n    async writeFile(path: string, data: Buffer | string): Promise<void> {\n      await fs.writeFile(path, data);\n    },\n\n    async appendFile(path: string, data: Buffer | string): Promise<void> {\n      await fs.appendFile(path, data);\n    },\n\n    async mkdir(path: string, opts?: { recursive?: boolean }): Promise<void> {\n      await fs.mkdir(path, opts);\n    },\n\n    async rm(path: string, opts?: { recursive?: boolean; force?: boolean }): Promise<void> {\n      try {\n        const stats = await fs.stat(path);\n        if (stats.isDirectory()) {\n          await fs.rmdir(path, { recursive: opts?.recursive });\n        } else {\n          await fs.unlink(path);\n        }\n      } catch (err) {\n        if (!opts?.force) throw err;\n      }\n    },\n\n    resolve(...paths: string[]): string {\n      return pathModule.resolve(...paths);\n    },\n\n    dirname(path: string): string {\n      return pathModule.dirname(path);\n    },\n\n    basename(path: string): string {\n      return pathModule.basename(path);\n    },\n\n    async glob(pattern: string, opts?: { cwd?: string }): Promise<string[]> {\n      const cwd = opts?.cwd ?? \"/\";\n      return expandGlob(memfs, pattern, cwd);\n    },\n  };\n}\n\nasync function expandGlob(memfs: IFs, pattern: string, cwd: string): Promise<string[]> {\n  const { promises: fs } = memfs;\n\n  // Handle brace expansion first\n  const patterns = expandBraces(pattern);\n  const allMatches: string[] = [];\n\n  for (const pat of patterns) {\n    const matches = await matchPattern(fs, pat, cwd);\n    allMatches.push(...matches);\n  }\n\n  // Remove duplicates and sort\n  return [...new Set(allMatches)].sort();\n}\n\nfunction expandBraces(pattern: string): string[] {\n  const braceMatch = pattern.match(/\\{([^{}]+)\\}/);\n  if (!braceMatch) return [pattern];\n\n  const before = pattern.slice(0, braceMatch.index);\n  const after = pattern.slice(braceMatch.index! + braceMatch[0].length);\n  const options = braceMatch[1]!.split(\",\");\n\n  const results: string[] = [];\n  for (const opt of options) {\n    const expanded = expandBraces(before + opt + after);\n    results.push(...expanded);\n  }\n  return results;\n}\n\nasync function matchPattern(\n  fs: IFs[\"promises\"],\n  pattern: string,\n  cwd: string\n): Promise<string[]> {\n  const parts = pattern.split(\"/\").filter((p) => p !== \"\");\n  const isAbsolute = pattern.startsWith(\"/\");\n  const startDir = isAbsolute ? \"/\" : cwd;\n\n  return matchParts(fs, parts, startDir, isAbsolute);\n}\n\nasync function matchParts(\n  fs: IFs[\"promises\"],\n  parts: string[],\n  currentPath: string,\n  isAbsolute: boolean\n): Promise<string[]> {\n  if (parts.length === 0) {\n    return [currentPath];\n  }\n\n  const [part, ...rest] = parts;\n\n  // Handle ** (recursive glob)\n  if (part === \"**\") {\n    const results: string[] = [];\n\n    // Match current directory\n    const withoutStar = await matchParts(fs, rest, currentPath, isAbsolute);\n    results.push(...withoutStar);\n\n    // Recurse into subdirectories\n    try {\n      const entries = await fs.readdir(currentPath);\n      for (const entry of entries) {\n        const entryPath = pathModule.join(currentPath, String(entry));\n        try {\n          const stat = await fs.stat(entryPath);\n          if (stat.isDirectory()) {\n            const subMatches = await matchParts(fs, parts, entryPath, isAbsolute);\n            results.push(...subMatches);\n          }\n        } catch {\n          // Skip inaccessible entries\n        }\n      }\n    } catch {\n      // Directory not readable\n    }\n\n    return results;\n  }\n\n  // Handle regular glob patterns\n  const regex = globToRegex(part!);\n\n  try {\n    const entries = await fs.readdir(currentPath);\n    const results: string[] = [];\n\n    for (const entry of entries) {\n      const entryName = String(entry);\n      if (regex.test(entryName)) {\n        const entryPath = pathModule.join(currentPath, entryName);\n        if (rest.length === 0) {\n          results.push(entryPath);\n        } else {\n          try {\n            const stat = await fs.stat(entryPath);\n            if (stat.isDirectory()) {\n              const subMatches = await matchParts(fs, rest, entryPath, isAbsolute);\n              results.push(...subMatches);\n            }\n          } catch {\n            // Skip inaccessible entries\n          }\n        }\n      }\n    }\n\n    return results;\n  } catch {\n    return [];\n  }\n}\n\nfunction globToRegex(pattern: string): RegExp {\n  let regex = \"^\";\n  for (let i = 0; i < pattern.length; i++) {\n    const char = pattern[i]!;\n    if (char === \"*\") {\n      regex += \"[^/]*\";\n    } else if (char === \"?\") {\n      regex += \"[^/]\";\n    } else if (char === \"[\") {\n      // Character class\n      let j = i + 1;\n      let classContent = \"\";\n      while (j < pattern.length && pattern[j] !== \"]\") {\n        classContent += pattern[j];\n        j++;\n      }\n      regex += `[${classContent}]`;\n      i = j;\n    } else if (\".+^${}()|\\\\\".includes(char)) {\n      regex += \"\\\\\" + char;\n    } else {\n      regex += char;\n    }\n  }\n  regex += \"$\";\n  return new RegExp(regex);\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "141567D3FA5282DB64756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/index.cjs

@@ -0,0 +1,80 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  tokenToString: () => import_lexer.tokenToString,
+  parse: () => import_parser.parse,
+  lex: () => import_lexer.lex,
+  isVariableNode: () => import_parser2.isVariableNode,
+  isSubstitutionNode: () => import_parser2.isSubstitutionNode,
+  isSequenceNode: () => import_parser2.isSequenceNode,
+  isRawValue: () => import_types.isRawValue,
+  isPipelineNode: () => import_parser2.isPipelineNode,
+  isOrNode: () => import_parser2.isOrNode,
+  isLiteralNode: () => import_parser2.isLiteralNode,
+  isGlobNode: () => import_parser2.isGlobNode,
+  isConcatNode: () => import_parser2.isConcatNode,
+  isCommandNode: () => import_parser2.isCommandNode,
+  isAndNode: () => import_parser2.isAndNode,
+  escapeForInterpolation: () => import_utils.escapeForInterpolation,
+  escape: () => import_utils.escape,
+  createVirtualFS: () => import_fs.createVirtualFS,
+  createStdout: () => import_io2.createStdout,
+  createStdin: () => import_io.createStdin,
+  createStderr: () => import_io2.createStderr,
+  createShellDSL: () => import_shell_dsl.createShellDSL,
+  createPipe: () => import_io2.createPipe,
+  StdinImpl: () => import_io.StdinImpl,
+  ShellPromise: () => import_shell_promise.ShellPromise,
+  ShellError: () => import_errors.ShellError,
+  ShellDSL: () => import_shell_dsl.ShellDSL,
+  PipeBuffer: () => import_io2.PipeBuffer,
+  Parser: () => import_parser.Parser,
+  ParseError: () => import_errors.ParseError,
+  OutputCollectorImpl: () => import_io2.OutputCollectorImpl,
+  Lexer: () => import_lexer.Lexer,
+  LexError: () => import_errors.LexError,
+  Interpreter: () => import_interpreter.Interpreter
+});
+module.exports = __toCommonJS(exports_src);
+var import_shell_dsl = require("./shell-dsl.cjs");
+var import_shell_promise = require("./shell-promise.cjs");
+var import_types = require("./types.cjs");
+var import_errors = require("./errors.cjs");
+var import_lexer = require("./lexer/index.cjs");
+var import_parser = require("./parser/index.cjs");
+var import_parser2 = require("./parser/index.cjs");
+var import_interpreter = require("./interpreter/index.cjs");
+var import_fs = require("./fs/index.cjs");
+var import_io = require("./io/index.cjs");
+var import_io2 = require("./io/index.cjs");
+var import_utils = require("./utils/index.cjs");
+
+//# debugId=CA28B33C8C95E9F064756E2164756E21

package/dist/cjs/src/index.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/index.ts"],
+  "sourcesContent": [
+    "// Main class exports\nexport { ShellDSL, createShellDSL, type Program } from \"./shell-dsl.cjs\";\nexport { ShellPromise, type ShellPromiseOptions } from \"./shell-promise.cjs\";\n\n// Types\nexport type {\n  VirtualFS,\n  FileStat,\n  Command,\n  CommandContext,\n  Stdin,\n  Stdout,\n  Stderr,\n  OutputCollector,\n  ExecResult,\n  ShellConfig,\n  RawValue,\n} from \"./types.cjs\";\nexport { isRawValue } from \"./types.cjs\";\n\n// Errors\nexport { ShellError, LexError, ParseError } from \"./errors.cjs\";\n\n// Lexer\nexport { Lexer, lex, tokenToString } from \"./lexer/index.cjs\";\nexport type { Token, RedirectMode } from \"./lexer/index.cjs\";\n\n// Parser\nexport { Parser, parse } from \"./parser/index.cjs\";\nexport type {\n  ASTNode,\n  Redirect,\n  CommandNode,\n  PipelineNode,\n  AndNode,\n  OrNode,\n  SequenceNode,\n  LiteralNode,\n  VariableNode,\n  SubstitutionNode,\n  GlobNode,\n  ConcatNode,\n} from \"./parser/index.cjs\";\nexport {\n  isCommandNode,\n  isPipelineNode,\n  isAndNode,\n  isOrNode,\n  isSequenceNode,\n  isLiteralNode,\n  isVariableNode,\n  isSubstitutionNode,\n  isGlobNode,\n  isConcatNode,\n} from \"./parser/index.cjs\";\n\n// Interpreter\nexport { Interpreter, type InterpreterOptions } from \"./interpreter/index.cjs\";\n\n// Filesystem\nexport { createVirtualFS } from \"./fs/index.cjs\";\n\n// I/O\nexport { createStdin, StdinImpl } from \"./io/index.cjs\";\nexport { createStdout, createStderr, createPipe, OutputCollectorImpl, PipeBuffer } from \"./io/index.cjs\";\n\n// Utilities\nexport { escape, escapeForInterpolation } from \"./utils/index.cjs\";\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACuD,IAAvD;AACuD,IAAvD;AAgB2B,IAA3B;AAGiD,IAAjD;AAG0C,IAA1C;AAI8B,IAA9B;AA0BO,IAXP;AAcqD,IAArD;AAGgC,IAAhC;AAGuC,IAAvC;AACwF,IAAxF;AAG+C,IAA/C;",
+  "debugId": "CA28B33C8C95E9F064756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/interpreter/context.cjs

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/interpreter/context.ts
+var exports_context = {};
+__export(exports_context, {
+  createCommandContext: () => createCommandContext
+});
+module.exports = __toCommonJS(exports_context);
+function createCommandContext(options) {
+  return {
+    args: options.args,
+    stdin: options.stdin,
+    stdout: options.stdout,
+    stderr: options.stderr,
+    fs: options.fs,
+    cwd: options.cwd,
+    env: options.env
+  };
+}
+
+//# debugId=8518566EF287DE6364756E2164756E21

package/dist/cjs/src/interpreter/context.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/interpreter/context.ts"],
+  "sourcesContent": [
+    "import type { CommandContext, VirtualFS, Stdin, Stdout, Stderr } from \"../types.cjs\";\n\nexport interface ContextOptions {\n  args: string[];\n  stdin: Stdin;\n  stdout: Stdout;\n  stderr: Stderr;\n  fs: VirtualFS;\n  cwd: string;\n  env: Record<string, string>;\n}\n\nexport function createCommandContext(options: ContextOptions): CommandContext {\n  return {\n    args: options.args,\n    stdin: options.stdin,\n    stdout: options.stdout,\n    stderr: options.stderr,\n    fs: options.fs,\n    cwd: options.cwd,\n    env: options.env,\n  };\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYO,SAAS,oBAAoB,CAAC,SAAyC;AAAA,EAC5E,OAAO;AAAA,IACL,MAAM,QAAQ;AAAA,IACd,OAAO,QAAQ;AAAA,IACf,QAAQ,QAAQ;AAAA,IAChB,QAAQ,QAAQ;AAAA,IAChB,IAAI,QAAQ;AAAA,IACZ,KAAK,QAAQ;AAAA,IACb,KAAK,QAAQ;AAAA,EACf;AAAA;",
+  "debugId": "8518566EF287DE6364756E2164756E21",
+  "names": []
+}

package/dist/cjs/src/interpreter/index.cjs

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/interpreter/index.ts
+var exports_interpreter = {};
+__export(exports_interpreter, {
+  createCommandContext: () => import_context.createCommandContext,
+  Interpreter: () => import_interpreter.Interpreter
+});
+module.exports = __toCommonJS(exports_interpreter);
+var import_interpreter = require("./interpreter.cjs");
+var import_context = require("./context.cjs");
+
+//# debugId=1DFD5D0BB70402B864756E2164756E21

package/dist/cjs/src/interpreter/index.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/interpreter/index.ts"],
+  "sourcesContent": [
+    "export { Interpreter, type InterpreterOptions } from \"./interpreter.cjs\";\nexport { createCommandContext, type ContextOptions } from \"./context.cjs\";\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAqD,IAArD;AAC0D,IAA1D;",
+  "debugId": "1DFD5D0BB70402B864756E2164756E21",
+  "names": []
+}