@mittwald/flow-remote-core 0.2.0-alpha.104 → 0.2.0-alpha.1041

package/dist/js/node_modules/.pnpm/@quilted_threads@3.3.1_patch_hash_df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/ThreadIframe.mjs

@@ -0,0 +1,154 @@
+import { Thread } from "../Thread.mjs";
+import { windowToThreadTarget } from "./window/ThreadWindow.mjs";
+import { ThreadNestedIframe } from "./ThreadNestedIframe.mjs";
+//#region ../../node_modules/.pnpm/@quilted+threads@3.3.1_patch_hash=df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/ThreadIframe.mjs
+/**
+* Creates a thread from an iframe element.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe
+*
+* @example
+* import {ThreadIframe} from '@quilted/threads';
+*
+* const iframe = document.querySelector('iframe#thread-iframe');
+* const thread = new ThreadIframe(iframe);
+* await thread.imports.sendMessage('Hello world!');
+*/
+var ThreadIframe = class ThreadIframe extends Thread {
+	/**
+	* Creates a thread from an iframe element.
+	*
+	* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe
+	*
+	* @example
+	* import {ThreadIframe} from '@quilted/threads';
+	*
+	* const iframe = document.querySelector('iframe#thread-iframe');
+	* const thread = ThreadIframe.from(iframe);
+	* await thread.imports.sendMessage('Hello world!');
+	*/
+	static from(iframe, options) {
+		return new ThreadIframe(iframe, options);
+	}
+	/**
+	* Starts a thread wrapped around an iframe element, and returns the imports
+	* of the thread.
+	*
+	* @example
+	* ```ts
+	* import {ThreadIframe} from '@quilted/threads';
+	*
+	* const {getMessage} = ThreadIframe.import(iframe);
+	* const message = await getMessage(); // 'Hello, world!'
+	*
+	* // In the nested window:
+	*
+	* import {ThreadIframe} from '@quilted/threads';
+	*
+	* ThreadIframe.parent.export({
+	*   async getMessage() {
+	*     return 'Hello, world!';
+	*   },
+	* });
+	* ```
+	*/
+	static import(iframe, options) {
+		return new ThreadIframe(iframe, options).imports;
+	}
+	/**
+	* Starts a thread wrapped around an iframe element, providing the second
+	* argument as the exports of the thread.
+	*
+	* @example
+	* ```ts
+	* import {ThreadIframe} from '@quilted/threads';
+	*
+	* ThreadIframe.export(iframe, {
+	*   async getMessage() {
+	*     return 'Hello, world!';
+	*   },
+	* });
+	*
+	* // In the nested iframe:
+	*
+	* import {ThreadIframe} from '@quilted/threads';
+	*
+	* const {getMessage} = ThreadIframe.parent.import();
+	* const message = await getMessage(); // 'Hello, world!'
+	* ```
+	*/
+	static export(iframe, exports, options) {
+		new ThreadIframe(iframe, {
+			...options,
+			exports
+		});
+	}
+	/**
+	* Creates a thread from a `window.parent`, a reference to the parent window when rendering
+	* in a nested iframe.
+	*
+	* @see https://developer.mozilla.org/en-US/docs/Web/API/Window/parent
+	*
+	* @example
+	* import {ThreadIframe} from '@quilted/threads';
+	*
+	* const thread = ThreadIframe.parent();
+	* await thread.imports.sendMessage('Hello world!');
+	*/
+	static parent = (() => Object.assign((options) => new ThreadNestedIframe(options), {
+		/**
+		* Starts a thread wrapped around a parent window, and returns the imports
+		* of the thread.
+		*
+		* @example
+		* ```ts
+		* import {ThreadIframe} from '@quilted/threads';
+		*
+		* const {getMessage} = ThreadIframe.parent.import();
+		* const message = await getMessage(); // 'Hello, world!'
+		*
+		* // In the parent window:
+		*
+		* import {ThreadIframe} from '@quilted/threads';
+		*
+		* ThreadIframe.export(iframe, {
+		*   async getMessage() {
+		*     return 'Hello, world!';
+		*   },
+		* });
+		* ```
+		*/
+		import: (options) => ThreadNestedIframe.import(options),
+		/**
+		* Starts a thread wrapped around a parent window, providing the second
+		* argument as the exports of the thread.
+		*
+		* @example
+		* ```ts
+		* import {ThreadIframe} from '@quilted/threads';
+		*
+		* ThreadIframe.parent.export({
+		*   async getMessage() {
+		*     return 'Hello, world!';
+		*   },
+		* });
+		*
+		* // In the parent window:
+		*
+		* import {ThreadIframe} from '@quilted/threads';
+		*
+		* const {getMessage} = ThreadIframe.import(iframe);
+		* const message = await getMessage(); // 'Hello, world!'
+		* ```
+		*/
+		export: (exports, options) => ThreadNestedIframe.export(exports, options)
+	}))();
+	constructor(iframe, { targetOrigin = "*", ...options } = {}) {
+		super(windowToThreadTarget(iframe.contentWindow, { targetOrigin }), options);
+		this.iframe = iframe;
+	}
+};
+//#endregion
+export { ThreadIframe };
+
+//# sourceMappingURL=ThreadIframe.mjs.map

