@kubesense/kubesense-browser-rum 1.8.0 → 2.0.0-beta.1

package/esm/domain/record/internalApi.mjs

@@ -0,0 +1,62 @@
+import { createRootInsertionCursor } from "./serialization/insertionCursor.mjs";
+import { serializeInTransaction } from "./serialization/serializationTransaction.mjs";
+import { createCanvasManager } from "./canvas/canvasManager.mjs";
+import { serializeNode } from "./serialization/serializeNode.mjs";
+import "./serialization/index.mjs";
+import { takeFullSnapshot as takeFullSnapshot$1 } from "./startFullSnapshots.mjs";
+import { createRecordingScope } from "./recordingScope.mjs";
+import { createElementsScrollPositions } from "./elementsScrollPositions.mjs";
+import { NodePrivacyLevel, getNodePrivacyLevel } from "@kubesense/kubesense-browser-rum-core";
+import { noop } from "@kubesense/kubesense-browser-core";
+import { timeStampNow } from "@kubesense/kubesense-js-core/time";
+//#region src/domain/record/internalApi.ts
+/**
+* Take a full snapshot of the document, generating the same records that the browser SDK
+* would generate.
+*
+* This is an internal API function. Be sure to update KubeSense-internal callers if you
+* change its signature or behavior.
+*/
+function takeFullSnapshot({ configuration } = {}) {
+	const records = [];
+	const emitRecord = (record) => {
+		records.push(record);
+	};
+	takeFullSnapshot$1(timeStampNow(), 0, emitRecord, noop, createTemporaryRecordingScope(configuration));
+	return records;
+}
+/**
+* Take a snapshot of a DOM node, generating the serialized representation that the
+* browser SDK would generate.
+*
+* This is an internal API function. Be sure to update KubeSense-internal callers if you
+* change its signature or behavior.
+*/
+function takeNodeSnapshot(node, { configuration } = {}) {
+	let nodeSnapshotRecord;
+	const emitRecord = (record) => {
+		nodeSnapshotRecord = record;
+	};
+	serializeInTransaction(0, emitRecord, noop, createTemporaryRecordingScope(configuration), timeStampNow(), (transaction) => {
+		const privacyLevel = getNodePrivacyLevel(node, transaction.scope.configuration.defaultPrivacyLevel);
+		if (privacyLevel === NodePrivacyLevel.HIDDEN || privacyLevel === NodePrivacyLevel.IGNORE) return;
+		const cursor = createRootInsertionCursor(transaction.scope.nodeIds);
+		serializeNode(cursor, node, privacyLevel, transaction);
+	});
+	return nodeSnapshotRecord;
+}
+function createTemporaryRecordingScope(configuration) {
+	return createRecordingScope(createCanvasManager(), {
+		defaultPrivacyLevel: NodePrivacyLevel.ALLOW,
+		...configuration
+	}, createElementsScrollPositions(), {
+		addShadowRoot: noop,
+		removeShadowRoot: noop,
+		flush: noop,
+		stop: noop
+	});
+}
+//#endregion
+export { takeFullSnapshot, takeNodeSnapshot };
+
+//# sourceMappingURL=internalApi.mjs.map

