@character-foundry/character-foundry 0.1.3 → 0.1.6

package/dist/png.js

@@ -1,2 +1,774 @@
-export * from '@character-foundry/png';
+// ../png/dist/index.js
+import { Inflate } from "fflate";
+
+// ../core/dist/index.js
+function readUInt32BE(data, offset) {
+  return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
+}
+function writeUInt32BE(data, value, offset) {
+  data[offset] = value >>> 24 & 255;
+  data[offset + 1] = value >>> 16 & 255;
+  data[offset + 2] = value >>> 8 & 255;
+  data[offset + 3] = value & 255;
+}
+function indexOf(data, search, fromIndex = 0) {
+  outer: for (let i = fromIndex; i <= data.length - search.length; i++) {
+    for (let j = 0; j < search.length; j++) {
+      if (data[i + j] !== search[j]) continue outer;
+    }
+    return i;
+  }
+  return -1;
+}
+function concat(...arrays) {
+  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+function slice(data, start, end) {
+  return data.subarray(start, end);
+}
+function fromString(str) {
+  return new TextEncoder().encode(str);
+}
+function toString(data) {
+  return new TextDecoder().decode(data);
+}
+function fromLatin1(str) {
+  const result = new Uint8Array(str.length);
+  for (let i = 0; i < str.length; i++) {
+    result[i] = str.charCodeAt(i) & 255;
+  }
+  return result;
+}
+function toLatin1(data) {
+  let result = "";
+  for (let i = 0; i < data.length; i++) {
+    result += String.fromCharCode(data[i]);
+  }
+  return result;
+}
+function alloc(size) {
+  return new Uint8Array(size);
+}
+var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+var LARGE_BUFFER_THRESHOLD = 1024 * 1024;
+function encode(data) {
+  if (isNode) {
+    return Buffer.from(data).toString("base64");
+  }
+  if (data.length > LARGE_BUFFER_THRESHOLD) {
+    return encodeChunked(data);
+  }
+  let binary = "";
+  for (let i = 0; i < data.length; i++) {
+    binary += String.fromCharCode(data[i]);
+  }
+  return btoa(binary);
+}
+function decode(base64) {
+  if (isNode) {
+    return new Uint8Array(Buffer.from(base64, "base64"));
+  }
+  const binary = atob(base64);
+  const result = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    result[i] = binary.charCodeAt(i);
+  }
+  return result;
+}
+var ENCODE_CHUNK_SIZE = 64 * 1024;
+function encodeChunked(data) {
+  if (isNode) {
+    return Buffer.from(data).toString("base64");
+  }
+  const chunks = [];
+  for (let i = 0; i < data.length; i += ENCODE_CHUNK_SIZE) {
+    const chunk = data.subarray(i, Math.min(i + ENCODE_CHUNK_SIZE, data.length));
+    let binary = "";
+    for (let j = 0; j < chunk.length; j++) {
+      binary += String.fromCharCode(chunk[j]);
+    }
+    chunks.push(binary);
+  }
+  return btoa(chunks.join(""));
+}
+var FOUNDRY_ERROR_MARKER = /* @__PURE__ */ Symbol.for("@character-foundry/core:FoundryError");
+var FoundryError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "FoundryError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /** @internal Marker for cross-module identification */
+  [FOUNDRY_ERROR_MARKER] = true;
+};
+var ParseError = class extends FoundryError {
+  constructor(message, format) {
+    super(message, "PARSE_ERROR");
+    this.format = format;
+    this.name = "ParseError";
+  }
+};
+var SizeLimitError = class extends FoundryError {
+  constructor(actualSize, maxSize, context) {
+    const actualMB = (actualSize / 1024 / 1024).toFixed(2);
+    const maxMB = (maxSize / 1024 / 1024).toFixed(2);
+    const msg = context ? `${context}: Size ${actualMB}MB exceeds limit ${maxMB}MB` : `Size ${actualMB}MB exceeds limit ${maxMB}MB`;
+    super(msg, "SIZE_LIMIT_EXCEEDED");
+    this.actualSize = actualSize;
+    this.maxSize = maxSize;
+    this.name = "SizeLimitError";
+  }
+};
+
+// ../schemas/dist/index.js
+import { z } from "zod";
+import { z as z2 } from "zod";
+import { z as z3 } from "zod";
+import "zod";
+var ISO8601Schema = z.string().datetime();
+var UUIDSchema = z.string().uuid();
+var SpecSchema = z.enum(["v2", "v3"]);
+var SourceFormatSchema = z.enum([
+  "png_v2",
+  // PNG with 'chara' chunk (v2)
+  "png_v3",
+  // PNG with 'ccv3' chunk (v3)
+  "json_v2",
+  // Raw JSON v2
+  "json_v3",
+  // Raw JSON v3
+  "charx",
+  // ZIP with card.json (v3 spec)
+  "charx_risu",
+  // ZIP with card.json + module.risum
+  "charx_jpeg",
+  // JPEG with appended ZIP (read-only)
+  "voxta"
+  // VoxPkg format
+]);
+var OriginalShapeSchema = z.enum(["wrapped", "unwrapped", "legacy"]);
+var AssetTypeSchema = z.enum([
+  "icon",
+  "background",
+  "emotion",
+  "user_icon",
+  "sound",
+  "video",
+  "custom",
+  "x-risu-asset"
+]);
+var AssetDescriptorSchema = z.object({
+  type: AssetTypeSchema,
+  uri: z.string(),
+  name: z.string(),
+  ext: z.string()
+});
+var ExtractedAssetSchema = z.object({
+  descriptor: AssetDescriptorSchema,
+  data: z.instanceof(Uint8Array),
+  mimeType: z.string()
+});
+var CCv2LorebookEntrySchema = z2.object({
+  keys: z2.array(z2.string()),
+  content: z2.string(),
+  enabled: z2.boolean(),
+  insertion_order: z2.number().int(),
+  // Optional fields
+  extensions: z2.record(z2.unknown()).optional(),
+  case_sensitive: z2.boolean().optional(),
+  name: z2.string().optional(),
+  priority: z2.number().int().optional(),
+  id: z2.number().int().optional(),
+  comment: z2.string().optional(),
+  selective: z2.boolean().optional(),
+  secondary_keys: z2.array(z2.string()).optional(),
+  constant: z2.boolean().optional(),
+  position: z2.enum(["before_char", "after_char"]).optional()
+});
+var CCv2CharacterBookSchema = z2.object({
+  name: z2.string().optional(),
+  description: z2.string().optional(),
+  scan_depth: z2.number().int().nonnegative().optional(),
+  token_budget: z2.number().int().nonnegative().optional(),
+  recursive_scanning: z2.boolean().optional(),
+  extensions: z2.record(z2.unknown()).optional(),
+  entries: z2.array(CCv2LorebookEntrySchema)
+});
+var CCv2DataSchema = z2.object({
+  // Core fields - use .default('') to handle missing fields in malformed cards
+  name: z2.string().default(""),
+  description: z2.string().default(""),
+  personality: z2.string().nullable().default(""),
+  // Can be null in wild (141 cards)
+  scenario: z2.string().default(""),
+  first_mes: z2.string().default(""),
+  mes_example: z2.string().nullable().default(""),
+  // Can be null in wild (186 cards)
+  // Optional fields
+  creator_notes: z2.string().optional(),
+  system_prompt: z2.string().optional(),
+  post_history_instructions: z2.string().optional(),
+  alternate_greetings: z2.array(z2.string()).optional(),
+  character_book: CCv2CharacterBookSchema.optional().nullable(),
+  tags: z2.array(z2.string()).optional(),
+  creator: z2.string().optional(),
+  character_version: z2.string().optional(),
+  extensions: z2.record(z2.unknown()).optional()
+});
+var CCv2WrappedSchema = z2.object({
+  spec: z2.literal("chara_card_v2"),
+  spec_version: z2.literal("2.0"),
+  data: CCv2DataSchema
+});
+var CCv3LorebookEntrySchema = z3.object({
+  keys: z3.array(z3.string()),
+  content: z3.string(),
+  enabled: z3.boolean(),
+  insertion_order: z3.number().int(),
+  // Optional fields
+  case_sensitive: z3.boolean().optional(),
+  name: z3.string().optional(),
+  priority: z3.number().int().optional(),
+  id: z3.number().int().optional(),
+  comment: z3.string().optional(),
+  selective: z3.boolean().optional(),
+  secondary_keys: z3.array(z3.string()).optional(),
+  constant: z3.boolean().optional(),
+  position: z3.enum(["before_char", "after_char"]).optional(),
+  extensions: z3.record(z3.unknown()).optional(),
+  // v3 specific
+  automation_id: z3.string().optional(),
+  role: z3.enum(["system", "user", "assistant"]).optional(),
+  group: z3.string().optional(),
+  scan_frequency: z3.number().int().nonnegative().optional(),
+  probability: z3.number().min(0).max(1).optional(),
+  use_regex: z3.boolean().optional(),
+  depth: z3.number().int().nonnegative().optional(),
+  selective_logic: z3.enum(["AND", "NOT"]).optional()
+});
+var CCv3CharacterBookSchema = z3.object({
+  name: z3.string().optional(),
+  description: z3.string().optional(),
+  scan_depth: z3.number().int().nonnegative().optional(),
+  token_budget: z3.number().int().nonnegative().optional(),
+  recursive_scanning: z3.boolean().optional(),
+  extensions: z3.record(z3.unknown()).optional(),
+  entries: z3.array(CCv3LorebookEntrySchema)
+});
+var CCv3DataInnerSchema = z3.object({
+  // Core fields - use .default('') to handle missing fields in malformed cards
+  name: z3.string().default(""),
+  description: z3.string().default(""),
+  personality: z3.string().nullable().default(""),
+  // Can be null in wild (141 cards)
+  scenario: z3.string().default(""),
+  first_mes: z3.string().default(""),
+  mes_example: z3.string().nullable().default(""),
+  // Can be null in wild (186 cards)
+  // "Required" per spec but often missing in wild - use defaults for leniency
+  creator: z3.string().default(""),
+  character_version: z3.string().default(""),
+  tags: z3.array(z3.string()).default([]),
+  group_only_greetings: z3.array(z3.string()).default([]),
+  // Optional fields
+  creator_notes: z3.string().optional(),
+  system_prompt: z3.string().optional(),
+  post_history_instructions: z3.string().optional(),
+  alternate_greetings: z3.array(z3.string()).optional(),
+  character_book: CCv3CharacterBookSchema.optional().nullable(),
+  extensions: z3.record(z3.unknown()).optional(),
+  // v3 specific
+  assets: z3.array(AssetDescriptorSchema).optional(),
+  nickname: z3.string().optional(),
+  creator_notes_multilingual: z3.record(z3.string()).optional(),
+  source: z3.array(z3.string()).optional(),
+  creation_date: z3.number().int().nonnegative().optional(),
+  // Unix timestamp in seconds
+  modification_date: z3.number().int().nonnegative().optional()
+  // Unix timestamp in seconds
+});
+var CCv3DataSchema = z3.object({
+  spec: z3.literal("chara_card_v3"),
+  spec_version: z3.literal("3.0"),
+  data: CCv3DataInnerSchema
+});
+var V3_ONLY_FIELDS = ["group_only_greetings", "creation_date", "modification_date", "assets"];
+function detectSpec(data) {
+  return detectSpecDetailed(data).spec;
+}
+function detectSpecDetailed(data) {
+  const result = {
+    spec: null,
+    confidence: "low",
+    indicators: [],
+    warnings: []
+  };
+  if (!data || typeof data !== "object") {
+    result.indicators.push("Input is not an object");
+    return result;
+  }
+  const obj = data;
+  const dataObj = obj.data && typeof obj.data === "object" ? obj.data : null;
+  if (obj.spec === "chara_card_v3") {
+    result.spec = "v3";
+    result.confidence = "high";
+    result.indicators.push('spec field is "chara_card_v3"');
+    if (obj.spec_version && obj.spec_version !== "3.0") {
+      result.warnings.push(`spec_version "${obj.spec_version}" inconsistent with v3 spec`);
+    }
+    return result;
+  }
+  if (obj.spec === "chara_card_v2") {
+    result.spec = "v2";
+    result.confidence = "high";
+    result.indicators.push('spec field is "chara_card_v2"');
+    if (dataObj) {
+      for (const field of V3_ONLY_FIELDS) {
+        if (field in dataObj) {
+          result.warnings.push(`V3-only field "${field}" found in V2 card`);
+        }
+      }
+    }
+    if (obj.spec_version && obj.spec_version !== "2.0") {
+      result.warnings.push(`spec_version "${obj.spec_version}" inconsistent with v2 spec`);
+    }
+    return result;
+  }
+  if (typeof obj.spec_version === "string") {
+    if (obj.spec_version.startsWith("3")) {
+      result.spec = "v3";
+      result.confidence = "high";
+      result.indicators.push(`spec_version "${obj.spec_version}" starts with "3"`);
+      return result;
+    }
+    if (obj.spec_version.startsWith("2")) {
+      result.spec = "v2";
+      result.confidence = "high";
+      result.indicators.push(`spec_version "${obj.spec_version}" starts with "2"`);
+      return result;
+    }
+  }
+  if (obj.spec_version === 2 || obj.spec_version === 2) {
+    result.spec = "v2";
+    result.confidence = "high";
+    result.indicators.push(`spec_version is numeric ${obj.spec_version}`);
+    return result;
+  }
+  if (dataObj) {
+    const v3Fields = [];
+    for (const field of V3_ONLY_FIELDS) {
+      if (field in dataObj) {
+        v3Fields.push(field);
+      }
+    }
+    if (v3Fields.length > 0) {
+      result.spec = "v3";
+      result.confidence = "medium";
+      result.indicators.push(`Has V3-only fields: ${v3Fields.join(", ")}`);
+      return result;
+    }
+  }
+  const rootV3Fields = [];
+  for (const field of V3_ONLY_FIELDS) {
+    if (field in obj) {
+      rootV3Fields.push(field);
+    }
+  }
+  if (rootV3Fields.length > 0) {
+    result.spec = "v3";
+    result.confidence = "medium";
+    result.indicators.push(`Has V3-only fields at root: ${rootV3Fields.join(", ")}`);
+    result.warnings.push("V3 fields found at root level instead of data object");
+    return result;
+  }
+  if (obj.spec && dataObj) {
+    const dataName = dataObj.name;
+    if (dataName && typeof dataName === "string") {
+      if (typeof obj.spec === "string") {
+        if (obj.spec.includes("v3") || obj.spec.includes("3")) {
+          result.spec = "v3";
+          result.confidence = "medium";
+          result.indicators.push(`spec field "${obj.spec}" contains "v3" or "3"`);
+          return result;
+        }
+        if (obj.spec.includes("v2") || obj.spec.includes("2")) {
+          result.spec = "v2";
+          result.confidence = "medium";
+          result.indicators.push(`spec field "${obj.spec}" contains "v2" or "2"`);
+          return result;
+        }
+      }
+      result.spec = "v3";
+      result.confidence = "medium";
+      result.indicators.push("Has wrapped format with spec and data.name");
+      return result;
+    }
+  }
+  if (obj.name && typeof obj.name === "string") {
+    if ("description" in obj || "personality" in obj || "scenario" in obj) {
+      result.spec = "v2";
+      result.confidence = "medium";
+      result.indicators.push("Unwrapped format with name, description/personality/scenario");
+      return result;
+    }
+  }
+  if (dataObj && typeof dataObj.name === "string") {
+    if ("description" in dataObj || "personality" in dataObj) {
+      result.spec = "v2";
+      result.confidence = "low";
+      result.indicators.push("Has data object with name and card fields, but no spec");
+      result.warnings.push("Missing spec field");
+      return result;
+    }
+  }
+  result.indicators.push("No card structure detected");
+  return result;
+}
+
+// ../png/dist/index.js
+var PNG_SIGNATURE = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+var MAX_CHUNK_SIZE = 50 * 1024 * 1024;
+var MAX_INFLATED_SIZE = 16 * 1024 * 1024;
+function inflateSyncWithLimit(compressed, maxSize = MAX_INFLATED_SIZE) {
+  const chunks = [];
+  let totalSize = 0;
+  let error = null;
+  const inflater = new Inflate((data, final) => {
+    if (error) return;
+    if (data && data.length > 0) {
+      totalSize += data.length;
+      if (totalSize > maxSize) {
+        error = new SizeLimitError(totalSize, maxSize, "inflated zTXt chunk");
+        return;
+      }
+      chunks.push(data);
+    }
+  });
+  try {
+    inflater.push(compressed instanceof Uint8Array ? compressed : new Uint8Array(compressed), true);
+  } catch (e) {
+    throw new ParseError(`Decompression failed: ${e instanceof Error ? e.message : String(e)}`, "png");
+  }
+  if (error) {
+    throw error;
+  }
+  return concat(...chunks);
+}
+var TEXT_CHUNK_KEYS = [
+  // v3 keys
+  "ccv3",
+  "chara_card_v3",
+  // v2 keys (most common)
+  "chara",
+  "ccv2",
+  "character",
+  // Alternative/legacy keys
+  "charactercard",
+  "card",
+  "CharacterCard",
+  "Chara"
+];
+function isPNG(data) {
+  if (data.length < 8) return false;
+  for (let i = 0; i < 8; i++) {
+    if (data[i] !== PNG_SIGNATURE[i]) return false;
+  }
+  return true;
+}
+function parseTextChunks(data) {
+  const textChunks = [];
+  if (!isPNG(data)) {
+    return textChunks;
+  }
+  let offset = 8;
+  while (offset < data.length) {
+    if (offset + 4 > data.length) break;
+    const length = readUInt32BE(data, offset);
+    offset += 4;
+    if (offset + 4 > data.length) break;
+    const typeBytes = slice(data, offset, offset + 4);
+    const type = toLatin1(typeBytes);
+    offset += 4;
+    if (length > MAX_CHUNK_SIZE) {
+      throw new SizeLimitError(length, MAX_CHUNK_SIZE, `PNG chunk '${type}'`);
+    }
+    if (offset + length > data.length) break;
+    const chunkData = slice(data, offset, offset + length);
+    offset += length;
+    if (offset + 4 > data.length) break;
+    offset += 4;
+    if (type === "tEXt") {
+      const nullIndex = indexOf(chunkData, new Uint8Array([0]));
+      if (nullIndex !== -1) {
+        const keyword = toLatin1(slice(chunkData, 0, nullIndex));
+        const text = toString(slice(chunkData, nullIndex + 1));
+        textChunks.push({ keyword, text });
+      }
+    }
+    if (type === "zTXt") {
+      const nullIndex = indexOf(chunkData, new Uint8Array([0]));
+      if (nullIndex !== -1) {
+        const keyword = toLatin1(slice(chunkData, 0, nullIndex));
+        const compressionMethod = chunkData[nullIndex + 1];
+        if (compressionMethod === 0) {
+          try {
+            const compressedData = slice(chunkData, nullIndex + 2);
+            const decompressed = inflateSyncWithLimit(compressedData, MAX_INFLATED_SIZE);
+            const text = toString(decompressed);
+            textChunks.push({ keyword, text });
+          } catch (err) {
+            if (err instanceof SizeLimitError) {
+              throw err;
+            }
+          }
+        }
+      }
+    }
+    if (type === "IEND") break;
+  }
+  return textChunks;
+}
+function listChunks(data) {
+  const chunks = [];
+  if (!isPNG(data)) {
+    return chunks;
+  }
+  let offset = 8;
+  while (offset < data.length) {
+    if (offset + 4 > data.length) break;
+    const length = readUInt32BE(data, offset);
+    const chunkStart = offset;
+    offset += 4;
+    if (offset + 4 > data.length) break;
+    const type = toLatin1(slice(data, offset, offset + 4));
+    offset += 4;
+    chunks.push({ type, offset: chunkStart, length });
+    offset += length + 4;
+    if (type === "IEND") break;
+  }
+  return chunks;
+}
+function tryParseChunk(chunkData) {
+  try {
+    return JSON.parse(chunkData);
+  } catch {
+    try {
+      const decoded = toString(decode(chunkData));
+      return JSON.parse(decoded);
+    } catch {
+      throw new ParseError("Not valid JSON or base64-encoded JSON", "png");
+    }
+  }
+}
+function hasLorebookInData(json) {
+  if (!json || typeof json !== "object") return false;
+  const obj = json;
+  const data = obj.data;
+  if (data?.character_book) {
+    const book = data.character_book;
+    if (Array.isArray(book.entries) && book.entries.length > 0) return true;
+  }
+  if (obj.character_book) {
+    const book = obj.character_book;
+    if (Array.isArray(book.entries) && book.entries.length > 0) return true;
+  }
+  return false;
+}
+function extractFromPNG(data) {
+  if (!isPNG(data)) {
+    throw new ParseError("Invalid PNG signature", "png");
+  }
+  const textChunks = parseTextChunks(data);
+  if (textChunks.length === 0) {
+    throw new ParseError("No text chunks found in PNG", "png");
+  }
+  let fallbackResult = null;
+  for (const key of TEXT_CHUNK_KEYS) {
+    const matchingChunks = textChunks.filter((c) => c.keyword === key);
+    for (const chunk of matchingChunks) {
+      try {
+        const json = tryParseChunk(chunk.text);
+        const spec = detectSpec(json);
+        if (spec === "v3" || spec === "v2") {
+          const result = {
+            data: json,
+            spec,
+            extraChunks: textChunks.filter((c) => c.keyword !== key)
+          };
+          if (hasLorebookInData(json)) {
+            return result;
+          }
+          if (!fallbackResult) {
+            fallbackResult = result;
+          }
+        }
+        if (!spec && json && typeof json === "object") {
+          const obj = json;
+          let inferredResult = null;
+          if (obj.spec === "chara_card_v3" && obj.data && obj.data.name) {
+            inferredResult = { data: json, spec: "v3" };
+          } else if (obj.spec === "chara_card_v2" && obj.data && obj.data.name) {
+            inferredResult = { data: json, spec: "v2" };
+          } else if (obj.name && (obj.description || obj.personality || obj.scenario)) {
+            inferredResult = { data: json, spec: "v2" };
+          }
+          if (inferredResult) {
+            const fullResult = {
+              ...inferredResult,
+              extraChunks: textChunks.filter((c) => c.keyword !== key)
+            };
+            if (hasLorebookInData(json)) {
+              return fullResult;
+            }
+            if (!fallbackResult) fallbackResult = fullResult;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (fallbackResult) {
+    return fallbackResult;
+  }
+  throw new ParseError("No valid character card data found in PNG", "png");
+}
+var CRC_TABLE = null;
+function getCRCTable() {
+  if (CRC_TABLE) return CRC_TABLE;
+  CRC_TABLE = new Uint32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let j = 0; j < 8; j++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    CRC_TABLE[i] = c;
+  }
+  return CRC_TABLE;
+}
+function crc32(data) {
+  const table = getCRCTable();
+  let crc = 4294967295;
+  for (let i = 0; i < data.length; i++) {
+    crc = table[(crc ^ data[i]) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function crc32Bytes(data) {
+  const crc = crc32(data);
+  const result = alloc(4);
+  writeUInt32BE(result, crc, 0);
+  return result;
+}
+function removeAllTextChunks(pngBuffer) {
+  if (!isPNG(pngBuffer)) {
+    throw new ParseError("Invalid PNG signature", "png");
+  }
+  const chunks = [slice(pngBuffer, 0, 8)];
+  let offset = 8;
+  while (offset < pngBuffer.length) {
+    if (offset + 4 > pngBuffer.length) break;
+    const length = readUInt32BE(pngBuffer, offset);
+    const lengthBuf = slice(pngBuffer, offset, offset + 4);
+    offset += 4;
+    if (offset + 4 > pngBuffer.length) break;
+    const type = toLatin1(slice(pngBuffer, offset, offset + 4));
+    const typeBuf = slice(pngBuffer, offset, offset + 4);
+    offset += 4;
+    if (offset + length + 4 > pngBuffer.length) break;
+    const dataBuf = slice(pngBuffer, offset, offset + length);
+    const crcBuf = slice(pngBuffer, offset + length, offset + length + 4);
+    offset += length + 4;
+    if (type === "tEXt" || type === "zTXt") {
+      continue;
+    }
+    chunks.push(lengthBuf, typeBuf, dataBuf, crcBuf);
+    if (type === "IEND") break;
+  }
+  return concat(...chunks);
+}
+function findIendOffset(pngBuffer) {
+  for (let i = pngBuffer.length - 12; i >= 8; i--) {
+    if (pngBuffer[i + 4] === 73 && // 'I'
+    pngBuffer[i + 5] === 69 && // 'E'
+    pngBuffer[i + 6] === 78 && // 'N'
+    pngBuffer[i + 7] === 68) {
+      return i;
+    }
+  }
+  return -1;
+}
+function createTextChunk(keyword, text) {
+  const keywordBuffer = fromLatin1(keyword);
+  const textBuffer = fromString(text);
+  const chunkData = concat(
+    keywordBuffer,
+    new Uint8Array([0]),
+    // null separator
+    textBuffer
+  );
+  const chunkType = fromLatin1("tEXt");
+  const crc = crc32Bytes(concat(chunkType, chunkData));
+  const lengthBuffer = alloc(4);
+  writeUInt32BE(lengthBuffer, chunkData.length, 0);
+  return concat(lengthBuffer, chunkType, chunkData, crc);
+}
+function injectTextChunk(pngBuffer, keyword, text) {
+  const iendOffset = findIendOffset(pngBuffer);
+  if (iendOffset === -1) {
+    throw new ParseError("Invalid PNG: IEND chunk not found", "png");
+  }
+  const textChunk = createTextChunk(keyword, text);
+  const beforeIend = slice(pngBuffer, 0, iendOffset);
+  const iendAndAfter = slice(pngBuffer, iendOffset);
+  return concat(beforeIend, textChunk, iendAndAfter);
+}
+function embedIntoPNG(imageBuffer, cardData, options = {}) {
+  const {
+    key = "chara",
+    base64 = true,
+    minify = true
+  } = options;
+  const cleanPng = removeAllTextChunks(imageBuffer);
+  const json = minify ? JSON.stringify(cardData) : JSON.stringify(cardData, null, 2);
+  const text = base64 ? encode(fromString(json)) : json;
+  return injectTextChunk(cleanPng, key, text);
+}
+function validatePNGSize(buffer, limits) {
+  const sizeMB = buffer.length / (1024 * 1024);
+  const warnings = [];
+  if (sizeMB > limits.max) {
+    return {
+      valid: false,
+      warnings: [`PNG size (${sizeMB.toFixed(2)}MB) exceeds maximum (${limits.max}MB)`]
+    };
+  }
+  if (sizeMB > limits.warn) {
+    warnings.push(`PNG size (${sizeMB.toFixed(2)}MB) is large (recommended: <${limits.warn}MB)`);
+  }
+  return { valid: true, warnings };
+}
+export {
+  PNG_SIGNATURE,
+  TEXT_CHUNK_KEYS,
+  crc32,
+  crc32Bytes,
+  embedIntoPNG,
+  extractFromPNG,
+  injectTextChunk,
+  isPNG,
+  listChunks,
+  parseTextChunks,
+  removeAllTextChunks,
+  validatePNGSize
+};
 //# sourceMappingURL=png.js.map