@kubesense/kubesense-browser-rum-core 1.0.0

package/esm/domain/lifeCycle.d.ts

@@ -0,0 +1,73 @@
+import type { Context, Duration, PageMayExitEvent, RawError, RelativeTime } from '@kubesense/kubesense-browser-core';
+import { AbstractLifeCycle } from '@kubesense/kubesense-browser-core';
+import type { RumEventDomainContext } from '../domainContext.types';
+import type { RawRumEvent, AssembledRumEvent } from '../rawRumEvent.types';
+import type { RequestCompleteEvent, RequestStartEvent } from './requestCollection';
+import type { AutoAction } from './action/actionCollection';
+import type { ViewEvent, ViewCreatedEvent, ViewEndedEvent, BeforeViewUpdateEvent } from './view/trackViews';
+export declare const enum LifeCycleEventType {
+    AUTO_ACTION_COMPLETED = 0,
+    BEFORE_VIEW_CREATED = 1,
+    VIEW_CREATED = 2,
+    BEFORE_VIEW_UPDATED = 3,
+    VIEW_UPDATED = 4,
+    VIEW_ENDED = 5,
+    AFTER_VIEW_ENDED = 6,
+    REQUEST_STARTED = 7,
+    REQUEST_COMPLETED = 8,
+    SESSION_EXPIRED = 9,
+    SESSION_RENEWED = 10,
+    PAGE_MAY_EXIT = 11,
+    RAW_RUM_EVENT_COLLECTED = 12,
+    RUM_EVENT_COLLECTED = 13,
+    RAW_ERROR_COLLECTED = 14
+}
+declare const LifeCycleEventTypeAsConst: {
+    AUTO_ACTION_COMPLETED: LifeCycleEventType.AUTO_ACTION_COMPLETED;
+    BEFORE_VIEW_CREATED: LifeCycleEventType.BEFORE_VIEW_CREATED;
+    VIEW_CREATED: LifeCycleEventType.VIEW_CREATED;
+    BEFORE_VIEW_UPDATED: LifeCycleEventType.BEFORE_VIEW_UPDATED;
+    VIEW_UPDATED: LifeCycleEventType.VIEW_UPDATED;
+    VIEW_ENDED: LifeCycleEventType.VIEW_ENDED;
+    AFTER_VIEW_ENDED: LifeCycleEventType.AFTER_VIEW_ENDED;
+    REQUEST_STARTED: LifeCycleEventType.REQUEST_STARTED;
+    REQUEST_COMPLETED: LifeCycleEventType.REQUEST_COMPLETED;
+    SESSION_EXPIRED: LifeCycleEventType.SESSION_EXPIRED;
+    SESSION_RENEWED: LifeCycleEventType.SESSION_RENEWED;
+    PAGE_MAY_EXIT: LifeCycleEventType.PAGE_MAY_EXIT;
+    RAW_RUM_EVENT_COLLECTED: LifeCycleEventType.RAW_RUM_EVENT_COLLECTED;
+    RUM_EVENT_COLLECTED: LifeCycleEventType.RUM_EVENT_COLLECTED;
+    RAW_ERROR_COLLECTED: LifeCycleEventType.RAW_ERROR_COLLECTED;
+};
+export interface LifeCycleEventMap {
+    [LifeCycleEventTypeAsConst.AUTO_ACTION_COMPLETED]: AutoAction;
+    [LifeCycleEventTypeAsConst.BEFORE_VIEW_CREATED]: ViewCreatedEvent;
+    [LifeCycleEventTypeAsConst.VIEW_CREATED]: ViewCreatedEvent;
+    [LifeCycleEventTypeAsConst.BEFORE_VIEW_UPDATED]: BeforeViewUpdateEvent;
+    [LifeCycleEventTypeAsConst.VIEW_UPDATED]: ViewEvent;
+    [LifeCycleEventTypeAsConst.VIEW_ENDED]: ViewEndedEvent;
+    [LifeCycleEventTypeAsConst.AFTER_VIEW_ENDED]: ViewEndedEvent;
+    [LifeCycleEventTypeAsConst.REQUEST_STARTED]: RequestStartEvent;
+    [LifeCycleEventTypeAsConst.REQUEST_COMPLETED]: RequestCompleteEvent;
+    [LifeCycleEventTypeAsConst.SESSION_EXPIRED]: void;
+    [LifeCycleEventTypeAsConst.SESSION_RENEWED]: void;
+    [LifeCycleEventTypeAsConst.PAGE_MAY_EXIT]: PageMayExitEvent;
+    [LifeCycleEventTypeAsConst.RAW_RUM_EVENT_COLLECTED]: RawRumEventCollectedData;
+    [LifeCycleEventTypeAsConst.RUM_EVENT_COLLECTED]: AssembledRumEvent;
+    [LifeCycleEventTypeAsConst.RAW_ERROR_COLLECTED]: {
+        error: RawError;
+        customerContext?: Context;
+    };
+}
+export interface RawRumEventCollectedData<E extends RawRumEvent = RawRumEvent> {
+    startTime: RelativeTime;
+    duration?: Duration;
+    customerContext?: Context;
+    rawRumEvent: E;
+    domainContext: RumEventDomainContext<E['type']>;
+}
+export declare const LifeCycle: {
+    new (): AbstractLifeCycle<LifeCycleEventMap>;
+};
+export type LifeCycle = AbstractLifeCycle<LifeCycleEventMap>;
+export {};

