@poe-platform/safe-bash 0.1.799 → 0.1.801

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

@@ -0,0 +1,298 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-unzip/src/sync.ts
+init_buffer();
+import { inflateRaw as inflateRawSync } from "pako";
+import { crc32 } from "../../safe-bash-zip-engine/zip-format.js";
+import { DEFAULT_ARCHIVE_LIMITS } from "../../safe-bash-io-engine/commands/archive/internal.js";
+var syncTextDecoder = new TextDecoder();
+function filteredZipName(name) {
+  let output = "";
+  for (const character of name) {
+    const code = character.charCodeAt(0);
+    output += code < 32 ? `^${String.fromCharCode(code + 64)}` : character;
+  }
+  return output;
+}
+function evalSyncUnzip(args, readFile, writeFile, mkdir) {
+  if (!readFile || args.length === 0) return void 0;
+  let zipinfoNames = false;
+  let pipe = false;
+  let list = false;
+  let testMode = false;
+  let caseInsensitive = false;
+  let overwrite = false;
+  let destDir;
+  let quiet = 0;
+  let archive;
+  const patterns = [];
+  const excludePatterns = [];
+  let inExclude = false;
+  let ended = false;
+  const zipGlobToRe = (pat) => {
+    let re = "^";
+    for (let idx = 0; idx < pat.length; idx++) {
+      const ch = pat[idx];
+      if (ch === "*") re += ".*";
+      else if (ch === "?") re += ".";
+      else if (ch === "[") {
+        const close = pat.indexOf("]", idx + 1);
+        if (close > idx + 1) {
+          re += pat.slice(idx, close + 1);
+          idx = close;
+        } else re += "\\[";
+      } else re += ch.replace(/[.+^$(){}|\\]/g, "\\$&");
+    }
+    return new RegExp(re + "$", caseInsensitive ? "iu" : "u");
+  };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (!ended && a === "--") {
+      ended = true;
+      continue;
+    }
+    if (!ended && archive !== void 0 && a === "-x") {
+      inExclude = true;
+      continue;
+    }
+    if (!ended && (a === "-d" || a.startsWith("-d"))) {
+      const d = a === "-d" ? args[++i] : a.slice(2);
+      if (!d) return void 0;
+      destDir = d;
+      continue;
+    }
+    if (!ended && archive === void 0 && a.startsWith("-") && a !== "-") {
+      if (a === "-Z1" && i === 0) {
+        zipinfoNames = true;
+        continue;
+      }
+      for (let c = 1; c < a.length; c++) {
+        const ch = a[c];
+        if (ch === "p") pipe = true;
+        else if (ch === "l") list = true;
+        else if (ch === "t") testMode = true;
+        else if (ch === "C") caseInsensitive = true;
+        else if (ch === "o") overwrite = true;
+        else if (ch === "q") quiet++;
+        else return void 0;
+      }
+    } else if (archive === void 0) {
+      archive = a;
+    } else if (inExclude) {
+      excludePatterns.push(a);
+    } else {
+      patterns.push(a);
+    }
+  }
+  void overwrite;
+  if (!archive) return void 0;
+  const modeCount = (zipinfoNames ? 1 : 0) + (pipe ? 1 : 0) + (list ? 1 : 0) + (testMode ? 1 : 0);
+  if (modeCount > 1) return void 0;
+  const extractMode = modeCount === 0;
+  if (extractMode && (!writeFile || !mkdir)) return void 0;
+  let chosenArchive = archive;
+  let bytes = readFile(archive);
+  if (!bytes) {
+    bytes = readFile(archive + ".zip");
+    if (bytes) chosenArchive = archive + ".zip";
+  }
+  if (!bytes) {
+    bytes = readFile(archive + ".ZIP");
+    if (bytes) chosenArchive = archive + ".ZIP";
+  }
+  if (!bytes || bytes.byteLength < 22) return void 0;
+  try {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let eocdOffset = -1;
+    const lower = Math.max(0, bytes.byteLength - 22 - 65535);
+    for (let off = bytes.byteLength - 22; off >= lower; off--) {
+      if (view.getUint32(off, true) === 101010256 && off + 22 + view.getUint16(off + 20, true) === bytes.byteLength) {
+        eocdOffset = off;
+        break;
+      }
+    }
+    if (eocdOffset === -1) return void 0;
+    const diskNum = view.getUint16(eocdOffset + 4, true);
+    const cdDisk = view.getUint16(eocdOffset + 6, true);
+    const totalEntries = view.getUint16(eocdOffset + 10, true);
+    const cdSize = view.getUint32(eocdOffset + 12, true);
+    const cdOffset = view.getUint32(eocdOffset + 16, true);
+    const commentLen = view.getUint16(eocdOffset + 20, true);
+    if (diskNum !== 0 || cdDisk !== 0 || totalEntries === 0 || totalEntries === 65535 || cdSize === 4294967295 || cdOffset === 4294967295 || commentLen !== 0) {
+      return void 0;
+    }
+    if (cdOffset + cdSize > eocdOffset) return void 0;
+    const members = [];
+    let ptr = cdOffset;
+    for (let idx = 0; idx < totalEntries; idx++) {
+      if (ptr + 46 > eocdOffset || view.getUint32(ptr, true) !== 33639248) return void 0;
+      const flags = view.getUint16(ptr + 8, true);
+      if (flags & 1) return void 0;
+      const method = view.getUint16(ptr + 10, true);
+      const dosTime = view.getUint16(ptr + 12, true);
+      const dosDate = view.getUint16(ptr + 14, true);
+      const crc = view.getUint32(ptr + 16, true);
+      const compSize = view.getUint32(ptr + 20, true);
+      const uncompSize = view.getUint32(ptr + 24, true);
+      const nameLen = view.getUint16(ptr + 28, true);
+      const extraLen = view.getUint16(ptr + 30, true);
+      const entryCommentLen = view.getUint16(ptr + 32, true);
+      const localOffset = view.getUint32(ptr + 42, true);
+      if (entryCommentLen !== 0 || compSize === 4294967295 || uncompSize === 4294967295 || localOffset === 4294967295) return void 0;
+      if (ptr + 46 + nameLen + extraLen > eocdOffset) return void 0;
+      const nameBytes = bytes.subarray(ptr + 46, ptr + 46 + nameLen);
+      const name = syncTextDecoder.decode(nameBytes);
+      members.push({ name, method, flags, crc, compSize, uncompSize, dosTime, dosDate, localOffset, extraLen });
+      ptr += 46 + nameLen + extraLen + entryCommentLen;
+    }
+    const matchedPatterns = /* @__PURE__ */ new Set();
+    const patRegexes = patterns.map(zipGlobToRe);
+    const exRegexes = excludePatterns.map(zipGlobToRe);
+    const selectedMembers = [];
+    for (const m of members) {
+      if (exRegexes.some((re) => re.test(m.name))) continue;
+      if (patterns.length === 0) {
+        selectedMembers.push(m);
+      } else {
+        let hit = false;
+        for (let pIdx = 0; pIdx < patRegexes.length; pIdx++) {
+          if (patRegexes[pIdx].test(m.name)) {
+            hit = true;
+            matchedPatterns.add(pIdx);
+          }
+        }
+        if (hit) selectedMembers.push(m);
+      }
+    }
+    if (selectedMembers.length === 0 || patterns.length > 0 && matchedPatterns.size !== patterns.length) {
+      return void 0;
+    }
+    if (zipinfoNames) {
+      let out = "";
+      for (const m of selectedMembers) {
+        out += `${filteredZipName(m.name)}
+`;
+      }
+      return out;
+    }
+    if (list) {
+      for (const m of selectedMembers) {
+        if (m.extraLen !== 0) return void 0;
+      }
+      let out = quiet === 0 ? `Archive:  ${filteredZipName(chosenArchive)}
+` : "";
+      out += "  Length      Date    Time    Name\n---------  ---------- -----   ----\n";
+      let totalSize = 0;
+      const pad2 = (v) => String(v).padStart(2, "0");
+      for (const m of selectedMembers) {
+        totalSize += m.uncompSize;
+        const year = (m.dosDate >> 9 & 127) + 1980;
+        const month = m.dosDate >> 5 & 15;
+        const day = m.dosDate & 31;
+        const hour = m.dosTime >> 11 & 31;
+        const minute = m.dosTime >> 5 & 63;
+        const dStr = `${year}-${pad2(month)}-${pad2(day)} ${pad2(hour)}:${pad2(minute)}`;
+        out += `${String(m.uncompSize).padStart(9)}  ${dStr}   ${filteredZipName(m.name)}
+`;
+      }
+      out += `---------                     -------
+${String(totalSize).padStart(9)}                     ${selectedMembers.length} file${selectedMembers.length === 1 ? "" : "s"}
+`;
+      return out;
+    }
+    if (testMode || extractMode) {
+      let out = quiet === 0 ? `Archive:  ${filteredZipName(chosenArchive)}
+` : "";
+      const staged = [];
+      for (const m of selectedMembers) {
+        if (m.localOffset + 30 > bytes.byteLength || view.getUint32(m.localOffset, true) !== 67324752) return void 0;
+        const lNameLen = view.getUint16(m.localOffset + 26, true);
+        const lExtraLen = view.getUint16(m.localOffset + 28, true);
+        const dataStart = m.localOffset + 30 + lNameLen + lExtraLen;
+        const dataEnd = dataStart + m.compSize;
+        if (dataEnd > bytes.byteLength) return void 0;
+        const compSlice = bytes.subarray(dataStart, dataEnd);
+        let decoded;
+        if (m.method === 0) {
+          decoded = compSlice;
+        } else if (m.method === 8) {
+          decoded = inflateRawSync(compSlice);
+        } else {
+          return void 0;
+        }
+        if (decoded.byteLength !== m.uncompSize || crc32(decoded) !== m.crc) return void 0;
+        if (testMode) {
+          if (quiet === 0) {
+            const fn = filteredZipName(m.name);
+            const pad = fn + " ".repeat(Math.max(0, 22 - new TextEncoder().encode(fn).byteLength));
+            out += `    testing: ${pad} OK
+`;
+          }
+        } else {
+          const isDir = m.name.endsWith("/");
+          const clean = m.name.replace(/\/+$/u, "");
+          if (!clean || clean.startsWith("/") || clean.split("/").includes("..")) return void 0;
+          const targetPath = destDir ? `${destDir.replace(/\/+$/u, "")}/${clean}` : clean;
+          const shown = destDir === void 0 ? m.name : `${destDir.endsWith("/") ? destDir : `${destDir}/`}${m.name}`;
+          staged.push({ isDir, path: targetPath, shown, method: m.method, bytes: decoded });
+        }
+      }
+      if (testMode) {
+        if (quiet < 2) out += `No errors detected in compressed data of ${filteredZipName(chosenArchive)}.
+`;
+        return out;
+      }
+      for (const item of staged) {
+        if (item.isDir) {
+          if (!mkdir(item.path, 493)) return void 0;
+          if (quiet === 0) out += `   creating: ${filteredZipName(item.shown)}
+`;
+        } else {
+          const slash = item.path.lastIndexOf("/");
+          if (slash > 0 && !mkdir(item.path.slice(0, slash), 493)) return void 0;
+          if (!writeFile(item.path, item.bytes, 420)) return void 0;
+          if (quiet === 0) {
+            const fn = filteredZipName(item.shown);
+            const pad = fn + " ".repeat(Math.max(0, 22 - new TextEncoder().encode(fn).byteLength));
+            out += `${item.method === 0 ? " extracting" : "  inflating"}: ${pad}  
+`;
+          }
+        }
+      }
+      return out;
+    }
+    if (pipe) {
+      let out = "";
+      for (const m of selectedMembers) {
+        if (m.localOffset + 30 > bytes.byteLength || view.getUint32(m.localOffset, true) !== 67324752) return void 0;
+        const lNameLen = view.getUint16(m.localOffset + 26, true);
+        const lExtraLen = view.getUint16(m.localOffset + 28, true);
+        const dataStart = m.localOffset + 30 + lNameLen + lExtraLen;
+        const dataEnd = dataStart + m.compSize;
+        if (dataEnd > bytes.byteLength) return void 0;
+        const compSlice = bytes.subarray(dataStart, dataEnd);
+        let decoded;
+        if (m.method === 0) {
+          decoded = compSlice;
+        } else if (m.method === 8) {
+          decoded = new Uint8Array(inflateRawSync(compSlice));
+        } else {
+          return void 0;
+        }
+        if (decoded.byteLength !== m.uncompSize || crc32(decoded) !== m.crc) return void 0;
+        out += syncTextDecoder.decode(decoded);
+      }
+      return out;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  evalSyncUnzip,
+  DEFAULT_ARCHIVE_LIMITS
+};

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

@@ -0,0 +1,266 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-unzip/src/unzip/safety.ts
+init_buffer();
+import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
+import { dirname, isPathWithin, readBytes, resolvePath } from "../../safe-bash-contracts/index.js";
+import { concatBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+import { checkPath, display, fail, hasIdentity, sameIdentity } from "../../safe-bash-io-engine/commands/archive/internal.js";
+var Extraction = class {
+  constructor(context, limits) {
+    this.context = context;
+    this.limits = limits;
+  }
+  context;
+  limits;
+  inputVolumes = [];
+  pending = /* @__PURE__ */ new Set();
+  publications = /* @__PURE__ */ new Set();
+  readers = /* @__PURE__ */ new Set();
+  closed = false;
+  work = 0;
+  serial = 0;
+  async operation(action) {
+    this.context.signal.throwIfAborted();
+    if (this.closed) fail("extraction is closed");
+    if (++this.work > this.limits.maxPatternSteps) fail("filesystem work limit exceeded");
+    const pending = Promise.resolve().then(() => {
+      this.context.signal.throwIfAborted();
+      return action();
+    });
+    this.pending.add(pending);
+    try {
+      const value = await pending;
+      this.context.signal.throwIfAborted();
+      return value;
+    } finally {
+      this.pending.delete(pending);
+    }
+  }
+  async close() {
+    this.closed = true;
+    while (this.pending.size) await Promise.allSettled([...this.pending]);
+    while (this.publications.size) await Promise.allSettled([...this.publications]);
+    await Promise.allSettled([...this.readers].map((close) => close()));
+  }
+  source(source) {
+    return { [Symbol.asyncIterator]: () => {
+      const state = {};
+      let closing;
+      const close = () => closing ??= (async () => {
+        try {
+          await state.iterator?.return?.();
+        } finally {
+          this.readers.delete(close);
+        }
+      })();
+      this.readers.add(close);
+      this.context.signal.throwIfAborted();
+      state.iterator = source[Symbol.asyncIterator]();
+      return {
+        next: () => this.operation(async () => {
+          const result = await state.iterator.next();
+          if (result.done) this.readers.delete(close);
+          return result;
+        }),
+        async return() {
+          await close();
+          return { done: true, value: void 0 };
+        }
+      };
+    } };
+  }
+  async *input(path) {
+    const { fs, signal } = this.context;
+    const capabilities = await this.operation(async () => await fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities);
+    if (fs.readStream && capabilities.streamingRead !== false) {
+      const source = await this.operation(async () => fs.readStream(path, { signal, chunkSize: this.limits.chunkSize }));
+      yield* readBytes(this.source(source), signal);
+    } else {
+      const stat = await this.operation(() => fs.stat(path, { signal }));
+      if (stat.size > this.limits.maxBufferedFileBytes) fail("filesystem lacks streaming reads: buffered file limit exceeded");
+      const bytes = await this.operation(() => fs.readFile(path, { signal, ...Number.isFinite(this.limits.maxBufferedFileBytes) ? { maxBytes: this.limits.maxBufferedFileBytes } : {} }));
+      if (bytes.length > this.limits.maxBufferedFileBytes) fail("buffered file limit exceeded");
+      yield bytes;
+    }
+  }
+  async stat(path) {
+    try {
+      return await this.operation(() => this.context.fs.lstat(path, { signal: this.context.signal }));
+    } catch (error) {
+      this.context.signal.throwIfAborted();
+      if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") return void 0;
+      throw error;
+    }
+  }
+  async directory(raw, create, ancestors) {
+    checkPath(raw, this.limits);
+    let current = "/";
+    const { fs, signal } = this.context;
+    if (ancestors) ancestors.push({ path: current, stat: await this.operation(() => fs.lstat(current, { signal })) });
+    for (const component of raw.split("/")) {
+      if (!component || component === ".") continue;
+      const parent = await this.operation(() => fs.lstat(current, { signal }));
+      current = resolvePath(current, component);
+      const stat = await this.stat(current);
+      if (!stat && create) await this.createDirectory(current, parent);
+      else if (!stat || stat.type !== "directory") fail(`unsafe non-directory or symlink ancestor: ${display(current)}`);
+      if (ancestors) ancestors.push({ path: current, stat: stat ?? await this.operation(() => fs.lstat(current, { signal })) });
+    }
+    return current;
+  }
+  async createDirectory(path, parent) {
+    const { fs, signal } = this.context;
+    const capabilities = await this.operation(async () => await fs.capabilitiesFor?.(path, { signal, create: true }) ?? fs.capabilities);
+    if (capabilities.atomicDirectoryMetadata !== true && capabilities.trustedOwnedStaging !== true || !fs.prepareDirectory) fail("extraction requires atomic directory creation");
+    return this.operation(() => fs.prepareDirectory(path, {
+      signal,
+      parent,
+      expected: null,
+      ...capabilities.permissions === false ? {} : { mode: 493 }
+    }));
+  }
+  async parents(root, path, create) {
+    if (!isPathWithin(root, path)) fail("extraction path escapes root");
+    await this.directory(dirname(path), create);
+  }
+  member(root, name) {
+    checkPath(name, this.limits);
+    if (name.startsWith("/") || name.split("/").includes("..")) fail(`unsafe archive member: ${display(name)}`);
+    const path = resolvePath(root, name);
+    checkPath(path, this.limits);
+    if (!isPathWithin(root, path)) fail("extraction path escapes root");
+    return path;
+  }
+  async target(root, path, target) {
+    checkPath(target, this.limits);
+    if (target.startsWith("/")) fail("symlink target escapes extraction root");
+    let current = dirname(path);
+    const components = (value) => {
+      checkPath(value, this.limits);
+      let descended = false;
+      const result = value.split("/");
+      for (const component of result) {
+        if (component === ".." && descended) fail("unsafe non-leading parent in symlink target");
+        if (component && component !== "." && component !== "..") descended = true;
+      }
+      return result;
+    };
+    let pending = components(target);
+    let links = 0;
+    let steps = 0;
+    while (pending.length) {
+      if (++steps > this.limits.maxDepth * 41) fail("symlink target resolution limit exceeded");
+      const component = pending.shift();
+      if (!component || component === ".") continue;
+      if (component === "..") {
+        if (current === root) fail("symlink target escapes extraction root");
+        current = dirname(current);
+        continue;
+      }
+      const candidate = resolvePath(current, component);
+      checkPath(candidate, this.limits);
+      if (!isPathWithin(root, candidate)) fail("symlink target escapes extraction root");
+      const stat = await this.stat(candidate);
+      if (stat?.type === "symlink") {
+        if (++links > 40 || !this.context.fs.readlink) fail("symlink target chain cannot be safely resolved");
+        const link = await this.operation(() => this.context.fs.readlink(candidate, { signal: this.context.signal }));
+        if (link.startsWith("/")) fail("absolute symlink target chain is unsafe");
+        pending = [...components(link), ...pending];
+        if (pending.length > this.limits.maxDepth * 41) fail("symlink target resolution limit exceeded");
+      } else current = candidate;
+    }
+  }
+  async destination(path, archivePath, archiveStat) {
+    const stat = await this.stat(path);
+    if (path === archivePath || stat && sameIdentity(stat, archiveStat)) fail("entry would overwrite input archive");
+    if (this.inputVolumes.some((volume) => path === volume.path || stat && sameIdentity(stat, volume.stat))) fail("entry would overwrite input archive volume");
+    if (stat && stat.type !== "file") fail(`unsafe non-regular destination: ${display(path)}`);
+    if (stat && (!hasIdentity(stat) || !hasIdentity(archiveStat))) fail("cannot overwrite file with unknown input-archive backing identity");
+    return stat;
+  }
+  async checked(root, path, expected) {
+    await this.parents(root, path, false);
+    const current = await this.stat(path);
+    if (!current || current.type !== expected.type || !sameIdentity(current, expected)) fail("extraction entry changed before mutation");
+  }
+  async metadata(root, path, identity, parent, mode, modified) {
+    const { fs, signal } = this.context;
+    await this.parents(root, path, false);
+    const capabilities = await this.operation(async () => await fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities);
+    if (capabilities.permissions === false && capabilities.timestamps === false) return;
+    if (capabilities.atomicDirectoryMetadata !== true && capabilities.trustedOwnedStaging !== true || !fs.prepareDirectory) fail("extraction metadata requires atomic entry conditions");
+    await this.operation(() => fs.prepareDirectory(path, {
+      signal,
+      expected: identity,
+      parent,
+      ...capabilities.permissions === false ? {} : { mode: mode & 511 },
+      ...capabilities.timestamps === false ? {} : { atimeMs: modified.getTime(), mtimeMs: modified.getTime() }
+    }));
+  }
+  publish(root, path, chunks, expected, parent, mode, modified, target) {
+    const publication = this.stage(root, path, chunks, expected, parent, mode, modified, target);
+    this.publications.add(publication);
+    return publication.finally(() => {
+      this.publications.delete(publication);
+    });
+  }
+  async stage(root, path, chunks, expected, parent, mode, modified, target) {
+    const { fs, signal } = this.context;
+    const capabilities = await this.operation(async () => await fs.capabilitiesFor?.(path, { signal, create: true }) ?? fs.capabilities);
+    if (capabilities.atomicFileStaging !== true && capabilities.trustedOwnedStaging !== true || !fs.createStagedFile || !fs.publishStagedFile || !fs.removeStagedFile) fail("extraction requires atomic owned file staging");
+    if (capabilities.atomicStagingAncestry !== true) fail("extraction requires atomic staging ancestry verification");
+    const ancestors = [];
+    let staging;
+    let failure;
+    const cleanup = retainFileSystemCleanup(fs, async (view) => {
+      if (staging) {
+        if (!view.removeStagedFile) fail("extraction atomic cleanup unavailable");
+        await view.removeStagedFile(staging);
+      }
+    }, { maxOperations: Math.min(4096, this.limits.maxDepth + 3) });
+    try {
+      if (!isPathWithin(root, path)) fail("extraction path escapes root");
+      await this.directory(dirname(path), false, ancestors);
+      const content = target === void 0 ? { type: "file", data: concatBytes(chunks) } : { type: "symlink", target };
+      for (let attempt = 0; attempt < this.limits.maxMembers; attempt++) {
+        const temporary = resolvePath(dirname(path), `.unzip-${++this.serial}`);
+        checkPath(temporary, this.limits);
+        checkPath(`${temporary}/entry`, this.limits);
+        if (temporary === path) continue;
+        try {
+          await this.operation(async () => {
+            staging = await fs.createStagedFile(temporary, "entry", content, {
+              signal,
+              parent,
+              ...target !== void 0 || capabilities.permissions === false ? {} : { mode: mode & 511 },
+              ...target !== void 0 || capabilities.timestamps === false ? {} : { atimeMs: modified.getTime(), mtimeMs: modified.getTime() }
+            });
+          });
+          break;
+        } catch (error) {
+          signal.throwIfAborted();
+          if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "EEXIST") throw error;
+        }
+      }
+      if (!staging) fail("temporary file attempt limit exceeded");
+      await this.parents(root, path, false);
+      await this.operation(() => fs.publishStagedFile(staging, path, { signal, parent, destination: expected ?? null, ancestors }));
+    } catch (error) {
+      failure = { reason: error };
+    }
+    try {
+      await cleanup();
+    } catch (error) {
+      if (failure) throw new AggregateError([failure.reason, error], "unzip publication and cleanup failed");
+      throw error;
+    }
+    if (failure) throw failure.reason;
+  }
+};
+
+export {
+  Extraction
+};