package/dist/js/node_modules/.pnpm/@quilted_threads@3.3.1_patch_hash_df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/ThreadIframe.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadIframe.mjs","names":[],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/@quilted+threads@3.3.1_patch_hash=df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/ThreadIframe.mjs"],"sourcesContent":["import { Thread } from '../Thread.mjs';\nimport { windowToThreadTarget } from './window/ThreadWindow.mjs';\nimport { ThreadNestedIframe } from './ThreadNestedIframe.mjs';\n\n/**\n * Creates a thread from an iframe element.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe\n *\n * @example\n * import {ThreadIframe} from '@quilted/threads';\n *\n * const iframe = document.querySelector('iframe#thread-iframe');\n * const thread = new ThreadIframe(iframe);\n * await thread.imports.sendMessage('Hello world!');\n */\nclass ThreadIframe extends Thread {\n  /**\n   * Creates a thread from an iframe element.\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe\n   *\n   * @example\n   * import {ThreadIframe} from '@quilted/threads';\n   *\n   * const iframe = document.querySelector('iframe#thread-iframe');\n   * const thread = ThreadIframe.from(iframe);\n   * await thread.imports.sendMessage('Hello world!');\n   */\n  static from(iframe, options) {\n    return new ThreadIframe(iframe, options);\n  }\n\n  /**\n   * Starts a thread wrapped around an iframe element, and returns the imports\n   * of the thread.\n   *\n   * @example\n   * ```ts\n   * import {ThreadIframe} from '@quilted/threads';\n   *\n   * const {getMessage} = ThreadIframe.import(iframe);\n   * const message = await getMessage(); // 'Hello, world!'\n   *\n   * // In the nested window:\n   *\n   * import {ThreadIframe} from '@quilted/threads';\n   *\n   * ThreadIframe.parent.export({\n   *   async getMessage() {\n   *     return 'Hello, world!';\n   *   },\n   * });\n   * ```\n   */\n  static import(iframe, options) {\n    return new ThreadIframe(iframe, options).imports;\n  }\n\n  /**\n   * Starts a thread wrapped around an iframe element, providing the second\n   * argument as the exports of the thread.\n   *\n   * @example\n   * ```ts\n   * import {ThreadIframe} from '@quilted/threads';\n   *\n   * ThreadIframe.export(iframe, {\n   *   async getMessage() {\n   *     return 'Hello, world!';\n   *   },\n   * });\n   *\n   * // In the nested iframe:\n   *\n   * import {ThreadIframe} from '@quilted/threads';\n   *\n   * const {getMessage} = ThreadIframe.parent.import();\n   * const message = await getMessage(); // 'Hello, world!'\n   * ```\n   */\n  static export(iframe, exports, options) {\n    new ThreadIframe(iframe, {\n      ...options,\n      exports\n    });\n  }\n\n  /**\n   * Creates a thread from a `window.parent`, a reference to the parent window when rendering\n   * in a nested iframe.\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/parent\n   *\n   * @example\n   * import {ThreadIframe} from '@quilted/threads';\n   *\n   * const thread = ThreadIframe.parent();\n   * await thread.imports.sendMessage('Hello world!');\n   */\n  static parent = (() => Object.assign(options => new ThreadNestedIframe(options), {\n    /**\n     * Starts a thread wrapped around a parent window, and returns the imports\n     * of the thread.\n     *\n     * @example\n     * ```ts\n     * import {ThreadIframe} from '@quilted/threads';\n     *\n     * const {getMessage} = ThreadIframe.parent.import();\n     * const message = await getMessage(); // 'Hello, world!'\n     *\n     * // In the parent window:\n     *\n     * import {ThreadIframe} from '@quilted/threads';\n     *\n     * ThreadIframe.export(iframe, {\n     *   async getMessage() {\n     *     return 'Hello, world!';\n     *   },\n     * });\n     * ```\n     */\n    import: options => ThreadNestedIframe.import(options),\n    /**\n     * Starts a thread wrapped around a parent window, providing the second\n     * argument as the exports of the thread.\n     *\n     * @example\n     * ```ts\n     * import {ThreadIframe} from '@quilted/threads';\n     *\n     * ThreadIframe.parent.export({\n     *   async getMessage() {\n     *     return 'Hello, world!';\n     *   },\n     * });\n     *\n     * // In the parent window:\n     *\n     * import {ThreadIframe} from '@quilted/threads';\n     *\n     * const {getMessage} = ThreadIframe.import(iframe);\n     * const message = await getMessage(); // 'Hello, world!'\n     * ```\n     */\n    export: (exports, options) => ThreadNestedIframe.export(exports, options)\n  }))();\n  constructor(iframe, {\n    targetOrigin = '*',\n    ...options\n  } = {}) {\n    super(windowToThreadTarget(iframe.contentWindow, {\n      targetOrigin\n    }), options);\n    this.iframe = iframe;\n  }\n}\n\nexport { ThreadIframe };\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;AAgBA,IAAM,eAAN,MAAM,qBAAqB,OAAO;;;;;;;;;;;;;CAahC,OAAO,KAAK,QAAQ,SAAS;EAC3B,OAAO,IAAI,aAAa,QAAQ,OAAO;CACzC;;;;;;;;;;;;;;;;;;;;;;;CAwBA,OAAO,OAAO,QAAQ,SAAS;EAC7B,OAAO,IAAI,aAAa,QAAQ,OAAO,CAAC,CAAC;CAC3C;;;;;;;;;;;;;;;;;;;;;;;CAwBA,OAAO,OAAO,QAAQ,SAAS,SAAS;EACtC,IAAI,aAAa,QAAQ;GACvB,GAAG;GACH;EACF,CAAC;CACH;;;;;;;;;;;;;CAcA,OAAO,gBAAgB,OAAO,QAAO,YAAW,IAAI,mBAAmB,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;EAuB/E,SAAQ,YAAW,mBAAmB,OAAO,OAAO;;;;;;;;;;;;;;;;;;;;;;;EAuBpD,SAAS,SAAS,YAAY,mBAAmB,OAAO,SAAS,OAAO;CAC1E,CAAC,EAAA,CAAG;CACJ,YAAY,QAAQ,EAClB,eAAe,KACf,GAAG,YACD,CAAC,GAAG;EACN,MAAM,qBAAqB,OAAO,eAAe,EAC/C,aACF,CAAC,GAAG,OAAO;EACX,KAAK,SAAS;CAChB;AACF"}

package/dist/js/node_modules/.pnpm/@quilted_threads@3.3.1_patch_hash_df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/ThreadNestedIframe.mjs

