async function runIndexLoader() {
  async function loadAndAppendResource(resource) {
    const { type, content, module } = resource;
    return new Promise((resolve, reject) => {
      let node;
      switch (type) {
        case "js":
          node = document.createElement("script");
          node.textContent = content;
          if (module) {
            node.type = "module";
          }
          break;
        case "css":
          node = document.createElement("style");
          node.textContent = content;
          break;
        case "html":
          node = document.createElement("div");
          node.innerHTML = content;
          break;
        default:
          return reject(new Error(`Unknown resource type: ${type}`));
      }
      document.body.appendChild(node);
      resolve();
    });
  }

  function setFavicon(path) {
    try {
      let link =
        document.querySelector("link[rel*='icon']") ||
        document.createElement("link");
      link.type = "image/x-icon";
      link.rel = "shortcut icon";
      link.href = path;
      document.getElementsByTagName("head")[0].appendChild(link);
    } catch (error) {
      console.error(`Failed to set favicon: ${error}`);
    }
  }

  async function pathToContents(path) {
    try {
      const response = await fetch(path);
      return response.text();
    } catch (error) {
      console.error(`Failed to fetch from path ${path}: ${error}`);
    }
  }

  async function createWebWorker(workerUrl, libraryScripts) {
    const response = await fetch(workerUrl);
    const workerScriptText = await response.text();

    if (typeof libraryScripts === "string") {
      libraryScripts = [libraryScripts];
    }
    const combinedScriptText = [...libraryScripts, workerScriptText].join("\n");

    const workerDataURL = `data:text/javascript;base64,${btoa(
      combinedScriptText
    )}`;

    return new Promise((resolve, reject) => {
      const worker = new Worker(workerDataURL);

      worker.onmessage = function (event) {
        if (event.data === "READY") {
          resolve(worker);
        }
      };
      worker.onerror = function (event) {
        reject(event.message);
      };
    });
  }

  async function decompressResource(compressionType, compressedFilePath) {
    return new Promise((resolve, reject) => {
      let worker;
      switch (compressionType) {
        case "gunzip":
          worker = gunzipWorker;
          break;
        case "brotli":
          worker = brotliWorker;
          break;
        default:
          return reject(
            new Error(`Unknown compression type: ${compressionType}`)
          );
      }

      worker.onmessage = function (event) {
        if (event.data.error) {
          reject(
            new Error(
              `${compressionType} decompression failed for ${compressedFilePath}: ${event.data.error}`
            )
          );
        } else {
          const textDecoder = new TextDecoder();
          resolve(textDecoder.decode(new Uint8Array(event.data)));
        }
      };

      worker.onerror = function (event) {
        reject(event.message);
      };

      fetch(compressedFilePath)
        .then((response) => response.arrayBuffer())
        .then((arrayBuffer) => {
          const arrayBufferView = new Uint8Array(arrayBuffer);
          worker.postMessage(arrayBufferView.buffer, [arrayBufferView.buffer]);
        })
        .catch((error) => {
          reject(error);
        });
    });
  }

  async function webWorkerLoader() {
    const gunzipLib = await pathToContents(
      "/content/b732bbbd8108d9df790c839ffb27002bb02d0c106cca8876b66aa768ba0ba59ci0"
    );
    gunzipWorker = await createWebWorker(
      "/content/f56c5eeb35d9b702fc69eef78dbf2dd935f43aea857bdf6c64bb09628a0c446ai0",
      gunzipLib
    );
    const brotliDecoderLib = await decompressResource(
      "gunzip",
      "/content/8429c4cc97f31550833537351602484b62e1390598b766548cf4d98eb577a4c5i0"
    );
    gunzipWorker.terminate();
    gunzipWorker = null;
    brotliWorker = await createWebWorker(
      "/content/343ad4a0ccc36700183d2a35f3eef84878195c826400152cd07219327c53af53i0",
      brotliDecoderLib
    );
  }

  async function indexLoaderStart() {
    try {
      setFavicon(favicon);

      await webWorkerLoader();

      for (const pageResource of pageResources) {
        try {
          let content;
          if (pageResource.compression && pageResource.compression !== "none") {
            content = await decompressResource(
              pageResource.compression,
              pageResource.path
            );
          } else {
            content = await pathToContents(pageResource.path);
          }
          pageResource.content = content;
          await loadAndAppendResource(pageResource);
          console.log(`loaded ${pageResource.name}`);
        } catch (error) {
          console.error(`Failed to load ${pageResource.name}: ${error}`);
        }
      }
    } finally {
      if (brotliWorker) {
        brotliWorker.terminate();
        brotliWorker = null;
      }
    }
  }

  let brotliWorker = null;
  let gunzipWorker = null;

  const favicon =
    "/content/ce128421ee72f6d9509be77a934a2ad58964d80781bb38b38ad1a5fd4cc3e0ddi0";

  const pageResources = [
    {
      name: "three.min.js.br",
      path: "/content/3dc3639944963ee65896e9d175cb59983fcaee453efcd3e2b031d079afe81484i0",
      type: "js",
      compression: "brotli",
    },
    {
      name: "index.js",
      path: "/content/c1750f4aad29d973cedc5d4298c396b962eec42c5d7ca39ece45027b0fc5aea4i0",
      type: "js",
      compression: "none",
    },
  ];

  await indexLoaderStart();
  window.dispatchEvent(new Event("indexLoaderComplete"));
}

(async function () {
  await runIndexLoader();
})();