`.
+ *
+ * This will load the engine if it is not loaded, and preload the main pck.
+ *
+ * This method expects the initial config (or the override) to have both the :js:attr:`executable` and :js:attr:`mainPack`
+ * properties set (normally done by the editor during export).
+ *
+ * @param {EngineConfig} override An optional configuration override.
+ * @return {Promise} Promise that resolves once the game started.
+ */
+ startGame: function (override) {
+ this.config.update(override);
+ // Add main-pack argument.
+ const exe = this.config.executable;
+ const pack = this.config.mainPack || `${exe}.pck`;
+ this.config.args = ['--main-pack', pack].concat(this.config.args);
+ // Start and init with execName as loadPath if not inited.
+ const me = this;
+ return Promise.all([
+ this.init(exe),
+ this.preloadFile(pack, pack),
+ ]).then(function () {
+ return me.start.apply(me);
+ });
+ },
+
+ /**
+ * Create a file at the specified ``path`` with the passed as ``buffer`` in the instance's file system.
+ *
+ * @param {string} path The location where the file will be created.
+ * @param {ArrayBuffer} buffer The content of the file.
+ */
+ copyToFS: function (path, buffer) {
+ if (this.rtenv == null) {
+ throw new Error('Engine must be inited before copying files');
+ }
+ this.rtenv['copyToFS'](path, buffer);
+ },
+
+ /**
+ * Request that the current instance quit.
+ *
+ * This is akin the user pressing the close button in the window manager, and will
+ * have no effect if the engine has crashed, or is stuck in a loop.
+ *
+ */
+ requestQuit: function () {
+ if (this.rtenv) {
+ this.rtenv['request_quit']();
+ }
+ },
+
+ /**
+ * Install the progressive-web app service worker.
+ * @returns {Promise} The service worker registration promise.
+ */
+ installServiceWorker: function () {
+ if (this.config.serviceWorker && 'serviceWorker' in navigator) {
+ return navigator.serviceWorker.register(this.config.serviceWorker);
+ }
+ return Promise.resolve();
+ },
+ };
+
+ Engine.prototype = proto;
+ // Closure compiler exported instance methods.
+ Engine.prototype['init'] = Engine.prototype.init;
+ Engine.prototype['preloadFile'] = Engine.prototype.preloadFile;
+ Engine.prototype['start'] = Engine.prototype.start;
+ Engine.prototype['startGame'] = Engine.prototype.startGame;
+ Engine.prototype['copyToFS'] = Engine.prototype.copyToFS;
+ Engine.prototype['requestQuit'] = Engine.prototype.requestQuit;
+ Engine.prototype['installServiceWorker'] = Engine.prototype.installServiceWorker;
+ // Also expose static methods as instance methods
+ Engine.prototype['load'] = Engine.load;
+ Engine.prototype['unload'] = Engine.unload;
+ return new Engine(initConfig);
+ }
+
+ // Closure compiler exported static methods.
+ SafeEngine['load'] = Engine.load;
+ SafeEngine['unload'] = Engine.unload;
+
+ // Feature-detection utilities.
+ SafeEngine['isWebGLAvailable'] = Features.isWebGLAvailable;
+ SafeEngine['isFetchAvailable'] = Features.isFetchAvailable;
+ SafeEngine['isSecureContext'] = Features.isSecureContext;
+ SafeEngine['isCrossOriginIsolated'] = Features.isCrossOriginIsolated;
+ SafeEngine['isSharedArrayBufferAvailable'] = Features.isSharedArrayBufferAvailable;
+ SafeEngine['isAudioWorkletAvailable'] = Features.isAudioWorkletAvailable;
+ SafeEngine['getMissingFeatures'] = Features.getMissingFeatures;
+
+ return SafeEngine;
+}());
+if (typeof window !== 'undefined') {
+ window['Engine'] = Engine;
+}
diff --git a/early_access/index.manifest.json b/early_access/index.manifest.json
new file mode 100644
index 00000000000..35e5a39f2f0
--- /dev/null
+++ b/early_access/index.manifest.json
@@ -0,0 +1 @@
+{"background_color":"#000000","display":"standalone","icons":[{"sizes":"144x144","src":"index.144x144.png","type":"image/png"},{"sizes":"180x180","src":"index.180x180.png","type":"image/png"},{"sizes":"512x512","src":"index.512x512.png","type":"image/png"}],"name":"Pixelorama","orientation":"any","start_url":"./index.html"}
\ No newline at end of file
diff --git a/early_access/index.offline.html b/early_access/index.offline.html
new file mode 100644
index 00000000000..ae5298ae46e
--- /dev/null
+++ b/early_access/index.offline.html
@@ -0,0 +1,41 @@
+
+
+
+
+
+
+ You are offline
+
+
+
+ You are offline
+ This application requires an Internet connection to run for the first time.
+ Press the button below to try reloading:
+
+
+
+
diff --git a/early_access/index.pck b/early_access/index.pck
new file mode 100644
index 00000000000..83be6239035
Binary files /dev/null and b/early_access/index.pck differ
diff --git a/early_access/index.png b/early_access/index.png
new file mode 100644
index 00000000000..2c6a3259509
Binary files /dev/null and b/early_access/index.png differ
diff --git a/early_access/index.service.worker.js b/early_access/index.service.worker.js
new file mode 100644
index 00000000000..865cdd8db76
--- /dev/null
+++ b/early_access/index.service.worker.js
@@ -0,0 +1,166 @@
+// This service worker is required to expose an exported Godot project as a
+// Progressive Web App. It provides an offline fallback page telling the user
+// that they need an Internet connection to run the project if desired.
+// Incrementing CACHE_VERSION will kick off the install event and force
+// previously cached resources to be updated from the network.
+/** @type {string} */
+const CACHE_VERSION = '1729846067|8313341';
+/** @type {string} */
+const CACHE_PREFIX = 'Pixelorama-sw-cache-';
+const CACHE_NAME = CACHE_PREFIX + CACHE_VERSION;
+/** @type {string} */
+const OFFLINE_URL = 'index.offline.html';
+/** @type {boolean} */
+const ENSURE_CROSSORIGIN_ISOLATION_HEADERS = true;
+// Files that will be cached on load.
+/** @type {string[]} */
+const CACHED_FILES = ["index.html","index.js","index.offline.html","index.icon.png","index.apple-touch-icon.png","index.worker.js","index.audio.worklet.js"];
+// Files that we might not want the user to preload, and will only be cached on first load.
+/** @type {string[]} */
+const CACHABLE_FILES = ["index.wasm","index.pck"];
+const FULL_CACHE = CACHED_FILES.concat(CACHABLE_FILES);
+
+self.addEventListener('install', (event) => {
+ event.waitUntil(caches.open(CACHE_NAME).then((cache) => cache.addAll(CACHED_FILES)));
+});
+
+self.addEventListener('activate', (event) => {
+ event.waitUntil(caches.keys().then(
+ function (keys) {
+ // Remove old caches.
+ return Promise.all(keys.filter((key) => key.startsWith(CACHE_PREFIX) && key !== CACHE_NAME).map((key) => caches.delete(key)));
+ }
+ ).then(function () {
+ // Enable navigation preload if available.
+ return ('navigationPreload' in self.registration) ? self.registration.navigationPreload.enable() : Promise.resolve();
+ }));
+});
+
+/**
+ * Ensures that the response has the correct COEP/COOP headers
+ * @param {Response} response
+ * @returns {Response}
+ */
+function ensureCrossOriginIsolationHeaders(response) {
+ if (response.headers.get('Cross-Origin-Embedder-Policy') === 'require-corp'
+ && response.headers.get('Cross-Origin-Opener-Policy') === 'same-origin') {
+ return response;
+ }
+
+ const crossOriginIsolatedHeaders = new Headers(response.headers);
+ crossOriginIsolatedHeaders.set('Cross-Origin-Embedder-Policy', 'require-corp');
+ crossOriginIsolatedHeaders.set('Cross-Origin-Opener-Policy', 'same-origin');
+ const newResponse = new Response(response.body, {
+ status: response.status,
+ statusText: response.statusText,
+ headers: crossOriginIsolatedHeaders,
+ });
+
+ return newResponse;
+}
+
+/**
+ * Calls fetch and cache the result if it is cacheable
+ * @param {FetchEvent} event
+ * @param {Cache} cache
+ * @param {boolean} isCacheable
+ * @returns {Response}
+ */
+async function fetchAndCache(event, cache, isCacheable) {
+ // Use the preloaded response, if it's there
+ /** @type { Response } */
+ let response = await event.preloadResponse;
+ if (response == null) {
+ // Or, go over network.
+ response = await self.fetch(event.request);
+ }
+
+ if (ENSURE_CROSSORIGIN_ISOLATION_HEADERS) {
+ response = ensureCrossOriginIsolationHeaders(response);
+ }
+
+ if (isCacheable) {
+ // And update the cache
+ cache.put(event.request, response.clone());
+ }
+
+ return response;
+}
+
+self.addEventListener(
+ 'fetch',
+ /**
+ * Triggered on fetch
+ * @param {FetchEvent} event
+ */
+ (event) => {
+ const isNavigate = event.request.mode === 'navigate';
+ const url = event.request.url || '';
+ const referrer = event.request.referrer || '';
+ const base = referrer.slice(0, referrer.lastIndexOf('/') + 1);
+ const local = url.startsWith(base) ? url.replace(base, '') : '';
+ const isCachable = FULL_CACHE.some((v) => v === local) || (base === referrer && base.endsWith(CACHED_FILES[0]));
+ if (isNavigate || isCachable) {
+ event.respondWith((async () => {
+ // Try to use cache first
+ const cache = await caches.open(CACHE_NAME);
+ if (isNavigate) {
+ // Check if we have full cache during HTML page request.
+ /** @type {Response[]} */
+ const fullCache = await Promise.all(FULL_CACHE.map((name) => cache.match(name)));
+ const missing = fullCache.some((v) => v === undefined);
+ if (missing) {
+ try {
+ // Try network if some cached file is missing (so we can display offline page in case).
+ const response = await fetchAndCache(event, cache, isCachable);
+ return response;
+ } catch (e) {
+ // And return the hopefully always cached offline page in case of network failure.
+ console.error('Network error: ', e); // eslint-disable-line no-console
+ return caches.match(OFFLINE_URL);
+ }
+ }
+ }
+ let cached = await cache.match(event.request);
+ if (cached != null) {
+ if (ENSURE_CROSSORIGIN_ISOLATION_HEADERS) {
+ cached = ensureCrossOriginIsolationHeaders(cached);
+ }
+ return cached;
+ }
+ // Try network if don't have it in cache.
+ const response = await fetchAndCache(event, cache, isCachable);
+ return response;
+ })());
+ } else if (ENSURE_CROSSORIGIN_ISOLATION_HEADERS) {
+ event.respondWith((async () => {
+ let response = await fetch(event.request);
+ response = ensureCrossOriginIsolationHeaders(response);
+ return response;
+ })());
+ }
+ }
+);
+
+self.addEventListener('message', (event) => {
+ // No cross origin
+ if (event.origin !== self.origin) {
+ return;
+ }
+ const id = event.source.id || '';
+ const msg = event.data || '';
+ // Ensure it's one of our clients.
+ self.clients.get(id).then(function (client) {
+ if (!client) {
+ return; // Not a valid client.
+ }
+ if (msg === 'claim') {
+ self.skipWaiting().then(() => self.clients.claim());
+ } else if (msg === 'clear') {
+ caches.delete(CACHE_NAME);
+ } else if (msg === 'update') {
+ self.skipWaiting().then(() => self.clients.claim()).then(() => self.clients.matchAll()).then((all) => all.forEach((c) => c.navigate(c.url)));
+ }
+ });
+});
+
diff --git a/early_access/index.wasm b/early_access/index.wasm
new file mode 100644
index 00000000000..f663665cd96
Binary files /dev/null and b/early_access/index.wasm differ
diff --git a/index.144x144.png b/index.144x144.png
new file mode 100644
index 00000000000..5e65f72f81c
Binary files /dev/null and b/index.144x144.png differ
diff --git a/index.180x180.png b/index.180x180.png
new file mode 100644
index 00000000000..87c545ffe8f
Binary files /dev/null and b/index.180x180.png differ
diff --git a/index.512x512.png b/index.512x512.png
new file mode 100644
index 00000000000..20749934e55
Binary files /dev/null and b/index.512x512.png differ
diff --git a/index.apple-touch-icon.png b/index.apple-touch-icon.png
new file mode 100644
index 00000000000..87c545ffe8f
Binary files /dev/null and b/index.apple-touch-icon.png differ
diff --git a/index.audio.worklet.js b/index.audio.worklet.js
new file mode 100644
index 00000000000..3b94cab85cb
--- /dev/null
+++ b/index.audio.worklet.js
@@ -0,0 +1,213 @@
+/**************************************************************************/
+/* audio.worklet.js */
+/**************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/**************************************************************************/
+
+class RingBuffer {
+ constructor(p_buffer, p_state, p_threads) {
+ this.buffer = p_buffer;
+ this.avail = p_state;
+ this.threads = p_threads;
+ this.rpos = 0;
+ this.wpos = 0;
+ }
+
+ data_left() {
+ return this.threads ? Atomics.load(this.avail, 0) : this.avail;
+ }
+
+ space_left() {
+ return this.buffer.length - this.data_left();
+ }
+
+ read(output) {
+ const size = this.buffer.length;
+ let from = 0;
+ let to_write = output.length;
+ if (this.rpos + to_write > size) {
+ const high = size - this.rpos;
+ output.set(this.buffer.subarray(this.rpos, size));
+ from = high;
+ to_write -= high;
+ this.rpos = 0;
+ }
+ if (to_write) {
+ output.set(this.buffer.subarray(this.rpos, this.rpos + to_write), from);
+ }
+ this.rpos += to_write;
+ if (this.threads) {
+ Atomics.add(this.avail, 0, -output.length);
+ Atomics.notify(this.avail, 0);
+ } else {
+ this.avail -= output.length;
+ }
+ }
+
+ write(p_buffer) {
+ const to_write = p_buffer.length;
+ const mw = this.buffer.length - this.wpos;
+ if (mw >= to_write) {
+ this.buffer.set(p_buffer, this.wpos);
+ this.wpos += to_write;
+ if (mw === to_write) {
+ this.wpos = 0;
+ }
+ } else {
+ const high = p_buffer.subarray(0, mw);
+ const low = p_buffer.subarray(mw);
+ this.buffer.set(high, this.wpos);
+ this.buffer.set(low);
+ this.wpos = low.length;
+ }
+ if (this.threads) {
+ Atomics.add(this.avail, 0, to_write);
+ Atomics.notify(this.avail, 0);
+ } else {
+ this.avail += to_write;
+ }
+ }
+}
+
+class GodotProcessor extends AudioWorkletProcessor {
+ constructor() {
+ super();
+ this.threads = false;
+ this.running = true;
+ this.lock = null;
+ this.notifier = null;
+ this.output = null;
+ this.output_buffer = new Float32Array();
+ this.input = null;
+ this.input_buffer = new Float32Array();
+ this.port.onmessage = (event) => {
+ const cmd = event.data['cmd'];
+ const data = event.data['data'];
+ this.parse_message(cmd, data);
+ };
+ }
+
+ process_notify() {
+ if (this.notifier) {
+ Atomics.add(this.notifier, 0, 1);
+ Atomics.notify(this.notifier, 0);
+ }
+ }
+
+ parse_message(p_cmd, p_data) {
+ if (p_cmd === 'start' && p_data) {
+ const state = p_data[0];
+ let idx = 0;
+ this.threads = true;
+ this.lock = state.subarray(idx, ++idx);
+ this.notifier = state.subarray(idx, ++idx);
+ const avail_in = state.subarray(idx, ++idx);
+ const avail_out = state.subarray(idx, ++idx);
+ this.input = new RingBuffer(p_data[1], avail_in, true);
+ this.output = new RingBuffer(p_data[2], avail_out, true);
+ } else if (p_cmd === 'stop') {
+ this.running = false;
+ this.output = null;
+ this.input = null;
+ this.lock = null;
+ this.notifier = null;
+ } else if (p_cmd === 'start_nothreads') {
+ this.output = new RingBuffer(p_data[0], p_data[0].length, false);
+ } else if (p_cmd === 'chunk') {
+ this.output.write(p_data);
+ }
+ }
+
+ static array_has_data(arr) {
+ return arr.length && arr[0].length && arr[0][0].length;
+ }
+
+ process(inputs, outputs, parameters) {
+ if (!this.running) {
+ return false; // Stop processing.
+ }
+ if (this.output === null) {
+ return true; // Not ready yet, keep processing.
+ }
+ const process_input = GodotProcessor.array_has_data(inputs);
+ if (process_input) {
+ const input = inputs[0];
+ const chunk = input[0].length * input.length;
+ if (this.input_buffer.length !== chunk) {
+ this.input_buffer = new Float32Array(chunk);
+ }
+ if (!this.threads) {
+ GodotProcessor.write_input(this.input_buffer, input);
+ this.port.postMessage({ 'cmd': 'input', 'data': this.input_buffer });
+ } else if (this.input.space_left() >= chunk) {
+ GodotProcessor.write_input(this.input_buffer, input);
+ this.input.write(this.input_buffer);
+ } else {
+ // this.port.postMessage('Input buffer is full! Skipping input frame.'); // Uncomment this line to debug input buffer.
+ }
+ }
+ const process_output = GodotProcessor.array_has_data(outputs);
+ if (process_output) {
+ const output = outputs[0];
+ const chunk = output[0].length * output.length;
+ if (this.output_buffer.length !== chunk) {
+ this.output_buffer = new Float32Array(chunk);
+ }
+ if (this.output.data_left() >= chunk) {
+ this.output.read(this.output_buffer);
+ GodotProcessor.write_output(output, this.output_buffer);
+ if (!this.threads) {
+ this.port.postMessage({ 'cmd': 'read', 'data': chunk });
+ }
+ } else {
+ // this.port.postMessage('Output buffer has not enough frames! Skipping output frame.'); // Uncomment this line to debug output buffer.
+ }
+ }
+ this.process_notify();
+ return true;
+ }
+
+ static write_output(dest, source) {
+ const channels = dest.length;
+ for (let ch = 0; ch < channels; ch++) {
+ for (let sample = 0; sample < dest[ch].length; sample++) {
+ dest[ch][sample] = source[sample * channels + ch];
+ }
+ }
+ }
+
+ static write_input(dest, source) {
+ const channels = source.length;
+ for (let ch = 0; ch < channels; ch++) {
+ for (let sample = 0; sample < source[ch].length; sample++) {
+ dest[sample * channels + ch] = source[ch][sample];
+ }
+ }
+ }
+}
+
+registerProcessor('godot-processor', GodotProcessor);
diff --git a/index.html b/index.html
new file mode 100644
index 00000000000..960b64a3537
--- /dev/null
+++ b/index.html
@@ -0,0 +1,200 @@
+
+
+
+
+
+ Pixelorama
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
You are offline
+ This application requires an Internet connection to run for the first time.
+ Press the button below to try reloading:
+
+
+
+
diff --git a/index.pck b/index.pck
new file mode 100644
index 00000000000..1654da8779e
Binary files /dev/null and b/index.pck differ
diff --git a/index.png b/index.png
new file mode 100644
index 00000000000..2c6a3259509
Binary files /dev/null and b/index.png differ
diff --git a/index.service.worker.js b/index.service.worker.js
new file mode 100644
index 00000000000..483f04a4471
--- /dev/null
+++ b/index.service.worker.js
@@ -0,0 +1,166 @@
+// This service worker is required to expose an exported Godot project as a
+// Progressive Web App. It provides an offline fallback page telling the user
+// that they need an Internet connection to run the project if desired.
+// Incrementing CACHE_VERSION will kick off the install event and force
+// previously cached resources to be updated from the network.
+/** @type {string} */
+const CACHE_VERSION = '1726237314|7649876';
+/** @type {string} */
+const CACHE_PREFIX = 'Pixelorama-sw-cache-';
+const CACHE_NAME = CACHE_PREFIX + CACHE_VERSION;
+/** @type {string} */
+const OFFLINE_URL = 'index.offline.html';
+/** @type {boolean} */
+const ENSURE_CROSSORIGIN_ISOLATION_HEADERS = true;
+// Files that will be cached on load.
+/** @type {string[]} */
+const CACHED_FILES = ["index.html","index.js","index.offline.html","index.icon.png","index.apple-touch-icon.png","index.worker.js","index.audio.worklet.js"];
+// Files that we might not want the user to preload, and will only be cached on first load.
+/** @type {string[]} */
+const CACHABLE_FILES = ["index.wasm","index.pck"];
+const FULL_CACHE = CACHED_FILES.concat(CACHABLE_FILES);
+
+self.addEventListener('install', (event) => {
+ event.waitUntil(caches.open(CACHE_NAME).then((cache) => cache.addAll(CACHED_FILES)));
+});
+
+self.addEventListener('activate', (event) => {
+ event.waitUntil(caches.keys().then(
+ function (keys) {
+ // Remove old caches.
+ return Promise.all(keys.filter((key) => key.startsWith(CACHE_PREFIX) && key !== CACHE_NAME).map((key) => caches.delete(key)));
+ }
+ ).then(function () {
+ // Enable navigation preload if available.
+ return ('navigationPreload' in self.registration) ? self.registration.navigationPreload.enable() : Promise.resolve();
+ }));
+});
+
+/**
+ * Ensures that the response has the correct COEP/COOP headers
+ * @param {Response} response
+ * @returns {Response}
+ */
+function ensureCrossOriginIsolationHeaders(response) {
+ if (response.headers.get('Cross-Origin-Embedder-Policy') === 'require-corp'
+ && response.headers.get('Cross-Origin-Opener-Policy') === 'same-origin') {
+ return response;
+ }
+
+ const crossOriginIsolatedHeaders = new Headers(response.headers);
+ crossOriginIsolatedHeaders.set('Cross-Origin-Embedder-Policy', 'require-corp');
+ crossOriginIsolatedHeaders.set('Cross-Origin-Opener-Policy', 'same-origin');
+ const newResponse = new Response(response.body, {
+ status: response.status,
+ statusText: response.statusText,
+ headers: crossOriginIsolatedHeaders,
+ });
+
+ return newResponse;
+}
+
+/**
+ * Calls fetch and cache the result if it is cacheable
+ * @param {FetchEvent} event
+ * @param {Cache} cache
+ * @param {boolean} isCacheable
+ * @returns {Response}
+ */
+async function fetchAndCache(event, cache, isCacheable) {
+ // Use the preloaded response, if it's there
+ /** @type { Response } */
+ let response = await event.preloadResponse;
+ if (response == null) {
+ // Or, go over network.
+ response = await self.fetch(event.request);
+ }
+
+ if (ENSURE_CROSSORIGIN_ISOLATION_HEADERS) {
+ response = ensureCrossOriginIsolationHeaders(response);
+ }
+
+ if (isCacheable) {
+ // And update the cache
+ cache.put(event.request, response.clone());
+ }
+
+ return response;
+}
+
+self.addEventListener(
+ 'fetch',
+ /**
+ * Triggered on fetch
+ * @param {FetchEvent} event
+ */
+ (event) => {
+ const isNavigate = event.request.mode === 'navigate';
+ const url = event.request.url || '';
+ const referrer = event.request.referrer || '';
+ const base = referrer.slice(0, referrer.lastIndexOf('/') + 1);
+ const local = url.startsWith(base) ? url.replace(base, '') : '';
+ const isCachable = FULL_CACHE.some((v) => v === local) || (base === referrer && base.endsWith(CACHED_FILES[0]));
+ if (isNavigate || isCachable) {
+ event.respondWith((async () => {
+ // Try to use cache first
+ const cache = await caches.open(CACHE_NAME);
+ if (isNavigate) {
+ // Check if we have full cache during HTML page request.
+ /** @type {Response[]} */
+ const fullCache = await Promise.all(FULL_CACHE.map((name) => cache.match(name)));
+ const missing = fullCache.some((v) => v === undefined);
+ if (missing) {
+ try {
+ // Try network if some cached file is missing (so we can display offline page in case).
+ const response = await fetchAndCache(event, cache, isCachable);
+ return response;
+ } catch (e) {
+ // And return the hopefully always cached offline page in case of network failure.
+ console.error('Network error: ', e); // eslint-disable-line no-console
+ return caches.match(OFFLINE_URL);
+ }
+ }
+ }
+ let cached = await cache.match(event.request);
+ if (cached != null) {
+ if (ENSURE_CROSSORIGIN_ISOLATION_HEADERS) {
+ cached = ensureCrossOriginIsolationHeaders(cached);
+ }
+ return cached;
+ }
+ // Try network if don't have it in cache.
+ const response = await fetchAndCache(event, cache, isCachable);
+ return response;
+ })());
+ } else if (ENSURE_CROSSORIGIN_ISOLATION_HEADERS) {
+ event.respondWith((async () => {
+ let response = await fetch(event.request);
+ response = ensureCrossOriginIsolationHeaders(response);
+ return response;
+ })());
+ }
+ }
+);
+
+self.addEventListener('message', (event) => {
+ // No cross origin
+ if (event.origin !== self.origin) {
+ return;
+ }
+ const id = event.source.id || '';
+ const msg = event.data || '';
+ // Ensure it's one of our clients.
+ self.clients.get(id).then(function (client) {
+ if (!client) {
+ return; // Not a valid client.
+ }
+ if (msg === 'claim') {
+ self.skipWaiting().then(() => self.clients.claim());
+ } else if (msg === 'clear') {
+ caches.delete(CACHE_NAME);
+ } else if (msg === 'update') {
+ self.skipWaiting().then(() => self.clients.claim()).then(() => self.clients.matchAll()).then((all) => all.forEach((c) => c.navigate(c.url)));
+ }
+ });
+});
+
diff --git a/index.wasm b/index.wasm
new file mode 100644
index 00000000000..f663665cd96
Binary files /dev/null and b/index.wasm differ