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

package/esm/transport/flushController.mjs

@@ -0,0 +1,103 @@
+import { Observable } from "../tools/observable.mjs";
+import { clearTimeout, setTimeout } from "../tools/timer.mjs";
+import { RECOMMENDED_REQUEST_BYTES_LIMIT } from "./httpRequest.mjs";
+import { isWorkerEnvironment } from "@kubesense/kubesense-js-core/util";
+import { ONE_SECOND } from "@kubesense/kubesense-js-core/time";
+//#region src/transport/flushController.ts
+/**
+* flush automatically, aim to be lower than ALB connection timeout
+* to maximize connection reuse.
+*/
+const FLUSH_DURATION_LIMIT = 30 * ONE_SECOND;
+/**
+* When using the SDK in a Worker Environment, we limit the batch size to 1 to ensure it can be sent
+* in a single event.
+*/
+const MESSAGES_LIMIT = isWorkerEnvironment ? 1 : 50;
+/**
+* Returns a "flush controller", responsible of notifying when flushing a pool of pending data needs
+* to happen. The implementation is designed to support both synchronous and asynchronous usages,
+* but relies on invariants described in each method documentation to keep a coherent state.
+*/
+function createFlushController({ pageMayExitObservable }) {
+	let forcedFlushReason;
+	const prepareUrgentFlushObservable = new Observable();
+	const pageMayExitSubscription = pageMayExitObservable.subscribe((event) => {
+		forcedFlushReason = event.reason;
+		try {
+			prepareUrgentFlushObservable.notify(event.reason);
+		} finally {
+			forcedFlushReason = void 0;
+		}
+		flush(event.reason);
+	});
+	const flushObservable = new Observable(() => () => {
+		pageMayExitSubscription.unsubscribe();
+	});
+	let currentBytesCount = 0;
+	let currentMessagesCount = 0;
+	function flush(flushReason) {
+		if (currentMessagesCount === 0) return;
+		const messagesCount = currentMessagesCount;
+		const bytesCount = currentBytesCount;
+		currentMessagesCount = 0;
+		currentBytesCount = 0;
+		cancelDurationLimitTimeout();
+		flushObservable.notify({
+			reason: flushReason,
+			messagesCount,
+			bytesCount
+		});
+	}
+	let durationLimitTimeoutId;
+	function scheduleDurationLimitTimeout() {
+		if (durationLimitTimeoutId === void 0) durationLimitTimeoutId = setTimeout(() => {
+			flush("duration_limit");
+		}, FLUSH_DURATION_LIMIT);
+	}
+	function cancelDurationLimitTimeout() {
+		clearTimeout(durationLimitTimeoutId);
+		durationLimitTimeoutId = void 0;
+	}
+	return {
+		flushObservable,
+		prepareUrgentFlushObservable,
+		forceFlush: flush,
+		get messagesCount() {
+			return currentMessagesCount;
+		},
+		/**
+		* Notifies that a message will be added to a pool of pending messages waiting to be flushed.
+		*
+		* This function needs to be called synchronously, right before adding the message, so no flush
+		* event can happen after `notifyBeforeAddMessage` and before adding the message.
+		*
+		* @param estimatedMessageBytesCount - an estimation of the message bytes count once it is
+		* actually added.
+		*/
+		notifyBeforeAddMessage(estimatedMessageBytesCount) {
+			if (currentBytesCount + estimatedMessageBytesCount >= RECOMMENDED_REQUEST_BYTES_LIMIT) flush(forcedFlushReason ?? "bytes_limit");
+			currentMessagesCount += 1;
+			currentBytesCount += estimatedMessageBytesCount;
+			scheduleDurationLimitTimeout();
+		},
+		/**
+		* Notifies that a message *was* added to a pool of pending messages waiting to be flushed.
+		*
+		* This function can be called asynchronously after the message was added, but in this case it
+		* should not be called if a flush event occurred in between.
+		*
+		* @param messageBytesCountDiff - the difference between the estimated message bytes count and
+		* its actual bytes count once added to the pool.
+		*/
+		notifyAfterAddMessage(messageBytesCountDiff = 0) {
+			currentBytesCount += messageBytesCountDiff;
+			if (currentMessagesCount >= MESSAGES_LIMIT) flush(forcedFlushReason ?? "messages_limit");
+			else if (currentBytesCount >= RECOMMENDED_REQUEST_BYTES_LIMIT) flush(forcedFlushReason ?? "bytes_limit");
+		}
+	};
+}
+//#endregion
+export { FLUSH_DURATION_LIMIT, MESSAGES_LIMIT, createFlushController };
+
+//# sourceMappingURL=flushController.mjs.map