@@ -0,0 +1,78 @@
+import { Thread } from "../Thread.mjs";
+import { nestedWindowToThreadTarget } from "./window/ThreadNestedWindow.mjs";
+//#region ../../node_modules/.pnpm/@quilted+threads@3.3.1_patch_hash=df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/ThreadNestedIframe.mjs
+/**
+* Creates a thread from within an iframe nested in a top-level document.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe
+*
+* @example
+* import {ThreadNestedIframe} from '@quilted/threads';
+*
+* const thread = new ThreadNestedIframe();
+* await thread.imports.sendMessage('Hello world!');
+*/
+var ThreadNestedIframe = class ThreadNestedIframe extends Thread {
+	/**
+	* Starts a thread wrapped around a parent window, and returns the imports
+	* of the thread.
+	*
+	* @example
+	* ```ts
+	* import {ThreadNestedIframe} from '@quilted/threads';
+	*
+	* const {getMessage} = ThreadNestedIframe.import();
+	* const message = await getMessage(); // 'Hello, world!'
+	*
+	* // In the parent window:
+	*
+	* import {ThreadIframe} from '@quilted/threads';
+	*
+	* ThreadIframe.export(iframe, {
+	*   async getMessage() {
+	*     return 'Hello, world!';
+	*   },
+	* });
+	* ```
+	*/
+	static import(options) {
+		return new ThreadNestedIframe(options).imports;
+	}
+	/**
+	* Starts a thread wrapped around a parent window, providing the second
+	* argument as the exports of the thread.
+	*
+	* @example
+	* ```ts
+	* import {ThreadNestedIframe} from '@quilted/threads';
+	*
+	* ThreadNestedIframe.export({
+	*   async getMessage() {
+	*     return 'Hello, world!';
+	*   },
+	* });
+	*
+	* // In the parent window:
+	*
+	* import {ThreadIframe} from '@quilted/threads';
+	*
+	* const {getMessage} = ThreadIframe.import(iframe);
+	* const message = await getMessage(); // 'Hello, world!'
+	* ```
+	*/
+	static export(exports, options) {
+		new ThreadNestedIframe({
+			...options,
+			exports
+		});
+	}
+	constructor({ parent = globalThis.parent, targetOrigin = "*", ...options } = {}) {
+		if (typeof self === "undefined" || parent == null) throw new Error("You are not inside an iframe, because there is no parent window.");
+		super(nestedWindowToThreadTarget(parent, { targetOrigin }), options);
+		this.parent = parent;
+	}
+};
+//#endregion
+export { ThreadNestedIframe };
+
+//# sourceMappingURL=ThreadNestedIframe.mjs.map

package/dist/js/node_modules/.pnpm/@quilted_threads@3.3.1_patch_hash_df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/ThreadNestedIframe.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadNestedIframe.mjs","names":[],"sources":["../../../../../../../../../../../../../node_modules/.pnpm/@quilted+threads@3.3.1_patch_hash=df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/ThreadNestedIframe.mjs"],"sourcesContent":["import { Thread } from '../Thread.mjs';\nimport { nestedWindowToThreadTarget } from './window/ThreadNestedWindow.mjs';\n\n/**\n * Creates a thread from within an iframe nested in a top-level document.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe\n *\n * @example\n * import {ThreadNestedIframe} from '@quilted/threads';\n *\n * const thread = new ThreadNestedIframe();\n * await thread.imports.sendMessage('Hello world!');\n */\nclass ThreadNestedIframe extends Thread {\n  /**\n   * Starts a thread wrapped around a parent window, and returns the imports\n   * of the thread.\n   *\n   * @example\n   * ```ts\n   * import {ThreadNestedIframe} from '@quilted/threads';\n   *\n   * const {getMessage} = ThreadNestedIframe.import();\n   * const message = await getMessage(); // 'Hello, world!'\n   *\n   * // In the parent window:\n   *\n   * import {ThreadIframe} from '@quilted/threads';\n   *\n   * ThreadIframe.export(iframe, {\n   *   async getMessage() {\n   *     return 'Hello, world!';\n   *   },\n   * });\n   * ```\n   */\n  static import(options) {\n    return new ThreadNestedIframe(options).imports;\n  }\n\n  /**\n   * Starts a thread wrapped around a parent window, providing the second\n   * argument as the exports of the thread.\n   *\n   * @example\n   * ```ts\n   * import {ThreadNestedIframe} from '@quilted/threads';\n   *\n   * ThreadNestedIframe.export({\n   *   async getMessage() {\n   *     return 'Hello, world!';\n   *   },\n   * });\n   *\n   * // In the parent window:\n   *\n   * import {ThreadIframe} from '@quilted/threads';\n   *\n   * const {getMessage} = ThreadIframe.import(iframe);\n   * const message = await getMessage(); // 'Hello, world!'\n   * ```\n   */\n  static export(exports, options) {\n    new ThreadNestedIframe({\n      ...options,\n      exports\n    });\n  }\n  constructor({\n    parent = globalThis.parent,\n    targetOrigin = '*',\n    ...options\n  } = {}) {\n    if (typeof self === 'undefined' || parent == null) {\n      throw new Error('You are not inside an iframe, because there is no parent window.');\n    }\n    super(nestedWindowToThreadTarget(parent, {\n      targetOrigin\n    }), options);\n    this.parent = parent;\n  }\n}\n\nexport { ThreadNestedIframe };\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;AAcA,IAAM,qBAAN,MAAM,2BAA2B,OAAO;;;;;;;;;;;;;;;;;;;;;;;CAuBtC,OAAO,OAAO,SAAS;EACrB,OAAO,IAAI,mBAAmB,OAAO,CAAC,CAAC;CACzC;;;;;;;;;;;;;;;;;;;;;;;CAwBA,OAAO,OAAO,SAAS,SAAS;EAC9B,IAAI,mBAAmB;GACrB,GAAG;GACH;EACF,CAAC;CACH;CACA,YAAY,EACV,SAAS,WAAW,QACpB,eAAe,KACf,GAAG,YACD,CAAC,GAAG;EACN,IAAI,OAAO,SAAS,eAAe,UAAU,MAC3C,MAAM,IAAI,MAAM,kEAAkE;EAEpF,MAAM,2BAA2B,QAAQ,EACvC,aACF,CAAC,GAAG,OAAO;EACX,KAAK,SAAS;CAChB;AACF"}