package/esm/domain/record/internalApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalApi.mjs","names":[],"sources":["../../../src/domain/record/internalApi.ts"],"sourcesContent":["import { noop } from '@kubesense/kubesense-browser-core'\nimport { timeStampNow } from '@kubesense/kubesense-js-core/time'\nimport type { RumConfiguration } from '@kubesense/kubesense-browser-rum-core'\nimport { getNodePrivacyLevel, NodePrivacyLevel } from '@kubesense/kubesense-browser-rum-core'\nimport type { BrowserRecord } from '../../types'\nimport { takeFullSnapshot as doTakeFullSnapshot } from './startFullSnapshots'\nimport type { RecordingScope } from './recordingScope'\nimport { createRecordingScope } from './recordingScope'\nimport { createElementsScrollPositions } from './elementsScrollPositions'\nimport type { EmitRecordCallback } from './record.types'\nimport type { SerializationTransaction } from './serialization'\nimport { createRootInsertionCursor, SerializationKind, serializeInTransaction, serializeNode } from './serialization'\nimport { createCanvasManager } from './canvas/canvasManager'\n\n/**\n * Take a full snapshot of the document, generating the same records that the browser SDK\n * would generate.\n *\n * This is an internal API function. Be sure to update KubeSense-internal callers if you\n * change its signature or behavior.\n */\nexport function takeFullSnapshot({\n  configuration,\n}: { configuration?: Partial<RumConfiguration> } = {}): BrowserRecord[] {\n  const records: BrowserRecord[] = []\n  const emitRecord: EmitRecordCallback = (record: BrowserRecord) => {\n    records.push(record)\n  }\n\n  doTakeFullSnapshot(\n    timeStampNow(),\n    SerializationKind.INITIAL_FULL_SNAPSHOT,\n    emitRecord,\n    noop,\n    createTemporaryRecordingScope(configuration)\n  )\n\n  return records\n}\n\n/**\n * Take a snapshot of a DOM node, generating the serialized representation that the\n * browser SDK would generate.\n *\n * This is an internal API function. Be sure to update KubeSense-internal callers if you\n * change its signature or behavior.\n */\nexport function takeNodeSnapshot(\n  node: Node,\n  { configuration }: { configuration?: Partial<RumConfiguration> } = {}\n): BrowserRecord | undefined {\n  let nodeSnapshotRecord: BrowserRecord | undefined\n  const emitRecord = (record: BrowserRecord) => {\n    nodeSnapshotRecord = record\n  }\n\n  serializeInTransaction(\n    SerializationKind.INITIAL_FULL_SNAPSHOT,\n    emitRecord,\n    noop,\n    createTemporaryRecordingScope(configuration),\n    timeStampNow(),\n    (transaction: SerializationTransaction): void => {\n      const privacyLevel = getNodePrivacyLevel(node, transaction.scope.configuration.defaultPrivacyLevel)\n      if (privacyLevel === NodePrivacyLevel.HIDDEN || privacyLevel === NodePrivacyLevel.IGNORE) {\n        return\n      }\n      const cursor = createRootInsertionCursor(transaction.scope.nodeIds)\n      serializeNode(cursor, node, privacyLevel, transaction)\n    }\n  )\n\n  return nodeSnapshotRecord\n}\n\nfunction createTemporaryRecordingScope(configuration?: Partial<RumConfiguration>): RecordingScope {\n  return createRecordingScope(\n    createCanvasManager(),\n    {\n      defaultPrivacyLevel: NodePrivacyLevel.ALLOW,\n      ...configuration,\n    } as RumConfiguration,\n    createElementsScrollPositions(),\n    {\n      addShadowRoot: noop,\n      removeShadowRoot: noop,\n      flush: noop,\n      stop: noop,\n    }\n  )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,iBAAiB,EAC/B,kBACiD,CAAC,GAAoB;CACtE,MAAM,UAA2B,CAAC;CAClC,MAAM,cAAkC,WAA0B;EAChE,QAAQ,KAAK,MAAM;CACrB;CAEA,mBACE,aAAa,GAAA,GAEb,YACA,MACA,8BAA8B,aAAa,CAC7C;CAEA,OAAO;AACT;;;;;;;;AASA,SAAgB,iBACd,MACA,EAAE,kBAAiE,CAAC,GACzC;CAC3B,IAAI;CACJ,MAAM,cAAc,WAA0B;EAC5C,qBAAqB;CACvB;CAEA,uBAAA,GAEE,YACA,MACA,8BAA8B,aAAa,GAC3C,aAAa,IACZ,gBAAgD;EAC/C,MAAM,eAAe,oBAAoB,MAAM,YAAY,MAAM,cAAc,mBAAmB;EAClG,IAAI,iBAAiB,iBAAiB,UAAU,iBAAiB,iBAAiB,QAChF;EAEF,MAAM,SAAS,0BAA0B,YAAY,MAAM,OAAO;EAClE,cAAc,QAAQ,MAAM,cAAc,WAAW;CACvD,CACF;CAEA,OAAO;AACT;AAEA,SAAS,8BAA8B,eAA2D;CAChG,OAAO,qBACL,oBAAoB,GACpB;EACE,qBAAqB,iBAAiB;EACtC,GAAG;CACL,GACA,8BAA8B,GAC9B;EACE,eAAe;EACf,kBAAkB;EAClB,OAAO;EACP,MAAM;CACR,CACF;AACF"}

package/esm/domain/record/mutationBatch.mjs

@@ -0,0 +1,43 @@
+import { noop, requestIdleCallback, throttle } from "@kubesense/kubesense-browser-core";
+//#region src/domain/record/mutationBatch.ts
+/**
+* Maximum duration to wait before processing mutations. If the browser is idle, mutations will be
+* processed more quickly. If the browser is busy executing small tasks (ex: rendering frames), the
+* mutations will wait MUTATION_PROCESS_MAX_DELAY milliseconds before being processed. If the
+* browser is busy executing a longer task, mutations will be processed after this task.
+*/
+const MUTATION_PROCESS_MAX_DELAY = 100;
+function createMutationBatch(processMutationBatch) {
+	let cancelScheduledFlush = noop;
+	let pendingMutations = [];
+	let flushScheduled = false;
+	function scheduleFlush() {
+		if (!flushScheduled) {
+			flushScheduled = true;
+			cancelScheduledFlush = requestIdleCallback(throttledFlush, { timeout: MUTATION_PROCESS_MAX_DELAY });
+		}
+	}
+	function flush() {
+		cancelScheduledFlush();
+		flushScheduled = false;
+		processMutationBatch(pendingMutations);
+		pendingMutations = [];
+	}
+	const { throttled: throttledFlush, cancel: cancelThrottle } = throttle(flush, 16, { leading: false });
+	return {
+		addMutations: (mutations) => {
+			scheduleFlush();
+			for (const mutation of mutations) pendingMutations.push(mutation);
+		},
+		notifyContentMutated: scheduleFlush,
+		flush,
+		stop: () => {
+			cancelScheduledFlush();
+			cancelThrottle();
+		}
+	};
+}
+//#endregion
+export { createMutationBatch };
+
+//# sourceMappingURL=mutationBatch.mjs.map

package/esm/domain/record/mutationBatch.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutationBatch.mjs","names":[],"sources":["../../../src/domain/record/mutationBatch.ts"],"sourcesContent":["import { noop, throttle, requestIdleCallback } from '@kubesense/kubesense-browser-core'\nimport type { RumMutationRecord } from '@kubesense/kubesense-browser-rum-core'\n\n/**\n * Maximum duration to wait before processing mutations. If the browser is idle, mutations will be\n * processed more quickly. If the browser is busy executing small tasks (ex: rendering frames), the\n * mutations will wait MUTATION_PROCESS_MAX_DELAY milliseconds before being processed. If the\n * browser is busy executing a longer task, mutations will be processed after this task.\n */\nconst MUTATION_PROCESS_MAX_DELAY = 100\n/**\n * Minimum duration to wait before processing mutations. This is used to batch mutations together\n * and be able to deduplicate them to save processing time and bandwidth.\n * 16ms is the duration of a frame at 60fps that ensure fluid UI.\n */\nexport const MUTATION_PROCESS_MIN_DELAY = 16\n\nexport function createMutationBatch(processMutationBatch: (mutations: RumMutationRecord[]) => void) {\n  let cancelScheduledFlush = noop\n  let pendingMutations: RumMutationRecord[] = []\n  let flushScheduled = false\n\n  function scheduleFlush() {\n    if (!flushScheduled) {\n      flushScheduled = true\n      cancelScheduledFlush = requestIdleCallback(throttledFlush, { timeout: MUTATION_PROCESS_MAX_DELAY })\n    }\n  }\n\n  function flush() {\n    cancelScheduledFlush()\n    flushScheduled = false\n    processMutationBatch(pendingMutations)\n    pendingMutations = []\n  }\n\n  const { throttled: throttledFlush, cancel: cancelThrottle } = throttle(flush, MUTATION_PROCESS_MIN_DELAY, {\n    leading: false,\n  })\n\n  return {\n    addMutations: (mutations: RumMutationRecord[]) => {\n      scheduleFlush()\n      for (const mutation of mutations) {\n        pendingMutations.push(mutation)\n      }\n    },\n\n    notifyContentMutated: scheduleFlush,\n\n    flush,\n\n    stop: () => {\n      cancelScheduledFlush()\n      cancelThrottle()\n    },\n  }\n}\n"],"mappings":";;;;;;;;AASA,MAAM,6BAA6B;AAQnC,SAAgB,oBAAoB,sBAAgE;CAClG,IAAI,uBAAuB;CAC3B,IAAI,mBAAwC,CAAC;CAC7C,IAAI,iBAAiB;CAErB,SAAS,gBAAgB;EACvB,IAAI,CAAC,gBAAgB;GACnB,iBAAiB;GACjB,uBAAuB,oBAAoB,gBAAgB,EAAE,SAAS,2BAA2B,CAAC;EACpG;CACF;CAEA,SAAS,QAAQ;EACf,qBAAqB;EACrB,iBAAiB;EACjB,qBAAqB,gBAAgB;EACrC,mBAAmB,CAAC;CACtB;CAEA,MAAM,EAAE,WAAW,gBAAgB,QAAQ,mBAAmB,SAAS,OAAA,IAAmC,EACxG,SAAS,MACX,CAAC;CAED,OAAO;EACL,eAAe,cAAmC;GAChD,cAAc;GACd,KAAK,MAAM,YAAY,WACrB,iBAAiB,KAAK,QAAQ;EAElC;EAEA,sBAAsB;EAEtB;EAEA,YAAY;GACV,qBAAqB;GACrB,eAAe;EACjB;CACF;AACF"}

package/esm/domain/record/record.mjs

@@ -0,0 +1,79 @@
+import { createCanvasManager } from "./canvas/canvasManager.mjs";
+import "./serialization/index.mjs";
+import { startFullSnapshots, takeFullSnapshot } from "./startFullSnapshots.mjs";
+import { createRecordingScope } from "./recordingScope.mjs";
+import { createElementsScrollPositions } from "./elementsScrollPositions.mjs";
+import { addRecord, addResource } from "../replayStats.mjs";
+import { trackMove } from "./trackers/trackMove.mjs";
+import { trackMouseInteraction } from "./trackers/trackMouseInteraction.mjs";
+import { trackScroll } from "./trackers/trackScroll.mjs";
+import { trackViewportResize, trackVisualViewportResize } from "./trackers/trackViewportResize.mjs";
+import { trackMediaInteraction } from "./trackers/trackMediaInteraction.mjs";
+import { trackStyleSheet } from "./trackers/trackStyleSheet.mjs";
+import { trackFocus } from "./trackers/trackFocus.mjs";
+import { trackViewEnd } from "./trackers/trackViewEnd.mjs";
+import { trackInput } from "./trackers/trackInput.mjs";
+import { trackMutation } from "./trackers/trackMutation.mjs";
+import { trackCanvasContent } from "./trackers/trackCanvasContent.mjs";
+import { trackCanvasCapture } from "./trackers/trackCanvasCapture.mjs";
+import "./trackers/index.mjs";
+import { initShadowRootsController } from "./shadowRootsController.mjs";
+import { sendToExtension } from "@kubesense/kubesense-browser-core";
+import { timeStampNow } from "@kubesense/kubesense-js-core/time";
+//#region src/domain/record/record.ts
+function record(options) {
+	const { emitRecord, emitResource, emitStats, configuration, lifeCycle } = options;
+	if (!emitRecord || !emitResource || !emitStats) throw new Error("emit functions are required");
+	const processRecord = (record) => {
+		emitRecord(record);
+		sendToExtension("record", { record });
+		const view = options.viewHistory.findView();
+		addRecord(view.id);
+	};
+	const processResource = (hash, content, onDiscard) => {
+		emitResource(hash, content, onDiscard);
+		const view = options.viewHistory.findView();
+		addResource(view.id);
+	};
+	const canvasManager = createCanvasManager();
+	const shadowRootsController = initShadowRootsController(processRecord, processResource, emitStats);
+	const scope = createRecordingScope(canvasManager, configuration, createElementsScrollPositions(), shadowRootsController);
+	const { stop: stopFullSnapshots } = startFullSnapshots(lifeCycle, processRecord, emitStats, flushMutations, scope);
+	function flushMutations() {
+		shadowRootsController.flush();
+		mutationTracker.flush();
+	}
+	const mutationTracker = trackMutation(document, processRecord, processResource, emitStats, scope);
+	const trackers = [
+		mutationTracker,
+		trackMove(processRecord, scope),
+		trackMouseInteraction(processRecord, scope),
+		trackScroll(document, processRecord, scope),
+		trackViewportResize(processRecord),
+		trackInput(document, processRecord, emitStats, scope),
+		trackMediaInteraction(processRecord, scope),
+		trackStyleSheet(processRecord, scope),
+		trackFocus(processRecord),
+		trackVisualViewportResize(processRecord),
+		trackViewEnd(lifeCycle, processRecord, flushMutations),
+		trackCanvasContent(scope),
+		trackCanvasCapture(scope, mutationTracker.notifyContentMutated)
+	];
+	return {
+		stop: () => {
+			shadowRootsController.stop();
+			trackers.forEach((tracker) => tracker.stop());
+			stopFullSnapshots();
+		},
+		flushMutations,
+		shadowRootsController,
+		takeFullSnapshot: () => {
+			flushMutations();
+			takeFullSnapshot(timeStampNow(), 1, processRecord, emitStats, scope);
+		}
+	};
+}
+//#endregion
+export { record };
+
+//# sourceMappingURL=record.mjs.map

package/esm/domain/record/record.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.mjs","names":[],"sources":["../../../src/domain/record/record.ts"],"sourcesContent":["import { sendToExtension } from '@kubesense/kubesense-browser-core'\nimport { timeStampNow } from '@kubesense/kubesense-js-core/time'\nimport type { LifeCycle, RumConfiguration, ViewHistory } from '@kubesense/kubesense-browser-rum-core'\nimport * as replayStats from '../replayStats'\nimport type { BrowserRecord } from '../../types'\nimport type { Tracker } from './trackers'\nimport {\n  trackFocus,\n  trackInput,\n  trackMediaInteraction,\n  trackMouseInteraction,\n  trackMove,\n  trackMutation,\n  trackScroll,\n  trackStyleSheet,\n  trackViewEnd,\n  trackViewportResize,\n  trackVisualViewportResize,\n  trackCanvasContent,\n  trackCanvasCapture,\n} from './trackers'\nimport { createElementsScrollPositions } from './elementsScrollPositions'\nimport type { ShadowRootsController } from './shadowRootsController'\nimport { initShadowRootsController } from './shadowRootsController'\nimport { startFullSnapshots, takeFullSnapshot } from './startFullSnapshots'\nimport type { EmitRecordCallback, EmitStatsCallback, EmitResourceCallback } from './record.types'\nimport { createRecordingScope } from './recordingScope'\nimport { createCanvasManager } from './canvas/canvasManager'\nimport { SerializationKind } from './serialization'\n\nexport interface RecordOptions {\n  emitRecord: EmitRecordCallback\n  emitResource: EmitResourceCallback\n  emitStats: EmitStatsCallback\n  configuration: RumConfiguration\n  lifeCycle: LifeCycle\n  viewHistory: ViewHistory\n}\n\nexport interface RecordAPI {\n  stop: () => void\n  flushMutations: () => void\n  shadowRootsController: ShadowRootsController\n  /**\n   * Starts the record stream over with a new full snapshot, so replay can recover when records\n   * already emitted never reached the intake.\n   */\n  takeFullSnapshot: () => void\n}\n\nexport function record(options: RecordOptions): RecordAPI {\n  const { emitRecord, emitResource, emitStats, configuration, lifeCycle } = options\n  // runtime checks for user options\n  if (!emitRecord || !emitResource || !emitStats) {\n    throw new Error('emit functions are required')\n  }\n\n  const processRecord: EmitRecordCallback = (record: BrowserRecord) => {\n    emitRecord(record)\n    sendToExtension('record', { record })\n    const view = options.viewHistory.findView()!\n    replayStats.addRecord(view.id)\n  }\n\n  const processResource: EmitResourceCallback = (hash, content, onDiscard) => {\n    emitResource(hash, content, onDiscard)\n    const view = options.viewHistory.findView()!\n    replayStats.addResource(view.id)\n  }\n\n  const canvasManager = createCanvasManager()\n  const shadowRootsController = initShadowRootsController(processRecord, processResource, emitStats)\n  const scope = createRecordingScope(\n    canvasManager,\n    configuration,\n    createElementsScrollPositions(),\n    shadowRootsController\n  )\n\n  const { stop: stopFullSnapshots } = startFullSnapshots(lifeCycle, processRecord, emitStats, flushMutations, scope)\n\n  function flushMutations() {\n    shadowRootsController.flush()\n    mutationTracker.flush()\n  }\n\n  const mutationTracker = trackMutation(document, processRecord, processResource, emitStats, scope)\n  const trackers: Tracker[] = [\n    mutationTracker,\n    trackMove(processRecord, scope),\n    trackMouseInteraction(processRecord, scope),\n    trackScroll(document, processRecord, scope),\n    trackViewportResize(processRecord),\n    trackInput(document, processRecord, emitStats, scope),\n    trackMediaInteraction(processRecord, scope),\n    trackStyleSheet(processRecord, scope),\n    trackFocus(processRecord),\n    trackVisualViewportResize(processRecord),\n    trackViewEnd(lifeCycle, processRecord, flushMutations),\n    trackCanvasContent(scope),\n    trackCanvasCapture(scope, mutationTracker.notifyContentMutated),\n  ]\n\n  return {\n    stop: () => {\n      shadowRootsController.stop()\n      trackers.forEach((tracker) => tracker.stop())\n      stopFullSnapshots()\n    },\n    flushMutations,\n    shadowRootsController,\n    takeFullSnapshot: () => {\n      flushMutations()\n      takeFullSnapshot(timeStampNow(), SerializationKind.SUBSEQUENT_FULL_SNAPSHOT, processRecord, emitStats, scope)\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,OAAO,SAAmC;CACxD,MAAM,EAAE,YAAY,cAAc,WAAW,eAAe,cAAc;CAE1E,IAAI,CAAC,cAAc,CAAC,gBAAgB,CAAC,WACnC,MAAM,IAAI,MAAM,6BAA6B;CAG/C,MAAM,iBAAqC,WAA0B;EACnE,WAAW,MAAM;EACjB,gBAAgB,UAAU,EAAE,OAAO,CAAC;EACpC,MAAM,OAAO,QAAQ,YAAY,SAAS;EAC1C,UAAsB,KAAK,EAAE;CAC/B;CAEA,MAAM,mBAAyC,MAAM,SAAS,cAAc;EAC1E,aAAa,MAAM,SAAS,SAAS;EACrC,MAAM,OAAO,QAAQ,YAAY,SAAS;EAC1C,YAAwB,KAAK,EAAE;CACjC;CAEA,MAAM,gBAAgB,oBAAoB;CAC1C,MAAM,wBAAwB,0BAA0B,eAAe,iBAAiB,SAAS;CACjG,MAAM,QAAQ,qBACZ,eACA,eACA,8BAA8B,GAC9B,qBACF;CAEA,MAAM,EAAE,MAAM,sBAAsB,mBAAmB,WAAW,eAAe,WAAW,gBAAgB,KAAK;CAEjH,SAAS,iBAAiB;EACxB,sBAAsB,MAAM;EAC5B,gBAAgB,MAAM;CACxB;CAEA,MAAM,kBAAkB,cAAc,UAAU,eAAe,iBAAiB,WAAW,KAAK;CAChG,MAAM,WAAsB;EAC1B;EACA,UAAU,eAAe,KAAK;EAC9B,sBAAsB,eAAe,KAAK;EAC1C,YAAY,UAAU,eAAe,KAAK;EAC1C,oBAAoB,aAAa;EACjC,WAAW,UAAU,eAAe,WAAW,KAAK;EACpD,sBAAsB,eAAe,KAAK;EAC1C,gBAAgB,eAAe,KAAK;EACpC,WAAW,aAAa;EACxB,0BAA0B,aAAa;EACvC,aAAa,WAAW,eAAe,cAAc;EACrD,mBAAmB,KAAK;EACxB,mBAAmB,OAAO,gBAAgB,oBAAoB;CAChE;CAEA,OAAO;EACL,YAAY;GACV,sBAAsB,KAAK;GAC3B,SAAS,SAAS,YAAY,QAAQ,KAAK,CAAC;GAC5C,kBAAkB;EACpB;EACA;EACA;EACA,wBAAwB;GACtB,eAAe;GACf,iBAAiB,aAAa,GAAA,GAA+C,eAAe,WAAW,KAAK;EAC9G;CACF;AACF"}

package/esm/domain/record/recordingScope.mjs

@@ -0,0 +1,27 @@
+import { createStringIds } from "./encoding/stringIds.mjs";
+import { createEventIds, createNodeIds, createStyleSheetIds } from "./encoding/itemIds.mjs";
+//#region src/domain/record/recordingScope.ts
+function createRecordingScope(canvasManager, configuration, elementsScrollPositions, shadowRootsController) {
+	const scope = {
+		resetIds() {
+			scope.eventIds.clear();
+			scope.nodeIds.clear();
+			scope.stringIds.clear();
+			scope.styleSheetIds.clear();
+			scope.canvasManager.reset();
+		},
+		canvasManager,
+		configuration,
+		elementsScrollPositions,
+		eventIds: createEventIds(),
+		nodeIds: createNodeIds(),
+		shadowRootsController,
+		stringIds: createStringIds(),
+		styleSheetIds: createStyleSheetIds()
+	};
+	return scope;
+}
+//#endregion
+export { createRecordingScope };
+
+//# sourceMappingURL=recordingScope.mjs.map

package/esm/domain/record/recordingScope.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"recordingScope.mjs","names":[],"sources":["../../../src/domain/record/recordingScope.ts"],"sourcesContent":["import type { RumConfiguration } from '@kubesense/kubesense-browser-rum-core'\n\nimport type { ElementsScrollPositions } from './elementsScrollPositions'\nimport { createEventIds, createNodeIds, createStringIds, createStyleSheetIds } from './encoding'\nimport type { EventIds, NodeIds, StringIds, StyleSheetIds } from './encoding'\nimport type { ShadowRootsController } from './shadowRootsController'\nimport type { CanvasManager } from './canvas/canvasManager'\n\n/**\n * State associated with a stream of session replay records. When a new stream of records\n * starts (e.g. because recording has shut down and restarted), a new RecordingScope\n * object must be created; this ensures that we don't generate records that reference ids\n * or data which aren't present in the current stream.\n */\nexport interface RecordingScope {\n  resetIds(): void\n\n  canvasManager: CanvasManager\n  configuration: RumConfiguration\n  elementsScrollPositions: ElementsScrollPositions\n  eventIds: EventIds\n  nodeIds: NodeIds\n  shadowRootsController: ShadowRootsController\n  stringIds: StringIds\n  styleSheetIds: StyleSheetIds\n}\n\nexport function createRecordingScope(\n  canvasManager: CanvasManager,\n  configuration: RumConfiguration,\n  elementsScrollPositions: ElementsScrollPositions,\n  shadowRootsController: ShadowRootsController\n): RecordingScope {\n  const eventIds = createEventIds()\n  const nodeIds = createNodeIds()\n  const stringIds = createStringIds()\n  const styleSheetIds = createStyleSheetIds()\n\n  const scope: RecordingScope = {\n    resetIds(): void {\n      scope.eventIds.clear()\n      scope.nodeIds.clear()\n      scope.stringIds.clear()\n      scope.styleSheetIds.clear()\n      scope.canvasManager.reset()\n    },\n\n    canvasManager,\n    configuration,\n    elementsScrollPositions,\n    eventIds,\n    nodeIds,\n    shadowRootsController,\n    stringIds,\n    styleSheetIds,\n  }\n\n  return scope\n}\n"],"mappings":";;;AA2BA,SAAgB,qBACd,eACA,eACA,yBACA,uBACgB;CAMhB,MAAM,QAAwB;EAC5B,WAAiB;GACf,MAAM,SAAS,MAAM;GACrB,MAAM,QAAQ,MAAM;GACpB,MAAM,UAAU,MAAM;GACtB,MAAM,cAAc,MAAM;GAC1B,MAAM,cAAc,MAAM;EAC5B;EAEA;EACA;EACA;EACA,UAjBe,eAiBR;EACP,SAjBc,cAiBR;EACN;EACA,WAlBgB,gBAkBR;EACR,eAlBoB,oBAkBR;CACd;CAEA,OAAO;AACT"}

package/esm/domain/record/serialization/index.mjs

@@ -0,0 +1,9 @@
+import { createRootInsertionCursor } from "./insertionCursor.mjs";
+import { getElementInputValue } from "./serializationUtils.mjs";
+import { aggregateSerializationStats, createSerializationStats } from "./serializationStats.mjs";
+import { serializeInTransaction } from "./serializationTransaction.mjs";
+import "./serializeAttribute.mjs";
+import { serializeNode } from "./serializeNode.mjs";
+import { serializeFullSnapshot } from "./serializeFullSnapshot.mjs";
+import { serializeMutations } from "./serializeMutations.mjs";
+export { aggregateSerializationStats, createRootInsertionCursor, createSerializationStats, getElementInputValue, serializeFullSnapshot, serializeInTransaction, serializeMutations, serializeNode };

package/esm/domain/record/serialization/insertionCursor.mjs

@@ -0,0 +1,54 @@
+//#region src/domain/record/serialization/insertionCursor.ts
+/** Returns an InsertionCursor which starts positioned at the root of the document. */
+function createRootInsertionCursor(nodeIds) {
+	return createInsertionCursor(void 0, void 0, nodeIds);
+}
+/**
+* Returns an InsertionCursor which starts positioned in the child list of the given
+* parent node. If a next sibling is provided, the cursor points to the position
+* immediately before the next sibling; otherwise, the cursor points to the end of the
+* child list.
+*/
+function createChildInsertionCursor(parentId, nextSiblingId, nodeIds) {
+	return createInsertionCursor(parentId, nextSiblingId, nodeIds);
+}
+function createInsertionCursor(parentId, nextSiblingId, nodeIds) {
+	let cursor = {
+		container: void 0,
+		parentId,
+		previousSiblingId: void 0,
+		nextSiblingId
+	};
+	const computeInsertionPoint = (nodeId) => {
+		if (cursor.previousSiblingId === nodeId - 1) return 0;
+		if (cursor.nextSiblingId !== void 0) return cursor.nextSiblingId - nodeId;
+		if (cursor.parentId !== void 0) return nodeId - cursor.parentId;
+		return null;
+	};
+	return {
+		advance(node) {
+			const nodeId = nodeIds.getOrInsert(node);
+			const insertionPoint = computeInsertionPoint(nodeId);
+			cursor.previousSiblingId = nodeId;
+			return {
+				nodeId,
+				insertionPoint
+			};
+		},
+		ascend() {
+			if (cursor.container) cursor = cursor.container;
+		},
+		descend() {
+			if (cursor.previousSiblingId !== void 0) cursor = {
+				container: cursor,
+				parentId: cursor.previousSiblingId,
+				previousSiblingId: void 0,
+				nextSiblingId: void 0
+			};
+		}
+	};
+}
+//#endregion
+export { createChildInsertionCursor, createRootInsertionCursor };
+
+//# sourceMappingURL=insertionCursor.mjs.map

package/esm/domain/record/serialization/insertionCursor.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"insertionCursor.mjs","names":[],"sources":["../../../../src/domain/record/serialization/insertionCursor.ts"],"sourcesContent":["import type { InsertionPoint } from '../../../types'\nimport type { NodeId, NodeIds } from '../encoding'\n\n/**\n * InsertionCursor tracks the point at which the next node will be inserted during\n * Change-style DOM serialization.\n *\n * When a new node is added to the document, we use an InsertionPoint to encode its\n * position. There are often multiple equally-valid ways to express the same insertion\n * point; we generally want to favor encodings that use as few characters as possible (to\n * reduce uncompressed size) and that are as repetitive as possible (to reduce compressed\n * size). InsertionCursor's purpose is to heuristically pick an efficient encoding based\n * on the nodes we've recently serialized, while doing as little work as possible. The\n * results are not optimal, but should be close to it in most situations.\n *\n * At the beginning of the serialization process, use a factory function like\n * createRootInsertionCursor() to create a new cursor with an appropriate initial\n * position.\n *\n * When visiting a node, the expected usage pattern is as follows:\n * 1. Call advance() to get a node id and insertion point for the node.\n * 2. Serialize the node.\n * 3. If the node has no children, we're done; continue to the node's next\n * sibling and apply this algorithm again.\n * 4. Otherwise, call descend() to move the cursor into the node's child list.\n * 5. Recursively apply this algorithm.\n * 6. Call ascend() to move the cursor out of the node's child list. We're done;\n * continue to the node's next sibling and apply this algorithm again.\n */\nexport interface InsertionCursor {\n  /**\n   * Given the node id for a new node, returns the InsertionPoint for that node.\n   * Updates the cursor to point to the new node's next sibling.\n   */\n  advance(node: Node): { nodeId: NodeId; insertionPoint: InsertionPoint }\n\n  /**\n   * Ascends out of the current child list and updates the cursor to point to the parent\n   * node's next sibling.\n   */\n  ascend(): void\n\n  /**\n   * Descends into the child list of the last node we inserted and updates the cursor to\n   * point to the node's first child.\n   */\n  descend(): void\n}\n\n/** Returns an InsertionCursor which starts positioned at the root of the document. */\nexport function createRootInsertionCursor(nodeIds: NodeIds): InsertionCursor {\n  return createInsertionCursor(undefined, undefined, nodeIds)\n}\n\n/**\n * Returns an InsertionCursor which starts positioned in the child list of the given\n * parent node. If a next sibling is provided, the cursor points to the position\n * immediately before the next sibling; otherwise, the cursor points to the end of the\n * child list.\n */\nexport function createChildInsertionCursor(\n  parentId: NodeId,\n  nextSiblingId: NodeId | undefined,\n  nodeIds: NodeIds\n): InsertionCursor {\n  return createInsertionCursor(parentId, nextSiblingId, nodeIds)\n}\n\nfunction createInsertionCursor(\n  parentId: NodeId | undefined,\n  nextSiblingId: NodeId | undefined,\n  nodeIds: NodeIds\n): InsertionCursor {\n  interface ChildListCursor {\n    container: ChildListCursor | undefined\n    parentId: NodeId | undefined\n    previousSiblingId: NodeId | undefined\n    nextSiblingId: NodeId | undefined\n  }\n\n  let cursor: ChildListCursor = {\n    container: undefined,\n    parentId,\n    previousSiblingId: undefined,\n    nextSiblingId,\n  }\n\n  const computeInsertionPoint = (nodeId: NodeId): InsertionPoint => {\n    if (cursor.previousSiblingId === nodeId - 1) {\n      // Use an AppendAfterPreviousInsertionPoint. (i.e., 0)\n      return 0\n    }\n    if (cursor.nextSiblingId !== undefined) {\n      // Use an InsertBeforeInsertionPoint. We identify the next sibling using a\n      // negative integer indicating the difference between the new node's id and its next\n      // sibling's id.\n      return cursor.nextSiblingId - nodeId\n    }\n    if (cursor.parentId !== undefined) {\n      // Use an AppendChildInsertionPoint. We identify the parent node using a positive\n      // integer indicating the difference between the new node's id and its parent's id.\n      return nodeId - cursor.parentId\n    }\n    // There's no parent. Use a RootInsertionPoint. (i.e., null)\n    return null\n  }\n\n  return {\n    advance(node: Node): { nodeId: NodeId; insertionPoint: InsertionPoint } {\n      const nodeId = nodeIds.getOrInsert(node)\n      const insertionPoint = computeInsertionPoint(nodeId)\n      cursor.previousSiblingId = nodeId\n      return { nodeId, insertionPoint }\n    },\n    ascend(): void {\n      if (cursor.container) {\n        cursor = cursor.container\n      }\n    },\n    descend(): void {\n      if (cursor.previousSiblingId !== undefined) {\n        cursor = {\n          container: cursor,\n          parentId: cursor.previousSiblingId,\n          previousSiblingId: undefined,\n          nextSiblingId: undefined,\n        }\n      }\n    },\n  }\n}\n"],"mappings":";;AAkDA,SAAgB,0BAA0B,SAAmC;CAC3E,OAAO,sBAAsB,KAAA,GAAW,KAAA,GAAW,OAAO;AAC5D;;;;;;;AAQA,SAAgB,2BACd,UACA,eACA,SACiB;CACjB,OAAO,sBAAsB,UAAU,eAAe,OAAO;AAC/D;AAEA,SAAS,sBACP,UACA,eACA,SACiB;CAQjB,IAAI,SAA0B;EAC5B,WAAW,KAAA;EACX;EACA,mBAAmB,KAAA;EACnB;CACF;CAEA,MAAM,yBAAyB,WAAmC;EAChE,IAAI,OAAO,sBAAsB,SAAS,GAExC,OAAO;EAET,IAAI,OAAO,kBAAkB,KAAA,GAI3B,OAAO,OAAO,gBAAgB;EAEhC,IAAI,OAAO,aAAa,KAAA,GAGtB,OAAO,SAAS,OAAO;EAGzB,OAAO;CACT;CAEA,OAAO;EACL,QAAQ,MAAgE;GACtE,MAAM,SAAS,QAAQ,YAAY,IAAI;GACvC,MAAM,iBAAiB,sBAAsB,MAAM;GACnD,OAAO,oBAAoB;GAC3B,OAAO;IAAE;IAAQ;GAAe;EAClC;EACA,SAAe;GACb,IAAI,OAAO,WACT,SAAS,OAAO;EAEpB;EACA,UAAgB;GACd,IAAI,OAAO,sBAAsB,KAAA,GAC/B,SAAS;IACP,WAAW;IACX,UAAU,OAAO;IACjB,mBAAmB,KAAA;IACnB,eAAe,KAAA;GACjB;EAEJ;CACF;AACF"}

