@enslo/sd-metadata 2.1.1 → 2.2.0

package/dist/index.js

@@ -164,6 +164,62 @@ function writeUint32(data, offset, value, isLittleEndian) {
   );
 }
 
+// src/utils/xmp.ts
+var XMP_KEYWORD = "XML:com.adobe.xmp";
+var XMP_APP1_PREFIX = /* @__PURE__ */ new TextEncoder().encode(
+  "http://ns.adobe.com/xap/1.0/\0"
+);
+function matchesXmpPrefix(data, offset) {
+  if (offset + XMP_APP1_PREFIX.length > data.length) return false;
+  for (let i = 0; i < XMP_APP1_PREFIX.length; i++) {
+    if (data[offset + i] !== XMP_APP1_PREFIX[i]) return false;
+  }
+  return true;
+}
+function isXmpKeyword(keyword) {
+  return keyword === XMP_KEYWORD;
+}
+var MAX_XMP_TEXT_LENGTH = 65535;
+function extractXmpEntries(xmpText) {
+  if (xmpText.length > MAX_XMP_TEXT_LENGTH) return null;
+  const candidates = [
+    ["CreatorTool", extractSimpleElement(xmpText, "xmp", "CreatorTool")],
+    ["UserComment", extractAltElement(xmpText, "exif", "UserComment")],
+    ["parameters", extractAltElement(xmpText, "dc", "description")]
+  ];
+  const entries = candidates.filter(
+    (entry) => entry[1] !== void 0
+  );
+  return entries.length > 0 ? Object.fromEntries(entries) : null;
+}
+function extractSimpleElement(xmp, ns, field) {
+  const pattern = new RegExp(`<${ns}:${field}>([^<]*)</${ns}:${field}>`);
+  const match = xmp.match(pattern);
+  return match?.[1] ? decodeXmlEntities(match[1]) : void 0;
+}
+function extractAltElement(xmp, ns, field) {
+  const pattern = new RegExp(
+    `<${ns}:${field}>[\\s\\S]*?<rdf:li[^>]*(?<!/)>([\\s\\S]*?)</rdf:li>[\\s\\S]*?</${ns}:${field}>`
+  );
+  const match = xmp.match(pattern);
+  return match?.[1] ? decodeXmlEntities(match[1]) : void 0;
+}
+function decodeXmlEntities(text) {
+  return text.replace(/&#x([0-9a-fA-F]+);/g, (match, hex) => {
+    try {
+      return String.fromCodePoint(parseInt(hex, 16));
+    } catch {
+      return match;
+    }
+  }).replace(/&#(\d+);/g, (match, dec) => {
+    try {
+      return String.fromCodePoint(parseInt(dec, 10));
+    } catch {
+      return match;
+    }
+  }).replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+
 // src/utils/exif-constants.ts
 var USER_COMMENT_TAG = 37510;
 var IMAGE_DESCRIPTION_TAG = 270;
@@ -317,6 +373,7 @@ function writeJpegMetadata(data, segments) {
     return Result.error({ type: "invalidSignature" });
   }
   const comSegments = segments.filter((s) => s.source.type === "jpegCom");
+  const xmpSegments = segments.filter((s) => s.source.type === "xmpPacket");
   const exifSegments = segments.filter(
     (s) => s.source.type === "exifUserComment" || s.source.type === "exifImageDescription" || s.source.type === "exifMake"
   );
@@ -326,11 +383,16 @@ function writeJpegMetadata(data, segments) {
   }
   const { beforeSos, scanData } = collectResult.value;
   const app1Segment = exifSegments.length > 0 ? buildApp1Segment(exifSegments) : null;
-  const comSegmentData = comSegments.map((s) => buildComSegment(s.data));
+  const firstXmp = xmpSegments[0];
+  const xmpApp1Segment = firstXmp ? buildXmpApp1Segment(firstXmp.data) : null;
+  const comSegmentData = comSegments.map((s) => buildComSegment(s.data)).filter((s) => s !== null);
   let totalSize = 2;
   if (app1Segment) {
     totalSize += app1Segment.length;
   }
+  if (xmpApp1Segment) {
+    totalSize += xmpApp1Segment.length;
+  }
   for (const seg of beforeSos) {
     totalSize += seg.length;
   }
@@ -346,6 +408,10 @@ function writeJpegMetadata(data, segments) {
     output.set(app1Segment, offset);
     offset += app1Segment.length;
   }