package/dist/js/node_modules/.pnpm/@quilted_threads@3.3.1_patch_hash_df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/window/ThreadNestedWindow.mjs

@@ -0,0 +1,120 @@
+import { Thread } from "../../Thread.mjs";
+import { RESPONSE_MESSAGE } from "./shared.mjs";
+//#region ../../node_modules/.pnpm/@quilted+threads@3.3.1_patch_hash=df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/window/ThreadNestedWindow.mjs
+/**
+* Creates a thread from within a window created by a parent document (for example,
+* an `iframe` or popup window).
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/Window/opener
+*
+* @example
+* import {ThreadNestedWindow} from '@quilted/threads';
+*
+* // Inside a document opened as a popup window
+* const thread = new ThreadNestedWindow(window.opener);
+* await thread.imports.sendMessage('Hello world!');
+*/
+var ThreadNestedWindow = class ThreadNestedWindow extends Thread {
+	/**
+	* Creates a thread from within a window created by a parent document (for example,
+	* an `iframe` or popup window).
+	*
+	* @see https://developer.mozilla.org/en-US/docs/Web/API/Window/opener
+	*
+	* @example
+	* import {ThreadNestedWindow} from '@quilted/threads';
+	*
+	* // Inside a document opened as a popup window
+	* const thread = ThreadNestedWindow.from(window.opener);
+	* await thread.imports.sendMessage('Hello world!');
+	*/
+	static from(window, options) {
+		return new ThreadNestedWindow(window, options);
+	}
+	/**
+	* Starts a thread wrapped around a nested `window` object, and returns the imports
+	* of the thread.
+	*
+	* @example
+	* ```ts
+	* import {ThreadNestedWindow} from '@quilted/threads';
+	*
+	* const {getMessage} = ThreadNestedWindow.import(window.opener);
+	* const message = await getMessage(); // 'Hello, world!'
+	*
+	* // In the parent window:
+	*
+	* import {ThreadWindow} from '@quilted/threads';
+	*
+	* ThreadWindow.export(window, {
+	*   async getMessage() {
+	*     return 'Hello, world!';
+	*   },
+	* });
+	* ```
+	*/
+	static import(window, options) {
+		return new ThreadNestedWindow(window, options).imports;
+	}
+	/**
+	* Starts a thread wrapped around a nested `window` object, providing the second
+	* argument as the exports of the thread.
+	*
+	* @example
+	* ```ts
+	* import {ThreadNestedWindow} from '@quilted/threads';
+	*
+	* ThreadNestedWindow.export(window.opener, {
+	*   async getMessage() {
+	*     return 'Hello, world!';
+	*   },
+	* });
+	*
+	* // In the parent window:
+	*
+	* import {ThreadWindow} from '@quilted/threads';
+	*
+	* const {getMessage} = ThreadWindow.import(window);
+	* const message = await getMessage(); // 'Hello, world!'
+	* ```
+	*/
+	static export(window, exports, options) {
+		new ThreadNestedWindow(window, {
+			...options,
+			exports
+		});
+	}
+	constructor(parent, { targetOrigin = "*", ...options } = {}) {
+		super(nestedWindowToThreadTarget(parent, { targetOrigin }), options);
+		this.parent = parent;
+	}
+};
+function nestedWindowToThreadTarget(parent, { targetOrigin = "*" } = {}) {
+	const ready = () => {
+		const respond = () => parent.postMessage(RESPONSE_MESSAGE, targetOrigin);
+		self.addEventListener("message", ({ data, source }) => {
+			if (source !== parent) return;
+			if (data === "quilt.threads.ping") respond();
+		});
+		respond();
+	};
+	if (document.readyState === "complete") ready();
+	else document.addEventListener("readystatechange", () => {
+		if (document.readyState === "complete") ready();
+	});
+	return {
+		send(message, transfer) {
+			return parent.postMessage(message, targetOrigin, transfer);
+		},
+		listen(listen, { signal }) {
+			self.addEventListener("message", (event) => {
+				if (event.data === "quilt.threads.ping") return;
+				listen(event.data);
+			}, { signal });
+		}
+	};
+}
+//#endregion
+export { ThreadNestedWindow, nestedWindowToThreadTarget };
+
+//# sourceMappingURL=ThreadNestedWindow.mjs.map