package/esm/domain/lifeCycle.js

@@ -0,0 +1,3 @@
+import { AbstractLifeCycle } from '@kubesense/kubesense-browser-core';
+export const LifeCycle = (AbstractLifeCycle);
+//# sourceMappingURL=lifeCycle.js.map

package/esm/domain/lifeCycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifeCycle.js","sourceRoot":"","sources":["../../src/domain/lifeCycle.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAA;AAoGrE,MAAM,CAAC,MAAM,SAAS,GAAG,CAAA,iBAAoC,CAAA,CAAA"}

package/esm/domain/limitModification.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from '@kubesense/kubesense-browser-core';
+export type ModifiableFieldPaths = Record<string, 'string' | 'object'>;
+/**
+ * Allows declaring and enforcing modifications to specific fields of an object.
+ * Only supports modifying properties of an object (even if nested in an array).
+ * Does not support array manipulation (adding/removing items).
+ */
+export declare function limitModification<T extends Context, Result>(object: T, modifiableFieldPaths: ModifiableFieldPaths, modifier: (object: T) => Result): Result | undefined;

package/esm/domain/limitModification.js

@@ -0,0 +1,43 @@
+import { sanitize, deepClone, getType, objectEntries } from '@kubesense/kubesense-browser-core';
+/**
+ * Allows declaring and enforcing modifications to specific fields of an object.
+ * Only supports modifying properties of an object (even if nested in an array).
+ * Does not support array manipulation (adding/removing items).
+ */
+export function limitModification(object, modifiableFieldPaths, modifier) {
+    const clone = deepClone(object);
+    const result = modifier(clone);
+    objectEntries(modifiableFieldPaths).forEach(([fieldPath, fieldType]) => 
+    // Traverse both object and clone simultaneously up to the path and apply the modification from the clone to the original object when the type is valid
+    setValueAtPath(object, clone, fieldPath.split(/\.|(?=\[\])/), fieldType));
+    return result;
+}
+function setValueAtPath(object, clone, pathSegments, fieldType) {
+    const [field, ...restPathSegments] = pathSegments;
+    if (field === '[]') {
+        if (Array.isArray(object) && Array.isArray(clone)) {
+            object.forEach((item, i) => setValueAtPath(item, clone[i], restPathSegments, fieldType));
+        }
+        return;
+    }
+    if (!isValidObject(object) || !isValidObject(clone)) {
+        return;
+    }
+    if (restPathSegments.length > 0) {
+        return setValueAtPath(object[field], clone[field], restPathSegments, fieldType);
+    }
+    setNestedValue(object, field, clone[field], fieldType);
+}
+function setNestedValue(object, field, value, fieldType) {
+    const newType = getType(value);
+    if (newType === fieldType) {
+        object[field] = sanitize(value);
+    }
+    else if (fieldType === 'object' && (newType === 'undefined' || newType === 'null')) {
+        object[field] = {};
+    }
+}
+function isValidObject(object) {
+    return getType(object) === 'object';
+}
+//# sourceMappingURL=limitModification.js.map

