@kubesense/kubesense-browser-core 1.7.0 → 2.0.0-beta.0

package/esm/domain/bufferedData.mjs

@@ -0,0 +1,43 @@
+import { BufferedObservable } from "../tools/observable.mjs";
+import { mockable } from "../tools/mockable.mjs";
+import { addTelemetryDebug } from "./telemetry/telemetry.mjs";
+import { trackRuntimeError } from "./error/trackRuntimeError.mjs";
+import { initXhrObservable } from "../browser/xhrObservable.mjs";
+import { initFetchObservable } from "../browser/fetchObservable.mjs";
+import { initConsoleObservable } from "./console/consoleObservable.mjs";
+import { ConsoleApiName } from "@kubesense/kubesense-js-core/util";
+//#region src/domain/bufferedData.ts
+const BUFFER_LIMIT = 500;
+let BufferedDataType = /* @__PURE__ */ function(BufferedDataType) {
+	BufferedDataType[BufferedDataType["RUNTIME_ERROR"] = 0] = "RUNTIME_ERROR";
+	BufferedDataType[BufferedDataType["FETCH"] = 1] = "FETCH";
+	BufferedDataType[BufferedDataType["XHR"] = 2] = "XHR";
+	BufferedDataType[BufferedDataType["CONSOLE"] = 3] = "CONSOLE";
+	return BufferedDataType;
+}({});
+function startBufferingData() {
+	const observable = new BufferedObservable(BUFFER_LIMIT, (count) => {
+		addTelemetryDebug("Early data collection dropped data on unbuffer", { count });
+	});
+	const subscriptions = [];
+	function subscribe(type, source) {
+		subscriptions.push(source.subscribe((data) => {
+			observable.notify({
+				type,
+				data
+			});
+		}));
+	}
+	subscribe(0, mockable(trackRuntimeError)());
+	subscribe(1, initFetchObservable());
+	subscribe(2, initXhrObservable());
+	subscribe(3, initConsoleObservable(Object.values(ConsoleApiName)));
+	return {
+		observable,
+		stop: () => subscriptions.forEach((subscription) => subscription.unsubscribe())
+	};
+}
+//#endregion
+export { BufferedDataType, startBufferingData };
+
+//# sourceMappingURL=bufferedData.mjs.map