package/dist/js/node_modules/.pnpm/@quilted_threads@3.3.1_patch_hash_df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/window/ThreadNestedWindow.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadNestedWindow.mjs","names":[],"sources":["../../../../../../../../../../../../../../node_modules/.pnpm/@quilted+threads@3.3.1_patch_hash=df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/window/ThreadNestedWindow.mjs"],"sourcesContent":["import { Thread } from '../../Thread.mjs';\nimport { CHECK_MESSAGE, RESPONSE_MESSAGE } from './shared.mjs';\n\n/**\n * Creates a thread from within a window created by a parent document (for example,\n * an `iframe` or popup window).\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/opener\n *\n * @example\n * import {ThreadNestedWindow} from '@quilted/threads';\n *\n * // Inside a document opened as a popup window\n * const thread = new ThreadNestedWindow(window.opener);\n * await thread.imports.sendMessage('Hello world!');\n */\nclass ThreadNestedWindow extends Thread {\n  /**\n   * Creates a thread from within a window created by a parent document (for example,\n   * an `iframe` or popup window).\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/opener\n   *\n   * @example\n   * import {ThreadNestedWindow} from '@quilted/threads';\n   *\n   * // Inside a document opened as a popup window\n   * const thread = ThreadNestedWindow.from(window.opener);\n   * await thread.imports.sendMessage('Hello world!');\n   */\n  static from(window, options) {\n    return new ThreadNestedWindow(window, options);\n  }\n\n  /**\n   * Starts a thread wrapped around a nested `window` object, and returns the imports\n   * of the thread.\n   *\n   * @example\n   * ```ts\n   * import {ThreadNestedWindow} from '@quilted/threads';\n   *\n   * const {getMessage} = ThreadNestedWindow.import(window.opener);\n   * const message = await getMessage(); // 'Hello, world!'\n   *\n   * // In the parent window:\n   *\n   * import {ThreadWindow} from '@quilted/threads';\n   *\n   * ThreadWindow.export(window, {\n   *   async getMessage() {\n   *     return 'Hello, world!';\n   *   },\n   * });\n   * ```\n   */\n  static import(window, options) {\n    return new ThreadNestedWindow(window, options).imports;\n  }\n\n  /**\n   * Starts a thread wrapped around a nested `window` object, providing the second\n   * argument as the exports of the thread.\n   *\n   * @example\n   * ```ts\n   * import {ThreadNestedWindow} from '@quilted/threads';\n   *\n   * ThreadNestedWindow.export(window.opener, {\n   *   async getMessage() {\n   *     return 'Hello, world!';\n   *   },\n   * });\n   *\n   * // In the parent window:\n   *\n   * import {ThreadWindow} from '@quilted/threads';\n   *\n   * const {getMessage} = ThreadWindow.import(window);\n   * const message = await getMessage(); // 'Hello, world!'\n   * ```\n   */\n  static export(window, exports, options) {\n    new ThreadNestedWindow(window, {\n      ...options,\n      exports\n    });\n  }\n  constructor(parent, {\n    targetOrigin = '*',\n    ...options\n  } = {}) {\n    super(nestedWindowToThreadTarget(parent, {\n      targetOrigin\n    }), options);\n    this.parent = parent;\n  }\n}\nfunction nestedWindowToThreadTarget(parent, {\n  targetOrigin = '*'\n} = {}) {\n  const ready = () => {\n    const respond = () => parent.postMessage(RESPONSE_MESSAGE, targetOrigin);\n    self.addEventListener('message', ({\n      data,\n      source\n    }) => {\n      if (source !== parent) return;\n      if (data === CHECK_MESSAGE) respond();\n    });\n    respond();\n  };\n  if (document.readyState === 'complete') {\n    ready();\n  } else {\n    document.addEventListener('readystatechange', () => {\n      if (document.readyState === 'complete') {\n        ready();\n      }\n    });\n  }\n  return {\n    send(message, transfer) {\n      return parent.postMessage(message, targetOrigin, transfer);\n    },\n    listen(listen, {\n      signal\n    }) {\n      self.addEventListener('message', event => {\n        if (event.data === CHECK_MESSAGE) return;\n        listen(event.data);\n      }, {\n        signal\n      });\n    }\n  };\n}\n\nexport { ThreadNestedWindow, nestedWindowToThreadTarget };\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;AAgBA,IAAM,qBAAN,MAAM,2BAA2B,OAAO;;;;;;;;;;;;;;CActC,OAAO,KAAK,QAAQ,SAAS;EAC3B,OAAO,IAAI,mBAAmB,QAAQ,OAAO;CAC/C;;;;;;;;;;;;;;;;;;;;;;;CAwBA,OAAO,OAAO,QAAQ,SAAS;EAC7B,OAAO,IAAI,mBAAmB,QAAQ,OAAO,CAAC,CAAC;CACjD;;;;;;;;;;;;;;;;;;;;;;;CAwBA,OAAO,OAAO,QAAQ,SAAS,SAAS;EACtC,IAAI,mBAAmB,QAAQ;GAC7B,GAAG;GACH;EACF,CAAC;CACH;CACA,YAAY,QAAQ,EAClB,eAAe,KACf,GAAG,YACD,CAAC,GAAG;EACN,MAAM,2BAA2B,QAAQ,EACvC,aACF,CAAC,GAAG,OAAO;EACX,KAAK,SAAS;CAChB;AACF;AACA,SAAS,2BAA2B,QAAQ,EAC1C,eAAe,QACb,CAAC,GAAG;CACN,MAAM,cAAc;EAClB,MAAM,gBAAgB,OAAO,YAAY,kBAAkB,YAAY;EACvE,KAAK,iBAAiB,YAAY,EAChC,MACA,aACI;GACJ,IAAI,WAAW,QAAQ;GACvB,IAAI,SAAA,sBAAwB,QAAQ;EACtC,CAAC;EACD,QAAQ;CACV;CACA,IAAI,SAAS,eAAe,YAC1B,MAAM;MAEN,SAAS,iBAAiB,0BAA0B;EAClD,IAAI,SAAS,eAAe,YAC1B,MAAM;CAEV,CAAC;CAEH,OAAO;EACL,KAAK,SAAS,UAAU;GACtB,OAAO,OAAO,YAAY,SAAS,cAAc,QAAQ;EAC3D;EACA,OAAO,QAAQ,EACb,UACC;GACD,KAAK,iBAAiB,YAAW,UAAS;IACxC,IAAI,MAAM,SAAA,sBAAwB;IAClC,OAAO,MAAM,IAAI;GACnB,GAAG,EACD,OACF,CAAC;EACH;CACF;AACF"}

package/dist/js/node_modules/.pnpm/@quilted_threads@3.3.1_patch_hash_df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/window/ThreadWindow.mjs