package/esm/domain/limitModification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limitModification.js","sourceRoot":"","sources":["../../src/domain/limitModification.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAA;AAK/F;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAC/B,MAAS,EACT,oBAA0C,EAC1C,QAA+B;IAE/B,MAAM,KAAK,GAAG,SAAS,CAAC,MAAM,CAAC,CAAA;IAC/B,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;IAE9B,aAAa,CAAC,oBAAoB,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,EAAE,SAAS,CAAC,EAAE,EAAE;IACrE,uJAAuJ;IACvJ,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,SAAS,CAAC,CACzE,CAAA;IAED,OAAO,MAAM,CAAA;AACf,CAAC;AAED,SAAS,cAAc,CAAC,MAAe,EAAE,KAAc,EAAE,YAAsB,EAAE,SAA8B;IAC7G,MAAM,CAAC,KAAK,EAAE,GAAG,gBAAgB,CAAC,GAAG,YAAY,CAAA;IAEjD,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACnB,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAClD,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,cAAc,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,SAAS,CAAC,CAAC,CAAA;QAC1F,CAAC;QAED,OAAM;IACR,CAAC;IAED,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;QACpD,OAAM;IACR,CAAC;IAED,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAChC,OAAO,cAAc,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE,gBAAgB,EAAE,SAAS,CAAC,CAAA;IACjF,CAAC;IAED,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,CAAA;AACxD,CAAC;AAED,SAAS,cAAc,CACrB,MAA+B,EAC/B,KAAa,EACb,KAAc,EACd,SAA8B;IAE9B,MAAM,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAA;IAE9B,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,MAAM,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;IACjC,CAAC;SAAM,IAAI,SAAS,KAAK,QAAQ,IAAI,CAAC,OAAO,KAAK,WAAW,IAAI,OAAO,KAAK,MAAM,CAAC,EAAE,CAAC;QACrF,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAA;IACpB,CAAC;AACH,CAAC;AAED,SAAS,aAAa,CAAC,MAAe;IACpC,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,QAAQ,CAAA;AACrC,CAAC"}

package/esm/domain/longTask/longTaskCollection.d.ts

@@ -0,0 +1,18 @@
+import type { RelativeTime, ClocksState, Duration } from '@kubesense/kubesense-browser-core';
+import type { LifeCycle } from '../lifeCycle';
+import { RumPerformanceEntryType } from '../../browser/performanceObservable';
+import type { RumConfiguration } from '../configuration';
+export declare const LONG_TASK_ID_HISTORY_TIME_OUT_DELAY: number;
+export interface LongTaskContext {
+    id: string;
+    startClocks: ClocksState;
+    duration: Duration;
+    entryType: RumPerformanceEntryType.LONG_ANIMATION_FRAME | RumPerformanceEntryType.LONG_TASK;
+}
+export interface LongTaskContexts {
+    findLongTasks: (startTime: RelativeTime) => LongTaskContext[];
+}
+export declare function startLongTaskCollection(lifeCycle: LifeCycle, configuration: RumConfiguration): {
+    stop: () => void;
+    longTaskContexts: LongTaskContexts;
+};

package/esm/domain/longTask/longTaskCollection.js