package/esm/domain/record/serialization/serializationStats.mjs

@@ -0,0 +1,31 @@
+//#region src/domain/record/serialization/serializationStats.ts
+function createSerializationStats() {
+	return {
+		cssText: {
+			count: 0,
+			max: 0,
+			sum: 0
+		},
+		serializationDuration: {
+			count: 0,
+			max: 0,
+			sum: 0
+		}
+	};
+}
+function updateSerializationStats(stats, metric, value) {
+	stats[metric].count += 1;
+	stats[metric].max = Math.max(stats[metric].max, value);
+	stats[metric].sum += value;
+}
+function aggregateSerializationStats(aggregateStats, stats) {
+	for (const metric of ["cssText", "serializationDuration"]) {
+		aggregateStats[metric].count += stats[metric].count;
+		aggregateStats[metric].max = Math.max(aggregateStats[metric].max, stats[metric].max);
+		aggregateStats[metric].sum += stats[metric].sum;
+	}
+}
+//#endregion
+export { aggregateSerializationStats, createSerializationStats, updateSerializationStats };
+
+//# sourceMappingURL=serializationStats.mjs.map

package/esm/domain/record/serialization/serializationStats.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializationStats.mjs","names":[],"sources":["../../../../src/domain/record/serialization/serializationStats.ts"],"sourcesContent":["export interface SerializationMetric {\n  count: number\n  max: number\n  sum: number\n}\n\nexport interface SerializationStats {\n  cssText: SerializationMetric\n  serializationDuration: SerializationMetric\n}\n\nexport function createSerializationStats(): SerializationStats {\n  return {\n    cssText: {\n      count: 0,\n      max: 0,\n      sum: 0,\n    },\n    serializationDuration: {\n      count: 0,\n      max: 0,\n      sum: 0,\n    },\n  }\n}\n\nexport function updateSerializationStats(\n  stats: SerializationStats,\n  metric: keyof SerializationStats,\n  value: number\n): void {\n  stats[metric].count += 1\n  stats[metric].max = Math.max(stats[metric].max, value)\n  stats[metric].sum += value\n}\n\nexport function aggregateSerializationStats(aggregateStats: SerializationStats, stats: SerializationStats) {\n  for (const metric of ['cssText', 'serializationDuration'] as const) {\n    aggregateStats[metric].count += stats[metric].count\n    aggregateStats[metric].max = Math.max(aggregateStats[metric].max, stats[metric].max)\n    aggregateStats[metric].sum += stats[metric].sum\n  }\n}\n"],"mappings":";AAWA,SAAgB,2BAA+C;CAC7D,OAAO;EACL,SAAS;GACP,OAAO;GACP,KAAK;GACL,KAAK;EACP;EACA,uBAAuB;GACrB,OAAO;GACP,KAAK;GACL,KAAK;EACP;CACF;AACF;AAEA,SAAgB,yBACd,OACA,QACA,OACM;CACN,MAAM,OAAO,CAAC,SAAS;CACvB,MAAM,OAAO,CAAC,MAAM,KAAK,IAAI,MAAM,OAAO,CAAC,KAAK,KAAK;CACrD,MAAM,OAAO,CAAC,OAAO;AACvB;AAEA,SAAgB,4BAA4B,gBAAoC,OAA2B;CACzG,KAAK,MAAM,UAAU,CAAC,WAAW,uBAAuB,GAAY;EAClE,eAAe,OAAO,CAAC,SAAS,MAAM,OAAO,CAAC;EAC9C,eAAe,OAAO,CAAC,MAAM,KAAK,IAAI,eAAe,OAAO,CAAC,KAAK,MAAM,OAAO,CAAC,GAAG;EACnF,eAAe,OAAO,CAAC,OAAO,MAAM,OAAO,CAAC;CAC9C;AACF"}

