@tushar-br/desktop 1.0.173 → 1.0.174

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/worker-interface.umd.cjs

@@ -0,0 +1,525 @@
+/**
+ * @monogrid/gainmap-js v3.4.0
+ * With ❤️, by MONOGRID <gainmap@monogrid.com>
+ */
+
+(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["worker-interface"] = {}));
+})(this, (function (exports) { 'use strict';
+
+	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+	function getDefaultExportFromCjs (x) {
+		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+	}
+
+	var lib$1;
+	var hasRequiredLib$1;
+
+	function requireLib$1 () {
+		if (hasRequiredLib$1) return lib$1;
+		hasRequiredLib$1 = 1;
+		var Mutation = commonjsGlobal.MutationObserver || commonjsGlobal.WebKitMutationObserver;
+
+		var scheduleDrain;
+
+		if (process.browser) {
+		  if (Mutation) {
+		    var called = 0;
+		    var observer = new Mutation(nextTick);
+		    var element = commonjsGlobal.document.createTextNode('');
+		    observer.observe(element, {
+		      characterData: true
+		    });
+		    scheduleDrain = function () {
+		      element.data = (called = ++called % 2);
+		    };
+		  } else if (!commonjsGlobal.setImmediate && typeof commonjsGlobal.MessageChannel !== 'undefined') {
+		    var channel = new commonjsGlobal.MessageChannel();
+		    channel.port1.onmessage = nextTick;
+		    scheduleDrain = function () {
+		      channel.port2.postMessage(0);
+		    };
+		  } else if ('document' in commonjsGlobal && 'onreadystatechange' in commonjsGlobal.document.createElement('script')) {
+		    scheduleDrain = function () {
+
+		      // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
+		      // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
+		      var scriptEl = commonjsGlobal.document.createElement('script');
+		      scriptEl.onreadystatechange = function () {
+		        nextTick();
+
+		        scriptEl.onreadystatechange = null;
+		        scriptEl.parentNode.removeChild(scriptEl);
+		        scriptEl = null;
+		      };
+		      commonjsGlobal.document.documentElement.appendChild(scriptEl);
+		    };
+		  } else {
+		    scheduleDrain = function () {
+		      setTimeout(nextTick, 0);
+		    };
+		  }
+		} else {
+		  scheduleDrain = function () {
+		    process.nextTick(nextTick);
+		  };
+		}
+
+		var draining;
+		var queue = [];
+		//named nextTick for less confusing stack traces
+		function nextTick() {
+		  draining = true;
+		  var i, oldQueue;
+		  var len = queue.length;
+		  while (len) {
+		    oldQueue = queue;
+		    queue = [];
+		    i = -1;
+		    while (++i < len) {
+		      oldQueue[i]();
+		    }
+		    len = queue.length;
+		  }
+		  draining = false;
+		}
+
+		lib$1 = immediate;
+		function immediate(task) {
+		  if (queue.push(task) === 1 && !draining) {
+		    scheduleDrain();
+		  }
+		}
+		return lib$1;
+	}
+
+	var lib;
+	var hasRequiredLib;
+
+	function requireLib () {
+		if (hasRequiredLib) return lib;
+		hasRequiredLib = 1;
+		var immediate = requireLib$1();
+
+		/* istanbul ignore next */
+		function INTERNAL() {}
+
+		var handlers = {};
+
+		var REJECTED = ['REJECTED'];
+		var FULFILLED = ['FULFILLED'];
+		var PENDING = ['PENDING'];
+		/* istanbul ignore else */
+		if (!process.browser) {
+		  // in which we actually take advantage of JS scoping
+		  var UNHANDLED = ['UNHANDLED'];
+		}
+
+		lib = Promise;
+
+		function Promise(resolver) {
+		  if (typeof resolver !== 'function') {
+		    throw new TypeError('resolver must be a function');
+		  }
+		  this.state = PENDING;
+		  this.queue = [];
+		  this.outcome = void 0;
+		  /* istanbul ignore else */
+		  if (!process.browser) {
+		    this.handled = UNHANDLED;
+		  }
+		  if (resolver !== INTERNAL) {
+		    safelyResolveThenable(this, resolver);
+		  }
+		}
+
+		Promise.prototype.finally = function (callback) {
+		  if (typeof callback !== 'function') {
+		    return this;
+		  }
+		  var p = this.constructor;
+		  return this.then(resolve, reject);
+
+		  function resolve(value) {
+		    function yes () {
+		      return value;
+		    }
+		    return p.resolve(callback()).then(yes);
+		  }
+		  function reject(reason) {
+		    function no () {
+		      throw reason;
+		    }
+		    return p.resolve(callback()).then(no);
+		  }
+		};
+		Promise.prototype.catch = function (onRejected) {
+		  return this.then(null, onRejected);
+		};
+		Promise.prototype.then = function (onFulfilled, onRejected) {
+		  if (typeof onFulfilled !== 'function' && this.state === FULFILLED ||
+		    typeof onRejected !== 'function' && this.state === REJECTED) {
+		    return this;
+		  }
+		  var promise = new this.constructor(INTERNAL);
+		  /* istanbul ignore else */
+		  if (!process.browser) {
+		    if (this.handled === UNHANDLED) {
+		      this.handled = null;
+		    }
+		  }
+		  if (this.state !== PENDING) {
+		    var resolver = this.state === FULFILLED ? onFulfilled : onRejected;
+		    unwrap(promise, resolver, this.outcome);
+		  } else {
+		    this.queue.push(new QueueItem(promise, onFulfilled, onRejected));
+		  }
+
+		  return promise;
+		};
+		function QueueItem(promise, onFulfilled, onRejected) {
+		  this.promise = promise;
+		  if (typeof onFulfilled === 'function') {
+		    this.onFulfilled = onFulfilled;
+		    this.callFulfilled = this.otherCallFulfilled;
+		  }
+		  if (typeof onRejected === 'function') {
+		    this.onRejected = onRejected;
+		    this.callRejected = this.otherCallRejected;
+		  }
+		}
+		QueueItem.prototype.callFulfilled = function (value) {
+		  handlers.resolve(this.promise, value);
+		};
+		QueueItem.prototype.otherCallFulfilled = function (value) {
+		  unwrap(this.promise, this.onFulfilled, value);
+		};
+		QueueItem.prototype.callRejected = function (value) {
+		  handlers.reject(this.promise, value);
+		};
+		QueueItem.prototype.otherCallRejected = function (value) {
+		  unwrap(this.promise, this.onRejected, value);
+		};
+
+		function unwrap(promise, func, value) {
+		  immediate(function () {
+		    var returnValue;
+		    try {
+		      returnValue = func(value);
+		    } catch (e) {
+		      return handlers.reject(promise, e);
+		    }
+		    if (returnValue === promise) {
+		      handlers.reject(promise, new TypeError('Cannot resolve promise with itself'));
+		    } else {
+		      handlers.resolve(promise, returnValue);
+		    }
+		  });
+		}
+
+		handlers.resolve = function (self, value) {
+		  var result = tryCatch(getThen, value);
+		  if (result.status === 'error') {
+		    return handlers.reject(self, result.value);
+		  }
+		  var thenable = result.value;
+
+		  if (thenable) {
+		    safelyResolveThenable(self, thenable);
+		  } else {
+		    self.state = FULFILLED;
+		    self.outcome = value;
+		    var i = -1;
+		    var len = self.queue.length;
+		    while (++i < len) {
+		      self.queue[i].callFulfilled(value);
+		    }
+		  }
+		  return self;
+		};
+		handlers.reject = function (self, error) {
+		  self.state = REJECTED;
+		  self.outcome = error;
+		  /* istanbul ignore else */
+		  if (!process.browser) {
+		    if (self.handled === UNHANDLED) {
+		      immediate(function () {
+		        if (self.handled === UNHANDLED) {
+		          process.emit('unhandledRejection', error, self);
+		        }
+		      });
+		    }
+		  }
+		  var i = -1;
+		  var len = self.queue.length;
+		  while (++i < len) {
+		    self.queue[i].callRejected(error);
+		  }
+		  return self;
+		};
+
+		function getThen(obj) {
+		  // Make sure we only access the accessor once as required by the spec
+		  var then = obj && obj.then;
+		  if (obj && (typeof obj === 'object' || typeof obj === 'function') && typeof then === 'function') {
+		    return function appyThen() {
+		      then.apply(obj, arguments);
+		    };
+		  }
+		}
+
+		function safelyResolveThenable(self, thenable) {
+		  // Either fulfill, reject or reject with error
+		  var called = false;
+		  function onError(value) {
+		    if (called) {
+		      return;
+		    }
+		    called = true;
+		    handlers.reject(self, value);
+		  }
+
+		  function onSuccess(value) {
+		    if (called) {
+		      return;
+		    }
+		    called = true;
+		    handlers.resolve(self, value);
+		  }
+
+		  function tryToUnwrap() {
+		    thenable(onSuccess, onError);
+		  }
+
+		  var result = tryCatch(tryToUnwrap);
+		  if (result.status === 'error') {
+		    onError(result.value);
+		  }
+		}
+
+		function tryCatch(func, value) {
+		  var out = {};
+		  try {
+		    out.value = func(value);
+		    out.status = 'success';
+		  } catch (e) {
+		    out.status = 'error';
+		    out.value = e;
+		  }
+		  return out;
+		}
+
+		Promise.resolve = resolve;
+		function resolve(value) {
+		  if (value instanceof this) {
+		    return value;
+		  }
+		  return handlers.resolve(new this(INTERNAL), value);
+		}
+
+		Promise.reject = reject;
+		function reject(reason) {
+		  var promise = new this(INTERNAL);
+		  return handlers.reject(promise, reason);
+		}
+
+		Promise.all = all;
+		function all(iterable) {
+		  var self = this;
+		  if (Object.prototype.toString.call(iterable) !== '[object Array]') {
+		    return this.reject(new TypeError('must be an array'));
+		  }
+
+		  var len = iterable.length;
+		  var called = false;
+		  if (!len) {
+		    return this.resolve([]);
+		  }
+
+		  var values = new Array(len);
+		  var resolved = 0;
+		  var i = -1;
+		  var promise = new this(INTERNAL);
+
+		  while (++i < len) {
+		    allResolver(iterable[i], i);
+		  }
+		  return promise;
+		  function allResolver(value, i) {
+		    self.resolve(value).then(resolveFromAll, function (error) {
+		      if (!called) {
+		        called = true;
+		        handlers.reject(promise, error);
+		      }
+		    });
+		    function resolveFromAll(outValue) {
+		      values[i] = outValue;
+		      if (++resolved === len && !called) {
+		        called = true;
+		        handlers.resolve(promise, values);
+		      }
+		    }
+		  }
+		}
+
+		Promise.race = race;
+		function race(iterable) {
+		  var self = this;
+		  if (Object.prototype.toString.call(iterable) !== '[object Array]') {
+		    return this.reject(new TypeError('must be an array'));
+		  }
+
+		  var len = iterable.length;
+		  var called = false;
+		  if (!len) {
+		    return this.resolve([]);
+		  }
+
+		  var i = -1;
+		  var promise = new this(INTERNAL);
+
+		  while (++i < len) {
+		    resolver(iterable[i]);
+		  }
+		  return promise;
+		  function resolver(value) {
+		    self.resolve(value).then(function (response) {
+		      if (!called) {
+		        called = true;
+		        handlers.resolve(promise, response);
+		      }
+		    }, function (error) {
+		      if (!called) {
+		        called = true;
+		        handlers.reject(promise, error);
+		      }
+		    });
+		  }
+		}
+		return lib;
+	}
+
+	var promiseWorkerTransferable;
+	var hasRequiredPromiseWorkerTransferable;
+
+	function requirePromiseWorkerTransferable () {
+		if (hasRequiredPromiseWorkerTransferable) return promiseWorkerTransferable;
+		hasRequiredPromiseWorkerTransferable = 1;
+
+		/* istanbul ignore next */
+		var MyPromise = typeof Promise !== 'undefined' ? Promise : requireLib();
+
+		var messageIds = 0;
+
+		function onMessage(self, e) {
+		  var message = e.data;
+		  if (!Array.isArray(message) || message.length < 2) {
+		    // Ignore - this message is not for us.
+		    return;
+		  }
+		  var messageId = message[0];
+		  var error = message[1];
+		  var result = message[2];
+
+		  var callback = self._callbacks[messageId];
+
+		  if (!callback) {
+		    // Ignore - user might have created multiple PromiseWorkers.
+		    // This message is not for us.
+		    return;
+		  }
+
+		  delete self._callbacks[messageId];
+		  callback(error, result);
+		}
+
+		function PromiseWorker(worker) {
+		  var self = this;
+		  self._worker = worker;
+		  self._callbacks = {};
+
+		  worker.addEventListener('message', function (e) {
+		    onMessage(self, e);
+		  });
+		}
+
+		PromiseWorker.prototype.postMessage = function (userMessage, transferList) {
+		  var self = this;
+		  var messageId = messageIds++;
+
+		  var messageToSend = [messageId, userMessage];
+
+		  return new MyPromise(function (resolve, reject) {
+		    self._callbacks[messageId] = function (error, result) {
+		      if (error) {
+		        return reject(new Error(error.message));
+		      }
+		      resolve(result);
+		    };
+		    /* istanbul ignore if */
+		    if (typeof self._worker.controller !== 'undefined') {
+		      // service worker, use MessageChannels because e.source is broken in Chrome < 51:
+		      // https://bugs.chromium.org/p/chromium/issues/detail?id=543198
+		      var channel = new MessageChannel();
+		      channel.port1.onmessage = function (e) {
+		        onMessage(self, e);
+		      };
+		      self._worker.controller.postMessage(messageToSend, [channel.port2].concat(transferList));
+		    } else {
+		      // web worker
+		      self._worker.postMessage(messageToSend, transferList);
+		    }
+		  });
+		};
+
+		PromiseWorker.prototype.terminate = function () {
+		    this._worker.terminate();
+		};
+
+		promiseWorkerTransferable = PromiseWorker;
+		return promiseWorkerTransferable;
+	}
+
+	var promiseWorkerTransferableExports = requirePromiseWorkerTransferable();
+	var PromiseWorker = /*@__PURE__*/getDefaultExportFromCjs(promiseWorkerTransferableExports);
+
+	// @ts-expect-error untyped lib
+	/**
+	 * Wraps a Regular worker into a `PromiseWorker`
+	 *
+	 * @param worker
+	 * @returns
+	 */
+	const getPromiseWorker = (worker) => {
+	    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+	    return new PromiseWorker(worker);
+	};
+	/**
+	 * Returns an interface where methods of the worker can be called by the host site
+	 *
+	 * @example
+	 * // this assumes a vite-like bundler understands the `?worker` import
+	 * import GainMapWorker from '@monogrid/gainmap-js/worker?worker'
+	 * import { getPromiseWorker, getWorkerInterface } from '@monogrid/gainmap-js/worker-interface'
+	 *
+	 * // turn our Worker into a PromiseWorker
+	 * const promiseWorker = getPromiseWorker(new GainMapWorker())
+	 * // get the interface
+	 * const workerInterface = getWorkerInterface(promiseWorker)
+	 *
+	 * @param worker
+	 * @returns
+	 */
+	const getWorkerInterface = (worker) => {
+	    return {
+	        compress: (payload) => worker.postMessage({ type: 'compress', payload })
+	    };
+	};
+
+	exports.getPromiseWorker = getPromiseWorker;
+	exports.getWorkerInterface = getWorkerInterface;
+
+}));

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/worker-interface.umd.min.cjs