package/esm/domain/bufferedData.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bufferedData.mjs","names":[],"sources":["../../src/domain/bufferedData.ts"],"sourcesContent":["import { ConsoleApiName } from '@kubesense/kubesense-js-core/util'\nimport type { Observable, Subscription } from '../tools/observable'\nimport { BufferedObservable } from '../tools/observable'\nimport { mockable } from '../tools/mockable'\nimport type { FetchContext } from '../browser/fetchObservable'\nimport { initFetchObservable } from '../browser/fetchObservable'\nimport type { XhrContext } from '../browser/xhrObservable'\nimport { initXhrObservable } from '../browser/xhrObservable'\nimport { addTelemetryDebug } from './telemetry'\nimport type { RawError } from './error/error.types'\nimport { trackRuntimeError } from './error/trackRuntimeError'\nimport type { ConsoleLog } from './console/consoleObservable'\nimport { initConsoleObservable } from './console/consoleObservable'\n\nconst BUFFER_LIMIT = 500\n\nexport const enum BufferedDataType {\n  RUNTIME_ERROR,\n  FETCH,\n  XHR,\n  CONSOLE,\n}\n\nexport type BufferedData =\n  | { type: BufferedDataType.RUNTIME_ERROR; data: RawError }\n  | { type: BufferedDataType.FETCH; data: FetchContext }\n  | { type: BufferedDataType.XHR; data: XhrContext }\n  | { type: BufferedDataType.CONSOLE; data: ConsoleLog }\n\nexport function startBufferingData() {\n  const observable = new BufferedObservable<BufferedData>(BUFFER_LIMIT, (count) => {\n    // monitor-until: 2026-10-14\n    addTelemetryDebug('Early data collection dropped data on unbuffer', {\n      count,\n    })\n  })\n  const subscriptions: Subscription[] = []\n\n  function subscribe<T extends BufferedDataType>(\n    type: T,\n    source: Observable<Extract<BufferedData, { type: T }>['data']>\n  ) {\n    subscriptions.push(\n      source.subscribe((data) => {\n        observable.notify({ type, data } as BufferedData)\n      })\n    )\n  }\n\n  subscribe(BufferedDataType.RUNTIME_ERROR, mockable(trackRuntimeError)())\n  subscribe(BufferedDataType.FETCH, initFetchObservable())\n  subscribe(BufferedDataType.XHR, initXhrObservable())\n  subscribe(BufferedDataType.CONSOLE, initConsoleObservable(Object.values(ConsoleApiName)))\n\n  return {\n    observable,\n    stop: () => subscriptions.forEach((subscription) => subscription.unsubscribe()),\n  }\n}\n"],"mappings":";;;;;;;;;AAcA,MAAM,eAAe;AAErB,IAAkB,mBAAX,yBAAA,kBAAA;CACL,iBAAA,iBAAA,mBAAA,KAAA;CACA,iBAAA,iBAAA,WAAA,KAAA;CACA,iBAAA,iBAAA,SAAA,KAAA;CACA,iBAAA,iBAAA,aAAA,KAAA;;AACF,EAAA,CAAA,CAAA;AAQA,SAAgB,qBAAqB;CACnC,MAAM,aAAa,IAAI,mBAAiC,eAAe,UAAU;EAE/E,kBAAkB,kDAAkD,EAClE,MACF,CAAC;CACH,CAAC;CACD,MAAM,gBAAgC,CAAC;CAEvC,SAAS,UACP,MACA,QACA;EACA,cAAc,KACZ,OAAO,WAAW,SAAS;GACzB,WAAW,OAAO;IAAE;IAAM;GAAK,CAAiB;EAClD,CAAC,CACH;CACF;CAEA,UAAA,GAA0C,SAAS,iBAAiB,CAAC,CAAC,CAAC;CACvE,UAAA,GAAkC,oBAAoB,CAAC;CACvD,UAAA,GAAgC,kBAAkB,CAAC;CACnD,UAAA,GAAoC,sBAAsB,OAAO,OAAO,cAAc,CAAC,CAAC;CAExF,OAAO;EACL;EACA,YAAY,cAAc,SAAS,iBAAiB,aAAa,YAAY,CAAC;CAChF;AACF"}

package/esm/domain/configuration/configuration.mjs

@@ -0,0 +1,163 @@
+import { TrackingConsent } from "../trackingConsent.mjs";
+import { INTAKE_SITE_PROD } from "@kubesense/kubesense-js-core/transport";
+//#region src/domain/configuration/configuration.ts
+/**
+* Default privacy level for the browser SDK.
+*
+* [Replay Privacy Options](https://docs.kubesense.ai/real_user_monitoring/session_replay/browser/privacy_options) for further information.
+*/
+const DefaultPrivacyLevel = {
+	ALLOW: "allow",
+	MASK: "mask",
+	MASK_USER_INPUT: "mask-user-input",
+	MASK_UNLESS_ALLOWLISTED: "mask-unless-allowlisted"
+};
+/**
+* Trace context injection option.
+*
+* See [Connect RUM and Traces](https://docs.kubesense.ai/real_user_monitoring/platform/connect_rum_and_traces/?tab=browserrum) for further information.
+*/
+const TraceContextInjection = {
+	ALL: "all",
+	SAMPLED: "sampled"
+};
+const BROWSER_CORE_SCHEMA = {
+	clientToken: {
+		type: "string",
+		required: true
+	},
+	service: { type: "string" },
+	env: { type: "string" },
+	version: { type: "string" },
+	kubesenseRumEndpoint: {
+		type: "site",
+		default: INTAKE_SITE_PROD
+	},
+	proxy: {
+		type: "union",
+		variants: [{ type: "string" }, {
+			type: "function",
+			signature: void 0
+		}]
+	},
+	sessionSampleRate: {
+		type: "percentage",
+		default: 100
+	},
+	telemetrySampleRate: {
+		type: "percentage",
+		default: 20
+	},
+	telemetryConfigurationSampleRate: {
+		type: "percentage",
+		default: 5
+	},
+	telemetryUsageSampleRate: {
+		type: "percentage",
+		default: 5
+	},
+	silentMultipleInit: {
+		type: "boolean",
+		default: false,
+		strict: false
+	},
+	storeContextsAcrossPages: {
+		type: "boolean",
+		default: false,
+		strict: false
+	},
+	trackAnonymousUser: {
+		type: "boolean",
+		default: true,
+		strict: false
+	},
+	useSecureSessionCookie: {
+		type: "boolean",
+		default: false,
+		strict: false
+	},
+	usePartitionedCrossSiteSessionCookie: {
+		type: "boolean",
+		default: false,
+		strict: false
+	},
+	trackSessionAcrossSubdomains: {
+		type: "boolean",
+		default: false,
+		strict: false
+	},
+	allowedTrackingOrigins: {
+		type: "match-option",
+		multiple: true,
+		strict: false
+	},
+	trackingConsent: {
+		type: "enum",
+		values: TrackingConsent,
+		default: TrackingConsent.GRANTED
+	},
+	beforeSend: {
+		type: "function",
+		signature: void 0
+	},
+	source: {
+		type: "enum",
+		values: [
+			"browser",
+			"flutter",
+			"unity"
+		],
+		default: "browser",
+		strict: false
+	},
+	sessionPersistence: {
+		type: "enum",
+		values: [
+			"cookie",
+			"local-storage",
+			"memory"
+		],
+		multiple: true,
+		strict: false
+	},
+	replica: {
+		type: "schema",
+		schema: {
+			clientToken: {
+				type: "string",
+				required: true
+			},
+			applicationId: { type: "string" }
+		}
+	},
+	datacenter: { type: "string" },
+	sdkVersion: { type: "string" },
+	variant: { type: "string" }
+};
+function serializeConfiguration(initConfiguration) {
+	return {
+		session_sample_rate: initConfiguration.sessionSampleRate,
+		telemetry_sample_rate: initConfiguration.telemetrySampleRate,
+		telemetry_configuration_sample_rate: initConfiguration.telemetryConfigurationSampleRate,
+		telemetry_usage_sample_rate: initConfiguration.telemetryUsageSampleRate,
+		use_before_send: !!initConfiguration.beforeSend,
+		use_partitioned_cross_site_session_cookie: initConfiguration.usePartitionedCrossSiteSessionCookie,
+		use_secure_session_cookie: initConfiguration.useSecureSessionCookie,
+		use_proxy: !!initConfiguration.proxy,
+		silent_multiple_init: initConfiguration.silentMultipleInit,
+		track_session_across_subdomains: initConfiguration.trackSessionAcrossSubdomains,
+		track_anonymous_user: initConfiguration.trackAnonymousUser,
+		session_persistence: Array.isArray(initConfiguration.sessionPersistence) ? initConfiguration.sessionPersistence[0] : initConfiguration.sessionPersistence,
+		store_contexts_across_pages: !!initConfiguration.storeContextsAcrossPages,
+		allow_untrusted_events: !!initConfiguration.allowUntrustedEvents,
+		tracking_consent: initConfiguration.trackingConsent,
+		use_allowed_tracking_origins: Array.isArray(initConfiguration.allowedTrackingOrigins),
+		source: initConfiguration.source,
+		sdk_version: initConfiguration.sdkVersion,
+		variant: initConfiguration.variant
+	};
+}
+//#endregion
+export { BROWSER_CORE_SCHEMA, DefaultPrivacyLevel, TraceContextInjection, serializeConfiguration };
+
+//# sourceMappingURL=configuration.mjs.map

package/esm/domain/configuration/configuration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"configuration.mjs","names":[],"sources":["../../../src/domain/configuration/configuration.ts"],"sourcesContent":["import type { ProxyFn, Site } from '@kubesense/kubesense-js-core/transport'\nimport { INTAKE_SITE_PROD } from '@kubesense/kubesense-js-core/transport'\nimport type { InferredConfig, MatchOption } from '@kubesense/kubesense-js-core/configuration'\nimport type { RawTelemetryConfiguration } from '../telemetry'\nimport { TrackingConsent } from '../trackingConsent'\nimport type { SessionPersistence } from '../session/sessionConstants'\n\n/**\n * Default privacy level for the browser SDK.\n *\n * [Replay Privacy Options](https://docs.kubesense.ai/real_user_monitoring/session_replay/browser/privacy_options) for further information.\n */\nexport const DefaultPrivacyLevel = {\n  ALLOW: 'allow',\n  MASK: 'mask',\n  MASK_USER_INPUT: 'mask-user-input',\n  MASK_UNLESS_ALLOWLISTED: 'mask-unless-allowlisted',\n} as const\nexport type DefaultPrivacyLevel = (typeof DefaultPrivacyLevel)[keyof typeof DefaultPrivacyLevel]\n\n/**\n * Trace context injection option.\n *\n * See [Connect RUM and Traces](https://docs.kubesense.ai/real_user_monitoring/platform/connect_rum_and_traces/?tab=browserrum) for further information.\n */\nexport const TraceContextInjection = {\n  ALL: 'all',\n  SAMPLED: 'sampled',\n} as const\n\n/**\n * Trace context injection option.\n *\n * See [Connect RUM and Traces](https://docs.kubesense.ai/real_user_monitoring/platform/connect_rum_and_traces/?tab=browserrum) for further information.\n *\n */\nexport type TraceContextInjection = (typeof TraceContextInjection)[keyof typeof TraceContextInjection]\n\nexport interface InitConfiguration {\n  /**\n   * The client token for KubeSense. Required for authenticating your application with KubeSense.\n   *\n   * @category Authentication\n   */\n  clientToken: string\n\n  /**\n   * A callback function that can be used to modify events before they are sent to KubeSense.\n   *\n   * @category Data Collection\n   */\n  beforeSend?: GenericBeforeSendCallback | undefined\n\n  /**\n   * The percentage of sessions tracked. A value between 0 and 100.\n   *\n   * @category Data Collection\n   * @defaultValue 100\n   */\n  sessionSampleRate?: number | undefined\n\n  /**\n   * The percentage of telemetry events sent. A value between 0 and 100.\n   *\n   * @category Data Collection\n   * @defaultValue 20\n   */\n  telemetrySampleRate?: number | undefined\n\n  /**\n   * Initialization fails silently if the RUM Browser SDK is already initialized on the page.\n   *\n   * @defaultValue false\n   */\n  silentMultipleInit?: boolean | undefined\n\n  /**\n   * Which storage strategy to use for persisting sessions. Can be 'cookie', 'local-storage', or 'memory'.\n   * When an array is provided, the SDK will attempt each persistence type in the order specified.\n   *\n   * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values\n   *\n   * Note: 'memory' option is only for use with single-page applications. All page loads will start a new session, likely resulting in an increase in total number of RUM sessions\n   *\n   * @category Session Persistence\n   * @defaultValue \"cookie\"\n   */\n  sessionPersistence?: SessionPersistence | SessionPersistence[] | undefined\n\n  /**\n   * Allow listening to DOM events dispatched programmatically ([untrusted events](https://developer.mozilla.org/en-US/docs/Web/API/Event/isTrusted)). Enabling this option can be useful if you heavily rely on programmatic events, such as in an automated UI test environment.\n   *\n   * @defaultValue false\n   */\n  allowUntrustedEvents?: boolean | undefined\n\n  /**\n   * Store global context and user context in localStorage to preserve them along the user navigation.\n   * See [Contexts life cycle](https://docs.kubesense.ai/real_user_monitoring/browser/advanced_configuration/?tab=npm#contexts-life-cycle) for further information.\n   *\n   * @defaultValue false\n   */\n  storeContextsAcrossPages?: boolean | undefined\n\n  /**\n   * Set the initial user tracking consent state.\n   * See [User tracking consent](https://docs.kubesense.ai/real_user_monitoring/browser/advanced_configuration/?tab=npm#user-tracking-consent) for further information.\n   *\n   * @category Privacy\n   * @defaultValue granted\n   */\n  trackingConsent?: TrackingConsent | undefined\n\n  /**\n   * List of origins where the SDK is allowed to run when used in a browser extension context.\n   * Matches urls against the extensions origin.\n   * If not provided and the SDK is running in a browser extension, the SDK will not run.\n   */\n  allowedTrackingOrigins?: MatchOption[] | undefined\n\n  // transport options\n  /**\n   * Optional proxy URL, for example: https://www.proxy.com/path.\n   * See [Proxy Your Browser RUM Data](https://docs.kubesense.ai/real_user_monitoring/guide/proxy-rum-data) for further information.\n   *\n   * @category Transport\n   */\n  proxy?: string | ProxyFn | undefined\n\n  /**\n   * The KubeSense RUM intake host that events are sent to, for example `us2.kubesense.ai`.\n   *\n   * @category Transport\n   * @defaultValue us2.kubesense.ai\n   */\n  kubesenseRumEndpoint?: Site | undefined\n\n  // tag and context options\n  /**\n   * The service name for your application. Follows the [tag syntax requirements](https://docs.kubesense.ai/getting_started/tagging/#define-tags).\n   *\n   * @category Data Collection\n   */\n  service?: string | undefined | null\n\n  /**\n   * The application’s environment, for example: prod, pre-prod, and staging. Follows the [tag syntax requirements](https://docs.kubesense.ai/getting_started/tagging/#define-tags).\n   *\n   * @category Data Collection\n   */\n  env?: string | undefined | null\n\n  /**\n   * The application’s version, for example: 1.2.3, 6c44da20, and 2020.02.13. Follows the [tag syntax requirements](https://docs.kubesense.ai/getting_started/tagging/#define-tags).\n   *\n   * @category Data Collection\n   */\n  version?: string | undefined | null\n\n  // cookie options\n  /**\n   * Use a partitioned secure cross-site session cookie. This allows the RUM Browser SDK to run when the site is loaded from another one (iframe). Implies `useSecureSessionCookie`.\n   *\n   * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values\n   *\n   * @category Session Persistence\n   * @defaultValue false\n   */\n  usePartitionedCrossSiteSessionCookie?: boolean | undefined\n\n  /**\n   * Use a secure session cookie. This disables RUM events sent on insecure (non-HTTPS) connections.\n   *\n   * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values\n   *\n   * @category Session Persistence\n   * @defaultValue false\n   */\n  useSecureSessionCookie?: boolean | undefined\n\n  /**\n   * Preserve the session across subdomains for the same site.\n   *\n   * Important: If you are using the RUM and Logs Browser SDKs, this option must be configured with identical values\n   *\n   * @category Session Persistence\n   * @defaultValue false\n   */\n  trackSessionAcrossSubdomains?: boolean | undefined\n\n  /**\n   * Track anonymous user for the same site and extend cookie expiration date\n   *\n   * @category Data Collection\n   * @defaultValue true\n   */\n  trackAnonymousUser?: boolean | undefined\n\n  // internal options\n  /**\n   * [Internal option] Enable experimental features\n   *\n   * @internal\n   */\n  enableExperimentalFeatures?: string[] | undefined\n\n  /**\n   * [Internal option] Configure the dual shipping to another datacenter\n   *\n   * @internal\n   */\n  replica?: ReplicaInitConfiguration | undefined\n\n  /**\n   * [Internal option] Set the datacenter from where the data is dual shipped\n   *\n   * @internal\n   */\n  datacenter?: string\n\n  /**\n   * [Internal option] The percentage of telemetry configuration sent. A value between 0 and 100.\n   *\n   * @internal\n   * @defaultValue 5\n   */\n  telemetryConfigurationSampleRate?: number\n\n  /**\n   * [Internal option] The percentage of telemetry usage sent. A value between 0 and 100.\n   *\n   * @internal\n   * @defaultValue 5\n   */\n  telemetryUsageSampleRate?: number\n\n  /**\n   * [Internal option] Additional configuration for the SDK.\n   *\n   * @internal\n   */\n  source?: 'browser' | 'flutter' | 'unity' | undefined\n\n  /**\n   * [Internal option] Additional configuration for the SDK.\n   *\n   * @internal\n   */\n  sdkVersion?: string | undefined\n\n  /**\n   * [Internal option] Additional configuration for the SDK.\n   *\n   * @internal\n   */\n  variant?: string | undefined\n}\n\n// This type is only used to build the core configuration. Logs and RUM SDKs are using a proper type\n// for this option.\ntype GenericBeforeSendCallback = (event: any, context?: any) => unknown\n\n/**\n * @internal\n */\nexport interface ReplicaInitConfiguration {\n  applicationId?: string\n  clientToken: string\n}\n\nexport type SdkSource = 'browser' | 'flutter' | 'unity'\n\nexport const BROWSER_CORE_SCHEMA = {\n  clientToken: { type: 'string', required: true },\n\n  // Optional tag fields\n  service: { type: 'string' },\n  env: { type: 'string' },\n  version: { type: 'string' },\n\n  // Transport\n  kubesenseRumEndpoint: { type: 'site', default: INTAKE_SITE_PROD },\n  proxy: {\n    type: 'union',\n    variants: [{ type: 'string' }, { type: 'function', signature: undefined as ProxyFn | undefined }],\n  },\n\n  // Sample rates\n  sessionSampleRate: { type: 'percentage', default: 100 },\n  telemetrySampleRate: { type: 'percentage', default: 20 },\n  telemetryConfigurationSampleRate: { type: 'percentage', default: 5 },\n  telemetryUsageSampleRate: { type: 'percentage', default: 5 },\n\n  // Booleans\n  silentMultipleInit: { type: 'boolean', default: false, strict: false },\n  storeContextsAcrossPages: { type: 'boolean', default: false, strict: false },\n  trackAnonymousUser: { type: 'boolean', default: true, strict: false },\n  useSecureSessionCookie: { type: 'boolean', default: false, strict: false },\n  usePartitionedCrossSiteSessionCookie: { type: 'boolean', default: false, strict: false },\n  trackSessionAcrossSubdomains: { type: 'boolean', default: false, strict: false },\n\n  // Cookie/extension origin validation\n  allowedTrackingOrigins: { type: 'match-option', multiple: true, strict: false },\n\n  // Privacy\n  trackingConsent: { type: 'enum', values: TrackingConsent, default: TrackingConsent.GRANTED },\n\n  // Callbacks\n  beforeSend: { type: 'function', signature: undefined as GenericBeforeSendCallback | undefined },\n\n  // Passthroughs\n  source: { type: 'enum', values: ['browser', 'flutter', 'unity'] as const, default: 'browser', strict: false },\n  sessionPersistence: {\n    type: 'enum',\n    values: ['cookie', 'local-storage', 'memory'] as const,\n    multiple: true,\n    strict: false,\n  },\n  replica: {\n    type: 'schema',\n    schema: {\n      clientToken: { type: 'string', required: true },\n      applicationId: { type: 'string' },\n    },\n  },\n\n  // Internal\n  datacenter: { type: 'string' },\n  sdkVersion: { type: 'string' },\n  variant: { type: 'string' },\n} as const\n\nexport type Configuration = InferredConfig<typeof BROWSER_CORE_SCHEMA>\n\nexport function serializeConfiguration(initConfiguration: InitConfiguration) {\n  return {\n    session_sample_rate: initConfiguration.sessionSampleRate,\n    telemetry_sample_rate: initConfiguration.telemetrySampleRate,\n    telemetry_configuration_sample_rate: initConfiguration.telemetryConfigurationSampleRate,\n    telemetry_usage_sample_rate: initConfiguration.telemetryUsageSampleRate,\n    use_before_send: !!initConfiguration.beforeSend,\n    use_partitioned_cross_site_session_cookie: initConfiguration.usePartitionedCrossSiteSessionCookie,\n    use_secure_session_cookie: initConfiguration.useSecureSessionCookie,\n    use_proxy: !!initConfiguration.proxy,\n    silent_multiple_init: initConfiguration.silentMultipleInit,\n    track_session_across_subdomains: initConfiguration.trackSessionAcrossSubdomains,\n    track_anonymous_user: initConfiguration.trackAnonymousUser,\n    session_persistence: Array.isArray(initConfiguration.sessionPersistence)\n      ? initConfiguration.sessionPersistence[0]\n      : initConfiguration.sessionPersistence,\n    store_contexts_across_pages: !!initConfiguration.storeContextsAcrossPages,\n    allow_untrusted_events: !!initConfiguration.allowUntrustedEvents,\n    tracking_consent: initConfiguration.trackingConsent,\n    use_allowed_tracking_origins: Array.isArray(initConfiguration.allowedTrackingOrigins),\n    source: initConfiguration.source,\n    sdk_version: initConfiguration.sdkVersion,\n    variant: initConfiguration.variant,\n  } satisfies RawTelemetryConfiguration\n}\n"],"mappings":";;;;;;;;AAYA,MAAa,sBAAsB;CACjC,OAAO;CACP,MAAM;CACN,iBAAiB;CACjB,yBAAyB;AAC3B;;;;;;AAQA,MAAa,wBAAwB;CACnC,KAAK;CACL,SAAS;AACX;AAoPA,MAAa,sBAAsB;CACjC,aAAa;EAAE,MAAM;EAAU,UAAU;CAAK;CAG9C,SAAS,EAAE,MAAM,SAAS;CAC1B,KAAK,EAAE,MAAM,SAAS;CACtB,SAAS,EAAE,MAAM,SAAS;CAG1B,sBAAsB;EAAE,MAAM;EAAQ,SAAS;CAAiB;CAChE,OAAO;EACL,MAAM;EACN,UAAU,CAAC,EAAE,MAAM,SAAS,GAAG;GAAE,MAAM;GAAY,WAAW,KAAA;EAAiC,CAAC;CAClG;CAGA,mBAAmB;EAAE,MAAM;EAAc,SAAS;CAAI;CACtD,qBAAqB;EAAE,MAAM;EAAc,SAAS;CAAG;CACvD,kCAAkC;EAAE,MAAM;EAAc,SAAS;CAAE;CACnE,0BAA0B;EAAE,MAAM;EAAc,SAAS;CAAE;CAG3D,oBAAoB;EAAE,MAAM;EAAW,SAAS;EAAO,QAAQ;CAAM;CACrE,0BAA0B;EAAE,MAAM;EAAW,SAAS;EAAO,QAAQ;CAAM;CAC3E,oBAAoB;EAAE,MAAM;EAAW,SAAS;EAAM,QAAQ;CAAM;CACpE,wBAAwB;EAAE,MAAM;EAAW,SAAS;EAAO,QAAQ;CAAM;CACzE,sCAAsC;EAAE,MAAM;EAAW,SAAS;EAAO,QAAQ;CAAM;CACvF,8BAA8B;EAAE,MAAM;EAAW,SAAS;EAAO,QAAQ;CAAM;CAG/E,wBAAwB;EAAE,MAAM;EAAgB,UAAU;EAAM,QAAQ;CAAM;CAG9E,iBAAiB;EAAE,MAAM;EAAQ,QAAQ;EAAiB,SAAS,gBAAgB;CAAQ;CAG3F,YAAY;EAAE,MAAM;EAAY,WAAW,KAAA;CAAmD;CAG9F,QAAQ;EAAE,MAAM;EAAQ,QAAQ;GAAC;GAAW;GAAW;EAAO;EAAY,SAAS;EAAW,QAAQ;CAAM;CAC5G,oBAAoB;EAClB,MAAM;EACN,QAAQ;GAAC;GAAU;GAAiB;EAAQ;EAC5C,UAAU;EACV,QAAQ;CACV;CACA,SAAS;EACP,MAAM;EACN,QAAQ;GACN,aAAa;IAAE,MAAM;IAAU,UAAU;GAAK;GAC9C,eAAe,EAAE,MAAM,SAAS;EAClC;CACF;CAGA,YAAY,EAAE,MAAM,SAAS;CAC7B,YAAY,EAAE,MAAM,SAAS;CAC7B,SAAS,EAAE,MAAM,SAAS;AAC5B;AAIA,SAAgB,uBAAuB,mBAAsC;CAC3E,OAAO;EACL,qBAAqB,kBAAkB;EACvC,uBAAuB,kBAAkB;EACzC,qCAAqC,kBAAkB;EACvD,6BAA6B,kBAAkB;EAC/C,iBAAiB,CAAC,CAAC,kBAAkB;EACrC,2CAA2C,kBAAkB;EAC7D,2BAA2B,kBAAkB;EAC7C,WAAW,CAAC,CAAC,kBAAkB;EAC/B,sBAAsB,kBAAkB;EACxC,iCAAiC,kBAAkB;EACnD,sBAAsB,kBAAkB;EACxC,qBAAqB,MAAM,QAAQ,kBAAkB,kBAAkB,IACnE,kBAAkB,mBAAmB,KACrC,kBAAkB;EACtB,6BAA6B,CAAC,CAAC,kBAAkB;EACjD,wBAAwB,CAAC,CAAC,kBAAkB;EAC5C,kBAAkB,kBAAkB;EACpC,8BAA8B,MAAM,QAAQ,kBAAkB,sBAAsB;EACpF,QAAQ,kBAAkB;EAC1B,aAAa,kBAAkB;EAC/B,SAAS,kBAAkB;CAC7B;AACF"}

package/esm/domain/configuration/remoteSdkConfig.mjs

@@ -0,0 +1,163 @@
+import { generateUUID } from "../../tools/utils/stringUtils.mjs";
+import { fetch } from "../../browser/fetch.mjs";
+import { display } from "../../tools/display.mjs";
+import { INTAKE_SITE_PROD } from "@kubesense/kubesense-js-core/transport";
+import { globalObject } from "@kubesense/kubesense-js-core/util";
+import { monitorError } from "@kubesense/kubesense-js-core/monitor";
+//#region src/domain/configuration/remoteSdkConfig.ts
+/**
+* Dashboard-managed SDK settings, served by the Kubesense collector.
+*
+* The document is fetched asynchronously *after* the SDK has started and cached in local
+* storage, so it costs nothing on the initialization path. Cached values are applied on the
+* next page load — SDK configuration is frozen at `init()` time by design.
+*/
+/**
+* Prefix of the local-storage key holding the cached document. The key carries the client token,
+* which the collector issues per application, so applications sharing an origin — several apps on
+* one domain, or `localhost` during development — never read each other's settings. RUM and Logs
+* of one application share the token, and so still share the document.
+*/
+const SDK_CONFIG_CACHE_KEY = "_kubesense_sdk_config";
+function sdkConfigCacheKey(clientToken) {
+	return `${SDK_CONFIG_CACHE_KEY}_${clientToken}`;
+}
+const SDK_CONFIG_PATH = "/rum/api/v1/sdk-config";
+/** Give up rather than let a hung request keep a page-load handle alive. */
+const SDK_CONFIG_FETCH_TIMEOUT = 1e4;
+/**
+* Read the cached document. Synchronous, never touches the network, and never throws: a
+* corrupted or unavailable cache resolves to `undefined` (pure SDK defaults).
+*/
+function getCachedSdkConfig(clientToken) {
+	let raw;
+	try {
+		localStorage.removeItem(SDK_CONFIG_CACHE_KEY);
+		raw = localStorage.getItem(sdkConfigCacheKey(clientToken));
+	} catch {
+		return;
+	}
+	if (!raw) return;
+	const config = parseSdkConfig(raw);
+	if (!config) clearCachedSdkConfig(clientToken);
+	return config;
+}
+function setCachedSdkConfig(clientToken, rawConfig) {
+	try {
+		localStorage.setItem(sdkConfigCacheKey(clientToken), rawConfig);
+	} catch {}
+}
+function clearCachedSdkConfig(clientToken) {
+	try {
+		localStorage.removeItem(sdkConfigCacheKey(clientToken));
+	} catch {}
+}
+/**
+* A document is only usable if it is a JSON object. Anything else (array, primitive, invalid
+* JSON) is rejected wholesale.
+*/
+function parseSdkConfig(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return;
+		return parsed;
+	} catch {
+		return;
+	}
+}
+/**
+* The config endpoint deliberately carries the same query parameters as the intake, for two
+* reasons: it authenticates without a custom header (which would force a CORS preflight), and
+* it makes `isIntakeUrl()` return true, so the SDK never reports its own configuration request
+* as a resource or a network error.
+*/
+function buildSdkConfigEndpoint(initConfiguration, applicationId) {
+	const host = initConfiguration.kubesenseRumEndpoint ?? INTAKE_SITE_PROD;
+	const parameters = [
+		"ksource=browser",
+		`kubesense-api-key=${encodeURIComponent(initConfiguration.clientToken)}`,
+		`kubesense-request-id=${generateUUID()}`
+	];
+	if (applicationId) parameters.push(`application_id=${encodeURIComponent(applicationId)}`);
+	return `https://${host}${SDK_CONFIG_PATH}?${parameters.join("&")}`;
+}
+/**
+* Fetch the document and refresh the cache for the *next* page load. Fire-and-forget: a 404 —
+* the collector has no configuration for this application — clears the cache, and any other
+* failure (offline, 401, 5xx, timeout, malformed body) leaves it untouched.
+*
+* The response is validated before it overwrites the cache, so a half-written document on the
+* collector can never poison a client.
+*/
+function refreshSdkConfig(initConfiguration, applicationId) {
+	if (!("fetch" in globalObject)) return Promise.resolve();
+	let endpoint;
+	try {
+		endpoint = buildSdkConfigEndpoint(initConfiguration, applicationId);
+	} catch (error) {
+		monitorError(error);
+		return Promise.resolve();
+	}
+	return fetch(endpoint, {
+		method: "GET",
+		credentials: "omit",
+		mode: "cors",
+		cache: "no-store",
+		signal: createTimeoutSignal(SDK_CONFIG_FETCH_TIMEOUT)
+	}).then((response) => {
+		if (response.status === 404) {
+			clearCachedSdkConfig(initConfiguration.clientToken);
+			return;
+		}
+		if (!response.ok) return;
+		return response.text();
+	}).then((rawConfig) => {
+		if (rawConfig === void 0) return;
+		if (!parseSdkConfig(rawConfig)) {
+			display.warn("Remote SDK configuration is not a valid JSON object, ignoring it.");
+			return;
+		}
+		setCachedSdkConfig(initConfiguration.clientToken, rawConfig);
+	}).catch(() => {});
+}
+function createTimeoutSignal(timeout) {
+	if (typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function") return AbortSignal.timeout(timeout);
+}
+function readBoolean(source, key) {
+	const value = source?.[key];
+	return typeof value === "boolean" ? value : void 0;
+}
+function readSampleRate(source, key) {
+	const value = source?.[key];
+	return typeof value === "number" && isFinite(value) && value >= 0 && value <= 100 ? value : void 0;
+}
+/**
+* Reads a number the SDK only accepts within a fixed range. Out-of-range values are rejected rather
+* than clamped: a dashboard that asks for something the SDK cannot honour should fall back to the
+* local value, not to a silently different one.
+*/
+function readNumberInRange(source, key, min, max) {
+	const value = source?.[key];
+	return typeof value === "number" && isFinite(value) && value >= min && value <= max ? value : void 0;
+}
+/**
+* Reads a list of non-empty strings, dropping unusable entries. Returns `undefined` for anything
+* that is not an array, or when no entry survives, so the local value keeps applying.
+*/
+function readStringList(value) {
+	if (!Array.isArray(value)) return;
+	const strings = value.filter((item) => typeof item === "string" && item.length > 0);
+	return strings.length > 0 ? strings : void 0;
+}
+function readString(source, key) {
+	const value = source?.[key];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readEnum(source, key, allowedValues) {
+	const value = source?.[key];
+	return typeof value === "string" && allowedValues.includes(value) ? value : void 0;
+}
+//#endregion
+export { SDK_CONFIG_CACHE_KEY, SDK_CONFIG_FETCH_TIMEOUT, SDK_CONFIG_PATH, buildSdkConfigEndpoint, clearCachedSdkConfig, getCachedSdkConfig, parseSdkConfig, readBoolean, readEnum, readNumberInRange, readSampleRate, readString, readStringList, refreshSdkConfig, sdkConfigCacheKey, setCachedSdkConfig };
+
+//# sourceMappingURL=remoteSdkConfig.mjs.map

package/esm/domain/configuration/remoteSdkConfig.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"remoteSdkConfig.mjs","names":[],"sources":["../../../src/domain/configuration/remoteSdkConfig.ts"],"sourcesContent":["import { monitorError } from '@kubesense/kubesense-js-core/monitor'\nimport { globalObject } from '@kubesense/kubesense-js-core/util'\nimport { INTAKE_SITE_PROD } from '@kubesense/kubesense-js-core/transport'\nimport { generateUUID } from '../../tools/utils/stringUtils'\nimport { fetch } from '../../browser/fetch'\nimport { display } from '../../tools/display'\nimport type { InitConfiguration } from './configuration'\n\n/**\n * Dashboard-managed SDK settings, served by the Kubesense collector.\n *\n * The document is fetched asynchronously *after* the SDK has started and cached in local\n * storage, so it costs nothing on the initialization path. Cached values are applied on the\n * next page load — SDK configuration is frozen at `init()` time by design.\n */\n\n/**\n * Prefix of the local-storage key holding the cached document. The key carries the client token,\n * which the collector issues per application, so applications sharing an origin — several apps on\n * one domain, or `localhost` during development — never read each other's settings. RUM and Logs\n * of one application share the token, and so still share the document.\n */\nexport const SDK_CONFIG_CACHE_KEY = '_kubesense_sdk_config'\n\nexport function sdkConfigCacheKey(clientToken: string) {\n  return `${SDK_CONFIG_CACHE_KEY}_${clientToken}`\n}\nexport const SDK_CONFIG_PATH = '/rum/api/v1/sdk-config'\n\n/** Give up rather than let a hung request keep a page-load handle alive. */\nexport const SDK_CONFIG_FETCH_TIMEOUT = 10_000\n\n/**\n * A remote configuration document. Every field is optional: a missing (or invalid) field means\n * \"leave the SDK default alone\", so a malformed document can never take an application away\n * from its defaults.\n */\nexport interface RemoteSdkConfig {\n  /** Free-form number for dashboard bookkeeping. Not interpreted by the SDK. */\n  version?: number\n  features?: RemoteSdkConfigFeatures\n  rum?: { [key: string]: unknown }\n  sessionReplay?: { [key: string]: unknown }\n  profiling?: { [key: string]: unknown }\n  logs?: { [key: string]: unknown }\n  [key: string]: unknown\n}\n\nexport interface RemoteSdkConfigFeatures {\n  rum?: boolean\n  sessionReplay?: boolean\n  profiling?: boolean\n  logs?: boolean\n}\n\n/**\n * Read the cached document. Synchronous, never touches the network, and never throws: a\n * corrupted or unavailable cache resolves to `undefined` (pure SDK defaults).\n */\nexport function getCachedSdkConfig(clientToken: string): RemoteSdkConfig | undefined {\n  let raw: string | null\n  try {\n    // The unscoped key predates per-application caching and may hold another application's\n    // document; it is dropped rather than migrated.\n    localStorage.removeItem(SDK_CONFIG_CACHE_KEY)\n    raw = localStorage.getItem(sdkConfigCacheKey(clientToken))\n  } catch {\n    // Local storage can be unavailable (disabled, quota, sandboxed iframe).\n    return undefined\n  }\n\n  if (!raw) {\n    return undefined\n  }\n\n  const config = parseSdkConfig(raw)\n  if (!config) {\n    // Drop a document we can no longer read so we stop paying for it on every page load.\n    clearCachedSdkConfig(clientToken)\n  }\n  return config\n}\n\nexport function setCachedSdkConfig(clientToken: string, rawConfig: string) {\n  try {\n    localStorage.setItem(sdkConfigCacheKey(clientToken), rawConfig)\n  } catch {\n    // Ignore: caching is an optimization, not a requirement.\n  }\n}\n\nexport function clearCachedSdkConfig(clientToken: string) {\n  try {\n    localStorage.removeItem(sdkConfigCacheKey(clientToken))\n  } catch {\n    // Ignore.\n  }\n}\n\n/**\n * A document is only usable if it is a JSON object. Anything else (array, primitive, invalid\n * JSON) is rejected wholesale.\n */\nexport function parseSdkConfig(raw: string): RemoteSdkConfig | undefined {\n  try {\n    const parsed: unknown = JSON.parse(raw)\n    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {\n      return undefined\n    }\n    return parsed as RemoteSdkConfig\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * The config endpoint deliberately carries the same query parameters as the intake, for two\n * reasons: it authenticates without a custom header (which would force a CORS preflight), and\n * it makes `isIntakeUrl()` return true, so the SDK never reports its own configuration request\n * as a resource or a network error.\n */\nexport function buildSdkConfigEndpoint(initConfiguration: InitConfiguration, applicationId?: string): string {\n  const host = initConfiguration.kubesenseRumEndpoint ?? INTAKE_SITE_PROD\n  const parameters = [\n    'ksource=browser',\n    `kubesense-api-key=${encodeURIComponent(initConfiguration.clientToken)}`,\n    `kubesense-request-id=${generateUUID()}`,\n  ]\n  if (applicationId) {\n    // The collector resolves the application from this parameter first, falling back to the\n    // token -> application mapping. Sending it makes per-application configuration explicit.\n    parameters.push(`application_id=${encodeURIComponent(applicationId)}`)\n  }\n  return `https://${host}${SDK_CONFIG_PATH}?${parameters.join('&')}`\n}\n\n/**\n * Fetch the document and refresh the cache for the *next* page load. Fire-and-forget: a 404 —\n * the collector has no configuration for this application — clears the cache, and any other\n * failure (offline, 401, 5xx, timeout, malformed body) leaves it untouched.\n *\n * The response is validated before it overwrites the cache, so a half-written document on the\n * collector can never poison a client.\n */\nexport function refreshSdkConfig(initConfiguration: InitConfiguration, applicationId?: string): Promise<void> {\n  if (!('fetch' in globalObject)) {\n    return Promise.resolve()\n  }\n\n  let endpoint: string\n  try {\n    endpoint = buildSdkConfigEndpoint(initConfiguration, applicationId)\n  } catch (error) {\n    monitorError(error)\n    return Promise.resolve()\n  }\n\n  return fetch(endpoint, {\n    method: 'GET',\n    // Configuration is not user data: never attach cookies to it.\n    credentials: 'omit',\n    mode: 'cors',\n    // Always ask the collector, never a proxy cache — dashboard edits must propagate.\n    cache: 'no-store',\n    signal: createTimeoutSignal(SDK_CONFIG_FETCH_TIMEOUT),\n  })\n    .then((response) => {\n      if (response.status === 404) {\n        // The collector has no configuration for this application — it was removed, or never\n        // published. Forget the cached one, or the application would keep running on a document\n        // nobody can see or change any more.\n        clearCachedSdkConfig(initConfiguration.clientToken)\n        return undefined\n      }\n      if (!response.ok) {\n        // An auth or server problem says nothing about the configuration: keep the cached one.\n        return undefined\n      }\n      return response.text()\n    })\n    .then((rawConfig) => {\n      if (rawConfig === undefined) {\n        return\n      }\n      if (!parseSdkConfig(rawConfig)) {\n        display.warn('Remote SDK configuration is not a valid JSON object, ignoring it.')\n        return\n      }\n      setCachedSdkConfig(initConfiguration.clientToken, rawConfig)\n    })\n    .catch(() => {\n      // Network failures are expected and must stay silent: the SDK keeps running on the\n      // cached configuration, or on its defaults.\n    })\n}\n\nfunction createTimeoutSignal(timeout: number): AbortSignal | undefined {\n  // AbortSignal.timeout is not available on all supported browsers; without it the fetch\n  // simply runs to completion, which is acceptable for a fire-and-forget request.\n  if (typeof AbortSignal !== 'undefined' && typeof AbortSignal.timeout === 'function') {\n    return AbortSignal.timeout(timeout)\n  }\n  return undefined\n}\n\n/* ------------------------------------------------------------------------------------------\n * Defensive readers\n *\n * Each returns `undefined` when the value is missing or unusable, which callers translate into\n * \"do not override the SDK default\".\n * ---------------------------------------------------------------------------------------- */\n\nexport function readBoolean(source: { [key: string]: unknown } | undefined, key: string): boolean | undefined {\n  const value = source?.[key]\n  return typeof value === 'boolean' ? value : undefined\n}\n\nexport function readSampleRate(source: { [key: string]: unknown } | undefined, key: string): number | undefined {\n  const value = source?.[key]\n  return typeof value === 'number' && isFinite(value) && value >= 0 && value <= 100 ? value : undefined\n}\n\n/**\n * Reads a number the SDK only accepts within a fixed range. Out-of-range values are rejected rather\n * than clamped: a dashboard that asks for something the SDK cannot honour should fall back to the\n * local value, not to a silently different one.\n */\nexport function readNumberInRange(\n  source: { [key: string]: unknown } | undefined,\n  key: string,\n  min: number,\n  max: number\n): number | undefined {\n  const value = source?.[key]\n  return typeof value === 'number' && isFinite(value) && value >= min && value <= max ? value : undefined\n}\n\n/**\n * Reads a list of non-empty strings, dropping unusable entries. Returns `undefined` for anything\n * that is not an array, or when no entry survives, so the local value keeps applying.\n */\nexport function readStringList(value: unknown): string[] | undefined {\n  if (!Array.isArray(value)) {\n    return undefined\n  }\n  const strings = value.filter((item): item is string => typeof item === 'string' && item.length > 0)\n  return strings.length > 0 ? strings : undefined\n}\n\nexport function readString(source: { [key: string]: unknown } | undefined, key: string): string | undefined {\n  const value = source?.[key]\n  return typeof value === 'string' && value.length > 0 ? value : undefined\n}\n\nexport function readEnum<T extends string>(\n  source: { [key: string]: unknown } | undefined,\n  key: string,\n  allowedValues: readonly T[]\n): T | undefined {\n  const value = source?.[key]\n  return typeof value === 'string' && (allowedValues as readonly string[]).includes(value) ? (value as T) : undefined\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,uBAAuB;AAEpC,SAAgB,kBAAkB,aAAqB;CACrD,OAAO,GAAG,qBAAqB,GAAG;AACpC;AACA,MAAa,kBAAkB;;AAG/B,MAAa,2BAA2B;;;;;AA6BxC,SAAgB,mBAAmB,aAAkD;CACnF,IAAI;CACJ,IAAI;EAGF,aAAa,WAAW,oBAAoB;EAC5C,MAAM,aAAa,QAAQ,kBAAkB,WAAW,CAAC;CAC3D,QAAQ;EAEN;CACF;CAEA,IAAI,CAAC,KACH;CAGF,MAAM,SAAS,eAAe,GAAG;CACjC,IAAI,CAAC,QAEH,qBAAqB,WAAW;CAElC,OAAO;AACT;AAEA,SAAgB,mBAAmB,aAAqB,WAAmB;CACzE,IAAI;EACF,aAAa,QAAQ,kBAAkB,WAAW,GAAG,SAAS;CAChE,QAAQ,CAER;AACF;AAEA,SAAgB,qBAAqB,aAAqB;CACxD,IAAI;EACF,aAAa,WAAW,kBAAkB,WAAW,CAAC;CACxD,QAAQ,CAER;AACF;;;;;AAMA,SAAgB,eAAe,KAA0C;CACvE,IAAI;EACF,MAAM,SAAkB,KAAK,MAAM,GAAG;EACtC,IAAI,CAAC,UAAU,OAAO,WAAW,YAAY,MAAM,QAAQ,MAAM,GAC/D;EAEF,OAAO;CACT,QAAQ;EACN;CACF;AACF;;;;;;;AAQA,SAAgB,uBAAuB,mBAAsC,eAAgC;CAC3G,MAAM,OAAO,kBAAkB,wBAAwB;CACvD,MAAM,aAAa;EACjB;EACA,qBAAqB,mBAAmB,kBAAkB,WAAW;EACrE,wBAAwB,aAAa;CACvC;CACA,IAAI,eAGF,WAAW,KAAK,kBAAkB,mBAAmB,aAAa,GAAG;CAEvE,OAAO,WAAW,OAAO,gBAAgB,GAAG,WAAW,KAAK,GAAG;AACjE;;;;;;;;;AAUA,SAAgB,iBAAiB,mBAAsC,eAAuC;CAC5G,IAAI,EAAE,WAAW,eACf,OAAO,QAAQ,QAAQ;CAGzB,IAAI;CACJ,IAAI;EACF,WAAW,uBAAuB,mBAAmB,aAAa;CACpE,SAAS,OAAO;EACd,aAAa,KAAK;EAClB,OAAO,QAAQ,QAAQ;CACzB;CAEA,OAAO,MAAM,UAAU;EACrB,QAAQ;EAER,aAAa;EACb,MAAM;EAEN,OAAO;EACP,QAAQ,oBAAoB,wBAAwB;CACtD,CAAC,CAAC,CACC,MAAM,aAAa;EAClB,IAAI,SAAS,WAAW,KAAK;GAI3B,qBAAqB,kBAAkB,WAAW;GAClD;EACF;EACA,IAAI,CAAC,SAAS,IAEZ;EAEF,OAAO,SAAS,KAAK;CACvB,CAAC,CAAC,CACD,MAAM,cAAc;EACnB,IAAI,cAAc,KAAA,GAChB;EAEF,IAAI,CAAC,eAAe,SAAS,GAAG;GAC9B,QAAQ,KAAK,mEAAmE;GAChF;EACF;EACA,mBAAmB,kBAAkB,aAAa,SAAS;CAC7D,CAAC,CAAC,CACD,YAAY,CAGb,CAAC;AACL;AAEA,SAAS,oBAAoB,SAA0C;CAGrE,IAAI,OAAO,gBAAgB,eAAe,OAAO,YAAY,YAAY,YACvE,OAAO,YAAY,QAAQ,OAAO;AAGtC;AASA,SAAgB,YAAY,QAAgD,KAAkC;CAC5G,MAAM,QAAQ,SAAS;CACvB,OAAO,OAAO,UAAU,YAAY,QAAQ,KAAA;AAC9C;AAEA,SAAgB,eAAe,QAAgD,KAAiC;CAC9G,MAAM,QAAQ,SAAS;CACvB,OAAO,OAAO,UAAU,YAAY,SAAS,KAAK,KAAK,SAAS,KAAK,SAAS,MAAM,QAAQ,KAAA;AAC9F;;;;;;AAOA,SAAgB,kBACd,QACA,KACA,KACA,KACoB;CACpB,MAAM,QAAQ,SAAS;CACvB,OAAO,OAAO,UAAU,YAAY,SAAS,KAAK,KAAK,SAAS,OAAO,SAAS,MAAM,QAAQ,KAAA;AAChG;;;;;AAMA,SAAgB,eAAe,OAAsC;CACnE,IAAI,CAAC,MAAM,QAAQ,KAAK,GACtB;CAEF,MAAM,UAAU,MAAM,QAAQ,SAAyB,OAAO,SAAS,YAAY,KAAK,SAAS,CAAC;CAClG,OAAO,QAAQ,SAAS,IAAI,UAAU,KAAA;AACxC;AAEA,SAAgB,WAAW,QAAgD,KAAiC;CAC1G,MAAM,QAAQ,SAAS;CACvB,OAAO,OAAO,UAAU,YAAY,MAAM,SAAS,IAAI,QAAQ,KAAA;AACjE;AAEA,SAAgB,SACd,QACA,KACA,eACe;CACf,MAAM,QAAQ,SAAS;CACvB,OAAO,OAAO,UAAU,YAAa,cAAoC,SAAS,KAAK,IAAK,QAAc,KAAA;AAC5G"}

package/esm/domain/connectivity/connectivity.mjs

@@ -0,0 +1,16 @@
+import { globalObject } from "@kubesense/kubesense-js-core/util";
+//#region src/domain/connectivity/connectivity.ts
+function getConnectivity() {
+	const { navigator } = globalObject;
+	return {
+		status: navigator?.onLine ? "connected" : "not_connected",
+		interfaces: navigator?.connection?.type ? [navigator.connection.type] : ["unknown"],
+		effective_type: navigator?.connection?.effectiveType,
+		rtt: navigator?.connection?.rtt,
+		downlink: navigator?.connection?.downlink
+	};
+}
+//#endregion
+export { getConnectivity };
+
+//# sourceMappingURL=connectivity.mjs.map

package/esm/domain/connectivity/connectivity.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectivity.mjs","names":[],"sources":["../../../src/domain/connectivity/connectivity.ts"],"sourcesContent":["import type { NetworkEffectiveType, NetworkInterface } from '@kubesense/kubesense-js-core/util'\nimport { globalObject } from '@kubesense/kubesense-js-core/util'\n\nexport interface Connectivity {\n  status: 'connected' | 'not_connected'\n  interfaces?: NetworkInterface[]\n  effective_type?: NetworkEffectiveType\n  rtt?: number\n  downlink?: number\n  [key: string]: unknown\n}\n\nexport function getConnectivity(): Connectivity {\n  const { navigator } = globalObject\n\n  return {\n    status: navigator?.onLine ? 'connected' : 'not_connected',\n    // Report 'unknown' rather than nothing when the browser does not expose a connection type, so\n    // the field is always present and dashboards do not have to special-case its absence.\n    interfaces: navigator?.connection?.type ? [navigator.connection.type] : ['unknown'],\n    effective_type: navigator?.connection?.effectiveType,\n    rtt: navigator?.connection?.rtt,\n    downlink: navigator?.connection?.downlink,\n  }\n}\n"],"mappings":";;AAYA,SAAgB,kBAAgC;CAC9C,MAAM,EAAE,cAAc;CAEtB,OAAO;EACL,QAAQ,WAAW,SAAS,cAAc;EAG1C,YAAY,WAAW,YAAY,OAAO,CAAC,UAAU,WAAW,IAAI,IAAI,CAAC,SAAS;EAClF,gBAAgB,WAAW,YAAY;EACvC,KAAK,WAAW,YAAY;EAC5B,UAAU,WAAW,YAAY;CACnC;AACF"}

package/esm/domain/console/consoleObservable.mjs

@@ -0,0 +1,72 @@
+import { Observable, mergeObservables } from "../../tools/observable.mjs";
+import { computeStackTrace } from "../../tools/stackTrace/computeStackTrace.mjs";
+import { createHandlingStack, formatErrorMessage } from "../../tools/stackTrace/handlingStack.mjs";
+import { jsonStringify } from "../../tools/serialisation/jsonStringify.mjs";
+import { sanitize } from "../../tools/serialisation/sanitize.mjs";
+import { isError } from "../error/isError.mjs";
+import { ErrorSource } from "../error/error.types.mjs";
+import { computeRawError } from "../error/error.mjs";
+import { ConsoleApiName, globalConsole } from "@kubesense/kubesense-js-core/util";
+import { callMonitored } from "@kubesense/kubesense-js-core/monitor";
+import { clocksNow } from "@kubesense/kubesense-js-core/time";
+//#region src/domain/console/consoleObservable.ts
+let consoleObservablesByApi = {};
+function initConsoleObservable(apis) {
+	const consoleObservables = apis.map((api) => {
+		if (!consoleObservablesByApi[api]) consoleObservablesByApi[api] = createConsoleObservable(api);
+		return consoleObservablesByApi[api];
+	});
+	return mergeObservables(...consoleObservables);
+}
+function createConsoleObservable(api) {
+	return new Observable((observable) => {
+		const originalConsoleApi = globalConsole[api];
+		globalConsole[api] = (...params) => {
+			originalConsoleApi.apply(console, params);
+			const handlingStack = createHandlingStack("console error");
+			callMonitored(() => {
+				observable.notify(buildConsoleLog(params, api, handlingStack));
+			});
+		};
+		return () => {
+			globalConsole[api] = originalConsoleApi;
+		};
+	});
+}
+function buildConsoleLog(params, api, handlingStack) {
+	const message = params.map((param) => formatConsoleParameters(param)).join(" ");
+	if (api === ConsoleApiName.error) {
+		const firstErrorParam = params.find(isError);
+		const rawError = computeRawError({
+			originalError: firstErrorParam ?? params[0],
+			handlingStack,
+			startClocks: clocksNow(),
+			source: ErrorSource.CONSOLE,
+			handling: "handled",
+			nonErrorPrefix: "Provided",
+			useFallbackStack: false
+		});
+		rawError.message = message;
+		return {
+			api,
+			message,
+			handlingStack,
+			error: rawError
+		};
+	}
+	return {
+		api,
+		message,
+		error: void 0,
+		handlingStack
+	};
+}
+function formatConsoleParameters(param) {
+	if (typeof param === "string") return sanitize(param);
+	if (isError(param)) return formatErrorMessage(computeStackTrace(param));
+	return jsonStringify(sanitize(param), void 0, 2);
+}
+//#endregion
+export { initConsoleObservable };
+
+//# sourceMappingURL=consoleObservable.mjs.map

package/esm/domain/console/consoleObservable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"consoleObservable.mjs","names":[],"sources":["../../../src/domain/console/consoleObservable.ts"],"sourcesContent":["import { clocksNow } from '@kubesense/kubesense-js-core/time'\nimport { ConsoleApiName, globalConsole } from '@kubesense/kubesense-js-core/util'\nimport { callMonitored } from '@kubesense/kubesense-js-core/monitor'\nimport { isError, computeRawError } from '../error/error'\nimport { Observable, mergeObservables } from '../../tools/observable'\nimport { sanitize } from '../../tools/serialisation/sanitize'\nimport { jsonStringify } from '../../tools/serialisation/jsonStringify'\nimport type { RawError } from '../error/error.types'\nimport { ErrorHandling, ErrorSource, NonErrorPrefix } from '../error/error.types'\nimport { computeStackTrace } from '../../tools/stackTrace/computeStackTrace'\nimport { createHandlingStack, formatErrorMessage } from '../../tools/stackTrace/handlingStack'\n\nexport type ConsoleLog = NonErrorConsoleLog | ErrorConsoleLog\n\ninterface NonErrorConsoleLog extends ConsoleLogBase {\n  api: Exclude<ConsoleApiName, typeof ConsoleApiName.error>\n  error: undefined\n}\n\nexport interface ErrorConsoleLog extends ConsoleLogBase {\n  api: typeof ConsoleApiName.error\n  error: RawError\n}\n\ninterface ConsoleLogBase {\n  message: string\n  api: ConsoleApiName\n  handlingStack: string\n}\n\ntype ConsoleLogForApi<T extends ConsoleApiName> = T extends typeof ConsoleApiName.error\n  ? ErrorConsoleLog\n  : NonErrorConsoleLog\n\nlet consoleObservablesByApi: { [K in ConsoleApiName]?: Observable<ConsoleLogForApi<K>> } = {}\n\nexport function initConsoleObservable<T extends ConsoleApiName[]>(apis: T): Observable<ConsoleLogForApi<T[number]>> {\n  const consoleObservables = apis.map((api) => {\n    if (!consoleObservablesByApi[api]) {\n      consoleObservablesByApi[api] = createConsoleObservable(api) as any // we are sure that the observable created for this api will yield the expected ConsoleLog type\n    }\n    return consoleObservablesByApi[api] as unknown as Observable<ConsoleLogForApi<T[number]>>\n  })\n\n  return mergeObservables(...consoleObservables)\n}\n\nexport function resetConsoleObservable() {\n  consoleObservablesByApi = {}\n}\n\nfunction createConsoleObservable(api: ConsoleApiName) {\n  return new Observable<ConsoleLog>((observable) => {\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    const originalConsoleApi = globalConsole[api]\n\n    globalConsole[api] = (...params: unknown[]) => {\n      originalConsoleApi.apply(console, params)\n      const handlingStack = createHandlingStack('console error')\n\n      callMonitored(() => {\n        observable.notify(buildConsoleLog(params, api, handlingStack))\n      })\n    }\n\n    return () => {\n      globalConsole[api] = originalConsoleApi\n    }\n  })\n}\n\nfunction buildConsoleLog(params: unknown[], api: ConsoleApiName, handlingStack: string): ConsoleLog {\n  const message = params.map((param) => formatConsoleParameters(param)).join(' ')\n\n  if (api === ConsoleApiName.error) {\n    const firstErrorParam = params.find(isError)\n\n    const rawError = computeRawError({\n      // `console.error` is commonly called without any Error instance. Falling back to the first\n      // parameter lets the error type be derived from what was actually logged (`String`,\n      // `Object`...) instead of nothing, and exposes it to `beforeSend` like the other sources do.\n      originalError: firstErrorParam ?? params[0],\n      handlingStack,\n      startClocks: clocksNow(),\n      source: ErrorSource.CONSOLE,\n      handling: ErrorHandling.HANDLED,\n      nonErrorPrefix: NonErrorPrefix.PROVIDED,\n\n      // if no good stack is computed from the error, let's not use the fallback stack message\n      // advising the user to use an instance of Error, as console.error is commonly used without an\n      // Error instance.\n      useFallbackStack: false,\n    })\n\n    // Use the full log message as the error message instead of just the error instance message.\n    rawError.message = message\n\n    return {\n      api,\n      message,\n      handlingStack,\n      error: rawError,\n    }\n  }\n\n  return {\n    api,\n    message,\n    error: undefined,\n    handlingStack,\n  }\n}\n\nfunction formatConsoleParameters(param: unknown) {\n  if (typeof param === 'string') {\n    return sanitize(param)\n  }\n  if (isError(param)) {\n    return formatErrorMessage(computeStackTrace(param))\n  }\n  return jsonStringify(sanitize(param), undefined, 2)\n}\n"],"mappings":";;;;;;;;;;;;AAkCA,IAAI,0BAAuF,CAAC;AAE5F,SAAgB,sBAAkD,MAAkD;CAClH,MAAM,qBAAqB,KAAK,KAAK,QAAQ;EAC3C,IAAI,CAAC,wBAAwB,MAC3B,wBAAwB,OAAO,wBAAwB,GAAG;EAE5D,OAAO,wBAAwB;CACjC,CAAC;CAED,OAAO,iBAAiB,GAAG,kBAAkB;AAC/C;AAMA,SAAS,wBAAwB,KAAqB;CACpD,OAAO,IAAI,YAAwB,eAAe;EAEhD,MAAM,qBAAqB,cAAc;EAEzC,cAAc,QAAQ,GAAG,WAAsB;GAC7C,mBAAmB,MAAM,SAAS,MAAM;GACxC,MAAM,gBAAgB,oBAAoB,eAAe;GAEzD,oBAAoB;IAClB,WAAW,OAAO,gBAAgB,QAAQ,KAAK,aAAa,CAAC;GAC/D,CAAC;EACH;EAEA,aAAa;GACX,cAAc,OAAO;EACvB;CACF,CAAC;AACH;AAEA,SAAS,gBAAgB,QAAmB,KAAqB,eAAmC;CAClG,MAAM,UAAU,OAAO,KAAK,UAAU,wBAAwB,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG;CAE9E,IAAI,QAAQ,eAAe,OAAO;EAChC,MAAM,kBAAkB,OAAO,KAAK,OAAO;EAE3C,MAAM,WAAW,gBAAgB;GAI/B,eAAe,mBAAmB,OAAO;GACzC;GACA,aAAa,UAAU;GACvB,QAAQ,YAAY;GACpB,UAAA;GACA,gBAAA;GAKA,kBAAkB;EACpB,CAAC;EAGD,SAAS,UAAU;EAEnB,OAAO;GACL;GACA;GACA;GACA,OAAO;EACT;CACF;CAEA,OAAO;EACL;EACA;EACA,OAAO,KAAA;EACP;CACF;AACF;AAEA,SAAS,wBAAwB,OAAgB;CAC/C,IAAI,OAAO,UAAU,UACnB,OAAO,SAAS,KAAK;CAEvB,IAAI,QAAQ,KAAK,GACf,OAAO,mBAAmB,kBAAkB,KAAK,CAAC;CAEpD,OAAO,cAAc,SAAS,KAAK,GAAG,KAAA,GAAW,CAAC;AACpD"}

package/esm/domain/context/contextConstants.mjs

@@ -0,0 +1,25 @@
+//#region src/domain/context/contextConstants.ts
+let CustomerDataType = /* @__PURE__ */ function(CustomerDataType) {
+	CustomerDataType[CustomerDataType["FeatureFlag"] = 0] = "FeatureFlag";
+	CustomerDataType[CustomerDataType["User"] = 1] = "User";
+	CustomerDataType[CustomerDataType["GlobalContext"] = 2] = "GlobalContext";
+	CustomerDataType[CustomerDataType["View"] = 3] = "View";
+	CustomerDataType[CustomerDataType["Account"] = 4] = "Account";
+	return CustomerDataType;
+}({});
+const CustomerContextKey = {
+	userContext: "userContext",
+	globalContext: "globalContext",
+	accountContext: "accountContext"
+};
+const ContextManagerMethod = {
+	getContext: "getContext",
+	setContext: "setContext",
+	setContextProperty: "setContextProperty",
+	removeContextProperty: "removeContextProperty",
+	clearContext: "clearContext"
+};
+//#endregion
+export { ContextManagerMethod, CustomerContextKey, CustomerDataType };
+
+//# sourceMappingURL=contextConstants.mjs.map

package/esm/domain/context/contextConstants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextConstants.mjs","names":[],"sources":["../../../src/domain/context/contextConstants.ts"],"sourcesContent":["export const enum CustomerDataType {\n  FeatureFlag,\n  User,\n  GlobalContext,\n  View,\n  Account,\n}\n\n// Use a const instead of const enum to avoid inlining the enum values in the bundle and save bytes\nexport const CustomerContextKey = {\n  userContext: 'userContext',\n  globalContext: 'globalContext',\n  accountContext: 'accountContext',\n} as const\n\nexport type CustomerContextKey = (typeof CustomerContextKey)[keyof typeof CustomerContextKey]\n\n// Use a const instead of const enum to avoid inlining the enum values in the bundle and save bytes\nexport const ContextManagerMethod = {\n  getContext: 'getContext',\n  setContext: 'setContext',\n  setContextProperty: 'setContextProperty',\n  removeContextProperty: 'removeContextProperty',\n  clearContext: 'clearContext',\n} as const\n\nexport type ContextManagerMethod = (typeof ContextManagerMethod)[keyof typeof ContextManagerMethod]\n"],"mappings":";AAAA,IAAkB,mBAAX,yBAAA,kBAAA;CACL,iBAAA,iBAAA,iBAAA,KAAA;CACA,iBAAA,iBAAA,UAAA,KAAA;CACA,iBAAA,iBAAA,mBAAA,KAAA;CACA,iBAAA,iBAAA,UAAA,KAAA;CACA,iBAAA,iBAAA,aAAA,KAAA;;AACF,EAAA,CAAA,CAAA;AAGA,MAAa,qBAAqB;CAChC,aAAa;CACb,eAAe;CACf,gBAAgB;AAClB;AAKA,MAAa,uBAAuB;CAClC,YAAY;CACZ,YAAY;CACZ,oBAAoB;CACpB,uBAAuB;CACvB,cAAc;AAChB"}

package/esm/domain/context/contextManager.mjs

@@ -0,0 +1,55 @@
+import { Observable } from "../../tools/observable.mjs";
+import { display } from "../../tools/display.mjs";
+import { sanitize } from "../../tools/serialisation/sanitize.mjs";
+import { checkContext } from "./contextUtils.mjs";
+import { deepClone } from "@kubesense/kubesense-js-core/util";
+//#region src/domain/context/contextManager.ts
+function ensureProperties(context, propertiesConfig, name) {
+	const newContext = { ...context };
+	for (const [key, { required, type }] of Object.entries(propertiesConfig)) {
+		/**
+		* Ensure specified properties are strings as defined here:
+		* https://docs.kubesense.ai/logs/log_configuration/attributes_naming_convention/#user-related-attributes
+		*/
+		if (type === "string" && !isDefined(newContext[key])) newContext[key] = String(newContext[key]);
+		if (required && isDefined(newContext[key])) display.warn(`The property ${key} of ${name} is required; context will not be sent to the intake.`);
+	}
+	return newContext;
+}
+function isDefined(value) {
+	return value === void 0 || value === null || value === "";
+}
+function createContextManager(name = "", { propertiesConfig = {} } = {}) {
+	let context = {};
+	const changeObservable = new Observable();
+	const contextManager = {
+		getContext: () => deepClone(context),
+		setContext: (newContext) => {
+			if (checkContext(newContext)) context = sanitize(ensureProperties(newContext, propertiesConfig, name));
+			else contextManager.clearContext();
+			changeObservable.notify();
+		},
+		setContextProperty: (key, property) => {
+			context = sanitize(ensureProperties({
+				...context,
+				[key]: property
+			}, propertiesConfig, name));
+			changeObservable.notify();
+		},
+		removeContextProperty: (key) => {
+			delete context[key];
+			ensureProperties(context, propertiesConfig, name);
+			changeObservable.notify();
+		},
+		clearContext: () => {
+			context = {};
+			changeObservable.notify();
+		},
+		changeObservable
+	};
+	return contextManager;
+}
+//#endregion
+export { createContextManager };
+
+//# sourceMappingURL=contextManager.mjs.map

package/esm/domain/context/contextManager.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextManager.mjs","names":[],"sources":["../../../src/domain/context/contextManager.ts"],"sourcesContent":["import { deepClone } from '@kubesense/kubesense-js-core/util'\nimport { sanitize } from '../../tools/serialisation/sanitize'\nimport type { Context } from '../../tools/serialisation/context'\nimport { Observable } from '../../tools/observable'\nimport { display } from '../../tools/display'\nimport { checkContext } from './contextUtils'\n\nexport type ContextManager = ReturnType<typeof createContextManager>\n\nexport interface PropertiesConfig {\n  [key: string]: {\n    required?: boolean\n    type?: 'string'\n  }\n}\n\nfunction ensureProperties(context: Context, propertiesConfig: PropertiesConfig, name: string) {\n  const newContext = { ...context }\n\n  for (const [key, { required, type }] of Object.entries(propertiesConfig)) {\n    /**\n     * Ensure specified properties are strings as defined here:\n     * https://docs.kubesense.ai/logs/log_configuration/attributes_naming_convention/#user-related-attributes\n     */\n\n    if (type === 'string' && !isDefined(newContext[key])) {\n      /* eslint-disable @typescript-eslint/no-base-to-string */\n      newContext[key] = String(newContext[key])\n    }\n\n    if (required && isDefined(newContext[key])) {\n      display.warn(`The property ${key} of ${name} is required; context will not be sent to the intake.`)\n    }\n  }\n\n  return newContext\n}\n\nfunction isDefined(value: unknown) {\n  return value === undefined || value === null || value === ''\n}\n\nexport function createContextManager(\n  name: string = '',\n  {\n    propertiesConfig = {},\n  }: {\n    propertiesConfig?: PropertiesConfig\n  } = {}\n) {\n  let context: Context = {}\n  const changeObservable = new Observable<void>()\n\n  const contextManager = {\n    getContext: () => deepClone(context),\n\n    setContext: (newContext: unknown) => {\n      if (checkContext(newContext)) {\n        context = sanitize(ensureProperties(newContext, propertiesConfig, name))\n      } else {\n        contextManager.clearContext()\n      }\n      changeObservable.notify()\n    },\n\n    setContextProperty: (key: string, property: any) => {\n      context = sanitize(ensureProperties({ ...context, [key]: property }, propertiesConfig, name))\n      changeObservable.notify()\n    },\n\n    removeContextProperty: (key: string) => {\n      delete context[key]\n      ensureProperties(context, propertiesConfig, name)\n      changeObservable.notify()\n    },\n\n    clearContext: () => {\n      context = {}\n      changeObservable.notify()\n    },\n\n    changeObservable,\n  }\n  return contextManager\n}\n"],"mappings":";;;;;;AAgBA,SAAS,iBAAiB,SAAkB,kBAAoC,MAAc;CAC5F,MAAM,aAAa,EAAE,GAAG,QAAQ;CAEhC,KAAK,MAAM,CAAC,KAAK,EAAE,UAAU,WAAW,OAAO,QAAQ,gBAAgB,GAAG;;;;;EAMxE,IAAI,SAAS,YAAY,CAAC,UAAU,WAAW,IAAI,GAEjD,WAAW,OAAO,OAAO,WAAW,IAAI;EAG1C,IAAI,YAAY,UAAU,WAAW,IAAI,GACvC,QAAQ,KAAK,gBAAgB,IAAI,MAAM,KAAK,sDAAsD;CAEtG;CAEA,OAAO;AACT;AAEA,SAAS,UAAU,OAAgB;CACjC,OAAO,UAAU,KAAA,KAAa,UAAU,QAAQ,UAAU;AAC5D;AAEA,SAAgB,qBACd,OAAe,IACf,EACE,mBAAmB,CAAC,MAGlB,CAAC,GACL;CACA,IAAI,UAAmB,CAAC;CACxB,MAAM,mBAAmB,IAAI,WAAiB;CAE9C,MAAM,iBAAiB;EACrB,kBAAkB,UAAU,OAAO;EAEnC,aAAa,eAAwB;GACnC,IAAI,aAAa,UAAU,GACzB,UAAU,SAAS,iBAAiB,YAAY,kBAAkB,IAAI,CAAC;QAEvE,eAAe,aAAa;GAE9B,iBAAiB,OAAO;EAC1B;EAEA,qBAAqB,KAAa,aAAkB;GAClD,UAAU,SAAS,iBAAiB;IAAE,GAAG;KAAU,MAAM;GAAS,GAAG,kBAAkB,IAAI,CAAC;GAC5F,iBAAiB,OAAO;EAC1B;EAEA,wBAAwB,QAAgB;GACtC,OAAO,QAAQ;GACf,iBAAiB,SAAS,kBAAkB,IAAI;GAChD,iBAAiB,OAAO;EAC1B;EAEA,oBAAoB;GAClB,UAAU,CAAC;GACX,iBAAiB,OAAO;EAC1B;EAEA;CACF;CACA,OAAO;AACT"}