package/esm/domain/record/serialization/serializationTransaction.mjs

@@ -0,0 +1,92 @@
+import { ChangeType, RecordType, SnapshotFormat } from "../../../types/sessionReplayConstants.mjs";
+import { createChangeEncoder } from "../encoding/changeEncoder.mjs";
+import { createSerializationStats, updateSerializationStats } from "./serializationStats.mjs";
+import { elapsed, timeStampNow } from "@kubesense/kubesense-js-core/time";
+//#region src/domain/record/serialization/serializationTransaction.ts
+function serializeInTransaction(kind, emitRecord, emitStats, scope, timestamp, serialize) {
+	const encoder = createChangeEncoder(scope.stringIds);
+	const stats = createSerializationStats();
+	const transaction = {
+		addMetric(metric, value) {
+			updateSerializationStats(stats, metric, value);
+		},
+		addNode(...change) {
+			encoder.add(ChangeType.AddNode, change);
+		},
+		addStyleSheet(rules, mediaList, disabled) {
+			if (disabled) encoder.add(ChangeType.AddStyleSheet, [
+				rules,
+				mediaList || [],
+				disabled
+			]);
+			else if (mediaList) encoder.add(ChangeType.AddStyleSheet, [rules, mediaList]);
+			else encoder.add(ChangeType.AddStyleSheet, [rules]);
+		},
+		attachStyleSheets(nodeId, sheetIds) {
+			const change = [nodeId];
+			for (const sheetId of sheetIds) change.push(sheetId);
+			encoder.add(ChangeType.AttachedStyleSheets, change);
+		},
+		removeNode(nodeId) {
+			encoder.add(ChangeType.RemoveNode, nodeId);
+		},
+		setAttributes(change) {
+			encoder.add(ChangeType.Attribute, change);
+		},
+		setInputSelection(state, nodeIds) {
+			const change = [state];
+			for (const nodeId of nodeIds) change.push(nodeId);
+			encoder.add(ChangeType.InputSelection, change);
+		},
+		setInputValue(nodeId, value) {
+			encoder.add(ChangeType.InputValue, [nodeId, value]);
+		},
+		setMediaPlaybackState(nodeId, state) {
+			encoder.add(ChangeType.MediaPlaybackState, [nodeId, state]);
+		},
+		setScrollPosition(nodeId, x, y) {
+			encoder.add(ChangeType.ScrollPosition, [
+				nodeId,
+				x,
+				y
+			]);
+		},
+		setSize(nodeId, width, height) {
+			encoder.add(ChangeType.Size, [
+				nodeId,
+				width,
+				height
+			]);
+		},
+		setText(nodeId, content) {
+			encoder.add(ChangeType.Text, [nodeId, content]);
+		},
+		setImageContent(nodeId, resourceId) {
+			encoder.add(ChangeType.ImageContent, [nodeId, resourceId]);
+		},
+		kind,
+		scope
+	};
+	const start = timeStampNow();
+	serialize(transaction);
+	updateSerializationStats(stats, "serializationDuration", elapsed(start, timeStampNow()));
+	const changes = encoder.flush();
+	if (changes.length > 0) {
+		if (kind === 0 || kind === 1) emitRecord({
+			data: changes,
+			format: SnapshotFormat.Change,
+			type: RecordType.FullSnapshot,
+			timestamp
+		});
+		else emitRecord({
+			data: changes,
+			type: RecordType.Change,
+			timestamp
+		});
+	}
+	emitStats(stats);
+}
+//#endregion
+export { serializeInTransaction };
+
+//# sourceMappingURL=serializationTransaction.mjs.map