+  if (xmpApp1Segment) {
+    output.set(xmpApp1Segment, offset);
+    offset += xmpApp1Segment.length;
+  }
   for (const seg of beforeSos) {
     output.set(seg, offset);
     offset += seg.length;
@@ -400,8 +466,9 @@ function collectNonMetadataSegments(data) {
     data[offset + 5] === 102 && // f
     data[offset + 6] === 0 && // NULL
     data[offset + 7] === 0;
+    const isXmpApp1 = marker === APP1_MARKER && !isExifApp1 && matchesXmpPrefix(data, offset + 2);
     const isCom = marker === COM_MARKER;
-    if (!isExifApp1 && !isCom) {
+    if (!isExifApp1 && !isXmpApp1 && !isCom) {
       beforeSos.push(data.slice(segmentStart, segmentEnd));
     }
     offset = segmentEnd;
@@ -425,9 +492,26 @@ function buildApp1Segment(segments) {
   segment.set(tiffData, 4 + EXIF_HEADER.length);
   return segment;
 }
+function buildXmpApp1Segment(xmpText) {
+  const textBytes = new TextEncoder().encode(xmpText);
+  const segmentLength = 2 + XMP_APP1_PREFIX.length + textBytes.length;
+  if (segmentLength > 65535) {
+    return null;
+  }
+  const segment = new Uint8Array(2 + segmentLength);
+  segment[0] = 255;
+  segment[1] = APP1_MARKER;
+  writeUint16BE(segment, 2, segmentLength);
+  segment.set(XMP_APP1_PREFIX, 4);
+  segment.set(textBytes, 4 + XMP_APP1_PREFIX.length);
+  return segment;
+}
 function buildComSegment(text) {
   const textBytes = new TextEncoder().encode(text);
   const segmentLength = 2 + textBytes.length;
+  if (segmentLength > 65535) {
+    return null;
+  }
   const segment = new Uint8Array(2 + segmentLength);
   segment[0] = 255;
   segment[1] = COM_MARKER;
@@ -594,18 +678,25 @@ function writeWebpMetadata(data, segments) {
   if (!isWebp(data)) {
     return Result.error({ type: "invalidSignature" });
   }
-  const collectResult = collectNonExifChunks(data);
+  const xmpSegments = segments.filter((s) => s.source.type === "xmpPacket");
+  const exifSegments = segments.filter((s) => s.source.type !== "xmpPacket");
+  const collectResult = collectNonMetadataChunks(data);
   if (!collectResult.ok) {
     return collectResult;
   }
   const { chunks } = collectResult.value;
-  const exifChunk = buildExifChunk(segments);
+  const exifChunk = buildExifChunk(exifSegments);
+  const firstXmp = xmpSegments[0];
+  const xmpChunk = firstXmp ? buildXmpChunk(firstXmp.data) : null;
+  const metadataChunks = [];
+  if (exifChunk) metadataChunks.push(exifChunk);
+  if (xmpChunk) metadataChunks.push(xmpChunk);
   let newFileSize = 4;
   for (const chunk of chunks) {
     newFileSize += chunk.length;
   }
-  if (exifChunk) {
-    newFileSize += exifChunk.length;
+  for (const meta of metadataChunks) {
+    newFileSize += meta.length;
   }
   const output = new Uint8Array(8 + newFileSize);
   let offset = 0;
@@ -615,18 +706,23 @@ function writeWebpMetadata(data, segments) {
   offset += 4;
   output.set(WEBP_MARKER, offset);
   offset += 4;
-  let exifWritten = false;
+  let metadataWritten = false;
   for (const chunk of chunks) {
     output.set(chunk, offset);
     offset += chunk.length;
-    if (!exifWritten && exifChunk && isImageChunk(chunk)) {
-      output.set(exifChunk, offset);
-      offset += exifChunk.length;
-      exifWritten = true;
+    if (!metadataWritten && metadataChunks.length > 0 && isImageChunk(chunk)) {
+      for (const meta of metadataChunks) {
+        output.set(meta, offset);
+        offset += meta.length;
+      }
+      metadataWritten = true;
     }
   }
-  if (!exifWritten && exifChunk) {
-    output.set(exifChunk, offset);
+  if (!metadataWritten) {
+    for (const meta of metadataChunks) {
+      output.set(meta, offset);
+      offset += meta.length;
+    }
   }
   return Result.ok(output);
 }
@@ -635,7 +731,7 @@ function isImageChunk(chunk) {
   const type = readChunkType(chunk, 0);
   return type === "VP8 " || type === "VP8L" || type === "VP8X";
 }
-function collectNonExifChunks(data) {
+function collectNonMetadataChunks(data) {
   const chunks = [];
   let firstChunkType = "";
   let offset = 12;
@@ -651,7 +747,7 @@ function collectNonExifChunks(data) {
         message: `Chunk extends beyond file at offset ${offset}`
       });
     }
-    if (typeStr !== "EXIF") {
+    if (typeStr !== "EXIF" && typeStr !== "XMP ") {
       const paddedSize2 = chunkSize + chunkSize % 2;
       const chunkData = data.slice(offset, offset + 8 + paddedSize2);
       chunks.push(chunkData);
@@ -662,13 +758,10 @@ function collectNonExifChunks(data) {
   return Result.ok({ chunks, firstChunkType });
 }
 function buildExifChunk(segments) {
-  const exifSegments = segments.filter(
-    (s) => s.source.type === "exifUserComment" || s.source.type === "exifImageDescription" || s.source.type === "exifMake"
-  );
-  if (exifSegments.length === 0) {
+  if (segments.length === 0) {
     return null;
   }
-  const tiffData = buildExifTiffData(exifSegments);
+  const tiffData = buildExifTiffData(segments);
   if (tiffData.length === 0) {
     return null;
   }
@@ -680,6 +773,16 @@ function buildExifChunk(segments) {
   chunk.set(tiffData, 8);
   return chunk;
 }
+function buildXmpChunk(xmpText) {
+  const textBytes = new TextEncoder().encode(xmpText);
+  const chunkSize = textBytes.length;
+  const paddedSize = chunkSize + chunkSize % 2;
+  const chunk = new Uint8Array(8 + paddedSize);
+  chunk.set(new TextEncoder().encode("XMP "));
+  writeUint32LE(chunk, 4, chunkSize);
+  chunk.set(textBytes, 8);
+  return chunk;
+}
 
 // src/api/stringify.ts
 function normalizeLineEndings(text) {
@@ -1393,6 +1496,9 @@ function detectUniqueKeywords(entryRecord) {
   if (entryRecord.Software?.startsWith("NovelAI")) {
     return "novelai";
   }
+  if (entryRecord.CreatorTool?.startsWith("Draw Things")) {
+    return "draw-things";
+  }
   const keyResult = detectByUniqueKey(entryRecord);
   if (keyResult) return keyResult;
   if ("fooocus_scheme" in entryRecord) {
@@ -1531,6 +1637,60 @@ function detectFromA1111Format(text) {
   return null;
 }
 
+// src/parsers/draw-things.ts
+function parseDrawThings(entries) {
+  const jsonText = entries.UserComment?.startsWith("{") ? entries.UserComment : entries.Comment?.startsWith("{") ? entries.Comment : void 0;
+  if (!jsonText) {
+    return Result.error({ type: "unsupportedFormat" });
+  }
+  const parsed = parseJson(jsonText);
+  if (!parsed.ok || parsed.type !== "object") {
+    return Result.error({
+      type: "parseError",
+      message: "Invalid JSON in Draw Things metadata"
+    });
+  }
+  return buildMetadata(parsed.value);
+}
+function parseSize2(size) {
+  if (typeof size !== "string") return { width: 0, height: 0 };
+  const match = size.match(/^(\d+)x(\d+)$/);
+  if (!match) return { width: 0, height: 0 };
+  return { width: Number(match[1]), height: Number(match[2]) };
+}
+function buildMetadata(data) {
+  const str = (key) => {
+    const v = data[key];
+    return typeof v === "string" ? v : void 0;
+  };
+  const num = (key) => {
+    const v = data[key];
+    if (typeof v === "number" && v !== 0) return v;
+    return void 0;
+  };
+  const prompt = (str("c") ?? "").trim();
+  const negativePrompt = (str("uc") ?? "").trim();
+  const { width, height } = parseSize2(data.size);
+  const metadata = {
+    software: "draw-things",
+    prompt,
+    negativePrompt,
+    width,
+    height,
+    model: trimObject({
+      name: str("model")
+    }),
+    sampling: trimObject({
+      sampler: str("sampler"),
+      steps: num("steps"),
+      cfg: num("scale"),
+      seed: num("seed"),
+      denoise: num("strength")
+    })
+  };
+  return Result.ok(metadata);
+}
+
 // src/parsers/easydiffusion.ts
 function extractModelName(path) {
   if (!path) return void 0;
@@ -1539,7 +1699,7 @@ function extractModelName(path) {
 }
 function parseEasyDiffusion(entries) {
   if ("use_stable_diffusion_model" in entries) {
-    return buildMetadata(entries);
+    return buildMetadata2(entries);
   }
   const jsonText = entries.UserComment?.startsWith("{") ? entries.UserComment : entries.parameters?.startsWith("{") ? entries.parameters : void 0;
   if (!jsonText) {
@@ -1552,9 +1712,9 @@ function parseEasyDiffusion(entries) {
       message: "Invalid JSON in Easy Diffusion metadata"
     });
   }
-  return buildMetadata(parsed.value);
+  return buildMetadata2(parsed.value);
 }
-function buildMetadata(data) {
+function buildMetadata2(data) {
   const str = (key) => {
     const v = data[key];
     return typeof v === "string" ? v : void 0;
@@ -2015,6 +2175,8 @@ function parseMetadata(entries) {
     }
     case "ruined-fooocus":
       return parseRuinedFooocus(entries);
+    case "draw-things":
+      return parseDrawThings(entries);
     default:
       return Result.error({ type: "unsupportedFormat" });
   }
@@ -2295,6 +2457,15 @@ function readJpegMetadata(data) {
     const exifSegments = parseExifMetadataSegments(exifData);
     segments.push(...exifSegments);
   }
+  const xmpApp1 = findXmpApp1Segment(data);
+  if (xmpApp1) {
+    const xmpData = data.slice(xmpApp1.offset, xmpApp1.offset + xmpApp1.length);
+    const xmpText = new TextDecoder("utf-8").decode(xmpData);
+    segments.push({
+      source: { type: "xmpPacket" },
+      data: xmpText
+    });
+  }
   const comSegment = findComSegment(data);
   if (comSegment) {
     const comData = data.slice(
@@ -2343,6 +2514,35 @@ function findApp1Segment(data) {
   }
   return null;
 }
+function findXmpApp1Segment(data) {
+  let offset = 2;
+  while (offset < data.length - 4) {
+    if (data[offset] !== 255) {
+      offset++;
+      continue;
+    }
+    const marker = data[offset + 1];
+    if (marker === 255) {
+      offset++;
+      continue;
+    }
+    const length = readUint16BE(data, offset + 2);
+    if (marker === APP1_MARKER2 && length >= XMP_APP1_PREFIX.length + 2) {
+      const headerStart = offset + 4;
+      if (matchesXmpPrefix(data, headerStart)) {
+        return {
+          offset: headerStart + XMP_APP1_PREFIX.length,
+          length: length - 2 - XMP_APP1_PREFIX.length
+        };
+      }
+    }
+    offset += 2 + length;
+    if (marker === 218 || marker === 217) {
+      break;
+    }
+  }
+  return null;
+}
 function findComSegment(data) {
   let offset = 2;
   while (offset < data.length - 4) {
@@ -2507,15 +2707,27 @@ function readWebpMetadata(data) {
   if (!isWebp(data)) {
     return Result.error({ type: "invalidSignature" });
   }
+  const segments = [];
   const exifChunk = findExifChunk(data);
-  if (!exifChunk) {
-    return Result.ok([]);
+  if (exifChunk) {
+    const exifData = data.slice(
+      exifChunk.offset,
+      exifChunk.offset + exifChunk.length
+    );
+    segments.push(...parseExifMetadataSegments(exifData));
+  }
+  const xmpChunk = findXmpChunk(data);
+  if (xmpChunk) {
+    const xmpData = data.slice(
+      xmpChunk.offset,
+      xmpChunk.offset + xmpChunk.length
+    );
+    const xmpText = new TextDecoder("utf-8").decode(xmpData);
+    segments.push({
+      source: { type: "xmpPacket" },
+      data: xmpText
+    });
   }
-  const exifData = data.slice(
-    exifChunk.offset,
-    exifChunk.offset + exifChunk.length
-  );
-  const segments = parseExifMetadataSegments(exifData);
   return Result.ok(segments);
 }
 function findExifChunk(data) {
@@ -2523,6 +2735,23 @@ function findExifChunk(data) {
   while (offset + 8 <= data.length) {
     const chunkSize = readUint32LE(data, offset + 4);
     if (readChunkType(data, offset) === "EXIF") {
+      if (offset + 8 + chunkSize > data.length) return null;
+      return {
+        offset: offset + 8,
+        length: chunkSize
+      };
+    }
+    const paddedSize = chunkSize + chunkSize % 2;
+    offset += 8 + paddedSize;
+  }
+  return null;
+}
+function findXmpChunk(data) {
+  let offset = 12;
+  while (offset + 8 <= data.length) {
+    const chunkSize = readUint32LE(data, offset + 4);
+    if (readChunkType(data, offset) === "XMP ") {
+      if (offset + 8 + chunkSize > data.length) return null;
       return {
         offset: offset + 8,
         length: chunkSize
@@ -2536,20 +2765,37 @@ function findExifChunk(data) {
 
 // src/utils/convert.ts
 function pngChunksToRecord(chunks) {
-  return Object.fromEntries(chunks.map((c) => [c.keyword, c.text]));
+  return Object.fromEntries(
+    chunks.flatMap((chunk) => {
+      if (isXmpKeyword(chunk.keyword)) {
+        const expanded = extractXmpEntries(chunk.text);
+        if (expanded) return Object.entries(expanded);
+      }
+      return [[chunk.keyword, chunk.text]];
+    })
+  );
 }
 function segmentsToRecord(segments) {
   const record = {};
   for (const segment of segments) {
     const keyword = sourceToKeyword(segment.source);
     const text = segment.data;
-    if (segment.source.type === "exifUserComment" && text.startsWith("{")) {
-      const expanded = tryExpandNovelAIWebpFormat(text);
+    if (segment.source.type === "xmpPacket") {
+      const expanded = extractXmpEntries(text);
       if (expanded) {
         Object.assign(record, expanded);
         continue;
       }
     }
+    if (segment.source.type === "exifUserComment") {
+      if (text.startsWith("{")) {
+        const expanded = tryExpandNovelAIWebpFormat(text);
+        if (expanded) {
+          Object.assign(record, expanded);
+          continue;
+        }
+      }
+    }
     record[keyword] = text;
   }
   return record;
@@ -2579,6 +2825,8 @@ function sourceToKeyword(source) {
       return source.prefix ?? "ImageDescription";
     case "exifMake":
       return source.prefix ?? "Make";
+    case "xmpPacket":
+      return "XML:com.adobe.xmp";
   }
 }
 
@@ -2750,6 +2998,24 @@ function convertComfyUISegmentsToPng(segments) {
   return tryParseExtendedFormat(segments) ?? tryParseSaveImagePlusFormat(segments) ?? [];
 }
 
+// src/converters/draw-things.ts
+var XMP_KEYWORD2 = "XML:com.adobe.xmp";
+function convertDrawThingsPngToSegments(chunks) {
+  const xmpChunk = chunks.find((c) => isXmpKeyword(c.keyword));
+  if (!xmpChunk) return [];
+  return [
+    {
+      source: { type: "xmpPacket" },
+      data: xmpChunk.text
+    }
+  ];
+}
+function convertDrawThingsSegmentsToPng(segments) {
+  const xmpSegment = findSegment(segments, "xmpPacket");
+  if (!xmpSegment) return [];
+  return createITxtChunk(XMP_KEYWORD2, xmpSegment.data);
+}
+
 // src/converters/easydiffusion.ts
 function convertEasyDiffusionPngToSegments(chunks) {
   const json = Object.fromEntries(
@@ -3065,6 +3331,10 @@ var convertHfSpace = createFormatConverter(
   createPngToSegments("parameters"),
   createSegmentsToPng("parameters", "text-unicode-escape")
 );
+var convertDrawThings = createFormatConverter(
+  convertDrawThingsPngToSegments,
+  convertDrawThingsSegmentsToPng
+);
 var convertCivitai = createFormatConverter(
   convertCivitaiPngToSegments,
   convertCivitaiSegmentsToPng
@@ -3106,7 +3376,9 @@ var softwareConverters = {
   // InvokeAI
   invokeai: convertInvokeAI,
   // HuggingFace Space
-  "hf-space": convertHfSpace
+  "hf-space": convertHfSpace,
+  // Draw Things (XMP format)
+  "draw-things": convertDrawThings
 };
 
 // src/api/write.ts
@@ -3232,7 +3504,8 @@ var softwareLabels = Object.freeze({
   "hf-space": "Hugging Face Space",
   easydiffusion: "Easy Diffusion",
   fooocus: "Fooocus",
-  "ruined-fooocus": "Ruined Fooocus"
+  "ruined-fooocus": "Ruined Fooocus",
+  "draw-things": "Draw Things"
 });
 export {
   embed,