@@ -0,0 +1,87 @@
+import { toServerDuration, relativeToClocks, generateUUID, createValueHistory, SESSION_TIME_OUT_DELAY, addDuration, } from '@kubesense/kubesense-browser-core';
+import { RumEventType, RumLongTaskEntryType } from '../../rawRumEvent.types';
+import { createPerformanceObservable, RumPerformanceEntryType, supportPerformanceTimingEvent, } from '../../browser/performanceObservable';
+export const LONG_TASK_ID_HISTORY_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;
+export function startLongTaskCollection(lifeCycle, configuration) {
+    const history = createValueHistory({
+        expireDelay: LONG_TASK_ID_HISTORY_TIME_OUT_DELAY,
+    });
+    const entryType = supportPerformanceTimingEvent(RumPerformanceEntryType.LONG_ANIMATION_FRAME)
+        ? RumPerformanceEntryType.LONG_ANIMATION_FRAME
+        : RumPerformanceEntryType.LONG_TASK;
+    const subscription = createPerformanceObservable(configuration, {
+        type: entryType,
+        buffered: true,
+    }).subscribe((entries) => {
+        for (const entry of entries) {
+            if (!configuration.trackLongTasks) {
+                break;
+            }
+            const startClocks = relativeToClocks(entry.startTime);
+            const taskId = generateUUID();
+            const rawRumEvent = processEntry(entry, startClocks, taskId);
+            lifeCycle.notify(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, {
+                rawRumEvent,
+                startTime: startClocks.relative,
+                duration: entry.duration,
+                domainContext: { performanceEntry: entry },
+            });
+            history.add({ id: taskId, startClocks, duration: entry.duration, entryType }, startClocks.relative);
+            history.closeActive(addDuration(startClocks.relative, entry.duration));
+        }
+    });
+    const longTaskContexts = {
+        findLongTasks: (startTime) => history.findAll(startTime),
+    };
+    return {
+        stop: () => {
+            subscription.unsubscribe();
+            history.stop();
+        },
+        longTaskContexts,
+    };
+}
+function processEntry(entry, startClocks, taskId) {
+    const baseEvent = {
+        date: startClocks.timeStamp,
+        type: RumEventType.LONG_TASK,
+        _kubesense: { discarded: false },
+    };
+    if (entry.entryType === RumPerformanceEntryType.LONG_TASK) {
+        return {
+            ...baseEvent,
+            long_task: {
+                id: taskId,
+                entry_type: RumLongTaskEntryType.LONG_TASK,
+                duration: toServerDuration(entry.duration),
+            },
+        };
+    }
+    return {
+        ...baseEvent,
+        long_task: {
+            id: taskId,
+            entry_type: RumLongTaskEntryType.LONG_ANIMATION_FRAME,
+            duration: toServerDuration(entry.duration),
+            blocking_duration: toServerDuration(entry.blockingDuration),
+            first_ui_event_timestamp: toServerDuration(entry.firstUIEventTimestamp),
+            render_start: toServerDuration(entry.renderStart),
+            style_and_layout_start: toServerDuration(entry.styleAndLayoutStart),
+            start_time: toServerDuration(entry.startTime),
+            scripts: entry.scripts.map((script) => ({
+                duration: toServerDuration(script.duration),
+                pause_duration: toServerDuration(script.pauseDuration),
+                forced_style_and_layout_duration: toServerDuration(script.forcedStyleAndLayoutDuration),
+                start_time: toServerDuration(script.startTime),
+                execution_start: toServerDuration(script.executionStart),
+                source_url: script.sourceURL,
+                source_function_name: script.sourceFunctionName,
+                source_char_position: script.sourceCharPosition,
+                invoker: script.invoker,
+                invoker_type: script.invokerType,
+                window_attribution: script.windowAttribution,
+            })),
+        },
+    };
+}
+//# sourceMappingURL=longTaskCollection.js.map

package/esm/domain/longTask/longTaskCollection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"longTaskCollection.js","sourceRoot":"","sources":["../../../src/domain/longTask/longTaskCollection.ts"],"names":[],"mappings":"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"}

package/esm/domain/plugins.d.ts

@@ -0,0 +1,40 @@
+import type { RumPublicApi, Strategy } from '../boot/rumPublicApi';
+import type { StartRumResult } from '../boot/startRum';
+import type { RumInitConfiguration } from './configuration';
+/**
+ * onRumStart plugin API options.
+ *
+ * @experimental
+ */
+export interface OnRumStartOptions {
+    /**
+     * @deprecated Use `addEvent` instead.
+     */
+    strategy?: Strategy;
+    /**
+     * Add an event to the RUM browser SDK.
+     */
+    addEvent?: StartRumResult['addEvent'];
+}
+/**
+ * Plugin interface of the RUM browser SDK.
+ *
+ * The plugins API is unstable and experimental, and may change without
+ * notice. Please use only plugins provided by Kubesense matching the version of the SDK you are
+ * using.
+ *
+ * @experimental
+ */
+export interface RumPlugin {
+    name: string;
+    getConfigurationTelemetry?(): Record<string, unknown>;
+    onInit?(options: {
+        initConfiguration: RumInitConfiguration;
+        publicApi: RumPublicApi;
+    }): void;
+    onRumStart?(options: OnRumStartOptions): void;
+}
+type MethodNames = 'onInit' | 'onRumStart';
+type MethodParameter<MethodName extends MethodNames> = Parameters<NonNullable<RumPlugin[MethodName]>>[0];
+export declare function callPluginsMethod<MethodName extends MethodNames>(plugins: RumPlugin[] | undefined, methodName: MethodName, parameter: MethodParameter<MethodName>): void;
+export {};