package/esm/transport/flushController.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"flushController.mjs","names":[],"sources":["../../src/transport/flushController.ts"],"sourcesContent":["import { ONE_SECOND } from '@kubesense/kubesense-js-core/time'\nimport type { Duration } from '@kubesense/kubesense-js-core/time'\nimport { isWorkerEnvironment } from '@kubesense/kubesense-js-core/util'\nimport type { PageMayExitEvent, PageExitReason } from '../browser/pageMayExitObservable'\nimport { Observable } from '../tools/observable'\nimport type { TimeoutId } from '../tools/timer'\nimport { clearTimeout, setTimeout } from '../tools/timer'\nimport { RECOMMENDED_REQUEST_BYTES_LIMIT } from './httpRequest'\n\nexport type UrgentFlushReason = PageExitReason\nexport type FlushReason = UrgentFlushReason | 'duration_limit' | 'bytes_limit' | 'messages_limit' | 'session_expire'\n\n/**\n * flush automatically, aim to be lower than ALB connection timeout\n * to maximize connection reuse.\n */\nexport const FLUSH_DURATION_LIMIT = (30 * ONE_SECOND) as Duration\n\n/**\n * When using the SDK in a Worker Environment, we limit the batch size to 1 to ensure it can be sent\n * in a single event.\n */\nexport const MESSAGES_LIMIT = isWorkerEnvironment ? 1 : 50\n\nexport type FlushController = ReturnType<typeof createFlushController>\nexport interface FlushEvent {\n  reason: FlushReason\n  bytesCount: number\n  messagesCount: number\n}\n\ninterface FlushControllerOptions {\n  pageMayExitObservable: Observable<PageMayExitEvent>\n}\n\n/**\n * Returns a \"flush controller\", responsible of notifying when flushing a pool of pending data needs\n * to happen. The implementation is designed to support both synchronous and asynchronous usages,\n * but relies on invariants described in each method documentation to keep a coherent state.\n */\nexport function createFlushController({ pageMayExitObservable }: FlushControllerOptions) {\n  let forcedFlushReason: FlushReason | undefined\n  const prepareUrgentFlushObservable = new Observable<UrgentFlushReason>()\n  const pageMayExitSubscription = pageMayExitObservable.subscribe((event) => {\n    forcedFlushReason = event.reason\n    try {\n      prepareUrgentFlushObservable.notify(event.reason)\n    } finally {\n      forcedFlushReason = undefined\n    }\n    flush(event.reason)\n  })\n\n  const flushObservable = new Observable<FlushEvent>(() => () => {\n    pageMayExitSubscription.unsubscribe()\n  })\n\n  let currentBytesCount = 0\n  let currentMessagesCount = 0\n\n  function flush(flushReason: FlushReason) {\n    if (currentMessagesCount === 0) {\n      return\n    }\n\n    const messagesCount = currentMessagesCount\n    const bytesCount = currentBytesCount\n\n    currentMessagesCount = 0\n    currentBytesCount = 0\n    cancelDurationLimitTimeout()\n\n    flushObservable.notify({\n      reason: flushReason,\n      messagesCount,\n      bytesCount,\n    })\n  }\n\n  let durationLimitTimeoutId: TimeoutId | undefined\n  function scheduleDurationLimitTimeout() {\n    if (durationLimitTimeoutId === undefined) {\n      durationLimitTimeoutId = setTimeout(() => {\n        flush('duration_limit')\n      }, FLUSH_DURATION_LIMIT)\n    }\n  }\n\n  function cancelDurationLimitTimeout() {\n    clearTimeout(durationLimitTimeoutId)\n    durationLimitTimeoutId = undefined\n  }\n\n  return {\n    flushObservable,\n    prepareUrgentFlushObservable,\n    forceFlush: flush,\n    get messagesCount() {\n      return currentMessagesCount\n    },\n\n    /**\n     * Notifies that a message will be added to a pool of pending messages waiting to be flushed.\n     *\n     * This function needs to be called synchronously, right before adding the message, so no flush\n     * event can happen after `notifyBeforeAddMessage` and before adding the message.\n     *\n     * @param estimatedMessageBytesCount - an estimation of the message bytes count once it is\n     * actually added.\n     */\n    notifyBeforeAddMessage(estimatedMessageBytesCount: number) {\n      if (currentBytesCount + estimatedMessageBytesCount >= RECOMMENDED_REQUEST_BYTES_LIMIT) {\n        flush(forcedFlushReason ?? 'bytes_limit')\n      }\n      // Consider the message to be added now rather than in `notifyAfterAddMessage`, because if no\n      // message was added yet and `notifyAfterAddMessage` is called asynchronously, we still want\n      // to notify when a flush is needed (for example on page exit).\n      currentMessagesCount += 1\n      currentBytesCount += estimatedMessageBytesCount\n      scheduleDurationLimitTimeout()\n    },\n\n    /**\n     * Notifies that a message *was* added to a pool of pending messages waiting to be flushed.\n     *\n     * This function can be called asynchronously after the message was added, but in this case it\n     * should not be called if a flush event occurred in between.\n     *\n     * @param messageBytesCountDiff - the difference between the estimated message bytes count and\n     * its actual bytes count once added to the pool.\n     */\n    notifyAfterAddMessage(messageBytesCountDiff = 0) {\n      currentBytesCount += messageBytesCountDiff\n\n      if (currentMessagesCount >= MESSAGES_LIMIT) {\n        flush(forcedFlushReason ?? 'messages_limit')\n      } else if (currentBytesCount >= RECOMMENDED_REQUEST_BYTES_LIMIT) {\n        flush(forcedFlushReason ?? 'bytes_limit')\n      }\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;AAgBA,MAAa,uBAAwB,KAAK;;;;;AAM1C,MAAa,iBAAiB,sBAAsB,IAAI;;;;;;AAkBxD,SAAgB,sBAAsB,EAAE,yBAAiD;CACvF,IAAI;CACJ,MAAM,+BAA+B,IAAI,WAA8B;CACvE,MAAM,0BAA0B,sBAAsB,WAAW,UAAU;EACzE,oBAAoB,MAAM;EAC1B,IAAI;GACF,6BAA6B,OAAO,MAAM,MAAM;EAClD,UAAU;GACR,oBAAoB,KAAA;EACtB;EACA,MAAM,MAAM,MAAM;CACpB,CAAC;CAED,MAAM,kBAAkB,IAAI,uBAAmC;EAC7D,wBAAwB,YAAY;CACtC,CAAC;CAED,IAAI,oBAAoB;CACxB,IAAI,uBAAuB;CAE3B,SAAS,MAAM,aAA0B;EACvC,IAAI,yBAAyB,GAC3B;EAGF,MAAM,gBAAgB;EACtB,MAAM,aAAa;EAEnB,uBAAuB;EACvB,oBAAoB;EACpB,2BAA2B;EAE3B,gBAAgB,OAAO;GACrB,QAAQ;GACR;GACA;EACF,CAAC;CACH;CAEA,IAAI;CACJ,SAAS,+BAA+B;EACtC,IAAI,2BAA2B,KAAA,GAC7B,yBAAyB,iBAAiB;GACxC,MAAM,gBAAgB;EACxB,GAAG,oBAAoB;CAE3B;CAEA,SAAS,6BAA6B;EACpC,aAAa,sBAAsB;EACnC,yBAAyB,KAAA;CAC3B;CAEA,OAAO;EACL;EACA;EACA,YAAY;EACZ,IAAI,gBAAgB;GAClB,OAAO;EACT;;;;;;;;;;EAWA,uBAAuB,4BAAoC;GACzD,IAAI,oBAAoB,8BAA8B,iCACpD,MAAM,qBAAqB,aAAa;GAK1C,wBAAwB;GACxB,qBAAqB;GACrB,6BAA6B;EAC/B;;;;;;;;;;EAWA,sBAAsB,wBAAwB,GAAG;GAC/C,qBAAqB;GAErB,IAAI,wBAAwB,gBAC1B,MAAM,qBAAqB,gBAAgB;QACtC,IAAI,qBAAqB,iCAC9B,MAAM,qBAAqB,aAAa;EAE5C;CACF;AACF"}

