@poe-platform/safe-bash 0.1.826 → 0.1.828

package/dist/safe-bash/command-chunks/chunk-KSCVKF7I.js

@@ -0,0 +1,604 @@
+import {
+  pythonPublicationFile
+} from "./chunk-HS2L7I4N.js";
+import {
+  PythonFailure
+} from "./chunk-TO6UNFEF.js";
+
+// packages/safe-bash-command-python/src/invocation.ts
+var PythonInvocationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PythonInvocationError";
+  }
+};
+function parsePythonInvocation(args, env) {
+  const startupArgs = [];
+  let informational = false;
+  let module;
+  scan: for (let index = 0; index < args.length; index++) {
+    const option = args[index];
+    if (option === "--" || option === "-" || !option.startsWith("-")) break;
+    if (option === "--help") {
+      informational = true;
+      break;
+    }
+    if (option === "--version") {
+      informational = true;
+      continue;
+    }
+    if (option.startsWith("--")) throw new PythonInvocationError("unsupported option " + option);
+    for (let offset = 1; offset < option.length; offset++) {
+      const flag = option[offset];
+      if (flag === "h" || flag === "?") {
+        informational = true;
+        break scan;
+      }
+      if (flag === "V") {
+        informational = true;
+        continue;
+      }
+      if ("cmWX".includes(flag)) {
+        const operand = option.slice(offset + 1) || args[++index];
+        if (operand === void 0) throw new PythonInvocationError("argument expected for -" + flag);
+        if (flag === "m" && !informational) module = { name: operand, args: args.slice(index + 1) };
+        if (flag === "c" || flag === "m") break scan;
+        if (flag === "X") {
+          const separator = operand.indexOf("=");
+          const name = separator < 0 ? operand : operand.slice(0, separator);
+          const value = separator < 0 ? void 0 : operand.slice(separator + 1);
+          let decimal = value ?? "";
+          while (decimal.length && " 	\n\r\v\f".includes(decimal[0])) decimal = decimal.slice(1);
+          if (decimal[0] === "+" || decimal[0] === "-") decimal = decimal.slice(1);
+          const digits = decimal.length > 0 && [...decimal].every((character) => character >= "0" && character <= "9");
+          const supported = name === "utf8" && (value === void 0 || value === "0" || value === "1") || (name === "dev" || name === "warn_default_encoding") && value === void 0 || name === "int_max_str_digits" && digits && Number.isSafeInteger(Number(value)) && Number(value) <= 2147483647 && (Number(value) === 0 || Number(value) >= 640);
+          if (!supported) throw new PythonInvocationError("unsupported -X option " + operand);
+          startupArgs.push("-X", operand);
+        }
+        break;
+      }
+      if (!"BEPOusISbdvqR".includes(flag)) throw new PythonInvocationError("unsupported option -" + flag);
+      startupArgs.push("-" + flag);
+    }
+  }
+  if (!informational && !startupArgs.includes("-E") && !startupArgs.includes("-I")) {
+    if (env.PYTHONINSPECT) throw new PythonInvocationError("PYTHONINSPECT requires an interactive terminal, which the shell does not expose");
+    if (env.PYTHONHOME) throw new PythonInvocationError("PYTHONHOME cannot replace the configured Pyodide runtime");
+  }
+  const runtimeEnv = { ...env };
+  delete runtimeEnv.PYTHONPATH;
+  delete runtimeEnv.PYTHONHOME;
+  delete runtimeEnv.PYTHONWARNINGS;
+  runtimeEnv.PYTHONINSPECT = "";
+  startupArgs.push("-c", "");
+  return { startupArgs, env: runtimeEnv, module };
+}
+
+// packages/safe-bash-command-python/src/package-program.generated.ts
+var pythonPackageProgramGzip = "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";
+
+// packages/safe-bash-command-python/src/package-program.ts
+var decoded;
+function loadPythonPackageProgram() {
+  return decoded ??= new Response(new Blob([Uint8Array.from(atob(pythonPackageProgramGzip), (character) => character.charCodeAt(0))]).stream().pipeThrough(new DecompressionStream("gzip"))).text();
+}
+
+// packages/safe-bash-command-python/src/native-wheel.generated.ts
+var pythonNativeWheelGzip = "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";
+
+// packages/safe-bash-command-python/src/native-wheel.ts
+var decoded2;
+function loadPythonNativeWheel() {
+  return decoded2 ??= new Response(new Blob([Uint8Array.from(atob(pythonNativeWheelGzip), (character) => character.charCodeAt(0))]).stream().pipeThrough(new DecompressionStream("gzip"))).text();
+}
+
+// packages/safe-bash-command-python/src/package-url-hash.ts
+function pythonPackageUrlHash(url) {
+  const match = /(sha1|sha224|sha384|sha256|sha512|md5)=([a-f0-9]+)/.exec(url);
+  return match ? [match[1], match[2]] : void 0;
+}
+
+// packages/safe-bash-command-python/src/provisioning-runtime.ts
+async function installPythonPackages(supplied, start, request, maxTransferBytes, installationRoot) {
+  if (!start.requirements.length && !start.uninstall && !start.bootstrap) return;
+  const runtime = supplied;
+  if (runtime.version !== "314.0.6" || !runtime._api?.packageManager || !runtime._api.lockfile_packages || typeof runtime._api.packageManager.installPackage !== "function" || typeof runtime.loadPackage !== "function" || typeof runtime.runPythonAsync !== "function") throw new PythonFailure("runtime-abi", { cause: new Error("Python package installer ABI requires Pyodide 314.0.6") });
+  let transportFailure;
+  let accepting = true;
+  let pending = Promise.resolve();
+  let installing = Promise.resolve();
+  const manager = runtime._api.packageManager;
+  const transfer = (consume) => {
+    if (!accepting) return Promise.reject(new Error("Python package transport is only available during installation"));
+    const work = pending.then(async () => {
+      if (transportFailure) throw transportFailure.error;
+      try {
+        return await consume();
+      } catch (error) {
+        transportFailure ??= { error };
+        throw error;
+      }
+    });
+    pending = work.then(() => {
+    }, () => {
+    });
+    return work;
+  };
+  const readArtifact = (operation, key, offset, length) => {
+    const failed = (error) => {
+      transportFailure ??= { error };
+      throw error;
+    };
+    try {
+      const result = request(operation, start.session, key, offset, Math.min(length, maxTransferBytes, 65536));
+      return result instanceof Promise ? result.catch(failed) : result;
+    } catch (error) {
+      return failed(error);
+    }
+  };
+  const withArtifact = (url, expected, metadata, consume) => transfer(async () => {
+    const opened = await request("package-open", start.session, url, expected, ...metadata ? [metadata] : []);
+    try {
+      return await consume(opened, (offset, length) => readArtifact("package-read", opened.key, offset, length));
+    } finally {
+      await request("package-close", start.session, opened.key);
+    }
+  });
+  const wheel = async (size, read, configuration) => {
+    const globals = ["_safe_native_wheel_read", "_safe_native_wheel_config", "_safe_extract_native_wheel", "_safe_native_wheel_index", "_safe_native_wheel_dynlib"];
+    let indexed = false;
+    try {
+      runtime.globals.set(globals[0], read);
+      runtime.globals.set(globals[4], async (path) => {
+        try {
+          await runtime._api.loadDynlib(path);
+          return "";
+        } catch (error) {
+          return String(error);
+        }
+      });
+      runtime.globals.set(globals[3], (operation, ...args) => {
+        if (operation === "start") indexed = true;
+        const failed = (error) => {
+          transportFailure ??= { error };
+          throw error;
+        };
+        try {
+          const result2 = request("package-index", start.session, operation, ...args);
+          return result2 instanceof Promise ? result2.catch(failed) : result2;
+        } catch (error) {
+          return failed(error);
+        }
+      });
+      runtime.globals.set(globals[1], JSON.stringify({ ...configuration, size }));
+      const result = JSON.parse(await runtime.runPythonAsync(await loadPythonNativeWheel()));
+      if (result && typeof result === "object" && "wheelError" in result) throw new Error(result.wheelError);
+      if (result && typeof result === "object" && "dynlibError" in result) throw new Error(result.dynlibError);
+      return result;
+    } finally {
+      try {
+        if (indexed) await request("package-index", start.session, "close");
+      } finally {
+        for (const name of globals) runtime.globals.delete(name);
+      }
+    }
+  };
+  const fetch = (url, expected, metadata) => withArtifact(url, expected, metadata, async (opened, read) => {
+    const bytes = new Uint8Array(opened.size);
+    for (let offset = 0; offset < bytes.length; ) {
+      const chunk = await read(offset, bytes.length - offset);
+      if (!Array.isArray(chunk) || chunk.length === 0 || offset + chunk.length > bytes.length) throw new Error("Invalid Python package chunk");
+      bytes.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return { bytes, headers: opened.headers };
+  });
+  manager.downloadPackage = async (metadata) => {
+    if (!accepting) throw new Error("Python package transport is only available during installation");
+    if (metadata.channel === manager.defaultChannel) {
+      const pkg = runtime._api.lockfile_packages[metadata.normalizedName];
+      if (!pkg) throw new Error(`Missing matching Pyodide package: ${metadata.normalizedName}`);
+      return { url: new URL(pkg.file_name, "https://cdn.jsdelivr.net/pyodide/v314.0.6/full/").href, expected: pkg.sha256 };
+    }
+    return { url: metadata.channel };
+  };
+  manager.installPackage = (metadata, source) => {
+    if (!accepting) return Promise.reject(new Error("Python package transport is only available during installation"));
+    const work = installing.then(async () => {
+      if (source instanceof Uint8Array) throw new Error("Expected retained Python package source");
+      const pkg = runtime._api.lockfile_packages[metadata.normalizedName] ?? metadata.packageData;
+      if (!pkg) throw new Error(`Missing matching Pyodide package: ${metadata.normalizedName}`);
+      return withArtifact(source.url, source.expected, void 0, (opened, read) => wheel(opened.size, read, {
+        filename: pkg.file_name,
+        target: pkg.install_dir ?? null,
+        metadata: { INSTALLER: "pyodide.loadPackage", PYODIDE_SOURCE: metadata.channel === manager.defaultChannel ? "pyodide" : metadata.channel }
+      }));
+    });
+    installing = work.then(() => {
+    }, () => {
+    });
+    return work;
+  };
+  const loadPackages = async (names) => {
+    const errors = [];
+    const importlib = runtime._api.importlib;
+    let invalidate = false;
+    if (installationRoot && importlib) runtime._api.importlib = { invalidate_caches() {
+      invalidate = true;
+    } };
+    try {
+      await runtime.loadPackage(names, { messageCallback() {
+      }, errorCallback(message) {
+        errors.push(message);
+      } });
+    } finally {
+      if (installationRoot && importlib) runtime._api.importlib = importlib;
+    }
+    if (invalidate) await runtime.runPythonAsync("import importlib; importlib.invalidate_caches()");
+    if (errors.length) throw new Error(errors.join("\n"));
+  };
+  const installedGlobals = [];
+  const bind = (name, value) => {
+    runtime.globals.set(name, value);
+    installedGlobals.push(name);
+  };
+  try {
+    if (installationRoot) {
+      bind("_safe_installation_root", installationRoot);
+      await runtime.runPythonAsync(`
+import sys, site, sysconfig
+from pathlib import Path
+from pyodide import _package_loader
+sys.prefix = sys.exec_prefix = _safe_installation_root
+site.PREFIXES = [sys.prefix, sys.exec_prefix]
+sysconfig._CONFIG_VARS = None
+_package_loader.SITE_PACKAGES = Path(site.getsitepackages()[0])
+_package_loader.DSO_DIR = _package_loader.SITE_PACKAGES.parents[1]
+_package_loader.TARGETS.update(site=_package_loader.SITE_PACKAGES, dynlib=_package_loader.DSO_DIR)
+_package_loader.SITE_PACKAGES.mkdir(parents=True, exist_ok=True)
+sys.path.insert(0, str(_package_loader.SITE_PACKAGES))
+`);
+    }
+    await loadPackages(["micropip", ...start.bootstrapPackages ?? []]);
+    bind("_safe_package_native", loadPackages);
+    bind("_safe_package_preloaded", (operation, name) => transfer(async () => request("package-index", start.session, "names-" + operation, ...name === void 0 ? [] : [name])));
+    bind("_safe_package_bytes", async (url, hash) => (await fetch(url, hash)).bytes);
+    bind("_safe_package_metadata", async (url) => {
+      const result = await fetch(url, void 0, "metadata");
+      return JSON.stringify({ text: new TextDecoder().decode(result.bytes), headers: Object.fromEntries(result.headers.map(([name, value]) => [name.toLowerCase(), value])) });
+    });
+    bind("_safe_package_wheel_download", async (url, expected) => withArtifact(url, expected, void 0, async (opened, read) => {
+      const hash = pythonPackageUrlHash(url);
+      if (hash) await wheel(opened.size, read, { integrity: hash });
+      return JSON.stringify(await request("package-retain", start.session, opened.key));
+    }));
+    bind("_safe_package_wheel_metadata", async (serialized) => transfer(async () => {
+      const { source, name } = JSON.parse(serialized);
+      return wheel(source.size, (offset, length) => readArtifact("package-read-retained", source.token, offset, length), { metadata_name: name });
+    }));
+    bind("_safe_package_wheel_install", async (serialized) => transfer(async () => {
+      const { source, ...configuration } = JSON.parse(serialized);
+      await wheel(source.size, (offset, length) => readArtifact("package-read-retained", source.token, offset, length), configuration);
+    }));
+    bind("_safe_package_indexes_json", JSON.stringify(start.indexUrls ?? null));
+    bind("_safe_package_constraints_json", JSON.stringify(start.constraints ?? []));
+    bind("_safe_package_requirements_json", JSON.stringify(start.requested ?? start.requirements));
+    for (const key of ["pre", "upgrade", "forceReinstall", "legacy", "noDeps"]) {
+      bind("_safe_package_" + key, !!start[key]);
+    }
+    bind("_safe_package_restore_json", JSON.stringify(start.restore ?? []));
+    const inputRecords = start.recordCount === void 0 ? start.records?.map((row) => [row[0], row[1], row[2], [...row[3]], [...row[4]], row[5] ?? null]) : void 0;
+    const recordCount = start.recordCount ?? inputRecords?.length ?? -1;
+    const publication = start.streamManifest && installationRoot && start.restore !== void 0 ? installationRoot + "/" + pythonPublicationFile : null;
+    bind("_safe_package_publication", publication);
+    const outputRecords = [], pinned = [];
+    bind("_safe_package_record", (operation, key, value, field) => transfer(async () => {
+      if (publication && (operation === "pin" || operation === "append")) throw new Error("Expected caller-file Python publication");
+      if (operation === "pin") {
+        if (typeof key !== "string") throw new Error("Invalid Python package pin");
+        const pin = JSON.parse(key);
+        if (typeof pin !== "string") throw new Error("Invalid Python package pin");
+        pinned.push(pin);
+        return null;
+      }
+      if (operation === "start") {
+        await request("package-index", start.session, "records-start");
+        return recordCount;
+      }
+      if (operation === "append") {
+        if (typeof key !== "string") throw new Error("Invalid Python package record");
+        if (start.restore !== void 0) outputRecords.push(JSON.parse(key));
+        return null;
+      }
+      if (operation === "read" || operation === "get" || operation === "field") {
+        if (operation === "field" && (!Number.isInteger(field) || field < 0 || field > 5)) throw new Error("Invalid Python package record field");
+        const offset = value ?? 0;
+        if (!Number.isSafeInteger(offset) || offset < 0) throw new Error("Invalid Python package record offset");
+        const ordinal = operation !== "read" ? await request("package-index", start.session, "records-get", key) : key;
+        if (ordinal === null) return offset === 0 ? "null" : "";
+        if (!Number.isSafeInteger(ordinal) || ordinal < 0 || ordinal >= recordCount) throw new Error("Invalid Python package record ordinal");
+        const chunk = start.recordCount === void 0 ? JSON.stringify(operation === "field" ? inputRecords[ordinal][field] ?? null : inputRecords[ordinal]).slice(offset, offset + 8192) : await request("package-record-read", start.session, ordinal, offset, ...operation === "field" ? [field] : []);
+        if (operation === "field" && chunk === false) return false;
+        if (typeof chunk !== "string" || chunk.length > 8192) throw new Error("Invalid Python package record chunk");
+        const last = chunk.charCodeAt(chunk.length - 1);
+        return last >= 55296 && last <= 56319 ? chunk.slice(0, -1) : chunk;
+      }
+      return request("package-index", start.session, "records-" + operation, ...key === void 0 ? [] : [key], ...value === void 0 ? [] : [value]);
+    }));
+    bind("_safe_package_uninstall_json", JSON.stringify(start.uninstall ?? null));
+    bind("_safe_package_emit", async (stream, message) => {
+      if (stream !== "stdout" && stream !== "stderr") throw new Error("Invalid package output stream");
+      const bytes = new TextEncoder().encode(message);
+      for (let offset = 0; offset < bytes.length; offset += maxTransferBytes) await request(stream, Array.from(bytes.subarray(offset, offset + maxTransferBytes)));
+    });
+    bind("_safe_package_line", async () => {
+      const bytes = [];
+      while (true) {
+        const chunk = await request("stdin", 1);
+        if (!chunk.length) {
+          if (!bytes.length) throw new Error("EOF when reading package confirmation");
+          break;
+        }
+        if (chunk[0] === 10) break;
+        bytes.push(chunk[0]);
+      }
+      return new TextDecoder().decode(Uint8Array.from(bytes));
+    });
+    const program = await loadPythonPackageProgram();
+    const installerFailure = await runtime.runPythonAsync(`
+import sys as _safe_install_sys
+from micropip.logging import setup_logging as _safe_install_logging
+_safe_install_handlers = [handler for handler in _safe_install_logging().logger.handlers if getattr(handler, 'stream', None) is _safe_install_sys.stdout]
+_safe_installer_failure = None
+try:
+ for handler in _safe_install_handlers: handler.setStream(_safe_install_sys.stderr)
+${program.split("\n").map((line) => " " + line).join("\n")}
+except BaseException:
+ import traceback
+ _safe_installer_failure = traceback.format_exc()
+finally:
+ for handler in _safe_install_handlers: handler.setStream(_safe_install_sys.stdout)
+_safe_installer_failure
+`);
+    if (typeof installerFailure === "string" && installerFailure) throw new Error(installerFailure);
+    await installing;
+    accepting = false;
+    await pending;
+    if (transportFailure) throw transportFailure.error;
+    if (publication) await request("package-commit-file", start.session);
+    else await request("package-commit", start.session, start.restore === void 0 ? pinned : { version: 3, installed: pinned, records: outputRecords });
+    if (start.uninstall) await runtime.runPythonAsync("await _safe_publish_uninstalled()");
+  } catch (error) {
+    await installing;
+    accepting = false;
+    await pending;
+    throw transportFailure ? transportFailure.error : error;
+  } finally {
+    await installing;
+    accepting = false;
+    await pending;
+    manager.downloadPackage = manager.installPackage = async () => {
+      throw new Error("Python package transport is only available during installation");
+    };
+    for (const name of installedGlobals) runtime.globals.delete(name);
+  }
+}
+
+// packages/safe-bash-command-python/src/execution.ts
+var pythonExecution = `
+import sys, os, json, runpy, traceback, types, warnings, textwrap, io, struct, linecache
+_safe_invocation = json.loads(_safe_invocation_json)
+os.environ.clear()
+os.environ.update(_safe_invocation['env'])
+_safe_args = list(_safe_invocation['args'])
+sys.orig_argv = [_safe_invocation.get('command', 'python')] + _safe_args
+_safe_exit = 0
+
+class _SafeOptionError(ValueError):
+ pass
+
+def _safe_system_exit(_error):
+ if isinstance(_error.code, int):
+  _status = int.__index__(_error.code)
+  _long_bound = 1 << (8 * struct.calcsize('@l') - 1)
+  status = (_status & 255) if -_long_bound <= _status < _long_bound else 255
+ else:
+  status = 0 if _error.code is None else 1
+ if _error.code is not None and not isinstance(_error.code, int):
+  print(_error.code, file=sys.stderr)
+ return status
+
+def _safe_launch():
+ args = list(_safe_args)
+ unbuffered = False
+ ignore_env = bool(sys.flags.ignore_environment)
+ safe_path = bool(sys.flags.safe_path)
+ native_warning_options = list(sys.warnoptions)
+ # Pyodide adds a bootstrap cwd entry even when CPython safe-path mode is set.
+ # Each execution mode below supplies its own entry after explicit PYTHONPATH.
+ sys.path[:] = [entry for entry in sys.path if entry != '']
+ warning_options = []
+ version_count = 0
+ options_terminated = False
+ while args and args[0].startswith('-') and args[0] != '-':
+  option = args.pop(0)
+  if option == '--':
+   options_terminated = True
+   break
+  if option in ('--help', '-h', '-?'):
+   print('usage: python [-uBEPOsSIbdvqR] [-W filter] [-X option] [-c code | -m module | file | -] [args ...]')
+   print('Dedicated Pyodide interpreter; stdin is noninteractive.')
+   print('-u: unbuffered binary output; -B: disable bytecode writes; -E: ignore PYTHON* settings')
+   print('-P: omit automatic unsafe sys.path entry; -W: Python warning filter')
+   print('-O/-OO, -S/-s/-I, -b/-bb, -d/-v/-q/-R: CPython startup flags')
+   print('-X: utf8, dev, warn_default_encoding, int_max_str_digits; interactive flags are unsupported.')
+   return
+  if option == '--version':
+   version_count += 1
+   continue
+  if option.startswith('--'):
+   raise _SafeOptionError('unsupported option ' + option)
+  index = 1
+  while index < len(option):
+   flag = option[index]
+   if flag in ('h', '?'):
+    args = ['--help']
+    break
+   if flag == 'V':
+    version_count += 1
+    index += 1
+    continue
+   if flag in ('c', 'm', 'W', 'X'):
+    operand = option[index + 1:] if index + 1 < len(option) else args.pop(0) if args else None
+    if operand is None:
+     raise _SafeOptionError('argument expected for -' + flag)
+    if flag in ('W', 'X'):
+     if flag == 'W': warning_options.append(operand)
+     break
+    args = ['-' + flag, operand] + args
+    break
+   elif flag in ('O', 'S', 's', 'I', 'b', 'd', 'v', 'q', 'R'):
+    pass # Applied by CPython startup configuration before bootstrap.
+   elif flag == 'u':
+    unbuffered = True
+   elif flag == 'B':
+    sys.dont_write_bytecode = True
+   elif flag == 'E':
+    ignore_env = True
+   elif flag == 'P':
+    safe_path = True
+   else:
+    raise _SafeOptionError('unsupported option -' + flag)
+   index += 1
+  if args and args[0] in ('-c', '-m'):
+   break
+ if version_count:
+  print('Python ' + (sys.version if version_count > 1 else sys.version.split()[0]))
+  return
+ if not ignore_env:
+  unbuffered = unbuffered or bool(os.environ.get('PYTHONUNBUFFERED'))
+  sys.dont_write_bytecode = sys.dont_write_bytecode or bool(os.environ.get('PYTHONDONTWRITEBYTECODE'))
+  safe_path = safe_path or bool(os.environ.get('PYTHONSAFEPATH'))
+  path = os.environ.get('PYTHONPATH')
+  if path:
+   sys.path[0:0] = [os.path.abspath(entry) for entry in path.split(os.pathsep)]
+  if os.environ.get('PYTHONWARNINGS'):
+   warning_options[0:0] = os.environ['PYTHONWARNINGS'].split(',')
+  encoding = os.environ.get('PYTHONIOENCODING')
+  if encoding:
+   name, separator, errors = encoding.partition(':')
+   for stream in (sys.stdin, sys.stdout):
+    stream.reconfigure(encoding=name or None, errors=(errors or 'strict'))
+   sys.stderr.reconfigure(encoding=name or None, errors='backslashreplace')
+ # CPython's -b/-bb filter follows environment and command-line -W filters.
+ byte_warning = ('error' if sys.flags.bytes_warning > 1 else 'default') + '::BytesWarning'
+ native_before = [value for value in native_warning_options if not (sys.flags.bytes_warning and value == byte_warning)]
+ warning_options = native_before + warning_options + ([byte_warning] if sys.flags.bytes_warning else [])
+ warnings._processoptions(warning_options)
+ sys.warnoptions[:] = warning_options
+ if unbuffered:
+  for name in ('stdout', 'stderr'):
+   stream = getattr(sys, name)
+   stream.flush()
+   encoding, errors = stream.encoding, stream.errors
+   binary = stream.detach()
+   raw = binary.detach() if hasattr(binary, 'detach') else binary
+   replacement = io.TextIOWrapper(raw, encoding=encoding, errors=errors, write_through=True)
+   setattr(sys, name, replacement)
+   setattr(sys, '__' + name + '__', replacement)
+ main = types.ModuleType('__main__')
+ main.__dict__.update(__package__=None, __spec__=None, __loader__=__import__('importlib.machinery', fromlist=['BuiltinImporter']).BuiltinImporter, __builtins__=__builtins__)
+ sys.modules['__main__'] = main
+ if not sys.flags.no_site:
+  sys.argv = [args[0]] + args[2:] if not options_terminated and args and args[0] in ('-c', '-m') else args or ['']
+  import site
+  site.addsitepackages(site.addusersitepackages(None), list(dict.fromkeys([_safe_runtime_mount, sys.prefix])))
+ if not options_terminated and args and args[0] == '-c':
+  sys.argv = ['-c'] + args[2:]
+  if not safe_path: sys.path.insert(0, '')
+  source = textwrap.dedent(args[1])
+  code = compile(source, '<string>', 'exec')
+  # CPython 3.14 retains -c source for both top-level and nested tracebacks.
+  linecache._register_code(code, source, '<string>')
+  exec(code, main.__dict__)
+ elif not options_terminated and args and args[0] == '-m':
+  sys.argv = args[1:]
+  if not safe_path: sys.path.insert(0, os.getcwd())
+  runpy._run_module_as_main(args[1], alter_argv=True)
+ elif not args or args[0] == '-':
+  sys.argv = (['-'] + args[1:]) if args else ['']
+  if not safe_path: sys.path.insert(0, '')
+  main.__file__ = '<stdin>'
+  exec(compile(sys.stdin.buffer.read(), '<stdin>', 'exec'), main.__dict__)
+ else:
+  sys.argv = args
+  # CPython makes __file__ absolute without collapsing ./ or ../ components.
+  path = args[0] if os.path.isabs(args[0]) else os.path.join(os.getcwd(), args[0])
+  importer = __import__('pkgutil').get_importer(path)
+  if importer is not None:
+   sys.path.insert(0, path)
+   runpy._run_module_as_main('__main__', alter_argv=False)
+  else:
+   if not safe_path: sys.path.insert(0, os.path.dirname(os.path.realpath(path)))
+   try:
+    with open(path, 'rb') as source:
+     code = source.read()
+   except OSError as error:
+    print("python: can't open file " + repr(path) + ': [Errno ' + str(error.errno) + '] ' + error.strerror, file=sys.stderr)
+    return 2
+   main.__file__ = path
+   main.__loader__ = __import__('importlib.machinery', fromlist=['SourceFileLoader']).SourceFileLoader('__main__', path)
+   exec(compile(code, path, 'exec'), main.__dict__)
+ return 0
+
+try:
+ _safe_exit = _safe_launch() or 0
+except SystemExit as _error:
+ _safe_exit = _safe_system_exit(_error)
+except _SafeOptionError as _error:
+ print('python: ' + str(_error), file=sys.stderr)
+ _safe_exit = 2
+except BaseException as _error:
+ # Hide bridge frames while preserving actual Python frames and chained errors.
+ _trace = _error.__traceback__
+ while _trace is not None and _trace.tb_frame.f_code.co_filename == '<exec>':
+  _trace = _trace.tb_next
+ _error.__traceback__ = _trace
+ sys.last_exc = _error
+ _safe_exit = 130 if isinstance(_error, KeyboardInterrupt) else 1
+ try:
+  sys.excepthook(type(_error), _error, _trace)
+ except SystemExit as _hook_error:
+  _safe_exit = _safe_system_exit(_hook_error)
+ except BaseException as _hook_error:
+  print('Error in sys.excepthook:', file=sys.stderr)
+  traceback.print_exception(type(_hook_error), _hook_error, _hook_error.__traceback__.tb_next)
+  print('\\nOriginal exception was:', file=sys.stderr)
+  sys.__excepthook__(type(_error), _error, _trace)
+finally:
+ for _stream in (sys.stdout, sys.stderr):
+  if _stream is not None and not getattr(_stream, 'closed', False):
+   try:
+    _stream.flush()
+   except BaseException:
+    _safe_exit = 120
+_safe_exit
+`;
+
+// packages/safe-bash-command-python/src/runtime-programs.generated.ts
+var pythonRuntimeProgramsGzip = "H4sIAAAAAAACE8U9a5PctpF/BZE+kLQoSsrlrq5WZqpiW/KpYssuSUnuvLvFwpKYGXg54ATgaHeUyn+/6m48Sc7srqXLpa6sWQJoNLob/UID949Hu8O4GdS7vRrlVrwT/dDyUQ7q0dmjCyW3u0GPzBxMyT7JHf1ZMvq3l1fVlrcbqYQ+XKgL1YkVa7S44kY0muA1Oz5u8o+834vi7EIxLca9VqwxfBX6bIe9GtkTht2YXDFppDIjV62goSUzoy4YVx2jD6yuWfasl1cZGzSNq8zI9Whu5LjJselZVhRM9EZQ+zEE+4F3Quf0D+KYIkAN0fIr/8v2Z1y3G/lRsHp59QShsr0KGCFXftDvapZ2QJCOUIuz5m7sE5Y9y9gTB2CnxUrewgSiX15EvsC56v2w1614LXvxg+12vFcvjLmr56vbUSgjBxU6FkQoIMcdVILfjkTYPdAH/kyIMx52bmmFG6/4VpTMQbEdqe1CmYNBKOdnl6xm5ydkla2cXDGpmBt3eaHge7Mdun2PLb00Yw7N9MlUOMbkhZMk39ewt4Mi5raDGqUCkcRpGj6OWl7tR4SYZ02zkr1omqxkWdO0vN2IrmkyIqFcsQ03MCK3oMsIAPVhRozHepTL1F8fH1EUBS1lNm/W4GCPm22o3OcH0Xg6+PL4pMTOhWldw4KM2W0+7wuLa8xOtKxmMypkDTYhL4B9lhLUXxqmhjGwFb9Wg5ZrqY5JedynCIMImRNoR73c7qBvZn9FyDZGgFponP42M/zuHvEgft0B7DJst8YpLhLmqu0F13lxoR6V1vq8wQ4/ipF3fOSx6QkKprkahtGMmu8acTsKrXhfogowJfvVDOpCkVWhEY0Z+di0vO+veHsNlJ02uv7EDN7Hbaw+PXFFQkpg0KrE0H1bjnrIagJSfvWi7Rs0Nsc2bNlEZs+s0CeGdGkJudOB1mAijVCETH6cUDTKinkmtFZDBtxGIDQxl0awn96/0nrQJBnntuNlyTJQXeZgRrG1FGRby1W2V/wjlz2/6kU2U9HIyOq93O568ZZvhdnxVuRmhK0oajsN/IZZzNgY+cl/ht/28xao5bvDHz+a7JI9Yy+eP39eOKm6m6tTgYnY7YX2O6lFOw768EqNWgoTi+1ghbJkSBona50bMpfM0CQIXCxYYGY6qZE7dVZlC34KNJVMqrFYYBMiUb16+9OH93/5uWSZFiOXSnTMz8o6YVotd+OgDeNasL0y+x1u2y4DPjkZYzUbTLUyqBiQiV64I4VDjldWZacEcE6NHEF3oh06kbsZi8+Rx7BAofZboVE5sRWXvejmUniO8wuF84MrQUoPfvlZzzPLoOzycsIDh3HJrg6jMLH7GY26UIOpLEc9++3fF+ox+7ARbKWHT0IxpzjZZug7w8aNYLvByFtmvQojdlzzUfQHGLEFztwp46cm97L9fuTjz3r4VbTTWOCIZC+rW/y683CSzrDjSZjwTy3MvvdKmeQrlrXQQuLh2ugv7917+HZDfFWCjDerrgaxLNlq6PvhpjGHbS/Vtak/aBuZyJXtOLObp7eSHeS1nDSzrXNyo8oVzjbBy/q5OPNfQX5o8gxWdsZarmDM3gi26jAsmgxn47AW40bojKIBIxL/OyFkHlM86P+ju3ZuL2ZU/UIG5A7LcS0O4LLkZBbKTKohK7NOfMzKTAEeWZntZZeV2Rr/i2bCYsbVIb8WByS9ww63OnyUBPuEIv3pr6/evf7hp7+VLGu5GpRsec9kJ9QoxwNYcy3+vpdadAyNyR0LATOFzhcR41ocnMWKUcozbu1Z6S1bmbX2VwH+srgdNQdInWzH/JPc5SAxDY4DAlj7SD9xZFaUND2yzOm6km1l30sj2kF1BiYnWA6Qg+JBODY6DC/LqQl2Hxy+lzYkdHPUsCPyZNpn3mozu7JzwBsCXlTIT1jWKLDutYfyFY6g/7EnTA971eUp1KeTzkUY5EjgCX7VD+01UPmqv0bpKTMN8uV3ru0ZhHuKKPKyZoGx0xyIV4X5uN/1Nt9BIjAVR/aEUR+gFJARKUQWCv+UVpSK0qJRpGqxP6oX57mZqKvtR//MNehr3hsxmWmFw1ed06y4zYIKBDATT+XDYed0HGiAyB1h270Z2ZVgXMEgsbZabY7uqivQtiYOHDltYPSSz73/vkq+r+i7S3xBEzcxr8jyXqi258aw5j1fie+kBhfwAMtBGjRSybFpciP6Vcn0MIwliqwT+X6FeQpW41f/LZg8DAZ+HaTKo8G+H4VRrGb/+KefkdS3nTMJETxo2xdJRZh9dcIeAtumVsVqywgJl2/wH84nYy6Dic89JvNppwZkiv8R4HZJUoEdW145ScaizFZmbCS4MATEgEN6H8pYVrOFnWzTC++bN++/e/MuP47BdMGVDXWstmvFbmSQP3s7jK9Bi+HeSGbFNQTcYdd8OeTfvfr+X4m8hRSx8H5o/vD2z/l9uPybkKMp2702gz4Vr1GPWP3Rl3zY2XijZDaNjfFbpHDB5V3ysSaTziAtOFgEbMFloYbfHhPR+GotxjzDyUH7RtrvfctVJ/UR5eczIHYfb7jqetBdQIXw2QZH4AZAgjsvIm1n1aJVYc6cYDaYVjrjZnDSX739cP8FM35lhh7ysElskcc5aZjaKWhp+JXJ3aDiLB2+FmN70+WFz9K7ZncA4HsfzQm5Lg/ICy3TM8R8wcEPYcGUNYkQB+L9tBMqKz1SgW6W7ZDgO2J/fCclbsekk9/ncpWiESfMGXPmUtxaM+JWWJDX5Zfieh5Zw1txO2ZlMhNBQN5imJ/Ma/fS+3HYvRmt4Pj+kUcTJNXF/mcWkVlGIdFqsfuQAPFdrcb6hhvxCn/KQUVca/vBiLwI4aIlNX0PdKa1llNWx3+W99qTmJN3HPJxckpunDwrWSAwcV+o+8iIuI30x1dcr02kQMJ6qXMn+pk8TQljSRjIt+MmSa8ZUmH/n+m1WCCsRs0fkmezni+NDM4v/Q3OuU/t/BfX3Q9gH++R1QE7Ojd9G647bEpTlGC/dVuyzozogxjdNknupTNjc+9kTBidrHfQEZjflqoB9Bk5tEucMHjQOTEBgRVGtwWJnxmlIktyrG9nxtO5lIS+Oc1cxqBLdjUMfT7Lr3xGgsUvn7VaTCwh8s8zq7CZSnUdZQqB6yBpRDPTTFCreNdFi4sPeT5oIb7tBVf7XVJcsNmPsi+9CDrZG7UQc9mjrwRldoKjt9gMhwig2xBwFX+NBTb6nAS6JRuUuG3vSgounr/cBfOULCTrzWf+h2M5YOHOPbzcXn4eTsckCTsAKnrbSU0Gv7xPrt0yaOJiFRdqgSeetQmfvNS4Q8HvpGmHj0IfHp09ik7cQD/3feMybE0/DNf7XW6/o3g3FEM7lwn+IuaS/HFQV7gI0O9wqjk6XQgiCZj38qpko9juIMiCX7fjjea7kt0Ifq3FCqtDoA0SSJCHhxN+cQs5eDcL8EoLMDtsdrLp04Pc+FRheuLivlY/4PKs9VvrYb+jE9ppjgHyRpRdqKzvke3H1dP/hJoCs9d6WPNRgBnMimojbvM44F7IP2SQgMpK9hUkTc/lmXzy4vlzylBJDD64Wov8ecl6oaBLUUJOrSicndZilFrknvTsMftO9GKUas26vYZ/Ys9cqo+8lx0fhcE14GHg03Yj2mvoChtEqM5U7J3Y9fxAAOFwZLgBq+v12q/DHs48gK2j4N1LJni7YVq0g+4IMIg4u4LAQXREzwqguYGLyZjMtmbOH3J9xK00o8lts/XHwWlnw04o971kyBGp1rXlSQGMJ+Vv3U4gbC8VFZ/EDYRj6bzcSIlAd+vKAk7YzyVs8uw5MP4F/Of38J9/g//8Af7z71kBNnWSoKMkMBRduXkXziLeEJdCdtvteiJw5rAJaqGORXaBsthaRM6vo5/bPfks1AsIDqbaY9o/hexnB79suDFZ4SFvMNHosftdjak6D9CHJhY6KsEAz4G5I6cA/yN/M+ltlShwXqSd5Yq+VKiTkH3BkXn1488f/seqq+rVq/9+8/5DoABjV1rwa/+niwdmXHAE6qQGUk/XFCjpRJl22Bu1Ao0o1mtTsl/e/MwgQjhYdptn9pS0E7clazeyp5MpV6u2Fdsroc1G0g4DCScZvVM+aX1L+M9EJ+y4uyXmHvIy6A6SzQ8FuyQo/jPqwAvFKIPyfhw07e1Z7iSO52EQq70JqrbXHfyGOeqZqcsxUgBPAs6Z5qbQHksvmEgqIKwzb5Ge2k1sIyra3rUze9UKzJP85PKOpOXLgHI8GBMVNXsePoWySRt3EkneDTdmmSKgkQYt4qSSy/EOfl6bLYp6Olh8txOqs5BCSSpbrji1Fr36OczlcxQI3OMfhycg8ce7UKFqrGTmWtX5O4w8GdZuwLZ2uN8sOKdZFyaqozmok/M36XCx4uNlyJi4NjNab66YmKwoY5/x7IjlGvbjbu9WRH9UN1qOIkfz1O23O+NKyJ6w7OJC0QKOpI2Wp/8cm7ngcsfW8iBF3yX8zueUtRJz/vyyWJYXyK/ZnWVdRgLl6UrS/T3oqdPyPZNsJ84zfZAoLkKXNjIwlP7GfWc1WPSFPanZC6fst/xadFKbfGnjog6czeU6BiUZRtjaldon+e1KwSnmUhm/2uCuTl1P60klc0auQzQ9wkhNO822FqMcxXZpssfsnfgotJFXvaAqAv5xkB2LSg/MTvQ9+JoaqnpxW2+42bB2gKNkqG+s2Cvebiy8dtjuBiUUOFHenQRTCBpHqLE/sGHFuPNcM4NzocHshVqPG9bLrRyrmaU7sWjs68FMGDT3epymixPYlswOyFTNESO9qiIW2VxjtEvnkhGLYvCW761DjiqRczcVlKii5xIklqhymaqYVLwjouDKm+GaUk7TFTmClCy7WcLY4Rn8uonOwj3x+eulCrRkQZYLYCTz2PZ5HrodYAvRI706j1QCrm5Jy+u4W/me0L5WvwK886kGvnTYrrQQn8TM7/GqBNgUR70mJ/OYZJG/j1sqd2IIGtWr3284hpCvuez3WuQ+JezuJyA/qaut6nyYqi5Tb8d+I6cnxBMkteQ2l6EeAFLtdg0EvUz/tAUmaTI7RBDkS0xWWFBCAnu4lZCc0TIG3UkblI76YNcTMJ3Ig8X5HOyLHVlcOgfh5n7C7uU7P7dx5j8yPDLJyB+hfMQ/l63srK4yLdB0RvwXuYNgpWoa0w+jaZr4KgGu1CrRtKb93F0AiLtcXpZ2BV+MAYknGhMeiRzYQ3LkupxmDQrQOfasnDK4N2sCT+Jpv+Cq423hXA/aVL1Q3v2L6zaw73Fz7qQvqDb6wL5mz8/c7yf1BJYzgM/Z13U0InSyq3kDUSw55G6iJdf01HY4pTNtBirySG3u39Iaw+p6QZqVuGmafPLdegK+ds+LM01ztnReabcT1AkWPgzAzQU6dwtb0KZ3aWteWhuJF8vI4ahZBhm6BmsAPYyois1HKbM95cKv2KJh86mwABboWOZTjoFzxVlkZ2w/b16M4L3fbl0zrFZGQEoY3UBYgohLZNhj9iMfMVOI7VjFCb4inMl8FMwMGjKXkC5u+31HScxdL1s+CrYReJWHpjCVhfcec8At77lreubWsuNSY42l8xv1XpkS0pmKbYVeCzbeDAzq0LC6jyDaHPJG8N3fiYoUEbgTXGaElpjAJNuDROAfLWeMM/dqUHBhp7fd6ePxMjQMK7Bn4ZmL0/hoItohD7MKiR4mJM8eEEtGevFUrmTmnfqMxye5ewp8dRkP1m72eO51fhnCy9RYAqYua524LnZwZdW8VcokGF72vCivEjEk0/bUCXCU0YXUOsItYO/9xx+8f4V8NXgQRB28YJNMFy8JHX/tygLEr2d3jo7IkYJo91qLKKljE6pWJJ769j+yFw7XXqxGW+Cg5Xozutqe/IiwYTaxICuNvzFbaAGXfoYn7EWR5ItRAKPJFgUQ2kvqGpA50hc7pBTHvVfhDs3zqWOb+MMwERRJn+yEMxTLxI9ylX5RxcvwMaBfvPQ0qdnvo3AOeHI2I9ERslsYRXEv1/+U78+m4n40C+Ntc7wbzsIwtyV8d2clE4X/kvZaE7Q8qyOV7wdHjtbEA36ZDI2Gfa4HhMnS3mmp6HABNMCA5y+T+5qWtF7wnclDBRxIfGdi+kime7bNiugoJU1Wf/byKaTCi33HAipX0EXlO6H4yF+Hu0dmxzkncaGyHU8OskX2z+JA3l3IpExcu2TUeexMn9oRC1KeeHaxg2tnmPkqUGgZFgbVICu+78dQNkrCE4Ei9GIhdetzvSwMG0Hvlfz7XjR4RqPRqtCPJKg1AgPvWQAKEkmnO1IxN9JTn1o8+X32CH6eY6M1p+Ss4ReL1Se5a5DauU+5RuiElygoUAf9BNIR3b0/d37xtwPcIh2hsM5Uja0XbppLqK3DcQBiMeCmc6635OZB+rbSwgz9Ryz3ZZ2Eupz1XpoNGOpbcPnkSGlDEneoXZACr2N1QpP395h9sweiwPl0azGLTsOYUXxnNgNccVhBshcpAz4lVwdbcWEGxpmtL2CPUQL3UEonOjeIs57DPUElzCg6C55Z5AFX3kISkhvnw/7y5md/Due9GUt4jB8hn03MW4wsvUtOJIXRlrh52rOI6jLNue2NBauX0dsZFbK+IaXb8+1Vx89oiD16tISNK3lJQfAO5I0pccPGYfe0Fx9F7+WygsuUUrOV1GZk7lDkMeO9Frw7sKFFU4eyzFVgKdGvxLyvJRg5c3gHcwveOLBTqO6+RCR5T0lzoSxwkEuDWfYotANFXjXvBO+/F+O3UFBCkkt9sVyI1VC9UuGX3FWlVJ2AlHNua1mgDplUUJ5MZoszfBU7EMTCw0RAAJzhcVTNVrsKOuVwE6ppuyIrqquhO8CRSALpar9a4WKWYK3g/FAO1TcQVr75KQfYE0goCdwYuVZb8i+XAKEOBYPyYYAg+Pw2yCar2W0Kksx4484yluBlGXDxk1SrgWJnCv2ca0zpSMvSEk4NahJTGnJG/6ROPl1xo4YTHknSsgAmy9LFUDDaPHxNn7GUiV/6f7Iu8hH8rfp3gvwzWM/boRMfNFdmNeity1aDMIIGJ3kztt4J/kWaGBeYYDZcGjk2f0KhctYV7oTYtNuG70RMQ+Xui6DzTK31VDDjZC7NHMJga3d9OB6DSfdcmhKGFT0UCq0/huMoMoMEC2yH3cE/0zHbmtPLLTdSdcNNvtqVbL7vLRFj10bhZeyY6K8H/dsoDqFeLOTlkuQX8bot3+Nl73reCqtGskTyK0wKBSEtsoS+yfaiKuuTw0s67iyyexM8Qu4URXHWtVBCy7ZBknpi0Y75G7Lo6DmFLSoG7iXHFe47Cd6WSwVOR50McDBJ7xM8eHjj6QsHSn7y1wgCEKAjNNi7FFBghn9/zZ4TKbdwUig/zaanhfuyhIBnsDzRQXOY8GmN6ZF5VtE+/eWMpiadwuq5milmpjUdUxHpoy62cjaf9MNNXE5H2y05+46KY/aVBLmAkrT8Rcno/+Dabxbp2+zkiUcRX1Swr7vZEpO/hIr3yB2MfCvCJotI4qsw3eXyxJeommbdD1e8N01THlEhNYkpvkdwK9ocXGG4sgj7YSVvm600Rqp1eEAoIXXJsq8BbCg2TDD+I5SKAVg4ZZ6i7IpQIbhr4CK7C3x9cPGYfTsoM+p9S+WnhpmDajd6UMMeSkTR2bOU6iTU9rcb1nMloAKVSjTER6HYzUaoUIxqB1jfTgt4BANKCZyH+NL67HtohuUAgoaRVLO9spU/6GHutPgoAZl7uYi4XFIy7tU52q5T35TV7pgzPmJ0vYJ3BZnlODTzAGjAlOLn2RSp7DKP37+7aw1u9y3dBE0KdXyCIsmu3Ae8JeiFYo/Zn4XY0eMqUilba4WZyTYSi5JB1gQ/X0llI7QuVGDgnq0CPMt+W8kMckX5Ud7xHRY+y9EwwddCoyjyNVWPda7OnaGxwxgSQuOtGDdDF9eCv+ZmxBgVml3EY3v/huggTEKhARmXX+TuTkfMnXY79wtotOB9fcv7fu4JwE3IxAkA47vkzM4LtJD5wRup4pq+UAz4UDfIXp9wyiIqu4krCqbTxob7IUvCrC3CR1OA7wmeXtMRV/MeawoZlmTiBy0sLhIfOlGt9qotcfI/+QcDUY6XOjqIKEl4/I4BdtpcyY4OF2U7ZpMOcJCIjZBtwTsJ2AFsP3bCy4LQ4YUdONLga3G4gZPamI6TOrjTdETZBRRqh3suu9rSdZJPy0rWjrfYEV6/zCGNDojV5x5H9PQWICEL5uMvMUrDFdTnl8XDnETgdfB7ov1cpLoi6md9HdfoHJ24hy0RiD9ZVyb+hPsvcWMe7JV4g+8VYxYj7oUVyGr/Q8duQD+u1znX65S8hRs/c2qCClzyaCZsrid/u24ecu1/uSanVGr34wHekGeGd4US6jgsEk8oWaRbtetpWR4Z7bg1c29r4LMiSV42+EwhzcrEFs0ZGi6fRqOcGCbf7IE2pVDb0WVKCZLz4yCf5xOJT4MlJNPqzDQf6QOm7If9iIYUFKf5zGTcl08ym1ajr1hToT+dnHqHZpJip76hmuOORTwo++ouDMX513D8FJ+ZTCez9oYyofHRSqgMpex+SAt7Cju6Js6ZXae7TpAXIQ0KRR90fTk29pX9jNHIuPmMzKcFFPs3MMG9HZwv69B4z+K+lv9BFiux/NEmPu45PcysIMhgV2I6FhNOxV19GG2bi/A4ampbwGi8eKixQO88ukmYeVSOBbBWJJb0fRhXh58Pil/dGhOVPcVxErvGuLrI1SIZnpNdeJyAJCmkdV+549SYnyn488wCzi7DGycuj5eQxzcv7Uv7QATtUHutqeXqdI0tvlHhDiBPrasEl+W1vRZdxPobT9xw6R5QLLyJqqXTXf9AQqAY5Kbg+QQ8zo4qficqOG1KDIhTcscPyKO3HGPCLB6RR4s9ltGzZ4LT+mP7OYQryQUSao18fn+jJOFEVMUUKhTkyr+M7WdKgk58KBu84/BQNiRRgjs1uUMQj82nyEeJiNkTZsmseVKZmtYfTKsT6EYlvKa+N6JpFgs6znw5f3LVAejjIn/LAcQg3VkBRd+XesH7jg83WO7ud+V4H9usO+0VlcizmkW+3n1t1/EAbylis7Haayjfh3TFd1Ro8J2P3Y6FZtNpZlFRNJNtc5OBfsvuju8sEb5EgEegjsd1yRCY/EEh3L80qgbJPBpVe+c/pS4s8h7xtJO1L0Hxu2PpZBCu6suGzcG1id0au5VTZyaOkV0LiUzpe7oFUTD8+4dGwkei4JlXM9MbS44N4VY7FFOK1x7T+3s6R1L0dBEn8W8S1wYwlHiB2CUPbfLY4o4xKKk8evciPAl+yja6XHfyGhuqZn4VnlNKrL933KM32eL3Qo49xpb0iV9hg3o8ofPC8yE4WLF/Yl/aCsmJNFKMbHBcL+jJFi06vt0lDbg4/l06OnKLHIs8srZx6i+t9ItcFTfzdEQSw7G7l7OA+73ROv4O2p1ouXcQJq+osJr551R8k7t+DQ7ua6iL1FV4jYReITU5vnZry1Xt7soLeiGR0Jg8R+OeqYEXpuyzQtOOIEF4oOfh2f+fIqdeuVmAUS69JVgEUEcxC5fs8I5HlswcHgn4jTguPDbwuXh2oj899YV69M//BfSUbLXfagAA";
+
+// packages/safe-bash-command-python/src/runtime-programs.ts
+var decoded3;
+function loadPythonRuntimePrograms() {
+  return decoded3 ??= new Response(new Blob([Uint8Array.from(atob(pythonRuntimeProgramsGzip), (character) => character.charCodeAt(0))]).stream().pipeThrough(new DecompressionStream("gzip"))).json();
+}
+
+export {
+  PythonInvocationError,
+  parsePythonInvocation,
+  pythonPackageUrlHash,
+  installPythonPackages,
+  pythonExecution,
+  loadPythonRuntimePrograms
+};