package/esm/domain/plugins.js

@@ -0,0 +1,12 @@
+export function callPluginsMethod(plugins, methodName, parameter) {
+    if (!plugins) {
+        return;
+    }
+    for (const plugin of plugins) {
+        const method = plugin[methodName];
+        if (method) {
+            method(parameter);
+        }
+    }
+}
+//# sourceMappingURL=plugins.js.map

package/esm/domain/plugins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.js","sourceRoot":"","sources":["../../src/domain/plugins.ts"],"names":[],"mappings":"AA4CA,MAAM,UAAU,iBAAiB,CAC/B,OAAgC,EAChC,UAAsB,EACtB,SAAc;IAEd,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAM;IACR,CAAC;IACD,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,MAAM,MAAM,GAAG,MAAM,CAAC,UAAU,CAAC,CAAA;QACjC,IAAI,MAAM,EAAE,CAAC;YACX,MAAM,CAAC,SAAS,CAAC,CAAA;QACnB,CAAC;IACH,CAAC;AACH,CAAC"}

package/esm/domain/privacy.d.ts

@@ -0,0 +1,44 @@
+import { NodePrivacyLevel } from './privacyConstants';
+import type { RumConfiguration } from './configuration';
+export type NodePrivacyLevelCache = Map<Node, NodePrivacyLevel>;
+/**
+ * Get node privacy level by iterating over its ancestors. When the direct parent privacy level is
+ * know, it is best to use something like:
+ *
+ * derivePrivacyLevelGivenParent(getNodeSelfPrivacyLevel(node), parentNodePrivacyLevel)
+ */
+export declare function getNodePrivacyLevel(node: Node, defaultPrivacyLevel: NodePrivacyLevel, cache?: NodePrivacyLevelCache): NodePrivacyLevel;
+/**
+ * Reduces the next privacy level based on self + parent privacy levels
+ */
+export declare function reducePrivacyLevel(childPrivacyLevel: NodePrivacyLevel | undefined, parentNodePrivacyLevel: NodePrivacyLevel): NodePrivacyLevel;
+/**
+ * Determines the node's own privacy level without checking for ancestors.
+ */
+export declare function getNodeSelfPrivacyLevel(node: Node): NodePrivacyLevel | undefined;
+/**
+ * Helper aiming to unify `mask` and `mask-user-input` privacy levels:
+ *
+ * In the `mask` case, it is trivial: we should mask the element.
+ *
+ * In the `mask-user-input` case, we should mask the element only if it is a "form" element or the
+ * direct parent is a form element for text nodes).
+ *
+ * Other `shouldMaskNode` cases are edge cases that should not matter too much (ex: should we mask a
+ * node if it is ignored or hidden? it doesn't matter since it won't be serialized).
+ */
+export declare function shouldMaskNode(node: Node, privacyLevel: NodePrivacyLevel): boolean;
+export declare function shouldMaskAttribute(tagName: string, attributeName: string, attributeValue: string | null, nodePrivacyLevel: NodePrivacyLevel, configuration: RumConfiguration): boolean;
+export declare function getTextContent(textNode: Node, parentNodePrivacyLevel: NodePrivacyLevel): string | undefined;
+/**
+ * TODO: Preserve CSS element order, and record the presence of the tag, just don't render
+ * We don't need this logic on the recorder side.
+ * For security related meta's, customer can mask themmanually given they
+ * are easy to identify in the HEAD tag.
+ */
+export declare function shouldIgnoreElement(element: Element): boolean;
+export interface BrowserWindow extends Window {
+    $KUBESENSE_ALLOW?: Set<string>;
+}
+export declare function isAllowlisted(text: string): boolean;
+export declare function maskDisallowedTextContent(text: string, fixedMask?: string): string;

package/esm/domain/privacy.js

