@poe-platform/safe-bash 0.1.817 → 0.1.819

package/dist/safe-bash-command-sqlite3/index.js

@@ -825,6 +825,27 @@ function serializeSqlJson(value, preserveRealType = true) {
 }
 var JsonText = class extends String {
 };
+function* ftsTokens(text, query) {
+  const words = [];
+  let word = "";
+  for (const char of text + " ") {
+    yield;
+    const code = char.charCodeAt(0);
+    const letter = code >= 65 && code <= 90 || code >= 97 && code <= 122;
+    const digit = code >= 48 && code <= 57;
+    if (code > 127 || query && !letter && !digit && !" 	\r\n".includes(char)) {
+      throw new Error("unsupported FTS5 input: only ASCII text and bare alphanumeric query terms are supported");
+    }
+    if (letter || digit) word += char;
+    else if (word) {
+      if (query && ["AND", "OR", "NOT", "NEAR"].includes(word)) throw new Error("unsupported FTS5 query operator");
+      words.push(word.toLowerCase());
+      word = "";
+    }
+  }
+  if (query && !words.length) throw new Error("unsupported FTS5 empty query");
+  return words;
+}
 function tableStorageColumns(table) {
   if (!table.withoutRowId) return table.columns;
   const keys = table.primaryKeyCols.map((name) => name.toLowerCase());
@@ -848,6 +869,8 @@ function cloneSqlValue(v) {
 }
 function cloneTableDef(t) {
   return {
+    fts5: t.fts5,
+    foreignKeys: t.foreignKeys?.map((key) => ({ ...key, columns: [...key.columns], target: [...key.target] })),
     name: t.name,
     sql: t.sql,
     columns: t.columns.map((c) => ({ ...c })),
@@ -2195,6 +2218,7 @@ var SqliteDatabase = class {
   lastChanges = 0;
   totalChanges = 0;
   inTransaction = false;
+  foreignKeyDepth = 0;
   outerRows = [];
   preparing = false;
   txSnapshot = null;
@@ -2335,6 +2359,9 @@ var SqliteDatabase = class {
     return runSynchronously(this.serializeToBytesSteps());
   }
   *serializeToBytesSteps() {
+    if ([...this.tables.values()].some((table) => table.fts5)) {
+      throw new Error("unsupported FTS5 binary persistence; use a SQL dump");
+    }
     const master = [];
     const tableRows = /* @__PURE__ */ new Map();
     const indexRows = /* @__PURE__ */ new Map();
@@ -2647,14 +2674,35 @@ var SqliteDatabase = class {
       this.schemaCookie += 1;
       return null;
     }
-    if (first === "INSERT" || first === "REPLACE") {
-      return yield* this.executeInsert(sql, tokens, positionalParams, cteScope);
-    }
-    if (first === "UPDATE") {
-      return yield* this.executeUpdate(tokens, positionalParams, cteScope);
-    }
-    if (first === "DELETE") {
-      return yield* this.executeDelete(tokens, positionalParams, cteScope);
+    if (["INSERT", "REPLACE", "UPDATE", "DELETE"].includes(first)) {
+      const snapshot = this.foreignKeys && this.foreignKeyDepth === 0 ? yield* this.captureSnapshot() : null;
+      const existingRows = /* @__PURE__ */ new Set();
+      if (snapshot) {
+        for (const table of this.tables.values()) {
+          for (const row of table.rows) {
+            yield;
+            existingRows.add(row);
+          }
+        }
+      }
+      const counters = [this.lastChanges, this.totalChanges, this.lastInsertRowid];
+      this.foreignKeyDepth++;
+      try {
+        let result;
+        if (first === "UPDATE") result = yield* this.executeUpdate(tokens, positionalParams, cteScope);
+        else if (first === "DELETE") result = yield* this.executeDelete(tokens, positionalParams, cteScope);
+        else result = yield* this.executeInsert(sql, tokens, positionalParams, cteScope);
+        if (snapshot) yield* this.validateForeignKeys(snapshot, existingRows);
+        return result;
+      } catch (error) {
+        if (snapshot) {
+          yield* this.restoreSnapshot(snapshot);
+          [this.lastChanges, this.totalChanges, this.lastInsertRowid] = counters;
+        }
+        throw error;
+      } finally {
+        this.foreignKeyDepth--;
+      }
     }
     if (first === "WITH") {
       return yield* this.executeWith(tokens, positionalParams, cteScope);
@@ -2699,7 +2747,7 @@ var SqliteDatabase = class {
     if (name === "foreign_keys") {
       if (arg !== void 0) {
         const u = arg.toUpperCase();
-        this.foreignKeys = u === "1" || u === "ON" || u === "TRUE";
+        if (!this.inTransaction && this.savepoints.size === 0) this.foreignKeys = u === "1" || u === "ON" || u === "TRUE";
         return null;
       }
       return { columns: ["foreign_keys"], rows: [[this.foreignKeys ? 1 : 0]] };
@@ -2793,7 +2841,7 @@ var SqliteDatabase = class {
     if (name === "foreign_key_list") {
       return {
         columns: ["id", "seq", "table", "from", "to", "on_update", "on_delete", "match"],
-        rows: []
+        rows: (this.findTable(arg ?? "")?.foreignKeys ?? []).flatMap((key, id) => key.columns.map((column, seq) => [id, seq, key.table, column, key.target[seq] ?? null, key.onUpdate, key.onDelete, "NONE"]))
       };
     }
     if (name === "compile_options") {
@@ -2820,7 +2868,10 @@ var SqliteDatabase = class {
       unique = true;
       idx += 1;
     }
+    const virtual = tokens[idx]?.value.toUpperCase() === "VIRTUAL";
+    if (virtual) idx += 1;
     const kind = (tokens[idx]?.value ?? "").toUpperCase();
+    if (virtual && kind !== "TABLE") throw new Error("unsupported virtual table declaration");
     idx += 1;
     let ifNotExists = false;
     if (tokens[idx]?.value.toUpperCase() === "IF" && tokens[idx + 1]?.value.toUpperCase() === "NOT" && tokens[idx + 2]?.value.toUpperCase() === "EXISTS") {
@@ -2839,6 +2890,48 @@ var SqliteDatabase = class {
         }
         throw new Error(`table ${objName} already exists`);
       }
+      if (virtual) {
+        if (tokens[idx]?.value.toUpperCase() !== "USING" || tokens[idx + 1]?.value.toLowerCase() !== "fts5" || tokens[idx + 2]?.value !== "(") {
+          throw new Error("unsupported virtual table module; only fts5 is supported");
+        }
+        const columns2 = [];
+        idx += 3;
+        while (idx < tokens.length && tokens[idx]?.value !== ")") {
+          yield;
+          const token = tokens[idx++];
+          if (!token || !["word", "ident", "string"].includes(token.type) || ![",", ")"].includes(tokens[idx]?.value ?? "")) {
+            throw new Error("unsupported FTS5 column or option");
+          }
+          const name = token.value;
+          if (["rank", "rowid", objName.toLowerCase()].includes(name.toLowerCase())) {
+            throw new Error("unsupported FTS5 reserved column name");
+          }
+          if (columns2.some((c) => c.name.toLowerCase() === name.toLowerCase())) {
+            throw new Error(`duplicate column name: ${name}`);
+          }
+          columns2.push({ name, type: "", notNull: false, primaryKey: false, autoIncrement: false, unique: false });
+          if (tokens[idx]?.value !== ",") break;
+          idx += 1;
+          if (tokens[idx]?.value === ")") throw new Error("unsupported FTS5 trailing comma");
+        }
+        if (!columns2.length || tokens[idx]?.value !== ")" || idx !== tokens.length - 1) {
+          throw new Error("unsupported FTS5 table definition");
+        }
+        this.tables.set(objName, {
+          name: objName,
+          sql,
+          columns: columns2,
+          rows: [],
+          nextRowId: 1,
+          maxAutoInc: 0,
+          withoutRowId: false,
+          strict: false,
+          primaryKeyCols: [],
+          uniqueColSets: [],
+          fts5: true
+        });
+        return;
+      }
       const asIdx = tokens.findIndex((t, i) => {
         return i >= idx && t.value.toUpperCase() === "AS";
       });
@@ -2924,6 +3017,7 @@ var SqliteDatabase = class {
       const primaryKeyCols = [];
       const primaryKeyOrder = [];
       const uniqueColSets = [];
+      const foreignKeys = [];
       for (const part of bodyParts) {
         yield;
         if (part.length === 0) {
@@ -2934,6 +3028,39 @@ var SqliteDatabase = class {
           pIdx += 2;
         }
         const firstWord = (part[pIdx]?.value ?? "").toUpperCase();
+        const reference = part.findIndex((token) => token.type === "word" && token.value.toUpperCase() === "REFERENCES");
+        if (reference !== -1) {
+          let cursor = reference + 1;
+          const table = part[cursor++].value;
+          const readColumns = (start) => {
+            const names = [];
+            for (let i = start + 1; i < part.length && part[i].value !== ")"; i++) {
+              if (part[i].value !== ",") names.push(part[i].value);
+            }
+            return names;
+          };
+          const target = part[cursor]?.value === "(" ? readColumns(cursor) : [];
+          const key = {
+            table,
+            target,
+            columns: firstWord === "FOREIGN" ? readColumns(pIdx + 2) : [part[0].value],
+            onDelete: "NO ACTION",
+            onUpdate: "NO ACTION"
+          };
+          for (; cursor < part.length; cursor++) {
+            if (part[cursor]?.value.toUpperCase() === "DEFERRABLE" && part[cursor - 1]?.value.toUpperCase() !== "NOT") {
+              throw new Error("unsupported deferred foreign key");
+            }
+            if (part[cursor]?.value.toUpperCase() !== "ON") continue;
+            const event = part[++cursor]?.value.toUpperCase();
+            let action = part[++cursor]?.value.toUpperCase() ?? "";
+            if (action === "SET" || action === "NO") action += " " + part[++cursor]?.value.toUpperCase();
+            if (!["CASCADE", "SET NULL", "SET DEFAULT", "RESTRICT", "NO ACTION"].includes(action)) throw new Error("invalid foreign key action");
+            if (event === "DELETE") key.onDelete = action;
+            else if (event === "UPDATE") key.onUpdate = action;
+          }
+          foreignKeys.unshift(key);
+        }
         if (firstWord === "PRIMARY" && part[pIdx + 1]?.value.toUpperCase() === "KEY") {
           pIdx += 2;
           if (part[pIdx]?.value === "(") {
@@ -3009,7 +3136,8 @@ var SqliteDatabase = class {
         strict,
         primaryKeyCols,
         primaryKeyOrder,
-        uniqueColSets
+        uniqueColSets,
+        foreignKeys
       });
       return;
     }
@@ -3541,6 +3669,109 @@ var SqliteDatabase = class {
     }
     return `X'${hex}'`;
   }
+  foreignKeyColumns(parent, key) {
+    const names = key.target.length ? key.target : parent.primaryKeyCols;
+    const columns = names.map((name) => parent.columns.find((column) => column.name.toLowerCase() === name.toLowerCase()));
+    const uniqueSets = [
+      parent.primaryKeyCols,
+      ...parent.uniqueColSets,
+      ...[...this.indexes.values()].filter((index) => index.unique && index.tableName.toLowerCase() === parent.name.toLowerCase()).map((index) => index.columns)
+    ];
+    if (names.length !== key.columns.length || columns.some((column) => !column) || !uniqueSets.some((set) => set.length === names.length && set.every((name, i) => name.toLowerCase() === names[i].toLowerCase()))) {
+      throw new Error(`foreign key mismatch - referencing ${parent.name}`);
+    }
+    return columns;
+  }
+  foreignKeyMatches(child, row, key, columns, parent) {
+    return key.columns.every((name, i) => {
+      const column = child.columns.find((column2) => column2.name.toLowerCase() === name.toLowerCase());
+      if (!column) throw new Error(`unknown column ${name} in foreign key definition`);
+      const value = row.data[column.name] ?? null;
+      const target = columns[i];
+      return value !== null && sqlEquals(applyColumnAffinity(value, target.type, false), parent[target.name] ?? null, target.collate) === true;
+    });
+  }
+  *validateForeignKeys(before, existingRows) {
+    for (const child of this.tables.values()) {
+      for (const key of child.foreignKeys ?? []) {
+        yield;
+        const parent = this.findTable(key.table);
+        for (const row of child.rows) {
+          yield;
+          if (key.columns.some((name) => {
+            const column = child.columns.find((column2) => column2.name.toLowerCase() === name.toLowerCase());
+            return column && row.data[column.name] == null;
+          })) continue;
+          if (!parent) throw new Error(`no such table: ${key.table}`);
+          const columns = this.foreignKeyColumns(parent, key);
+          let found = false;
+          for (const target of parent.rows) {
+            yield;
+            if (this.foreignKeyMatches(child, row, key, columns, target.data)) {
+              found = true;
+              break;
+            }
+          }
+          if (!found) {
+            const oldChild = before.tables.get(child.name);
+            const oldRow = oldChild?.rows.find((old) => old.rowid === row.rowid);
+            const unchanged = existingRows.has(row) && oldRow && key.columns.every((name) => {
+              const column = child.columns.find((column2) => column2.name.toLowerCase() === name.toLowerCase());
+              return sqlEquals(oldRow.data[column.name] ?? null, row.data[column.name] ?? null) === true;
+            });
+            if (unchanged) {
+              let previouslyValid = false;
+              const oldParent = before.tables.get(parent.name);
+              for (const target of oldParent?.rows ?? []) {
+                yield;
+                if (this.foreignKeyMatches(child, oldRow, key, columns, target.data)) {
+                  previouslyValid = true;
+                  break;
+                }
+              }
+              if (!previouslyValid) continue;
+            }
+            throw new Error("FOREIGN KEY constraint failed");
+          }
+        }
+      }
+    }
+  }
+  *applyForeignKeyActions(parent, oldData, newData) {
+    if (!this.foreignKeys) return;
+    if (this.foreignKeyDepth > 100) throw new Error("too many levels of foreign key recursion");
+    const quote = (name) => '"' + name.split('"').join('""') + '"';
+    for (const child of this.tables.values()) {
+      for (const key of child.foreignKeys ?? []) {
+        yield;
+        if (key.table.toLowerCase() !== parent.name.toLowerCase()) continue;
+        const columns = this.foreignKeyColumns(parent, key);
+        if (newData && columns.every((column) => sqlEquals(oldData[column.name] ?? null, newData[column.name] ?? null, column.collate) === true)) continue;
+        const action = newData ? key.onUpdate : key.onDelete;
+        if (action === "NO ACTION") continue;
+        const matches = [];
+        for (const row of child.rows) {
+          yield;
+          if (this.foreignKeyMatches(child, row, key, columns, oldData)) matches.push(row);
+        }
+        if (action === "RESTRICT" && matches.length) throw new Error("FOREIGN KEY constraint failed");
+        for (const row of matches) {
+          yield;
+          const where = child.withoutRowId ? child.primaryKeyCols.map((name) => `${quote(name)} IS ${this.toSqlLiteral(row.data[name] ?? null)}`).join(" AND ") : `rowid = ${row.rowid}`;
+          if (action === "CASCADE" && !newData) {
+            yield* this.executeStatementSteps(`DELETE FROM ${quote(child.name)} WHERE ${where}`);
+          } else {
+            const assignments = key.columns.map((name, i) => {
+              const column = child.columns.find((column2) => column2.name.toLowerCase() === name.toLowerCase());
+              const value = action === "CASCADE" ? this.toSqlLiteral(newData[columns[i].name] ?? null) : action === "SET DEFAULT" ? column.defaultExpr ?? "NULL" : "NULL";
+              return `${quote(name)} = ${value}`;
+            });
+            yield* this.executeStatementSteps(`UPDATE ${quote(child.name)} SET ${assignments.join(", ")} WHERE ${where}`);
+          }
+        }
+      }
+    }
+  }
   *checkConstraintsAndConflicts(tbl, candidate, excludeRowid, replaceNotNull = false) {
     for (const col of tbl.columns) {
       yield;
@@ -3937,18 +4168,24 @@ var SqliteDatabase = class {
               continue;
             }
           }
+          const oldData = { ...conflictRow.data };
+          const newData = { ...conflictRow.data };
           for (const assign of upsertSetPairs) {
             yield;
             const realCol = tbl.columns.find((c) => {
               return c.name.toLowerCase() === assign.col.toLowerCase();
             });
             const colKey = realCol ? realCol.name : assign.col;
-            conflictRow.data[colKey] = applyColumnAffinity(
+            newData[colKey] = applyColumnAffinity(
               yield* this.evalExprSteps(assign.expr, ctx, positionalParams),
               realCol?.type ?? "",
               tbl.strict
             );
           }
+          yield* this.fireTriggers(tbl.name, "BEFORE", "UPDATE", oldData, newData);
+          conflictRow.data = newData;
+          yield* this.applyForeignKeyActions(tbl, oldData, newData);
+          yield* this.fireTriggers(tbl.name, "AFTER", "UPDATE", oldData, newData);
           insertedCount += 1;
           affectedRows.push(conflictRow);
           continue;
@@ -3957,6 +4194,7 @@ var SqliteDatabase = class {
           const idxToRemove = tbl.rows.indexOf(conflictRow);
           if (idxToRemove !== -1) {
             tbl.rows.splice(idxToRemove, 1);
+            yield* this.applyForeignKeyActions(tbl, conflictRow.data);
           }
         } else {
           throw new Error(`UNIQUE constraint failed: ${tbl.name}`);
@@ -4211,10 +4449,12 @@ var SqliteDatabase = class {
         if (conflictAction !== "REPLACE") throw new Error(`UNIQUE constraint failed: ${tbl.name}`);
         replacedRows.add(conflict);
         tbl.rows.splice(tbl.rows.indexOf(conflict), 1);
+        yield* this.applyForeignKeyActions(tbl, conflict.data);
         conflict = yield* this.checkConstraintsAndConflicts(tbl, candidate, row.rowid);
       }
       row.data = newData;
       row.rowid = candidate.rowid;
+      yield* this.applyForeignKeyActions(tbl, oldData, newData);
       tbl.nextRowId = Math.max(tbl.nextRowId, row.rowid + 1);
       tbl.maxAutoInc = Math.max(tbl.maxAutoInc, row.rowid);
       updated += 1;
@@ -4308,6 +4548,10 @@ var SqliteDatabase = class {
       yield* this.fireTriggers(tbl.name, "AFTER", "DELETE", row.data, void 0);
     }
     tbl.rows = kept;
+    for (const row of deletedRows) {
+      yield;
+      yield* this.applyForeignKeyActions(tbl, row.data);
+    }
     this.lastChanges = deletedRows.length;
     this.totalChanges += deletedRows.length;
     if (returningIdx !== -1) {
@@ -4796,8 +5040,11 @@ var SqliteDatabase = class {
       }
     }
     const bindings = {};
+    const ftsBindings = {};
+    bindings.__fts = ftsBindings;
     for (const source of sourceSchema) {
       yield;
+      if (source.ftsTable) ftsBindings[source.tableAlias] = source.ftsTable;
       for (const column of [...source.columns, "rowid", "_rowid_", "oid"]) {
         yield;
         bindings[column] = null;
@@ -5285,7 +5532,7 @@ var SqliteDatabase = class {
           });
         }, this)
       );
-      schema.push({ tableAlias: resolved.alias, columns: resolved.columns });
+      schema.push({ tableAlias: resolved.alias, columns: resolved.columns, ftsTable: resolved.ftsTable });
       if (itemIdx === 0) {
         currentRows = resolved.rows;
         continue;
@@ -5866,7 +6113,7 @@ var SqliteDatabase = class {
         __sources: [r.data]
       };
     }, this);
-    return { alias, columns: cols, rows };
+    return { alias, columns: cols, rows, ftsTable: tbl.fts5 ? tbl : void 0 };
   }
   *evaluateTableValuedFunction(fnName, args) {
     const lower = fnName.toLowerCase();
@@ -6345,6 +6592,16 @@ var SqliteDatabase = class {
   }
   *validateColumns(node, scope, positionalParams, cteScope) {
     if (!node || typeof node !== "object") return;
+    if ("kind" in node && node.kind === "binary" && node.op === "MATCH") {
+      const match = node;
+      this.ftsValues(match.left, scope);
+      if (match.right.kind === "literal" || match.right.kind === "param") {
+        const query = yield* this.evalExprSteps(match.right, scope, positionalParams, cteScope);
+        yield* ftsTokens(toSqlString(query), true);
+      }
+      yield* this.validateColumns(match.right, scope, positionalParams, cteScope);
+      return;
+    }
     if ("kind" in node && node.kind === "column") {
       const column = node;
       this.lookupColInRow(scope, column.table, column.name, column.doubleQuoted);
@@ -6374,6 +6631,34 @@ var SqliteDatabase = class {
       yield* this.validateColumns(child, scope, positionalParams, cteScope);
     }
   }
+  ftsValues(expr, row) {
+    if (expr.kind !== "column") throw new Error("MATCH requires an FTS5 table or column");
+    const tables = row.__tables ?? {};
+    const bindings = row.__fts;
+    if (bindings) {
+      for (const [alias, table2] of Object.entries(bindings)) {
+        if (!expr.table && table2.name.toLowerCase() === expr.name.toLowerCase()) {
+          return table2.columns.map((column) => this.lookupColInRow(row, alias, column.name));
+        }
+        if ((!expr.table || expr.table.toLowerCase() === alias.toLowerCase()) && table2.columns.some((column) => column.name.toLowerCase() === expr.name.toLowerCase())) {
+          return [this.lookupColInRow(row, expr.table, expr.name)];
+        }
+      }
+      throw new Error("MATCH requires an FTS5 table or column");
+    }
+    const table = this.findTable(expr.name);
+    if (!expr.table && table?.fts5) {
+      return table.columns.map((column) => this.lookupColInRow(row, table.name, column.name));
+    }
+    const value = this.lookupColInRow(row, expr.table, expr.name);
+    for (const [name, data] of Object.entries(tables)) {
+      const candidate = this.findTable(name);
+      if (!candidate?.fts5) continue;
+      if (expr.table && !Object.entries(tables).some(([alias, source]) => alias.toLowerCase() === expr.table.toLowerCase() && source === data)) continue;
+      if (candidate.columns.some((column) => column.name.toLowerCase() === expr.name.toLowerCase())) return [value];
+    }
+    throw new Error("MATCH requires an FTS5 table or column");
+  }
   lookupColInRow(row, table, name, doubleQuoted = false) {
     const tables = row.__tables;
     const sources = row.__sources;
@@ -6560,6 +6845,17 @@ var SqliteDatabase = class {
           yield* this.evalExprSteps(expr.expr, row, positionalParams, cteScope, evaluation)
         );
       case "binary": {
+        if (expr.op === "MATCH") {
+          const values = this.ftsValues(expr.left, row);
+          const query = yield* this.evalExprSteps(expr.right, row, positionalParams, cteScope, evaluation);
+          const terms = yield* ftsTokens(toSqlString(query), true);
+          const words = /* @__PURE__ */ new Set();
+          for (const value of values) {
+            yield;
+            for (const word of yield* ftsTokens(toSqlString(value), false)) words.add(word);
+          }
+          return terms.every((term) => words.has(term)) ? 1 : 0;
+        }
         if (expr.op === "AND") {
           const l2 = yield* this.evalExprSteps(expr.left, row, positionalParams, cteScope, evaluation);
           if (l2 !== null && !isTruthy(l2)) {
@@ -6849,7 +7145,6 @@ var SqliteDatabase = class {
       case "GLOB":
         return matchGlob(toSqlString(l), toSqlString(r)) ? 1 : 0;
       case "REGEXP":
-      case "MATCH":
         try {
           return new RegExp(toSqlString(r)).test(toSqlString(l)) ? 1 : 0;
         } catch {

package/dist/safe-bash-command-ssconvert/index.js

@@ -10,11 +10,7 @@ import {
   gt,
   j,
   oe
-} from "../safe-bash/command-chunks/chunk-ABL2DPJI.js";
-import {
-  n as n3,
-  o as o5
-} from "../safe-bash/command-chunks/chunk-HQAHDJPX.js";
+} from "../safe-bash/command-chunks/chunk-6PDXNY3T.js";
 import {
   a,
   g,
@@ -22,6 +18,10 @@ import {
   o,
   t
 } from "../safe-bash/command-chunks/chunk-Z7ESJVFP.js";
+import {
+  n as n3,
+  o as o5
+} from "../safe-bash/command-chunks/chunk-HQAHDJPX.js";
 import {
   a as a5,
   c,
@@ -32,13 +32,6 @@ import {
 import {
   p as p2
 } from "../safe-bash/command-chunks/chunk-4XWFUW5L.js";
-import {
-  r as r2
-} from "../safe-bash/command-chunks/chunk-RVEDPJRP.js";
-import {
-  a as a4,
-  t as t4
-} from "../safe-bash/command-chunks/chunk-Y4RGZJIG.js";
 import {
   i as i2,
   o as o4
@@ -54,6 +47,13 @@ import {
   t as t2,
   x
 } from "../safe-bash/command-chunks/chunk-PFOVSF3U.js";
+import {
+  a as a4,
+  t as t4
+} from "../safe-bash/command-chunks/chunk-Y4RGZJIG.js";
+import {
+  r as r2
+} from "../safe-bash/command-chunks/chunk-RVEDPJRP.js";
 import {
   o as o3
 } from "../safe-bash/command-chunks/chunk-PYU5VF5I.js";
@@ -719,7 +719,7 @@ var le;
 function wr(...u) {
   return le ??= V({ read: readZipArchiveEntries, write: createStoredZipArchive }), le(...u);
 }
-var H = de(async (u) => (await import("../safe-bash/command-chunks/engine-T4GP6QOK-ECFKMR5V.js")).createEngine(u), true, wr);
+var H = de(async (u) => (await import("../safe-bash/command-chunks/engine-UPLVIV72-IGXUDNO5.js")).createEngine(u), true, wr);
 var Do = H.createSsconvertCommand;
 var To = H.createSsconvertCommands;
 var Uo = H.ssconvertCommands;

package/dist/safe-bash-command-tar/create.js

@@ -1,12 +1,12 @@
 import {
   createArchive,
   manifest
-} from "../safe-bash/command-chunks/chunk-WKU65Z3Q.js";
+} from "../safe-bash/command-chunks/chunk-3NJETNC2.js";
+import "../safe-bash/command-chunks/chunk-PYIG32ZI.js";
 import "../safe-bash/command-chunks/chunk-2GILUQJY.js";
 import "../safe-bash/command-chunks/chunk-5H7ZHP7F.js";
 import "../safe-bash/command-chunks/chunk-LSYPQ2W5.js";
 import "../safe-bash/command-chunks/chunk-TCXM7BSZ.js";
-import "../safe-bash/command-chunks/chunk-PYIG32ZI.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {
   createArchive,

package/dist/safe-bash-command-tar/extract.js

@@ -1,12 +1,12 @@
 import {
   extractionInput,
   readArchive
-} from "../safe-bash/command-chunks/chunk-OU4VE5CR.js";
+} from "../safe-bash/command-chunks/chunk-PKH57OIC.js";
+import "../safe-bash/command-chunks/chunk-PYIG32ZI.js";
 import "../safe-bash/command-chunks/chunk-2GILUQJY.js";
 import "../safe-bash/command-chunks/chunk-5H7ZHP7F.js";
 import "../safe-bash/command-chunks/chunk-LSYPQ2W5.js";
 import "../safe-bash/command-chunks/chunk-TCXM7BSZ.js";
-import "../safe-bash/command-chunks/chunk-PYIG32ZI.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {
   extractionInput,

package/dist/safe-bash-command-tar/index.js

@@ -1,15 +1,18 @@
 import {
   compareArchive,
   mutateArchive
-} from "../safe-bash/command-chunks/chunk-E4TF5W6O.js";
+} from "../safe-bash/command-chunks/chunk-BBOYR6LV.js";
 import {
   createArchive,
   manifest
-} from "../safe-bash/command-chunks/chunk-WKU65Z3Q.js";
+} from "../safe-bash/command-chunks/chunk-3NJETNC2.js";
 import {
   extractionInput,
   readArchive
-} from "../safe-bash/command-chunks/chunk-OU4VE5CR.js";
+} from "../safe-bash/command-chunks/chunk-PKH57OIC.js";
+import {
+  quoteName
+} from "../safe-bash/command-chunks/chunk-PYIG32ZI.js";
 import {
   parseOptions
 } from "../safe-bash/command-chunks/chunk-2GILUQJY.js";
@@ -24,9 +27,6 @@ import {
   parseHeader,
   parsePax
 } from "../safe-bash/command-chunks/chunk-TCXM7BSZ.js";
-import {
-  quoteName
-} from "../safe-bash/command-chunks/chunk-PYIG32ZI.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
 // packages/safe-bash-command-tar/src/index.ts

package/dist/safe-bash-command-tar/modes.js

@@ -1,14 +1,14 @@
 import {
   compareArchive,
   mutateArchive
-} from "../safe-bash/command-chunks/chunk-E4TF5W6O.js";
-import "../safe-bash/command-chunks/chunk-WKU65Z3Q.js";
-import "../safe-bash/command-chunks/chunk-OU4VE5CR.js";
+} from "../safe-bash/command-chunks/chunk-BBOYR6LV.js";
+import "../safe-bash/command-chunks/chunk-3NJETNC2.js";
+import "../safe-bash/command-chunks/chunk-PKH57OIC.js";
+import "../safe-bash/command-chunks/chunk-PYIG32ZI.js";
 import "../safe-bash/command-chunks/chunk-2GILUQJY.js";
 import "../safe-bash/command-chunks/chunk-5H7ZHP7F.js";
 import "../safe-bash/command-chunks/chunk-LSYPQ2W5.js";
 import "../safe-bash/command-chunks/chunk-TCXM7BSZ.js";
-import "../safe-bash/command-chunks/chunk-PYIG32ZI.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {
   compareArchive,

package/dist/safe-bash-command-unzip/index.js

@@ -1,12 +1,12 @@
+import {
+  createUnzipCommand
+} from "../safe-bash/command-chunks/chunk-ZSQCROFE.js";
+import "../safe-bash/command-chunks/chunk-CVV7ZVV2.js";
+import "../safe-bash/command-chunks/chunk-ILPEPT7O.js";
 import {
   DEFAULT_ARCHIVE_LIMITS,
   evalSyncUnzip
 } from "../safe-bash/command-chunks/chunk-MKYJAZ2Q.js";
-import {
-  createUnzipCommand
-} from "../safe-bash/command-chunks/chunk-RXXNLH7A.js";
-import "../safe-bash/command-chunks/chunk-ILPEPT7O.js";
-import "../safe-bash/command-chunks/chunk-CVV7ZVV2.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
 // packages/safe-bash-command-unzip/src/index.ts

package/dist/safe-bash-command-unzip/unzip.js

@@ -1,8 +1,8 @@
 import {
   createUnzipCommand
-} from "../safe-bash/command-chunks/chunk-RXXNLH7A.js";
-import "../safe-bash/command-chunks/chunk-ILPEPT7O.js";
+} from "../safe-bash/command-chunks/chunk-ZSQCROFE.js";
 import "../safe-bash/command-chunks/chunk-CVV7ZVV2.js";
+import "../safe-bash/command-chunks/chunk-ILPEPT7O.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {
   createUnzipCommand