@aglyn/aglyn 1.0.0-beta.198 → 1.0.0-beta.199

package/src/lib/app-utils/media-embedded-metadata/image-blocks.d.ts

@@ -0,0 +1,145 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * The raw metadata BLOCKS of an image container (AGL-3331), and the byte
+ * helpers the container modules share.
+ *
+ * Each image format hides the same few payloads in its own wrapper — EXIF is
+ * a JPEG APP1 segment, a PNG `eXIf` chunk, a WebP `EXIF` chunk and a HEIF
+ * item — and the container modules (`jpeg.ts`, `png.ts`, `webp.ts`, `gif.ts`,
+ * `heif.ts`) do nothing but find those payloads and, for the writable
+ * formats, put new ones back. They never interpret EXIF, IPTC or XMP; the
+ * block readers do, over the {@link ImageBlocks} handed to them. Keeping the
+ * split is what lets one EXIF parser serve four containers.
+ */
+/** One PNG text chunk (PNG 3rd edition, 11.3.3). */
+export interface PngTextChunk {
+    /** 1 to 79 Latin-1 characters. */
+    keyword: string;
+    text: string;
+    type: 'tEXt' | 'zTXt' | 'iTXt';
+    /** `iTXt` only: the RFC 3066 language tag, when there is one. */
+    language?: string;
+    /** `iTXt` only: the keyword translated into `language`. */
+    translatedKeyword?: string;
+}
+/**
+ * The metadata payloads found in one image, unwrapped from their container.
+ * A key is absent when the file does not carry that block.
+ */
+export interface ImageBlocks {
+    /**
+     * TIFF-structured EXIF, starting at the byte-order mark (`II*\0` or
+     * `MM\0*`): the JPEG `Exif\0\0` prefix and HEIF's 4-byte header offset are
+     * already stripped.
+     */
+    exif?: Uint8Array;
+    /** The standard (main) XMP packet, decoded as UTF-8. */
+    xmp?: string;
+    /**
+     * Photoshop Image Resource Blocks — the JPEG APP13 payload after
+     * `Photoshop 3.0\0`, with several consecutive APP13 segments concatenated
+     * in file order the way Photoshop splits a large one.
+     */
+    irb?: Uint8Array;
+    /** JPEG COM segments and GIF comment extensions, in file order. */
+    comments?: string[];
+    /** Every PNG text chunk except the XMP one, in file order. */
+    pngText?: PngTextChunk[];
+    /**
+     * The ICC profile: JPEG APP2 `ICC_PROFILE` chunks reassembled by sequence
+     * number, a PNG `iCCP` inflated, a WebP `ICCP`, a GIF `ICCRGBG1`
+     * application extension, or a HEIF `colr` box of type `prof`/`rICC`.
+     */
+    icc?: Uint8Array;
+}
+/**
+ * An edit to an image's blocks. For every key, `undefined` keeps the block
+ * as it is and `null` removes it.
+ *
+ * A writer throws `EmbeddedWriteError` when asked to SET a block its
+ * container has no place for (IRB in a PNG, a text chunk in a JPEG); asking
+ * to remove one is a no-op, since the file already does not carry it.
+ */
+export interface ImageBlockUpdate {
+    exif?: Uint8Array | null;
+    xmp?: string | null;
+    irb?: Uint8Array | null;
+    /** PNG only: set or remove a text chunk by keyword. */
+    pngText?: Record<string, string | null>;
+}
+/** Reads an unsigned 16-bit big-endian integer. */
+export declare function readU16BE(bytes: Uint8Array, offset: number): number;
+/** Reads an unsigned 16-bit little-endian integer. */
+export declare function readU16LE(bytes: Uint8Array, offset: number): number;
+/** Reads an unsigned 24-bit little-endian integer. */
+export declare function readU24LE(bytes: Uint8Array, offset: number): number;
+/** Reads an unsigned 32-bit big-endian integer. */
+export declare function readU32BE(bytes: Uint8Array, offset: number): number;
+/** Reads an unsigned 32-bit little-endian integer. */
+export declare function readU32LE(bytes: Uint8Array, offset: number): number;
+/** Writes an unsigned 16-bit big-endian integer. */
+export declare function writeU16BE(bytes: Uint8Array, offset: number, value: number): void;
+/** Writes an unsigned 32-bit big-endian integer. */
+export declare function writeU32BE(bytes: Uint8Array, offset: number, value: number): void;
+/** Writes an unsigned 32-bit little-endian integer. */
+export declare function writeU32LE(bytes: Uint8Array, offset: number, value: number): void;
+/** Whether `bytes` holds exactly `magic` at `offset`. */
+export declare function bytesAt(bytes: Uint8Array, offset: number, magic: Uint8Array): boolean;
+/** The first index of `needle` in `bytes` at or after `from`, or -1. */
+export declare function indexOfBytes(bytes: Uint8Array, needle: Uint8Array, from?: number, to?: number): number;
+/** The ASCII (Latin-1) bytes of a string of code points below 256. */
+export declare function asciiBytes(text: string): Uint8Array;
+/** Reads `length` bytes at `offset` as a four-character code or tag. */
+export declare function readAscii(bytes: Uint8Array, offset: number, length: number): string;
+/** Decodes ISO 8859-1, where every byte is the code point of its value. */
+export declare function latin1Decode(bytes: Uint8Array): string;
+/**
+ * Encodes a string as ISO 8859-1, or `null` when any character is outside
+ * it (the signal for PNG to use `iTXt` instead of `tEXt`).
+ */
+export declare function latin1Encode(text: string): Uint8Array | null;
+/** Decodes UTF-8, replacing malformed sequences rather than throwing. */
+export declare function utf8Decode(bytes: Uint8Array): string;
+/** Encodes a string as UTF-8. */
+export declare function utf8Encode(text: string): Uint8Array;
+/**
+ * Decodes free text of unknown encoding — a JPEG COM segment, a GIF comment
+ * — as UTF-8 when it is valid UTF-8 and as Latin-1 otherwise. Neither format
+ * names an encoding; UTF-8 is what current tools write and Latin-1 is what
+ * older ones did, and a Latin-1 accent is almost never valid UTF-8.
+ */
+export declare function decodeFreeText(bytes: Uint8Array): string;
+/** Decodes big-endian UTF-16 code units (ICC `mluc`/`desc` text). */
+export declare function utf16beDecode(bytes: Uint8Array): string;
+/** Removes trailing NUL characters, which several writers terminate with. */
+export declare function trimNul(text: string): string;
+/** Concatenates byte arrays into one new array. */
+export declare function concatBytes(parts: readonly Uint8Array[]): Uint8Array;
+/**
+ * CRC-32 (ISO 3309 / ITU-T V.42, polynomial 0xEDB88320), the checksum every
+ * PNG chunk ends with (PNG 3rd edition, 5.5). Computed here rather than
+ * through `zlib.crc32`, which older Node releases do not have.
+ */
+export declare function crc32(...parts: Uint8Array[]): number;
+/**
+ * The sentence every writer throws when a block will not fit its container
+ * — a JPEG segment tops out at 64 KB.
+ */
+export declare const METADATA_TOO_LARGE = "This file's embedded metadata is too large to edit here.";
+/** The sentence a writer throws when the file's own structure is broken. */
+export declare const FILE_DAMAGED = "This file's structure is damaged, so its embedded metadata cannot be edited safely.";

