@poe-platform/safe-bash 0.1.803 → 0.1.804

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

@@ -7,6 +7,42 @@ init_buffer();
 
 // packages/safe-bash-command-exiftool/src/command.ts
 init_buffer();
+
+// packages/safe-bash-command-exiftool/src/system-tags.ts
+init_buffer();
+function systemTags(file, size, metadata, invocation, resources) {
+  resources.admit("work", file.length * 4 + metadata.length + 256);
+  resources.admit("decoded", file.length * 2 + 256);
+  resources.admit("retained", file.length * 16 + 2048);
+  const values = [];
+  if (file !== "-") {
+    const slash = file.lastIndexOf("/");
+    values.push(["FileName", file.slice(slash + 1), "System"], ["Directory", slash < 0 ? "." : file.slice(0, slash) || "/", "System"]);
+  }
+  const numeric = invocation.numeric || invocation.binary || invocation.valueConvTags.includes("filesize");
+  let formatted = String(size) + " bytes";
+  if (size >= 1e3) {
+    const units = ["kB", "MB", "GB", "TB", "PB"];
+    const exponent = Math.min(units.length, Math.floor(Math.log10(size) / 3));
+    formatted = String(Number((size / 1e3 ** exponent).toPrecision(3))) + " " + units[exponent - 1];
+  }
+  values.push(["FileSize", numeric ? String(size) : formatted, "System"]);
+  const type = metadata.find((tag) => tag.name === "FileType")?.value ?? (metadata.some((tag) => tag.name === "PDFVersion") ? "PDF" : void 0);
+  if (type) values.push(["FileTypeExtension", type === "JPEG" ? "jpg" : type.toLowerCase(), "File"]);
+  return values.map(([name, value, group]) => ({
+    name,
+    rawName: name,
+    value,
+    group,
+    chunkType: "System",
+    index: -1,
+    instance: 0,
+    offset: 0,
+    raw: new TextEncoder().encode(value)
+  }));
+}
+
+// packages/safe-bash-command-exiftool/src/command.ts
 import { yieldTurn } from "../safe-bash-contracts/yield.js";
 import { commandRuntimeIdentity, getCommandArguments } from "../safe-bash-contracts/command.js";
 import { FsError as FsError2 } from "../safe-bash-contracts/errors.js";
@@ -19,21 +55,24 @@ init_buffer();
 
 // packages/safe-bash-command-exiftool/src/registry.ts
 init_buffer();
+var stringMetadataTags = /* @__PURE__ */ new Set(["Artist", "Copyright", "Title", "Author", "Subject", "Description", "ImageDescription", "Comment", "UserComment", "Creator", "Producer", "Software", "Make", "Model", "LensModel", "Keywords", "ModifyDate", "DateTimeOriginal", "CreateDate", "FileName", "Directory"]);
 var textChunks = Object.freeze(["tEXt", "iTXt"]);
 var writeChunks = Object.freeze({
   Artist: textChunks,
   Title: textChunks,
   Author: textChunks,
   Description: textChunks,
+  ImageDescription: textChunks,
+  Software: textChunks,
   Comment: textChunks,
   Copyright: textChunks,
   ModifyDate: Object.freeze(["tIME"])
 });
 var exiftoolRegistry = Object.freeze({
-  version: 4,
+  version: 6,
   source: Object.freeze({ version: "13.59", commit: "2200871d9cef988051d2a99d67df3bda6cbb30a8", archiveSha256: "e1e2ad6c6fbf568afee5993ef8b2b91ab013d21698c9304e079e633ad82776f5" }),
-  formats: Object.freeze({ PNG: Object.freeze({ reader: "header-uncompressed-text-time", writer: "selected-text-time" }), JPEG: Object.freeze({ reader: "frame-ifd0-text", writer: "ifd0-artist-copyright" }) }),
-  tags: Object.freeze([...Object.keys(writeChunks), "ImageWidth", "ImageHeight", "BitDepth", "ColorType", "FileType", "MIMEType", "ImageSize", "Subject", "Keywords", "Creator", "Producer", "CreateDate", "PDFVersion", "PageCount"]),
+  formats: Object.freeze({ PNG: Object.freeze({ reader: "header-uncompressed-text-time", writer: "selected-text-time" }), JPEG: Object.freeze({ reader: "frame-ifd0-text", writer: "ifd0-exififd-selected-tags" }) }),
+  tags: Object.freeze([...Object.keys(writeChunks), "ImageWidth", "ImageHeight", "BitDepth", "ColorType", "FileName", "Directory", "FileSize", "FileTypeExtension", "FileType", "MIMEType", "ImageSize", "Subject", "Keywords", "Creator", "Producer", "CreateDate", "PDFVersion", "PageCount", "Make", "Model", "Orientation", "ExposureTime", "FNumber", "ISO", "DateTimeOriginal", "FocalLength", "LensModel", "UserComment"]),
   writeChunks,
   scalarShiftErrorGroups: Object.freeze({ Title: "XMP-xmp" })
 });
