@sweberdev/witness 0.0.0-stage → 0.1.1

package/dist/index.cjs

@@ -0,0 +1,1344 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BUILT_IN_LOCALES: () => BUILT_IN_LOCALES,
+  DISCLOSURE_KINDS: () => DISCLOSURE_KINDS,
+  buildXmp: () => buildXmp,
+  createDisclosure: () => createDisclosure,
+  createMarking: () => createMarking,
+  detectImageFormat: () => detectImageFormat,
+  disclosureText: () => disclosureText,
+  escapeHtml: () => escapeHtml,
+  format: () => format,
+  generatorName: () => generatorName,
+  getMessages: () => getMessages,
+  hasTextWatermark: () => hasTextWatermark,
+  iptcSourceType: () => iptcSourceType,
+  isAiSourceType: () => isAiSourceType,
+  labelHtml: () => labelHtml,
+  labelText: () => labelText,
+  markImage: () => markImage,
+  markingAttributes: () => markingAttributes,
+  markingJsonLd: () => markingJsonLd,
+  markingMetaTags: () => markingMetaTags,
+  memoryStorage: () => memoryStorage,
+  nextMetadata: () => nextMetadata,
+  parseSourceType: () => parseSourceType,
+  readImageMarking: () => readImageMarking,
+  readTextWatermark: () => readTextWatermark,
+  registerLocale: () => registerLocale,
+  registeredLocales: () => registeredLocales,
+  renderJsonLd: () => renderJsonLd,
+  renderMetaTags: () => renderMetaTags,
+  resolveLocale: () => resolveLocale,
+  schemaOrgSourceType: () => schemaOrgSourceType,
+  stripTextWatermark: () => stripTextWatermark,
+  watermarkSuffix: () => watermarkSuffix,
+  watermarkText: () => watermarkText
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/disclosure.ts
+var PREFIX = "witness:ack:";
+function createDisclosure(options = {}) {
+  const kind = options.kind ?? "chatbot";
+  const id = options.id ?? kind;
+  const version = options.version ?? "1";
+  const locale = options.locale ?? "en";
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const storage = resolveStorage(options.storage);
+  const key = `${PREFIX}${id}`;
+  const listeners = /* @__PURE__ */ new Set();
+  let shown = false;
+  const read = () => {
+    try {
+      const raw = storage.getItem(key);
+      if (!raw) return null;
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.version !== "string" || typeof parsed.at !== "string") return null;
+      return { version: parsed.version, at: parsed.at };
+    } catch {
+      return null;
+    }
+  };
+  const emit = (type, at) => {
+    options.onEvent?.({ type, id, kind, version, locale, at });
+  };
+  const notify = () => {
+    for (const listener of listeners) listener();
+  };
+  return {
+    id,
+    kind,
+    version,
+    needsAcknowledgement: () => read()?.version !== version,
+    acknowledgedAt: () => {
+      const entry = read();
+      return entry?.version === version ? entry.at : null;
+    },
+    markShown() {
+      if (shown) return;
+      shown = true;
+      emit("shown", now().toISOString());
+    },
+    acknowledge() {
+      const at = now().toISOString();
+      try {
+        storage.setItem(key, JSON.stringify({ version, at }));
+      } catch {
+      }
+      emit("acknowledged", at);
+      notify();
+    },
+    reset() {
+      try {
+        storage.removeItem(key);
+      } catch {
+      }
+      notify();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+function resolveStorage(option) {
+  if (option && typeof option === "object") return option;
+  if (option !== "memory") {
+    try {
+      const candidate = option === "session" ? globalThis.sessionStorage : globalThis.localStorage;
+      if (candidate) {
+        const probe = `${PREFIX}probe`;
+        candidate.setItem(probe, "1");
+        candidate.removeItem(probe);
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  return memoryStorage();
+}
+function memoryStorage() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    getItem: (key) => map.get(key) ?? null,
+    setItem: (key, value) => {
+      map.set(key, value);
+    },
+    removeItem: (key) => {
+      map.delete(key);
+    }
+  };
+}
+
+// src/i18n.ts
+var en = {
+  kinds: {
+    chatbot: {
+      label: "AI assistant",
+      title: "You are chatting with an AI",
+      body: "This assistant is an AI system, not a person. Its answers are generated automatically and can be wrong."
+    },
+    generated: {
+      label: "AI-generated",
+      title: "AI-generated content",
+      body: "This content was generated by an AI system."
+    },
+    edited: {
+      label: "AI-edited",
+      title: "Edited with AI",
+      body: "This content was edited or altered with an AI system."
+    },
+    deepfake: {
+      label: "Artificially generated",
+      title: "Artificially generated or manipulated",
+      body: "This content was generated or manipulated with AI. It may show people, places or events differently from how they really were."
+    },
+    "emotion-recognition": {
+      label: "Emotion recognition",
+      title: "Emotion recognition is active",
+      body: "This service uses an AI system that recognises emotions or intentions from your data."
+    },
+    "biometric-categorisation": {
+      label: "Biometric categorisation",
+      title: "Biometric categorisation is active",
+      body: "This service uses an AI system that assigns people to categories based on biometric data."
+    }
+  },
+  ui: {
+    acknowledge: "Got it",
+    details: "About this label",
+    generatedWith: "Generated with {generator}",
+    createdOn: "Created on {date}",
+    humanReviewed: "Reviewed by a person",
+    moreInfo: "How we use AI",
+    close: "Close"
+  }
+};
+var de = {
+  kinds: {
+    chatbot: {
+      label: "KI-Assistent",
+      title: "Sie chatten mit einer KI",
+      body: "Dieser Assistent ist ein KI-System und kein Mensch. Seine Antworten werden automatisch erzeugt und k\xF6nnen falsch sein."
+    },
+    generated: {
+      label: "KI-generiert",
+      title: "KI-generierter Inhalt",
+      body: "Dieser Inhalt wurde von einem KI-System erzeugt."
+    },
+    edited: {
+      label: "Mit KI bearbeitet",
+      title: "Mit KI bearbeitet",
+      body: "Dieser Inhalt wurde mit einem KI-System bearbeitet oder ver\xE4ndert."
+    },
+    deepfake: {
+      label: "K\xFCnstlich erzeugt",
+      title: "K\xFCnstlich erzeugt oder ver\xE4ndert",
+      body: "Dieser Inhalt wurde mit KI erzeugt oder ver\xE4ndert. Er kann Personen, Orte oder Ereignisse anders zeigen, als sie wirklich waren."
+    },
+    "emotion-recognition": {
+      label: "Emotionserkennung",
+      title: "Emotionserkennung ist aktiv",
+      body: "Dieser Dienst setzt ein KI-System ein, das aus Ihren Daten Emotionen oder Absichten erkennt."
+    },
+    "biometric-categorisation": {
+      label: "Biometrische Kategorisierung",
+      title: "Biometrische Kategorisierung ist aktiv",
+      body: "Dieser Dienst setzt ein KI-System ein, das Personen anhand biometrischer Daten Kategorien zuordnet."
+    }
+  },
+  ui: {
+    acknowledge: "Verstanden",
+    details: "\xDCber diese Kennzeichnung",
+    generatedWith: "Erzeugt mit {generator}",
+    createdOn: "Erstellt am {date}",
+    humanReviewed: "Von einem Menschen gepr\xFCft",
+    moreInfo: "Wie wir KI einsetzen",
+    close: "Schliessen"
+  }
+};
+var fr = {
+  kinds: {
+    chatbot: {
+      label: "Assistant IA",
+      title: "Vous discutez avec une IA",
+      body: "Cet assistant est un syst\xE8me d\u2019IA, pas une personne. Ses r\xE9ponses sont g\xE9n\xE9r\xE9es automatiquement et peuvent \xEAtre erron\xE9es."
+    },
+    generated: {
+      label: "G\xE9n\xE9r\xE9 par IA",
+      title: "Contenu g\xE9n\xE9r\xE9 par IA",
+      body: "Ce contenu a \xE9t\xE9 g\xE9n\xE9r\xE9 par un syst\xE8me d\u2019IA."
+    },
+    edited: {
+      label: "Modifi\xE9 par IA",
+      title: "Modifi\xE9 avec l\u2019IA",
+      body: "Ce contenu a \xE9t\xE9 modifi\xE9 ou alt\xE9r\xE9 \xE0 l\u2019aide d\u2019un syst\xE8me d\u2019IA."
+    },
+    deepfake: {
+      label: "G\xE9n\xE9r\xE9 artificiellement",
+      title: "G\xE9n\xE9r\xE9 ou manipul\xE9 artificiellement",
+      body: "Ce contenu a \xE9t\xE9 g\xE9n\xE9r\xE9 ou manipul\xE9 avec l\u2019IA. Il peut montrer des personnes, des lieux ou des \xE9v\xE9nements autrement qu\u2019ils n\u2019ont r\xE9ellement \xE9t\xE9."
+    },
+    "emotion-recognition": {
+      label: "Reconnaissance des \xE9motions",
+      title: "La reconnaissance des \xE9motions est active",
+      body: "Ce service utilise un syst\xE8me d\u2019IA qui reconna\xEEt des \xE9motions ou des intentions \xE0 partir de vos donn\xE9es."
+    },
+    "biometric-categorisation": {
+      label: "Cat\xE9gorisation biom\xE9trique",
+      title: "La cat\xE9gorisation biom\xE9trique est active",
+      body: "Ce service utilise un syst\xE8me d\u2019IA qui classe les personnes dans des cat\xE9gories \xE0 partir de donn\xE9es biom\xE9triques."
+    }
+  },
+  ui: {
+    acknowledge: "Compris",
+    details: "\xC0 propos de ce label",
+    generatedWith: "G\xE9n\xE9r\xE9 avec {generator}",
+    createdOn: "Cr\xE9\xE9 le {date}",
+    humanReviewed: "V\xE9rifi\xE9 par une personne",
+    moreInfo: "Comment nous utilisons l\u2019IA",
+    close: "Fermer"
+  }
+};
+var it = {
+  kinds: {
+    chatbot: {
+      label: "Assistente IA",
+      title: "Stai parlando con un\u2019IA",
+      body: "Questo assistente \xE8 un sistema di IA, non una persona. Le sue risposte sono generate automaticamente e possono essere sbagliate."
+    },
+    generated: {
+      label: "Generato con IA",
+      title: "Contenuto generato con IA",
+      body: "Questo contenuto \xE8 stato generato da un sistema di IA."
+    },
+    edited: {
+      label: "Modificato con IA",
+      title: "Modificato con l\u2019IA",
+      body: "Questo contenuto \xE8 stato modificato o alterato con un sistema di IA."
+    },
+    deepfake: {
+      label: "Generato artificialmente",
+      title: "Generato o manipolato artificialmente",
+      body: "Questo contenuto \xE8 stato generato o manipolato con l\u2019IA. Pu\xF2 mostrare persone, luoghi o eventi in modo diverso da come sono stati realmente."
+    },
+    "emotion-recognition": {
+      label: "Riconoscimento delle emozioni",
+      title: "Il riconoscimento delle emozioni \xE8 attivo",
+      body: "Questo servizio utilizza un sistema di IA che riconosce emozioni o intenzioni a partire dai tuoi dati."
+    },
+    "biometric-categorisation": {
+      label: "Categorizzazione biometrica",
+      title: "La categorizzazione biometrica \xE8 attiva",
+      body: "Questo servizio utilizza un sistema di IA che assegna le persone a categorie in base a dati biometrici."
+    }
+  },
+  ui: {
+    acknowledge: "Ho capito",
+    details: "Informazioni su questa etichetta",
+    generatedWith: "Generato con {generator}",
+    createdOn: "Creato il {date}",
+    humanReviewed: "Verificato da una persona",
+    moreInfo: "Come usiamo l\u2019IA",
+    close: "Chiudi"
+  }
+};
+var registry = /* @__PURE__ */ new Map([
+  ["en", en],
+  ["de", de],
+  ["fr", fr],
+  ["it", it]
+]);
+var BUILT_IN_LOCALES = ["en", "de", "fr", "it"];
+function registerLocale(code, messages) {
+  const key = code.toLowerCase();
+  const base = registry.get(key) ?? registry.get(key.split("-")[0] ?? "") ?? en;
+  registry.set(key, mergeMessages(base, messages));
+}
+function registeredLocales() {
+  return [...registry.keys()];
+}
+function resolveLocale(input) {
+  const tags = input == null ? [] : typeof input === "string" ? [input] : input;
+  for (const tag of tags) {
+    const lower = tag.toLowerCase();
+    if (registry.has(lower)) return lower;
+    const language = lower.split("-")[0] ?? "";
+    if (registry.has(language)) return language;
+  }
+  return "en";
+}
+function getMessages(locale, override) {
+  const messages = registry.get(resolveLocale(locale)) ?? en;
+  return override ? mergeMessages(messages, override) : messages;
+}
+function disclosureText(kind, locale, override) {
+  return getMessages(locale, override).kinds[kind];
+}
+function format(template, values) {
+  return template.replace(/\{(\w+)\}/g, (match, name) => values[name] ?? match);
+}
+function mergeMessages(base, override) {
+  const kinds = { ...base.kinds };
+  for (const [kind, text] of Object.entries(override.kinds ?? {})) {
+    const key = kind;
+    kinds[key] = { ...base.kinds[key], ...text };
+  }
+  const ui = { ...base.ui, ...override.ui ?? {} };
+  return { kinds, ui };
+}
+
+// src/inflate.ts
+var LENGTH_BASE = [
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  13,
+  15,
+  17,
+  19,
+  23,
+  27,
+  31,
+  35,
+  43,
+  51,
+  59,
+  67,
+  83,
+  99,
+  115,
+  131,
+  163,
+  195,
+  227,
+  258
+];
+var LENGTH_EXTRA = [
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0
+];
+var DIST_BASE = [
+  1,
+  2,
+  3,
+  4,
+  5,
+  7,
+  9,
+  13,
+  17,
+  25,
+  33,
+  49,
+  65,
+  97,
+  129,
+  193,
+  257,
+  385,
+  513,
+  769,
+  1025,
+  1537,
+  2049,
+  3073,
+  4097,
+  6145,
+  8193,
+  12289,
+  16385,
+  24577
+];
+var DIST_EXTRA = [
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13
+];
+var CODE_LENGTH_ORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+function buildTree(lengths, offset, count) {
+  const tree = { counts: new Uint16Array(16), symbols: new Uint16Array(count) };
+  for (let i = 0; i < count; i++) {
+    const length = lengths[offset + i] ?? 0;
+    tree.counts[length] = (tree.counts[length] ?? 0) + 1;
+  }
+  tree.counts[0] = 0;
+  const offsets = new Uint16Array(16);
+  let sum = 0;
+  for (let i = 0; i < 16; i++) {
+    offsets[i] = sum;
+    sum += tree.counts[i] ?? 0;
+  }
+  for (let i = 0; i < count; i++) {
+    const length = lengths[offset + i] ?? 0;
+    if (length) {
+      const at = offsets[length] ?? 0;
+      tree.symbols[at] = i;
+      offsets[length] = at + 1;
+    }
+  }
+  return tree;
+}
+var fixed = null;
+function fixedTrees() {
+  if (!fixed) {
+    const lengths = new Uint8Array(288);
+    lengths.fill(8, 0, 144);
+    lengths.fill(9, 144, 256);
+    lengths.fill(7, 256, 280);
+    lengths.fill(8, 280, 288);
+    fixed = { lit: buildTree(lengths, 0, 288), dist: buildTree(new Uint8Array(30).fill(5), 0, 30) };
+  }
+  return fixed;
+}
+var Reader = class {
+  constructor(data) {
+    this.data = data;
+    this.pos = 0;
+    this.bit = 0;
+    this.bits = 0;
+  }
+  getBit() {
+    if (this.bits === 0) {
+      if (this.pos >= this.data.length) throw new Error("inflate: unexpected end of data");
+      this.bit = this.data[this.pos++] ?? 0;
+      this.bits = 8;
+    }
+    const value = this.bit & 1;
+    this.bit >>>= 1;
+    this.bits--;
+    return value;
+  }
+  read(count, base = 0) {
+    let value = 0;
+    for (let i = 0; i < count; i++) value |= this.getBit() << i;
+    return value + base;
+  }
+  decode(tree) {
+    let sum = 0;
+    let cur = 0;
+    let len = 0;
+    do {
+      cur = 2 * cur + this.getBit();
+      len++;
+      if (len > 15) throw new Error("inflate: invalid code");
+      sum += tree.counts[len] ?? 0;
+      cur -= tree.counts[len] ?? 0;
+    } while (cur >= 0);
+    return tree.symbols[sum + cur] ?? 0;
+  }
+};
+function dynamicTrees(r) {
+  const hlit = r.read(5, 257);
+  const hdist = r.read(5, 1);
+  const hclen = r.read(4, 4);
+  const codeLengths = new Uint8Array(19);
+  for (let i = 0; i < hclen; i++) codeLengths[CODE_LENGTH_ORDER[i] ?? 0] = r.read(3);
+  const codeTree = buildTree(codeLengths, 0, 19);
+  const lengths = new Uint8Array(hlit + hdist);
+  for (let n = 0; n < hlit + hdist; ) {
+    const sym = r.decode(codeTree);
+    if (sym < 16) {
+      lengths[n++] = sym;
+      continue;
+    }
+    let repeat;
+    let value = 0;
+    if (sym === 16) {
+      if (n === 0) throw new Error("inflate: invalid repeat");
+      value = lengths[n - 1] ?? 0;
+      repeat = r.read(2, 3);
+    } else if (sym === 17) {
+      repeat = r.read(3, 3);
+    } else {
+      repeat = r.read(7, 11);
+    }
+    while (repeat-- > 0) lengths[n++] = value;
+  }
+  return { lit: buildTree(lengths, 0, hlit), dist: buildTree(lengths, hlit, hdist) };
+}
+function inflateZlib(data, maxLength = 16 * 1024 * 1024) {
+  if (data.length < 2 || ((data[0] ?? 0) & 15) !== 8 || ((data[0] ?? 0) << 8 | (data[1] ?? 0)) % 31 !== 0) {
+    throw new Error("inflate: not a zlib stream");
+  }
+  const r = new Reader(data);
+  r.pos = 2;
+  let out = new Uint8Array(Math.max(1024, data.length * 4));
+  let length = 0;
+  const push = (byte) => {
+    if (length >= out.length) {
+      if (out.length >= maxLength) throw new Error("inflate: output too large");
+      const next = new Uint8Array(Math.min(maxLength, out.length * 2));
+      next.set(out);
+      out = next;
+    }
+    out[length++] = byte;
+  };
+  let final = 0;
+  do {
+    final = r.getBit();
+    const type = r.read(2);
+    if (type === 0) {
+      r.bits = 0;
+      if (r.pos + 4 > data.length) throw new Error("inflate: unexpected end of data");
+      const len = (data[r.pos] ?? 0) | (data[r.pos + 1] ?? 0) << 8;
+      r.pos += 4;
+      if (r.pos + len > data.length) throw new Error("inflate: unexpected end of data");
+      for (let i = 0; i < len; i++) push(data[r.pos++] ?? 0);
+    } else if (type === 1 || type === 2) {
+      const { lit, dist } = type === 1 ? fixedTrees() : dynamicTrees(r);
+      for (; ; ) {
+        const sym = r.decode(lit);
+        if (sym === 256) break;
+        if (sym < 256) {
+          push(sym);
+          continue;
+        }
+        const index = sym - 257;
+        const len = r.read(LENGTH_EXTRA[index] ?? 0, LENGTH_BASE[index] ?? 0);
+        const distSym = r.decode(dist);
+        const offset = r.read(DIST_EXTRA[distSym] ?? 0, DIST_BASE[distSym] ?? 0);
+        if (offset > length) throw new Error("inflate: invalid distance");
+        for (let i = 0; i < len; i++) push(out[length - offset] ?? 0);
+      }
+    } else {
+      throw new Error("inflate: invalid block type");
+    }
+  } while (!final);
+  return out.subarray(0, length);
+}
+
+// src/marking.ts
+var IPTC_BASE = "http://cv.iptc.org/newscodes/digitalsourcetype/";
+var SCHEMA_ORG = {
+  trainedAlgorithmicMedia: "https://schema.org/TrainedAlgorithmicMediaDigitalSource",
+  compositeWithTrainedAlgorithmicMedia: "https://schema.org/CompositeWithTrainedAlgorithmicMediaDigitalSource",
+  algorithmicallyEnhanced: "https://schema.org/AlgorithmicallyEnhancedDigitalSource",
+  algorithmicMedia: "https://schema.org/AlgorithmicMediaDigitalSource",
+  compositeSynthetic: "https://schema.org/CompositeSyntheticDigitalSource"
+};
+var DEFAULT_SOURCE = {
+  generated: "trainedAlgorithmicMedia",
+  edited: "compositeWithTrainedAlgorithmicMedia",
+  deepfake: "trainedAlgorithmicMedia"
+};
+function iptcSourceType(type) {
+  return IPTC_BASE + type;
+}
+function schemaOrgSourceType(type) {
+  return SCHEMA_ORG[type];
+}
+function parseSourceType(value) {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  const name = trimmed.startsWith(IPTC_BASE) ? trimmed.slice(IPTC_BASE.length) : trimmed;
+  if (name in SCHEMA_ORG) return name;
+  for (const [type, uri] of Object.entries(SCHEMA_ORG)) {
+    if (uri === trimmed) return type;
+  }
+  return void 0;
+}
+function isAiSourceType(type) {
+  return type === "trainedAlgorithmicMedia" || type === "compositeWithTrainedAlgorithmicMedia" || type === "algorithmicallyEnhanced";
+}
+function createMarking(input = {}) {
+  const kind = input.kind ?? "generated";
+  const createdAt = input.createdAt instanceof Date ? input.createdAt.toISOString() : input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const marking = {
+    kind,
+    sourceType: input.sourceType ?? DEFAULT_SOURCE[kind],
+    createdAt,
+    humanReviewed: input.humanReviewed ?? false
+  };
+  if (input.generator) marking.generator = input.generator;
+  if (input.generatorVersion) marking.generatorVersion = input.generatorVersion;
+  if (input.provider) marking.provider = input.provider;
+  if (input.disclosureUrl) marking.disclosureUrl = input.disclosureUrl;
+  if (input.description) marking.description = input.description;
+  return marking;
+}
+function markingAttributes(input) {
+  const m = normalise(input);
+  const attributes = {
+    "data-ai-generated": "true",
+    "data-ai-kind": m.kind,
+    "data-ai-source-type": iptcSourceType(m.sourceType),
+    "data-ai-created": m.createdAt
+  };
+  if (m.generator) attributes["data-ai-generator"] = generatorName(m);
+  if (m.provider) attributes["data-ai-provider"] = m.provider;
+  if (m.humanReviewed) attributes["data-ai-reviewed"] = "true";
+  return attributes;
+}
+function markingMetaTags(input) {
+  const m = normalise(input);
+  const tags = [
+    { name: "ai-generated", content: m.kind },
+    { name: "ai-source-type", content: iptcSourceType(m.sourceType) }
+  ];
+  if (m.generator) tags.push({ name: "ai-generator", content: generatorName(m) });
+  if (m.humanReviewed) tags.push({ name: "ai-reviewed", content: "true" });
+  return tags;
+}
+function renderMetaTags(input) {
+  return markingMetaTags(input).map((tag) => `<meta name="${escapeHtml(tag.name)}" content="${escapeHtml(tag.content)}">`).join("\n");
+}
+function nextMetadata(input) {
+  return {
+    other: Object.fromEntries(markingMetaTags(input).map((tag) => [tag.name, tag.content]))
+  };
+}
+function markingJsonLd(input, extra = {}) {
+  const m = normalise(input);
+  const data = {
+    "@context": "https://schema.org",
+    "@type": "CreativeWork",
+    digitalSourceType: schemaOrgSourceType(m.sourceType),
+    dateCreated: m.createdAt
+  };
+  if (m.generator) {
+    data.creator = {
+      "@type": "SoftwareApplication",
+      name: m.generator,
+      ...m.generatorVersion ? { softwareVersion: m.generatorVersion } : {}
+    };
+  }
+  if (m.provider) data.publisher = { "@type": "Organization", name: m.provider };
+  if (m.description) data.description = m.description;
+  return { ...data, ...extra };
+}
+function renderJsonLd(input, extra = {}) {
+  const json = JSON.stringify(markingJsonLd(input, extra)).replace(/</g, "\\u003c");
+  return `<script type="application/ld+json">${json}</script>`;
+}
+function labelHtml(html, input, options = {}) {
+  const m = normalise(input);
+  const tag = options.tag ?? "div";
+  const attributes = Object.entries(markingAttributes(m)).map(([name, value]) => ` ${name}="${escapeHtml(value)}"`).join("");
+  const label = renderLabelLine(m, options);
+  const body = options.position === "bottom" ? `${html}${label}` : `${label}${html}`;
+  return `<${tag} class="witness-content"${attributes}>${body}</${tag}>`;
+}
+function labelText(input, options = {}) {
+  const m = normalise(input);
+  const messages = getMessages(options.locale, options.messages);
+  const parts = [messages.kinds[m.kind].label];
+  if (m.generator) {
+    parts.push(format(messages.ui.generatedWith, { generator: generatorName(m) }));
+  }
+  if (m.humanReviewed) parts.push(messages.ui.humanReviewed);
+  return parts.join(" \xB7 ");
+}
+function renderLabelLine(m, options) {
+  const messages = getMessages(options.locale, options.messages);
+  const text = escapeHtml(labelText(m, options));
+  const link = m.disclosureUrl ? ` <a class="witness-label__link" href="${escapeHtml(m.disclosureUrl)}">${escapeHtml(messages.ui.moreInfo)}</a>` : "";
+  return `<p class="witness-label" role="note"><span class="witness-label__icon" aria-hidden="true">AI</span> <span class="witness-label__text">${text}</span>${link}</p>`;
+}
+function generatorName(m) {
+  if (!m.generator) return "";
+  return m.generatorVersion ? `${m.generator} ${m.generatorVersion}` : m.generator;
+}
+function normalise(input) {
+  return isMarking(input) ? input : createMarking(input);
+}
+function isMarking(input) {
+  return typeof input.kind === "string" && typeof input.sourceType === "string" && typeof input.createdAt === "string" && typeof input.humanReviewed === "boolean";
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+
+// src/image.ts
+var XMP_NS = "http://ns.adobe.com/xap/1.0/\0";
+var WITNESS_NS = "https://packages.sweber.dev/witness/ns/1.0/";
+function detectImageFormat(bytes) {
+  if (bytes.length >= 8 && bytes[0] === 137 && ascii(bytes, 1, 3) === "PNG") return "png";
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return "jpeg";
+  }
+  if (bytes.length >= 12 && ascii(bytes, 0, 4) === "RIFF" && ascii(bytes, 8, 4) === "WEBP") {
+    return "webp";
+  }
+  return null;
+}
+function markImage(bytes, input = {}, options = {}) {
+  const format2 = detectImageFormat(bytes);
+  if (!format2) return { bytes, status: "unsupported", format: format2 };
+  if (options.c2pa !== "overwrite" && hasC2pa(bytes, format2)) {
+    return { bytes, status: "skipped-c2pa", format: format2 };
+  }
+  const marking = "sourceType" in input && "humanReviewed" in input ? input : createMarking(input);
+  const existing = readXmp(bytes, format2);
+  const xmp = buildXmp(marking, existing);
+  const out = format2 === "png" ? writePng(bytes, xmp) : format2 === "jpeg" ? writeJpeg(bytes, xmp) : writeWebp(bytes, xmp);
+  return { bytes: out, status: "marked", format: format2 };
+}
+function readImageMarking(bytes) {
+  const format2 = detectImageFormat(bytes);
+  if (!format2) return { format: format2, xmp: null, aiGenerated: false, witness: false, c2pa: false };
+  const xmp = readXmp(bytes, format2);
+  const sourceType = xmp ? parseSourceType(xmpProperty(xmp, "Iptc4xmpExt:DigitalSourceType")) : void 0;
+  const generator = xmp ? xmpProperty(xmp, "Iptc4xmpExt:AISystemUsed") ?? xmpProperty(xmp, "xmp:CreatorTool") : void 0;
+  const info = {
+    format: format2,
+    xmp,
+    aiGenerated: isAiSourceType(sourceType),
+    witness: xmp?.includes(WITNESS_NS) ?? false,
+    c2pa: hasC2pa(bytes, format2)
+  };
+  if (sourceType) info.sourceType = sourceType;
+  if (generator) info.generator = generator;
+  return info;
+}
+function buildXmp(marking, existing) {
+  const description = buildDescription(marking);
+  if (existing?.includes("</rdf:RDF>")) {
+    const cleaned = existing.replace(/<rdf:Description\b[^>]*witness:marker="1"[^>]*\/>\s*/g, "").replace(
+      /<rdf:Description\b[^>]*witness:marker="1"[^>]*>[\s\S]*?<\/rdf:Description>\s*/g,
+      ""
+    );
+    return cleaned.replace("</rdf:RDF>", `${description}
+</rdf:RDF>`);
+  }
+  return [
+    '<?xpacket begin="\uFEFF" id="W5M0MpCehiHzreSzNTczkc9d"?>',
+    '<x:xmpmeta xmlns:x="adobe:ns:meta/">',
+    '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">',
+    description,
+    "</rdf:RDF>",
+    "</x:xmpmeta>",
+    '<?xpacket end="w"?>'
+  ].join("\n");
+}
+function buildDescription(m) {
+  const attributes = [
+    ["rdf:about", ""],
+    ["xmlns:Iptc4xmpExt", "http://iptc.org/std/Iptc4xmpExt/2008-02-29/"],
+    ["xmlns:xmp", "http://ns.adobe.com/xap/1.0/"],
+    ["xmlns:dc", "http://purl.org/dc/elements/1.1/"],
+    ["xmlns:witness", WITNESS_NS],
+    ["witness:marker", "1"],
+    ["witness:kind", m.kind],
+    ["Iptc4xmpExt:DigitalSourceType", iptcSourceType(m.sourceType)],
+    ["xmp:CreateDate", m.createdAt]
+  ];
+  if (m.generator) {
+    attributes.push(["Iptc4xmpExt:AISystemUsed", m.generator]);
+    attributes.push(["xmp:CreatorTool", generatorName(m)]);
+  }
+  if (m.generatorVersion) attributes.push(["Iptc4xmpExt:AISystemVersionUsed", m.generatorVersion]);
+  if (m.provider) attributes.push(["witness:provider", m.provider]);
+  if (m.disclosureUrl) attributes.push(["witness:disclosureUrl", m.disclosureUrl]);
+  if (m.humanReviewed) attributes.push(["witness:humanReviewed", "True"]);
+  const attrs = attributes.map(([name, value]) => `
+  ${name}="${escapeXml(value)}"`).join("");
+  const description = m.description ? `
+  <dc:description><rdf:Alt><rdf:li xml:lang="x-default">${escapeXml(m.description)}</rdf:li></rdf:Alt></dc:description>
+` : "";
+  return description ? `<rdf:Description${attrs}>${description}</rdf:Description>` : `<rdf:Description${attrs}/>`;
+}
+function xmpProperty(xmp, name) {
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const attribute = new RegExp(`${escaped}="([^"]*)"`).exec(xmp);
+  if (attribute?.[1] !== void 0) return unescapeXml(attribute[1]);
+  const element = new RegExp(
+    `<${escaped}(?:\\s+rdf:resource="([^"]*)")?\\s*(?:/>|>([\\s\\S]*?)</${escaped}>)`
+  ).exec(xmp);
+  if (!element) return void 0;
+  if (element[1] !== void 0) return unescapeXml(element[1]);
+  const inner = element[2] ?? "";
+  const li = /<rdf:li[^>]*>([\s\S]*?)<\/rdf:li>/.exec(inner);
+  const value = (li ? li[1] : inner)?.trim();
+  return value ? unescapeXml(value) : void 0;
+}
+function writePng(bytes, xmp) {
+  const chunks = pngChunks(bytes).filter((chunk) => !isPngXmp(bytes, chunk));
+  const itxt = pngChunk(
+    "iTXt",
+    concat(latin1("XML:com.adobe.xmp"), new Uint8Array([0, 0, 0, 0, 0]), utf8(xmp))
+  );
+  const parts = [bytes.subarray(0, 8)];
+  for (const chunk of chunks) {
+    parts.push(bytes.subarray(chunk.offset, chunk.end));
+    if (chunk.type === "IHDR") parts.push(itxt);
+  }
+  return concat(...parts);
+}
+function pngChunks(bytes) {
+  const chunks = [];
+  let offset = 8;
+  while (offset + 12 <= bytes.length) {
+    const length = readU32BE(bytes, offset);
+    const type = ascii(bytes, offset + 4, 4);
+    const dataStart = offset + 8;
+    const dataEnd = dataStart + length;
+    const end = dataEnd + 4;
+    if (end > bytes.length) throw new Error("Witness: truncated PNG chunk");
+    chunks.push({ type, offset, dataStart, dataEnd, end });
+    offset = end;
+    if (type === "IEND") break;
+  }
+  return chunks;
+}
+function isPngXmp(bytes, chunk) {
+  return (chunk.type === "iTXt" || chunk.type === "zTXt") && ascii(bytes, chunk.dataStart, 18) === "XML:com.adobe.xmp\0";
+}
+function readPngXmp(bytes) {
+  for (const chunk of pngChunks(bytes)) {
+    if (!isPngXmp(bytes, chunk)) continue;
+    let p = chunk.dataStart + 18;
+    let compressed;
+    if (chunk.type === "zTXt") {
+      compressed = true;
+      p += 1;
+    } else {
+      compressed = bytes[p] === 1;
+      p += 2;
+      while (p < chunk.dataEnd && bytes[p] !== 0) p++;
+      p++;
+      while (p < chunk.dataEnd && bytes[p] !== 0) p++;
+      p++;
+    }
+    const data = bytes.subarray(p, chunk.dataEnd);
+    try {
+      return new TextDecoder().decode(compressed ? inflateZlib(data) : data);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function pngChunk(type, data) {
+  const out = new Uint8Array(12 + data.length);
+  writeU32BE(out, 0, data.length);
+  out.set(latin1(type), 4);
+  out.set(data, 8);
+  writeU32BE(out, 8 + data.length, crc32(out.subarray(4, 8 + data.length)));
+  return out;
+}
+function jpegSegments(bytes) {
+  const segments = [];
+  let offset = 2;
+  while (offset + 4 <= bytes.length) {
+    if (bytes[offset] !== 255) throw new Error("Witness: invalid JPEG marker");
+    let markerOffset = offset;
+    while (bytes[markerOffset + 1] === 255) markerOffset++;
+    const marker = bytes[markerOffset + 1] ?? 0;
+    if (marker === 218 || marker === 217) return { segments, scanStart: offset };
+    const length = readU16BE(bytes, markerOffset + 2);
+    const end = markerOffset + 2 + length;
+    if (end > bytes.length) throw new Error("Witness: truncated JPEG segment");
+    segments.push({ marker, offset, dataStart: markerOffset + 4, end });
+    offset = end;
+  }
+  return { segments, scanStart: offset };
+}
+function isJpegXmp(bytes, segment) {
+  return segment.marker === 225 && ascii(bytes, segment.dataStart, XMP_NS.length) === XMP_NS;
+}
+function writeJpeg(bytes, xmp) {
+  const { segments, scanStart } = jpegSegments(bytes);
+  const payload = concat(latin1(XMP_NS), utf8(xmp));
+  if (payload.length + 2 > 65535) throw new Error("Witness: XMP packet too large for JPEG");
+  const app1 = new Uint8Array(4 + payload.length);
+  app1[0] = 255;
+  app1[1] = 225;
+  app1[2] = payload.length + 2 >> 8 & 255;
+  app1[3] = payload.length + 2 & 255;
+  app1.set(payload, 4);
+  const kept = segments.filter((segment) => !isJpegXmp(bytes, segment));
+  let insertAt = 0;
+  while (insertAt < kept.length) {
+    const segment = kept[insertAt];
+    if (!segment) break;
+    const isJfif = segment.marker === 224;
+    const isExif = segment.marker === 225 && ascii(bytes, segment.dataStart, 4) === "Exif";
+    if (!isJfif && !isExif) break;
+    insertAt++;
+  }
+  const parts = [bytes.subarray(0, 2)];
+  kept.forEach((segment, index) => {
+    if (index === insertAt) parts.push(app1);
+    parts.push(bytes.subarray(segment.offset, segment.end));
+  });
+  if (insertAt >= kept.length) parts.push(app1);
+  parts.push(bytes.subarray(scanStart));
+  return concat(...parts);
+}
+function readJpegXmp(bytes) {
+  for (const segment of jpegSegments(bytes).segments) {
+    if (isJpegXmp(bytes, segment)) {
+      return new TextDecoder().decode(
+        bytes.subarray(segment.dataStart + XMP_NS.length, segment.end)
+      );
+    }
+  }
+  return null;
+}
+function webpChunks(bytes) {
+  const chunks = [];
+  const riffEnd = Math.min(bytes.length, 8 + readU32LE(bytes, 4));
+  let offset = 12;
+  while (offset + 8 <= riffEnd) {
+    const fourcc = ascii(bytes, offset, 4);
+    const size = readU32LE(bytes, offset + 4);
+    const dataStart = offset + 8;
+    const end = dataStart + size + size % 2;
+    if (dataStart + size > bytes.length) throw new Error("Witness: truncated WebP chunk");
+    chunks.push({ fourcc, offset, dataStart, size, end: Math.min(end, bytes.length) });
+    offset = end;
+  }
+  return chunks;
+}
+function writeWebp(bytes, xmp) {
+  const chunks = webpChunks(bytes).filter((chunk) => chunk.fourcc !== "XMP ");
+  const first = chunks[0];
+  if (!first) throw new Error("Witness: empty WebP file");
+  const parts = [];
+  if (first.fourcc === "VP8X") {
+    const vp8x = bytes.slice(first.offset, first.end);
+    vp8x[8] = (vp8x[8] ?? 0) | 4;
+    parts.push(vp8x);
+    for (const chunk of chunks.slice(1)) parts.push(bytes.subarray(chunk.offset, chunk.end));
+  } else {
+    const { width, height, alpha } = webpCanvas(bytes, first);
+    const data = new Uint8Array(10);
+    data[0] = 4 | (alpha ? 16 : 0);
+    writeU24LE(data, 4, width - 1);
+    writeU24LE(data, 7, height - 1);
+    parts.push(riffChunk("VP8X", data));
+    for (const chunk of chunks) parts.push(bytes.subarray(chunk.offset, chunk.end));
+  }
+  parts.push(riffChunk("XMP ", utf8(xmp)));
+  const body = concat(...parts);
+  const out = new Uint8Array(12 + body.length);
+  out.set(latin1("RIFF"), 0);
+  writeU32LE(out, 4, 4 + body.length);
+  out.set(latin1("WEBP"), 8);
+  out.set(body, 12);
+  return out;
+}
+function webpCanvas(bytes, chunk) {
+  const d = chunk.dataStart;
+  if (chunk.fourcc === "VP8 ") {
+    if (bytes[d + 3] !== 157 || bytes[d + 4] !== 1 || bytes[d + 5] !== 42) {
+      throw new Error("Witness: invalid VP8 frame");
+    }
+    return {
+      width: readU16LE(bytes, d + 6) & 16383,
+      height: readU16LE(bytes, d + 8) & 16383,
+      alpha: false
+    };
+  }
+  if (chunk.fourcc === "VP8L") {
+    if (bytes[d] !== 47) throw new Error("Witness: invalid VP8L frame");
+    const bits = readU32LE(bytes, d + 1);
+    return {
+      width: (bits & 16383) + 1,
+      height: (bits >>> 14 & 16383) + 1,
+      alpha: (bits >>> 28 & 1) === 1
+    };
+  }
+  throw new Error(`Witness: unexpected WebP chunk ${chunk.fourcc}`);
+}
+function readWebpXmp(bytes) {
+  const chunk = webpChunks(bytes).find((c) => c.fourcc === "XMP ");
+  return chunk ? new TextDecoder().decode(bytes.subarray(chunk.dataStart, chunk.dataStart + chunk.size)) : null;
+}
+function riffChunk(fourcc, data) {
+  const out = new Uint8Array(8 + data.length + data.length % 2);
+  out.set(latin1(fourcc), 0);
+  writeU32LE(out, 4, data.length);
+  out.set(data, 8);
+  return out;
+}
+function readXmp(bytes, format2) {
+  if (format2 === "png") return readPngXmp(bytes);
+  if (format2 === "jpeg") return readJpegXmp(bytes);
+  return readWebpXmp(bytes);
+}
+function hasC2pa(bytes, format2) {
+  if (format2 === "png") return pngChunks(bytes).some((chunk) => chunk.type === "caBX");
+  if (format2 === "webp") return webpChunks(bytes).some((chunk) => chunk.fourcc === "C2PA");
+  return jpegSegments(bytes).segments.some(
+    (segment) => segment.marker === 235 && ascii(bytes, segment.dataStart, Math.min(64, segment.end - segment.dataStart)).includes(
+      "c2pa"
+    )
+  );
+}
+function ascii(bytes, offset, length) {
+  let out = "";
+  for (let i = offset; i < offset + length && i < bytes.length; i++) {
+    out += String.fromCharCode(bytes[i] ?? 0);
+  }
+  return out;
+}
+function latin1(text) {
+  const out = new Uint8Array(text.length);
+  for (let i = 0; i < text.length; i++) out[i] = text.charCodeAt(i) & 255;
+  return out;
+}
+function utf8(text) {
+  return new TextEncoder().encode(text);
+}
+function concat(...parts) {
+  const out = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function readU16BE(b, o) {
+  return (b[o] ?? 0) << 8 | (b[o + 1] ?? 0);
+}
+function readU16LE(b, o) {
+  return (b[o] ?? 0) | (b[o + 1] ?? 0) << 8;
+}
+function readU32BE(b, o) {
+  return ((b[o] ?? 0) << 24 | (b[o + 1] ?? 0) << 16 | (b[o + 2] ?? 0) << 8 | (b[o + 3] ?? 0)) >>> 0;
+}
+function readU32LE(b, o) {
+  return ((b[o] ?? 0) | (b[o + 1] ?? 0) << 8 | (b[o + 2] ?? 0) << 16 | (b[o + 3] ?? 0) << 24) >>> 0;
+}
+function writeU32BE(b, o, v) {
+  b[o] = v >>> 24 & 255;
+  b[o + 1] = v >>> 16 & 255;
+  b[o + 2] = v >>> 8 & 255;
+  b[o + 3] = v & 255;
+}
+function writeU32LE(b, o, v) {
+  b[o] = v & 255;
+  b[o + 1] = v >>> 8 & 255;
+  b[o + 2] = v >>> 16 & 255;
+  b[o + 3] = v >>> 24 & 255;
+}
+function writeU24LE(b, o, v) {
+  b[o] = v & 255;
+  b[o + 1] = v >>> 8 & 255;
+  b[o + 2] = v >>> 16 & 255;
+}
+var crcTable = null;
+function crc32(data) {
+  if (!crcTable) {
+    crcTable = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+      let c = n;
+      for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+      crcTable[n] = c >>> 0;
+    }
+  }
+  let crc = 4294967295;
+  for (const byte of data) crc = (crcTable[(crc ^ byte) & 255] ?? 0) ^ crc >>> 8;
+  return (crc ^ 4294967295) >>> 0;
+}
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function unescapeXml(value) {
+  return value.replace(/&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+
+// src/types.ts
+var DISCLOSURE_KINDS = [
+  "chatbot",
+  "generated",
+  "edited",
+  "deepfake",
+  "emotion-recognition",
+  "biometric-categorisation"
+];
+
+// src/watermark.ts
+var MAGIC = [87, 49];
+var MAX_PAYLOAD = 255;
+function watermarkText(text, mark = {}) {
+  if (text.length === 0) return text;
+  return stripTextWatermark(text) + watermarkSuffix(mark);
+}
+function watermarkSuffix(mark = {}) {
+  const payload = encodePayload(mark);
+  return [...MAGIC, payload.length, ...payload].map(byteToSelector).join("");
+}
+function readTextWatermark(text) {
+  for (const run of selectorRuns(text)) {
+    const found = findInRun(run.bytes);
+    if (found) {
+      const raw = new TextDecoder().decode(new Uint8Array(found.payload));
+      return { ...decodePayload(raw), raw };
+    }
+  }
+  return null;
+}
+function hasTextWatermark(text) {
+  return readTextWatermark(text) !== null;
+}
+function stripTextWatermark(text) {
+  const chars = [...text];
+  const remove = /* @__PURE__ */ new Set();
+  for (const run of selectorRuns(text)) {
+    let offset = 0;
+    while (offset < run.bytes.length) {
+      const found = findInRun(run.bytes.slice(offset));
+      if (!found) break;
+      const start = offset + found.start;
+      const end = offset + found.end;
+      for (let i = start; i < end; i++) remove.add(run.start + i);
+      offset = end;
+    }
+  }
+  if (remove.size === 0) return text;
+  return chars.filter((_, index) => !remove.has(index)).join("");
+}
+function encodePayload(mark) {
+  const fields = [];
+  if (mark.generator) fields.push(`g=${encodeURIComponent(mark.generator)}`);
+  if (mark.createdAt) fields.push(`t=${encodeURIComponent(mark.createdAt)}`);
+  if (mark.id) fields.push(`i=${encodeURIComponent(mark.id)}`);
+  let bytes = [...new TextEncoder().encode(fields.join(";"))];
+  if (bytes.length > MAX_PAYLOAD) {
+    while (fields.length > 0 && bytes.length > MAX_PAYLOAD) {
+      fields.pop();
+      bytes = [...new TextEncoder().encode(fields.join(";"))];
+    }
+  }
+  return bytes;
+}
+function decodePayload(raw) {
+  const result = {};
+  for (const field of raw.split(";")) {
+    const index = field.indexOf("=");
+    if (index < 1) continue;
+    const key = field.slice(0, index);
+    let value;
+    try {
+      value = decodeURIComponent(field.slice(index + 1));
+    } catch {
+      continue;
+    }
+    if (key === "g") result.generator = value;
+    else if (key === "t") result.createdAt = value;
+    else if (key === "i") result.id = value;
+  }
+  return result;
+}
+function byteToSelector(byte) {
+  return byte < 16 ? String.fromCodePoint(65024 + byte) : String.fromCodePoint(917760 + (byte - 16));
+}
+function selectorToByte(codePoint) {
+  if (codePoint >= 65024 && codePoint <= 65039) return codePoint - 65024;
+  if (codePoint >= 917760 && codePoint <= 917999) return codePoint - 917760 + 16;
+  return null;
+}
+function selectorRuns(text) {
+  const runs = [];
+  let current = null;
+  let index = 0;
+  for (const char of text) {
+    const byte = selectorToByte(char.codePointAt(0) ?? 0);
+    if (byte === null) {
+      current = null;
+    } else {
+      if (!current) {
+        current = { start: index, bytes: [] };
+        runs.push(current);
+      }
+      current.bytes.push(byte);
+    }
+    index++;
+  }
+  return runs;
+}
+function findInRun(bytes) {
+  for (let i = 0; i + MAGIC.length < bytes.length; i++) {
+    if (bytes[i] !== MAGIC[0] || bytes[i + 1] !== MAGIC[1]) continue;
+    const length = bytes[i + 2];
+    if (length === void 0) continue;
+    const start = i + 3;
+    const end = start + length;
+    if (end > bytes.length) continue;
+    return { start: i, end, payload: bytes.slice(start, end) };
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BUILT_IN_LOCALES,
+  DISCLOSURE_KINDS,
+  buildXmp,
+  createDisclosure,
+  createMarking,
+  detectImageFormat,
+  disclosureText,
+  escapeHtml,
+  format,
+  generatorName,
+  getMessages,
+  hasTextWatermark,
+  iptcSourceType,
+  isAiSourceType,
+  labelHtml,
+  labelText,
+  markImage,
+  markingAttributes,
+  markingJsonLd,
+  markingMetaTags,
+  memoryStorage,
+  nextMetadata,
+  parseSourceType,
+  readImageMarking,
+  readTextWatermark,
+  registerLocale,
+  registeredLocales,
+  renderJsonLd,
+  renderMetaTags,
+  resolveLocale,
+  schemaOrgSourceType,
+  stripTextWatermark,
+  watermarkSuffix,
+  watermarkText
+});
+//# sourceMappingURL=index.cjs.map