package/esm/domain/record/serialization/serializationTransaction.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializationTransaction.mjs","names":[],"sources":["../../../../src/domain/record/serialization/serializationTransaction.ts"],"sourcesContent":["import { elapsed, timeStampNow } from '@kubesense/kubesense-js-core/time'\nimport type { TimeStamp } from '@kubesense/kubesense-js-core/time'\nimport { ChangeType, RecordType, SnapshotFormat } from '../../../types'\nimport type {\n  AddCDataSectionNodeChange,\n  AddDocTypeNodeChange,\n  AddDocumentFragmentNodeChange,\n  AddDocumentNodeChange,\n  AddElementNodeChange,\n  AddNodeChange,\n  AddShadowRootNodeChange,\n  AddTextNodeChange,\n  AttachedStyleSheetsChange,\n  InputSelectionChange,\n  InputSelectionState,\n  InsertionPoint,\n  MediaInteractionType,\n  RoleAnnotatedStringLiteral,\n} from '../../../types'\nimport type {\n  NodeId,\n  RoleAnnotatedAddNodeName,\n  RoleAnnotatedAddNodeParams,\n  RoleAnnotatedAttributeChange,\n  RoleAnnotatedStringLiteralValue,\n  RoleAnnotatedStyleSheetMediaList,\n  RoleAnnotatedStyleSheetRules,\n  StyleSheetId,\n} from '../encoding'\nimport { createChangeEncoder } from '../encoding'\nimport type { EmitRecordCallback, EmitStatsCallback } from '../record.types'\nimport type { RecordingScope } from '../recordingScope'\nimport type { SerializationStats } from './serializationStats'\nimport { createSerializationStats, updateSerializationStats } from './serializationStats'\n\nexport const enum SerializationKind {\n  INITIAL_FULL_SNAPSHOT,\n  SUBSEQUENT_FULL_SNAPSHOT,\n  INCREMENTAL_SNAPSHOT,\n}\n\nexport type SerializationTransactionCallback = (transaction: SerializationTransaction) => void\n\n/**\n * SerializationTransaction is used to build and emit a `BrowserChangeRecord` containing a\n * serialized snapshot of the DOM. The term \"transaction\" is used because all the changes\n * in a serialization transaction are applied together, atomically. A serialization\n * transaction is thus always associated with a single timestamp.\n *\n * To use `SerializationTransaction`, call the builder methods it exposes to add changes\n * to the transaction. At the end of the transaction, the changes will be combined into a\n * single `BrowserChangeRecord` and emitted.\n */\nexport interface SerializationTransaction {\n  /**\n   * Add a metric to the transaction's statistics. The aggregated statistics will be\n   * emitted when the transaction ends.\n   */\n  addMetric(metric: keyof SerializationStats, value: number): void\n\n  /** Add a node to the document at the given insertion point. */\n  addNode(\n    pos: InsertionPoint,\n    nodeName: RoleAnnotatedAddNodeName<AddCDataSectionNodeChange>,\n    ...params: RoleAnnotatedAddNodeParams<AddCDataSectionNodeChange>\n  ): void\n  addNode(\n    pos: InsertionPoint,\n    nodeName: RoleAnnotatedAddNodeName<AddDocTypeNodeChange>,\n    ...params: RoleAnnotatedAddNodeParams<AddDocTypeNodeChange>\n  ): void\n  addNode(\n    pos: InsertionPoint,\n    nodeName: RoleAnnotatedAddNodeName<AddDocumentNodeChange>,\n    ...params: RoleAnnotatedAddNodeParams<AddDocumentNodeChange>\n  ): void\n  addNode(\n    pos: InsertionPoint,\n    nodeName: RoleAnnotatedAddNodeName<AddDocumentFragmentNodeChange>,\n    ...params: RoleAnnotatedAddNodeParams<AddDocumentFragmentNodeChange>\n  ): void\n  addNode(\n    pos: InsertionPoint,\n    nodeName: RoleAnnotatedAddNodeName<AddShadowRootNodeChange>,\n    ...params: RoleAnnotatedAddNodeParams<AddShadowRootNodeChange>\n  ): void\n  addNode(\n    pos: InsertionPoint,\n    nodeName: RoleAnnotatedAddNodeName<AddTextNodeChange>,\n    ...params: RoleAnnotatedAddNodeParams<AddTextNodeChange>\n  ): void\n  addNode<Name extends RoleAnnotatedAddNodeName<AddElementNodeChange>>(\n    pos: InsertionPoint,\n    nodeName: Name,\n    // This overload is deliberately unsatisfiable; a '#'-prefixed name belongs to one of\n    // the node kinds above, so we should never reach it unless the caller provided\n    // invalid parameters.\n    ...params: RoleAnnotatedStringLiteralValue<Name> extends `#${string}`\n      ? [never]\n      : RoleAnnotatedAddNodeParams<AddElementNodeChange>\n  ): void\n\n  /** Add a stylesheet to the document. */\n  addStyleSheet(\n    rules: RoleAnnotatedStyleSheetRules,\n    mediaList?: RoleAnnotatedStyleSheetMediaList,\n    disabled?: boolean\n  ): void\n\n  /**\n   * Attach one or more stylesheets to a <link>, <style>, #document, #document-fragment,\n   * or #shadow-root node.\n   */\n  attachStyleSheets(nodeId: NodeId, sheetIds: StyleSheetId[]): void\n\n  /** Remove a node from the document. */\n  removeNode(nodeId: NodeId): void\n\n  /** Set a node's attributes to the given values. */\n  setAttributes(change: RoleAnnotatedAttributeChange): void\n\n  /** Set the content of a canvas node to the given resource ID. */\n  setImageContent(nodeId: NodeId, resourceId: RoleAnnotatedStringLiteral): void\n\n  /** Set the selection state of one or more checkboxes, radio buttons, or <option> elements. */\n  setInputSelection(state: InputSelectionState, nodeIds: NodeId[]): void\n\n  /** Set the value of a form element. */\n  setInputValue(nodeId: NodeId, value: RoleAnnotatedStringLiteral): void\n\n  /** Set the media playback state of an <audio> or <video> element. */\n  setMediaPlaybackState(nodeId: NodeId, state: MediaInteractionType): void\n\n  /** Set the given node's scroll position in CSS pixels. */\n  setScrollPosition(nodeId: NodeId, x: number, y: number): void\n\n  /** Set the given node's size in CSS pixels. */\n  setSize(nodeId: NodeId, width: number, height: number): void\n\n  /** Set the given node's text content. */\n  setText(nodeId: NodeId, content: RoleAnnotatedStringLiteral): void\n\n  /** The kind of serialization being performed in this transaction. */\n  kind: SerializationKind\n\n  /** The recording scope in which this transaction is occurring. */\n  scope: RecordingScope\n}\n\nexport function serializeInTransaction(\n  kind: SerializationKind,\n  emitRecord: EmitRecordCallback,\n  emitStats: EmitStatsCallback,\n  scope: RecordingScope,\n  timestamp: TimeStamp,\n  serialize: SerializationTransactionCallback\n): void {\n  const encoder = createChangeEncoder(scope.stringIds)\n  const stats = createSerializationStats()\n\n  const transaction: SerializationTransaction = {\n    addMetric(metric: keyof SerializationStats, value: number): void {\n      updateSerializationStats(stats, metric, value)\n    },\n    // The overloads declared above are what callers are checked against; this implementation\n    // takes the parameters of any of them.\n    addNode(...change: unknown[]): void {\n      encoder.add(ChangeType.AddNode, change as AddNodeChange)\n    },\n    addStyleSheet(\n      rules: RoleAnnotatedStyleSheetRules,\n      mediaList?: RoleAnnotatedStyleSheetMediaList,\n      disabled?: boolean\n    ): void {\n      if (disabled) {\n        encoder.add(ChangeType.AddStyleSheet, [rules, mediaList || [], disabled])\n      } else if (mediaList) {\n        encoder.add(ChangeType.AddStyleSheet, [rules, mediaList])\n      } else {\n        encoder.add(ChangeType.AddStyleSheet, [rules])\n      }\n    },\n    attachStyleSheets(nodeId: NodeId, sheetIds: StyleSheetId[]): void {\n      const change: AttachedStyleSheetsChange = [nodeId]\n      for (const sheetId of sheetIds) {\n        change.push(sheetId)\n      }\n      encoder.add(ChangeType.AttachedStyleSheets, change)\n    },\n    removeNode(nodeId: NodeId): void {\n      encoder.add(ChangeType.RemoveNode, nodeId)\n    },\n    setAttributes(change: RoleAnnotatedAttributeChange): void {\n      encoder.add(ChangeType.Attribute, change)\n    },\n    setInputSelection(state: InputSelectionState, nodeIds: NodeId[]): void {\n      const change: InputSelectionChange = [state]\n      for (const nodeId of nodeIds) {\n        change.push(nodeId)\n      }\n      encoder.add(ChangeType.InputSelection, change)\n    },\n    setInputValue(nodeId: NodeId, value: RoleAnnotatedStringLiteral): void {\n      encoder.add(ChangeType.InputValue, [nodeId, value])\n    },\n    setMediaPlaybackState(nodeId: NodeId, state: MediaInteractionType): void {\n      encoder.add(ChangeType.MediaPlaybackState, [nodeId, state])\n    },\n    setScrollPosition(nodeId: NodeId, x: number, y: number): void {\n      encoder.add(ChangeType.ScrollPosition, [nodeId, x, y])\n    },\n    setSize(nodeId: NodeId, width: number, height: number): void {\n      encoder.add(ChangeType.Size, [nodeId, width, height])\n    },\n    setText(nodeId: NodeId, content: RoleAnnotatedStringLiteral): void {\n      encoder.add(ChangeType.Text, [nodeId, content])\n    },\n    setImageContent(nodeId: NodeId, resourceId: RoleAnnotatedStringLiteral): void {\n      encoder.add(ChangeType.ImageContent, [nodeId, resourceId])\n    },\n    kind,\n    scope,\n  }\n\n  const start = timeStampNow()\n  serialize(transaction)\n  updateSerializationStats(stats, 'serializationDuration', elapsed(start, timeStampNow()))\n\n  const changes = encoder.flush()\n  if (changes.length > 0) {\n    if (kind === SerializationKind.INITIAL_FULL_SNAPSHOT || kind === SerializationKind.SUBSEQUENT_FULL_SNAPSHOT) {\n      emitRecord({\n        data: changes,\n        format: SnapshotFormat.Change,\n        type: RecordType.FullSnapshot,\n        timestamp,\n      })\n    } else {\n      emitRecord({\n        data: changes,\n        type: RecordType.Change,\n        timestamp,\n      })\n    }\n  }\n\n  emitStats(stats)\n}\n"],"mappings":";;;;;AAqJA,SAAgB,uBACd,MACA,YACA,WACA,OACA,WACA,WACM;CACN,MAAM,UAAU,oBAAoB,MAAM,SAAS;CACnD,MAAM,QAAQ,yBAAyB;CAEvC,MAAM,cAAwC;EAC5C,UAAU,QAAkC,OAAqB;GAC/D,yBAAyB,OAAO,QAAQ,KAAK;EAC/C;EAGA,QAAQ,GAAG,QAAyB;GAClC,QAAQ,IAAI,WAAW,SAAS,MAAuB;EACzD;EACA,cACE,OACA,WACA,UACM;GACN,IAAI,UACF,QAAQ,IAAI,WAAW,eAAe;IAAC;IAAO,aAAa,CAAC;IAAG;GAAQ,CAAC;QACnE,IAAI,WACT,QAAQ,IAAI,WAAW,eAAe,CAAC,OAAO,SAAS,CAAC;QAExD,QAAQ,IAAI,WAAW,eAAe,CAAC,KAAK,CAAC;EAEjD;EACA,kBAAkB,QAAgB,UAAgC;GAChE,MAAM,SAAoC,CAAC,MAAM;GACjD,KAAK,MAAM,WAAW,UACpB,OAAO,KAAK,OAAO;GAErB,QAAQ,IAAI,WAAW,qBAAqB,MAAM;EACpD;EACA,WAAW,QAAsB;GAC/B,QAAQ,IAAI,WAAW,YAAY,MAAM;EAC3C;EACA,cAAc,QAA4C;GACxD,QAAQ,IAAI,WAAW,WAAW,MAAM;EAC1C;EACA,kBAAkB,OAA4B,SAAyB;GACrE,MAAM,SAA+B,CAAC,KAAK;GAC3C,KAAK,MAAM,UAAU,SACnB,OAAO,KAAK,MAAM;GAEpB,QAAQ,IAAI,WAAW,gBAAgB,MAAM;EAC/C;EACA,cAAc,QAAgB,OAAyC;GACrE,QAAQ,IAAI,WAAW,YAAY,CAAC,QAAQ,KAAK,CAAC;EACpD;EACA,sBAAsB,QAAgB,OAAmC;GACvE,QAAQ,IAAI,WAAW,oBAAoB,CAAC,QAAQ,KAAK,CAAC;EAC5D;EACA,kBAAkB,QAAgB,GAAW,GAAiB;GAC5D,QAAQ,IAAI,WAAW,gBAAgB;IAAC;IAAQ;IAAG;GAAC,CAAC;EACvD;EACA,QAAQ,QAAgB,OAAe,QAAsB;GAC3D,QAAQ,IAAI,WAAW,MAAM;IAAC;IAAQ;IAAO;GAAM,CAAC;EACtD;EACA,QAAQ,QAAgB,SAA2C;GACjE,QAAQ,IAAI,WAAW,MAAM,CAAC,QAAQ,OAAO,CAAC;EAChD;EACA,gBAAgB,QAAgB,YAA8C;GAC5E,QAAQ,IAAI,WAAW,cAAc,CAAC,QAAQ,UAAU,CAAC;EAC3D;EACA;EACA;CACF;CAEA,MAAM,QAAQ,aAAa;CAC3B,UAAU,WAAW;CACrB,yBAAyB,OAAO,yBAAyB,QAAQ,OAAO,aAAa,CAAC,CAAC;CAEvF,MAAM,UAAU,QAAQ,MAAM;CAC9B,IAAI,QAAQ,SAAS,GAAG;EACtB,IAAI,SAAA,KAAoD,SAAA,GACtD,WAAW;GACT,MAAM;GACN,QAAQ,eAAe;GACvB,MAAM,WAAW;GACjB;EACF,CAAC;OAED,WAAW;GACT,MAAM;GACN,MAAM,WAAW;GACjB;EACF,CAAC;CAEL;CAEA,UAAU,KAAK;AACjB"}

package/esm/domain/record/serialization/serializationUtils.mjs

@@ -0,0 +1,53 @@
+import { CENSORED_STRING_MARK, shouldMaskNode } from "@kubesense/kubesense-browser-rum-core";
+import { buildUrl } from "@kubesense/kubesense-js-core/util";
+//#region src/domain/record/serialization/serializationUtils.ts
+/**
+* Get the element "value" to be serialized as an attribute or an input update record. It respects
+* the input privacy mode of the element.
+* PERFROMANCE OPTIMIZATION: Assumes that privacy level `HIDDEN` is never encountered because of earlier checks.
+*/
+function getElementInputValue(element, nodePrivacyLevel) {
+	const tagName = element.tagName;
+	const value = element.value;
+	if (shouldMaskNode(element, nodePrivacyLevel)) {
+		const type = element.type;
+		if (tagName === "INPUT" && (type === "button" || type === "submit" || type === "reset")) return value;
+		else if (!value || tagName === "OPTION") return;
+		return CENSORED_STRING_MARK;
+	}
+	if (tagName === "OPTION" || tagName === "SELECT") return element.value;
+	if (tagName !== "INPUT" && tagName !== "TEXTAREA") return;
+	return value;
+}
+const URL_IN_CSS_REF = /url\((?:(')([^']*)'|(")([^"]*)"|([^)]*))\)/gm;
+const ABSOLUTE_URL = /^[A-Za-z]+:|^\/\//;
+const DATA_URI = /^["']?data:.*,/i;
+function switchToAbsoluteUrl(cssText, cssHref) {
+	return cssText.replace(URL_IN_CSS_REF, (matchingSubstring, singleQuote, urlWrappedInSingleQuotes, doubleQuote, urlWrappedInDoubleQuotes, urlNotWrappedInQuotes) => {
+		const url = urlWrappedInSingleQuotes || urlWrappedInDoubleQuotes || urlNotWrappedInQuotes;
+		if (!cssHref || !url || ABSOLUTE_URL.test(url) || DATA_URI.test(url)) return matchingSubstring;
+		const quote = singleQuote || doubleQuote || "";
+		return `url(${quote}${makeUrlAbsolute(url, cssHref)}${quote})`;
+	});
+}
+function makeUrlAbsolute(url, baseUrl) {
+	try {
+		return buildUrl(url, baseUrl).href;
+	} catch {
+		return url;
+	}
+}
+/**
+* Returns the tag name of the given element, normalized to ensure a consistent lowercase
+* representation regardless of whether the element is HTML, XHTML, or SVG.
+*/
+function normalizedTagName(element) {
+	return element.tagName.toLowerCase();
+}
+function censoredImageForSize(width, height) {
+	return `data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='${width}' height='${height}' style='background-color:silver'%3E%3C/svg%3E`;
+}
+//#endregion
+export { ABSOLUTE_URL, DATA_URI, URL_IN_CSS_REF, censoredImageForSize, getElementInputValue, normalizedTagName, switchToAbsoluteUrl };
+
+//# sourceMappingURL=serializationUtils.mjs.map

package/esm/domain/record/serialization/serializationUtils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializationUtils.mjs","names":[],"sources":["../../../../src/domain/record/serialization/serializationUtils.ts"],"sourcesContent":["import { buildUrl } from '@kubesense/kubesense-js-core/util'\nimport { CENSORED_STRING_MARK, shouldMaskNode } from '@kubesense/kubesense-browser-rum-core'\nimport type { NodePrivacyLevel } from '@kubesense/kubesense-browser-rum-core'\n\n/**\n * Get the element \"value\" to be serialized as an attribute or an input update record. It respects\n * the input privacy mode of the element.\n * PERFROMANCE OPTIMIZATION: Assumes that privacy level `HIDDEN` is never encountered because of earlier checks.\n */\nexport function getElementInputValue(element: Element, nodePrivacyLevel: NodePrivacyLevel) {\n  /*\n   BROWSER SPEC NOTE: <input>, <select>\n   For some <input> elements, the `value` is an exceptional property/attribute that has the\n   value synced between el.value and el.getAttribute()\n   input[type=button,checkbox,hidden,image,radio,reset,submit]\n   */\n  const tagName = element.tagName\n  const value = (element as HTMLInputElement | HTMLTextAreaElement).value\n\n  if (shouldMaskNode(element, nodePrivacyLevel)) {\n    const type = (element as HTMLInputElement | HTMLTextAreaElement).type\n    if (tagName === 'INPUT' && (type === 'button' || type === 'submit' || type === 'reset')) {\n      // Overrule `MASK` privacy level for button-like element values, as they are used during replay\n      // to display their label. They can still be hidden via the \"hidden\" privacy attribute or class name.\n      return value\n    } else if (!value || tagName === 'OPTION') {\n      // <Option> value provides no benefit\n      return\n    }\n    return CENSORED_STRING_MARK\n  }\n\n  if (tagName === 'OPTION' || tagName === 'SELECT') {\n    return (element as HTMLOptionElement | HTMLSelectElement).value\n  }\n\n  if (tagName !== 'INPUT' && tagName !== 'TEXTAREA') {\n    return\n  }\n\n  return value\n}\n\nexport const URL_IN_CSS_REF = /url\\((?:(')([^']*)'|(\")([^\"]*)\"|([^)]*))\\)/gm\nexport const ABSOLUTE_URL = /^[A-Za-z]+:|^\\/\\//\nexport const DATA_URI = /^[\"']?data:.*,/i\n\nexport function switchToAbsoluteUrl(cssText: string, cssHref: string | null): string {\n  return cssText.replace(\n    URL_IN_CSS_REF,\n    (\n      matchingSubstring: string,\n      singleQuote: string | undefined,\n      urlWrappedInSingleQuotes: string | undefined,\n      doubleQuote: string | undefined,\n      urlWrappedInDoubleQuotes: string | undefined,\n      urlNotWrappedInQuotes: string | undefined\n    ) => {\n      const url = urlWrappedInSingleQuotes || urlWrappedInDoubleQuotes || urlNotWrappedInQuotes\n\n      if (!cssHref || !url || ABSOLUTE_URL.test(url) || DATA_URI.test(url)) {\n        return matchingSubstring\n      }\n\n      const quote = singleQuote || doubleQuote || ''\n      return `url(${quote}${makeUrlAbsolute(url, cssHref)}${quote})`\n    }\n  )\n}\n\nfunction makeUrlAbsolute(url: string, baseUrl: string): string {\n  try {\n    return buildUrl(url, baseUrl).href\n  } catch {\n    return url\n  }\n}\n\n/**\n * Returns the tag name of the given element, normalized to ensure a consistent lowercase\n * representation regardless of whether the element is HTML, XHTML, or SVG.\n */\nexport function normalizedTagName(element: Element): string {\n  return element.tagName.toLowerCase()\n}\n\nexport function censoredImageForSize(width: number, height: number) {\n  return `data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='${width}' height='${height}' style='background-color:silver'%3E%3C/svg%3E`\n}\n"],"mappings":";;;;;;;;AASA,SAAgB,qBAAqB,SAAkB,kBAAoC;CAOzF,MAAM,UAAU,QAAQ;CACxB,MAAM,QAAS,QAAmD;CAElE,IAAI,eAAe,SAAS,gBAAgB,GAAG;EAC7C,MAAM,OAAQ,QAAmD;EACjE,IAAI,YAAY,YAAY,SAAS,YAAY,SAAS,YAAY,SAAS,UAG7E,OAAO;OACF,IAAI,CAAC,SAAS,YAAY,UAE/B;EAEF,OAAO;CACT;CAEA,IAAI,YAAY,YAAY,YAAY,UACtC,OAAQ,QAAkD;CAG5D,IAAI,YAAY,WAAW,YAAY,YACrC;CAGF,OAAO;AACT;AAEA,MAAa,iBAAiB;AAC9B,MAAa,eAAe;AAC5B,MAAa,WAAW;AAExB,SAAgB,oBAAoB,SAAiB,SAAgC;CACnF,OAAO,QAAQ,QACb,iBAEE,mBACA,aACA,0BACA,aACA,0BACA,0BACG;EACH,MAAM,MAAM,4BAA4B,4BAA4B;EAEpE,IAAI,CAAC,WAAW,CAAC,OAAO,aAAa,KAAK,GAAG,KAAK,SAAS,KAAK,GAAG,GACjE,OAAO;EAGT,MAAM,QAAQ,eAAe,eAAe;EAC5C,OAAO,OAAO,QAAQ,gBAAgB,KAAK,OAAO,IAAI,MAAM;CAC9D,CACF;AACF;AAEA,SAAS,gBAAgB,KAAa,SAAyB;CAC7D,IAAI;EACF,OAAO,SAAS,KAAK,OAAO,CAAC,CAAC;CAChC,QAAQ;EACN,OAAO;CACT;AACF;;;;;AAMA,SAAgB,kBAAkB,SAA0B;CAC1D,OAAO,QAAQ,QAAQ,YAAY;AACrC;AAEA,SAAgB,qBAAqB,OAAe,QAAgB;CAClE,OAAO,uEAAuE,MAAM,YAAY,OAAO;AACzG"}

package/esm/domain/record/serialization/serializeAttribute.mjs

@@ -0,0 +1,26 @@
+import { censoredImageForSize } from "./serializationUtils.mjs";
+import { CENSORED_IMG_MARK, CENSORED_STRING_MARK, NodePrivacyLevel, sanitizeIfLongDataUrl, shouldMaskAttribute } from "@kubesense/kubesense-browser-rum-core";
+//#region src/domain/record/serialization/serializeAttribute.ts
+const MAX_ATTRIBUTE_VALUE_CHAR_LENGTH = 1e6;
+function serializeAttribute(element, nodePrivacyLevel, attributeName, configuration) {
+	if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) return null;
+	const attributeValue = element.getAttribute(attributeName);
+	const tagName = element.tagName;
+	if (shouldMaskAttribute(tagName, attributeName, attributeValue, nodePrivacyLevel, configuration)) {
+		if (tagName === "IMG") {
+			const image = element;
+			if (image.naturalWidth > 0) return censoredImageForSize(image.naturalWidth, image.naturalHeight);
+			const { width, height } = element.getBoundingClientRect();
+			if (width > 0 || height > 0) return censoredImageForSize(width, height);
+			return CENSORED_IMG_MARK;
+		}
+		if (tagName === "SOURCE") return CENSORED_IMG_MARK;
+		return CENSORED_STRING_MARK;
+	}
+	if (!attributeValue) return attributeValue;
+	return sanitizeIfLongDataUrl(attributeValue, MAX_ATTRIBUTE_VALUE_CHAR_LENGTH);
+}
+//#endregion
+export { MAX_ATTRIBUTE_VALUE_CHAR_LENGTH, serializeAttribute };
+
+//# sourceMappingURL=serializeAttribute.mjs.map

package/esm/domain/record/serialization/serializeAttribute.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializeAttribute.mjs","names":[],"sources":["../../../../src/domain/record/serialization/serializeAttribute.ts"],"sourcesContent":["import {\n  NodePrivacyLevel,\n  CENSORED_STRING_MARK,\n  CENSORED_IMG_MARK,\n  sanitizeIfLongDataUrl,\n  shouldMaskAttribute,\n} from '@kubesense/kubesense-browser-rum-core'\nimport type { RumConfiguration } from '@kubesense/kubesense-browser-rum-core'\nimport { censoredImageForSize } from './serializationUtils'\n\n// TODO: temporarily bump the Session Replay limit to 1Mb for dataUrls\n// This limit should be removed after [PANA-2843] is implemented\nexport const MAX_ATTRIBUTE_VALUE_CHAR_LENGTH = 1_000_000\n\nexport function serializeAttribute(\n  element: Element,\n  nodePrivacyLevel: NodePrivacyLevel,\n  attributeName: string,\n  configuration: RumConfiguration\n): string | null {\n  if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n    // dup condition for direct access case\n    return null\n  }\n\n  const attributeValue = element.getAttribute(attributeName)\n  const tagName = element.tagName\n  if (shouldMaskAttribute(tagName, attributeName, attributeValue, nodePrivacyLevel, configuration)) {\n    // mask image URLs\n    if (tagName === 'IMG') {\n      // generate image with similar dimension than the original to have the same rendering behaviour\n      const image = element as HTMLImageElement\n      if (image.naturalWidth > 0) {\n        return censoredImageForSize(image.naturalWidth, image.naturalHeight)\n      }\n      const { width, height } = element.getBoundingClientRect()\n      if (width > 0 || height > 0) {\n        return censoredImageForSize(width, height)\n      }\n      // if we can't get the image size, fallback to the censored image\n      return CENSORED_IMG_MARK\n    }\n    if (tagName === 'SOURCE') {\n      return CENSORED_IMG_MARK\n    }\n\n    return CENSORED_STRING_MARK\n  }\n\n  if (!attributeValue) {\n    return attributeValue\n  }\n\n  return sanitizeIfLongDataUrl(attributeValue, MAX_ATTRIBUTE_VALUE_CHAR_LENGTH)\n}\n"],"mappings":";;;AAYA,MAAa,kCAAkC;AAE/C,SAAgB,mBACd,SACA,kBACA,eACA,eACe;CACf,IAAI,qBAAqB,iBAAiB,QAExC,OAAO;CAGT,MAAM,iBAAiB,QAAQ,aAAa,aAAa;CACzD,MAAM,UAAU,QAAQ;CACxB,IAAI,oBAAoB,SAAS,eAAe,gBAAgB,kBAAkB,aAAa,GAAG;EAEhG,IAAI,YAAY,OAAO;GAErB,MAAM,QAAQ;GACd,IAAI,MAAM,eAAe,GACvB,OAAO,qBAAqB,MAAM,cAAc,MAAM,aAAa;GAErE,MAAM,EAAE,OAAO,WAAW,QAAQ,sBAAsB;GACxD,IAAI,QAAQ,KAAK,SAAS,GACxB,OAAO,qBAAqB,OAAO,MAAM;GAG3C,OAAO;EACT;EACA,IAAI,YAAY,UACd,OAAO;EAGT,OAAO;CACT;CAEA,IAAI,CAAC,gBACH,OAAO;CAGT,OAAO,sBAAsB,gBAAgB,+BAA+B;AAC9E"}