@configdirector/react-native-sdk 1.5.1 → 1.6.0

package/dist/installedTestClient-CxGEAMOE.mjs

@@ -0,0 +1,1341 @@
+//#region \0@oxc-project+runtime@0.122.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.122.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.122.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.122.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region ../js-client-core/src/Emitter.ts
+var Emitter = class {
+	constructor() {
+		_defineProperty(this, "handlerMap", /* @__PURE__ */ new Map());
+	}
+	on(name, handler) {
+		const handlers = this.handlerMap.get(name);
+		if (handlers) handlers.push(handler);
+		else this.handlerMap.set(name, [handler]);
+	}
+	once(name, handler) {
+		const self = this;
+		function onceHandler(payload) {
+			self.off(name, onceHandler);
+			handler.apply(self, payload);
+		}
+		this.on(name, onceHandler);
+	}
+	off(name, handler) {
+		const handlers = this.handlerMap.get(name);
+		if (!handlers) return;
+		if (handler) {
+			const listenerIndex = handlers.indexOf(handler);
+			if (listenerIndex >= 0) handlers.splice(listenerIndex, 1);
+		} else this.handlerMap.set(name, []);
+	}
+	clear() {
+		this.handlerMap.clear();
+	}
+	emit(name, payload) {
+		const handlers = this.handlerMap.get(name);
+		if (!handlers) return;
+		handlers.slice().map((h) => h(payload));
+	}
+};
+//#endregion
+//#region ../shared/src/errors.ts
+var ConfigDirectorConnectionError = class ConfigDirectorConnectionError extends Error {
+	constructor(message, status) {
+		super(message);
+		_defineProperty(this, "name", "ConfigDirectorConnectionError");
+		_defineProperty(this, "status", void 0);
+		this.status = status;
+		Object.setPrototypeOf(this, ConfigDirectorConnectionError.prototype);
+	}
+};
+var ConfigDirectorValidationError = class ConfigDirectorValidationError extends Error {
+	constructor(message) {
+		super(message);
+		_defineProperty(this, "name", "ConfigDirectorValidationError");
+		Object.setPrototypeOf(this, ConfigDirectorValidationError.prototype);
+	}
+};
+//#endregion
+//#region ../js-client-core/src/errors.ts
+const isFetchErrorFatal = (fetchError) => {
+	if ((fetchError === null || fetchError === void 0 ? void 0 : fetchError.name) === "NotAllowedError") return true;
+	else if (fetchError instanceof TypeError) return true;
+	return false;
+};
+//#endregion
+//#region ../eventsource/src/errors.ts
+var StreamClosedError = class StreamClosedError extends Error {
+	constructor(message) {
+		super(message);
+		_defineProperty(this, "name", "StreamClosedError");
+		Object.setPrototypeOf(this, StreamClosedError.prototype);
+	}
+};
+var MissingResponseBodyError = class MissingResponseBodyError extends Error {
+	constructor(message) {
+		super(message);
+		_defineProperty(this, "name", "MissingResponseBodyError");
+		Object.setPrototypeOf(this, MissingResponseBodyError.prototype);
+	}
+};
+var InvalidOptionError = class InvalidOptionError extends Error {
+	constructor(message) {
+		super(message);
+		_defineProperty(this, "name", "InvalidOptionError");
+		Object.setPrototypeOf(this, InvalidOptionError.prototype);
+	}
+};
+var ValueOutOfRangeError = class ValueOutOfRangeError extends Error {
+	constructor(message) {
+		super(message);
+		_defineProperty(this, "name", "ValueOutOfRangeError");
+		Object.setPrototypeOf(this, ValueOutOfRangeError.prototype);
+	}
+};
+//#endregion
+//#region ../eventsource/src/types.ts
+let ReadyState = /* @__PURE__ */ function(ReadyState) {
+	ReadyState["OPEN"] = "open";
+	ReadyState["CLOSED"] = "closed";
+	ReadyState["CONNECTING"] = "connecting";
+	return ReadyState;
+}({});
+//#endregion
+//#region ../eventsource/src/EventSourceParser.ts
+var EventSourceParser = class {
+	constructor(options) {
+		var _options$onEvent;
+		_defineProperty(this, "isFirstChunk", true);
+		_defineProperty(this, "bufferedInput", "");
+		_defineProperty(this, "currentEvent", { data: "" });
+		_defineProperty(this, "lastEventId", void 0);
+		_defineProperty(this, "onEvent", void 0);
+		_defineProperty(this, "onRetry", void 0);
+		_defineProperty(this, "onComment", void 0);
+		this.currentEvent = { data: "" };
+		this.onEvent = (_options$onEvent = options.onEvent) !== null && _options$onEvent !== void 0 ? _options$onEvent : (() => {});
+		this.onRetry = options.onRetry;
+		this.onComment = options.onComment;
+	}
+	parse(chunk) {
+		let input = chunk;
+		if (this.isFirstChunk) {
+			this.isFirstChunk = false;
+			if (input.startsWith("")) input = input.slice(1);
+			else if (input.startsWith("")) input = input.slice(3);
+		}
+		const lines = this.scanLines(this.bufferedInput + input);
+		for (const line of lines) this.dispatchLine(line);
+	}
+	finish() {
+		this.bufferedInput = "";
+	}
+	/**
+	* Scans `text` character by character to extract complete lines, recognizing
+	* CR, LF, and CRLF as line terminators per the SSE spec. Any unterminated
+	* trailing text is buffered and prepended to the next chunk.
+	*/
+	scanLines(text) {
+		const lines = [];
+		let lineStart = 0;
+		let i = 0;
+		while (i < text.length) {
+			const ch = text[i];
+			if (ch === "\r" || ch === "\n") {
+				lines.push(text.slice(lineStart, i));
+				if (ch === "\r" && text[i + 1] === "\n") i++;
+				i++;
+				lineStart = i;
+			} else i++;
+		}
+		this.bufferedInput = text.slice(lineStart);
+		return lines;
+	}
+	dispatchLine(line) {
+		if (line.startsWith(":")) {
+			var _this$onComment;
+			(_this$onComment = this.onComment) === null || _this$onComment === void 0 || _this$onComment.call(this, this.extractValue(line, 1));
+			return;
+		}
+		if (line === "") {
+			this.emitEvent();
+			return;
+		}
+		this.applyField(this.parseField(line));
+	}
+	emitEvent() {
+		const data = this.currentEvent.data.endsWith("\n") ? this.currentEvent.data.slice(0, -1) : this.currentEvent.data;
+		if (data !== "") this.onEvent({
+			...this.currentEvent,
+			id: this.lastEventId,
+			data
+		});
+		this.currentEvent = { data: "" };
+	}
+	applyField(parsed) {
+		switch (parsed.field) {
+			case "event":
+				this.currentEvent.type = parsed.value;
+				break;
+			case "data":
+				this.currentEvent.data += parsed.value + "\n";
+				break;
+			case "id":
+				if (!parsed.value.includes("\0")) this.lastEventId = parsed.value;
+				break;
+			case "retry":
+				if (/^\d+$/.test(parsed.value)) {
+					var _this$onRetry;
+					(_this$onRetry = this.onRetry) === null || _this$onRetry === void 0 || _this$onRetry.call(this, Number.parseInt(parsed.value, 10));
+				}
+				break;
+			default: break;
+		}
+	}
+	parseField(line) {
+		const colon = line.indexOf(":");
+		if (colon === -1) return {
+			field: line,
+			value: ""
+		};
+		return {
+			field: line.slice(0, colon),
+			value: this.extractValue(line, colon + 1)
+		};
+	}
+	/** Returns the value portion of a line, stripping a single leading space per spec. */
+	extractValue(line, from) {
+		return line[from] === " " ? line.slice(from + 1) : line.slice(from);
+	}
+};
+//#endregion
+//#region ../eventsource/src/EventSourceClient.ts
+var EventSourceClient = class {
+	constructor(options) {
+		var _options$method, _options$fetch;
+		_defineProperty(this, "DEFAULT_SHOULD_RECONNECT", () => true);
+		_defineProperty(this, "DEFAULT_CALCULATE_RECONNECT_DELAY", () => this.serverReconnectionTime);
+		_defineProperty(this, "url", void 0);
+		_defineProperty(this, "headers", void 0);
+		_defineProperty(this, "body", void 0);
+		_defineProperty(this, "requestOptions", void 0);
+		_defineProperty(this, "lastEventId", void 0);
+		_defineProperty(this, "reconnectAttempt", 0);
+		_defineProperty(this, "abortController", new AbortController());
+		_defineProperty(this, "reconnectTimeout", void 0);
+		_defineProperty(this, "_readyState", ReadyState.CLOSED);
+		_defineProperty(this, "serverReconnectionTime", 2e3);
+		_defineProperty(this, "_fetch", void 0);
+		_defineProperty(this, "_onError", void 0);
+		_defineProperty(this, "_onMessage", void 0);
+		_defineProperty(this, "_onComment", void 0);
+		_defineProperty(this, "_onConnect", void 0);
+		_defineProperty(this, "_onDisconnect", void 0);
+		_defineProperty(this, "_shouldReconnect", void 0);
+		_defineProperty(this, "_calculateReconnectDelay", void 0);
+		this.url = options.url.toString();
+		this.lastEventId = options.lastEventId;
+		this.headers = {
+			Accept: "text/event-stream",
+			...options.headers
+		};
+		const body = options.body;
+		this.body = typeof body === "function" ? body : () => body;
+		this.requestOptions = {
+			method: (_options$method = options.method) !== null && _options$method !== void 0 ? _options$method : "GET",
+			mode: options.mode,
+			credentials: options.credentials,
+			redirect: options.redirect,
+			referrer: options.referrer,
+			referrerPolicy: options.referrerPolicy
+		};
+		this._fetch = (_options$fetch = options.fetch) !== null && _options$fetch !== void 0 ? _options$fetch : ((url, init) => fetch(url, init));
+		this._onError = this.resolveCallback(options.onError, () => {}, "onError");
+		this._onConnect = this.resolveCallback(options.onConnect, () => {}, "onConnect");
+		this._onDisconnect = this.resolveCallback(options.onDisconnect, () => {}, "onDisconnect");
+		this._onMessage = this.resolveCallback(options.onMessage, () => {}, "onMessage");
+		this._onComment = this.resolveCallback(options.onComment, () => {}, "onComment");
+		this._shouldReconnect = this.resolveCallback(options.shouldReconnect, this.DEFAULT_SHOULD_RECONNECT, "shouldReconnect");
+		this._calculateReconnectDelay = this.resolveCallback(options.calculateReconnectDelay, this.DEFAULT_CALCULATE_RECONNECT_DELAY, "calculateReconnectDelay");
+	}
+	set onError(value) {
+		this._onError = this.resolveCallback(value, () => {}, "onError");
+	}
+	set onMessage(value) {
+		this._onMessage = this.resolveCallback(value, () => {}, "onMessage");
+	}
+	set onComment(value) {
+		this._onComment = this.resolveCallback(value, () => {}, "onComment");
+	}
+	set onConnect(value) {
+		this._onConnect = this.resolveCallback(value, () => {}, "onConnect");
+	}
+	set onDisconnect(value) {
+		this._onDisconnect = this.resolveCallback(value, () => {}, "onDisconnect");
+	}
+	set shouldReconnect(value) {
+		this._shouldReconnect = this.resolveCallback(value, this.DEFAULT_SHOULD_RECONNECT, "shouldReconnect");
+	}
+	set calculateReconnectDelay(value) {
+		this._calculateReconnectDelay = this.resolveCallback(value, this.DEFAULT_CALCULATE_RECONNECT_DELAY, "shouldReconnect");
+	}
+	get readyState() {
+		return this._readyState;
+	}
+	connect() {
+		if (this._readyState !== ReadyState.CLOSED) return;
+		this.reconnectAttempt = 0;
+		this.initiateConnection();
+	}
+	close() {
+		clearTimeout(this.reconnectTimeout);
+		this._readyState = ReadyState.CLOSED;
+		this.abortController.abort();
+	}
+	initiateConnection() {
+		this.abortController = new AbortController();
+		this._readyState = ReadyState.CONNECTING;
+		this._fetch(this.url, {
+			...this.requestOptions,
+			body: this.body(),
+			headers: this.buildRequestHeaders(),
+			signal: this.abortController.signal,
+			cache: "no-store"
+		}).then((response) => this.handleFetchResponse(response)).catch((error) => {
+			if (error.name === "AbortError" || this.abortController.signal.aborted) {
+				this.close();
+				return;
+			}
+			this._onError(error);
+			this.scheduleReconnect({ error });
+		});
+	}
+	async handleFetchResponse(response) {
+		const { body, status } = response;
+		if (status === 204) {
+			this.disconnected();
+			return;
+		}
+		if (status >= 400) {
+			this.scheduleReconnect({ status });
+			return;
+		}
+		if (!body) throw new MissingResponseBodyError("The server response did not have a body");
+		this._readyState = ReadyState.OPEN;
+		this._onConnect();
+		this.reconnectAttempt = 0;
+		const parser = new EventSourceParser({
+			onEvent: (event) => {
+				if (typeof event.id === "string") this.lastEventId = event.id;
+				this._onMessage(event);
+			},
+			onComment: (comment) => this._onComment(comment),
+			onRetry: (retryDelay) => this.serverReconnectionTime = retryDelay
+		});
+		await this.readResponseStream(body, parser);
+		this.scheduleReconnect({
+			status,
+			error: new StreamClosedError("The server response stream was closed")
+		});
+	}
+	async readResponseStream(body, parser) {
+		const reader = body.getReader();
+		const decoder = new TextDecoder();
+		let done = false;
+		while (!done) {
+			const result = await reader.read();
+			if (result.value) parser.parse(decoder.decode(result.value, { stream: true }));
+			done = result.done;
+		}
+		parser.finish();
+	}
+	disconnected() {
+		clearTimeout(this.reconnectTimeout);
+		this._readyState = ReadyState.CLOSED;
+		this._onDisconnect();
+	}
+	buildRequestHeaders() {
+		const lastEventIdHeader = this.lastEventId ? { "Last-Event-ID": this.lastEventId } : void 0;
+		return {
+			...this.headers,
+			...lastEventIdHeader
+		};
+	}
+	scheduleReconnect(state) {
+		if (this.abortController.signal.aborted) return;
+		clearTimeout(this.reconnectTimeout);
+		this.reconnectAttempt += 1;
+		const reconnectionState = {
+			attempt: this.reconnectAttempt,
+			status: state.status,
+			error: state.error,
+			serverReconnectionTime: this.serverReconnectionTime
+		};
+		if (!this._shouldReconnect(reconnectionState)) {
+			this.disconnected();
+			return;
+		}
+		this._readyState = ReadyState.CONNECTING;
+		let delay = this._calculateReconnectDelay(reconnectionState);
+		if (!Number.isFinite(delay) || delay < 1 || delay > 1e3 * 60 * 60) {
+			this._onError(new ValueOutOfRangeError(`The calculated reconnect delay is out of range: ${delay}. Defaulting to ${this.serverReconnectionTime}`));
+			delay = this.serverReconnectionTime;
+		}
+		this.reconnectTimeout = setTimeout(() => this.initiateConnection(), delay);
+	}
+	resolveCallback(provided, fallback, optionName) {
+		if (provided == null) return fallback;
+		if (typeof provided !== "function") throw new InvalidOptionError(`${optionName} must be a function`);
+		return provided;
+	}
+};
+//#endregion
+//#region ../eventsource/src/index.ts
+const createEventSourceClient = (options) => {
+	return new EventSourceClient(options);
+};
+//#endregion
+//#region ../js-client-core/src/StreamingTransport.ts
+var StreamingTransport = class {
+	constructor(options) {
+		this.options = options;
+		_defineProperty(this, "logger", void 0);
+		_defineProperty(this, "eventSource", void 0);
+		_defineProperty(this, "eventEmitter", new Emitter());
+		_defineProperty(this, "url", void 0);
+		_defineProperty(this, "timeoutTimer", void 0);
+		this.options = options;
+		this.logger = options.logger;
+		this.url = options.resolveUrl("client/sse/v1", options.baseUrl);
+	}
+	async connect(context, timeout) {
+		if (this.eventSource) this.close();
+		const eventSourcePromise = new Promise((resolve, reject) => {
+			this.eventSource = createEventSourceClient({
+				url: this.url,
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				fetch: this.options.fetch,
+				body: JSON.stringify({
+					givenContext: context,
+					metaContext: this.options.metaContext,
+					clientSdkKey: this.options.clientSdkKey,
+					instanceId: this.options.instanceId
+				}),
+				onMessage: ({ data }) => {
+					this.dispatchMessage(data);
+				},
+				onConnect: () => {
+					this.logger.debug("[StreamingTransport] Connected");
+					resolve(this);
+				},
+				shouldReconnect: (state) => {
+					const reconnect = !this.isStatusFatal(state.status);
+					if (!reconnect) {
+						const error = this.prepareFatalError(state.status, state.error);
+						this.eventEmitter.emit("connectionError", error);
+						reject(error);
+					}
+					return reconnect;
+				},
+				calculateReconnectDelay: (state) => {
+					const delay = this.options.connectionRetryDelay(state.attempt);
+					const logMessage = `[StreamingTransport] Scheduling reconnect attempt #${state.attempt} in ${delay}ms.`;
+					if (state.attempt <= 5) this.logger.info(logMessage);
+					else this.logger.warn(logMessage);
+					return delay;
+				},
+				onError: (error) => {
+					this.logger.debug("[StreamingTransport] Error: ", error);
+				},
+				onDisconnect: () => {
+					this.logger.debug("[StreamingTransport] Disconnected");
+				}
+			});
+			this.eventSource.connect();
+		});
+		clearTimeout(this.timeoutTimer);
+		this.timeoutTimer = void 0;
+		return Promise.race([eventSourcePromise, new Promise((resolve) => {
+			this.timeoutTimer = setTimeout(() => resolve(this), timeout);
+		})]).finally(() => clearTimeout(this.timeoutTimer));
+	}
+	dispatchMessage(data) {
+		try {
+			const json = JSON.parse(data);
+			this.eventEmitter.emit("configSetReceived", json);
+		} catch (error) {
+			this.logger.error("[StreamingTransport] Error parsing and dispatching config data update: ", error);
+		}
+	}
+	prepareFatalError(responseStatus, error) {
+		const status = responseStatus !== null && responseStatus !== void 0 ? responseStatus : 0;
+		return new ConfigDirectorConnectionError(`${`Connection failed with status: ${responseStatus !== null && responseStatus !== void 0 ? responseStatus : "unknown"}.`}${error ? ` Error: ${error}` : ""}. This is an unrecoverable error, will not attempt to reconnect.`, status);
+	}
+	isStatusFatal(status) {
+		return !!status && status >= 400 && status < 500 && status != 429;
+	}
+	on(name, handler) {
+		this.eventEmitter.on(name, handler);
+	}
+	off(name, handler) {
+		this.eventEmitter.off(name, handler);
+	}
+	clear() {
+		this.eventEmitter.clear();
+	}
+	close() {
+		var _this$eventSource;
+		(_this$eventSource = this.eventSource) === null || _this$eventSource === void 0 || _this$eventSource.close();
+		clearTimeout(this.timeoutTimer);
+	}
+	dispose() {
+		this.close();
+		this.clear();
+	}
+};
+//#endregion
+//#region ../shared/src/value-parser.ts
+const getRequestedType = (defaultValue) => {
+	const baseType = typeof defaultValue;
+	if (baseType === "object") try {
+		var _constructor$name, _constructor;
+		return (_constructor$name = (_constructor = defaultValue.constructor) === null || _constructor === void 0 ? void 0 : _constructor.name) !== null && _constructor$name !== void 0 ? _constructor$name : baseType;
+	} catch {
+		return baseType;
+	}
+	else if (baseType === "function") try {
+		const functionName = defaultValue.name;
+		return functionName ? `function: ${functionName}` : baseType;
+	} catch {
+		return baseType;
+	}
+	return baseType;
+};
+const isNumericNativeType = (requestedType) => {
+	return requestedType === "number" || requestedType === "bigint";
+};
+const configTypesNotReadableAsString = new Set([
+	"boolean",
+	"integer",
+	"float"
+]);
+const parseConfigValue = (configState, defaultValue) => {
+	const value = configState.value;
+	const requestedType = getRequestedType(defaultValue);
+	if (value == null || value === "") return {
+		parsedValue: defaultValue,
+		parsedValueId: void 0,
+		requestedType,
+		usedDefault: true,
+		reason: "value-missing"
+	};
+	if (configState.type === "json") return parseJson(value, defaultValue, requestedType, configState.valueId);
+	if (typeof defaultValue === "string") {
+		if (configTypesNotReadableAsString.has(configState.type)) return {
+			parsedValue: defaultValue,
+			parsedValueId: void 0,
+			requestedType,
+			usedDefault: true,
+			reason: "type-mismatch"
+		};
+		return {
+			parsedValue: value,
+			parsedValueId: configState.valueId,
+			requestedType,
+			usedDefault: false,
+			reason: "found-match"
+		};
+	}
+	if (typeof defaultValue === "boolean" && (configState.type === "boolean" || configState.type === "string" || configState.type === "enum")) {
+		const boolValue = parseConfigBoolean(value);
+		const hasBoolean = typeof boolValue === "boolean";
+		return {
+			parsedValue: hasBoolean ? boolValue : defaultValue,
+			parsedValueId: hasBoolean ? configState.valueId : void 0,
+			requestedType,
+			usedDefault: !hasBoolean,
+			reason: hasBoolean ? "found-match" : "invalid-boolean"
+		};
+	}
+	if (isNumericNativeType(typeof defaultValue) && configState.type === "integer") {
+		const numValue = parseConfigInteger(value);
+		const hasNumber = typeof numValue === "number";
+		return {
+			parsedValue: hasNumber ? numValue : defaultValue,
+			parsedValueId: hasNumber ? configState.valueId : void 0,
+			requestedType,
+			usedDefault: !hasNumber,
+			reason: hasNumber ? "found-match" : "invalid-number"
+		};
+	}
+	if (isNumericNativeType(typeof defaultValue) && (configState.type === "float" || configState.type === "enum" || configState.type === "string")) {
+		const numValue = parseConfigFloat(value);
+		const hasNumber = typeof numValue === "number";
+		return {
+			parsedValue: hasNumber ? numValue : defaultValue,
+			parsedValueId: hasNumber ? configState.valueId : void 0,
+			requestedType,
+			usedDefault: !hasNumber,
+			reason: hasNumber ? "found-match" : "invalid-number"
+		};
+	}
+	return {
+		parsedValue: defaultValue,
+		parsedValueId: void 0,
+		requestedType,
+		usedDefault: true,
+		reason: "type-mismatch"
+	};
+};
+const parseConfigBoolean = (value) => {
+	if (!value) return;
+	const lowerValue = value.toLowerCase();
+	if (lowerValue != "true" && lowerValue != "false") return;
+	return lowerValue === "true";
+};
+const parseConfigInteger = (value) => {
+	const num = parseStrictNumber(value);
+	return num == null ? void 0 : Math.trunc(num);
+};
+const parseConfigFloat = (value) => {
+	return parseStrictNumber(value);
+};
+const parseStrictNumber = (value) => {
+	if (!value || !isDecimalCharacters(value)) return;
+	const num = Number(value);
+	if (isNaN(num) || !isFinite(num)) return;
+	return num;
+};
+const isDecimalCharacters = (value) => {
+	for (const character of value) if (!(character >= "0" && character <= "9") && !"+-.eE".includes(character)) return false;
+	return true;
+};
+const parseJson = (jsonString, defaultValue, requestedType, valueId) => {
+	if (typeof defaultValue === "string") return {
+		parsedValue: jsonString,
+		parsedValueId: valueId,
+		requestedType,
+		usedDefault: false,
+		reason: "found-match"
+	};
+	try {
+		const parsed = JSON.parse(jsonString);
+		if (!isJsonTypeCompatible(parsed, defaultValue)) return {
+			parsedValue: defaultValue,
+			parsedValueId: void 0,
+			requestedType,
+			usedDefault: true,
+			reason: "type-mismatch"
+		};
+		return {
+			parsedValue: parsed,
+			parsedValueId: valueId,
+			requestedType,
+			usedDefault: false,
+			reason: "found-match"
+		};
+	} catch {
+		return {
+			parsedValue: defaultValue,
+			parsedValueId: void 0,
+			requestedType,
+			usedDefault: true,
+			reason: "invalid-json"
+		};
+	}
+};
+const isJsonTypeCompatible = (parsed, defaultValue) => {
+	if (parsed === null) return false;
+	const defaultType = typeof defaultValue;
+	if (defaultType === "bigint") return typeof parsed === "number";
+	return typeof parsed === defaultType;
+};
+//#endregion
+//#region ../shared/src/logger.ts
+const LEVELS = {
+	off: -1,
+	error: 0,
+	warn: 1,
+	info: 2,
+	debug: 3
+};
+const buildDateFormatter = () => {
+	const baseOptions = {
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit",
+		timeZoneName: "short"
+	};
+	try {
+		return new Intl.DateTimeFormat(void 0, {
+			...baseOptions,
+			fractionalSecondDigits: 3
+		});
+	} catch {
+		return new Intl.DateTimeFormat(void 0, baseOptions);
+	}
+};
+var DefaultConsoleLogger = class {
+	constructor(level, decorator) {
+		this.level = level;
+		this.decorator = decorator;
+		_defineProperty(this, "dateFormatter", void 0);
+		this.level = level;
+		this.decorator = decorator;
+		this.dateFormatter = buildDateFormatter();
+	}
+	debug(message, ...args) {
+		this.log(console.debug, "debug", message, ...args);
+	}
+	info(message, ...args) {
+		this.log(console.info, "info", message, ...args);
+	}
+	warn(message, ...args) {
+		this.log(console.warn, "warn", message, ...args);
+	}
+	error(message, ...args) {
+		this.log(console.error, "error", message, ...args);
+	}
+	log(loggerFunction, level, message, ...args) {
+		if (LEVELS[this.level] >= LEVELS[level]) {
+			var _this$decorator;
+			loggerFunction(`[${this.dateFormatter.format(/* @__PURE__ */ new Date())}] ${(_this$decorator = this.decorator) === null || _this$decorator === void 0 ? void 0 : _this$decorator.decorateMessage(message)}`, ...args);
+		}
+	}
+};
+//#endregion
+//#region ../js-client-core/src/logger.ts
+var LogMessageDecorator = class {
+	decorateMessage(message) {
+		return `[ConfigDirector:js-client-sdk] ${message}`;
+	}
+};
+const createDefaultLogger = (level, messageDecorator) => {
+	return new DefaultConsoleLogger(level !== null && level !== void 0 ? level : "warn", messageDecorator !== null && messageDecorator !== void 0 ? messageDecorator : new LogMessageDecorator());
+};
+//#endregion
+//#region ../shared/src/url.ts
+const defaultUrlFactory = (input, base) => new URL(input, base === null || base === void 0 ? void 0 : base.toString());
+//#endregion
+//#region ../shared/src/constants.ts
+const CLIENT_BASE_URL = "https://client-sdk-api.configdirector.com";
+//#endregion
+//#region ../shared/src/transport/pollingInterval.ts
+const resolvePollingInterval = (configuredSeconds, defaults) => {
+	if (configuredSeconds === void 0) return {
+		seconds: defaults.defaultSeconds,
+		warning: void 0
+	};
+	if (configuredSeconds >= defaults.minimumSeconds) return {
+		seconds: configuredSeconds,
+		warning: void 0
+	};
+	return {
+		seconds: defaults.minimumSeconds,
+		warning: `pollingInterval of ${configuredSeconds} seconds is below the minimum of ${defaults.minimumSeconds} seconds. Using ${defaults.minimumSeconds} seconds.`
+	};
+};
+//#endregion
+//#region ../shared/src/instance-id.ts
+const generateInstanceId = () => {
+	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (placeholder) => {
+		const random = Math.random() * 16 | 0;
+		return (placeholder === "x" ? random : random & 3 | 8).toString(16);
+	});
+};
+//#endregion
+//#region ../js-client-core/src/instance-id.ts
+const STORAGE_KEY = "configdirector-sdk:instance-id";
+const RECORD_VERSION = 1;
+const MAX_AGE_MS = 360 * 60 * 1e3;
+const CHECKSUM_SALT = "configdirector.instanceId.v1";
+const UUID_V4_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+const fnv1a = (input, offsetBasis) => {
+	let hash = offsetBasis;
+	for (let i = 0; i < input.length; i++) {
+		hash ^= input.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return hash >>> 0;
+};
+const checksumFor = (id, createdAt) => {
+	const payload = `${CHECKSUM_SALT}|${id}|${createdAt}`;
+	const low = fnv1a(payload, 2166136261);
+	return fnv1a(`${low}|${payload}`, 16777619).toString(16).padStart(8, "0") + low.toString(16).padStart(8, "0");
+};
+const getLocalStorage = () => {
+	try {
+		var _localStorage;
+		return (_localStorage = globalThis.localStorage) !== null && _localStorage !== void 0 ? _localStorage : void 0;
+	} catch {
+		return;
+	}
+};
+const isUsableRecord = (record) => {
+	if (!record || typeof record !== "object") return false;
+	const { v, id, createdAt, checksum } = record;
+	if (v !== RECORD_VERSION || typeof id !== "string" || typeof checksum !== "string") return false;
+	if (typeof createdAt !== "number" || !Number.isInteger(createdAt) || createdAt <= 0) return false;
+	if (!UUID_V4_PATTERN.test(id)) return false;
+	return checksum === checksumFor(id, createdAt);
+};
+const readStoredInstanceId = (storage, logger) => {
+	let raw;
+	try {
+		raw = storage.getItem(STORAGE_KEY);
+	} catch (error) {
+		logger === null || logger === void 0 || logger.debug("[ConfigDirectorClient] Could not read the stored instance id, generating a new one", error);
+		return;
+	}
+	if (!raw) return;
+	let record;
+	try {
+		record = JSON.parse(raw);
+	} catch {
+		logger === null || logger === void 0 || logger.debug("[ConfigDirectorClient] The stored instance id is not valid JSON, generating a new one");
+		return;
+	}
+	if (!isUsableRecord(record)) {
+		logger === null || logger === void 0 || logger.debug("[ConfigDirectorClient] The stored instance id failed validation, generating a new one");
+		return;
+	}
+	const age = Date.now() - record.createdAt;
+	if (age < 0 || age >= MAX_AGE_MS) {
+		logger === null || logger === void 0 || logger.debug("[ConfigDirectorClient] The stored instance id has expired, generating a new one");
+		return;
+	}
+	return record.id;
+};
+const storeInstanceId = (storage, id, logger) => {
+	const createdAt = Date.now();
+	const record = {
+		v: RECORD_VERSION,
+		id,
+		createdAt,
+		checksum: checksumFor(id, createdAt)
+	};
+	try {
+		storage.setItem(STORAGE_KEY, JSON.stringify(record));
+	} catch (error) {
+		logger === null || logger === void 0 || logger.debug("[ConfigDirectorClient] Could not persist the instance id", error);
+	}
+};
+const resolveInstanceId = (logger) => {
+	const storage = getLocalStorage();
+	if (!storage) return generateInstanceId();
+	const storedInstanceId = readStoredInstanceId(storage, logger);
+	if (storedInstanceId) return storedInstanceId;
+	const instanceId = generateInstanceId();
+	storeInstanceId(storage, instanceId, logger);
+	return instanceId;
+};
+//#endregion
+//#region ../shared/src/transport/AbstractPollingTransport.ts
+var AbstractPollingTransport = class {
+	constructor() {
+		_defineProperty(this, "fatalError", false);
+		_defineProperty(this, "pollingInterval", void 0);
+	}
+	clearPollingInterval() {
+		clearInterval(this.pollingInterval);
+	}
+	schedulePollingInterval(callback) {
+		clearInterval(this.pollingInterval);
+		if (this.pollingIntervalSeconds <= 0) return;
+		this.pollingInterval = setInterval(callback, this.pollingIntervalSeconds * 1e3);
+	}
+	async handleNonOkResponse(response) {
+		if (!response.ok) if (this.isStatusFatal(response.status)) {
+			this.fatalError = true;
+			this.close();
+			throw this.prepareFatalResponseStatusError(response.status, await response.text());
+		} else throw new ConfigDirectorConnectionError(`Connection failed with status: ${response.status}`, response.status);
+	}
+	handleFetchError(fetchError) {
+		if (this.isFetchErrorFatal(fetchError)) {
+			this.fatalError = true;
+			this.close();
+			throw new ConfigDirectorConnectionError(`Connection failed with fatal error: ${fetchError}. This is an unrecoverable error, retry attempts will be ignored.`);
+		} else if (fetchError instanceof SyntaxError) throw new ConfigDirectorConnectionError(`Failed to parse the response from the server: ${fetchError}`);
+		else throw new ConfigDirectorConnectionError(`Connection failed with error: ${fetchError}.`);
+	}
+	prepareFatalResponseStatusError(responseStatus, errorBody) {
+		var _errorBody$trim$lengt, _errorBody$trim;
+		const status = responseStatus !== null && responseStatus !== void 0 ? responseStatus : 0;
+		return new ConfigDirectorConnectionError(`${`Connection failed with status: ${responseStatus !== null && responseStatus !== void 0 ? responseStatus : "unknown"}`}${((_errorBody$trim$lengt = errorBody === null || errorBody === void 0 || (_errorBody$trim = errorBody.trim()) === null || _errorBody$trim === void 0 ? void 0 : _errorBody$trim.length) !== null && _errorBody$trim$lengt !== void 0 ? _errorBody$trim$lengt : 0) > 0 ? ` (${errorBody})` : ""}. This is an unrecoverable error, retry attempts will be ignored.`, status);
+	}
+	isStatusFatal(status) {
+		return !!status && status >= 400 && status < 500 && status != 429;
+	}
+	isFetchErrorFatal(fetchError) {
+		return (fetchError === null || fetchError === void 0 ? void 0 : fetchError.name) === "NotAllowedError";
+	}
+	get isConnected() {
+		return this.pollingInterval !== void 0;
+	}
+	close() {
+		clearInterval(this.pollingInterval);
+		this.pollingInterval = void 0;
+	}
+	dispose() {
+		this.close();
+		this.clear();
+	}
+};
+//#endregion
+//#region ../shared/src/fetchWithTimeout.ts
+const fetchWithTimeout = async (timeout, resource, options, logger) => {
+	const abortController = new AbortController();
+	const abortTimeoutId = setTimeout(() => {
+		logger.debug("[fetchWithTimeout] Reached timeout, aborting request");
+		abortController.abort();
+	}, timeout);
+	try {
+		const response = await fetch(typeof resource === "string" || resource instanceof Request ? resource : resource.toString(), {
+			...options,
+			signal: abortController.signal
+		});
+		clearTimeout(abortTimeoutId);
+		return response;
+	} catch (error) {
+		logger.warn("[fetchWithTimeout] Fetch error: ", error);
+		clearTimeout(abortTimeoutId);
+		throw error;
+	}
+};
+//#endregion
+//#region ../js-client-core/src/PollingTransport.ts
+var PollingTransport = class extends AbstractPollingTransport {
+	constructor(options) {
+		var _options$pollingInter;
+		super();
+		this.options = options;
+		_defineProperty(this, "pollingIntervalSeconds", void 0);
+		_defineProperty(this, "logger", void 0);
+		_defineProperty(this, "eventEmitter", new Emitter());
+		_defineProperty(this, "url", void 0);
+		_defineProperty(this, "lastUpdateTimestamp", void 0);
+		this.options = options;
+		this.logger = options.logger;
+		this.url = options.resolveUrl("client/polling/v1", options.baseUrl);
+		this.pollingIntervalSeconds = (_options$pollingInter = options.pollingInterval) !== null && _options$pollingInter !== void 0 ? _options$pollingInter : 60;
+	}
+	async connect(context, timeout) {
+		this.clearPollingInterval();
+		try {
+			await this.fetchConfigs(context, timeout);
+		} finally {
+			if (!this.fatalError) this.schedulePollingInterval(() => {
+				this.fetchConfigs(context, timeout).catch((error) => {
+					this.logger.error("[PollingTransport] Error during polling:", error);
+				});
+			});
+		}
+		return this;
+	}
+	async fetchConfigs(context, timeout) {
+		if (this.fatalError) {
+			this.logger.warn("[PollingTransport] There was a prior unrecoverable error. Ignoring attempt to reconnect.");
+			return;
+		}
+		try {
+			const response = await fetchWithTimeout(timeout, this.url, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					givenContext: context,
+					metaContext: this.options.metaContext,
+					clientSdkKey: this.options.clientSdkKey,
+					instanceId: this.options.instanceId,
+					lastUpdateTimestamp: this.lastUpdateTimestamp
+				})
+			}, this.logger);
+			await this.handleNonOkResponse(response);
+			if (response.status == 200) {
+				const json = JSON.parse(await response.text());
+				this.lastUpdateTimestamp = json.timestamp;
+				this.eventEmitter.emit("configSetReceived", json);
+			}
+		} catch (fetchError) {
+			try {
+				this.handleFetchError(fetchError);
+			} catch (handledError) {
+				if (this.fatalError) this.eventEmitter.emit("connectionError", handledError);
+				throw handledError;
+			}
+		}
+	}
+	on(name, handler) {
+		this.eventEmitter.on(name, handler);
+	}
+	off(name, handler) {
+		this.eventEmitter.off(name, handler);
+	}
+	clear() {
+		this.eventEmitter.clear();
+	}
+};
+//#endregion
+//#region ../js-client-core/src/browser-globals.ts
+const read = (readValue) => {
+	try {
+		return readValue(globalThis);
+	} catch {
+		return;
+	}
+};
+const readUserAgent = () => read((globals) => {
+	var _globals$navigator;
+	return (_globals$navigator = globals.navigator) === null || _globals$navigator === void 0 ? void 0 : _globals$navigator.userAgent;
+});
+const readHost = () => read((globals) => {
+	var _globals$location;
+	return (_globals$location = globals.location) === null || _globals$location === void 0 ? void 0 : _globals$location.host;
+});
+//#endregion
+//#region ../js-client-core/src/DefaultConfigDirectorClient.ts
+const MAX_EXPONENTIAL_DELAY = 9;
+var DefaultConfigDirectorClient = class {
+	constructor(telemetryClient, clientSdkKey, sdkOptions, clientOptions, internalClientOptions) {
+		var _clientOptions$logger, _clientOptions$connec, _clientOptions$connec2, _internalClientOption, _this$parseUrl, _clientOptions$connec3, _clientOptions$connec4, _clientOptions$connec5, _internalClientOption2, _clientOptions$hooks, _clientOptions$hooks2, _clientOptions$hooks3, _clientOptions$hooks4, _clientOptions$hooks5;
+		_defineProperty(this, "logger", void 0);
+		_defineProperty(this, "telemetryClient", void 0);
+		_defineProperty(this, "configSet", void 0);
+		_defineProperty(this, "handlersMap", /* @__PURE__ */ new Map());
+		_defineProperty(this, "transport", void 0);
+		_defineProperty(this, "eventEmitter", new Emitter());
+		_defineProperty(this, "timeout", void 0);
+		_defineProperty(this, "timeoutTimer", void 0);
+		_defineProperty(this, "ready", false);
+		_defineProperty(this, "initializing", false);
+		_defineProperty(this, "hasReceivedConfigSet", false);
+		_defineProperty(this, "readyPromise", void 0);
+		_defineProperty(this, "readyResolve", void 0);
+		_defineProperty(this, "currentContext", void 0);
+		_defineProperty(this, "connectionMode", void 0);
+		_defineProperty(this, "instanceId", void 0);
+		this.logger = (_clientOptions$logger = clientOptions === null || clientOptions === void 0 ? void 0 : clientOptions.logger) !== null && _clientOptions$logger !== void 0 ? _clientOptions$logger : createDefaultLogger();
+		this.instanceId = resolveInstanceId(this.logger);
+		this.timeout = (_clientOptions$connec = clientOptions === null || clientOptions === void 0 || (_clientOptions$connec2 = clientOptions.connection) === null || _clientOptions$connec2 === void 0 ? void 0 : _clientOptions$connec2.timeout) !== null && _clientOptions$connec !== void 0 ? _clientOptions$connec : 3e3;
+		this.validateSdkKeyPresence(clientSdkKey);
+		const urlFactory = (_internalClientOption = internalClientOptions === null || internalClientOptions === void 0 ? void 0 : internalClientOptions.urlFactory) !== null && _internalClientOption !== void 0 ? _internalClientOption : defaultUrlFactory;
+		const baseUrl = (_this$parseUrl = this.parseUrl(clientOptions === null || clientOptions === void 0 || (_clientOptions$connec3 = clientOptions.connection) === null || _clientOptions$connec3 === void 0 ? void 0 : _clientOptions$connec3.url, urlFactory)) !== null && _this$parseUrl !== void 0 ? _this$parseUrl : CLIENT_BASE_URL;
+		this.connectionMode = (_clientOptions$connec4 = clientOptions === null || clientOptions === void 0 || (_clientOptions$connec5 = clientOptions.connection) === null || _clientOptions$connec5 === void 0 ? void 0 : _clientOptions$connec5.mode) !== null && _clientOptions$connec4 !== void 0 ? _clientOptions$connec4 : "streaming";
+		this.telemetryClient = telemetryClient;
+		this.transport = (_internalClientOption2 = internalClientOptions === null || internalClientOptions === void 0 ? void 0 : internalClientOptions.transport) !== null && _internalClientOption2 !== void 0 ? _internalClientOption2 : this.buildTransport(clientSdkKey, sdkOptions, baseUrl, urlFactory, clientOptions, internalClientOptions);
+		this.transport.on("configSetReceived", (configSet) => {
+			var _this$readyResolve;
+			this.hasReceivedConfigSet = true;
+			(_this$readyResolve = this.readyResolve) === null || _this$readyResolve === void 0 || _this$readyResolve.call(this);
+			const removedKeys = this.findKeysRemovedBy(configSet);
+			if (!this.configSet || configSet.kind == "full") this.configSet = configSet;
+			else this.configSet.configs = {
+				...this.configSet.configs,
+				...configSet.configs
+			};
+			const keys = Object.keys(configSet.configs);
+			this.emit("configsUpdated", {
+				keys,
+				removedKeys
+			});
+			this.updateWatchers([...keys, ...removedKeys]);
+			this.logger.debug("[ConfigDirectorClient] ConfigSet updated from server:", {
+				keys,
+				removedKeys
+			});
+		});
+		this.transport.on("connectionError", (error) => {
+			this.initializing = false;
+			this.logger.error("[ConfigDirectorClient] The connection encountered an unrecoverable error and will not be retried. Configs will no longer receive updates.", error);
+			this.emit("connectionError", { error });
+		});
+		this.registerHandler("clientReady", clientOptions === null || clientOptions === void 0 || (_clientOptions$hooks = clientOptions.hooks) === null || _clientOptions$hooks === void 0 ? void 0 : _clientOptions$hooks.clientReady);
+		this.registerHandler("configEvaluated", clientOptions === null || clientOptions === void 0 || (_clientOptions$hooks2 = clientOptions.hooks) === null || _clientOptions$hooks2 === void 0 ? void 0 : _clientOptions$hooks2.configEvaluated);
+		this.registerHandler("configsUpdated", clientOptions === null || clientOptions === void 0 || (_clientOptions$hooks3 = clientOptions.hooks) === null || _clientOptions$hooks3 === void 0 ? void 0 : _clientOptions$hooks3.configsUpdated);
+		this.registerHandler("contextUpdated", clientOptions === null || clientOptions === void 0 || (_clientOptions$hooks4 = clientOptions.hooks) === null || _clientOptions$hooks4 === void 0 ? void 0 : _clientOptions$hooks4.contextUpdated);
+		this.registerHandler("connectionError", clientOptions === null || clientOptions === void 0 || (_clientOptions$hooks5 = clientOptions.hooks) === null || _clientOptions$hooks5 === void 0 ? void 0 : _clientOptions$hooks5.connectionError);
+	}
+	registerHandler(event, handler) {
+		if (!handler) return;
+		const handlers = Array.isArray(handler) ? handler : [handler];
+		for (const h of handlers) if (typeof h === "function") this.on(event, h);
+	}
+	resolvePollingIntervalForMode(configuredSeconds) {
+		if (this.connectionMode !== "polling") return;
+		const resolved = resolvePollingInterval(configuredSeconds, {
+			defaultSeconds: 60,
+			minimumSeconds: 30
+		});
+		if (resolved.warning) this.logger.warn(`[ConfigDirectorClient] ${resolved.warning}`);
+		return resolved.seconds;
+	}
+	buildTransport(clientSdkKey, sdkOptions, baseUrl, urlFactory, clientOptions, internalClientOptions) {
+		var _internalClientOption3, _clientOptions$connec6;
+		return new (this.getTransportConstructor(this.connectionMode))({
+			instanceId: this.instanceId,
+			clientSdkKey,
+			baseUrl,
+			resolveUrl: urlFactory,
+			metaContext: {
+				...clientOptions === null || clientOptions === void 0 ? void 0 : clientOptions.metadata,
+				sdkName: sdkOptions.sdkName,
+				sdkVersion: sdkOptions.sdkVersion,
+				userAgent: readUserAgent(),
+				host: readHost()
+			},
+			logger: this.logger,
+			fetch: internalClientOptions === null || internalClientOptions === void 0 ? void 0 : internalClientOptions.fetch,
+			connectionRetryDelay: (_internalClientOption3 = internalClientOptions === null || internalClientOptions === void 0 ? void 0 : internalClientOptions.connectionRetryDelay) !== null && _internalClientOption3 !== void 0 ? _internalClientOption3 : ((attempt) => {
+				return Math.pow(2, Math.min(attempt, MAX_EXPONENTIAL_DELAY)) * 1e3;
+			}),
+			pollingInterval: this.resolvePollingIntervalForMode(clientOptions === null || clientOptions === void 0 || (_clientOptions$connec6 = clientOptions.connection) === null || _clientOptions$connec6 === void 0 ? void 0 : _clientOptions$connec6.pollingInterval)
+		});
+	}
+	getTransportConstructor(connectionMode) {
+		switch (connectionMode) {
+			case "polling": return PollingTransport;
+			default: return StreamingTransport;
+		}
+	}
+	async initialize(context) {
+		if (!this.hasReceivedConfigSet) this.initializing = true;
+		await this.connectToTransport(context, "initialization");
+	}
+	async updateContext(context) {
+		await this.connectToTransport(context, "context update");
+	}
+	get context() {
+		return this.currentContext;
+	}
+	async connectToTransport(context, caller) {
+		try {
+			this.ready = false;
+			this.readyPromise = new Promise((resolve) => {
+				this.readyResolve = resolve;
+			}).then((cancelled) => {
+				if (cancelled) return;
+				this.ready = true;
+				this.initializing = false;
+				this.emit("clientReady", { action: caller });
+				this.logger.debug("[ConfigDirectorClient] Received initial payload from the server, client is ready");
+			});
+			const startTime = (/* @__PURE__ */ new Date()).getTime();
+			await this.transport.connect(context !== null && context !== void 0 ? context : {}, this.timeout, caller);
+			this.currentContext = context;
+			this.telemetryClient.updateContext(context);
+			this.emit("contextUpdated", { context });
+			const elapsedTime = (/* @__PURE__ */ new Date()).getTime() - startTime;
+			const remainingTimeout = this.timeout - elapsedTime;
+			clearTimeout(this.timeoutTimer);
+			this.timeoutTimer = void 0;
+			if (remainingTimeout > 0) await Promise.race([this.readyPromise, new Promise((resolve) => {
+				this.timeoutTimer = setTimeout(() => resolve(), remainingTimeout);
+			})]).finally(() => clearTimeout(this.timeoutTimer));
+			if (!this.ready) this.logger.warn(`[ConfigDirectorClient] Timed out waiting for ${caller} after ${this.timeout}ms. The client will continue to retry since there were no fatal errors detected. Configs will return the default value until the connection succeeds.`);
+		} catch (error) {
+			this.logger.error(`[ConfigDirectorClient] An error occurred during ${caller}: `, error);
+		}
+	}
+	findKeysRemovedBy(configSet) {
+		if (!this.configSet || configSet.kind != "full") return [];
+		return Object.keys(this.configSet.configs).filter((key) => !Object.prototype.hasOwnProperty.call(configSet.configs, key));
+	}
+	updateWatchers(configKeys) {
+		configKeys.forEach((configKey) => this.updateWatchersForConfig(configKey));
+	}
+	updateWatchersForConfig(configKey) {
+		var _this$configSet, _this$handlersMap$get;
+		const configState = (_this$configSet = this.configSet) === null || _this$configSet === void 0 ? void 0 : _this$configSet.configs[configKey];
+		(_this$handlersMap$get = this.handlersMap.get(configKey)) === null || _this$handlersMap$get === void 0 || _this$handlersMap$get.forEach((h) => {
+			const value = this.getValueFromConfigState(configKey, configState, h.defaultValue);
+			h.handler(value);
+		});
+	}
+	watch(configKey, defaultValue, callback) {
+		this.validateDefaultValue(defaultValue);
+		const handlers = this.handlersMap.get(configKey);
+		const handlerWithOptions = {
+			handler: callback,
+			defaultValue,
+			requestedType: typeof defaultValue
+		};
+		if (handlers) handlers.push(handlerWithOptions);
+		else this.handlersMap.set(configKey, [handlerWithOptions]);
+		return () => this.unwatch(configKey, callback);
+	}
+	unwatch(configKey, callback) {
+		const handlers = this.handlersMap.get(configKey);
+		if (!handlers) return;
+		if (callback) {
+			const index = handlers.findIndex((h) => h.handler == callback);
+			if (index >= 0) handlers === null || handlers === void 0 || handlers.splice(index, 1);
+		} else handlers.splice(0);
+	}
+	getValue(configKey, defaultValue) {
+		var _this$configSet2;
+		this.validateDefaultValue(defaultValue);
+		const configState = (_this$configSet2 = this.configSet) === null || _this$configSet2 === void 0 ? void 0 : _this$configSet2.configs[configKey];
+		return this.getValueFromConfigState(configKey, configState, defaultValue);
+	}
+	getValueFromConfigState(configKey, configState, defaultValue) {
+		var _this$currentContext2, _parseResult$parsedVa;
+		if (!configState) {
+			var _this$currentContext;
+			this.logger.debug(`[ConfigDirectorClient] No config state found for '${configKey}', returning default value '${defaultValue}'`);
+			const reason = this.isReady ? "config-state-missing" : "client-not-ready";
+			this.telemetryClient.evaluatedConfig({
+				contextId: (_this$currentContext = this.currentContext) === null || _this$currentContext === void 0 ? void 0 : _this$currentContext.id,
+				key: configKey,
+				defaultValue,
+				requestedType: getRequestedType(defaultValue),
+				evaluatedValue: defaultValue,
+				usedDefault: true,
+				evaluationReason: reason
+			});
+			this.dispatchEvaluationEvent({
+				key: configKey,
+				value: defaultValue,
+				isDefaultValue: true,
+				reason,
+				context: this.context
+			});
+			return defaultValue;
+		}
+		const parseResult = parseConfigValue(configState, defaultValue);
+		this.telemetryClient.evaluatedConfig({
+			contextId: (_this$currentContext2 = this.currentContext) === null || _this$currentContext2 === void 0 ? void 0 : _this$currentContext2.id,
+			type: configState.type,
+			key: configKey,
+			defaultValue,
+			requestedType: parseResult.requestedType,
+			evaluatedValue: parseResult.parsedValue,
+			evaluatedValueId: parseResult.parsedValueId,
+			usedDefault: parseResult.usedDefault,
+			evaluationReason: parseResult.reason
+		});
+		this.dispatchEvaluationEvent({
+			key: configKey,
+			value: parseResult.parsedValue,
+			valueId: (_parseResult$parsedVa = parseResult.parsedValueId) !== null && _parseResult$parsedVa !== void 0 ? _parseResult$parsedVa : void 0,
+			isDefaultValue: parseResult.usedDefault,
+			reason: parseResult.reason,
+			context: this.context
+		});
+		this.logger.debug(`[ConfigDirectorClient] Evaluated '${configKey}' to '${parseResult.parsedValue}'`);
+		return parseResult.parsedValue;
+	}
+	dispatchEvaluationEvent(event) {
+		setTimeout(() => this.emit("configEvaluated", { evaluation: event }), 0);
+	}
+	emit(name, payload) {
+		try {
+			this.eventEmitter.emit(name, payload);
+		} catch (error) {
+			this.logger.error(`[ConfigDirectorClient] Error executing event handlers for '${name}'`, error);
+		}
+	}
+	parseUrl(url, urlFactory) {
+		if (!url) return;
+		try {
+			return urlFactory(url);
+		} catch (error) {
+			throw new ConfigDirectorValidationError(`Invalid base URL '${url}'. Parsing failed: ${error}`);
+		}
+	}
+	validateSdkKeyPresence(sdkKey) {
+		if (!sdkKey || sdkKey.trim().length == 0) throw new ConfigDirectorValidationError("No client SDK key was provided, the client cannot be instantiated without a valid client SDK key");
+	}
+	validateDefaultValue(defaultValue) {
+		if (defaultValue === void 0 || defaultValue === null) throw new ConfigDirectorValidationError("Invalid default value. The default value for a config must be defined and non-null.");
+		if (typeof defaultValue === "function") throw new ConfigDirectorValidationError("Invalid default value. The default value for a config cannot be a function.");
+	}
+	get isReady() {
+		return this.ready;
+	}
+	get isInitializing() {
+		return this.initializing;
+	}
+	on(eventName, handler) {
+		this.eventEmitter.on(eventName, handler);
+	}
+	off(eventName, handler) {
+		this.eventEmitter.off(eventName, handler);
+	}
+	clear() {
+		this.logger.debug("[ConfigDirectorClient] clear() has been called, removing all observers");
+		this.eventEmitter.clear();
+		this.handlersMap.clear();
+	}
+	unwatchAll() {
+		this.handlersMap.clear();
+	}
+	pauseNetwork() {
+		this.logger.debug("[ConfigDirectorClient] pauseNetwork() called, pausing transport connection");
+		clearTimeout(this.timeoutTimer);
+		this.timeoutTimer = void 0;
+		this.transport.close();
+		this.ready = false;
+	}
+	async resumeNetwork() {
+		await this.connectToTransport(this.currentContext, "network resume");
+	}
+	async close() {
+		var _this$readyResolve2;
+		this.logger.debug("[ConfigDirectorClient] close() has been called, closing connection to server");
+		clearTimeout(this.timeoutTimer);
+		(_this$readyResolve2 = this.readyResolve) === null || _this$readyResolve2 === void 0 || _this$readyResolve2.call(this, true);
+		this.telemetryClient.close();
+		this.transport.close();
+		this.ready = false;
+		this.initializing = false;
+	}
+	dispose() {
+		this.clear();
+		this.close();
+	}
+};
+//#endregion
+//#region ../js-client-core/src/installedTestClient.ts
+const INSTALLED_TEST_CLIENT_SLOT = Symbol.for("@configdirector/installed-test-client");
+const readInstalledTestClient = () => globalThis[INSTALLED_TEST_CLIENT_SLOT];
+//#endregion
+export { CLIENT_BASE_URL as a, ConfigDirectorConnectionError as c, _defineProperty as d, fetchWithTimeout as i, ConfigDirectorValidationError as l, readInstalledTestClient as n, createDefaultLogger as o, DefaultConfigDirectorClient as r, isFetchErrorFatal as s, INSTALLED_TEST_CLIENT_SLOT as t, Emitter as u };