@@ -0,0 +1,5 @@
+/**
+ * @monogrid/gainmap-js v3.4.0
+ * With ❤️, by MONOGRID <gainmap@monogrid.com>
+ */
+!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)["worker-interface"]={})}(this,function(e){"use strict";var t,n,r,o,i,s,u="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{};function c(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}function a(){if(o)return r;o=1;var e=function(){if(n)return t;n=1;var e,r,o=u.MutationObserver||u.WebKitMutationObserver;if(process.browser)if(o){var i=0,s=new o(f),c=u.document.createTextNode("");s.observe(c,{characterData:!0}),e=function(){c.data=i=++i%2}}else if(u.setImmediate||void 0===u.MessageChannel)e="document"in u&&"onreadystatechange"in u.document.createElement("script")?function(){var e=u.document.createElement("script");e.onreadystatechange=function(){f(),e.onreadystatechange=null,e.parentNode.removeChild(e),e=null},u.document.documentElement.appendChild(e)}:function(){setTimeout(f,0)};else{var a=new u.MessageChannel;a.port1.onmessage=f,e=function(){a.port2.postMessage(0)}}else e=function(){process.nextTick(f)};var l=[];function f(){var e,t;r=!0;for(var n=l.length;n;){for(t=l,l=[],e=-1;++e<n;)t[e]();n=l.length}r=!1}return t=function(t){1!==l.push(t)||r||e()}}();function i(){}var s={},c=["REJECTED"],a=["FULFILLED"],l=["PENDING"];if(!process.browser)var f=["UNHANDLED"];function h(e){if("function"!=typeof e)throw new TypeError("resolver must be a function");this.state=l,this.queue=[],this.outcome=void 0,process.browser||(this.handled=f),e!==i&&y(this,e)}function p(e,t,n){this.promise=e,"function"==typeof t&&(this.onFulfilled=t,this.callFulfilled=this.otherCallFulfilled),"function"==typeof n&&(this.onRejected=n,this.callRejected=this.otherCallRejected)}function d(t,n,r){e(function(){var e;try{e=n(r)}catch(e){return s.reject(t,e)}e===t?s.reject(t,new TypeError("Cannot resolve promise with itself")):s.resolve(t,e)})}function v(e){var t=e&&e.then;if(e&&("object"==typeof e||"function"==typeof e)&&"function"==typeof t)return function(){t.apply(e,arguments)}}function y(e,t){var n=!1;function r(t){n||(n=!0,s.reject(e,t))}function o(t){n||(n=!0,s.resolve(e,t))}var i=m(function(){t(o,r)});"error"===i.status&&r(i.value)}function m(e,t){var n={};try{n.value=e(t),n.status="success"}catch(e){n.status="error",n.value=e}return n}return r=h,h.prototype.finally=function(e){if("function"!=typeof e)return this;var t=this.constructor;return this.then(function(n){return t.resolve(e()).then(function(){return n})},function(n){return t.resolve(e()).then(function(){throw n})})},h.prototype.catch=function(e){return this.then(null,e)},h.prototype.then=function(e,t){if("function"!=typeof e&&this.state===a||"function"!=typeof t&&this.state===c)return this;var n=new this.constructor(i);(process.browser||this.handled===f&&(this.handled=null),this.state!==l)?d(n,this.state===a?e:t,this.outcome):this.queue.push(new p(n,e,t));return n},p.prototype.callFulfilled=function(e){s.resolve(this.promise,e)},p.prototype.otherCallFulfilled=function(e){d(this.promise,this.onFulfilled,e)},p.prototype.callRejected=function(e){s.reject(this.promise,e)},p.prototype.otherCallRejected=function(e){d(this.promise,this.onRejected,e)},s.resolve=function(e,t){var n=m(v,t);if("error"===n.status)return s.reject(e,n.value);var r=n.value;if(r)y(e,r);else{e.state=a,e.outcome=t;for(var o=-1,i=e.queue.length;++o<i;)e.queue[o].callFulfilled(t)}return e},s.reject=function(t,n){t.state=c,t.outcome=n,process.browser||t.handled===f&&e(function(){t.handled===f&&process.emit("unhandledRejection",n,t)});for(var r=-1,o=t.queue.length;++r<o;)t.queue[r].callRejected(n);return t},h.resolve=function(e){if(e instanceof this)return e;return s.resolve(new this(i),e)},h.reject=function(e){var t=new this(i);return s.reject(t,e)},h.all=function(e){var t=this;if("[object Array]"!==Object.prototype.toString.call(e))return this.reject(new TypeError("must be an array"));var n=e.length,r=!1;if(!n)return this.resolve([]);var o=new Array(n),u=0,c=-1,a=new this(i);for(;++c<n;)l(e[c],c);return a;function l(e,i){t.resolve(e).then(function(e){o[i]=e,++u!==n||r||(r=!0,s.resolve(a,o))},function(e){r||(r=!0,s.reject(a,e))})}},h.race=function(e){var t=this;if("[object Array]"!==Object.prototype.toString.call(e))return this.reject(new TypeError("must be an array"));var n=e.length,r=!1;if(!n)return this.resolve([]);var o=-1,u=new this(i);for(;++o<n;)c(e[o]);return u;function c(e){t.resolve(e).then(function(e){r||(r=!0,s.resolve(u,e))},function(e){r||(r=!0,s.reject(u,e))})}},r}var l=function(){if(s)return i;s=1;var e="undefined"!=typeof Promise?Promise:a(),t=0;function n(e,t){var n=t.data;if(Array.isArray(n)&&!(n.length<2)){var r=n[0],o=n[1],i=n[2],s=e._callbacks[r];s&&(delete e._callbacks[r],s(o,i))}}function r(e){var t=this;t._worker=e,t._callbacks={},e.addEventListener("message",function(e){n(t,e)})}return r.prototype.postMessage=function(r,o){var i=this,s=t++,u=[s,r];return new e(function(e,t){if(i._callbacks[s]=function(n,r){if(n)return t(new Error(n.message));e(r)},void 0!==i._worker.controller){var r=new MessageChannel;r.port1.onmessage=function(e){n(i,e)},i._worker.controller.postMessage(u,[r.port2].concat(o))}else i._worker.postMessage(u,o)})},r.prototype.terminate=function(){this._worker.terminate()},i=r}(),f=c(l);e.getPromiseWorker=e=>new f(e),e.getWorkerInterface=e=>({compress:t=>e.postMessage({type:"compress",payload:t})})});

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/worker-types.d.ts

@@ -0,0 +1,24 @@
+import { CompressedImage, type CompressParameters } from './encode/types';
+export type WorkerInterface = {
+    compress: {
+        request: {
+            type: 'compress';
+            payload: CompressParameters;
+        };
+        result: Awaited<CompressedImage> & {
+            source: Uint8ClampedArray;
+        };
+    };
+};
+/**
+ * Transferable
+ */
+export type Transferable = ArrayBufferLike | ImageBitmap;
+export type WorkerInterfaceImplementation = {
+    [k in keyof WorkerInterface]: (payload: WorkerInterface[k]['request']['payload']) => Promise<WorkerInterface[k]['result']>;
+};
+export type WorkerRequest = WorkerInterface[keyof WorkerInterface]['request'];
+export type WithTransferListFunction = <T>(payload: T, transferList: Transferable[]) => T;
+export type PromiseWorkerType = {
+    postMessage: (message: any, transferables?: Transferable[]) => Promise<any>;
+};

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/worker.js

@@ -0,0 +1,142 @@
+/**
+ * @monogrid/gainmap-js v3.4.0
+ * With ❤️, by MONOGRID <gainmap@monogrid.com>
+ */
+
+import { g as getDefaultExportFromCjs } from './_commonjsHelpers-v3qvwW2J.js';
+import { c as compress } from './compress-C-X439Jm.js';
+
+var isPromise = {exports: {}};
+
+var hasRequiredIsPromise;
+
+function requireIsPromise () {
+	if (hasRequiredIsPromise) return isPromise.exports;
+	hasRequiredIsPromise = 1;
+	isPromise.exports = isPromise$1;
+	isPromise.exports.default = isPromise$1;
+
+	function isPromise$1(obj) {
+	  return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
+	}
+	return isPromise.exports;
+}
+
+var register;
+var hasRequiredRegister;
+
+function requireRegister () {
+	if (hasRequiredRegister) return register;
+	hasRequiredRegister = 1;
+
+	var isPromise = requireIsPromise();
+
+	function registerPromiseWorker(callback) {
+
+	  function postOutgoingMessage(e, messageId, error, result) {
+	    function postMessage(msg, transferList) {
+	      /* istanbul ignore if */
+	      if (typeof self.postMessage !== 'function') { // service worker
+	        e.ports[0].postMessage(msg, transferList);
+	      } else { // web worker
+	        self.postMessage(msg, transferList);
+	      }
+	    }
+	    if (error) {
+	      /* istanbul ignore else */
+	      if (typeof console !== 'undefined' && 'error' in console) {
+	        // This is to make errors easier to debug. I think it's important
+	        // enough to just leave here without giving the user an option
+	        // to silence it.
+	        console.error('Worker caught an error:', error);
+	      }
+	      postMessage([messageId, {
+	        message: error.message
+	      }]);
+	    } else {
+	      if (result instanceof MessageWithTransferList) {
+	        postMessage([messageId, null, result.message], result.transferList);
+	      } else {
+	        postMessage([messageId, null, result]);
+	      }
+	    }
+	  }
+
+	  function tryCatchFunc(callback, message) {
+	    try {
+	      return {res: callback(message, withTransferList)};
+	    } catch (e) {
+	      return {err: e};
+	    }
+	  }
+
+	  function withTransferList(resMessage, transferList) {
+	    return new MessageWithTransferList(resMessage, transferList);
+	  } 
+
+	  function handleIncomingMessage(e, callback, messageId, message) {
+
+	    var result = tryCatchFunc(callback, message);
+
+	    if (result.err) {
+	      postOutgoingMessage(e, messageId, result.err);
+	    } else if (!isPromise(result.res)) {
+	        postOutgoingMessage(e, messageId, null, result.res);
+	    } else {
+	      result.res.then(function (finalResult) {
+	        postOutgoingMessage(e, messageId, null, finalResult);
+	      }, function (finalError) {
+	        postOutgoingMessage(e, messageId, finalError);
+	      });
+	    }
+	  }
+
+	  function onIncomingMessage(e) {
+	    var payload = e.data;
+	    if (!Array.isArray(payload) || payload.length !== 2) {
+	      // message doens't match communication format; ignore
+	      return;
+	    }
+	    var messageId = payload[0];
+	    var message = payload[1];
+
+	    if (typeof callback !== 'function') {
+	      postOutgoingMessage(e, messageId, new Error(
+	        'Please pass a function into register().'));
+	    } else {
+	      handleIncomingMessage(e, callback, messageId, message);
+	    }
+	  }
+
+	  function MessageWithTransferList(message, transferList) {
+	    this.message = message;
+	    this.transferList = transferList;
+	  }
+
+	  self.addEventListener('message', onIncomingMessage);
+	}
+
+	register = registerPromiseWorker;
+	return register;
+}
+
+var registerExports = requireRegister();
+var registerPromiseWorker = /*@__PURE__*/getDefaultExportFromCjs(registerExports);
+
+// @ts-expect-error untyped lib
+const _compress = async (message, withTransferList) => {
+    const result = await compress(message.payload);
+    return withTransferList({
+        ...result,
+        source: message.payload.source instanceof ImageData ? message.payload.source.data : new Uint8ClampedArray(message.payload.source)
+    }, [result.data.buffer, message.payload.source instanceof ImageData ? message.payload.source.data.buffer : message.payload.source.buffer]);
+};
+// eslint-disable-next-line @typescript-eslint/no-unsafe-call
+registerPromiseWorker(async (message, withTransferList) => {
+    switch (message.type) {
+        // case 'encode-gainmap-buffers':
+        //   return encodeGainmapBuffers(message, withTransferList)
+        case 'compress':
+            return _compress(message, withTransferList);
+    }
+});