@@ -0,0 +1,192 @@
+import { Thread } from "../../Thread.mjs";
+import { CHECK_MESSAGE } from "./shared.mjs";
+import { ThreadNestedWindow } from "./ThreadNestedWindow.mjs";
+//#region ../../node_modules/.pnpm/@quilted+threads@3.3.1_patch_hash=df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/window/ThreadWindow.mjs
+/**
+* Creates a thread from a `Window` created by this environment.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe
+*
+* @example
+* import {ThreadWindow} from '@quilted/threads';
+*
+* const popup = window.open('https://my-app.com/popup', 'MyAppPopup', 'popup');
+* const thread = new ThreadWindow(popup);
+* await thread.imports.sendMessage('Hello world!');
+*/
+var ThreadWindow = class ThreadWindow extends Thread {
+	/**
+	* Creates a thread from a `Window` created by this environment.
+	*
+	* @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe
+	*
+	* @example
+	* import {ThreadWindow} from '@quilted/threads';
+	*
+	* const popup = window.open('https://my-app.com/popup', 'MyAppPopup', 'popup');
+	* const thread = ThreadWindow.from(popup);
+	* await thread.imports.sendMessage('Hello world!');
+	*/
+	static from(window, options) {
+		return new ThreadWindow(window, options);
+	}
+	/**
+	* Starts a thread wrapped around a `window` object, and returns the imports
+	* of the thread.
+	*
+	* @example
+	* ```ts
+	* import {ThreadWindow} from '@quilted/threads';
+	*
+	* const {getMessage} = ThreadWindow.import(window);
+	* const message = await getMessage(); // 'Hello, world!'
+	*
+	* // In the nested window:
+	*
+	* import {ThreadNestedWindow} from '@quilted/threads';
+	*
+	* ThreadNestedWindow.export(window.opener, {
+	*   async getMessage() {
+	*     return 'Hello, world!';
+	*   },
+	* });
+	* ```
+	*/
+	static import(window, options) {
+		return new ThreadWindow(window, options).imports;
+	}
+	/**
+	* Starts a thread wrapped around a `window` object, providing the second
+	* argument as the exports of the thread.
+	*
+	* @example
+	* ```ts
+	* import {ThreadWindow} from '@quilted/threads';
+	*
+	* ThreadWindow.export(window, {
+	*   async getMessage() {
+	*     return 'Hello, world!';
+	*   },
+	* });
+	*
+	* // In the nested window:
+	*
+	* import {ThreadNestedWindow} from '@quilted/threads';
+	*
+	* const {getMessage} = ThreadNestedWindow.import(window.opener);
+	* const message = await getMessage(); // 'Hello, world!'
+	* ```
+	*/
+	static export(window, exports, options) {
+		new ThreadWindow(window, {
+			...options,
+			exports
+		});
+	}
+	/**
+	* Creates a thread from within a window created by a parent document (for example,
+	* an `iframe` or popup window).
+	*
+	* @see https://developer.mozilla.org/en-US/docs/Web/API/Window/opener
+	*
+	* @example
+	* import {ThreadWindow} from '@quilted/threads';
+	*
+	* // Inside a document opened as a popup window
+	* const thread = ThreadWindow.opener();
+	* await thread.imports.sendMessage('Hello world!');
+	*/
+	static opener = (() => Object.assign((options) => ThreadNestedWindow.from(window.opener, options), {
+		/**
+		* Starts a thread wrapped around a nested `window` object, and returns the imports
+		* of the thread.
+		*
+		* @example
+		* ```ts
+		* import {ThreadWindow} from '@quilted/threads';
+		*
+		* const {getMessage} = ThreadWindow.opener.import();
+		* const message = await getMessage(); // 'Hello, world!'
+		*
+		* // In the parent window:
+		*
+		* import {ThreadWindow} from '@quilted/threads';
+		*
+		* ThreadWindow.export(window, {
+		*   async getMessage() {
+		*     return 'Hello, world!';
+		*   },
+		* });
+		* ```
+		*/
+		import: (options) => ThreadNestedWindow.import(window.opener, options),
+		/**
+		* Starts a thread wrapped around a nested `window` object, providing the second
+		* argument as the exports of the thread.
+		*
+		* @example
+		* ```ts
+		* import {ThreadWindow} from '@quilted/threads';
+		*
+		* ThreadWindow.opener.export({
+		*   async getMessage() {
+		*     return 'Hello, world!';
+		*   },
+		* });
+		*
+		* // In the parent window:
+		*
+		* import {ThreadWindow} from '@quilted/threads';
+		*
+		* const {getMessage} = ThreadWindow.import(window);
+		* const message = await getMessage(); // 'Hello, world!'
+		* ```
+		*/
+		export: (exports, options) => ThreadNestedWindow.export(window.opener, {
+			...options,
+			exports
+		})
+	}))();
+	constructor(window, { targetOrigin = "*", ...options } = {}) {
+		super(windowToThreadTarget(window, { targetOrigin }), options);
+		this.window = window;
+	}
+};
+function windowToThreadTarget(window, { targetOrigin = "*" } = {}) {
+	let connected = false;
+	const sendMessage = function send(message, transfer) {
+		window.postMessage(message, targetOrigin, transfer);
+	};
+	const connectedPromise = new Promise((resolve) => {
+		const abort = new AbortController();
+		globalThis.window.addEventListener("message", (event) => {
+			if (event.source !== window) return;
+			if (event.data === "quilt.threads.pong") {
+				connected = true;
+				abort.abort();
+				resolve();
+			}
+		}, { signal: abort.signal });
+		abort.signal.addEventListener("abort", () => resolve(), { once: true });
+		sendMessage(CHECK_MESSAGE);
+	});
+	return {
+		send(message, transfer) {
+			if (!connected) return connectedPromise.then(() => {
+				if (connected) return sendMessage(message, transfer);
+			});
+			return sendMessage(message, transfer);
+		},
+		listen(listen, { signal }) {
+			self.addEventListener("message", (event) => {
+				if (event.source !== window) return;
+				if (event.data === "quilt.threads.pong") return;
+				listen(event.data);
+			}, { signal });
+		}
+	};
+}
+//#endregion
+export { ThreadWindow, windowToThreadTarget };
+
+//# sourceMappingURL=ThreadWindow.mjs.map