@@ -0,0 +1,302 @@
+import { isElementNode, getParentNode, isTextNode } from '../browser/htmlDomUtils';
+import { NodePrivacyLevel, FORM_PRIVATE_TAG_NAMES, CENSORED_STRING_MARK, getPrivacySelector, TEXT_MASKING_CHAR, PRIVACY_ATTR_NAME, } from './privacyConstants';
+import { STABLE_ATTRIBUTES } from './getSelectorFromElement';
+/**
+ * Get node privacy level by iterating over its ancestors. When the direct parent privacy level is
+ * know, it is best to use something like:
+ *
+ * derivePrivacyLevelGivenParent(getNodeSelfPrivacyLevel(node), parentNodePrivacyLevel)
+ */
+export function getNodePrivacyLevel(node, defaultPrivacyLevel, cache) {
+    if (cache && cache.has(node)) {
+        return cache.get(node);
+    }
+    const parentNode = getParentNode(node);
+    const parentNodePrivacyLevel = parentNode
+        ? getNodePrivacyLevel(parentNode, defaultPrivacyLevel, cache)
+        : defaultPrivacyLevel;
+    const selfNodePrivacyLevel = getNodeSelfPrivacyLevel(node);
+    const nodePrivacyLevel = reducePrivacyLevel(selfNodePrivacyLevel, parentNodePrivacyLevel);
+    if (cache) {
+        cache.set(node, nodePrivacyLevel);
+    }
+    return nodePrivacyLevel;
+}
+/**
+ * Reduces the next privacy level based on self + parent privacy levels
+ */
+export function reducePrivacyLevel(childPrivacyLevel, parentNodePrivacyLevel) {
+    switch (parentNodePrivacyLevel) {
+        // These values cannot be overridden
+        case NodePrivacyLevel.HIDDEN:
+        case NodePrivacyLevel.IGNORE:
+            return parentNodePrivacyLevel;
+    }
+    switch (childPrivacyLevel) {
+        case NodePrivacyLevel.ALLOW:
+        case NodePrivacyLevel.MASK:
+        case NodePrivacyLevel.MASK_USER_INPUT:
+        case NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED:
+        case NodePrivacyLevel.HIDDEN:
+        case NodePrivacyLevel.IGNORE:
+            return childPrivacyLevel;
+        default:
+            return parentNodePrivacyLevel;
+    }
+}
+/**
+ * Determines the node's own privacy level without checking for ancestors.
+ */
+export function getNodeSelfPrivacyLevel(node) {
+    // Only Element types can have a privacy level set
+    if (!isElementNode(node)) {
+        return;
+    }
+    // Overrules for replay purpose
+    if (node.tagName === 'BASE') {
+        return NodePrivacyLevel.ALLOW;
+    }
+    // Overrules to enforce end-user protection
+    if (node.tagName === 'INPUT') {
+        const inputElement = node;
+        if (inputElement.type === 'password' || inputElement.type === 'email' || inputElement.type === 'tel') {
+            return NodePrivacyLevel.MASK;
+        }
+        if (inputElement.type === 'hidden') {
+            return NodePrivacyLevel.MASK;
+        }
+        const autocomplete = inputElement.getAttribute('autocomplete');
+        // Handle input[autocomplete=cc-number/cc-csc/cc-exp/cc-exp-month/cc-exp-year/new-password/current-password]
+        if (autocomplete && (autocomplete.startsWith('cc-') || autocomplete.endsWith('-password'))) {
+            return NodePrivacyLevel.MASK;
+        }
+    }
+    // Check HTML privacy attributes and classes
+    if (node.matches(getPrivacySelector(NodePrivacyLevel.HIDDEN))) {
+        return NodePrivacyLevel.HIDDEN;
+    }
+    if (node.matches(getPrivacySelector(NodePrivacyLevel.MASK))) {
+        return NodePrivacyLevel.MASK;
+    }
+    if (node.matches(getPrivacySelector(NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED))) {
+        return NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED;
+    }
+    if (node.matches(getPrivacySelector(NodePrivacyLevel.MASK_USER_INPUT))) {
+        return NodePrivacyLevel.MASK_USER_INPUT;
+    }
+    if (node.matches(getPrivacySelector(NodePrivacyLevel.ALLOW))) {
+        return NodePrivacyLevel.ALLOW;
+    }
+    if (shouldIgnoreElement(node)) {
+        return NodePrivacyLevel.IGNORE;
+    }
+}
+/**
+ * Helper aiming to unify `mask` and `mask-user-input` privacy levels:
+ *
+ * In the `mask` case, it is trivial: we should mask the element.
+ *
+ * In the `mask-user-input` case, we should mask the element only if it is a "form" element or the
+ * direct parent is a form element for text nodes).
+ *
+ * Other `shouldMaskNode` cases are edge cases that should not matter too much (ex: should we mask a
+ * node if it is ignored or hidden? it doesn't matter since it won't be serialized).
+ */
+export function shouldMaskNode(node, privacyLevel) {
+    switch (privacyLevel) {
+        case NodePrivacyLevel.MASK:
+        case NodePrivacyLevel.HIDDEN:
+        case NodePrivacyLevel.IGNORE:
+            return true;
+        case NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED:
+            if (isTextNode(node)) {
+                // Always return true if our parent is a form element, like MASK_USER_INPUT.
+                // Otherwise, decide whether to mask based on the allowlist.
+                return isFormElement(node.parentNode) ? true : !isAllowlisted(node.textContent || '');
+            }
+            // Always return true if we're a form element, like MASK_USER_INPUT.
+            // Otherwise, return false; MASK_UNLESS_ALLOWLISTED only directly masks text nodes.
+            return isFormElement(node);
+        case NodePrivacyLevel.MASK_USER_INPUT:
+            return isTextNode(node) ? isFormElement(node.parentNode) : isFormElement(node);
+        default:
+            return false;
+    }
+}
+export function shouldMaskAttribute(tagName, attributeName, attributeValue, nodePrivacyLevel, configuration) {
+    if (nodePrivacyLevel !== NodePrivacyLevel.MASK && nodePrivacyLevel !== NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED) {
+        return false;
+    }
+    if (attributeName === PRIVACY_ATTR_NAME ||
+        STABLE_ATTRIBUTES.includes(attributeName) ||
+        attributeName === configuration.actionNameAttribute) {
+        return false;
+    }
+    switch (attributeName) {
+        case 'title':
+        case 'alt':
+        case 'placeholder':
+        case 'aria-label':
+        case 'name':
+            return true;
+    }
+    if (tagName === 'A' && attributeName === 'href') {
+        return true;
+    }
+    if (tagName === 'IFRAME' && attributeName === 'srcdoc') {
+        return true;
+    }
+    if (attributeValue && attributeName.startsWith('data-')) {
+        return true;
+    }
+    if ((tagName === 'IMG' || tagName === 'SOURCE') && (attributeName === 'src' || attributeName === 'srcset')) {
+        return true;
+    }
+    return false;
+}
+function isFormElement(node) {
+    if (!node || node.nodeType !== node.ELEMENT_NODE) {
+        return false;
+    }
+    const element = node;
+    if (element.tagName === 'INPUT') {
+        switch (element.type) {
+            case 'button':
+            case 'color':
+            case 'reset':
+            case 'submit':
+                return false;
+        }
+    }
+    return !!FORM_PRIVATE_TAG_NAMES[element.tagName];
+}
+/**
+ * Text censoring non-destructively maintains whitespace characters in order to preserve text shape
+ * during replay.
+ */
+const censorText = (text) => text.replace(/\S/g, TEXT_MASKING_CHAR);
+export function getTextContent(textNode, parentNodePrivacyLevel) {
+    var _a;
+    // The parent node may not be a html element which has a tagName attribute.
+    // So just let it be undefined which is ok in this use case.
+    const parentTagName = (_a = textNode.parentElement) === null || _a === void 0 ? void 0 : _a.tagName;
+    let textContent = textNode.textContent || '';
+    const shouldIgnoreWhiteSpace = parentTagName === 'HEAD';
+    if (shouldIgnoreWhiteSpace && !textContent.trim()) {
+        return;
+    }
+    const nodePrivacyLevel = parentNodePrivacyLevel;
+    const isScript = parentTagName === 'SCRIPT';
+    if (isScript) {
+        // For perf reasons, we don't record script (heuristic)
+        textContent = CENSORED_STRING_MARK;
+    }
+    else if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {
+        // Should never occur, but just in case, we set to CENSORED_MARK.
+        textContent = CENSORED_STRING_MARK;
+    }
+    else if (shouldMaskNode(textNode, nodePrivacyLevel)) {
+        if (
+        // Scrambling the child list breaks text nodes for DATALIST/SELECT/OPTGROUP
+        parentTagName === 'DATALIST' ||
+            parentTagName === 'SELECT' ||
+            parentTagName === 'OPTGROUP') {
+            if (!textContent.trim()) {
+                return;
+            }
+        }
+        else if (parentTagName === 'OPTION') {
+            // <Option> has low entropy in charset + text length, so use `CENSORED_STRING_MARK` when masked
+            textContent = CENSORED_STRING_MARK;
+        }
+        else if (nodePrivacyLevel === NodePrivacyLevel.MASK_UNLESS_ALLOWLISTED) {
+            textContent = maskDisallowedTextContent(textContent);
+        }
+        else {
+            textContent = censorText(textContent);
+        }
+    }
+    return textContent;
+}
+/**
+ * TODO: Preserve CSS element order, and record the presence of the tag, just don't render
+ * We don't need this logic on the recorder side.
+ * For security related meta's, customer can mask themmanually given they
+ * are easy to identify in the HEAD tag.
+ */
+export function shouldIgnoreElement(element) {
+    if (element.nodeName === 'SCRIPT') {
+        return true;
+    }
+    if (element.nodeName === 'LINK') {
+        const relAttribute = getLowerCaseAttribute('rel');
+        return (
+        // Link as script - Ignore only when rel=preload, modulepreload or prefetch
+        (/preload|prefetch/i.test(relAttribute) && getLowerCaseAttribute('as') === 'script') ||
+            // Favicons
+            relAttribute === 'shortcut icon' ||
+            relAttribute === 'icon');
+    }
+    if (element.nodeName === 'META') {
+        const nameAttribute = getLowerCaseAttribute('name');
+        const relAttribute = getLowerCaseAttribute('rel');
+        const propertyAttribute = getLowerCaseAttribute('property');
+        return (
+        // Favicons
+        /^msapplication-tile(image|color)$/.test(nameAttribute) ||
+            nameAttribute === 'application-name' ||
+            relAttribute === 'icon' ||
+            relAttribute === 'apple-touch-icon' ||
+            relAttribute === 'shortcut icon' ||
+            // Description
+            nameAttribute === 'keywords' ||
+            nameAttribute === 'description' ||
+            // Social
+            /^(og|twitter|fb):/.test(propertyAttribute) ||
+            /^(og|twitter):/.test(nameAttribute) ||
+            nameAttribute === 'pinterest' ||
+            // Robots
+            nameAttribute === 'robots' ||
+            nameAttribute === 'googlebot' ||
+            nameAttribute === 'bingbot' ||
+            // Http headers. Ex: X-UA-Compatible, Content-Type, Content-Language, cache-control,
+            // X-Translated-By
+            element.hasAttribute('http-equiv') ||
+            // Authorship
+            nameAttribute === 'author' ||
+            nameAttribute === 'generator' ||
+            nameAttribute === 'framework' ||
+            nameAttribute === 'publisher' ||
+            nameAttribute === 'progid' ||
+            /^article:/.test(propertyAttribute) ||
+            /^product:/.test(propertyAttribute) ||
+            // Verification
+            nameAttribute === 'google-site-verification' ||
+            nameAttribute === 'yandex-verification' ||
+            nameAttribute === 'csrf-token' ||
+            nameAttribute === 'p:domain_verify' ||
+            nameAttribute === 'verify-v1' ||
+            nameAttribute === 'verification' ||
+            nameAttribute === 'shopify-checkout-api-token');
+    }
+    function getLowerCaseAttribute(name) {
+        return (element.getAttribute(name) || '').toLowerCase();
+    }
+    return false;
+}
+export function isAllowlisted(text) {
+    var _a;
+    if (!text || !text.trim()) {
+        return true;
+    }
+    // We are using toLocaleLowerCase when adding to the allowlist to avoid case sensitivity
+    // so we need to do the same here
+    return ((_a = window.$KUBESENSE_ALLOW) === null || _a === void 0 ? void 0 : _a.has(text.toLocaleLowerCase())) || false;
+}
+export function maskDisallowedTextContent(text, fixedMask) {
+    if (isAllowlisted(text)) {
+        return text;
+    }
+    return fixedMask || censorText(text);
+}
+//# sourceMappingURL=privacy.js.map