maplibre-gl-components 0.16.2 → 0.17.0

package/dist/jpeg-CJcNvScS.js

@@ -0,0 +1,545 @@
+import { t as ie } from "./basedecoder-BliCKuUS.js";
+var O = new Int32Array([
+  0,
+  1,
+  8,
+  16,
+  9,
+  2,
+  3,
+  10,
+  17,
+  24,
+  32,
+  25,
+  18,
+  11,
+  4,
+  5,
+  12,
+  19,
+  26,
+  33,
+  40,
+  48,
+  41,
+  34,
+  27,
+  20,
+  13,
+  6,
+  7,
+  14,
+  21,
+  28,
+  35,
+  42,
+  49,
+  56,
+  57,
+  50,
+  43,
+  36,
+  29,
+  22,
+  15,
+  23,
+  30,
+  37,
+  44,
+  51,
+  58,
+  59,
+  52,
+  45,
+  38,
+  31,
+  39,
+  46,
+  53,
+  60,
+  61,
+  54,
+  47,
+  55,
+  62,
+  63
+]), Z = 4017, $ = 799, z = 3406, Q = 2276, W = 1567, _ = 3784, V = 5793, K = 2896;
+function te(c, s) {
+  let g = 0;
+  const v = [];
+  let D = 16;
+  for (; D > 0 && !c[D - 1]; ) --D;
+  v.push({
+    children: [],
+    index: 0
+  });
+  let d = v[0], e;
+  for (let u = 0; u < D; u++) {
+    for (let a = 0; a < c[u]; a++) {
+      if (d = v.pop(), !d) throw new Error("buildHuffmanTable: codeLength mismatch");
+      for (d.children[d.index] = s[g]; d.index > 0; )
+        if (d = v.pop(), !d) throw new Error("buildHuffmanTable: codeLength mismatch");
+      for (d.index++, v.push(d); v.length <= u; )
+        v.push(e = {
+          children: [],
+          index: 0
+        }), d.children[d.index] = e.children, d = e;
+      g++;
+    }
+    u + 1 < D && (v.push(e = {
+      children: [],
+      index: 0
+    }), d.children[d.index] = e.children, d = e);
+  }
+  return v[0].children;
+}
+function ce(c, s, g, v, D, d, e, u, a) {
+  const { mcusPerLine: r, progressive: l } = g;
+  if (v.length > 1 && (r === void 0 || g.mcusPerColumn === void 0)) throw new Error("Missing MCU dimensions");
+  if (v.length === 1 && (v[0].blocksPerLine === void 0 || v[0].blocksPerColumn === void 0)) throw new Error("Missing block dimensions");
+  const x = s;
+  let i = s, w = 0, p = 0;
+  function h() {
+    if (p > 0)
+      return p--, w >> p & 1;
+    if (w = c[i++], w === 255) {
+      const f = c[i++];
+      if (f) throw new Error(`unexpected marker: ${(w << 8 | f).toString(16)}`);
+    }
+    return p = 7, w >>> 7;
+  }
+  function E(f) {
+    if (!f) throw new Error("Huffman table not found");
+    let b = f, m;
+    for (; (m = h()) !== null; ) {
+      const y = b[m];
+      if (typeof y == "number") return y;
+      if (typeof y != "object") throw new Error("invalid huffman sequence");
+      b = y;
+    }
+    return null;
+  }
+  function A(f) {
+    let b = f, m = 0;
+    for (; b > 0; ) {
+      const y = h();
+      if (y === null) return;
+      m = m << 1 | y, --b;
+    }
+    return m;
+  }
+  function C(f) {
+    const b = A(f);
+    if (b !== void 0)
+      return b >= 1 << f - 1 ? b : b + (-1 << f) + 1;
+  }
+  function L(f, b) {
+    const m = E(f.huffmanTableDC);
+    if (m === null) throw new Error("Huffman error");
+    const y = m === 0 ? 0 : C(m);
+    if (y === void 0) throw new Error("Unexpected end of stream");
+    f.pred === void 0 && (f.pred = 0), f.pred += y, b[0] = f.pred;
+    let P = 1;
+    for (; P < 64; ) {
+      const U = E(f.huffmanTableAC);
+      if (U === null) throw new Error("Unexpected end of data in AC coefficient decoding");
+      const q = U & 15, T = U >> 4;
+      if (q === 0) {
+        if (T < 15) break;
+        P += 16;
+      } else {
+        P += T;
+        const I = O[P], j = C(q);
+        if (j === void 0) throw new Error("Unexpected end of stream");
+        b[I] = j, P++;
+      }
+    }
+  }
+  function o(f, b) {
+    const m = E(f.huffmanTableDC);
+    if (m === null) throw new Error("Huffman error");
+    const y = C(m);
+    if (y === void 0) throw new Error("Unexpected end of data in DC coefficient decoding");
+    const P = m === 0 ? 0 : y << a;
+    f.pred === void 0 && (f.pred = 0), f.pred += P, b[0] = f.pred;
+  }
+  function t(f, b) {
+    const m = h();
+    if (m === null) throw new Error("Unexpected end of data in DC coefficient decoding");
+    b[0] |= m << a;
+  }
+  let k = 0;
+  function n(f, b) {
+    if (k > 0) {
+      k--;
+      return;
+    }
+    let m = d;
+    const y = e;
+    for (; m <= y; ) {
+      const P = E(f.huffmanTableAC);
+      if (P === null) throw new Error("Unexpected end of data in AC coefficient decoding");
+      const U = P & 15, q = P >> 4;
+      if (U === 0) {
+        if (q < 15) {
+          const T = A(q);
+          if (T === void 0) throw new Error("Unexpected end of data in AC coefficient decoding");
+          k = T + (1 << q) - 1;
+          break;
+        }
+        m += 16;
+      } else {
+        m += q;
+        const T = O[m], I = C(U);
+        if (I === void 0) throw new Error("Unexpected end of data in AC coefficient decoding");
+        b[T] = I * (1 << a), m++;
+      }
+    }
+  }
+  let M = 0, ee;
+  function oe(f, b) {
+    let m = d;
+    const y = e;
+    let P = 0;
+    for (; m <= y; ) {
+      const U = O[m], q = b[U] < 0 ? -1 : 1;
+      switch (M) {
+        case 0: {
+          const T = E(f.huffmanTableAC);
+          if (T === null) throw new Error("Unexpected end of data in AC coefficient decoding");
+          const I = T & 15;
+          if (P = T >> 4, I === 0) if (P < 15) {
+            const j = A(P);
+            if (j === void 0) throw new Error("Unexpected end of data in AC coefficient decoding");
+            k = j + (1 << P), M = 4;
+          } else
+            P = 16, M = 1;
+          else {
+            if (I !== 1) throw new Error("invalid ACn encoding");
+            const j = C(I);
+            if (j === void 0) throw new Error("Unexpected end of data in AC coefficient decoding");
+            ee = j, M = P ? 2 : 3;
+          }
+          continue;
+        }
+        case 1:
+        case 2:
+          if (b[U]) {
+            const T = h();
+            if (T === null) throw new Error("Unexpected end of data in AC coefficient decoding");
+            b[U] += (T << a) * q;
+          } else
+            P--, P === 0 && (M = M === 2 ? 3 : 0);
+          break;
+        case 3:
+          if (b[U]) {
+            const T = h();
+            if (T === null) throw new Error("Unexpected end of data in AC coefficient decoding");
+            b[U] += (T << a) * q;
+          } else
+            b[U] = ee << a, M = 0;
+          break;
+        case 4:
+          if (b[U]) {
+            const T = h();
+            if (T === null) throw new Error("Unexpected end of data in AC coefficient decoding");
+            b[U] += (T << a) * q;
+          }
+          break;
+        default:
+          break;
+      }
+      m++;
+    }
+    M === 4 && (k--, k === 0 && (M = 0));
+  }
+  function re(f, b, m, y, P) {
+    const U = m / r | 0, q = m % r, T = U * f.v + y, I = q * f.h + P;
+    if (!f.blocks) throw new Error("Missing blocks");
+    b(f, f.blocks[T][I]);
+  }
+  function se(f, b, m) {
+    const y = m / f.blocksPerLine | 0, P = m % f.blocksPerLine;
+    if (!f.blocks) throw new Error("Missing blocks");
+    b(f, f.blocks[y][P]);
+  }
+  const G = v.length;
+  let B, S, N, X, H, F;
+  l ? d === 0 ? F = u === 0 ? o : t : F = u === 0 ? n : oe : F = L;
+  let R = 0, Y, J;
+  G === 1 ? J = v[0].blocksPerLine * v[0].blocksPerColumn : J = r * g.mcusPerColumn;
+  const ne = D || J;
+  for (; R < J; ) {
+    for (S = 0; S < G; S++) v[S].pred = 0;
+    if (k = 0, G === 1)
+      for (B = v[0], H = 0; H < ne; H++)
+        se(B, F, R), R++;
+    else for (H = 0; H < ne; H++) {
+      for (S = 0; S < G; S++) {
+        B = v[S];
+        const { h: f, v: b } = B;
+        for (N = 0; N < b; N++) for (X = 0; X < f; X++) re(B, F, R, N, X);
+      }
+      if (R++, R === J) break;
+    }
+    if (p = 0, Y = c[i] << 8 | c[i + 1], Y < 65280) throw new Error("marker was not found");
+    if (Y >= 65488 && Y <= 65495) i += 2;
+    else break;
+  }
+  return i - x;
+}
+function le(c) {
+  const s = [], { blocksPerLine: g, blocksPerColumn: v } = c;
+  if (!g || !v || !c.blocks) throw new Error("Missing component data");
+  const D = g << 3, d = new Int32Array(64), e = new Uint8Array(64);
+  function u(a, r, l) {
+    const x = c.quantizationTable;
+    if (!x) throw new Error("No quantization table found");
+    let i, w, p, h, E, A, C, L, o;
+    const t = l;
+    let k;
+    for (k = 0; k < 64; k++) t[k] = a[k] * x[k];
+    for (k = 0; k < 8; ++k) {
+      const n = 8 * k;
+      if (t[1 + n] === 0 && t[2 + n] === 0 && t[3 + n] === 0 && t[4 + n] === 0 && t[5 + n] === 0 && t[6 + n] === 0 && t[7 + n] === 0) {
+        o = V * t[0 + n] + 512 >> 10, t[0 + n] = o, t[1 + n] = o, t[2 + n] = o, t[3 + n] = o, t[4 + n] = o, t[5 + n] = o, t[6 + n] = o, t[7 + n] = o;
+        continue;
+      }
+      i = V * t[0 + n] + 128 >> 8, w = V * t[4 + n] + 128 >> 8, p = t[2 + n], h = t[6 + n], E = K * (t[1 + n] - t[7 + n]) + 128 >> 8, L = K * (t[1 + n] + t[7 + n]) + 128 >> 8, A = t[3 + n] << 4, C = t[5 + n] << 4, o = i - w + 1 >> 1, i = i + w + 1 >> 1, w = o, o = p * _ + h * W + 128 >> 8, p = p * W - h * _ + 128 >> 8, h = o, o = E - C + 1 >> 1, E = E + C + 1 >> 1, C = o, o = L + A + 1 >> 1, A = L - A + 1 >> 1, L = o, o = i - h + 1 >> 1, i = i + h + 1 >> 1, h = o, o = w - p + 1 >> 1, w = w + p + 1 >> 1, p = o, o = E * Q + L * z + 2048 >> 12, E = E * z - L * Q + 2048 >> 12, L = o, o = A * $ + C * Z + 2048 >> 12, A = A * Z - C * $ + 2048 >> 12, C = o, t[0 + n] = i + L, t[7 + n] = i - L, t[1 + n] = w + C, t[6 + n] = w - C, t[2 + n] = p + A, t[5 + n] = p - A, t[3 + n] = h + E, t[4 + n] = h - E;
+    }
+    for (k = 0; k < 8; ++k) {
+      const n = k;
+      if (t[8 + n] === 0 && t[16 + n] === 0 && t[24 + n] === 0 && t[32 + n] === 0 && t[40 + n] === 0 && t[48 + n] === 0 && t[56 + n] === 0) {
+        o = V * l[k + 0] + 8192 >> 14, t[0 + n] = o, t[8 + n] = o, t[16 + n] = o, t[24 + n] = o, t[32 + n] = o, t[40 + n] = o, t[48 + n] = o, t[56 + n] = o;
+        continue;
+      }
+      i = V * t[0 + n] + 2048 >> 12, w = V * t[32 + n] + 2048 >> 12, p = t[16 + n], h = t[48 + n], E = K * (t[8 + n] - t[56 + n]) + 2048 >> 12, L = K * (t[8 + n] + t[56 + n]) + 2048 >> 12, A = t[24 + n], C = t[40 + n], o = i - w + 1 >> 1, i = i + w + 1 >> 1, w = o, o = p * _ + h * W + 2048 >> 12, p = p * W - h * _ + 2048 >> 12, h = o, o = E - C + 1 >> 1, E = E + C + 1 >> 1, C = o, o = L + A + 1 >> 1, A = L - A + 1 >> 1, L = o, o = i - h + 1 >> 1, i = i + h + 1 >> 1, h = o, o = w - p + 1 >> 1, w = w + p + 1 >> 1, p = o, o = E * Q + L * z + 2048 >> 12, E = E * z - L * Q + 2048 >> 12, L = o, o = A * $ + C * Z + 2048 >> 12, A = A * Z - C * $ + 2048 >> 12, C = o, t[0 + n] = i + L, t[56 + n] = i - L, t[8 + n] = w + C, t[48 + n] = w - C, t[16 + n] = p + A, t[40 + n] = p - A, t[24 + n] = h + E, t[32 + n] = h - E;
+    }
+    for (k = 0; k < 64; ++k) {
+      const n = 128 + (t[k] + 8 >> 4);
+      n < 0 ? r[k] = 0 : n > 255 ? r[k] = 255 : r[k] = n;
+    }
+  }
+  for (let a = 0; a < v; a++) {
+    const r = a << 3;
+    for (let l = 0; l < 8; l++) s.push(new Uint8Array(D));
+    for (let l = 0; l < g; l++) {
+      u(c.blocks[a][l], e, d);
+      let x = 0;
+      const i = l << 3;
+      for (let w = 0; w < 8; w++) {
+        const p = s[r + w];
+        for (let h = 0; h < 8; h++) p[i + h] = e[x++];
+      }
+    }
+  }
+  return s;
+}
+var fe = class {
+  constructor() {
+    this.jfif = null, this.adobe = null, this.resetInterval = 0, this.quantizationTables = [], this.huffmanTablesAC = [], this.huffmanTablesDC = [], this.frames = [];
+  }
+  resetFrames() {
+    this.frames = [];
+  }
+  parse(c) {
+    let s = 0;
+    function g() {
+      const e = c[s] << 8 | c[s + 1];
+      return s += 2, e;
+    }
+    function v() {
+      const e = g(), u = c.subarray(s, s + e - 2);
+      return s += u.length, u;
+    }
+    function D(e) {
+      let u = 0, a = 0, r, l;
+      for (l in e.components) e.components.hasOwnProperty(l) && (r = e.components[l], u < r.h && (u = r.h), a < r.v && (a = r.v));
+      const x = Math.ceil(e.samplesPerLine / 8 / u), i = Math.ceil(e.scanLines / 8 / a);
+      for (l in e.components) if (e.components.hasOwnProperty(l)) {
+        r = e.components[l];
+        const w = Math.ceil(Math.ceil(e.samplesPerLine / 8) * r.h / u), p = Math.ceil(Math.ceil(e.scanLines / 8) * r.v / a), h = x * r.h, E = i * r.v, A = [];
+        for (let C = 0; C < E; C++) {
+          const L = [];
+          for (let o = 0; o < h; o++) L.push(new Int32Array(64));
+          A.push(L);
+        }
+        r.blocksPerLine = w, r.blocksPerColumn = p, r.blocks = A;
+      }
+      e.maxH = u, e.maxV = a, e.mcusPerLine = x, e.mcusPerColumn = i;
+    }
+    let d = g();
+    if (d !== 65496) throw new Error("SOI not found");
+    for (d = g(); d !== 65497; ) {
+      switch (d) {
+        case 65280:
+          break;
+        case 65504:
+        case 65505:
+        case 65506:
+        case 65507:
+        case 65508:
+        case 65509:
+        case 65510:
+        case 65511:
+        case 65512:
+        case 65513:
+        case 65514:
+        case 65515:
+        case 65516:
+        case 65517:
+        case 65518:
+        case 65519:
+        case 65534: {
+          const e = v();
+          d === 65504 && e[0] === 74 && e[1] === 70 && e[2] === 73 && e[3] === 70 && e[4] === 0 && (this.jfif = {
+            version: {
+              major: e[5],
+              minor: e[6]
+            },
+            densityUnits: e[7],
+            xDensity: e[8] << 8 | e[9],
+            yDensity: e[10] << 8 | e[11],
+            thumbWidth: e[12],
+            thumbHeight: e[13],
+            thumbData: e.subarray(14, 14 + 3 * e[12] * e[13])
+          }), d === 65518 && e[0] === 65 && e[1] === 100 && e[2] === 111 && e[3] === 98 && e[4] === 101 && e[5] === 0 && (this.adobe = {
+            version: e[6],
+            flags0: e[7] << 8 | e[8],
+            flags1: e[9] << 8 | e[10],
+            transformCode: e[11]
+          });
+          break;
+        }
+        case 65499: {
+          const e = g() + s - 2;
+          for (; s < e; ) {
+            const u = c[s++], a = new Int32Array(64);
+            if (u >> 4 === 0) for (let r = 0; r < 64; r++) {
+              const l = O[r];
+              a[l] = c[s++];
+            }
+            else if (u >> 4 === 1) for (let r = 0; r < 64; r++) {
+              const l = O[r];
+              a[l] = g();
+            }
+            else throw new Error("DQT: invalid table spec");
+            this.quantizationTables[u & 15] = a;
+          }
+          break;
+        }
+        case 65472:
+        case 65473:
+        case 65474: {
+          g();
+          const e = {
+            extended: d === 65473,
+            progressive: d === 65474,
+            precision: c[s++],
+            scanLines: g(),
+            samplesPerLine: g(),
+            components: {},
+            componentsOrder: [],
+            maxH: 0,
+            maxV: 0,
+            mcusPerLine: 0,
+            mcusPerColumn: 0
+          }, u = c[s++];
+          let a;
+          for (let r = 0; r < u; r++) {
+            a = c[s];
+            const l = c[s + 1] >> 4, x = c[s + 1] & 15, i = c[s + 2];
+            e.componentsOrder.push(a), e.components[a] = {
+              h: l,
+              v: x,
+              quantizationIdx: i,
+              blocksPerLine: 0,
+              blocksPerColumn: 0,
+              blocks: []
+            }, s += 3;
+          }
+          D(e), this.frames.push(e);
+          break;
+        }
+        case 65476: {
+          const e = g();
+          for (let u = 2; u < e; ) {
+            const a = c[s++], r = new Uint8Array(16);
+            let l = 0;
+            for (let i = 0; i < 16; i++, s++)
+              r[i] = c[s], l += r[i];
+            const x = new Uint8Array(l);
+            for (let i = 0; i < l; i++, s++) x[i] = c[s];
+            u += 17 + l, a >> 4 === 0 ? this.huffmanTablesDC[a & 15] = te(r, x) : this.huffmanTablesAC[a & 15] = te(r, x);
+          }
+          break;
+        }
+        case 65501:
+          g(), this.resetInterval = g();
+          break;
+        case 65498: {
+          g();
+          const e = c[s++], u = [], a = this.frames[0];
+          for (let w = 0; w < e; w++) {
+            const p = a.components[c[s++]], h = c[s++];
+            p.huffmanTableDC = this.huffmanTablesDC[h >> 4], p.huffmanTableAC = this.huffmanTablesAC[h & 15], u.push(p);
+          }
+          const r = c[s++], l = c[s++], x = c[s++], i = ce(c, s, a, u, this.resetInterval, r, l, x >> 4, x & 15);
+          s += i;
+          break;
+        }
+        case 65535:
+          c[s] !== 255 && s--;
+          break;
+        default:
+          if (c[s - 3] === 255 && c[s - 2] >= 192 && c[s - 2] <= 254) {
+            s -= 3;
+            break;
+          }
+          throw new Error(`unknown JPEG marker ${d.toString(16)}`);
+      }
+      d = g();
+    }
+  }
+  getResult() {
+    const { frames: c } = this;
+    if (this.frames.length === 0) throw new Error("no frames were decoded");
+    this.frames.length > 1 && console.warn("more than one frame is not supported");
+    for (let r = 0; r < this.frames.length; r++) {
+      const l = this.frames[r].components;
+      for (const x of Object.keys(l)) {
+        const i = l[x].quantizationIdx;
+        typeof i == "number" && (l[x].quantizationTable = this.quantizationTables[i], delete l[x].quantizationIdx);
+      }
+    }
+    const s = c[0];
+    if (!s.maxH || !s.maxV) throw new Error("Invalid frame dimensions");
+    const { components: g, componentsOrder: v } = s, D = [], d = s.samplesPerLine, e = s.scanLines;
+    for (let r = 0; r < v.length; r++) {
+      const l = g[v[r]];
+      D.push({
+        lines: le(l),
+        scaleX: l.h / s.maxH,
+        scaleY: l.v / s.maxV
+      });
+    }
+    const u = new Uint8Array(d * e * D.length);
+    let a = 0;
+    for (let r = 0; r < e; ++r) for (let l = 0; l < d; ++l) for (let x = 0; x < D.length; ++x) {
+      const i = D[x];
+      u[a] = i.lines[0 | r * i.scaleY][0 | l * i.scaleX], ++a;
+    }
+    return u;
+  }
+}, de = class extends ie {
+  constructor(c) {
+    super(c), this.reader = new fe(), c.JPEGTables && this.reader.parse(c.JPEGTables);
+  }
+  decodeBlock(c) {
+    return this.reader.resetFrames(), this.reader.parse(new Uint8Array(c)), this.reader.getResult().buffer;
+  }
+};
+export {
+  de as default
+};