package/src/lib/app-utils/media-embedded-metadata/image-blocks.js

@@ -0,0 +1,200 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * The raw metadata BLOCKS of an image container (AGL-3331), and the byte
+ * helpers the container modules share.
+ *
+ * Each image format hides the same few payloads in its own wrapper — EXIF is
+ * a JPEG APP1 segment, a PNG `eXIf` chunk, a WebP `EXIF` chunk and a HEIF
+ * item — and the container modules (`jpeg.ts`, `png.ts`, `webp.ts`, `gif.ts`,
+ * `heif.ts`) do nothing but find those payloads and, for the writable
+ * formats, put new ones back. They never interpret EXIF, IPTC or XMP; the
+ * block readers do, over the {@link ImageBlocks} handed to them. Keeping the
+ * split is what lets one EXIF parser serve four containers.
+ */ /** One PNG text chunk (PNG 3rd edition, 11.3.3). */ // ---------------------------------------------------------------------------
+// Byte helpers shared by the container modules. Every read is bounds-safe: a
+// byte past the end reads as 0, so a caller that checked its range once can
+// read without a second check, and one that did not gets zeros, not a throw.
+// ---------------------------------------------------------------------------
+/** Reads an unsigned 16-bit big-endian integer. */ export function readU16BE(bytes, offset) {
+    var _bytes_offset, _bytes_;
+    return ((_bytes_offset = bytes[offset]) != null ? _bytes_offset : 0) << 8 | ((_bytes_ = bytes[offset + 1]) != null ? _bytes_ : 0);
+}
+/** Reads an unsigned 16-bit little-endian integer. */ export function readU16LE(bytes, offset) {
+    var _bytes_offset, _bytes_;
+    return ((_bytes_offset = bytes[offset]) != null ? _bytes_offset : 0) | ((_bytes_ = bytes[offset + 1]) != null ? _bytes_ : 0) << 8;
+}
+/** Reads an unsigned 24-bit little-endian integer. */ export function readU24LE(bytes, offset) {
+    var _bytes_offset, _bytes_, _bytes_1;
+    return ((_bytes_offset = bytes[offset]) != null ? _bytes_offset : 0) | ((_bytes_ = bytes[offset + 1]) != null ? _bytes_ : 0) << 8 | ((_bytes_1 = bytes[offset + 2]) != null ? _bytes_1 : 0) << 16;
+}
+/** Reads an unsigned 32-bit big-endian integer. */ export function readU32BE(bytes, offset) {
+    var _bytes_offset, _bytes_, _bytes_1, _bytes_2;
+    return ((_bytes_offset = bytes[offset]) != null ? _bytes_offset : 0) * 0x1000000 + (((_bytes_ = bytes[offset + 1]) != null ? _bytes_ : 0) << 16 | ((_bytes_1 = bytes[offset + 2]) != null ? _bytes_1 : 0) << 8 | ((_bytes_2 = bytes[offset + 3]) != null ? _bytes_2 : 0));
+}
+/** Reads an unsigned 32-bit little-endian integer. */ export function readU32LE(bytes, offset) {
+    var _bytes_, _bytes_1, _bytes_2, _bytes_offset;
+    return ((_bytes_ = bytes[offset + 3]) != null ? _bytes_ : 0) * 0x1000000 + (((_bytes_1 = bytes[offset + 2]) != null ? _bytes_1 : 0) << 16 | ((_bytes_2 = bytes[offset + 1]) != null ? _bytes_2 : 0) << 8 | ((_bytes_offset = bytes[offset]) != null ? _bytes_offset : 0));
+}
+/** Writes an unsigned 16-bit big-endian integer. */ export function writeU16BE(bytes, offset, value) {
+    bytes[offset] = value >>> 8 & 0xff;
+    bytes[offset + 1] = value & 0xff;
+}
+/** Writes an unsigned 32-bit big-endian integer. */ export function writeU32BE(bytes, offset, value) {
+    bytes[offset] = value >>> 24 & 0xff;
+    bytes[offset + 1] = value >>> 16 & 0xff;
+    bytes[offset + 2] = value >>> 8 & 0xff;
+    bytes[offset + 3] = value & 0xff;
+}
+/** Writes an unsigned 32-bit little-endian integer. */ export function writeU32LE(bytes, offset, value) {
+    bytes[offset] = value & 0xff;
+    bytes[offset + 1] = value >>> 8 & 0xff;
+    bytes[offset + 2] = value >>> 16 & 0xff;
+    bytes[offset + 3] = value >>> 24 & 0xff;
+}
+/** Whether `bytes` holds exactly `magic` at `offset`. */ export function bytesAt(bytes, offset, magic) {
+    if (offset < 0 || offset + magic.length > bytes.length) return false;
+    for(let i = 0; i < magic.length; i += 1){
+        if (bytes[offset + i] !== magic[i]) return false;
+    }
+    return true;
+}
+/** The first index of `needle` in `bytes` at or after `from`, or -1. */ export function indexOfBytes(bytes, needle, from = 0, to = bytes.length) {
+    const first = needle[0];
+    if (first === undefined) return -1;
+    const last = Math.min(to, bytes.length) - needle.length;
+    for(let i = Math.max(0, from); i <= last; i += 1){
+        if (bytes[i] === first && bytesAt(bytes, i, needle)) return i;
+    }
+    return -1;
+}
+/** The ASCII (Latin-1) bytes of a string of code points below 256. */ export function asciiBytes(text) {
+    const out = new Uint8Array(text.length);
+    for(let i = 0; i < text.length; i += 1)out[i] = text.charCodeAt(i) & 0xff;
+    return out;
+}
+/** Reads `length` bytes at `offset` as a four-character code or tag. */ export function readAscii(bytes, offset, length) {
+    let out = '';
+    const end = Math.min(bytes.length, offset + length);
+    for(let i = Math.max(0, offset); i < end; i += 1){
+        var _bytes_i;
+        out += String.fromCharCode((_bytes_i = bytes[i]) != null ? _bytes_i : 0);
+    }
+    return out;
+}
+/** Decodes ISO 8859-1, where every byte is the code point of its value. */ export function latin1Decode(bytes) {
+    let out = '';
+    // Chunked so a long text chunk never builds a huge argument list.
+    for(let i = 0; i < bytes.length; i += 0x2000){
+        out += String.fromCharCode(...bytes.subarray(i, i + 0x2000));
+    }
+    return out;
+}
+/**
+ * Encodes a string as ISO 8859-1, or `null` when any character is outside
+ * it (the signal for PNG to use `iTXt` instead of `tEXt`).
+ */ export function latin1Encode(text) {
+    const out = new Uint8Array(text.length);
+    for(let i = 0; i < text.length; i += 1){
+        const code = text.charCodeAt(i);
+        if (code > 0xff) return null;
+        out[i] = code;
+    }
+    return out;
+}
+const utf8Lenient = new TextDecoder('utf-8');
+const utf8Strict = new TextDecoder('utf-8', {
+    fatal: true
+});
+const utf8Encoder = new TextEncoder();
+/** Decodes UTF-8, replacing malformed sequences rather than throwing. */ export function utf8Decode(bytes) {
+    return utf8Lenient.decode(bytes);
+}
+/** Encodes a string as UTF-8. */ export function utf8Encode(text) {
+    return utf8Encoder.encode(text);
+}
+/**
+ * Decodes free text of unknown encoding — a JPEG COM segment, a GIF comment
+ * — as UTF-8 when it is valid UTF-8 and as Latin-1 otherwise. Neither format
+ * names an encoding; UTF-8 is what current tools write and Latin-1 is what
+ * older ones did, and a Latin-1 accent is almost never valid UTF-8.
+ */ export function decodeFreeText(bytes) {
+    try {
+        return utf8Strict.decode(bytes);
+    } catch (unused) {
+        return latin1Decode(bytes);
+    }
+}
+/** Decodes big-endian UTF-16 code units (ICC `mluc`/`desc` text). */ export function utf16beDecode(bytes) {
+    let out = '';
+    const units = [];
+    for(let i = 0; i + 1 < bytes.length; i += 2){
+        units.push(readU16BE(bytes, i));
+        if (units.length === 0x2000) {
+            out += String.fromCharCode(...units);
+            units.length = 0;
+        }
+    }
+    return out + String.fromCharCode(...units);
+}
+/** Removes trailing NUL characters, which several writers terminate with. */ export function trimNul(text) {
+    let end = text.length;
+    while(end > 0 && text.charCodeAt(end - 1) === 0)end -= 1;
+    return text.slice(0, end);
+}
+/** Concatenates byte arrays into one new array. */ export function concatBytes(parts) {
+    let length = 0;
+    for (const part of parts)length += part.length;
+    const out = new Uint8Array(length);
+    let offset = 0;
+    for (const part of parts){
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}
+let crcTable = null;
+/**
+ * CRC-32 (ISO 3309 / ITU-T V.42, polynomial 0xEDB88320), the checksum every
+ * PNG chunk ends with (PNG 3rd edition, 5.5). Computed here rather than
+ * through `zlib.crc32`, which older Node releases do not have.
+ */ export function crc32(...parts) {
+    if (!crcTable) {
+        crcTable = new Uint32Array(256);
+        for(let n = 0; n < 256; n += 1){
+            let c = n;
+            for(let k = 0; k < 8; k += 1){
+                c = c & 1 ? 0xedb88320 ^ c >>> 1 : c >>> 1;
+            }
+            crcTable[n] = c >>> 0;
+        }
+    }
+    let crc = 0xffffffff;
+    for (const part of parts){
+        for(let i = 0; i < part.length; i += 1){
+            var _crcTable_, _part_i;
+            crc = ((_crcTable_ = crcTable[(crc ^ ((_part_i = part[i]) != null ? _part_i : 0)) & 0xff]) != null ? _crcTable_ : 0) ^ crc >>> 8;
+        }
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+/**
+ * The sentence every writer throws when a block will not fit its container
+ * — a JPEG segment tops out at 64 KB.
+ */ export const METADATA_TOO_LARGE = "This file's embedded metadata is too large to edit here.";
+/** The sentence a writer throws when the file's own structure is broken. */ export const FILE_DAMAGED = "This file's structure is damaged, so its embedded metadata cannot be edited safely.";
+
+//# sourceMappingURL=image-blocks.js.map

package/src/lib/app-utils/media-embedded-metadata/image-blocks.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/aglyn/src/lib/app-utils/media-embedded-metadata/image-blocks.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * The raw metadata BLOCKS of an image container (AGL-3331), and the byte\n * helpers the container modules share.\n *\n * Each image format hides the same few payloads in its own wrapper — EXIF is\n * a JPEG APP1 segment, a PNG `eXIf` chunk, a WebP `EXIF` chunk and a HEIF\n * item — and the container modules (`jpeg.ts`, `png.ts`, `webp.ts`, `gif.ts`,\n * `heif.ts`) do nothing but find those payloads and, for the writable\n * formats, put new ones back. They never interpret EXIF, IPTC or XMP; the\n * block readers do, over the {@link ImageBlocks} handed to them. Keeping the\n * split is what lets one EXIF parser serve four containers.\n */\n\n/** One PNG text chunk (PNG 3rd edition, 11.3.3). */\nexport interface PngTextChunk {\n  /** 1 to 79 Latin-1 characters. */\n  keyword: string\n  text: string\n  type: 'tEXt' | 'zTXt' | 'iTXt'\n  /** `iTXt` only: the RFC 3066 language tag, when there is one. */\n  language?: string\n  /** `iTXt` only: the keyword translated into `language`. */\n  translatedKeyword?: string\n}\n\n/**\n * The metadata payloads found in one image, unwrapped from their container.\n * A key is absent when the file does not carry that block.\n */\nexport interface ImageBlocks {\n  /**\n   * TIFF-structured EXIF, starting at the byte-order mark (`II*\\0` or\n   * `MM\\0*`): the JPEG `Exif\\0\\0` prefix and HEIF's 4-byte header offset are\n   * already stripped.\n   */\n  exif?: Uint8Array\n  /** The standard (main) XMP packet, decoded as UTF-8. */\n  xmp?: string\n  /**\n   * Photoshop Image Resource Blocks — the JPEG APP13 payload after\n   * `Photoshop 3.0\\0`, with several consecutive APP13 segments concatenated\n   * in file order the way Photoshop splits a large one.\n   */\n  irb?: Uint8Array\n  /** JPEG COM segments and GIF comment extensions, in file order. */\n  comments?: string[]\n  /** Every PNG text chunk except the XMP one, in file order. */\n  pngText?: PngTextChunk[]\n  /**\n   * The ICC profile: JPEG APP2 `ICC_PROFILE` chunks reassembled by sequence\n   * number, a PNG `iCCP` inflated, a WebP `ICCP`, a GIF `ICCRGBG1`\n   * application extension, or a HEIF `colr` box of type `prof`/`rICC`.\n   */\n  icc?: Uint8Array\n}\n\n/**\n * An edit to an image's blocks. For every key, `undefined` keeps the block\n * as it is and `null` removes it.\n *\n * A writer throws `EmbeddedWriteError` when asked to SET a block its\n * container has no place for (IRB in a PNG, a text chunk in a JPEG); asking\n * to remove one is a no-op, since the file already does not carry it.\n */\nexport interface ImageBlockUpdate {\n  exif?: Uint8Array | null\n  xmp?: string | null\n  irb?: Uint8Array | null\n  /** PNG only: set or remove a text chunk by keyword. */\n  pngText?: Record<string, string | null>\n}\n\n// ---------------------------------------------------------------------------\n// Byte helpers shared by the container modules. Every read is bounds-safe: a\n// byte past the end reads as 0, so a caller that checked its range once can\n// read without a second check, and one that did not gets zeros, not a throw.\n// ---------------------------------------------------------------------------\n\n/** Reads an unsigned 16-bit big-endian integer. */\nexport function readU16BE(bytes: Uint8Array, offset: number): number {\n  return ((bytes[offset] ?? 0) << 8) | (bytes[offset + 1] ?? 0)\n}\n\n/** Reads an unsigned 16-bit little-endian integer. */\nexport function readU16LE(bytes: Uint8Array, offset: number): number {\n  return (bytes[offset] ?? 0) | ((bytes[offset + 1] ?? 0) << 8)\n}\n\n/** Reads an unsigned 24-bit little-endian integer. */\nexport function readU24LE(bytes: Uint8Array, offset: number): number {\n  return (\n    (bytes[offset] ?? 0) |\n    ((bytes[offset + 1] ?? 0) << 8) |\n    ((bytes[offset + 2] ?? 0) << 16)\n  )\n}\n\n/** Reads an unsigned 32-bit big-endian integer. */\nexport function readU32BE(bytes: Uint8Array, offset: number): number {\n  return (\n    (bytes[offset] ?? 0) * 0x1000000 +\n    (((bytes[offset + 1] ?? 0) << 16) |\n      ((bytes[offset + 2] ?? 0) << 8) |\n      (bytes[offset + 3] ?? 0))\n  )\n}\n\n/** Reads an unsigned 32-bit little-endian integer. */\nexport function readU32LE(bytes: Uint8Array, offset: number): number {\n  return (\n    (bytes[offset + 3] ?? 0) * 0x1000000 +\n    (((bytes[offset + 2] ?? 0) << 16) |\n      ((bytes[offset + 1] ?? 0) << 8) |\n      (bytes[offset] ?? 0))\n  )\n}\n\n/** Writes an unsigned 16-bit big-endian integer. */\nexport function writeU16BE(bytes: Uint8Array, offset: number, value: number) {\n  bytes[offset] = (value >>> 8) & 0xff\n  bytes[offset + 1] = value & 0xff\n}\n\n/** Writes an unsigned 32-bit big-endian integer. */\nexport function writeU32BE(bytes: Uint8Array, offset: number, value: number) {\n  bytes[offset] = (value >>> 24) & 0xff\n  bytes[offset + 1] = (value >>> 16) & 0xff\n  bytes[offset + 2] = (value >>> 8) & 0xff\n  bytes[offset + 3] = value & 0xff\n}\n\n/** Writes an unsigned 32-bit little-endian integer. */\nexport function writeU32LE(bytes: Uint8Array, offset: number, value: number) {\n  bytes[offset] = value & 0xff\n  bytes[offset + 1] = (value >>> 8) & 0xff\n  bytes[offset + 2] = (value >>> 16) & 0xff\n  bytes[offset + 3] = (value >>> 24) & 0xff\n}\n\n/** Whether `bytes` holds exactly `magic` at `offset`. */\nexport function bytesAt(\n  bytes: Uint8Array,\n  offset: number,\n  magic: Uint8Array,\n): boolean {\n  if (offset < 0 || offset + magic.length > bytes.length) return false\n  for (let i = 0; i < magic.length; i += 1) {\n    if (bytes[offset + i] !== magic[i]) return false\n  }\n  return true\n}\n\n/** The first index of `needle` in `bytes` at or after `from`, or -1. */\nexport function indexOfBytes(\n  bytes: Uint8Array,\n  needle: Uint8Array,\n  from = 0,\n  to = bytes.length,\n): number {\n  const first = needle[0]\n  if (first === undefined) return -1\n  const last = Math.min(to, bytes.length) - needle.length\n  for (let i = Math.max(0, from); i <= last; i += 1) {\n    if (bytes[i] === first && bytesAt(bytes, i, needle)) return i\n  }\n  return -1\n}\n\n/** The ASCII (Latin-1) bytes of a string of code points below 256. */\nexport function asciiBytes(text: string): Uint8Array {\n  const out = new Uint8Array(text.length)\n  for (let i = 0; i < text.length; i += 1) out[i] = text.charCodeAt(i) & 0xff\n  return out\n}\n\n/** Reads `length` bytes at `offset` as a four-character code or tag. */\nexport function readAscii(\n  bytes: Uint8Array,\n  offset: number,\n  length: number,\n): string {\n  let out = ''\n  const end = Math.min(bytes.length, offset + length)\n  for (let i = Math.max(0, offset); i < end; i += 1) {\n    out += String.fromCharCode(bytes[i] ?? 0)\n  }\n  return out\n}\n\n/** Decodes ISO 8859-1, where every byte is the code point of its value. */\nexport function latin1Decode(bytes: Uint8Array): string {\n  let out = ''\n  // Chunked so a long text chunk never builds a huge argument list.\n  for (let i = 0; i < bytes.length; i += 0x2000) {\n    out += String.fromCharCode(...bytes.subarray(i, i + 0x2000))\n  }\n  return out\n}\n\n/**\n * Encodes a string as ISO 8859-1, or `null` when any character is outside\n * it (the signal for PNG to use `iTXt` instead of `tEXt`).\n */\nexport function latin1Encode(text: string): Uint8Array | null {\n  const out = new Uint8Array(text.length)\n  for (let i = 0; i < text.length; i += 1) {\n    const code = text.charCodeAt(i)\n    if (code > 0xff) return null\n    out[i] = code\n  }\n  return out\n}\n\nconst utf8Lenient = new TextDecoder('utf-8')\nconst utf8Strict = new TextDecoder('utf-8', { fatal: true })\nconst utf8Encoder = new TextEncoder()\n\n/** Decodes UTF-8, replacing malformed sequences rather than throwing. */\nexport function utf8Decode(bytes: Uint8Array): string {\n  return utf8Lenient.decode(bytes)\n}\n\n/** Encodes a string as UTF-8. */\nexport function utf8Encode(text: string): Uint8Array {\n  return utf8Encoder.encode(text)\n}\n\n/**\n * Decodes free text of unknown encoding — a JPEG COM segment, a GIF comment\n * — as UTF-8 when it is valid UTF-8 and as Latin-1 otherwise. Neither format\n * names an encoding; UTF-8 is what current tools write and Latin-1 is what\n * older ones did, and a Latin-1 accent is almost never valid UTF-8.\n */\nexport function decodeFreeText(bytes: Uint8Array): string {\n  try {\n    return utf8Strict.decode(bytes)\n  } catch {\n    return latin1Decode(bytes)\n  }\n}\n\n/** Decodes big-endian UTF-16 code units (ICC `mluc`/`desc` text). */\nexport function utf16beDecode(bytes: Uint8Array): string {\n  let out = ''\n  const units: number[] = []\n  for (let i = 0; i + 1 < bytes.length; i += 2) {\n    units.push(readU16BE(bytes, i))\n    if (units.length === 0x2000) {\n      out += String.fromCharCode(...units)\n      units.length = 0\n    }\n  }\n  return out + String.fromCharCode(...units)\n}\n\n/** Removes trailing NUL characters, which several writers terminate with. */\nexport function trimNul(text: string): string {\n  let end = text.length\n  while (end > 0 && text.charCodeAt(end - 1) === 0) end -= 1\n  return text.slice(0, end)\n}\n\n/** Concatenates byte arrays into one new array. */\nexport function concatBytes(parts: readonly Uint8Array[]): Uint8Array {\n  let length = 0\n  for (const part of parts) length += part.length\n  const out = new Uint8Array(length)\n  let offset = 0\n  for (const part of parts) {\n    out.set(part, offset)\n    offset += part.length\n  }\n  return out\n}\n\nlet crcTable: Uint32Array | null = null\n\n/**\n * CRC-32 (ISO 3309 / ITU-T V.42, polynomial 0xEDB88320), the checksum every\n * PNG chunk ends with (PNG 3rd edition, 5.5). Computed here rather than\n * through `zlib.crc32`, which older Node releases do not have.\n */\nexport function crc32(...parts: Uint8Array[]): number {\n  if (!crcTable) {\n    crcTable = new Uint32Array(256)\n    for (let n = 0; n < 256; n += 1) {\n      let c = n\n      for (let k = 0; k < 8; k += 1) {\n        c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1\n      }\n      crcTable[n] = c >>> 0\n    }\n  }\n  let crc = 0xffffffff\n  for (const part of parts) {\n    for (let i = 0; i < part.length; i += 1) {\n      crc = (crcTable[(crc ^ (part[i] ?? 0)) & 0xff] ?? 0) ^ (crc >>> 8)\n    }\n  }\n  return (crc ^ 0xffffffff) >>> 0\n}\n\n/**\n * The sentence every writer throws when a block will not fit its container\n * — a JPEG segment tops out at 64 KB.\n */\nexport const METADATA_TOO_LARGE =\n  \"This file's embedded metadata is too large to edit here.\"\n\n/** The sentence a writer throws when the file's own structure is broken. */\nexport const FILE_DAMAGED =\n  \"This file's structure is damaged, so its embedded metadata cannot be edited safely.\"\n"],"names":["readU16BE","bytes","offset","readU16LE","readU24LE","readU32BE","readU32LE","writeU16BE","value","writeU32BE","writeU32LE","bytesAt","magic","length","i","indexOfBytes","needle","from","to","first","undefined","last","Math","min","max","asciiBytes","text","out","Uint8Array","charCodeAt","readAscii","end","String","fromCharCode","latin1Decode","subarray","latin1Encode","code","utf8Lenient","TextDecoder","utf8Strict","fatal","utf8Encoder","TextEncoder","utf8Decode","decode","utf8Encode","encode","decodeFreeText","utf16beDecode","units","push","trimNul","slice","concatBytes","parts","part","set","crcTable","crc32","Uint32Array","n","c","k","crc","METADATA_TOO_LARGE","FILE_DAMAGED"],"mappings":"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"}

package/src/lib/app-utils/media-embedded-metadata/index.d.ts

@@ -0,0 +1,93 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Reads the metadata a media file carries inside its own bytes, and writes
+ * edits back into them without re-encoding anything (AGL-3331).
+ *
+ * This file is the dispatcher. It sniffs the container, hands the bytes to
+ * the format module, and folds what comes back — up to three copies of a
+ * photo's caption, from XMP, IPTC and EXIF — into the one list of fields a
+ * media document stores. Writing is the same trip in reverse: one edit fans
+ * out to every block that already holds that idea, so no stale copy is left
+ * for the next reader to prefer.
+ *
+ * Server-only: exposed through `@aglyn/aglyn/server` and never the client
+ * barrel. The client half — the catalog, the value formats, the edit rules —
+ * is `../media-embedded-fields`.
+ */
+import { type MediaEmbeddedField, type MediaEmbeddedFormat, type MediaEmbeddedMetadata, type MediaEmbeddedPatch } from '../media-embedded-fields';
+import { bytesReader, EmbeddedWriteError, type EmbeddedByteReader, type EmbeddedCandidate } from './types';
+export { bytesReader, EmbeddedWriteError };
+export type { EmbeddedByteReader, EmbeddedCandidate };
+/**
+ * The most of a file the reader will pull into memory, by format.
+ *
+ * Every one is the upload ceiling for the family, so an asset the DAM
+ * accepted is always readable; the numbers exist so a future raise of a
+ * ceiling does not silently turn this into a 500 MB download. Video is read
+ * by range — its metadata lives in one box, not across the file — and its
+ * cap is on that box (see `mp4.ts`).
+ */
+export declare const MEDIA_EMBEDDED_READ_MAX_BYTES: Record<Exclude<MediaEmbeddedFormat, 'mp4' | 'webm'>, number>;
+/**
+ * Which reader a file gets, from its first bytes — the stored content type
+ * only breaks the ties the bytes cannot (an ISOBMFF `ftyp` is a HEIC photo
+ * or an MP4 film; a ZIP is a Word file or a ZIP). A type label is the
+ * uploader's claim and the signature is the file's, so the signature wins
+ * wherever it can speak.
+ */
+export declare function embeddedFormatFor(contentType: string, head: Uint8Array): MediaEmbeddedFormat | null;
+/**
+ * Fold every block's candidates into the stored field list.
+ *
+ * One field per key, valued from the most-believed source that holds it and
+ * naming every source that does. A value clipped to the stored cap is shown
+ * and NOT offered for editing: saving it back would write the clipped text
+ * over the whole one, which is data loss the person never asked for.
+ */
+export declare function mergeEmbeddedCandidates(format: MediaEmbeddedFormat, candidates: EmbeddedCandidate[]): {
+    fields: MediaEmbeddedField[];
+    truncated: boolean;
+};
+/**
+ * Read a stored file's embedded metadata.
+ *
+ * Returns `null` when the format has no reader or the file is past the read
+ * cap — the drawer then simply has no "In the file" section, which is the
+ * honest thing to show about a CSV. Never throws on the bytes: every format
+ * module is written to return what it could read from a hostile file.
+ */
+export declare function readMediaEmbeddedMetadata(options: {
+    contentType: string;
+    reader: EmbeddedByteReader;
+    contentSha256?: string;
+}): Promise<MediaEmbeddedMetadata | null>;
+/**
+ * Write an edit into a file's bytes and return the new bytes.
+ *
+ * The patch is validated against the catalog first (the route has already
+ * done so for the person's benefit; this is for every other caller), then
+ * written by the format module. Throws `EmbeddedWriteError` — a sentence for
+ * the person who asked — when the file cannot take it safely; anything else
+ * thrown is a fault.
+ */
+export declare function writeMediaEmbeddedMetadata(options: {
+    contentType: string;
+    bytes: Uint8Array;
+    patch: MediaEmbeddedPatch;
+    now?: Date;
+}): Uint8Array;