package/dist/js/node_modules/.pnpm/@quilted_threads@3.3.1_patch_hash_df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/window/ThreadWindow.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThreadWindow.mjs","names":[],"sources":["../../../../../../../../../../../../../../node_modules/.pnpm/@quilted+threads@3.3.1_patch_hash=df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/window/ThreadWindow.mjs"],"sourcesContent":["import { Thread } from '../../Thread.mjs';\nimport { RESPONSE_MESSAGE, CHECK_MESSAGE } from './shared.mjs';\nimport { ThreadNestedWindow } from './ThreadNestedWindow.mjs';\n\n/**\n * Creates a thread from a `Window` created by this environment.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe\n *\n * @example\n * import {ThreadWindow} from '@quilted/threads';\n *\n * const popup = window.open('https://my-app.com/popup', 'MyAppPopup', 'popup');\n * const thread = new ThreadWindow(popup);\n * await thread.imports.sendMessage('Hello world!');\n */\nclass ThreadWindow extends Thread {\n  /**\n   * Creates a thread from a `Window` created by this environment.\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe\n   *\n   * @example\n   * import {ThreadWindow} from '@quilted/threads';\n   *\n   * const popup = window.open('https://my-app.com/popup', 'MyAppPopup', 'popup');\n   * const thread = ThreadWindow.from(popup);\n   * await thread.imports.sendMessage('Hello world!');\n   */\n  static from(window, options) {\n    return new ThreadWindow(window, options);\n  }\n\n  /**\n   * Starts a thread wrapped around a `window` object, and returns the imports\n   * of the thread.\n   *\n   * @example\n   * ```ts\n   * import {ThreadWindow} from '@quilted/threads';\n   *\n   * const {getMessage} = ThreadWindow.import(window);\n   * const message = await getMessage(); // 'Hello, world!'\n   *\n   * // In the nested window:\n   *\n   * import {ThreadNestedWindow} from '@quilted/threads';\n   *\n   * ThreadNestedWindow.export(window.opener, {\n   *   async getMessage() {\n   *     return 'Hello, world!';\n   *   },\n   * });\n   * ```\n   */\n  static import(window, options) {\n    return new ThreadWindow(window, options).imports;\n  }\n\n  /**\n   * Starts a thread wrapped around a `window` object, providing the second\n   * argument as the exports of the thread.\n   *\n   * @example\n   * ```ts\n   * import {ThreadWindow} from '@quilted/threads';\n   *\n   * ThreadWindow.export(window, {\n   *   async getMessage() {\n   *     return 'Hello, world!';\n   *   },\n   * });\n   *\n   * // In the nested window:\n   *\n   * import {ThreadNestedWindow} from '@quilted/threads';\n   *\n   * const {getMessage} = ThreadNestedWindow.import(window.opener);\n   * const message = await getMessage(); // 'Hello, world!'\n   * ```\n   */\n  static export(window, exports, options) {\n    new ThreadWindow(window, {\n      ...options,\n      exports\n    });\n  }\n\n  /**\n   * Creates a thread from within a window created by a parent document (for example,\n   * an `iframe` or popup window).\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/opener\n   *\n   * @example\n   * import {ThreadWindow} from '@quilted/threads';\n   *\n   * // Inside a document opened as a popup window\n   * const thread = ThreadWindow.opener();\n   * await thread.imports.sendMessage('Hello world!');\n   */\n  static opener = (() => Object.assign(options => ThreadNestedWindow.from(window.opener, options), {\n    /**\n     * Starts a thread wrapped around a nested `window` object, and returns the imports\n     * of the thread.\n     *\n     * @example\n     * ```ts\n     * import {ThreadWindow} from '@quilted/threads';\n     *\n     * const {getMessage} = ThreadWindow.opener.import();\n     * const message = await getMessage(); // 'Hello, world!'\n     *\n     * // In the parent window:\n     *\n     * import {ThreadWindow} from '@quilted/threads';\n     *\n     * ThreadWindow.export(window, {\n     *   async getMessage() {\n     *     return 'Hello, world!';\n     *   },\n     * });\n     * ```\n     */\n    import: options => ThreadNestedWindow.import(window.opener, options),\n    /**\n     * Starts a thread wrapped around a nested `window` object, providing the second\n     * argument as the exports of the thread.\n     *\n     * @example\n     * ```ts\n     * import {ThreadWindow} from '@quilted/threads';\n     *\n     * ThreadWindow.opener.export({\n     *   async getMessage() {\n     *     return 'Hello, world!';\n     *   },\n     * });\n     *\n     * // In the parent window:\n     *\n     * import {ThreadWindow} from '@quilted/threads';\n     *\n     * const {getMessage} = ThreadWindow.import(window);\n     * const message = await getMessage(); // 'Hello, world!'\n     * ```\n     */\n    export: (exports, options) => ThreadNestedWindow.export(window.opener, {\n      ...options,\n      exports\n    })\n  }))();\n  constructor(window, {\n    targetOrigin = '*',\n    ...options\n  } = {}) {\n    super(windowToThreadTarget(window, {\n      targetOrigin\n    }), options);\n    this.window = window;\n  }\n}\nfunction windowToThreadTarget(window, {\n  targetOrigin = '*'\n} = {}) {\n  let connected = false;\n  const sendMessage = function send(message, transfer) {\n    window.postMessage(message, targetOrigin, transfer);\n  };\n  const connectedPromise = new Promise(resolve => {\n    const abort = new AbortController();\n    globalThis.window.addEventListener('message', event => {\n      if (event.source !== window) return;\n      if (event.data === RESPONSE_MESSAGE) {\n        connected = true;\n        abort.abort();\n        resolve();\n      }\n    }, {\n      signal: abort.signal\n    });\n    abort.signal.addEventListener('abort', () => resolve(), {\n      once: true\n    });\n    sendMessage(CHECK_MESSAGE);\n  });\n  return {\n    send(message, transfer) {\n      if (!connected) {\n        return connectedPromise.then(() => {\n          if (connected) return sendMessage(message, transfer);\n        });\n      }\n      return sendMessage(message, transfer);\n    },\n    listen(listen, {\n      signal\n    }) {\n      self.addEventListener('message', event => {\n        if (event.source !== window) return;\n        if (event.data === RESPONSE_MESSAGE) return;\n        listen(event.data);\n      }, {\n        signal\n      });\n    }\n  };\n}\n\nexport { ThreadWindow, windowToThreadTarget };\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;AAgBA,IAAM,eAAN,MAAM,qBAAqB,OAAO;;;;;;;;;;;;;CAahC,OAAO,KAAK,QAAQ,SAAS;EAC3B,OAAO,IAAI,aAAa,QAAQ,OAAO;CACzC;;;;;;;;;;;;;;;;;;;;;;;CAwBA,OAAO,OAAO,QAAQ,SAAS;EAC7B,OAAO,IAAI,aAAa,QAAQ,OAAO,CAAC,CAAC;CAC3C;;;;;;;;;;;;;;;;;;;;;;;CAwBA,OAAO,OAAO,QAAQ,SAAS,SAAS;EACtC,IAAI,aAAa,QAAQ;GACvB,GAAG;GACH;EACF,CAAC;CACH;;;;;;;;;;;;;;CAeA,OAAO,gBAAgB,OAAO,QAAO,YAAW,mBAAmB,KAAK,OAAO,QAAQ,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;EAuB/F,SAAQ,YAAW,mBAAmB,OAAO,OAAO,QAAQ,OAAO;;;;;;;;;;;;;;;;;;;;;;;EAuBnE,SAAS,SAAS,YAAY,mBAAmB,OAAO,OAAO,QAAQ;GACrE,GAAG;GACH;EACF,CAAC;CACH,CAAC,EAAA,CAAG;CACJ,YAAY,QAAQ,EAClB,eAAe,KACf,GAAG,YACD,CAAC,GAAG;EACN,MAAM,qBAAqB,QAAQ,EACjC,aACF,CAAC,GAAG,OAAO;EACX,KAAK,SAAS;CAChB;AACF;AACA,SAAS,qBAAqB,QAAQ,EACpC,eAAe,QACb,CAAC,GAAG;CACN,IAAI,YAAY;CAChB,MAAM,cAAc,SAAS,KAAK,SAAS,UAAU;EACnD,OAAO,YAAY,SAAS,cAAc,QAAQ;CACpD;CACA,MAAM,mBAAmB,IAAI,SAAQ,YAAW;EAC9C,MAAM,QAAQ,IAAI,gBAAgB;EAClC,WAAW,OAAO,iBAAiB,YAAW,UAAS;GACrD,IAAI,MAAM,WAAW,QAAQ;GAC7B,IAAI,MAAM,SAAA,sBAA2B;IACnC,YAAY;IACZ,MAAM,MAAM;IACZ,QAAQ;GACV;EACF,GAAG,EACD,QAAQ,MAAM,OAChB,CAAC;EACD,MAAM,OAAO,iBAAiB,eAAe,QAAQ,GAAG,EACtD,MAAM,KACR,CAAC;EACD,YAAY,aAAa;CAC3B,CAAC;CACD,OAAO;EACL,KAAK,SAAS,UAAU;GACtB,IAAI,CAAC,WACH,OAAO,iBAAiB,WAAW;IACjC,IAAI,WAAW,OAAO,YAAY,SAAS,QAAQ;GACrD,CAAC;GAEH,OAAO,YAAY,SAAS,QAAQ;EACtC;EACA,OAAO,QAAQ,EACb,UACC;GACD,KAAK,iBAAiB,YAAW,UAAS;IACxC,IAAI,MAAM,WAAW,QAAQ;IAC7B,IAAI,MAAM,SAAA,sBAA2B;IACrC,OAAO,MAAM,IAAI;GACnB,GAAG,EACD,OACF,CAAC;EACH;CACF;AACF"}

