@sweberdev/witness 0.0.0-stage → 0.1.0

package/dist/cli.cjs

@@ -0,0 +1,964 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  runCli: () => runCli
+});
+module.exports = __toCommonJS(cli_exports);
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_node_util = require("util");
+
+// src/inflate.ts
+var LENGTH_BASE = [
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  13,
+  15,
+  17,
+  19,
+  23,
+  27,
+  31,
+  35,
+  43,
+  51,
+  59,
+  67,
+  83,
+  99,
+  115,
+  131,
+  163,
+  195,
+  227,
+  258
+];
+var LENGTH_EXTRA = [
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0
+];
+var DIST_BASE = [
+  1,
+  2,
+  3,
+  4,
+  5,
+  7,
+  9,
+  13,
+  17,
+  25,
+  33,
+  49,
+  65,
+  97,
+  129,
+  193,
+  257,
+  385,
+  513,
+  769,
+  1025,
+  1537,
+  2049,
+  3073,
+  4097,
+  6145,
+  8193,
+  12289,
+  16385,
+  24577
+];
+var DIST_EXTRA = [
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13
+];
+var CODE_LENGTH_ORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+function buildTree(lengths, offset, count) {
+  const tree = { counts: new Uint16Array(16), symbols: new Uint16Array(count) };
+  for (let i = 0; i < count; i++) {
+    const length = lengths[offset + i] ?? 0;
+    tree.counts[length] = (tree.counts[length] ?? 0) + 1;
+  }
+  tree.counts[0] = 0;
+  const offsets = new Uint16Array(16);
+  let sum = 0;
+  for (let i = 0; i < 16; i++) {
+    offsets[i] = sum;
+    sum += tree.counts[i] ?? 0;
+  }
+  for (let i = 0; i < count; i++) {
+    const length = lengths[offset + i] ?? 0;
+    if (length) {
+      const at = offsets[length] ?? 0;
+      tree.symbols[at] = i;
+      offsets[length] = at + 1;
+    }
+  }
+  return tree;
+}
+var fixed = null;
+function fixedTrees() {
+  if (!fixed) {
+    const lengths = new Uint8Array(288);
+    lengths.fill(8, 0, 144);
+    lengths.fill(9, 144, 256);
+    lengths.fill(7, 256, 280);
+    lengths.fill(8, 280, 288);
+    fixed = { lit: buildTree(lengths, 0, 288), dist: buildTree(new Uint8Array(30).fill(5), 0, 30) };
+  }
+  return fixed;
+}
+var Reader = class {
+  constructor(data) {
+    this.data = data;
+    this.pos = 0;
+    this.bit = 0;
+    this.bits = 0;
+  }
+  getBit() {
+    if (this.bits === 0) {
+      if (this.pos >= this.data.length) throw new Error("inflate: unexpected end of data");
+      this.bit = this.data[this.pos++] ?? 0;
+      this.bits = 8;
+    }
+    const value = this.bit & 1;
+    this.bit >>>= 1;
+    this.bits--;
+    return value;
+  }
+  read(count, base = 0) {
+    let value = 0;
+    for (let i = 0; i < count; i++) value |= this.getBit() << i;
+    return value + base;
+  }
+  decode(tree) {
+    let sum = 0;
+    let cur = 0;
+    let len = 0;
+    do {
+      cur = 2 * cur + this.getBit();
+      len++;
+      if (len > 15) throw new Error("inflate: invalid code");
+      sum += tree.counts[len] ?? 0;
+      cur -= tree.counts[len] ?? 0;
+    } while (cur >= 0);
+    return tree.symbols[sum + cur] ?? 0;
+  }
+};
+function dynamicTrees(r) {
+  const hlit = r.read(5, 257);
+  const hdist = r.read(5, 1);
+  const hclen = r.read(4, 4);
+  const codeLengths = new Uint8Array(19);
+  for (let i = 0; i < hclen; i++) codeLengths[CODE_LENGTH_ORDER[i] ?? 0] = r.read(3);
+  const codeTree = buildTree(codeLengths, 0, 19);
+  const lengths = new Uint8Array(hlit + hdist);
+  for (let n = 0; n < hlit + hdist; ) {
+    const sym = r.decode(codeTree);
+    if (sym < 16) {
+      lengths[n++] = sym;
+      continue;
+    }
+    let repeat;
+    let value = 0;
+    if (sym === 16) {
+      if (n === 0) throw new Error("inflate: invalid repeat");
+      value = lengths[n - 1] ?? 0;
+      repeat = r.read(2, 3);
+    } else if (sym === 17) {
+      repeat = r.read(3, 3);
+    } else {
+      repeat = r.read(7, 11);
+    }
+    while (repeat-- > 0) lengths[n++] = value;
+  }
+  return { lit: buildTree(lengths, 0, hlit), dist: buildTree(lengths, hlit, hdist) };
+}
+function inflateZlib(data, maxLength = 16 * 1024 * 1024) {
+  if (data.length < 2 || ((data[0] ?? 0) & 15) !== 8 || ((data[0] ?? 0) << 8 | (data[1] ?? 0)) % 31 !== 0) {
+    throw new Error("inflate: not a zlib stream");
+  }
+  const r = new Reader(data);
+  r.pos = 2;
+  let out = new Uint8Array(Math.max(1024, data.length * 4));
+  let length = 0;
+  const push = (byte) => {
+    if (length >= out.length) {
+      if (out.length >= maxLength) throw new Error("inflate: output too large");
+      const next = new Uint8Array(Math.min(maxLength, out.length * 2));
+      next.set(out);
+      out = next;
+    }
+    out[length++] = byte;
+  };
+  let final = 0;
+  do {
+    final = r.getBit();
+    const type = r.read(2);
+    if (type === 0) {
+      r.bits = 0;
+      if (r.pos + 4 > data.length) throw new Error("inflate: unexpected end of data");
+      const len = (data[r.pos] ?? 0) | (data[r.pos + 1] ?? 0) << 8;
+      r.pos += 4;
+      if (r.pos + len > data.length) throw new Error("inflate: unexpected end of data");
+      for (let i = 0; i < len; i++) push(data[r.pos++] ?? 0);
+    } else if (type === 1 || type === 2) {
+      const { lit, dist } = type === 1 ? fixedTrees() : dynamicTrees(r);
+      for (; ; ) {
+        const sym = r.decode(lit);
+        if (sym === 256) break;
+        if (sym < 256) {
+          push(sym);
+          continue;
+        }
+        const index = sym - 257;
+        const len = r.read(LENGTH_EXTRA[index] ?? 0, LENGTH_BASE[index] ?? 0);
+        const distSym = r.decode(dist);
+        const offset = r.read(DIST_EXTRA[distSym] ?? 0, DIST_BASE[distSym] ?? 0);
+        if (offset > length) throw new Error("inflate: invalid distance");
+        for (let i = 0; i < len; i++) push(out[length - offset] ?? 0);
+      }
+    } else {
+      throw new Error("inflate: invalid block type");
+    }
+  } while (!final);
+  return out.subarray(0, length);
+}
+
+// src/marking.ts
+var IPTC_BASE = "http://cv.iptc.org/newscodes/digitalsourcetype/";
+var SCHEMA_ORG = {
+  trainedAlgorithmicMedia: "https://schema.org/TrainedAlgorithmicMediaDigitalSource",
+  compositeWithTrainedAlgorithmicMedia: "https://schema.org/CompositeWithTrainedAlgorithmicMediaDigitalSource",
+  algorithmicallyEnhanced: "https://schema.org/AlgorithmicallyEnhancedDigitalSource",
+  algorithmicMedia: "https://schema.org/AlgorithmicMediaDigitalSource",
+  compositeSynthetic: "https://schema.org/CompositeSyntheticDigitalSource"
+};
+var DEFAULT_SOURCE = {
+  generated: "trainedAlgorithmicMedia",
+  edited: "compositeWithTrainedAlgorithmicMedia",
+  deepfake: "trainedAlgorithmicMedia"
+};
+function iptcSourceType(type) {
+  return IPTC_BASE + type;
+}
+function parseSourceType(value) {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  const name = trimmed.startsWith(IPTC_BASE) ? trimmed.slice(IPTC_BASE.length) : trimmed;
+  if (name in SCHEMA_ORG) return name;
+  for (const [type, uri] of Object.entries(SCHEMA_ORG)) {
+    if (uri === trimmed) return type;
+  }
+  return void 0;
+}
+function isAiSourceType(type) {
+  return type === "trainedAlgorithmicMedia" || type === "compositeWithTrainedAlgorithmicMedia" || type === "algorithmicallyEnhanced";
+}
+function createMarking(input = {}) {
+  const kind = input.kind ?? "generated";
+  const createdAt = input.createdAt instanceof Date ? input.createdAt.toISOString() : input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const marking = {
+    kind,
+    sourceType: input.sourceType ?? DEFAULT_SOURCE[kind],
+    createdAt,
+    humanReviewed: input.humanReviewed ?? false
+  };
+  if (input.generator) marking.generator = input.generator;
+  if (input.generatorVersion) marking.generatorVersion = input.generatorVersion;
+  if (input.provider) marking.provider = input.provider;
+  if (input.disclosureUrl) marking.disclosureUrl = input.disclosureUrl;
+  if (input.description) marking.description = input.description;
+  return marking;
+}
+function generatorName(m) {
+  if (!m.generator) return "";
+  return m.generatorVersion ? `${m.generator} ${m.generatorVersion}` : m.generator;
+}
+
+// src/image.ts
+var XMP_NS = "http://ns.adobe.com/xap/1.0/\0";
+var WITNESS_NS = "https://packages.sweber.dev/witness/ns/1.0/";
+function detectImageFormat(bytes) {
+  if (bytes.length >= 8 && bytes[0] === 137 && ascii(bytes, 1, 3) === "PNG") return "png";
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return "jpeg";
+  }
+  if (bytes.length >= 12 && ascii(bytes, 0, 4) === "RIFF" && ascii(bytes, 8, 4) === "WEBP") {
+    return "webp";
+  }
+  return null;
+}
+function markImage(bytes, input = {}, options = {}) {
+  const format = detectImageFormat(bytes);
+  if (!format) return { bytes, status: "unsupported", format };
+  if (options.c2pa !== "overwrite" && hasC2pa(bytes, format)) {
+    return { bytes, status: "skipped-c2pa", format };
+  }
+  const marking = "sourceType" in input && "humanReviewed" in input ? input : createMarking(input);
+  const existing = readXmp(bytes, format);
+  const xmp = buildXmp(marking, existing);
+  const out = format === "png" ? writePng(bytes, xmp) : format === "jpeg" ? writeJpeg(bytes, xmp) : writeWebp(bytes, xmp);
+  return { bytes: out, status: "marked", format };
+}
+function readImageMarking(bytes) {
+  const format = detectImageFormat(bytes);
+  if (!format) return { format, xmp: null, aiGenerated: false, witness: false, c2pa: false };
+  const xmp = readXmp(bytes, format);
+  const sourceType = xmp ? parseSourceType(xmpProperty(xmp, "Iptc4xmpExt:DigitalSourceType")) : void 0;
+  const generator = xmp ? xmpProperty(xmp, "Iptc4xmpExt:AISystemUsed") ?? xmpProperty(xmp, "xmp:CreatorTool") : void 0;
+  const info = {
+    format,
+    xmp,
+    aiGenerated: isAiSourceType(sourceType),
+    witness: xmp?.includes(WITNESS_NS) ?? false,
+    c2pa: hasC2pa(bytes, format)
+  };
+  if (sourceType) info.sourceType = sourceType;
+  if (generator) info.generator = generator;
+  return info;
+}
+function buildXmp(marking, existing) {
+  const description = buildDescription(marking);
+  if (existing?.includes("</rdf:RDF>")) {
+    const cleaned = existing.replace(/<rdf:Description\b[^>]*witness:marker="1"[^>]*\/>\s*/g, "").replace(
+      /<rdf:Description\b[^>]*witness:marker="1"[^>]*>[\s\S]*?<\/rdf:Description>\s*/g,
+      ""
+    );
+    return cleaned.replace("</rdf:RDF>", `${description}
+</rdf:RDF>`);
+  }
+  return [
+    '<?xpacket begin="\uFEFF" id="W5M0MpCehiHzreSzNTczkc9d"?>',
+    '<x:xmpmeta xmlns:x="adobe:ns:meta/">',
+    '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">',
+    description,
+    "</rdf:RDF>",
+    "</x:xmpmeta>",
+    '<?xpacket end="w"?>'
+  ].join("\n");
+}
+function buildDescription(m) {
+  const attributes = [
+    ["rdf:about", ""],
+    ["xmlns:Iptc4xmpExt", "http://iptc.org/std/Iptc4xmpExt/2008-02-29/"],
+    ["xmlns:xmp", "http://ns.adobe.com/xap/1.0/"],
+    ["xmlns:dc", "http://purl.org/dc/elements/1.1/"],
+    ["xmlns:witness", WITNESS_NS],
+    ["witness:marker", "1"],
+    ["witness:kind", m.kind],
+    ["Iptc4xmpExt:DigitalSourceType", iptcSourceType(m.sourceType)],
+    ["xmp:CreateDate", m.createdAt]
+  ];
+  if (m.generator) {
+    attributes.push(["Iptc4xmpExt:AISystemUsed", m.generator]);
+    attributes.push(["xmp:CreatorTool", generatorName(m)]);
+  }
+  if (m.generatorVersion) attributes.push(["Iptc4xmpExt:AISystemVersionUsed", m.generatorVersion]);
+  if (m.provider) attributes.push(["witness:provider", m.provider]);
+  if (m.disclosureUrl) attributes.push(["witness:disclosureUrl", m.disclosureUrl]);
+  if (m.humanReviewed) attributes.push(["witness:humanReviewed", "True"]);
+  const attrs = attributes.map(([name, value]) => `
+  ${name}="${escapeXml(value)}"`).join("");
+  const description = m.description ? `
+  <dc:description><rdf:Alt><rdf:li xml:lang="x-default">${escapeXml(m.description)}</rdf:li></rdf:Alt></dc:description>
+` : "";
+  return description ? `<rdf:Description${attrs}>${description}</rdf:Description>` : `<rdf:Description${attrs}/>`;
+}
+function xmpProperty(xmp, name) {
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const attribute = new RegExp(`${escaped}="([^"]*)"`).exec(xmp);
+  if (attribute?.[1] !== void 0) return unescapeXml(attribute[1]);
+  const element = new RegExp(
+    `<${escaped}(?:\\s+rdf:resource="([^"]*)")?\\s*(?:/>|>([\\s\\S]*?)</${escaped}>)`
+  ).exec(xmp);
+  if (!element) return void 0;
+  if (element[1] !== void 0) return unescapeXml(element[1]);
+  const inner = element[2] ?? "";
+  const li = /<rdf:li[^>]*>([\s\S]*?)<\/rdf:li>/.exec(inner);
+  const value = (li ? li[1] : inner)?.trim();
+  return value ? unescapeXml(value) : void 0;
+}
+function writePng(bytes, xmp) {
+  const chunks = pngChunks(bytes).filter((chunk) => !isPngXmp(bytes, chunk));
+  const itxt = pngChunk(
+    "iTXt",
+    concat(latin1("XML:com.adobe.xmp"), new Uint8Array([0, 0, 0, 0, 0]), utf8(xmp))
+  );
+  const parts = [bytes.subarray(0, 8)];
+  for (const chunk of chunks) {
+    parts.push(bytes.subarray(chunk.offset, chunk.end));
+    if (chunk.type === "IHDR") parts.push(itxt);
+  }
+  return concat(...parts);
+}
+function pngChunks(bytes) {
+  const chunks = [];
+  let offset = 8;
+  while (offset + 12 <= bytes.length) {
+    const length = readU32BE(bytes, offset);
+    const type = ascii(bytes, offset + 4, 4);
+    const dataStart = offset + 8;
+    const dataEnd = dataStart + length;
+    const end = dataEnd + 4;
+    if (end > bytes.length) throw new Error("Witness: truncated PNG chunk");
+    chunks.push({ type, offset, dataStart, dataEnd, end });
+    offset = end;
+    if (type === "IEND") break;
+  }
+  return chunks;
+}
+function isPngXmp(bytes, chunk) {
+  return (chunk.type === "iTXt" || chunk.type === "zTXt") && ascii(bytes, chunk.dataStart, 18) === "XML:com.adobe.xmp\0";
+}
+function readPngXmp(bytes) {
+  for (const chunk of pngChunks(bytes)) {
+    if (!isPngXmp(bytes, chunk)) continue;
+    let p = chunk.dataStart + 18;
+    let compressed;
+    if (chunk.type === "zTXt") {
+      compressed = true;
+      p += 1;
+    } else {
+      compressed = bytes[p] === 1;
+      p += 2;
+      while (p < chunk.dataEnd && bytes[p] !== 0) p++;
+      p++;
+      while (p < chunk.dataEnd && bytes[p] !== 0) p++;
+      p++;
+    }
+    const data = bytes.subarray(p, chunk.dataEnd);
+    try {
+      return new TextDecoder().decode(compressed ? inflateZlib(data) : data);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function pngChunk(type, data) {
+  const out = new Uint8Array(12 + data.length);
+  writeU32BE(out, 0, data.length);
+  out.set(latin1(type), 4);
+  out.set(data, 8);
+  writeU32BE(out, 8 + data.length, crc32(out.subarray(4, 8 + data.length)));
+  return out;
+}
+function jpegSegments(bytes) {
+  const segments = [];
+  let offset = 2;
+  while (offset + 4 <= bytes.length) {
+    if (bytes[offset] !== 255) throw new Error("Witness: invalid JPEG marker");
+    let markerOffset = offset;
+    while (bytes[markerOffset + 1] === 255) markerOffset++;
+    const marker = bytes[markerOffset + 1] ?? 0;
+    if (marker === 218 || marker === 217) return { segments, scanStart: offset };
+    const length = readU16BE(bytes, markerOffset + 2);
+    const end = markerOffset + 2 + length;
+    if (end > bytes.length) throw new Error("Witness: truncated JPEG segment");
+    segments.push({ marker, offset, dataStart: markerOffset + 4, end });
+    offset = end;
+  }
+  return { segments, scanStart: offset };
+}
+function isJpegXmp(bytes, segment) {
+  return segment.marker === 225 && ascii(bytes, segment.dataStart, XMP_NS.length) === XMP_NS;
+}
+function writeJpeg(bytes, xmp) {
+  const { segments, scanStart } = jpegSegments(bytes);
+  const payload = concat(latin1(XMP_NS), utf8(xmp));
+  if (payload.length + 2 > 65535) throw new Error("Witness: XMP packet too large for JPEG");
+  const app1 = new Uint8Array(4 + payload.length);
+  app1[0] = 255;
+  app1[1] = 225;
+  app1[2] = payload.length + 2 >> 8 & 255;
+  app1[3] = payload.length + 2 & 255;
+  app1.set(payload, 4);
+  const kept = segments.filter((segment) => !isJpegXmp(bytes, segment));
+  let insertAt = 0;
+  while (insertAt < kept.length) {
+    const segment = kept[insertAt];
+    if (!segment) break;
+    const isJfif = segment.marker === 224;
+    const isExif = segment.marker === 225 && ascii(bytes, segment.dataStart, 4) === "Exif";
+    if (!isJfif && !isExif) break;
+    insertAt++;
+  }
+  const parts = [bytes.subarray(0, 2)];
+  kept.forEach((segment, index) => {
+    if (index === insertAt) parts.push(app1);
+    parts.push(bytes.subarray(segment.offset, segment.end));
+  });
+  if (insertAt >= kept.length) parts.push(app1);
+  parts.push(bytes.subarray(scanStart));
+  return concat(...parts);
+}
+function readJpegXmp(bytes) {
+  for (const segment of jpegSegments(bytes).segments) {
+    if (isJpegXmp(bytes, segment)) {
+      return new TextDecoder().decode(
+        bytes.subarray(segment.dataStart + XMP_NS.length, segment.end)
+      );
+    }
+  }
+  return null;
+}
+function webpChunks(bytes) {
+  const chunks = [];
+  const riffEnd = Math.min(bytes.length, 8 + readU32LE(bytes, 4));
+  let offset = 12;
+  while (offset + 8 <= riffEnd) {
+    const fourcc = ascii(bytes, offset, 4);
+    const size = readU32LE(bytes, offset + 4);
+    const dataStart = offset + 8;
+    const end = dataStart + size + size % 2;
+    if (dataStart + size > bytes.length) throw new Error("Witness: truncated WebP chunk");
+    chunks.push({ fourcc, offset, dataStart, size, end: Math.min(end, bytes.length) });
+    offset = end;
+  }
+  return chunks;
+}
+function writeWebp(bytes, xmp) {
+  const chunks = webpChunks(bytes).filter((chunk) => chunk.fourcc !== "XMP ");
+  const first = chunks[0];
+  if (!first) throw new Error("Witness: empty WebP file");
+  const parts = [];
+  if (first.fourcc === "VP8X") {
+    const vp8x = bytes.slice(first.offset, first.end);
+    vp8x[8] = (vp8x[8] ?? 0) | 4;
+    parts.push(vp8x);
+    for (const chunk of chunks.slice(1)) parts.push(bytes.subarray(chunk.offset, chunk.end));
+  } else {
+    const { width, height, alpha } = webpCanvas(bytes, first);
+    const data = new Uint8Array(10);
+    data[0] = 4 | (alpha ? 16 : 0);
+    writeU24LE(data, 4, width - 1);
+    writeU24LE(data, 7, height - 1);
+    parts.push(riffChunk("VP8X", data));
+    for (const chunk of chunks) parts.push(bytes.subarray(chunk.offset, chunk.end));
+  }
+  parts.push(riffChunk("XMP ", utf8(xmp)));
+  const body = concat(...parts);
+  const out = new Uint8Array(12 + body.length);
+  out.set(latin1("RIFF"), 0);
+  writeU32LE(out, 4, 4 + body.length);
+  out.set(latin1("WEBP"), 8);
+  out.set(body, 12);
+  return out;
+}
+function webpCanvas(bytes, chunk) {
+  const d = chunk.dataStart;
+  if (chunk.fourcc === "VP8 ") {
+    if (bytes[d + 3] !== 157 || bytes[d + 4] !== 1 || bytes[d + 5] !== 42) {
+      throw new Error("Witness: invalid VP8 frame");
+    }
+    return {
+      width: readU16LE(bytes, d + 6) & 16383,
+      height: readU16LE(bytes, d + 8) & 16383,
+      alpha: false
+    };
+  }
+  if (chunk.fourcc === "VP8L") {
+    if (bytes[d] !== 47) throw new Error("Witness: invalid VP8L frame");
+    const bits = readU32LE(bytes, d + 1);
+    return {
+      width: (bits & 16383) + 1,
+      height: (bits >>> 14 & 16383) + 1,
+      alpha: (bits >>> 28 & 1) === 1
+    };
+  }
+  throw new Error(`Witness: unexpected WebP chunk ${chunk.fourcc}`);
+}
+function readWebpXmp(bytes) {
+  const chunk = webpChunks(bytes).find((c) => c.fourcc === "XMP ");
+  return chunk ? new TextDecoder().decode(bytes.subarray(chunk.dataStart, chunk.dataStart + chunk.size)) : null;
+}
+function riffChunk(fourcc, data) {
+  const out = new Uint8Array(8 + data.length + data.length % 2);
+  out.set(latin1(fourcc), 0);
+  writeU32LE(out, 4, data.length);
+  out.set(data, 8);
+  return out;
+}
+function readXmp(bytes, format) {
+  if (format === "png") return readPngXmp(bytes);
+  if (format === "jpeg") return readJpegXmp(bytes);
+  return readWebpXmp(bytes);
+}
+function hasC2pa(bytes, format) {
+  if (format === "png") return pngChunks(bytes).some((chunk) => chunk.type === "caBX");
+  if (format === "webp") return webpChunks(bytes).some((chunk) => chunk.fourcc === "C2PA");
+  return jpegSegments(bytes).segments.some(
+    (segment) => segment.marker === 235 && ascii(bytes, segment.dataStart, Math.min(64, segment.end - segment.dataStart)).includes(
+      "c2pa"
+    )
+  );
+}
+function ascii(bytes, offset, length) {
+  let out = "";
+  for (let i = offset; i < offset + length && i < bytes.length; i++) {
+    out += String.fromCharCode(bytes[i] ?? 0);
+  }
+  return out;
+}
+function latin1(text) {
+  const out = new Uint8Array(text.length);
+  for (let i = 0; i < text.length; i++) out[i] = text.charCodeAt(i) & 255;
+  return out;
+}
+function utf8(text) {
+  return new TextEncoder().encode(text);
+}
+function concat(...parts) {
+  const out = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function readU16BE(b, o) {
+  return (b[o] ?? 0) << 8 | (b[o + 1] ?? 0);
+}
+function readU16LE(b, o) {
+  return (b[o] ?? 0) | (b[o + 1] ?? 0) << 8;
+}
+function readU32BE(b, o) {
+  return ((b[o] ?? 0) << 24 | (b[o + 1] ?? 0) << 16 | (b[o + 2] ?? 0) << 8 | (b[o + 3] ?? 0)) >>> 0;
+}
+function readU32LE(b, o) {
+  return ((b[o] ?? 0) | (b[o + 1] ?? 0) << 8 | (b[o + 2] ?? 0) << 16 | (b[o + 3] ?? 0) << 24) >>> 0;
+}
+function writeU32BE(b, o, v) {
+  b[o] = v >>> 24 & 255;
+  b[o + 1] = v >>> 16 & 255;
+  b[o + 2] = v >>> 8 & 255;
+  b[o + 3] = v & 255;
+}
+function writeU32LE(b, o, v) {
+  b[o] = v & 255;
+  b[o + 1] = v >>> 8 & 255;
+  b[o + 2] = v >>> 16 & 255;
+  b[o + 3] = v >>> 24 & 255;
+}
+function writeU24LE(b, o, v) {
+  b[o] = v & 255;
+  b[o + 1] = v >>> 8 & 255;
+  b[o + 2] = v >>> 16 & 255;
+}
+var crcTable = null;
+function crc32(data) {
+  if (!crcTable) {
+    crcTable = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+      let c = n;
+      for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+      crcTable[n] = c >>> 0;
+    }
+  }
+  let crc = 4294967295;
+  for (const byte of data) crc = (crcTable[(crc ^ byte) & 255] ?? 0) ^ crc >>> 8;
+  return (crc ^ 4294967295) >>> 0;
+}
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function unescapeXml(value) {
+  return value.replace(/&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+
+// src/watermark.ts
+var MAGIC = [87, 49];
+function readTextWatermark(text) {
+  for (const run of selectorRuns(text)) {
+    const found = findInRun(run.bytes);
+    if (found) {
+      const raw = new TextDecoder().decode(new Uint8Array(found.payload));
+      return { ...decodePayload(raw), raw };
+    }
+  }
+  return null;
+}
+function decodePayload(raw) {
+  const result = {};
+  for (const field of raw.split(";")) {
+    const index = field.indexOf("=");
+    if (index < 1) continue;
+    const key = field.slice(0, index);
+    let value;
+    try {
+      value = decodeURIComponent(field.slice(index + 1));
+    } catch {
+      continue;
+    }
+    if (key === "g") result.generator = value;
+    else if (key === "t") result.createdAt = value;
+    else if (key === "i") result.id = value;
+  }
+  return result;
+}
+function selectorToByte(codePoint) {
+  if (codePoint >= 65024 && codePoint <= 65039) return codePoint - 65024;
+  if (codePoint >= 917760 && codePoint <= 917999) return codePoint - 917760 + 16;
+  return null;
+}
+function selectorRuns(text) {
+  const runs = [];
+  let current = null;
+  let index = 0;
+  for (const char of text) {
+    const byte = selectorToByte(char.codePointAt(0) ?? 0);
+    if (byte === null) {
+      current = null;
+    } else {
+      if (!current) {
+        current = { start: index, bytes: [] };
+        runs.push(current);
+      }
+      current.bytes.push(byte);
+    }
+    index++;
+  }
+  return runs;
+}
+function findInRun(bytes) {
+  for (let i = 0; i + MAGIC.length < bytes.length; i++) {
+    if (bytes[i] !== MAGIC[0] || bytes[i + 1] !== MAGIC[1]) continue;
+    const length = bytes[i + 2];
+    if (length === void 0) continue;
+    const start = i + 3;
+    const end = start + length;
+    if (end > bytes.length) continue;
+    return { start: i, end, payload: bytes.slice(start, end) };
+  }
+  return null;
+}
+
+// src/cli.ts
+var HELP = `witness: AI Act Article 50 marking for images and text
+
+Usage
+  witness mark <files...> (--out <dir> | --in-place) [options]
+  witness inspect <files...> [--json] [--require]
+
+mark options
+  --generator <name>         AI system, e.g. "gpt-image-2"
+  --generator-version <v>    its version
+  --kind <kind>              generated (default), edited or deepfake
+  --provider <name>          your company or product
+  --url <url>                page that explains how you use AI
+  --description <text>       free text written to dc:description
+  --overwrite-c2pa           also rewrite files that carry a C2PA manifest
+
+inspect options
+  --json                     one JSON object per file
+  --require                  exit 1 if a file carries no AI marking
+
+Images: PNG, JPEG, WebP (XMP with IPTC Digital Source Type).
+Text files are checked for the Witness text watermark.`;
+var KINDS = ["generated", "edited", "deepfake"];
+async function runCli(argv, io = defaultIo) {
+  const [command, ...rest] = argv;
+  if (!command || command === "--help" || command === "-h" || command === "help") {
+    io.out(HELP);
+    return command ? 0 : 1;
+  }
+  try {
+    if (command === "mark") return await mark(rest, io);
+    if (command === "inspect") return await inspect(rest, io);
+    io.err(`Unknown command "${command}". Run "witness --help".`);
+    return 1;
+  } catch (error) {
+    io.err(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+}
+async function mark(argv, io) {
+  const { values, positionals } = (0, import_node_util.parseArgs)({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      out: { type: "string" },
+      "in-place": { type: "boolean" },
+      generator: { type: "string" },
+      "generator-version": { type: "string" },
+      kind: { type: "string" },
+      provider: { type: "string" },
+      url: { type: "string" },
+      description: { type: "string" },
+      "overwrite-c2pa": { type: "boolean" }
+    }
+  });
+  if (positionals.length === 0) throw new Error("witness mark: no files given.");
+  if (!values.out && !values["in-place"]) {
+    throw new Error("witness mark: pass --out <dir> or --in-place.");
+  }
+  const kind = values.kind ?? "generated";
+  if (!KINDS.includes(kind))
+    throw new Error(`witness mark: --kind must be one of ${KINDS.join(", ")}.`);
+  const input = { kind };
+  if (values.generator) input.generator = values.generator;
+  if (values["generator-version"]) input.generatorVersion = values["generator-version"];
+  if (values.provider) input.provider = values.provider;
+  if (values.url) input.disclosureUrl = values.url;
+  if (values.description) input.description = values.description;
+  if (values.out) await (0, import_promises.mkdir)(values.out, { recursive: true });
+  let failed = 0;
+  for (const file of positionals) {
+    const bytes = new Uint8Array(await (0, import_promises.readFile)(file));
+    const result = markImage(bytes, input, {
+      c2pa: values["overwrite-c2pa"] ? "overwrite" : "skip"
+    });
+    if (result.status === "unsupported") {
+      io.err(`${file}: not a PNG, JPEG or WebP file, skipped`);
+      failed++;
+      continue;
+    }
+    if (result.status === "skipped-c2pa") {
+      io.err(`${file}: carries a C2PA manifest, left unchanged (use --overwrite-c2pa to force)`);
+      continue;
+    }
+    const target = values.out ? (0, import_node_path.join)(values.out, (0, import_node_path.basename)(file)) : file;
+    await (0, import_promises.writeFile)(target, result.bytes);
+    io.out(`${file}: marked (${result.format}) -> ${target}`);
+  }
+  return failed > 0 ? 1 : 0;
+}
+async function inspect(argv, io) {
+  const { values, positionals } = (0, import_node_util.parseArgs)({
+    args: argv,
+    allowPositionals: true,
+    options: { json: { type: "boolean" }, require: { type: "boolean" } }
+  });
+  if (positionals.length === 0) throw new Error("witness inspect: no files given.");
+  let unmarked = 0;
+  for (const file of positionals) {
+    const bytes = new Uint8Array(await (0, import_promises.readFile)(file));
+    const format = detectImageFormat(bytes);
+    if (format) {
+      const info = readImageMarking(bytes);
+      const marked = info.aiGenerated || info.c2pa;
+      if (!marked) unmarked++;
+      if (values.json) {
+        const { xmp: _xmp, ...rest } = info;
+        io.out(JSON.stringify({ file, ...rest }));
+      } else {
+        const parts = [
+          `${file}: ${format}`,
+          info.sourceType ? `source type ${iptcSourceType(info.sourceType)}` : "no IPTC source type",
+          info.generator ? `generator ${info.generator}` : null,
+          info.c2pa ? "C2PA manifest present (not verified)" : null,
+          marked ? "AI-marked" : "NOT AI-marked"
+        ];
+        io.out(parts.filter(Boolean).join(", "));
+      }
+      continue;
+    }
+    const ext = (0, import_node_path.extname)(file).toLowerCase();
+    const text = new TextDecoder().decode(bytes);
+    const watermark = readTextWatermark(text);
+    if (!watermark) unmarked++;
+    if (values.json) {
+      io.out(JSON.stringify({ file, format: ext.slice(1) || "text", watermark }));
+    } else {
+      io.out(
+        watermark ? `${file}: text watermark found${watermark.generator ? `, generator ${watermark.generator}` : ""}${watermark.createdAt ? `, created ${watermark.createdAt}` : ""}` : `${file}: no Witness text watermark`
+      );
+    }
+  }
+  return values.require && unmarked > 0 ? 1 : 0;
+}
+var defaultIo = {
+  out: (line) => process.stdout.write(`${line}
+`),
+  err: (line) => process.stderr.write(`${line}
+`)
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runCli
+});
+//# sourceMappingURL=cli.cjs.map