@su-engineering/heic 0.1.0

package/dist/index.js

@@ -0,0 +1,1648 @@
+import { HeicParseError, HeicUnsupportedError, HeicAbortError, HeicDecodeError } from './chunk-Y5FFG5J7.js';
+export { HeicAbortError, HeicDecodeError, HeicError, HeicParseError, HeicUnsupportedError } from './chunk-Y5FFG5J7.js';
+
+// src/bytes.ts
+function toBlobPart(bytes) {
+  return bytes;
+}
+function toHeicBlob(bytes) {
+  return new Blob([toBlobPart(bytes)], { type: "image/heic" });
+}
+
+// src/render/canvas.ts
+function createCanvas(width, height) {
+  if (typeof OffscreenCanvas === "undefined") {
+    throw new HeicDecodeError(
+      "OffscreenCanvas is not available; this environment cannot composite",
+      {}
+    );
+  }
+  return new OffscreenCanvas(width, height);
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw new HeicAbortError();
+}
+
+// src/decoders/native.ts
+var nativeDecoderRejects = false;
+async function decodeNative(blob, plan, signal) {
+  if (typeof createImageBitmap === "undefined") {
+    return { status: "unsupported", reason: "createImageBitmap is not available" };
+  }
+  if (nativeDecoderRejects) {
+    return { status: "unsupported", reason: "this browser has no HEIC image decoder" };
+  }
+  throwIfAborted(signal);
+  let bitmap;
+  try {
+    bitmap = await createImageBitmap(blob);
+  } catch {
+    nativeDecoderRejects = true;
+    return { status: "unsupported", reason: "createImageBitmap rejected the file" };
+  }
+  throwIfAborted(signal);
+  if (!dimensionsMatch(bitmap, plan)) {
+    const got = `${bitmap.width}x${bitmap.height}`;
+    bitmap.close();
+    return {
+      status: "wrong-image",
+      reason: `returned ${got}, expected ${plan.displayWidth}x${plan.displayHeight}`
+    };
+  }
+  return { status: "ok", bitmap };
+}
+function dimensionsMatch(bitmap, plan) {
+  const { displayWidth, displayHeight } = plan;
+  const upright = bitmap.width === displayWidth && bitmap.height === displayHeight;
+  const swapped = bitmap.width === displayHeight && bitmap.height === displayWidth;
+  return upright || swapped;
+}
+async function probeNativeSupport() {
+  if (typeof createImageBitmap === "undefined") return false;
+  try {
+    const bytes = decodeBase64(TINY_HEIC_BASE64);
+    const bitmap = await createImageBitmap(toHeicBlob(bytes));
+    const ok = bitmap.width === TINY_HEIC_WIDTH && bitmap.height === TINY_HEIC_HEIGHT;
+    bitmap.close();
+    return ok;
+  } catch {
+    return false;
+  }
+}
+function decodeBase64(input) {
+  const binary = atob(input);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+  return out;
+}
+var TINY_HEIC_WIDTH = 2;
+var TINY_HEIC_HEIGHT = 2;
+var TINY_HEIC_BASE64 = "AAAAHGZ0eXBoZWljAAAAAG1pZjFoZWljbWlhZgAAAXxtZXRhAAAAAAAAACFoZGxyAAAAAAAAAABwaWN0AAAAAAAAAAAAAAAAAAAAACJpbG9jAAAAAERAAAEAAQAAAAABoAABAAAAAAAAADcAAAAjaWluZgAAAAAAAQAAABVpbmZlAgAAAAABAABodmMxAAAAAA5waXRtAAAAAAABAAAA/GlwcnAAAADcaXBjbwAAAHVodmNDAQNwAAAAAAAAAAAAHvAA/P34+AAADwNgAAEAGEABDAH//wNwAAADAJAAAAMAAAMAHroCQGEAAQApQgEBA3AAAAMAkAAAAwAAAwAeoCCBBZbqrprm4CGgwIAAAAyAAAADAIRiAAEABkQBwXPBiQAAABNjb2xybmNseAABAA0ABoAAAAAUaXNwZQAAAAAAAABAAAAAQAAAAChjbGFwAAAAAgAAAAEAAAACAAAAAf///8IAAAAC////wgAAAAIAAAAQcGl4aQAAAAADCAgIAAAAGGlwbWEAAAAAAAAAAQABBYECAwWEAAAAP21kYXQAAAAzKAGvBjIWhzSJIPC/cov//8tX9l+i9qzWyeuEfoBjx+S3kJGe9F97GFLlPHQg9JxTuc2A";
+
+// src/parser/reader.ts
+var Reader = class _Reader {
+  bytes;
+  view;
+  /** Absolute offset of this window's start within the underlying ArrayBuffer. */
+  base;
+  /** Cursor, relative to the window start. */
+  pos = 0;
+  constructor(source, byteOffset = 0, byteLength) {
+    const u8 = source instanceof Uint8Array ? source : new Uint8Array(source);
+    const start = u8.byteOffset + byteOffset;
+    const length = byteLength ?? u8.byteLength - byteOffset;
+    if (byteOffset < 0 || length < 0 || byteOffset + length > u8.byteLength) {
+      throw new HeicParseError("Reader window is outside the source buffer", {
+        offset: byteOffset
+      });
+    }
+    this.bytes = new Uint8Array(u8.buffer, start, length);
+    this.view = new DataView(u8.buffer, start, length);
+    this.base = start;
+  }
+  get length() {
+    return this.bytes.byteLength;
+  }
+  get offset() {
+    return this.pos;
+  }
+  /** Absolute offset of the cursor in the underlying buffer, for error reports. */
+  get absoluteOffset() {
+    return this.base + this.pos;
+  }
+  get remaining() {
+    return this.length - this.pos;
+  }
+  get eof() {
+    return this.pos >= this.length;
+  }
+  seek(to) {
+    this.require(0, to);
+    this.pos = to;
+  }
+  skip(count) {
+    this.require(count);
+    this.pos += count;
+  }
+  /**
+   * Throws unless `count` bytes are readable at `at` (default: the cursor).
+   * Callers that are about to allocate should call this first with the declared
+   * size, so a hostile length field fails here rather than in the allocator.
+   */
+  require(count, at = this.pos) {
+    if (!Number.isFinite(count) || count < 0 || !Number.isFinite(at) || at < 0) {
+      throw new HeicParseError("Malformed read request", { offset: this.base + this.pos });
+    }
+    if (at + count > this.length) {
+      throw new HeicParseError(
+        `Read of ${count} bytes at ${at} exceeds the ${this.length}-byte window`,
+        { offset: this.base + at }
+      );
+    }
+  }
+  u8() {
+    this.require(1);
+    return this.view.getUint8(this.pos++);
+  }
+  u16() {
+    this.require(2);
+    const value = this.view.getUint16(this.pos);
+    this.pos += 2;
+    return value;
+  }
+  u24() {
+    this.require(3);
+    const value = this.view.getUint8(this.pos) << 16 | this.view.getUint8(this.pos + 1) << 8 | this.view.getUint8(this.pos + 2);
+    this.pos += 3;
+    return value >>> 0;
+  }
+  u32() {
+    this.require(4);
+    const value = this.view.getUint32(this.pos);
+    this.pos += 4;
+    return value >>> 0;
+  }
+  /**
+   * Returns a JS number, not a BigInt. Values above Number.MAX_SAFE_INTEGER are
+   * rejected rather than silently losing precision — a 9-petabyte box size is a
+   * malformed file, not something to accommodate.
+   */
+  u64() {
+    this.require(8);
+    const value = this.view.getBigUint64(this.pos);
+    this.pos += 8;
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new HeicParseError("64-bit value exceeds the safe integer range", {
+        offset: this.base + this.pos - 8
+      });
+    }
+    return Number(value);
+  }
+  /** Reads a big-endian unsigned integer of 0, 1, 2, 4 or 8 bytes. `iloc` needs this. */
+  uint(byteCount) {
+    switch (byteCount) {
+      case 0:
+        return 0;
+      case 1:
+        return this.u8();
+      case 2:
+        return this.u16();
+      case 4:
+        return this.u32();
+      case 8:
+        return this.u64();
+      default:
+        throw new HeicParseError(`Unsupported integer width: ${byteCount} bytes`, {
+          offset: this.base + this.pos
+        });
+    }
+  }
+  /** Four-character box type. Non-printable bytes are escaped so error messages stay readable. */
+  fourCC() {
+    this.require(4);
+    let out = "";
+    for (let i = 0; i < 4; i++) {
+      const byte = this.view.getUint8(this.pos + i);
+      out += byte >= 32 && byte <= 126 ? String.fromCharCode(byte) : `\\x${byte.toString(16).padStart(2, "0")}`;
+    }
+    this.pos += 4;
+    return out;
+  }
+  /** NUL-terminated UTF-8 string. Stops at the window end if the NUL is missing. */
+  cString() {
+    const start = this.pos;
+    while (this.pos < this.length && this.bytes[this.pos] !== 0) this.pos++;
+    const raw = this.bytes.subarray(start, this.pos);
+    if (this.pos < this.length) this.pos++;
+    return new TextDecoder().decode(raw);
+  }
+  /** A view onto the next `count` bytes. No copy — do not retain past the buffer's life. */
+  view_(count) {
+    this.require(count);
+    const out = this.bytes.subarray(this.pos, this.pos + count);
+    this.pos += count;
+    return out;
+  }
+  /** A copy of the next `count` bytes. Use when the result outlives the source buffer. */
+  copy(count) {
+    return new Uint8Array(this.view_(count));
+  }
+  /** A sub-reader over `count` bytes, advancing this reader past them. */
+  sub(count) {
+    this.require(count);
+    const child = new _Reader(this.bytes, this.pos, count);
+    this.pos += count;
+    return child;
+  }
+  /** A sub-reader over the rest of the window, without advancing this reader. */
+  peekRest() {
+    return new _Reader(this.bytes, this.pos, this.remaining);
+  }
+};
+function readFullBoxHeader(reader) {
+  const version = reader.u8();
+  const flags = reader.u24();
+  return { version, flags };
+}
+
+// src/parser/hvcc.ts
+var NAL_VPS = 32;
+var NAL_SPS = 33;
+var NAL_PPS = 34;
+var MAX_HVCC_ARRAYS = 32;
+var MAX_NALUS_PER_ARRAY = 256;
+function parseHvcC(reader) {
+  const raw = reader.peekRest().bytes;
+  const configurationVersion = reader.u8();
+  if (configurationVersion !== 1) {
+    throw new HeicParseError(
+      `Unsupported HEVCDecoderConfigurationRecord version ${configurationVersion}`,
+      { box: "hvcC" }
+    );
+  }
+  const profileByte = reader.u8();
+  const generalProfileSpace = profileByte >> 6 & 3;
+  const generalTierFlag = profileByte >> 5 & 1;
+  const generalProfileIdc = profileByte & 31;
+  const generalProfileCompatibilityFlags = reader.u32();
+  const generalConstraintIndicatorFlags = reader.copy(6);
+  const generalLevelIdc = reader.u8();
+  const minSpatialSegmentationIdc = reader.u16() & 4095;
+  const parallelismType = reader.u8() & 3;
+  const chromaFormat = reader.u8() & 3;
+  const bitDepthLumaMinus8 = reader.u8() & 7;
+  const bitDepthChromaMinus8 = reader.u8() & 7;
+  const avgFrameRate = reader.u16();
+  const rateByte = reader.u8();
+  const constantFrameRate = rateByte >> 6 & 3;
+  const numTemporalLayers = rateByte >> 3 & 7;
+  const temporalIdNested = rateByte >> 2 & 1;
+  const lengthSizeMinusOne = rateByte & 3;
+  const numOfArrays = reader.u8();
+  if (numOfArrays > MAX_HVCC_ARRAYS) {
+    throw new HeicParseError(`hvcC declares ${numOfArrays} NAL arrays`, { box: "hvcC" });
+  }
+  const arrays = [];
+  for (let i = 0; i < numOfArrays; i++) {
+    const head = reader.u8();
+    const arrayCompleteness = (head >> 7 & 1) === 1;
+    const nalUnitType = head & 63;
+    const numNalus = reader.u16();
+    if (numNalus > MAX_NALUS_PER_ARRAY) {
+      throw new HeicParseError(`hvcC array declares ${numNalus} NAL units`, { box: "hvcC" });
+    }
+    const nalus = [];
+    for (let j = 0; j < numNalus; j++) {
+      const nalUnitLength = reader.u16();
+      nalus.push(reader.view_(nalUnitLength));
+    }
+    arrays.push({ arrayCompleteness, nalUnitType, nalus });
+  }
+  return {
+    configurationVersion,
+    generalProfileSpace,
+    generalTierFlag,
+    generalProfileIdc,
+    generalProfileCompatibilityFlags,
+    generalConstraintIndicatorFlags,
+    generalLevelIdc,
+    minSpatialSegmentationIdc,
+    parallelismType,
+    chromaFormat,
+    bitDepthLumaMinus8,
+    bitDepthChromaMinus8,
+    avgFrameRate,
+    constantFrameRate,
+    numTemporalLayers,
+    temporalIdNested,
+    lengthSizeMinusOne,
+    arrays,
+    raw
+  };
+}
+var PROFILE_SPACE_PREFIX = ["", "A", "B", "C"];
+function hvccToCodecString(hvcc, fourCC = "hvc1") {
+  const space = PROFILE_SPACE_PREFIX[hvcc.generalProfileSpace] ?? "";
+  const profile = `${space}${hvcc.generalProfileIdc}`;
+  const compat = reverseBits32(hvcc.generalProfileCompatibilityFlags).toString(16);
+  const tier = hvcc.generalTierFlag === 1 ? "H" : "L";
+  const level = `${tier}${hvcc.generalLevelIdc}`;
+  const constraintBytes = [...hvcc.generalConstraintIndicatorFlags];
+  while (constraintBytes.length > 0 && constraintBytes[constraintBytes.length - 1] === 0) {
+    constraintBytes.pop();
+  }
+  const constraints = constraintBytes.map((b) => b.toString(16).padStart(2, "0").toUpperCase());
+  return [fourCC, profile, compat, level, ...constraints].join(".");
+}
+function reverseBits32(value) {
+  let v = value >>> 0;
+  v = (v & 1431655765) << 1 | v >>> 1 & 1431655765;
+  v = (v & 858993459) << 2 | v >>> 2 & 858993459;
+  v = (v & 252645135) << 4 | v >>> 4 & 252645135;
+  v = (v & 16711935) << 8 | v >>> 8 & 16711935;
+  v = v >>> 16 | v << 16;
+  return v >>> 0;
+}
+function hvccBitDepth(hvcc) {
+  return hvcc.bitDepthLumaMinus8 + 8;
+}
+function hvccToAnnexBPrologue(hvcc) {
+  const wanted = [NAL_VPS, NAL_SPS, NAL_PPS];
+  const selected = wanted.flatMap((type) => hvcc.arrays.filter((a) => a.nalUnitType === type)).flatMap((a) => a.nalus);
+  let total = 0;
+  for (const nalu of selected) total += 4 + nalu.byteLength;
+  const out = new Uint8Array(total);
+  let pos = 0;
+  for (const nalu of selected) {
+    out.set([0, 0, 0, 1], pos);
+    pos += 4;
+    out.set(nalu, pos);
+    pos += nalu.byteLength;
+  }
+  return out;
+}
+function lengthPrefixedToAnnexB(data, lengthSize) {
+  if (lengthSize < 1 || lengthSize > 4) {
+    throw new HeicParseError(`Invalid NAL length size ${lengthSize}`, { box: "hvcC" });
+  }
+  const out = new Uint8Array(data.byteLength + countNalUnits(data, lengthSize) * (4 - lengthSize));
+  let read = 0;
+  let write = 0;
+  while (read + lengthSize <= data.byteLength) {
+    let naluLength = 0;
+    for (let i = 0; i < lengthSize; i++) naluLength = naluLength << 8 | data[read + i];
+    read += lengthSize;
+    if (naluLength < 0 || read + naluLength > data.byteLength) {
+      throw new HeicParseError("NAL unit length runs past the end of the item payload", {
+        offset: read
+      });
+    }
+    out.set([0, 0, 0, 1], write);
+    write += 4;
+    out.set(data.subarray(read, read + naluLength), write);
+    write += naluLength;
+    read += naluLength;
+  }
+  return out.subarray(0, write);
+}
+function countNalUnits(data, lengthSize) {
+  let read = 0;
+  let count = 0;
+  while (read + lengthSize <= data.byteLength) {
+    let naluLength = 0;
+    for (let i = 0; i < lengthSize; i++) naluLength = naluLength << 8 | data[read + i];
+    read += lengthSize + naluLength;
+    if (naluLength < 0 || read > data.byteLength) break;
+    count++;
+  }
+  return count;
+}
+
+// src/parser/boxes.ts
+var MAX_BOX_DEPTH = 32;
+var MAX_SIBLING_BOXES = 65536;
+function* walkBoxes(reader, options = {}) {
+  const { depth = 0, lenient = false } = typeof options === "number" ? { depth: options, lenient: false } : options;
+  if (depth > MAX_BOX_DEPTH) {
+    throw new HeicParseError(`Box nesting deeper than ${MAX_BOX_DEPTH}`, {
+      offset: reader.absoluteOffset
+    });
+  }
+  let count = 0;
+  while (reader.remaining >= 8) {
+    if (++count > MAX_SIBLING_BOXES) {
+      throw new HeicParseError(`More than ${MAX_SIBLING_BOXES} sibling boxes at one level`, {
+        offset: reader.absoluteOffset
+      });
+    }
+    const offset = reader.absoluteOffset;
+    const start = reader.offset;
+    let size = reader.u32();
+    const type = reader.fourCC();
+    let headerSize = 8;
+    if (size === 1) {
+      size = reader.u64();
+      headerSize = 16;
+    } else if (size === 0) {
+      size = reader.length - start;
+    }
+    if (size < headerSize) {
+      if (lenient) return;
+      throw new HeicParseError(`Box size ${size} is smaller than its ${headerSize}-byte header`, {
+        offset,
+        box: type
+      });
+    }
+    if (start + size > reader.length) {
+      if (lenient) return;
+      throw new HeicParseError(
+        `Box extends ${start + size - reader.length} bytes past its container`,
+        { offset, box: type }
+      );
+    }
+    const payloadSize = size - headerSize;
+    const body = reader.sub(payloadSize);
+    yield { type, offset, size, headerSize, body };
+    reader.seek(start + size);
+  }
+}
+function childBoxes(reader, options = {}) {
+  return [...walkBoxes(reader, options)];
+}
+function findBox(boxes, type) {
+  return boxes.find((box) => box.type === type);
+}
+function findBoxes(boxes, type) {
+  return boxes.filter((box) => box.type === type);
+}
+
+// src/parser/meta.ts
+var MAX_ITEMS = 65536;
+var MAX_EXTENTS_PER_ITEM = 4096;
+var MAX_PROPERTIES = 4096;
+var MAX_ASSOCIATIONS_PER_ITEM = 256;
+var MAX_REFERENCES_PER_ITEM = 8192;
+function parseInfe(box) {
+  const r = box.body;
+  const { version, flags } = readFullBoxHeader(r);
+  const hidden = (flags & 1) === 1;
+  if (version >= 2) {
+    const itemId2 = version === 2 ? r.u16() : r.u32();
+    const protectionIndex2 = r.u16();
+    const itemType = r.fourCC();
+    const itemName2 = r.cString();
+    const info = { itemId: itemId2, protectionIndex: protectionIndex2, itemType, itemName: itemName2, hidden };
+    if (itemType === "mime") info.contentType = r.cString();
+    return info;
+  }
+  const itemId = r.u16();
+  const protectionIndex = r.u16();
+  const itemName = r.cString();
+  const contentType = r.cString();
+  return { itemId, protectionIndex, itemType: "", itemName, contentType, hidden };
+}
+function parseIinf(box) {
+  const r = box.body;
+  const { version } = readFullBoxHeader(r);
+  const entryCount = version === 0 ? r.u16() : r.u32();
+  if (entryCount > MAX_ITEMS) {
+    throw new HeicParseError(`iinf declares ${entryCount} items`, { box: "iinf" });
+  }
+  const items = /* @__PURE__ */ new Map();
+  let seen = 0;
+  for (const child of walkBoxes(r.peekRest())) {
+    if (child.type !== "infe") continue;
+    if (++seen > MAX_ITEMS) break;
+    const info = parseInfe(child);
+    items.set(info.itemId, info);
+  }
+  return items;
+}
+function parseIloc(box) {
+  const r = box.body;
+  const { version } = readFullBoxHeader(r);
+  const sizesByte = r.u8();
+  const offsetSize = sizesByte >> 4 & 15;
+  const lengthSize = sizesByte & 15;
+  const baseByte = r.u8();
+  const baseOffsetSize = baseByte >> 4 & 15;
+  const indexSize = version === 1 || version === 2 ? baseByte & 15 : 0;
+  const itemCount = version < 2 ? r.u16() : r.u32();
+  if (itemCount > MAX_ITEMS) {
+    throw new HeicParseError(`iloc declares ${itemCount} items`, { box: "iloc" });
+  }
+  const locations = /* @__PURE__ */ new Map();
+  for (let i = 0; i < itemCount; i++) {
+    const itemId = version < 2 ? r.u16() : r.u32();
+    let constructionMethod = 0;
+    if (version === 1 || version === 2) {
+      constructionMethod = r.u16() & 15;
+    }
+    r.u16();
+    const baseOffset = r.uint(baseOffsetSize);
+    const extentCount = r.u16();
+    if (extentCount > MAX_EXTENTS_PER_ITEM) {
+      throw new HeicParseError(`Item ${itemId} declares ${extentCount} extents`, {
+        box: "iloc",
+        itemId
+      });
+    }
+    const extents = [];
+    for (let j = 0; j < extentCount; j++) {
+      if ((version === 1 || version === 2) && indexSize > 0) r.uint(indexSize);
+      const offset = r.uint(offsetSize);
+      const length = r.uint(lengthSize);
+      extents.push({ offset, length });
+    }
+    locations.set(itemId, { itemId, constructionMethod, baseOffset, extents });
+  }
+  return locations;
+}
+function parseProperty(box) {
+  const r = box.body;
+  switch (box.type) {
+    case "ispe": {
+      readFullBoxHeader(r);
+      return { type: "ispe", width: r.u32(), height: r.u32() };
+    }
+    case "hvcC":
+      return { type: "hvcC", hvcc: parseHvcC(r) };
+    case "irot": {
+      const angle = (r.u8() & 3) * 90;
+      return { type: "irot", angle };
+    }
+    case "imir": {
+      const axis = r.u8() & 1;
+      return { type: "imir", axis };
+    }
+    case "colr": {
+      const colorType = r.fourCC();
+      if (colorType === "nclx") {
+        const primaries = r.u16();
+        const transfer = r.u16();
+        const matrix = r.u16();
+        const fullRange = (r.u8() & 128) !== 0;
+        return { type: "colr", colorType: "nclx", primaries, transfer, matrix, fullRange };
+      }
+      if (colorType === "rICC" || colorType === "prof") {
+        return { type: "colr", colorType: "icc", profile: r.copy(r.remaining) };
+      }
+      return { type: "unknown", boxType: `colr:${colorType}` };
+    }
+    case "pixi": {
+      readFullBoxHeader(r);
+      const numChannels = r.u8();
+      const bitsPerChannel = [];
+      for (let i = 0; i < numChannels; i++) bitsPerChannel.push(r.u8());
+      return { type: "pixi", bitsPerChannel };
+    }
+    case "clap":
+      return {
+        type: "clap",
+        widthN: r.u32(),
+        widthD: r.u32(),
+        heightN: r.u32(),
+        heightD: r.u32(),
+        horizOffN: r.u32() | 0,
+        // stored as a signed 32-bit numerator
+        horizOffD: r.u32(),
+        vertOffN: r.u32() | 0,
+        vertOffD: r.u32()
+      };
+    case "auxC": {
+      readFullBoxHeader(r);
+      return { type: "auxC", auxType: r.cString() };
+    }
+    default:
+      return { type: "unknown", boxType: box.type };
+  }
+}
+function parseIpma(box, into) {
+  const r = box.body;
+  const { version, flags } = readFullBoxHeader(r);
+  const wideIndex = (flags & 1) === 1;
+  const entryCount = r.u32();
+  if (entryCount > MAX_ITEMS) {
+    throw new HeicParseError(`ipma declares ${entryCount} entries`, { box: "ipma" });
+  }
+  for (let i = 0; i < entryCount; i++) {
+    const itemId = version === 0 ? r.u16() : r.u32();
+    const associationCount = r.u8();
+    if (associationCount > MAX_ASSOCIATIONS_PER_ITEM) {
+      throw new HeicParseError(`Item ${itemId} declares ${associationCount} properties`, {
+        box: "ipma",
+        itemId
+      });
+    }
+    const associations = [];
+    for (let j = 0; j < associationCount; j++) {
+      if (wideIndex) {
+        const value = r.u16();
+        associations.push({ essential: (value & 32768) !== 0, index: value & 32767 });
+      } else {
+        const value = r.u8();
+        associations.push({ essential: (value & 128) !== 0, index: value & 127 });
+      }
+    }
+    const existing = into.get(itemId);
+    if (existing) existing.push(...associations);
+    else into.set(itemId, associations);
+  }
+}
+function parseIprp(box) {
+  const children = childBoxes(box.body);
+  const ipco = findBox(children, "ipco");
+  const properties = [];
+  if (ipco) {
+    for (const child of walkBoxes(ipco.body)) {
+      if (properties.length >= MAX_PROPERTIES) {
+        throw new HeicParseError(`ipco holds more than ${MAX_PROPERTIES} properties`, {
+          box: "ipco"
+        });
+      }
+      properties.push(parseProperty(child));
+    }
+  }
+  const associations = /* @__PURE__ */ new Map();
+  for (const ipma of findBoxes(children, "ipma")) parseIpma(ipma, associations);
+  return { properties, associations };
+}
+function parseIref(box) {
+  const r = box.body;
+  const { version } = readFullBoxHeader(r);
+  const refs = /* @__PURE__ */ new Map();
+  for (const child of walkBoxes(r.peekRest())) {
+    const cr = child.body;
+    const fromItemId = version === 0 ? cr.u16() : cr.u32();
+    const referenceCount = cr.u16();
+    if (referenceCount > MAX_REFERENCES_PER_ITEM) {
+      throw new HeicParseError(`Item ${fromItemId} declares ${referenceCount} references`, {
+        box: child.type,
+        itemId: fromItemId
+      });
+    }
+    const toItemIds = [];
+    for (let i = 0; i < referenceCount; i++) {
+      toItemIds.push(version === 0 ? cr.u16() : cr.u32());
+    }
+    let byType = refs.get(child.type);
+    if (!byType) refs.set(child.type, byType = /* @__PURE__ */ new Map());
+    byType.set(fromItemId, toItemIds);
+  }
+  return refs;
+}
+function parseHeif(input, options = {}) {
+  const source = input instanceof Uint8Array ? input : new Uint8Array(input);
+  const root = new Reader(source);
+  const boxes = childBoxes(root, { lenient: options.truncated === true });
+  const ftyp = findBox(boxes, "ftyp");
+  if (!ftyp) throw new HeicParseError("No 'ftyp' box: this is not an ISOBMFF file", { offset: 0 });
+  const majorBrand = ftyp.body.fourCC();
+  const minorVersion = ftyp.body.u32();
+  const compatibleBrands = [];
+  while (ftyp.body.remaining >= 4) compatibleBrands.push(ftyp.body.fourCC());
+  const meta = findBox(boxes, "meta");
+  if (!meta) {
+    throw new HeicParseError("No 'meta' box: not a HEIF image file", { brand: majorBrand });
+  }
+  readFullBoxHeader(meta.body);
+  const metaChildren = childBoxes(meta.body, 1);
+  const hdlr = findBox(metaChildren, "hdlr");
+  let handlerType = "";
+  if (hdlr) {
+    readFullBoxHeader(hdlr.body);
+    hdlr.body.u32();
+    handlerType = hdlr.body.fourCC();
+  }
+  if (handlerType && handlerType !== "pict") {
+    throw new HeicParseError(`meta handler is '${handlerType}', expected 'pict'`, {
+      brand: majorBrand
+    });
+  }
+  let primaryItemId = 0;
+  const pitm = findBox(metaChildren, "pitm");
+  if (pitm) {
+    const { version } = readFullBoxHeader(pitm.body);
+    primaryItemId = version === 0 ? pitm.body.u16() : pitm.body.u32();
+  }
+  const iinf = findBox(metaChildren, "iinf");
+  const items = iinf ? parseIinf(iinf) : /* @__PURE__ */ new Map();
+  const iloc = findBox(metaChildren, "iloc");
+  const locations = iloc ? parseIloc(iloc) : /* @__PURE__ */ new Map();
+  const iprp = findBox(metaChildren, "iprp");
+  const itemProperties = iprp ? parseIprp(iprp) : { properties: [], associations: /* @__PURE__ */ new Map() };
+  const iref = findBox(metaChildren, "iref");
+  const references = iref ? parseIref(iref) : /* @__PURE__ */ new Map();
+  const idat = findBox(metaChildren, "idat");
+  const itemData = idat ? idat.body.copy(idat.body.remaining) : void 0;
+  if (primaryItemId === 0) {
+    for (const [id, info] of items) {
+      if (info.itemType === "hvc1" || info.itemType === "hev1" || info.itemType === "grid") {
+        primaryItemId = id;
+        break;
+      }
+    }
+  }
+  return {
+    majorBrand,
+    minorVersion,
+    compatibleBrands,
+    primaryItemId,
+    handlerType,
+    items,
+    locations,
+    itemProperties,
+    references,
+    itemData,
+    source
+  };
+}
+function propertiesForItem(file, itemId) {
+  const associations = file.itemProperties.associations.get(itemId) ?? [];
+  const out = [];
+  for (const association of associations) {
+    if (association.index === 0) continue;
+    const property = file.itemProperties.properties[association.index - 1];
+    if (!property) {
+      throw new HeicParseError(
+        `Item ${itemId} references property ${association.index}, but ipco holds ${file.itemProperties.properties.length}`,
+        { itemId, box: "ipma" }
+      );
+    }
+    if (association.essential && property.type === "unknown") {
+      throw new HeicParseError(
+        `Item ${itemId} requires unsupported essential property '${property.boxType}'`,
+        { itemId, box: property.boxType }
+      );
+    }
+    out.push(property);
+  }
+  return out;
+}
+function findProperty(properties, type) {
+  return properties.find((p) => p.type === type);
+}
+function readItemData(file, itemId) {
+  const location = file.locations.get(itemId);
+  if (!location) {
+    throw new HeicParseError(`No iloc entry for item ${itemId}`, { itemId, box: "iloc" });
+  }
+  const info = file.items.get(itemId);
+  const context2 = { itemId, itemType: info?.itemType, box: "iloc" };
+  let container;
+  switch (location.constructionMethod) {
+    case 0:
+      container = file.source;
+      break;
+    case 1:
+      if (!file.itemData) {
+        throw new HeicParseError(
+          `Item ${itemId} points into 'idat', but the file has no idat box`,
+          context2
+        );
+      }
+      container = file.itemData;
+      break;
+    case 2:
+      throw new HeicParseError(
+        `Item ${itemId} uses construction_method 2 (item offset), which is not supported`,
+        context2
+      );
+    default:
+      throw new HeicParseError(
+        `Item ${itemId} uses unknown construction_method ${location.constructionMethod}`,
+        context2
+      );
+  }
+  let total = 0;
+  for (const extent of location.extents) {
+    const start = location.baseOffset + extent.offset;
+    const length = extent.length === 0 ? container.byteLength - start : extent.length;
+    if (start < 0 || length < 0 || start + length > container.byteLength) {
+      throw new HeicParseError(
+        `Item ${itemId} extent [${start}, ${start + length}) is outside its ${container.byteLength}-byte container`,
+        context2
+      );
+    }
+    total += length;
+  }
+  if (location.extents.length === 1) {
+    const extent = location.extents[0];
+    const start = location.baseOffset + extent.offset;
+    return container.subarray(start, start + total);
+  }
+  const out = new Uint8Array(total);
+  let pos = 0;
+  for (const extent of location.extents) {
+    const start = location.baseOffset + extent.offset;
+    const length = extent.length === 0 ? container.byteLength - start : extent.length;
+    out.set(container.subarray(start, start + length), pos);
+    pos += length;
+  }
+  return out;
+}
+
+// src/parser/grid.ts
+var MAX_TILES = 4096;
+function parseGridPayload(payload) {
+  const r = new Reader(payload);
+  const version = r.u8();
+  if (version !== 0) {
+    throw new HeicParseError(`Unsupported grid version ${version}`, { itemType: "grid" });
+  }
+  const flags = r.u8();
+  const wideFields = (flags & 1) === 1;
+  const rows = r.u8() + 1;
+  const columns = r.u8() + 1;
+  const outputWidth = wideFields ? r.u32() : r.u16();
+  const outputHeight = wideFields ? r.u32() : r.u16();
+  return { rows, columns, outputWidth, outputHeight };
+}
+function readGrid(file, itemId, warnings = []) {
+  const payload = readItemData(file, itemId);
+  const { rows, columns, outputWidth, outputHeight } = parseGridPayload(payload);
+  const tileItemIds = file.references.get("dimg")?.get(itemId) ?? [];
+  if (tileItemIds.length === 0) {
+    throw new HeicParseError(`Grid item ${itemId} has no 'dimg' tile references`, {
+      itemId,
+      itemType: "grid"
+    });
+  }
+  const expected = rows * columns;
+  if (expected !== tileItemIds.length) {
+    throw new HeicParseError(
+      `Grid item ${itemId} declares ${rows}x${columns} = ${expected} tiles but 'dimg' lists ${tileItemIds.length}`,
+      { itemId, itemType: "grid" }
+    );
+  }
+  if (expected > MAX_TILES) {
+    throw new HeicParseError(`Grid item ${itemId} declares ${expected} tiles (max ${MAX_TILES})`, {
+      itemId,
+      itemType: "grid"
+    });
+  }
+  let width = outputWidth;
+  let height = outputHeight;
+  const ispe = findProperty(propertiesForItem(file, itemId), "ispe");
+  if (ispe && (ispe.width !== outputWidth || ispe.height !== outputHeight)) {
+    warnings.push({
+      code: "grid-dimension-mismatch",
+      message: `Grid payload declares ${outputWidth}x${outputHeight} but ispe declares ${ispe.width}x${ispe.height}; using ispe`
+    });
+    width = ispe.width;
+    height = ispe.height;
+  }
+  return { rows, columns, outputWidth: width, outputHeight: height, tileItemIds };
+}
+
+// src/plan.ts
+var MAX_TOTAL_PIXELS = 256e6;
+function planDecode(input) {
+  const file = parseHeif(input);
+  const warnings = [];
+  const primaryItemId = file.primaryItemId;
+  const info = file.items.get(primaryItemId);
+  if (!info) {
+    throw new HeicParseError(`Primary item ${primaryItemId} is not described by iinf`, {
+      brand: file.majorBrand,
+      itemId: primaryItemId
+    });
+  }
+  const isGrid = info.itemType === "grid";
+  if (!isGrid && info.itemType !== "hvc1" && info.itemType !== "hev1") {
+    throw new HeicUnsupportedError(
+      `Primary item type '${info.itemType}' is not a supported image item`,
+      [],
+      { brand: file.majorBrand, itemType: info.itemType, itemId: primaryItemId }
+    );
+  }
+  const primaryProps = propertiesForItem(file, primaryItemId);
+  const tiles = [];
+  let codedWidth;
+  let codedHeight;
+  if (isGrid) {
+    const grid = readGrid(file, primaryItemId, warnings);
+    codedWidth = grid.outputWidth;
+    codedHeight = grid.outputHeight;
+    const firstTileProps = propertiesForItem(file, grid.tileItemIds[0]);
+    const firstIspe = findProperty(firstTileProps, "ispe");
+    if (!firstIspe) {
+      throw new HeicParseError(`Grid tile ${grid.tileItemIds[0]} has no ispe`, {
+        itemId: grid.tileItemIds[0]
+      });
+    }
+    for (const [index, itemId] of grid.tileItemIds.entries()) {
+      const ispe = findProperty(propertiesForItem(file, itemId), "ispe") ?? firstIspe;
+      tiles.push({
+        itemId,
+        x: index % grid.columns * firstIspe.width,
+        y: Math.floor(index / grid.columns) * firstIspe.height,
+        width: ispe.width,
+        height: ispe.height
+      });
+    }
+  } else {
+    const ispe = findProperty(primaryProps, "ispe");
+    if (!ispe) {
+      throw new HeicParseError(`Primary item ${primaryItemId} has no ispe`, {
+        itemId: primaryItemId
+      });
+    }
+    codedWidth = ispe.width;
+    codedHeight = ispe.height;
+    tiles.push({ itemId: primaryItemId, x: 0, y: 0, width: ispe.width, height: ispe.height });
+  }
+  if (codedWidth <= 0 || codedHeight <= 0) {
+    throw new HeicParseError(`Implausible image dimensions ${codedWidth}x${codedHeight}`, {
+      itemId: primaryItemId
+    });
+  }
+  if (codedWidth * codedHeight > MAX_TOTAL_PIXELS) {
+    throw new HeicUnsupportedError(
+      `Image is ${codedWidth}x${codedHeight}, above the ${MAX_TOTAL_PIXELS}-pixel limit`,
+      [],
+      { itemId: primaryItemId }
+    );
+  }
+  const tileGroups = groupTilesByConfig(file, tiles, warnings);
+  const transforms = readTransforms(primaryProps, codedWidth, codedHeight);
+  const { displayWidth, displayHeight } = applyTransformsToSize(
+    codedWidth,
+    codedHeight,
+    transforms
+  );
+  const pixi = findProperty(primaryProps, "pixi");
+  const bitDepth = pixi?.bitsPerChannel[0] ?? hvccBitDepth(tileGroups[0].hvcc);
+  collectFeatureWarnings(file, primaryItemId, warnings);
+  return {
+    file,
+    primaryItemId,
+    isGrid,
+    codedWidth,
+    codedHeight,
+    displayWidth,
+    displayHeight,
+    tiles,
+    tileGroups,
+    transforms,
+    bitDepth,
+    sourceColor: readSourceColor(primaryProps, propertiesForItem(file, tiles[0].itemId)),
+    warnings
+  };
+}
+function groupTilesByConfig(file, tiles, warnings) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const [index, tile] of tiles.entries()) {
+    const associations = file.itemProperties.associations.get(tile.itemId) ?? [];
+    const association = associations.find(
+      (a) => file.itemProperties.properties[a.index - 1]?.type === "hvcC"
+    );
+    if (!association) {
+      throw new HeicParseError(`Item ${tile.itemId} has no hvcC property`, { itemId: tile.itemId });
+    }
+    let group = groups.get(association.index);
+    if (!group) {
+      const property = file.itemProperties.properties[association.index - 1];
+      if (property?.type !== "hvcC") {
+        throw new HeicParseError(`Property ${association.index} is not an hvcC`, {
+          itemId: tile.itemId
+        });
+      }
+      group = {
+        configIndex: association.index,
+        hvcc: property.hvcc,
+        codec: hvccToCodecString(property.hvcc),
+        tileIndices: []
+      };
+      groups.set(association.index, group);
+    }
+    group.tileIndices.push(index);
+  }
+  const result = [...groups.values()];
+  if (result.length === 0) {
+    throw new HeicParseError("No decoder configuration found for any tile", {});
+  }
+  if (result.length > 1) {
+    warnings.push({
+      code: "mixed-tile-configs",
+      message: `Tiles use ${result.length} different decoder configurations; decoding in ${result.length} groups`
+    });
+  }
+  return result;
+}
+function readTransforms(properties, width, height) {
+  const ops = [];
+  let currentWidth = width;
+  let currentHeight = height;
+  for (const property of properties) {
+    switch (property.type) {
+      case "clap": {
+        const crop2 = resolveCleanAperture(property, currentWidth, currentHeight);
+        if (crop2) {
+          ops.push(crop2);
+          currentWidth = crop2.width;
+          currentHeight = crop2.height;
+        }
+        break;
+      }
+      case "irot":
+        if (property.angle !== 0) {
+          ops.push({ kind: "rotate", angle: property.angle });
+          if (property.angle === 90 || property.angle === 270) {
+            [currentWidth, currentHeight] = [currentHeight, currentWidth];
+          }
+        }
+        break;
+      case "imir":
+        ops.push({ kind: "mirror", axis: property.axis });
+        break;
+    }
+  }
+  return ops;
+}
+function resolveCleanAperture(clap, width, height) {
+  if (clap.widthD === 0 || clap.heightD === 0 || clap.horizOffD === 0 || clap.vertOffD === 0) {
+    return void 0;
+  }
+  const cropWidth = Math.round(clap.widthN / clap.widthD);
+  const cropHeight = Math.round(clap.heightN / clap.heightD);
+  const centreOffsetX = clap.horizOffN / clap.horizOffD;
+  const centreOffsetY = clap.vertOffN / clap.vertOffD;
+  const offsetX = Math.round((width - cropWidth) / 2 + centreOffsetX);
+  const offsetY = Math.round((height - cropHeight) / 2 + centreOffsetY);
+  if (cropWidth <= 0 || cropHeight <= 0) return void 0;
+  if (cropWidth === width && cropHeight === height && offsetX === 0 && offsetY === 0) {
+    return void 0;
+  }
+  if (offsetX < 0 || offsetY < 0 || offsetX + cropWidth > width || offsetY + cropHeight > height) {
+    return void 0;
+  }
+  return { kind: "crop", width: cropWidth, height: cropHeight, offsetX, offsetY };
+}
+function applyTransformsToSize(width, height, transforms) {
+  let w = width;
+  let h = height;
+  for (const op of transforms) {
+    if (op.kind === "crop") {
+      w = op.width;
+      h = op.height;
+    } else if (op.kind === "rotate" && (op.angle === 90 || op.angle === 270)) {
+      [w, h] = [h, w];
+    }
+  }
+  return { displayWidth: w, displayHeight: h };
+}
+function readSourceColor(primaryProps, tileProps) {
+  const colr = findProperty(primaryProps, "colr") ?? findProperty(tileProps, "colr");
+  if (!colr) return null;
+  return colr.colorType === "nclx" ? {
+    type: "nclx",
+    primaries: colr.primaries,
+    transfer: colr.transfer,
+    matrix: colr.matrix,
+    fullRange: colr.fullRange
+  } : { type: "icc", profile: colr.profile };
+}
+function collectFeatureWarnings(file, primaryItemId, warnings) {
+  const seen = /* @__PURE__ */ new Set();
+  const add = (warning) => {
+    if (seen.has(warning.code)) return;
+    seen.add(warning.code);
+    warnings.push(warning);
+  };
+  const auxTargets = file.references.get("auxl");
+  if (auxTargets) {
+    for (const [auxItemId, targets] of auxTargets) {
+      if (!targets.includes(primaryItemId)) continue;
+      const auxType = findProperty(propertiesForItem(file, auxItemId), "auxC")?.auxType ?? "";
+      if (/alpha/i.test(auxType)) {
+        add({ code: "alpha-ignored", message: `Alpha aux image ${auxItemId} ignored` });
+      } else if (/depth|disparity/i.test(auxType)) {
+        add({ code: "depth-ignored", message: `Depth aux image ${auxItemId} ignored` });
+      } else if (/hdrgainmap|gainmap/i.test(auxType)) {
+        add({
+          code: "gain-map-ignored",
+          message: `HDR gain map ${auxItemId} ignored; the image decodes as SDR`
+        });
+      }
+    }
+  }
+  for (const item of file.items.values()) {
+    if (item.itemType === "tmap") {
+      add({
+        code: "gain-map-ignored",
+        message: `Tone-map item ${item.itemId} ignored; the image decodes as SDR`
+      });
+      break;
+    }
+  }
+}
+function tileData(plan, tile) {
+  return readItemData(plan.file, tile.itemId);
+}
+
+// src/decoders/webcodecs.ts
+function isWebCodecsAvailable() {
+  return typeof VideoDecoder !== "undefined" && typeof EncodedVideoChunk !== "undefined";
+}
+async function resolveConfig(group, codedWidth, codedHeight) {
+  const lengthSize = group.hvcc.lengthSizeMinusOne + 1;
+  const failures = [];
+  const hvc1 = {
+    codec: group.codec,
+    // A fresh copy: VideoDecoderConfig.description is retained by the decoder,
+    // and hvcc.raw is a view onto the caller's buffer.
+    description: new Uint8Array(group.hvcc.raw),
+    codedWidth,
+    codedHeight,
+    optimizeForLatency: true
+  };
+  try {
+    const support = await VideoDecoder.isConfigSupported(hvc1);
+    if (support.supported) return { mode: "hvc1", config: support.config ?? hvc1, lengthSize };
+    failures.push({ strategy: "hvc1", reason: "isConfigSupported returned false" });
+  } catch (error) {
+    failures.push({ strategy: "hvc1", reason: String(error) });
+  }
+  const hev1 = {
+    codec: hvccToCodecString(group.hvcc, "hev1"),
+    codedWidth,
+    codedHeight,
+    optimizeForLatency: true
+  };
+  try {
+    const support = await VideoDecoder.isConfigSupported(hev1);
+    if (support.supported) {
+      return {
+        mode: "hev1",
+        config: support.config ?? hev1,
+        prologue: hvccToAnnexBPrologue(group.hvcc),
+        lengthSize
+      };
+    }
+    failures.push({ strategy: "hev1", reason: "isConfigSupported returned false" });
+  } catch (error) {
+    failures.push({ strategy: "hev1", reason: String(error) });
+  }
+  throw new HeicUnsupportedError(
+    "No HEVC decoder configuration was accepted",
+    failures,
+    { strategy: "webcodecs", codec: group.codec }
+  );
+}
+function chunkBytes(config, payload) {
+  if (config.mode === "hvc1") return payload;
+  const body = lengthPrefixedToAnnexB(payload, config.lengthSize);
+  const prologue = config.prologue;
+  const out = new Uint8Array(prologue.byteLength + body.byteLength);
+  out.set(prologue, 0);
+  out.set(body, prologue.byteLength);
+  return out;
+}
+async function decodeWithWebCodecs(plan, colorSpace, signal) {
+  if (!isWebCodecsAvailable()) {
+    throw new HeicUnsupportedError(
+      "WebCodecs VideoDecoder is not available in this environment",
+      [{ strategy: "webcodecs", reason: "VideoDecoder is undefined" }],
+      { strategy: "webcodecs" }
+    );
+  }
+  throwIfAborted(signal);
+  const canvas = createCanvas(plan.codedWidth, plan.codedHeight);
+  const ctx = canvas.getContext("2d", { colorSpace, alpha: false, willReadFrequently: false });
+  if (!ctx) {
+    throw new HeicDecodeError("Could not get a 2d context for compositing", {
+      strategy: "webcodecs"
+    });
+  }
+  for (const group of plan.tileGroups) {
+    throwIfAborted(signal);
+    await decodeGroup(plan, group, ctx, signal);
+  }
+  return canvas;
+}
+async function decodeGroup(plan, group, ctx, signal) {
+  const first = plan.tiles[group.tileIndices[0]];
+  const config = await resolveConfig(group, first.width, first.height);
+  throwIfAborted(signal);
+  let nextTile = 0;
+  let drawn = 0;
+  let settle;
+  const failure = new Promise((_, reject) => {
+    settle = reject;
+  });
+  const decoder = new VideoDecoder({
+    output: (frame) => {
+      try {
+        const tile = plan.tiles[group.tileIndices[nextTile++]];
+        if (tile) {
+          ctx.drawImage(frame, tile.x, tile.y, tile.width, tile.height);
+          drawn++;
+        }
+      } finally {
+        frame.close();
+      }
+    },
+    error: (error) => {
+      settle?.(
+        new HeicDecodeError(`VideoDecoder failed: ${error.message}`, {
+          strategy: "webcodecs",
+          codec: config.config.codec
+        })
+      );
+    }
+  });
+  const onAbort = () => settle?.(new HeicAbortError());
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    try {
+      decoder.configure(config.config);
+      for (const tileIndex of group.tileIndices) {
+        const tile = plan.tiles[tileIndex];
+        const bytes = chunkBytes(config, tileData(plan, tile));
+        decoder.decode(
+          new EncodedVideoChunk({ type: "key", timestamp: tileIndex, duration: 0, data: bytes })
+        );
+      }
+    } catch (error) {
+      if (error instanceof HeicAbortError || error instanceof HeicDecodeError) throw error;
+      throw new HeicDecodeError(
+        `VideoDecoder rejected the stream: ${error instanceof Error ? error.message : String(error)}`,
+        { strategy: "webcodecs", codec: config.config.codec },
+        { cause: error }
+      );
+    }
+    await Promise.race([decoder.flush(), failure]);
+    if (drawn !== group.tileIndices.length) {
+      throw new HeicDecodeError(
+        `Decoder emitted ${drawn} frames for ${group.tileIndices.length} tiles`,
+        { strategy: "webcodecs", codec: config.config.codec }
+      );
+    }
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    try {
+      decoder.close();
+    } catch {
+    }
+  }
+}
+var PROBE_CODEC_STRINGS = [
+  "hvc1.3.e.L93.B0",
+  // Main Still Picture, 8-bit — what iPhones write
+  "hvc1.1.6.L93.B0",
+  // Main, 8-bit
+  "hvc1.2.4.L120.B0"
+  // Main10, 10-bit
+];
+async function probeHevcCodecStrings() {
+  if (!isWebCodecsAvailable()) return [];
+  const supported = [];
+  for (const codec of PROBE_CODEC_STRINGS) {
+    try {
+      const support = await VideoDecoder.isConfigSupported({
+        codec,
+        codedWidth: 1920,
+        codedHeight: 1080
+      });
+      if (support.supported) supported.push(codec);
+    } catch {
+    }
+  }
+  return supported;
+}
+
+// src/parser/detect.ts
+var HEIF_BRANDS = /* @__PURE__ */ new Set([
+  "heic",
+  "heix",
+  "hevc",
+  "hevx",
+  "heim",
+  "heis",
+  "hevm",
+  "hevs",
+  "mif1",
+  "msf1"
+]);
+var UNAMBIGUOUS_HEIC_BRANDS = /* @__PURE__ */ new Set([
+  "heic",
+  "heix",
+  "hevc",
+  "hevx",
+  "heim",
+  "heis",
+  "hevm",
+  "hevs"
+]);
+var DETECTION_PREFIX_BYTES = 65536;
+function detectFromBuffer(input) {
+  const source = input instanceof Uint8Array ? input : new Uint8Array(input);
+  let brands;
+  let brand;
+  try {
+    const boxes = childBoxes(new Reader(source), { lenient: true });
+    const ftyp = findBox(boxes, "ftyp");
+    if (!ftyp) return { isHeic: false };
+    brand = ftyp.body.fourCC();
+    brands = /* @__PURE__ */ new Set([brand]);
+    ftyp.body.u32();
+    while (ftyp.body.remaining >= 4) brands.add(ftyp.body.fourCC());
+  } catch {
+    return { isHeic: false };
+  }
+  if (![...brands].some((b) => HEIF_BRANDS.has(b))) return { isHeic: false, brand };
+  let file;
+  try {
+    file = parseHeif(source, { truncated: true });
+  } catch {
+    file = void 0;
+  }
+  const primaryItemType = file?.items.get(file.primaryItemId)?.itemType;
+  const coding = file ? codingOf(file, primaryItemType) : "unknown";
+  if (coding === "av1") return { isHeic: false, brand, primaryItemType, coding };
+  if (coding === "hevc") return { isHeic: true, brand, primaryItemType, coding };
+  const result = {
+    isHeic: [...brands].some((b) => UNAMBIGUOUS_HEIC_BRANDS.has(b)),
+    brand,
+    coding: "unknown"
+  };
+  if (primaryItemType !== void 0) result.primaryItemType = primaryItemType;
+  return result;
+}
+function codingOf(file, itemType, depth = 0) {
+  if (itemType === "hvc1" || itemType === "hev1") return "hevc";
+  if (itemType === "av01") return "av1";
+  if (depth < 4 && (itemType === "grid" || itemType === "iovl" || itemType === "iden")) {
+    const first = file.references.get("dimg")?.get(file.primaryItemId)?.[0];
+    if (first !== void 0) return codingOf(file, file.items.get(first)?.itemType, depth + 1);
+  }
+  return "unknown";
+}
+
+// src/render/transform.ts
+function applyTransforms(source, transforms, colorSpace) {
+  let current = source;
+  for (const op of transforms) {
+    switch (op.kind) {
+      case "crop":
+        current = release(current, crop(current, op, colorSpace), source);
+        break;
+      case "rotate":
+        current = release(current, rotate(current, op.angle, colorSpace), source);
+        break;
+      case "mirror":
+        current = release(current, mirror(current, op.axis, colorSpace), source);
+        break;
+    }
+  }
+  return { canvas: current, applied: summarizeTransforms(transforms) };
+}
+function summarizeTransforms(transforms) {
+  const applied = { rotation: 0, mirrored: "none", cropped: false };
+  for (const op of transforms) {
+    switch (op.kind) {
+      case "crop":
+        applied.cropped = true;
+        break;
+      case "rotate":
+        applied.rotation = (applied.rotation + op.angle) % 360;
+        break;
+      case "mirror": {
+        const direction = mirrorDirection(op.axis);
+        if (applied.mirrored === "none") applied.mirrored = direction;
+        else if (applied.mirrored === direction) applied.mirrored = "none";
+        else {
+          applied.mirrored = "none";
+          applied.rotation = (applied.rotation + 180) % 360;
+        }
+        break;
+      }
+    }
+  }
+  return applied;
+}
+function mirrorDirection(axis) {
+  return axis === 0 ? "vertical" : "horizontal";
+}
+function crop(source, op, colorSpace) {
+  const target = createCanvas(op.width, op.height);
+  const ctx = context(target, colorSpace);
+  ctx.drawImage(
+    source,
+    op.offsetX,
+    op.offsetY,
+    op.width,
+    op.height,
+    0,
+    0,
+    op.width,
+    op.height
+  );
+  return target;
+}
+function rotate(source, angle, colorSpace) {
+  const swap = angle === 90 || angle === 270;
+  const target = createCanvas(
+    swap ? source.height : source.width,
+    swap ? source.width : source.height
+  );
+  const ctx = context(target, colorSpace);
+  ctx.translate(target.width / 2, target.height / 2);
+  ctx.rotate(-angle * Math.PI / 180);
+  ctx.drawImage(source, -source.width / 2, -source.height / 2);
+  return target;
+}
+function mirror(source, axis, colorSpace) {
+  const target = createCanvas(source.width, source.height);
+  const ctx = context(target, colorSpace);
+  if (mirrorDirection(axis) === "horizontal") {
+    ctx.translate(source.width, 0);
+    ctx.scale(-1, 1);
+  } else {
+    ctx.translate(0, source.height);
+    ctx.scale(1, -1);
+  }
+  ctx.drawImage(source, 0, 0);
+  return target;
+}
+function context(canvas, colorSpace) {
+  const ctx = canvas.getContext("2d", { colorSpace, alpha: false });
+  if (!ctx) throw new Error("Could not get a 2d context");
+  return ctx;
+}
+function release(previous, next, original) {
+  if (previous !== original) {
+    previous.width = 0;
+    previous.height = 0;
+  }
+  return next;
+}
+
+// src/probe.ts
+async function probeSupport() {
+  const [native, hevcCodecStrings] = await Promise.all([
+    probeNativeSupport(),
+    probeHevcCodecStrings()
+  ]);
+  const webcodecs = isWebCodecsAvailable() && hevcCodecStrings.length > 0;
+  const recommended = native ? "native" : webcodecs ? "webcodecs" : "wasm";
+  return { native, webcodecs, hevcCodecStrings, recommended };
+}
+
+// src/index.ts
+async function isHeic(input) {
+  const prefix = await readPrefix(input, DETECTION_PREFIX_BYTES);
+  const detection = detectFromBuffer(prefix);
+  const result = { isHeic: detection.isHeic };
+  if (detection.brand !== void 0) result.brand = detection.brand;
+  if (detection.primaryItemType !== void 0) result.primaryItemType = detection.primaryItemType;
+  if (detection.coding !== void 0) result.coding = detection.coding;
+  return result;
+}
+async function decodeHeic(input, options = {}) {
+  const {
+    strategy = "auto",
+    colorSpace = "srgb",
+    maxDimension,
+    signal,
+    wasmLoader
+  } = options;
+  throwIfAborted(signal);
+  const bytes = await readAll(input);
+  throwIfAborted(signal);
+  const plan = planDecode(bytes);
+  throwIfAborted(signal);
+  const attempts = [];
+  const wants = (candidate) => strategy === "auto" || strategy === candidate;
+  if (wants("native")) {
+    const blob = input instanceof Blob ? input : toHeicBlob(bytes);
+    const outcome = await decodeNative(blob, plan, signal);
+    if (outcome.status === "ok") {
+      const finalBitmap = await resizeBitmap(outcome.bitmap, maxDimension, signal);
+      return describe(plan, finalBitmap, "native", summarizeTransforms(plan.transforms));
+    }
+    attempts.push({ strategy: "native", reason: outcome.reason });
+  }
+  if (wants("webcodecs")) {
+    if (!isWebCodecsAvailable()) {
+      attempts.push({ strategy: "webcodecs", reason: "VideoDecoder is not available" });
+    } else {
+      try {
+        const composited = await decodeWithWebCodecs(plan, colorSpace, signal);
+        const { canvas, applied } = applyTransforms(composited, plan.transforms, colorSpace);
+        const bitmap = await canvasToBitmap(canvas, maxDimension, signal);
+        return describe(plan, bitmap, "webcodecs", applied);
+      } catch (error) {
+        if (error instanceof HeicAbortError) throw error;
+        if (strategy === "webcodecs") throw error;
+        attempts.push({ strategy: "webcodecs", reason: describeError(error) });
+      }
+    }
+  }
+  if (wants("wasm")) {
+    const adapter = await resolveAdapter(wasmLoader);
+    if (!adapter) {
+      attempts.push({
+        strategy: "wasm",
+        reason: "no adapter: pass options.wasmLoader or call registerDecoderAdapter()"
+      });
+    } else {
+      try {
+        const result = await adapter.decode({ data: bytes, colorSpace, signal });
+        const applied = summarizeTransforms(plan.transforms);
+        let bitmap;
+        if (result.image instanceof ImageBitmap) {
+          const source = adapter.appliesTransforms ? result.image : await transformBitmap(result.image, plan, colorSpace);
+          bitmap = await resizeBitmap(source, maxDimension, signal);
+        } else {
+          const canvas = adapter.appliesTransforms ? result.image : applyTransforms(result.image, plan.transforms, colorSpace).canvas;
+          bitmap = await canvasToBitmap(canvas, maxDimension, signal);
+        }
+        return describe(plan, bitmap, "wasm", applied);
+      } catch (error) {
+        if (error instanceof HeicAbortError) throw error;
+        if (strategy === "wasm") throw error;
+        attempts.push({ strategy: "wasm", reason: describeError(error) });
+      }
+    }
+  }
+  throw new HeicUnsupportedError("Could not decode this HEIC", attempts, {
+    brand: plan.file.majorBrand,
+    itemType: plan.file.items.get(plan.primaryItemId)?.itemType,
+    itemId: plan.primaryItemId
+  });
+}
+var registeredAdapter;
+function registerDecoderAdapter(adapter) {
+  registeredAdapter = adapter;
+}
+function getRegisteredAdapter() {
+  return registeredAdapter;
+}
+async function resolveAdapter(loader) {
+  if (registeredAdapter) return registeredAdapter;
+  if (!loader) return void 0;
+  return loader();
+}
+async function readAll(input) {
+  if (input instanceof Uint8Array) return input;
+  if (input instanceof ArrayBuffer) return new Uint8Array(input);
+  return new Uint8Array(await input.arrayBuffer());
+}
+async function readPrefix(input, byteCount) {
+  if (input instanceof Blob) {
+    return new Uint8Array(await input.slice(0, byteCount).arrayBuffer());
+  }
+  const bytes = await readAll(input);
+  return bytes.subarray(0, byteCount);
+}
+function scaleFor(width, height, maxDimension) {
+  if (!maxDimension || maxDimension <= 0) return 1;
+  const longest = Math.max(width, height);
+  return longest <= maxDimension ? 1 : maxDimension / longest;
+}
+async function canvasToBitmap(canvas, maxDimension, signal) {
+  throwIfAborted(signal);
+  const scale = scaleFor(canvas.width, canvas.height, maxDimension);
+  if (scale === 1) {
+    return canvas.transferToImageBitmap();
+  }
+  const resizeWidth = Math.max(1, Math.round(canvas.width * scale));
+  const resizeHeight = Math.max(1, Math.round(canvas.height * scale));
+  try {
+    return await createImageBitmap(canvas, {
+      resizeWidth,
+      resizeHeight,
+      resizeQuality: "high"
+    });
+  } finally {
+    canvas.width = 0;
+    canvas.height = 0;
+  }
+}
+async function resizeBitmap(bitmap, maxDimension, signal) {
+  throwIfAborted(signal);
+  const scale = scaleFor(bitmap.width, bitmap.height, maxDimension);
+  if (scale === 1) return bitmap;
+  const resized = await createImageBitmap(bitmap, {
+    resizeWidth: Math.max(1, Math.round(bitmap.width * scale)),
+    resizeHeight: Math.max(1, Math.round(bitmap.height * scale)),
+    resizeQuality: "high"
+  });
+  bitmap.close();
+  return resized;
+}
+async function transformBitmap(bitmap, plan, colorSpace) {
+  if (plan.transforms.length === 0) return bitmap;
+  const canvas = createCanvas(bitmap.width, bitmap.height);
+  const ctx = canvas.getContext("2d", { colorSpace, alpha: false });
+  if (!ctx) return bitmap;
+  ctx.drawImage(bitmap, 0, 0);
+  bitmap.close();
+  const { canvas: transformed } = applyTransforms(canvas, plan.transforms, colorSpace);
+  return transformed.transferToImageBitmap();
+}
+function describe(plan, image, strategy, transformsApplied) {
+  return {
+    image,
+    width: image.width,
+    height: image.height,
+    sourceWidth: plan.displayWidth,
+    sourceHeight: plan.displayHeight,
+    strategy,
+    bitDepth: plan.bitDepth,
+    isGrid: plan.isGrid,
+    tileCount: plan.tiles.length,
+    sourceColor: plan.sourceColor,
+    transformsApplied,
+    warnings: plan.warnings
+  };
+}
+function describeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export { decodeHeic, findProperty, getRegisteredAdapter, hvccToAnnexBPrologue, hvccToCodecString, isHeic, lengthPrefixedToAnnexB, parseGridPayload, parseHeif, parseHvcC, planDecode, probeSupport, propertiesForItem, readGrid, readItemData, registerDecoderAdapter };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map