@@ -50,6 +89,8 @@ function parseArguments(args, limits) {
     files: [],
     tags: [],
     assignments: [],
+    numeric: false,
+    valueConvTags: [],
     json: false,
     csv: false,
     quoteScalars: false,
@@ -142,7 +183,10 @@ function parseArguments(args, limits) {
       result.style = shortLevel >= 3 ? "values" : shortLevel === 2 ? "compact" : "short";
       continue;
     }
-    if (option === "-n") continue;
+    if (option === "-n") {
+      result.numeric = true;
+      continue;
+    }
     if (option === "-overwrite_original") {
       result.overwrite = "replace";
       continue;
@@ -167,7 +211,10 @@ function parseArguments(args, limits) {
     const operation = name.endsWith("+") ? "add" : name.endsWith("-") ? "remove" : "set";
     if (operation !== "set") name = name.slice(0, -1);
     if (name.endsWith("#")) {
-      if (equals < 0) valueConvSelector = true;
+      if (equals < 0) {
+        valueConvSelector = true;
+        result.valueConvTags.push(name.slice(0, -1).toLowerCase());
+      }
       name = name.slice(0, -1);
     }
     const known = exiftoolRegistry.tags.find((tag) => tag.toLowerCase() === name.toLowerCase());
@@ -580,7 +627,42 @@ function editPng(input, assignments, options) {
 
 // packages/safe-bash-command-exiftool/src/jpeg.ts
 init_buffer();
-var jpegWriteTags = Object.freeze({ Artist: 315, Copyright: 33432 });
+var jpegWriteTags = Object.freeze({ ImageDescription: 270, Description: 270, Make: 271, Model: 272, Orientation: 274, Software: 305, ModifyDate: 306, UserComment: 37510, DateTimeOriginal: 36867, CreateDate: 36868, Artist: 315, Copyright: 33432 });
+var jpegReadIfd0Tags = Object.freeze({
+  270: "ImageDescription",
+  271: "Make",
+  272: "Model",
+  274: "Orientation",
+  305: "Software",
+  306: "ModifyDate",
+  315: "Artist",
+  33432: "Copyright"
+});
+var jpegReadExifIfdTags = Object.freeze({
+  33434: "ExposureTime",
+  33437: "FNumber",
+  34855: "ISO",
+  36867: "DateTimeOriginal",
+  36868: "CreateDate",
+  37510: "UserComment",
+  37386: "FocalLength",
+  42036: "LensModel"
+});
+function hasValidEoiAfterSos(bytes, sosEnd) {
+  let trimmedLen = bytes.length;
+  while (trimmedLen > sosEnd + 2 && bytes[trimmedLen - 1] === 0) {
+    trimmedLen--;
+  }
+  if (trimmedLen >= sosEnd + 2 && bytes[trimmedLen - 2] === 255 && bytes[trimmedLen - 1] === 217) {
+    return true;
+  }
+  for (let i = sosEnd; i + 1 < bytes.length; i++) {
+    if (bytes[i] === 255 && bytes[i + 1] === 217) {
+      return true;
+    }
+  }
+  return false;
+}
 function segments(bytes, resources) {
   resources.admit("input", bytes.length);
   resources.admit("work", bytes.length * 8);
@@ -608,7 +690,7 @@ function segments(bytes, resources) {
     resources.admit("retained", 128);
     result.push({ marker, start, end, payload: bytes.subarray(position + 2, end) });
     if (marker === 218) {
-      if (bytes[bytes.length - 2] !== 255 || bytes[bytes.length - 1] !== 217) throw new Error("JPEG missing EOI");
+      if (!hasValidEoiAfterSos(bytes, end)) throw new Error("JPEG missing EOI");
       return result;
     }
     position = end;
@@ -632,6 +714,59 @@ function tiff(payload) {
   if (count * 12 + 6 > bytes.length - offset) throw new Error("Truncated EXIF directory");
   return { bytes, view, little, offset, count };
 }
+function decodeTiffEntryValue(bytes, view, little, entry) {
+  const type = view.getUint16(entry + 2, little);
+  const count = view.getUint32(entry + 4, little);
+  if (type === 2) {
+    const start = count <= 4 ? entry + 8 : view.getUint32(entry + 8, little);
+    if (start > bytes.length || count > bytes.length - start) throw new Error("Truncated EXIF text");
+    const raw = bytes.subarray(start, start + count);
+    const end = raw.indexOf(0);
+    return {
+      value: new TextDecoder("utf-8").decode(end < 0 ? raw : raw.subarray(0, end)),
+      valueOffset: start
+    };
+  }
+  if (type === 7 && view.getUint16(entry, little) === 37510) {
+    const start = count <= 4 ? entry + 8 : view.getUint32(entry + 8, little);
+    if (start > bytes.length || count > bytes.length - start || count < 8) throw new Error("Truncated EXIF UserComment");
+    const raw = bytes.subarray(start, start + count);
+    const encoding = new TextDecoder().decode(raw.subarray(0, 8));
+    const text = raw.subarray(8);
+    const value = encoding === "UNICODE\0" ? new TextDecoder(little ? "utf-16le" : "utf-16be", { fatal: true }).decode(text) : new TextDecoder().decode(text);
+    return { value: value.endsWith("\0") ? value.slice(0, -1) : value, valueOffset: start };
+  }
+  if (type === 3 && count >= 1) {
+    const start = count <= 2 ? entry + 8 : view.getUint32(entry + 8, little);
+    if (start + 2 <= bytes.length) {
+      return { value: String(view.getUint16(start, little)), valueOffset: start };
+    }
+  }
+  if (type === 4 && count >= 1) {
+    const start = count === 1 ? entry + 8 : view.getUint32(entry + 8, little);
+    if (start + 4 <= bytes.length) {
+      return { value: String(view.getUint32(start, little)), valueOffset: start };
+    }
+  }
+  if (type === 5 && count >= 1) {
+    const start = view.getUint32(entry + 8, little);
+    if (start + 8 <= bytes.length) {
+      const num = view.getUint32(start, little);
+      const den = view.getUint32(start + 4, little);
+      if (den > 0) {
+        if (num < den && num > 0 && den % num === 0) {
+          return { value: `1/${Math.round(den / num)}`, valueOffset: start };
+        }
+        const ratio = num / den;
+        return {
+          value: Number.isInteger(ratio) ? String(ratio) : ratio.toFixed(2).replace(/\.?0+$/, ""),
+          valueOffset: start
+        };
+      }
+    }
+  }
+  return void 0;
+}
 function inspectJpeg(input, options) {
   const resources = options instanceof Resources ? options : new Resources(options);
   const parts = segments(input, resources);
@@ -656,16 +791,40 @@ function inspectJpeg(input, options) {
     }
     if (!isExif(part)) continue;
     const { bytes, view, little, offset, count } = tiff(part.payload);
+    let exifIfdOffset = 0;
     for (let i = 0; i < count; i++) {
       const entry = offset + 2 + i * 12;
-      const name = Object.keys(jpegWriteTags).find((name2) => jpegWriteTags[name2] === view.getUint16(entry, little));
-      if (!name || view.getUint16(entry + 2, little) !== 2) continue;
-      const length = view.getUint32(entry + 4, little);
-      const start = length <= 4 ? entry + 8 : view.getUint32(entry + 8, little);
-      if (start > bytes.length || length > bytes.length - start) throw new Error("Truncated EXIF text");
-      const raw = bytes.subarray(start, start + length);
-      const end = raw.indexOf(0);
-      add(name, new TextDecoder("utf-8").decode(end < 0 ? raw : raw.subarray(0, end)), "IFD0", part.start + 10 + start);
+      const tagId = view.getUint16(entry, little);
+      if (tagId === 34665 && view.getUint16(entry + 2, little) === 4) {
+        exifIfdOffset = view.getUint32(entry + 8, little);
+        continue;
+      }
+      const name = jpegReadIfd0Tags[tagId];
+      if (!name) continue;
+      const decoded = decodeTiffEntryValue(bytes, view, little, entry);
+      if (decoded) {
+        add(name, decoded.value, "IFD0", part.start + 10 + decoded.valueOffset);
+      }
+    }
+    if (exifIfdOffset >= 8 && exifIfdOffset + 2 <= bytes.length) {
+      const subCount = view.getUint16(exifIfdOffset, little);
+      if (subCount * 12 + 2 <= bytes.length - exifIfdOffset) {
+        for (let i = 0; i < subCount; i++) {
+          const entry = exifIfdOffset + 2 + i * 12;
+          const tagId = view.getUint16(entry, little);
+          const name = jpegReadExifIfdTags[tagId];
+          if (!name) continue;
+          let decoded;
+          try {
+            decoded = decodeTiffEntryValue(bytes, view, little, entry);
+          } catch {
+            continue;
+          }
+          if (decoded) {
+            add(name, decoded.value, "ExifIFD", part.start + 10 + decoded.valueOffset);
+          }
+        }
+      }
     }
   }
   return { tags };
@@ -688,38 +847,98 @@ function editJpeg(input, assignments, options) {
       changes.set(jpegWriteTags[name], assignment.value);
     }
     const base = exif[0] ? tiff(exif[0].payload) : tiff(new Uint8Array([69, 120, 105, 102, 0, 0, 73, 73, 42, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
-    const entries = [];
-    for (let i = 0; i < base.count; i++) {
-      const start2 = base.offset + 2 + i * 12;
-      if (!changes.has(base.view.getUint16(start2, base.little))) entries.push(base.bytes.subarray(start2, start2 + 12));
-    }
-    const values = [...changes].filter(([, value]) => value !== "").map(([tag, value]) => ({ tag, bytes: new TextEncoder().encode(value + "\0") }));
-    const offset = base.bytes.length + base.bytes.length % 2;
-    const count = entries.length + values.length;
-    const length = offset + 6 + count * 12 + values.reduce((sum, v) => sum + (v.bytes.length > 4 ? v.bytes.length : 0), 0);
-    if (length + 8 > 65535 || count > 65535) throw new Error("EXIF segment too large");
-    resources.admit("retained", length * 3 + count * 128);
-    resources.admit("work", length * 4);
-    const bytes = new Uint8Array(length);
-    bytes.set(base.bytes);
-    const view = new DataView(bytes.buffer);
-    view.setUint32(4, offset, base.little);
-    view.setUint16(offset, count, base.little);
-    entries.forEach((entry, i) => bytes.set(entry, offset + 2 + i * 12));
-    view.setUint32(offset + 2 + count * 12, base.view.getUint32(base.offset + 2 + base.count * 12, base.little), base.little);
-    let cursor2 = offset + 6 + count * 12;
-    values.forEach((value, i) => {
-      const p = offset + 2 + (entries.length + i) * 12;
-      view.setUint16(p, value.tag, base.little);
-      view.setUint16(p + 2, 2, base.little);
-      view.setUint32(p + 4, value.bytes.length, base.little);
-      if (value.bytes.length <= 4) bytes.set(value.bytes, p + 8);
-      else {
-        view.setUint32(p + 8, cursor2, base.little);
-        bytes.set(value.bytes, cursor2);
-        cursor2 += value.bytes.length;
+    let bytes = base.bytes;
+    const rootChanges = /* @__PURE__ */ new Map();
+    const exifChanges = /* @__PURE__ */ new Map();
+    for (const [tag, value] of changes) {
+      let encoded;
+      if (value !== "") {
+        if (tag === 274) {
+          if (value.length !== 1 || value < "1" || value > "8") throw new Error("Orientation must be an integer from 1 to 8");
+          const data = new Uint8Array(2);
+          new DataView(data.buffer).setUint16(0, Number(value), base.little);
+          encoded = { type: 3, count: 1, bytes: data };
+        } else if (tag === 37510) {
+          const ascii = [...value].every((char) => char.charCodeAt(0) < 128);
+          const data = new Uint8Array(8 + (ascii ? value.length : value.length * 2));
+          data.set(new TextEncoder().encode(ascii ? "ASCII" : "UNICODE"));
+          if (ascii) data.set(new TextEncoder().encode(value), 8);
+          else {
+            const view = new DataView(data.buffer);
+            for (let i = 0; i < value.length; i++) view.setUint16(8 + i * 2, value.charCodeAt(i), base.little);
+          }
+          encoded = { type: 7, count: data.length, bytes: data };
+        } else {
+          const data = new TextEncoder().encode(value + "\0");
+          encoded = { type: 2, count: data.length, bytes: data };
+        }
+      }
+      (Object.hasOwn(jpegReadExifIfdTags, tag) ? exifChanges : rootChanges).set(tag, encoded);
+    }
+    const appendDirectory = (oldOffset, updates) => {
+      const entries = /* @__PURE__ */ new Map();
+      let next = 0;
+      if (oldOffset) {
+        if (oldOffset < 8 || oldOffset > base.bytes.length - 2) throw new Error("Invalid EXIF directory");
+        const count2 = base.view.getUint16(oldOffset, base.little);
+        if (count2 * 12 + 6 > base.bytes.length - oldOffset) throw new Error("Truncated EXIF directory");
+        for (let i = 0; i < count2; i++) {
+          const start2 = oldOffset + 2 + i * 12;
+          const tag = base.view.getUint16(start2, base.little);
+          if (!updates.has(tag)) entries.set(tag, base.bytes.subarray(start2, start2 + 12));
+        }
+        next = base.view.getUint32(oldOffset + 2 + count2 * 12, base.little);
       }
-    });
+      for (const [tag, value] of updates) if (value) entries.set(tag, new Uint8Array(12));
+      const offset2 = bytes.length + bytes.length % 2;
+      const count = entries.size;
+      const dataStart = offset2 + 6 + count * 12;
+      let length2 = dataStart;
+      for (const value of updates.values()) if (value && value.bytes.length > 4) length2 += value.bytes.length + value.bytes.length % 2;
+      if (length2 + 8 > 65535 || count > 65535) throw new Error("EXIF segment too large");
+      resources.admit("retained", length2 * 3 + count * 128);
+      resources.admit("work", length2 * 4);
+      const result2 = new Uint8Array(length2);
+      result2.set(bytes);
+      const view = new DataView(result2.buffer);
+      view.setUint16(offset2, count, base.little);
+      view.setUint32(offset2 + 2 + count * 12, next, base.little);
+      let cursor2 = dataStart;
+      [...entries].sort(([a], [b]) => a - b).forEach(([tag, entry], i) => {
+        const p = offset2 + 2 + i * 12;
+        result2.set(entry, p);
+        const value = updates.get(tag);
+        if (!value) return;
+        view.setUint16(p, tag, base.little);
+        view.setUint16(p + 2, value.type, base.little);
+        view.setUint32(p + 4, value.count, base.little);
+        if (value.bytes.length <= 4) result2.set(value.bytes, p + 8);
+        else {
+          view.setUint32(p + 8, cursor2, base.little);
+          result2.set(value.bytes, cursor2);
+          cursor2 += value.bytes.length + value.bytes.length % 2;
+        }
+      });
+      bytes = result2;
+      return offset2;
+    };
+    if (exifChanges.size) {
+      let oldOffset = 0;
+      for (let i = 0; i < base.count; i++) {
+        const entry = base.offset + 2 + i * 12;
+        if (base.view.getUint16(entry, base.little) === 34665) {
+          if (base.view.getUint16(entry + 2, base.little) !== 4 || base.view.getUint32(entry + 4, base.little) !== 1) throw new Error("Invalid ExifIFD pointer");
+          oldOffset = base.view.getUint32(entry + 8, base.little);
+        }
+      }
+      const offset2 = appendDirectory(oldOffset, exifChanges);
+      const pointer = new Uint8Array(4);
+      new DataView(pointer.buffer).setUint32(0, offset2, base.little);
+      rootChanges.set(34665, { type: 4, count: 1, bytes: pointer });
+    }
+    const offset = appendDirectory(base.offset, rootChanges);
+    new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).setUint32(4, offset, base.little);
+    const length = bytes.length;
     replacement = new Uint8Array(length + 10);
     replacement.set([255, 225, length + 8 >>> 8, length + 8 & 255, 69, 120, 105, 102, 0, 0]);
     replacement.set(bytes, 10);
@@ -1737,7 +1956,10 @@ function renderPresentation(file, tags, invocation, resources) {
     return Array.from(text(value), (character) => escapes2[character] ?? character).join("");
   };
   if (invocation.xml) {
-    return "\n<rdf:Description rdf:about='" + xml(file) + "'\n  xmlns:et='http://ns.exiftool.org/1.0/' et:toolkit='Image::ExifTool " + exiftoolRegistry.source.version + "'\n  xmlns:PNG='http://ns.exiftool.org/PNG/PNG/1.0/'>\n" + tags.map((tag) => " <PNG:" + tag.name + ">" + xml(tag.value) + "</PNG:" + tag.name + ">\n").join("") + "</rdf:Description>\n";
+    const groups = [...new Set(tags.map((tag) => tag.group))];
+    if (!groups.length) groups.push("PNG");
+    const namespaces = groups.map((group) => "  xmlns:" + group + "='http://ns.exiftool.org/" + (group === "System" ? "File" : group) + "/" + group + "/1.0/'").join("\n");
+    return "\n<rdf:Description rdf:about='" + xml(file) + "'\n  xmlns:et='http://ns.exiftool.org/1.0/' et:toolkit='Image::ExifTool " + exiftoolRegistry.source.version + "'\n" + namespaces + ">\n" + tags.map((tag) => " <" + tag.group + ":" + tag.name + ">" + xml(tag.value) + "</" + tag.group + ":" + tag.name + ">\n").join("") + "</rdf:Description>\n";
   }
   if (invocation.template !== void 0) {
     const parts = parseTemplate(invocation.template);
@@ -1806,6 +2028,10 @@ function createExiftoolCommand(options = {}) {
           resources.admit("retained", text.length * 5);
           await writeBytes(error ? stderr.output : stdout.output, new TextEncoder().encode(text), context.signal);
         };
+        if (context.args.length === 1 && (context.args[0] === "-ver" || context.args[0] === "--version")) {
+          await output(exiftoolRegistry.source.version + "\n");
+          return { exitCode: 0 };
+        }
         let invocation;
         try {
           const carrier = getCommandArguments(context);
@@ -1946,6 +2172,7 @@ function createExiftoolCommand(options = {}) {
             }
             if (!png && !isPdf && !jpeg && ["XMP", "DOCX", "PPTX", "XLSX", "JPG", "JPEG", "TIF", "TIFF"].includes(extension)) throw new Error(extension + " reader not yet supported");
             tags = jpeg ? inspectJpeg(bytes, resources).tags : png ? inspectPng(bytes, resources).tags : isPdf ? inspectPdf(bytes, resources).tags : [];
+            tags = [...systemTags(file, bytes.length, tags, invocation, resources), ...tags];
           } catch (error) {
             context.signal.throwIfAborted();
             if (error instanceof ResourceLimitError || error instanceof Error && error.name === "BudgetExceededError" || error instanceof FsError2 && error.code === "EFBIG") throw error;
@@ -2002,7 +2229,7 @@ function createExiftoolCommand(options = {}) {
               if (tokens.has(token)) continue;
               tokens.add(token);
               resources.admit("work", tag.value.length * 4);
-              entries.push("  " + token + ": " + encodeJsonScalar(tag.value, scalarOptions));
+              entries.push("  " + token + ": " + encodeJsonScalar(tag.value, { ...scalarOptions, quoteScalars: invocation.quoteScalars || stringMetadataTags.has(tag.name) }));
             }
             if (invocation.missing) for (const name of invocation.tags) {
               if (present.has(name)) continue;
@@ -2140,7 +2367,8 @@ function evalSyncExiftool(inBytes, opArgs, readFileSync, writeFileSync) {
         }
         continue;
       }
-      const tags = jpeg ? inspectJpeg(bytes, resources).tags : png ? inspectPng(bytes, resources).tags : inspectPdf(bytes, resources).tags;
+      const metadata = jpeg ? inspectJpeg(bytes, resources).tags : png ? inspectPng(bytes, resources).tags : inspectPdf(bytes, resources).tags;
+      const tags = [...systemTags(file, bytes.length, metadata, invocation, resources), ...metadata];
       const chosen = selected(tags, invocation.tags, invocation.json ? invocation.groupFamily === 4 : invocation.duplicates && !invocation.csv, resources);
       if (invocation.xml || invocation.tabular || invocation.template !== void 0) {
         const values = invocation.template !== void 0 ? selected(tags, [], false, resources) : chosen;
@@ -2179,7 +2407,7 @@ function evalSyncExiftool(inBytes, opArgs, readFileSync, writeFileSync) {
           const token = encodeJsonScalar(name, { ...scalarOptions, quoteScalars: true });
           if (tokens.has(token)) continue;
           tokens.add(token);
-          entries.push("  " + token + ": " + encodeJsonScalar(tag.value, scalarOptions));
+          entries.push("  " + token + ": " + encodeJsonScalar(tag.value, { ...scalarOptions, quoteScalars: invocation.quoteScalars || stringMetadataTags.has(tag.name) }));
         }
         if (invocation.missing) {
           for (const name of invocation.tags) {

package/dist/safe-bash-command-exiftool/registry.d.ts

@@ -1,5 +1,7 @@
+/** Text metadata must retain its type even when its contents look like JSON scalars. */
+export declare const stringMetadataTags: Set<string>;
 export declare const exiftoolRegistry: Readonly<{
-    version: 4;
+    version: 6;
     source: Readonly<{
         version: "13.59";
         commit: "2200871d9cef988051d2a99d67df3bda6cbb30a8";
@@ -12,7 +14,7 @@ export declare const exiftoolRegistry: Readonly<{
         }>;
         JPEG: Readonly<{
             reader: "frame-ifd0-text";
-            writer: "ifd0-artist-copyright";
+            writer: "ifd0-exififd-selected-tags";
         }>;
     }>;
     tags: readonly string[];

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

@@ -1,9 +1,9 @@
 import {
   createFactorCommand
-} from "../safe-bash/command-chunks/chunk-ZRRBXU3M.js";
+} from "../safe-bash/command-chunks/chunk-GIN5GUDP.js";
 import "../safe-bash/command-chunks/chunk-OBEPWAOK.js";
-import "../safe-bash/command-chunks/chunk-Z6Z7XREG.js";
 import "../safe-bash/command-chunks/chunk-UDSYWUZO.js";
+import "../safe-bash/command-chunks/chunk-Z6Z7XREG.js";
 import "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
 export {
   createFactorCommand

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

@@ -1,9 +1,9 @@
 import {
   createFactorCommand
-} from "../safe-bash/command-chunks/chunk-ZRRBXU3M.js";
+} from "../safe-bash/command-chunks/chunk-GIN5GUDP.js";
 import "../safe-bash/command-chunks/chunk-OBEPWAOK.js";
-import "../safe-bash/command-chunks/chunk-Z6Z7XREG.js";
 import "../safe-bash/command-chunks/chunk-UDSYWUZO.js";
+import "../safe-bash/command-chunks/chunk-Z6Z7XREG.js";
 import {
   init_buffer
 } from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";

package/dist/safe-bash-command-fd/arguments.d.ts

@@ -3,6 +3,8 @@ export interface FdArguments {
     roots: string[];
     mode: 'regex' | 'glob' | 'fixed';
     caseMode: 'smart' | 'sensitive' | 'insensitive';
+    prune: boolean;
+    ignoreFiles: string[];
     hidden: boolean;
     ignore: boolean;
     ignoreVcs: boolean;