package/dist/js/node_modules/.pnpm/@quilted_threads@3.3.1_patch_hash_df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/window/shared.mjs

@@ -0,0 +1,7 @@
+//#region ../../node_modules/.pnpm/@quilted+threads@3.3.1_patch_hash=df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/window/shared.mjs
+var CHECK_MESSAGE = "quilt.threads.ping";
+var RESPONSE_MESSAGE = "quilt.threads.pong";
+//#endregion
+export { CHECK_MESSAGE, RESPONSE_MESSAGE };
+
+//# sourceMappingURL=shared.mjs.map

package/dist/js/node_modules/.pnpm/@quilted_threads@3.3.1_patch_hash_df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/window/shared.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.mjs","names":[],"sources":["../../../../../../../../../../../../../../node_modules/.pnpm/@quilted+threads@3.3.1_patch_hash=df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/threads/window/shared.mjs"],"sourcesContent":["const CHECK_MESSAGE = 'quilt.threads.ping';\nconst RESPONSE_MESSAGE = 'quilt.threads.pong';\n\nexport { CHECK_MESSAGE, RESPONSE_MESSAGE };\n"],"x_google_ignoreList":[0],"mappings":";AAAA,IAAM,gBAAgB;AACtB,IAAM,mBAAmB"}

package/dist/js/node_modules/.pnpm/@quilted_threads@3.3.1_patch_hash_df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/transfer.mjs

@@ -0,0 +1,16 @@
+import { TRANSFERABLE } from "./constants.mjs";
+//#region ../../node_modules/.pnpm/@quilted+threads@3.3.1_patch_hash=df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/transfer.mjs
+/**
+* Marks the value as being transferable between threads. The memory for this object
+* will be moved to the target thread once the object is sent.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Transferable_objects
+*/
+function markAsTransferable(value) {
+	Object.assign(value, { [TRANSFERABLE]: true });
+	return value;
+}
+//#endregion
+export { markAsTransferable };
+
+//# sourceMappingURL=transfer.mjs.map

package/dist/js/node_modules/.pnpm/@quilted_threads@3.3.1_patch_hash_df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/transfer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer.mjs","names":[],"sources":["../../../../../../../../../../../../node_modules/.pnpm/@quilted+threads@3.3.1_patch_hash=df15ead5d86def314ee16ab6a48f9e4faa765b52aa161b10d2848_aa11bff1669c76d0bae25976909ea4eb/node_modules/@quilted/threads/build/esm/transfer.mjs"],"sourcesContent":["import { TRANSFERABLE } from './constants.mjs';\n\n/**\n * Marks the value as being transferable between threads. The memory for this object\n * will be moved to the target thread once the object is sent.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Transferable_objects\n */\nfunction markAsTransferable(value) {\n  Object.assign(value, {\n    [TRANSFERABLE]: true\n  });\n  return value;\n}\n\nexport { markAsTransferable };\n"],"x_google_ignoreList":[0],"mappings":";;;;;;;;AAQA,SAAS,mBAAmB,OAAO;CACjC,OAAO,OAAO,OAAO,GAClB,eAAe,KAClB,CAAC;CACD,OAAO;AACT"}