@serwist/window 8.0.0 → 8.0.1

package/dist/Serwist.d.ts

@@ -268,4 +268,3 @@ export declare class Serwist extends SerwistEventTarget {
  * @property {string} type `redundant`.
  * @property {Workbox} target The `Workbox` instance.
  */
-//# sourceMappingURL=Serwist.d.ts.map

package/dist/index.d.ts

@@ -2,4 +2,3 @@ import { messageSW } from "./messageSW.js";
 import { Serwist } from "./Serwist.js";
 export { messageSW, Serwist };
 export * from "./utils/SerwistEvent.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/messageSW.d.ts

@@ -13,4 +13,3 @@
  */
 declare function messageSW(sw: ServiceWorker, data: {}): Promise<any>;
 export { messageSW };
-//# sourceMappingURL=messageSW.d.ts.map

package/dist/utils/SerwistEvent.d.ts

@@ -36,4 +36,3 @@ export interface SerwistLifecycleEventMap {
 export interface SerwistEventMap extends SerwistLifecycleEventMap {
     message: SerwistMessageEvent;
 }
-//# sourceMappingURL=SerwistEvent.d.ts.map

package/dist/utils/SerwistEventTarget.d.ts

@@ -35,4 +35,3 @@ export declare class SerwistEventTarget {
      */
     private _getEventListenersByType;
 }
-//# sourceMappingURL=SerwistEventTarget.d.ts.map

package/dist/utils/urlsMatch.d.ts

@@ -8,4 +8,3 @@
  * @returns
  */
 export declare function urlsMatch(url1: string, url2: string): boolean;
-//# sourceMappingURL=urlsMatch.d.ts.map

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@serwist/window",
-  "version": "8.0.0",
+  "version": "8.0.1",
   "type": "module",
   "description": "Simplifies communications with Serwist packages running in the service worker",
+  "files": [
+    "dist",
+    "!dist/**/dts"
+  ],
   "keywords": [
     "serwist",
     "serwistjs",
@@ -30,11 +34,11 @@
   },
   "dependencies": {
     "@types/trusted-types": "2.0.4",
-    "@serwist/core": "8.0.0"
+    "@serwist/core": "8.0.1"
   },
   "devDependencies": {
     "rollup": "3.28.1",
-    "@serwist/constants": "8.0.0"
+    "@serwist/constants": "8.0.1"
   },
   "scripts": {
     "build": "rimraf dist && cross-env NODE_ENV=production rollup --config rollup.config.js",

package/.turbo/turbo-build.log

@@ -1,10 +0,0 @@
-
-> @serwist/window@8.0.0 build /home/runner/work/serwist/serwist/packages/window
-> rimraf dist && cross-env NODE_ENV=production rollup --config rollup.config.js
-
-(node:2592) ExperimentalWarning: Import assertions are not a stable feature of the JavaScript language. Avoid relying on their current behavior and syntax as those might change in a future version of Node.js.
-(Use `node --trace-warnings ...` to show where the warning was created)
-(node:2592) ExperimentalWarning: Importing JSON modules is an experimental feature and might change at any time
-
-src/index.ts → dist/index.old.cjs, dist/index.js...
-created dist/index.old.cjs, dist/index.js in 7.8s

package/.turbo/turbo-lint.log

@@ -1,4 +0,0 @@
-
-> @serwist/window@8.0.0 lint /home/runner/work/serwist/serwist/packages/window
-> eslint src --ext ts,tsx,js,jsx,cjs,mjs
-

package/.turbo/turbo-typecheck.log

@@ -1,4 +0,0 @@
-
-> @serwist/window@8.0.0 typecheck /home/runner/work/serwist/serwist/packages/window
-> tsc
-

package/CHANGELOG.md

@@ -1,33 +0,0 @@
-# @serwist/window
-
-## 8.0.0
-
-### Major Changes
-
-- [`e0313f0`](https://github.com/serwist/serwist/commit/e0313f02f661a07ccbe9edc64e44e1af6136c73e) Thanks [@DuCanhGH](https://github.com/DuCanhGH)! - chore: initial release
-
-  - Reimagined `@serwist/next`.
-    - Removed various options.
-      - Removed `aggressiveFrontEndNavCaching` to reassess its usefulness.
-      - Removed `browserslist`. Use `swcEnvTargets` instead (TODO: add this option).
-      - Custom workers have been removed. You should use `swSrc`.
-      - Removed `extendDefaultRuntimeCaching`. Use the spread syntax instead (use `import { defaultCache } from "@serwist/next/browser"` to import the default runtimeCaching array).
-      - Temporarily removed `fallbacks` to investigate module-friendly alternatives.
-      - Removed `swcMinify`.
-      - Removed `watchWorkersInDev`.
-      - Removed `cacheStartUrl`, `dynamicStartUrl`, and `dynamicStartUrl`. These shall be re-added only when their use cases are made more clear to me.
-    - Merged `workboxOptions` with the plugin's options.
-    - Removed `swc-loader`, `terser-minify`, `webpack-builders`,... (we now leverage `ChildCompilationPlugin` to compile workers - this change will be backported to `@ducanh2912/next-pwa@10`)
-    - Removed the ability to use GenerateSW. `@serwist/sw.installSerwist` is provided as a replacement.
-    - `swSrc` is now a required property.
-    - Moved minimum support Next.js version from `11.0.0` to `14.0.0`.
-  - Removed GenerateSW (replaced by `@serwist/sw.installSerwist`).
-    - See `examples/next-basic/app/sw.ts` to see how `installSerwist` should be used.
-  - Repurposed `@serwist/sw`.
-    - The old package might be reintroduced if there's demand.
-  - **Note:** This is just the initial release, and there is still a lot of ground to cover (a lot of legacy code to be removed, a lot of features to be reintroduced,...). Here's to a bright future for the project :\_)
-
-### Patch Changes
-
-- Updated dependencies [[`e0313f0`](https://github.com/serwist/serwist/commit/e0313f02f661a07ccbe9edc64e44e1af6136c73e)]:
-  - @serwist/core@8.0.0

package/dist/Serwist.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Serwist.d.ts","sourceRoot":"","sources":["../src/Serwist.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAK1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAgBnE;;;;;;;;;;GAUG;AACH,qBAAa,OAAQ,SAAQ,kBAAkB;IAC7C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA4B;IACvD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA2B;IAC5D,OAAO,CAAC,iBAAiB,CAAK;IAG9B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA2C;IACvE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA2C;IAC3E,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA2C;IAEhF,OAAO,CAAC,iBAAiB,CAA0B;IACnD,OAAO,CAAC,SAAS,CAAC,CAAU;IAC5B,OAAO,CAAC,wBAAwB,CAAC,CAAgB;IACjD,OAAO,CAAC,aAAa,CAAC,CAA4B;IAClD,OAAO,CAAC,GAAG,CAAC,CAAgB;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiC;IACzD,OAAO,CAAC,WAAW,CAAC,CAAgB;IACpC,OAAO,CAAC,eAAe,CAAC,CAAS;IAEjC;;;;;;;;;;OAUG;gBAES,SAAS,EAAE,MAAM,GAAG,gBAAgB,EAAE,eAAe,GAAE,EAAO;IAY1E;;;;;;OAMG;IACG,QAAQ,CAAC,EACb,SAAiB,GAClB,GAAE;QACD;;;WAGG;QACH,SAAS,CAAC,EAAE,OAAO,CAAC;KAChB,GAAG,OAAO,CAAC,yBAAyB,GAAG,SAAS,CAAC;IAkGvD;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAY7B;;;;;;;;OAQG;IACH,IAAI,MAAM,IAAI,OAAO,CAAC,aAAa,CAAC,CAEnC;IAED;;;;;;;;;;;OAWG;IACH,IAAI,WAAW,IAAI,OAAO,CAAC,aAAa,CAAC,CAExC;IAED;;;;;;;;;;;;;;OAcG;IACH,KAAK,IAAI,OAAO,CAAC,aAAa,CAAC;IAM/B;;;;;;;;;;;;OAYG;IAGG,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAK3C;;;;;;OAMG;IACH,kBAAkB,IAAI,IAAI;IAM1B;;;;;;OAMG;IACH,OAAO,CAAC,6BAA6B;IASrC;;;;;OAKG;YACW,eAAe;IAsB7B;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAgE7B;IAEF;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAqF7B;IAEF;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAuBlC;IAEF;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU,CA2BzB;CACH;AAKD;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;GAeG"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC;AAG9B,cAAc,yBAAyB,CAAC"}

package/dist/messageSW.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"messageSW.d.ts","sourceRoot":"","sources":["../src/messageSW.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;GAYG;AAGH,iBAAS,SAAS,CAAC,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,CAQ5D;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/utils/SerwistEvent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SerwistEvent.d.ts","sourceRoot":"","sources":["../../src/utils/SerwistEvent.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;GAKG;AACH,qBAAa,YAAY,CAAC,CAAC,SAAS,MAAM,eAAe;IAO9C,IAAI,EAAE,CAAC;IANhB,MAAM,CAAC,EAAE,kBAAkB,CAAC;IAC5B,EAAE,CAAC,EAAE,aAAa,CAAC;IACnB,aAAa,CAAC,EAAE,KAAK,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;gBAGZ,IAAI,EAAE,CAAC,EACd,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;CAIrD;AAED,MAAM,WAAW,mBAAoB,SAAQ,YAAY,CAAC,SAAS,CAAC;IAClE,IAAI,EAAE,GAAG,CAAC;IACV,aAAa,EAAE,KAAK,CAAC;IACrB,KAAK,EAAE,SAAS,WAAW,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,qBAAsB,SAAQ,YAAY,CAAC,MAAM,wBAAwB,CAAC;IACzF,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,4BAA6B,SAAQ,qBAAqB;IACzE,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC;AAED,MAAM,WAAW,wBAAwB;IACvC,UAAU,EAAE,qBAAqB,CAAC;IAClC,SAAS,EAAE,qBAAqB,CAAC;IACjC,OAAO,EAAE,4BAA4B,CAAC;IACtC,UAAU,EAAE,qBAAqB,CAAC;IAClC,SAAS,EAAE,qBAAqB,CAAC;IACjC,WAAW,EAAE,qBAAqB,CAAC;IACnC,SAAS,EAAE,qBAAqB,CAAC;CAClC;AAED,MAAM,WAAW,eAAgB,SAAQ,wBAAwB;IAC/D,OAAO,EAAE,mBAAmB,CAAC;CAC9B"}

package/dist/utils/SerwistEventTarget.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SerwistEventTarget.d.ts","sourceRoot":"","sources":["../../src/utils/SerwistEventTarget.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEvE,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,YAAY,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC;AAEjE;;;;;GAKG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAgE;IAEvG;;;;OAIG;IACH,gBAAgB,CAAC,CAAC,SAAS,MAAM,eAAe,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,GAAG,GAAG,IAAI;IAK9G;;;;OAIG;IACH,mBAAmB,CAAC,CAAC,SAAS,MAAM,eAAe,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,GAAG,GAAG,IAAI;IAIjH;;;OAGG;IACH,aAAa,CAAC,KAAK,EAAE,YAAY,CAAC,GAAG,CAAC,GAAG,IAAI;IAS7C;;;;;;;OAOG;IACH,OAAO,CAAC,wBAAwB;CAMjC"}

package/dist/utils/urlsMatch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"urlsMatch.d.ts","sourceRoot":"","sources":["../../src/utils/urlsMatch.ts"],"names":[],"mappings":"AAQA;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAG7D"}

package/rollup.config.js

@@ -1,27 +0,0 @@
-// @ts-check
-import { getRollupOptions } from "@serwist/constants/rollup";
-
-import packageJson from "./package.json" assert { type: "json" };
-
-const isDev = process.env.NODE_ENV === "development";
-
-export default getRollupOptions({
-  packageJson,
-  jsFiles: [
-    {
-      input: "src/index.ts",
-      output: [
-        {
-          file: "dist/index.old.cjs",
-          format: "cjs",
-          exports: "named",
-        },
-        {
-          file: "dist/index.js",
-          format: "esm",
-        },
-      ],
-    },
-  ],
-  shouldEmitDeclaration: !isDev,
-});

package/src/Serwist.ts

@@ -1,686 +0,0 @@
-/*
-  Copyright 2019 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/
-
-import { Deferred, dontWaitFor, logger } from "@serwist/core/internal";
-import type { TrustedScriptURL } from "trusted-types/lib";
-
-import { messageSW } from "./messageSW.js";
-import type { SerwistLifecycleEventMap } from "./utils/SerwistEvent.js";
-import { SerwistEvent } from "./utils/SerwistEvent.js";
-import { SerwistEventTarget } from "./utils/SerwistEventTarget.js";
-import { urlsMatch } from "./utils/urlsMatch.js";
-
-// The time a SW must be in the waiting phase before we can conclude
-// `skipWaiting()` wasn't called. This 200 amount wasn't scientifically
-// chosen, but it seems to avoid false positives in my testing.
-const WAITING_TIMEOUT_DURATION = 200;
-
-// The amount of time after a registration that we can reasonably conclude
-// that the registration didn't trigger an update.
-const REGISTRATION_TIMEOUT_DURATION = 60000;
-
-// The de facto standard message that a service worker should be listening for
-// to trigger a call to skipWaiting().
-const SKIP_WAITING_MESSAGE = { type: "SKIP_WAITING" };
-
-/**
- * A class to aid in handling service worker registration, updates, and
- * reacting to service worker lifecycle events.
- *
- * @fires `@serwist/window.Serwist.message`
- * @fires `@serwist/window.Serwist.installed`
- * @fires `@serwist/window.Serwist.waiting`
- * @fires `@serwist/window.Serwist.controlling`
- * @fires `@serwist/window.Serwist.activated`
- * @fires `@serwist/window.Serwist.redundant`
- */
-export class Serwist extends SerwistEventTarget {
-  private readonly _scriptURL: string | TrustedScriptURL;
-  private readonly _registerOptions: RegistrationOptions = {};
-  private _updateFoundCount = 0;
-
-  // Deferreds we can resolve later.
-  private readonly _swDeferred: Deferred<ServiceWorker> = new Deferred();
-  private readonly _activeDeferred: Deferred<ServiceWorker> = new Deferred();
-  private readonly _controllingDeferred: Deferred<ServiceWorker> = new Deferred();
-
-  private _registrationTime: DOMHighResTimeStamp = 0;
-  private _isUpdate?: boolean;
-  private _compatibleControllingSW?: ServiceWorker;
-  private _registration?: ServiceWorkerRegistration;
-  private _sw?: ServiceWorker;
-  private readonly _ownSWs: Set<ServiceWorker> = new Set();
-  private _externalSW?: ServiceWorker;
-  private _waitingTimeout?: number;
-
-  /**
-   * Creates a new Serwist instance with a script URL and service worker
-   * options. The script URL and options are the same as those used when
-   * calling [navigator.serviceWorker.register(scriptURL, options)](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/register).
-   *
-   * @param scriptURL The service worker script
-   *     associated with this instance. Using a
-   *     [`TrustedScriptURL`](https://web.dev/trusted-types/) is supported.
-   * @param registerOptions The service worker options associated
-   *     with this instance.
-   */
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  constructor(scriptURL: string | TrustedScriptURL, registerOptions: {} = {}) {
-    super();
-
-    this._scriptURL = scriptURL;
-    this._registerOptions = registerOptions;
-
-    // Add a message listener immediately since messages received during
-    // page load are buffered only until the DOMContentLoaded event:
-    // https://github.com/GoogleChrome/workbox/issues/2202
-    navigator.serviceWorker.addEventListener("message", this._onMessage);
-  }
-
-  /**
-   * Registers a service worker for this instances script URL and service
-   * worker options. By default this method delays registration until after
-   * the window has loaded.
-   *
-   * @param options
-   */
-  async register({
-    immediate = false,
-  }: {
-    /**
-     * Setting this to true will  register the service worker immediately,
-     * even if the window has not loaded (not recommended).
-     */
-    immediate?: boolean;
-  } = {}): Promise<ServiceWorkerRegistration | undefined> {
-    if (process.env.NODE_ENV !== "production") {
-      if (this._registrationTime) {
-        logger.error("Cannot re-register a Serwist instance after it has " + "been registered. Create a new instance instead.");
-        return;
-      }
-    }
-
-    if (!immediate && document.readyState !== "complete") {
-      await new Promise((res) => window.addEventListener("load", res));
-    }
-
-    // Set this flag to true if any service worker was controlling the page
-    // at registration time.
-    this._isUpdate = Boolean(navigator.serviceWorker.controller);
-
-    // Before registering, attempt to determine if a SW is already controlling
-    // the page, and if that SW script (and version, if specified) matches this
-    // instance's script.
-    this._compatibleControllingSW = this._getControllingSWIfCompatible();
-
-    this._registration = await this._registerScript();
-
-    // If we have a compatible controller, store the controller as the "own"
-    // SW, resolve active/controlling deferreds and add necessary listeners.
-    if (this._compatibleControllingSW) {
-      this._sw = this._compatibleControllingSW;
-      this._activeDeferred.resolve(this._compatibleControllingSW);
-      this._controllingDeferred.resolve(this._compatibleControllingSW);
-
-      this._compatibleControllingSW.addEventListener("statechange", this._onStateChange, { once: true });
-    }
-
-    // If there's a waiting service worker with a matching URL before the
-    // `updatefound` event fires, it likely means that this site is open
-    // in another tab, or the user refreshed the page (and thus the previous
-    // page wasn't fully unloaded before this page started loading).
-    // https://developers.google.com/web/fundamentals/primers/service-workers/lifecycle#waiting
-    const waitingSW = this._registration.waiting;
-    if (waitingSW && urlsMatch(waitingSW.scriptURL, this._scriptURL.toString())) {
-      // Store the waiting SW as the "own" Sw, even if it means overwriting
-      // a compatible controller.
-      this._sw = waitingSW;
-
-      // Run this in the next microtask, so any code that adds an event
-      // listener after awaiting `register()` will get this event.
-      dontWaitFor(
-        Promise.resolve().then(() => {
-          this.dispatchEvent(
-            new SerwistEvent("waiting", {
-              sw: waitingSW,
-              wasWaitingBeforeRegister: true,
-            })
-          );
-          if (process.env.NODE_ENV !== "production") {
-            logger.warn("A service worker was already waiting to activate " + "before this script was registered...");
-          }
-        })
-      );
-    }
-
-    // If an "own" SW is already set, resolve the deferred.
-    if (this._sw) {
-      this._swDeferred.resolve(this._sw);
-      this._ownSWs.add(this._sw);
-    }
-
-    if (process.env.NODE_ENV !== "production") {
-      logger.log("Successfully registered service worker.", this._scriptURL.toString());
-
-      if (navigator.serviceWorker.controller) {
-        if (this._compatibleControllingSW) {
-          logger.debug("A service worker with the same script URL " + "is already controlling this page.");
-        } else {
-          logger.debug(
-            "A service worker with a different script URL is " +
-              "currently controlling the page. The browser is now fetching " +
-              "the new script now..."
-          );
-        }
-      }
-
-      const currentPageIsOutOfScope = () => {
-        const scopeURL = new URL(this._registerOptions.scope || this._scriptURL.toString(), document.baseURI);
-        const scopeURLBasePath = new URL("./", scopeURL.href).pathname;
-        return !location.pathname.startsWith(scopeURLBasePath);
-      };
-      if (currentPageIsOutOfScope()) {
-        logger.warn("The current page is not in scope for the registered " + "service worker. Was this a mistake?");
-      }
-    }
-
-    this._registration.addEventListener("updatefound", this._onUpdateFound);
-    navigator.serviceWorker.addEventListener("controllerchange", this._onControllerChange);
-
-    return this._registration;
-  }
-
-  /**
-   * Checks for updates of the registered service worker.
-   */
-  async update(): Promise<void> {
-    if (!this._registration) {
-      if (process.env.NODE_ENV !== "production") {
-        logger.error("Cannot update a Serwist instance without " + "being registered. Register the Serwist instance first.");
-      }
-      return;
-    }
-
-    // Try to update registration
-    await this._registration.update();
-  }
-
-  /**
-   * Resolves to the service worker registered by this instance as soon as it
-   * is active. If a service worker was already controlling at registration
-   * time then it will resolve to that if the script URLs (and optionally
-   * script versions) match, otherwise it will wait until an update is found
-   * and activates.
-   *
-   * @returns
-   */
-  get active(): Promise<ServiceWorker> {
-    return this._activeDeferred.promise;
-  }
-
-  /**
-   * Resolves to the service worker registered by this instance as soon as it
-   * is controlling the page. If a service worker was already controlling at
-   * registration time then it will resolve to that if the script URLs (and
-   * optionally script versions) match, otherwise it will wait until an update
-   * is found and starts controlling the page.
-   * Note: the first time a service worker is installed it will active but
-   * not start controlling the page unless `clients.claim()` is called in the
-   * service worker.
-   *
-   * @returns
-   */
-  get controlling(): Promise<ServiceWorker> {
-    return this._controllingDeferred.promise;
-  }
-
-  /**
-   * Resolves with a reference to a service worker that matches the script URL
-   * of this instance, as soon as it's available.
-   *
-   * If, at registration time, there's already an active or waiting service
-   * worker with a matching script URL, it will be used (with the waiting
-   * service worker taking precedence over the active service worker if both
-   * match, since the waiting service worker would have been registered more
-   * recently).
-   * If there's no matching active or waiting service worker at registration
-   * time then the promise will not resolve until an update is found and starts
-   * installing, at which point the installing service worker is used.
-   *
-   * @returns
-   */
-  getSW(): Promise<ServiceWorker> {
-    // If `this._sw` is set, resolve with that as we want `getSW()` to
-    // return the correct (new) service worker if an update is found.
-    return this._sw !== undefined ? Promise.resolve(this._sw) : this._swDeferred.promise;
-  }
-
-  /**
-   * Sends the passed data object to the service worker registered by this
-   * instance (via `@serwist/window.Serwist.getSW`) and resolves
-   * with a response (if any).
-   *
-   * A response can be set in a message handler in the service worker by
-   * calling `event.ports[0].postMessage(...)`, which will resolve the promise
-   * returned by `messageSW()`. If no response is set, the promise will never
-   * resolve.
-   *
-   * @param data An object to send to the service worker
-   * @returns
-   */
-  // We might be able to change the 'data' type to Record<string, unknown> in the future.
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  async messageSW(data: object): Promise<any> {
-    const sw = await this.getSW();
-    return messageSW(sw, data);
-  }
-
-  /**
-   * Sends a `{type: 'SKIP_WAITING'}` message to the service worker that's
-   * currently in the `waiting` state associated with the current registration.
-   *
-   * If there is no current registration or no service worker is `waiting`,
-   * calling this will have no effect.
-   */
-  messageSkipWaiting(): void {
-    if (this._registration && this._registration.waiting) {
-      void messageSW(this._registration.waiting, SKIP_WAITING_MESSAGE);
-    }
-  }
-
-  /**
-   * Checks for a service worker already controlling the page and returns
-   * it if its script URL matches.
-   *
-   * @private
-   * @returns
-   */
-  private _getControllingSWIfCompatible() {
-    const controller = navigator.serviceWorker.controller;
-    if (controller && urlsMatch(controller.scriptURL, this._scriptURL.toString())) {
-      return controller;
-    } else {
-      return undefined;
-    }
-  }
-
-  /**
-   * Registers a service worker for this instances script URL and register
-   * options and tracks the time registration was complete.
-   *
-   * @private
-   */
-  private async _registerScript() {
-    try {
-      // this._scriptURL may be a TrustedScriptURL, but there's no support for
-      // passing that to register() in lib.dom right now.
-      // https://github.com/GoogleChrome/workbox/issues/2855
-      const reg = await navigator.serviceWorker.register(this._scriptURL as string, this._registerOptions);
-
-      // Keep track of when registration happened, so it can be used in the
-      // `this._onUpdateFound` heuristic. Also use the presence of this
-      // property as a way to see if `.register()` has been called.
-      this._registrationTime = performance.now();
-
-      return reg;
-    } catch (error) {
-      if (process.env.NODE_ENV !== "production") {
-        logger.error(error);
-      }
-      // Re-throw the error.
-      throw error;
-    }
-  }
-
-  /**
-   * @private
-   */
-  private readonly _onUpdateFound = () => {
-    // `this._registration` will never be `undefined` after an update is found.
-    const registration = this._registration!;
-    const installingSW = registration.installing as ServiceWorker;
-
-    // If the script URL passed to `navigator.serviceWorker.register()` is
-    // different from the current controlling SW's script URL, we know any
-    // successful registration calls will trigger an `updatefound` event.
-    // But if the registered script URL is the same as the current controlling
-    // SW's script URL, we'll only get an `updatefound` event if the file
-    // changed since it was last registered. This can be a problem if the user
-    // opens up the same page in a different tab, and that page registers
-    // a SW that triggers an update. It's a problem because this page has no
-    // good way of knowing whether the `updatefound` event came from the SW
-    // script it registered or from a registration attempt made by a newer
-    // version of the page running in another tab.
-    // To minimize the possibility of a false positive, we use the logic here:
-    const updateLikelyTriggeredExternally =
-      // Since we enforce only calling `register()` once, and since we don't
-      // add the `updatefound` event listener until the `register()` call, if
-      // `_updateFoundCount` is > 0 then it means this method has already
-      // been called, thus this SW must be external
-      this._updateFoundCount > 0 ||
-      // If the script URL of the installing SW is different from this
-      // instance's script URL, we know it's definitely not from our
-      // registration.
-      !urlsMatch(installingSW.scriptURL, this._scriptURL.toString()) ||
-      // If all of the above are false, then we use a time-based heuristic:
-      // Any `updatefound` event that occurs long after our registration is
-      // assumed to be external.
-      performance.now() > this._registrationTime + REGISTRATION_TIMEOUT_DURATION
-        ? // If any of the above are not true, we assume the update was
-          // triggered by this instance.
-          true
-        : false;
-
-    if (updateLikelyTriggeredExternally) {
-      this._externalSW = installingSW;
-      registration.removeEventListener("updatefound", this._onUpdateFound);
-    } else {
-      // If the update was not triggered externally we know the installing
-      // SW is the one we registered, so we set it.
-      this._sw = installingSW;
-      this._ownSWs.add(installingSW);
-      this._swDeferred.resolve(installingSW);
-
-      // The `installing` state isn't something we have a dedicated
-      // callback for, but we do log messages for it in development.
-      if (process.env.NODE_ENV !== "production") {
-        if (navigator.serviceWorker.controller) {
-          logger.log("Updated service worker found. Installing now...");
-        } else {
-          logger.log("Service worker is installing...");
-        }
-      }
-    }
-
-    // Increment the `updatefound` count, so future invocations of this
-    // method can be sure they were triggered externally.
-    ++this._updateFoundCount;
-
-    // Add a `statechange` listener regardless of whether this update was
-    // triggered externally, since we have callbacks for both.
-    installingSW.addEventListener("statechange", this._onStateChange);
-  };
-
-  /**
-   * @private
-   * @param originalEvent
-   */
-  private readonly _onStateChange = (originalEvent: Event) => {
-    // `this._registration` will never be `undefined` after an update is found.
-    const registration = this._registration!;
-    const sw = originalEvent.target as ServiceWorker;
-    const { state } = sw;
-    const isExternal = sw === this._externalSW;
-
-    const eventProps: {
-      sw: ServiceWorker;
-      originalEvent: Event;
-      isUpdate?: boolean;
-      isExternal: boolean;
-    } = {
-      sw,
-      isExternal,
-      originalEvent,
-    };
-    if (!isExternal && this._isUpdate) {
-      eventProps.isUpdate = true;
-    }
-
-    this.dispatchEvent(new SerwistEvent(state as keyof SerwistLifecycleEventMap, eventProps));
-
-    if (state === "installed") {
-      // This timeout is used to ignore cases where the service worker calls
-      // `skipWaiting()` in the install event, thus moving it directly in the
-      // activating state. (Since all service workers *must* go through the
-      // waiting phase, the only way to detect `skipWaiting()` called in the
-      // install event is to observe that the time spent in the waiting phase
-      // is very short.)
-      // NOTE: we don't need separate timeouts for the own and external SWs
-      // since they can't go through these phases at the same time.
-      this._waitingTimeout = self.setTimeout(() => {
-        // Ensure the SW is still waiting (it may now be redundant).
-        if (state === "installed" && registration.waiting === sw) {
-          this.dispatchEvent(new SerwistEvent("waiting", eventProps));
-
-          if (process.env.NODE_ENV !== "production") {
-            if (isExternal) {
-              logger.warn("An external service worker has installed but is " + "waiting for this client to close before activating...");
-            } else {
-              logger.warn("The service worker has installed but is waiting " + "for existing clients to close before activating...");
-            }
-          }
-        }
-      }, WAITING_TIMEOUT_DURATION);
-    } else if (state === "activating") {
-      clearTimeout(this._waitingTimeout);
-      if (!isExternal) {
-        this._activeDeferred.resolve(sw);
-      }
-    }
-
-    if (process.env.NODE_ENV !== "production") {
-      switch (state) {
-        case "installed":
-          if (isExternal) {
-            logger.warn("An external service worker has installed. " + "You may want to suggest users reload this page.");
-          } else {
-            logger.log("Registered service worker installed.");
-          }
-          break;
-        case "activated":
-          if (isExternal) {
-            logger.warn("An external service worker has activated.");
-          } else {
-            logger.log("Registered service worker activated.");
-            if (sw !== navigator.serviceWorker.controller) {
-              logger.warn(
-                "The registered service worker is active but " +
-                  "not yet controlling the page. Reload or run " +
-                  "`clients.claim()` in the service worker."
-              );
-            }
-          }
-          break;
-        case "redundant":
-          if (sw === this._compatibleControllingSW) {
-            logger.log("Previously controlling service worker now redundant!");
-          } else if (!isExternal) {
-            logger.log("Registered service worker now redundant!");
-          }
-          break;
-      }
-    }
-  };
-
-  /**
-   * @private
-   * @param originalEvent
-   */
-  private readonly _onControllerChange = (originalEvent: Event) => {
-    const sw = this._sw;
-    const isExternal = sw !== navigator.serviceWorker.controller;
-
-    // Unconditionally dispatch the controlling event, with isExternal set
-    // to distinguish between controller changes due to the initial registration
-    // vs. an update-check or other tab's registration.
-    // See https://github.com/GoogleChrome/workbox/issues/2786
-    this.dispatchEvent(
-      new SerwistEvent("controlling", {
-        isExternal,
-        originalEvent,
-        sw,
-        isUpdate: this._isUpdate,
-      })
-    );
-
-    if (!isExternal) {
-      if (process.env.NODE_ENV !== "production") {
-        logger.log("Registered service worker now controlling this page.");
-      }
-      this._controllingDeferred.resolve(sw);
-    }
-  };
-
-  /**
-   * @private
-   * @param originalEvent
-   */
-  private readonly _onMessage = async (originalEvent: MessageEvent) => {
-    // Can't change type 'any' of data.
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const { data, ports, source } = originalEvent;
-
-    // Wait until there's an "own" service worker. This is used to buffer
-    // `message` events that may be received prior to calling `register()`.
-    await this.getSW();
-
-    // If the service worker that sent the message is in the list of own
-    // service workers for this instance, dispatch a `message` event.
-    // NOTE: we check for all previously owned service workers rather than
-    // just the current one because some messages (e.g. cache updates) use
-    // a timeout when sent and may be delayed long enough for a service worker
-    // update to be found.
-    if (this._ownSWs.has(source as ServiceWorker)) {
-      this.dispatchEvent(
-        new SerwistEvent("message", {
-          // Can't change type 'any' of data.
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-          data,
-          originalEvent,
-          ports,
-          sw: source as ServiceWorker,
-        })
-      );
-    }
-  };
-}
-
-// The jsdoc comments below outline the events this instance may dispatch:
-// -----------------------------------------------------------------------
-
-/**
- * The `message` event is dispatched any time a `postMessage` is received.
- *
- * @event workbox-window.Workbox#message
- * @type {SerwistEvent}
- * @property {*} data The `data` property from the original `message` event.
- * @property {Event} originalEvent The original [`message`]{@link https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent}
- *     event.
- * @property {string} type `message`.
- * @property {MessagePort[]} ports The `ports` value from `originalEvent`.
- * @property {Workbox} target The `Workbox` instance.
- */
-
-/**
- * The `installed` event is dispatched if the state of a
- * {@link workbox-window.Workbox} instance's
- * {@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw|registered service worker}
- * changes to `installed`.
- *
- * Then can happen either the very first time a service worker is installed,
- * or after an update to the current service worker is found. In the case
- * of an update being found, the event's `isUpdate` property will be `true`.
- *
- * @event workbox-window.Workbox#installed
- * @type {SerwistEvent}
- * @property {ServiceWorker} sw The service worker instance.
- * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
- *     event.
- * @property {boolean|undefined} isUpdate True if a service worker was already
- *     controlling when this `Workbox` instance called `register()`.
- * @property {boolean|undefined} isExternal True if this event is associated
- *     with an [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}.
- * @property {string} type `installed`.
- * @property {Workbox} target The `Workbox` instance.
- */
-
-/**
- * The `waiting` event is dispatched if the state of a
- * {@link workbox-window.Workbox} instance's
- * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}
- * changes to `installed` and then doesn't immediately change to `activating`.
- * It may also be dispatched if a service worker with the same
- * [`scriptURL`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/scriptURL}
- * was already waiting when the {@link workbox-window.Workbox#register}
- * method was called.
- *
- * @event workbox-window.Workbox#waiting
- * @type {SerwistEvent}
- * @property {ServiceWorker} sw The service worker instance.
- * @property {Event|undefined} originalEvent The original
- *    [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
- *     event, or `undefined` in the case where the service worker was waiting
- *     to before `.register()` was called.
- * @property {boolean|undefined} isUpdate True if a service worker was already
- *     controlling when this `Workbox` instance called `register()`.
- * @property {boolean|undefined} isExternal True if this event is associated
- *     with an [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}.
- * @property {boolean|undefined} wasWaitingBeforeRegister True if a service worker with
- *     a matching `scriptURL` was already waiting when this `Workbox`
- *     instance called `register()`.
- * @property {string} type `waiting`.
- * @property {Workbox} target The `Workbox` instance.
- */
-
-/**
- * The `controlling` event is dispatched if a
- * [`controllerchange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/oncontrollerchange}
- * fires on the service worker [container]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer}
- * and the [`scriptURL`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/scriptURL}
- * of the new [controller]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/controller}
- * matches the `scriptURL` of the `Workbox` instance's
- * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}.
- *
- * @event workbox-window.Workbox#controlling
- * @type {SerwistEvent}
- * @property {ServiceWorker} sw The service worker instance.
- * @property {Event} originalEvent The original [`controllerchange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/oncontrollerchange}
- *     event.
- * @property {boolean|undefined} isUpdate True if a service worker was already
- *     controlling when this service worker was registered.
- * @property {boolean|undefined} isExternal True if this event is associated
- *     with an [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}.
- * @property {string} type `controlling`.
- * @property {Workbox} target The `Workbox` instance.
- */
-
-/**
- * The `activated` event is dispatched if the state of a
- * {@link workbox-window.Workbox} instance's
- * {@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw|registered service worker}
- * changes to `activated`.
- *
- * @event workbox-window.Workbox#activated
- * @type {SerwistEvent}
- * @property {ServiceWorker} sw The service worker instance.
- * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
- *     event.
- * @property {boolean|undefined} isUpdate True if a service worker was already
- *     controlling when this `Workbox` instance called `register()`.
- * @property {boolean|undefined} isExternal True if this event is associated
- *     with an [external service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-window#when_an_unexpected_version_of_the_service_worker_is_found}.
- * @property {string} type `activated`.
- * @property {Workbox} target The `Workbox` instance.
- */
-
-/**
- * The `redundant` event is dispatched if the state of a
- * {@link workbox-window.Workbox} instance's
- * [registered service worker]{@link https://developers.google.com/web/tools/workbox/modules/workbox-precaching#def-registered-sw}
- * changes to `redundant`.
- *
- * @event workbox-window.Workbox#redundant
- * @type {SerwistEvent}
- * @property {ServiceWorker} sw The service worker instance.
- * @property {Event} originalEvent The original [`statechange`]{@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorker/onstatechange}
- *     event.
- * @property {boolean|undefined} isUpdate True if a service worker was already
- *     controlling when this `Workbox` instance called `register()`.
- * @property {string} type `redundant`.
- * @property {Workbox} target The `Workbox` instance.
- */

package/src/index.ts

@@ -1,15 +0,0 @@
-/*
-  Copyright 2019 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/
-
-import { messageSW } from "./messageSW.js";
-import { Serwist } from "./Serwist.js";
-
-export { messageSW, Serwist };
-
-// See https://github.com/GoogleChrome/workbox/issues/2770
-export * from "./utils/SerwistEvent.js";

package/src/messageSW.ts

@@ -1,34 +0,0 @@
-/*
-  Copyright 2019 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/
-
-/**
- * Sends a data object to a service worker via `postMessage` and resolves with
- * a response (if any).
- *
- * A response can be set in a message handler in the service worker by
- * calling `event.ports[0].postMessage(...)`, which will resolve the promise
- * returned by `messageSW()`. If no response is set, the promise will not
- * resolve.
- *
- * @param sw The service worker to send the message to.
- * @param data An object to send to the service worker.
- * @returns
- */
-// Better not change type of data.
-// eslint-disable-next-line @typescript-eslint/ban-types
-function messageSW(sw: ServiceWorker, data: {}): Promise<any> {
-  return new Promise((resolve) => {
-    const messageChannel = new MessageChannel();
-    messageChannel.port1.onmessage = (event: MessageEvent) => {
-      resolve(event.data);
-    };
-    sw.postMessage(data, [messageChannel.port2]);
-  });
-}
-
-export { messageSW };

package/src/utils/SerwistEvent.ts

@@ -1,57 +0,0 @@
-/*
-  Copyright 2019 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/
-
-import type { SerwistEventTarget } from "./SerwistEventTarget.js";
-
-/**
- * A minimal `Event` subclass shim.
- * This doesn't *actually* subclass `Event` because not all browsers support
- * constructable `EventTarget`, and using a real `Event` will error.
- * @private
- */
-export class SerwistEvent<K extends keyof SerwistEventMap> {
-  target?: SerwistEventTarget;
-  sw?: ServiceWorker;
-  originalEvent?: Event;
-  isExternal?: boolean;
-
-  constructor(
-    public type: K,
-    props: Omit<SerwistEventMap[K], "target" | "type">
-  ) {
-    Object.assign(this, props);
-  }
-}
-
-export interface SerwistMessageEvent extends SerwistEvent<"message"> {
-  data: any;
-  originalEvent: Event;
-  ports: readonly MessagePort[];
-}
-
-export interface SerwistLifecycleEvent extends SerwistEvent<keyof SerwistLifecycleEventMap> {
-  isUpdate?: boolean;
-}
-
-export interface SerwistLifecycleWaitingEvent extends SerwistLifecycleEvent {
-  wasWaitingBeforeRegister?: boolean;
-}
-
-export interface SerwistLifecycleEventMap {
-  installing: SerwistLifecycleEvent;
-  installed: SerwistLifecycleEvent;
-  waiting: SerwistLifecycleWaitingEvent;
-  activating: SerwistLifecycleEvent;
-  activated: SerwistLifecycleEvent;
-  controlling: SerwistLifecycleEvent;
-  redundant: SerwistLifecycleEvent;
-}
-
-export interface SerwistEventMap extends SerwistLifecycleEventMap {
-  message: SerwistMessageEvent;
-}

package/src/utils/SerwistEventTarget.ts

@@ -1,68 +0,0 @@
-/*
-  Copyright 2019 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/
-
-import type { SerwistEvent, SerwistEventMap } from "./SerwistEvent.js";
-
-export type ListenerCallback = (event: SerwistEvent<any>) => any;
-
-/**
- * A minimal `EventTarget` shim.
- * This is necessary because not all browsers support constructable
- * `EventTarget`, so using a real `EventTarget` will error.
- * @private
- */
-export class SerwistEventTarget {
-  private readonly _eventListenerRegistry: Map<keyof SerwistEventMap, Set<ListenerCallback>> = new Map();
-
-  /**
-   * @param type
-   * @param listener
-   * @private
-   */
-  addEventListener<K extends keyof SerwistEventMap>(type: K, listener: (event: SerwistEventMap[K]) => any): void {
-    const foo = this._getEventListenersByType(type);
-    foo.add(listener as ListenerCallback);
-  }
-
-  /**
-   * @param type
-   * @param listener
-   * @private
-   */
-  removeEventListener<K extends keyof SerwistEventMap>(type: K, listener: (event: SerwistEventMap[K]) => any): void {
-    this._getEventListenersByType(type).delete(listener as ListenerCallback);
-  }
-
-  /**
-   * @param event
-   * @private
-   */
-  dispatchEvent(event: SerwistEvent<any>): void {
-    event.target = this;
-
-    const listeners = this._getEventListenersByType(event.type);
-    for (const listener of listeners) {
-      listener(event);
-    }
-  }
-
-  /**
-   * Returns a Set of listeners associated with the passed event type.
-   * If no handlers have been registered, an empty Set is returned.
-   *
-   * @param type The event type.
-   * @returns An array of handler functions.
-   * @private
-   */
-  private _getEventListenersByType(type: keyof SerwistEventMap) {
-    if (!this._eventListenerRegistry.has(type)) {
-      this._eventListenerRegistry.set(type, new Set());
-    }
-    return this._eventListenerRegistry.get(type)!;
-  }
-}

package/src/utils/urlsMatch.ts

@@ -1,21 +0,0 @@
-/*
-  Copyright 2019 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/
-
-/**
- * Returns true if two URLs have the same `.href` property. The URLS can be
- * relative, and if they are the current location href is used to resolve URLs.
- *
- * @private
- * @param url1
- * @param url2
- * @returns
- */
-export function urlsMatch(url1: string, url2: string): boolean {
-  const { href } = location;
-  return new URL(url1, href).href === new URL(url2, href).href;
-}

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "module": "NodeNext"
-  },
-  "include": ["**/*.ts", "rollup.config.js", "src/Serwist.js"],
-  "exclude": ["dist", "node_modules"]
-}