@statewalker/webrun-http-browser 0.1.0

package/CHANGELOG.md

@@ -0,0 +1 @@
+# @statewalker/webrun-http-browser

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 statewalker
+
+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.

package/README.md

@@ -0,0 +1,5 @@
+# @statewalker/webrun-http-browser
+
+This module simulates HTTP server using Service Workers.
+It allows to develop, test, run and debug server-side code directly in the browser.
+After that the same code can be deployed in Deno / Deno Deploy / Cloudflare / Node JS environments (with adapters).

package/dist/index-sw-umd.js

@@ -0,0 +1,651 @@
+// @statewalker/webrun-http-browser v0.1.0 https://github.com/statewalker/statewalker-webrun-http-browser Copyright 2023 Mikhail Kotelnikov
+(function (global, factory) {
+typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+typeof define === 'function' && define.amd ? define(['exports'], factory) :
+(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.statewalker = global.statewalker || {}, global.statewalker["webrun-http-browser"] = global.statewalker["webrun-http-browser"] || {})));
+})(this, (function (exports) { 'use strict';
+
+function serializeError(error) {
+  return Object.assign({
+    message: error,
+    stack: error.stack,
+  }, error);
+}
+
+function deserializeError(error) {
+  if (typeof error === "string") {
+    error = { message: error };
+  }
+  return Object.assign(new Error(error.message), error);
+}
+
+// See https://github.com/agenjs/agen-utils/blob/main/src/iterator.js
+async function* iterate(init, queue = []) {
+  let promise, notify, push = async (error, value, done) => {
+    const slot = { error, value, done };
+    slot.promise = new Promise(n => slot.notify = n);
+    await queue.push(slot);
+    notify && notify();
+    notify = null;
+    return slot.promise;
+  };
+  const next = (value) => push(undefined, value, false);
+  const complete = () => push(undefined, undefined, true);
+  const error = err => push(err, undefined, true);
+  const unsubscribe = init(Object.assign([next, complete, error], { next, complete, error }));
+  let slot;
+  try {
+    while (true) {
+      slot = await queue.shift();
+      if (slot) {
+        try {
+          if (slot.error) { throw slot.error; }
+          else if (slot.done) { break; }
+          else { yield slot.value; }
+        } finally {
+          slot.notify(true);
+        }
+      } else {
+        await (promise = notify ? promise : new Promise(n => notify = n));
+      }
+    }
+  } finally {
+    notify && notify();
+    push = () => false; // Stop pushing in the queue...
+    ((typeof unsubscribe === 'function') && (await unsubscribe()));
+    while (slot = await queue.shift()) { slot.notify(false); }
+  }
+}
+
+async function* recieveData(onMessage) {
+  yield* iterate((iterator) => {
+    return onMessage(async ({ done = true, value, error } = {}) => {
+      if (error) {
+        await iterator.error(error);
+      } else if (done) {
+        await iterator.complete();
+      } else {
+        await iterator.next(value);
+      }
+    });
+  });
+}
+
+async function sendData(send, it) {
+  let error;
+  try {
+    for await (let value of it) {
+      await send({ done: false, value });
+    }
+  } catch (err) {
+    error = err;
+  } finally {
+    await send({ done: true, error });
+  }
+}
+
+async function* sendStream(communicationPort, input, params = {}) {
+  const messageChannel = new MessageChannel();
+  communicationPort.postMessage({ type: "START_CALL", params }, [
+    messageChannel.port2,
+  ]);
+
+  const channel = newChannel(messageChannel.port1);
+  try {
+    await channel.start();
+    channel.sendAll(input);
+    yield* channel.recieveAll();
+  } finally {
+    await channel.close();
+  }
+}
+
+/**
+ * This method creates and returns methods allowing to send and recieve data over the specified port.
+ * The main characteristics of the returned methods is that they properly manage backpressure - sender
+ * iterators are waiting to send the next value until the previous one is consumed on the other side.
+ * @param {*} port
+ * @returns an object with the following methods:
+ *  * `start` - starts the connection over the specified port
+ *  * `close`- stops all iterators and closes the port
+ *  * `recieveAll() : AsyncIterator` - returns an AsyncIterator over all values send by the peer
+ *  * `sendAll(it : AsyncIterator) : Promise<any>` - sends all values defined by the given
+ *     AsyncIterator to the peer
+ */
+function newChannel(port) {
+  let listeners = [];
+  let iterators = [];
+
+  const notifyAll = async (data) => {
+    for (let listener of listeners) {
+      await listener(data);
+    }
+  };
+  const channel = newInvokationChannel(port, notifyAll);
+
+  const start = () => channel.start();
+
+  const close = async () => {
+    await notifyAll({ done: true });
+    [...iterators].forEach((it) => it.return && it.return());
+    await channel.close();
+  };
+
+  async function* recieveAll() {
+    yield* recieveData((listener) => {
+      listeners.push(listener);
+      return () => listeners = listeners.filter((l) => l !== listener);
+    });
+  }
+
+  async function sendAll(it) {
+    await sendData(
+      channel.invoke,
+      (async function* () {
+        try {
+          iterators.push(it);
+          yield* it;
+        } finally {
+          iterators = iterators.filter((i) => i !== it);
+        }
+      })(),
+    );
+  }
+  return {
+    start,
+    close,
+    recieveAll,
+    sendAll,
+  };
+}
+
+function newInvokationChannel(port, handler = () => {
+  throw new Error("Handler not implemented");
+}) {
+  const MESSAGE_TYPE_REQUEST = "REQUEST";
+  const MESSAGE_TYPE_RESPONSE = "RESPONSE";
+  const EVENT_MESSAGE = "message";
+
+  const requests = {};
+  let requestCounter = 0;
+  const listener = async (event) => {
+    const data = event.data || {};
+    const { type, callId } = data;
+    if (type === MESSAGE_TYPE_REQUEST) {
+      try {
+        const { request } = data;
+        let result = await handler(request, ...(event.ports || []));
+        const [response, ...transfers] = Array.isArray(result)
+          ? result
+          : result !== undefined
+          ? [result]
+          : [];
+        port.postMessage(
+          { type: MESSAGE_TYPE_RESPONSE, callId, response },
+          transfers,
+        );
+      } catch (error) {
+        port.postMessage({
+          type: MESSAGE_TYPE_RESPONSE,
+          callId,
+          error: serializeError(error),
+        });
+      }
+    } else if (type === MESSAGE_TYPE_RESPONSE) {
+      const { callId, response, error } = data;
+      const request = requests[callId];
+      delete requests[callId];
+      if (request) {
+        error
+          ? request.reject(deserializeError(error))
+          : request.resolve(response);
+      }
+    }
+  };
+
+  const start = async () => {
+    port.addEventListener(EVENT_MESSAGE, listener);
+    await port.start();
+  };
+
+  const close = async () => {
+    port.removeEventListener(EVENT_MESSAGE, listener);
+    await port.close();
+  };
+
+  const invoke = async function (request = {}, ...transfers) {
+    const callId = ++requestCounter;
+    return new Promise((resolve, reject) => {
+      try {
+        requests[callId] = { resolve, reject };
+        port.postMessage(
+          { type: MESSAGE_TYPE_REQUEST, callId, request },
+          transfers,
+        );
+      } catch (error) {
+        reject(error);
+        delete request[callId];
+      }
+    });
+  };
+
+  return {
+    start,
+    close,
+    invoke,
+  };
+}
+
+function toReadableStream(it) {
+  return new ReadableStream({
+    type: "bytes",
+    async pull(controller) {
+      let handled = false;
+      try {
+        while (true) {
+          const slot = await it.next();
+          if (!slot || slot.done) {
+            break;
+          }
+          controller.enqueue(await slot.value);
+        }
+      } catch (error) {
+        handled = true;
+        controller.error(error);
+      } finally {
+        !handled && controller.close();
+      }
+    },
+  });
+}
+
+async function* fromReadableStream(stream) {
+  const reader = await stream.getReader();
+  let done, value;
+  while (({ done, value } = await reader.read())) {
+    if (done) {
+      break;
+    }
+    yield await value;
+  }
+}
+
+/**
+ * This method returns an HTTP handlers transforming
+ * HTTP Request instances to binary representations and
+ * sending them to a transport layer.
+ * Results of these transport ivokations are deserialized
+ * as meaningful Response instances and returned back to the caller.
+ *
+ * The specified `send` method is used to dispatch serialized
+ * requests to return the serialized remote results.
+ * This transport method accepts and returns objects with
+ * the same structure:
+ * * `options` - contains serialized request or response parameters
+ * * `content` - an async iterator over binary blocks for
+ *    the request or response
+ *
+ * @param {*} send transport function accepting serialized requests
+ * and returning back serialized responses
+ * @returns an async handler accepting standard
+ *   HTTP `Request` instances and returning `Response` instances
+ */
+function newHttpClientStub(send) {
+  return async (request) => {
+    request = await request;
+    const fields = [
+      "url",
+      "method",
+      "mode",
+      "credentials",
+      "cache",
+      "redirect",
+      "referrer",
+      "referrerPolicy",
+      "integrity",
+      "keepalive",
+    ];
+    // request = await request.clone();
+    const requestOptions = fields.reduce((options, key) => {
+      const val = request[key];
+      if (val !== undefined) options[key] = val;
+      return options;
+    }, {});
+    const requestContent = (request.body)
+      ? fromReadableStream(request.body)
+      : [];
+    const result = await send({
+      options: requestOptions,
+      content: requestContent,
+    });
+    let responseBody = null;
+    let responseOptions = {};
+    if (!result) {
+      responseOptions = {
+        status: 404,
+        statusText: "Error 404: Not Found",
+      };
+    } else {
+      responseOptions = result.options;
+      const responseContent = result.content;
+      if (
+        requestOptions.method !== "HEAD" &&
+        requestOptions.method !== "OPTIONS"
+      ) {
+        responseBody = toReadableStream(responseContent);
+      } else if (responseContent && responseContent.return) {
+        responseContent.return();
+      }
+    }
+    return new Response(responseBody, responseOptions);
+  };
+}
+
+async function* httpToIterator(params) {
+  const { options, content } = await params;
+  const encoder = new TextEncoder();
+  yield encoder.encode(JSON.stringify(options));
+  yield* content;
+}
+
+async function httpFromIterator(it) {
+  it = await it;
+  const { done, value } = await it.next();
+  let options = {};
+  if (!done && value) {
+    const decoder = new TextDecoder();
+    const str = decoder.decode(value);
+    options = JSON.parse(str);
+  }
+  return {
+    options,
+    content: it,
+  };
+}
+
+async function sendHttpRequest(communicationPort, request) {
+  const clientStub = newHttpClientStub(async (req) => {
+    return await httpFromIterator(
+      sendStream(communicationPort, httpToIterator(req)),
+    );
+  });
+  return await clientStub(request);
+}
+
+async function callChannel(mainChannel, callType, params, ...transfers) {
+  return new Promise((resolve, reject) => {
+    const channel = new MessageChannel();
+    channel.port1.onmessage = (ev) => {
+      const { result, error } = ev.data;
+      if (error) reject(deserializeError(error));
+      else resolve(result);
+    };
+    mainChannel.postMessage({ type: callType, params }, [
+      channel.port2,
+      ...transfers,
+    ]);
+  });
+}
+
+function handleChannelCalls(mainChannel, callType, handler) {
+  const messageListener = async (event) => {
+    if (!event.data || event.data.type !== callType) return;
+    const [port, ...transfers] = event.ports;
+    let response = {};
+    try {
+      const params = event.data.params;
+      response.result = await handler(event, params, ...transfers);
+    } catch (error) {
+      response.error = serializeError(error);
+    }
+    port.postMessage(response);
+  };
+  mainChannel.addEventListener("message", messageListener);
+  try {
+    mainChannel.start && mainChannel.start();
+  } catch (e) {}
+  return () => mainChannel.removeEventListener("message", messageListener);
+}
+
+function promisifyRequest(request) {
+    return new Promise((resolve, reject) => {
+        // @ts-ignore - file size hacks
+        request.oncomplete = request.onsuccess = () => resolve(request.result);
+        // @ts-ignore - file size hacks
+        request.onabort = request.onerror = () => reject(request.error);
+    });
+}
+function createStore(dbName, storeName) {
+    const request = indexedDB.open(dbName);
+    request.onupgradeneeded = () => request.result.createObjectStore(storeName);
+    const dbp = promisifyRequest(request);
+    return (txMode, callback) => dbp.then((db) => callback(db.transaction(storeName, txMode).objectStore(storeName)));
+}
+let defaultGetStoreFunc;
+function defaultGetStore() {
+    if (!defaultGetStoreFunc) {
+        defaultGetStoreFunc = createStore('keyval-store', 'keyval');
+    }
+    return defaultGetStoreFunc;
+}
+/**
+ * Get a value by its key.
+ *
+ * @param key
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+function get(key, customStore = defaultGetStore()) {
+    return customStore('readonly', (store) => promisifyRequest(store.get(key)));
+}
+/**
+ * Set a value with a key.
+ *
+ * @param key
+ * @param value
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+function set(key, value, customStore = defaultGetStore()) {
+    return customStore('readwrite', (store) => {
+        store.put(value, key);
+        return promisifyRequest(store.transaction);
+    });
+}
+
+class SwPortDispatcher {
+  constructor({ self, log }) {
+    this.self = self;
+    this.log = log;
+    // Contains mapping between path prefixes and clientIds
+    this.handlersIndex = new Map();
+  }
+
+  get scope() {
+    return new URL("./", (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (document.currentScript && document.currentScript.src || new URL('index-sw-umd.js', document.baseURI).href))) + "";
+  }
+
+  async loadChannelInfo(key) {
+    await this._checkActivation();
+    let result;
+    for (let channelInfo of this.handlersIndex.values()) {
+      if (channelInfo.key !== key) continue;
+      const clientId = channelInfo.clientId;
+      const client = await self.clients.get(clientId);
+      if (!client) {
+        // Client gone. Remove the corresponding handlers from the index.
+        this.handlersIndex.delete(clientId);
+        throw Object.assign(new Error("Error 410: Resource Gone"), {
+          status: 410,
+        });
+      }
+      result = channelInfo;
+      break;
+    }
+    return result;
+  }
+
+  start() {
+    this._cleanup = handleChannelCalls(
+      this.self,
+      "UPDATE_COMMUNICATION_PORT",
+      async (event, channelInfo, port) => {
+        const clientId = event.source.id;
+        this.log("[UPDATE_COMMUNICATION_PORT]", clientId, channelInfo);
+        await this._updateChannelInfo({ ...channelInfo, port, clientId });
+        return { ...channelInfo };
+      },
+    );
+    this.self.onmessage = () => {};
+
+    this.self.addEventListener("install", (event) => {
+      this.log("Skip waiting on install.", event);
+      this.self.skipWaiting();
+    });
+
+    this.self.addEventListener("activate", async (event) => {
+      this.log(
+        "Claim control over all clients.",
+        event,
+        clients,
+        this.self.clients,
+      );
+      event.waitUntil((async () => {
+        await this.self.clients.claim();
+        await this._checkActivation();
+      })());
+    });
+  }
+
+  async stop() {
+    if (this._cleanup) {
+      await this._cleanup();
+      this._cleanup = undefined;
+    }
+  }
+
+  async _checkActivation() {
+    return this._activationPromise = this._activationPromise ||
+      this._activate();
+  }
+
+  async _activate() {
+    this.log("[checkActivation]");
+    let clientsIndex = await this._loadClientIds();
+    for (let [clientId, client] of clientsIndex.entries()) {
+      const messageChannel = new MessageChannel();
+      const port = messageChannel.port1;
+      const channelInfo = await callChannel(
+        client,
+        "UPDATE_COMMUNICATION_PORT",
+        {},
+        messageChannel.port2,
+      );
+      await this._updateChannelInfo({ ...channelInfo, port, clientId });
+    }
+  }
+
+  async _updateChannelInfo(channelInfo) {
+    this.log("[updateClientInfo]", channelInfo);
+    this.handlersIndex.set(channelInfo.clientId, channelInfo);
+    await this._updateClientIds([]);
+  }
+
+  async _loadClientIds() {
+    const clientIds = new Set((await get("clientIds")) || []);
+    return await this._updateClientIds(clientIds);
+  }
+
+  async _updateClientIds(clientIds) {
+    clientIds = new Set(clientIds);
+    for (let clientId of this.handlersIndex.keys()) {
+      clientIds.add(clientId);
+    }
+    const index = new Map();
+    for (let clientId of clientIds) {
+      const client = await this.self.clients.get(clientId);
+      if (client) index.set(clientId, client);
+      else this.handlersIndex.delete(clientId);
+    }
+    await set("clientIds", [...index.keys()].sort());
+    return index;
+  }
+}
+
+class SwHttpDispatcher extends SwPortDispatcher {
+  constructor(options) {
+    super(options);
+  }
+
+  start() {
+    super.start();
+    this.self.addEventListener("fetch", this._handleFetchEvent.bind(this));
+  }
+
+  _handleFetchEvent(event) {
+    event.respondWith((async () => {
+      const request = event.request;
+      try {
+        const requestUrl = request.url;
+        const rootUrl = this.scope;
+        let channelInfo;
+        if (requestUrl.indexOf(rootUrl) === 0) {
+          const key = requestUrl
+            .substring(rootUrl.length)
+            .replace(/^\/?([^\/]+).*$/, "$1");
+          // console.log(`* rootUrl="${rootUrl}" requestUrl="${requestUrl}" key="${key}"`);
+          channelInfo = await this.loadChannelInfo(key);
+        }
+        if (channelInfo && channelInfo.port) {
+          return await sendHttpRequest(channelInfo.port, request);
+        } else {
+          const newRequest = new Request(requestUrl, {
+            method: request.method,
+            headers: request.headers,
+            body: request.body,
+            referrer: request.referrer,
+            referrerPolicy: request.referrerPolicy,
+            // mode: request.mode,
+            credentials: request.credentials,
+            cache: request.cache,
+            redirect: request.redirect,
+            integrity: request.integrity,
+          });
+          return await fetch(newRequest);
+        }
+
+        // const requestUrl = request.url;
+        // let url = requestUrl.replace(
+        //   /^.*\/[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}(.*)$/,
+        //   "$1",
+        // );
+        // if (url !== requestUrl) {
+        //   url = new URL(
+        //     "/packages/webrun-http-browser/src" + url,
+        //     self.location.href,
+        //   );
+        // }
+      } catch (error) {
+        console.error(error);
+        return new Response(null, {
+          status: 500,
+          statusText: "Error 500: Internal error",
+        });
+      }
+    })());
+  }
+}
+function startHttpDispatcher({ self, log }) {
+  const dispatcher = new SwHttpDispatcher({ self, log });
+  dispatcher.start();
+  return () => {
+    dispatcher.stop();
+  };
+}
+
+const result = startHttpDispatcher({
+  self,
+  log: console.log.bind(console, "[sw]"),
+});
+
+exports.result = result;
+
+}));

package/dist/index-sw-umd.min.js

@@ -0,0 +1,2 @@
+// @statewalker/webrun-http-browser v0.1.0 https://github.com/statewalker/statewalker-webrun-http-browser Copyright 2023 Mikhail Kotelnikov
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t(((e="undefined"!=typeof globalThis?globalThis:e||self).statewalker=e.statewalker||{},e.statewalker["webrun-http-browser"]=e.statewalker["webrun-http-browser"]||{}))}(this,(function(e){"use strict";function t(e){return Object.assign({message:e,stack:e.stack},e)}function n(e){return"string"==typeof e&&(e={message:e}),Object.assign(new Error(e.message),e)}async function*s(e){yield*async function*(e,t=[]){let n,s,r=async(e,n,r)=>{const a={error:e,value:n,done:r};return a.promise=new Promise((e=>a.notify=e)),await t.push(a),s&&s(),s=null,a.promise};const a=e=>r(void 0,e,!1),o=()=>r(void 0,void 0,!0),i=e=>r(e,void 0,!0),c=e(Object.assign([a,o,i],{next:a,complete:o,error:i}));let l;try{for(;;)if(l=await t.shift(),l)try{if(l.error)throw l.error;if(l.done)break;yield l.value}finally{l.notify(!0)}else await(n=s?n:new Promise((e=>s=e)))}finally{for(s&&s(),r=()=>!1,"function"==typeof c&&await c();l=await t.shift();)l.notify(!1)}}((t=>e((async({done:e=!0,value:n,error:s}={})=>{s?await t.error(s):e?await t.complete():await t.next(n)}))))}async function*r(e,r,a={}){const o=new MessageChannel;e.postMessage({type:"START_CALL",params:a},[o.port2]);const i=function(e){let r=[],a=[];const o=async e=>{for(let t of r)await t(e)},i=function(e,s=(()=>{throw new Error("Handler not implemented")})){const r="REQUEST",a="RESPONSE",o="message",i={};let c=0;const l=async o=>{const c=o.data||{},{type:l,callId:d}=c;if(l===r)try{const{request:t}=c;let n=await s(t,...o.ports||[]);const[r,...i]=Array.isArray(n)?n:void 0!==n?[n]:[];e.postMessage({type:a,callId:d,response:r},i)}catch(n){e.postMessage({type:a,callId:d,error:t(n)})}else if(l===a){const{callId:e,response:t,error:s}=c,r=i[e];delete i[e],r&&(s?r.reject(n(s)):r.resolve(t))}},d=async()=>{e.addEventListener(o,l),await e.start()},u=async()=>{e.removeEventListener(o,l),await e.close()},f=async function(t={},...n){const s=++c;return new Promise(((a,o)=>{try{i[s]={resolve:a,reject:o},e.postMessage({type:r,callId:s,request:t},n)}catch(e){o(e),delete t[s]}}))};return{start:d,close:u,invoke:f}}(e,o),c=()=>i.start(),l=async()=>{await o({done:!0}),[...a].forEach((e=>e.return&&e.return())),await i.close()};async function*d(){yield*s((e=>(r.push(e),()=>r=r.filter((t=>t!==e)))))}async function u(e){await async function(e,t){let n;try{for await(let n of t)await e({done:!1,value:n})}catch(e){n=e}finally{await e({done:!0,error:n})}}(i.invoke,async function*(){try{a.push(e),yield*e}finally{a=a.filter((t=>t!==e))}}())}return{start:c,close:l,recieveAll:d,sendAll:u}}(o.port1);try{await i.start(),i.sendAll(r),yield*i.recieveAll()}finally{await i.close()}}function a(e){return async t=>{t=await t;const n=["url","method","mode","credentials","cache","redirect","referrer","referrerPolicy","integrity","keepalive"].reduce(((e,n)=>{const s=t[n];return void 0!==s&&(e[n]=s),e}),{}),s=t.body?async function*(e){const t=await e.getReader();let n,s;for(;({done:n,value:s}=await t.read())&&!n;)yield await s}(t.body):[],r=await e({options:n,content:s});let a=null,o={};if(r){o=r.options;const e=r.content;"HEAD"!==n.method&&"OPTIONS"!==n.method?(i=e,a=new ReadableStream({type:"bytes",async pull(e){let t=!1;try{for(;;){const t=await i.next();if(!t||t.done)break;e.enqueue(await t.value)}}catch(n){t=!0,e.error(n)}finally{!t&&e.close()}}})):e&&e.return&&e.return()}else o={status:404,statusText:"Error 404: Not Found"};var i;return new Response(a,o)}}async function o(e,t){const n=a((async t=>await async function(e){e=await e;const{done:t,value:n}=await e.next();let s={};if(!t&&n){const e=(new TextDecoder).decode(n);s=JSON.parse(e)}return{options:s,content:e}}(r(e,async function*(e){const{options:t,content:n}=await e,s=new TextEncoder;yield s.encode(JSON.stringify(t)),yield*n}(t)))));return await n(t)}async function i(e,t,s,...r){return new Promise(((a,o)=>{const i=new MessageChannel;i.port1.onmessage=e=>{const{result:t,error:s}=e.data;s?o(n(s)):a(t)},e.postMessage({type:t,params:s},[i.port2,...r])}))}function c(e){return new Promise(((t,n)=>{e.oncomplete=e.onsuccess=()=>t(e.result),e.onabort=e.onerror=()=>n(e.error)}))}let l;function d(){return l||(l=function(e,t){const n=indexedDB.open(e);n.onupgradeneeded=()=>n.result.createObjectStore(t);const s=c(n);return(e,n)=>s.then((s=>n(s.transaction(t,e).objectStore(t))))}("keyval-store","keyval")),l}class u{constructor({self:e,log:t}){this.self=e,this.log=t,this.handlersIndex=new Map}get scope(){return new URL("./","undefined"==typeof document&&"undefined"==typeof location?require("url").pathToFileURL(__filename).href:"undefined"==typeof document?location.href:document.currentScript&&document.currentScript.src||new URL("index-sw-umd.min.js",document.baseURI).href)+""}async loadChannelInfo(e){let t;await this._checkActivation();for(let n of this.handlersIndex.values()){if(n.key!==e)continue;const s=n.clientId;if(!await self.clients.get(s))throw this.handlersIndex.delete(s),Object.assign(new Error("Error 410: Resource Gone"),{status:410});t=n;break}return t}start(){this._cleanup=function(e,n,s){const r=async e=>{if(!e.data||e.data.type!==n)return;const[r,...a]=e.ports;let o={};try{const t=e.data.params;o.result=await s(e,t,...a)}catch(e){o.error=t(e)}r.postMessage(o)};e.addEventListener("message",r);try{e.start&&e.start()}catch(e){}return()=>e.removeEventListener("message",r)}(this.self,"UPDATE_COMMUNICATION_PORT",(async(e,t,n)=>{const s=e.source.id;return this.log("[UPDATE_COMMUNICATION_PORT]",s,t),await this._updateChannelInfo({...t,port:n,clientId:s}),{...t}})),this.self.onmessage=()=>{},this.self.addEventListener("install",(e=>{this.log("Skip waiting on install.",e),this.self.skipWaiting()})),this.self.addEventListener("activate",(async e=>{this.log("Claim control over all clients.",e,clients,this.self.clients),e.waitUntil((async()=>{await this.self.clients.claim(),await this._checkActivation()})())}))}async stop(){this._cleanup&&(await this._cleanup(),this._cleanup=void 0)}async _checkActivation(){return this._activationPromise=this._activationPromise||this._activate()}async _activate(){this.log("[checkActivation]");let e=await this._loadClientIds();for(let[t,n]of e.entries()){const e=new MessageChannel,s=e.port1,r=await i(n,"UPDATE_COMMUNICATION_PORT",{},e.port2);await this._updateChannelInfo({...r,port:s,clientId:t})}}async _updateChannelInfo(e){this.log("[updateClientInfo]",e),this.handlersIndex.set(e.clientId,e),await this._updateClientIds([])}async _loadClientIds(){const e=new Set(await function(e,t=d()){return t("readonly",(t=>c(t.get(e))))}("clientIds")||[]);return await this._updateClientIds(e)}async _updateClientIds(e){e=new Set(e);for(let t of this.handlersIndex.keys())e.add(t);const t=new Map;for(let n of e){const e=await this.self.clients.get(n);e?t.set(n,e):this.handlersIndex.delete(n)}return await function(e,t,n=d()){return n("readwrite",(n=>(n.put(t,e),c(n.transaction))))}("clientIds",[...t.keys()].sort()),t}}class f extends u{constructor(e){super(e)}start(){super.start(),this.self.addEventListener("fetch",this._handleFetchEvent.bind(this))}_handleFetchEvent(e){e.respondWith((async()=>{const t=e.request;try{const e=t.url,n=this.scope;let s;if(0===e.indexOf(n)){const t=e.substring(n.length).replace(/^\/?([^\/]+).*$/,"$1");s=await this.loadChannelInfo(t)}if(s&&s.port)return await o(s.port,t);{const n=new Request(e,{method:t.method,headers:t.headers,body:t.body,referrer:t.referrer,referrerPolicy:t.referrerPolicy,credentials:t.credentials,cache:t.cache,redirect:t.redirect,integrity:t.integrity});return await fetch(n)}}catch(e){return console.error(e),new Response(null,{status:500,statusText:"Error 500: Internal error"})}})())}}const h=function({self:e,log:t}){const n=new f({self:e,log:t});return n.start(),()=>{n.stop()}}({self:self,log:console.log.bind(console,"[sw]")});e.result=h}));