@crowdstrike/foundry-js 0.2.2

package/dist/index.js

@@ -0,0 +1,911 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function Memoize(args) {
+    let hashFunction;
+    let duration;
+    let tags;
+    if (typeof args === 'object') {
+        hashFunction = args.hashFunction;
+        duration = args.expiring;
+        tags = args.tags;
+    }
+    else {
+        hashFunction = args;
+    }
+    return (target, propertyKey, descriptor) => {
+        if (descriptor.value != null) {
+            descriptor.value = getNewFunction(descriptor.value, hashFunction, duration, tags);
+        }
+        else if (descriptor.get != null) {
+            descriptor.get = getNewFunction(descriptor.get, hashFunction, duration, tags);
+        }
+        else {
+            throw 'Only put a Memoize() decorator on a method or get accessor.';
+        }
+    };
+}
+const clearCacheTagsMap = new Map();
+function getNewFunction(originalMethod, hashFunction, duration = 0, tags) {
+    const propMapName = Symbol(`__memoized_map__`);
+    return function (...args) {
+        let returnedValue;
+        if (!this.hasOwnProperty(propMapName)) {
+            Object.defineProperty(this, propMapName, {
+                configurable: false,
+                enumerable: false,
+                writable: false,
+                value: new Map()
+            });
+        }
+        let myMap = this[propMapName];
+        if (Array.isArray(tags)) {
+            for (const tag of tags) {
+                if (clearCacheTagsMap.has(tag)) {
+                    clearCacheTagsMap.get(tag).push(myMap);
+                }
+                else {
+                    clearCacheTagsMap.set(tag, [myMap]);
+                }
+            }
+        }
+        if (hashFunction || args.length > 0 || duration > 0) {
+            let hashKey;
+            if (hashFunction === true) {
+                hashKey = args.map(a => a.toString()).join('!');
+            }
+            else if (hashFunction) {
+                hashKey = hashFunction.apply(this, args);
+            }
+            else {
+                hashKey = args[0];
+            }
+            const timestampKey = `${hashKey}__timestamp`;
+            let isExpired = false;
+            if (duration > 0) {
+                if (!myMap.has(timestampKey)) {
+                    isExpired = true;
+                }
+                else {
+                    let timestamp = myMap.get(timestampKey);
+                    isExpired = (Date.now() - timestamp) > duration;
+                }
+            }
+            if (myMap.has(hashKey) && !isExpired) {
+                returnedValue = myMap.get(hashKey);
+            }
+            else {
+                returnedValue = originalMethod.apply(this, args);
+                myMap.set(hashKey, returnedValue);
+                if (duration > 0) {
+                    myMap.set(timestampKey, Date.now());
+                }
+            }
+        }
+        else {
+            const hashKey = this;
+            if (myMap.has(hashKey)) {
+                returnedValue = myMap.get(hashKey);
+            }
+            else {
+                returnedValue = originalMethod.apply(this, args);
+                myMap.set(hashKey, returnedValue);
+            }
+        }
+        return returnedValue;
+    };
+}
+
+/**
+ *
+ * This file is autogenerated.
+ *
+ * DO NOT EDIT DIRECTLY
+ *
+ **/
+class IncidentsApiBridge {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    async getIncidentIds(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'incidents',
+            method: 'getQueriesIncidentsV1',
+            payload: {
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getIncidentEntities(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'incidents',
+            method: 'postEntitiesIncidentsGetV1',
+            payload: {
+                body: postBody,
+                params: urlParams,
+            },
+        };
+        return this.bridge.postMessage(message);
+    }
+}
+
+/**
+ *
+ * This file is autogenerated.
+ *
+ * DO NOT EDIT DIRECTLY
+ *
+ **/
+class RemoteResponseApiBridge {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    async getScriptIds(urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'remoteResponse',
+            method: 'getQueriesScriptsV1',
+            payload: { params: urlParams },
+        };
+        return this.bridge.postMessage(message);
+    }
+    async getScriptEntities(postBody, urlParams = {}) {
+        const message = {
+            type: 'api',
+            api: 'remoteResponse',
+            method: 'postEntitiesScriptsGetV2',
+            payload: { body: postBody, params: urlParams },
+        };
+        return this.bridge.postMessage(message);
+    }
+}
+
+function assertConnection(falcon) {
+    if (!falcon.isConnected) {
+        throw new Error('You cannot call this API before having established a connection to the host!');
+    }
+}
+function isValidResponse(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+event) {
+    return !!event?.data?.meta?.messageId;
+}
+
+/**
+ *
+ * This file is autogenerated from the available APIs for App Platform.
+ *
+ * DO NOT EDIT DIRECTLY
+ *
+ * If you need to change the contents of this file please edit the above configuration file and
+ * then run:
+ *
+ * ```
+ * yarn cs-gen platform-apis
+ * ```
+ *
+ **/
+class FalconPublicApis {
+    isConnected = false;
+    get incidents() {
+        assertConnection(this);
+        return new IncidentsApiBridge(this.bridge);
+    }
+    get remoteResponse() {
+        assertConnection(this);
+        return new RemoteResponseApiBridge(this.bridge);
+    }
+}
+__decorate([
+    Memoize()
+], FalconPublicApis.prototype, "incidents", null);
+__decorate([
+    Memoize()
+], FalconPublicApis.prototype, "remoteResponse", null);
+
+const anyMap = new WeakMap();
+const eventsMap = new WeakMap();
+const producersMap = new WeakMap();
+
+const anyProducer = Symbol('anyProducer');
+const resolvedPromise = Promise.resolve();
+
+// Define symbols for "meta" events.
+const listenerAdded = Symbol('listenerAdded');
+const listenerRemoved = Symbol('listenerRemoved');
+
+let canEmitMetaEvents = false;
+let isGlobalDebugEnabled = false;
+
+function assertEventName(eventName) {
+	if (typeof eventName !== 'string' && typeof eventName !== 'symbol' && typeof eventName !== 'number') {
+		throw new TypeError('`eventName` must be a string, symbol, or number');
+	}
+}
+
+function assertListener(listener) {
+	if (typeof listener !== 'function') {
+		throw new TypeError('listener must be a function');
+	}
+}
+
+function getListeners(instance, eventName) {
+	const events = eventsMap.get(instance);
+	if (!events.has(eventName)) {
+		return;
+	}
+
+	return events.get(eventName);
+}
+
+function getEventProducers(instance, eventName) {
+	const key = typeof eventName === 'string' || typeof eventName === 'symbol' || typeof eventName === 'number' ? eventName : anyProducer;
+	const producers = producersMap.get(instance);
+	if (!producers.has(key)) {
+		return;
+	}
+
+	return producers.get(key);
+}
+
+function enqueueProducers(instance, eventName, eventData) {
+	const producers = producersMap.get(instance);
+	if (producers.has(eventName)) {
+		for (const producer of producers.get(eventName)) {
+			producer.enqueue(eventData);
+		}
+	}
+
+	if (producers.has(anyProducer)) {
+		const item = Promise.all([eventName, eventData]);
+		for (const producer of producers.get(anyProducer)) {
+			producer.enqueue(item);
+		}
+	}
+}
+
+function iterator(instance, eventNames) {
+	eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
+
+	let isFinished = false;
+	let flush = () => {};
+	let queue = [];
+
+	const producer = {
+		enqueue(item) {
+			queue.push(item);
+			flush();
+		},
+		finish() {
+			isFinished = true;
+			flush();
+		},
+	};
+
+	for (const eventName of eventNames) {
+		let set = getEventProducers(instance, eventName);
+		if (!set) {
+			set = new Set();
+			const producers = producersMap.get(instance);
+			producers.set(eventName, set);
+		}
+
+		set.add(producer);
+	}
+
+	return {
+		async next() {
+			if (!queue) {
+				return {done: true};
+			}
+
+			if (queue.length === 0) {
+				if (isFinished) {
+					queue = undefined;
+					return this.next();
+				}
+
+				await new Promise(resolve => {
+					flush = resolve;
+				});
+
+				return this.next();
+			}
+
+			return {
+				done: false,
+				value: await queue.shift(),
+			};
+		},
+
+		async return(value) {
+			queue = undefined;
+
+			for (const eventName of eventNames) {
+				const set = getEventProducers(instance, eventName);
+				if (set) {
+					set.delete(producer);
+					if (set.size === 0) {
+						const producers = producersMap.get(instance);
+						producers.delete(eventName);
+					}
+				}
+			}
+
+			flush();
+
+			return arguments.length > 0
+				? {done: true, value: await value}
+				: {done: true};
+		},
+
+		[Symbol.asyncIterator]() {
+			return this;
+		},
+	};
+}
+
+function defaultMethodNamesOrAssert(methodNames) {
+	if (methodNames === undefined) {
+		return allEmitteryMethods;
+	}
+
+	if (!Array.isArray(methodNames)) {
+		throw new TypeError('`methodNames` must be an array of strings');
+	}
+
+	for (const methodName of methodNames) {
+		if (!allEmitteryMethods.includes(methodName)) {
+			if (typeof methodName !== 'string') {
+				throw new TypeError('`methodNames` element must be a string');
+			}
+
+			throw new Error(`${methodName} is not Emittery method`);
+		}
+	}
+
+	return methodNames;
+}
+
+const isMetaEvent = eventName => eventName === listenerAdded || eventName === listenerRemoved;
+
+function emitMetaEvent(emitter, eventName, eventData) {
+	if (isMetaEvent(eventName)) {
+		try {
+			canEmitMetaEvents = true;
+			emitter.emit(eventName, eventData);
+		} finally {
+			canEmitMetaEvents = false;
+		}
+	}
+}
+
+class Emittery {
+	static mixin(emitteryPropertyName, methodNames) {
+		methodNames = defaultMethodNamesOrAssert(methodNames);
+		return target => {
+			if (typeof target !== 'function') {
+				throw new TypeError('`target` must be function');
+			}
+
+			for (const methodName of methodNames) {
+				if (target.prototype[methodName] !== undefined) {
+					throw new Error(`The property \`${methodName}\` already exists on \`target\``);
+				}
+			}
+
+			function getEmitteryProperty() {
+				Object.defineProperty(this, emitteryPropertyName, {
+					enumerable: false,
+					value: new Emittery(),
+				});
+				return this[emitteryPropertyName];
+			}
+
+			Object.defineProperty(target.prototype, emitteryPropertyName, {
+				enumerable: false,
+				get: getEmitteryProperty,
+			});
+
+			const emitteryMethodCaller = methodName => function (...args) {
+				return this[emitteryPropertyName][methodName](...args);
+			};
+
+			for (const methodName of methodNames) {
+				Object.defineProperty(target.prototype, methodName, {
+					enumerable: false,
+					value: emitteryMethodCaller(methodName),
+				});
+			}
+
+			return target;
+		};
+	}
+
+	static get isDebugEnabled() {
+		// In a browser environment, `globalThis.process` can potentially reference a DOM Element with a `#process` ID,
+		// so instead of just type checking `globalThis.process`, we need to make sure that `globalThis.process.env` exists.
+		// eslint-disable-next-line n/prefer-global/process
+		if (typeof globalThis.process?.env !== 'object') {
+			return isGlobalDebugEnabled;
+		}
+
+		// eslint-disable-next-line n/prefer-global/process
+		const {env} = globalThis.process ?? {env: {}};
+		return env.DEBUG === 'emittery' || env.DEBUG === '*' || isGlobalDebugEnabled;
+	}
+
+	static set isDebugEnabled(newValue) {
+		isGlobalDebugEnabled = newValue;
+	}
+
+	constructor(options = {}) {
+		anyMap.set(this, new Set());
+		eventsMap.set(this, new Map());
+		producersMap.set(this, new Map());
+
+		producersMap.get(this).set(anyProducer, new Set());
+
+		this.debug = options.debug ?? {};
+
+		if (this.debug.enabled === undefined) {
+			this.debug.enabled = false;
+		}
+
+		if (!this.debug.logger) {
+			this.debug.logger = (type, debugName, eventName, eventData) => {
+				try {
+					// TODO: Use https://github.com/sindresorhus/safe-stringify when the package is more mature. Just copy-paste the code.
+					eventData = JSON.stringify(eventData);
+				} catch {
+					eventData = `Object with the following keys failed to stringify: ${Object.keys(eventData).join(',')}`;
+				}
+
+				if (typeof eventName === 'symbol' || typeof eventName === 'number') {
+					eventName = eventName.toString();
+				}
+
+				const currentTime = new Date();
+				const logTime = `${currentTime.getHours()}:${currentTime.getMinutes()}:${currentTime.getSeconds()}.${currentTime.getMilliseconds()}`;
+				console.log(`[${logTime}][emittery:${type}][${debugName}] Event Name: ${eventName}\n\tdata: ${eventData}`);
+			};
+		}
+	}
+
+	logIfDebugEnabled(type, eventName, eventData) {
+		if (Emittery.isDebugEnabled || this.debug.enabled) {
+			this.debug.logger(type, this.debug.name, eventName, eventData);
+		}
+	}
+
+	on(eventNames, listener) {
+		assertListener(listener);
+
+		eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
+		for (const eventName of eventNames) {
+			assertEventName(eventName);
+			let set = getListeners(this, eventName);
+			if (!set) {
+				set = new Set();
+				const events = eventsMap.get(this);
+				events.set(eventName, set);
+			}
+
+			set.add(listener);
+
+			this.logIfDebugEnabled('subscribe', eventName, undefined);
+
+			if (!isMetaEvent(eventName)) {
+				emitMetaEvent(this, listenerAdded, {eventName, listener});
+			}
+		}
+
+		return this.off.bind(this, eventNames, listener);
+	}
+
+	off(eventNames, listener) {
+		assertListener(listener);
+
+		eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
+		for (const eventName of eventNames) {
+			assertEventName(eventName);
+			const set = getListeners(this, eventName);
+			if (set) {
+				set.delete(listener);
+				if (set.size === 0) {
+					const events = eventsMap.get(this);
+					events.delete(eventName);
+				}
+			}
+
+			this.logIfDebugEnabled('unsubscribe', eventName, undefined);
+
+			if (!isMetaEvent(eventName)) {
+				emitMetaEvent(this, listenerRemoved, {eventName, listener});
+			}
+		}
+	}
+
+	once(eventNames) {
+		let off_;
+
+		const promise = new Promise(resolve => {
+			off_ = this.on(eventNames, data => {
+				off_();
+				resolve(data);
+			});
+		});
+
+		promise.off = off_;
+		return promise;
+	}
+
+	events(eventNames) {
+		eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
+		for (const eventName of eventNames) {
+			assertEventName(eventName);
+		}
+
+		return iterator(this, eventNames);
+	}
+
+	async emit(eventName, eventData) {
+		assertEventName(eventName);
+
+		if (isMetaEvent(eventName) && !canEmitMetaEvents) {
+			throw new TypeError('`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`');
+		}
+
+		this.logIfDebugEnabled('emit', eventName, eventData);
+
+		enqueueProducers(this, eventName, eventData);
+
+		const listeners = getListeners(this, eventName) ?? new Set();
+		const anyListeners = anyMap.get(this);
+		const staticListeners = [...listeners];
+		const staticAnyListeners = isMetaEvent(eventName) ? [] : [...anyListeners];
+
+		await resolvedPromise;
+		await Promise.all([
+			...staticListeners.map(async listener => {
+				if (listeners.has(listener)) {
+					return listener(eventData);
+				}
+			}),
+			...staticAnyListeners.map(async listener => {
+				if (anyListeners.has(listener)) {
+					return listener(eventName, eventData);
+				}
+			}),
+		]);
+	}
+
+	async emitSerial(eventName, eventData) {
+		assertEventName(eventName);
+
+		if (isMetaEvent(eventName) && !canEmitMetaEvents) {
+			throw new TypeError('`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`');
+		}
+
+		this.logIfDebugEnabled('emitSerial', eventName, eventData);
+
+		const listeners = getListeners(this, eventName) ?? new Set();
+		const anyListeners = anyMap.get(this);
+		const staticListeners = [...listeners];
+		const staticAnyListeners = [...anyListeners];
+
+		await resolvedPromise;
+		/* eslint-disable no-await-in-loop */
+		for (const listener of staticListeners) {
+			if (listeners.has(listener)) {
+				await listener(eventData);
+			}
+		}
+
+		for (const listener of staticAnyListeners) {
+			if (anyListeners.has(listener)) {
+				await listener(eventName, eventData);
+			}
+		}
+		/* eslint-enable no-await-in-loop */
+	}
+
+	onAny(listener) {
+		assertListener(listener);
+
+		this.logIfDebugEnabled('subscribeAny', undefined, undefined);
+
+		anyMap.get(this).add(listener);
+		emitMetaEvent(this, listenerAdded, {listener});
+		return this.offAny.bind(this, listener);
+	}
+
+	anyEvent() {
+		return iterator(this);
+	}
+
+	offAny(listener) {
+		assertListener(listener);
+
+		this.logIfDebugEnabled('unsubscribeAny', undefined, undefined);
+
+		emitMetaEvent(this, listenerRemoved, {listener});
+		anyMap.get(this).delete(listener);
+	}
+
+	clearListeners(eventNames) {
+		eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
+
+		for (const eventName of eventNames) {
+			this.logIfDebugEnabled('clear', eventName, undefined);
+
+			if (typeof eventName === 'string' || typeof eventName === 'symbol' || typeof eventName === 'number') {
+				const set = getListeners(this, eventName);
+				if (set) {
+					set.clear();
+				}
+
+				const producers = getEventProducers(this, eventName);
+				if (producers) {
+					for (const producer of producers) {
+						producer.finish();
+					}
+
+					producers.clear();
+				}
+			} else {
+				anyMap.get(this).clear();
+
+				for (const [eventName, listeners] of eventsMap.get(this).entries()) {
+					listeners.clear();
+					eventsMap.get(this).delete(eventName);
+				}
+
+				for (const [eventName, producers] of producersMap.get(this).entries()) {
+					for (const producer of producers) {
+						producer.finish();
+					}
+
+					producers.clear();
+					producersMap.get(this).delete(eventName);
+				}
+			}
+		}
+	}
+
+	listenerCount(eventNames) {
+		eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
+		let count = 0;
+
+		for (const eventName of eventNames) {
+			if (typeof eventName === 'string') {
+				count += anyMap.get(this).size
+					+ (getListeners(this, eventName)?.size ?? 0)
+					+ (getEventProducers(this, eventName)?.size ?? 0)
+					+ (getEventProducers(this)?.size ?? 0);
+
+				continue;
+			}
+
+			if (typeof eventName !== 'undefined') {
+				assertEventName(eventName);
+			}
+
+			count += anyMap.get(this).size;
+
+			for (const value of eventsMap.get(this).values()) {
+				count += value.size;
+			}
+
+			for (const value of producersMap.get(this).values()) {
+				count += value.size;
+			}
+		}
+
+		return count;
+	}
+
+	bindMethods(target, methodNames) {
+		if (typeof target !== 'object' || target === null) {
+			throw new TypeError('`target` must be an object');
+		}
+
+		methodNames = defaultMethodNamesOrAssert(methodNames);
+
+		for (const methodName of methodNames) {
+			if (target[methodName] !== undefined) {
+				throw new Error(`The property \`${methodName}\` already exists on \`target\``);
+			}
+
+			Object.defineProperty(target, methodName, {
+				enumerable: false,
+				value: this[methodName].bind(this),
+			});
+		}
+	}
+}
+
+const allEmitteryMethods = Object.getOwnPropertyNames(Emittery.prototype).filter(v => v !== 'constructor');
+
+Object.defineProperty(Emittery, 'listenerAdded', {
+	value: listenerAdded,
+	writable: false,
+	enumerable: true,
+	configurable: false,
+});
+Object.defineProperty(Emittery, 'listenerRemoved', {
+	value: listenerRemoved,
+	writable: false,
+	enumerable: true,
+	configurable: false,
+});
+
+// Unique ID creation requires a high quality random # generator. In the browser we therefore
+// require the crypto API and do not support built-in fallback to lower quality random number
+// generators (like Math.random()).
+let getRandomValues;
+const rnds8 = new Uint8Array(16);
+function rng() {
+  // lazy load so that environments that need to polyfill have a chance to do so
+  if (!getRandomValues) {
+    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
+    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
+
+    if (!getRandomValues) {
+      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+    }
+  }
+
+  return getRandomValues(rnds8);
+}
+
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+
+const byteToHex = [];
+
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 0x100).toString(16).slice(1));
+}
+
+function unsafeStringify(arr, offset = 0) {
+  // Note: Be careful editing this code!  It's been tuned for performance
+  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+var native = {
+  randomUUID
+};
+
+function v4(options, buf, offset) {
+  if (native.randomUUID && !buf && !options) {
+    return native.randomUUID();
+  }
+
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+
+  rnds[6] = rnds[6] & 0x0f | 0x40;
+  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
+
+  if (buf) {
+    offset = offset || 0;
+
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+
+    return buf;
+  }
+
+  return unsafeStringify(rnds);
+}
+
+const VERSION = 'current';
+
+const CONNECTION_TIMEOUT = 5000;
+class Bridge {
+    onDataUpdate;
+    pendingMessages = new Map();
+    targetOrigin = '*';
+    constructor({ onDataUpdate } = {}) {
+        this.onDataUpdate = onDataUpdate;
+        window.addEventListener('message', this.handleMessage);
+    }
+    destroy() {
+        window.removeEventListener('message', this.handleMessage);
+    }
+    setOrigin(origin) {
+        this.targetOrigin = origin;
+    }
+    async postMessage(message) {
+        return new Promise((resolve, reject) => {
+            const messageId = v4();
+            const timeoutTimer = setTimeout(() => {
+                reject(new Error(`Waiting for response from foundry host for "${message.type}" message (ID: ${messageId}) timed out after ${CONNECTION_TIMEOUT}ms`));
+            }, CONNECTION_TIMEOUT);
+            this.pendingMessages.set(messageId, (result) => {
+                clearTimeout(timeoutTimer);
+                resolve(result);
+            });
+            const eventData = {
+                message,
+                meta: {
+                    messageId,
+                    version: VERSION,
+                },
+            };
+            window.parent.postMessage(eventData, this.targetOrigin);
+        });
+    }
+    handleMessage = (event) => {
+        if (!isValidResponse(event)) {
+            return;
+        }
+        const message = event.data.message;
+        if (message.type === 'data') {
+            this.onDataUpdate?.(message);
+            // data update events are unidirectional and originated from the host, so there cannot be a callback waiting for this message
+            return;
+        }
+        const { messageId } = event.data.meta;
+        const callback = this.pendingMessages.get(messageId);
+        if (!callback) {
+            throw new Error(`Received unexpected message`);
+        }
+        this.pendingMessages.delete(messageId);
+        callback(message.payload);
+    };
+}
+
+class FalconApi extends FalconPublicApis {
+    events = new Emittery();
+    data;
+    bridge = new Bridge({
+        onDataUpdate: (data) => this.handleDataUpdate(data),
+    });
+    async connect() {
+        const { origin, data } = await this.bridge.postMessage({ type: 'connect' });
+        this.bridge.setOrigin(origin);
+        this.data = data;
+        this.isConnected = true;
+    }
+    handleDataUpdate(dataMessage) {
+        this.data = dataMessage.payload;
+        this.events.emit('data', this.data);
+    }
+    destroy() {
+        this.bridge.destroy();
+    }
+}
+
+export { FalconApi as default };
+//# sourceMappingURL=index.js.map