{
  "version": 3,
  "sources": ["../../../node_modules/thumbhash/thumbhash.js", "../../javascript/placeholder_images.ts"],
  "sourcesContent": ["/**\n * Encodes an RGBA image to a ThumbHash. RGB should not be premultiplied by A.\n *\n * @param w The width of the input image. Must be \u2264100px.\n * @param h The height of the input image. Must be \u2264100px.\n * @param rgba The pixels in the input image, row-by-row. Must have w*h*4 elements.\n * @returns The ThumbHash as a Uint8Array.\n */\nexport function rgbaToThumbHash(w, h, rgba) {\n  // Encoding an image larger than 100x100 is slow with no benefit\n  if (w > 100 || h > 100) throw new Error(`${w}x${h} doesn't fit in 100x100`)\n  let { PI, round, max, cos, abs } = Math\n\n  // Determine the average color\n  let avg_r = 0, avg_g = 0, avg_b = 0, avg_a = 0\n  for (let i = 0, j = 0; i < w * h; i++, j += 4) {\n    let alpha = rgba[j + 3] / 255\n    avg_r += alpha / 255 * rgba[j]\n    avg_g += alpha / 255 * rgba[j + 1]\n    avg_b += alpha / 255 * rgba[j + 2]\n    avg_a += alpha\n  }\n  if (avg_a) {\n    avg_r /= avg_a\n    avg_g /= avg_a\n    avg_b /= avg_a\n  }\n\n  let hasAlpha = avg_a < w * h\n  let l_limit = hasAlpha ? 5 : 7 // Use fewer luminance bits if there's alpha\n  let lx = max(1, round(l_limit * w / max(w, h)))\n  let ly = max(1, round(l_limit * h / max(w, h)))\n  let l = [] // luminance\n  let p = [] // yellow - blue\n  let q = [] // red - green\n  let a = [] // alpha\n\n  // Convert the image from RGBA to LPQA (composite atop the average color)\n  for (let i = 0, j = 0; i < w * h; i++, j += 4) {\n    let alpha = rgba[j + 3] / 255\n    let r = avg_r * (1 - alpha) + alpha / 255 * rgba[j]\n    let g = avg_g * (1 - alpha) + alpha / 255 * rgba[j + 1]\n    let b = avg_b * (1 - alpha) + alpha / 255 * rgba[j + 2]\n    l[i] = (r + g + b) / 3\n    p[i] = (r + g) / 2 - b\n    q[i] = r - g\n    a[i] = alpha\n  }\n\n  // Encode using the DCT into DC (constant) and normalized AC (varying) terms\n  let encodeChannel = (channel, nx, ny) => {\n    let dc = 0, ac = [], scale = 0, fx = []\n    for (let cy = 0; cy < ny; cy++) {\n      for (let cx = 0; cx * ny < nx * (ny - cy); cx++) {\n        let f = 0\n        for (let x = 0; x < w; x++)\n          fx[x] = cos(PI / w * cx * (x + 0.5))\n        for (let y = 0; y < h; y++)\n          for (let x = 0, fy = cos(PI / h * cy * (y + 0.5)); x < w; x++)\n            f += channel[x + y * w] * fx[x] * fy\n        f /= w * h\n        if (cx || cy) {\n          ac.push(f)\n          scale = max(scale, abs(f))\n        } else {\n          dc = f\n        }\n      }\n    }\n    if (scale)\n      for (let i = 0; i < ac.length; i++)\n        ac[i] = 0.5 + 0.5 / scale * ac[i]\n    return [dc, ac, scale]\n  }\n  let [l_dc, l_ac, l_scale] = encodeChannel(l, max(3, lx), max(3, ly))\n  let [p_dc, p_ac, p_scale] = encodeChannel(p, 3, 3)\n  let [q_dc, q_ac, q_scale] = encodeChannel(q, 3, 3)\n  let [a_dc, a_ac, a_scale] = hasAlpha ? encodeChannel(a, 5, 5) : []\n\n  // Write the constants\n  let isLandscape = w > h\n  let header24 = round(63 * l_dc) | (round(31.5 + 31.5 * p_dc) << 6) | (round(31.5 + 31.5 * q_dc) << 12) | (round(31 * l_scale) << 18) | (hasAlpha << 23)\n  let header16 = (isLandscape ? ly : lx) | (round(63 * p_scale) << 3) | (round(63 * q_scale) << 9) | (isLandscape << 15)\n  let hash = [header24 & 255, (header24 >> 8) & 255, header24 >> 16, header16 & 255, header16 >> 8]\n  let ac_start = hasAlpha ? 6 : 5\n  let ac_index = 0\n  if (hasAlpha) hash.push(round(15 * a_dc) | (round(15 * a_scale) << 4))\n\n  // Write the varying factors\n  for (let ac of hasAlpha ? [l_ac, p_ac, q_ac, a_ac] : [l_ac, p_ac, q_ac])\n    for (let f of ac)\n      hash[ac_start + (ac_index >> 1)] |= round(15 * f) << ((ac_index++ & 1) << 2)\n  return new Uint8Array(hash)\n}\n\n/**\n * Decodes a ThumbHash to an RGBA image. RGB is not be premultiplied by A.\n *\n * @param hash The bytes of the ThumbHash.\n * @returns The width, height, and pixels of the rendered placeholder image.\n */\nexport function thumbHashToRGBA(hash) {\n  let { PI, min, max, cos, round } = Math\n\n  // Read the constants\n  let header24 = hash[0] | (hash[1] << 8) | (hash[2] << 16)\n  let header16 = hash[3] | (hash[4] << 8)\n  let l_dc = (header24 & 63) / 63\n  let p_dc = ((header24 >> 6) & 63) / 31.5 - 1\n  let q_dc = ((header24 >> 12) & 63) / 31.5 - 1\n  let l_scale = ((header24 >> 18) & 31) / 31\n  let hasAlpha = header24 >> 23\n  let p_scale = ((header16 >> 3) & 63) / 63\n  let q_scale = ((header16 >> 9) & 63) / 63\n  let isLandscape = header16 >> 15\n  let lx = max(3, isLandscape ? hasAlpha ? 5 : 7 : header16 & 7)\n  let ly = max(3, isLandscape ? header16 & 7 : hasAlpha ? 5 : 7)\n  let a_dc = hasAlpha ? (hash[5] & 15) / 15 : 1\n  let a_scale = (hash[5] >> 4) / 15\n\n  // Read the varying factors (boost saturation by 1.25x to compensate for quantization)\n  let ac_start = hasAlpha ? 6 : 5\n  let ac_index = 0\n  let decodeChannel = (nx, ny, scale) => {\n    let ac = []\n    for (let cy = 0; cy < ny; cy++)\n      for (let cx = cy ? 0 : 1; cx * ny < nx * (ny - cy); cx++)\n        ac.push((((hash[ac_start + (ac_index >> 1)] >> ((ac_index++ & 1) << 2)) & 15) / 7.5 - 1) * scale)\n    return ac\n  }\n  let l_ac = decodeChannel(lx, ly, l_scale)\n  let p_ac = decodeChannel(3, 3, p_scale * 1.25)\n  let q_ac = decodeChannel(3, 3, q_scale * 1.25)\n  let a_ac = hasAlpha && decodeChannel(5, 5, a_scale)\n\n  // Decode using the DCT into RGB\n  let ratio = thumbHashToApproximateAspectRatio(hash)\n  let w = round(ratio > 1 ? 32 : 32 * ratio)\n  let h = round(ratio > 1 ? 32 / ratio : 32)\n  let rgba = new Uint8Array(w * h * 4), fx = [], fy = []\n  for (let y = 0, i = 0; y < h; y++) {\n    for (let x = 0; x < w; x++, i += 4) {\n      let l = l_dc, p = p_dc, q = q_dc, a = a_dc\n\n      // Precompute the coefficients\n      for (let cx = 0, n = max(lx, hasAlpha ? 5 : 3); cx < n; cx++)\n        fx[cx] = cos(PI / w * (x + 0.5) * cx)\n      for (let cy = 0, n = max(ly, hasAlpha ? 5 : 3); cy < n; cy++)\n        fy[cy] = cos(PI / h * (y + 0.5) * cy)\n\n      // Decode L\n      for (let cy = 0, j = 0; cy < ly; cy++)\n        for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx * ly < lx * (ly - cy); cx++, j++)\n          l += l_ac[j] * fx[cx] * fy2\n\n      // Decode P and Q\n      for (let cy = 0, j = 0; cy < 3; cy++) {\n        for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx < 3 - cy; cx++, j++) {\n          let f = fx[cx] * fy2\n          p += p_ac[j] * f\n          q += q_ac[j] * f\n        }\n      }\n\n      // Decode A\n      if (hasAlpha)\n        for (let cy = 0, j = 0; cy < 5; cy++)\n          for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx < 5 - cy; cx++, j++)\n            a += a_ac[j] * fx[cx] * fy2\n\n      // Convert to RGB\n      let b = l - 2 / 3 * p\n      let r = (3 * l - b + q) / 2\n      let g = r - q\n      rgba[i] = max(0, 255 * min(1, r))\n      rgba[i + 1] = max(0, 255 * min(1, g))\n      rgba[i + 2] = max(0, 255 * min(1, b))\n      rgba[i + 3] = max(0, 255 * min(1, a))\n    }\n  }\n  return { w, h, rgba }\n}\n\n/**\n * Extracts the average color from a ThumbHash. RGB is not be premultiplied by A.\n *\n * @param hash The bytes of the ThumbHash.\n * @returns The RGBA values for the average color. Each value ranges from 0 to 1.\n */\nexport function thumbHashToAverageRGBA(hash) {\n  let { min, max } = Math\n  let header = hash[0] | (hash[1] << 8) | (hash[2] << 16)\n  let l = (header & 63) / 63\n  let p = ((header >> 6) & 63) / 31.5 - 1\n  let q = ((header >> 12) & 63) / 31.5 - 1\n  let hasAlpha = header >> 23\n  let a = hasAlpha ? (hash[5] & 15) / 15 : 1\n  let b = l - 2 / 3 * p\n  let r = (3 * l - b + q) / 2\n  let g = r - q\n  return {\n    r: max(0, min(1, r)),\n    g: max(0, min(1, g)),\n    b: max(0, min(1, b)),\n    a\n  }\n}\n\n/**\n * Extracts the approximate aspect ratio of the original image.\n *\n * @param hash The bytes of the ThumbHash.\n * @returns The approximate aspect ratio (i.e. width / height).\n */\nexport function thumbHashToApproximateAspectRatio(hash) {\n  let header = hash[3]\n  let hasAlpha = hash[2] & 0x80\n  let isLandscape = hash[4] & 0x80\n  let lx = isLandscape ? hasAlpha ? 5 : 7 : header & 7\n  let ly = isLandscape ? header & 7 : hasAlpha ? 5 : 7\n  return lx / ly\n}\n\n/**\n * Encodes an RGBA image to a PNG data URL. RGB should not be premultiplied by\n * A. This is optimized for speed and simplicity and does not optimize for size\n * at all. This doesn't do any compression (all values are stored uncompressed).\n *\n * @param w The width of the input image. Must be \u2264100px.\n * @param h The height of the input image. Must be \u2264100px.\n * @param rgba The pixels in the input image, row-by-row. Must have w*h*4 elements.\n * @returns A data URL containing a PNG for the input image.\n */\nexport function rgbaToDataURL(w, h, rgba) {\n  let row = w * 4 + 1\n  let idat = 6 + h * (5 + row)\n  let bytes = [\n    137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82, 0, 0,\n    w >> 8, w & 255, 0, 0, h >> 8, h & 255, 8, 6, 0, 0, 0, 0, 0, 0, 0,\n    idat >>> 24, (idat >> 16) & 255, (idat >> 8) & 255, idat & 255,\n    73, 68, 65, 84, 120, 1\n  ]\n  let table = [\n    0, 498536548, 997073096, 651767980, 1994146192, 1802195444, 1303535960,\n    1342533948, -306674912, -267414716, -690576408, -882789492, -1687895376,\n    -2032938284, -1609899400, -1111625188\n  ]\n  let a = 1, b = 0\n  for (let y = 0, i = 0, end = row - 1; y < h; y++, end += row - 1) {\n    bytes.push(y + 1 < h ? 0 : 1, row & 255, row >> 8, ~row & 255, (row >> 8) ^ 255, 0)\n    for (b = (b + a) % 65521; i < end; i++) {\n      let u = rgba[i] & 255\n      bytes.push(u)\n      a = (a + u) % 65521\n      b = (b + a) % 65521\n    }\n  }\n  bytes.push(\n    b >> 8, b & 255, a >> 8, a & 255, 0, 0, 0, 0,\n    0, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130\n  )\n  for (let [start, end] of [[12, 29], [37, 41 + idat]]) {\n    let c = ~0\n    for (let i = start; i < end; i++) {\n      c ^= bytes[i]\n      c = (c >>> 4) ^ table[c & 15]\n      c = (c >>> 4) ^ table[c & 15]\n    }\n    c = ~c\n    bytes[end++] = c >>> 24\n    bytes[end++] = (c >> 16) & 255\n    bytes[end++] = (c >> 8) & 255\n    bytes[end++] = c & 255\n  }\n  return 'data:image/png;base64,' + btoa(String.fromCharCode(...bytes))\n}\n\n/**\n * Decodes a ThumbHash to a PNG data URL. This is a convenience function that\n * just calls \"thumbHashToRGBA\" followed by \"rgbaToDataURL\".\n *\n * @param hash The bytes of the ThumbHash.\n * @returns A data URL containing a PNG for the rendered ThumbHash.\n */\nexport function thumbHashToDataURL(hash) {\n  let image = thumbHashToRGBA(hash)\n  return rgbaToDataURL(image.w, image.h, image.rgba)\n}\n", "import { thumbHashToDataURL } from \"thumbhash\";\n\nconst HASH_ATTRIBUTE_NAME = \"data-thumbhash\";\nconst BG_SIZE_ATTRIBUTE_NAME = \"data-hash-background-size\";\nconst BG_SIZE_DEFAULT = \"cover\"; // maintain aspect ratio\n\nprocessNode(document.querySelector(\"body\"));\n\nconst observer = new MutationObserver(onMutation);\nobserver.observe(document, {\n  subtree: true,\n  childList: true,\n});\n\nfunction onMutation(mutationList: MutationRecord[]) {\n  mutationList.forEach((mutation) => mutation.addedNodes.forEach(processNode));\n}\n\nfunction processNode(node: Node | null) {\n  if (node instanceof HTMLElement) {\n    const element = node as HTMLElement;\n    const elements = element.querySelectorAll(`[${HASH_ATTRIBUTE_NAME}]`);\n    elements.forEach((el) => setPlaceholder(el as HTMLElement));\n  }\n}\n\nfunction setPlaceholder(element: HTMLElement) {\n  const thumbhash = element.getAttribute(HASH_ATTRIBUTE_NAME);\n  if (thumbhash) {\n    const dataBackgroundSize = element.getAttribute(BG_SIZE_ATTRIBUTE_NAME);\n    const backgroundSize = dataBackgroundSize\n      ? dataBackgroundSize\n      : BG_SIZE_DEFAULT;\n    const dataUrl = thumbHashToDataURL(decodeBase64(thumbhash));\n\n    element.style.backgroundImage = `url(${dataUrl})`;\n    element.style.backgroundSize = backgroundSize;\n  }\n}\n\nfunction decodeBase64(base64: string): number[] {\n  return atob(base64)\n    .split(\"\")\n    .map((x) => x.charCodeAt(0));\n}\n"],
  "mappings": "mBAqGO,SAASA,EAAgBC,EAAM,CACpC,GAAI,CAAE,GAAAC,EAAI,IAAAC,EAAK,IAAAC,EAAK,IAAAC,EAAK,MAAAC,CAAM,EAAI,KAG/BC,EAAWN,EAAK,CAAC,EAAKA,EAAK,CAAC,GAAK,EAAMA,EAAK,CAAC,GAAK,GAClDO,EAAWP,EAAK,CAAC,EAAKA,EAAK,CAAC,GAAK,EACjCQ,GAAQF,EAAW,IAAM,GACzBG,GAASH,GAAY,EAAK,IAAM,KAAO,EACvCI,GAASJ,GAAY,GAAM,IAAM,KAAO,EACxCK,GAAYL,GAAY,GAAM,IAAM,GACpCM,EAAWN,GAAY,GACvBO,GAAYN,GAAY,EAAK,IAAM,GACnCO,GAAYP,GAAY,EAAK,IAAM,GACnCQ,EAAcR,GAAY,GAC1BS,EAAKb,EAAI,EAAGY,EAAcH,EAAW,EAAI,EAAIL,EAAW,CAAC,EACzDU,EAAKd,EAAI,EAAGY,EAAcR,EAAW,EAAIK,EAAW,EAAI,CAAC,EACzDM,EAAON,GAAYZ,EAAK,CAAC,EAAI,IAAM,GAAK,EACxCmB,GAAWnB,EAAK,CAAC,GAAK,GAAK,GAG3BoB,EAAWR,EAAW,EAAI,EAC1BS,EAAW,EACXC,EAAgB,CAACC,EAAIC,EAAIC,IAAU,CACrC,IAAIC,EAAK,CAAC,EACV,QAASC,EAAK,EAAGA,EAAKH,EAAIG,IACxB,QAASC,EAAKD,EAAK,EAAI,EAAGC,EAAKJ,EAAKD,GAAMC,EAAKG,GAAKC,IAClDF,EAAG,OAAQ1B,EAAKoB,GAAYC,GAAY,EAAE,KAAOA,IAAa,IAAM,GAAM,IAAM,IAAM,GAAKI,CAAK,EACpG,OAAOC,CACT,EACIG,EAAOP,EAAcN,EAAIC,EAAIN,CAAO,EACpCmB,EAAOR,EAAc,EAAG,EAAGT,EAAU,IAAI,EACzCkB,EAAOT,EAAc,EAAG,EAAGR,EAAU,IAAI,EACzCkB,EAAOpB,GAAYU,EAAc,EAAG,EAAGH,CAAO,EAG9Cc,EAAQC,EAAkClC,CAAI,EAC9CmC,EAAI9B,EAAM4B,EAAQ,EAAI,GAAK,GAAKA,CAAK,EACrCG,EAAI/B,EAAM4B,EAAQ,EAAI,GAAKA,EAAQ,EAAE,EACrCI,EAAO,IAAI,WAAWF,EAAIC,EAAI,CAAC,EAAGE,EAAK,CAAC,EAAGC,EAAK,CAAC,EACrD,QAASC,EAAI,EAAGC,EAAI,EAAGD,EAAIJ,EAAGI,IAC5B,QAASE,EAAI,EAAGA,EAAIP,EAAGO,IAAKD,GAAK,EAAG,CAClC,IAAIE,EAAInC,EAAMoC,EAAInC,EAAMoC,EAAInC,EAAMoC,EAAI5B,EAGtC,QAASU,EAAK,EAAGmB,EAAI5C,EAAIa,EAAIJ,EAAW,EAAI,CAAC,EAAGgB,EAAKmB,EAAGnB,IACtDU,EAAGV,CAAE,EAAIxB,EAAIH,EAAKkC,GAAKO,EAAI,IAAOd,CAAE,EACtC,QAASD,EAAK,EAAGoB,EAAI5C,EAAIc,EAAIL,EAAW,EAAI,CAAC,EAAGe,EAAKoB,EAAGpB,IACtDY,EAAGZ,CAAE,EAAIvB,EAAIH,EAAKmC,GAAKI,EAAI,IAAOb,CAAE,EAGtC,QAASA,EAAK,EAAGqB,EAAI,EAAGrB,EAAKV,EAAIU,IAC/B,QAASC,EAAKD,EAAK,EAAI,EAAGsB,EAAMV,EAAGZ,CAAE,EAAI,EAAGC,EAAKX,EAAKD,GAAMC,EAAKU,GAAKC,IAAMoB,IAC1EL,GAAKd,EAAKmB,CAAC,EAAIV,EAAGV,CAAE,EAAIqB,EAG5B,QAAStB,EAAK,EAAGqB,EAAI,EAAGrB,EAAK,EAAGA,IAC9B,QAASC,EAAKD,EAAK,EAAI,EAAGsB,EAAMV,EAAGZ,CAAE,EAAI,EAAGC,EAAK,EAAID,EAAIC,IAAMoB,IAAK,CAClE,IAAIE,EAAIZ,EAAGV,CAAE,EAAIqB,EACjBL,GAAKd,EAAKkB,CAAC,EAAIE,EACfL,GAAKd,EAAKiB,CAAC,EAAIE,CACjB,CAIF,GAAItC,EACF,QAASe,EAAK,EAAGqB,EAAI,EAAGrB,EAAK,EAAGA,IAC9B,QAASC,EAAKD,EAAK,EAAI,EAAGsB,EAAMV,EAAGZ,CAAE,EAAI,EAAGC,EAAK,EAAID,EAAIC,IAAMoB,IAC7DF,GAAKd,EAAKgB,CAAC,EAAIV,EAAGV,CAAE,EAAIqB,EAG9B,IAAIE,EAAIR,EAAI,EAAI,EAAIC,EAChBQ,GAAK,EAAIT,EAAIQ,EAAIN,GAAK,EACtBQ,EAAID,EAAIP,EACZR,EAAKI,CAAC,EAAItC,EAAI,EAAG,IAAMD,EAAI,EAAGkD,CAAC,CAAC,EAChCf,EAAKI,EAAI,CAAC,EAAItC,EAAI,EAAG,IAAMD,EAAI,EAAGmD,CAAC,CAAC,EACpChB,EAAKI,EAAI,CAAC,EAAItC,EAAI,EAAG,IAAMD,EAAI,EAAGiD,CAAC,CAAC,EACpCd,EAAKI,EAAI,CAAC,EAAItC,EAAI,EAAG,IAAMD,EAAI,EAAG4C,CAAC,CAAC,CACtC,CAEF,MAAO,CAAE,EAAAX,EAAG,EAAAC,EAAG,KAAAC,CAAK,CACtB,CAiCO,SAASiB,EAAkCC,EAAM,CACtD,IAAIC,EAASD,EAAK,CAAC,EACfE,EAAWF,EAAK,CAAC,EAAI,IACrBG,EAAcH,EAAK,CAAC,EAAI,IACxBI,EAAKD,EAAcD,EAAW,EAAI,EAAID,EAAS,EAC/CI,EAAKF,EAAcF,EAAS,EAAIC,EAAW,EAAI,EACnD,OAAOE,EAAKC,CACd,CAYO,SAASC,EAAcC,EAAGC,EAAGC,EAAM,CACxC,IAAIC,EAAMH,EAAI,EAAI,EACdI,EAAO,EAAIH,GAAK,EAAIE,GACpBE,EAAQ,CACV,IAAK,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,EAAG,EAAG,EAAG,GAAI,GAAI,GAAI,GAAI,GAAI,EAAG,EACjEL,GAAK,EAAGA,EAAI,IAAK,EAAG,EAAGC,GAAK,EAAGA,EAAI,IAAK,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAChEG,IAAS,GAAKA,GAAQ,GAAM,IAAMA,GAAQ,EAAK,IAAKA,EAAO,IAC3D,GAAI,GAAI,GAAI,GAAI,IAAK,CACvB,EACIE,EAAQ,CACV,EAAG,UAAW,UAAW,UAAW,WAAY,WAAY,WAC5D,WAAY,WAAY,WAAY,WAAY,WAAY,YAC5D,YAAa,YAAa,WAC5B,EACIC,EAAI,EAAGC,EAAI,EACf,QAASC,EAAI,EAAGC,EAAI,EAAGC,EAAMR,EAAM,EAAGM,EAAIR,EAAGQ,IAAKE,GAAOR,EAAM,EAE7D,IADAE,EAAM,KAAKI,EAAI,EAAIR,EAAI,EAAI,EAAGE,EAAM,IAAKA,GAAO,EAAG,CAACA,EAAM,IAAMA,GAAO,EAAK,IAAK,CAAC,EAC7EK,GAAKA,EAAID,GAAK,MAAOG,EAAIC,EAAKD,IAAK,CACtC,IAAIE,EAAIV,EAAKQ,CAAC,EAAI,IAClBL,EAAM,KAAKO,CAAC,EACZL,GAAKA,EAAIK,GAAK,MACdJ,GAAKA,EAAID,GAAK,KAChB,CAEFF,EAAM,KACJG,GAAK,EAAGA,EAAI,IAAKD,GAAK,EAAGA,EAAI,IAAK,EAAG,EAAG,EAAG,EAC3C,EAAG,EAAG,EAAG,EAAG,GAAI,GAAI,GAAI,GAAI,IAAK,GAAI,GAAI,GAC3C,EACA,OAAS,CAACM,EAAOF,CAAG,GAAK,CAAC,CAAC,GAAI,EAAE,EAAG,CAAC,GAAI,GAAKP,CAAI,CAAC,EAAG,CACpD,IAAIU,EAAI,GACR,QAASJ,EAAIG,EAAOH,EAAIC,EAAKD,IAC3BI,GAAKT,EAAMK,CAAC,EACZI,EAAKA,IAAM,EAAKR,EAAMQ,EAAI,EAAE,EAC5BA,EAAKA,IAAM,EAAKR,EAAMQ,EAAI,EAAE,EAE9BA,EAAI,CAACA,EACLT,EAAMM,GAAK,EAAIG,IAAM,GACrBT,EAAMM,GAAK,EAAKG,GAAK,GAAM,IAC3BT,EAAMM,GAAK,EAAKG,GAAK,EAAK,IAC1BT,EAAMM,GAAK,EAAIG,EAAI,GACrB,CACA,MAAO,yBAA2B,KAAK,OAAO,aAAa,GAAGT,CAAK,CAAC,CACtE,CASO,SAASU,EAAmBtB,EAAM,CACvC,IAAIuB,EAAQC,EAAgBxB,CAAI,EAChC,OAAOM,EAAciB,EAAM,EAAGA,EAAM,EAAGA,EAAM,IAAI,CACnD,CC7RA,IAAME,EAAsB,iBACtBC,GAAyB,4BACzBC,GAAkB,QAExBC,EAAY,SAAS,cAAc,MAAM,CAAC,EAE1C,IAAMC,GAAW,IAAI,iBAAiBC,EAAU,EAChDD,GAAS,QAAQ,SAAU,CACzB,QAAS,GACT,UAAW,EACb,CAAC,EAED,SAASC,GAAWC,EAAgC,CAClDA,EAAa,QAASC,GAAaA,EAAS,WAAW,QAAQJ,CAAW,CAAC,CAC7E,CAEA,SAASA,EAAYK,EAAmB,CAClCA,aAAgB,aACFA,EACS,iBAAiB,IAAIR,CAAmB,GAAG,EAC3D,QAASS,GAAOC,GAAeD,CAAiB,CAAC,CAE9D,CAEA,SAASC,GAAeC,EAAsB,CAC5C,IAAMC,EAAYD,EAAQ,aAAaX,CAAmB,EAC1D,GAAIY,EAAW,CACb,IAAMC,EAAqBF,EAAQ,aAAaV,EAAsB,EAChEa,EAAiBD,GAEnBX,GACEa,EAAUC,EAAmBC,GAAaL,CAAS,CAAC,EAE1DD,EAAQ,MAAM,gBAAkB,OAAOI,CAAO,IAC9CJ,EAAQ,MAAM,eAAiBG,CACjC,CACF,CAEA,SAASG,GAAaC,EAA0B,CAC9C,OAAO,KAAKA,CAAM,EACf,MAAM,EAAE,EACR,IAAKC,GAAMA,EAAE,WAAW,CAAC,CAAC,CAC/B",
  "names": ["thumbHashToRGBA", "hash", "PI", "min", "max", "cos", "round", "header24", "header16", "l_dc", "p_dc", "q_dc", "l_scale", "hasAlpha", "p_scale", "q_scale", "isLandscape", "lx", "ly", "a_dc", "a_scale", "ac_start", "ac_index", "decodeChannel", "nx", "ny", "scale", "ac", "cy", "cx", "l_ac", "p_ac", "q_ac", "a_ac", "ratio", "thumbHashToApproximateAspectRatio", "w", "h", "rgba", "fx", "fy", "y", "i", "x", "l", "p", "q", "a", "n", "j", "fy2", "f", "b", "r", "g", "thumbHashToApproximateAspectRatio", "hash", "header", "hasAlpha", "isLandscape", "lx", "ly", "rgbaToDataURL", "w", "h", "rgba", "row", "idat", "bytes", "table", "a", "b", "y", "i", "end", "u", "start", "c", "thumbHashToDataURL", "image", "thumbHashToRGBA", "HASH_ATTRIBUTE_NAME", "BG_SIZE_ATTRIBUTE_NAME", "BG_SIZE_DEFAULT", "processNode", "observer", "onMutation", "mutationList", "mutation", "node", "el", "setPlaceholder", "element", "thumbhash", "dataBackgroundSize", "backgroundSize", "dataUrl", "thumbHashToDataURL", "decodeBase64", "base64", "x"]
}