@india-boundary-corrector/service-worker 0.0.1

package/dist/index.global.js

@@ -0,0 +1,622 @@
+"use strict";
+var IndiaBoundaryCorrector = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.js
+  var index_exports = {};
+  __export(index_exports, {
+    CorrectionServiceWorker: () => CorrectionServiceWorker,
+    LayerConfig: () => LayerConfig,
+    MessageTypes: () => MessageTypes,
+    getPmtilesUrl: () => getPmtilesUrl,
+    getWorkerImportSnippet: () => getWorkerImportSnippet,
+    layerConfigs: () => layerConfigs,
+    registerCorrectionServiceWorker: () => registerCorrectionServiceWorker
+  });
+
+  // ../layer-configs/dist/index.js
+  var configs_default = [
+    {
+      id: "cartodb-dark",
+      zoomThreshold: 5,
+      tileUrlTemplates: [
+        "https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}{r}.png",
+        "https://basemaps.cartocdn.com/dark_all/{z}/{x}/{y}{r}.png",
+        "https://cartodb-basemaps-{s}.global.ssl.fastly.net/dark_all/{z}/{x}/{y}{r}.png",
+        "https://{s}.basemaps.cartocdn.com/dark_nolabels/{z}/{x}/{y}{r}.png",
+        "https://basemaps.cartocdn.com/dark_nolabels/{z}/{x}/{y}{r}.png",
+        "https://cartodb-basemaps-{s}.global.ssl.fastly.net/dark_nolabels/{z}/{x}/{y}{r}.png"
+      ],
+      lineWidthStops: { "1": 0.5, "10": 2.5 },
+      lineStyles: [
+        { color: "rgb(40, 40, 40)" }
+      ]
+    },
+    {
+      id: "cartodb-light",
+      startZoom: 0,
+      zoomThreshold: 5,
+      tileUrlTemplates: [
+        "https://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}{r}.png",
+        "https://basemaps.cartocdn.com/light_all/{z}/{x}/{y}{r}.png",
+        "https://cartodb-basemaps-{s}.global.ssl.fastly.net/light_all/{z}/{x}/{y}{r}.png",
+        "https://{s}.basemaps.cartocdn.com/light_nolabels/{z}/{x}/{y}{r}.png",
+        "https://basemaps.cartocdn.com/light_nolabels/{z}/{x}/{y}{r}.png",
+        "https://cartodb-basemaps-{s}.global.ssl.fastly.net/light_nolabels/{z}/{x}/{y}{r}.png",
+        "https://{s}.basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}{r}.png",
+        "https://basemaps.cartocdn.com/rastertiles/voyager/{z}/{x}/{y}{r}.png",
+        "https://{s}.basemaps.cartocdn.com/rastertiles/voyager_nolabels/{z}/{x}/{y}{r}.png",
+        "https://basemaps.cartocdn.com/rastertiles/voyager_nolabels/{z}/{x}/{y}{r}.png",
+        "https://{s}.basemaps.cartocdn.com/rastertiles/voyager_labels_under/{z}/{x}/{y}{r}.png",
+        "https://basemaps.cartocdn.com/rastertiles/voyager_labels_under/{z}/{x}/{y}{r}.png"
+      ],
+      lineWidthStops: { "1": 0.25, "2": 0.25, "3": 0.5, "4": 0.75, "5": 1 },
+      lineStyles: [
+        { color: "rgb(235, 214, 214)", alpha: 0.2, startZoom: 6, widthFraction: 5 },
+        { color: "rgb(235, 214, 214)" }
+      ]
+    },
+    {
+      id: "open-topo",
+      startZoom: 4,
+      zoomThreshold: 4,
+      tileUrlTemplates: [
+        "https://{s}.tile.opentopomap.org/{z}/{x}/{y}.png",
+        "https://tile.opentopomap.org/{z}/{x}/{y}.png"
+      ],
+      lineWidthStops: { "4": 0.75, "5": 1, "6": 1.25, "7": 1.5, "8": 1.75, "9": 1.25, "10": 1.25, "13": 1.5 },
+      lineStyles: [
+        { color: "rgb(83, 83, 83)", startZoom: 7, endZoom: 8, alpha: 0.4, widthFraction: 4 },
+        { color: "rgb(83, 83, 83)", endZoom: 8 },
+        { color: "rgb(140, 20, 180)", startZoom: 9, widthFraction: 9, alpha: 0.2 },
+        { color: "rgb(140, 20, 180)", startZoom: 9 }
+      ]
+    },
+    {
+      id: "osm-carto",
+      startZoom: 1,
+      zoomThreshold: 1,
+      tileUrlTemplates: [
+        "https://tile.openstreetmap.org/{z}/{x}/{y}.png",
+        "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png"
+      ],
+      lineWidthStops: { "1": 0.5, "2": 0.6, "3": 0.7, "4": 1, "10": 3.75 },
+      lineStyles: [
+        { color: "rgb(200, 180, 200)" },
+        { color: "rgb(160, 120, 160)", widthFraction: 0.333, dashArray: [30, 2, 8, 2] }
+      ]
+    },
+    {
+      id: "osm-hot",
+      startZoom: 2,
+      zoomThreshold: 2,
+      tileUrlTemplates: [
+        "https://{s}.tile.openstreetmap.fr/hot/{z}/{x}/{y}.png"
+      ],
+      lineWidthStops: { "2": 3, "3": 3, "7": 3, "8": 3.5, "9": 3.5 },
+      lineStyles: [
+        { color: "rgb(149, 175, 180)" },
+        { color: "rgb(89, 117, 123)", widthFraction: 0.33 }
+      ]
+    }
+  ];
+  function templateToRegex(template) {
+    const groups = [];
+    let pattern = template.replace(/[.*+?^${}()|[\]\\]/g, (char) => {
+      if (char === "{" || char === "}") return char;
+      return "\\" + char;
+    }).replace(/^https:\/\//, "https?://").replace(/^http:\/\//, "https?://").replace(/\{[a-z0-9]-[a-z0-9]\}/gi, () => {
+      groups.push("s");
+      return "([a-z0-9]+)";
+    }).replace(/\{(z|x|y|s|r)\}/gi, (_, name) => {
+      const lowerName = name.toLowerCase();
+      groups.push(lowerName);
+      if (lowerName === "s") {
+        return "([a-z0-9]+)";
+      }
+      if (lowerName === "r") {
+        return "(@\\d+x)?";
+      }
+      return "(\\d+)";
+    });
+    return { pattern: new RegExp("^" + pattern + "(\\?.*)?$", "i"), groups };
+  }
+  function templateToTemplateRegex(template) {
+    let pattern = template.replace(/[.*+?^${}()|[\]\\]/g, (char) => {
+      if (char === "{" || char === "}") return char;
+      return "\\" + char;
+    }).replace(/^https:\/\//, "https?://").replace(/^http:\/\//, "https?://").replace(/\{([a-z0-9])-([a-z0-9])\}/gi, (_, start, end) => `(\\{${start}-${end}\\}|[a-z0-9]+)`).replace(/\{(z|x|y|s|r)\}/gi, (_, name) => {
+      const lowerName = name.toLowerCase();
+      if (lowerName === "s") {
+        return "(\\{s\\}|[a-z0-9]+)";
+      }
+      if (lowerName === "r") {
+        return "(\\{r\\}|@\\d+x)?";
+      }
+      return `\\{${lowerName}\\}`;
+    });
+    return new RegExp("^" + pattern + "(\\?.*)?$", "i");
+  }
+  var LayerConfig = class _LayerConfig {
+    constructor({
+      id,
+      startZoom = 0,
+      zoomThreshold = 5,
+      // Tile URL templates for matching (e.g., "https://{s}.tile.example.com/{z}/{x}/{y}.png")
+      tileUrlTemplates = [],
+      // Line width stops: map of zoom level to line width (at least 2 entries)
+      lineWidthStops = { 1: 0.5, 10: 2.5 },
+      // Line styles array - each element describes a line to draw
+      // { color: string, widthFraction?: number, dashArray?: number[], startZoom?: number, endZoom?: number }
+      // Lines are drawn in array order. startZoom defaults to layerConfig startZoom, endZoom defaults to Infinity
+      lineStyles = [{ color: "green", widthFraction: 1 }],
+      // Factor to multiply line width for deletion blur (default 1.5)
+      // Higher values leave gaps where wiped lines meet existing lines
+      // Lower values mean wiped lines show through
+      delWidthFactor = 1.5,
+      // Factor to extend add lines by (multiplied by deletion line width)
+      // Helps cover gaps where deleted lines meet the new boundary
+      // Set to 0 to disable extension
+      lineExtensionFactor = 0.5
+    }) {
+      if (!id || typeof id !== "string") {
+        throw new Error("LayerConfig requires a non-empty string id");
+      }
+      this.id = id;
+      this.startZoom = startZoom;
+      this.zoomThreshold = zoomThreshold;
+      if (startZoom > zoomThreshold) {
+        throw new Error(`LayerConfig "${id}": startZoom (${startZoom}) must be <= zoomThreshold (${zoomThreshold})`);
+      }
+      const templates = Array.isArray(tileUrlTemplates) ? tileUrlTemplates : tileUrlTemplates ? [tileUrlTemplates] : [];
+      this.tileUrlTemplates = templates;
+      this._compiledPatterns = templates.map((t) => templateToRegex(t));
+      this._templatePatterns = templates.map((t) => templateToTemplateRegex(t));
+      if (!lineWidthStops || typeof lineWidthStops !== "object" || Array.isArray(lineWidthStops)) {
+        throw new Error(`LayerConfig "${id}": lineWidthStops must be an object`);
+      }
+      const stopKeys = Object.keys(lineWidthStops);
+      if (stopKeys.length < 2) {
+        throw new Error(`LayerConfig "${id}": lineWidthStops must have at least 2 entries`);
+      }
+      for (const key of stopKeys) {
+        const zoom = Number(key);
+        if (!Number.isInteger(zoom) || zoom < 0) {
+          throw new Error(`LayerConfig "${id}": lineWidthStops keys must be non-negative integers, got "${key}"`);
+        }
+        if (typeof lineWidthStops[key] !== "number" || lineWidthStops[key] <= 0) {
+          throw new Error(`LayerConfig "${id}": lineWidthStops values must be positive numbers`);
+        }
+      }
+      this.lineWidthStops = lineWidthStops;
+      if (!Array.isArray(lineStyles) || lineStyles.length === 0) {
+        throw new Error(`LayerConfig "${id}": lineStyles must be a non-empty array`);
+      }
+      for (let i = 0; i < lineStyles.length; i++) {
+        const style = lineStyles[i];
+        if (!style || typeof style !== "object") {
+          throw new Error(`LayerConfig "${id}": lineStyles[${i}] must be an object`);
+        }
+        if (!style.color || typeof style.color !== "string") {
+          throw new Error(`LayerConfig "${id}": lineStyles[${i}].color must be a non-empty string`);
+        }
+      }
+      this.lineStyles = lineStyles.map((style) => ({
+        ...style,
+        startZoom: style.startZoom ?? startZoom,
+        endZoom: style.endZoom ?? Infinity
+      }));
+      this.delWidthFactor = delWidthFactor;
+      this.lineExtensionFactor = lineExtensionFactor;
+    }
+    /**
+     * Get line styles active at a given zoom level
+     * @param {number} z - Zoom level
+     * @returns {Array<{color: string, widthFraction?: number, dashArray?: number[]}>}
+     */
+    getLineStylesForZoom(z) {
+      return this.lineStyles.filter((style) => z >= style.startZoom && z <= style.endZoom);
+    }
+    /**
+     * Check if this config matches the given template URLs (with {z}/{x}/{y} placeholders)
+     * @param {string | string[]} templates - Single template URL or array of template URLs
+     * @returns {boolean}
+     */
+    matchTemplate(templates) {
+      if (this._templatePatterns.length === 0) return false;
+      const urls = Array.isArray(templates) ? templates : [templates];
+      if (urls.length === 0) return false;
+      return urls.some(
+        (url) => this._templatePatterns.some((pattern) => pattern.test(url))
+      );
+    }
+    /**
+     * Check if this config matches the given tile URLs (with actual coordinates)
+     * @param {string | string[]} tiles - Single tile URL or array of tile URLs
+     * @returns {boolean}
+     */
+    matchTileUrl(tiles) {
+      if (this._compiledPatterns.length === 0) return false;
+      const urls = Array.isArray(tiles) ? tiles : [tiles];
+      if (urls.length === 0) return false;
+      return urls.some(
+        (url) => this._compiledPatterns.some(({ pattern }) => pattern.test(url))
+      );
+    }
+    /**
+     * Extract tile coordinates (z, x, y) from a URL using this config's templates
+     * @param {string} url - Tile URL to extract coordinates from
+     * @returns {{ z: number, x: number, y: number } | null}
+     */
+    extractCoords(url) {
+      for (const { pattern, groups } of this._compiledPatterns) {
+        const match = url.match(pattern);
+        if (match) {
+          const result = {};
+          for (let i = 0; i < groups.length; i++) {
+            const name = groups[i];
+            const value = match[i + 1];
+            if (name === "z" || name === "x" || name === "y") {
+              result[name] = parseInt(value, 10);
+            }
+          }
+          if ("z" in result && "x" in result && "y" in result) {
+            return { z: result.z, x: result.x, y: result.y };
+          }
+        }
+      }
+      return null;
+    }
+    /**
+     * Serialize the config to a plain object for postMessage
+     * @returns {Object}
+     */
+    toJSON() {
+      return {
+        id: this.id,
+        startZoom: this.startZoom,
+        zoomThreshold: this.zoomThreshold,
+        tileUrlTemplates: this.tileUrlTemplates,
+        lineWidthStops: this.lineWidthStops,
+        lineStyles: this.lineStyles,
+        delWidthFactor: this.delWidthFactor,
+        lineExtensionFactor: this.lineExtensionFactor
+      };
+    }
+    /**
+     * Create a LayerConfig from a plain object (e.g., from postMessage)
+     * @param {Object} obj
+     * @returns {LayerConfig}
+     */
+    static fromJSON(obj) {
+      return new _LayerConfig(obj);
+    }
+  };
+  var LayerConfigRegistry = class _LayerConfigRegistry {
+    constructor() {
+      this.registry = {};
+    }
+    /**
+     * Get a layer config by id
+     */
+    get(id) {
+      return this.registry[id];
+    }
+    /**
+     * Register a new layer config
+     */
+    register(config) {
+      this.registry[config.id] = config;
+    }
+    /**
+     * Remove a layer config by id
+     */
+    remove(id) {
+      if (!this.registry[id]) return false;
+      delete this.registry[id];
+      return true;
+    }
+    /**
+     * Detect layer config from tile URL templates (with {z}/{x}/{y} placeholders)
+     * @param {string | string[]} templates - Single template URL or array of template URLs
+     */
+    detectFromTemplates(templates) {
+      if (!templates || Array.isArray(templates) && templates.length === 0) return void 0;
+      for (const config of Object.values(this.registry)) {
+        if (config.matchTemplate(templates)) {
+          return config;
+        }
+      }
+      return void 0;
+    }
+    /**
+     * Detect layer config from actual tile URLs (with numeric coordinates)
+     * @param {string | string[]} urls - Single tile URL or array of tile URLs
+     */
+    detectFromTileUrls(urls) {
+      if (!urls || Array.isArray(urls) && urls.length === 0) return void 0;
+      for (const config of Object.values(this.registry)) {
+        if (config.matchTileUrl(urls)) {
+          return config;
+        }
+      }
+      return void 0;
+    }
+    /**
+     * Get all available layer config ids
+     */
+    getAvailableIds() {
+      return Object.keys(this.registry);
+    }
+    /**
+     * Create a new registry with all configs from this registry plus extra configs.
+     * @param {LayerConfig[]} extraLayerConfigs - Additional configs to add
+     * @returns {LayerConfigRegistry} A new registry with merged configs
+     */
+    createMergedRegistry(extraLayerConfigs) {
+      const registry = new _LayerConfigRegistry();
+      for (const id of this.getAvailableIds()) {
+        registry.register(this.get(id));
+      }
+      if (extraLayerConfigs && extraLayerConfigs.length > 0) {
+        for (const config of extraLayerConfigs) {
+          registry.register(config);
+        }
+      }
+      return registry;
+    }
+    /**
+     * Parse a tile URL into its components: layer config and coordinates
+     * @param {string} url - Tile URL to parse
+     * @returns {{ layerConfig: LayerConfig, coords: { z: number, x: number, y: number } } | null}
+     */
+    parseTileUrl(url) {
+      const layerConfig = this.detectFromTileUrls([url]);
+      if (!layerConfig) return null;
+      const coords = layerConfig.extractCoords(url);
+      if (!coords) return null;
+      return { layerConfig, coords };
+    }
+  };
+  var layerConfigs = new LayerConfigRegistry();
+  for (const configData of configs_default) {
+    layerConfigs.register(new LayerConfig(configData));
+  }
+
+  // ../data/version.js
+  var packageVersion = "0.0.1";
+
+  // ../data/index.js
+  var import_meta = {};
+  var PACKAGE_NAME = "@india-boundary-corrector/data";
+  var PMTILES_FILENAME = "india_boundary_corrections.pmtiles";
+  var DEFAULT_CDN_URL = `https://unpkg.com/${PACKAGE_NAME}@${packageVersion}/${PMTILES_FILENAME}`;
+  function detectPmtilesUrl() {
+    try {
+      if (typeof import_meta !== "undefined" && import_meta.url) {
+        const moduleUrl = new URL(".", import_meta.url);
+        return new URL(PMTILES_FILENAME, moduleUrl).href;
+      }
+    } catch {
+    }
+    return DEFAULT_CDN_URL;
+  }
+  var cachedPmtilesUrl = null;
+  function getPmtilesUrl() {
+    if (cachedPmtilesUrl === null) {
+      cachedPmtilesUrl = detectPmtilesUrl();
+    }
+    return cachedPmtilesUrl;
+  }
+
+  // src/index.js
+  var MessageTypes = {
+    ADD_LAYER_CONFIG: "ADD_LAYER_CONFIG",
+    REMOVE_LAYER_CONFIG: "REMOVE_LAYER_CONFIG",
+    SET_PMTILES_URL: "SET_PMTILES_URL",
+    SET_ENABLED: "SET_ENABLED",
+    CLEAR_CACHE: "CLEAR_CACHE",
+    GET_STATUS: "GET_STATUS",
+    RESET_CONFIG: "RESET_CONFIG"
+  };
+  var CorrectionServiceWorker = class {
+    /**
+     * @param {string} workerUrl - URL to the service worker script
+     * @param {Object} [options]
+     * @param {string} [options.scope] - Service worker scope (defaults to workerUrl directory)
+     * @param {string} [options.pmtilesUrl] - PMTiles URL to set after registration
+     * @param {number} [options.controllerTimeout=3000] - Timeout in ms to wait for SW to take control
+     */
+    constructor(workerUrl, options = {}) {
+      this._workerUrl = workerUrl;
+      this._scope = options.scope;
+      this._pmtilesUrl = options.pmtilesUrl;
+      this._controllerTimeout = options.controllerTimeout ?? 3e3;
+      this._registration = null;
+    }
+    /**
+     * Register the service worker and wait for it to take control.
+     * @returns {Promise<CorrectionServiceWorker>} Returns this instance for chaining
+     * @throws {Error} If service workers not supported or registration fails
+     */
+    async register() {
+      if (!("serviceWorker" in navigator)) {
+        throw new Error("Service workers not supported");
+      }
+      const regOptions = this._scope ? { scope: this._scope } : void 0;
+      this._registration = await navigator.serviceWorker.register(
+        this._workerUrl,
+        regOptions
+      );
+      await navigator.serviceWorker.ready;
+      if (!navigator.serviceWorker.controller) {
+        await this._waitForController();
+      }
+      await this.resetConfig();
+      if (this._pmtilesUrl) {
+        await this.setPmtilesUrl(this._pmtilesUrl);
+      }
+      return this;
+    }
+    /**
+     * Wait for the service worker to take control of the page.
+     * @returns {Promise<void>}
+     * @private
+     */
+    async _waitForController() {
+      return new Promise((resolve) => {
+        const onControllerChange = () => {
+          navigator.serviceWorker.removeEventListener("controllerchange", onControllerChange);
+          resolve();
+        };
+        navigator.serviceWorker.addEventListener("controllerchange", onControllerChange);
+        setTimeout(resolve, this._controllerTimeout);
+      });
+    }
+    /**
+     * Check if the service worker is controlling the page.
+     * @returns {boolean}
+     */
+    isControlling() {
+      return !!navigator.serviceWorker.controller;
+    }
+    /**
+     * Unregister the service worker.
+     * @returns {Promise<boolean>}
+     */
+    async unregister() {
+      if (this._registration) {
+        return this._registration.unregister();
+      }
+      return false;
+    }
+    /**
+     * Get the active service worker.
+     * @returns {ServiceWorker|null}
+     */
+    getWorker() {
+      return this._registration?.active ?? navigator.serviceWorker.controller;
+    }
+    /**
+     * Send a message to the service worker.
+     * @param {Object} message
+     * @returns {Promise<any>}
+     */
+    async sendMessage(message) {
+      const worker = this.getWorker();
+      if (!worker) {
+        throw new Error("Service worker not active");
+      }
+      return new Promise((resolve, reject) => {
+        const channel = new MessageChannel();
+        channel.port1.onmessage = (event) => {
+          if (event.data.error) {
+            reject(new Error(event.data.error));
+          } else {
+            resolve(event.data);
+          }
+        };
+        worker.postMessage(message, [channel.port2]);
+      });
+    }
+    /**
+     * Add a layer config to the service worker.
+     * @param {Object} layerConfig
+     * @returns {Promise<void>}
+     */
+    async addLayerConfig(layerConfig) {
+      const serialized = typeof layerConfig.toJSON === "function" ? layerConfig.toJSON() : layerConfig;
+      await this.sendMessage({
+        type: MessageTypes.ADD_LAYER_CONFIG,
+        layerConfig: serialized
+      });
+    }
+    /**
+     * Remove a layer config from the service worker.
+     * @param {string} configId
+     * @returns {Promise<void>}
+     */
+    async removeLayerConfig(configId) {
+      await this.sendMessage({
+        type: MessageTypes.REMOVE_LAYER_CONFIG,
+        configId
+      });
+    }
+    /**
+     * Set the PMTiles URL.
+     * @param {string} pmtilesUrl
+     * @returns {Promise<void>}
+     */
+    async setPmtilesUrl(pmtilesUrl) {
+      await this.sendMessage({
+        type: MessageTypes.SET_PMTILES_URL,
+        pmtilesUrl
+      });
+    }
+    /**
+     * Enable or disable the correction service.
+     * @param {boolean} enabled
+     * @returns {Promise<void>}
+     */
+    async setEnabled(enabled) {
+      await this.sendMessage({
+        type: MessageTypes.SET_ENABLED,
+        enabled
+      });
+    }
+    /**
+     * Clear the tile cache.
+     * @returns {Promise<void>}
+     */
+    async clearCache() {
+      await this.sendMessage({
+        type: MessageTypes.CLEAR_CACHE
+      });
+    }
+    /**
+     * Get the status of the service worker.
+     * @returns {Promise<Object>}
+     */
+    async getStatus() {
+      return this.sendMessage({
+        type: MessageTypes.GET_STATUS
+      });
+    }
+    /**
+     * Reset the service worker configuration to defaults.
+     * Resets pmtilesUrl to default and restores default layer configs.
+     * @returns {Promise<void>}
+     */
+    async resetConfig() {
+      await this.sendMessage({
+        type: MessageTypes.RESET_CONFIG
+      });
+    }
+  };
+  async function registerCorrectionServiceWorker(workerUrl, options = {}) {
+    const sw = new CorrectionServiceWorker(workerUrl, options);
+    await sw.register();
+    return sw;
+  }
+  function getWorkerImportSnippet(workerGlobalUrl) {
+    return `importScripts('${workerGlobalUrl}');`;
+  }
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map