@nika-js/onlymap 0.5.3 → 0.5.7

package/dist/full.esm-Cl_Dig1y.js

@@ -0,0 +1,1467 @@
+var ne = typeof self < "u" ? self : global;
+const Y = typeof navigator < "u", ht = Y && typeof HTMLImageElement > "u", Z = !(typeof global > "u" || typeof process > "u" || !process.versions || !process.versions.node), re = ne.Buffer, $ = ne.BigInt, ae = !!re, ut = (s) => s;
+function ee(s, e = ut) {
+  if (Z) try {
+    return typeof require == "function" ? Promise.resolve(e(require(s))) : import(
+      /* webpackIgnore: true */
+      s
+    ).then(e);
+  } catch {
+    console.warn(`Couldn't load ${s}`);
+  }
+}
+let Ie = ne.fetch;
+const ft = (s) => Ie = s;
+if (!ne.fetch) {
+  const s = ee("http", ((i) => i)), e = ee("https", ((i) => i)), t = (i, { headers: n } = {}) => new Promise((async (r, a) => {
+    let { port: o, hostname: l, pathname: u, protocol: f, search: c } = new URL(i);
+    const y = { method: "GET", hostname: l, path: encodeURI(u) + c, headers: n };
+    o !== "" && (y.port = Number(o));
+    const T = (f === "https:" ? await e : await s).request(y, ((A) => {
+      if (A.statusCode === 301 || A.statusCode === 302) {
+        let ue = new URL(A.headers.location, i).toString();
+        return t(ue, { headers: n }).then(r).catch(a);
+      }
+      r({ status: A.statusCode, arrayBuffer: () => new Promise(((ue) => {
+        let ve = [];
+        A.on("data", ((lt) => ve.push(lt))), A.on("end", (() => ue(Buffer.concat(ve))));
+      })) });
+    }));
+    T.on("error", a), T.end();
+  }));
+  ft(t);
+}
+function h(s, e, t) {
+  return e in s ? Object.defineProperty(s, e, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : s[e] = t, s;
+}
+const te = (s) => $e(s) ? void 0 : s, ct = (s) => s !== void 0;
+function $e(s) {
+  return s === void 0 || (s instanceof Map ? s.size === 0 : Object.values(s).filter(ct).length === 0);
+}
+function m(s) {
+  let e = new Error(s);
+  throw delete e.stack, e;
+}
+function U(s) {
+  return (s = (function(e) {
+    for (; e.endsWith("\0"); ) e = e.slice(0, -1);
+    return e;
+  })(s).trim()) === "" ? void 0 : s;
+}
+function Se(s) {
+  let e = (function(t) {
+    let i = 0;
+    return t.ifd0.enabled && (i += 1024), t.exif.enabled && (i += 2048), t.makerNote && (i += 2048), t.userComment && (i += 1024), t.gps.enabled && (i += 512), t.interop.enabled && (i += 100), t.ifd1.enabled && (i += 1024), i + 2048;
+  })(s);
+  return s.jfif.enabled && (e += 50), s.xmp.enabled && (e += 2e4), s.iptc.enabled && (e += 14e3), s.icc.enabled && (e += 6e3), e;
+}
+const ye = (s) => String.fromCharCode.apply(null, s), Me = typeof TextDecoder < "u" ? new TextDecoder("utf-8") : void 0;
+function Je(s) {
+  return Me ? Me.decode(s) : ae ? Buffer.from(s).toString("utf8") : decodeURIComponent(escape(ye(s)));
+}
+class b {
+  static from(e, t) {
+    return e instanceof this && e.le === t ? e : new b(e, void 0, void 0, t);
+  }
+  constructor(e, t = 0, i, n) {
+    if (typeof n == "boolean" && (this.le = n), Array.isArray(e) && (e = new Uint8Array(e)), e === 0) this.byteOffset = 0, this.byteLength = 0;
+    else if (e instanceof ArrayBuffer) {
+      i === void 0 && (i = e.byteLength - t);
+      let r = new DataView(e, t, i);
+      this._swapDataView(r);
+    } else if (e instanceof Uint8Array || e instanceof DataView || e instanceof b) {
+      i === void 0 && (i = e.byteLength - t), (t += e.byteOffset) + i > e.byteOffset + e.byteLength && m("Creating view outside of available memory in ArrayBuffer");
+      let r = new DataView(e.buffer, t, i);
+      this._swapDataView(r);
+    } else if (typeof e == "number") {
+      let r = new DataView(new ArrayBuffer(e));
+      this._swapDataView(r);
+    } else m("Invalid input argument for BufferView: " + e);
+  }
+  _swapArrayBuffer(e) {
+    this._swapDataView(new DataView(e));
+  }
+  _swapBuffer(e) {
+    this._swapDataView(new DataView(e.buffer, e.byteOffset, e.byteLength));
+  }
+  _swapDataView(e) {
+    this.dataView = e, this.buffer = e.buffer, this.byteOffset = e.byteOffset, this.byteLength = e.byteLength;
+  }
+  _lengthToEnd(e) {
+    return this.byteLength - e;
+  }
+  set(e, t, i = b) {
+    return e instanceof DataView || e instanceof b ? e = new Uint8Array(e.buffer, e.byteOffset, e.byteLength) : e instanceof ArrayBuffer && (e = new Uint8Array(e)), e instanceof Uint8Array || m("BufferView.set(): Invalid data argument."), this.toUint8().set(e, t), new i(this, t, e.byteLength);
+  }
+  subarray(e, t) {
+    return t = t || this._lengthToEnd(e), new b(this, e, t);
+  }
+  toUint8() {
+    return new Uint8Array(this.buffer, this.byteOffset, this.byteLength);
+  }
+  getUint8Array(e, t) {
+    return new Uint8Array(this.buffer, this.byteOffset + e, t);
+  }
+  getString(e = 0, t = this.byteLength) {
+    return Je(this.getUint8Array(e, t));
+  }
+  getLatin1String(e = 0, t = this.byteLength) {
+    let i = this.getUint8Array(e, t);
+    return ye(i);
+  }
+  getUnicodeString(e = 0, t = this.byteLength) {
+    const i = [];
+    for (let n = 0; n < t && e + n < this.byteLength; n += 2) i.push(this.getUint16(e + n));
+    return ye(i);
+  }
+  getInt8(e) {
+    return this.dataView.getInt8(e);
+  }
+  getUint8(e) {
+    return this.dataView.getUint8(e);
+  }
+  getInt16(e, t = this.le) {
+    return this.dataView.getInt16(e, t);
+  }
+  getInt32(e, t = this.le) {
+    return this.dataView.getInt32(e, t);
+  }
+  getUint16(e, t = this.le) {
+    return this.dataView.getUint16(e, t);
+  }
+  getUint32(e, t = this.le) {
+    return this.dataView.getUint32(e, t);
+  }
+  getFloat32(e, t = this.le) {
+    return this.dataView.getFloat32(e, t);
+  }
+  getFloat64(e, t = this.le) {
+    return this.dataView.getFloat64(e, t);
+  }
+  getFloat(e, t = this.le) {
+    return this.dataView.getFloat32(e, t);
+  }
+  getDouble(e, t = this.le) {
+    return this.dataView.getFloat64(e, t);
+  }
+  getUintBytes(e, t, i) {
+    switch (t) {
+      case 1:
+        return this.getUint8(e, i);
+      case 2:
+        return this.getUint16(e, i);
+      case 4:
+        return this.getUint32(e, i);
+      case 8:
+        return this.getUint64 && this.getUint64(e, i);
+    }
+  }
+  getUint(e, t, i) {
+    switch (t) {
+      case 8:
+        return this.getUint8(e, i);
+      case 16:
+        return this.getUint16(e, i);
+      case 32:
+        return this.getUint32(e, i);
+      case 64:
+        return this.getUint64 && this.getUint64(e, i);
+    }
+  }
+  toString(e) {
+    return this.dataView.toString(e, this.constructor.name);
+  }
+  ensureChunk() {
+  }
+}
+function Ce(s, e) {
+  m(`${s} '${e}' was not loaded, try using full build of exifr.`);
+}
+class ke extends Map {
+  constructor(e) {
+    super(), this.kind = e;
+  }
+  get(e, t) {
+    return this.has(e) || Ce(this.kind, e), t && (e in t || (function(i, n) {
+      m(`Unknown ${i} '${n}'.`);
+    })(this.kind, e), t[e].enabled || Ce(this.kind, e)), super.get(e);
+  }
+  keyList() {
+    return Array.from(this.keys());
+  }
+}
+var k = new ke("file parser"), g = new ke("segment parser"), w = new ke("file reader");
+function dt(s, e) {
+  return typeof s == "string" ? Re(s, e) : Y && !ht && s instanceof HTMLImageElement ? Re(s.src, e) : s instanceof Uint8Array || s instanceof ArrayBuffer || s instanceof DataView ? new b(s) : Y && s instanceof Blob ? be(s, e, "blob", N) : void m("Invalid input argument");
+}
+function Re(s, e) {
+  return (t = s).startsWith("data:") || t.length > 1e4 ? Pe(s, e, "base64") : Z && s.includes("://") ? be(s, e, "url", E) : Z ? Pe(s, e, "fs") : Y ? be(s, e, "url", E) : void m("Invalid input argument");
+  var t;
+}
+async function be(s, e, t, i) {
+  return w.has(t) ? Pe(s, e, t) : i ? (async function(n, r) {
+    let a = await r(n);
+    return new b(a);
+  })(s, i) : void m(`Parser ${t} is not loaded`);
+}
+async function Pe(s, e, t) {
+  let i = new (w.get(t))(s, e);
+  return await i.read(), i;
+}
+const E = (s) => Ie(s).then(((e) => e.arrayBuffer())), N = (s) => new Promise(((e, t) => {
+  let i = new FileReader();
+  i.onloadend = () => e(i.result || new ArrayBuffer()), i.onerror = t, i.readAsArrayBuffer(s);
+}));
+class pt extends Map {
+  get tagKeys() {
+    return this.allKeys || (this.allKeys = Array.from(this.keys())), this.allKeys;
+  }
+  get tagValues() {
+    return this.allValues || (this.allValues = Array.from(this.values())), this.allValues;
+  }
+}
+function p(s, e, t) {
+  let i = new pt();
+  for (let [n, r] of t) i.set(n, r);
+  if (Array.isArray(e)) for (let n of e) s.set(n, i);
+  else s.set(e, i);
+  return i;
+}
+function G(s, e, t) {
+  let i, n = s.get(e);
+  for (i of t) n.set(i[0], i[1]);
+}
+const S = /* @__PURE__ */ new Map(), I = /* @__PURE__ */ new Map(), R = /* @__PURE__ */ new Map(), O = ["chunked", "firstChunkSize", "firstChunkSizeNode", "firstChunkSizeBrowser", "chunkSize", "chunkLimit"], j = ["jfif", "xmp", "icc", "iptc", "ihdr"], V = ["tiff", ...j], d = ["ifd0", "ifd1", "exif", "gps", "interop"], x = [...V, ...d], v = ["makerNote", "userComment"], W = ["translateKeys", "translateValues", "reviveValues", "multiSegment"], M = [...W, "sanitize", "mergeOutput", "silentErrors"];
+class qe {
+  get translate() {
+    return this.translateKeys || this.translateValues || this.reviveValues;
+  }
+}
+class K extends qe {
+  get needed() {
+    return this.enabled || this.deps.size > 0;
+  }
+  constructor(e, t, i, n) {
+    if (super(), h(this, "enabled", !1), h(this, "skip", /* @__PURE__ */ new Set()), h(this, "pick", /* @__PURE__ */ new Set()), h(this, "deps", /* @__PURE__ */ new Set()), h(this, "translateKeys", !1), h(this, "translateValues", !1), h(this, "reviveValues", !1), this.key = e, this.enabled = t, this.parse = this.enabled, this.applyInheritables(n), this.canBeFiltered = d.includes(e), this.canBeFiltered && (this.dict = S.get(e)), i !== void 0) if (Array.isArray(i)) this.parse = this.enabled = !0, this.canBeFiltered && i.length > 0 && this.translateTagSet(i, this.pick);
+    else if (typeof i == "object") {
+      if (this.enabled = !0, this.parse = i.parse !== !1, this.canBeFiltered) {
+        let { pick: r, skip: a } = i;
+        r && r.length > 0 && this.translateTagSet(r, this.pick), a && a.length > 0 && this.translateTagSet(a, this.skip);
+      }
+      this.applyInheritables(i);
+    } else i === !0 || i === !1 ? this.parse = this.enabled = i : m(`Invalid options argument: ${i}`);
+  }
+  applyInheritables(e) {
+    let t, i;
+    for (t of W) i = e[t], i !== void 0 && (this[t] = i);
+  }
+  translateTagSet(e, t) {
+    if (this.dict) {
+      let i, n, { tagKeys: r, tagValues: a } = this.dict;
+      for (i of e) typeof i == "string" ? (n = a.indexOf(i), n === -1 && (n = r.indexOf(Number(i))), n !== -1 && t.add(Number(r[n]))) : t.add(i);
+    } else for (let i of e) t.add(i);
+  }
+  finalizeFilters() {
+    !this.enabled && this.deps.size > 0 ? (this.enabled = !0, ie(this.pick, this.deps)) : this.enabled && this.pick.size > 0 && ie(this.pick, this.deps);
+  }
+}
+var C = { jfif: !1, tiff: !0, xmp: !1, icc: !1, iptc: !1, ifd0: !0, ifd1: !1, exif: !0, gps: !0, interop: !1, ihdr: void 0, makerNote: !1, userComment: !1, multiSegment: !1, skip: [], pick: [], translateKeys: !0, translateValues: !0, reviveValues: !0, sanitize: !0, mergeOutput: !0, silentErrors: !0, chunked: !0, firstChunkSize: void 0, firstChunkSizeNode: 512, firstChunkSizeBrowser: 65536, chunkSize: 65536, chunkLimit: 5 }, Le = /* @__PURE__ */ new Map();
+class z extends qe {
+  static useCached(e) {
+    let t = Le.get(e);
+    return t !== void 0 || (t = new this(e), Le.set(e, t)), t;
+  }
+  constructor(e) {
+    super(), e === !0 ? this.setupFromTrue() : e === void 0 ? this.setupFromUndefined() : Array.isArray(e) ? this.setupFromArray(e) : typeof e == "object" ? this.setupFromObject(e) : m(`Invalid options argument ${e}`), this.firstChunkSize === void 0 && (this.firstChunkSize = Y ? this.firstChunkSizeBrowser : this.firstChunkSizeNode), this.mergeOutput && (this.ifd1.enabled = !1), this.filterNestedSegmentTags(), this.traverseTiffDependencyTree(), this.checkLoadedPlugins();
+  }
+  setupFromUndefined() {
+    let e;
+    for (e of O) this[e] = C[e];
+    for (e of M) this[e] = C[e];
+    for (e of v) this[e] = C[e];
+    for (e of x) this[e] = new K(e, C[e], void 0, this);
+  }
+  setupFromTrue() {
+    let e;
+    for (e of O) this[e] = C[e];
+    for (e of M) this[e] = C[e];
+    for (e of v) this[e] = !0;
+    for (e of x) this[e] = new K(e, !0, void 0, this);
+  }
+  setupFromArray(e) {
+    let t;
+    for (t of O) this[t] = C[t];
+    for (t of M) this[t] = C[t];
+    for (t of v) this[t] = C[t];
+    for (t of x) this[t] = new K(t, !1, void 0, this);
+    this.setupGlobalFilters(e, void 0, d);
+  }
+  setupFromObject(e) {
+    let t;
+    for (t of (d.ifd0 = d.ifd0 || d.image, d.ifd1 = d.ifd1 || d.thumbnail, Object.assign(this, e), O)) this[t] = fe(e[t], C[t]);
+    for (t of M) this[t] = fe(e[t], C[t]);
+    for (t of v) this[t] = fe(e[t], C[t]);
+    for (t of V) this[t] = new K(t, C[t], e[t], this);
+    for (t of d) this[t] = new K(t, C[t], e[t], this.tiff);
+    this.setupGlobalFilters(e.pick, e.skip, d, x), e.tiff === !0 ? this.batchEnableWithBool(d, !0) : e.tiff === !1 ? this.batchEnableWithUserValue(d, e) : Array.isArray(e.tiff) ? this.setupGlobalFilters(e.tiff, void 0, d) : typeof e.tiff == "object" && this.setupGlobalFilters(e.tiff.pick, e.tiff.skip, d);
+  }
+  batchEnableWithBool(e, t) {
+    for (let i of e) this[i].enabled = t;
+  }
+  batchEnableWithUserValue(e, t) {
+    for (let i of e) {
+      let n = t[i];
+      this[i].enabled = n !== !1 && n !== void 0;
+    }
+  }
+  setupGlobalFilters(e, t, i, n = i) {
+    if (e && e.length) {
+      for (let a of n) this[a].enabled = !1;
+      let r = Ue(e, i);
+      for (let [a, o] of r) ie(this[a].pick, o), this[a].enabled = !0;
+    } else if (t && t.length) {
+      let r = Ue(t, i);
+      for (let [a, o] of r) ie(this[a].skip, o);
+    }
+  }
+  filterNestedSegmentTags() {
+    let { ifd0: e, exif: t, xmp: i, iptc: n, icc: r } = this;
+    this.makerNote ? t.deps.add(37500) : t.skip.add(37500), this.userComment ? t.deps.add(37510) : t.skip.add(37510), i.enabled || e.skip.add(700), n.enabled || e.skip.add(33723), r.enabled || e.skip.add(34675);
+  }
+  traverseTiffDependencyTree() {
+    let { ifd0: e, exif: t, gps: i, interop: n } = this;
+    n.needed && (t.deps.add(40965), e.deps.add(40965)), t.needed && e.deps.add(34665), i.needed && e.deps.add(34853), this.tiff.enabled = d.some(((r) => this[r].enabled === !0)) || this.makerNote || this.userComment;
+    for (let r of d) this[r].finalizeFilters();
+  }
+  get onlyTiff() {
+    return !j.map(((e) => this[e].enabled)).some(((e) => e === !0)) && this.tiff.enabled;
+  }
+  checkLoadedPlugins() {
+    for (let e of V) this[e].enabled && !g.has(e) && Ce("segment parser", e);
+  }
+}
+function Ue(s, e) {
+  let t, i, n, r, a = [];
+  for (n of e) {
+    for (r of (t = S.get(n), i = [], t)) (s.includes(r[0]) || s.includes(r[1])) && i.push(r[0]);
+    i.length && a.push([n, i]);
+  }
+  return a;
+}
+function fe(s, e) {
+  return s !== void 0 ? s : e !== void 0 ? e : void 0;
+}
+function ie(s, e) {
+  for (let t of e) s.add(t);
+}
+h(z, "default", C);
+class L {
+  constructor(e) {
+    h(this, "parsers", {}), h(this, "output", {}), h(this, "errors", []), h(this, "pushToErrors", ((t) => this.errors.push(t))), this.options = z.useCached(e);
+  }
+  async read(e) {
+    this.file = await dt(e, this.options);
+  }
+  setup() {
+    if (this.fileParser) return;
+    let { file: e } = this, t = e.getUint16(0);
+    for (let [i, n] of k) if (n.canHandle(e, t)) return this.fileParser = new n(this.options, this.file, this.parsers), e[i] = !0;
+    this.file.close && this.file.close(), m("Unknown file format");
+  }
+  async parse() {
+    let { output: e, errors: t } = this;
+    return this.setup(), this.options.silentErrors ? (await this.executeParsers().catch(this.pushToErrors), t.push(...this.fileParser.errors)) : await this.executeParsers(), this.file.close && this.file.close(), this.options.silentErrors && t.length > 0 && (e.errors = t), te(e);
+  }
+  async executeParsers() {
+    let { output: e } = this;
+    await this.fileParser.parse();
+    let t = Object.values(this.parsers).map((async (i) => {
+      let n = await i.parse();
+      i.assignToOutput(e, n);
+    }));
+    this.options.silentErrors && (t = t.map(((i) => i.catch(this.pushToErrors)))), await Promise.all(t);
+  }
+  async extractThumbnail() {
+    this.setup();
+    let { options: e, file: t } = this, i = g.get("tiff", e);
+    var n;
+    if (t.tiff ? n = { start: 0, type: "tiff" } : t.jpeg && (n = await this.fileParser.getOrFindSegment("tiff")), n === void 0) return;
+    let r = await this.fileParser.ensureSegmentChunk(n), a = this.parsers.tiff = new i(r, e, t), o = await a.extractThumbnail();
+    return t.close && t.close(), o;
+  }
+}
+async function oe(s, e) {
+  let t = new L(e);
+  return await t.read(s), t.parse();
+}
+var gt = Object.freeze({ __proto__: null, parse: oe, Exifr: L, fileParsers: k, segmentParsers: g, fileReaders: w, tagKeys: S, tagValues: I, tagRevivers: R, createDictionary: p, extendDictionary: G, fetchUrlAsArrayBuffer: E, readBlobAsArrayBuffer: N, chunkedProps: O, otherSegments: j, segments: V, tiffBlocks: d, segmentsAndBlocks: x, tiffExtractables: v, inheritables: W, allFormatters: M, Options: z });
+class le {
+  constructor(e, t, i) {
+    h(this, "errors", []), h(this, "ensureSegmentChunk", (async (n) => {
+      let r = n.start, a = n.size || 65536;
+      if (this.file.chunked) if (this.file.available(r, a)) n.chunk = this.file.subarray(r, a);
+      else try {
+        n.chunk = await this.file.readChunk(r, a);
+      } catch (o) {
+        m(`Couldn't read segment: ${JSON.stringify(n)}. ${o.message}`);
+      }
+      else this.file.byteLength > r + a ? n.chunk = this.file.subarray(r, a) : n.size === void 0 ? n.chunk = this.file.subarray(r) : m("Segment unreachable: " + JSON.stringify(n));
+      return n.chunk;
+    })), this.extendOptions && this.extendOptions(e), this.options = e, this.file = t, this.parsers = i;
+  }
+  injectSegment(e, t) {
+    this.options[e].enabled && this.createParser(e, t);
+  }
+  createParser(e, t) {
+    let i = new (g.get(e))(t, this.options, this.file);
+    return this.parsers[e] = i;
+  }
+  createParsers(e) {
+    for (let t of e) {
+      let { type: i, chunk: n } = t, r = this.options[i];
+      if (r && r.enabled) {
+        let a = this.parsers[i];
+        a && a.append || a || this.createParser(i, n);
+      }
+    }
+  }
+  async readSegments(e) {
+    let t = e.map(this.ensureSegmentChunk);
+    await Promise.all(t);
+  }
+}
+class P {
+  static findPosition(e, t) {
+    let i = e.getUint16(t + 2) + 2, n = typeof this.headerLength == "function" ? this.headerLength(e, t, i) : this.headerLength, r = t + n, a = i - n;
+    return { offset: t, length: i, headerLength: n, start: r, size: a, end: r + a };
+  }
+  static parse(e, t = {}) {
+    return new this(e, new z({ [this.type]: t }), e).parse();
+  }
+  normalizeInput(e) {
+    return e instanceof b ? e : new b(e);
+  }
+  constructor(e, t = {}, i) {
+    h(this, "errors", []), h(this, "raw", /* @__PURE__ */ new Map()), h(this, "handleError", ((n) => {
+      if (!this.options.silentErrors) throw n;
+      this.errors.push(n.message);
+    })), this.chunk = this.normalizeInput(e), this.file = i, this.type = this.constructor.type, this.globalOptions = this.options = t, this.localOptions = t[this.type], this.canTranslate = this.localOptions && this.localOptions.translate;
+  }
+  translate() {
+    this.canTranslate && (this.translated = this.translateBlock(this.raw, this.type));
+  }
+  get output() {
+    return this.translated ? this.translated : this.raw ? Object.fromEntries(this.raw) : void 0;
+  }
+  translateBlock(e, t) {
+    let i = R.get(t), n = I.get(t), r = S.get(t), a = this.options[t], o = a.reviveValues && !!i, l = a.translateValues && !!n, u = a.translateKeys && !!r, f = {};
+    for (let [c, y] of e) o && i.has(c) ? y = i.get(c)(y) : l && n.has(c) && (y = this.translateValue(y, n.get(c))), u && r.has(c) && (c = r.get(c) || c), f[c] = y;
+    return f;
+  }
+  translateValue(e, t) {
+    return t[e] || t.DEFAULT || e;
+  }
+  assignToOutput(e, t) {
+    this.assignObjectToOutput(e, this.constructor.type, t);
+  }
+  assignObjectToOutput(e, t, i) {
+    if (this.globalOptions.mergeOutput) return Object.assign(e, i);
+    e[t] ? Object.assign(e[t], i) : e[t] = i;
+  }
+}
+h(P, "headerLength", 4), h(P, "type", void 0), h(P, "multiSegment", !1), h(P, "canHandle", (() => !1));
+function mt(s) {
+  return s === 192 || s === 194 || s === 196 || s === 219 || s === 221 || s === 218 || s === 254;
+}
+function St(s) {
+  return s >= 224 && s <= 239;
+}
+function yt(s, e, t) {
+  for (let [i, n] of g) if (n.canHandle(s, e, t)) return i;
+}
+class Fe extends le {
+  constructor(...e) {
+    super(...e), h(this, "appSegments", []), h(this, "jpegSegments", []), h(this, "unknownSegments", []);
+  }
+  static canHandle(e, t) {
+    return t === 65496;
+  }
+  async parse() {
+    await this.findAppSegments(), await this.readSegments(this.appSegments), this.mergeMultiSegments(), this.createParsers(this.mergedAppSegments || this.appSegments);
+  }
+  setupSegmentFinderArgs(e) {
+    e === !0 ? (this.findAll = !0, this.wanted = new Set(g.keyList())) : (e = e === void 0 ? g.keyList().filter(((t) => this.options[t].enabled)) : e.filter(((t) => this.options[t].enabled && g.has(t))), this.findAll = !1, this.remaining = new Set(e), this.wanted = new Set(e)), this.unfinishedMultiSegment = !1;
+  }
+  async findAppSegments(e = 0, t) {
+    this.setupSegmentFinderArgs(t);
+    let { file: i, findAll: n, wanted: r, remaining: a } = this;
+    if (!n && this.file.chunked && (n = Array.from(r).some(((o) => {
+      let l = g.get(o), u = this.options[o];
+      return l.multiSegment && u.multiSegment;
+    })), n && await this.file.readWhole()), e = this.findAppSegmentsInRange(e, i.byteLength), !this.options.onlyTiff && i.chunked) {
+      let o = !1;
+      for (; a.size > 0 && !o && (i.canReadNextChunk || this.unfinishedMultiSegment); ) {
+        let { nextChunkOffset: l } = i, u = this.appSegments.some(((f) => !this.file.available(f.offset || f.start, f.length || f.size)));
+        if (o = e > l && !u ? !await i.readNextChunk(e) : !await i.readNextChunk(l), (e = this.findAppSegmentsInRange(e, i.byteLength)) === void 0) return;
+      }
+    }
+  }
+  findAppSegmentsInRange(e, t) {
+    t -= 2;
+    let i, n, r, a, o, l, { file: u, findAll: f, wanted: c, remaining: y, options: T } = this;
+    for (; e < t; e++) if (u.getUint8(e) === 255) {
+      if (i = u.getUint8(e + 1), St(i)) {
+        if (n = u.getUint16(e + 2), r = yt(u, e, n), r && c.has(r) && (a = g.get(r), o = a.findPosition(u, e), l = T[r], o.type = r, this.appSegments.push(o), !f && (a.multiSegment && l.multiSegment ? (this.unfinishedMultiSegment = o.chunkNumber < o.chunkCount, this.unfinishedMultiSegment || y.delete(r)) : y.delete(r), y.size === 0))) break;
+        T.recordUnknownSegments && (o = P.findPosition(u, e), o.marker = i, this.unknownSegments.push(o)), e += n + 1;
+      } else if (mt(i)) {
+        if (n = u.getUint16(e + 2), i === 218 && T.stopAfterSos !== !1) return;
+        T.recordJpegSegments && this.jpegSegments.push({ offset: e, length: n, marker: i }), e += n + 1;
+      }
+    }
+    return e;
+  }
+  mergeMultiSegments() {
+    if (!this.appSegments.some(((t) => t.multiSegment))) return;
+    let e = (function(t, i) {
+      let n, r, a, o = /* @__PURE__ */ new Map();
+      for (let l = 0; l < t.length; l++) n = t[l], r = n[i], o.has(r) ? a = o.get(r) : o.set(r, a = []), a.push(n);
+      return Array.from(o);
+    })(this.appSegments, "type");
+    this.mergedAppSegments = e.map((([t, i]) => {
+      let n = g.get(t, this.options);
+      return n.handleMultiSegments ? { type: t, chunk: n.handleMultiSegments(i) } : i[0];
+    }));
+  }
+  getSegment(e) {
+    return this.appSegments.find(((t) => t.type === e));
+  }
+  async getOrFindSegment(e) {
+    let t = this.getSegment(e);
+    return t === void 0 && (await this.findAppSegments(0, [e]), t = this.getSegment(e)), t;
+  }
+}
+h(Fe, "type", "jpeg"), k.set("jpeg", Fe);
+const Ct = [void 0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8, 4];
+class bt extends P {
+  parseHeader() {
+    var e = this.chunk.getUint16();
+    e === 18761 ? this.le = !0 : e === 19789 && (this.le = !1), this.chunk.le = this.le, this.headerParsed = !0;
+  }
+  parseTags(e, t, i = /* @__PURE__ */ new Map()) {
+    let { pick: n, skip: r } = this.options[t];
+    n = new Set(n);
+    let a = n.size > 0, o = r.size === 0, l = this.chunk.getUint16(e);
+    e += 2;
+    for (let u = 0; u < l; u++) {
+      let f = this.chunk.getUint16(e);
+      if (a) {
+        if (n.has(f) && (i.set(f, this.parseTag(e, f, t)), n.delete(f), n.size === 0)) break;
+      } else !o && r.has(f) || i.set(f, this.parseTag(e, f, t));
+      e += 12;
+    }
+    return i;
+  }
+  parseTag(e, t, i) {
+    let { chunk: n } = this, r = n.getUint16(e + 2), a = n.getUint32(e + 4), o = Ct[r];
+    if (o * a <= 4 ? e += 8 : e = n.getUint32(e + 8), (r < 1 || r > 13) && m(`Invalid TIFF value type. block: ${i.toUpperCase()}, tag: ${t.toString(16)}, type: ${r}, offset ${e}`), e > n.byteLength && m(`Invalid TIFF value offset. block: ${i.toUpperCase()}, tag: ${t.toString(16)}, type: ${r}, offset ${e} is outside of chunk size ${n.byteLength}`), r === 1) return n.getUint8Array(e, a);
+    if (r === 2) return U(n.getString(e, a));
+    if (r === 7) return n.getUint8Array(e, a);
+    if (a === 1) return this.parseTagValue(r, e);
+    {
+      let l = new ((function(f) {
+        switch (f) {
+          case 1:
+            return Uint8Array;
+          case 3:
+            return Uint16Array;
+          case 4:
+            return Uint32Array;
+          case 5:
+            return Array;
+          case 6:
+            return Int8Array;
+          case 8:
+            return Int16Array;
+          case 9:
+            return Int32Array;
+          case 10:
+            return Array;
+          case 11:
+            return Float32Array;
+          case 12:
+            return Float64Array;
+          default:
+            return Array;
+        }
+      })(r))(a), u = o;
+      for (let f = 0; f < a; f++) l[f] = this.parseTagValue(r, e), e += u;
+      return l;
+    }
+  }
+  parseTagValue(e, t) {
+    let { chunk: i } = this;
+    switch (e) {
+      case 1:
+        return i.getUint8(t);
+      case 3:
+        return i.getUint16(t);
+      case 4:
+        return i.getUint32(t);
+      case 5:
+        return i.getUint32(t) / i.getUint32(t + 4);
+      case 6:
+        return i.getInt8(t);
+      case 8:
+        return i.getInt16(t);
+      case 9:
+        return i.getInt32(t);
+      case 10:
+        return i.getInt32(t) / i.getInt32(t + 4);
+      case 11:
+        return i.getFloat(t);
+      case 12:
+        return i.getDouble(t);
+      case 13:
+        return i.getUint32(t);
+      default:
+        m(`Invalid tiff type ${e}`);
+    }
+  }
+}
+class ce extends bt {
+  static canHandle(e, t) {
+    return e.getUint8(t + 1) === 225 && e.getUint32(t + 4) === 1165519206 && e.getUint16(t + 8) === 0;
+  }
+  async parse() {
+    this.parseHeader();
+    let { options: e } = this;
+    return e.ifd0.enabled && await this.parseIfd0Block(), e.exif.enabled && await this.safeParse("parseExifBlock"), e.gps.enabled && await this.safeParse("parseGpsBlock"), e.interop.enabled && await this.safeParse("parseInteropBlock"), e.ifd1.enabled && await this.safeParse("parseThumbnailBlock"), this.createOutput();
+  }
+  safeParse(e) {
+    let t = this[e]();
+    return t.catch !== void 0 && (t = t.catch(this.handleError)), t;
+  }
+  findIfd0Offset() {
+    this.ifd0Offset === void 0 && (this.ifd0Offset = this.chunk.getUint32(4));
+  }
+  findIfd1Offset() {
+    if (this.ifd1Offset === void 0) {
+      this.findIfd0Offset();
+      let e = this.chunk.getUint16(this.ifd0Offset), t = this.ifd0Offset + 2 + 12 * e;
+      this.ifd1Offset = this.chunk.getUint32(t);
+    }
+  }
+  parseBlock(e, t) {
+    let i = /* @__PURE__ */ new Map();
+    return this[t] = i, this.parseTags(e, t, i), i;
+  }
+  async parseIfd0Block() {
+    if (this.ifd0) return;
+    let { file: e } = this;
+    this.findIfd0Offset(), this.ifd0Offset < 8 && m("Malformed EXIF data"), !e.chunked && this.ifd0Offset > e.byteLength && m(`IFD0 offset points to outside of file.
+this.ifd0Offset: ${this.ifd0Offset}, file.byteLength: ${e.byteLength}`), e.tiff && await e.ensureChunk(this.ifd0Offset, Se(this.options));
+    let t = this.parseBlock(this.ifd0Offset, "ifd0");
+    return t.size !== 0 ? (this.exifOffset = t.get(34665), this.interopOffset = t.get(40965), this.gpsOffset = t.get(34853), this.xmp = t.get(700), this.iptc = t.get(33723), this.icc = t.get(34675), this.options.sanitize && (t.delete(34665), t.delete(40965), t.delete(34853), t.delete(700), t.delete(33723), t.delete(34675)), t) : void 0;
+  }
+  async parseExifBlock() {
+    if (this.exif || (this.ifd0 || await this.parseIfd0Block(), this.exifOffset === void 0)) return;
+    this.file.tiff && await this.file.ensureChunk(this.exifOffset, Se(this.options));
+    let e = this.parseBlock(this.exifOffset, "exif");
+    return this.interopOffset || (this.interopOffset = e.get(40965)), this.makerNote = e.get(37500), this.userComment = e.get(37510), this.options.sanitize && (e.delete(40965), e.delete(37500), e.delete(37510)), this.unpack(e, 41728), this.unpack(e, 41729), e;
+  }
+  unpack(e, t) {
+    let i = e.get(t);
+    i && i.length === 1 && e.set(t, i[0]);
+  }
+  async parseGpsBlock() {
+    if (this.gps || (this.ifd0 || await this.parseIfd0Block(), this.gpsOffset === void 0)) return;
+    let e = this.parseBlock(this.gpsOffset, "gps");
+    return e && e.has(2) && e.has(4) && (e.set("latitude", Be(...e.get(2), e.get(1))), e.set("longitude", Be(...e.get(4), e.get(3)))), e;
+  }
+  async parseInteropBlock() {
+    if (!this.interop && (this.ifd0 || await this.parseIfd0Block(), this.interopOffset !== void 0 || this.exif || await this.parseExifBlock(), this.interopOffset !== void 0)) return this.parseBlock(this.interopOffset, "interop");
+  }
+  async parseThumbnailBlock(e = !1) {
+    if (!this.ifd1 && !this.ifd1Parsed && (!this.options.mergeOutput || e)) return this.findIfd1Offset(), this.ifd1Offset > 0 && (this.parseBlock(this.ifd1Offset, "ifd1"), this.ifd1Parsed = !0), this.ifd1;
+  }
+  async extractThumbnail() {
+    if (this.headerParsed || this.parseHeader(), this.ifd1Parsed || await this.parseThumbnailBlock(!0), this.ifd1 === void 0) return;
+    let e = this.ifd1.get(513), t = this.ifd1.get(514);
+    return this.chunk.getUint8Array(e, t);
+  }
+  get image() {
+    return this.ifd0;
+  }
+  get thumbnail() {
+    return this.ifd1;
+  }
+  createOutput() {
+    let e, t, i, n = {};
+    for (t of d) if (e = this[t], !$e(e)) if (i = this.canTranslate ? this.translateBlock(e, t) : Object.fromEntries(e), this.options.mergeOutput) {
+      if (t === "ifd1") continue;
+      Object.assign(n, i);
+    } else n[t] = i;
+    return this.makerNote && (n.makerNote = this.makerNote), this.userComment && (n.userComment = this.userComment), n;
+  }
+  assignToOutput(e, t) {
+    if (this.globalOptions.mergeOutput) Object.assign(e, t);
+    else for (let [i, n] of Object.entries(t)) this.assignObjectToOutput(e, i, n);
+  }
+}
+function Be(s, e, t, i) {
+  var n = s + e / 60 + t / 3600;
+  return i !== "S" && i !== "W" || (n *= -1), n;
+}
+h(ce, "type", "tiff"), h(ce, "headerLength", 10), g.set("tiff", ce);
+var Pt = Object.freeze({ __proto__: null, default: gt, Exifr: L, fileParsers: k, segmentParsers: g, fileReaders: w, tagKeys: S, tagValues: I, tagRevivers: R, createDictionary: p, extendDictionary: G, fetchUrlAsArrayBuffer: E, readBlobAsArrayBuffer: N, chunkedProps: O, otherSegments: j, segments: V, tiffBlocks: d, segmentsAndBlocks: x, tiffExtractables: v, inheritables: W, allFormatters: M, Options: z, parse: oe });
+const we = { ifd0: !1, ifd1: !1, exif: !1, gps: !1, interop: !1, sanitize: !1, reviveValues: !0, translateKeys: !1, translateValues: !1, mergeOutput: !1 }, Te = Object.assign({}, we, { firstChunkSize: 4e4, gps: [1, 2, 3, 4] });
+async function Qe(s) {
+  let e = new L(Te);
+  await e.read(s);
+  let t = await e.parse();
+  if (t && t.gps) {
+    let { latitude: i, longitude: n } = t.gps;
+    return { latitude: i, longitude: n };
+  }
+}
+const Ae = Object.assign({}, we, { tiff: !1, ifd1: !0, mergeOutput: !1 });
+async function Ze(s) {
+  let e = new L(Ae);
+  await e.read(s);
+  let t = await e.extractThumbnail();
+  return t && ae ? re.from(t) : t;
+}
+async function et(s) {
+  let e = await this.thumbnail(s);
+  if (e !== void 0) {
+    let t = new Blob([e]);
+    return URL.createObjectURL(t);
+  }
+}
+const De = Object.assign({}, we, { firstChunkSize: 4e4, ifd0: [274] });
+async function Oe(s) {
+  let e = new L(De);
+  await e.read(s);
+  let t = await e.parse();
+  if (t && t.ifd0) return t.ifd0[274];
+}
+const xe = Object.freeze({ 1: { dimensionSwapped: !1, scaleX: 1, scaleY: 1, deg: 0, rad: 0 }, 2: { dimensionSwapped: !1, scaleX: -1, scaleY: 1, deg: 0, rad: 0 }, 3: { dimensionSwapped: !1, scaleX: 1, scaleY: 1, deg: 180, rad: 180 * Math.PI / 180 }, 4: { dimensionSwapped: !1, scaleX: -1, scaleY: 1, deg: 180, rad: 180 * Math.PI / 180 }, 5: { dimensionSwapped: !0, scaleX: 1, scaleY: -1, deg: 90, rad: 90 * Math.PI / 180 }, 6: { dimensionSwapped: !0, scaleX: 1, scaleY: 1, deg: 90, rad: 90 * Math.PI / 180 }, 7: { dimensionSwapped: !0, scaleX: 1, scaleY: -1, deg: 270, rad: 270 * Math.PI / 180 }, 8: { dimensionSwapped: !0, scaleX: 1, scaleY: 1, deg: 270, rad: 270 * Math.PI / 180 } });
+let F = !0, B = !0;
+if (typeof navigator == "object") {
+  let s = navigator.userAgent;
+  if (s.includes("iPad") || s.includes("iPhone")) {
+    let e = s.match(/OS (\d+)_(\d+)/);
+    if (e) {
+      let [, t, i] = e;
+      F = Number(t) + 0.1 * Number(i) < 13.4, B = !1;
+    }
+  } else if (s.includes("OS X 10")) {
+    let [, e] = s.match(/OS X 10[_.](\d+)/);
+    F = B = Number(e) < 15;
+  }
+  if (s.includes("Chrome/")) {
+    let [, e] = s.match(/Chrome\/(\d+)/);
+    F = B = Number(e) < 81;
+  } else if (s.includes("Firefox/")) {
+    let [, e] = s.match(/Firefox\/(\d+)/);
+    F = B = Number(e) < 77;
+  }
+}
+async function tt(s) {
+  let e = await Oe(s);
+  return Object.assign({ canvas: F, css: B }, xe[e]);
+}
+class It extends b {
+  constructor(...e) {
+    super(...e), h(this, "ranges", new kt()), this.byteLength !== 0 && this.ranges.add(0, this.byteLength);
+  }
+  _tryExtend(e, t, i) {
+    if (e === 0 && this.byteLength === 0 && i) {
+      let n = new DataView(i.buffer || i, i.byteOffset, i.byteLength);
+      this._swapDataView(n);
+    } else {
+      let n = e + t;
+      if (n > this.byteLength) {
+        let { dataView: r } = this._extend(n);
+        this._swapDataView(r);
+      }
+    }
+  }
+  _extend(e) {
+    let t;
+    t = ae ? re.allocUnsafe(e) : new Uint8Array(e);
+    let i = new DataView(t.buffer, t.byteOffset, t.byteLength);
+    return t.set(new Uint8Array(this.buffer, this.byteOffset, this.byteLength), 0), { uintView: t, dataView: i };
+  }
+  subarray(e, t, i = !1) {
+    return t = t || this._lengthToEnd(e), i && this._tryExtend(e, t), this.ranges.add(e, t), super.subarray(e, t);
+  }
+  set(e, t, i = !1) {
+    i && this._tryExtend(t, e.byteLength, e);
+    let n = super.set(e, t);
+    return this.ranges.add(t, n.byteLength), n;
+  }
+  async ensureChunk(e, t) {
+    this.chunked && (this.ranges.available(e, t) || await this.readChunk(e, t));
+  }
+  available(e, t) {
+    return this.ranges.available(e, t);
+  }
+}
+class kt {
+  constructor() {
+    h(this, "list", []);
+  }
+  get length() {
+    return this.list.length;
+  }
+  add(e, t, i = 0) {
+    let n = e + t, r = this.list.filter(((a) => Ee(e, a.offset, n) || Ee(e, a.end, n)));
+    if (r.length > 0) {
+      e = Math.min(e, ...r.map(((o) => o.offset))), n = Math.max(n, ...r.map(((o) => o.end))), t = n - e;
+      let a = r.shift();
+      a.offset = e, a.length = t, a.end = n, this.list = this.list.filter(((o) => !r.includes(o)));
+    } else this.list.push({ offset: e, length: t, end: n });
+  }
+  available(e, t) {
+    let i = e + t;
+    return this.list.some(((n) => n.offset <= e && i <= n.end));
+  }
+}
+function Ee(s, e, t) {
+  return s <= e && e <= t;
+}
+class he extends It {
+  constructor(e, t) {
+    super(0), h(this, "chunksRead", 0), this.input = e, this.options = t;
+  }
+  async readWhole() {
+    this.chunked = !1, await this.readChunk(this.nextChunkOffset);
+  }
+  async readChunked() {
+    this.chunked = !0, await this.readChunk(0, this.options.firstChunkSize);
+  }
+  async readNextChunk(e = this.nextChunkOffset) {
+    if (this.fullyRead) return this.chunksRead++, !1;
+    let t = this.options.chunkSize, i = await this.readChunk(e, t);
+    return !!i && i.byteLength === t;
+  }
+  async readChunk(e, t) {
+    if (this.chunksRead++, (t = this.safeWrapAddress(e, t)) !== 0) return this._readChunk(e, t);
+  }
+  safeWrapAddress(e, t) {
+    return this.size !== void 0 && e + t > this.size ? Math.max(0, this.size - e) : t;
+  }
+  get nextChunkOffset() {
+    if (this.ranges.list.length !== 0) return this.ranges.list[0].length;
+  }
+  get canReadNextChunk() {
+    return this.chunksRead < this.options.chunkLimit;
+  }
+  get fullyRead() {
+    return this.size !== void 0 && this.nextChunkOffset === this.size;
+  }
+  read() {
+    return this.options.chunked ? this.readChunked() : this.readWhole();
+  }
+  close() {
+  }
+}
+w.set("blob", class extends he {
+  async readWhole() {
+    this.chunked = !1;
+    let s = await N(this.input);
+    this._swapArrayBuffer(s);
+  }
+  readChunked() {
+    return this.chunked = !0, this.size = this.input.size, super.readChunked();
+  }
+  async _readChunk(s, e) {
+    let t = e ? s + e : void 0, i = this.input.slice(s, t), n = await N(i);
+    return this.set(n, s, !0);
+  }
+});
+var wt = Object.freeze({ __proto__: null, default: Pt, Exifr: L, fileParsers: k, segmentParsers: g, fileReaders: w, tagKeys: S, tagValues: I, tagRevivers: R, createDictionary: p, extendDictionary: G, fetchUrlAsArrayBuffer: E, readBlobAsArrayBuffer: N, chunkedProps: O, otherSegments: j, segments: V, tiffBlocks: d, segmentsAndBlocks: x, tiffExtractables: v, inheritables: W, allFormatters: M, Options: z, parse: oe, gpsOnlyOptions: Te, gps: Qe, thumbnailOnlyOptions: Ae, thumbnail: Ze, thumbnailUrl: et, orientationOnlyOptions: De, orientation: Oe, rotations: xe, get rotateCanvas() {
+  return F;
+}, get rotateCss() {
+  return B;
+}, rotation: tt });
+w.set("url", class extends he {
+  async readWhole() {
+    this.chunked = !1;
+    let s = await E(this.input);
+    s instanceof ArrayBuffer ? this._swapArrayBuffer(s) : s instanceof Uint8Array && this._swapBuffer(s);
+  }
+  async _readChunk(s, e) {
+    let t = e ? s + e - 1 : void 0, i = this.options.httpHeaders || {};
+    (s || t) && (i.range = `bytes=${[s, t].join("-")}`);
+    let n = await Ie(this.input, { headers: i }), r = await n.arrayBuffer(), a = r.byteLength;
+    if (n.status !== 416) return a !== e && (this.size = s + a), this.set(r, s, !0);
+  }
+});
+b.prototype.getUint64 = function(s) {
+  let e = this.getUint32(s), t = this.getUint32(s + 4);
+  return e < 1048575 ? e << 32 | t : typeof $ !== void 0 ? (console.warn("Using BigInt because of type 64uint but JS can only handle 53b numbers."), $(e) << $(32) | $(t)) : void m("Trying to read 64b value but JS can only handle 53b numbers.");
+};
+class Tt extends le {
+  parseBoxes(e = 0) {
+    let t = [];
+    for (; e < this.file.byteLength - 4; ) {
+      let i = this.parseBoxHead(e);
+      if (t.push(i), i.length === 0) break;
+      e += i.length;
+    }
+    return t;
+  }
+  parseSubBoxes(e) {
+    e.boxes = this.parseBoxes(e.start);
+  }
+  findBox(e, t) {
+    return e.boxes === void 0 && this.parseSubBoxes(e), e.boxes.find(((i) => i.kind === t));
+  }
+  parseBoxHead(e) {
+    let t = this.file.getUint32(e), i = this.file.getString(e + 4, 4), n = e + 8;
+    return t === 1 && (t = this.file.getUint64(e + 8), n += 8), { offset: e, length: t, kind: i, start: n };
+  }
+  parseBoxFullHead(e) {
+    if (e.version !== void 0) return;
+    let t = this.file.getUint32(e.start);
+    e.version = t >> 24, e.start += 4;
+  }
+}
+class it extends Tt {
+  static canHandle(e, t) {
+    if (t !== 0) return !1;
+    let i = e.getUint16(2);
+    if (i > 50) return !1;
+    let n = 16, r = [];
+    for (; n < i; ) r.push(e.getString(n, 4)), n += 4;
+    return r.includes(this.type);
+  }
+  async parse() {
+    let e = this.file.getUint32(0), t = this.parseBoxHead(e);
+    for (; t.kind !== "meta"; ) e += t.length, await this.file.ensureChunk(e, 16), t = this.parseBoxHead(e);
+    await this.file.ensureChunk(t.offset, t.length), this.parseBoxFullHead(t), this.parseSubBoxes(t), this.options.icc.enabled && await this.findIcc(t), this.options.tiff.enabled && await this.findExif(t);
+  }
+  async registerSegment(e, t, i) {
+    await this.file.ensureChunk(t, i);
+    let n = this.file.subarray(t, i);
+    this.createParser(e, n);
+  }
+  async findIcc(e) {
+    let t = this.findBox(e, "iprp");
+    if (t === void 0) return;
+    let i = this.findBox(t, "ipco");
+    if (i === void 0) return;
+    let n = this.findBox(i, "colr");
+    n !== void 0 && await this.registerSegment("icc", n.offset + 12, n.length);
+  }
+  async findExif(e) {
+    let t = this.findBox(e, "iinf");
+    if (t === void 0) return;
+    let i = this.findBox(e, "iloc");
+    if (i === void 0) return;
+    let n = this.findExifLocIdInIinf(t), r = this.findExtentInIloc(i, n);
+    if (r === void 0) return;
+    let [a, o] = r;
+    await this.file.ensureChunk(a, o);
+    let l = 4 + this.file.getUint32(a);
+    a += l, o -= l, await this.registerSegment("tiff", a, o);
+  }
+  findExifLocIdInIinf(e) {
+    this.parseBoxFullHead(e);
+    let t, i, n, r, a = e.start, o = this.file.getUint16(a);
+    for (a += 2; o--; ) {
+      if (t = this.parseBoxHead(a), this.parseBoxFullHead(t), i = t.start, t.version >= 2 && (n = t.version === 3 ? 4 : 2, r = this.file.getString(i + n + 2, 4), r === "Exif")) return this.file.getUintBytes(i, n);
+      a += t.length;
+    }
+  }
+  get8bits(e) {
+    let t = this.file.getUint8(e);
+    return [t >> 4, 15 & t];
+  }
+  findExtentInIloc(e, t) {
+    this.parseBoxFullHead(e);
+    let i = e.start, [n, r] = this.get8bits(i++), [a, o] = this.get8bits(i++), l = e.version === 2 ? 4 : 2, u = e.version === 1 || e.version === 2 ? 2 : 0, f = o + n + r, c = e.version === 2 ? 4 : 2, y = this.file.getUintBytes(i, c);
+    for (i += c; y--; ) {
+      let T = this.file.getUintBytes(i, l);
+      i += l + u + 2 + a;
+      let A = this.file.getUint16(i);
+      if (i += 2, T === t) return A > 1 && console.warn(`ILOC box has more than one extent but we're only processing one
+Please create an issue at https://github.com/MikeKovarik/exifr with this file`), [this.file.getUintBytes(i + o, n), this.file.getUintBytes(i + o + n, r)];
+      i += A * f;
+    }
+  }
+}
+class st extends it {
+}
+h(st, "type", "heic");
+class Ne extends it {
+}
+h(Ne, "type", "avif"), k.set("heic", st), k.set("avif", Ne), p(S, ["ifd0", "ifd1"], [[256, "ImageWidth"], [257, "ImageHeight"], [258, "BitsPerSample"], [259, "Compression"], [262, "PhotometricInterpretation"], [270, "ImageDescription"], [271, "Make"], [272, "Model"], [273, "StripOffsets"], [274, "Orientation"], [277, "SamplesPerPixel"], [278, "RowsPerStrip"], [279, "StripByteCounts"], [282, "XResolution"], [283, "YResolution"], [284, "PlanarConfiguration"], [296, "ResolutionUnit"], [301, "TransferFunction"], [305, "Software"], [306, "ModifyDate"], [315, "Artist"], [316, "HostComputer"], [317, "Predictor"], [318, "WhitePoint"], [319, "PrimaryChromaticities"], [513, "ThumbnailOffset"], [514, "ThumbnailLength"], [529, "YCbCrCoefficients"], [530, "YCbCrSubSampling"], [531, "YCbCrPositioning"], [532, "ReferenceBlackWhite"], [700, "ApplicationNotes"], [33432, "Copyright"], [33723, "IPTC"], [34665, "ExifIFD"], [34675, "ICC"], [34853, "GpsIFD"], [330, "SubIFD"], [40965, "InteropIFD"], [40091, "XPTitle"], [40092, "XPComment"], [40093, "XPAuthor"], [40094, "XPKeywords"], [40095, "XPSubject"]]), p(S, "exif", [[33434, "ExposureTime"], [33437, "FNumber"], [34850, "ExposureProgram"], [34852, "SpectralSensitivity"], [34855, "ISO"], [34858, "TimeZoneOffset"], [34859, "SelfTimerMode"], [34864, "SensitivityType"], [34865, "StandardOutputSensitivity"], [34866, "RecommendedExposureIndex"], [34867, "ISOSpeed"], [34868, "ISOSpeedLatitudeyyy"], [34869, "ISOSpeedLatitudezzz"], [36864, "ExifVersion"], [36867, "DateTimeOriginal"], [36868, "CreateDate"], [36873, "GooglePlusUploadCode"], [36880, "OffsetTime"], [36881, "OffsetTimeOriginal"], [36882, "OffsetTimeDigitized"], [37121, "ComponentsConfiguration"], [37122, "CompressedBitsPerPixel"], [37377, "ShutterSpeedValue"], [37378, "ApertureValue"], [37379, "BrightnessValue"], [37380, "ExposureCompensation"], [37381, "MaxApertureValue"], [37382, "SubjectDistance"], [37383, "MeteringMode"], [37384, "LightSource"], [37385, "Flash"], [37386, "FocalLength"], [37393, "ImageNumber"], [37394, "SecurityClassification"], [37395, "ImageHistory"], [37396, "SubjectArea"], [37500, "MakerNote"], [37510, "UserComment"], [37520, "SubSecTime"], [37521, "SubSecTimeOriginal"], [37522, "SubSecTimeDigitized"], [37888, "AmbientTemperature"], [37889, "Humidity"], [37890, "Pressure"], [37891, "WaterDepth"], [37892, "Acceleration"], [37893, "CameraElevationAngle"], [40960, "FlashpixVersion"], [40961, "ColorSpace"], [40962, "ExifImageWidth"], [40963, "ExifImageHeight"], [40964, "RelatedSoundFile"], [41483, "FlashEnergy"], [41486, "FocalPlaneXResolution"], [41487, "FocalPlaneYResolution"], [41488, "FocalPlaneResolutionUnit"], [41492, "SubjectLocation"], [41493, "ExposureIndex"], [41495, "SensingMethod"], [41728, "FileSource"], [41729, "SceneType"], [41730, "CFAPattern"], [41985, "CustomRendered"], [41986, "ExposureMode"], [41987, "WhiteBalance"], [41988, "DigitalZoomRatio"], [41989, "FocalLengthIn35mmFormat"], [41990, "SceneCaptureType"], [41991, "GainControl"], [41992, "Contrast"], [41993, "Saturation"], [41994, "Sharpness"], [41996, "SubjectDistanceRange"], [42016, "ImageUniqueID"], [42032, "OwnerName"], [42033, "SerialNumber"], [42034, "LensInfo"], [42035, "LensMake"], [42036, "LensModel"], [42037, "LensSerialNumber"], [42080, "CompositeImage"], [42081, "CompositeImageCount"], [42082, "CompositeImageExposureTimes"], [42240, "Gamma"], [59932, "Padding"], [59933, "OffsetSchema"], [65e3, "OwnerName"], [65001, "SerialNumber"], [65002, "Lens"], [65100, "RawFile"], [65101, "Converter"], [65102, "WhiteBalance"], [65105, "Exposure"], [65106, "Shadows"], [65107, "Brightness"], [65108, "Contrast"], [65109, "Saturation"], [65110, "Sharpness"], [65111, "Smoothness"], [65112, "MoireFilter"], [40965, "InteropIFD"]]), p(S, "gps", [[0, "GPSVersionID"], [1, "GPSLatitudeRef"], [2, "GPSLatitude"], [3, "GPSLongitudeRef"], [4, "GPSLongitude"], [5, "GPSAltitudeRef"], [6, "GPSAltitude"], [7, "GPSTimeStamp"], [8, "GPSSatellites"], [9, "GPSStatus"], [10, "GPSMeasureMode"], [11, "GPSDOP"], [12, "GPSSpeedRef"], [13, "GPSSpeed"], [14, "GPSTrackRef"], [15, "GPSTrack"], [16, "GPSImgDirectionRef"], [17, "GPSImgDirection"], [18, "GPSMapDatum"], [19, "GPSDestLatitudeRef"], [20, "GPSDestLatitude"], [21, "GPSDestLongitudeRef"], [22, "GPSDestLongitude"], [23, "GPSDestBearingRef"], [24, "GPSDestBearing"], [25, "GPSDestDistanceRef"], [26, "GPSDestDistance"], [27, "GPSProcessingMethod"], [28, "GPSAreaInformation"], [29, "GPSDateStamp"], [30, "GPSDifferential"], [31, "GPSHPositioningError"]]), p(I, ["ifd0", "ifd1"], [[274, { 1: "Horizontal (normal)", 2: "Mirror horizontal", 3: "Rotate 180", 4: "Mirror vertical", 5: "Mirror horizontal and rotate 270 CW", 6: "Rotate 90 CW", 7: "Mirror horizontal and rotate 90 CW", 8: "Rotate 270 CW" }], [296, { 1: "None", 2: "inches", 3: "cm" }]]);
+let _ = p(I, "exif", [[34850, { 0: "Not defined", 1: "Manual", 2: "Normal program", 3: "Aperture priority", 4: "Shutter priority", 5: "Creative program", 6: "Action program", 7: "Portrait mode", 8: "Landscape mode" }], [37121, { 0: "-", 1: "Y", 2: "Cb", 3: "Cr", 4: "R", 5: "G", 6: "B" }], [37383, { 0: "Unknown", 1: "Average", 2: "CenterWeightedAverage", 3: "Spot", 4: "MultiSpot", 5: "Pattern", 6: "Partial", 255: "Other" }], [37384, { 0: "Unknown", 1: "Daylight", 2: "Fluorescent", 3: "Tungsten (incandescent light)", 4: "Flash", 9: "Fine weather", 10: "Cloudy weather", 11: "Shade", 12: "Daylight fluorescent (D 5700 - 7100K)", 13: "Day white fluorescent (N 4600 - 5400K)", 14: "Cool white fluorescent (W 3900 - 4500K)", 15: "White fluorescent (WW 3200 - 3700K)", 17: "Standard light A", 18: "Standard light B", 19: "Standard light C", 20: "D55", 21: "D65", 22: "D75", 23: "D50", 24: "ISO studio tungsten", 255: "Other" }], [37385, { 0: "Flash did not fire", 1: "Flash fired", 5: "Strobe return light not detected", 7: "Strobe return light detected", 9: "Flash fired, compulsory flash mode", 13: "Flash fired, compulsory flash mode, return light not detected", 15: "Flash fired, compulsory flash mode, return light detected", 16: "Flash did not fire, compulsory flash mode", 24: "Flash did not fire, auto mode", 25: "Flash fired, auto mode", 29: "Flash fired, auto mode, return light not detected", 31: "Flash fired, auto mode, return light detected", 32: "No flash function", 65: "Flash fired, red-eye reduction mode", 69: "Flash fired, red-eye reduction mode, return light not detected", 71: "Flash fired, red-eye reduction mode, return light detected", 73: "Flash fired, compulsory flash mode, red-eye reduction mode", 77: "Flash fired, compulsory flash mode, red-eye reduction mode, return light not detected", 79: "Flash fired, compulsory flash mode, red-eye reduction mode, return light detected", 89: "Flash fired, auto mode, red-eye reduction mode", 93: "Flash fired, auto mode, return light not detected, red-eye reduction mode", 95: "Flash fired, auto mode, return light detected, red-eye reduction mode" }], [41495, { 1: "Not defined", 2: "One-chip color area sensor", 3: "Two-chip color area sensor", 4: "Three-chip color area sensor", 5: "Color sequential area sensor", 7: "Trilinear sensor", 8: "Color sequential linear sensor" }], [41728, { 1: "Film Scanner", 2: "Reflection Print Scanner", 3: "Digital Camera" }], [41729, { 1: "Directly photographed" }], [41985, { 0: "Normal", 1: "Custom", 2: "HDR (no original saved)", 3: "HDR (original saved)", 4: "Original (for HDR)", 6: "Panorama", 7: "Portrait HDR", 8: "Portrait" }], [41986, { 0: "Auto", 1: "Manual", 2: "Auto bracket" }], [41987, { 0: "Auto", 1: "Manual" }], [41990, { 0: "Standard", 1: "Landscape", 2: "Portrait", 3: "Night", 4: "Other" }], [41991, { 0: "None", 1: "Low gain up", 2: "High gain up", 3: "Low gain down", 4: "High gain down" }], [41996, { 0: "Unknown", 1: "Macro", 2: "Close", 3: "Distant" }], [42080, { 0: "Unknown", 1: "Not a Composite Image", 2: "General Composite Image", 3: "Composite Image Captured While Shooting" }]]);
+const Ge = { 1: "No absolute unit of measurement", 2: "Inch", 3: "Centimeter" };
+_.set(37392, Ge), _.set(41488, Ge);
+const de = { 0: "Normal", 1: "Low", 2: "High" };
+function Ve(s) {
+  return typeof s == "object" && s.length !== void 0 ? s[0] : s;
+}
+function ze(s) {
+  let e = Array.from(s).slice(1);
+  return e[1] > 15 && (e = e.map(((t) => String.fromCharCode(t)))), e[2] !== "0" && e[2] !== 0 || e.pop(), e.join(".");
+}
+function pe(s) {
+  if (typeof s == "string") {
+    var [e, t, i, n, r, a] = s.trim().split(/[-: ]/g).map(Number), o = new Date(e, t - 1, i);
+    return Number.isNaN(n) || Number.isNaN(r) || Number.isNaN(a) || (o.setHours(n), o.setMinutes(r), o.setSeconds(a)), Number.isNaN(+o) ? s : o;
+  }
+}
+function X(s) {
+  if (typeof s == "string") return s;
+  let e = [];
+  if (s[1] === 0 && s[s.length - 1] === 0) for (let t = 0; t < s.length; t += 2) e.push(He(s[t + 1], s[t]));
+  else for (let t = 0; t < s.length; t += 2) e.push(He(s[t], s[t + 1]));
+  return U(String.fromCodePoint(...e));
+}
+function He(s, e) {
+  return s << 8 | e;
+}
+_.set(41992, de), _.set(41993, de), _.set(41994, de), p(R, ["ifd0", "ifd1"], [[50827, function(s) {
+  return typeof s != "string" ? Je(s) : s;
+}], [306, pe], [40091, X], [40092, X], [40093, X], [40094, X], [40095, X]]), p(R, "exif", [[40960, ze], [36864, ze], [36867, pe], [36868, pe], [40962, Ve], [40963, Ve]]), p(R, "gps", [[0, (s) => Array.from(s).join(".")], [7, (s) => Array.from(s).join(":")]]);
+class ge extends P {
+  static canHandle(e, t) {
+    return e.getUint8(t + 1) === 225 && e.getUint32(t + 4) === 1752462448 && e.getString(t + 4, 20) === "http://ns.adobe.com/";
+  }
+  static headerLength(e, t) {
+    return e.getString(t + 4, 34) === "http://ns.adobe.com/xmp/extension/" ? 79 : 33;
+  }
+  static findPosition(e, t) {
+    let i = super.findPosition(e, t);
+    return i.multiSegment = i.extended = i.headerLength === 79, i.multiSegment ? (i.chunkCount = e.getUint8(t + 72), i.chunkNumber = e.getUint8(t + 76), e.getUint8(t + 77) !== 0 && i.chunkNumber++) : (i.chunkCount = 1 / 0, i.chunkNumber = -1), i;
+  }
+  static handleMultiSegments(e) {
+    return e.map(((t) => t.chunk.getString())).join("");
+  }
+  normalizeInput(e) {
+    return typeof e == "string" ? e : b.from(e).getString();
+  }
+  parse(e = this.chunk) {
+    if (!this.localOptions.parse) return e;
+    e = (function(r) {
+      let a = {}, o = {};
+      for (let l of ot) a[l] = [], o[l] = 0;
+      return r.replace(xt, ((l, u, f) => {
+        if (u === "<") {
+          let c = ++o[f];
+          return a[f].push(c), `${l}#${c}`;
+        }
+        return `${l}#${a[f].pop()}`;
+      }));
+    })(e);
+    let t = H.findAll(e, "rdf", "Description");
+    t.length === 0 && t.push(new H("rdf", "Description", void 0, e));
+    let i, n = {};
+    for (let r of t) for (let a of r.properties) i = Ot(a.ns, n), nt(a, i);
+    return (function(r) {
+      let a;
+      for (let o in r) a = r[o] = te(r[o]), a === void 0 && delete r[o];
+      return te(r);
+    })(n);
+  }
+  assignToOutput(e, t) {
+    if (this.localOptions.parse) for (let [i, n] of Object.entries(t)) switch (i) {
+      case "tiff":
+        this.assignObjectToOutput(e, "ifd0", n);
+        break;
+      case "exif":
+        this.assignObjectToOutput(e, "exif", n);
+        break;
+      case "xmlns":
+        break;
+      default:
+        this.assignObjectToOutput(e, i, n);
+    }
+    else e.xmp = t;
+  }
+}
+h(ge, "type", "xmp"), h(ge, "multiSegment", !0), g.set("xmp", ge);
+class se {
+  static findAll(e) {
+    return rt(e, /([a-zA-Z0-9-]+):([a-zA-Z0-9-]+)=("[^"]*"|'[^']*')/gm).map(se.unpackMatch);
+  }
+  static unpackMatch(e) {
+    let t = e[1], i = e[2], n = e[3].slice(1, -1);
+    return n = at(n), new se(t, i, n);
+  }
+  constructor(e, t, i) {
+    this.ns = e, this.name = t, this.value = i;
+  }
+  serialize() {
+    return this.value;
+  }
+}
+class H {
+  static findAll(e, t, i) {
+    if (t !== void 0 || i !== void 0) {
+      t = t || "[\\w\\d-]+", i = i || "[\\w\\d-]+";
+      var n = new RegExp(`<(${t}):(${i})(#\\d+)?((\\s+?[\\w\\d-:]+=("[^"]*"|'[^']*'))*\\s*)(\\/>|>([\\s\\S]*?)<\\/\\1:\\2\\3>)`, "gm");
+    } else n = /<([\w\d-]+):([\w\d-]+)(#\d+)?((\s+?[\w\d-:]+=("[^"]*"|'[^']*'))*\s*)(\/>|>([\s\S]*?)<\/\1:\2\3>)/gm;
+    return rt(e, n).map(H.unpackMatch);
+  }
+  static unpackMatch(e) {
+    let t = e[1], i = e[2], n = e[4], r = e[8];
+    return new H(t, i, n, r);
+  }
+  constructor(e, t, i, n) {
+    this.ns = e, this.name = t, this.attrString = i, this.innerXml = n, this.attrs = se.findAll(i), this.children = H.findAll(n), this.value = this.children.length === 0 ? at(n) : void 0, this.properties = [...this.attrs, ...this.children];
+  }
+  get isPrimitive() {
+    return this.value !== void 0 && this.attrs.length === 0 && this.children.length === 0;
+  }
+  get isListContainer() {
+    return this.children.length === 1 && this.children[0].isList;
+  }
+  get isList() {
+    let { ns: e, name: t } = this;
+    return e === "rdf" && (t === "Seq" || t === "Bag" || t === "Alt");
+  }
+  get isListItem() {
+    return this.ns === "rdf" && this.name === "li";
+  }
+  serialize() {
+    if (this.properties.length === 0 && this.value === void 0) return;
+    if (this.isPrimitive) return this.value;
+    if (this.isListContainer) return this.children[0].serialize();
+    if (this.isList) return Dt(this.children.map(At));
+    if (this.isListItem && this.children.length === 1 && this.attrs.length === 0) return this.children[0].serialize();
+    let e = {};
+    for (let t of this.properties) nt(t, e);
+    return this.value !== void 0 && (e.value = this.value), te(e);
+  }
+}
+function nt(s, e) {
+  let t = s.serialize();
+  t !== void 0 && (e[s.name] = t);
+}
+var At = (s) => s.serialize(), Dt = (s) => s.length === 1 ? s[0] : s, Ot = (s, e) => e[s] ? e[s] : e[s] = {};
+function rt(s, e) {
+  let t, i = [];
+  if (!s) return i;
+  for (; (t = e.exec(s)) !== null; ) i.push(t);
+  return i;
+}
+function at(s) {
+  if ((function(i) {
+    return i == null || i === "null" || i === "undefined" || i === "" || i.trim() === "";
+  })(s)) return;
+  let e = Number(s);
+  if (!Number.isNaN(e)) return e;
+  let t = s.toLowerCase();
+  return t === "true" || t !== "false" && s.trim();
+}
+const ot = ["rdf:li", "rdf:Seq", "rdf:Bag", "rdf:Alt", "rdf:Description"], xt = new RegExp(`(<|\\/)(${ot.join("|")})`, "g");
+var Lt = Object.freeze({ __proto__: null, default: wt, Exifr: L, fileParsers: k, segmentParsers: g, fileReaders: w, tagKeys: S, tagValues: I, tagRevivers: R, createDictionary: p, extendDictionary: G, fetchUrlAsArrayBuffer: E, readBlobAsArrayBuffer: N, chunkedProps: O, otherSegments: j, segments: V, tiffBlocks: d, segmentsAndBlocks: x, tiffExtractables: v, inheritables: W, allFormatters: M, Options: z, parse: oe, gpsOnlyOptions: Te, gps: Qe, thumbnailOnlyOptions: Ae, thumbnail: Ze, thumbnailUrl: et, orientationOnlyOptions: De, orientation: Oe, rotations: xe, get rotateCanvas() {
+  return F;
+}, get rotateCss() {
+  return B;
+}, rotation: tt });
+let je = ee("fs", ((s) => s.promises));
+w.set("fs", class extends he {
+  async readWhole() {
+    this.chunked = !1, this.fs = await je;
+    let s = await this.fs.readFile(this.input);
+    this._swapBuffer(s);
+  }
+  async readChunked() {
+    this.chunked = !0, this.fs = await je, await this.open(), await this.readChunk(0, this.options.firstChunkSize);
+  }
+  async open() {
+    this.fh === void 0 && (this.fh = await this.fs.open(this.input, "r"), this.size = (await this.fh.stat(this.input)).size);
+  }
+  async _readChunk(s, e) {
+    this.fh === void 0 && await this.open(), s + e > this.size && (e = this.size - s);
+    var t = this.subarray(s, e, !0);
+    return await this.fh.read(t.dataView, 0, e, s), t;
+  }
+  async close() {
+    if (this.fh) {
+      let s = this.fh;
+      this.fh = void 0, await s.close();
+    }
+  }
+});
+w.set("base64", class extends he {
+  constructor(...s) {
+    super(...s), this.input = this.input.replace(/^data:([^;]+);base64,/gim, ""), this.size = this.input.length / 4 * 3, this.input.endsWith("==") ? this.size -= 2 : this.input.endsWith("=") && (this.size -= 1);
+  }
+  async _readChunk(s, e) {
+    let t, i, n = this.input;
+    s === void 0 ? (s = 0, t = 0, i = 0) : (t = 4 * Math.floor(s / 3), i = s - t / 4 * 3), e === void 0 && (e = this.size);
+    let r = s + e, a = t + 4 * Math.ceil(r / 3);
+    n = n.slice(t, a);
+    let o = Math.min(e, this.size - s);
+    if (ae) {
+      let l = re.from(n, "base64").slice(i, i + o);
+      return this.set(l, s, !0);
+    }
+    {
+      let l = this.subarray(s, o, !0), u = atob(n), f = l.toUint8();
+      for (let c = 0; c < o; c++) f[c] = u.charCodeAt(i + c);
+      return l;
+    }
+  }
+});
+class We extends le {
+  static canHandle(e, t) {
+    return t === 18761 || t === 19789;
+  }
+  extendOptions(e) {
+    let { ifd0: t, xmp: i, iptc: n, icc: r } = e;
+    i.enabled && t.deps.add(700), n.enabled && t.deps.add(33723), r.enabled && t.deps.add(34675), t.finalizeFilters();
+  }
+  async parse() {
+    let { tiff: e, xmp: t, iptc: i, icc: n } = this.options;
+    if (e.enabled || t.enabled || i.enabled || n.enabled) {
+      let r = Math.max(Se(this.options), this.options.chunkSize);
+      await this.file.ensureChunk(0, r), this.createParser("tiff", this.file), this.parsers.tiff.parseHeader(), await this.parsers.tiff.parseIfd0Block(), this.adaptTiffPropAsSegment("xmp"), this.adaptTiffPropAsSegment("iptc"), this.adaptTiffPropAsSegment("icc");
+    }
+  }
+  adaptTiffPropAsSegment(e) {
+    if (this.parsers.tiff[e]) {
+      let t = this.parsers.tiff[e];
+      this.injectSegment(e, t);
+    }
+  }
+}
+h(We, "type", "tiff"), k.set("tiff", We);
+let vt = ee("zlib");
+const Mt = ["ihdr", "iccp", "text", "itxt", "exif"];
+class Ke extends le {
+  constructor(...e) {
+    super(...e), h(this, "catchError", ((t) => this.errors.push(t))), h(this, "metaChunks", []), h(this, "unknownChunks", []);
+  }
+  static canHandle(e, t) {
+    return t === 35152 && e.getUint32(0) === 2303741511 && e.getUint32(4) === 218765834;
+  }
+  async parse() {
+    let { file: e } = this;
+    await this.findPngChunksInRange(8, e.byteLength), await this.readSegments(this.metaChunks), this.findIhdr(), this.parseTextChunks(), await this.findExif().catch(this.catchError), await this.findXmp().catch(this.catchError), await this.findIcc().catch(this.catchError);
+  }
+  async findPngChunksInRange(e, t) {
+    let { file: i } = this;
+    for (; e < t; ) {
+      let n = i.getUint32(e), r = i.getUint32(e + 4), a = i.getString(e + 4, 4).toLowerCase(), o = n + 4 + 4 + 4, l = { type: a, offset: e, length: o, start: e + 4 + 4, size: n, marker: r };
+      Mt.includes(a) ? this.metaChunks.push(l) : this.unknownChunks.push(l), e += o;
+    }
+  }
+  parseTextChunks() {
+    let e = this.metaChunks.filter(((t) => t.type === "text"));
+    for (let t of e) {
+      let [i, n] = this.file.getString(t.start, t.size).split("\0");
+      this.injectKeyValToIhdr(i, n);
+    }
+  }
+  injectKeyValToIhdr(e, t) {
+    let i = this.parsers.ihdr;
+    i && i.raw.set(e, t);
+  }
+  findIhdr() {
+    let e = this.metaChunks.find(((t) => t.type === "ihdr"));
+    e && this.options.ihdr.enabled !== !1 && this.createParser("ihdr", e.chunk);
+  }
+  async findExif() {
+    let e = this.metaChunks.find(((t) => t.type === "exif"));
+    e && this.injectSegment("tiff", e.chunk);
+  }
+  async findXmp() {
+    let e = this.metaChunks.filter(((t) => t.type === "itxt"));
+    for (let t of e)
+      t.chunk.getString(0, 17) === "XML:com.adobe.xmp" && this.injectSegment("xmp", t.chunk);
+  }
+  async findIcc() {
+    let e = this.metaChunks.find(((o) => o.type === "iccp"));
+    if (!e) return;
+    let { chunk: t } = e, i = t.getUint8Array(0, 81), n = 0;
+    for (; n < 80 && i[n] !== 0; ) n++;
+    let r = n + 2, a = t.getString(0, n);
+    if (this.injectKeyValToIhdr("ProfileName", a), Z) {
+      let o = await vt, l = t.getUint8Array(r);
+      l = o.inflateSync(l), this.injectSegment("icc", l);
+    }
+  }
+}
+h(Ke, "type", "png"), k.set("png", Ke), p(S, "interop", [[1, "InteropIndex"], [2, "InteropVersion"], [4096, "RelatedImageFileFormat"], [4097, "RelatedImageWidth"], [4098, "RelatedImageHeight"]]), G(S, "ifd0", [[11, "ProcessingSoftware"], [254, "SubfileType"], [255, "OldSubfileType"], [263, "Thresholding"], [264, "CellWidth"], [265, "CellLength"], [266, "FillOrder"], [269, "DocumentName"], [280, "MinSampleValue"], [281, "MaxSampleValue"], [285, "PageName"], [286, "XPosition"], [287, "YPosition"], [290, "GrayResponseUnit"], [297, "PageNumber"], [321, "HalftoneHints"], [322, "TileWidth"], [323, "TileLength"], [332, "InkSet"], [337, "TargetPrinter"], [18246, "Rating"], [18249, "RatingPercent"], [33550, "PixelScale"], [34264, "ModelTransform"], [34377, "PhotoshopSettings"], [50706, "DNGVersion"], [50707, "DNGBackwardVersion"], [50708, "UniqueCameraModel"], [50709, "LocalizedCameraModel"], [50736, "DNGLensInfo"], [50739, "ShadowScale"], [50740, "DNGPrivateData"], [33920, "IntergraphMatrix"], [33922, "ModelTiePoint"], [34118, "SEMInfo"], [34735, "GeoTiffDirectory"], [34736, "GeoTiffDoubleParams"], [34737, "GeoTiffAsciiParams"], [50341, "PrintIM"], [50721, "ColorMatrix1"], [50722, "ColorMatrix2"], [50723, "CameraCalibration1"], [50724, "CameraCalibration2"], [50725, "ReductionMatrix1"], [50726, "ReductionMatrix2"], [50727, "AnalogBalance"], [50728, "AsShotNeutral"], [50729, "AsShotWhiteXY"], [50730, "BaselineExposure"], [50731, "BaselineNoise"], [50732, "BaselineSharpness"], [50734, "LinearResponseLimit"], [50735, "CameraSerialNumber"], [50741, "MakerNoteSafety"], [50778, "CalibrationIlluminant1"], [50779, "CalibrationIlluminant2"], [50781, "RawDataUniqueID"], [50827, "OriginalRawFileName"], [50828, "OriginalRawFileData"], [50831, "AsShotICCProfile"], [50832, "AsShotPreProfileMatrix"], [50833, "CurrentICCProfile"], [50834, "CurrentPreProfileMatrix"], [50879, "ColorimetricReference"], [50885, "SRawType"], [50898, "PanasonicTitle"], [50899, "PanasonicTitle2"], [50931, "CameraCalibrationSig"], [50932, "ProfileCalibrationSig"], [50933, "ProfileIFD"], [50934, "AsShotProfileName"], [50936, "ProfileName"], [50937, "ProfileHueSatMapDims"], [50938, "ProfileHueSatMapData1"], [50939, "ProfileHueSatMapData2"], [50940, "ProfileToneCurve"], [50941, "ProfileEmbedPolicy"], [50942, "ProfileCopyright"], [50964, "ForwardMatrix1"], [50965, "ForwardMatrix2"], [50966, "PreviewApplicationName"], [50967, "PreviewApplicationVersion"], [50968, "PreviewSettingsName"], [50969, "PreviewSettingsDigest"], [50970, "PreviewColorSpace"], [50971, "PreviewDateTime"], [50972, "RawImageDigest"], [50973, "OriginalRawFileDigest"], [50981, "ProfileLookTableDims"], [50982, "ProfileLookTableData"], [51043, "TimeCodes"], [51044, "FrameRate"], [51058, "TStop"], [51081, "ReelName"], [51089, "OriginalDefaultFinalSize"], [51090, "OriginalBestQualitySize"], [51091, "OriginalDefaultCropSize"], [51105, "CameraLabel"], [51107, "ProfileHueSatMapEncoding"], [51108, "ProfileLookTableEncoding"], [51109, "BaselineExposureOffset"], [51110, "DefaultBlackRender"], [51111, "NewRawImageDigest"], [51112, "RawToPreviewGain"]]);
+let Xe = [[273, "StripOffsets"], [279, "StripByteCounts"], [288, "FreeOffsets"], [289, "FreeByteCounts"], [291, "GrayResponseCurve"], [292, "T4Options"], [293, "T6Options"], [300, "ColorResponseUnit"], [320, "ColorMap"], [324, "TileOffsets"], [325, "TileByteCounts"], [326, "BadFaxLines"], [327, "CleanFaxData"], [328, "ConsecutiveBadFaxLines"], [330, "SubIFD"], [333, "InkNames"], [334, "NumberofInks"], [336, "DotRange"], [338, "ExtraSamples"], [339, "SampleFormat"], [340, "SMinSampleValue"], [341, "SMaxSampleValue"], [342, "TransferRange"], [343, "ClipPath"], [344, "XClipPathUnits"], [345, "YClipPathUnits"], [346, "Indexed"], [347, "JPEGTables"], [351, "OPIProxy"], [400, "GlobalParametersIFD"], [401, "ProfileType"], [402, "FaxProfile"], [403, "CodingMethods"], [404, "VersionYear"], [405, "ModeNumber"], [433, "Decode"], [434, "DefaultImageColor"], [435, "T82Options"], [437, "JPEGTables"], [512, "JPEGProc"], [515, "JPEGRestartInterval"], [517, "JPEGLosslessPredictors"], [518, "JPEGPointTransforms"], [519, "JPEGQTables"], [520, "JPEGDCTables"], [521, "JPEGACTables"], [559, "StripRowCounts"], [999, "USPTOMiscellaneous"], [18247, "XP_DIP_XML"], [18248, "StitchInfo"], [28672, "SonyRawFileType"], [28688, "SonyToneCurve"], [28721, "VignettingCorrection"], [28722, "VignettingCorrParams"], [28724, "ChromaticAberrationCorrection"], [28725, "ChromaticAberrationCorrParams"], [28726, "DistortionCorrection"], [28727, "DistortionCorrParams"], [29895, "SonyCropTopLeft"], [29896, "SonyCropSize"], [32781, "ImageID"], [32931, "WangTag1"], [32932, "WangAnnotation"], [32933, "WangTag3"], [32934, "WangTag4"], [32953, "ImageReferencePoints"], [32954, "RegionXformTackPoint"], [32955, "WarpQuadrilateral"], [32956, "AffineTransformMat"], [32995, "Matteing"], [32996, "DataType"], [32997, "ImageDepth"], [32998, "TileDepth"], [33300, "ImageFullWidth"], [33301, "ImageFullHeight"], [33302, "TextureFormat"], [33303, "WrapModes"], [33304, "FovCot"], [33305, "MatrixWorldToScreen"], [33306, "MatrixWorldToCamera"], [33405, "Model2"], [33421, "CFARepeatPatternDim"], [33422, "CFAPattern2"], [33423, "BatteryLevel"], [33424, "KodakIFD"], [33445, "MDFileTag"], [33446, "MDScalePixel"], [33447, "MDColorTable"], [33448, "MDLabName"], [33449, "MDSampleInfo"], [33450, "MDPrepDate"], [33451, "MDPrepTime"], [33452, "MDFileUnits"], [33589, "AdventScale"], [33590, "AdventRevision"], [33628, "UIC1Tag"], [33629, "UIC2Tag"], [33630, "UIC3Tag"], [33631, "UIC4Tag"], [33918, "IntergraphPacketData"], [33919, "IntergraphFlagRegisters"], [33921, "INGRReserved"], [34016, "Site"], [34017, "ColorSequence"], [34018, "IT8Header"], [34019, "RasterPadding"], [34020, "BitsPerRunLength"], [34021, "BitsPerExtendedRunLength"], [34022, "ColorTable"], [34023, "ImageColorIndicator"], [34024, "BackgroundColorIndicator"], [34025, "ImageColorValue"], [34026, "BackgroundColorValue"], [34027, "PixelIntensityRange"], [34028, "TransparencyIndicator"], [34029, "ColorCharacterization"], [34030, "HCUsage"], [34031, "TrapIndicator"], [34032, "CMYKEquivalent"], [34152, "AFCP_IPTC"], [34232, "PixelMagicJBIGOptions"], [34263, "JPLCartoIFD"], [34306, "WB_GRGBLevels"], [34310, "LeafData"], [34687, "TIFF_FXExtensions"], [34688, "MultiProfiles"], [34689, "SharedData"], [34690, "T88Options"], [34732, "ImageLayer"], [34750, "JBIGOptions"], [34856, "Opto-ElectricConvFactor"], [34857, "Interlace"], [34908, "FaxRecvParams"], [34909, "FaxSubAddress"], [34910, "FaxRecvTime"], [34929, "FedexEDR"], [34954, "LeafSubIFD"], [37387, "FlashEnergy"], [37388, "SpatialFrequencyResponse"], [37389, "Noise"], [37390, "FocalPlaneXResolution"], [37391, "FocalPlaneYResolution"], [37392, "FocalPlaneResolutionUnit"], [37397, "ExposureIndex"], [37398, "TIFF-EPStandardID"], [37399, "SensingMethod"], [37434, "CIP3DataFile"], [37435, "CIP3Sheet"], [37436, "CIP3Side"], [37439, "StoNits"], [37679, "MSDocumentText"], [37680, "MSPropertySetStorage"], [37681, "MSDocumentTextPosition"], [37724, "ImageSourceData"], [40965, "InteropIFD"], [40976, "SamsungRawPointersOffset"], [40977, "SamsungRawPointersLength"], [41217, "SamsungRawByteOrder"], [41218, "SamsungRawUnknown"], [41484, "SpatialFrequencyResponse"], [41485, "Noise"], [41489, "ImageNumber"], [41490, "SecurityClassification"], [41491, "ImageHistory"], [41494, "TIFF-EPStandardID"], [41995, "DeviceSettingDescription"], [42112, "GDALMetadata"], [42113, "GDALNoData"], [44992, "ExpandSoftware"], [44993, "ExpandLens"], [44994, "ExpandFilm"], [44995, "ExpandFilterLens"], [44996, "ExpandScanner"], [44997, "ExpandFlashLamp"], [46275, "HasselbladRawImage"], [48129, "PixelFormat"], [48130, "Transformation"], [48131, "Uncompressed"], [48132, "ImageType"], [48256, "ImageWidth"], [48257, "ImageHeight"], [48258, "WidthResolution"], [48259, "HeightResolution"], [48320, "ImageOffset"], [48321, "ImageByteCount"], [48322, "AlphaOffset"], [48323, "AlphaByteCount"], [48324, "ImageDataDiscard"], [48325, "AlphaDataDiscard"], [50215, "OceScanjobDesc"], [50216, "OceApplicationSelector"], [50217, "OceIDNumber"], [50218, "OceImageLogic"], [50255, "Annotations"], [50459, "HasselbladExif"], [50547, "OriginalFileName"], [50560, "USPTOOriginalContentType"], [50656, "CR2CFAPattern"], [50710, "CFAPlaneColor"], [50711, "CFALayout"], [50712, "LinearizationTable"], [50713, "BlackLevelRepeatDim"], [50714, "BlackLevel"], [50715, "BlackLevelDeltaH"], [50716, "BlackLevelDeltaV"], [50717, "WhiteLevel"], [50718, "DefaultScale"], [50719, "DefaultCropOrigin"], [50720, "DefaultCropSize"], [50733, "BayerGreenSplit"], [50737, "ChromaBlurRadius"], [50738, "AntiAliasStrength"], [50752, "RawImageSegmentation"], [50780, "BestQualityScale"], [50784, "AliasLayerMetadata"], [50829, "ActiveArea"], [50830, "MaskedAreas"], [50935, "NoiseReductionApplied"], [50974, "SubTileBlockSize"], [50975, "RowInterleaveFactor"], [51008, "OpcodeList1"], [51009, "OpcodeList2"], [51022, "OpcodeList3"], [51041, "NoiseProfile"], [51114, "CacheVersion"], [51125, "DefaultUserCrop"], [51157, "NikonNEFInfo"], [65024, "KdcIFD"]];
+G(S, "ifd0", Xe), G(S, "exif", Xe), p(I, "gps", [[23, { M: "Magnetic North", T: "True North" }], [25, { K: "Kilometers", M: "Miles", N: "Nautical Miles" }]]);
+class me extends P {
+  static canHandle(e, t) {
+    return e.getUint8(t + 1) === 224 && e.getUint32(t + 4) === 1246120262 && e.getUint8(t + 8) === 0;
+  }
+  parse() {
+    return this.parseTags(), this.translate(), this.output;
+  }
+  parseTags() {
+    this.raw = /* @__PURE__ */ new Map([[0, this.chunk.getUint16(0)], [2, this.chunk.getUint8(2)], [3, this.chunk.getUint16(3)], [5, this.chunk.getUint16(5)], [7, this.chunk.getUint8(7)], [8, this.chunk.getUint8(8)]]);
+  }
+}
+h(me, "type", "jfif"), h(me, "headerLength", 9), g.set("jfif", me), p(S, "jfif", [[0, "JFIFVersion"], [2, "ResolutionUnit"], [3, "XResolution"], [5, "YResolution"], [7, "ThumbnailWidth"], [8, "ThumbnailHeight"]]);
+class _e extends P {
+  parse() {
+    return this.parseTags(), this.translate(), this.output;
+  }
+  parseTags() {
+    this.raw = new Map([[0, this.chunk.getUint32(0)], [4, this.chunk.getUint32(4)], [8, this.chunk.getUint8(8)], [9, this.chunk.getUint8(9)], [10, this.chunk.getUint8(10)], [11, this.chunk.getUint8(11)], [12, this.chunk.getUint8(12)], ...Array.from(this.raw)]);
+  }
+}
+h(_e, "type", "ihdr"), g.set("ihdr", _e), p(S, "ihdr", [[0, "ImageWidth"], [4, "ImageHeight"], [8, "BitDepth"], [9, "ColorType"], [10, "Compression"], [11, "Filter"], [12, "Interlace"]]), p(I, "ihdr", [[9, { 0: "Grayscale", 2: "RGB", 3: "Palette", 4: "Grayscale with Alpha", 6: "RGB with Alpha", DEFAULT: "Unknown" }], [10, { 0: "Deflate/Inflate", DEFAULT: "Unknown" }], [11, { 0: "Adaptive", DEFAULT: "Unknown" }], [12, { 0: "Noninterlaced", 1: "Adam7 Interlace", DEFAULT: "Unknown" }]]);
+class Q extends P {
+  static canHandle(e, t) {
+    return e.getUint8(t + 1) === 226 && e.getUint32(t + 4) === 1229144927;
+  }
+  static findPosition(e, t) {
+    let i = super.findPosition(e, t);
+    return i.chunkNumber = e.getUint8(t + 16), i.chunkCount = e.getUint8(t + 17), i.multiSegment = i.chunkCount > 1, i;
+  }
+  static handleMultiSegments(e) {
+    return (function(t) {
+      let i = (function(n) {
+        let r = n[0].constructor, a = 0;
+        for (let u of n) a += u.length;
+        let o = new r(a), l = 0;
+        for (let u of n) o.set(u, l), l += u.length;
+        return o;
+      })(t.map(((n) => n.chunk.toUint8())));
+      return new b(i);
+    })(e);
+  }
+  parse() {
+    return this.raw = /* @__PURE__ */ new Map(), this.parseHeader(), this.parseTags(), this.translate(), this.output;
+  }
+  parseHeader() {
+    let { raw: e } = this;
+    this.chunk.byteLength < 84 && m("ICC header is too short");
+    for (let [t, i] of Object.entries(Rt)) {
+      t = parseInt(t, 10);
+      let n = i(this.chunk, t);
+      n !== "\0\0\0\0" && e.set(t, n);
+    }
+  }
+  parseTags() {
+    let e, t, i, n, r, { raw: a } = this, o = this.chunk.getUint32(128), l = 132, u = this.chunk.byteLength;
+    for (; o--; ) {
+      if (e = this.chunk.getString(l, 4), t = this.chunk.getUint32(l + 4), i = this.chunk.getUint32(l + 8), n = this.chunk.getString(t, 4), t + i > u) return void console.warn("reached the end of the first ICC chunk. Enable options.tiff.multiSegment to read all ICC segments.");
+      r = this.parseTag(n, t, i), r !== void 0 && r !== "\0\0\0\0" && a.set(e, r), l += 12;
+    }
+  }
+  parseTag(e, t, i) {
+    switch (e) {
+      case "desc":
+        return this.parseDesc(t);
+      case "mluc":
+        return this.parseMluc(t);
+      case "text":
+        return this.parseText(t, i);
+      case "sig ":
+        return this.parseSig(t);
+    }
+    if (!(t + i > this.chunk.byteLength)) return this.chunk.getUint8Array(t, i);
+  }
+  parseDesc(e) {
+    let t = this.chunk.getUint32(e + 8) - 1;
+    return U(this.chunk.getString(e + 12, t));
+  }
+  parseText(e, t) {
+    return U(this.chunk.getString(e + 8, t - 8));
+  }
+  parseSig(e) {
+    return U(this.chunk.getString(e + 8, 4));
+  }
+  parseMluc(e) {
+    let { chunk: t } = this, i = t.getUint32(e + 8), n = t.getUint32(e + 12), r = e + 16, a = [];
+    for (let o = 0; o < i; o++) {
+      let l = t.getString(r + 0, 2), u = t.getString(r + 2, 2), f = t.getUint32(r + 4), c = t.getUint32(r + 8) + e, y = U(t.getUnicodeString(c, f));
+      a.push({ lang: l, country: u, text: y }), r += n;
+    }
+    return i === 1 ? a[0].text : a;
+  }
+  translateValue(e, t) {
+    return typeof e == "string" ? t[e] || t[e.toLowerCase()] || e : t[e] || e;
+  }
+}
+h(Q, "type", "icc"), h(Q, "multiSegment", !0), h(Q, "headerLength", 18);
+const Rt = { 4: D, 8: function(s, e) {
+  return [s.getUint8(e), s.getUint8(e + 1) >> 4, s.getUint8(e + 1) % 16].map(((t) => t.toString(10))).join(".");
+}, 12: D, 16: D, 20: D, 24: function(s, e) {
+  const t = s.getUint16(e), i = s.getUint16(e + 2) - 1, n = s.getUint16(e + 4), r = s.getUint16(e + 6), a = s.getUint16(e + 8), o = s.getUint16(e + 10);
+  return new Date(Date.UTC(t, i, n, r, a, o));
+}, 36: D, 40: D, 48: D, 52: D, 64: (s, e) => s.getUint32(e), 80: D };
+function D(s, e) {
+  return U(s.getString(e, 4));
+}
+g.set("icc", Q), p(S, "icc", [[4, "ProfileCMMType"], [8, "ProfileVersion"], [12, "ProfileClass"], [16, "ColorSpaceData"], [20, "ProfileConnectionSpace"], [24, "ProfileDateTime"], [36, "ProfileFileSignature"], [40, "PrimaryPlatform"], [44, "CMMFlags"], [48, "DeviceManufacturer"], [52, "DeviceModel"], [56, "DeviceAttributes"], [64, "RenderingIntent"], [68, "ConnectionSpaceIlluminant"], [80, "ProfileCreator"], [84, "ProfileID"], ["Header", "ProfileHeader"], ["MS00", "WCSProfiles"], ["bTRC", "BlueTRC"], ["bXYZ", "BlueMatrixColumn"], ["bfd", "UCRBG"], ["bkpt", "MediaBlackPoint"], ["calt", "CalibrationDateTime"], ["chad", "ChromaticAdaptation"], ["chrm", "Chromaticity"], ["ciis", "ColorimetricIntentImageState"], ["clot", "ColorantTableOut"], ["clro", "ColorantOrder"], ["clrt", "ColorantTable"], ["cprt", "ProfileCopyright"], ["crdi", "CRDInfo"], ["desc", "ProfileDescription"], ["devs", "DeviceSettings"], ["dmdd", "DeviceModelDesc"], ["dmnd", "DeviceMfgDesc"], ["dscm", "ProfileDescriptionML"], ["fpce", "FocalPlaneColorimetryEstimates"], ["gTRC", "GreenTRC"], ["gXYZ", "GreenMatrixColumn"], ["gamt", "Gamut"], ["kTRC", "GrayTRC"], ["lumi", "Luminance"], ["meas", "Measurement"], ["meta", "Metadata"], ["mmod", "MakeAndModel"], ["ncl2", "NamedColor2"], ["ncol", "NamedColor"], ["ndin", "NativeDisplayInfo"], ["pre0", "Preview0"], ["pre1", "Preview1"], ["pre2", "Preview2"], ["ps2i", "PS2RenderingIntent"], ["ps2s", "PostScript2CSA"], ["psd0", "PostScript2CRD0"], ["psd1", "PostScript2CRD1"], ["psd2", "PostScript2CRD2"], ["psd3", "PostScript2CRD3"], ["pseq", "ProfileSequenceDesc"], ["psid", "ProfileSequenceIdentifier"], ["psvm", "PS2CRDVMSize"], ["rTRC", "RedTRC"], ["rXYZ", "RedMatrixColumn"], ["resp", "OutputResponse"], ["rhoc", "ReflectionHardcopyOrigColorimetry"], ["rig0", "PerceptualRenderingIntentGamut"], ["rig2", "SaturationRenderingIntentGamut"], ["rpoc", "ReflectionPrintOutputColorimetry"], ["sape", "SceneAppearanceEstimates"], ["scoe", "SceneColorimetryEstimates"], ["scrd", "ScreeningDesc"], ["scrn", "Screening"], ["targ", "CharTarget"], ["tech", "Technology"], ["vcgt", "VideoCardGamma"], ["view", "ViewingConditions"], ["vued", "ViewingCondDesc"], ["wtpt", "MediaWhitePoint"]]);
+const J = { "4d2p": "Erdt Systems", AAMA: "Aamazing Technologies", ACER: "Acer", ACLT: "Acolyte Color Research", ACTI: "Actix Sytems", ADAR: "Adara Technology", ADBE: "Adobe", ADI: "ADI Systems", AGFA: "Agfa Graphics", ALMD: "Alps Electric", ALPS: "Alps Electric", ALWN: "Alwan Color Expertise", AMTI: "Amiable Technologies", AOC: "AOC International", APAG: "Apago", APPL: "Apple Computer", AST: "AST", "AT&T": "AT&T", BAEL: "BARBIERI electronic", BRCO: "Barco NV", BRKP: "Breakpoint", BROT: "Brother", BULL: "Bull", BUS: "Bus Computer Systems", "C-IT": "C-Itoh", CAMR: "Intel", CANO: "Canon", CARR: "Carroll Touch", CASI: "Casio", CBUS: "Colorbus PL", CEL: "Crossfield", CELx: "Crossfield", CGS: "CGS Publishing Technologies International", CHM: "Rochester Robotics", CIGL: "Colour Imaging Group, London", CITI: "Citizen", CL00: "Candela", CLIQ: "Color IQ", CMCO: "Chromaco", CMiX: "CHROMiX", COLO: "Colorgraphic Communications", COMP: "Compaq", COMp: "Compeq/Focus Technology", CONR: "Conrac Display Products", CORD: "Cordata Technologies", CPQ: "Compaq", CPRO: "ColorPro", CRN: "Cornerstone", CTX: "CTX International", CVIS: "ColorVision", CWC: "Fujitsu Laboratories", DARI: "Darius Technology", DATA: "Dataproducts", DCP: "Dry Creek Photo", DCRC: "Digital Contents Resource Center, Chung-Ang University", DELL: "Dell Computer", DIC: "Dainippon Ink and Chemicals", DICO: "Diconix", DIGI: "Digital", "DL&C": "Digital Light & Color", DPLG: "Doppelganger", DS: "Dainippon Screen", DSOL: "DOOSOL", DUPN: "DuPont", EPSO: "Epson", ESKO: "Esko-Graphics", ETRI: "Electronics and Telecommunications Research Institute", EVER: "Everex Systems", EXAC: "ExactCODE", Eizo: "Eizo", FALC: "Falco Data Products", FF: "Fuji Photo Film", FFEI: "FujiFilm Electronic Imaging", FNRD: "Fnord Software", FORA: "Fora", FORE: "Forefront Technology", FP: "Fujitsu", FPA: "WayTech Development", FUJI: "Fujitsu", FX: "Fuji Xerox", GCC: "GCC Technologies", GGSL: "Global Graphics Software", GMB: "Gretagmacbeth", GMG: "GMG", GOLD: "GoldStar Technology", GOOG: "Google", GPRT: "Giantprint", GTMB: "Gretagmacbeth", GVC: "WayTech Development", GW2K: "Sony", HCI: "HCI", HDM: "Heidelberger Druckmaschinen", HERM: "Hermes", HITA: "Hitachi America", HP: "Hewlett-Packard", HTC: "Hitachi", HiTi: "HiTi Digital", IBM: "IBM", IDNT: "Scitex", IEC: "Hewlett-Packard", IIYA: "Iiyama North America", IKEG: "Ikegami Electronics", IMAG: "Image Systems", IMI: "Ingram Micro", INTC: "Intel", INTL: "N/A (INTL)", INTR: "Intra Electronics", IOCO: "Iocomm International Technology", IPS: "InfoPrint Solutions Company", IRIS: "Scitex", ISL: "Ichikawa Soft Laboratory", ITNL: "N/A (ITNL)", IVM: "IVM", IWAT: "Iwatsu Electric", Idnt: "Scitex", Inca: "Inca Digital Printers", Iris: "Scitex", JPEG: "Joint Photographic Experts Group", JSFT: "Jetsoft Development", JVC: "JVC Information Products", KART: "Scitex", KFC: "KFC Computek Components", KLH: "KLH Computers", KMHD: "Konica Minolta", KNCA: "Konica", KODA: "Kodak", KYOC: "Kyocera", Kart: "Scitex", LCAG: "Leica", LCCD: "Leeds Colour", LDAK: "Left Dakota", LEAD: "Leading Technology", LEXM: "Lexmark International", LINK: "Link Computer", LINO: "Linotronic", LITE: "Lite-On", Leaf: "Leaf", Lino: "Linotronic", MAGC: "Mag Computronic", MAGI: "MAG Innovision", MANN: "Mannesmann", MICN: "Micron Technology", MICR: "Microtek", MICV: "Microvitec", MINO: "Minolta", MITS: "Mitsubishi Electronics America", MITs: "Mitsuba", MNLT: "Minolta", MODG: "Modgraph", MONI: "Monitronix", MONS: "Monaco Systems", MORS: "Morse Technology", MOTI: "Motive Systems", MSFT: "Microsoft", MUTO: "MUTOH INDUSTRIES", Mits: "Mitsubishi Electric", NANA: "NANAO", NEC: "NEC", NEXP: "NexPress Solutions", NISS: "Nissei Sangyo America", NKON: "Nikon", NONE: "none", OCE: "Oce Technologies", OCEC: "OceColor", OKI: "Oki", OKID: "Okidata", OKIP: "Okidata", OLIV: "Olivetti", OLYM: "Olympus", ONYX: "Onyx Graphics", OPTI: "Optiquest", PACK: "Packard Bell", PANA: "Matsushita Electric Industrial", PANT: "Pantone", PBN: "Packard Bell", PFU: "PFU", PHIL: "Philips Consumer Electronics", PNTX: "HOYA", POne: "Phase One A/S", PREM: "Premier Computer Innovations", PRIN: "Princeton Graphic Systems", PRIP: "Princeton Publishing Labs", QLUX: "Hong Kong", QMS: "QMS", QPCD: "QPcard AB", QUAD: "QuadLaser", QUME: "Qume", RADI: "Radius", RDDx: "Integrated Color Solutions", RDG: "Roland DG", REDM: "REDMS Group", RELI: "Relisys", RGMS: "Rolf Gierling Multitools", RICO: "Ricoh", RNLD: "Edmund Ronald", ROYA: "Royal", RPC: "Ricoh Printing Systems", RTL: "Royal Information Electronics", SAMP: "Sampo", SAMS: "Samsung", SANT: "Jaime Santana Pomares", SCIT: "Scitex", SCRN: "Dainippon Screen", SDP: "Scitex", SEC: "Samsung", SEIK: "Seiko Instruments", SEIk: "Seikosha", SGUY: "ScanGuy.com", SHAR: "Sharp Laboratories", SICC: "International Color Consortium", SONY: "Sony", SPCL: "SpectraCal", STAR: "Star", STC: "Sampo Technology", Scit: "Scitex", Sdp: "Scitex", Sony: "Sony", TALO: "Talon Technology", TAND: "Tandy", TATU: "Tatung", TAXA: "TAXAN America", TDS: "Tokyo Denshi Sekei", TECO: "TECO Information Systems", TEGR: "Tegra", TEKT: "Tektronix", TI: "Texas Instruments", TMKR: "TypeMaker", TOSB: "Toshiba", TOSH: "Toshiba", TOTK: "TOTOKU ELECTRIC", TRIU: "Triumph", TSBT: "Toshiba", TTX: "TTX Computer Products", TVM: "TVM Professional Monitor", TW: "TW Casper", ULSX: "Ulead Systems", UNIS: "Unisys", UTZF: "Utz Fehlau & Sohn", VARI: "Varityper", VIEW: "Viewsonic", VISL: "Visual communication", VIVO: "Vivo Mobile Communication", WANG: "Wang", WLBR: "Wilbur Imaging", WTG2: "Ware To Go", WYSE: "WYSE Technology", XERX: "Xerox", XRIT: "X-Rite", ZRAN: "Zoran", Zebr: "Zebra Technologies", appl: "Apple Computer", bICC: "basICColor", berg: "bergdesign", ceyd: "Integrated Color Solutions", clsp: "MacDermid ColorSpan", ds: "Dainippon Screen", dupn: "DuPont", ffei: "FujiFilm Electronic Imaging", flux: "FluxData", iris: "Scitex", kart: "Scitex", lcms: "Little CMS", lino: "Linotronic", none: "none", ob4d: "Erdt Systems", obic: "Medigraph", quby: "Qubyx Sarl", scit: "Scitex", scrn: "Dainippon Screen", sdp: "Scitex", siwi: "SIWI GRAFIKA", yxym: "YxyMaster" }, Ye = { scnr: "Scanner", mntr: "Monitor", prtr: "Printer", link: "Device Link", abst: "Abstract", spac: "Color Space Conversion Profile", nmcl: "Named Color", cenc: "ColorEncodingSpace profile", mid: "MultiplexIdentification profile", mlnk: "MultiplexLink profile", mvis: "MultiplexVisualization profile", nkpf: "Nikon Input Device Profile (NON-STANDARD!)" };
+p(I, "icc", [[4, J], [12, Ye], [40, Object.assign({}, J, Ye)], [48, J], [80, J], [64, { 0: "Perceptual", 1: "Relative Colorimetric", 2: "Saturation", 3: "Absolute Colorimetric" }], ["tech", { amd: "Active Matrix Display", crt: "Cathode Ray Tube Display", kpcd: "Photo CD", pmd: "Passive Matrix Display", dcam: "Digital Camera", dcpj: "Digital Cinema Projector", dmpc: "Digital Motion Picture Camera", dsub: "Dye Sublimation Printer", epho: "Electrophotographic Printer", esta: "Electrostatic Printer", flex: "Flexography", fprn: "Film Writer", fscn: "Film Scanner", grav: "Gravure", ijet: "Ink Jet Printer", imgs: "Photo Image Setter", mpfr: "Motion Picture Film Recorder", mpfs: "Motion Picture Film Scanner", offs: "Offset Lithography", pjtv: "Projection Television", rpho: "Photographic Paper Printer", rscn: "Reflective Scanner", silk: "Silkscreen", twax: "Thermal Wax Printer", vidc: "Video Camera", vidm: "Video Monitor" }]]);
+class q extends P {
+  static canHandle(e, t, i) {
+    return e.getUint8(t + 1) === 237 && e.getString(t + 4, 9) === "Photoshop" && this.containsIptc8bim(e, t, i) !== void 0;
+  }
+  static headerLength(e, t, i) {
+    let n, r = this.containsIptc8bim(e, t, i);
+    if (r !== void 0) return n = e.getUint8(t + r + 7), n % 2 != 0 && (n += 1), n === 0 && (n = 4), r + 8 + n;
+  }
+  static containsIptc8bim(e, t, i) {
+    for (let n = 0; n < i; n++) if (this.isIptcSegmentHead(e, t + n)) return n;
+  }
+  static isIptcSegmentHead(e, t) {
+    return e.getUint8(t) === 56 && e.getUint32(t) === 943868237 && e.getUint16(t + 4) === 1028;
+  }
+  parse() {
+    let { raw: e } = this, t = this.chunk.byteLength - 1, i = !1;
+    for (let n = 0; n < t; n++) if (this.chunk.getUint8(n) === 28 && this.chunk.getUint8(n + 1) === 2) {
+      i = !0;
+      let r = this.chunk.getUint16(n + 3), a = this.chunk.getUint8(n + 2), o = this.chunk.getLatin1String(n + 5, r);
+      e.set(a, this.pluralizeValue(e.get(a), o)), n += 4 + r;
+    } else if (i) break;
+    return this.translate(), this.output;
+  }
+  pluralizeValue(e, t) {
+    return e !== void 0 ? e instanceof Array ? (e.push(t), e) : [e, t] : t;
+  }
+}
+h(q, "type", "iptc"), h(q, "translateValues", !1), h(q, "reviveValues", !1), g.set("iptc", q), p(S, "iptc", [[0, "ApplicationRecordVersion"], [3, "ObjectTypeReference"], [4, "ObjectAttributeReference"], [5, "ObjectName"], [7, "EditStatus"], [8, "EditorialUpdate"], [10, "Urgency"], [12, "SubjectReference"], [15, "Category"], [20, "SupplementalCategories"], [22, "FixtureIdentifier"], [25, "Keywords"], [26, "ContentLocationCode"], [27, "ContentLocationName"], [30, "ReleaseDate"], [35, "ReleaseTime"], [37, "ExpirationDate"], [38, "ExpirationTime"], [40, "SpecialInstructions"], [42, "ActionAdvised"], [45, "ReferenceService"], [47, "ReferenceDate"], [50, "ReferenceNumber"], [55, "DateCreated"], [60, "TimeCreated"], [62, "DigitalCreationDate"], [63, "DigitalCreationTime"], [65, "OriginatingProgram"], [70, "ProgramVersion"], [75, "ObjectCycle"], [80, "Byline"], [85, "BylineTitle"], [90, "City"], [92, "Sublocation"], [95, "State"], [100, "CountryCode"], [101, "Country"], [103, "OriginalTransmissionReference"], [105, "Headline"], [110, "Credit"], [115, "Source"], [116, "CopyrightNotice"], [118, "Contact"], [120, "Caption"], [121, "LocalCaption"], [122, "Writer"], [125, "RasterizedCaption"], [130, "ImageType"], [131, "ImageOrientation"], [135, "LanguageIdentifier"], [150, "AudioType"], [151, "AudioSamplingRate"], [152, "AudioSamplingResolution"], [153, "AudioDuration"], [154, "AudioOutcue"], [184, "JobID"], [185, "MasterDocumentID"], [186, "ShortDocumentID"], [187, "UniqueDocumentID"], [188, "OwnerID"], [200, "ObjectPreviewFileFormat"], [201, "ObjectPreviewFileVersion"], [202, "ObjectPreviewData"], [221, "Prefs"], [225, "ClassifyState"], [228, "SimilarityIndex"], [230, "DocumentNotes"], [231, "DocumentHistory"], [232, "ExifCameraInfo"], [255, "CatalogSets"]]), p(I, "iptc", [[10, { 0: "0 (reserved)", 1: "1 (most urgent)", 2: "2", 3: "3", 4: "4", 5: "5 (normal urgency)", 6: "6", 7: "7", 8: "8 (least urgent)", 9: "9 (user-defined priority)" }], [75, { a: "Morning", b: "Both Morning and Evening", p: "Evening" }], [131, { L: "Landscape", P: "Portrait", S: "Square" }]]);
+export {
+  L as Exifr,
+  z as Options,
+  M as allFormatters,
+  O as chunkedProps,
+  p as createDictionary,
+  Lt as default,
+  G as extendDictionary,
+  E as fetchUrlAsArrayBuffer,
+  k as fileParsers,
+  w as fileReaders,
+  Qe as gps,
+  Te as gpsOnlyOptions,
+  W as inheritables,
+  Oe as orientation,
+  De as orientationOnlyOptions,
+  j as otherSegments,
+  oe as parse,
+  N as readBlobAsArrayBuffer,
+  F as rotateCanvas,
+  B as rotateCss,
+  tt as rotation,
+  xe as rotations,
+  g as segmentParsers,
+  V as segments,
+  x as segmentsAndBlocks,
+  S as tagKeys,
+  R as tagRevivers,
+  I as tagValues,
+  Ze as thumbnail,
+  Ae as thumbnailOnlyOptions,
+  et as thumbnailUrl,
+  d as tiffBlocks,
+  v as tiffExtractables
+};