package/esm/transport/httpRequest.mjs

@@ -0,0 +1,69 @@
+import { Observable } from "../tools/observable.mjs";
+import { fetch } from "../browser/fetch.mjs";
+import { ONE_KIBI_BYTE } from "../tools/utils/byteUtils.mjs";
+import { newRetryState, sendWithRetryStrategy } from "./sendWithRetryStrategy.mjs";
+import { monitor, monitorError } from "@kubesense/kubesense-js-core/monitor";
+//#region src/transport/httpRequest.ts
+/**
+* beacon payload max queue size implementation is 64kb
+* ensure that we leave room for logs, rum and potential other users
+*/
+const RECOMMENDED_REQUEST_BYTES_LIMIT = 16 * ONE_KIBI_BYTE;
+function createHttpRequest(endpointBuilders, reportError, bytesLimit = RECOMMENDED_REQUEST_BYTES_LIMIT, networkErrorRetries = 0) {
+	const observable = new Observable();
+	const retryState = newRetryState(networkErrorRetries);
+	return {
+		observable,
+		send: (payload) => {
+			for (const endpointBuilder of endpointBuilders) sendWithRetryStrategy(payload, retryState, (payload, onResponse) => {
+				fetchStrategy(endpointBuilder, payload, onResponse);
+			}, endpointBuilder.trackType, reportError, observable);
+		},
+		/**
+		* Since fetch keepalive behaves like regular fetch on Firefox,
+		* keep using sendBeaconStrategy on exit
+		*/
+		sendOnExit: (payload) => {
+			for (const endpointBuilder of endpointBuilders) sendBeaconStrategy(endpointBuilder, bytesLimit, payload);
+		},
+		/**
+		* Drains any payloads queued for retry by sending them via sendBeacon.
+		* This prevents data loss when the page exits while events are pending retry.
+		*/
+		sendQueuedOnExit: () => {
+			let payload;
+			while ((payload = retryState.queuedPayloads.dequeue()) !== void 0) for (const endpointBuilder of endpointBuilders) sendBeaconStrategy(endpointBuilder, bytesLimit, payload);
+		}
+	};
+}
+function sendBeaconStrategy(endpointBuilder, bytesLimit, payload) {
+	if (payload.bytesCount < bytesLimit) try {
+		const beaconUrl = endpointBuilder.build("beacon", payload);
+		if (navigator.sendBeacon(beaconUrl, payload.data)) return;
+	} catch (e) {
+		reportBeaconError(e);
+	}
+	fetchStrategy(endpointBuilder, payload);
+}
+let hasReportedBeaconError = false;
+function reportBeaconError(e) {
+	if (!hasReportedBeaconError) {
+		hasReportedBeaconError = true;
+		monitorError(e);
+	}
+}
+function fetchStrategy(endpointBuilder, payload, onResponse) {
+	const fetchUrl = endpointBuilder.build("fetch", payload);
+	fetch(fetchUrl, {
+		method: "POST",
+		body: payload.data,
+		mode: "cors"
+	}).then(monitor((response) => onResponse?.({
+		status: response.status,
+		type: response.type
+	}))).catch(monitor(() => onResponse?.({ status: 0 })));
+}
+//#endregion
+export { RECOMMENDED_REQUEST_BYTES_LIMIT, createHttpRequest, fetchStrategy };
+
+//# sourceMappingURL=httpRequest.mjs.map

