@enslo/sd-metadata 1.0.0

package/dist/index.js

@@ -0,0 +1,2805 @@
+// src/types.ts
+var Result = {
+  ok: (value) => ({ ok: true, value }),
+  error: (error) => ({ ok: false, error })
+};
+
+// src/converters/utils.ts
+var createTextChunk = (keyword, text) => text !== void 0 ? [{ type: "tEXt", keyword, text }] : [];
+var createITxtChunk = (keyword, text) => text !== void 0 ? [
+  {
+    type: "iTXt",
+    keyword,
+    compressionFlag: 0,
+    compressionMethod: 0,
+    languageTag: "",
+    translatedKeyword: "",
+    text
+  }
+] : [];
+var findSegment = (segments, type) => segments.find((s) => s.source.type === type);
+var stringify = (value) => {
+  if (value === void 0) return void 0;
+  return typeof value === "string" ? value : JSON.stringify(value);
+};
+
+// src/converters/chunk-encoding.ts
+var CHUNK_ENCODING_STRATEGIES = {
+  // Dynamic selection tools
+  a1111: "dynamic",
+  forge: "dynamic",
+  "forge-neo": "dynamic",
+  "sd-webui": "dynamic",
+  invokeai: "dynamic",
+  novelai: "dynamic",
+  "sd-next": "dynamic",
+  easydiffusion: "dynamic",
+  blind: "dynamic",
+  // Unicode escape tools (spec-compliant)
+  comfyui: "text-unicode-escape",
+  swarmui: "text-unicode-escape",
+  fooocus: "text-unicode-escape",
+  "ruined-fooocus": "text-unicode-escape",
+  "hf-space": "text-unicode-escape",
+  // Raw UTF-8 tools (non-compliant but compatible)
+  "stability-matrix": "text-utf8-raw",
+  tensorart: "text-utf8-raw"
+};
+function getEncodingStrategy(tool) {
+  return CHUNK_ENCODING_STRATEGIES[tool] ?? "text-unicode-escape";
+}
+function escapeUnicode(text) {
+  return text.replace(/[\u0100-\uffff]/g, (char) => {
+    const code = char.charCodeAt(0).toString(16).padStart(4, "0");
+    return `\\u${code}`;
+  });
+}
+function hasNonLatin1(text) {
+  return /[^\x00-\xFF]/.test(text);
+}
+function createEncodedChunk(keyword, text, strategy) {
+  if (text === void 0) return [];
+  switch (strategy) {
+    case "dynamic": {
+      const chunkType = hasNonLatin1(text) ? "iTXt" : "tEXt";
+      return chunkType === "iTXt" ? createITxtChunk(keyword, text) : createTextChunk(keyword, text);
+    }
+    case "text-unicode-escape": {
+      const escaped = escapeUnicode(text);
+      return createTextChunk(keyword, escaped);
+    }
+    case "text-utf8-raw": {
+      return createTextChunk(keyword, text);
+    }
+  }
+}
+
+// src/converters/a1111.ts
+function convertA1111PngToSegments(chunks) {
+  const parameters = chunks.find((c) => c.keyword === "parameters");
+  if (!parameters) {
+    return [];
+  }
+  return [
+    {
+      source: { type: "exifUserComment" },
+      data: parameters.text
+    }
+  ];
+}
+function convertA1111SegmentsToPng(segments) {
+  const userComment = segments.find((s) => s.source.type === "exifUserComment");
+  if (!userComment) {
+    return [];
+  }
+  return createEncodedChunk(
+    "parameters",
+    userComment.data,
+    getEncodingStrategy("a1111")
+  );
+}
+
+// src/utils/json.ts
+function parseJson(text) {
+  try {
+    return Result.ok(JSON.parse(text));
+  } catch {
+    return Result.error({
+      type: "parseError",
+      message: "Invalid JSON"
+    });
+  }
+}
+
+// src/converters/blind.ts
+function blindPngToSegments(chunks) {
+  if (chunks.length === 0) return [];
+  const chunkMap = Object.fromEntries(
+    chunks.map((chunk) => [chunk.keyword, chunk.text])
+  );
+  return [
+    {
+      source: { type: "exifUserComment" },
+      data: JSON.stringify(chunkMap)
+    }
+  ];
+}
+function blindSegmentsToPng(segments) {
+  const userComment = segments.find((s) => s.source.type === "exifUserComment");
+  if (!userComment) return [];
+  const parsed = parseJson(userComment.data);
+  if (parsed.ok) {
+    return Object.entries(parsed.value).flatMap(([keyword, value]) => {
+      const text = typeof value === "string" ? value : JSON.stringify(value);
+      if (!text) return [];
+      return createEncodedChunk(keyword, text, getEncodingStrategy("blind"));
+    });
+  }
+  return createEncodedChunk(
+    "metadata",
+    userComment.data,
+    getEncodingStrategy("blind")
+  );
+}
+
+// src/converters/comfyui.ts
+function convertComfyUIPngToSegments(chunks) {
+  const data = {};
+  for (const chunk of chunks) {
+    const parsed = parseJson(chunk.text);
+    if (parsed.ok) {
+      data[chunk.keyword] = parsed.value;
+    } else {
+      data[chunk.keyword] = chunk.text;
+    }
+  }
+  return [
+    {
+      source: { type: "exifUserComment" },
+      data: JSON.stringify(data)
+    }
+  ];
+}
+var tryParseExtendedFormat = (segments) => {
+  const imageDescription = findSegment(segments, "exifImageDescription");
+  const make = findSegment(segments, "exifMake");
+  if (!imageDescription && !make) {
+    return null;
+  }
+  return [
+    ...createEncodedChunk("prompt", make?.data, getEncodingStrategy("comfyui")),
+    ...createEncodedChunk(
+      "workflow",
+      imageDescription?.data,
+      getEncodingStrategy("comfyui")
+    )
+  ];
+};
+var tryParseSaveImagePlusFormat = (segments) => {
+  const userComment = findSegment(segments, "exifUserComment");
+  if (!userComment) {
+    return null;
+  }
+  const parsed = parseJson(userComment.data);
+  if (!parsed.ok) {
+    return createEncodedChunk(
+      "prompt",
+      userComment.data,
+      getEncodingStrategy("comfyui")
+    );
+  }
+  return Object.entries(parsed.value).flatMap(
+    ([keyword, value]) => createEncodedChunk(
+      keyword,
+      stringify(value),
+      getEncodingStrategy("comfyui")
+    )
+  );
+};
+function convertComfyUISegmentsToPng(segments) {
+  return tryParseExtendedFormat(segments) ?? tryParseSaveImagePlusFormat(segments) ?? [];
+}
+
+// src/converters/easydiffusion.ts
+function convertEasyDiffusionPngToSegments(chunks) {
+  const json = Object.fromEntries(
+    chunks.map((chunk) => [chunk.keyword, chunk.text])
+  );
+  return [
+    {
+      source: { type: "exifUserComment" },
+      data: JSON.stringify(json)
+    }
+  ];
+}
+function convertEasyDiffusionSegmentsToPng(segments) {
+  const userComment = findSegment(segments, "exifUserComment");
+  if (!userComment) {
+    return [];
+  }
+  const parsed = parseJson(userComment.data);
+  if (!parsed.ok) {
+    return [];
+  }
+  return Object.entries(parsed.value).flatMap(([keyword, value]) => {
+    const text = value != null ? typeof value === "string" ? value : String(value) : void 0;
+    if (!text) return [];
+    return createEncodedChunk(
+      keyword,
+      text,
+      getEncodingStrategy("easydiffusion")
+    );
+  });
+}
+
+// src/converters/invokeai.ts
+function convertInvokeAIPngToSegments(chunks) {
+  const data = {};
+  for (const chunk of chunks) {
+    const parsed = parseJson(chunk.text);
+    if (parsed.ok) {
+      data[chunk.keyword] = parsed.value;
+    } else {
+      data[chunk.keyword] = chunk.text;
+    }
+  }
+  return [
+    {
+      source: { type: "exifUserComment" },
+      data: JSON.stringify(data)
+    }
+  ];
+}
+function convertInvokeAISegmentsToPng(segments) {
+  const userComment = findSegment(segments, "exifUserComment");
+  if (!userComment) {
+    return [];
+  }
+  const parsed = parseJson(userComment.data);
+  if (!parsed.ok) {
+    return createEncodedChunk(
+      "invokeai_metadata",
+      userComment.data,
+      getEncodingStrategy("invokeai")
+    );
+  }
+  const metadataText = stringify(parsed.value.invokeai_metadata);
+  const graphText = stringify(parsed.value.invokeai_graph);
+  const chunks = [
+    ...createEncodedChunk(
+      "invokeai_metadata",
+      metadataText,
+      getEncodingStrategy("invokeai")
+    ),
+    ...createEncodedChunk(
+      "invokeai_graph",
+      graphText,
+      getEncodingStrategy("invokeai")
+    )
+  ];
+  if (chunks.length > 0) {
+    return chunks;
+  }
+  return createEncodedChunk(
+    "invokeai_metadata",
+    userComment.data,
+    getEncodingStrategy("invokeai")
+  );
+}
+
+// src/converters/novelai.ts
+var NOVELAI_TITLE = "NovelAI generated image";
+var NOVELAI_SOFTWARE = "NovelAI";
+function convertNovelaiPngToSegments(chunks) {
+  const comment = chunks.find((c) => c.keyword === "Comment");
+  if (!comment) {
+    return [];
+  }
+  const description = chunks.find((c) => c.keyword === "Description");
+  const data = buildUserCommentJson(chunks);
+  const descriptionSegment = description ? [
+    {
+      source: { type: "exifImageDescription" },
+      data: `\0\0\0\0${description.text}`
+    }
+  ] : [];
+  const userCommentSegment = {
+    source: { type: "exifUserComment" },
+    data: JSON.stringify(data)
+  };
+  return [...descriptionSegment, userCommentSegment];
+}
+function buildUserCommentJson(chunks) {
+  return NOVELAI_KEY_ORDER.map((key) => {
+    const chunk = chunks.find((c) => c.keyword === key);
+    return chunk ? { [key]: chunk.text } : null;
+  }).filter((entry) => entry !== null).reduce(
+    (acc, entry) => Object.assign(acc, entry),
+    {}
+  );
+}
+var NOVELAI_KEY_ORDER = [
+  "Comment",
+  "Description",
+  "Generation time",
+  "Software",
+  "Source",
+  "Title"
+];
+function convertNovelaiSegmentsToPng(segments) {
+  const userCommentSeg = findSegment(segments, "exifUserComment");
+  const descriptionSeg = findSegment(segments, "exifImageDescription");
+  return parseSegments(userCommentSeg, descriptionSeg);
+}
+function parseSegments(userCommentSeg, descriptionSeg) {
+  if (!userCommentSeg || !descriptionSeg) {
+    return [];
+  }
+  const parsed = parseJson(userCommentSeg.data);
+  if (!parsed.ok) {
+    return createTextChunk("Comment", userCommentSeg.data);
+  }
+  const jsonData = parsed.value;
+  const descriptionText = extractDescriptionText(
+    descriptionSeg,
+    stringify(jsonData.Description)
+  );
+  const descriptionChunks = descriptionText ? createEncodedChunk(
+    "Description",
+    descriptionText,
+    getEncodingStrategy("novelai")
+  ) : [];
+  return [
+    // Title (required, use default if missing)
+    createTextChunk("Title", stringify(jsonData.Title) ?? NOVELAI_TITLE),
+    // Description (optional, prefer exifImageDescription over JSON)
+    ...descriptionChunks,
+    // Software (required, use default if missing)
+    createTextChunk(
+      "Software",
+      stringify(jsonData.Software) ?? NOVELAI_SOFTWARE
+    ),
+    // Source (optional)
+    createTextChunk("Source", stringify(jsonData.Source)),
+    // Generation time (optional)
+    createTextChunk("Generation time", stringify(jsonData["Generation time"])),
+    // Comment (optional)
+    createTextChunk("Comment", stringify(jsonData.Comment))
+  ].flat();
+}
+function extractDescriptionText(descriptionSeg, jsonDescription) {
+  if (descriptionSeg?.data) {
+    const data = descriptionSeg.data;
+    return data.startsWith("\0\0\0\0") ? data.slice(4) : data;
+  }
+  if (jsonDescription) {
+    return jsonDescription.startsWith("\0\0\0\0") ? jsonDescription.slice(4) : jsonDescription;
+  }
+  return void 0;
+}
+
+// src/converters/simple-chunk.ts
+function createPngToSegments(keyword) {
+  return (chunks) => {
+    const chunk = chunks.find((c) => c.keyword === keyword);
+    return !chunk ? [] : [{ source: { type: "exifUserComment" }, data: chunk.text }];
+  };
+}
+function createSegmentsToPng(keyword) {
+  return (segments) => {
+    const userComment = segments.find(
+      (s) => s.source.type === "exifUserComment"
+    );
+    if (!userComment) return [];
+    return createEncodedChunk(
+      keyword,
+      userComment.data,
+      getEncodingStrategy(keyword)
+    );
+  };
+}
+
+// src/converters/swarmui.ts
+function convertSwarmUIPngToSegments(chunks) {
+  const parametersChunk = chunks.find((c) => c.keyword === "parameters");
+  if (!parametersChunk) {
+    return [];
+  }
+  const parsed = parseJson(parametersChunk.text);
+  const data = parsed.ok ? parsed.value : parametersChunk.text;
+  return [
+    {
+      source: { type: "exifUserComment" },
+      data: typeof data === "string" ? data : JSON.stringify(data)
+    }
+  ];
+}
+function convertSwarmUISegmentsToPng(segments) {
+  const userComment = findSegment(segments, "exifUserComment");
+  if (!userComment) {
+    return [];
+  }
+  return createEncodedChunk(
+    "parameters",
+    userComment.data,
+    getEncodingStrategy("swarmui")
+  );
+}
+
+// src/converters/index.ts
+function convertMetadata(parseResult, targetFormat, force = false) {
+  if (parseResult.status === "empty") {
+    return Result.error({ type: "missingRawData" });
+  }
+  if (parseResult.status === "invalid") {
+    return Result.error({
+      type: "invalidParseResult",
+      status: parseResult.status
+    });
+  }
+  const raw = parseResult.raw;
+  if (raw.format === "png" && targetFormat === "png" || raw.format === "jpeg" && targetFormat === "jpeg" || raw.format === "webp" && targetFormat === "webp") {
+    return Result.ok(raw);
+  }
+  const software = parseResult.status === "success" ? parseResult.metadata.software : null;
+  if (!software) {
+    return force ? convertBlind(raw, targetFormat) : Result.error({
+      type: "unsupportedSoftware",
+      software: "unknown"
+    });
+  }
+  const converter = softwareConverters[software];
+  if (!converter) {
+    return Result.error({
+      type: "unsupportedSoftware",
+      software
+    });
+  }
+  return converter(raw, targetFormat);
+}
+function createFormatConverter(pngToSegments, segmentsToPng) {
+  return (raw, targetFormat) => {
+    if (raw.format === "png") {
+      if (targetFormat === "png") {
+        return Result.ok(raw);
+      }
+      const segments = pngToSegments(raw.chunks);
+      return Result.ok({ format: targetFormat, segments });
+    }
+    if (targetFormat === "jpeg" || targetFormat === "webp") {
+      return Result.ok({ format: targetFormat, segments: raw.segments });
+    }
+    const chunks = segmentsToPng(raw.segments);
+    return Result.ok({ format: "png", chunks });
+  };
+}
+var convertNovelai = createFormatConverter(
+  convertNovelaiPngToSegments,
+  convertNovelaiSegmentsToPng
+);
+var convertA1111 = createFormatConverter(
+  convertA1111PngToSegments,
+  convertA1111SegmentsToPng
+);
+var convertComfyUI = createFormatConverter(
+  convertComfyUIPngToSegments,
+  convertComfyUISegmentsToPng
+);
+var convertEasyDiffusion = createFormatConverter(
+  convertEasyDiffusionPngToSegments,
+  convertEasyDiffusionSegmentsToPng
+);
+var convertFooocus = createFormatConverter(
+  createPngToSegments("Comment"),
+  createSegmentsToPng("Comment")
+);
+var convertRuinedFooocus = createFormatConverter(
+  createPngToSegments("parameters"),
+  createSegmentsToPng("parameters")
+);
+var convertSwarmUI = createFormatConverter(
+  convertSwarmUIPngToSegments,
+  convertSwarmUISegmentsToPng
+);
+var convertInvokeAI = createFormatConverter(
+  convertInvokeAIPngToSegments,
+  convertInvokeAISegmentsToPng
+);
+var convertHfSpace = createFormatConverter(
+  createPngToSegments("parameters"),
+  createSegmentsToPng("parameters")
+);
+var convertBlind = createFormatConverter(
+  blindPngToSegments,
+  blindSegmentsToPng
+);
+var softwareConverters = {
+  // NovelAI
+  novelai: convertNovelai,
+  // A1111-format (sd-webui, forge, forge-neo, civitai, sd-next)
+  "sd-webui": convertA1111,
+  "sd-next": convertA1111,
+  forge: convertA1111,
+  "forge-neo": convertA1111,
+  civitai: convertA1111,
+  // ComfyUI-format (comfyui, tensorart, stability-matrix)
+  comfyui: convertComfyUI,
+  tensorart: convertComfyUI,
+  "stability-matrix": convertComfyUI,
+  // Easy Diffusion
+  easydiffusion: convertEasyDiffusion,
+  // Fooocus variants
+  fooocus: convertFooocus,
+  "ruined-fooocus": convertRuinedFooocus,
+  // SwarmUI
+  swarmui: convertSwarmUI,
+  // InvokeAI
+  invokeai: convertInvokeAI,
+  // HuggingFace Space
+  "hf-space": convertHfSpace
+};
+
+// src/parsers/a1111.ts
+function parseA1111(entries) {
+  const parametersEntry = entries.find(
+    (e) => e.keyword === "parameters" || e.keyword === "Comment"
+  );
+  if (!parametersEntry) {
+    return Result.error({ type: "unsupportedFormat" });
+  }
+  const text = parametersEntry.text;
+  const { prompt, negativePrompt, settings } = parseParametersText(text);
+  const settingsMap = parseSettings(settings);
+  const size = settingsMap.get("Size") ?? "0x0";
+  const [width, height] = parseSize(size);
+  const version = settingsMap.get("Version");
+  const app = settingsMap.get("App");
+  const software = detectSoftwareVariant(version, app);
+  const metadata = {
+    type: "a1111",
+    software,
+    prompt,
+    negativePrompt,
+    width,
+    height
+  };
+  const modelName = settingsMap.get("Model");
+  const modelHash = settingsMap.get("Model hash");
+  if (modelName || modelHash) {
+    metadata.model = {
+      name: modelName,
+      hash: modelHash
+    };
+  }
+  const sampler = settingsMap.get("Sampler");
+  const scheduler = settingsMap.get("Schedule type");
+  const steps = parseNumber(settingsMap.get("Steps"));
+  const cfg = parseNumber(
+    settingsMap.get("CFG scale") ?? settingsMap.get("CFG Scale")
+  );
+  const seed = parseNumber(settingsMap.get("Seed"));
+  const clipSkip = parseNumber(settingsMap.get("Clip skip"));
+  if (sampler !== void 0 || scheduler !== void 0 || steps !== void 0 || cfg !== void 0 || seed !== void 0 || clipSkip !== void 0) {
+    metadata.sampling = {
+      sampler,
+      scheduler,
+      steps,
+      cfg,
+      seed,
+      clipSkip
+    };
+  }
+  const hiresScale = parseNumber(settingsMap.get("Hires upscale"));
+  const upscaler = settingsMap.get("Hires upscaler");
+  const hiresSteps = parseNumber(settingsMap.get("Hires steps"));
+  const denoise = parseNumber(settingsMap.get("Denoising strength"));
+  const hiresSize = settingsMap.get("Hires size");
+  if ([hiresScale, hiresSize, upscaler, hiresSteps, denoise].some(
+    (v) => v !== void 0
+  )) {
+    const [hiresWidth] = parseSize(hiresSize ?? "");
+    const scale = hiresScale ?? hiresWidth / width;
+    metadata.hires = { scale, upscaler, steps: hiresSteps, denoise };
+  }
+  return Result.ok(metadata);
+}
+function parseParametersText(text) {
+  const negativeIndex = text.indexOf("Negative prompt:");
+  const stepsIndex = text.indexOf("Steps:");
+  if (negativeIndex === -1 && stepsIndex === -1) {
+    return { prompt: text.trim(), negativePrompt: "", settings: "" };
+  }
+  if (negativeIndex === -1) {
+    const settingsStart2 = text.lastIndexOf("\n", stepsIndex);
+    return {
+      prompt: text.slice(0, settingsStart2).trim(),
+      negativePrompt: "",
+      settings: text.slice(settingsStart2).trim()
+    };
+  }
+  if (stepsIndex === -1) {
+    return {
+      prompt: text.slice(0, negativeIndex).trim(),
+      negativePrompt: text.slice(negativeIndex + 16).trim(),
+      settings: ""
+    };
+  }
+  const settingsStart = text.lastIndexOf("\n", stepsIndex);
+  return {
+    prompt: text.slice(0, negativeIndex).trim(),
+    negativePrompt: text.slice(negativeIndex + 16, settingsStart).trim(),
+    settings: text.slice(settingsStart).trim()
+  };
+}
+function parseSettings(settings) {
+  const result = /* @__PURE__ */ new Map();
+  if (!settings) return result;
+  const regex = /([A-Za-z][A-Za-z0-9 ]*?):\s*([^,]+?)(?=,\s*[A-Za-z][A-Za-z0-9 ]*?:|$)/g;
+  const matches = Array.from(settings.matchAll(regex));
+  for (const match of matches) {
+    const key = (match[1] ?? "").trim();
+    const value = (match[2] ?? "").trim();
+    result.set(key, value);
+  }
+  return result;
+}
+function parseSize(size) {
+  const match = size.match(/(\d+)x(\d+)/);
+  if (!match) return [0, 0];
+  return [
+    Number.parseInt(match[1] ?? "0", 10),
+    Number.parseInt(match[2] ?? "0", 10)
+  ];
+}
+function parseNumber(value) {
+  if (value === void 0) return void 0;
+  const num = Number.parseFloat(value);
+  return Number.isNaN(num) ? void 0 : num;
+}
+function detectSoftwareVariant(version, app) {
+  if (app === "SD.Next") return "sd-next";
+  if (!version) return "sd-webui";
+  if (version === "neo") return "forge-neo";
+  if (version === "classic") return "forge";
+  if (/^f\d+\.\d+/.test(version)) return "forge";
+  return "sd-webui";
+}
+
+// src/utils/entries.ts
+function buildEntryRecord(entries) {
+  return Object.freeze(
+    Object.fromEntries(entries.map((e) => [e.keyword, e.text]))
+  );
+}
+
+// src/parsers/comfyui.ts
+function parseComfyUI(entries) {
+  const entryRecord = buildEntryRecord(entries);
+  const promptText = findPromptJson(entryRecord);
+  if (!promptText) {
+    return Result.error({ type: "unsupportedFormat" });
+  }
+  const parsed = parseJson(promptText);
+  if (!parsed.ok) {
+    return Result.error({
+      type: "parseError",
+      message: "Invalid JSON in prompt entry"
+    });
+  }
+  const prompt = parsed.value;
+  const nodes = Object.values(prompt);
+  if (!nodes.some((node) => "class_type" in node)) {
+    return Result.error({ type: "unsupportedFormat" });
+  }
+  const ksampler = findNode(prompt, ["Sampler"]);
+  const positiveClip = findNode(prompt, ["PositiveCLIP_Base"]);
+  const negativeClip = findNode(prompt, ["NegativeCLIP_Base"]);
+  const clipPositiveText = extractText(positiveClip);
+  const clipNegativeText = extractText(negativeClip);
+  const latentImage = findNode(prompt, ["EmptyLatentImage"]);
+  const latentWidth = latentImage ? Number(latentImage.inputs.width) || 0 : 0;
+  const latentHeight = latentImage ? Number(latentImage.inputs.height) || 0 : 0;
+  const extraMeta = extractExtraMetadata(prompt);
+  const positiveText = clipPositiveText || extraMeta?.prompt || "";
+  const negativeText = clipNegativeText || extraMeta?.negativePrompt || "";
+  const width = latentWidth || extraMeta?.width || 0;
+  const height = latentHeight || extraMeta?.height || 0;
+  const metadata = {
+    type: "comfyui",
+    software: "comfyui",
+    prompt: positiveText,
+    negativePrompt: negativeText,
+    width,
+    height
+  };
+  const checkpoint = findNode(prompt, ["CheckpointLoader_Base"])?.inputs?.ckpt_name;
+  if (checkpoint) {
+    metadata.model = { name: String(checkpoint) };
+  } else if (extraMeta?.baseModel) {
+    metadata.model = { name: extraMeta.baseModel };
+  }
+  if (ksampler) {
+    metadata.sampling = {
+      seed: ksampler.inputs.seed,
+      steps: ksampler.inputs.steps,
+      cfg: ksampler.inputs.cfg,
+      sampler: ksampler.inputs.sampler_name,
+      scheduler: ksampler.inputs.scheduler
+    };
+  } else if (extraMeta) {
+    metadata.sampling = {
+      seed: extraMeta.seed,
+      steps: extraMeta.steps,
+      cfg: extraMeta.cfgScale,
+      sampler: extraMeta.sampler
+    };
+  }
+  const hiresModel = findNode(prompt, [
+    "HiresFix_ModelUpscale_UpscaleModelLoader",
+    "PostUpscale_ModelUpscale_UpscaleModelLoader"
+  ])?.inputs;
+  const hiresScale = findNode(prompt, [
+    "HiresFix_ImageScale",
+    "PostUpscale_ImageScale"
+  ])?.inputs;
+  const hiresSampler = findNode(prompt, ["HiresFix_Sampler"])?.inputs;
+  if (hiresModel && hiresScale) {
+    const hiresWidth = hiresScale.width;
+    const scale = latentWidth > 0 ? Math.round(hiresWidth / latentWidth * 100) / 100 : void 0;
+    if (hiresSampler) {
+      metadata.hires = {
+        upscaler: hiresModel.model_name,
+        scale,
+        steps: hiresSampler.steps,
+        denoise: hiresSampler.denoise
+      };
+    } else {
+      metadata.upscale = {
+        upscaler: hiresModel.model_name,
+        scale
+      };
+    }
+  }
+  if (extraMeta?.transformations) {
+    const upscaleTransform = extraMeta.transformations.find(
+      (t) => t.type === "upscale"
+    );
+    if (upscaleTransform) {
+      const originalWidth = extraMeta.width ?? width;
+      if (originalWidth > 0 && upscaleTransform.upscaleWidth) {
+        const scale = upscaleTransform.upscaleWidth / originalWidth;
+        metadata.upscale = {
+          scale: Math.round(scale * 100) / 100
+        };
+      }
+    }
+  }
+  return Result.ok(metadata);
+}
+function findPromptJson(entryRecord) {
+  if (entryRecord.prompt) {
+    return entryRecord.prompt;
+  }
+  const candidates = [
+    entryRecord.Comment,
+    entryRecord.Description,
+    entryRecord.Make,
+    entryRecord.Prompt,
+    // save-image-extended uses this
+    entryRecord.Workflow
+    // Not a prompt, but may contain nodes info
+  ];
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    if (candidate.startsWith("{")) {
+      const cleaned = candidate.replace(/\0+$/, "");
+      const parsed = parseJson(cleaned);
+      if (!parsed.ok) continue;
+      if (parsed.value.prompt && typeof parsed.value.prompt === "object") {
+        return JSON.stringify(parsed.value.prompt);
+      }
+      const values = Object.values(parsed.value);
+      if (values.some((v) => v && typeof v === "object" && "class_type" in v)) {
+        return candidate;
+      }
+    }
+  }
+  return void 0;
+}
+function findNode(prompt, keys) {
+  return Object.entries(prompt).find(([key]) => keys.includes(key))?.[1];
+}
+function extractText(node) {
+  return typeof node?.inputs.text === "string" ? node.inputs.text : "";
+}
+function extractExtraMetadata(prompt) {
+  const extraMetaField = prompt.extraMetadata;
+  if (typeof extraMetaField !== "string") return void 0;
+  const parsed = parseJson(extraMetaField);
+  return parsed.ok ? parsed.value : void 0;
+}
+
+// src/parsers/detect.ts
+function detectSoftware(entries) {
+  const entryRecord = buildEntryRecord(entries);
+  const keywordResult = detectFromKeywords(entryRecord);
+  if (keywordResult) return keywordResult;
+  return detectFromContent(entryRecord);
+}
+function detectFromKeywords(entryRecord) {
+  if (entryRecord.Software === "NovelAI") {
+    return "novelai";
+  }
+  if ("invokeai_metadata" in entryRecord) {
+    return "invokeai";
+  }
+  if ("generation_data" in entryRecord) {
+    return "tensorart";
+  }
+  if ("smproj" in entryRecord) {
+    return "stability-matrix";
+  }
+  if ("negative_prompt" in entryRecord || "Negative Prompt" in entryRecord) {
+    return "easydiffusion";
+  }
+  const comment = entryRecord.Comment;
+  if (comment?.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(comment);
+      if ("invokeai_metadata" in parsed) {
+        return "invokeai";
+      }
+      if ("prompt" in parsed && "workflow" in parsed) {
+        const workflow = parsed.workflow;
+        const prompt = parsed.prompt;
+        const isObject = typeof workflow === "object" || typeof prompt === "object";
+        const isJsonString = typeof workflow === "string" && workflow.startsWith("{") || typeof prompt === "string" && prompt.startsWith("{");
+        if (isObject || isJsonString) {
+          return "comfyui";
+        }
+      }
+      if ("sui_image_params" in parsed) {
+        return "swarmui";
+      }
+      if ("prompt" in parsed && "parameters" in parsed) {
+        const params = String(parsed.parameters || "");
+        if (params.includes("sui_image_params") || params.includes("swarm_version")) {
+          return "swarmui";
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function detectFromContent(entryRecord) {
+  if ("prompt" in entryRecord && "workflow" in entryRecord) {
+    return "comfyui";
+  }
+  const text = entryRecord.parameters ?? entryRecord.Comment ?? "";
+  if (!text) {
+    if ("workflow" in entryRecord) {
+      return "comfyui";
+    }
+    return null;
+  }
+  if (text.startsWith("{")) {
+    return detectFromJson(text);
+  }
+  return detectFromA1111Text(text);
+}
+function detectFromJson(json) {
+  if (json.includes("sui_image_params")) {
+    return "swarmui";
+  }
+  if (json.includes("civitai:") || json.includes('"resource-stack"')) {
+    return "civitai";
+  }
+  if (json.includes('"v4_prompt"') || json.includes('"noise_schedule"') || json.includes('"uncond_scale"') || json.includes('"Software":"NovelAI"') || json.includes('\\"noise_schedule\\"') || json.includes('\\"v4_prompt\\"')) {
+    return "novelai";
+  }
+  if (json.includes('"Model"') && json.includes('"resolution"')) {
+    return "hf-space";
+  }
+  if (json.includes('"use_stable_diffusion_model"')) {
+    return "easydiffusion";
+  }
+  if (json.includes('"software":"RuinedFooocus"') || json.includes('"software": "RuinedFooocus"')) {
+    return "ruined-fooocus";
+  }
+  if (json.includes('"prompt"') && json.includes('"base_model"')) {
+    return "fooocus";
+  }
+  if (json.includes('"prompt"') || json.includes('"nodes"')) {
+    return "comfyui";
+  }
+  return null;
+}
+function detectFromA1111Text(text) {
+  if (text.includes("sui_image_params")) {
+    return "swarmui";
+  }
+  if (text.includes("swarm_version")) {
+    return "swarmui";
+  }
+  const versionMatch = text.match(/Version:\s*([^\s,]+)/);
+  if (versionMatch) {
+    const version = versionMatch[1];
+    if (version === "neo" || version?.startsWith("neo")) {
+      return "forge-neo";
+    }
+    if (version?.startsWith("f") && /^f\d/.test(version)) {
+      return "forge";
+    }
+    if (version === "ComfyUI") {
+      return "comfyui";
+    }
+  }
+  if (text.includes("App: SD.Next") || text.includes("App:SD.Next")) {
+    return "sd-next";
+  }
+  if (text.includes("Civitai resources:")) {
+    return "civitai";
+  }
+  if (text.includes("Steps:") && text.includes("Sampler:")) {
+    return "sd-webui";
+  }
+  return null;
+}
+
+// src/parsers/easydiffusion.ts
+function getValue(json, keyA, keyB) {
+  return json[keyA] ?? json[keyB];
+}
+function extractModelName(path) {
+  if (!path) return void 0;
+  const parts = path.replace(/\\/g, "/").split("/");
+  return parts[parts.length - 1];
+}
+function parseEasyDiffusion(entries) {
+  const entryRecord = buildEntryRecord(entries);
+  if (entryRecord.negative_prompt || entryRecord["Negative Prompt"]) {
+    return parseFromEntries(entryRecord);
+  }
+  const jsonText = (entryRecord.parameters?.startsWith("{") ? entryRecord.parameters : void 0) ?? (entryRecord.Comment?.startsWith("{") ? entryRecord.Comment : void 0);
+  if (!jsonText) {
+    return Result.error({ type: "unsupportedFormat" });
+  }
+  const parsed = parseJson(jsonText);
+  if (!parsed.ok) {
+    return Result.error({
+      type: "parseError",
+      message: "Invalid JSON in Easy Diffusion metadata"
+    });
+  }
+  return parseFromJson(parsed.value);
+}
+function parseFromEntries(entryRecord) {
+  const prompt = entryRecord.prompt ?? entryRecord.Prompt ?? "";
+  const negativePrompt = entryRecord.negative_prompt ?? entryRecord["Negative Prompt"] ?? entryRecord.negative_prompt ?? "";
+  const modelPath = entryRecord.use_stable_diffusion_model ?? entryRecord["Stable Diffusion model"];
+  const width = Number(entryRecord.width ?? entryRecord.Width) || 0;
+  const height = Number(entryRecord.height ?? entryRecord.Height) || 0;
+  const metadata = {
+    type: "a1111",
+    software: "easydiffusion",
+    prompt: prompt.trim(),
+    negativePrompt: negativePrompt.trim(),
+    width,
+    height,
+    model: {
+      name: extractModelName(modelPath),
+      vae: entryRecord.use_vae_model ?? entryRecord["VAE model"]
+    },
+    sampling: {
+      sampler: entryRecord.sampler_name ?? entryRecord.Sampler,
+      steps: Number(entryRecord.num_inference_steps ?? entryRecord.Steps) || void 0,
+      cfg: Number(entryRecord.guidance_scale ?? entryRecord["Guidance Scale"]) || void 0,
+      seed: Number(entryRecord.seed ?? entryRecord.Seed) || void 0,
+      clipSkip: Number(entryRecord.clip_skip ?? entryRecord["Clip Skip"]) || void 0
+    }
+  };
+  return Result.ok(metadata);
+}
+function parseFromJson(json) {
+  const prompt = getValue(json, "prompt", "Prompt") ?? "";
+  const negativePrompt = getValue(json, "negative_prompt", "Negative Prompt") ?? "";
+  const modelPath = getValue(
+    json,
+    "use_stable_diffusion_model",
+    "Stable Diffusion model"
+  );
+  const width = getValue(json, "width", "Width") ?? 0;
+  const height = getValue(json, "height", "Height") ?? 0;
+  const metadata = {
+    type: "a1111",
+    software: "easydiffusion",
+    prompt: prompt.trim(),
+    negativePrompt: negativePrompt.trim(),
+    width,
+    height,
+    model: {
+      name: extractModelName(modelPath),
+      vae: getValue(json, "use_vae_model", "VAE model")
+    },
+    sampling: {
+      sampler: getValue(json, "sampler_name", "Sampler"),
+      steps: getValue(json, "num_inference_steps", "Steps"),
+      cfg: getValue(json, "guidance_scale", "Guidance Scale"),
+      seed: getValue(json, "seed", "Seed"),
+      clipSkip: getValue(json, "clip_skip", "Clip Skip")
+    }
+  };
+  return Result.ok(metadata);
+}
+
+// src/parsers/fooocus.ts
+function parseFooocus(entries) {
+  const entryRecord = buildEntryRecord(entries);
+  const jsonText = entryRecord.Comment ?? entryRecord.comment;
+  if (!jsonText || !jsonText.startsWith("{")) {
+    return Result.error({ type: "unsupportedFormat" });
+  }
+  const parsed = parseJson(jsonText);
+  if (!parsed.ok) {
+    return Result.error({
+      type: "parseError",
+      message: "Invalid JSON in Fooocus metadata"
+    });
+  }
+  const json = parsed.value;
+  if (!json.base_model && !json.prompt) {
+    return Result.error({ type: "unsupportedFormat" });
+  }
+  const metadata = {
+    type: "a1111",
+    software: "fooocus",
+    prompt: json.prompt?.trim() ?? "",
+    negativePrompt: json.negative_prompt?.trim() ?? "",
+    width: json.width ?? 0,
+    height: json.height ?? 0,
+    model: {
+      name: json.base_model
+    },
+    sampling: {
+      sampler: json.sampler,
+      scheduler: json.scheduler,
+      steps: json.steps,
+      cfg: json.cfg,
+      seed: json.seed
+    }
+  };
+  return Result.ok(metadata);
+}
+
+// src/parsers/hf-space.ts
+function parseHfSpace(entries) {
+  const entryRecord = buildEntryRecord(entries);
+  const parametersText = entryRecord.parameters;
+  if (!parametersText) {
+    return Result.error({ type: "unsupportedFormat" });
+  }
+  const parsed = parseJson(parametersText);
+  if (!parsed.ok) {
+    return Result.error({
+      type: "parseError",
+      message: "Invalid JSON in parameters entry"
+    });
+  }
+  const json = parsed.value;
+  const parseResolution = (res) => {
+    const match = res?.match(/(\d+)\s*x\s*(\d+)/);
+    return match?.[1] && match?.[2] ? {
+      width: Number.parseInt(match[1], 10),
+      height: Number.parseInt(match[2], 10)
+    } : { width: 0, height: 0 };
+  };
+  const { width, height } = parseResolution(json.resolution);
+  const metadata = {
+    type: "a1111",
+    software: "hf-space",
+    prompt: json.prompt ?? "",
+    negativePrompt: json.negative_prompt ?? "",
+    width,
+    height,
+    model: {
+      name: json.Model,
+      hash: json["Model hash"]
+    },
+    sampling: {
+      sampler: json.sampler,
+      steps: json.num_inference_steps,
+      cfg: json.guidance_scale,
+      seed: json.seed
+    }
+  };
+  return Result.ok(metadata);
+}
+
+// src/parsers/invokeai.ts
+function extractInvokeAIMetadata(entryRecord) {
+  if (entryRecord.invokeai_metadata) {
+    return entryRecord.invokeai_metadata;
+  }
+  if (!entryRecord.Comment) {
+    return void 0;
+  }
+  const commentParsed = parseJson(entryRecord.Comment);
+  if (!commentParsed.ok || !("invokeai_metadata" in commentParsed.value)) {
+    return void 0;
+  }
+  return JSON.stringify(commentParsed.value.invokeai_metadata);
+}
+function parseInvokeAI(entries) {
+  const entryRecord = buildEntryRecord(entries);
+  const metadataText = extractInvokeAIMetadata(entryRecord);
+  if (!metadataText) {
+    return Result.error({ type: "unsupportedFormat" });
+  }
+  const parsed = parseJson(metadataText);
+  if (!parsed.ok) {
+    return Result.error({
+      type: "parseError",
+      message: "Invalid JSON in invokeai_metadata entry"
+    });
+  }
+  const data = parsed.value;
+  const width = data.width ?? 0;
+  const height = data.height ?? 0;
+  const metadata = {
+    type: "invokeai",
+    software: "invokeai",
+    prompt: data.positive_prompt ?? "",
+    negativePrompt: data.negative_prompt ?? "",
+    width,
+    height
+  };
+  if (data.model?.name || data.model?.hash) {
+    metadata.model = {
+      name: data.model.name,
+      hash: data.model.hash
+    };
+  }
+  if (data.seed !== void 0 || data.steps !== void 0 || data.cfg_scale !== void 0 || data.scheduler !== void 0) {
+    metadata.sampling = {
+      seed: data.seed,
+      steps: data.steps,
+      cfg: data.cfg_scale,
+      sampler: data.scheduler
+    };
+  }
+  return Result.ok(metadata);
+}
+
+// src/parsers/novelai.ts
+function parseNovelAI(entries) {
+  const entryRecord = buildEntryRecord(entries);
+  if (entryRecord.Software !== "NovelAI") {
+    return Result.error({ type: "unsupportedFormat" });
+  }
+  const commentText = entryRecord.Comment;
+  if (!commentText) {
+    return Result.error({
+      type: "parseError",
+      message: "Missing Comment entry"
+    });
+  }
+  const parsed = parseJson(commentText);
+  if (!parsed.ok) {
+    return Result.error({
+      type: "parseError",
+      message: "Invalid JSON in Comment entry"
+    });
+  }
+  const comment = parsed.value;
+  const width = comment.width ?? 0;
+  const height = comment.height ?? 0;
+  const prompt = comment.v4_prompt?.caption?.base_caption ?? comment.prompt ?? "";
+  const negativePrompt = comment.v4_negative_prompt?.caption?.base_caption ?? comment.uc ?? "";
+  const metadata = {
+    type: "novelai",
+    software: "novelai",
+    prompt,
+    negativePrompt,
+    width,
+    height
+  };
+  if (comment.steps !== void 0 || comment.scale !== void 0 || comment.seed !== void 0 || comment.noise_schedule !== void 0 || comment.sampler !== void 0) {
+    metadata.sampling = {
+      steps: comment.steps,
+      cfg: comment.scale,
+      seed: comment.seed,
+      sampler: comment.sampler,
+      scheduler: comment.noise_schedule
+    };
+  }
+  const charCaptions = comment.v4_prompt?.caption?.char_captions;
+  if (charCaptions && charCaptions.length > 0) {
+    metadata.characterPrompts = charCaptions.map((cc) => {
+      if (!cc.char_caption) return null;
+      return {
+        prompt: cc.char_caption,
+        center: cc.centers?.[0]
+      };
+    }).filter((cp) => cp !== null);
+    metadata.useCoords = comment.v4_prompt?.use_coords;
+    metadata.useOrder = comment.v4_prompt?.use_order;
+  }
+  return Result.ok(metadata);
+}
+
+// src/parsers/ruined-fooocus.ts
+function parseRuinedFooocus(entries) {
+  const entryRecord = buildEntryRecord(entries);
+  const jsonText = entryRecord.parameters;
+  if (!jsonText || !jsonText.startsWith("{")) {
+    return Result.error({ type: "unsupportedFormat" });
+  }
+  const parsed = parseJson(jsonText);
+  if (!parsed.ok) {
+    return Result.error({
+      type: "parseError",
+      message: "Invalid JSON in Ruined Fooocus metadata"
+    });
+  }
+  const json = parsed.value;
+  if (json.software !== "RuinedFooocus") {
+    return Result.error({ type: "unsupportedFormat" });
+  }
+  const metadata = {
+    type: "a1111",
+    software: "ruined-fooocus",
+    prompt: json.Prompt?.trim() ?? "",
+    negativePrompt: json.Negative?.trim() ?? "",
+    width: json.width ?? 0,
+    height: json.height ?? 0,
+    model: {
+      name: json.base_model_name,
+      hash: json.base_model_hash
+    },
+    sampling: {
+      sampler: json.sampler_name,
+      scheduler: json.scheduler,
+      steps: json.steps,
+      cfg: json.cfg,
+      seed: json.seed,
+      clipSkip: json.clip_skip
+    }
+  };
+  return Result.ok(metadata);
+}
+
+// src/parsers/stability-matrix.ts
+function parseStabilityMatrix(entries) {
+  const entryRecord = buildEntryRecord(entries);
+  const comfyResult = parseComfyUI(entries);
+  if (!comfyResult.ok) {
+    return Result.error({ type: "unsupportedFormat" });
+  }
+  const metadata = {
+    ...comfyResult.value,
+    type: "comfyui",
+    software: "stability-matrix"
+  };
+  const jsonText = entryRecord["parameters-json"];
+  if (jsonText) {
+    const parsed = parseJson(jsonText);
+    if (parsed.ok) {
+      const data = parsed.value;
+      if (data.PositivePrompt !== void 0) {
+        metadata.prompt = data.PositivePrompt;
+      }
+      if (data.NegativePrompt !== void 0) {
+        metadata.negativePrompt = data.NegativePrompt;
+      }
+      if (data.ModelName !== void 0 || data.ModelHash !== void 0) {
+        metadata.model = {
+          name: data.ModelName,
+          hash: data.ModelHash
+        };
+      }
+    }
+  }
+  return Result.ok(metadata);
+}
+
+// src/parsers/swarmui.ts
+function extractSwarmUIParameters(entryRecord) {
+  if (entryRecord.parameters) {
+    return entryRecord.parameters;
+  }
+  if (!entryRecord.Comment) {
+    return void 0;
+  }
+  const commentParsed = parseJson(entryRecord.Comment);
+  if (!commentParsed.ok) {
+    return void 0;
+  }
+  if ("sui_image_params" in commentParsed.value) {
+    return entryRecord.Comment;
+  }
+  return void 0;
+}
+function parseSwarmUI(entries) {
+  const entryRecord = buildEntryRecord(entries);
+  const parametersText = extractSwarmUIParameters(entryRecord);
+  if (!parametersText) {
+    return Result.error({ type: "unsupportedFormat" });
+  }
+  const parsed = parseJson(parametersText);
+  if (!parsed.ok) {
+    return Result.error({
+      type: "parseError",
+      message: "Invalid JSON in parameters entry"
+    });
+  }
+  const params = parsed.value.sui_image_params;
+  if (!params) {
+    return Result.error({ type: "unsupportedFormat" });
+  }
+  const width = params.width ?? 0;
+  const height = params.height ?? 0;
+  const metadata = {
+    type: "swarmui",
+    software: "swarmui",
+    prompt: params.prompt ?? "",
+    negativePrompt: params.negativeprompt ?? "",
+    width,
+    height
+  };
+  if (params.model) {
+    metadata.model = {
+      name: params.model
+    };
+  }
+  if (params.seed !== void 0 || params.steps !== void 0 || params.cfgscale !== void 0 || params.sampler !== void 0 || params.scheduler !== void 0) {
+    metadata.sampling = {
+      seed: params.seed,
+      steps: params.steps,
+      cfg: params.cfgscale,
+      sampler: params.sampler,
+      scheduler: params.scheduler
+    };
+  }
+  if (params.refinerupscale !== void 0 || params.refinerupscalemethod !== void 0 || params.refinercontrolpercentage !== void 0) {
+    metadata.hires = {
+      scale: params.refinerupscale,
+      upscaler: params.refinerupscalemethod,
+      denoise: params.refinercontrolpercentage
+    };
+  }
+  return Result.ok(metadata);
+}
+
+// src/parsers/tensorart.ts
+function parseTensorArt(entries) {
+  const entryRecord = buildEntryRecord(entries);
+  const dataText = entryRecord.generation_data;
+  if (!dataText) {
+    return Result.error({ type: "unsupportedFormat" });
+  }
+  const cleanedText = dataText.replace(/\0+$/, "");
+  const parsed = parseJson(cleanedText);
+  if (!parsed.ok) {
+    return Result.error({
+      type: "parseError",
+      message: "Invalid JSON in generation_data entry"
+    });
+  }
+  const data = parsed.value;
+  const width = data.width ?? 0;
+  const height = data.height ?? 0;
+  const metadata = {
+    type: "comfyui",
+    software: "tensorart",
+    prompt: data.prompt ?? "",
+    negativePrompt: data.negativePrompt ?? "",
+    width,
+    height
+  };
+  if (data.baseModel?.modelFileName || data.baseModel?.hash) {
+    metadata.model = {
+      name: data.baseModel.modelFileName,
+      hash: data.baseModel.hash
+    };
+  }
+  if (data.seed !== void 0 || data.steps !== void 0 || data.cfgScale !== void 0 || data.clipSkip !== void 0) {
+    metadata.sampling = {
+      seed: data.seed ? Number(data.seed) : void 0,
+      steps: data.steps,
+      cfg: data.cfgScale,
+      clipSkip: data.clipSkip
+    };
+  }
+  return Result.ok(metadata);
+}
+
+// src/parsers/index.ts
+function parseMetadata(entries) {
+  const software = detectSoftware(entries);
+  switch (software) {
+    case "novelai":
+      return parseNovelAI(entries);
+    case "sd-webui":
+    case "sd-next":
+    case "forge":
+    case "forge-neo":
+      return parseA1111(entries);
+    case "hf-space":
+      return parseHfSpace(entries);
+    case "civitai": {
+      const comfyResult = parseComfyUI(entries);
+      if (comfyResult.ok) return comfyResult;
+      return parseA1111(entries);
+    }
+    case "comfyui": {
+      const comfyResult = parseComfyUI(entries);
+      if (comfyResult.ok) return comfyResult;
+      return parseA1111(entries);
+    }
+    case "invokeai":
+      return parseInvokeAI(entries);
+    case "swarmui":
+      return parseSwarmUI(entries);
+    case "tensorart":
+      return parseTensorArt(entries);
+    case "stability-matrix":
+      return parseStabilityMatrix(entries);
+    case "easydiffusion":
+      return parseEasyDiffusion(entries);
+    case "fooocus":
+      return parseFooocus(entries);
+    case "ruined-fooocus":
+      return parseRuinedFooocus(entries);
+    default: {
+      const a1111Result = parseA1111(entries);
+      if (a1111Result.ok) return a1111Result;
+      const comfyResult = parseComfyUI(entries);
+      if (comfyResult.ok) return comfyResult;
+      const invokeResult = parseInvokeAI(entries);
+      if (invokeResult.ok) return invokeResult;
+      const swarmResult = parseSwarmUI(entries);
+      if (swarmResult.ok) return swarmResult;
+      const tensorResult = parseTensorArt(entries);
+      if (tensorResult.ok) return tensorResult;
+      const stabilityResult = parseStabilityMatrix(entries);
+      if (stabilityResult.ok) return stabilityResult;
+      const novelaiResult = parseNovelAI(entries);
+      if (novelaiResult.ok) return novelaiResult;
+      return Result.error({ type: "unsupportedFormat" });
+    }
+  }
+}
+
+// src/utils/binary.ts
+function readUint24LE(data, offset) {
+  return (data[offset] ?? 0) | (data[offset + 1] ?? 0) << 8 | (data[offset + 2] ?? 0) << 16;
+}
+function readUint32BE(data, offset) {
+  return (data[offset] ?? 0) << 24 | (data[offset + 1] ?? 0) << 16 | (data[offset + 2] ?? 0) << 8 | (data[offset + 3] ?? 0);
+}
+function readUint32LE(data, offset) {
+  return (data[offset] ?? 0) | (data[offset + 1] ?? 0) << 8 | (data[offset + 2] ?? 0) << 16 | (data[offset + 3] ?? 0) << 24;
+}
+function writeUint32BE(data, offset, value) {
+  data[offset] = value >>> 24 & 255;
+  data[offset + 1] = value >>> 16 & 255;
+  data[offset + 2] = value >>> 8 & 255;
+  data[offset + 3] = value & 255;
+}
+function readChunkType(data, offset) {
+  return String.fromCharCode(
+    data[offset] ?? 0,
+    data[offset + 1] ?? 0,
+    data[offset + 2] ?? 0,
+    data[offset + 3] ?? 0
+  );
+}
+function readUint16(data, offset, isLittleEndian) {
+  if (isLittleEndian) {
+    return (data[offset] ?? 0) | (data[offset + 1] ?? 0) << 8;
+  }
+  return (data[offset] ?? 0) << 8 | (data[offset + 1] ?? 0);
+}
+function readUint32(data, offset, isLittleEndian) {
+  if (isLittleEndian) {
+    return (data[offset] ?? 0) | (data[offset + 1] ?? 0) << 8 | (data[offset + 2] ?? 0) << 16 | (data[offset + 3] ?? 0) << 24;
+  }
+  return (data[offset] ?? 0) << 24 | (data[offset + 1] ?? 0) << 16 | (data[offset + 2] ?? 0) << 8 | (data[offset + 3] ?? 0);
+}
+function arraysEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function writeUint16(data, offset, value, isLittleEndian) {
+  if (isLittleEndian) {
+    data[offset] = value & 255;
+    data[offset + 1] = value >>> 8 & 255;
+  } else {
+    data[offset] = value >>> 8 & 255;
+    data[offset + 1] = value & 255;
+  }
+}
+function writeUint32(data, offset, value, isLittleEndian) {
+  if (isLittleEndian) {
+    data[offset] = value & 255;
+    data[offset + 1] = value >>> 8 & 255;
+    data[offset + 2] = value >>> 16 & 255;
+    data[offset + 3] = value >>> 24 & 255;
+  } else {
+    data[offset] = value >>> 24 & 255;
+    data[offset + 1] = value >>> 16 & 255;
+    data[offset + 2] = value >>> 8 & 255;
+    data[offset + 3] = value & 255;
+  }
+}
+function writeUint32LE(data, offset, value) {
+  data[offset] = value & 255;
+  data[offset + 1] = value >>> 8 & 255;
+  data[offset + 2] = value >>> 16 & 255;
+  data[offset + 3] = value >>> 24 & 255;
+}
+function isPng(data) {
+  if (data.length < 8) return false;
+  return data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71 && data[4] === 13 && data[5] === 10 && data[6] === 26 && data[7] === 10;
+}
+function isJpeg(data) {
+  if (data.length < 2) return false;
+  return data[0] === 255 && data[1] === 216;
+}
+function isWebp(data) {
+  if (data.length < 12) return false;
+  return data[0] === 82 && // R
+  data[1] === 73 && // I
+  data[2] === 70 && // F
+  data[3] === 70 && // F
+  data[8] === 87 && // W
+  data[9] === 69 && // E
+  data[10] === 66 && // B
+  data[11] === 80;
+}
+function detectFormat(data) {
+  if (isPng(data)) return "png";
+  if (isJpeg(data)) return "jpeg";
+  if (isWebp(data)) return "webp";
+  return null;
+}
+
+// src/utils/exif-constants.ts
+var USER_COMMENT_TAG = 37510;
+var IMAGE_DESCRIPTION_TAG = 270;
+var MAKE_TAG = 271;
+var EXIF_IFD_POINTER_TAG = 34665;
+
+// src/readers/exif.ts
+function parseExifMetadataSegments(exifData) {
+  if (exifData.length < 8) return [];
+  const isLittleEndian = exifData[0] === 73 && exifData[1] === 73;
+  const isBigEndian = exifData[0] === 77 && exifData[1] === 77;
+  if (!isLittleEndian && !isBigEndian) return [];
+  const magic = readUint16(exifData, 2, isLittleEndian);
+  if (magic !== 42) return [];
+  const ifd0Offset = readUint32(exifData, 4, isLittleEndian);
+  const ifd0Segments = extractTagsFromIfd(exifData, ifd0Offset, isLittleEndian);
+  const exifIfdOffset = findExifIfdOffset(exifData, ifd0Offset, isLittleEndian);
+  const exifIfdSegments = exifIfdOffset !== null ? extractTagsFromIfd(exifData, exifIfdOffset, isLittleEndian) : [];
+  return [...ifd0Segments, ...exifIfdSegments];
+}
+function extractTagsFromIfd(data, ifdOffset, isLittleEndian) {
+  const segments = [];
+  if (ifdOffset + 2 > data.length) return segments;
+  const entryCount = readUint16(data, ifdOffset, isLittleEndian);
+  let offset = ifdOffset + 2;
+  for (let i = 0; i < entryCount; i++) {
+    if (offset + 12 > data.length) return segments;
+    const tag = readUint16(data, offset, isLittleEndian);
+    const type = readUint16(data, offset + 2, isLittleEndian);
+    const count = readUint32(data, offset + 4, isLittleEndian);
+    const typeSize = getTypeSize(type);
+    const dataSize = count * typeSize;
+    let valueOffset;
+    if (dataSize <= 4) {
+      valueOffset = offset + 8;
+    } else {
+      valueOffset = readUint32(data, offset + 8, isLittleEndian);
+    }
+    if (valueOffset + dataSize > data.length) {
+      offset += 12;
+      continue;
+    }
+    const tagData = data.slice(valueOffset, valueOffset + dataSize);
+    if (tag === IMAGE_DESCRIPTION_TAG) {
+      const text = decodeAsciiString(tagData);
+      if (text) {
+        const prefix = extractPrefix(text);
+        segments.push({
+          source: { type: "exifImageDescription", prefix: prefix ?? void 0 },
+          data: prefix ? text.slice(prefix.length + 2) : text
+        });
+      }
+    } else if (tag === MAKE_TAG) {
+      const text = decodeAsciiString(tagData);
+      if (text) {
+        const prefix = extractPrefix(text);
+        segments.push({
+          source: { type: "exifMake", prefix: prefix ?? void 0 },
+          data: prefix ? text.slice(prefix.length + 2) : text
+        });
+      }
+    } else if (tag === USER_COMMENT_TAG) {
+      const text = decodeUserComment(tagData);
+      if (text) {
+        segments.push({
+          source: { type: "exifUserComment" },
+          data: text
+        });
+      }
+    }
+    offset += 12;
+  }
+  return segments;
+}
+function extractPrefix(text) {
+  const match = text.match(/^([A-Za-z]+):\s/);
+  return match?.[1] ?? null;
+}
+function getTypeSize(type) {
+  switch (type) {
+    case 1:
+      return 1;
+    // BYTE
+    case 2:
+      return 1;
+    // ASCII
+    case 3:
+      return 2;
+    // SHORT
+    case 4:
+      return 4;
+    // LONG
+    case 5:
+      return 8;
+    // RATIONAL
+    case 7:
+      return 1;
+    // UNDEFINED
+    default:
+      return 1;
+  }
+}
+function decodeAsciiString(data) {
+  try {
+    const decoder = new TextDecoder("utf-8", { fatal: false });
+    let text = decoder.decode(data);
+    if (text.endsWith("\0")) {
+      text = text.slice(0, -1);
+    }
+    return text.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function findExifIfdOffset(data, ifdOffset, isLittleEndian) {
+  if (ifdOffset + 2 > data.length) return null;
+  const entryCount = readUint16(data, ifdOffset, isLittleEndian);
+  let offset = ifdOffset + 2;
+  for (let i = 0; i < entryCount; i++) {
+    if (offset + 12 > data.length) return null;
+    const tag = readUint16(data, offset, isLittleEndian);
+    if (tag === EXIF_IFD_POINTER_TAG) {
+      return readUint32(data, offset + 8, isLittleEndian);
+    }
+    offset += 12;
+  }
+  return null;
+}
+function decodeUserComment(data) {
+  if (data.length < 8) return null;
+  if (data[0] === 85 && // U
+  data[1] === 78 && // N
+  data[2] === 73 && // I
+  data[3] === 67 && // C
+  data[4] === 79 && // O
+  data[5] === 68 && // D
+  data[6] === 69 && // E
+  data[7] === 0) {
+    const textData = data.slice(8);
+    if (textData.length >= 2) {
+      const isLikelyLE = textData[0] !== 0 && textData[1] === 0;
+      return isLikelyLE ? decodeUtf16LE(textData) : decodeUtf16BE(textData);
+    }
+    return decodeUtf16BE(textData);
+  }
+  if (data[0] === 65 && // A
+  data[1] === 83 && // S
+  data[2] === 67 && // C
+  data[3] === 73 && // I
+  data[4] === 73 && // I
+  data[5] === 0 && // NULL
+  data[6] === 0 && // NULL
+  data[7] === 0) {
+    return decodeAscii(data.slice(8));
+  }
+  try {
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    let result = decoder.decode(data);
+    if (result.endsWith("\0")) {
+      result = result.slice(0, -1);
+    }
+    return result;
+  } catch {
+    return null;
+  }
+}
+function decodeUtf16BE(data) {
+  const chars = [];
+  for (let i = 0; i < data.length - 1; i += 2) {
+    const code = (data[i] ?? 0) << 8 | (data[i + 1] ?? 0);
+    if (code === 0) break;
+    chars.push(String.fromCharCode(code));
+  }
+  return chars.join("");
+}
+function decodeUtf16LE(data) {
+  const chars = [];
+  for (let i = 0; i < data.length - 1; i += 2) {
+    const code = (data[i] ?? 0) | (data[i + 1] ?? 0) << 8;
+    if (code === 0) break;
+    chars.push(String.fromCharCode(code));
+  }
+  return chars.join("");
+}
+function decodeAscii(data) {
+  const chars = [];
+  for (let i = 0; i < data.length; i++) {
+    if (data[i] === 0) break;
+    chars.push(String.fromCharCode(data[i] ?? 0));
+  }
+  return chars.join("");
+}
+
+// src/readers/jpeg.ts
+var APP1_MARKER = 225;
+var COM_MARKER = 254;
+var EXIF_HEADER = new Uint8Array([69, 120, 105, 102, 0, 0]);
+function readJpegMetadata(data) {
+  if (!isJpeg(data)) {
+    return Result.error({ type: "invalidSignature" });
+  }
+  const segments = [];
+  const app1 = findApp1Segment(data);
+  if (app1) {
+    const exifData = data.slice(app1.offset, app1.offset + app1.length);
+    const exifSegments = parseExifMetadataSegments(exifData);
+    segments.push(...exifSegments);
+  }
+  const comSegment = findComSegment(data);
+  if (comSegment) {
+    const comData = data.slice(
+      comSegment.offset,
+      comSegment.offset + comSegment.length
+    );
+    const comText = decodeComSegment(comData);
+    if (comText !== null) {
+      segments.push({
+        source: { type: "jpegCom" },
+        data: comText
+      });
+    }
+  }
+  return Result.ok(segments);
+}
+function findApp1Segment(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 = (data[offset + 2] ?? 0) << 8 | (data[offset + 3] ?? 0);
+    if (marker === APP1_MARKER) {
+      const headerStart = offset + 4;
+      if (headerStart + 6 <= data.length) {
+        const header = data.slice(headerStart, headerStart + 6);
+        if (arraysEqual(header, EXIF_HEADER)) {
+          return {
+            offset: headerStart + 6,
+            length: length - 8
+            // Subtract length bytes and Exif header
+          };
+        }
+      }
+    }
+    offset += 2 + length;
+    if (marker === 218 || marker === 217) {
+      break;
+    }
+  }
+  return null;
+}
+function findComSegment(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 = (data[offset + 2] ?? 0) << 8 | (data[offset + 3] ?? 0);
+    if (marker === COM_MARKER) {
+      return {
+        offset: offset + 4,
+        length: length - 2
+        // Subtract length bytes only
+      };
+    }
+    offset += 2 + length;
+    if (marker === 218 || marker === 217) {
+      break;
+    }
+  }
+  return null;
+}
+function decodeComSegment(data) {
+  try {
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    return decoder.decode(data);
+  } catch {
+    return null;
+  }
+}
+
+// src/readers/png.ts
+function readPngMetadata(data) {
+  if (!isPng(data)) {
+    return Result.error({ type: "invalidSignature" });
+  }
+  const chunksResult = extractTextChunks(data);
+  if (!chunksResult.ok) {
+    return chunksResult;
+  }
+  return Result.ok(chunksResult.value);
+}
+var PNG_SIGNATURE_LENGTH = 8;
+function extractTextChunks(data) {
+  const chunks = [];
+  let offset = PNG_SIGNATURE_LENGTH;
+  while (offset < data.length) {
+    if (offset + 4 > data.length) {
+      return Result.error({
+        type: "corruptedChunk",
+        message: "Unexpected end of file while reading chunk length"
+      });
+    }
+    const length = readUint32BE(data, offset);
+    offset += 4;
+    if (offset + 4 > data.length) {
+      return Result.error({
+        type: "corruptedChunk",
+        message: "Unexpected end of file while reading chunk type"
+      });
+    }
+    const chunkType = readChunkType(data, offset);
+    offset += 4;
+    if (offset + length > data.length) {
+      return Result.error({
+        type: "corruptedChunk",
+        message: `Unexpected end of file while reading chunk data (${chunkType})`
+      });
+    }
+    const chunkData = data.slice(offset, offset + length);
+    offset += length;
+    offset += 4;
+    if (chunkType === "tEXt") {
+      const parsed = parseTExtChunk(chunkData);
+      if (parsed) {
+        chunks.push(parsed);
+      }
+    } else if (chunkType === "iTXt") {
+      const parsed = parseITXtChunk(chunkData);
+      if (parsed) {
+        chunks.push(parsed);
+      }
+    }
+    if (chunkType === "IEND") {
+      break;
+    }
+  }
+  return Result.ok(chunks);
+}
+function parseTExtChunk(data) {
+  const nullIndex = data.indexOf(0);
+  if (nullIndex === -1) {
+    return null;
+  }
+  const keyword = latin1Decode(data.slice(0, nullIndex));
+  const textData = data.slice(nullIndex + 1);
+  const text = tryUtf8Decode(textData) ?? latin1Decode(textData);
+  return { type: "tEXt", keyword, text };
+}
+function tryUtf8Decode(data) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(data);
+  } catch {
+    return null;
+  }
+}
+function parseITXtChunk(data) {
+  let offset = 0;
+  const keywordEnd = findNull(data, offset);
+  if (keywordEnd === -1) return null;
+  const keyword = utf8Decode(data.slice(offset, keywordEnd));
+  offset = keywordEnd + 1;
+  if (offset >= data.length) return null;
+  const compressionFlag = data[offset] ?? 0;
+  offset += 1;
+  if (offset >= data.length) return null;
+  const compressionMethod = data[offset] ?? 0;
+  offset += 1;
+  const langEnd = findNull(data, offset);
+  if (langEnd === -1) return null;
+  const languageTag = utf8Decode(data.slice(offset, langEnd));
+  offset = langEnd + 1;
+  const transEnd = findNull(data, offset);
+  if (transEnd === -1) return null;
+  const translatedKeyword = utf8Decode(data.slice(offset, transEnd));
+  offset = transEnd + 1;
+  let text;
+  if (compressionFlag === 1) {
+    const decompressed = decompressZlib(data.slice(offset));
+    if (!decompressed) return null;
+    text = utf8Decode(decompressed);
+  } else {
+    text = utf8Decode(data.slice(offset));
+  }
+  return {
+    type: "iTXt",
+    keyword,
+    compressionFlag,
+    compressionMethod,
+    languageTag,
+    translatedKeyword,
+    text
+  };
+}
+function findNull(data, offset) {
+  for (let i = offset; i < data.length; i++) {
+    if (data[i] === 0) {
+      return i;
+    }
+  }
+  return -1;
+}
+function latin1Decode(data) {
+  let result = "";
+  for (let i = 0; i < data.length; i++) {
+    result += String.fromCharCode(data[i] ?? 0);
+  }
+  return result;
+}
+function utf8Decode(data) {
+  return new TextDecoder("utf-8").decode(data);
+}
+function decompressZlib(_data) {
+  return null;
+}
+
+// src/readers/webp.ts
+var EXIF_CHUNK_TYPE = new Uint8Array([69, 88, 73, 70]);
+function readWebpMetadata(data) {
+  if (!isWebp(data)) {
+    return Result.error({ type: "invalidSignature" });
+  }
+  const exifChunk = findExifChunk(data);
+  if (!exifChunk) {
+    return Result.ok([]);
+  }
+  const exifData = data.slice(
+    exifChunk.offset,
+    exifChunk.offset + exifChunk.length
+  );
+  const segments = parseExifMetadataSegments(exifData);
+  return Result.ok(segments);
+}
+function findExifChunk(data) {
+  let offset = 12;
+  while (offset < data.length - 8) {
+    const chunkType = data.slice(offset, offset + 4);
+    const chunkSize = readUint32LE(data, offset + 4);
+    if (arraysEqual(chunkType, EXIF_CHUNK_TYPE)) {
+      return {
+        offset: offset + 8,
+        length: chunkSize
+      };
+    }
+    const paddedSize = chunkSize + chunkSize % 2;
+    offset += 8 + paddedSize;
+  }
+  return null;
+}
+
+// src/utils/convert.ts
+function pngChunksToEntries(chunks) {
+  return chunks.map((chunk) => ({
+    keyword: chunk.keyword,
+    text: chunk.text
+  }));
+}
+function segmentsToEntries(segments) {
+  const entries = [];
+  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 (expanded) {
+        entries.push(...expanded);
+        continue;
+      }
+    }
+    entries.push({ keyword, text });
+  }
+  return entries;
+}
+function tryExpandNovelAIWebpFormat(text) {
+  const outerParsed = parseJson(text);
+  if (!outerParsed.ok) {
+    return null;
+  }
+  const outer = outerParsed.value;
+  if (typeof outer !== "object" || outer === null || outer.Software !== "NovelAI" || typeof outer.Comment !== "string") {
+    return null;
+  }
+  const entries = [{ keyword: "Software", text: "NovelAI" }];
+  const innerParsed = parseJson(outer.Comment);
+  return [
+    ...entries,
+    innerParsed.ok ? { keyword: "Comment", text: JSON.stringify(innerParsed.value) } : { keyword: "Comment", text: outer.Comment }
+  ];
+}
+function sourceToKeyword(source) {
+  switch (source.type) {
+    case "jpegCom":
+      return "Comment";
+    case "exifUserComment":
+      return "Comment";
+    case "exifImageDescription":
+      return source.prefix ?? "Description";
+    case "exifMake":
+      return source.prefix ?? "Make";
+  }
+}
+
+// src/writers/exif.ts
+function buildExifTiffData(segments) {
+  const ifd0Segments = segments.filter(
+    (s) => s.source.type === "exifImageDescription" || s.source.type === "exifMake"
+  );
+  const exifIfdSegments = segments.filter(
+    (s) => s.source.type === "exifUserComment"
+  );
+  if (ifd0Segments.length === 0 && exifIfdSegments.length === 0) {
+    return new Uint8Array(0);
+  }
+  const isLittleEndian = true;
+  const ifd0Tags = [];
+  const exifTags = [];
+  for (const seg of ifd0Segments) {
+    if (seg.source.type === "exifImageDescription") {
+      const data = encodeAsciiTag(seg.data, seg.source.prefix);
+      ifd0Tags.push({ tag: IMAGE_DESCRIPTION_TAG, type: 2, data });
+    } else if (seg.source.type === "exifMake") {
+      const data = encodeAsciiTag(seg.data, seg.source.prefix);
+      ifd0Tags.push({ tag: MAKE_TAG, type: 2, data });
+    }
+  }
+  for (const seg of exifIfdSegments) {
+    if (seg.source.type === "exifUserComment") {
+      const data = encodeUserComment(seg.data);
+      exifTags.push({ tag: USER_COMMENT_TAG, type: 7, data });
+    }
+  }
+  const hasExifIfd = exifTags.length > 0;
+  if (hasExifIfd) {
+    ifd0Tags.push({
+      tag: EXIF_IFD_POINTER_TAG,
+      type: 4,
+      data: new Uint8Array(4)
+    });
+  }
+  ifd0Tags.sort((a, b) => a.tag - b.tag);
+  exifTags.sort((a, b) => a.tag - b.tag);
+  const headerSize = 8;
+  const ifd0EntryCount = ifd0Tags.length;
+  const ifd0Size = 2 + 12 * ifd0EntryCount + 4;
+  const exifEntryCount = exifTags.length;
+  const exifIfdSize = hasExifIfd ? 2 + 12 * exifEntryCount + 4 : 0;
+  const ifd0Offset = headerSize;
+  const exifIfdOffset = ifd0Offset + ifd0Size;
+  let dataOffset = exifIfdOffset + exifIfdSize;
+  if (hasExifIfd) {
+    const exifPtrTag = ifd0Tags.find((t) => t.tag === EXIF_IFD_POINTER_TAG);
+    if (exifPtrTag) {
+      writeUint32(exifPtrTag.data, 0, exifIfdOffset, isLittleEndian);
+    }
+  }
+  const tagDataOffsets = /* @__PURE__ */ new Map();
+  for (const tag of [...ifd0Tags, ...exifTags]) {
+    if (tag.data.length > 4) {
+      tagDataOffsets.set(tag, dataOffset);
+      dataOffset += tag.data.length;
+      if (tag.data.length % 2 !== 0) {
+        dataOffset += 1;
+      }
+    }
+  }
+  const totalSize = dataOffset;
+  const result = new Uint8Array(totalSize);
+  result[0] = 73;
+  result[1] = 73;
+  writeUint16(result, 2, 42, isLittleEndian);
+  writeUint32(result, 4, ifd0Offset, isLittleEndian);
+  let offset = ifd0Offset;
+  writeUint16(result, offset, ifd0EntryCount, isLittleEndian);
+  offset += 2;
+  for (const tag of ifd0Tags) {
+    writeIfdEntry(result, offset, tag, tagDataOffsets.get(tag), isLittleEndian);
+    offset += 12;
+  }
+  writeUint32(result, offset, 0, isLittleEndian);
+  offset += 4;
+  if (hasExifIfd) {
+    writeUint16(result, offset, exifEntryCount, isLittleEndian);
+    offset += 2;
+    for (const tag of exifTags) {
+      writeIfdEntry(
+        result,
+        offset,
+        tag,
+        tagDataOffsets.get(tag),
+        isLittleEndian
+      );
+      offset += 12;
+    }
+    writeUint32(result, offset, 0, isLittleEndian);
+  }
+  for (const [tag, dataOff] of tagDataOffsets) {
+    result.set(tag.data, dataOff);
+  }
+  return result;
+}
+function writeIfdEntry(data, offset, tag, dataOffset, isLittleEndian) {
+  writeUint16(data, offset, tag.tag, isLittleEndian);
+  writeUint16(data, offset + 2, tag.type, isLittleEndian);
+  writeUint32(data, offset + 4, tag.data.length, isLittleEndian);
+  if (tag.data.length <= 4) {
+    data.set(tag.data, offset + 8);
+  } else {
+    writeUint32(data, offset + 8, dataOffset ?? 0, isLittleEndian);
+  }
+}
+function encodeUserComment(text) {
+  const utf16Data = [];
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    utf16Data.push(code & 255);
+    utf16Data.push(code >> 8 & 255);
+  }
+  const result = new Uint8Array(8 + utf16Data.length);
+  result[0] = 85;
+  result[1] = 78;
+  result[2] = 73;
+  result[3] = 67;
+  result[4] = 79;
+  result[5] = 68;
+  result[6] = 69;
+  result[7] = 0;
+  result.set(new Uint8Array(utf16Data), 8);
+  return result;
+}
+function encodeAsciiTag(text, prefix) {
+  const fullText = prefix ? `${prefix}: ${text}` : text;
+  const textBytes = new TextEncoder().encode(fullText);
+  const result = new Uint8Array(textBytes.length + 1);
+  result.set(textBytes, 0);
+  result[textBytes.length] = 0;
+  return result;
+}
+
+// src/writers/jpeg.ts
+var APP1_MARKER2 = 225;
+var COM_MARKER2 = 254;
+var SOS_MARKER = 218;
+var EOI_MARKER = 217;
+var EXIF_HEADER2 = new Uint8Array([69, 120, 105, 102, 0, 0]);
+function writeJpegMetadata(data, segments) {
+  if (!isJpeg(data)) {
+    return Result.error({ type: "invalidSignature" });
+  }
+  const comSegments = segments.filter((s) => s.source.type === "jpegCom");
+  const exifSegments = segments.filter(
+    (s) => s.source.type === "exifUserComment" || s.source.type === "exifImageDescription" || s.source.type === "exifMake"
+  );
+  const collectResult = collectNonMetadataSegments(data);
+  if (!collectResult.ok) {
+    return collectResult;
+  }
+  const { beforeSos, scanData } = collectResult.value;
+  const app1Segment = exifSegments.length > 0 ? buildApp1Segment(exifSegments) : null;
+  const comSegmentData = comSegments.map((s) => buildComSegment(s.data));
+  let totalSize = 2;
+  if (app1Segment) {
+    totalSize += app1Segment.length;
+  }
+  for (const seg of beforeSos) {
+    totalSize += seg.length;
+  }
+  for (const com of comSegmentData) {
+    totalSize += com.length;
+  }
+  totalSize += scanData.length;
+  const output = new Uint8Array(totalSize);
+  let offset = 0;
+  output[offset++] = 255;
+  output[offset++] = 216;
+  if (app1Segment) {
+    output.set(app1Segment, offset);
+    offset += app1Segment.length;
+  }
+  for (const seg of beforeSos) {
+    output.set(seg, offset);
+    offset += seg.length;
+  }
+  for (const com of comSegmentData) {
+    output.set(com, offset);
+    offset += com.length;
+  }
+  output.set(scanData, offset);
+  return Result.ok(output);
+}
+function collectNonMetadataSegments(data) {
+  const beforeSos = [];
+  let offset = 2;
+  while (offset < data.length - 1) {
+    if (data[offset] !== 255) {
+      return Result.error({
+        type: "corruptedStructure",
+        message: `Expected marker at offset ${offset}`
+      });
+    }
+    while (data[offset] === 255 && offset < data.length - 1) {
+      offset++;
+    }
+    const marker = data[offset];
+    offset++;
+    if (marker === SOS_MARKER) {
+      const scanData = data.slice(offset - 2);
+      return Result.ok({ beforeSos, scanData });
+    }
+    if (marker === EOI_MARKER) {
+      return Result.ok({ beforeSos, scanData: new Uint8Array([255, 217]) });
+    }
+    if (offset + 2 > data.length) {
+      return Result.error({
+        type: "corruptedStructure",
+        message: "Unexpected end of file"
+      });
+    }
+    const length = (data[offset] ?? 0) << 8 | (data[offset + 1] ?? 0);
+    const segmentStart = offset - 2;
+    const segmentEnd = offset + length;
+    if (segmentEnd > data.length) {
+      return Result.error({
+        type: "corruptedStructure",
+        message: "Segment extends beyond file"
+      });
+    }
+    const isExifApp1 = marker === APP1_MARKER2 && offset + 2 + 6 <= data.length && data[offset + 2] === 69 && // E
+    data[offset + 3] === 120 && // x
+    data[offset + 4] === 105 && // i
+    data[offset + 5] === 102 && // f
+    data[offset + 6] === 0 && // NULL
+    data[offset + 7] === 0;
+    const isCom = marker === COM_MARKER2;
+    if (!isExifApp1 && !isCom) {
+      beforeSos.push(data.slice(segmentStart, segmentEnd));
+    }
+    offset = segmentEnd;
+  }
+  return Result.error({
+    type: "corruptedStructure",
+    message: "No SOS marker found"
+  });
+}
+function buildApp1Segment(segments) {
+  const tiffData = buildExifTiffData(segments);
+  if (tiffData.length === 0) {
+    return new Uint8Array(0);
+  }
+  const segmentLength = 2 + EXIF_HEADER2.length + tiffData.length;
+  const segment = new Uint8Array(2 + segmentLength);
+  segment[0] = 255;
+  segment[1] = APP1_MARKER2;
+  segment[2] = segmentLength >> 8 & 255;
+  segment[3] = segmentLength & 255;
+  segment.set(EXIF_HEADER2, 4);
+  segment.set(tiffData, 4 + EXIF_HEADER2.length);
+  return segment;
+}
+function buildComSegment(text) {
+  const textBytes = new TextEncoder().encode(text);
+  const segmentLength = 2 + textBytes.length;
+  const segment = new Uint8Array(2 + segmentLength);
+  segment[0] = 255;
+  segment[1] = COM_MARKER2;
+  segment[2] = segmentLength >> 8 & 255;
+  segment[3] = segmentLength & 255;
+  segment.set(textBytes, 4);
+  return segment;
+}
+
+// src/writers/png.ts
+var PNG_SIGNATURE = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+function writePngMetadata(data, chunks) {
+  if (!isPng(data)) {
+    return Result.error({ type: "invalidSignature" });
+  }
+  const ihdrEnd = findIhdrChunkEnd(data);
+  if (ihdrEnd === -1) {
+    return Result.error({ type: "noIhdrChunk" });
+  }
+  const originalChunks = collectNonTextChunks(data);
+  const serializedTextChunks = chunks.map(
+    (chunk) => chunk.type === "tEXt" ? serializeTExtChunk(chunk) : serializeITXtChunk(chunk)
+  );
+  const totalSize = PNG_SIGNATURE.length + originalChunks.ihdr.length + serializedTextChunks.reduce((sum, chunk) => sum + chunk.length, 0) + originalChunks.others.reduce((sum, chunk) => sum + chunk.length, 0);
+  const output = new Uint8Array(totalSize);
+  let offset = 0;
+  output.set(PNG_SIGNATURE, offset);
+  offset += PNG_SIGNATURE.length;
+  output.set(originalChunks.ihdr, offset);
+  offset += originalChunks.ihdr.length;
+  for (const chunk of serializedTextChunks) {
+    output.set(chunk, offset);
+    offset += chunk.length;
+  }
+  for (const chunk of originalChunks.others) {
+    output.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return Result.ok(output);
+}
+function findIhdrChunkEnd(data) {
+  const offset = PNG_SIGNATURE.length;
+  if (offset + 8 > data.length) {
+    return -1;
+  }
+  const length = readUint32BE(data, offset);
+  const chunkType = readChunkType(data, offset + 4);
+  if (chunkType !== "IHDR") {
+    return -1;
+  }
+  return offset + 4 + 4 + length + 4;
+}
+function collectNonTextChunks(data) {
+  const others = [];
+  let offset = PNG_SIGNATURE.length;
+  let ihdr = new Uint8Array(0);
+  while (offset < data.length) {
+    const chunkStart = offset;
+    if (offset + 4 > data.length) break;
+    const length = readUint32BE(data, offset);
+    offset += 4;
+    if (offset + 4 > data.length) break;
+    const chunkType = readChunkType(data, offset);
+    offset += 4;
+    offset += length;
+    offset += 4;
+    const chunkEnd = offset;
+    const chunkData = data.slice(chunkStart, chunkEnd);
+    if (chunkType === "IHDR") {
+      ihdr = chunkData;
+    } else if (chunkType !== "tEXt" && chunkType !== "iTXt") {
+      others.push(chunkData);
+    }
+    if (chunkType === "IEND") {
+      break;
+    }
+  }
+  return { ihdr, others };
+}
+function serializeTExtChunk(chunk) {
+  const keyword = latin1Encode(chunk.keyword);
+  const text = utf8Encode(chunk.text);
+  const chunkData = new Uint8Array(keyword.length + 1 + text.length);
+  chunkData.set(keyword, 0);
+  chunkData[keyword.length] = 0;
+  chunkData.set(text, keyword.length + 1);
+  return buildChunk("tEXt", chunkData);
+}
+function serializeITXtChunk(chunk) {
+  const keyword = utf8Encode(chunk.keyword);
+  const languageTag = utf8Encode(chunk.languageTag);
+  const translatedKeyword = utf8Encode(chunk.translatedKeyword);
+  const text = utf8Encode(chunk.text);
+  const dataSize = keyword.length + 1 + // null
+  1 + // compression flag
+  1 + // compression method
+  languageTag.length + 1 + // null
+  translatedKeyword.length + 1 + // null
+  text.length;
+  const chunkData = new Uint8Array(dataSize);
+  let offset = 0;
+  chunkData.set(keyword, offset);
+  offset += keyword.length;
+  chunkData[offset++] = 0;
+  chunkData[offset++] = chunk.compressionFlag;
+  chunkData[offset++] = chunk.compressionMethod;
+  chunkData.set(languageTag, offset);
+  offset += languageTag.length;
+  chunkData[offset++] = 0;
+  chunkData.set(translatedKeyword, offset);
+  offset += translatedKeyword.length;
+  chunkData[offset++] = 0;
+  chunkData.set(text, offset);
+  return buildChunk("iTXt", chunkData);
+}
+function buildChunk(type, data) {
+  const chunk = new Uint8Array(4 + 4 + data.length + 4);
+  writeUint32BE(chunk, 0, data.length);
+  for (let i = 0; i < 4; i++) {
+    chunk[4 + i] = type.charCodeAt(i);
+  }
+  chunk.set(data, 8);
+  const crcData = chunk.slice(4, 8 + data.length);
+  const crc = calculateCrc32(crcData);
+  writeUint32BE(chunk, 8 + data.length, crc);
+  return chunk;
+}
+function latin1Encode(str) {
+  const bytes = new Uint8Array(str.length);
+  for (let i = 0; i < str.length; i++) {
+    bytes[i] = str.charCodeAt(i) & 255;
+  }
+  return bytes;
+}
+function utf8Encode(str) {
+  return new TextEncoder().encode(str);
+}
+var CRC_TABLE = makeCrcTable();
+function makeCrcTable() {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+      if (c & 1) {
+        c = 3988292384 ^ c >>> 1;
+      } else {
+        c = c >>> 1;
+      }
+    }
+    table[n] = c >>> 0;
+  }
+  return table;
+}
+function calculateCrc32(data) {
+  let crc = 4294967295;
+  for (let i = 0; i < data.length; i++) {
+    crc = (CRC_TABLE[(crc ^ (data[i] ?? 0)) & 255] ?? 0) ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+
+// src/writers/webp.ts
+var RIFF_SIGNATURE = new Uint8Array([82, 73, 70, 70]);
+var WEBP_MARKER = new Uint8Array([87, 69, 66, 80]);
+var EXIF_CHUNK_TYPE2 = new Uint8Array([69, 88, 73, 70]);
+function writeWebpMetadata(data, segments) {
+  if (!isWebp(data)) {
+    return Result.error({ type: "invalidSignature" });
+  }
+  const collectResult = collectNonExifChunks(data);
+  if (!collectResult.ok) {
+    return collectResult;
+  }
+  const { chunks } = collectResult.value;
+  const exifChunk = buildExifChunk(segments);
+  let newFileSize = 4;
+  for (const chunk of chunks) {
+    newFileSize += chunk.length;
+  }
+  if (exifChunk) {
+    newFileSize += exifChunk.length;
+  }
+  const output = new Uint8Array(8 + newFileSize);
+  let offset = 0;
+  output.set(RIFF_SIGNATURE, offset);
+  offset += 4;
+  writeUint32LE(output, offset, newFileSize);
+  offset += 4;
+  output.set(WEBP_MARKER, offset);
+  offset += 4;
+  let exifWritten = 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 (!exifWritten && exifChunk) {
+    output.set(exifChunk, offset);
+  }
+  return Result.ok(output);
+}
+function isImageChunk(chunk) {
+  if (chunk.length < 4) return false;
+  const type = String.fromCharCode(
+    chunk[0] ?? 0,
+    chunk[1] ?? 0,
+    chunk[2] ?? 0,
+    chunk[3] ?? 0
+  );
+  return type === "VP8 " || type === "VP8L" || type === "VP8X";
+}
+function collectNonExifChunks(data) {
+  const chunks = [];
+  let firstChunkType = "";
+  let offset = 12;
+  while (offset < data.length - 8) {
+    const chunkType = data.slice(offset, offset + 4);
+    const typeStr = String.fromCharCode(
+      chunkType[0] ?? 0,
+      chunkType[1] ?? 0,
+      chunkType[2] ?? 0,
+      chunkType[3] ?? 0
+    );
+    if (!firstChunkType) {
+      firstChunkType = typeStr;
+    }
+    const chunkSize = (data[offset + 4] ?? 0) | (data[offset + 5] ?? 0) << 8 | (data[offset + 6] ?? 0) << 16 | (data[offset + 7] ?? 0) << 24;
+    if (offset + 8 + chunkSize > data.length) {
+      return Result.error({
+        type: "invalidRiffStructure",
+        message: `Chunk extends beyond file at offset ${offset}`
+      });
+    }
+    if (!arraysEqual(chunkType, EXIF_CHUNK_TYPE2)) {
+      const paddedSize2 = chunkSize + chunkSize % 2;
+      const chunkData = data.slice(offset, offset + 8 + paddedSize2);
+      chunks.push(chunkData);
+    }
+    const paddedSize = chunkSize + chunkSize % 2;
+    offset += 8 + paddedSize;
+  }
+  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) {
+    return null;
+  }
+  const tiffData = buildExifTiffData(exifSegments);
+  if (tiffData.length === 0) {
+    return null;
+  }
+  const chunkSize = tiffData.length;
+  const paddedSize = chunkSize + chunkSize % 2;
+  const chunk = new Uint8Array(8 + paddedSize);
+  chunk.set(EXIF_CHUNK_TYPE2, 0);
+  writeUint32LE(chunk, 4, chunkSize);
+  chunk.set(tiffData, 8);
+  return chunk;
+}
+
+// src/index.ts
+var HELPERS = {
+  png: {
+    readMetadata: readPngMetadata,
+    readDimensions: readPngDimensions,
+    writeEmpty: writePngMetadata,
+    createRaw: (chunks) => ({ format: "png", chunks })
+  },
+  jpeg: {
+    readMetadata: readJpegMetadata,
+    readDimensions: readJpegDimensions,
+    writeEmpty: writeJpegMetadata,
+    createRaw: (segments) => ({
+      format: "jpeg",
+      segments
+    })
+  },
+  webp: {
+    readMetadata: readWebpMetadata,
+    readDimensions: readWebpDimensions,
+    writeEmpty: writeWebpMetadata,
+    createRaw: (segments) => ({
+      format: "webp",
+      segments
+    })
+  }
+};
+function read(data) {
+  const format = detectFormat(data);
+  if (!format) {
+    return { status: "invalid", message: "Unknown image format" };
+  }
+  const rawResult = readRawMetadata(data, format);
+  if (rawResult.status !== "success") {
+    return rawResult;
+  }
+  const raw = rawResult.raw;
+  const entries = raw.format === "png" ? pngChunksToEntries(raw.chunks) : segmentsToEntries(raw.segments);
+  const parseResult = parseMetadata(entries);
+  if (!parseResult.ok) {
+    return { status: "unrecognized", raw };
+  }
+  const metadata = parseResult.value;
+  if (metadata.width === 0 || metadata.height === 0) {
+    const dims = HELPERS[format].readDimensions(data);
+    if (dims) {
+      metadata.width = metadata.width || dims.width;
+      metadata.height = metadata.height || dims.height;
+    }
+  }
+  return { status: "success", metadata, raw };
+}
+function write(data, metadata, options) {
+  const targetFormat = detectFormat(data);
+  if (!targetFormat) {
+    return Result.error({ type: "unsupportedFormat" });
+  }
+  if (metadata.status === "empty") {
+    const result = HELPERS[targetFormat].writeEmpty(data, []);
+    if (!result.ok) {
+      return Result.error({ type: "writeFailed", message: result.error.type });
+    }
+    return Result.ok(result.value);
+  }
+  if (metadata.status === "invalid") {
+    return Result.error({
+      type: "writeFailed",
+      message: "Cannot write invalid metadata"
+    });
+  }
+  const conversionResult = convertMetadata(
+    metadata,
+    targetFormat,
+    options?.force ?? false
+  );
+  if (!conversionResult.ok) {
+    return Result.error({
+      type: "conversionFailed",
+      message: `Failed to convert metadata: ${conversionResult.error.type}`
+    });
+  }
+  const newRaw = conversionResult.value;
+  if (targetFormat === "png" && newRaw.format === "png") {
+    const result = writePngMetadata(data, newRaw.chunks);
+    if (!result.ok)
+      return Result.error({ type: "writeFailed", message: result.error.type });
+    return Result.ok(result.value);
+  }
+  if (targetFormat === "jpeg" && newRaw.format === "jpeg") {
+    const result = writeJpegMetadata(data, newRaw.segments);
+    if (!result.ok)
+      return Result.error({ type: "writeFailed", message: result.error.type });
+    return Result.ok(result.value);
+  }
+  if (targetFormat === "webp" && newRaw.format === "webp") {
+    const result = writeWebpMetadata(data, newRaw.segments);
+    if (!result.ok)
+      return Result.error({ type: "writeFailed", message: result.error.type });
+    return Result.ok(result.value);
+  }
+  return Result.error({
+    type: "writeFailed",
+    message: "Internal error: format mismatch after conversion"
+  });
+}
+function readRawMetadata(data, format) {
+  const result = HELPERS[format].readMetadata(data);
+  if (!result.ok) {
+    const message = result.error.type === "invalidSignature" ? `Invalid ${format.toUpperCase()} signature` : result.error.message;
+    return { status: "invalid", message };
+  }
+  if (result.value.length === 0) return { status: "empty" };
+  if (format === "png") {
+    return {
+      status: "success",
+      raw: HELPERS.png.createRaw(result.value)
+    };
+  }
+  return {
+    status: "success",
+    raw: HELPERS[format].createRaw(result.value)
+  };
+}
+function readPngDimensions(data) {
+  const PNG_SIGNATURE_LENGTH2 = 8;
+  if (data.length < 24) return null;
+  return {
+    width: readUint32BE(data, PNG_SIGNATURE_LENGTH2 + 8),
+    height: readUint32BE(data, PNG_SIGNATURE_LENGTH2 + 12)
+  };
+}
+function readJpegDimensions(data) {
+  let offset = 2;
+  while (offset < data.length - 4) {
+    if (data[offset] !== 255) {
+      offset++;
+      continue;
+    }
+    const marker = data[offset + 1] ?? 0;
+    if (marker === 255) {
+      offset++;
+      continue;
+    }
+    const length = (data[offset + 2] ?? 0) << 8 | (data[offset + 3] ?? 0);
+    if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+      const height = (data[offset + 5] ?? 0) << 8 | (data[offset + 6] ?? 0);
+      const width = (data[offset + 7] ?? 0) << 8 | (data[offset + 8] ?? 0);
+      return { width, height };
+    }
+    offset += 2 + length;
+    if (marker === 218) break;
+  }
+  return null;
+}
+function readWebpDimensions(data) {
+  let offset = 12;
+  while (offset < data.length) {
+    if (offset + 8 > data.length) break;
+    const chunkType = readChunkType(data, offset);
+    const chunkSize = readUint32LE(data, offset + 4);
+    const paddedSize = chunkSize + chunkSize % 2;
+    if (chunkType === "VP8X") {
+      const wMinus1 = readUint24LE(data, offset + 12);
+      const hMinus1 = readUint24LE(data, offset + 15);
+      return { width: wMinus1 + 1, height: hMinus1 + 1 };
+    }
+    if (chunkType === "VP8 ") {
+      const start = offset + 8;
+      const tag = (data[start] ?? 0) | (data[start + 1] ?? 0) << 8 | (data[start + 2] ?? 0) << 16;
+      const keyFrame = !(tag & 1);
+      if (keyFrame) {
+        if (data[start + 3] === 157 && data[start + 4] === 1 && data[start + 5] === 42) {
+          const wRaw = (data[start + 6] ?? 0) | (data[start + 7] ?? 0) << 8;
+          const hRaw = (data[start + 8] ?? 0) | (data[start + 9] ?? 0) << 8;
+          return { width: wRaw & 16383, height: hRaw & 16383 };
+        }
+      }
+    }
+    if (chunkType === "VP8L") {
+      if (data[offset + 8] === 47) {
+        const bits = readUint32LE(data, offset + 9);
+        const width = (bits & 16383) + 1;
+        const height = (bits >> 14 & 16383) + 1;
+        return { width, height };
+      }
+    }
+    offset += 8 + paddedSize;
+  }
+  return null;
+}
+export {
+  read,
+  write
+};
+//# sourceMappingURL=index.js.map