package/esm/transport/httpRequest.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpRequest.mjs","names":[],"sources":["../../src/transport/httpRequest.ts"],"sourcesContent":["import type { EndpointBuilder, TransportRetryInfo } from '@kubesense/kubesense-js-core/transport'\nimport { monitor, monitorError } from '@kubesense/kubesense-js-core/monitor'\nimport type { Context } from '../tools/serialisation/context'\nimport { fetch } from '../browser/fetch'\nimport { Observable } from '../tools/observable'\nimport { ONE_KIBI_BYTE } from '../tools/utils/byteUtils'\nimport { newRetryState, sendWithRetryStrategy } from './sendWithRetryStrategy'\n\n/**\n * beacon payload max queue size implementation is 64kb\n * ensure that we leave room for logs, rum and potential other users\n */\nexport const RECOMMENDED_REQUEST_BYTES_LIMIT = 16 * ONE_KIBI_BYTE\n\n/**\n * Use POST request without content type to:\n * - avoid CORS preflight requests\n * - allow usage of sendBeacon\n *\n * multiple elements are sent separated by \\n in order\n * to be parsed correctly without content type header\n */\n\nexport interface HttpRequest<Body extends Payload = Payload> {\n  observable: Observable<HttpRequestEvent<Body>>\n  send(this: void, payload: Body): void\n  sendOnExit(this: void, payload: Body): void\n  sendQueuedOnExit(this: void): void\n}\n\nexport interface HttpResponse extends Context {\n  status: number\n  type?: ResponseType\n}\n\nexport interface BandwidthStats {\n  ongoingByteCount: number\n  ongoingRequestCount: number\n}\n\nexport type HttpRequestEvent<Body extends Payload = Payload> =\n  | {\n      // A request to send the given payload failed. (We may retry.)\n      type: 'failure'\n      bandwidth: BandwidthStats\n      payload: Body\n    }\n  | {\n      // The given payload was discarded because the request queue is full.\n      type: 'queue-full'\n      bandwidth: BandwidthStats\n      payload: Body\n    }\n  | {\n      // A request to send the given payload succeeded.\n      type: 'success'\n      bandwidth: BandwidthStats\n      payload: Body\n    }\n  | {\n      // A request to send the given payload failed and will not be retried; the payload is gone.\n      // `status` is the last response's, 0 for a network error.\n      type: 'dropped'\n      bandwidth: BandwidthStats\n      payload: Body\n      status: number\n    }\n\nexport interface Payload {\n  data: string | FormData | Blob\n  bytesCount: number\n  retry?: TransportRetryInfo\n  encoding?: 'deflate'\n}\n\nexport function createHttpRequest<Body extends Payload = Payload>(\n  endpointBuilders: EndpointBuilder[],\n  reportError: (message: string) => void,\n  bytesLimit: number = RECOMMENDED_REQUEST_BYTES_LIMIT,\n  networkErrorRetries = 0\n): HttpRequest<Body> {\n  const observable = new Observable<HttpRequestEvent<Body>>()\n  const retryState = newRetryState<Body>(networkErrorRetries)\n\n  return {\n    observable,\n    send: (payload: Body) => {\n      for (const endpointBuilder of endpointBuilders) {\n        sendWithRetryStrategy(\n          payload,\n          retryState,\n          (payload, onResponse) => {\n            fetchStrategy(endpointBuilder, payload, onResponse)\n          },\n          endpointBuilder.trackType,\n          reportError,\n          observable\n        )\n      }\n    },\n    /**\n     * Since fetch keepalive behaves like regular fetch on Firefox,\n     * keep using sendBeaconStrategy on exit\n     */\n    sendOnExit: (payload: Body) => {\n      for (const endpointBuilder of endpointBuilders) {\n        sendBeaconStrategy(endpointBuilder, bytesLimit, payload)\n      }\n    },\n    /**\n     * Drains any payloads queued for retry by sending them via sendBeacon.\n     * This prevents data loss when the page exits while events are pending retry.\n     */\n    sendQueuedOnExit: () => {\n      let payload: Body | undefined\n      while ((payload = retryState.queuedPayloads.dequeue()) !== undefined) {\n        for (const endpointBuilder of endpointBuilders) {\n          sendBeaconStrategy(endpointBuilder, bytesLimit, payload)\n        }\n      }\n    },\n  }\n}\n\nfunction sendBeaconStrategy(endpointBuilder: EndpointBuilder, bytesLimit: number, payload: Payload) {\n  const canUseBeacon = payload.bytesCount < bytesLimit\n  if (canUseBeacon) {\n    try {\n      const beaconUrl = endpointBuilder.build('beacon', payload)\n      const isQueued = navigator.sendBeacon(beaconUrl, payload.data)\n\n      if (isQueued) {\n        return\n      }\n    } catch (e) {\n      reportBeaconError(e)\n    }\n  }\n\n  fetchStrategy(endpointBuilder, payload)\n}\n\nlet hasReportedBeaconError = false\n\nfunction reportBeaconError(e: unknown) {\n  if (!hasReportedBeaconError) {\n    hasReportedBeaconError = true\n    monitorError(e)\n  }\n}\n\nexport function fetchStrategy(\n  endpointBuilder: EndpointBuilder,\n  payload: Payload,\n  onResponse?: (r: HttpResponse) => void\n) {\n  const fetchUrl = endpointBuilder.build('fetch', payload)\n\n  fetch(fetchUrl, { method: 'POST', body: payload.data, mode: 'cors' })\n    .then(monitor((response: Response) => onResponse?.({ status: response.status, type: response.type })))\n    .catch(monitor(() => onResponse?.({ status: 0 })))\n}\n"],"mappings":";;;;;;;;;;AAYA,MAAa,kCAAkC,KAAK;AA+DpD,SAAgB,kBACd,kBACA,aACA,aAAqB,iCACrB,sBAAsB,GACH;CACnB,MAAM,aAAa,IAAI,WAAmC;CAC1D,MAAM,aAAa,cAAoB,mBAAmB;CAE1D,OAAO;EACL;EACA,OAAO,YAAkB;GACvB,KAAK,MAAM,mBAAmB,kBAC5B,sBACE,SACA,aACC,SAAS,eAAe;IACvB,cAAc,iBAAiB,SAAS,UAAU;GACpD,GACA,gBAAgB,WAChB,aACA,UACF;EAEJ;;;;;EAKA,aAAa,YAAkB;GAC7B,KAAK,MAAM,mBAAmB,kBAC5B,mBAAmB,iBAAiB,YAAY,OAAO;EAE3D;;;;;EAKA,wBAAwB;GACtB,IAAI;GACJ,QAAQ,UAAU,WAAW,eAAe,QAAQ,OAAO,KAAA,GACzD,KAAK,MAAM,mBAAmB,kBAC5B,mBAAmB,iBAAiB,YAAY,OAAO;EAG7D;CACF;AACF;AAEA,SAAS,mBAAmB,iBAAkC,YAAoB,SAAkB;CAElG,IADqB,QAAQ,aAAa,YAExC,IAAI;EACF,MAAM,YAAY,gBAAgB,MAAM,UAAU,OAAO;EAGzD,IAFiB,UAAU,WAAW,WAAW,QAAQ,IAE9C,GACT;CAEJ,SAAS,GAAG;EACV,kBAAkB,CAAC;CACrB;CAGF,cAAc,iBAAiB,OAAO;AACxC;AAEA,IAAI,yBAAyB;AAE7B,SAAS,kBAAkB,GAAY;CACrC,IAAI,CAAC,wBAAwB;EAC3B,yBAAyB;EACzB,aAAa,CAAC;CAChB;AACF;AAEA,SAAgB,cACd,iBACA,SACA,YACA;CACA,MAAM,WAAW,gBAAgB,MAAM,SAAS,OAAO;CAEvD,MAAM,UAAU;EAAE,QAAQ;EAAQ,MAAM,QAAQ;EAAM,MAAM;CAAO,CAAC,CAAC,CAClE,KAAK,SAAS,aAAuB,aAAa;EAAE,QAAQ,SAAS;EAAQ,MAAM,SAAS;CAAK,CAAC,CAAC,CAAC,CAAC,CACrG,MAAM,cAAc,aAAa,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC;AACrD"}

package/esm/transport/sendWithRetryStrategy.mjs

@@ -0,0 +1,154 @@
+import { setTimeout } from "../tools/timer.mjs";
+import { ONE_KIBI_BYTE, ONE_MEBI_BYTE } from "../tools/utils/byteUtils.mjs";
+import { isServerError } from "../tools/utils/responseUtils.mjs";
+import { ONE_MINUTE, ONE_SECOND } from "@kubesense/kubesense-js-core/time";
+//#region src/transport/sendWithRetryStrategy.ts
+const MAX_ONGOING_BYTES_COUNT = 80 * ONE_KIBI_BYTE;
+const MAX_QUEUE_BYTES_COUNT = 20 * ONE_MEBI_BYTE;
+const MAX_BACKOFF_TIME = ONE_MINUTE;
+const INITIAL_BACKOFF_TIME = ONE_SECOND;
+function sendWithRetryStrategy(payload, state, sendStrategy, trackType, reportError, requestObservable) {
+	if (state.transportStatus === 0 && state.queuedPayloads.size() === 0 && state.bandwidthMonitor.canHandle(payload)) send(payload, state, sendStrategy, requestObservable, {
+		onSuccess: () => retryQueuedPayloads(0, state, sendStrategy, trackType, reportError, requestObservable),
+		onFailure: () => {
+			if (!state.queuedPayloads.enqueue(payload)) requestObservable.notify({
+				type: "queue-full",
+				bandwidth: state.bandwidthMonitor.stats(),
+				payload
+			});
+			scheduleRetry(state, sendStrategy, trackType, reportError, requestObservable);
+		}
+	});
+	else if (!state.queuedPayloads.enqueue(payload)) requestObservable.notify({
+		type: "queue-full",
+		bandwidth: state.bandwidthMonitor.stats(),
+		payload
+	});
+}
+function scheduleRetry(state, sendStrategy, trackType, reportError, requestObservable) {
+	if (state.transportStatus !== 2) return;
+	setTimeout(() => {
+		send(state.queuedPayloads.first(), state, sendStrategy, requestObservable, {
+			onSuccess: () => {
+				state.queuedPayloads.dequeue();
+				state.currentBackoffTime = INITIAL_BACKOFF_TIME;
+				retryQueuedPayloads(1, state, sendStrategy, trackType, reportError, requestObservable);
+			},
+			onFailure: () => {
+				state.currentBackoffTime = Math.min(MAX_BACKOFF_TIME, state.currentBackoffTime * 2);
+				scheduleRetry(state, sendStrategy, trackType, reportError, requestObservable);
+			}
+		});
+	}, state.currentBackoffTime);
+}
+function send(payload, state, sendStrategy, requestObservable, { onSuccess, onFailure }) {
+	state.bandwidthMonitor.add(payload);
+	sendStrategy(payload, (response) => {
+		state.bandwidthMonitor.remove(payload);
+		if (!shouldRetryRequest(response, payload, state.networkErrorRetries)) {
+			state.transportStatus = 0;
+			requestObservable.notify(isDelivered(response) ? {
+				type: "success",
+				bandwidth: state.bandwidthMonitor.stats(),
+				payload
+			} : {
+				type: "dropped",
+				bandwidth: state.bandwidthMonitor.stats(),
+				payload,
+				status: response.status
+			});
+			onSuccess();
+		} else {
+			state.transportStatus = state.bandwidthMonitor.ongoingRequestCount > 0 ? 1 : 2;
+			payload.retry = {
+				count: payload.retry ? payload.retry.count + 1 : 1,
+				lastFailureStatus: response.status
+			};
+			requestObservable.notify({
+				type: "failure",
+				bandwidth: state.bandwidthMonitor.stats(),
+				payload
+			});
+			onFailure();
+		}
+	});
+}
+function retryQueuedPayloads(reason, state, sendStrategy, trackType, reportError, requestObservable) {
+	if (reason === 0 && state.queuedPayloads.isFull() && !state.queueFullReported) {
+		reportError(`Reached max ${trackType} events size queued for upload: ${MAX_QUEUE_BYTES_COUNT / ONE_MEBI_BYTE}MiB`);
+		state.queueFullReported = true;
+	}
+	const previousQueue = state.queuedPayloads;
+	state.queuedPayloads = newPayloadQueue();
+	while (previousQueue.size() > 0) sendWithRetryStrategy(previousQueue.dequeue(), state, sendStrategy, trackType, reportError, requestObservable);
+}
+function shouldRetryRequest(response, payload, networkErrorRetries) {
+	return response.type !== "opaque" && (response.status === 0 && (!navigator.onLine || (payload.retry?.count ?? 0) < networkErrorRetries) || response.status === 408 || response.status === 429 || isServerError(response.status));
+}
+/** An opaque response (a no-cors request) cannot be inspected, so it counts as delivered. */
+function isDelivered(response) {
+	return response.type === "opaque" || response.status >= 200 && response.status < 400;
+}
+function newRetryState(networkErrorRetries = 0) {
+	return {
+		transportStatus: 0,
+		currentBackoffTime: INITIAL_BACKOFF_TIME,
+		bandwidthMonitor: newBandwidthMonitor(),
+		queuedPayloads: newPayloadQueue(),
+		queueFullReported: false,
+		networkErrorRetries
+	};
+}
+function newPayloadQueue() {
+	const queue = [];
+	return {
+		bytesCount: 0,
+		enqueue(payload) {
+			if (this.isFull()) return false;
+			queue.push(payload);
+			this.bytesCount += payload.bytesCount;
+			return true;
+		},
+		first() {
+			return queue[0];
+		},
+		dequeue() {
+			const payload = queue.shift();
+			if (payload) this.bytesCount -= payload.bytesCount;
+			return payload;
+		},
+		size() {
+			return queue.length;
+		},
+		isFull() {
+			return this.bytesCount >= MAX_QUEUE_BYTES_COUNT;
+		}
+	};
+}
+function newBandwidthMonitor() {
+	return {
+		ongoingRequestCount: 0,
+		ongoingByteCount: 0,
+		canHandle(payload) {
+			return this.ongoingRequestCount === 0 || this.ongoingByteCount + payload.bytesCount <= MAX_ONGOING_BYTES_COUNT && this.ongoingRequestCount < 32;
+		},
+		add(payload) {
+			this.ongoingRequestCount += 1;
+			this.ongoingByteCount += payload.bytesCount;
+		},
+		remove(payload) {
+			this.ongoingRequestCount -= 1;
+			this.ongoingByteCount -= payload.bytesCount;
+		},
+		stats() {
+			return {
+				ongoingByteCount: this.ongoingByteCount,
+				ongoingRequestCount: this.ongoingRequestCount
+			};
+		}
+	};
+}
+//#endregion
+export { INITIAL_BACKOFF_TIME, MAX_BACKOFF_TIME, MAX_ONGOING_BYTES_COUNT, MAX_QUEUE_BYTES_COUNT, newRetryState, sendWithRetryStrategy };
+
+//# sourceMappingURL=sendWithRetryStrategy.mjs.map

package/esm/transport/sendWithRetryStrategy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sendWithRetryStrategy.mjs","names":[],"sources":["../../src/transport/sendWithRetryStrategy.ts"],"sourcesContent":["import { ONE_MINUTE, ONE_SECOND } from '@kubesense/kubesense-js-core/time'\nimport type { TrackType } from '@kubesense/kubesense-js-core/transport'\nimport { setTimeout } from '../tools/timer'\nimport { ONE_MEBI_BYTE, ONE_KIBI_BYTE } from '../tools/utils/byteUtils'\nimport { isServerError } from '../tools/utils/responseUtils'\nimport type { Observable } from '../tools/observable'\nimport type { Payload, HttpRequestEvent, HttpResponse, BandwidthStats } from './httpRequest'\n\nexport const MAX_ONGOING_BYTES_COUNT = 80 * ONE_KIBI_BYTE\nexport const MAX_ONGOING_REQUESTS = 32\nexport const MAX_QUEUE_BYTES_COUNT = 20 * ONE_MEBI_BYTE\nexport const MAX_BACKOFF_TIME = ONE_MINUTE\nexport const INITIAL_BACKOFF_TIME = ONE_SECOND\n\nconst enum TransportStatus {\n  UP,\n  FAILURE_DETECTED,\n  DOWN,\n}\n\nconst enum RetryReason {\n  AFTER_SUCCESS,\n  AFTER_RESUME,\n}\n\nexport interface RetryState<Body extends Payload> {\n  transportStatus: TransportStatus\n  currentBackoffTime: number\n  bandwidthMonitor: ReturnType<typeof newBandwidthMonitor>\n  queuedPayloads: ReturnType<typeof newPayloadQueue<Body>>\n  queueFullReported: boolean\n  /**\n   * How many times a payload is retried after a network error while the browser is online. 0 keeps\n   * such a payload from being retried at all: it is usually a blocked or CORS-rejected request that\n   * would fail forever.\n   */\n  networkErrorRetries: number\n}\n\ntype SendStrategy<Body extends Payload> = (payload: Body, onResponse: (r: HttpResponse) => void) => void\n\nexport function sendWithRetryStrategy<Body extends Payload>(\n  payload: Body,\n  state: RetryState<Body>,\n  sendStrategy: SendStrategy<Body>,\n  trackType: TrackType,\n  reportError: (message: string) => void,\n  requestObservable: Observable<HttpRequestEvent<Body>>\n) {\n  if (\n    state.transportStatus === TransportStatus.UP &&\n    state.queuedPayloads.size() === 0 &&\n    state.bandwidthMonitor.canHandle(payload)\n  ) {\n    send(payload, state, sendStrategy, requestObservable, {\n      onSuccess: () =>\n        retryQueuedPayloads(RetryReason.AFTER_SUCCESS, state, sendStrategy, trackType, reportError, requestObservable),\n      onFailure: () => {\n        if (!state.queuedPayloads.enqueue(payload)) {\n          requestObservable.notify({ type: 'queue-full', bandwidth: state.bandwidthMonitor.stats(), payload })\n        }\n        scheduleRetry(state, sendStrategy, trackType, reportError, requestObservable)\n      },\n    })\n  } else {\n    if (!state.queuedPayloads.enqueue(payload)) {\n      requestObservable.notify({ type: 'queue-full', bandwidth: state.bandwidthMonitor.stats(), payload })\n    }\n  }\n}\n\nfunction scheduleRetry<Body extends Payload>(\n  state: RetryState<Body>,\n  sendStrategy: SendStrategy<Body>,\n  trackType: TrackType,\n  reportError: (message: string) => void,\n  requestObservable: Observable<HttpRequestEvent<Body>>\n) {\n  if (state.transportStatus !== TransportStatus.DOWN) {\n    return\n  }\n  setTimeout(() => {\n    const payload = state.queuedPayloads.first()\n    send(payload, state, sendStrategy, requestObservable, {\n      onSuccess: () => {\n        state.queuedPayloads.dequeue()\n        state.currentBackoffTime = INITIAL_BACKOFF_TIME\n        retryQueuedPayloads(RetryReason.AFTER_RESUME, state, sendStrategy, trackType, reportError, requestObservable)\n      },\n      onFailure: () => {\n        state.currentBackoffTime = Math.min(MAX_BACKOFF_TIME, state.currentBackoffTime * 2)\n        scheduleRetry(state, sendStrategy, trackType, reportError, requestObservable)\n      },\n    })\n  }, state.currentBackoffTime)\n}\n\nfunction send<Body extends Payload>(\n  payload: Body,\n  state: RetryState<Body>,\n  sendStrategy: SendStrategy<Body>,\n  requestObservable: Observable<HttpRequestEvent<Body>>,\n  { onSuccess, onFailure }: { onSuccess: () => void; onFailure: () => void }\n) {\n  state.bandwidthMonitor.add(payload)\n  sendStrategy(payload, (response) => {\n    state.bandwidthMonitor.remove(payload)\n    if (!shouldRetryRequest(response, payload, state.networkErrorRetries)) {\n      state.transportStatus = TransportStatus.UP\n      // A failure that is not retried still unblocks the queue, but the payload is gone: say so,\n      // rather than reporting it delivered.\n      requestObservable.notify(\n        isDelivered(response)\n          ? { type: 'success', bandwidth: state.bandwidthMonitor.stats(), payload }\n          : { type: 'dropped', bandwidth: state.bandwidthMonitor.stats(), payload, status: response.status }\n      )\n      onSuccess()\n    } else {\n      // do not consider transport down if another ongoing request could succeed\n      state.transportStatus =\n        state.bandwidthMonitor.ongoingRequestCount > 0 ? TransportStatus.FAILURE_DETECTED : TransportStatus.DOWN\n      payload.retry = {\n        count: payload.retry ? payload.retry.count + 1 : 1,\n        lastFailureStatus: response.status,\n      }\n      requestObservable.notify({ type: 'failure', bandwidth: state.bandwidthMonitor.stats(), payload })\n      onFailure()\n    }\n  })\n}\n\nfunction retryQueuedPayloads<Body extends Payload>(\n  reason: RetryReason,\n  state: RetryState<Body>,\n  sendStrategy: SendStrategy<Body>,\n  trackType: TrackType,\n  reportError: (message: string) => void,\n  requestObservable: Observable<HttpRequestEvent<Body>>\n) {\n  if (reason === RetryReason.AFTER_SUCCESS && state.queuedPayloads.isFull() && !state.queueFullReported) {\n    reportError(`Reached max ${trackType} events size queued for upload: ${MAX_QUEUE_BYTES_COUNT / ONE_MEBI_BYTE}MiB`)\n    state.queueFullReported = true\n  }\n  const previousQueue = state.queuedPayloads\n  state.queuedPayloads = newPayloadQueue()\n  while (previousQueue.size() > 0) {\n    sendWithRetryStrategy(previousQueue.dequeue()!, state, sendStrategy, trackType, reportError, requestObservable)\n  }\n}\n\nfunction shouldRetryRequest(response: HttpResponse, payload: Payload, networkErrorRetries: number) {\n  return (\n    response.type !== 'opaque' &&\n    ((response.status === 0 && (!navigator.onLine || (payload.retry?.count ?? 0) < networkErrorRetries)) ||\n      response.status === 408 ||\n      response.status === 429 ||\n      isServerError(response.status))\n  )\n}\n\n/** An opaque response (a no-cors request) cannot be inspected, so it counts as delivered. */\nfunction isDelivered(response: HttpResponse) {\n  return response.type === 'opaque' || (response.status >= 200 && response.status < 400)\n}\n\nexport function newRetryState<Body extends Payload>(networkErrorRetries = 0): RetryState<Body> {\n  return {\n    transportStatus: TransportStatus.UP,\n    currentBackoffTime: INITIAL_BACKOFF_TIME,\n    bandwidthMonitor: newBandwidthMonitor(),\n    queuedPayloads: newPayloadQueue(),\n    queueFullReported: false,\n    networkErrorRetries,\n  }\n}\n\nfunction newPayloadQueue<Body extends Payload>() {\n  const queue: Body[] = []\n  return {\n    bytesCount: 0,\n    enqueue(payload: Body) {\n      if (this.isFull()) {\n        return false\n      }\n      queue.push(payload)\n      this.bytesCount += payload.bytesCount\n      return true\n    },\n    first() {\n      return queue[0]\n    },\n    dequeue() {\n      const payload = queue.shift()\n      if (payload) {\n        this.bytesCount -= payload.bytesCount\n      }\n      return payload\n    },\n    size() {\n      return queue.length\n    },\n    isFull() {\n      return this.bytesCount >= MAX_QUEUE_BYTES_COUNT\n    },\n  }\n}\n\nfunction newBandwidthMonitor() {\n  return {\n    ongoingRequestCount: 0,\n    ongoingByteCount: 0,\n    canHandle(payload: Payload) {\n      return (\n        this.ongoingRequestCount === 0 ||\n        (this.ongoingByteCount + payload.bytesCount <= MAX_ONGOING_BYTES_COUNT &&\n          this.ongoingRequestCount < MAX_ONGOING_REQUESTS)\n      )\n    },\n    add(payload: Payload) {\n      this.ongoingRequestCount += 1\n      this.ongoingByteCount += payload.bytesCount\n    },\n    remove(payload: Payload) {\n      this.ongoingRequestCount -= 1\n      this.ongoingByteCount -= payload.bytesCount\n    },\n    stats(): BandwidthStats {\n      return {\n        ongoingByteCount: this.ongoingByteCount,\n        ongoingRequestCount: this.ongoingRequestCount,\n      }\n    },\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,8 +1,6 @@
 {
   "name": "@kubesense/kubesense-browser-core",
-  "version": "1.7.0",
-  "description": "Core utilities shared across the Kubesense Browser SDK (session management, transport, configuration, and context).",
-  "license": "Apache-2.0",
+  "version": "2.0.0-beta.0",
   "keywords": [
     "kubesense",
     "browser",
@@ -13,27 +11,38 @@
     "rum",
     "core"
   ],
+  "description": "Core utilities shared across the Kubesense Browser SDK (session management, transport, configuration, and context).",
+  "license": "Apache-2.0",
   "main": "cjs/index.js",
-  "module": "esm/index.js",
+  "module": "esm/index.mjs",
   "types": "cjs/index.d.ts",
   "sideEffects": false,
+  "files": [
+    "cjs",
+    "esm",
+    "src",
+    "!src/**/*.spec.ts",
+    "!src/**/*.specHelper.ts"
+  ],
   "scripts": {
-    "build": "node ../../scripts/build/build-package.ts --modules"
+    "build": "node ../../scripts/build/build-package.ts --modules",
+    "prepack": "yarn build"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/kubesense-ai/kubesense-browser-sdk.git",
+    "url": "git+https://github.com/kubesense-ai/kubesense-browser-sdk.git",
     "directory": "packages/core"
   },
+  "dependencies": {
+    "@kubesense/kubesense-js-core": "2.0.0-beta.0"
+  },
   "devDependencies": {
-    "@types/pako": "2.0.4",
-    "pako": "2.1.0"
+    "pako": "3.0.1"
   },
   "volta": {
     "extends": "../../package.json"
   },
   "publishConfig": {
     "access": "public"
-  },
-  "gitHead": "4fbd31e2193c63405fc075f032f4d0d6a16c1baf"
-}
+  }
+}

package/src/boot/displayAlreadyInitializedError.ts

@@ -1,7 +1,10 @@
 import type { InitConfiguration } from '../domain/configuration'
 import { display } from '../tools/display'
 
-export function displayAlreadyInitializedError(sdkName: 'KUBESENSE_SDK' | 'KUBESENSE_LOGS', initConfiguration: InitConfiguration) {
+export function displayAlreadyInitializedError(
+  sdkName: 'KUBESENSE_SDK' | 'KUBESENSE_LOGS',
+  initConfiguration: InitConfiguration
+) {
   if (!initConfiguration.silentMultipleInit) {
     display.error(`${sdkName} is already initialized.`)
   }

package/src/boot/init.ts

@@ -1,5 +1,5 @@
+import { setDebugMode } from '@kubesense/kubesense-js-core/util'
 import { catchUserErrors } from '../tools/catchUserErrors'
-import { setDebugMode } from '../tools/monitor'
 import { display } from '../tools/display'
 
 // replaced at build time
@@ -14,6 +14,7 @@ export interface PublicApi {
   /**
    * For CDN async setup: Early RUM API calls must be wrapped in the `window.KUBESENSE_SDK.onReady()` callback. This ensures the code only gets executed once the SDK is properly loaded.
    *
+   * See [CDN async setup](https://docs.kubesense.ai/real_user_monitoring/browser/#cdn-async) for further information.
    */
   onReady: (callback: () => void) => void
 }
@@ -48,7 +49,7 @@ export function defineGlobal<Global, Name extends keyof Global>(global: Global,
     display.warn('SDK is loaded more than once. This is unsupported and might have unexpected behavior.')
   }
   global[name] = api
-  if (existingGlobalVariable && existingGlobalVariable.q) {
+  if (existingGlobalVariable?.q) {
     existingGlobalVariable.q.forEach((fn) => catchUserErrors(fn, 'onReady callback threw an error:')())
   }
 }

package/src/browser/addEventListener.ts

@@ -1,6 +1,8 @@
-import { monitor } from '../tools/monitor'
+import type { CookieStore, CookieStoreEventMap } from '@kubesense/kubesense-js-core/util'
+import { monitor } from '@kubesense/kubesense-js-core/monitor'
 import { getZoneJsOriginalValue } from '../tools/getZoneJsOriginalValue'
-import type { CookieStore, CookieStoreEventMap, VisualViewport, VisualViewportEventMap } from './browser.types'
+import { noop } from '../tools/utils/functionUtils'
+import type { VisualViewport, VisualViewportEventMap } from './browser.types'
 
 export type TrustableEvent<E extends Event = Event> = E & { __kubesenseIsTrusted?: boolean }
 
@@ -39,6 +41,7 @@ export const enum DOM_EVENT {
   SECURITY_POLICY_VIOLATION = 'securitypolicyviolation',
   SELECTION_CHANGE = 'selectionchange',
   STORAGE = 'storage',
+  UNHANDLED_REJECTION = 'unhandledrejection',
 }
 
 interface AddEventListenerOptions {
@@ -56,7 +59,10 @@ type EventMapFor<T> = T extends Window
       visibilitychange: Event
     }
   : T extends Document
-    ? DocumentEventMap
+    ? DocumentEventMap & {
+        // TS 4.9.5 does not define `prerenderingchange` on Document yet (Speculation Rules / Prerender2)
+        prerenderingchange: Event
+      }
     : T extends HTMLElement
       ? HTMLElementEventMap
       : T extends VisualViewport
@@ -74,7 +80,9 @@ type EventMapFor<T> = T extends Window
                 ? WorkerEventMap
                 : T extends CookieStore
                   ? CookieStoreEventMap
-                  : Record<never, never>
+                  : T extends WebSocket
+                    ? WebSocketEventMap
+                    : Record<never, never>
 
 /**
  * Add an event listener to an event target object (Window, Element, mock object...).  This provides
@@ -87,13 +95,12 @@ type EventMapFor<T> = T extends Window
  * * returns a `stop` function to remove the listener
  */
 export function addEventListener<Target extends EventTarget, EventName extends keyof EventMapFor<Target> & string>(
-  configuration: { allowUntrustedEvents?: boolean | undefined },
   eventTarget: Target,
   eventName: EventName,
   listener: (event: EventMapFor<Target>[EventName] & { type: EventName }) => void,
   options?: AddEventListenerOptions
 ) {
-  return addEventListeners(configuration, eventTarget, [eventName], listener, options)
+  return addEventListeners(eventTarget, [eventName], listener, options)
 }
 
 /**
@@ -109,14 +116,13 @@ export function addEventListener<Target extends EventTarget, EventName extends k
  * * with `once: true`, the listener will be called at most once, even if different events are listened
  */
 export function addEventListeners<Target extends EventTarget, EventName extends keyof EventMapFor<Target> & string>(
-  configuration: { allowUntrustedEvents?: boolean | undefined },
   eventTarget: Target,
   eventNames: EventName[],
   listener: (event: EventMapFor<Target>[EventName] & { type: EventName }) => void,
   { once, capture, passive }: AddEventListenerOptions = {}
 ) {
   const listenerWithMonitor = monitor((event: TrustableEvent) => {
-    if (!event.isTrusted && !event.__kubesenseIsTrusted && !configuration.allowUntrustedEvents) {
+    if (!event.isTrusted && !event.__kubesenseIsTrusted && allowUntrustedEventsFromConfiguration === false) {
       return
     }
     if (once) {
@@ -143,3 +149,32 @@ export function addEventListeners<Target extends EventTarget, EventName extends
     stop,
   }
 }
+
+export function isEventSupported<Target extends EventTarget, EventName extends keyof EventMapFor<Target> & string>(
+  eventTarget: Target | undefined,
+  eventName: EventName
+) {
+  if (!eventTarget) {
+    return false
+  }
+
+  try {
+    addEventListener(eventTarget, eventName, noop).stop()
+    return true
+  } catch {
+    return false
+  }
+}
+
+let allowUntrustedEventsFromConfiguration: boolean | undefined
+
+export function setAllowUntrustedEvents(value: boolean | undefined) {
+  if (allowUntrustedEventsFromConfiguration === true) {
+    return // keep the laxer value (true)
+  }
+  allowUntrustedEventsFromConfiguration = value ?? false
+}
+
+export function resetAllowUntrustedEvents() {
+  allowUntrustedEventsFromConfiguration = undefined
+}

package/src/browser/browser.types.ts

@@ -50,35 +50,3 @@ export interface WeakRefConstructor {
 
   new <T extends object>(target: T): WeakRef<T>
 }
-
-// Those are native API types that are not official supported by TypeScript yet
-
-export interface CookieStore extends EventTarget {
-  get(name: string): Promise<unknown>
-  getAll(name?: string): Promise<
-    Array<{
-      name: string
-      value: string
-      domain?: string
-      path?: string
-      expires?: number
-      secure?: boolean
-      sameSite?: 'strict' | 'lax' | 'none'
-      partitioned?: boolean
-    }>
-  >
-}
-
-export interface CookieStoreEventMap {
-  change: CookieChangeEvent
-}
-
-export interface CookieChangeItem {
-  name: string
-  value: string | undefined
-}
-
-export type CookieChangeEvent = Event & {
-  changed: CookieChangeItem[]
-  deleted: CookieChangeItem[]
-}